~ubuntu-branches/ubuntu/hardy/openswan/hardy-updates

« back to all changes in this revision

Viewing changes to linux/net/ipsec/aes/aes-i586.S

  • Committer: Bazaar Package Importer
  • Author(s): Rene Mayrhofer
  • Date: 2005-01-27 16:10:11 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050127161011-idgybmyz3vwhpfiq
Tags: 2.3.0-2
Urgency HIGH due to security issue and problems with build-deps in sarge.
* Fix the security issue. Please see
  http://www.idefense.com/application/poi/display?id=190&
      type=vulnerabilities&flashstatus=false
  for more details. Thanks to Martin Schulze for informing me about
  this issue.
  Closes: #292458: Openswan XAUTH/PAM Buffer Overflow Vulnerability
* Added a Build-Dependency to lynx.
  Closes: #291143: openswan: FTBFS: Missing build dependency.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
//
 
2
// Copyright (c) 2001, Dr Brian Gladman <brg@gladman.uk.net>, Worcester, UK.
 
3
// All rights reserved.
 
4
//
 
5
// TERMS
 
6
//
 
7
//  Redistribution and use in source and binary forms, with or without
 
8
//  modification, are permitted subject to the following conditions:
 
9
//
 
10
//  1. Redistributions of source code must retain the above copyright
 
11
//     notice, this list of conditions and the following disclaimer.
 
12
//
 
13
//  2. Redistributions in binary form must reproduce the above copyright
 
14
//     notice, this list of conditions and the following disclaimer in the
 
15
//     documentation and/or other materials provided with the distribution.
 
16
//
 
17
//  3. The copyright holder's name must not be used to endorse or promote
 
18
//     any products derived from this software without his specific prior
 
19
//     written permission.
 
20
//
 
21
//  This software is provided 'as is' with no express or implied warranties
 
22
//  of correctness or fitness for purpose.
 
23
 
 
24
// Modified by Jari Ruusu,  December 24 2001
 
25
//  - Converted syntax to GNU CPP/assembler syntax
 
26
//  - C programming interface converted back to "old" API
 
27
//  - Minor portability cleanups and speed optimizations
 
28
 
 
29
// An AES (Rijndael) implementation for the Pentium. This version only
 
30
// implements the standard AES block length (128 bits, 16 bytes). This code
 
31
// does not preserve the eax, ecx or edx registers or the artihmetic status
 
32
// flags. However, the ebx, esi, edi, and ebp registers are preserved across
 
33
// calls.
 
34
 
 
35
// void aes_set_key(aes_context *cx, const unsigned char key[], const int key_len, const int f)
 
36
// void aes_encrypt(const aes_context *cx, const unsigned char in_blk[], unsigned char out_blk[])
 
37
// void aes_decrypt(const aes_context *cx, const unsigned char in_blk[], unsigned char out_blk[])
 
38
 
 
39
#if defined(USE_UNDERLINE)
 
40
# define aes_set_key _aes_set_key
 
41
# define aes_encrypt _aes_encrypt
 
42
# define aes_decrypt _aes_decrypt
 
43
#endif
 
44
#if !defined(ALIGN32BYTES)
 
45
# define ALIGN32BYTES 32
 
46
#endif
 
47
 
 
48
        .file   "aes-i586.S"
 
49
        .globl  aes_set_key
 
50
        .globl  aes_encrypt
 
51
        .globl  aes_decrypt
 
52
 
 
53
#define tlen    1024    // length of each of 4 'xor' arrays (256 32-bit words)
 
54
 
 
55
// offsets to parameters with one register pushed onto stack
 
56
 
 
57
#define ctx     8       // AES context structure
 
58
#define in_blk  12      // input byte array address parameter
 
59
#define out_blk 16      // output byte array address parameter
 
60
 
 
61
// offsets in context structure
 
62
 
 
63
#define nkey    0       // key length, size 4
 
64
#define nrnd    4       // number of rounds, size 4
 
65
#define ekey    8       // encryption key schedule base address, size 256
 
66
#define dkey    264     // decryption key schedule base address, size 256
 
67
 
 
68
// This macro performs a forward encryption cycle. It is entered with
 
69
// the first previous round column values in %eax, %ebx, %esi and %edi and
 
70
// exits with the final values in the same registers.
 
71
 
 
72
#define fwd_rnd(p1,p2)                   \
 
73
        mov     %ebx,(%esp)             ;\
 
74
        movzbl  %al,%edx                ;\
 
75
        mov     %eax,%ecx               ;\
 
76
        mov     p2(%ebp),%eax           ;\
 
77
        mov     %edi,4(%esp)            ;\
 
78
        mov     p2+12(%ebp),%edi        ;\
 
79
        xor     p1(,%edx,4),%eax        ;\
 
80
        movzbl  %ch,%edx                ;\
 
81
        shr     $16,%ecx                ;\
 
82
        mov     p2+4(%ebp),%ebx         ;\
 
83
        xor     p1+tlen(,%edx,4),%edi   ;\
 
84
        movzbl  %cl,%edx                ;\
 
85
        movzbl  %ch,%ecx                ;\
 
86
        xor     p1+3*tlen(,%ecx,4),%ebx ;\
 
87
        mov     %esi,%ecx               ;\
 
88
        mov     p1+2*tlen(,%edx,4),%esi ;\
 
89
        movzbl  %cl,%edx                ;\
 
90
        xor     p1(,%edx,4),%esi        ;\
 
91
        movzbl  %ch,%edx                ;\
 
92
        shr     $16,%ecx                ;\
 
93
        xor     p1+tlen(,%edx,4),%ebx   ;\
 
94
        movzbl  %cl,%edx                ;\
 
95
        movzbl  %ch,%ecx                ;\
 
96
        xor     p1+2*tlen(,%edx,4),%eax ;\
 
97
        mov     (%esp),%edx             ;\
 
98
        xor     p1+3*tlen(,%ecx,4),%edi ;\
 
99
        movzbl  %dl,%ecx                ;\
 
100
        xor     p2+8(%ebp),%esi         ;\
 
101
        xor     p1(,%ecx,4),%ebx        ;\
 
102
        movzbl  %dh,%ecx                ;\
 
103
        shr     $16,%edx                ;\
 
104
        xor     p1+tlen(,%ecx,4),%eax   ;\
 
105
        movzbl  %dl,%ecx                ;\
 
106
        movzbl  %dh,%edx                ;\
 
107
        xor     p1+2*tlen(,%ecx,4),%edi ;\
 
108
        mov     4(%esp),%ecx            ;\
 
109
        xor     p1+3*tlen(,%edx,4),%esi ;\
 
110
        movzbl  %cl,%edx                ;\
 
111
        xor     p1(,%edx,4),%edi        ;\
 
112
        movzbl  %ch,%edx                ;\
 
113
        shr     $16,%ecx                ;\
 
114
        xor     p1+tlen(,%edx,4),%esi   ;\
 
115
        movzbl  %cl,%edx                ;\
 
116
        movzbl  %ch,%ecx                ;\
 
117
        xor     p1+2*tlen(,%edx,4),%ebx ;\
 
118
        xor     p1+3*tlen(,%ecx,4),%eax
 
119
 
 
120
// This macro performs an inverse encryption cycle. It is entered with
 
121
// the first previous round column values in %eax, %ebx, %esi and %edi and
 
122
// exits with the final values in the same registers.
 
123
 
 
124
#define inv_rnd(p1,p2)                   \
 
125
        movzbl  %al,%edx                ;\
 
126
        mov     %ebx,(%esp)             ;\
 
127
        mov     %eax,%ecx               ;\
 
128
        mov     p2(%ebp),%eax           ;\
 
129
        mov     %edi,4(%esp)            ;\
 
130
        mov     p2+4(%ebp),%ebx         ;\
 
131
        xor     p1(,%edx,4),%eax        ;\
 
132
        movzbl  %ch,%edx                ;\
 
133
        shr     $16,%ecx                ;\
 
134
        mov     p2+12(%ebp),%edi        ;\
 
135
        xor     p1+tlen(,%edx,4),%ebx   ;\
 
136
        movzbl  %cl,%edx                ;\
 
137
        movzbl  %ch,%ecx                ;\
 
138
        xor     p1+3*tlen(,%ecx,4),%edi ;\
 
139
        mov     %esi,%ecx               ;\
 
140
        mov     p1+2*tlen(,%edx,4),%esi ;\
 
141
        movzbl  %cl,%edx                ;\
 
142
        xor     p1(,%edx,4),%esi        ;\
 
143
        movzbl  %ch,%edx                ;\
 
144
        shr     $16,%ecx                ;\
 
145
        xor     p1+tlen(,%edx,4),%edi   ;\
 
146
        movzbl  %cl,%edx                ;\
 
147
        movzbl  %ch,%ecx                ;\
 
148
        xor     p1+2*tlen(,%edx,4),%eax ;\
 
149
        mov     (%esp),%edx             ;\
 
150
        xor     p1+3*tlen(,%ecx,4),%ebx ;\
 
151
        movzbl  %dl,%ecx                ;\
 
152
        xor     p2+8(%ebp),%esi         ;\
 
153
        xor     p1(,%ecx,4),%ebx        ;\
 
154
        movzbl  %dh,%ecx                ;\
 
155
        shr     $16,%edx                ;\
 
156
        xor     p1+tlen(,%ecx,4),%esi   ;\
 
157
        movzbl  %dl,%ecx                ;\
 
158
        movzbl  %dh,%edx                ;\
 
159
        xor     p1+2*tlen(,%ecx,4),%edi ;\
 
160
        mov     4(%esp),%ecx            ;\
 
161
        xor     p1+3*tlen(,%edx,4),%eax ;\
 
162
        movzbl  %cl,%edx                ;\
 
163
        xor     p1(,%edx,4),%edi        ;\
 
164
        movzbl  %ch,%edx                ;\
 
165
        shr     $16,%ecx                ;\
 
166
        xor     p1+tlen(,%edx,4),%eax   ;\
 
167
        movzbl  %cl,%edx                ;\
 
168
        movzbl  %ch,%ecx                ;\
 
169
        xor     p1+2*tlen(,%edx,4),%ebx ;\
 
170
        xor     p1+3*tlen(,%ecx,4),%esi
 
171
 
 
172
// AES (Rijndael) Encryption Subroutine
 
173
 
 
174
        .text
 
175
        .align  ALIGN32BYTES
 
176
aes_encrypt:
 
177
        push    %ebp
 
178
        mov     ctx(%esp),%ebp          // pointer to context
 
179
        mov     in_blk(%esp),%ecx
 
180
        push    %ebx
 
181
        push    %esi
 
182
        push    %edi
 
183
        mov     nrnd(%ebp),%edx         // number of rounds
 
184
        lea     ekey+16(%ebp),%ebp      // key pointer
 
185
 
 
186
// input four columns and xor in first round key
 
187
 
 
188
        mov     (%ecx),%eax
 
189
        mov     4(%ecx),%ebx
 
190
        mov     8(%ecx),%esi
 
191
        mov     12(%ecx),%edi
 
192
        xor     -16(%ebp),%eax
 
193
        xor     -12(%ebp),%ebx
 
194
        xor     -8(%ebp),%esi
 
195
        xor     -4(%ebp),%edi
 
196
 
 
197
        sub     $8,%esp                 // space for register saves on stack
 
198
 
 
199
        sub     $10,%edx
 
200
        je      aes_15
 
201
        add     $32,%ebp
 
202
        sub     $2,%edx
 
203
        je      aes_13
 
204
        add     $32,%ebp
 
205
 
 
206
        fwd_rnd(aes_ft_tab,-64)         // 14 rounds for 256-bit key
 
207
        fwd_rnd(aes_ft_tab,-48)
 
208
aes_13: fwd_rnd(aes_ft_tab,-32)         // 12 rounds for 192-bit key
 
209
        fwd_rnd(aes_ft_tab,-16)
 
210
aes_15: fwd_rnd(aes_ft_tab,0)           // 10 rounds for 128-bit key
 
211
        fwd_rnd(aes_ft_tab,16)
 
212
        fwd_rnd(aes_ft_tab,32)
 
213
        fwd_rnd(aes_ft_tab,48)
 
214
        fwd_rnd(aes_ft_tab,64)
 
215
        fwd_rnd(aes_ft_tab,80)
 
216
        fwd_rnd(aes_ft_tab,96)
 
217
        fwd_rnd(aes_ft_tab,112)
 
218
        fwd_rnd(aes_ft_tab,128)
 
219
        fwd_rnd(aes_fl_tab,144)         // last round uses a different table
 
220
 
 
221
// move final values to the output array.
 
222
 
 
223
        mov     out_blk+20(%esp),%ebp
 
224
        add     $8,%esp
 
225
        mov     %eax,(%ebp)
 
226
        mov     %ebx,4(%ebp)
 
227
        mov     %esi,8(%ebp)
 
228
        mov     %edi,12(%ebp)
 
229
        pop     %edi
 
230
        pop     %esi
 
231
        pop     %ebx
 
232
        pop     %ebp
 
233
        ret
 
234
 
 
235
 
 
236
// AES (Rijndael) Decryption Subroutine
 
237
 
 
238
        .align  ALIGN32BYTES
 
239
aes_decrypt:
 
240
        push    %ebp
 
241
        mov     ctx(%esp),%ebp          // pointer to context
 
242
        mov     in_blk(%esp),%ecx
 
243
        push    %ebx
 
244
        push    %esi
 
245
        push    %edi
 
246
        mov     nrnd(%ebp),%edx         // number of rounds
 
247
        lea     dkey+16(%ebp),%ebp      // key pointer
 
248
 
 
249
// input four columns and xor in first round key
 
250
 
 
251
        mov     (%ecx),%eax
 
252
        mov     4(%ecx),%ebx
 
253
        mov     8(%ecx),%esi
 
254
        mov     12(%ecx),%edi
 
255
        xor     -16(%ebp),%eax
 
256
        xor     -12(%ebp),%ebx
 
257
        xor     -8(%ebp),%esi
 
258
        xor     -4(%ebp),%edi
 
259
 
 
260
        sub     $8,%esp                 // space for register saves on stack
 
261
 
 
262
        sub     $10,%edx
 
263
        je      aes_25
 
264
        add     $32,%ebp
 
265
        sub     $2,%edx
 
266
        je      aes_23
 
267
        add     $32,%ebp
 
268
 
 
269
        inv_rnd(aes_it_tab,-64)         // 14 rounds for 256-bit key
 
270
        inv_rnd(aes_it_tab,-48)
 
271
aes_23: inv_rnd(aes_it_tab,-32)         // 12 rounds for 192-bit key
 
272
        inv_rnd(aes_it_tab,-16)
 
273
aes_25: inv_rnd(aes_it_tab,0)           // 10 rounds for 128-bit key
 
274
        inv_rnd(aes_it_tab,16)
 
275
        inv_rnd(aes_it_tab,32)
 
276
        inv_rnd(aes_it_tab,48)
 
277
        inv_rnd(aes_it_tab,64)
 
278
        inv_rnd(aes_it_tab,80)
 
279
        inv_rnd(aes_it_tab,96)
 
280
        inv_rnd(aes_it_tab,112)
 
281
        inv_rnd(aes_it_tab,128)
 
282
        inv_rnd(aes_il_tab,144)         // last round uses a different table
 
283
 
 
284
// move final values to the output array.
 
285
 
 
286
        mov     out_blk+20(%esp),%ebp
 
287
        add     $8,%esp
 
288
        mov     %eax,(%ebp)
 
289
        mov     %ebx,4(%ebp)
 
290
        mov     %esi,8(%ebp)
 
291
        mov     %edi,12(%ebp)
 
292
        pop     %edi
 
293
        pop     %esi
 
294
        pop     %ebx
 
295
        pop     %ebp
 
296
        ret
 
297
 
 
298
// AES (Rijndael) Key Schedule Subroutine
 
299
 
 
300
// input/output parameters
 
301
 
 
302
#define aes_cx  12      // AES context
 
303
#define in_key  16      // key input array address
 
304
#define key_ln  20      // key length, bytes (16,24,32) or bits (128,192,256)
 
305
#define ed_flg  24      // 0=create both encr/decr keys, 1=create encr key only
 
306
 
 
307
// offsets for locals
 
308
 
 
309
#define cnt     -4
 
310
#define kpf     -8
 
311
#define slen    8
 
312
 
 
313
// This macro performs a column mixing operation on an input 32-bit
 
314
// word to give a 32-bit result. It uses each of the 4 bytes in the
 
315
// the input column to index 4 different tables of 256 32-bit words
 
316
// that are xored together to form the output value.
 
317
 
 
318
#define mix_col(p1)                      \
 
319
        movzbl  %bl,%ecx                ;\
 
320
        mov     p1(,%ecx,4),%eax        ;\
 
321
        movzbl  %bh,%ecx                ;\
 
322
        ror     $16,%ebx                ;\
 
323
        xor     p1+tlen(,%ecx,4),%eax   ;\
 
324
        movzbl  %bl,%ecx                ;\
 
325
        xor     p1+2*tlen(,%ecx,4),%eax ;\
 
326
        movzbl  %bh,%ecx                ;\
 
327
        xor     p1+3*tlen(,%ecx,4),%eax
 
328
 
 
329
// Key Schedule Macros
 
330
 
 
331
#define ksc4(p1)                         \
 
332
        rol     $24,%ebx                ;\
 
333
        mix_col(aes_fl_tab)             ;\
 
334
        ror     $8,%ebx                 ;\
 
335
        xor     4*p1+aes_rcon_tab,%eax  ;\
 
336
        xor     %eax,%esi               ;\
 
337
        xor     %esi,%ebp               ;\
 
338
        mov     %esi,16*p1(%edi)        ;\
 
339
        mov     %ebp,16*p1+4(%edi)      ;\
 
340
        xor     %ebp,%edx               ;\
 
341
        xor     %edx,%ebx               ;\
 
342
        mov     %edx,16*p1+8(%edi)      ;\
 
343
        mov     %ebx,16*p1+12(%edi)
 
344
 
 
345
#define ksc6(p1)                         \
 
346
        rol     $24,%ebx                ;\
 
347
        mix_col(aes_fl_tab)             ;\
 
348
        ror     $8,%ebx                 ;\
 
349
        xor     4*p1+aes_rcon_tab,%eax  ;\
 
350
        xor     24*p1-24(%edi),%eax     ;\
 
351
        mov     %eax,24*p1(%edi)        ;\
 
352
        xor     24*p1-20(%edi),%eax     ;\
 
353
        mov     %eax,24*p1+4(%edi)      ;\
 
354
        xor     %eax,%esi               ;\
 
355
        xor     %esi,%ebp               ;\
 
356
        mov     %esi,24*p1+8(%edi)      ;\
 
357
        mov     %ebp,24*p1+12(%edi)     ;\
 
358
        xor     %ebp,%edx               ;\
 
359
        xor     %edx,%ebx               ;\
 
360
        mov     %edx,24*p1+16(%edi)     ;\
 
361
        mov     %ebx,24*p1+20(%edi)
 
362
 
 
363
#define ksc8(p1)                         \
 
364
        rol     $24,%ebx                ;\
 
365
        mix_col(aes_fl_tab)             ;\
 
366
        ror     $8,%ebx                 ;\
 
367
        xor     4*p1+aes_rcon_tab,%eax  ;\
 
368
        xor     32*p1-32(%edi),%eax     ;\
 
369
        mov     %eax,32*p1(%edi)        ;\
 
370
        xor     32*p1-28(%edi),%eax     ;\
 
371
        mov     %eax,32*p1+4(%edi)      ;\
 
372
        xor     32*p1-24(%edi),%eax     ;\
 
373
        mov     %eax,32*p1+8(%edi)      ;\
 
374
        xor     32*p1-20(%edi),%eax     ;\
 
375
        mov     %eax,32*p1+12(%edi)     ;\
 
376
        push    %ebx                    ;\
 
377
        mov     %eax,%ebx               ;\
 
378
        mix_col(aes_fl_tab)             ;\
 
379
        pop     %ebx                    ;\
 
380
        xor     %eax,%esi               ;\
 
381
        xor     %esi,%ebp               ;\
 
382
        mov     %esi,32*p1+16(%edi)     ;\
 
383
        mov     %ebp,32*p1+20(%edi)     ;\
 
384
        xor     %ebp,%edx               ;\
 
385
        xor     %edx,%ebx               ;\
 
386
        mov     %edx,32*p1+24(%edi)     ;\
 
387
        mov     %ebx,32*p1+28(%edi)
 
388
 
 
389
        .align  ALIGN32BYTES
 
390
aes_set_key:
 
391
        pushfl
 
392
        push    %ebp
 
393
        mov     %esp,%ebp
 
394
        sub     $slen,%esp
 
395
        push    %ebx
 
396
        push    %esi
 
397
        push    %edi
 
398
 
 
399
        mov     aes_cx(%ebp),%edx       // edx -> AES context
 
400
 
 
401
        mov     key_ln(%ebp),%ecx       // key length
 
402
        cmpl    $128,%ecx
 
403
        jb      aes_30
 
404
        shr     $3,%ecx
 
405
aes_30: cmpl    $32,%ecx
 
406
        je      aes_32
 
407
        cmpl    $24,%ecx
 
408
        je      aes_32
 
409
        mov     $16,%ecx
 
410
aes_32: shr     $2,%ecx
 
411
        mov     %ecx,nkey(%edx)
 
412
 
 
413
        lea     6(%ecx),%eax            // 10/12/14 for 4/6/8 32-bit key length
 
414
        mov     %eax,nrnd(%edx)
 
415
 
 
416
        mov     in_key(%ebp),%esi       // key input array
 
417
        lea     ekey(%edx),%edi         // key position in AES context
 
418
        cld
 
419
        push    %ebp
 
420
        mov     %ecx,%eax               // save key length in eax
 
421
        rep ;   movsl                   // words in the key schedule
 
422
        mov     -4(%esi),%ebx           // put some values in registers
 
423
        mov     -8(%esi),%edx           // to allow faster code
 
424
        mov     -12(%esi),%ebp
 
425
        mov     -16(%esi),%esi
 
426
 
 
427
        cmpl    $4,%eax                 // jump on key size
 
428
        je      aes_36
 
429
        cmpl    $6,%eax
 
430
        je      aes_35
 
431
 
 
432
        ksc8(0)
 
433
        ksc8(1)
 
434
        ksc8(2)
 
435
        ksc8(3)
 
436
        ksc8(4)
 
437
        ksc8(5)
 
438
        ksc8(6)
 
439
        jmp     aes_37
 
440
aes_35: ksc6(0)
 
441
        ksc6(1)
 
442
        ksc6(2)
 
443
        ksc6(3)
 
444
        ksc6(4)
 
445
        ksc6(5)
 
446
        ksc6(6)
 
447
        ksc6(7)
 
448
        jmp     aes_37
 
449
aes_36: ksc4(0)
 
450
        ksc4(1)
 
451
        ksc4(2)
 
452
        ksc4(3)
 
453
        ksc4(4)
 
454
        ksc4(5)
 
455
        ksc4(6)
 
456
        ksc4(7)
 
457
        ksc4(8)
 
458
        ksc4(9)
 
459
aes_37: pop     %ebp
 
460
        mov     aes_cx(%ebp),%edx       // edx -> AES context
 
461
        cmpl    $0,ed_flg(%ebp)
 
462
        jne     aes_39
 
463
 
 
464
// compile decryption key schedule from encryption schedule - reverse
 
465
// order and do mix_column operation on round keys except first and last
 
466
 
 
467
        mov     nrnd(%edx),%eax         // kt = cx->d_key + nc * cx->Nrnd
 
468
        shl     $2,%eax
 
469
        lea     dkey(%edx,%eax,4),%edi
 
470
        lea     ekey(%edx),%esi         // kf = cx->e_key
 
471
 
 
472
        movsl                           // copy first round key (unmodified)
 
473
        movsl
 
474
        movsl
 
475
        movsl
 
476
        sub     $32,%edi
 
477
        movl    $1,cnt(%ebp)
 
478
aes_38:                                 // do mix column on each column of
 
479
        lodsl                           // each round key
 
480
        mov     %eax,%ebx
 
481
        mix_col(aes_im_tab)
 
482
        stosl
 
483
        lodsl
 
484
        mov     %eax,%ebx
 
485
        mix_col(aes_im_tab)
 
486
        stosl
 
487
        lodsl
 
488
        mov     %eax,%ebx
 
489
        mix_col(aes_im_tab)
 
490
        stosl
 
491
        lodsl
 
492
        mov     %eax,%ebx
 
493
        mix_col(aes_im_tab)
 
494
        stosl
 
495
        sub     $32,%edi
 
496
 
 
497
        incl    cnt(%ebp)
 
498
        mov     cnt(%ebp),%eax
 
499
        cmp     nrnd(%edx),%eax
 
500
        jb      aes_38
 
501
 
 
502
        movsl                           // copy last round key (unmodified)
 
503
        movsl
 
504
        movsl
 
505
        movsl
 
506
aes_39: pop     %edi
 
507
        pop     %esi
 
508
        pop     %ebx
 
509
        mov     %ebp,%esp
 
510
        pop     %ebp
 
511
        popfl
 
512
        ret
 
513
 
 
514
 
 
515
// finite field multiplies by {02}, {04} and {08}
 
516
 
 
517
#define f2(x)   ((x<<1)^(((x>>7)&1)*0x11b))
 
518
#define f4(x)   ((x<<2)^(((x>>6)&1)*0x11b)^(((x>>6)&2)*0x11b))
 
519
#define f8(x)   ((x<<3)^(((x>>5)&1)*0x11b)^(((x>>5)&2)*0x11b)^(((x>>5)&4)*0x11b))
 
520
 
 
521
// finite field multiplies required in table generation
 
522
 
 
523
#define f3(x)   (f2(x) ^ x)
 
524
#define f9(x)   (f8(x) ^ x)
 
525
#define fb(x)   (f8(x) ^ f2(x) ^ x)
 
526
#define fd(x)   (f8(x) ^ f4(x) ^ x)
 
527
#define fe(x)   (f8(x) ^ f4(x) ^ f2(x))
 
528
 
 
529
// These defines generate the forward table entries
 
530
 
 
531
#define u0(x)   ((f3(x) << 24) | (x << 16) | (x << 8) | f2(x))
 
532
#define u1(x)   ((x << 24) | (x << 16) | (f2(x) << 8) | f3(x))
 
533
#define u2(x)   ((x << 24) | (f2(x) << 16) | (f3(x) << 8) | x)
 
534
#define u3(x)   ((f2(x) << 24) | (f3(x) << 16) | (x << 8) | x)
 
535
 
 
536
// These defines generate the inverse table entries
 
537
 
 
538
#define v0(x)   ((fb(x) << 24) | (fd(x) << 16) | (f9(x) << 8) | fe(x))
 
539
#define v1(x)   ((fd(x) << 24) | (f9(x) << 16) | (fe(x) << 8) | fb(x))
 
540
#define v2(x)   ((f9(x) << 24) | (fe(x) << 16) | (fb(x) << 8) | fd(x))
 
541
#define v3(x)   ((fe(x) << 24) | (fb(x) << 16) | (fd(x) << 8) | f9(x))
 
542
 
 
543
// These defines generate entries for the last round tables
 
544
 
 
545
#define w0(x)   (x)
 
546
#define w1(x)   (x <<  8)
 
547
#define w2(x)   (x << 16)
 
548
#define w3(x)   (x << 24)
 
549
 
 
550
// macro to generate inverse mix column tables (needed for the key schedule)
 
551
 
 
552
#define im_data0(p1) \
 
553
        .long   p1(0x00),p1(0x01),p1(0x02),p1(0x03),p1(0x04),p1(0x05),p1(0x06),p1(0x07) ;\
 
554
        .long   p1(0x08),p1(0x09),p1(0x0a),p1(0x0b),p1(0x0c),p1(0x0d),p1(0x0e),p1(0x0f) ;\
 
555
        .long   p1(0x10),p1(0x11),p1(0x12),p1(0x13),p1(0x14),p1(0x15),p1(0x16),p1(0x17) ;\
 
556
        .long   p1(0x18),p1(0x19),p1(0x1a),p1(0x1b),p1(0x1c),p1(0x1d),p1(0x1e),p1(0x1f)
 
557
#define im_data1(p1) \
 
558
        .long   p1(0x20),p1(0x21),p1(0x22),p1(0x23),p1(0x24),p1(0x25),p1(0x26),p1(0x27) ;\
 
559
        .long   p1(0x28),p1(0x29),p1(0x2a),p1(0x2b),p1(0x2c),p1(0x2d),p1(0x2e),p1(0x2f) ;\
 
560
        .long   p1(0x30),p1(0x31),p1(0x32),p1(0x33),p1(0x34),p1(0x35),p1(0x36),p1(0x37) ;\
 
561
        .long   p1(0x38),p1(0x39),p1(0x3a),p1(0x3b),p1(0x3c),p1(0x3d),p1(0x3e),p1(0x3f)
 
562
#define im_data2(p1) \
 
563
        .long   p1(0x40),p1(0x41),p1(0x42),p1(0x43),p1(0x44),p1(0x45),p1(0x46),p1(0x47) ;\
 
564
        .long   p1(0x48),p1(0x49),p1(0x4a),p1(0x4b),p1(0x4c),p1(0x4d),p1(0x4e),p1(0x4f) ;\
 
565
        .long   p1(0x50),p1(0x51),p1(0x52),p1(0x53),p1(0x54),p1(0x55),p1(0x56),p1(0x57) ;\
 
566
        .long   p1(0x58),p1(0x59),p1(0x5a),p1(0x5b),p1(0x5c),p1(0x5d),p1(0x5e),p1(0x5f)
 
567
#define im_data3(p1) \
 
568
        .long   p1(0x60),p1(0x61),p1(0x62),p1(0x63),p1(0x64),p1(0x65),p1(0x66),p1(0x67) ;\
 
569
        .long   p1(0x68),p1(0x69),p1(0x6a),p1(0x6b),p1(0x6c),p1(0x6d),p1(0x6e),p1(0x6f) ;\
 
570
        .long   p1(0x70),p1(0x71),p1(0x72),p1(0x73),p1(0x74),p1(0x75),p1(0x76),p1(0x77) ;\
 
571
        .long   p1(0x78),p1(0x79),p1(0x7a),p1(0x7b),p1(0x7c),p1(0x7d),p1(0x7e),p1(0x7f)
 
572
#define im_data4(p1) \
 
573
        .long   p1(0x80),p1(0x81),p1(0x82),p1(0x83),p1(0x84),p1(0x85),p1(0x86),p1(0x87) ;\
 
574
        .long   p1(0x88),p1(0x89),p1(0x8a),p1(0x8b),p1(0x8c),p1(0x8d),p1(0x8e),p1(0x8f) ;\
 
575
        .long   p1(0x90),p1(0x91),p1(0x92),p1(0x93),p1(0x94),p1(0x95),p1(0x96),p1(0x97) ;\
 
576
        .long   p1(0x98),p1(0x99),p1(0x9a),p1(0x9b),p1(0x9c),p1(0x9d),p1(0x9e),p1(0x9f)
 
577
#define im_data5(p1) \
 
578
        .long   p1(0xa0),p1(0xa1),p1(0xa2),p1(0xa3),p1(0xa4),p1(0xa5),p1(0xa6),p1(0xa7) ;\
 
579
        .long   p1(0xa8),p1(0xa9),p1(0xaa),p1(0xab),p1(0xac),p1(0xad),p1(0xae),p1(0xaf) ;\
 
580
        .long   p1(0xb0),p1(0xb1),p1(0xb2),p1(0xb3),p1(0xb4),p1(0xb5),p1(0xb6),p1(0xb7) ;\
 
581
        .long   p1(0xb8),p1(0xb9),p1(0xba),p1(0xbb),p1(0xbc),p1(0xbd),p1(0xbe),p1(0xbf)
 
582
#define im_data6(p1) \
 
583
        .long   p1(0xc0),p1(0xc1),p1(0xc2),p1(0xc3),p1(0xc4),p1(0xc5),p1(0xc6),p1(0xc7) ;\
 
584
        .long   p1(0xc8),p1(0xc9),p1(0xca),p1(0xcb),p1(0xcc),p1(0xcd),p1(0xce),p1(0xcf) ;\
 
585
        .long   p1(0xd0),p1(0xd1),p1(0xd2),p1(0xd3),p1(0xd4),p1(0xd5),p1(0xd6),p1(0xd7) ;\
 
586
        .long   p1(0xd8),p1(0xd9),p1(0xda),p1(0xdb),p1(0xdc),p1(0xdd),p1(0xde),p1(0xdf)
 
587
#define im_data7(p1) \
 
588
        .long   p1(0xe0),p1(0xe1),p1(0xe2),p1(0xe3),p1(0xe4),p1(0xe5),p1(0xe6),p1(0xe7) ;\
 
589
        .long   p1(0xe8),p1(0xe9),p1(0xea),p1(0xeb),p1(0xec),p1(0xed),p1(0xee),p1(0xef) ;\
 
590
        .long   p1(0xf0),p1(0xf1),p1(0xf2),p1(0xf3),p1(0xf4),p1(0xf5),p1(0xf6),p1(0xf7) ;\
 
591
        .long   p1(0xf8),p1(0xf9),p1(0xfa),p1(0xfb),p1(0xfc),p1(0xfd),p1(0xfe),p1(0xff)
 
592
 
 
593
// S-box data - 256 entries
 
594
 
 
595
#define sb_data0(p1) \
 
596
        .long   p1(0x63),p1(0x7c),p1(0x77),p1(0x7b),p1(0xf2),p1(0x6b),p1(0x6f),p1(0xc5) ;\
 
597
        .long   p1(0x30),p1(0x01),p1(0x67),p1(0x2b),p1(0xfe),p1(0xd7),p1(0xab),p1(0x76) ;\
 
598
        .long   p1(0xca),p1(0x82),p1(0xc9),p1(0x7d),p1(0xfa),p1(0x59),p1(0x47),p1(0xf0) ;\
 
599
        .long   p1(0xad),p1(0xd4),p1(0xa2),p1(0xaf),p1(0x9c),p1(0xa4),p1(0x72),p1(0xc0)
 
600
#define sb_data1(p1) \
 
601
        .long   p1(0xb7),p1(0xfd),p1(0x93),p1(0x26),p1(0x36),p1(0x3f),p1(0xf7),p1(0xcc) ;\
 
602
        .long   p1(0x34),p1(0xa5),p1(0xe5),p1(0xf1),p1(0x71),p1(0xd8),p1(0x31),p1(0x15) ;\
 
603
        .long   p1(0x04),p1(0xc7),p1(0x23),p1(0xc3),p1(0x18),p1(0x96),p1(0x05),p1(0x9a) ;\
 
604
        .long   p1(0x07),p1(0x12),p1(0x80),p1(0xe2),p1(0xeb),p1(0x27),p1(0xb2),p1(0x75)
 
605
#define sb_data2(p1) \
 
606
        .long   p1(0x09),p1(0x83),p1(0x2c),p1(0x1a),p1(0x1b),p1(0x6e),p1(0x5a),p1(0xa0) ;\
 
607
        .long   p1(0x52),p1(0x3b),p1(0xd6),p1(0xb3),p1(0x29),p1(0xe3),p1(0x2f),p1(0x84) ;\
 
608
        .long   p1(0x53),p1(0xd1),p1(0x00),p1(0xed),p1(0x20),p1(0xfc),p1(0xb1),p1(0x5b) ;\
 
609
        .long   p1(0x6a),p1(0xcb),p1(0xbe),p1(0x39),p1(0x4a),p1(0x4c),p1(0x58),p1(0xcf)
 
610
#define sb_data3(p1) \
 
611
        .long   p1(0xd0),p1(0xef),p1(0xaa),p1(0xfb),p1(0x43),p1(0x4d),p1(0x33),p1(0x85) ;\
 
612
        .long   p1(0x45),p1(0xf9),p1(0x02),p1(0x7f),p1(0x50),p1(0x3c),p1(0x9f),p1(0xa8) ;\
 
613
        .long   p1(0x51),p1(0xa3),p1(0x40),p1(0x8f),p1(0x92),p1(0x9d),p1(0x38),p1(0xf5) ;\
 
614
        .long   p1(0xbc),p1(0xb6),p1(0xda),p1(0x21),p1(0x10),p1(0xff),p1(0xf3),p1(0xd2)
 
615
#define sb_data4(p1) \
 
616
        .long   p1(0xcd),p1(0x0c),p1(0x13),p1(0xec),p1(0x5f),p1(0x97),p1(0x44),p1(0x17) ;\
 
617
        .long   p1(0xc4),p1(0xa7),p1(0x7e),p1(0x3d),p1(0x64),p1(0x5d),p1(0x19),p1(0x73) ;\
 
618
        .long   p1(0x60),p1(0x81),p1(0x4f),p1(0xdc),p1(0x22),p1(0x2a),p1(0x90),p1(0x88) ;\
 
619
        .long   p1(0x46),p1(0xee),p1(0xb8),p1(0x14),p1(0xde),p1(0x5e),p1(0x0b),p1(0xdb)
 
620
#define sb_data5(p1) \
 
621
        .long   p1(0xe0),p1(0x32),p1(0x3a),p1(0x0a),p1(0x49),p1(0x06),p1(0x24),p1(0x5c) ;\
 
622
        .long   p1(0xc2),p1(0xd3),p1(0xac),p1(0x62),p1(0x91),p1(0x95),p1(0xe4),p1(0x79) ;\
 
623
        .long   p1(0xe7),p1(0xc8),p1(0x37),p1(0x6d),p1(0x8d),p1(0xd5),p1(0x4e),p1(0xa9) ;\
 
624
        .long   p1(0x6c),p1(0x56),p1(0xf4),p1(0xea),p1(0x65),p1(0x7a),p1(0xae),p1(0x08)
 
625
#define sb_data6(p1) \
 
626
        .long   p1(0xba),p1(0x78),p1(0x25),p1(0x2e),p1(0x1c),p1(0xa6),p1(0xb4),p1(0xc6) ;\
 
627
        .long   p1(0xe8),p1(0xdd),p1(0x74),p1(0x1f),p1(0x4b),p1(0xbd),p1(0x8b),p1(0x8a) ;\
 
628
        .long   p1(0x70),p1(0x3e),p1(0xb5),p1(0x66),p1(0x48),p1(0x03),p1(0xf6),p1(0x0e) ;\
 
629
        .long   p1(0x61),p1(0x35),p1(0x57),p1(0xb9),p1(0x86),p1(0xc1),p1(0x1d),p1(0x9e)
 
630
#define sb_data7(p1) \
 
631
        .long   p1(0xe1),p1(0xf8),p1(0x98),p1(0x11),p1(0x69),p1(0xd9),p1(0x8e),p1(0x94) ;\
 
632
        .long   p1(0x9b),p1(0x1e),p1(0x87),p1(0xe9),p1(0xce),p1(0x55),p1(0x28),p1(0xdf) ;\
 
633
        .long   p1(0x8c),p1(0xa1),p1(0x89),p1(0x0d),p1(0xbf),p1(0xe6),p1(0x42),p1(0x68) ;\
 
634
        .long   p1(0x41),p1(0x99),p1(0x2d),p1(0x0f),p1(0xb0),p1(0x54),p1(0xbb),p1(0x16)
 
635
 
 
636
// Inverse S-box data - 256 entries
 
637
 
 
638
#define ib_data0(p1) \
 
639
        .long   p1(0x52),p1(0x09),p1(0x6a),p1(0xd5),p1(0x30),p1(0x36),p1(0xa5),p1(0x38) ;\
 
640
        .long   p1(0xbf),p1(0x40),p1(0xa3),p1(0x9e),p1(0x81),p1(0xf3),p1(0xd7),p1(0xfb) ;\
 
641
        .long   p1(0x7c),p1(0xe3),p1(0x39),p1(0x82),p1(0x9b),p1(0x2f),p1(0xff),p1(0x87) ;\
 
642
        .long   p1(0x34),p1(0x8e),p1(0x43),p1(0x44),p1(0xc4),p1(0xde),p1(0xe9),p1(0xcb)
 
643
#define ib_data1(p1) \
 
644
        .long   p1(0x54),p1(0x7b),p1(0x94),p1(0x32),p1(0xa6),p1(0xc2),p1(0x23),p1(0x3d) ;\
 
645
        .long   p1(0xee),p1(0x4c),p1(0x95),p1(0x0b),p1(0x42),p1(0xfa),p1(0xc3),p1(0x4e) ;\
 
646
        .long   p1(0x08),p1(0x2e),p1(0xa1),p1(0x66),p1(0x28),p1(0xd9),p1(0x24),p1(0xb2) ;\
 
647
        .long   p1(0x76),p1(0x5b),p1(0xa2),p1(0x49),p1(0x6d),p1(0x8b),p1(0xd1),p1(0x25)
 
648
#define ib_data2(p1) \
 
649
        .long   p1(0x72),p1(0xf8),p1(0xf6),p1(0x64),p1(0x86),p1(0x68),p1(0x98),p1(0x16) ;\
 
650
        .long   p1(0xd4),p1(0xa4),p1(0x5c),p1(0xcc),p1(0x5d),p1(0x65),p1(0xb6),p1(0x92) ;\
 
651
        .long   p1(0x6c),p1(0x70),p1(0x48),p1(0x50),p1(0xfd),p1(0xed),p1(0xb9),p1(0xda) ;\
 
652
        .long   p1(0x5e),p1(0x15),p1(0x46),p1(0x57),p1(0xa7),p1(0x8d),p1(0x9d),p1(0x84)
 
653
#define ib_data3(p1) \
 
654
        .long   p1(0x90),p1(0xd8),p1(0xab),p1(0x00),p1(0x8c),p1(0xbc),p1(0xd3),p1(0x0a) ;\
 
655
        .long   p1(0xf7),p1(0xe4),p1(0x58),p1(0x05),p1(0xb8),p1(0xb3),p1(0x45),p1(0x06) ;\
 
656
        .long   p1(0xd0),p1(0x2c),p1(0x1e),p1(0x8f),p1(0xca),p1(0x3f),p1(0x0f),p1(0x02) ;\
 
657
        .long   p1(0xc1),p1(0xaf),p1(0xbd),p1(0x03),p1(0x01),p1(0x13),p1(0x8a),p1(0x6b)
 
658
#define ib_data4(p1) \
 
659
        .long   p1(0x3a),p1(0x91),p1(0x11),p1(0x41),p1(0x4f),p1(0x67),p1(0xdc),p1(0xea) ;\
 
660
        .long   p1(0x97),p1(0xf2),p1(0xcf),p1(0xce),p1(0xf0),p1(0xb4),p1(0xe6),p1(0x73) ;\
 
661
        .long   p1(0x96),p1(0xac),p1(0x74),p1(0x22),p1(0xe7),p1(0xad),p1(0x35),p1(0x85) ;\
 
662
        .long   p1(0xe2),p1(0xf9),p1(0x37),p1(0xe8),p1(0x1c),p1(0x75),p1(0xdf),p1(0x6e)
 
663
#define ib_data5(p1) \
 
664
        .long   p1(0x47),p1(0xf1),p1(0x1a),p1(0x71),p1(0x1d),p1(0x29),p1(0xc5),p1(0x89) ;\
 
665
        .long   p1(0x6f),p1(0xb7),p1(0x62),p1(0x0e),p1(0xaa),p1(0x18),p1(0xbe),p1(0x1b) ;\
 
666
        .long   p1(0xfc),p1(0x56),p1(0x3e),p1(0x4b),p1(0xc6),p1(0xd2),p1(0x79),p1(0x20) ;\
 
667
        .long   p1(0x9a),p1(0xdb),p1(0xc0),p1(0xfe),p1(0x78),p1(0xcd),p1(0x5a),p1(0xf4)
 
668
#define ib_data6(p1) \
 
669
        .long   p1(0x1f),p1(0xdd),p1(0xa8),p1(0x33),p1(0x88),p1(0x07),p1(0xc7),p1(0x31) ;\
 
670
        .long   p1(0xb1),p1(0x12),p1(0x10),p1(0x59),p1(0x27),p1(0x80),p1(0xec),p1(0x5f) ;\
 
671
        .long   p1(0x60),p1(0x51),p1(0x7f),p1(0xa9),p1(0x19),p1(0xb5),p1(0x4a),p1(0x0d) ;\
 
672
        .long   p1(0x2d),p1(0xe5),p1(0x7a),p1(0x9f),p1(0x93),p1(0xc9),p1(0x9c),p1(0xef)
 
673
#define ib_data7(p1) \
 
674
        .long   p1(0xa0),p1(0xe0),p1(0x3b),p1(0x4d),p1(0xae),p1(0x2a),p1(0xf5),p1(0xb0) ;\
 
675
        .long   p1(0xc8),p1(0xeb),p1(0xbb),p1(0x3c),p1(0x83),p1(0x53),p1(0x99),p1(0x61) ;\
 
676
        .long   p1(0x17),p1(0x2b),p1(0x04),p1(0x7e),p1(0xba),p1(0x77),p1(0xd6),p1(0x26) ;\
 
677
        .long   p1(0xe1),p1(0x69),p1(0x14),p1(0x63),p1(0x55),p1(0x21),p1(0x0c),p1(0x7d)
 
678
 
 
679
// The rcon_table (needed for the key schedule)
 
680
//
 
681
// Here is original Dr Brian Gladman's source code:
 
682
//      _rcon_tab:
 
683
//      %assign x   1
 
684
//      %rep 29
 
685
//          dd  x
 
686
//      %assign x f2(x)
 
687
//      %endrep
 
688
//
 
689
// Here is precomputed output (it's more portable this way):
 
690
 
 
691
        .align  ALIGN32BYTES
 
692
aes_rcon_tab:
 
693
        .long   0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80
 
694
        .long   0x1b,0x36,0x6c,0xd8,0xab,0x4d,0x9a,0x2f
 
695
        .long   0x5e,0xbc,0x63,0xc6,0x97,0x35,0x6a,0xd4
 
696
        .long   0xb3,0x7d,0xfa,0xef,0xc5
 
697
 
 
698
// The forward xor tables
 
699
 
 
700
        .align  ALIGN32BYTES
 
701
aes_ft_tab:
 
702
        sb_data0(u0)
 
703
        sb_data1(u0)
 
704
        sb_data2(u0)
 
705
        sb_data3(u0)
 
706
        sb_data4(u0)
 
707
        sb_data5(u0)
 
708
        sb_data6(u0)
 
709
        sb_data7(u0)
 
710
 
 
711
        sb_data0(u1)
 
712
        sb_data1(u1)
 
713
        sb_data2(u1)
 
714
        sb_data3(u1)
 
715
        sb_data4(u1)
 
716
        sb_data5(u1)
 
717
        sb_data6(u1)
 
718
        sb_data7(u1)
 
719
 
 
720
        sb_data0(u2)
 
721
        sb_data1(u2)
 
722
        sb_data2(u2)
 
723
        sb_data3(u2)
 
724
        sb_data4(u2)
 
725
        sb_data5(u2)
 
726
        sb_data6(u2)
 
727
        sb_data7(u2)
 
728
 
 
729
        sb_data0(u3)
 
730
        sb_data1(u3)
 
731
        sb_data2(u3)
 
732
        sb_data3(u3)
 
733
        sb_data4(u3)
 
734
        sb_data5(u3)
 
735
        sb_data6(u3)
 
736
        sb_data7(u3)
 
737
 
 
738
        .align  ALIGN32BYTES
 
739
aes_fl_tab:
 
740
        sb_data0(w0)
 
741
        sb_data1(w0)
 
742
        sb_data2(w0)
 
743
        sb_data3(w0)
 
744
        sb_data4(w0)
 
745
        sb_data5(w0)
 
746
        sb_data6(w0)
 
747
        sb_data7(w0)
 
748
 
 
749
        sb_data0(w1)
 
750
        sb_data1(w1)
 
751
        sb_data2(w1)
 
752
        sb_data3(w1)
 
753
        sb_data4(w1)
 
754
        sb_data5(w1)
 
755
        sb_data6(w1)
 
756
        sb_data7(w1)
 
757
 
 
758
        sb_data0(w2)
 
759
        sb_data1(w2)
 
760
        sb_data2(w2)
 
761
        sb_data3(w2)
 
762
        sb_data4(w2)
 
763
        sb_data5(w2)
 
764
        sb_data6(w2)
 
765
        sb_data7(w2)
 
766
 
 
767
        sb_data0(w3)
 
768
        sb_data1(w3)
 
769
        sb_data2(w3)
 
770
        sb_data3(w3)
 
771
        sb_data4(w3)
 
772
        sb_data5(w3)
 
773
        sb_data6(w3)
 
774
        sb_data7(w3)
 
775
 
 
776
// The inverse xor tables
 
777
 
 
778
        .align  ALIGN32BYTES
 
779
aes_it_tab:
 
780
        ib_data0(v0)
 
781
        ib_data1(v0)
 
782
        ib_data2(v0)
 
783
        ib_data3(v0)
 
784
        ib_data4(v0)
 
785
        ib_data5(v0)
 
786
        ib_data6(v0)
 
787
        ib_data7(v0)
 
788
 
 
789
        ib_data0(v1)
 
790
        ib_data1(v1)
 
791
        ib_data2(v1)
 
792
        ib_data3(v1)
 
793
        ib_data4(v1)
 
794
        ib_data5(v1)
 
795
        ib_data6(v1)
 
796
        ib_data7(v1)
 
797
 
 
798
        ib_data0(v2)
 
799
        ib_data1(v2)
 
800
        ib_data2(v2)
 
801
        ib_data3(v2)
 
802
        ib_data4(v2)
 
803
        ib_data5(v2)
 
804
        ib_data6(v2)
 
805
        ib_data7(v2)
 
806
 
 
807
        ib_data0(v3)
 
808
        ib_data1(v3)
 
809
        ib_data2(v3)
 
810
        ib_data3(v3)
 
811
        ib_data4(v3)
 
812
        ib_data5(v3)
 
813
        ib_data6(v3)
 
814
        ib_data7(v3)
 
815
 
 
816
        .align  ALIGN32BYTES
 
817
aes_il_tab:
 
818
        ib_data0(w0)
 
819
        ib_data1(w0)
 
820
        ib_data2(w0)
 
821
        ib_data3(w0)
 
822
        ib_data4(w0)
 
823
        ib_data5(w0)
 
824
        ib_data6(w0)
 
825
        ib_data7(w0)
 
826
 
 
827
        ib_data0(w1)
 
828
        ib_data1(w1)
 
829
        ib_data2(w1)
 
830
        ib_data3(w1)
 
831
        ib_data4(w1)
 
832
        ib_data5(w1)
 
833
        ib_data6(w1)
 
834
        ib_data7(w1)
 
835
 
 
836
        ib_data0(w2)
 
837
        ib_data1(w2)
 
838
        ib_data2(w2)
 
839
        ib_data3(w2)
 
840
        ib_data4(w2)
 
841
        ib_data5(w2)
 
842
        ib_data6(w2)
 
843
        ib_data7(w2)
 
844
 
 
845
        ib_data0(w3)
 
846
        ib_data1(w3)
 
847
        ib_data2(w3)
 
848
        ib_data3(w3)
 
849
        ib_data4(w3)
 
850
        ib_data5(w3)
 
851
        ib_data6(w3)
 
852
        ib_data7(w3)
 
853
 
 
854
// The inverse mix column tables
 
855
 
 
856
        .align  ALIGN32BYTES
 
857
aes_im_tab:
 
858
        im_data0(v0)
 
859
        im_data1(v0)
 
860
        im_data2(v0)
 
861
        im_data3(v0)
 
862
        im_data4(v0)
 
863
        im_data5(v0)
 
864
        im_data6(v0)
 
865
        im_data7(v0)
 
866
 
 
867
        im_data0(v1)
 
868
        im_data1(v1)
 
869
        im_data2(v1)
 
870
        im_data3(v1)
 
871
        im_data4(v1)
 
872
        im_data5(v1)
 
873
        im_data6(v1)
 
874
        im_data7(v1)
 
875
 
 
876
        im_data0(v2)
 
877
        im_data1(v2)
 
878
        im_data2(v2)
 
879
        im_data3(v2)
 
880
        im_data4(v2)
 
881
        im_data5(v2)
 
882
        im_data6(v2)
 
883
        im_data7(v2)
 
884
 
 
885
        im_data0(v3)
 
886
        im_data1(v3)
 
887
        im_data2(v3)
 
888
        im_data3(v3)
 
889
        im_data4(v3)
 
890
        im_data5(v3)
 
891
        im_data6(v3)
 
892
        im_data7(v3)