![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to serpent.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / crypto|
Return to serpent.c CVS log | Up to [truecrypt] / truecrypt / crypto |
1.1 root 1: // Except as noted below copyright in this code is held by Dr B.R. Gladman
2: // but free direct or derivative use is permitted subject to acknowledgement
3: // of its origin and subject to any constraints placed on the use of the
4: // algorithm by its designers (if such constraints may exist, this will be
5: // indicated below).
6: //
7: // Dr. B. R. Gladman ( ). 25th January 2000.
8: //
9: // This is an implementation of Serpent, an encryption algorithm designed
10: // by Anderson, Biham and Knudsen and submitted as a candidate for the
11: // Advanced Encryption Standard programme of the US National Institute of
12: // Standards and Technology.
13: //
14: // The designers of Serpent have not placed any constraints on the use of
15: // this algorithm.
16: //
17: // The S box expressions used below are Copyright (C) 2000 Dag Arne Osvik.
18:
19: /* Support for multithreaded operation added by TrueCrypt Foundation */
20:
21: #include "serpent.h"
22:
23: //static u4byte serpent_l_key[140];
24:
25: #define sb0(r0,r1,r2,r3,r4) \
26: __asm { \
27: __asm xor r3,r0 \
28: __asm mov r4,r1 \
29: __asm and r1,r3 \
30: __asm xor r4,r2 \
31: __asm xor r1,r0 \
32: __asm or r0,r3 \
33: __asm xor r0,r4 \
34: __asm xor r4,r3 \
35: __asm xor r3,r2 \
36: __asm or r2,r1 \
37: __asm xor r2,r4 \
38: __asm not r4 \
39: __asm or r4,r1 \
40: __asm xor r1,r3 \
41: __asm xor r1,r4 \
42: __asm or r3,r0 \
43: __asm xor r1,r3 \
44: __asm xor r4,r3 \
45: }
46:
47: #define ib0(r0,r1,r2,r3,r4) \
48: __asm { \
49: __asm not r2 \
50: __asm mov r4,r1 \
51: __asm or r1,r0 \
52: __asm not r4 \
53: __asm xor r1,r2 \
54: __asm or r2,r4 \
55: __asm xor r1,r3 \
56: __asm xor r0,r4 \
57: __asm xor r2,r0 \
58: __asm and r0,r3 \
59: __asm xor r4,r0 \
60: __asm or r0,r1 \
61: __asm xor r0,r2 \
62: __asm xor r3,r4 \
63: __asm xor r2,r1 \
64: __asm xor r3,r0 \
65: __asm xor r3,r1 \
66: __asm and r2,r3 \
67: __asm xor r4,r2 \
68: }
69:
70: #define sb1(r0,r1,r2,r3,r4) \
71: __asm { \
72: __asm not r0 \
73: __asm not r2 \
74: __asm mov r4,r0 \
75: __asm and r0,r1 \
76: __asm xor r2,r0 \
77: __asm or r0,r3 \
78: __asm xor r3,r2 \
79: __asm xor r1,r0 \
80: __asm xor r0,r4 \
81: __asm or r4,r1 \
82: __asm xor r1,r3 \
83: __asm or r2,r0 \
84: __asm and r2,r4 \
85: __asm xor r0,r1 \
86: __asm and r1,r2 \
87: __asm xor r1,r0 \
88: __asm and r0,r2 \
89: __asm xor r0,r4 \
90: }
91:
92: #define ib1(r0,r1,r2,r3,r4) \
93: __asm { \
94: __asm mov r4,r1 \
95: __asm xor r1,r3 \
96: __asm and r3,r1 \
97: __asm xor r4,r2 \
98: __asm xor r3,r0 \
99: __asm or r0,r1 \
100: __asm xor r2,r3 \
101: __asm xor r0,r4 \
102: __asm or r0,r2 \
103: __asm xor r1,r3 \
104: __asm xor r0,r1 \
105: __asm or r1,r3 \
106: __asm xor r1,r0 \
107: __asm not r4 \
108: __asm xor r4,r1 \
109: __asm or r1,r0 \
110: __asm xor r1,r0 \
111: __asm or r1,r4 \
112: __asm xor r3,r1 \
113: }
114:
115: #define sb2(r0,r1,r2,r3,r4) \
116: __asm { \
117: __asm mov r4,r0 \
118: __asm and r0,r2 \
119: __asm xor r0,r3 \
120: __asm xor r2,r1 \
121: __asm xor r2,r0 \
122: __asm or r3,r4 \
123: __asm xor r3,r1 \
124: __asm xor r4,r2 \
125: __asm mov r1,r3 \
126: __asm or r3,r4 \
127: __asm xor r3,r0 \
128: __asm and r0,r1 \
129: __asm xor r4,r0 \
130: __asm xor r1,r3 \
131: __asm xor r1,r4 \
132: __asm not r4 \
133: }
134:
135: #define ib2(r0,r1,r2,r3,r4) \
136: __asm { \
137: __asm xor r2,r3 \
138: __asm xor r3,r0 \
139: __asm mov r4,r3 \
140: __asm and r3,r2 \
141: __asm xor r3,r1 \
142: __asm or r1,r2 \
143: __asm xor r1,r4 \
144: __asm and r4,r3 \
145: __asm xor r2,r3 \
146: __asm and r4,r0 \
147: __asm xor r4,r2 \
148: __asm and r2,r1 \
149: __asm or r2,r0 \
150: __asm not r3 \
151: __asm xor r2,r3 \
152: __asm xor r0,r3 \
153: __asm and r0,r1 \
154: __asm xor r3,r4 \
155: __asm xor r3,r0 \
156: }
157:
158: #define sb3(r0,r1,r2,r3,r4) \
159: __asm { \
160: __asm mov r4,r0 \
161: __asm or r0,r3 \
162: __asm xor r3,r1 \
163: __asm and r1,r4 \
164: __asm xor r4,r2 \
165: __asm xor r2,r3 \
166: __asm and r3,r0 \
167: __asm or r4,r1 \
168: __asm xor r3,r4 \
169: __asm xor r0,r1 \
170: __asm and r4,r0 \
171: __asm xor r1,r3 \
172: __asm xor r4,r2 \
173: __asm or r1,r0 \
174: __asm xor r1,r2 \
175: __asm xor r0,r3 \
176: __asm mov r2,r1 \
177: __asm or r1,r3 \
178: __asm xor r1,r0 \
179: }
180:
181: #define ib3(r0,r1,r2,r3,r4) \
182: __asm { \
183: __asm mov r4,r2 \
184: __asm xor r2,r1 \
185: __asm and r1,r2 \
186: __asm xor r1,r0 \
187: __asm and r0,r4 \
188: __asm xor r4,r3 \
189: __asm or r3,r1 \
190: __asm xor r3,r2 \
191: __asm xor r0,r4 \
192: __asm xor r2,r0 \
193: __asm or r0,r3 \
194: __asm xor r0,r1 \
195: __asm xor r4,r2 \
196: __asm and r2,r3 \
197: __asm or r1,r3 \
198: __asm xor r1,r2 \
199: __asm xor r4,r0 \
200: __asm xor r2,r4 \
201: }
202:
203: #define sb4(r0,r1,r2,r3,r4) \
204: __asm { \
205: __asm xor r1,r3 \
206: __asm not r3 \
207: __asm xor r2,r3 \
208: __asm xor r3,r0 \
209: __asm mov r4,r1 \
210: __asm and r1,r3 \
211: __asm xor r1,r2 \
212: __asm xor r4,r3 \
213: __asm xor r0,r4 \
214: __asm and r2,r4 \
215: __asm xor r2,r0 \
216: __asm and r0,r1 \
217: __asm xor r3,r0 \
218: __asm or r4,r1 \
219: __asm xor r4,r0 \
220: __asm or r0,r3 \
221: __asm xor r0,r2 \
222: __asm and r2,r3 \
223: __asm not r0 \
224: __asm xor r4,r2 \
225: }
226:
227: #define ib4(r0,r1,r2,r3,r4) \
228: __asm { \
229: __asm mov r4,r2 \
230: __asm and r2,r3 \
231: __asm xor r2,r1 \
232: __asm or r1,r3 \
233: __asm and r1,r0 \
234: __asm xor r4,r2 \
235: __asm xor r4,r1 \
236: __asm and r1,r2 \
237: __asm not r0 \
238: __asm xor r3,r4 \
239: __asm xor r1,r3 \
240: __asm and r3,r0 \
241: __asm xor r3,r2 \
242: __asm xor r0,r1 \
243: __asm and r2,r0 \
244: __asm xor r3,r0 \
245: __asm xor r2,r4 \
246: __asm or r2,r3 \
247: __asm xor r3,r0 \
248: __asm xor r2,r1 \
249: }
250:
251: #define sb5(r0,r1,r2,r3,r4) \
252: __asm { \
253: __asm xor r0,r1 \
254: __asm xor r1,r3 \
255: __asm not r3 \
256: __asm mov r4,r1 \
257: __asm and r1,r0 \
258: __asm xor r2,r3 \
259: __asm xor r1,r2 \
260: __asm or r2,r4 \
261: __asm xor r4,r3 \
262: __asm and r3,r1 \
263: __asm xor r3,r0 \
264: __asm xor r4,r1 \
265: __asm xor r4,r2 \
266: __asm xor r2,r0 \
267: __asm and r0,r3 \
268: __asm not r2 \
269: __asm xor r0,r4 \
270: __asm or r4,r3 \
271: __asm xor r2,r4 \
272: }
273:
274: #define ib5(r0,r1,r2,r3,r4) \
275: __asm { \
276: __asm not r1 \
277: __asm mov r4,r3 \
278: __asm xor r2,r1 \
279: __asm or r3,r0 \
280: __asm xor r3,r2 \
281: __asm or r2,r1 \
282: __asm and r2,r0 \
283: __asm xor r4,r3 \
284: __asm xor r2,r4 \
285: __asm or r4,r0 \
286: __asm xor r4,r1 \
287: __asm and r1,r2 \
288: __asm xor r1,r3 \
289: __asm xor r4,r2 \
290: __asm and r3,r4 \
291: __asm xor r4,r1 \
292: __asm xor r3,r0 \
293: __asm xor r3,r4 \
294: __asm not r4 \
295: }
296:
297: #define sb6(r0,r1,r2,r3,r4) \
298: __asm { \
299: __asm not r2 \
300: __asm mov r4,r3 \
301: __asm and r3,r0 \
302: __asm xor r0,r4 \
303: __asm xor r3,r2 \
304: __asm or r2,r4 \
305: __asm xor r1,r3 \
306: __asm xor r2,r0 \
307: __asm or r0,r1 \
308: __asm xor r2,r1 \
309: __asm xor r4,r0 \
310: __asm or r0,r3 \
311: __asm xor r0,r2 \
312: __asm xor r4,r3 \
313: __asm xor r4,r0 \
314: __asm not r3 \
315: __asm and r2,r4 \
316: __asm xor r2,r3 \
317: }
318:
319: #define ib6(r0,r1,r2,r3,r4) \
320: __asm { \
321: __asm xor r0,r2 \
322: __asm mov r4,r2 \
323: __asm and r2,r0 \
324: __asm xor r4,r3 \
325: __asm not r2 \
326: __asm xor r3,r1 \
327: __asm xor r2,r3 \
328: __asm or r4,r0 \
329: __asm xor r0,r2 \
330: __asm xor r3,r4 \
331: __asm xor r4,r1 \
332: __asm and r1,r3 \
333: __asm xor r1,r0 \
334: __asm xor r0,r3 \
335: __asm or r0,r2 \
336: __asm xor r3,r1 \
337: __asm xor r4,r0 \
338: }
339:
340: #define sb7(r0,r1,r2,r3,r4) \
341: __asm { \
342: __asm mov r4,r2 \
343: __asm and r2,r1 \
344: __asm xor r2,r3 \
345: __asm and r3,r1 \
346: __asm xor r4,r2 \
347: __asm xor r2,r1 \
348: __asm xor r1,r0 \
349: __asm or r0,r4 \
350: __asm xor r0,r2 \
351: __asm xor r3,r1 \
352: __asm xor r2,r3 \
353: __asm and r3,r0 \
354: __asm xor r3,r4 \
355: __asm xor r4,r2 \
356: __asm and r2,r0 \
357: __asm not r4 \
358: __asm xor r2,r4 \
359: __asm and r4,r0 \
360: __asm xor r1,r3 \
361: __asm xor r4,r1 \
362: }
363:
364: #define ib7(r0,r1,r2,r3,r4) \
365: __asm { \
366: __asm mov r4,r2 \
367: __asm xor r2,r0 \
368: __asm and r0,r3 \
369: __asm not r2 \
370: __asm or r4,r3 \
371: __asm xor r3,r1 \
372: __asm or r1,r0 \
373: __asm xor r0,r2 \
374: __asm and r2,r4 \
375: __asm xor r1,r2 \
376: __asm xor r2,r0 \
377: __asm or r0,r2 \
378: __asm and r3,r4 \
379: __asm xor r0,r3 \
380: __asm xor r4,r1 \
381: __asm xor r3,r4 \
382: __asm or r4,r0 \
383: __asm xor r3,r2 \
384: __asm xor r4,r2 \
385: }
386:
387: #define f_key(r0,r1,r2,r3) \
388: __asm { \
389: __asm mov r0,[esi] \
390: __asm mov r1,[esi+4] \
391: __asm mov r2,[esi+8] \
392: __asm mov r3,[esi+12] \
393: }
394:
395: #define t_key(r0,r1,r2,r3) \
396: __asm { \
397: __asm mov [esi ],r0 \
398: __asm mov [esi+4],r1 \
399: __asm mov [esi+8],r2 \
400: __asm mov [esi+12],r3 \
401: __asm add esi,16 \
402: }
403:
404: #define f_xor(r0,r1,r2,r3) \
405: __asm { \
406: __asm xor r0,[esi] \
407: __asm xor r1,[esi+4] \
408: __asm xor r2,[esi+8] \
409: __asm xor r3,[esi+12] \
410: __asm add esi,16 \
411: }
412:
413: #define i_xor(r0,r1,r2,r3) \
414: __asm { \
415: __asm sub esi,16 \
416: __asm xor r0,[esi] \
417: __asm xor r1,[esi+4] \
418: __asm xor r2,[esi+8] \
419: __asm xor r3,[esi+12] \
420: }
421:
422: // the linear transformation and its inverse
423:
424: #define rot(r0,r1,r2,r3,r4) \
425: __asm { \
426: __asm rol r0,13 \
427: __asm rol r2,3 \
428: __asm mov r4,r0 \
429: __asm sal r4,3 \
430: __asm xor r3,r2 \
431: __asm xor r3,r4 \
432: __asm xor r1,r0 \
433: __asm xor r1,r2 \
434: __asm rol r1,1 \
435: __asm rol r3,7 \
436: __asm mov r4,r1 \
437: __asm xor r0,r1 \
438: __asm xor r0,r3 \
439: __asm sal r4,7 \
440: __asm xor r2,r3 \
441: __asm xor r2,r4 \
442: __asm rol r0,5 \
443: __asm rol r2,22 \
444: }
445:
446: #define irot(r0,r1,r2,r3,r4) \
447: __asm { \
448: __asm ror r2,22 \
449: __asm ror r0,5 \
450: __asm mov r4,r1 \
451: __asm sal r4,7 \
452: __asm xor r2,r3 \
453: __asm xor r2,r4 \
454: __asm xor r0,r1 \
455: __asm xor r0,r3 \
456: __asm ror r3,7 \
457: __asm mov r4,r0 \
458: __asm ror r1,1 \
459: __asm sal r4,3 \
460: __asm xor r3,r2 \
461: __asm xor r3,r4 \
462: __asm xor r1,r0 \
463: __asm xor r1,r2 \
464: __asm ror r2,3 \
465: __asm ror r0,13 \
466: }
467:
468: char* serpent_name(void)
469: {
470: return "serpent";
471: }
472:
473: // initialise the key schedule from the user supplied key
474:
475: #define k_loop \
476: f_key(eax,ebx,ecx,edx); sb3(eax,ebx,ecx,edx,edi); t_key(ebx,ecx,edx,edi); \
477: f_key(eax,ebx,ecx,edx); sb2(eax,ebx,ecx,edx,edi); t_key(ecx,edx,ebx,edi); \
478: f_key(eax,ebx,ecx,edx); sb1(eax,ebx,ecx,edx,edi); t_key(ecx,eax,edx,ebx); \
479: f_key(eax,ebx,ecx,edx); sb0(eax,ebx,ecx,edx,edi); t_key(ebx,edi,ecx,eax); \
480: f_key(eax,ebx,ecx,edx); sb7(eax,ebx,ecx,edx,edi); t_key(ecx,edi,edx,eax); \
481: f_key(eax,ebx,ecx,edx); sb6(eax,ebx,ecx,edx,edi); t_key(eax,ebx,edi,ecx); \
482: f_key(eax,ebx,ecx,edx); sb5(eax,ebx,ecx,edx,edi); t_key(ebx,edx,eax,ecx); \
483: f_key(eax,ebx,ecx,edx); sb4(eax,ebx,ecx,edx,edi); t_key(ebx,edi,eax,edx);
484:
485: void serpent_set_key(const u1byte in_key[], const u4byte key_len, u1byte *serpent_l_key)
486: {
487: __asm mov edx,key_len
488: __asm cmp edx,256
489: __asm ja short l3
490:
491: #ifdef __cplusplus
492: __asm mov ebx,this
493: __asm lea ebx,[ebx].l_key
494: #else
495: __asm mov ebx,serpent_l_key
496: #endif
497: __asm mov esi,in_key
498: __asm mov ecx,edx
499: __asm add ecx,31
500: __asm sar ecx,5
501: __asm je short l0
502: __asm mov edi,ebx
503: __asm mov eax,ecx
504: __asm rep movsd
505: l0: __asm cmp edx,256
506: __asm je short l1
507: __asm mov ecx,8
508: __asm sub ecx,eax
509: __asm xor eax,eax
510: __asm rep stosd
511: __asm mov ecx,edx
512: __asm mov edx,1
513: __asm sal edx,cl
514: __asm sar ecx,5
515: __asm mov eax,edx
516: __asm dec eax
517: __asm and eax,[ebx+4*ecx]
518: __asm or eax,edx
519: __asm mov [ebx+4*ecx],eax
520: l1: __asm mov esi,ebx
521: __asm mov eax,0x9e3779b9
522: __asm mov ebx,eax
523: __asm xor eax,[esi+ 8]
524: __asm xor ebx,[esi+12]
525: __asm xor eax,[esi+16]
526: __asm xor ebx,[esi+20]
527: __asm xor eax,[esi+24]
528: __asm xor ebx,[esi+28]
529: __asm mov ecx,0
530: __asm push esi
531: l2: __asm mov edx,[esi]
532: __asm xor edx,ecx
533: __asm xor edx,ebx
534: __asm ror edx,21
535: __asm mov [esi+32],edx
536: __asm xor eax,[esi+8]
537: __asm xor eax,edx
538: __asm add esi,4
539: __asm inc ecx
540: __asm mov edx,[esi]
541: __asm xor edx,ecx
542: __asm xor edx,eax
543: __asm ror edx,21
544: __asm mov [esi+32],edx
545: __asm xor ebx,[esi+8]
546: __asm xor ebx,edx
547: __asm add esi,4
548: __asm inc ecx
549: __asm cmp ecx,132
550: __asm jne l2
551: __asm pop esi
552: __asm add esi,4*8
553:
554: k_loop;
555: k_loop;
556: k_loop;
557: k_loop;
558: f_key(eax,ebx,ecx,edx);
559: sb3(eax,ebx,ecx,edx,edi);
560: t_key(ebx,ecx,edx,edi);
561:
562: l3: return;
563: }
564:
565: // encrypt a block of text
566:
567: #define f_loop(a,b,c,d,t) \
568: f_xor(a,b,c,d); sb0(a,b,c,d,t); rot(b,t,c,a,d); \
569: f_xor(b,t,c,a); sb1(b,t,c,a,d); rot(c,b,a,t,d); \
570: f_xor(c,b,a,t); sb2(c,b,a,t,d); rot(a,t,b,d,c); \
571: f_xor(a,t,b,d); sb3(a,t,b,d,c); rot(t,b,d,c,a); \
572: f_xor(t,b,d,c); sb4(t,b,d,c,a); rot(b,a,t,c,d); \
573: f_xor(b,a,t,c); sb5(b,a,t,c,d); rot(a,c,b,t,d); \
574: f_xor(a,c,b,t); sb6(a,c,b,t,d); rot(a,c,d,b,t); \
575: f_xor(a,c,d,b); sb7(a,c,d,b,t);
576:
577: void serpent_encrypt(const u1byte in_blk[16], u1byte out_blk[16], u1byte *serpent_l_key)
578: {
579: __asm mov esi,in_blk
580: __asm mov eax,[esi]
581: __asm mov ebx,[esi+4]
582: __asm mov ecx,[esi+8]
583: __asm mov edx,[esi+12]
584:
585: #ifdef __cplusplus
586: __asm mov esi,this
587: __asm lea esi,[esi].l_key + 4*8
588: #else
589: __asm mov esi,serpent_l_key
590: __asm add esi,4*8
591: #endif
592:
593: f_loop(eax,ebx,ecx,edx,edi); rot(edx,edi,ebx,eax,ecx);
594: f_loop(edx,edi,ebx,eax,ecx); rot(eax,ecx,edi,edx,ebx);
595: f_loop(eax,ecx,edi,edx,ebx); rot(edx,ebx,ecx,eax,edi);
596: f_loop(edx,ebx,ecx,eax,edi); f_xor(eax,edi,ebx,edx);
597:
598: __asm mov esi,out_blk
599: __asm mov [esi],eax
600: __asm mov [esi+4],edi
601: __asm mov [esi+8],ebx
602: __asm mov [esi+12],edx
603: }
604:
605: // decrypt a block of text
606:
607: #define i_loop(a,b,c,d,t) \
608: ib7(a,b,c,d,t); i_xor(d,a,b,t); \
609: irot(d,a,b,t,c); ib6(d,a,b,t,c); i_xor(a,b,c,t); \
610: irot(a,b,c,t,d); ib5(a,b,c,t,d); i_xor(b,d,t,c); \
611: irot(b,d,t,c,a); ib4(b,d,t,c,a); i_xor(b,c,t,a); \
612: irot(b,c,t,a,d); ib3(b,c,t,a,d); i_xor(a,b,t,c); \
613: irot(a,b,t,c,d); ib2(a,b,t,c,d); i_xor(b,d,t,c); \
614: irot(b,d,t,c,a); ib1(b,d,t,c,a); i_xor(a,b,c,t); \
615: irot(a,b,c,t,d); ib0(a,b,c,t,d); i_xor(a,d,b,t);
616:
617: void serpent_decrypt(const u1byte in_blk[16], u1byte out_blk[16], u1byte *serpent_l_key)
618: {
619: __asm mov esi,in_blk
620: __asm mov eax,[esi]
621: __asm mov ebx,[esi+4]
622: __asm mov ecx,[esi+8]
623: __asm mov edx,[esi+12]
624:
625: #ifdef __cplusplus
626: __asm mov esi,this
627: __asm lea esi,[esi].l_key + 4*140
628: #else
629: __asm mov esi,serpent_l_key
630: __asm add esi,4*140
631: #endif
632:
633: i_xor(eax,ebx,ecx,edx); i_loop(eax,ebx,ecx,edx,edi);
634: irot(eax,edx,ebx,edi,ecx); i_loop(eax,edx,ebx,edi,ecx);
635: irot(eax,edi,edx,ecx,ebx); i_loop(eax,edi,edx,ecx,ebx);
636: irot(eax,ecx,edi,ebx,edx); i_loop(eax,ecx,edi,ebx,edx);
637:
638: __asm mov esi,out_blk
639: __asm mov [esi],eax
640: __asm mov [esi+4],ebx
641: __asm mov [esi+8],ecx
642: __asm mov [esi+12],edx
643: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.