【算法】加密解密算法

幻夜星云

1. #include <string.h>
   
2. /*
   
3. 
   
4. 调用方法：        对String参数传递待加密/解密数据，对Key参数传递密钥数据。无返回值。函数返回后String参数对应数据即为加密/解密结果。
   
5. 
   
6. 警告：                不得对String参数传递const char*变量，否则造成致命错误。
   
7. 
   
8. */
   
9. void StrEncrypt(char* String, const char* Key)
   
10. {
    
11.         int Length_A = strlen(String);
    
12.         int Length_B = strlen(Key);
    
13.         int Count_A;
    
14.         int Count_B = 0;
    
15.         for(Count_A = 1; Count_A <= Length_A; Count_A++)
    
16.         {
    
17.                 Count_B++;
    
18.                 switch(*(Key - 1 + Count_B) % 4)
    
19.                 {
    
20.                 case 0:
    
21.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key - 1 + Count_B);
    
22.                         break;
    
23.                 case 1:
    
24.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key + Length_B - Count_B);
    
25.                         break;
    
26.                 case 2:
    
27.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key - 1 + Count_B);
    
28.                         break;
    
29.                 case 3:
    
30.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key + Length_B - Count_B);
    
31.                         break;
    
32.                 }
    
33.                 if(Count_B == Length_B)
    
34.                 {
    
35.                         Count_B = 0;
    
36.                 }
    
37.         }
    
38.         Count_B = 0;
    
39.         for(Count_A = 1; Count_A <= Length_A; Count_A++)
    
40.         {
    
41.                 Count_B++;
    
42.                 switch(*(Key + Length_B - Count_B) % 8)
    
43.                 {
    
44.                 case 0:
    
45.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) ^ (~*(Key - 1 + Count_B));
    
46.                         break;
    
47.                 case 1:
    
48.                         *(String - 1 + Count_A) = (~*(String - 1 + Count_A)) ^ *(Key - 1 + Count_B);
    
49.                         break;
    
50.                 case 2:
    
51.                         *(String - 1 + Count_A) = ~( (~*(String - 1 + Count_A)) ^ (~*(Key - 1 + Count_B)) );
    
52.                         break;
    
53.                 case 3:
    
54.                         *(String - 1 + Count_A) = ~( *(String - 1 + Count_A) ^ *(Key - 1 + Count_B) );
    
55.                         break;
    
56.                 case 4:
    
57.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) ^ *(Key - 1 + Count_B);
    
58.                         break;
    
59.                 case 5:
    
60.                         *(String - 1 + Count_A) = (~*(String - 1 + Count_A)) ^ (~*(Key - 1 + Count_B));
    
61.                         break;
    
62.                 case 6:
    
63.                         *(String - 1 + Count_A) = ~( (~*(String - 1 + Count_A)) ^ *(Key - 1 + Count_B) );
    
64.                         break;
    
65.                 case 7:
    
66.                         *(String - 1 + Count_A) = ~( *(String - 1 + Count_A) ^ (~*(Key - 1 + Count_B)) );
    
67.                         break;
    
68.                 }
    
69.                 if(Count_B == Length_B)
    
70.                 {
    
71.                         Count_B = 0;
    
72.                 }
    
73.         }
    
74.         Count_B = 0;
    
75.         for(Count_A = 1; Count_A <= Length_A; Count_A++)
    
76.         {
    
77.                 Count_B++;
    
78.                 switch(*(Key - 1 + Count_B) % 4)
    
79.                 {
    
80.                 case 0:
    
81.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key + Length_B - Count_B);
    
82.                         break;
    
83.                 case 1:
    
84.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key - 1 + Count_B);
    
85.                         break;
    
86.                 case 2:
    
87.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key + Length_B - Count_B);
    
88.                         break;
    
89.                 case 3:
    
90.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key - 1 + Count_B);
    
91.                         break;
    
92.                 }
    
93.                 if(Count_B == Length_B)
    
94.                 {
    
95.                         Count_B = 0;
    
96.                 }
    
97.         }
    
98.         return;
    
99. }
    
100. void StrDecrypt(char* String, const char* Key)
     
101. {
     
102.         int Length_A = strlen(String);
     
103.         int Length_B = strlen(Key);
     
104.         int Count_A;
     
105.         int Count_B = 0;
     
106.         for(Count_A = 1; Count_A <= Length_A; Count_A++)
     
107.         {
     
108.                 Count_B++;
     
109.                 switch(*(Key - 1 + Count_B) % 4)
     
110.                 {
     
111.                 case 0:
     
112.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key + Length_B - Count_B);
     
113.                         break;
     
114.                 case 1:
     
115.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key - 1 + Count_B);
     
116.                         break;
     
117.                 case 2:
     
118.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key + Length_B - Count_B);
     
119.                         break;
     
120.                 case 3:
     
121.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key - 1 + Count_B);
     
122.                         break;
     
123.                 }
     
124.                 if(Count_B == Length_B)
     
125.                 {
     
126.                         Count_B = 0;
     
127.                 }
     
128.         }
     
129.         Count_B = 0;
     
130.         for(Count_A = 1; Count_A <= Length_A; Count_A++)
     
131.         {
     
132.                 Count_B++;
     
133.                 switch(*(Key + Length_B - Count_B) % 8)
     
134.                 {
     
135.                 case 0:
     
136.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) ^ (~*(Key - 1 + Count_B));
     
137.                         break;
     
138.                 case 1:
     
139.                         *(String - 1 + Count_A) = ~( *(String - 1 + Count_A) ^ *(Key - 1 + Count_B) );
     
140.                         break;
     
141.                 case 2:
     
142.                         *(String - 1 + Count_A) = ~( (~*(String - 1 + Count_A)) ^ (~*(Key - 1 + Count_B)) );
     
143.                         break;
     
144.                 case 3:
     
145.                         *(String - 1 + Count_A) = (~*(String - 1 + Count_A)) ^ *(Key - 1 + Count_B);
     
146.                         break;
     
147.                 case 4:
     
148.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) ^ *(Key - 1 + Count_B);
     
149.                         break;
     
150.                 case 5:
     
151.                         *(String - 1 + Count_A) = ~( *(String - 1 + Count_A) ^ (~*(Key - 1 + Count_B)) );
     
152.                         break;
     
153.                 case 6:
     
154.                         *(String - 1 + Count_A) = ~( (~*(String - 1 + Count_A)) ^ *(Key - 1 + Count_B) );
     
155.                         break;
     
156.                 case 7:
     
157.                         *(String - 1 + Count_A) = (~*(String - 1 + Count_A)) ^ (~*(Key - 1 + Count_B));
     
158.                         break;
     
159.                 }
     
160.                 if(Count_B == Length_B)
     
161.                 {
     
162.                         Count_B = 0;
     
163.                 }
     
164.         }
     
165.         Count_B = 0;
     
166.         for(Count_A = 1; Count_A <= Length_A; Count_A++)
     
167.         {
     
168.                 Count_B++;
     
169.                 switch(*(Key - 1 + Count_B) % 4)
     
170.                 {
     
171.                 case 0:
     
172.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key - 1 + Count_B);
     
173.                         break;
     
174.                 case 1:
     
175.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key + Length_B - Count_B);
     
176.                         break;
     
177.                 case 2:
     
178.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) - *(Key - 1 + Count_B);
     
179.                         break;
     
180.                 case 3:
     
181.                         *(String - 1 + Count_A) = *(String - 1 + Count_A) + *(Key + Length_B - Count_B);
     
182.                         break;
     
183.                 }
     
184.                 if(Count_B == Length_B)
     
185.                 {
     
186.                         Count_B = 0;
     
187.                 }
     
188.         }
     
189.         return;
     
190. }

复制代码

CElib.rar (4.96 KB, 下载次数: 3)

2014-1-29 21:55 上传

点击文件名下载附件

原创的加密解密算法，亲测可用，强度高，不易破解。

POPOPO西瓜

好厉害的大神。。。

侠

不明觉厉

上邪

...加密我比较喜欢单向的。自己不想让别人知道的也不能让自己再看到。。。

ssfs333asas

有没有简单的算法啊

j815551469

好厉害的大神。。。

ssclo168

11111111111111111111