字符串的加密与解密的源代码

蓝色键盘

代码一

1. 
   
2. #include "windows.h"
   
3. #include "stdio.h"
   
4. #include "zlib.h"
   
5. 
   
6. #define ZIPCPZ_BUFFER 32768
   
7. static char tmp_in[ZIPCPZ_BUFFER];
   
8. static char tmp_out[ZIPCPZ_BUFFER];
   
9. static z_stream stream;
   
10. 
    
11. static int in_length=0;
    
12. static int out_length=0;
    
13. 
    
14. int ZIPCpzInit(int Level=Z_DEFAULT_COMPRESSION)
    
15. {
    
16. int err;
    
17. stream.next_in = (Bytef*)tmp_in;
    
18. stream.avail_in = (uInt)in_length;
    
19. 
    
20. stream.next_out = (Bytef*)tmp_out;
    
21. stream.avail_out = ZIPCPZ_BUFFER;
    
22. 
    
23. stream.zalloc = (alloc_func)0;
    
24. stream.zfree = (free_func)0;
    
25. stream.opaque = (voidpf)0;
    
26. 
    
27. err = deflateInit(&stream, Level);
    
28. 
    
29. if (err != Z_OK) return err;
    
30. 
    
31. return Z_OK;
    
32. }
    
33. 
    
34. int ZIPCpz (LPCSTR src,DWORD src_length,FILE *fp,int bFlush=0)
    
35. {
    
36. int err;
    
37. DWORD offset=0;
    
38. 
    
39. if( src_length >; 0 ) //make sure input stream is available
    
40. while(1)
    
41. {
    
42. int rLen,wLen;
    
43. 
    
44. if( src_length + in_length >;= ZIPCPZ_BUFFER )
    
45. {
    
46. //buffer a block of input stream to tmp_in if it's big enough
    
47. rLen=ZIPCPZ_BUFFER-in_length;
    
48. 
    
49. memcpy(&tmp_in[in_length],src+offset,rLen);
    
50. src_length -= rLen;
    
51. in_length += rLen;
    
52. offset+=rLen;
    
53. 
    
54. { //zip tmp_in
    
55. stream.next_in = (Bytef*)tmp_in;
    
56. stream.avail_in = (uInt)in_length;
    
57. 
    
58. stream.next_out = (Bytef*)(tmp_out+out_length);
    
59. stream.avail_out = ZIPCPZ_BUFFER-out_length;
    
60. 
    
61. while(1)
    
62. {
    
63. wLen=ZIPCPZ_BUFFER-out_length;
    
64. 
    
65. err = deflate(&stream, Z_NO_FLUSH);
    
66. wLen -= stream.avail_out;
    
67. 
    
68. if(err ==Z_OK)
    
69. {
    
70. if( (stream.avail_out!=0) ) //cpz finished
    
71. {
    
72. out_length+=wLen;
    
73. break;
    
74. }
    
75. else
    
76. { // out buffer full
    
77. fwrite(tmp_out,1,ZIPCPZ_BUFFER,fp);
    
78. out_length=0;
    
79. stream.next_out = (Bytef*)tmp_out;
    
80. stream.avail_out = ZIPCPZ_BUFFER;
    
81. }
    
82. }
    
83. else
    
84. {
    
85. //error ~~~~~~~~~~~
    
86. printf("Error!\n");
    
87. printf("Error no %d\n",err);
    
88. 
    
89. }
    
90. }
    
91. 
    
92. in_length=0;
    
93. }
    
94. }
    
95. else
    
96. {
    
97. // buffer whole input stream to tmp_in if it's not big enough
    
98. // then wait for next call to fill tmp_in
    
99. memcpy(&tmp_in[in_length],src+offset,src_length);
    
100. in_length+=src_length;
     
101. break;
     
102. }
     
103. }//write ok;
     
104. 
     
105. if(bFlush)
     
106. {
     
107. if(in_length>;0)
     
108. {
     
109. stream.next_in = (Bytef*)tmp_in;
     
110. stream.avail_in = (uInt)in_length;
     
111. 
     
112. stream.next_out = (Bytef*)(tmp_out+out_length);
     
113. stream.avail_out = ZIPCPZ_BUFFER-out_length;
     
114. 
     
115. while(1)
     
116. {
     
117. DWORD wLen=ZIPCPZ_BUFFER-out_length;
     
118. 
     
119. err = deflate(&stream, Z_FINISH);
     
120. wLen -= stream.avail_out;
     
121. 
     
122. if(err ==Z_STREAM_END)
     
123. {
     
124. if( (stream.avail_out!=0) ) //cpz finished
     
125. {
     
126. out_length+=wLen;
     
127. break;
     
128. }
     
129. }
     
130. else
     
131. {
     
132. if( err== Z_OK)
     
133. {
     
134. // out buffer full
     
135. fwrite(tmp_out,1,ZIPCPZ_BUFFER,fp);
     
136. out_length=0;
     
137. stream.next_out = (Bytef*)tmp_out;
     
138. stream.avail_out = ZIPCPZ_BUFFER;
     
139. }
     
140. else
     
141. {
     
142. //error ~~~~~~~~~~~
     
143. printf("Error while end z file!\n");
     
144. printf("Error no %d\n",err);
     
145. break;
     
146. }
     
147. }
     
148. }
     
149. }
     
150. 
     
151. fwrite(tmp_out,1,out_length,fp);
     
152. in_length=0;
     
153. out_length=0;
     
154. }
     
155. 
     
156. return Z_OK;
     
157. }
     
158. 
     
159. int ZIPCpzFinal()
     
160. {
     
161. int err;
     
162. err = deflateEnd(&stream);
     
163. return err;
     
164. 
     
165. }
     
166. 
     
167. 
     
168. int ZEXPORT uncompress (
     
169. Bytef *dest,
     
170. uLongf *destLen,
     
171. const Bytef *source,
     
172. uLong sourceLen)
     
173. {
     
174. z_stream stream;
     
175. int err;
     
176. 
     
177. stream.next_in = (Bytef*)source;
     
178. stream.avail_in = (uInt)sourceLen;
     
179. 
     
180. stream.next_out = dest;
     
181. stream.avail_out = (uInt)*destLen;
     
182. if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
     
183. 
     
184. stream.zalloc = (alloc_func)0;
     
185. stream.zfree = (free_func)0;
     
186. 
     
187. err = inflateInit(&stream);
     
188. if (err != Z_OK) return err;
     
189. 
     
190. err = inflate(&stream, Z_FINISH);
     
191. if (err != Z_STREAM_END) {
     
192. inflateEnd(&stream);
     
193. return err == Z_OK ? Z_BUF_ERROR : err;
     
194. }
     
195. *destLen = stream.total_out;
     
196. 
     
197. err = inflateEnd(&stream);
     
198. return err;
     
199. }
     
200. 
     
201. 
     
202. void main()
     
203. {
     
204. 
     
205. printf("Zlib Version %s !\n",zlibVersion());
     
206. /*char *pByte=new char[1024*1024];
     
207. for(int i=0;i<1024*1024;i++)
     
208. {
     
209. pByte[i]=i;
     
210. }
     
211. ZIPCpz(pByte,1024*1024,"b.z");*/
     
212. long length;
     
213. FILE* fp=fopen("a.bin","rb");
     
214. fseek(fp,0,SEEK_END);
     
215. length=ftell(fp);
     
216. fseek(fp,0,SEEK_SET);
     
217. 
     
218. char *pByte=new char[length];
     
219. FILE* fp1=fopen("b.z","wb");
     
220. 
     
221. fread(pByte,1,length,fp);
     
222. ZIPCpzInit();
     
223. 
     
224. ZIPCpz(pByte,length>;>;1,fp1);
     
225. ZIPCpz(pByte+(length>;>;1),length-(length>;>;1),fp1);
     
226. 
     
227. ZIPCpz(0,0,fp1,1);
     
228. fclose(fp1);
     
229. 
     
230. ZIPCpzFinal();
     
231. 
     
232. fclose(fp);
     
233. 
     
234. printf("Add ok!\n");
     
235. 
     
236. delete pByte;
     
237. 
     
238. 
     
239. FILE* fp2=fopen("b.z","rb");
     
240. 
     
241. fseek(fp2,0,SEEK_END);
     
242. length=ftell(fp2);
     
243. fseek(fp2,0,SEEK_SET);
     
244. 
     
245. pByte=new char[length];
     
246. 
     
247. fread(pByte,length,1,fp2);
     
248. fclose(fp2);
     
249. 
     
250. fp2=fopen("c.bin","wb");
     
251. 
     
252. LPSTR pByte1=new char[1024*1024*25];
     
253. DWORD length1=1024*1024*25;
     
254. uncompress((Bytef*)pByte1,&length1,(Bytef*)pByte,length);
     
255. fwrite(pByte1,1,length1,fp2);
     
256. fclose(fp2);
     
257. 
     
258. }
     

复制代码

蓝色键盘

代码二

1. 
   
2. RLE算法
   
3. CRLECompressioin rle;
   
4. char src[] = "11122233333336666666666666666666666666666666666666666666";
   
5. char dest[100];
   
6. char dest1[100];
   
7. memset(dest, 0, 100);
   
8. memset(dest1, 0, 100);
   
9. int len = strlen(src);
   
10. int rc = rle.Compress((unsigned char*)src, len, (unsigned char*)dest);
    
11. int rc1 = rle.Decompress((unsigned char*)dest, rc, (unsigned char*)dest1);
    
12. /////////////////////////////////////////////////////////////////////////////
    
13. 
    
14. class CRLECompressioin  
    
15. {
    
16. public:
    
17. CRLECompressioin();
    
18. virtual ~CRLECompressioin();
    
19. 
    
20. int Compress(unsigned char* src, int len, unsigned char* dest);
    
21. int Decompress(unsigned char* src, int len, unsigned char* dest);
    
22. };
    
23. 
    
24. // RLECompressioin.cpp: implementation of the CRLECompressioin class.
    
25. //
    
26. //////////////////////////////////////////////////////////////////////
    
27. 
    
28. #include "Compress.h"
    
29. 
    
30. const unsigned char DELIM = (char)0xFF;
    
31. const unsigned char MAX  = (char)0xFE;
    
32. 
    
33. //////////////////////////////////////////////////////////////////////
    
34. // Construction/Destruction
    
35. //////////////////////////////////////////////////////////////////////
    
36. 
    
37. CRLECompressioin::CRLECompressioin()
    
38. {
    
39. 
    
40. }
    
41. 
    
42. CRLECompressioin::~CRLECompressioin()
    
43. {
    
44. 
    
45. }
    
46. 
    
47. int CRLECompressioin:: Compress(unsigned char* src, int len, unsigned char* dest)
    
48. {
    
49. unsigned char current_char;
    
50. int  char_count = 0;
    
51. 
    
52. int iCompressedLen = 0;
    
53. 
    
54. for(int iLoop = 0; iLoop < len; iLoop++)
    
55. {
    
56. if((src[iLoop] == src[iLoop + 1]) && (src[iLoop] == src[iLoop + 2]))
    
57. {
    
58. current_char = src[iLoop];
    
59. char_count = 0x00;
    
60. bool hit_end = false;
    
61. for(int iLoop2 = 0; iLoop2 < 0xFE; iLoop2++)
    
62. {
    
63. if(src[iLoop + iLoop2] == current_char)
    
64. {
    
65. char_count++;
    
66. }
    
67. else
    
68. {
    
69. iLoop += (char_count - 1);
    
70. dest[iCompressedLen++] = DELIM;
    
71. dest[iCompressedLen++] = char_count;
    
72. dest[iCompressedLen++] = current_char;
    
73. iLoop2 = 0xFE;
    
74. hit_end = true;
    
75. }
    
76. }
    
77. if(!hit_end)
    
78. {
    
79. iLoop += 0xFD;
    
80. dest[iCompressedLen++] = DELIM;
    
81. dest[iCompressedLen++] = MAX;
    
82. dest[iCompressedLen++] = current_char;
    
83. }
    
84. }
    
85. else
    
86. {
    
87. if(src[iLoop] == DELIM)
    
88. {
    
89. dest[iCompressedLen++] = DELIM;
    
90. dest[iCompressedLen++] = DELIM;
    
91. }
    
92. else
    
93. {
    
94. dest[iCompressedLen++] = src[iLoop];
    
95. }
    
96. }
    
97. }
    
98. 
    
99. return iCompressedLen;
    
100. 
     
101. }
     
102. 
     
103. int CRLECompressioin::Decompress(unsigned char* src, int len, unsigned char* dest)
     
104. {
     
105. 
     
106. int iDecompressedLen = 0;
     
107. 
     
108. for(int iLoop = 0; iLoop < len; iLoop++)
     
109. {
     
110. if(src[iLoop] == DELIM)
     
111. {
     
112. if(src[iLoop + 1] == DELIM)
     
113. {
     
114. dest[iDecompressedLen++] = src[iLoop];
     
115. iLoop++;
     
116. }
     
117. else
     
118. {
     
119. int iBufSize = (int)src[iLoop + 1];
     
120. for(int iLoop2 = 0; iLoop2 < iBufSize; iLoop2++)
     
121. {
     
122. dest[iDecompressedLen++] = src[iLoop+2];
     
123. }
     
124. iLoop += 2;
     
125. }
     
126. }
     
127. else
     
128. {
     
129. dest[iDecompressedLen++] = src[iLoop];
     
130. }
     
131. }
     
132. 
     
133. return iDecompressedLen;
     
134. }
     

复制代码

蓝色键盘

代码三

1. 
   
2. 这个是LZO的压缩算法，应该很快。
   
3. 
   
4. // LZOCompress.cpp: implementation of the CLZOCompress class.
   
5. //
   
6. //////////////////////////////////////////////////////////////////////
   
7. 
   
8. #include "stdafx.h"
   
9. #include "LZOCompress.h"
   
10. 
    
11. #ifdef _DEBUG
    
12. #undef THIS_FILE
    
13. static char THIS_FILE[]=__FILE__;
    
14. #define new DEBUG_NEW
    
15. #endif
    
16. 
    
17. //////////////////////////////////////////////////////////////////////
    
18. // Construction/Destruction
    
19. //////////////////////////////////////////////////////////////////////
    
20. 
    
21. CLZOCompress::CLZOCompress()
    
22. {
    
23. 
    
24. }
    
25. 
    
26. CLZOCompress::~CLZOCompress()
    
27. {
    
28. 
    
29. }
    
30. 
    
31. unsigned CLZOCompress::_do_compress (byte *in,
    
32. unsigned in_len,
    
33. byte *out,
    
34. unsigned *out_len)
    
35. {
    
36. static long wrkmem [16384L];
    
37.     register byte *ip;
    
38.     byte *op;
    
39. byte *in_end = in + in_len;
    
40.     byte *ip_end = in + in_len - 13;
    
41.     byte *ii;
    
42.     byte **dict = (byte **)wrkmem;
    
43.     op = out;
    
44. ip = in;
    
45. ii = ip;
    
46.     ip += 4;
    
47.     for(;;)
    
48. {
    
49. register byte *m_pos;
    
50. unsigned m_off;
    
51. unsigned m_len;
    
52. unsigned dindex;
    
53. dindex = ((0x21*(((((((unsigned)(ip[3])<<6)^ip[2])<<5)^ip[1])<<5)^ip[0]))>;>;5) & 0x3fff;
    
54. m_pos = dict [dindex];
    
55. if(((unsigned)m_pos < (unsigned)in) ||
    
56. (m_off = (unsigned)((unsigned)ip-(unsigned)m_pos) ) <= 0 ||
    
57. m_off >; 0xbfff)
    
58. goto literal;
    
59. if(m_off <= 0x0800 || m_pos[3] == ip[3])
    
60. goto try_match;
    
61. dindex = (dindex & 0x7ff ) ^ 0x201f;
    
62. m_pos = dict[dindex];
    
63. if((unsigned)(m_pos) < (unsigned)(in) ||
    
64. (m_off = (unsigned)( (int)((unsigned)ip-(unsigned)m_pos))) <= 0 ||
    
65. m_off >; 0xbfff)
    
66. goto literal;
    
67. if (m_off <= 0x0800 || m_pos[3] == ip[3])
    
68. goto try_match;
    
69. goto literal;
    
70. try_match:
    
71. if(*(unsigned short*)m_pos == *(unsigned short*)ip && m_pos[2]==ip[2])
    
72. goto match;
    
73. literal:
    
74. dict[dindex] = ip;
    
75. ++ip;
    
76. if (ip >;= ip_end)
    
77. break;
    
78. continue;
    
79. match:
    
80. dict[dindex] = ip;
    
81. if(ip - ii >; 0)
    
82. {
    
83. register unsigned t = ip - ii;
    
84. 
    
85. if (t <= 3)
    
86. op[-2] |= (byte)t;
    
87. else if(t <= 18)
    
88. *op++ = (byte)(t - 3);
    
89. else
    
90. {
    
91. register unsigned tt = t - 18;
    
92. *op++ = 0;
    
93. while(tt >; 255)
    
94. {
    
95. tt -= 255;
    
96. *op++ = 0;
    
97. }
    
98. *op++ = (byte)tt;
    
99. }
    
100. do *op++ = *ii++; while (--t >; 0);
     
101. }
     
102. ip += 3;
     
103. if(m_pos[3] != *ip++ || m_pos[4] != *ip++ || m_pos[5] != *ip++ ||
     
104. m_pos[6] != *ip++ || m_pos[7] != *ip++ || m_pos[8] != *ip++ )
     
105. {
     
106. --ip;
     
107. m_len = ip - ii;
     
108. 
     
109. if(m_off <= 0x0800 )
     
110. {
     
111. --m_off;
     
112. *op++ = (byte)(((m_len - 1) << 5) | ((m_off & 7) << 2));
     
113. *op++ = (byte)(m_off >;>; 3);
     
114. }
     
115. else
     
116. if (m_off <= 0x4000 )
     
117. {
     
118. -- m_off;
     
119. *op++ = (byte)(32 | (m_len - 2));
     
120. goto m3_m4_offset;
     
121. }
     
122. else
     
123. {
     
124. m_off -= 0x4000;
     
125. *op++ = (byte)(16 | ((m_off & 0x4000) >;>; 11) | (m_len - 2));
     
126. goto m3_m4_offset;
     
127. }
     
128. }
     
129. else
     
130. {
     
131. {
     
132. byte *end = in_end;
     
133. byte *m = m_pos + 9;
     
134. while (ip < end && *m == *ip)
     
135. m++, ip++;
     
136. m_len = (ip - ii);
     
137. }
     
138. 
     
139. if(m_off <= 0x4000)
     
140. {
     
141. --m_off;
     
142. if (m_len <= 33)
     
143. *op++ = (byte)(32 | (m_len - 2));
     
144. else
     
145. {
     
146. m_len -= 33;
     
147. *op++=32;
     
148. goto m3_m4_len;
     
149. }
     
150. }
     
151. else
     
152. {
     
153. m_off -= 0x4000;
     
154. if(m_len <= 9)
     
155. *op++ = (byte)(16|((m_off & 0x4000) >;>; 11) | (m_len - 2));
     
156. else
     
157. {
     
158. m_len -= 9;
     
159. *op++ = (byte)(16 | ((m_off & 0x4000) >;>; 11));
     
160. m3_m4_len:
     
161. while (m_len >; 255)
     
162. {
     
163. m_len -= 255;
     
164. *op++ = 0;
     
165. }
     
166. *op++ = (byte)m_len;
     
167. }
     
168. }
     
169. m3_m4_offset:
     
170. *op++ = (byte)((m_off & 63) << 2);
     
171. *op++ = (byte)(m_off >;>; 6);
     
172. }
     
173. ii = ip;
     
174. if (ip >;= ip_end)
     
175. break;
     
176.     }
     
177.     *out_len = op - out;
     
178.     return (unsigned) (in_end - ii);
     
179. }
     
180. 
     
181. int _stdcall CLZOCompress::compress(void *in, unsigned in_len,
     
182.   void *out)
     
183. {
     
184.     byte *op = (unsigned char*)out;
     
185.     unsigned t,out_len;
     
186.     if (in_len <= 13)
     
187. t = in_len;
     
188.     else
     
189. {
     
190. t = CLZOCompress::_do_compress ((unsigned char*)in,in_len,op,&out_len);
     
191. op += out_len;
     
192.     }
     
193.     if (t >; 0)
     
194. {
     
195. byte *ii = (byte*)in + in_len - t;
     
196. if (op == (byte*)out && t <= 238)
     
197. *op++ = (byte) ( 17 + t );
     
198. else
     
199. if (t <= 3)
     
200. op[-2] |= (byte)t ;
     
201. else
     
202. if (t <= 18)
     
203. *op++ = (byte)(t-3);
     
204. else
     
205. {
     
206. unsigned tt = t - 18;
     
207. *op++ = 0;
     
208. while (tt >; 255)
     
209. {
     
210. tt -= 255;
     
211. *op++ = 0;
     
212. }
     
213. *op++ = (byte)tt;
     
214. }
     
215. do *op++ = *ii++; while (--t >; 0);
     
216.     }
     
217.     *op++ = 17;
     
218.     *op++ = 0;
     
219.     *op++ = 0;
     
220.     return (op - (byte*)out);
     
221. }
     
222. 
     
223. int _stdcall CLZOCompress::decompress (void *in, unsigned in_len,
     
224. void *out)
     
225. {
     
226.     register byte *op;
     
227.     register byte *ip;
     
228.     register unsigned t;
     
229.     register byte *m_pos;
     
230.     byte *ip_end = (byte*)in + in_len;
     
231.     op = (unsigned char*)out;
     
232.     ip = (unsigned char*)in;
     
233.     if(*ip >; 17)
     
234. {
     
235. t = *ip++ - 17;
     
236. if (t < 4)
     
237. goto match_next;
     
238. do *op++ = *ip++; while (--t >; 0);
     
239. goto first_literal_run;
     
240.     }
     
241.     for(;;)
     
242. {
     
243. t = *ip++;
     
244. if (t >;= 16) goto match;
     
245. if (t == 0)
     
246. {
     
247. while (*ip == 0)
     
248. {
     
249. t += 255;
     
250. ip++;
     
251. }
     
252. t += 15 + *ip++;
     
253. }
     
254. * (unsigned *) op = * ( unsigned *) ip;
     
255. op += 4; ip += 4;
     
256. if (--t >; 0)
     
257. {
     
258. if (t >;= 4)
     
259. {
     
260. do
     
261. {
     
262. * (unsigned * ) op = * ( unsigned * ) ip;
     
263. op += 4; ip += 4; t -= 4;
     
264. } while (t >;= 4);
     
265. if (t >; 0) do *op++ = *ip++; while (--t >; 0);
     
266. }
     
267. else
     
268. do *op++ = *ip++; while (--t >; 0);
     
269. }
     
270. first_literal_run:
     
271. t = *ip++;
     
272. if (t >;= 16)
     
273. goto match;
     
274. m_pos = op - 0x0801;
     
275. m_pos -= t >;>; 2;
     
276. m_pos -= *ip++ << 2;
     
277. *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
     
278. goto match_done;
     
279. for(;;)
     
280. {
     
281. match:
     
282. if (t >;= 64)
     
283. {
     
284. m_pos = op - 1;
     
285. m_pos -= (t >;>; 2) & 7;
     
286. m_pos -= *ip++ << 3;
     
287. t = (t >;>; 5) - 1;
     
288. goto copy_match;
     
289. }
     
290. else
     
291. if (t >;= 32)
     
292. {
     
293. t &= 31;
     
294. if (t == 0)
     
295. {
     
296. while (*ip == 0)
     
297. {
     
298. t += 255;
     
299. ip++;
     
300. }
     
301. t += 31 + *ip++;
     
302. }
     
303. m_pos = op - 1;
     
304. m_pos -= (* ( unsigned short * ) ip) >;>; 2;
     
305. ip += 2;
     
306. }
     
307. else
     
308. if (t >;= 16)
     
309. {
     
310. m_pos = op;
     
311. m_pos -= (t & 8) << 11;
     
312. t &= 7;
     
313. if (t == 0)
     
314. {
     
315. while (*ip == 0)
     
316. {
     
317. t += 255;
     
318. ip++;
     
319. }
     
320. t += 7 + *ip++;
     
321. }
     
322. m_pos -= (* ( unsigned short *) ip) >;>; 2;
     
323. ip += 2;
     
324. if (m_pos == op)
     
325. goto eof_found;
     
326. m_pos -= 0x4000;
     
327. }
     
328. else
     
329. {
     
330. m_pos = op - 1;
     
331. m_pos -= t >;>; 2;
     
332. m_pos -= *ip++ << 2;
     
333. *op++ = *m_pos++; *op++ = *m_pos;
     
334. goto match_done;
     
335. }
     
336. if (t >;= 6 && (op - m_pos) >;= 4)
     
337. {
     
338. * (unsigned *) op = * ( unsigned *) m_pos;
     
339. op += 4; m_pos += 4; t -= 2;
     
340. do
     
341. {
     
342. * (unsigned *) op = * ( unsigned *) m_pos;
     
343. op += 4; m_pos += 4; t -= 4;
     
344. }while (t >;= 4);
     
345. if (t >; 0)
     
346. do *op++ = *m_pos++; while (--t >; 0);
     
347. }
     
348. else
     
349. {
     
350. copy_match:
     
351. *op++ = *m_pos++; *op++ = *m_pos++;
     
352. do *op++ = *m_pos++; while (--t >; 0);
     
353. }
     
354. match_done:
     
355. t = ip[-2] & 3;
     
356. if (t == 0) break;
     
357. match_next:
     
358. do *op++ = *ip++; while (--t >; 0);
     
359. t = *ip++;
     
360. }
     
361.   }
     
362. eof_found:
     
363.   if (ip != ip_end) return -1;
     
364.   return (op - (byte*)out);
     
365. }
     
366. 
     

复制代码

蓝色键盘

穷举密码算法

1. 
   
2. void createpassword()
   
3. {
   
4. #define passwordmax 8 //将生成密码的最大长度
   
5. 
   
6. char a[]="0123456789abcdefghijklmnopqrstuvwxyz"; //可能的字符
   
7. long ndictcount=sizeof(a); //获得密码词典长度
   
8. char cpass[passwordmax+2]; //将生成的密码
   
9. long nminl=1,nmaxl=3; //本例中密码长度从1-3
   
10. long array[passwordmax]; //密码词典下标
    
11. 
    
12. assert(nminl<=nmaxl && nmaxl<=passwordmax);//容错保证
    
13. long nlength=nminl;
    
14. register long j,i=0;
    
15. bool bnext;
    
16. cstdiofile file;
    
17. file.open("c:\\dict.txt",cfile::modecreate|cfile::modewrite);
    
18. while(nlength<=nmaxl)
    
19. {
    
20. for(i=0;i<passwordmax;i++)
    
21. array[i]=0;
    
22. bnext=true;
    
23. while(bnext)
    
24. {
    
25. for(i=0;i<nlength;i++)
    
26. cpass[i]=a[array[i]];
    
27. cpass[i]='\0';
    
28. file.writestring(cpass);
    
29. file.writestring("\n");
    
30. for(j=nlength-1;j>;=0;j--) //密码指针进位
    
31. {
    
32. array[j]++;
    
33. if(array[j]!=ndictcount-1)break;
    
34. else
    
35. {
    
36. array[j]=0;
    
37. if(j==0)bnext=false;
    
38. }
    
39. }
    
40. 
    
41. }
    
42. nlength++;
    
43. }
    
44. file.close();
    
45. }
    
46. 
    

复制代码

Law

高人!

fanfan

我看Morris的worm程序里有加密的字符串，只是不会用，估计一般也不用吧

jsean

键盘兄，有标准des加密解密算法吗？

无双

精华中有过介绍吧
很久以前的