MagickCore 7.0.10
serpent.c
Go to the documentation of this file.
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% SSSSS EEEEE RRRR PPPP EEEEE N N TTTTT %
7% SS E R R P P E NN N T %
8% SSS EEE RRRR PPPP EEE N N N T %
9% SS E R R P E N NN T %
10% SSSSS EEEEE R R P EEEEE N N T %
11% %
12% %
13% Wizard's Toolkit Serpent Cipher Methods %
14% %
15% Software Design %
16% Cristy %
17% March 2003 %
18% %
19% Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
20% dedicated to making software imaging solutions freely available. %
21% %
22% You may not use this file except in compliance with the License. You may %
23% obtain a copy of the License at %
24% %
25% https://imagemagick.org/script/license.php %
26% %
27% Unless required by applicable law or agreed to in writing, software %
28% distributed under the License is distributed on an "AS IS" BASIS, %
29% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
30% See the License for the specific language governing permissions and %
31% limitations under the License. %
32% %
33%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
34%
35%
36*/
37␌
38/*
39 Include declarations.
40*/
41#include "wizard/studio.h"
42#include "wizard/exception.h"
43#include "wizard/exception-private.h"
44#include "wizard/memory_.h"
45#include "wizard/serpent.h"
46␌
47/*
48 Typedef declarations.
49*/
50struct _SerpentInfo
51{
52 unsigned int
53 blocksize,
54 crypt_key[132];
55
56 time_t
57 timestamp;
58
59 size_t
60 signature;
61};
62␌
63/*
64 Define declarations.
65*/
66#define Read32Bits(value,p) \
67{ \
68 (value)=(*p++); \
69 (value)|=(*p++) << 8; \
70 (value)|=(*p++) << 16; \
71 (value)|=(*p++) << 24; \
72}
73#define SerpentBlocksize 32
74#define Write32Bits(p,value) \
75{ \
76 *p++=(unsigned char) (value); \
77 *p++=(unsigned char) ((value) >> 8); \
78 *p++=(unsigned char) ((value) >> 16); \
79 *p++=(unsigned char) ((value) >> 24); \
80}
81␌
82/*
83%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
84% %
85% %
86% %
87% A c q u i r e S e r p e n t I n f o %
88% %
89% %
90% %
91%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
92%
93% AcquireSerpentInfo() allocate the SerpentInfo structure.
94%
95% The format of the AcquireSerpentInfo method is:
96%
97% SerpentInfo *AcquireSerpentInfo(void)
98%
99*/
100WizardExport SerpentInfo *AcquireSerpentInfo(void)
101{
102 SerpentInfo
103 *serpent_info;
104
105 serpent_info=(SerpentInfo *) AcquireWizardMemory(sizeof(*serpent_info));
106 if (serpent_info == (SerpentInfo *) NULL)
107 ThrowWizardFatalError(CipherError,MemoryError);
108 (void) memset(serpent_info,0,sizeof(*serpent_info));
109 serpent_info->blocksize=SerpentBlocksize;
110 serpent_info->timestamp=time((time_t *) NULL);
111 serpent_info->signature=WizardSignature;
112 return(serpent_info);
113}
114␌
115/*
116%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
117% %
118% %
119% %
120% D e c i p h e r S e r p e n t B l o c k %
121% %
122% %
123% %
124%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
125%
126% DecipherSerpentBlock() deciphers a single block of ciphertext to produce a
127% block of plaintext.
128%
129% The format of the DecipherSerpentBlock method is:
130%
131% void DecipherSerpentBlock(SerpentInfo *serpent_info,
132% const unsigned char *ciphertext,unsigned char plaintext)
133%
134% A description of each parameter follows:
135%
136% o serpent_info: The cipher context.
137%
138% o ciphertext: The cipher text.
139%
140% o plaintext: The plaint text.
141%
142*/
143
144static inline unsigned int Trunc32(unsigned int x)
145{
146 return((unsigned int) (x & 0xffffffffUL));
147}
148
149static inline unsigned int RotateRight(unsigned int x,unsigned int n)
150{
151 return(Trunc32((x >> n) | (x << (32-n))));
152}
153
154WizardExport void DecipherSerpentBlock(SerpentInfo *serpent_info,
155 const unsigned char *ciphertext,unsigned char *plaintext)
156{
157#define DecipherSbox0(alpha,beta,gamma,delta,epsilon) \
158{ \
159 beta^=alpha; epsilon=delta; delta|=beta; epsilon^=beta; \
160 alpha=(~alpha); gamma^=delta; delta^=alpha; alpha&=beta; \
161 alpha^=gamma; gamma&=delta; delta^=epsilon; gamma^=delta; \
162 beta^=delta; delta&=alpha; beta^=alpha; alpha^=gamma; epsilon^=delta; \
163}
164#define DecipherSbox1(alpha,beta,gamma,delta,epsilon) \
165{ \
166 beta^=delta; epsilon=alpha; alpha^=gamma; gamma=(~gamma); \
167 epsilon|=beta; epsilon^=delta; delta&=beta; beta^=gamma; \
168 gamma&=epsilon; epsilon^=beta; beta|=delta; delta^=alpha; \
169 gamma^=alpha; alpha|=epsilon; gamma^=epsilon; beta^=alpha; epsilon^=beta; \
170}
171#define DecipherSbox2(alpha,beta,gamma,delta,epsilon) \
172{ \
173 gamma^=beta; epsilon=delta; delta=(~delta); delta|=gamma; \
174 gamma^=epsilon; epsilon^=alpha; delta^=beta; beta|=gamma; \
175 gamma^=alpha; beta^=epsilon; epsilon|=delta; gamma^=delta; \
176 epsilon^=gamma; gamma&=beta; gamma^=delta; delta^=epsilon; epsilon^=alpha; \
177}
178#define DecipherSbox3(alpha,beta,gamma,delta,epsilon) \
179{ \
180 gamma^=beta; epsilon=beta; beta&=gamma; beta^=alpha; \
181 alpha|=epsilon; epsilon^=delta; alpha^=delta; delta|=beta; \
182 beta^=gamma; beta^=delta; alpha^=gamma; gamma^=delta; delta&=beta; \
183 beta^=alpha; alpha&=gamma; epsilon^=delta; delta^=alpha; alpha^=beta; \
184}
185#define DecipherSbox4(alpha,beta,gamma,delta,epsilon) \
186{ \
187 gamma^=delta; epsilon=alpha; alpha&=beta; alpha^=gamma; \
188 gamma|=delta; epsilon=(~epsilon); beta^=alpha; alpha^=gamma; \
189 gamma&=epsilon; gamma^=alpha; alpha|=epsilon; alpha^=delta; \
190 delta&=gamma; epsilon^=delta; delta^=beta; beta&=alpha; \
191 epsilon^=beta; alpha^=delta; \
192}
193#define DecipherSbox5(alpha,beta,gamma,delta,epsilon) \
194{ \
195 epsilon=beta; beta|=gamma; gamma^=epsilon; beta^=delta; \
196 delta&=epsilon; gamma^=delta; delta|=alpha; alpha=(~alpha); \
197 delta^=gamma; gamma|=alpha; epsilon^=beta; gamma^=epsilon; \
198 epsilon&=alpha; alpha^=beta; beta^=delta; alpha&=gamma; \
199 gamma^=delta; alpha^=gamma; gamma^=epsilon; epsilon^=delta; \
200}
201#define DecipherSbox6(alpha,beta,gamma,delta,epsilon) \
202{ \
203 alpha^=gamma; epsilon=alpha; alpha&=delta; gamma^=delta; \
204 alpha^=gamma; delta^=beta; gamma|=epsilon; gamma^=delta; \
205 delta&=alpha; alpha=(~alpha); delta^=beta; beta&=gamma; \
206 epsilon^=alpha; delta^=epsilon; epsilon^=gamma; alpha^=beta; gamma^=alpha; \
207}
208#define DecipherSbox7(alpha,beta,gamma,delta,epsilon) \
209{ \
210 epsilon=delta; delta&=alpha; alpha^=gamma; gamma|=epsilon; \
211 epsilon^=beta; alpha=(~alpha); beta|=delta; epsilon^=alpha; \
212 alpha&=gamma; alpha^=beta; beta&=gamma; delta^=gamma; \
213 epsilon^=delta; gamma&=delta; delta|=alpha; beta^=epsilon; \
214 delta^=epsilon; epsilon&=alpha; epsilon^=gamma; \
215}
216#define DecipherK(alpha,beta,gamma,delta,epsilon,i) \
217{ \
218 MixKey(alpha,beta,gamma,delta,i) \
219 alpha=RotateRight(alpha,5); gamma=RotateRight(gamma,22); \
220 alpha^=delta; gamma^=delta; epsilon=beta << 7; alpha^=beta; \
221 beta=RotateRight(beta,1); gamma^=epsilon; delta=RotateRight(delta,7); \
222 epsilon=alpha << 3; beta^=alpha; delta^=epsilon; \
223 alpha=RotateRight(alpha,13); beta^=gamma; delta^=gamma; \
224 gamma=RotateRight(gamma,3); \
225}
226#define MixKey(alpha,beta,gamma,delta,i) \
227{ \
228 alpha^=crypt_key[4*(i)+0]; beta^=crypt_key[4*(i)+1]; \
229 gamma^=crypt_key[4*(i)+2]; delta^=crypt_key[4*(i)+3]; \
230}
231
232 const unsigned char
233 *p;
234
235 unsigned char
236 *q;
237
238 unsigned int
239 *crypt_key;
240
241 unsigned int
242 alpha,
243 beta,
244 gamma,
245 delta,
246 epsilon;
247
248 /*
249 Exercise 32 deciphering rounds.
250 */
251 p=(const unsigned char *) ciphertext;
252 Read32Bits(alpha,p);
253 Read32Bits(beta,p);
254 Read32Bits(gamma,p);
255 Read32Bits(delta,p);
256 crypt_key=serpent_info->crypt_key;
257 MixKey(alpha,beta,gamma,delta,32);
258 DecipherSbox7(alpha,beta,gamma,delta,epsilon);
259 DecipherK(beta,delta,alpha,epsilon,gamma,31);
260 DecipherSbox6(beta,delta,alpha,epsilon,gamma);
261 DecipherK(alpha,gamma,epsilon,beta,delta,30);
262 DecipherSbox5(alpha,gamma,epsilon,beta,delta);
263 DecipherK(gamma,delta,alpha,epsilon,beta,29);
264 DecipherSbox4(gamma,delta,alpha,epsilon,beta);
265 DecipherK(gamma,alpha,beta,epsilon,delta,28);
266 DecipherSbox3(gamma,alpha,beta,epsilon,delta);
267 DecipherK(beta,gamma,delta,epsilon,alpha,27);
268 DecipherSbox2(beta,gamma,delta,epsilon,alpha);
269 DecipherK(gamma,alpha,epsilon,delta,beta,26);
270 DecipherSbox1(gamma,alpha,epsilon,delta,beta);
271 DecipherK(beta,alpha,epsilon,delta,gamma,25);
272 DecipherSbox0(beta,alpha,epsilon,delta,gamma);
273 DecipherK(epsilon,gamma,alpha,beta,delta,24);
274 DecipherSbox7(epsilon,gamma,alpha,beta,delta);
275 DecipherK(gamma,beta,epsilon,delta,alpha,23);
276 DecipherSbox6(gamma,beta,epsilon,delta,alpha);
277 DecipherK(epsilon,alpha,delta,gamma,beta,22);
278 DecipherSbox5(epsilon,alpha,delta,gamma,beta);
279 DecipherK(alpha,beta,epsilon,delta,gamma,21);
280 DecipherSbox4(alpha,beta,epsilon,delta,gamma);
281 DecipherK(alpha,epsilon,gamma,delta,beta,20);
282 DecipherSbox3(alpha,epsilon,gamma,delta,beta);
283 DecipherK(gamma,alpha,beta,delta,epsilon,19);
284 DecipherSbox2(gamma,alpha,beta,delta,epsilon);
285 DecipherK(alpha,epsilon,delta,beta,gamma,18);
286 DecipherSbox1(alpha,epsilon,delta,beta,gamma);
287 DecipherK(gamma,epsilon,delta,beta,alpha,17);
288 DecipherSbox0(gamma,epsilon,delta,beta,alpha);
289 DecipherK(delta,alpha,epsilon,gamma,beta,16);
290 DecipherSbox7(delta,alpha,epsilon,gamma,beta);
291 DecipherK(alpha,gamma,delta,beta,epsilon,15);
292 DecipherSbox6(alpha,gamma,delta,beta,epsilon);
293 DecipherK(delta,epsilon,beta,alpha,gamma,14);
294 DecipherSbox5(delta,epsilon,beta,alpha,gamma);
295 DecipherK(epsilon,gamma,delta,beta,alpha,13);
296 DecipherSbox4(epsilon,gamma,delta,beta,alpha);
297 DecipherK(epsilon,delta,alpha,beta,gamma,12);
298 DecipherSbox3(epsilon,delta,alpha,beta,gamma);
299 DecipherK(alpha,epsilon,gamma,beta,delta,11);
300 DecipherSbox2(alpha,epsilon,gamma,beta,delta);
301 DecipherK(epsilon,delta,beta,gamma,alpha,10);
302 DecipherSbox1(epsilon,delta,beta,gamma,alpha);
303 DecipherK(alpha,delta,beta,gamma,epsilon,9);
304 DecipherSbox0(alpha,delta,beta,gamma,epsilon);
305 DecipherK(beta,epsilon,delta,alpha,gamma,8);
306 DecipherSbox7(beta,epsilon,delta,alpha,gamma);
307 DecipherK(epsilon,alpha,beta,gamma,delta,7);
308 DecipherSbox6(epsilon,alpha,beta,gamma,delta);
309 DecipherK(beta,delta,gamma,epsilon,alpha,6);
310 DecipherSbox5(beta,delta,gamma,epsilon,alpha);
311 DecipherK(delta,alpha,beta,gamma,epsilon,5);
312 DecipherSbox4(delta,alpha,beta,gamma,epsilon);
313 DecipherK(delta,beta,epsilon,gamma,alpha,4);
314 DecipherSbox3(delta,beta,epsilon,gamma,alpha);
315 DecipherK(epsilon,delta,alpha,gamma,beta,3);
316 DecipherSbox2(epsilon,delta,alpha,gamma,beta);
317 DecipherK(delta,beta,gamma,alpha,epsilon,2);
318 DecipherSbox1(delta,beta,gamma,alpha,epsilon);
319 DecipherK(epsilon,beta,gamma,alpha,delta,1);
320 DecipherSbox0(epsilon,beta,gamma,alpha,delta);
321 MixKey(gamma,delta,beta,epsilon,0);
322 q=(unsigned char *) plaintext;
323 Write32Bits(q,gamma);
324 Write32Bits(q,delta);
325 Write32Bits(q,beta);
326 Write32Bits(q,epsilon);
327 /*
328 Reset registers.
329 */
330 alpha=0;
331 beta=0;
332 gamma=0;
333 delta=0;
334 epsilon=0;
335}
336␌
337/*
338%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
339% %
340% %
341% %
342% D e s t r o y S e r p e n t I n f o %
343% %
344% %
345% %
346%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
347%
348% DestroySerpentInfo() zeros memory associated with the SerpentInfo structure.
349%
350% The format of the DestroySerpentInfo method is:
351%
352% SerpentInfo *DestroySerpentInfo(SerpentInfo *serpent_info)
353%
354% A description of each parameter follows:
355%
356% o serpent_info: The cipher context.
357%
358*/
359WizardExport SerpentInfo *DestroySerpentInfo(SerpentInfo *serpent_info)
360{
361 (void) LogWizardEvent(TraceEvent,GetWizardModule(),"...");
362 WizardAssert(CipherDomain,serpent_info != (SerpentInfo *) NULL);
363 WizardAssert(CipherDomain,serpent_info->signature == WizardSignature);
364 serpent_info->signature=(~WizardSignature);
365 serpent_info=(SerpentInfo *) RelinquishWizardMemory(serpent_info);
366 return(serpent_info);
367}
368␌
369/*
370%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
371% %
372% %
373% %
374% E n c i p h e r S e r p e n t B l o c k %
375% %
376% %
377% %
378%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
379%
380% EncipherSerpentBlock() enciphers a single block of plaintext to produce a
381% block of ciphertext.
382%
383% The format of the EncipherSerpentBlock method is:
384%
385% void EncipherSerpentBlock(SerpentInfo *serpent_info,
386% const unsigned char *plaintext,unsigned char ciphertext)
387%
388% A description of each parameter follows:
389%
390% o serpent_info: The cipher context.
391%
392% o plaintext: The plain text.
393%
394% o ciphertext: The cipher text.
395%
396*/
397
398static inline unsigned int RotateLeft(unsigned int x,unsigned int n)
399{
400 return(Trunc32((x << n) | (x >> (32-n))));
401}
402
403WizardExport void EncipherSerpentBlock(SerpentInfo *serpent_info,
404 const unsigned char *plaintext,unsigned char *ciphertext)
405{
406#define EncipherK(alpha,beta,gamma,delta,epsilon,i) \
407{ \
408 alpha=RotateLeft(alpha,13); gamma=RotateLeft(gamma,3); \
409 beta^=alpha; epsilon=alpha << 3; delta^=gamma; beta^=gamma; \
410 beta=RotateLeft(beta,1); delta^=epsilon; delta=RotateLeft(delta,7); \
411 epsilon=beta << 7; alpha^=beta; gamma^=delta; alpha^=delta; \
412 gamma^=epsilon; delta^=crypt_key[4*(i)+3]; beta^=crypt_key[4*(i)+1]; \
413 alpha=RotateLeft(alpha,5); gamma=RotateLeft(gamma,22); \
414 alpha^=crypt_key[4*(i)+0]; gamma^=crypt_key[4*(i)+2]; \
415}
416#define EncipherSbox0(alpha,beta,gamma,delta,epsilon) \
417{ \
418 epsilon=delta; delta|=alpha; alpha^=epsilon; epsilon^=gamma; \
419 epsilon=(~epsilon); delta^=beta; beta&=alpha; beta^=epsilon; \
420 gamma^=alpha; alpha^=delta; epsilon|=alpha; alpha^=gamma; \
421 gamma&=beta; delta^=gamma; beta=(~beta); gamma^=epsilon; beta^=gamma; \
422}
423#define EncipherSbox1(alpha,beta,gamma,delta,epsilon) \
424{ \
425 epsilon=beta; beta^=alpha; alpha^=delta; delta=~delta; \
426 epsilon&=beta; alpha|=beta; delta^=gamma; alpha^=delta; \
427 beta^=delta; delta^=epsilon; beta|=epsilon; epsilon^=gamma; \
428 gamma&=alpha; gamma^=beta; beta|=alpha; alpha=(~alpha); \
429 alpha^=gamma; epsilon^=beta; \
430}
431#define EncipherSbox2(alpha,beta,gamma,delta,epsilon) \
432{ \
433 delta=(~delta); beta^=alpha; epsilon=alpha; alpha&=gamma; \
434 alpha^=delta; delta|=epsilon; gamma^=beta; delta^=beta; \
435 beta&=alpha; alpha^=gamma; gamma&=delta; delta|=beta; \
436 alpha=(~alpha); delta^=alpha; epsilon^=alpha; alpha^=gamma; beta|=gamma; \
437}
438#define EncipherSbox3(alpha,beta,gamma,delta,epsilon) \
439{ \
440 epsilon=beta; beta^=delta; delta|=alpha; epsilon&=alpha; \
441 alpha^=gamma; gamma^=beta; beta&=delta; gamma^=delta; \
442 alpha|=epsilon; epsilon^=delta; beta^=alpha; alpha&=delta; \
443 delta&=epsilon; delta^=gamma; epsilon|=beta; gamma&=beta; \
444 epsilon^=delta; alpha^=delta; delta^=gamma; \
445}
446#define EncipherSbox4(alpha,beta,gamma,delta,epsilon) \
447{ \
448 epsilon=delta; delta&=alpha; alpha^=epsilon; delta^=gamma; \
449 gamma|=epsilon; alpha^=beta; epsilon^=delta; gamma|=alpha; \
450 gamma^=beta; beta&=alpha; beta^=epsilon; epsilon&=gamma; \
451 gamma^=delta; epsilon^=alpha; delta|=beta; beta=(~beta); delta^=alpha; \
452}
453#define EncipherSbox5(alpha,beta,gamma,delta,epsilon) \
454{ \
455 epsilon=beta; beta|=alpha; gamma^=beta; delta=(~delta); \
456 epsilon^=alpha; alpha^=gamma; beta&=epsilon; epsilon|=delta; \
457 epsilon^=alpha; alpha&=delta; beta^=delta; delta^=gamma; \
458 alpha^=beta; gamma&=epsilon; beta^=gamma; gamma&=alpha; delta^=gamma; \
459}
460#define EncipherSbox6(alpha,beta,gamma,delta,epsilon) \
461{ \
462 epsilon=beta; delta^=alpha; beta^=gamma; gamma^=alpha; \
463 alpha&=delta; beta|=delta; epsilon=(~epsilon); alpha^=beta; \
464 beta^=gamma; delta^=epsilon; epsilon^=alpha; gamma&=alpha; \
465 epsilon^=beta; gamma^=delta; delta&=beta; delta^=alpha; beta^=gamma; \
466}
467#define EncipherSbox7(alpha,beta,gamma,delta,epsilon) \
468{ \
469 beta=(~beta); epsilon=beta; alpha=(~alpha); beta&=gamma; \
470 beta^=delta; delta|=epsilon; epsilon^=gamma; gamma^=delta; \
471 delta^=alpha; alpha|=beta; gamma&=alpha; alpha^=epsilon; \
472 epsilon^=delta; delta&=alpha; epsilon^=beta; gamma^=epsilon; \
473 delta^=beta; epsilon|=alpha; epsilon^=beta; \
474}
475
476 const unsigned char
477 *p;
478
479 unsigned char
480 *q;
481
482 unsigned int
483 *crypt_key;
484
485 unsigned int
486 alpha,
487 beta,
488 gamma,
489 delta,
490 epsilon;
491
492 /*
493 Exercise 32 enciphering rounds.
494 */
495 p=(const unsigned char *) plaintext;
496 Read32Bits(alpha,p);
497 Read32Bits(beta,p);
498 Read32Bits(gamma,p);
499 Read32Bits(delta,p);
500 crypt_key=serpent_info->crypt_key;
501 MixKey(alpha,beta,gamma,delta,0);
502 EncipherSbox0(alpha,beta,gamma,delta,epsilon);
503 EncipherK(gamma,beta,delta,alpha,epsilon,1);
504 EncipherSbox1(gamma,beta,delta,alpha,epsilon);
505 EncipherK(epsilon,delta,alpha,gamma,beta,2);
506 EncipherSbox2(epsilon,delta,alpha,gamma,beta);
507 EncipherK(beta,delta,epsilon,gamma,alpha,3);
508 EncipherSbox3(beta,delta,epsilon,gamma,alpha);
509 EncipherK(gamma,alpha,delta,beta,epsilon,4);
510 EncipherSbox4(gamma,alpha,delta,beta,epsilon);
511 EncipherK(alpha,delta,beta,epsilon,gamma,5);
512 EncipherSbox5(alpha,delta,beta,epsilon,gamma);
513 EncipherK(gamma,alpha,delta,epsilon,beta,6);
514 EncipherSbox6(gamma,alpha,delta,epsilon,beta);
515 EncipherK(delta,beta,alpha,epsilon,gamma,7);
516 EncipherSbox7(delta,beta,alpha,epsilon,gamma);
517 EncipherK(gamma,alpha,epsilon,delta,beta,8);
518 EncipherSbox0(gamma,alpha,epsilon,delta,beta);
519 EncipherK(epsilon,alpha,delta,gamma,beta,9);
520 EncipherSbox1(epsilon,alpha,delta,gamma,beta);
521 EncipherK(beta,delta,gamma,epsilon,alpha,10);
522 EncipherSbox2(beta,delta,gamma,epsilon,alpha);
523 EncipherK(alpha,delta,beta,epsilon,gamma,11);
524 EncipherSbox3(alpha,delta,beta,epsilon,gamma);
525 EncipherK(epsilon,gamma,delta,alpha,beta,12);
526 EncipherSbox4(epsilon,gamma,delta,alpha,beta);
527 EncipherK(gamma,delta,alpha,beta,epsilon,13);
528 EncipherSbox5(gamma,delta,alpha,beta,epsilon);
529 EncipherK(epsilon,gamma,delta,beta,alpha,14);
530 EncipherSbox6(epsilon,gamma,delta,beta,alpha);
531 EncipherK(delta,alpha,gamma,beta,epsilon,15);
532 EncipherSbox7(delta,alpha,gamma,beta,epsilon);
533 EncipherK(epsilon,gamma,beta,delta,alpha,16);
534 EncipherSbox0(epsilon,gamma,beta,delta,alpha);
535 EncipherK(beta,gamma,delta,epsilon,alpha,17);
536 EncipherSbox1(beta,gamma,delta,epsilon,alpha);
537 EncipherK(alpha,delta,epsilon,beta,gamma,18);
538 EncipherSbox2(alpha,delta,epsilon,beta,gamma);
539 EncipherK(gamma,delta,alpha,beta,epsilon,19);
540 EncipherSbox3(gamma,delta,alpha,beta,epsilon);
541 EncipherK(beta,epsilon,delta,gamma,alpha,20);
542 EncipherSbox4(beta,epsilon,delta,gamma,alpha);
543 EncipherK(epsilon,delta,gamma,alpha,beta,21);
544 EncipherSbox5(epsilon,delta,gamma,alpha,beta);
545 EncipherK(beta,epsilon,delta,alpha,gamma,22);
546 EncipherSbox6(beta,epsilon,delta,alpha,gamma);
547 EncipherK(delta,gamma,epsilon,alpha,beta,23);
548 EncipherSbox7(delta,gamma,epsilon,alpha,beta);
549 EncipherK(beta,epsilon,alpha,delta,gamma,24);
550 EncipherSbox0(beta,epsilon,alpha,delta,gamma);
551 EncipherK(alpha,epsilon,delta,beta,gamma,25);
552 EncipherSbox1(alpha,epsilon,delta,beta,gamma);
553 EncipherK(gamma,delta,beta,alpha,epsilon,26);
554 EncipherSbox2(gamma,delta,beta,alpha,epsilon);
555 EncipherK(epsilon,delta,gamma,alpha,beta,27);
556 EncipherSbox3(epsilon,delta,gamma,alpha,beta);
557 EncipherK(alpha,beta,delta,epsilon,gamma,28);
558 EncipherSbox4(alpha,beta,delta,epsilon,gamma);
559 EncipherK(beta,delta,epsilon,gamma,alpha,29);
560 EncipherSbox5(beta,delta,epsilon,gamma,alpha);
561 EncipherK(alpha,beta,delta,gamma,epsilon,30);
562 EncipherSbox6(alpha,beta,delta,gamma,epsilon);
563 EncipherK(delta,epsilon,beta,gamma,alpha,31);
564 EncipherSbox7(delta,epsilon,beta,gamma,alpha);
565 MixKey(alpha,beta,gamma,delta,32);
566 q=(unsigned char * ) ciphertext;
567 Write32Bits(q,alpha);
568 Write32Bits(q,beta);
569 Write32Bits(q,gamma);
570 Write32Bits(q,delta);
571 /*
572 Reset registers.
573 */
574 alpha=0;
575 beta=0;
576 gamma=0;
577 delta=0;
578 epsilon=0;
579}
580␌
581/*
582%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
583% %
584% %
585% %
586% G e t S e r p e n t B l o c k s i z e %
587% %
588% %
589% %
590%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
591%
592% GetSerpentBlocksize() returns the Serpent blocksize.
593%
594% The format of the GetSerpentBlocksize method is:
595%
596% unsigned int *GetSerpentBlocksize(const SerpentInfo *serpent_info)
597%
598% A description of each parameter follows:
599%
600% o serpent_info: The serpent info.
601%
602*/
603WizardExport unsigned int GetSerpentBlocksize(const SerpentInfo *serpent_info)
604{
605 (void) LogWizardEvent(TraceEvent,GetWizardModule(),"...");
606 WizardAssert(CipherDomain,serpent_info != (SerpentInfo *) NULL);
607 WizardAssert(CipherDomain,serpent_info->signature == WizardSignature);
608 return(serpent_info->blocksize);
609}
610␌
611/*
612%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
613% %
614% %
615% %
616% S e t S e r p e n t K e y %
617% %
618% %
619% %
620%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
621%
622% SetSerpentKey() sets the key for the Serpent cipher. The key length is
623% specified in bits. Valid values are 128,192,or 256 requiring a key
624% buffer length in bytes of 16,24,and 32 respectively.
625%
626% The format of the SetSerpentKey method is:
627%
628% SetSerpentKey(SerpentInfo *serpent_info,const StringInfo *key)
629%
630% A description of each parameter follows:
631%
632% o serpent_info: The cipher context.
633%
634% o key: The key.
635%
636*/
637WizardExport void SetSerpentKey(SerpentInfo *serpent_info,const StringInfo *key)
638{
639#define ChurnKey(alpha,beta,gamma,delta,i,j) \
640{ \
641 beta^=delta; beta^=gamma; beta^=alpha; beta^=0x9e3779b9UL ^ i; \
642 beta=RotateLeft(beta,11); crypt_key[j]=beta; \
643}
644#define LoadKey(alpha,beta,gamma,delta,i) \
645{ \
646 alpha=crypt_key[i]; beta=crypt_key[(i)+1]; \
647 gamma=crypt_key[(i)+2]; delta=crypt_key[(i)+3]; \
648}
649#define MaximumSerpentKeyLength 32
650#define StoreKey(alpha,beta,gamma,delta,i) \
651{ \
652 crypt_key[i]=alpha; crypt_key[(i)+1]=beta; \
653 crypt_key[(i)+2]=gamma; crypt_key[(i)+3]=delta; \
654}
655
656 size_t
657 i;
658
659 unsigned char
660 *p;
661
662 unsigned int
663 *crypt_key;
664
665 unsigned char
666 *datum;
667
668 unsigned int
669 alpha,
670 beta,
671 gamma,
672 delta,
673 epsilon,
674 rho;
675
676 /*
677 Generate crypt key.
678 */
679 (void) LogWizardEvent(TraceEvent,GetWizardModule(),"...");
680 WizardAssert(CipherDomain,serpent_info != (SerpentInfo *) NULL);
681 WizardAssert(CipherDomain,serpent_info->signature == WizardSignature);
682 WizardAssert(CipherDomain,key != (StringInfo *) NULL);
683 crypt_key=serpent_info->crypt_key;
684 p=(unsigned char *) crypt_key;
685 datum=GetStringInfoDatum(key);
686 for (i=0; i < Min(GetStringInfoLength(key),MaximumSerpentKeyLength); i++)
687 p[i]=datum[i];
688 if (i < MaximumSerpentKeyLength)
689 p[i++]=1;
690 while (i < MaximumSerpentKeyLength)
691 p[i++]=0;
692 p=(unsigned char *) crypt_key;
693 p+=12;
694 Read32Bits(alpha,p);
695 Read32Bits(beta,p);
696 Read32Bits(gamma,p);
697 Read32Bits(delta,p);
698 Read32Bits(epsilon,p);
699 p=(unsigned char *) crypt_key;
700 Read32Bits(rho,p);
701 ChurnKey(rho,alpha,epsilon,gamma,0,0);
702 Read32Bits(rho,p);
703 ChurnKey(rho,beta,alpha,delta,1,1);
704 Read32Bits(rho,p);
705 ChurnKey(rho,gamma,beta,epsilon,2,2);
706 Read32Bits(rho,p);
707 ChurnKey(rho,delta,gamma,alpha,3,3);
708 Read32Bits(rho,p);
709 ChurnKey(rho,epsilon,delta,beta,4,4);
710 Read32Bits(rho,p);
711 ChurnKey(rho,alpha,epsilon,gamma,5,5);
712 Read32Bits(rho,p);
713 ChurnKey(rho,beta,alpha,delta,6,6);
714 Read32Bits(rho,p);
715 ChurnKey(rho,gamma,beta,epsilon,7,7);
716 ChurnKey(crypt_key[0],delta,gamma,alpha,8,8);
717 ChurnKey(crypt_key[1],epsilon,delta,beta,9,9);
718 ChurnKey(crypt_key[2],alpha,epsilon,gamma,10,10);
719 ChurnKey(crypt_key[3],beta,alpha,delta,11,11);
720 ChurnKey(crypt_key[4],gamma,beta,epsilon,12,12);
721 ChurnKey(crypt_key[5],delta,gamma,alpha,13,13);
722 ChurnKey(crypt_key[6],epsilon,delta,beta,14,14);
723 ChurnKey(crypt_key[7],alpha,epsilon,gamma,15,15);
724 ChurnKey(crypt_key[8],beta,alpha,delta,16,16);
725 ChurnKey(crypt_key[9],gamma,beta,epsilon,17,17);
726 ChurnKey(crypt_key[10],delta,gamma,alpha,18,18);
727 ChurnKey(crypt_key[11],epsilon,delta,beta,19,19);
728 ChurnKey(crypt_key[12],alpha,epsilon,gamma,20,20);
729 ChurnKey(crypt_key[13],beta,alpha,delta,21,21);
730 ChurnKey(crypt_key[14],gamma,beta,epsilon,22,22);
731 ChurnKey(crypt_key[15],delta,gamma,alpha,23,23);
732 ChurnKey(crypt_key[16],epsilon,delta,beta,24,24);
733 ChurnKey(crypt_key[17],alpha,epsilon,gamma,25,25);
734 ChurnKey(crypt_key[18],beta,alpha,delta,26,26);
735 ChurnKey(crypt_key[19],gamma,beta,epsilon,27,27);
736 ChurnKey(crypt_key[20],delta,gamma,alpha,28,28);
737 ChurnKey(crypt_key[21],epsilon,delta,beta,29,29);
738 ChurnKey(crypt_key[22],alpha,epsilon,gamma,30,30);
739 ChurnKey(crypt_key[23],beta,alpha,delta,31,31);
740 crypt_key+=50;
741 ChurnKey(crypt_key[-26],gamma,beta,epsilon,32,-18);
742 ChurnKey(crypt_key[-25],delta,gamma,alpha,33,-17);
743 ChurnKey(crypt_key[-24],epsilon,delta,beta,34,-16);
744 ChurnKey(crypt_key[-23],alpha,epsilon,gamma,35,-15);
745 ChurnKey(crypt_key[-22],beta,alpha,delta,36,-14);
746 ChurnKey(crypt_key[-21],gamma,beta,epsilon,37,-13);
747 ChurnKey(crypt_key[-20],delta,gamma,alpha,38,-12);
748 ChurnKey(crypt_key[-19],epsilon,delta,beta,39,-11);
749 ChurnKey(crypt_key[-18],alpha,epsilon,gamma,40,-10);
750 ChurnKey(crypt_key[-17],beta,alpha,delta,41,-9);
751 ChurnKey(crypt_key[-16],gamma,beta,epsilon,42,-8);
752 ChurnKey(crypt_key[-15],delta,gamma,alpha,43,-7);
753 ChurnKey(crypt_key[-14],epsilon,delta,beta,44,-6);
754 ChurnKey(crypt_key[-13],alpha,epsilon,gamma,45,-5);
755 ChurnKey(crypt_key[-12],beta,alpha,delta,46,-4);
756 ChurnKey(crypt_key[-11],gamma,beta,epsilon,47,-3);
757 ChurnKey(crypt_key[-10],delta,gamma,alpha,48,-2);
758 ChurnKey(crypt_key[-9],epsilon,delta,beta,49,-1);
759 ChurnKey(crypt_key[-8],alpha,epsilon,gamma,50,0);
760 ChurnKey(crypt_key[-7],beta,alpha,delta,51,1);
761 ChurnKey(crypt_key[-6],gamma,beta,epsilon,52,2);
762 ChurnKey(crypt_key[-5],delta,gamma,alpha,53,3);
763 ChurnKey(crypt_key[-4],epsilon,delta,beta,54,4);
764 ChurnKey(crypt_key[-3],alpha,epsilon,gamma,55,5);
765 ChurnKey(crypt_key[-2],beta,alpha,delta,56,6);
766 ChurnKey(crypt_key[-1],gamma,beta,epsilon,57,7);
767 ChurnKey(crypt_key[0],delta,gamma,alpha,58,8);
768 ChurnKey(crypt_key[1],epsilon,delta,beta,59,9);
769 ChurnKey(crypt_key[2],alpha,epsilon,gamma,60,10);
770 ChurnKey(crypt_key[3],beta,alpha,delta,61,11);
771 ChurnKey(crypt_key[4],gamma,beta,epsilon,62,12);
772 ChurnKey(crypt_key[5],delta,gamma,alpha,63,13);
773 ChurnKey(crypt_key[6],epsilon,delta,beta,64,14);
774 ChurnKey(crypt_key[7],alpha,epsilon,gamma,65,15);
775 ChurnKey(crypt_key[8],beta,alpha,delta,66,16);
776 ChurnKey(crypt_key[9],gamma,beta,epsilon,67,17);
777 ChurnKey(crypt_key[10],delta,gamma,alpha,68,18);
778 ChurnKey(crypt_key[11],epsilon,delta,beta,69,19);
779 ChurnKey(crypt_key[12],alpha,epsilon,gamma,70,20);
780 ChurnKey(crypt_key[13],beta,alpha,delta,71,21);
781 ChurnKey(crypt_key[14],gamma,beta,epsilon,72,22);
782 ChurnKey(crypt_key[15],delta,gamma,alpha,73,23);
783 ChurnKey(crypt_key[16],epsilon,delta,beta,74,24);
784 ChurnKey(crypt_key[17],alpha,epsilon,gamma,75,25);
785 ChurnKey(crypt_key[18],beta,alpha,delta,76,26);
786 ChurnKey(crypt_key[19],gamma,beta,epsilon,77,27);
787 ChurnKey(crypt_key[20],delta,gamma,alpha,78,28);
788 ChurnKey(crypt_key[21],epsilon,delta,beta,79,29);
789 ChurnKey(crypt_key[22],alpha,epsilon,gamma,80,30);
790 ChurnKey(crypt_key[23],beta,alpha,delta,81,31);
791 crypt_key+=50;
792 ChurnKey(crypt_key[-26],gamma,beta,epsilon,82,-18);
793 ChurnKey(crypt_key[-25],delta,gamma,alpha,83,-17);
794 ChurnKey(crypt_key[-24],epsilon,delta,beta,84,-16);
795 ChurnKey(crypt_key[-23],alpha,epsilon,gamma,85,-15);
796 ChurnKey(crypt_key[-22],beta,alpha,delta,86,-14);
797 ChurnKey(crypt_key[-21],gamma,beta,epsilon,87,-13);
798 ChurnKey(crypt_key[-20],delta,gamma,alpha,88,-12);
799 ChurnKey(crypt_key[-19],epsilon,delta,beta,89,-11);
800 ChurnKey(crypt_key[-18],alpha,epsilon,gamma,90,-10);
801 ChurnKey(crypt_key[-17],beta,alpha,delta,91,-9);
802 ChurnKey(crypt_key[-16],gamma,beta,epsilon,92,-8);
803 ChurnKey(crypt_key[-15],delta,gamma,alpha,93,-7);
804 ChurnKey(crypt_key[-14],epsilon,delta,beta,94,-6);
805 ChurnKey(crypt_key[-13],alpha,epsilon,gamma,95,-5);
806 ChurnKey(crypt_key[-12],beta,alpha,delta,96,-4);
807 ChurnKey(crypt_key[-11],gamma,beta,epsilon,97,-3);
808 ChurnKey(crypt_key[-10],delta,gamma,alpha,98,-2);
809 ChurnKey(crypt_key[-9],epsilon,delta,beta,99,-1);
810 ChurnKey(crypt_key[-8],alpha,epsilon,gamma,100,0);
811 ChurnKey(crypt_key[-7],beta,alpha,delta,101,1);
812 ChurnKey(crypt_key[-6],gamma,beta,epsilon,102,2);
813 ChurnKey(crypt_key[-5],delta,gamma,alpha,103,3);
814 ChurnKey(crypt_key[-4],epsilon,delta,beta,104,4);
815 ChurnKey(crypt_key[-3],alpha,epsilon,gamma,105,5);
816 ChurnKey(crypt_key[-2],beta,alpha,delta,106,6);
817 ChurnKey(crypt_key[-1],gamma,beta,epsilon,107,7);
818 ChurnKey(crypt_key[0],delta,gamma,alpha,108,8);
819 ChurnKey(crypt_key[1],epsilon,delta,beta,109,9);
820 ChurnKey(crypt_key[2],alpha,epsilon,gamma,110,10);
821 ChurnKey(crypt_key[3],beta,alpha,delta,111,11);
822 ChurnKey(crypt_key[4],gamma,beta,epsilon,112,12);
823 ChurnKey(crypt_key[5],delta,gamma,alpha,113,13);
824 ChurnKey(crypt_key[6],epsilon,delta,beta,114,14);
825 ChurnKey(crypt_key[7],alpha,epsilon,gamma,115,15);
826 ChurnKey(crypt_key[8],beta,alpha,delta,116,16);
827 ChurnKey(crypt_key[9],gamma,beta,epsilon,117,17);
828 ChurnKey(crypt_key[10],delta,gamma,alpha,118,18);
829 ChurnKey(crypt_key[11],epsilon,delta,beta,119,19);
830 ChurnKey(crypt_key[12],alpha,epsilon,gamma,120,20);
831 ChurnKey(crypt_key[13],beta,alpha,delta,121,21);
832 ChurnKey(crypt_key[14],gamma,beta,epsilon,122,22);
833 ChurnKey(crypt_key[15],delta,gamma,alpha,123,23);
834 ChurnKey(crypt_key[16],epsilon,delta,beta,124,24);
835 ChurnKey(crypt_key[17],alpha,epsilon,gamma,125,25);
836 ChurnKey(crypt_key[18],beta,alpha,delta,126,26);
837 ChurnKey(crypt_key[19],gamma,beta,epsilon,127,27);
838 ChurnKey(crypt_key[20],delta,gamma,alpha,128,28);
839 ChurnKey(crypt_key[21],epsilon,delta,beta,129,29);
840 ChurnKey(crypt_key[22],alpha,epsilon,gamma,130,30);
841 ChurnKey(crypt_key[23],beta,alpha,delta,131,31);
842 /*
843 Apply S-boxes.
844 */
845 EncipherSbox3(delta,epsilon,alpha,beta,gamma);
846 StoreKey(beta,gamma,epsilon,delta,28);
847 LoadKey(beta,gamma,epsilon,delta,24);
848 EncipherSbox4(beta,gamma,epsilon,delta,alpha);
849 StoreKey(gamma,epsilon,delta,alpha,24);
850 LoadKey(gamma,epsilon,delta,alpha,20);
851 EncipherSbox5(gamma,epsilon,delta,alpha,beta);
852 StoreKey(beta,gamma,epsilon,alpha,20);
853 LoadKey(beta,gamma,epsilon,alpha,16);
854 EncipherSbox6(beta,gamma,epsilon,alpha,delta);
855 StoreKey(epsilon,delta,gamma,alpha,16);
856 LoadKey(epsilon,delta,gamma,alpha,12);
857 EncipherSbox7(epsilon,delta,gamma,alpha,beta);
858 StoreKey(beta,gamma,alpha,epsilon,12);
859 LoadKey(beta,gamma,alpha,epsilon,8);
860 EncipherSbox0(beta,gamma,alpha,epsilon,delta);
861 StoreKey(alpha,gamma,epsilon,beta,8);
862 LoadKey(alpha,gamma,epsilon,beta,4);
863 EncipherSbox1(alpha,gamma,epsilon,beta,delta);
864 StoreKey(delta,epsilon,beta,alpha,4);
865 LoadKey(delta,epsilon,beta,alpha,0);
866 EncipherSbox2(delta,epsilon,beta,alpha,gamma);
867 StoreKey(gamma,epsilon,delta,alpha,0);
868 LoadKey(gamma,epsilon,delta,alpha,-4);
869 EncipherSbox3(gamma,epsilon,delta,alpha,beta);
870 StoreKey(alpha,beta,epsilon,gamma,-4);
871 LoadKey(alpha,beta,epsilon,gamma,-8);
872 EncipherSbox4(alpha,beta,epsilon,gamma,delta);
873 StoreKey(beta,epsilon,gamma,delta,-8);
874 LoadKey(beta,epsilon,gamma,delta,-12);
875 EncipherSbox5(beta,epsilon,gamma,delta,alpha);
876 StoreKey(alpha,beta,epsilon,delta,-12);
877 LoadKey(alpha,beta,epsilon,delta,-16);
878 EncipherSbox6(alpha,beta,epsilon,delta,gamma);
879 StoreKey(epsilon,gamma,beta,delta,-16);
880 LoadKey(epsilon,gamma,beta,delta,-20);
881 EncipherSbox7(epsilon,gamma,beta,delta,alpha);
882 StoreKey(alpha,beta,delta,epsilon,-20);
883 LoadKey(alpha,beta,delta,epsilon,-24);
884 EncipherSbox0(alpha,beta,delta,epsilon,gamma);
885 StoreKey(delta,beta,epsilon,alpha,-24);
886 LoadKey(delta,beta,epsilon,alpha,-28);
887 crypt_key-=50;
888 EncipherSbox1(delta,beta,epsilon,alpha,gamma);
889 StoreKey(gamma,epsilon,alpha,delta,22);
890 LoadKey(gamma,epsilon,alpha,delta,18);
891 EncipherSbox2(gamma,epsilon,alpha,delta,beta);
892 StoreKey(beta,epsilon,gamma,delta,18);
893 LoadKey(beta,epsilon,gamma,delta,14);
894 EncipherSbox3(beta,epsilon,gamma,delta,alpha);
895 StoreKey(delta,alpha,epsilon,beta,14);
896 LoadKey(delta,alpha,epsilon,beta,10);
897 EncipherSbox4(delta,alpha,epsilon,beta,gamma);
898 StoreKey(alpha,epsilon,beta,gamma,10);
899 LoadKey(alpha,epsilon,beta,gamma,6);
900 EncipherSbox5(alpha,epsilon,beta,gamma,delta);
901 StoreKey(delta,alpha,epsilon,gamma,6);
902 LoadKey(delta,alpha,epsilon,gamma,2);
903 EncipherSbox6(delta,alpha,epsilon,gamma,beta);
904 StoreKey(epsilon,beta,alpha,gamma,2);
905 LoadKey(epsilon,beta,alpha,gamma,-2);
906 EncipherSbox7(epsilon,beta,alpha,gamma,delta);
907 StoreKey(delta,alpha,gamma,epsilon,-2);
908 LoadKey(delta,alpha,gamma,epsilon,-6);
909 EncipherSbox0(delta,alpha,gamma,epsilon,beta);
910 StoreKey(gamma,alpha,epsilon,delta,-6);
911 LoadKey(gamma,alpha,epsilon,delta,-10);
912 EncipherSbox1(gamma,alpha,epsilon,delta,beta);
913 StoreKey(beta,epsilon,delta,gamma,-10);
914 LoadKey(beta,epsilon,delta,gamma,-14);
915 EncipherSbox2(beta,epsilon,delta,gamma,alpha);
916 StoreKey(alpha,epsilon,beta,gamma,-14);
917 LoadKey(alpha,epsilon,beta,gamma,-18);
918 EncipherSbox3(alpha,epsilon,beta,gamma,delta);
919 StoreKey(gamma,delta,epsilon,alpha,-18);
920 LoadKey(gamma,delta,epsilon,alpha,-22);
921 crypt_key-=50;
922 EncipherSbox4(gamma,delta,epsilon,alpha,beta);
923 StoreKey(delta,epsilon,alpha,beta,28);
924 LoadKey(delta,epsilon,alpha,beta,24);
925 EncipherSbox5(delta,epsilon,alpha,beta,gamma);
926 StoreKey(gamma,delta,epsilon,beta,24);
927 LoadKey(gamma,delta,epsilon,beta,20);
928 EncipherSbox6(gamma,delta,epsilon,beta,alpha);
929 StoreKey(epsilon,alpha,delta,beta,20);
930 LoadKey(epsilon,alpha,delta,beta,16);
931 EncipherSbox7(epsilon,alpha,delta,beta,gamma);
932 StoreKey(gamma,delta,beta,epsilon,16);
933 LoadKey(gamma,delta,beta,epsilon,12);
934 EncipherSbox0(gamma,delta,beta,epsilon,alpha);
935 StoreKey(beta,delta,epsilon,gamma,12);
936 LoadKey(beta,delta,epsilon,gamma,8);
937 EncipherSbox1(beta,delta,epsilon,gamma,alpha);
938 StoreKey(alpha,epsilon,gamma,beta,8);
939 LoadKey(alpha,epsilon,gamma,beta,4);
940 EncipherSbox2(alpha,epsilon,gamma,beta,delta);
941 StoreKey(delta,epsilon,alpha,beta,4);
942 LoadKey(delta,epsilon,alpha,beta,0);
943 EncipherSbox3(delta,epsilon,alpha,beta,gamma);
944 StoreKey(beta,gamma,epsilon,delta,0);
945 /*
946 Reset registers.
947 */
948 alpha=0;
949 beta=0;
950 gamma=0;
951 delta=0;
952 epsilon=0;
953 rho=0;
954}
WizardAssert
#define WizardAssert(domain, predicate)
Definition exception-private.h:46
ThrowWizardFatalError
#define ThrowWizardFatalError(domain, error)
Definition exception-private.h:64
CipherDomain
@ CipherDomain
Definition exception.h:34
CipherError
@ CipherError
Definition exception.h:89
MemoryError
@ MemoryError
Definition exception.h:49
LogWizardEvent
WizardBooleanType LogWizardEvent(const LogEventType type, const char *module, const char *function, const size_t line, const char *format,...)
Definition log.c:1390
TraceEvent
@ TraceEvent
Definition log.h:39
GetWizardModule
#define GetWizardModule()
Definition log.h:30
AcquireWizardMemory
WizardExport void * AcquireWizardMemory(const size_t size)
Definition memory.c:586
RelinquishWizardMemory
WizardExport void * RelinquishWizardMemory(void *memory)
Definition memory.c:1039
memory_.h
WizardExport
#define WizardExport
Definition method-attribute.h:98
WizardSignature
#define WizardSignature
Definition method-attribute.h:104
EncipherSbox6
#define EncipherSbox6(alpha, beta, gamma, delta, epsilon)
Write32Bits
#define Write32Bits(p, value)
Definition serpent.c:74
EncipherSbox4
#define EncipherSbox4(alpha, beta, gamma, delta, epsilon)
EncipherSbox5
#define EncipherSbox5(alpha, beta, gamma, delta, epsilon)
DecipherSbox5
#define DecipherSbox5(alpha, beta, gamma, delta, epsilon)
DecipherSbox6
#define DecipherSbox6(alpha, beta, gamma, delta, epsilon)
DecipherSerpentBlock
WizardExport void DecipherSerpentBlock(SerpentInfo *serpent_info, const unsigned char *ciphertext, unsigned char *plaintext)
Definition serpent.c:154
EncipherSbox3
#define EncipherSbox3(alpha, beta, gamma, delta, epsilon)
DecipherSbox0
#define DecipherSbox0(alpha, beta, gamma, delta, epsilon)
EncipherK
#define EncipherK(alpha, beta, gamma, delta, epsilon, i)
DecipherSbox4
#define DecipherSbox4(alpha, beta, gamma, delta, epsilon)
DecipherSbox3
#define DecipherSbox3(alpha, beta, gamma, delta, epsilon)
StoreKey
#define StoreKey(alpha, beta, gamma, delta, i)
EncipherSerpentBlock
WizardExport void EncipherSerpentBlock(SerpentInfo *serpent_info, const unsigned char *plaintext, unsigned char *ciphertext)
Definition serpent.c:403
MixKey
#define MixKey(alpha, beta, gamma, delta, i)
EncipherSbox7
#define EncipherSbox7(alpha, beta, gamma, delta, epsilon)
AcquireSerpentInfo
WizardExport SerpentInfo * AcquireSerpentInfo(void)
Definition serpent.c:100
DecipherSbox7
#define DecipherSbox7(alpha, beta, gamma, delta, epsilon)
EncipherSbox1
#define EncipherSbox1(alpha, beta, gamma, delta, epsilon)
EncipherSbox0
#define EncipherSbox0(alpha, beta, gamma, delta, epsilon)
SetSerpentKey
WizardExport void SetSerpentKey(SerpentInfo *serpent_info, const StringInfo *key)
Definition serpent.c:637
GetSerpentBlocksize
WizardExport unsigned int GetSerpentBlocksize(const SerpentInfo *serpent_info)
Definition serpent.c:603
DecipherSbox2
#define DecipherSbox2(alpha, beta, gamma, delta, epsilon)
MaximumSerpentKeyLength
#define MaximumSerpentKeyLength
EncipherSbox2
#define EncipherSbox2(alpha, beta, gamma, delta, epsilon)
ChurnKey
#define ChurnKey(alpha, beta, gamma, delta, i, j)
LoadKey
#define LoadKey(alpha, beta, gamma, delta, i)
DestroySerpentInfo
WizardExport SerpentInfo * DestroySerpentInfo(SerpentInfo *serpent_info)
Definition serpent.c:359
DecipherSbox1
#define DecipherSbox1(alpha, beta, gamma, delta, epsilon)
DecipherK
#define DecipherK(alpha, beta, gamma, delta, epsilon, i)
SerpentBlocksize
#define SerpentBlocksize
Definition serpent.c:73
Read32Bits
#define Read32Bits(value, p)
Definition serpent.c:66
RotateLeft
static unsigned int RotateLeft(unsigned int x, unsigned int n)
Definition serpent.c:398
Trunc32
#define Trunc32(x)
Definition signature.c:52
RotateRight
#define RotateRight(x, n)
GetStringInfoLength
WizardExport size_t GetStringInfoLength(const StringInfo *string_info)
Definition string.c:1280
GetStringInfoDatum
WizardExport unsigned char * GetStringInfoDatum(const StringInfo *string_info)
Definition string.c:1251
_SerpentInfo
Definition serpent.c:51
_SerpentInfo::signature
size_t signature
Definition serpent.c:60
_SerpentInfo::blocksize
unsigned int blocksize
Definition serpent.c:53
_SerpentInfo::crypt_key
unsigned int crypt_key[132]
Definition serpent.c:54
_SerpentInfo::timestamp
time_t timestamp
Definition serpent.c:57
_StringInfo
Definition string.c:58
Min
#define Min(x, y)
Definition studio.h:307