基于LR的HTTP协议接口性能测试脚本实例

背景介绍

XXX项目性能测试中新增业务场景：XX设备的在线激活，因为存在多用户同时在线激活，故需进行性能测试以确认后台服务器系统在多用并发时功能是否正常，性能指标是否满足规格要求。用户使用场景为用户通过XX设备平台（类似客户端）触发激活请求，该请求经过中间系统处理并最终被Licnese后台服务器处理并响应。客户端与服务器经过了广域网环境，无设备在线激活业务操作界面。

场景和现状

XX设备平台通过http协议与中转系统进行交互，中转系统将http协议的消息转换为Web Service（SOAP）消息并转送给Licnese服务器进行处理，XX设备发出的http消息数据是经过加密处理的。已提供XX设备激活模拟工具（.exe文件+配置文件）和加解密dll文件/加解密jar包。.exe文件为win32控制台程序编写的模拟激活业务的工具，模拟工具执行时间很短，在几秒钟就完成激活业务（与XXX服务器发生五次交互），试图通过LR工具试录制脚本，发现无法录制到模拟工具发出的请求消息脚本。

方案确定

在LR中通过手工编写http协议脚本，在LR中模拟设备在线激活业务与中转系统交互，由于提供的加解密DLL文件并非C/C++语言写的，所以LR中选择http协议时无法直接调用加解密DLL，但因为提供了加解密jar包，可以在本地java环境中部署该jar包，在命令行中执行java命令来进行加解密操作，最终确定通过手工编写一个C的DLL，在该DLL中编写调用命令行并获取命令行结果的函数，在LR中加载并调用该DLL来实现数据的加解密，另外，因为加解密后的数据为二进制数据，所以需要使用web_custom_request函数发送二进制消息体，如对二进制消息体的处理过程中需要使用循环，出于执行效率的考虑，可将这部分代码一并放入DLL中文件。

脚本

 1 #ifndef _GLOBALS_H
 2 #define _GLOBALS_H
 3 
 4 //--------------------------------------------------------------------
 5 // Include Files
 6 #include "lrun.h"
 7 #include "web_api.h"
 8 #include "lrw_custom_body.h"
 9 
10 //--------------------------------------------------------------------
11 // Global Variables
12 //#define TESTDLL 0
13 
14     //--------------------------------初始化--------------------------------
15     //获取安全码的局部变量
16     char szSecurityCodeBody[8192]; //存放Body
17     char szPdtName[128];    //产品名称
18     char szPdtVer[128];    //产品版本号
19     char szDevESN[128];    //生成ESN，20-30位随机数字和字母
20     char szDevIndex[5];    //生成devIndex，设备ESN哈希后取前四个字节....
21     char szSecurityCodBodyEnc[8192];//存放加密后的Body
22     char getSecurityCode_requestData[8192];//存放待解密data数据
23     char getSecurityCode_requestDataDnc[8192];//存放解密后的data数据
24     char vuserid_str[50]; //组装临时文件名
25     char curtime_str[50];
26     char TmpFileName[100];  //临时文件名
27     int iRet = -1; //加解密函数返回值
28     int ContentLength = 0;    
29     const char *SecurityCodeTou = "securityCode=";
30     char *SecurityCodeTmp = NULL;
31     const char *resCodeTou = "resCode=";
32     char *resCodeTmp = NULL;
33     int resCode = 0;
34     char *delim = "&";
35     char requestDataDnc_Tmp[8192];//临时存放各响应解密后的data数据
36 
37     //获取订单授权信息
38     char szAuthorizeBody[8192];
39     char szOrdLac[128];
40     char szAuthorizeBodyEnc[8192];
41     char getAuthInfo_requestData[8192];//存放待解密data数据
42     char getAuthInfo_requestDataDnc[8192];//存放解密后的data数据
43     const char *authInfoTou = "authInfo=";
44     char *authInfoTmp = NULL;
45 
46     //在线激活
47     char szActDevLicenseBody[8192];
48     char szActDevLicenseBodyEnc[8192];
49     char actDevLicense_requestData[8192];//存放待解密data数据
50     char actDevLicense_requestDataDnc[8192];//存放解密后的data数据
51     
52     //在线下载
53     char szDownLoadOnlineBody[8192];
54     char szDownLoadOnlineBodyEnc[8192];
55     char getDevLicense_requestData[8192];//存放待解密data数据
56     char getDevLicense_requestDataDnc[8192];//存放解密后的data数据
57 
58     //释放会话资源
59     char szReleaseSessionBody[8192];
60     char szJsessionid[128];
61     char szReleaseSessionBodyEnc[8192];
62     char relSesRsr_requestData[8192];//存放待解密data数据
63     char relSesRsr_requestDataDnc[8192];//存放解密后的data数据
64 
65     //文件内容校验
66     const char *ProductNameTou = "Product=";
67     char *ProductNameTmp = NULL;
68     char ProductNameTmp_STR[64];
69     char *ProductName_delim = "
";
70     const char *VersionTou = "Version=";
71     char *VersionTmp = NULL;
72     char VersionTmp_STR[64];
73     char *Version_delim = "
";
74     const char *EsnTou = "Esn="";
75     char *EsnTmp = NULL;
76     char EsnTmp_STR[128];
77     char *Esn_delim = ""
";
78     int strcmp_result = 0;   //比较结果，相等为0
79 
80 
81 #endif // _GLOBALS_H

 1 vuser_init()
 2 {
 3 
 4     int iLoadDllRes1 = -1;
 5 
 6 
 7         //char szRes[4096] = {0};        //加密后的字符串，一定要定义足够大，防止越界！！！
 8          //char szRes[4096] = "3d9d1defa4044f28e228b43de69b48ca9c992f974d184bc353905bee18d4890614eed06bce9a237da6a636043c456b3831e62ddf6ad7571487b38afc6a0ee1041b32f4ecf69c1d135f79e51ff71684132458d5d1935ddc8c700bf9552b06c80dd568cb4711a2d841674874d16570c3ac0efd5c8e2201e98788fdaa11763cf968f7b7b800655c26d3731fda05362ff59b6a9ec1caa8e06adf9db3900ef26c4dd898cc462f7597ee6800053e5748cc97584419b3f7b60a301bdb034701a9e97ee62749b1d9308deef976e1eaa103123ac2db17bc5e86545a6ad75711fc2442434fd0c9d365baf6267c12b070d1836b8e0e843c70232644a963a06a14357c78de0d";
 9          //int iRet = -1;
10          //char szRes2[4096] = {0};    //解密后的字符串
11         //char hello[100] = "hello";
12         //char hello[100] = "version=1.0&reqType=getSecurityCode&prdName=USG5560&prdVer=V300R001&devIndex=CEA9";
13 
14 
15     iLoadDllRes1 = lr_load_dll("dencdll.dll");
16     if (0 != iLoadDllRes1)
17     {
18         lr_output_message("Notify:Load Dll error: dencdll.dll");
19         return -1;
20     }
21 
22     //----------------------------------------------测试加密----------------------------------------------
23     /*
24     * 打印hello的加密结果
25     * 注意：1. SdpEndecTest文件夹、commons-codec-1.8.jar、libscpjavainterface.dll、log4j-1.2.15.jar、
26     *          scpjavainterface.jar、SdpEndecApi.jar、vcgscpjavainterface.dll等均要放到“D:dmsdpsystemdll”目录下
27     * 函数原型： int Encrypt(int iType, const char* szSecurityCode, const char* szOri, const char* szFileName, char *szRes)
28     *          iType： 类型
29     *          szSecurityCode： 安全码
30     *          szOri：需要被加密的字符串；
31     *          szFileName：临时文件（建议一个用户创建一个）；
32     *          szRes： 加密后的字符串
33     *
34     */
35 
36          //iRet = Encrypt(0,"",hello,"D:\dm\sdp\LicenseLog\TmpFile\TmpFile1",szRes);
37          //lr_output_message("Notify:The result = %d, the encrypt are: %s",iRet,szRes);
38 
39 //         iRet = Decrypt(0,"",szRes,"D:\dm\sdp\LicenseLog\TmpFile\TmpFile2",szRes2);
40 //         lr_output_message("Notify:The result = %d, the decrypt are: %s",iRet,szRes2);
41 
42     return 0;
43 }

  1 Action()
  2 {
  3     web_set_max_html_param_len("40960");
  4 
  5 START:    
  6     //--------------------------------初始化--------------------------------
  7     memset(szSecurityCodeBody, '',sizeof(szSecurityCodeBody));
  8     memset(szSecurityCodBodyEnc, '',sizeof(szSecurityCodBodyEnc));
  9     memset(szPdtName, '',sizeof(szPdtName));
 10     memset(szPdtVer, '',sizeof(szPdtVer));
 11     memset(szDevESN, '',sizeof(szDevESN));
 12     memset(szDevIndex, '',sizeof(szDevIndex));
 13     memset(szAuthorizeBody, '',sizeof(szAuthorizeBody));
 14     memset(szOrdLac, '',sizeof(szOrdLac));
 15     memset(szActDevLicenseBody, '',sizeof(szActDevLicenseBody));
 16     memset(szAuthorizeBodyEnc, '',sizeof(szAuthorizeBodyEnc));
 17 
 18     memset(szActDevLicenseBodyEnc, '',sizeof(szActDevLicenseBodyEnc));
 19     memset(szDownLoadOnlineBody, '',sizeof(szDownLoadOnlineBody));
 20     memset(szReleaseSessionBody, '',sizeof(szReleaseSessionBody));
 21     memset(szJsessionid, '',sizeof(szJsessionid));
 22     memset(getSecurityCode_requestData,'',sizeof(getSecurityCode_requestData));
 23     memset(getSecurityCode_requestDataDnc,'',sizeof(getSecurityCode_requestDataDnc));
 24     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
 25     memset(vuserid_str,'',sizeof(vuserid_str));
 26     memset(curtime_str,'',sizeof(curtime_str));
 27     memset(TmpFileName,'',sizeof(TmpFileName));
 28 
 29     memset(actDevLicense_requestData,'',sizeof(actDevLicense_requestData));
 30     memset(actDevLicense_requestDataDnc,'',sizeof(actDevLicense_requestDataDnc));
 31     memset(ProductNameTmp_STR,'',sizeof(ProductNameTmp_STR));
 32     memset(VersionTmp_STR,'',sizeof(VersionTmp_STR));
 33     memset(EsnTmp_STR,'',sizeof(EsnTmp_STR));
 34     memset(szDownLoadOnlineBodyEnc,'',sizeof(szDownLoadOnlineBodyEnc));
 35     memset(getDevLicense_requestData,'',sizeof(getDevLicense_requestData));
 36     memset(getDevLicense_requestDataDnc,'',sizeof(getDevLicense_requestDataDnc));
 37     memset(szReleaseSessionBodyEnc,'',sizeof(szReleaseSessionBodyEnc));
 38     memset(relSesRsr_requestData,'',sizeof(relSesRsr_requestData));
 39 
 40     memset(relSesRsr_requestDataDnc,'',sizeof(relSesRsr_requestDataDnc));
 41     memset(getAuthInfo_requestData,'',sizeof(getAuthInfo_requestData));
 42     memset(getAuthInfo_requestDataDnc,'',sizeof(getAuthInfo_requestDataDnc));
 43 
 44     strcpy(szSecurityCodeBody,"version=1.1&reqType=getSecurityCode&prdName=");
 45     strcpy(szAuthorizeBody,"version=1.1&reqType=getAuthInfo&prdName=");
 46     strcpy(szActDevLicenseBody,"version=1.1&reqType=actDevLicense&prdName=");
 47     strcpy(szDownLoadOnlineBody,"version=1.1&reqType=getDevLicense&prdName=");
 48     strcpy(szReleaseSessionBody,"version=1.1&reqType=relSesRsr&jsessionid=");
 49     strcpy(szOrdLac,lr_eval_string("{Param_OrdLac}"));
 50     strcpy(szPdtName,lr_eval_string("{Param_PdtName}"));    //获取产品名称
 51     strcpy(szPdtVer, lr_eval_string("{Param_PdtVer}"));        //获取产品版本号
 52 
 53     //USG5560,V300R001,PSCE59A36540B14
 54     //USG5560,V300R001,T69YGLB7A405
 55     //USG5560,V300R001,PSCE59A36540B12
 56     //---调试用ESN
 57     //strcpy(szDevESN,lr_eval_string("{Param_ESN_Part1}"));
 58     //strcat(szDevESN,lr_eval_string("{Param_ESN_Part2}"));
 59     //strcpy(szDevESN,"456789ASWABCDHSJEUWYDSWDF");
 60     strcpy(szDevESN,lr_eval_string("{Param_ESN}"));
 61 
 62     //对szDevESN进行HASH
 63 
 64     //取前四个字节得到szDevIndex ASDE
 65     //strcpy(szDevIndex,"SWDF");
 66     strcpy(szDevIndex,lr_eval_string("{Param_DevIndex}"));
 67 
 68     lr_output_message("----------szOrdLac:%s, szPdtName:%s, szPdtVer:%s, szDevESN:%s, szDevIndex:%s----------", szOrdLac,szPdtName,szPdtVer,szDevESN,szDevIndex);
 69 
 70     //固定头
 71     web_add_auto_header("Accept",
 72         "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
 73     web_add_auto_header("Accept-Language",
 74         "zh-cn,zh;q=0.5");
 75     web_add_auto_header("Accept-Encoding",
 76         "gzip,deflate");
 77     web_add_auto_header("Connection",
 78         "keep-alive");    
 79     web_remove_auto_header("Content-Type",
 80         LAST);
 81     web_remove_auto_header("Cache-Control",
 82         LAST);
 83     web_remove_auto_header("User-Agent",
 84         LAST);
 85 
 86     //--------------------------------获取安全码-------------------------------
 87     //封装body
 88     strcat(szSecurityCodeBody,szPdtName);
 89     strcat(szSecurityCodeBody,"&prdVer=");
 90     strcat(szSecurityCodeBody,szPdtVer);
 91     strcat(szSecurityCodeBody,"&devIndex=");
 92     strcat(szSecurityCodeBody,szDevIndex);
 93     lr_output_message("Notify:The szSecurityCodeBody: %s",szSecurityCodeBody);
 94 
 95     //临时文件名生成
 96     strcpy(TmpFileName,"D:\dm\sdp\LicenseLog\TmpFile\TmpFile");
 97     strcpy(vuserid_str,lr_eval_string("{vuserid_Param}"));
 98     strcpy(curtime_str,lr_eval_string("{curtime_Param}"));
 99 
100     strcat(TmpFileName,vuserid_str);
101     strcat(TmpFileName,"_");
102     strcat(TmpFileName,curtime_str);
103 
104     //加密szSecurityCodeBody
105     iRet = Encrypt(0,"",szSecurityCodeBody,TmpFileName,szSecurityCodBodyEnc);
106     lr_output_message("----------iRet:%d,TmpFileName:%s,szSecurityCodBodyEnc:%s----------", iRet,TmpFileName,szSecurityCodBodyEnc);
107 
108     //放入参数中
109     lr_save_string(szSecurityCodBodyEnc,"getSecurityCodeBody_Param");
110     //lr_save_string(destHexCode,"getSecurityCodeBody_Param");
111 
112     //关联data内容
113     web_reg_save_param_ex(
114         "ParamName=getSecurityCode_requestData_Param",
115         "LB=data=",
116         "RB=",
117         SEARCH_FILTERS,
118         LAST);
119 
120     //关联Content-Length的值    
121     web_reg_save_param_ex(
122         "ParamName=ContentLength_Param",
123         "LB=Content-Length: ",
124         "RB=
",
125         SEARCH_FILTERS,
126         "Scope=HEADERS",
127         LAST);
128 
129     //关联会话ID
130     web_reg_save_param_ex(
131         "ParamName=jsessionid_Param",
132         "LB=JSESSIONID=",
133         "RB=;",
134         SEARCH_FILTERS,
135         LAST);
136 
137     //事物开始
138     lr_start_transaction("GetSecurityCode");
139 
140     //发起获取安全码请求
141     web_custom_request("web_custom_request",
142         "URL=http://{Param_serverIP}/LSP/device/licOnlineActivation.do?type=0",
143         "Method=POST",
144         "TargetFrame=",
145         "Resource=0",
146         "Referer=",
147         "Mode=HTTP",
148         "BodyBinary={getSecurityCodeBody_Param}",   
149         LAST);
150 
151     lr_end_transaction("GetSecurityCode", LR_AUTO);
152 
153 
154     ContentLength = atoi(lr_eval_string("{ContentLength_Param}")) - strlen("type=0&data=");
155 
156     //解密data内容
157     memcpy(getSecurityCode_requestData,lr_eval_string("{getSecurityCode_requestData_Param}"),ContentLength);
158     iRet = Decrypt(0,"",getSecurityCode_requestData,ContentLength,TmpFileName,getSecurityCode_requestDataDnc);
159     lr_output_message("----------iRet:%d,getSecurityCode_requestData:%s,getSecurityCode_requestDataDnc: %s----------",iRet,getSecurityCode_requestData,getSecurityCode_requestDataDnc);
160 
161 
162     //提取resCode
163     strcpy(requestDataDnc_Tmp,getSecurityCode_requestDataDnc);
164     resCodeTmp = (char *)strstr(requestDataDnc_Tmp,resCodeTou);
165     if (NULL == resCodeTmp)
166     {
167         lr_error_message("resCodeTmp is NULL!");
168         //return -1;
169         goto START;
170     }
171     resCodeTmp += strlen(resCodeTou);
172     resCodeTmp = (char *)strtok(resCodeTmp,delim);
173     resCode = atoi(resCodeTmp);
174     lr_output_message("----------resCode:%d----------",resCode);
175 
176 
177     //判断响应的返回码是否正确,如果不正确就退出!
178     if (100!=resCode && 200!=resCode)
179     {
180         //return -1;
181         goto START;
182     }
183 
184     //提取安全码
185     SecurityCodeTmp = (char *)strstr(getSecurityCode_requestDataDnc,SecurityCodeTou);
186     if (NULL == SecurityCodeTmp)
187     {
188         //return -1;
189         goto START;
190     }
191     SecurityCodeTmp += strlen(SecurityCodeTou);
192     lr_output_message("----------SecurityCodeTmp:%s----------",SecurityCodeTmp);
193 
194 
195     //--------------------------------获取订单授权信息--------------------------------
196     //封装body
197     strcat(szAuthorizeBody,szPdtName);
198     strcat(szAuthorizeBody,"&prdVer=");
199     strcat(szAuthorizeBody,szPdtVer);
200     strcat(szAuthorizeBody,"&devEsn=");
201     strcat(szAuthorizeBody,szDevESN);
202     strcat(szAuthorizeBody,"&ordLac=");
203     strcat(szAuthorizeBody,szOrdLac);
204 
205     //临时文件名生成
206     strcpy(TmpFileName,"D:\dm\sdp\LicenseLog\TmpFile\TmpFile");
207     strcpy(vuserid_str,lr_eval_string("{vuserid_Param}"));
208     strcpy(curtime_str,lr_eval_string("{curtime_Param}"));
209     strcat(TmpFileName,vuserid_str);
210     strcat(TmpFileName,"_");
211     strcat(TmpFileName,curtime_str);
212 
213 
214     //加密szAuthorizeBody
215     iRet = Encrypt(1,SecurityCodeTmp,szAuthorizeBody,TmpFileName,szAuthorizeBodyEnc);
216     lr_output_message("----------iRet:%d, szAuthorizeBodyEnc: %s----------",iRet,szAuthorizeBodyEnc);
217     
218     //放入参数中
219     lr_save_string(szAuthorizeBodyEnc,"getAuthBody_Param");
220 
221     //关联data内容
222     web_reg_save_param_ex(
223         "ParamName=getAuthInfo_requestData_Param",
224         "LB=data=",
225         "RB=",
226         SEARCH_FILTERS,
227         LAST);
228 
229     //关联Content-Length的值   
230     web_reg_save_param_ex(
231         "ParamName=ContentLength_Param",
232         "LB=Content-Length: ",
233         "RB=
",
234         SEARCH_FILTERS,
235         "Scope=HEADERS",
236         LAST);
237 
238     lr_start_transaction("GetOrderAuthorInfo");
239 
240     web_custom_request("web_custom_request",
241         "URL=http://{Param_serverIP}/LSP/device/licOnlineActivation.do;jsessionid={jsessionid_Param}?type=1",
242         "Method=POST",
243         "TargetFrame=",
244         "Resource=0",
245         "Referer=",
246         "Mode=HTTP",
247         "BodyBinary={getAuthBody_Param}",
248         LAST);
249     lr_end_transaction("GetOrderAuthorInfo", LR_AUTO);
250 
251     ContentLength = atoi(lr_eval_string("{ContentLength_Param}")) - strlen("type=0&data=");
252 
253 
254     //解密data内容
255     memcpy(getAuthInfo_requestData,lr_eval_string("{getAuthInfo_requestData_Param}"),ContentLength);
256     iRet = Decrypt(1,SecurityCodeTmp,getAuthInfo_requestData,ContentLength,TmpFileName,getAuthInfo_requestDataDnc);
257     lr_output_message("----------iRet:%d, getAuthInfo_requestDataDnc: %s----------",iRet,getAuthInfo_requestDataDnc);
258 
259 
260     //提取resCode
261     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
262     strcpy(requestDataDnc_Tmp,getAuthInfo_requestDataDnc);
263     resCodeTmp = (char *)strstr(requestDataDnc_Tmp,resCodeTou);
264     if (NULL == resCodeTmp)
265     {
266         lr_error_message("resCodeTmp is NULL!");
267         //return -1;
268         goto START;
269 
270     }
271     resCodeTmp += strlen(resCodeTou);
272     resCodeTmp = (char *)strtok(resCodeTmp,delim);
273     resCode = atoi(resCodeTmp);
274     lr_output_message("Notify:resCode:%d",resCode);
275    
276      //判断响应的返回码是否正确,为100，如果不正确就退出!
277      if (100!=resCode && 200!=resCode && 104!=resCode)
278      {
279          lr_error_message("resCode is not 100 !");
280          //return -1;
281         goto START;
282      }
283 
284      //提取授权信息/
285     /*
286      authInfoTmp = (char *)strstr(getAuthInfo_requestDataDnc,authInfoTou);
287      if (NULL == authInfoTmp)
288      {
289          lr_error_message("authInfoTmp is NULL!");
290          return -1;
291 
292      }
293      authInfoTmp += strlen(authInfoTou);
294      lr_output_message("Notify:authInfoTmp:%s",authInfoTmp);
295     */
296 
297 
298     //--------------------------------在线激活--------------------------------
299     //封装body
300     strcat(szActDevLicenseBody,szPdtName);
301     strcat(szActDevLicenseBody,"&prdVer=");
302     strcat(szActDevLicenseBody,szPdtVer);
303     strcat(szActDevLicenseBody,"&devEsn=");
304     strcat(szActDevLicenseBody,szDevESN);
305     strcat(szActDevLicenseBody,"&ordLac=");
306     strcat(szActDevLicenseBody,szOrdLac);
307 
308     //临时文件名生成
309     strcpy(TmpFileName,"D:\dm\sdp\LicenseLog\TmpFile\TmpFile");
310     strcpy(vuserid_str,lr_eval_string("{vuserid_Param}"));
311     strcpy(curtime_str,lr_eval_string("{curtime_Param}"));
312     strcat(TmpFileName,vuserid_str);
313     strcat(TmpFileName,"_");
314     strcat(TmpFileName,curtime_str);
315 
316     //加密szActDevLicenseBody
317     iRet = Encrypt(1,SecurityCodeTmp,szActDevLicenseBody,TmpFileName,szActDevLicenseBodyEnc);
318     lr_output_message("----------iRet:%d, szActDevLicenseBodyEnc: %s----------",iRet,szActDevLicenseBodyEnc);
319    
320     //放入参数中
321     lr_save_string(szActDevLicenseBodyEnc,"actDevLicenseBody_Param");
322 
323     //关联data内容
324     web_reg_save_param_ex(
325         "ParamName=actDevLicense_requestData_Param",
326         "LB=data=",
327         "RB=",
328         SEARCH_FILTERS,
329         LAST);
330 
331     //关联Content-Length的值   
332     web_reg_save_param_ex(
333         "ParamName=ContentLength_Param",
334         "LB=Content-Length: ",
335         "RB=
",
336         SEARCH_FILTERS,
337         "Scope=HEADERS",
338         LAST);
339 
340     lr_start_transaction("ActiveOnline");
341 
342     web_custom_request("web_custom_request",
343         "URL=http://{Param_serverIP}/LSP/device/licOnlineActivation.do;jsessionid={jsessionid_Param}?type=1",
344         "Method=POST",
345         "TargetFrame=",
346         "Resource=0",
347         "Referer=",
348         "Mode=HTTP",
349         "BodyBinary={actDevLicenseBody_Param}",
350         LAST);
351 
352     lr_end_transaction("ActiveOnline", LR_AUTO);
353 
354     ContentLength = atoi(lr_eval_string("{ContentLength_Param}")) - strlen("type=0&data=");
355 
356     //解密data内容
357     memcpy(actDevLicense_requestData,lr_eval_string("{actDevLicense_requestData_Param}"),ContentLength);
358     iRet = Decrypt(1,SecurityCodeTmp,actDevLicense_requestData,ContentLength,TmpFileName,actDevLicense_requestDataDnc);
359     lr_output_message("----------iRet:%d, actDevLicense_requestDataDnc: %s----------",iRet,actDevLicense_requestDataDnc);
360 
361     //提取resCode
362     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
363     strcpy(requestDataDnc_Tmp,actDevLicense_requestDataDnc); //因为strtok会破坏源字符串，因此放在一个临时区域中
364     resCodeTmp = (char *)strstr(requestDataDnc_Tmp,resCodeTou);
365     if (NULL == resCodeTmp)
366     {
367         lr_error_message("resCodeTmp is NULL!");
368         //return -1;
369         goto START;
370 
371     }
372     resCodeTmp += strlen(resCodeTou);
373     resCodeTmp = (char *)strtok(resCodeTmp,delim);
374     resCode = atoi(resCodeTmp);
375     lr_output_message("----------resCode:%d----------",resCode);
376 
377      //判断响应的返回码是否正确,为100，如果不正确就退出!
378      if (100!=resCode && 200!=resCode && 104!=resCode)
379      {
380          lr_error_message("resCode is not 100 !");
381          //return -1;
382         goto START;
383      }
384 
385     if (104 == resCode)
386     {
387         goto DOWNLOADSTEP;
388     }
389 
390     //提取license文件信息中的产品名称
391     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
392     strcpy(requestDataDnc_Tmp,actDevLicense_requestDataDnc);
393     ProductNameTmp = (char *)strstr(requestDataDnc_Tmp,ProductNameTou);
394     if (NULL == ProductNameTmp)
395     {
396         lr_error_message("ProductNameTmp is NULL!");
397         //return -1;
398         goto START;
399 
400     }
401     ProductNameTmp += strlen(ProductNameTou);
402     ProductNameTmp = (char *)strtok(ProductNameTmp,ProductName_delim);
403     lr_output_message("Notify:ProductNameTmp:%s",ProductNameTmp);
404 
405 
406     //提取license文件信息中的版本号
407     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
408     //strcpy(requestDataDnc_Tmp,getDevLicense_requestDataD); //jzq
409     strcpy(requestDataDnc_Tmp,actDevLicense_requestDataDnc);
410     VersionTmp = (char *)strstr(requestDataDnc_Tmp,VersionTou);
411     lr_output_message("actDevLicense_requestDataDnc:%s,requestDataDnc_Tmp:%s", actDevLicense_requestDataDnc,requestDataDnc_Tmp);
412     if (NULL == VersionTmp)
413     {
414         lr_error_message("VersionTmp is NULL!");
415         //return -1;
416         goto START;
417 
418     }
419     VersionTmp += strlen(VersionTou);
420     VersionTmp = (char *)strtok(VersionTmp,Version_delim);
421     lr_output_message("Notify:VersionTmp:%s",VersionTmp);
422 
423 
424     //提取license文件信息中的ESN
425     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
426     //strcpy(requestDataDnc_Tmp,getDevLicense_requestDataDnc);    //jzq
427     strcpy(requestDataDnc_Tmp,actDevLicense_requestDataDnc);
428     EsnTmp = (char *)strstr(requestDataDnc_Tmp,EsnTou);
429     if (NULL == EsnTmp)
430     {
431         lr_error_message("Esn is NULL!");
432         //return -1;
433         goto START;
434 
435     }
436     EsnTmp += strlen(EsnTou);
437     EsnTmp = (char *)strtok(EsnTmp,Esn_delim);
438     lr_output_message("Notify:EsnTmp:%s",EsnTmp);
439 
440     //数据校验....1.需要用到安全码；2.需要用到刚才请求的返回值。校验规则："产品名称、版本号、ESN"三者是否跟最初一致？如果不一致就事务报错！！！
441     //校验产品名称
442     memcpy(ProductNameTmp_STR,ProductNameTmp,strlen(szPdtName));
443     strcmp_result = strcmp(szPdtName,ProductNameTmp_STR);
444     if (0 != strcmp_result) {
445         lr_error_message("strcmp_result:%d ProductName is not same!!!",strcmp_result);
446         //return -1;
447         goto START;
448     }
449 
450     //校验版本
451     memcpy(VersionTmp_STR,VersionTmp,strlen(szPdtVer));
452     strcmp_result = strcmp(szPdtVer,VersionTmp_STR);
453     if (0 != strcmp_result) {
454         lr_error_message("strcmp_result:%d Version is not same!!!",strcmp_result);
455         //return -1;
456         goto START;
457     }
458 
459     //校验Esn
460     memcpy(EsnTmp_STR,EsnTmp,strlen(szDevESN));
461     strcmp_result = strcmp(szDevESN,EsnTmp_STR);
462     if (0 != strcmp_result) {
463         lr_error_message("strcmp_result:%d Esn is not same!!!",strcmp_result);
464         //return -1;
465         goto START;
466     }
467 
468     goto RELEASESESSIONSTEP;
469 
470 
471 DOWNLOADSTEP:
472     //--------------------------------在线下载--------------------------------
473     //封装body   
474     strcat(szDownLoadOnlineBody,szPdtName);
475     strcat(szDownLoadOnlineBody,"&prdVer=");
476     strcat(szDownLoadOnlineBody,szPdtVer);
477     strcat(szDownLoadOnlineBody,"&devEsn=");
478     strcat(szDownLoadOnlineBody,szDevESN);
479     strcat(szDownLoadOnlineBody,"&ordLac=");
480     strcat(szDownLoadOnlineBody,szOrdLac);
481 
482     //临时文件名生成
483     strcpy(TmpFileName,"D:\dm\sdp\LicenseLog\TmpFile\TmpFile");
484     strcpy(vuserid_str,lr_eval_string("{vuserid_Param}"));
485     strcpy(curtime_str,lr_eval_string("{curtime_Param}"));
486     strcat(TmpFileName,vuserid_str);
487     strcat(TmpFileName,"_");
488     strcat(TmpFileName,curtime_str);
489 
490     //加密szDownLoadOnlineBody
491     iRet = Encrypt(1,SecurityCodeTmp,szDownLoadOnlineBody,TmpFileName,szDownLoadOnlineBodyEnc);
492     lr_output_message("----------iRet:%d, szDownLoadOnlineBodyEnc: %----------s",iRet,szDownLoadOnlineBodyEnc);
493    
494     //放入参数中
495     lr_save_string(szDownLoadOnlineBodyEnc,"getDevLicenseBody_Param");
496 
497     //设置能关联到得最大值
498     web_set_max_html_param_len("100000");
499 
500 
501     //关联data内容
502     web_reg_save_param_ex(
503         "ParamName=getDevLicense_requestData_Param",
504         "LB=data=",
505         "RB=",
506         SEARCH_FILTERS,
507         LAST);
508 
509     //关联Content-Length的值   
510     web_reg_save_param_ex(
511         "ParamName=ContentLength_Param",
512         "LB=Content-Length: ",
513         "RB=
",
514         SEARCH_FILTERS,
515         "Scope=HEADERS",
516         LAST);
517 
518     lr_start_transaction("DownloadOnline");
519 
520     web_custom_request("web_custom_request",
521         "URL=http://{Param_serverIP}/LSP/device/licOnlineActivation.do;jsessionid={jsessionid_Param}?type=1",
522         "Method=POST",
523         "TargetFrame=",
524         "Resource=0",
525         "Referer=",
526         "Mode=HTTP",
527         "BodyBinary={getDevLicenseBody_Param}",
528         LAST);
529 
530     lr_end_transaction("DownloadOnline", LR_AUTO);
531 
532     ContentLength = atoi(lr_eval_string("{ContentLength_Param}")) - strlen("type=0&data=");
533 
534     //解密data内容
535     memcpy(getDevLicense_requestData,lr_eval_string("{getDevLicense_requestData_Param}"),ContentLength);
536     iRet = Decrypt(1,SecurityCodeTmp,getDevLicense_requestData,ContentLength,TmpFileName,getDevLicense_requestDataDnc);
537     lr_output_message("----------iRet:%d, getDevLicense_requestDataDnc: %s----------",iRet,getDevLicense_requestDataDnc);
538 
539 
540     //提取resCode
541     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
542     strcpy(requestDataDnc_Tmp,getDevLicense_requestDataDnc);
543     resCodeTmp = (char *)strstr(requestDataDnc_Tmp,resCodeTou);
544     if (NULL == resCodeTmp)
545     {
546         lr_error_message("resCodeTmp is NULL!");
547         //return -1;
548         goto START;
549 
550     }
551     resCodeTmp += strlen(resCodeTou);
552     resCodeTmp = (char *)strtok(resCodeTmp,delim);
553     resCode = atoi(resCodeTmp);
554     lr_output_message("Notify:resCode:%d",resCode);
555 
556     //判断响应的返回码是否正确,为100，如果不正确就退出!
557     if (100!=resCode && 200!=resCode)
558     {
559         //return -1;
560         goto START;
561     }
562 
563     //提取license文件信息中的产品名称
564     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
565     strcpy(requestDataDnc_Tmp,getDevLicense_requestDataDnc); //因为strtok会破坏源字符串，因此放在一个临时区域中
566     ProductNameTmp = (char *)strstr(requestDataDnc_Tmp,ProductNameTou);
567     if (NULL == ProductNameTmp)
568     {
569         lr_error_message("ProductNameTmp is NULL!");
570         //return -1;
571         goto START;
572 
573     }
574     ProductNameTmp += strlen(ProductNameTou);
575     ProductNameTmp = (char *)strtok(ProductNameTmp,ProductName_delim);
576     lr_output_message("----------ProductNameTmp:%s----------",ProductNameTmp);
577 
578 
579     //提取license文件信息中的版本号
580     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
581     strcpy(requestDataDnc_Tmp,getDevLicense_requestDataDnc); //因为strtok会破坏源字符串，因此放在一个临时区域中
582     VersionTmp = (char *)strstr(requestDataDnc_Tmp,VersionTou);
583     if (NULL == VersionTmp)
584     {
585         lr_error_message("VersionTmp is NULL!");
586         //return -1;
587         goto START;
588 
589     }
590     VersionTmp += strlen(VersionTou);
591     VersionTmp = (char *)strtok(VersionTmp,Version_delim);
592     lr_output_message("----------VersionTmp:%s----------",VersionTmp);
593 
594 
595     //提取license文件信息中的ESN
596     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
597     strcpy(requestDataDnc_Tmp,getDevLicense_requestDataDnc); //因为strtok会破坏源字符串，因此放在一个临时区域中
598     EsnTmp = (char *)strstr(requestDataDnc_Tmp,EsnTou);
599     if (NULL == EsnTmp)
600     {
601         lr_error_message("Esn is NULL!");
602         //return -1;
603         goto START;
604 
605     }
606     EsnTmp += strlen(EsnTou);
607     EsnTmp = (char *)strtok(EsnTmp,Esn_delim);
608     lr_output_message("----------EsnTmp:%s----------",EsnTmp);
609 
610     //数据校验....1.需要用到安全码；2.需要用到刚才请求的返回值。校验规则："产品名称、版本号、ESN"三者是否跟最初一致？如果不一致就事务报错！！！
611     //校验产品名称
612     memcpy(ProductNameTmp_STR,ProductNameTmp,strlen(szPdtName));
613     strcmp_result = strcmp(szPdtName,ProductNameTmp_STR);
614     if (0 != strcmp_result)
615     {
616         lr_error_message("strcmp_result:%d ProductName is not same!",strcmp_result);
617         //return -1;
618         goto START;
619     }
620 
621     //校验版本
622     memcpy(VersionTmp_STR,VersionTmp,strlen(szPdtVer));
623     strcmp_result = strcmp(szPdtVer,VersionTmp_STR);
624     if (0 != strcmp_result)
625     {
626         lr_error_message("strcmp_result:%d Version is not same!",strcmp_result);
627         //return -1;
628         goto START;
629     }
630 
631     //校验Esn
632     memcpy(EsnTmp_STR,EsnTmp,strlen(szDevESN));
633     strcmp_result = strcmp(szDevESN,EsnTmp_STR);
634     if (0 != strcmp_result)
635     {
636         lr_error_message("strcmp_result:%d Esn is not same!",strcmp_result);
637         //return -1;
638         goto START;
639     }
640 
641 RELEASESESSIONSTEP:
642     //--------------------------------释放会话资源--------------------------------
643     //封装body
644     strcpy(szJsessionid,lr_eval_string("{jsessionid_Param}"));
645     strcat(szReleaseSessionBody,szJsessionid);
646 
647     //加密szReleaseSessionBody
648     iRet = Encrypt(0,"",szReleaseSessionBody,TmpFileName,szReleaseSessionBodyEnc);
649     lr_output_message("----------iRet:%d, szReleaseSessionBodyEnc: %s----------",iRet,szReleaseSessionBodyEnc);
650    
651     //放入参数中
652     lr_save_string(szReleaseSessionBodyEnc,"relSesRsrBody_Param");
653 
654     //关联data内容
655     web_reg_save_param_ex(
656         "ParamName=relSesRsr_requestData_Param",
657         "LB=data=",
658         "RB=",
659         SEARCH_FILTERS,
660         LAST);
661 
662     //关联Content-Length的值   
663     web_reg_save_param_ex(
664         "ParamName=ContentLength_Param",
665         "LB=Content-Length: ",
666         "RB=
",
667         SEARCH_FILTERS,
668         "Scope=HEADERS",
669         LAST);
670 
671     lr_start_transaction("ReleaseSession");
672 
673     web_custom_request("web_custom_request",
674         "URL=http://{Param_serverIP}/LSP/device/licOnlineActivation.do;jsessionid={jsessionid_Param}?type=0",
675         "Method=POST",
676         "TargetFrame=",
677         "Resource=0",
678         "Referer=",
679         "Mode=HTTP",
680         "BodyBinary={relSesRsrBody_Param}",
681         LAST);
682 
683     lr_end_transaction("ReleaseSession", LR_AUTO);
684 
685     ContentLength = atoi(lr_eval_string("{ContentLength_Param}")) - strlen("type=0&data=");
686 
687     //解密data内容
688     memcpy(relSesRsr_requestData,lr_eval_string("{relSesRsr_requestData_Param}"),ContentLength);
689     iRet = Decrypt(0,"",relSesRsr_requestData,ContentLength,TmpFileName,relSesRsr_requestDataDnc);
690     lr_output_message("----------iRet:%d, relSesRsr_requestDataDnc: %s----------",iRet,relSesRsr_requestDataDnc);
691 
692     //提取resCode
693     memset(requestDataDnc_Tmp,'',sizeof(requestDataDnc_Tmp));
694     strcpy(requestDataDnc_Tmp,relSesRsr_requestDataDnc);
695     resCodeTmp = (char *)strstr(requestDataDnc_Tmp,resCodeTou);
696     if (NULL == resCodeTmp)
697     {
698         lr_error_message("resCodeTmp is NULL!");
699         //return -1;
700         goto START;
701 
702     }
703     resCodeTmp += strlen(resCodeTou);
704     resCodeTmp = (char *)strtok(resCodeTmp,delim);
705     resCode = atoi(resCodeTmp);
706     lr_output_message("----------resCode:%d----------",resCode);
707 
708     return 0;
709 }

DLL源码

头文件dencdll.h：

1 _declspec(dllexport) int Encrypt(int iType, const char *szSecurityCode, const char *szOri, const char *szFileName, char *szRes);
2 
3 _declspec(dllexport) int Decrypt(int iType, const char *szSecurityCode, const unsigned char *szOri, int iOriLen, const char *szFileName, char *szRes);

源文件dencdll.c：

  1 #include "dencdll.h"
  2 #include <stdio.h>
  3 #include <string.h>
  4 #include <stdlib.h>
  5 #include <ctype.h>
  6 
  7 /*
  8 函数介绍：调用加密批处理命令进行加密操作，并将加密结果转换成十六进制的形式以供web_custom_request函数使用。（当没有安全码传入时使用enc0.bat进行加密，
  9 如：enc0.bat enc 0 "string"；当需要安全码传入时使用enc1.bat进行加密，如：enc1.bat enc 1 安全码 "string"）
 10 
 11 参数：iType--类型：0不传入安全码，1传入安全码； szSecurityCode--安全码； szOri--待加密的字符串； szFileName--临时文
 12 件名（包含文件绝对路径）； szRes--返回的密文串，调用者负责申请足够的内存
 13 
 14 返回值：0--成功； 非0--失败
 15 */
 16 int Encrypt(int iType, const char *szSecurityCode, const char *szOri, const char *szFileName, char *szRes)
 17 {
 18     char *szCommand = NULL;
 19     FILE *pFile = NULL;
 20     char szTmp1[32];
 21     char szTmp2[128];
 22     const char *szTmp3 = "cd C:\dm\sdp\systemdll\SdpEndecTest\bin";
 23     char szTmp4 = '';
 24     int iLen = 0;
 25     int i = 0;
 26     char szResTmp[4096];
 27     char curHexCode[10];
 28 
 29     memset(szTmp1,'',sizeof(szTmp1));
 30     memset(szTmp2,'',sizeof(szTmp2));
 31     memset(szResTmp,'',sizeof(szResTmp));
 32     memset(curHexCode,'',sizeof(curHexCode));
 33     
 34     //判断传入的参数是否齐全
 35     if(NULL==szOri || NULL==szFileName || NULL==szRes)
 36     {
 37         return -1;
 38     }
 39 
 40     //判断是否需要传入安全码
 41     if(0 == iType)
 42     {
 43         strcpy(szTmp1,"enc0.bat enc 0");
 44     }
 45     else if(1 == iType)
 46     {
 47         strcpy(szTmp1,"enc0.bat enc 1");
 48     }
 49     else
 50     {
 51         return -2;
 52     }
 53 
 54     //申请内存用于存放加密命令串
 55     szCommand = (char *)malloc(strlen(szOri)+strlen(szTmp1)+strlen(szFileName)+64);
 56     if(NULL == szCommand)
 57     {
 58         return -3;
 59     }
 60     sprintf(szCommand,"%s %s "%s" > %s",szTmp1,szSecurityCode,szOri,szFileName);
 61 
 62     //进入到加解密批处理命令执行目录下
 63     system(szTmp3);
 64 
 65     //执行加密命令行，命令执行结果重定向到临时文件中
 66     system(szCommand);
 67     
 68     //释放存放加密命令串的内存
 69     free(szCommand);
 70 
 71     //读临时文件
 72     pFile = fopen(szFileName,"r+");
 73     if(NULL == pFile)
 74     {
 75         return -4;
 76     }
 77 
 78     while(!feof(pFile))
 79     {
 80         fread(szTmp2,sizeof(szTmp2)-1,1,pFile);
 81         strcat(szResTmp,szTmp2);
 82         memset(szTmp2,'',sizeof(szTmp2));
 83     }
 84 
 85     //文件尾处理
 86     iLen = strlen(szResTmp);
 87     if((0<iLen) && iscntrl(szResTmp[iLen-1]))
 88     {
 89         szResTmp[iLen-1] = '';
 90     }
 91 
 92     //将字符流转换成十六进制形式
 93     iLen = strlen(szResTmp);
 94     for(i=0; i<iLen; i+=2)
 95     {
 96         memset(curHexCode,'',sizeof(curHexCode));
 97         curHexCode[0] = '\';
 98         curHexCode[1] = 'x';
 99         curHexCode[2] = szResTmp[i];
100         curHexCode[3] = szResTmp[i+1];
101         strcat(szRes, curHexCode);
102     }
103 
104     //关闭文件
105     fclose(pFile);
106     pFile = NULL;
107 
108     return 0;
109 }
110 
111 
112 
113 
114 /*
115 函数介绍：调用解密批处理命令进行解密操作。（当没有安全码传入时使用dec0.bat进行解密；当需要安全码传入时使用dec1.bat进行解密）
116 
117 参数：iType--类型：0不传入安全码，1传入安全码； szSecurityCode--安全码； szOri--待解密的密文串；iOriLen--密文串的长度；szFileName--临时文
118 件名（包含文件绝对路径）； szRes--返回的解密后的字符串，调用者负责申请足够的内存
119 
120 返回值：0--成功； 非0--失败
121 */
122 int Decrypt(int iType, const char *szSecurityCode, const unsigned char *szOri, int iOriLen, const char *szFileName, char *szRes)
123 {
124     char *szCommand = NULL;
125     FILE *pFile = NULL;
126     char szTmp1[32];
127     char szTmp2[128];
128     int iLen = 0;
129     int i = 0;
130     char hexCodeString[40960];
131     char curHexCode[10];
132     const char *szTmp3 = "cd C:\dm\sdp\systemdll\SdpEndecTest\bin";    
133 
134     memset(szTmp1,'',sizeof(szTmp1));
135     memset(szTmp2,'',sizeof(szTmp2));
136     memset(curHexCode,'',sizeof(curHexCode));
137     memset(hexCodeString,'',sizeof(hexCodeString));
138     
139     //将密文串格式化为十六进制形式
140     for (i=0; i<iOriLen; i++)
141     {
142         sprintf(curHexCode, "%02X", szOri[i]);
143         strcat(hexCodeString, curHexCode);
144         memset(curHexCode,'',sizeof(curHexCode));
145     }
146 
147     //判断传入的参数是否齐全
148     if(NULL==szOri || NULL==szFileName || NULL==szRes)
149     {
150         return -1;
151     }
152 
153     //判断是否需要传入安全码
154     if(0 == iType)
155     {
156         strcpy(szTmp1,"dec0.bat dec 0");
157     }
158     else if(1 == iType)
159     {
160         strcpy(szTmp1,"dec0.bat dec 1");
161     }
162     else
163     {
164         return -2;
165     }
166 
167     //申请内存用于存放解密命令串
168     szCommand = (char *)malloc(strlen(hexCodeString)+strlen(szTmp1)+strlen(szFileName)+64);
169     if(NULL == szCommand)
170     {
171         return -3;
172     }
173     sprintf(szCommand,"%s %s "%s" > %s",szTmp1,szSecurityCode,hexCodeString,szFileName);
174 
175     //进入到加解密批处理命令执行目录下
176     system(szTmp3);
177 
178     //执行解密命令行，命令执行结果重定向到临时文件中
179     system(szCommand);
180     
181     //释放存放加密命令串的内存
182     free(szCommand);
183 
184     //读临时文件
185     pFile = fopen(szFileName,"r+");
186     if(NULL == pFile)
187     {
188         return -4;
189     }
190 
191     while(!feof(pFile))
192     {
193         fread(szTmp2,sizeof(szTmp2)-1,1,pFile);
194         strcat(szRes,szTmp2);
195         memset(szTmp2,'',sizeof(szTmp2));
196     }
197         
198     //文件尾处理
199     iLen = strlen(szRes);
200     if((0<iLen) && iscntrl(szRes[iLen-1]))
201     {
202         szRes[iLen-1] = '';
203     }
204 
205         //关闭文件
206     fclose(pFile);
207     pFile = NULL;
208 
209     return 0;
210 }