~ubuntu-branches/debian/sid/botan/sid

« back to all changes in this revision

Viewing changes to modules/alg_ia32/serp_asm.S

  • Committer: Package Import Robot
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2018-03-01 22:23:25 UTC
  • mfrom: (1.2.2)
  • Revision ID: package-import@ubuntu.com-20180301222325-7p7vc45gu3hta34d
Tags: 2.4.0-2
* Don't remove .doctrees from the manual if it doesn't exist.
* Don't specify parallel to debhelper.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*************************************************
2
 
* Serpent Source File                            *
3
 
* (C) 1999-2007 The Botan Project                *
4
 
*************************************************/
5
 
 
6
 
#include <botan/asm_macr.h>
7
 
 
8
 
START_LISTING(serp_asm.S)
9
 
 
10
 
#define SBOX_E1(A, B, C, D, T)     \
11
 
   XOR(D, A)                     ; \
12
 
   ASSIGN(T, B)                  ; \
13
 
   AND(B, D)                     ; \
14
 
   XOR(T, C)                     ; \
15
 
   XOR(B, A)                     ; \
16
 
   OR(A, D)                      ; \
17
 
   XOR(A, T)                     ; \
18
 
   XOR(T, D)                     ; \
19
 
   XOR(D, C)                     ; \
20
 
   OR(C, B)                      ; \
21
 
   XOR(C, T)                     ; \
22
 
   NOT(T)                        ; \
23
 
   OR(T, B)                      ; \
24
 
   XOR(B, D)                     ; \
25
 
   XOR(B, T)                     ; \
26
 
   OR(D, A)                      ; \
27
 
   XOR(B, D)                     ; \
28
 
   XOR(T, D)                     ; \
29
 
   ASSIGN(D, A)                  ; \
30
 
   ASSIGN(A, B)                  ; \
31
 
   ASSIGN(B, T)                  ;
32
 
 
33
 
#define SBOX_E2(A, B, C, D, T)     \
34
 
   NOT(A)                        ; \
35
 
   NOT(C)                        ; \
36
 
   ASSIGN(T, A)                  ; \
37
 
   AND(A, B)                     ; \
38
 
   XOR(C, A)                     ; \
39
 
   OR(A, D)                      ; \
40
 
   XOR(D, C)                     ; \
41
 
   XOR(B, A)                     ; \
42
 
   XOR(A, T)                     ; \
43
 
   OR(T, B)                      ; \
44
 
   XOR(B, D)                     ; \
45
 
   OR(C, A)                      ; \
46
 
   AND(C, T)                     ; \
47
 
   XOR(A, B)                     ; \
48
 
   AND(B, C)                     ; \
49
 
   XOR(B, A)                     ; \
50
 
   AND(A, C)                     ; \
51
 
   XOR(T, A)                     ; \
52
 
   ASSIGN(A, C)                  ; \
53
 
   ASSIGN(C, D)                  ; \
54
 
   ASSIGN(D, B)                  ; \
55
 
   ASSIGN(B, T)                  ;
56
 
 
57
 
#define SBOX_E3(A, B, C, D, T)     \
58
 
   ASSIGN(T, A)                  ; \
59
 
   AND(A, C)                     ; \
60
 
   XOR(A, D)                     ; \
61
 
   XOR(C, B)                     ; \
62
 
   XOR(C, A)                     ; \
63
 
   OR(D, T)                      ; \
64
 
   XOR(D, B)                     ; \
65
 
   XOR(T, C)                     ; \
66
 
   ASSIGN(B, D)                  ; \
67
 
   OR(D, T)                      ; \
68
 
   XOR(D, A)                     ; \
69
 
   AND(A, B)                     ; \
70
 
   XOR(T, A)                     ; \
71
 
   XOR(B, D)                     ; \
72
 
   XOR(B, T)                     ; \
73
 
   NOT(T)                        ; \
74
 
   ASSIGN(A, C)                  ; \
75
 
   ASSIGN(C, B)                  ; \
76
 
   ASSIGN(B, D)                  ; \
77
 
   ASSIGN(D, T)                  ;
78
 
 
79
 
#define SBOX_E4(A, B, C, D, T)     \
80
 
   ASSIGN(T, A)                  ; \
81
 
   OR(A, D)                      ; \
82
 
   XOR(D, B)                     ; \
83
 
   AND(B, T)                     ; \
84
 
   XOR(T, C)                     ; \
85
 
   XOR(C, D)                     ; \
86
 
   AND(D, A)                     ; \
87
 
   OR(T, B)                      ; \
88
 
   XOR(D, T)                     ; \
89
 
   XOR(A, B)                     ; \
90
 
   AND(T, A)                     ; \
91
 
   XOR(B, D)                     ; \
92
 
   XOR(T, C)                     ; \
93
 
   OR(B, A)                      ; \
94
 
   XOR(B, C)                     ; \
95
 
   XOR(A, D)                     ; \
96
 
   ASSIGN(C, B)                  ; \
97
 
   OR(B, D)                      ; \
98
 
   XOR(B, A)                     ; \
99
 
   ASSIGN(A, B)                  ; \
100
 
   ASSIGN(B, C)                  ; \
101
 
   ASSIGN(C, D)                  ; \
102
 
   ASSIGN(D, T)                  ;
103
 
 
104
 
#define SBOX_E5(A, B, C, D, T)     \
105
 
   XOR(B, D)                     ; \
106
 
   NOT(D)                        ; \
107
 
   XOR(C, D)                     ; \
108
 
   XOR(D, A)                     ; \
109
 
   ASSIGN(T, B)                  ; \
110
 
   AND(B, D)                     ; \
111
 
   XOR(B, C)                     ; \
112
 
   XOR(T, D)                     ; \
113
 
   XOR(A, T)                     ; \
114
 
   AND(C, T)                     ; \
115
 
   XOR(C, A)                     ; \
116
 
   AND(A, B)                     ; \
117
 
   XOR(D, A)                     ; \
118
 
   OR(T, B)                      ; \
119
 
   XOR(T, A)                     ; \
120
 
   OR(A, D)                      ; \
121
 
   XOR(A, C)                     ; \
122
 
   AND(C, D)                     ; \
123
 
   NOT(A)                        ; \
124
 
   XOR(T, C)                     ; \
125
 
   ASSIGN(C, A)                  ; \
126
 
   ASSIGN(A, B)                  ; \
127
 
   ASSIGN(B, T)                  ;
128
 
 
129
 
#define SBOX_E6(A, B, C, D, T)     \
130
 
   XOR(A, B)                     ; \
131
 
   XOR(B, D)                     ; \
132
 
   NOT(D)                        ; \
133
 
   ASSIGN(T, B)                  ; \
134
 
   AND(B, A)                     ; \
135
 
   XOR(C, D)                     ; \
136
 
   XOR(B, C)                     ; \
137
 
   OR(C, T)                      ; \
138
 
   XOR(T, D)                     ; \
139
 
   AND(D, B)                     ; \
140
 
   XOR(D, A)                     ; \
141
 
   XOR(T, B)                     ; \
142
 
   XOR(T, C)                     ; \
143
 
   XOR(C, A)                     ; \
144
 
   AND(A, D)                     ; \
145
 
   NOT(C)                        ; \
146
 
   XOR(A, T)                     ; \
147
 
   OR(T, D)                      ; \
148
 
   XOR(T, C)                     ; \
149
 
   ASSIGN(C, A)                  ; \
150
 
   ASSIGN(A, B)                  ; \
151
 
   ASSIGN(B, D)                  ; \
152
 
   ASSIGN(D, T)                  ;
153
 
 
154
 
#define SBOX_E7(A, B, C, D, T)     \
155
 
   NOT(C)                        ; \
156
 
   ASSIGN(T, D)                  ; \
157
 
   AND(D, A)                     ; \
158
 
   XOR(A, T)                     ; \
159
 
   XOR(D, C)                     ; \
160
 
   OR(C, T)                      ; \
161
 
   XOR(B, D)                     ; \
162
 
   XOR(C, A)                     ; \
163
 
   OR(A, B)                      ; \
164
 
   XOR(C, B)                     ; \
165
 
   XOR(T, A)                     ; \
166
 
   OR(A, D)                      ; \
167
 
   XOR(A, C)                     ; \
168
 
   XOR(T, D)                     ; \
169
 
   XOR(T, A)                     ; \
170
 
   NOT(D)                        ; \
171
 
   AND(C, T)                     ; \
172
 
   XOR(C, D)                     ; \
173
 
   ASSIGN(D, C)                  ; \
174
 
   ASSIGN(C, T)                  ;
175
 
 
176
 
#define SBOX_E8(A, B, C, D, T)     \
177
 
   ASSIGN(T, B)                  ; \
178
 
   OR(B, C)                      ; \
179
 
   XOR(B, D)                     ; \
180
 
   XOR(T, C)                     ; \
181
 
   XOR(C, B)                     ; \
182
 
   OR(D, T)                      ; \
183
 
   AND(D, A)                     ; \
184
 
   XOR(T, C)                     ; \
185
 
   XOR(D, B)                     ; \
186
 
   OR(B, T)                      ; \
187
 
   XOR(B, A)                     ; \
188
 
   OR(A, T)                      ; \
189
 
   XOR(A, C)                     ; \
190
 
   XOR(B, T)                     ; \
191
 
   XOR(C, B)                     ; \
192
 
   AND(B, A)                     ; \
193
 
   XOR(B, T)                     ; \
194
 
   NOT(C)                        ; \
195
 
   OR(C, A)                      ; \
196
 
   XOR(T, C)                     ; \
197
 
   ASSIGN(C, B)                  ; \
198
 
   ASSIGN(B, D)                  ; \
199
 
   ASSIGN(D, A)                  ; \
200
 
   ASSIGN(A, T)                  ;
201
 
 
202
 
#define SBOX_D1(A, B, C, D, T)     \
203
 
   NOT(C)                        ; \
204
 
   ASSIGN(T, B)                  ; \
205
 
   OR(B, A)                      ; \
206
 
   NOT(T)                        ; \
207
 
   XOR(B, C)                     ; \
208
 
   OR(C, T)                      ; \
209
 
   XOR(B, D)                     ; \
210
 
   XOR(A, T)                     ; \
211
 
   XOR(C, A)                     ; \
212
 
   AND(A, D)                     ; \
213
 
   XOR(T, A)                     ; \
214
 
   OR(A, B)                      ; \
215
 
   XOR(A, C)                     ; \
216
 
   XOR(D, T)                     ; \
217
 
   XOR(C, B)                     ; \
218
 
   XOR(D, A)                     ; \
219
 
   XOR(D, B)                     ; \
220
 
   AND(C, D)                     ; \
221
 
   XOR(T, C)                     ; \
222
 
   ASSIGN(C, B)                  ; \
223
 
   ASSIGN(B, T)                  ;
224
 
 
225
 
#define SBOX_D2(A, B, C, D, T)     \
226
 
   ASSIGN(T, B)                  ; \
227
 
   XOR(B, D)                     ; \
228
 
   AND(D, B)                     ; \
229
 
   XOR(T, C)                     ; \
230
 
   XOR(D, A)                     ; \
231
 
   OR(A, B)                      ; \
232
 
   XOR(C, D)                     ; \
233
 
   XOR(A, T)                     ; \
234
 
   OR(A, C)                      ; \
235
 
   XOR(B, D)                     ; \
236
 
   XOR(A, B)                     ; \
237
 
   OR(B, D)                      ; \
238
 
   XOR(B, A)                     ; \
239
 
   NOT(T)                        ; \
240
 
   XOR(T, B)                     ; \
241
 
   OR(B, A)                      ; \
242
 
   XOR(B, A)                     ; \
243
 
   OR(B, T)                      ; \
244
 
   XOR(D, B)                     ; \
245
 
   ASSIGN(B, A)                  ; \
246
 
   ASSIGN(A, T)                  ; \
247
 
   ASSIGN(T, D)                  ; \
248
 
   ASSIGN(D, C)                  ; \
249
 
   ASSIGN(C, T)                  ;
250
 
 
251
 
#define SBOX_D3(A, B, C, D, T)     \
252
 
   XOR(C, D)                     ; \
253
 
   XOR(D, A)                     ; \
254
 
   ASSIGN(T, D)                  ; \
255
 
   AND(D, C)                     ; \
256
 
   XOR(D, B)                     ; \
257
 
   OR(B, C)                      ; \
258
 
   XOR(B, T)                     ; \
259
 
   AND(T, D)                     ; \
260
 
   XOR(C, D)                     ; \
261
 
   AND(T, A)                     ; \
262
 
   XOR(T, C)                     ; \
263
 
   AND(C, B)                     ; \
264
 
   OR(C, A)                      ; \
265
 
   NOT(D)                        ; \
266
 
   XOR(C, D)                     ; \
267
 
   XOR(A, D)                     ; \
268
 
   AND(A, B)                     ; \
269
 
   XOR(D, T)                     ; \
270
 
   XOR(D, A)                     ; \
271
 
   ASSIGN(A, B)                  ; \
272
 
   ASSIGN(B, T)                  ;
273
 
 
274
 
#define SBOX_D4(A, B, C, D, T)     \
275
 
   ASSIGN(T, C)                  ; \
276
 
   XOR(C, B)                     ; \
277
 
   XOR(A, C)                     ; \
278
 
   AND(T, C)                     ; \
279
 
   XOR(T, A)                     ; \
280
 
   AND(A, B)                     ; \
281
 
   XOR(B, D)                     ; \
282
 
   OR(D, T)                      ; \
283
 
   XOR(C, D)                     ; \
284
 
   XOR(A, D)                     ; \
285
 
   XOR(B, T)                     ; \
286
 
   AND(D, C)                     ; \
287
 
   XOR(D, B)                     ; \
288
 
   XOR(B, A)                     ; \
289
 
   OR(B, C)                      ; \
290
 
   XOR(A, D)                     ; \
291
 
   XOR(B, T)                     ; \
292
 
   XOR(A, B)                     ; \
293
 
   ASSIGN(T, A)                  ; \
294
 
   ASSIGN(A, C)                  ; \
295
 
   ASSIGN(C, D)                  ; \
296
 
   ASSIGN(D, T)                  ;
297
 
 
298
 
#define SBOX_D5(A, B, C, D, T)     \
299
 
   ASSIGN(T, C)                  ; \
300
 
   AND(C, D)                     ; \
301
 
   XOR(C, B)                     ; \
302
 
   OR(B, D)                      ; \
303
 
   AND(B, A)                     ; \
304
 
   XOR(T, C)                     ; \
305
 
   XOR(T, B)                     ; \
306
 
   AND(B, C)                     ; \
307
 
   NOT(A)                        ; \
308
 
   XOR(D, T)                     ; \
309
 
   XOR(B, D)                     ; \
310
 
   AND(D, A)                     ; \
311
 
   XOR(D, C)                     ; \
312
 
   XOR(A, B)                     ; \
313
 
   AND(C, A)                     ; \
314
 
   XOR(D, A)                     ; \
315
 
   XOR(C, T)                     ; \
316
 
   OR(C, D)                      ; \
317
 
   XOR(D, A)                     ; \
318
 
   XOR(C, B)                     ; \
319
 
   ASSIGN(B, D)                  ; \
320
 
   ASSIGN(D, T)                  ;
321
 
 
322
 
#define SBOX_D6(A, B, C, D, T)     \
323
 
   NOT(B)                        ; \
324
 
   ASSIGN(T, D)                  ; \
325
 
   XOR(C, B)                     ; \
326
 
   OR(D, A)                      ; \
327
 
   XOR(D, C)                     ; \
328
 
   OR(C, B)                      ; \
329
 
   AND(C, A)                     ; \
330
 
   XOR(T, D)                     ; \
331
 
   XOR(C, T)                     ; \
332
 
   OR(T, A)                      ; \
333
 
   XOR(T, B)                     ; \
334
 
   AND(B, C)                     ; \
335
 
   XOR(B, D)                     ; \
336
 
   XOR(T, C)                     ; \
337
 
   AND(D, T)                     ; \
338
 
   XOR(T, B)                     ; \
339
 
   XOR(D, T)                     ; \
340
 
   NOT(T)                        ; \
341
 
   XOR(D, A)                     ; \
342
 
   ASSIGN(A, B)                  ; \
343
 
   ASSIGN(B, T)                  ; \
344
 
   ASSIGN(T, D)                  ; \
345
 
   ASSIGN(D, C)                  ; \
346
 
   ASSIGN(C, T)                  ;
347
 
 
348
 
#define SBOX_D7(A, B, C, D, T)     \
349
 
   XOR(A, C)                     ; \
350
 
   ASSIGN(T, C)                  ; \
351
 
   AND(C, A)                     ; \
352
 
   XOR(T, D)                     ; \
353
 
   NOT(C)                        ; \
354
 
   XOR(D, B)                     ; \
355
 
   XOR(C, D)                     ; \
356
 
   OR(T, A)                      ; \
357
 
   XOR(A, C)                     ; \
358
 
   XOR(D, T)                     ; \
359
 
   XOR(T, B)                     ; \
360
 
   AND(B, D)                     ; \
361
 
   XOR(B, A)                     ; \
362
 
   XOR(A, D)                     ; \
363
 
   OR(A, C)                      ; \
364
 
   XOR(D, B)                     ; \
365
 
   XOR(T, A)                     ; \
366
 
   ASSIGN(A, B)                  ; \
367
 
   ASSIGN(B, C)                  ; \
368
 
   ASSIGN(C, T)                  ;
369
 
 
370
 
#define SBOX_D8(A, B, C, D, T)     \
371
 
   ASSIGN(T, C)                  ; \
372
 
   XOR(C, A)                     ; \
373
 
   AND(A, D)                     ; \
374
 
   OR(T, D)                      ; \
375
 
   NOT(C)                        ; \
376
 
   XOR(D, B)                     ; \
377
 
   OR(B, A)                      ; \
378
 
   XOR(A, C)                     ; \
379
 
   AND(C, T)                     ; \
380
 
   AND(D, T)                     ; \
381
 
   XOR(B, C)                     ; \
382
 
   XOR(C, A)                     ; \
383
 
   OR(A, C)                      ; \
384
 
   XOR(T, B)                     ; \
385
 
   XOR(A, D)                     ; \
386
 
   XOR(D, T)                     ; \
387
 
   OR(T, A)                      ; \
388
 
   XOR(D, C)                     ; \
389
 
   XOR(T, C)                     ; \
390
 
   ASSIGN(C, B)                  ; \
391
 
   ASSIGN(B, A)                  ; \
392
 
   ASSIGN(A, D)                  ; \
393
 
   ASSIGN(D, T)                  ;
394
 
 
395
 
#define TRANSFORM(A, B, C, D, T)   \
396
 
   ROTL_IMM(A, 13)               ; \
397
 
   ROTL_IMM(C, 3)                ; \
398
 
   SHL2_3(T, A)                  ; \
399
 
   XOR(B, A)                     ; \
400
 
   XOR(D, C)                     ; \
401
 
   XOR(B, C)                     ; \
402
 
   XOR(D, T)                     ; \
403
 
   ROTL_IMM(B, 1)                ; \
404
 
   ROTL_IMM(D, 7)                ; \
405
 
   ASSIGN(T, B)                  ; \
406
 
   SHL_IMM(T, 7)                 ; \
407
 
   XOR(A, B)                     ; \
408
 
   XOR(C, D)                     ; \
409
 
   XOR(A, D)                     ; \
410
 
   XOR(C, T)                     ; \
411
 
   ROTL_IMM(A, 5)                ; \
412
 
   ROTL_IMM(C, 22)               ;
413
 
 
414
 
#define I_TRANSFORM(A, B, C, D, T) \
415
 
   ROTR_IMM(C, 22)               ; \
416
 
   ROTR_IMM(A, 5)                ; \
417
 
   ASSIGN(T, B)                  ; \
418
 
   SHL_IMM(T, 7)                 ; \
419
 
   XOR(A, B)                     ; \
420
 
   XOR(C, D)                     ; \
421
 
   XOR(A, D)                     ; \
422
 
   XOR(C, T)                     ; \
423
 
   ROTR_IMM(D, 7)                ; \
424
 
   ROTR_IMM(B, 1)                ; \
425
 
   SHL2_3(T, A)                  ; \
426
 
   XOR(B, C)                     ; \
427
 
   XOR(D, C)                     ; \
428
 
   XOR(B, A)                     ; \
429
 
   XOR(D, T)                     ; \
430
 
   ROTR_IMM(C, 3)                ; \
431
 
   ROTR_IMM(A, 13)               ;
432
 
 
433
 
#define KEY_XOR(A, B, C, D, N)     \
434
 
   XOR(A, ARRAY4(EDI, (4*N  )))  ; \
435
 
   XOR(B, ARRAY4(EDI, (4*N+1)))  ; \
436
 
   XOR(C, ARRAY4(EDI, (4*N+2)))  ; \
437
 
   XOR(D, ARRAY4(EDI, (4*N+3)))  ;
438
 
 
439
 
/*************************************************
440
 
* Serpent Encryption                             *
441
 
*************************************************/
442
 
START_FUNCTION(serpent_encrypt)
443
 
   SPILL_REGS()
444
 
#define PUSHED 4
445
 
 
446
 
   ASSIGN(EBP, ARG(1)) /* input block */
447
 
   ASSIGN(EAX, ARRAY4(EBP, 0))
448
 
   ASSIGN(EBX, ARRAY4(EBP, 1))
449
 
   ASSIGN(ECX, ARRAY4(EBP, 2))
450
 
   ASSIGN(EDX, ARRAY4(EBP, 3))
451
 
 
452
 
   ASSIGN(EDI, ARG(3)) /* round keys */
453
 
   ZEROIZE(EBP)
454
 
 
455
 
#define E_ROUND(A, B, C, D, T, N, SBOX) \
456
 
   KEY_XOR(A, B, C, D, N) \
457
 
   SBOX(A, B, C, D, T) \
458
 
   TRANSFORM(A, B, C, D, T)
459
 
 
460
 
 
461
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  0, SBOX_E1)
462
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  1, SBOX_E2)
463
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  2, SBOX_E3)
464
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  3, SBOX_E4)
465
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  4, SBOX_E5)
466
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  5, SBOX_E6)
467
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  6, SBOX_E7)
468
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  7, SBOX_E8)
469
 
 
470
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  8, SBOX_E1)
471
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP,  9, SBOX_E2)
472
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 10, SBOX_E3)
473
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 11, SBOX_E4)
474
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 12, SBOX_E5)
475
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 13, SBOX_E6)
476
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 14, SBOX_E7)
477
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 15, SBOX_E8)
478
 
 
479
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 16, SBOX_E1)
480
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 17, SBOX_E2)
481
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 18, SBOX_E3)
482
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 19, SBOX_E4)
483
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 20, SBOX_E5)
484
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 21, SBOX_E6)
485
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 22, SBOX_E7)
486
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 23, SBOX_E8)
487
 
 
488
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 24, SBOX_E1)
489
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 25, SBOX_E2)
490
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 26, SBOX_E3)
491
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 27, SBOX_E4)
492
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 28, SBOX_E5)
493
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 29, SBOX_E6)
494
 
   E_ROUND(EAX, EBX, ECX, EDX, EBP, 30, SBOX_E7)
495
 
 
496
 
   KEY_XOR(EAX, EBX, ECX, EDX, 31)
497
 
   SBOX_E8(EAX, EBX, ECX, EDX, EBP)
498
 
   KEY_XOR(EAX, EBX, ECX, EDX, 32)
499
 
 
500
 
   ASSIGN(EBP, ARG(2)) /* output block */
501
 
   ASSIGN(ARRAY4(EBP, 0), EAX)
502
 
   ASSIGN(ARRAY4(EBP, 1), EBX)
503
 
   ASSIGN(ARRAY4(EBP, 2), ECX)
504
 
   ASSIGN(ARRAY4(EBP, 3), EDX)
505
 
 
506
 
   RESTORE_REGS()
507
 
#undef PUSHED
508
 
END_FUNCTION(serpent_encrypt)
509
 
 
510
 
/*************************************************
511
 
* Serpent Decryption                             *
512
 
*************************************************/
513
 
START_FUNCTION(serpent_decrypt)
514
 
   SPILL_REGS()
515
 
#define PUSHED 4
516
 
 
517
 
   ASSIGN(EBP, ARG(1)) /* input block */
518
 
   ASSIGN(EAX, ARRAY4(EBP, 0))
519
 
   ASSIGN(EBX, ARRAY4(EBP, 1))
520
 
   ASSIGN(ECX, ARRAY4(EBP, 2))
521
 
   ASSIGN(EDX, ARRAY4(EBP, 3))
522
 
 
523
 
   ASSIGN(EDI, ARG(3)) /* round keys */
524
 
 
525
 
   ZEROIZE(EBP)
526
 
 
527
 
#define D_ROUND(A, B, C, D, T, N, SBOX) \
528
 
   I_TRANSFORM(A, B, C, D, T) \
529
 
   SBOX(A, B, C, D, T) \
530
 
   KEY_XOR(A, B, C, D, N) \
531
 
 
532
 
   KEY_XOR(EAX, EBX, ECX, EDX, 32)
533
 
   SBOX_D8(EAX, EBX, ECX, EDX, EBP)
534
 
   KEY_XOR(EAX, EBX, ECX, EDX, 31)
535
 
 
536
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 30, SBOX_D7)
537
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 29, SBOX_D6)
538
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 28, SBOX_D5)
539
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 27, SBOX_D4)
540
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 26, SBOX_D3)
541
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 25, SBOX_D2)
542
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 24, SBOX_D1)
543
 
 
544
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 23, SBOX_D8)
545
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 22, SBOX_D7)
546
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 21, SBOX_D6)
547
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 20, SBOX_D5)
548
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 19, SBOX_D4)
549
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 18, SBOX_D3)
550
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 17, SBOX_D2)
551
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 16, SBOX_D1)
552
 
 
553
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 15, SBOX_D8)
554
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 14, SBOX_D7)
555
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 13, SBOX_D6)
556
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 12, SBOX_D5)
557
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 11, SBOX_D4)
558
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP, 10, SBOX_D3)
559
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  9, SBOX_D2)
560
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  8, SBOX_D1)
561
 
 
562
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  7, SBOX_D8)
563
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  6, SBOX_D7)
564
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  5, SBOX_D6)
565
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  4, SBOX_D5)
566
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  3, SBOX_D4)
567
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  2, SBOX_D3)
568
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  1, SBOX_D2)
569
 
   D_ROUND(EAX, EBX, ECX, EDX, EBP,  0, SBOX_D1)
570
 
 
571
 
   ASSIGN(EBP, ARG(2)) /* output block */
572
 
   ASSIGN(ARRAY4(EBP, 0), EAX)
573
 
   ASSIGN(ARRAY4(EBP, 1), EBX)
574
 
   ASSIGN(ARRAY4(EBP, 2), ECX)
575
 
   ASSIGN(ARRAY4(EBP, 3), EDX)
576
 
 
577
 
   RESTORE_REGS()
578
 
#undef PUSHED
579
 
END_FUNCTION(serpent_decrypt)
580
 
 
581
 
/*************************************************
582
 
* Serpent Key Schedule                           *
583
 
*************************************************/
584
 
START_FUNCTION(serpent_key_schedule)
585
 
   SPILL_REGS()
586
 
#define PUSHED 4
587
 
 
588
 
   ASSIGN(EDI, ARG(1)) /* round keys */
589
 
   ASSIGN(ESI, IMM(8))
590
 
   ADD_IMM(EDI, 32)
591
 
 
592
 
START_LOOP(.EXPANSION)
593
 
   ASSIGN(EAX, ARRAY4(EDI, -1))
594
 
   ASSIGN(EBX, ARRAY4(EDI, -3))
595
 
   ASSIGN(ECX, ARRAY4(EDI, -5))
596
 
   ASSIGN(EDX, ARRAY4(EDI, -8))
597
 
 
598
 
   ASSIGN(EBP, ESI)
599
 
   SUB_IMM(EBP, 8)
600
 
   XOR(EBP, IMM(0x9E3779B9))
601
 
   XOR(EAX, EBX)
602
 
   XOR(ECX, EDX)
603
 
   XOR(EAX, EBP)
604
 
   XOR(EAX, ECX)
605
 
 
606
 
   ROTL_IMM(EAX, 11)
607
 
 
608
 
   ASSIGN(ARRAY4(EDI, 0), EAX)
609
 
 
610
 
   ADD_IMM(ESI, 1)
611
 
   ADD_IMM(EDI, 4)
612
 
LOOP_UNTIL_EQ(ESI, 140, .EXPANSION)
613
 
 
614
 
   ASSIGN(EDI, ARG(1)) /* round keys */
615
 
 
616
 
#define LOAD_AND_SBOX(MSG, SBOX)          \
617
 
   ASSIGN(EAX, ARRAY4(EDI, (4*MSG+ 8))) ; \
618
 
   ASSIGN(EBX, ARRAY4(EDI, (4*MSG+ 9))) ; \
619
 
   ASSIGN(ECX, ARRAY4(EDI, (4*MSG+10))) ; \
620
 
   ASSIGN(EDX, ARRAY4(EDI, (4*MSG+11))) ; \
621
 
   SBOX(EAX, EBX, ECX, EDX, EBP)        ; \
622
 
   ASSIGN(ARRAY4(EDI, (4*MSG+ 8)), EAX) ; \
623
 
   ASSIGN(ARRAY4(EDI, (4*MSG+ 9)), EBX) ; \
624
 
   ASSIGN(ARRAY4(EDI, (4*MSG+10)), ECX) ; \
625
 
   ASSIGN(ARRAY4(EDI, (4*MSG+11)), EDX)
626
 
 
627
 
   LOAD_AND_SBOX( 0, SBOX_E4)
628
 
   LOAD_AND_SBOX( 1, SBOX_E3)
629
 
   LOAD_AND_SBOX( 2, SBOX_E2)
630
 
   LOAD_AND_SBOX( 3, SBOX_E1)
631
 
 
632
 
   LOAD_AND_SBOX( 4, SBOX_E8)
633
 
   LOAD_AND_SBOX( 5, SBOX_E7)
634
 
   LOAD_AND_SBOX( 6, SBOX_E6)
635
 
   LOAD_AND_SBOX( 7, SBOX_E5)
636
 
   LOAD_AND_SBOX( 8, SBOX_E4)
637
 
   LOAD_AND_SBOX( 9, SBOX_E3)
638
 
   LOAD_AND_SBOX(10, SBOX_E2)
639
 
   LOAD_AND_SBOX(11, SBOX_E1)
640
 
 
641
 
   LOAD_AND_SBOX(12, SBOX_E8)
642
 
   LOAD_AND_SBOX(13, SBOX_E7)
643
 
   LOAD_AND_SBOX(14, SBOX_E6)
644
 
   LOAD_AND_SBOX(15, SBOX_E5)
645
 
   LOAD_AND_SBOX(16, SBOX_E4)
646
 
   LOAD_AND_SBOX(17, SBOX_E3)
647
 
   LOAD_AND_SBOX(18, SBOX_E2)
648
 
   LOAD_AND_SBOX(19, SBOX_E1)
649
 
 
650
 
   LOAD_AND_SBOX(20, SBOX_E8)
651
 
   LOAD_AND_SBOX(21, SBOX_E7)
652
 
   LOAD_AND_SBOX(22, SBOX_E6)
653
 
   LOAD_AND_SBOX(23, SBOX_E5)
654
 
   LOAD_AND_SBOX(24, SBOX_E4)
655
 
   LOAD_AND_SBOX(25, SBOX_E3)
656
 
   LOAD_AND_SBOX(26, SBOX_E2)
657
 
   LOAD_AND_SBOX(27, SBOX_E1)
658
 
 
659
 
   LOAD_AND_SBOX(28, SBOX_E8)
660
 
   LOAD_AND_SBOX(29, SBOX_E7)
661
 
   LOAD_AND_SBOX(30, SBOX_E6)
662
 
   LOAD_AND_SBOX(31, SBOX_E5)
663
 
   LOAD_AND_SBOX(32, SBOX_E4)
664
 
 
665
 
   RESTORE_REGS()
666
 
#undef PUSHED
667
 
END_FUNCTION(serpent_key_schedule)