调用一个函数，当函数返回时修改了上层函数的参数地址，不知为何?

free_ever

在查看QQ的加密算法时，写了一个解码的测试程序，该程序运行时段错误异常终止。程序如下：

1. 
   
2. //main
   
3. 
   
4. #include "crypt.h"
   
5. #include <stdio.h>
   
6. 
   
7. int main(int argc,char **argv)
   
8. {
   
9.   unsigned char key[]={ 0xc8, 0x55, 0x40, 0x00, 0xab, 0x95, 0x05, 0x63, 0xae, 0x4b, 0xe6, 0xec, 0xc7, 0x22, 0x38, 0xb3};
   
10.   
    
11.   
    
12.   unsigned char dest[] = {0x15, 0xe5,
    
13.                           0x63, 0x0c,0x83,  0x58, 0x32,  0xf0, 0xe0, 0x7e, 0x1b, 0x76, 0x90, 0xe3,
    
14.                           0x88, 0x03, 0xe1, 0x97, 0x38,  0x5f, 0xdf, 0xa5, 0x76, 0xd1 };
    
15.   unsigned char decrypt[1024]={0};
    
16. 
    
17.   
    
18.   int len = 1024;
    
19.   int i=0;
    
20. 
    
21.   qq_decrypt(dest,24,key,decrypt,&len);
    
22. 
    
23.   for(;i<len;i++){
    
24.     printf("%x,",decrypt[i]);
    
25. 
    
26.   }
    
27.   printf("\n");
    
28.    
    
29.   
    
30.   return 0;
    
31.   
    
32. }
    
33. 
    
34. //crypt.c
    
35. 
    
36. 
    
37. #ifndef _WIN32
    
38. #include <arpa/inet.h>
    
39. #else
    
40. #include "win32dep.h"
    
41. #endif
    
42. 
    
43. #include <string.h>
    
44. 
    
45. #include "crypt.h"
    
46. 
    
47. /*****************************************************************************/
    
48. void qq_encipher(unsigned long *const v, const unsigned long *const k, unsigned long *const w)
    
49. {
    
50.         register unsigned long y = ntohl(v[0]), z = ntohl(v[1]), a = ntohl(k[0]), b = ntohl(k[1]), c = ntohl(k[2]), d = ntohl(k[3]), n = 0x10, sum = 0, delta = 0x9E3779B9&0xFFFFFFFF;        /*  0x9E3779B9 - 0x100000000 = -0x61C88647 */
    
51. 
    
52.         while (n-- > 0) {
    
53.                 sum += delta;
    
54.                 sum &=0xFFFFFFFF;
    
55.                 y += ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
    
56.                 z += ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
    
57.         }                        // while
    
58. 
    
59.         w[0] = htonl(y);
    
60.         w[1] = htonl(z);
    
61. }                                // qq_enciper
    
62. 
    
63. /*****************************************************************************/
    
64. void qq_decipher(unsigned long *const v, const unsigned long *const k, unsigned long *const w)
    
65. {
    
66.         register unsigned long y = ntohl(v[0]), z = ntohl(v[1]), a = ntohl(k[0]), b = ntohl(k[1]), c = ntohl(k[2]), d = ntohl(k[3]), n = 0x10, sum = 0xE3779B90,        // why this ? must be related with n value
    
67.             delta = 0x9E3779B9;
    
68. 
    
69.         /* sum = delta<<5, in general sum = delta * n */
    
70.         while (n-- > 0) {
    
71.                 z -= ((y << 4) + c) ^ (y + sum) ^ ((y >> 5) + d);
    
72.                 y -= ((z << 4) + a) ^ (z + sum) ^ ((z >> 5) + b);
    
73.                 sum -= delta;
    
74.         }
    
75. 
    
76.         w[0] = htonl(y);
    
77.         w[1] = htonl(z);
    
78. }                                // qq_decipher
    
79. 
    
80. /********************************************************************
    
81. * encrypt part
    
82. *******************************************************************/
    
83. 
    
84. void qq_encrypt(unsigned char *instr, int instrlen, unsigned char *key, unsigned char *outstr, int *outstrlen_prt)
    
85. {
    
86.         unsigned char plain[8],        // plain text buffer
    
87.          plain_pre_8[8],        // plain text buffer, previous 8 bytes
    
88.         *crypted,                // crypted text
    
89.         *crypted_pre_8,                // crypted test, previous 8 bytes
    
90.         *inp;                        // current position in instr
    
91.         int pos_in_byte = 1,        // loop in the byte
    
92.             is_header = 1,        // header is one byte
    
93.             count = 0,                // number of bytes being crypted
    
94.             padding = 0;        // number of padding stuff
    
95. 
    
96.         int rand(void) {        // it can be the real random seed function
    
97.                 return 0xdead;
    
98.         }                        // override with number, convenient for debug
    
99. 
    
100.   /*** we encrypt every eight byte ***/
     
101.         void encrypt_every_8_byte(void) {
     
102.                 for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
     
103.                         if (is_header) {
     
104.                                 plain[pos_in_byte] ^= plain_pre_8[pos_in_byte];
     
105.                         } else {
     
106.                                 plain[pos_in_byte] ^= crypted_pre_8[pos_in_byte];
     
107.                         }
     
108.                 }                // prepare plain text
     
109.                 qq_encipher((unsigned long *) plain, (unsigned long *) key, (unsigned long *) crypted);        // encrypt it
     
110. 
     
111.                 for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
     
112.                         crypted[pos_in_byte] ^= plain_pre_8[pos_in_byte];
     
113.                 }
     
114.                 memcpy(plain_pre_8, plain, 8 );        // prepare next
     
115. 
     
116.                 crypted_pre_8 = crypted;        // store position of previous 8 byte
     
117.                 crypted += 8;        // prepare next output
     
118.                 count += 8;        // outstrlen increase by 8
     
119.                 pos_in_byte = 0;        // back to start
     
120.                 is_header = 0;        // and exit header
     
121.         }                        // encrypt_every_8_byte
     
122. 
     
123.         pos_in_byte = (instrlen + 0x0a) % 8;        // header padding decided by instrlen
     
124.         if (pos_in_byte) {
     
125.                 pos_in_byte = 8 - pos_in_byte;
     
126.         }
     
127.         plain[0] = (rand() & 0xf8 ) | pos_in_byte;
     
128. 
     
129.         memset(plain + 1, rand() & 0xff, pos_in_byte++);
     
130.         memset(plain_pre_8, 0x00, sizeof(plain_pre_8 ));
     
131. 
     
132.         crypted = crypted_pre_8 = outstr;
     
133. 
     
134.         padding = 1;                // pad some stuff in header
     
135.         while (padding <= 2) {        // at most two byte
     
136.                 if (pos_in_byte < 8 ) {
     
137.                         plain[pos_in_byte++] = rand() & 0xff;
     
138.                         padding++;
     
139.                 }
     
140.                 if (pos_in_byte == 8 ) {
     
141.                         encrypt_every_8_byte();
     
142.                 }
     
143.         }
     
144. 
     
145.         inp = instr;
     
146.         while (instrlen > 0) {
     
147.                 if (pos_in_byte < 8 ) {
     
148.                         plain[pos_in_byte++] = *(inp++);
     
149.                         instrlen--;
     
150.                 }
     
151.                 if (pos_in_byte == 8 ) {
     
152.                         encrypt_every_8_byte();
     
153.                 }
     
154.         }
     
155. 
     
156.         padding = 1;                // pad some stuff in tailer
     
157.         while (padding <= 7) {        // at most sever byte
     
158.                 if (pos_in_byte < 8 ) {
     
159.                         plain[pos_in_byte++] = 0x00;
     
160.                         padding++;
     
161.                 }
     
162.                 if (pos_in_byte == 8) {
     
163.                         encrypt_every_8_byte();
     
164.                 }
     
165.         }
     
166. 
     
167.         *outstrlen_prt = count;
     
168. }                                // qq_encrypt
     
169. 
     
170. 
     
171. /********************************************************************
     
172. * [decrypt part]
     
173. * return 0 if failed, otherwise return 1
     
174. ********************************************************************/
     
175. 
     
176. int qq_decrypt(unsigned char *instr, int instrlen, unsigned char *key, unsigned char *outstr, int [color=green]*outstrlen_ptr[/color])
     
177. {
     
178.         unsigned char decrypted[8], m[8], *crypt_buff, *crypt_buff_pre_8, *outp;
     
179.         int count, context_start, pos_in_byte, padding;
     
180. 
     
181. 
     
182.         int decrypt_every_8_byte(void) {
     
183.                 for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
     
184.                         if (context_start + pos_in_byte >= instrlen)
     
185.                                 return 1;
     
186.                         decrypted[pos_in_byte] ^= crypt_buff[pos_in_byte];
     
187.                 }
     
188.                 qq_decipher((unsigned long *) decrypted, (unsigned long *) key, (unsigned long *) decrypted);
     
189. 
     
190.                 context_start += 8;
     
191.                 crypt_buff += 8;
     
192.                 pos_in_byte = 0;
     
193.                 return 1;
     
194.         }                        // decrypt_every_8_byte
     
195. 
     
196.         // at least 16 bytes and %8 == 0
     
197.         if ((instrlen % 8) || (instrlen < 16))
     
198.                 return 0;
     
199.         // get information from header
     
200. 
     
201.         [color=red]qq_decipher((unsigned long *) instr, (unsigned long *) key, (unsigned long *) decrypted);
     
202. [/color]      
     
203.       
     
204.         pos_in_byte = decrypted[0] & 0x7;
     
205.        
     
206.         count = instrlen - pos_in_byte - 10;        // this is the plaintext length
     
207.         // return if outstr buffer is not large enought or error plaintext length
     
208. 
     
209.         if (*outstrlen_ptr < count || count < 0)
     
210.                 return 0;
     
211. 
     
212.         memset(m, 0, 8);
     
213.         crypt_buff_pre_8 = m;
     
214.         *outstrlen_ptr = count;        // everything is ok! set return string length
     
215. 
     
216.         crypt_buff = instr + 8;        // address of real data start
     
217.         context_start = 8;        // context is at the second 8 byte
     
218.         pos_in_byte++;                // start of paddng stuff
     
219. 
     
220.         padding = 1;                // at least one in header
     
221.         while (padding <= 2) {        // there are 2 byte padding stuff in header
     
222.                 if (pos_in_byte < 8) {        // bypass the padding stuff, none sense data
     
223.                         pos_in_byte++;
     
224.                         padding++;
     
225.                 }
     
226.                 if (pos_in_byte == 8) {
     
227.                         crypt_buff_pre_8 = instr;
     
228.                         if (!decrypt_every_8_byte())
     
229.                                 return 0;
     
230.                 }
     
231.         }                        // while
     
232. 
     
233.         outp = outstr;
     
234.         while (count != 0) {
     
235.                 if (pos_in_byte < 8) {
     
236.                         *outp = crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte];
     
237.                         outp++;
     
238.                         count--;
     
239.                         pos_in_byte++;
     
240.                 }
     
241.                 if (pos_in_byte == 8) {
     
242.                         crypt_buff_pre_8 = crypt_buff - 8;
     
243.                         if (!decrypt_every_8_byte())
     
244.                                 return 0;
     
245.                 }
     
246.         }                        // while
     
247. 
     
248.         for (padding = 1; padding < 8; padding++) {
     
249.                 if (pos_in_byte < 8) {
     
250.                         if (crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte])
     
251.                                 return 0;
     
252.                         pos_in_byte++;
     
253.                 }
     
254.                 if (pos_in_byte == 8) {
     
255.                         crypt_buff_pre_8 = crypt_buff;
     
256.                         if (!decrypt_every_8_byte())
     
257.                                 return 0;
     
258.                 }
     
259.         }                        // for
     
260.         return 1;
     
261. }                                // qq_decrypt
     
262. 
     

复制代码

gdb调试发现当调用qq_decipher函数返回时修改了outstrlen_ptr的地址，应该说outstrlen_ptr是上层函数的入参，是保存在栈中的，程序中也没有修改该地址的地方,不知那里修改了该地址？
还请高手指教

使用平台:FreeBSD 6.1 AMD64

[ 本帖最后由 free_ever 于 2007-3-25 20:32 编辑 ]

雨丝风片

实在没功夫去看这么一长串的代码，你可以仔细检查有无栈越界访问的可能，并在必要时设置watchpoint来跟踪对变量的修改。

snow888

粗略看了一下程序,好像调用 qq_decipher函数返回时并没有修改outstrlen_ptr的地址,不过在整个程序中确实修改了.看这个地方:

1. 
   
2.        *outstrlen_ptr = count;        // everything is ok! set return string length
   

复制代码

free_ever

*outstrlen_ptr = count;只是修改outstrlen_ptr所指向的地址的值，并不会修改outstrlen_ptr的本身的值。

使用watch发现：

  调用qq_decrypt函数
    时outstrlen_ptr=0x7fffffffe31c
  从qq_decipher函数返回时outstrlen_ptr的值发生了变化.

Old value = (int *) 0x7fffffffe31c
New value = (int *) 0xc0ca0318
qq_decipher (v=0x7fffffffe720, k=0x7fffffffe740, w=0x7fffffffe2d0) at crypt.c:84


查询qq_decrypt函数中的变量decrypted的地址是

(gdb) p &decrypted
$27 = (unsigned char (*)[8]) 0x7fffffffe2d0


函数qq_decipher返回后outstrlen_ptr的值被修改了，也就是说栈被越界修改，导致outstrlen_ptr指向不可访问的地址。怎么会遇上这种鸟事。我就很迷茫.

[ 本帖最后由 free_ever 于 2007-4-8 21:30 编辑 ]