projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'core-printk-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[deliverable/linux.git] / arch / x86 / crypto / aesni-intel_asm.S
1 /*
2 * Implement AES algorithm in Intel AES-NI instructions.
3 *
4 * The white paper of AES-NI instructions can be downloaded from:
5 * http://softwarecommunity.intel.com/isn/downloads/intelavx/AES-Instructions-Set_WP.pdf
6 *
7 * Copyright (C) 2008, Intel Corp.
8 * Author: Huang Ying <ying.huang@intel.com>
9 * Vinodh Gopal <vinodh.gopal@intel.com>
10 * Kahraman Akdemir
11 *
12 * Added RFC4106 AES-GCM support for 128-bit keys under the AEAD
13 * interface for 64-bit kernels.
14 * Authors: Erdinc Ozturk (erdinc.ozturk@intel.com)
15 * Aidan O'Mahony (aidan.o.mahony@intel.com)
16 * Adrian Hoban <adrian.hoban@intel.com>
17 * James Guilford (james.guilford@intel.com)
18 * Gabriele Paoloni <gabriele.paoloni@intel.com>
19 * Tadeusz Struk (tadeusz.struk@intel.com)
20 * Wajdi Feghali (wajdi.k.feghali@intel.com)
21 * Copyright (c) 2010, Intel Corporation.
22 *
23 * Ported x86_64 version to x86:
24 * Author: Mathias Krause <minipli@googlemail.com>
25 *
26 * This program is free software; you can redistribute it and/or modify
27 * it under the terms of the GNU General Public License as published by
28 * the Free Software Foundation; either version 2 of the License, or
29 * (at your option) any later version.
30 */
31
32 #include <linux/linkage.h>
33 #include <asm/inst.h>
34
35 #ifdef __x86_64__
36 .data
37 .align 16
38 .Lgf128mul_x_ble_mask:
39 .octa 0x00000000000000010000000000000087
40
41 POLY: .octa 0xC2000000000000000000000000000001
42 TWOONE: .octa 0x00000001000000000000000000000001
43
44 # order of these constants should not change.
45 # more specifically, ALL_F should follow SHIFT_MASK,
46 # and ZERO should follow ALL_F
47
48 SHUF_MASK: .octa 0x000102030405060708090A0B0C0D0E0F
49 MASK1: .octa 0x0000000000000000ffffffffffffffff
50 MASK2: .octa 0xffffffffffffffff0000000000000000
51 SHIFT_MASK: .octa 0x0f0e0d0c0b0a09080706050403020100
52 ALL_F: .octa 0xffffffffffffffffffffffffffffffff
53 ZERO: .octa 0x00000000000000000000000000000000
54 ONE: .octa 0x00000000000000000000000000000001
55 F_MIN_MASK: .octa 0xf1f2f3f4f5f6f7f8f9fafbfcfdfeff0
56 dec: .octa 0x1
57 enc: .octa 0x2
58
59
60 .text
61
62
63 #define STACK_OFFSET 8*3
64 #define HashKey 16*0 // store HashKey <<1 mod poly here
65 #define HashKey_2 16*1 // store HashKey^2 <<1 mod poly here
66 #define HashKey_3 16*2 // store HashKey^3 <<1 mod poly here
67 #define HashKey_4 16*3 // store HashKey^4 <<1 mod poly here
68 #define HashKey_k 16*4 // store XOR of High 64 bits and Low 64
69 // bits of HashKey <<1 mod poly here
70 //(for Karatsuba purposes)
71 #define HashKey_2_k 16*5 // store XOR of High 64 bits and Low 64
72 // bits of HashKey^2 <<1 mod poly here
73 // (for Karatsuba purposes)
74 #define HashKey_3_k 16*6 // store XOR of High 64 bits and Low 64
75 // bits of HashKey^3 <<1 mod poly here
76 // (for Karatsuba purposes)
77 #define HashKey_4_k 16*7 // store XOR of High 64 bits and Low 64
78 // bits of HashKey^4 <<1 mod poly here
79 // (for Karatsuba purposes)
80 #define VARIABLE_OFFSET 16*8
81
82 #define arg1 rdi
83 #define arg2 rsi
84 #define arg3 rdx
85 #define arg4 rcx
86 #define arg5 r8
87 #define arg6 r9
88 #define arg7 STACK_OFFSET+8(%r14)
89 #define arg8 STACK_OFFSET+16(%r14)
90 #define arg9 STACK_OFFSET+24(%r14)
91 #define arg10 STACK_OFFSET+32(%r14)
92 #endif
93
94
95 #define STATE1 %xmm0
96 #define STATE2 %xmm4
97 #define STATE3 %xmm5
98 #define STATE4 %xmm6
99 #define STATE STATE1
100 #define IN1 %xmm1
101 #define IN2 %xmm7
102 #define IN3 %xmm8
103 #define IN4 %xmm9
104 #define IN IN1
105 #define KEY %xmm2
106 #define IV %xmm3
107
108 #define BSWAP_MASK %xmm10
109 #define CTR %xmm11
110 #define INC %xmm12
111
112 #define GF128MUL_MASK %xmm10
113
114 #ifdef __x86_64__
115 #define AREG %rax
116 #define KEYP %rdi
117 #define OUTP %rsi
118 #define UKEYP OUTP
119 #define INP %rdx
120 #define LEN %rcx
121 #define IVP %r8
122 #define KLEN %r9d
123 #define T1 %r10
124 #define TKEYP T1
125 #define T2 %r11
126 #define TCTR_LOW T2
127 #else
128 #define AREG %eax
129 #define KEYP %edi
130 #define OUTP AREG
131 #define UKEYP OUTP
132 #define INP %edx
133 #define LEN %esi
134 #define IVP %ebp
135 #define KLEN %ebx
136 #define T1 %ecx
137 #define TKEYP T1
138 #endif
139
140
141 #ifdef __x86_64__
142 /* GHASH_MUL MACRO to implement: Data*HashKey mod (128,127,126,121,0)
143 *
144 *
145 * Input: A and B (128-bits each, bit-reflected)
146 * Output: C = A*B*x mod poly, (i.e. >>1 )
147 * To compute GH = GH*HashKey mod poly, give HK = HashKey<<1 mod poly as input
148 * GH = GH * HK * x mod poly which is equivalent to GH*HashKey mod poly.
149 *
150 */
151 .macro GHASH_MUL GH HK TMP1 TMP2 TMP3 TMP4 TMP5
152 movdqa \GH, \TMP1
153 pshufd $78, \GH, \TMP2
154 pshufd $78, \HK, \TMP3
155 pxor \GH, \TMP2 # TMP2 = a1+a0
156 pxor \HK, \TMP3 # TMP3 = b1+b0
157 PCLMULQDQ 0x11, \HK, \TMP1 # TMP1 = a1*b1
158 PCLMULQDQ 0x00, \HK, \GH # GH = a0*b0
159 PCLMULQDQ 0x00, \TMP3, \TMP2 # TMP2 = (a0+a1)*(b1+b0)
160 pxor \GH, \TMP2
161 pxor \TMP1, \TMP2 # TMP2 = (a0*b0)+(a1*b0)
162 movdqa \TMP2, \TMP3
163 pslldq $8, \TMP3 # left shift TMP3 2 DWs
164 psrldq $8, \TMP2 # right shift TMP2 2 DWs
165 pxor \TMP3, \GH
166 pxor \TMP2, \TMP1 # TMP2:GH holds the result of GH*HK
167
168 # first phase of the reduction
169
170 movdqa \GH, \TMP2
171 movdqa \GH, \TMP3
172 movdqa \GH, \TMP4 # copy GH into TMP2,TMP3 and TMP4
173 # in in order to perform
174 # independent shifts
175 pslld $31, \TMP2 # packed right shift <<31
176 pslld $30, \TMP3 # packed right shift <<30
177 pslld $25, \TMP4 # packed right shift <<25
178 pxor \TMP3, \TMP2 # xor the shifted versions
179 pxor \TMP4, \TMP2
180 movdqa \TMP2, \TMP5
181 psrldq $4, \TMP5 # right shift TMP5 1 DW
182 pslldq $12, \TMP2 # left shift TMP2 3 DWs
183 pxor \TMP2, \GH
184
185 # second phase of the reduction
186
187 movdqa \GH,\TMP2 # copy GH into TMP2,TMP3 and TMP4
188 # in in order to perform
189 # independent shifts
190 movdqa \GH,\TMP3
191 movdqa \GH,\TMP4
192 psrld $1,\TMP2 # packed left shift >>1
193 psrld $2,\TMP3 # packed left shift >>2
194 psrld $7,\TMP4 # packed left shift >>7
195 pxor \TMP3,\TMP2 # xor the shifted versions
196 pxor \TMP4,\TMP2
197 pxor \TMP5, \TMP2
198 pxor \TMP2, \GH
199 pxor \TMP1, \GH # result is in TMP1
200 .endm
201
202 /*
203 * if a = number of total plaintext bytes
204 * b = floor(a/16)
205 * num_initial_blocks = b mod 4
206 * encrypt the initial num_initial_blocks blocks and apply ghash on
207 * the ciphertext
208 * %r10, %r11, %r12, %rax, %xmm5, %xmm6, %xmm7, %xmm8, %xmm9 registers
209 * are clobbered
210 * arg1, %arg2, %arg3, %r14 are used as a pointer only, not modified
211 */
212
213
214 .macro INITIAL_BLOCKS_DEC num_initial_blocks TMP1 TMP2 TMP3 TMP4 TMP5 XMM0 XMM1 \
215 XMM2 XMM3 XMM4 XMMDst TMP6 TMP7 i i_seq operation
216 mov arg7, %r10 # %r10 = AAD
217 mov arg8, %r12 # %r12 = aadLen
218 mov %r12, %r11
219 pxor %xmm\i, %xmm\i
220 _get_AAD_loop\num_initial_blocks\operation:
221 movd (%r10), \TMP1
222 pslldq $12, \TMP1
223 psrldq $4, %xmm\i
224 pxor \TMP1, %xmm\i
225 add $4, %r10
226 sub $4, %r12
227 jne _get_AAD_loop\num_initial_blocks\operation
228 cmp $16, %r11
229 je _get_AAD_loop2_done\num_initial_blocks\operation
230 mov $16, %r12
231 _get_AAD_loop2\num_initial_blocks\operation:
232 psrldq $4, %xmm\i
233 sub $4, %r12
234 cmp %r11, %r12
235 jne _get_AAD_loop2\num_initial_blocks\operation
236 _get_AAD_loop2_done\num_initial_blocks\operation:
237 movdqa SHUF_MASK(%rip), %xmm14
238 PSHUFB_XMM %xmm14, %xmm\i # byte-reflect the AAD data
239
240 xor %r11, %r11 # initialise the data pointer offset as zero
241
242 # start AES for num_initial_blocks blocks
243
244 mov %arg5, %rax # %rax = *Y0
245 movdqu (%rax), \XMM0 # XMM0 = Y0
246 movdqa SHUF_MASK(%rip), %xmm14
247 PSHUFB_XMM %xmm14, \XMM0
248
249 .if (\i == 5) || (\i == 6) || (\i == 7)
250 .irpc index, \i_seq
251 paddd ONE(%rip), \XMM0 # INCR Y0
252 movdqa \XMM0, %xmm\index
253 movdqa SHUF_MASK(%rip), %xmm14
254 PSHUFB_XMM %xmm14, %xmm\index # perform a 16 byte swap
255
256 .endr
257 .irpc index, \i_seq
258 pxor 16*0(%arg1), %xmm\index
259 .endr
260 .irpc index, \i_seq
261 movaps 0x10(%rdi), \TMP1
262 AESENC \TMP1, %xmm\index # Round 1
263 .endr
264 .irpc index, \i_seq
265 movaps 0x20(%arg1), \TMP1
266 AESENC \TMP1, %xmm\index # Round 2
267 .endr
268 .irpc index, \i_seq
269 movaps 0x30(%arg1), \TMP1
270 AESENC \TMP1, %xmm\index # Round 2
271 .endr
272 .irpc index, \i_seq
273 movaps 0x40(%arg1), \TMP1
274 AESENC \TMP1, %xmm\index # Round 2
275 .endr
276 .irpc index, \i_seq
277 movaps 0x50(%arg1), \TMP1
278 AESENC \TMP1, %xmm\index # Round 2
279 .endr
280 .irpc index, \i_seq
281 movaps 0x60(%arg1), \TMP1
282 AESENC \TMP1, %xmm\index # Round 2
283 .endr
284 .irpc index, \i_seq
285 movaps 0x70(%arg1), \TMP1
286 AESENC \TMP1, %xmm\index # Round 2
287 .endr
288 .irpc index, \i_seq
289 movaps 0x80(%arg1), \TMP1
290 AESENC \TMP1, %xmm\index # Round 2
291 .endr
292 .irpc index, \i_seq
293 movaps 0x90(%arg1), \TMP1
294 AESENC \TMP1, %xmm\index # Round 2
295 .endr
296 .irpc index, \i_seq
297 movaps 0xa0(%arg1), \TMP1
298 AESENCLAST \TMP1, %xmm\index # Round 10
299 .endr
300 .irpc index, \i_seq
301 movdqu (%arg3 , %r11, 1), \TMP1
302 pxor \TMP1, %xmm\index
303 movdqu %xmm\index, (%arg2 , %r11, 1)
304 # write back plaintext/ciphertext for num_initial_blocks
305 add $16, %r11
306
307 movdqa \TMP1, %xmm\index
308 movdqa SHUF_MASK(%rip), %xmm14
309 PSHUFB_XMM %xmm14, %xmm\index
310
311 # prepare plaintext/ciphertext for GHASH computation
312 .endr
313 .endif
314 GHASH_MUL %xmm\i, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
315 # apply GHASH on num_initial_blocks blocks
316
317 .if \i == 5
318 pxor %xmm5, %xmm6
319 GHASH_MUL %xmm6, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
320 pxor %xmm6, %xmm7
321 GHASH_MUL %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
322 pxor %xmm7, %xmm8
323 GHASH_MUL %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
324 .elseif \i == 6
325 pxor %xmm6, %xmm7
326 GHASH_MUL %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
327 pxor %xmm7, %xmm8
328 GHASH_MUL %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
329 .elseif \i == 7
330 pxor %xmm7, %xmm8
331 GHASH_MUL %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
332 .endif
333 cmp $64, %r13
334 jl _initial_blocks_done\num_initial_blocks\operation
335 # no need for precomputed values
336 /*
337 *
338 * Precomputations for HashKey parallel with encryption of first 4 blocks.
339 * Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
340 */
341 paddd ONE(%rip), \XMM0 # INCR Y0
342 movdqa \XMM0, \XMM1
343 movdqa SHUF_MASK(%rip), %xmm14
344 PSHUFB_XMM %xmm14, \XMM1 # perform a 16 byte swap
345
346 paddd ONE(%rip), \XMM0 # INCR Y0
347 movdqa \XMM0, \XMM2
348 movdqa SHUF_MASK(%rip), %xmm14
349 PSHUFB_XMM %xmm14, \XMM2 # perform a 16 byte swap
350
351 paddd ONE(%rip), \XMM0 # INCR Y0
352 movdqa \XMM0, \XMM3
353 movdqa SHUF_MASK(%rip), %xmm14
354 PSHUFB_XMM %xmm14, \XMM3 # perform a 16 byte swap
355
356 paddd ONE(%rip), \XMM0 # INCR Y0
357 movdqa \XMM0, \XMM4
358 movdqa SHUF_MASK(%rip), %xmm14
359 PSHUFB_XMM %xmm14, \XMM4 # perform a 16 byte swap
360
361 pxor 16*0(%arg1), \XMM1
362 pxor 16*0(%arg1), \XMM2
363 pxor 16*0(%arg1), \XMM3
364 pxor 16*0(%arg1), \XMM4
365 movdqa \TMP3, \TMP5
366 pshufd $78, \TMP3, \TMP1
367 pxor \TMP3, \TMP1
368 movdqa \TMP1, HashKey_k(%rsp)
369 GHASH_MUL \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
370 # TMP5 = HashKey^2<<1 (mod poly)
371 movdqa \TMP5, HashKey_2(%rsp)
372 # HashKey_2 = HashKey^2<<1 (mod poly)
373 pshufd $78, \TMP5, \TMP1
374 pxor \TMP5, \TMP1
375 movdqa \TMP1, HashKey_2_k(%rsp)
376 .irpc index, 1234 # do 4 rounds
377 movaps 0x10*\index(%arg1), \TMP1
378 AESENC \TMP1, \XMM1
379 AESENC \TMP1, \XMM2
380 AESENC \TMP1, \XMM3
381 AESENC \TMP1, \XMM4
382 .endr
383 GHASH_MUL \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
384 # TMP5 = HashKey^3<<1 (mod poly)
385 movdqa \TMP5, HashKey_3(%rsp)
386 pshufd $78, \TMP5, \TMP1
387 pxor \TMP5, \TMP1
388 movdqa \TMP1, HashKey_3_k(%rsp)
389 .irpc index, 56789 # do next 5 rounds
390 movaps 0x10*\index(%arg1), \TMP1
391 AESENC \TMP1, \XMM1
392 AESENC \TMP1, \XMM2
393 AESENC \TMP1, \XMM3
394 AESENC \TMP1, \XMM4
395 .endr
396 GHASH_MUL \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
397 # TMP5 = HashKey^3<<1 (mod poly)
398 movdqa \TMP5, HashKey_4(%rsp)
399 pshufd $78, \TMP5, \TMP1
400 pxor \TMP5, \TMP1
401 movdqa \TMP1, HashKey_4_k(%rsp)
402 movaps 0xa0(%arg1), \TMP2
403 AESENCLAST \TMP2, \XMM1
404 AESENCLAST \TMP2, \XMM2
405 AESENCLAST \TMP2, \XMM3
406 AESENCLAST \TMP2, \XMM4
407 movdqu 16*0(%arg3 , %r11 , 1), \TMP1
408 pxor \TMP1, \XMM1
409 movdqu \XMM1, 16*0(%arg2 , %r11 , 1)
410 movdqa \TMP1, \XMM1
411 movdqu 16*1(%arg3 , %r11 , 1), \TMP1
412 pxor \TMP1, \XMM2
413 movdqu \XMM2, 16*1(%arg2 , %r11 , 1)
414 movdqa \TMP1, \XMM2
415 movdqu 16*2(%arg3 , %r11 , 1), \TMP1
416 pxor \TMP1, \XMM3
417 movdqu \XMM3, 16*2(%arg2 , %r11 , 1)
418 movdqa \TMP1, \XMM3
419 movdqu 16*3(%arg3 , %r11 , 1), \TMP1
420 pxor \TMP1, \XMM4
421 movdqu \XMM4, 16*3(%arg2 , %r11 , 1)
422 movdqa \TMP1, \XMM4
423 add $64, %r11
424 movdqa SHUF_MASK(%rip), %xmm14
425 PSHUFB_XMM %xmm14, \XMM1 # perform a 16 byte swap
426 pxor \XMMDst, \XMM1
427 # combine GHASHed value with the corresponding ciphertext
428 movdqa SHUF_MASK(%rip), %xmm14
429 PSHUFB_XMM %xmm14, \XMM2 # perform a 16 byte swap
430 movdqa SHUF_MASK(%rip), %xmm14
431 PSHUFB_XMM %xmm14, \XMM3 # perform a 16 byte swap
432 movdqa SHUF_MASK(%rip), %xmm14
433 PSHUFB_XMM %xmm14, \XMM4 # perform a 16 byte swap
434
435 _initial_blocks_done\num_initial_blocks\operation:
436
437 .endm
438
439
440 /*
441 * if a = number of total plaintext bytes
442 * b = floor(a/16)
443 * num_initial_blocks = b mod 4
444 * encrypt the initial num_initial_blocks blocks and apply ghash on
445 * the ciphertext
446 * %r10, %r11, %r12, %rax, %xmm5, %xmm6, %xmm7, %xmm8, %xmm9 registers
447 * are clobbered
448 * arg1, %arg2, %arg3, %r14 are used as a pointer only, not modified
449 */
450
451
452 .macro INITIAL_BLOCKS_ENC num_initial_blocks TMP1 TMP2 TMP3 TMP4 TMP5 XMM0 XMM1 \
453 XMM2 XMM3 XMM4 XMMDst TMP6 TMP7 i i_seq operation
454 mov arg7, %r10 # %r10 = AAD
455 mov arg8, %r12 # %r12 = aadLen
456 mov %r12, %r11
457 pxor %xmm\i, %xmm\i
458 _get_AAD_loop\num_initial_blocks\operation:
459 movd (%r10), \TMP1
460 pslldq $12, \TMP1
461 psrldq $4, %xmm\i
462 pxor \TMP1, %xmm\i
463 add $4, %r10
464 sub $4, %r12
465 jne _get_AAD_loop\num_initial_blocks\operation
466 cmp $16, %r11
467 je _get_AAD_loop2_done\num_initial_blocks\operation
468 mov $16, %r12
469 _get_AAD_loop2\num_initial_blocks\operation:
470 psrldq $4, %xmm\i
471 sub $4, %r12
472 cmp %r11, %r12
473 jne _get_AAD_loop2\num_initial_blocks\operation
474 _get_AAD_loop2_done\num_initial_blocks\operation:
475 movdqa SHUF_MASK(%rip), %xmm14
476 PSHUFB_XMM %xmm14, %xmm\i # byte-reflect the AAD data
477
478 xor %r11, %r11 # initialise the data pointer offset as zero
479
480 # start AES for num_initial_blocks blocks
481
482 mov %arg5, %rax # %rax = *Y0
483 movdqu (%rax), \XMM0 # XMM0 = Y0
484 movdqa SHUF_MASK(%rip), %xmm14
485 PSHUFB_XMM %xmm14, \XMM0
486
487 .if (\i == 5) || (\i == 6) || (\i == 7)
488 .irpc index, \i_seq
489 paddd ONE(%rip), \XMM0 # INCR Y0
490 movdqa \XMM0, %xmm\index
491 movdqa SHUF_MASK(%rip), %xmm14
492 PSHUFB_XMM %xmm14, %xmm\index # perform a 16 byte swap
493
494 .endr
495 .irpc index, \i_seq
496 pxor 16*0(%arg1), %xmm\index
497 .endr
498 .irpc index, \i_seq
499 movaps 0x10(%rdi), \TMP1
500 AESENC \TMP1, %xmm\index # Round 1
501 .endr
502 .irpc index, \i_seq
503 movaps 0x20(%arg1), \TMP1
504 AESENC \TMP1, %xmm\index # Round 2
505 .endr
506 .irpc index, \i_seq
507 movaps 0x30(%arg1), \TMP1
508 AESENC \TMP1, %xmm\index # Round 2
509 .endr
510 .irpc index, \i_seq
511 movaps 0x40(%arg1), \TMP1
512 AESENC \TMP1, %xmm\index # Round 2
513 .endr
514 .irpc index, \i_seq
515 movaps 0x50(%arg1), \TMP1
516 AESENC \TMP1, %xmm\index # Round 2
517 .endr
518 .irpc index, \i_seq
519 movaps 0x60(%arg1), \TMP1
520 AESENC \TMP1, %xmm\index # Round 2
521 .endr
522 .irpc index, \i_seq
523 movaps 0x70(%arg1), \TMP1
524 AESENC \TMP1, %xmm\index # Round 2
525 .endr
526 .irpc index, \i_seq
527 movaps 0x80(%arg1), \TMP1
528 AESENC \TMP1, %xmm\index # Round 2
529 .endr
530 .irpc index, \i_seq
531 movaps 0x90(%arg1), \TMP1
532 AESENC \TMP1, %xmm\index # Round 2
533 .endr
534 .irpc index, \i_seq
535 movaps 0xa0(%arg1), \TMP1
536 AESENCLAST \TMP1, %xmm\index # Round 10
537 .endr
538 .irpc index, \i_seq
539 movdqu (%arg3 , %r11, 1), \TMP1
540 pxor \TMP1, %xmm\index
541 movdqu %xmm\index, (%arg2 , %r11, 1)
542 # write back plaintext/ciphertext for num_initial_blocks
543 add $16, %r11
544
545 movdqa SHUF_MASK(%rip), %xmm14
546 PSHUFB_XMM %xmm14, %xmm\index
547
548 # prepare plaintext/ciphertext for GHASH computation
549 .endr
550 .endif
551 GHASH_MUL %xmm\i, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
552 # apply GHASH on num_initial_blocks blocks
553
554 .if \i == 5
555 pxor %xmm5, %xmm6
556 GHASH_MUL %xmm6, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
557 pxor %xmm6, %xmm7
558 GHASH_MUL %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
559 pxor %xmm7, %xmm8
560 GHASH_MUL %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
561 .elseif \i == 6
562 pxor %xmm6, %xmm7
563 GHASH_MUL %xmm7, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
564 pxor %xmm7, %xmm8
565 GHASH_MUL %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
566 .elseif \i == 7
567 pxor %xmm7, %xmm8
568 GHASH_MUL %xmm8, \TMP3, \TMP1, \TMP2, \TMP4, \TMP5, \XMM1
569 .endif
570 cmp $64, %r13
571 jl _initial_blocks_done\num_initial_blocks\operation
572 # no need for precomputed values
573 /*
574 *
575 * Precomputations for HashKey parallel with encryption of first 4 blocks.
576 * Haskey_i_k holds XORed values of the low and high parts of the Haskey_i
577 */
578 paddd ONE(%rip), \XMM0 # INCR Y0
579 movdqa \XMM0, \XMM1
580 movdqa SHUF_MASK(%rip), %xmm14
581 PSHUFB_XMM %xmm14, \XMM1 # perform a 16 byte swap
582
583 paddd ONE(%rip), \XMM0 # INCR Y0
584 movdqa \XMM0, \XMM2
585 movdqa SHUF_MASK(%rip), %xmm14
586 PSHUFB_XMM %xmm14, \XMM2 # perform a 16 byte swap
587
588 paddd ONE(%rip), \XMM0 # INCR Y0
589 movdqa \XMM0, \XMM3
590 movdqa SHUF_MASK(%rip), %xmm14
591 PSHUFB_XMM %xmm14, \XMM3 # perform a 16 byte swap
592
593 paddd ONE(%rip), \XMM0 # INCR Y0
594 movdqa \XMM0, \XMM4
595 movdqa SHUF_MASK(%rip), %xmm14
596 PSHUFB_XMM %xmm14, \XMM4 # perform a 16 byte swap
597
598 pxor 16*0(%arg1), \XMM1
599 pxor 16*0(%arg1), \XMM2
600 pxor 16*0(%arg1), \XMM3
601 pxor 16*0(%arg1), \XMM4
602 movdqa \TMP3, \TMP5
603 pshufd $78, \TMP3, \TMP1
604 pxor \TMP3, \TMP1
605 movdqa \TMP1, HashKey_k(%rsp)
606 GHASH_MUL \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
607 # TMP5 = HashKey^2<<1 (mod poly)
608 movdqa \TMP5, HashKey_2(%rsp)
609 # HashKey_2 = HashKey^2<<1 (mod poly)
610 pshufd $78, \TMP5, \TMP1
611 pxor \TMP5, \TMP1
612 movdqa \TMP1, HashKey_2_k(%rsp)
613 .irpc index, 1234 # do 4 rounds
614 movaps 0x10*\index(%arg1), \TMP1
615 AESENC \TMP1, \XMM1
616 AESENC \TMP1, \XMM2
617 AESENC \TMP1, \XMM3
618 AESENC \TMP1, \XMM4
619 .endr
620 GHASH_MUL \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
621 # TMP5 = HashKey^3<<1 (mod poly)
622 movdqa \TMP5, HashKey_3(%rsp)
623 pshufd $78, \TMP5, \TMP1
624 pxor \TMP5, \TMP1
625 movdqa \TMP1, HashKey_3_k(%rsp)
626 .irpc index, 56789 # do next 5 rounds
627 movaps 0x10*\index(%arg1), \TMP1
628 AESENC \TMP1, \XMM1
629 AESENC \TMP1, \XMM2
630 AESENC \TMP1, \XMM3
631 AESENC \TMP1, \XMM4
632 .endr
633 GHASH_MUL \TMP5, \TMP3, \TMP1, \TMP2, \TMP4, \TMP6, \TMP7
634 # TMP5 = HashKey^3<<1 (mod poly)
635 movdqa \TMP5, HashKey_4(%rsp)
636 pshufd $78, \TMP5, \TMP1
637 pxor \TMP5, \TMP1
638 movdqa \TMP1, HashKey_4_k(%rsp)
639 movaps 0xa0(%arg1), \TMP2
640 AESENCLAST \TMP2, \XMM1
641 AESENCLAST \TMP2, \XMM2
642 AESENCLAST \TMP2, \XMM3
643 AESENCLAST \TMP2, \XMM4
644 movdqu 16*0(%arg3 , %r11 , 1), \TMP1
645 pxor \TMP1, \XMM1
646 movdqu 16*1(%arg3 , %r11 , 1), \TMP1
647 pxor \TMP1, \XMM2
648 movdqu 16*2(%arg3 , %r11 , 1), \TMP1
649 pxor \TMP1, \XMM3
650 movdqu 16*3(%arg3 , %r11 , 1), \TMP1
651 pxor \TMP1, \XMM4
652 movdqu \XMM1, 16*0(%arg2 , %r11 , 1)
653 movdqu \XMM2, 16*1(%arg2 , %r11 , 1)
654 movdqu \XMM3, 16*2(%arg2 , %r11 , 1)
655 movdqu \XMM4, 16*3(%arg2 , %r11 , 1)
656
657 add $64, %r11
658 movdqa SHUF_MASK(%rip), %xmm14
659 PSHUFB_XMM %xmm14, \XMM1 # perform a 16 byte swap
660 pxor \XMMDst, \XMM1
661 # combine GHASHed value with the corresponding ciphertext
662 movdqa SHUF_MASK(%rip), %xmm14
663 PSHUFB_XMM %xmm14, \XMM2 # perform a 16 byte swap
664 movdqa SHUF_MASK(%rip), %xmm14
665 PSHUFB_XMM %xmm14, \XMM3 # perform a 16 byte swap
666 movdqa SHUF_MASK(%rip), %xmm14
667 PSHUFB_XMM %xmm14, \XMM4 # perform a 16 byte swap
668
669 _initial_blocks_done\num_initial_blocks\operation:
670
671 .endm
672
673 /*
674 * encrypt 4 blocks at a time
675 * ghash the 4 previously encrypted ciphertext blocks
676 * arg1, %arg2, %arg3 are used as pointers only, not modified
677 * %r11 is the data offset value
678 */
679 .macro GHASH_4_ENCRYPT_4_PARALLEL_ENC TMP1 TMP2 TMP3 TMP4 TMP5 \
680 TMP6 XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 operation
681
682 movdqa \XMM1, \XMM5
683 movdqa \XMM2, \XMM6
684 movdqa \XMM3, \XMM7
685 movdqa \XMM4, \XMM8
686
687 movdqa SHUF_MASK(%rip), %xmm15
688 # multiply TMP5 * HashKey using karatsuba
689
690 movdqa \XMM5, \TMP4
691 pshufd $78, \XMM5, \TMP6
692 pxor \XMM5, \TMP6
693 paddd ONE(%rip), \XMM0 # INCR CNT
694 movdqa HashKey_4(%rsp), \TMP5
695 PCLMULQDQ 0x11, \TMP5, \TMP4 # TMP4 = a1*b1
696 movdqa \XMM0, \XMM1
697 paddd ONE(%rip), \XMM0 # INCR CNT
698 movdqa \XMM0, \XMM2
699 paddd ONE(%rip), \XMM0 # INCR CNT
700 movdqa \XMM0, \XMM3
701 paddd ONE(%rip), \XMM0 # INCR CNT
702 movdqa \XMM0, \XMM4
703 PSHUFB_XMM %xmm15, \XMM1 # perform a 16 byte swap
704 PCLMULQDQ 0x00, \TMP5, \XMM5 # XMM5 = a0*b0
705 PSHUFB_XMM %xmm15, \XMM2 # perform a 16 byte swap
706 PSHUFB_XMM %xmm15, \XMM3 # perform a 16 byte swap
707 PSHUFB_XMM %xmm15, \XMM4 # perform a 16 byte swap
708
709 pxor (%arg1), \XMM1
710 pxor (%arg1), \XMM2
711 pxor (%arg1), \XMM3
712 pxor (%arg1), \XMM4
713 movdqa HashKey_4_k(%rsp), \TMP5
714 PCLMULQDQ 0x00, \TMP5, \TMP6 # TMP6 = (a1+a0)*(b1+b0)
715 movaps 0x10(%arg1), \TMP1
716 AESENC \TMP1, \XMM1 # Round 1
717 AESENC \TMP1, \XMM2
718 AESENC \TMP1, \XMM3
719 AESENC \TMP1, \XMM4
720 movaps 0x20(%arg1), \TMP1
721 AESENC \TMP1, \XMM1 # Round 2
722 AESENC \TMP1, \XMM2
723 AESENC \TMP1, \XMM3
724 AESENC \TMP1, \XMM4
725 movdqa \XMM6, \TMP1
726 pshufd $78, \XMM6, \TMP2
727 pxor \XMM6, \TMP2
728 movdqa HashKey_3(%rsp), \TMP5
729 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1 * b1
730 movaps 0x30(%arg1), \TMP3
731 AESENC \TMP3, \XMM1 # Round 3
732 AESENC \TMP3, \XMM2
733 AESENC \TMP3, \XMM3
734 AESENC \TMP3, \XMM4
735 PCLMULQDQ 0x00, \TMP5, \XMM6 # XMM6 = a0*b0
736 movaps 0x40(%arg1), \TMP3
737 AESENC \TMP3, \XMM1 # Round 4
738 AESENC \TMP3, \XMM2
739 AESENC \TMP3, \XMM3
740 AESENC \TMP3, \XMM4
741 movdqa HashKey_3_k(%rsp), \TMP5
742 PCLMULQDQ 0x00, \TMP5, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
743 movaps 0x50(%arg1), \TMP3
744 AESENC \TMP3, \XMM1 # Round 5
745 AESENC \TMP3, \XMM2
746 AESENC \TMP3, \XMM3
747 AESENC \TMP3, \XMM4
748 pxor \TMP1, \TMP4
749 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
750 pxor \XMM6, \XMM5
751 pxor \TMP2, \TMP6
752 movdqa \XMM7, \TMP1
753 pshufd $78, \XMM7, \TMP2
754 pxor \XMM7, \TMP2
755 movdqa HashKey_2(%rsp ), \TMP5
756
757 # Multiply TMP5 * HashKey using karatsuba
758
759 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1*b1
760 movaps 0x60(%arg1), \TMP3
761 AESENC \TMP3, \XMM1 # Round 6
762 AESENC \TMP3, \XMM2
763 AESENC \TMP3, \XMM3
764 AESENC \TMP3, \XMM4
765 PCLMULQDQ 0x00, \TMP5, \XMM7 # XMM7 = a0*b0
766 movaps 0x70(%arg1), \TMP3
767 AESENC \TMP3, \XMM1 # Round 7
768 AESENC \TMP3, \XMM2
769 AESENC \TMP3, \XMM3
770 AESENC \TMP3, \XMM4
771 movdqa HashKey_2_k(%rsp), \TMP5
772 PCLMULQDQ 0x00, \TMP5, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
773 movaps 0x80(%arg1), \TMP3
774 AESENC \TMP3, \XMM1 # Round 8
775 AESENC \TMP3, \XMM2
776 AESENC \TMP3, \XMM3
777 AESENC \TMP3, \XMM4
778 pxor \TMP1, \TMP4
779 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
780 pxor \XMM7, \XMM5
781 pxor \TMP2, \TMP6
782
783 # Multiply XMM8 * HashKey
784 # XMM8 and TMP5 hold the values for the two operands
785
786 movdqa \XMM8, \TMP1
787 pshufd $78, \XMM8, \TMP2
788 pxor \XMM8, \TMP2
789 movdqa HashKey(%rsp), \TMP5
790 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1*b1
791 movaps 0x90(%arg1), \TMP3
792 AESENC \TMP3, \XMM1 # Round 9
793 AESENC \TMP3, \XMM2
794 AESENC \TMP3, \XMM3
795 AESENC \TMP3, \XMM4
796 PCLMULQDQ 0x00, \TMP5, \XMM8 # XMM8 = a0*b0
797 movaps 0xa0(%arg1), \TMP3
798 AESENCLAST \TMP3, \XMM1 # Round 10
799 AESENCLAST \TMP3, \XMM2
800 AESENCLAST \TMP3, \XMM3
801 AESENCLAST \TMP3, \XMM4
802 movdqa HashKey_k(%rsp), \TMP5
803 PCLMULQDQ 0x00, \TMP5, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
804 movdqu (%arg3,%r11,1), \TMP3
805 pxor \TMP3, \XMM1 # Ciphertext/Plaintext XOR EK
806 movdqu 16(%arg3,%r11,1), \TMP3
807 pxor \TMP3, \XMM2 # Ciphertext/Plaintext XOR EK
808 movdqu 32(%arg3,%r11,1), \TMP3
809 pxor \TMP3, \XMM3 # Ciphertext/Plaintext XOR EK
810 movdqu 48(%arg3,%r11,1), \TMP3
811 pxor \TMP3, \XMM4 # Ciphertext/Plaintext XOR EK
812 movdqu \XMM1, (%arg2,%r11,1) # Write to the ciphertext buffer
813 movdqu \XMM2, 16(%arg2,%r11,1) # Write to the ciphertext buffer
814 movdqu \XMM3, 32(%arg2,%r11,1) # Write to the ciphertext buffer
815 movdqu \XMM4, 48(%arg2,%r11,1) # Write to the ciphertext buffer
816 PSHUFB_XMM %xmm15, \XMM1 # perform a 16 byte swap
817 PSHUFB_XMM %xmm15, \XMM2 # perform a 16 byte swap
818 PSHUFB_XMM %xmm15, \XMM3 # perform a 16 byte swap
819 PSHUFB_XMM %xmm15, \XMM4 # perform a 16 byte swap
820
821 pxor \TMP4, \TMP1
822 pxor \XMM8, \XMM5
823 pxor \TMP6, \TMP2
824 pxor \TMP1, \TMP2
825 pxor \XMM5, \TMP2
826 movdqa \TMP2, \TMP3
827 pslldq $8, \TMP3 # left shift TMP3 2 DWs
828 psrldq $8, \TMP2 # right shift TMP2 2 DWs
829 pxor \TMP3, \XMM5
830 pxor \TMP2, \TMP1 # accumulate the results in TMP1:XMM5
831
832 # first phase of reduction
833
834 movdqa \XMM5, \TMP2
835 movdqa \XMM5, \TMP3
836 movdqa \XMM5, \TMP4
837 # move XMM5 into TMP2, TMP3, TMP4 in order to perform shifts independently
838 pslld $31, \TMP2 # packed right shift << 31
839 pslld $30, \TMP3 # packed right shift << 30
840 pslld $25, \TMP4 # packed right shift << 25
841 pxor \TMP3, \TMP2 # xor the shifted versions
842 pxor \TMP4, \TMP2
843 movdqa \TMP2, \TMP5
844 psrldq $4, \TMP5 # right shift T5 1 DW
845 pslldq $12, \TMP2 # left shift T2 3 DWs
846 pxor \TMP2, \XMM5
847
848 # second phase of reduction
849
850 movdqa \XMM5,\TMP2 # make 3 copies of XMM5 into TMP2, TMP3, TMP4
851 movdqa \XMM5,\TMP3
852 movdqa \XMM5,\TMP4
853 psrld $1, \TMP2 # packed left shift >>1
854 psrld $2, \TMP3 # packed left shift >>2
855 psrld $7, \TMP4 # packed left shift >>7
856 pxor \TMP3,\TMP2 # xor the shifted versions
857 pxor \TMP4,\TMP2
858 pxor \TMP5, \TMP2
859 pxor \TMP2, \XMM5
860 pxor \TMP1, \XMM5 # result is in TMP1
861
862 pxor \XMM5, \XMM1
863 .endm
864
865 /*
866 * decrypt 4 blocks at a time
867 * ghash the 4 previously decrypted ciphertext blocks
868 * arg1, %arg2, %arg3 are used as pointers only, not modified
869 * %r11 is the data offset value
870 */
871 .macro GHASH_4_ENCRYPT_4_PARALLEL_DEC TMP1 TMP2 TMP3 TMP4 TMP5 \
872 TMP6 XMM0 XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 operation
873
874 movdqa \XMM1, \XMM5
875 movdqa \XMM2, \XMM6
876 movdqa \XMM3, \XMM7
877 movdqa \XMM4, \XMM8
878
879 movdqa SHUF_MASK(%rip), %xmm15
880 # multiply TMP5 * HashKey using karatsuba
881
882 movdqa \XMM5, \TMP4
883 pshufd $78, \XMM5, \TMP6
884 pxor \XMM5, \TMP6
885 paddd ONE(%rip), \XMM0 # INCR CNT
886 movdqa HashKey_4(%rsp), \TMP5
887 PCLMULQDQ 0x11, \TMP5, \TMP4 # TMP4 = a1*b1
888 movdqa \XMM0, \XMM1
889 paddd ONE(%rip), \XMM0 # INCR CNT
890 movdqa \XMM0, \XMM2
891 paddd ONE(%rip), \XMM0 # INCR CNT
892 movdqa \XMM0, \XMM3
893 paddd ONE(%rip), \XMM0 # INCR CNT
894 movdqa \XMM0, \XMM4
895 PSHUFB_XMM %xmm15, \XMM1 # perform a 16 byte swap
896 PCLMULQDQ 0x00, \TMP5, \XMM5 # XMM5 = a0*b0
897 PSHUFB_XMM %xmm15, \XMM2 # perform a 16 byte swap
898 PSHUFB_XMM %xmm15, \XMM3 # perform a 16 byte swap
899 PSHUFB_XMM %xmm15, \XMM4 # perform a 16 byte swap
900
901 pxor (%arg1), \XMM1
902 pxor (%arg1), \XMM2
903 pxor (%arg1), \XMM3
904 pxor (%arg1), \XMM4
905 movdqa HashKey_4_k(%rsp), \TMP5
906 PCLMULQDQ 0x00, \TMP5, \TMP6 # TMP6 = (a1+a0)*(b1+b0)
907 movaps 0x10(%arg1), \TMP1
908 AESENC \TMP1, \XMM1 # Round 1
909 AESENC \TMP1, \XMM2
910 AESENC \TMP1, \XMM3
911 AESENC \TMP1, \XMM4
912 movaps 0x20(%arg1), \TMP1
913 AESENC \TMP1, \XMM1 # Round 2
914 AESENC \TMP1, \XMM2
915 AESENC \TMP1, \XMM3
916 AESENC \TMP1, \XMM4
917 movdqa \XMM6, \TMP1
918 pshufd $78, \XMM6, \TMP2
919 pxor \XMM6, \TMP2
920 movdqa HashKey_3(%rsp), \TMP5
921 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1 * b1
922 movaps 0x30(%arg1), \TMP3
923 AESENC \TMP3, \XMM1 # Round 3
924 AESENC \TMP3, \XMM2
925 AESENC \TMP3, \XMM3
926 AESENC \TMP3, \XMM4
927 PCLMULQDQ 0x00, \TMP5, \XMM6 # XMM6 = a0*b0
928 movaps 0x40(%arg1), \TMP3
929 AESENC \TMP3, \XMM1 # Round 4
930 AESENC \TMP3, \XMM2
931 AESENC \TMP3, \XMM3
932 AESENC \TMP3, \XMM4
933 movdqa HashKey_3_k(%rsp), \TMP5
934 PCLMULQDQ 0x00, \TMP5, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
935 movaps 0x50(%arg1), \TMP3
936 AESENC \TMP3, \XMM1 # Round 5
937 AESENC \TMP3, \XMM2
938 AESENC \TMP3, \XMM3
939 AESENC \TMP3, \XMM4
940 pxor \TMP1, \TMP4
941 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
942 pxor \XMM6, \XMM5
943 pxor \TMP2, \TMP6
944 movdqa \XMM7, \TMP1
945 pshufd $78, \XMM7, \TMP2
946 pxor \XMM7, \TMP2
947 movdqa HashKey_2(%rsp ), \TMP5
948
949 # Multiply TMP5 * HashKey using karatsuba
950
951 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1*b1
952 movaps 0x60(%arg1), \TMP3
953 AESENC \TMP3, \XMM1 # Round 6
954 AESENC \TMP3, \XMM2
955 AESENC \TMP3, \XMM3
956 AESENC \TMP3, \XMM4
957 PCLMULQDQ 0x00, \TMP5, \XMM7 # XMM7 = a0*b0
958 movaps 0x70(%arg1), \TMP3
959 AESENC \TMP3, \XMM1 # Round 7
960 AESENC \TMP3, \XMM2
961 AESENC \TMP3, \XMM3
962 AESENC \TMP3, \XMM4
963 movdqa HashKey_2_k(%rsp), \TMP5
964 PCLMULQDQ 0x00, \TMP5, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
965 movaps 0x80(%arg1), \TMP3
966 AESENC \TMP3, \XMM1 # Round 8
967 AESENC \TMP3, \XMM2
968 AESENC \TMP3, \XMM3
969 AESENC \TMP3, \XMM4
970 pxor \TMP1, \TMP4
971 # accumulate the results in TMP4:XMM5, TMP6 holds the middle part
972 pxor \XMM7, \XMM5
973 pxor \TMP2, \TMP6
974
975 # Multiply XMM8 * HashKey
976 # XMM8 and TMP5 hold the values for the two operands
977
978 movdqa \XMM8, \TMP1
979 pshufd $78, \XMM8, \TMP2
980 pxor \XMM8, \TMP2
981 movdqa HashKey(%rsp), \TMP5
982 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1*b1
983 movaps 0x90(%arg1), \TMP3
984 AESENC \TMP3, \XMM1 # Round 9
985 AESENC \TMP3, \XMM2
986 AESENC \TMP3, \XMM3
987 AESENC \TMP3, \XMM4
988 PCLMULQDQ 0x00, \TMP5, \XMM8 # XMM8 = a0*b0
989 movaps 0xa0(%arg1), \TMP3
990 AESENCLAST \TMP3, \XMM1 # Round 10
991 AESENCLAST \TMP3, \XMM2
992 AESENCLAST \TMP3, \XMM3
993 AESENCLAST \TMP3, \XMM4
994 movdqa HashKey_k(%rsp), \TMP5
995 PCLMULQDQ 0x00, \TMP5, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
996 movdqu (%arg3,%r11,1), \TMP3
997 pxor \TMP3, \XMM1 # Ciphertext/Plaintext XOR EK
998 movdqu \XMM1, (%arg2,%r11,1) # Write to plaintext buffer
999 movdqa \TMP3, \XMM1
1000 movdqu 16(%arg3,%r11,1), \TMP3
1001 pxor \TMP3, \XMM2 # Ciphertext/Plaintext XOR EK
1002 movdqu \XMM2, 16(%arg2,%r11,1) # Write to plaintext buffer
1003 movdqa \TMP3, \XMM2
1004 movdqu 32(%arg3,%r11,1), \TMP3
1005 pxor \TMP3, \XMM3 # Ciphertext/Plaintext XOR EK
1006 movdqu \XMM3, 32(%arg2,%r11,1) # Write to plaintext buffer
1007 movdqa \TMP3, \XMM3
1008 movdqu 48(%arg3,%r11,1), \TMP3
1009 pxor \TMP3, \XMM4 # Ciphertext/Plaintext XOR EK
1010 movdqu \XMM4, 48(%arg2,%r11,1) # Write to plaintext buffer
1011 movdqa \TMP3, \XMM4
1012 PSHUFB_XMM %xmm15, \XMM1 # perform a 16 byte swap
1013 PSHUFB_XMM %xmm15, \XMM2 # perform a 16 byte swap
1014 PSHUFB_XMM %xmm15, \XMM3 # perform a 16 byte swap
1015 PSHUFB_XMM %xmm15, \XMM4 # perform a 16 byte swap
1016
1017 pxor \TMP4, \TMP1
1018 pxor \XMM8, \XMM5
1019 pxor \TMP6, \TMP2
1020 pxor \TMP1, \TMP2
1021 pxor \XMM5, \TMP2
1022 movdqa \TMP2, \TMP3
1023 pslldq $8, \TMP3 # left shift TMP3 2 DWs
1024 psrldq $8, \TMP2 # right shift TMP2 2 DWs
1025 pxor \TMP3, \XMM5
1026 pxor \TMP2, \TMP1 # accumulate the results in TMP1:XMM5
1027
1028 # first phase of reduction
1029
1030 movdqa \XMM5, \TMP2
1031 movdqa \XMM5, \TMP3
1032 movdqa \XMM5, \TMP4
1033 # move XMM5 into TMP2, TMP3, TMP4 in order to perform shifts independently
1034 pslld $31, \TMP2 # packed right shift << 31
1035 pslld $30, \TMP3 # packed right shift << 30
1036 pslld $25, \TMP4 # packed right shift << 25
1037 pxor \TMP3, \TMP2 # xor the shifted versions
1038 pxor \TMP4, \TMP2
1039 movdqa \TMP2, \TMP5
1040 psrldq $4, \TMP5 # right shift T5 1 DW
1041 pslldq $12, \TMP2 # left shift T2 3 DWs
1042 pxor \TMP2, \XMM5
1043
1044 # second phase of reduction
1045
1046 movdqa \XMM5,\TMP2 # make 3 copies of XMM5 into TMP2, TMP3, TMP4
1047 movdqa \XMM5,\TMP3
1048 movdqa \XMM5,\TMP4
1049 psrld $1, \TMP2 # packed left shift >>1
1050 psrld $2, \TMP3 # packed left shift >>2
1051 psrld $7, \TMP4 # packed left shift >>7
1052 pxor \TMP3,\TMP2 # xor the shifted versions
1053 pxor \TMP4,\TMP2
1054 pxor \TMP5, \TMP2
1055 pxor \TMP2, \XMM5
1056 pxor \TMP1, \XMM5 # result is in TMP1
1057
1058 pxor \XMM5, \XMM1
1059 .endm
1060
1061 /* GHASH the last 4 ciphertext blocks. */
1062 .macro GHASH_LAST_4 TMP1 TMP2 TMP3 TMP4 TMP5 TMP6 \
1063 TMP7 XMM1 XMM2 XMM3 XMM4 XMMDst
1064
1065 # Multiply TMP6 * HashKey (using Karatsuba)
1066
1067 movdqa \XMM1, \TMP6
1068 pshufd $78, \XMM1, \TMP2
1069 pxor \XMM1, \TMP2
1070 movdqa HashKey_4(%rsp), \TMP5
1071 PCLMULQDQ 0x11, \TMP5, \TMP6 # TMP6 = a1*b1
1072 PCLMULQDQ 0x00, \TMP5, \XMM1 # XMM1 = a0*b0
1073 movdqa HashKey_4_k(%rsp), \TMP4
1074 PCLMULQDQ 0x00, \TMP4, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
1075 movdqa \XMM1, \XMMDst
1076 movdqa \TMP2, \XMM1 # result in TMP6, XMMDst, XMM1
1077
1078 # Multiply TMP1 * HashKey (using Karatsuba)
1079
1080 movdqa \XMM2, \TMP1
1081 pshufd $78, \XMM2, \TMP2
1082 pxor \XMM2, \TMP2
1083 movdqa HashKey_3(%rsp), \TMP5
1084 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1*b1
1085 PCLMULQDQ 0x00, \TMP5, \XMM2 # XMM2 = a0*b0
1086 movdqa HashKey_3_k(%rsp), \TMP4
1087 PCLMULQDQ 0x00, \TMP4, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
1088 pxor \TMP1, \TMP6
1089 pxor \XMM2, \XMMDst
1090 pxor \TMP2, \XMM1
1091 # results accumulated in TMP6, XMMDst, XMM1
1092
1093 # Multiply TMP1 * HashKey (using Karatsuba)
1094
1095 movdqa \XMM3, \TMP1
1096 pshufd $78, \XMM3, \TMP2
1097 pxor \XMM3, \TMP2
1098 movdqa HashKey_2(%rsp), \TMP5
1099 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1*b1
1100 PCLMULQDQ 0x00, \TMP5, \XMM3 # XMM3 = a0*b0
1101 movdqa HashKey_2_k(%rsp), \TMP4
1102 PCLMULQDQ 0x00, \TMP4, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
1103 pxor \TMP1, \TMP6
1104 pxor \XMM3, \XMMDst
1105 pxor \TMP2, \XMM1 # results accumulated in TMP6, XMMDst, XMM1
1106
1107 # Multiply TMP1 * HashKey (using Karatsuba)
1108 movdqa \XMM4, \TMP1
1109 pshufd $78, \XMM4, \TMP2
1110 pxor \XMM4, \TMP2
1111 movdqa HashKey(%rsp), \TMP5
1112 PCLMULQDQ 0x11, \TMP5, \TMP1 # TMP1 = a1*b1
1113 PCLMULQDQ 0x00, \TMP5, \XMM4 # XMM4 = a0*b0
1114 movdqa HashKey_k(%rsp), \TMP4
1115 PCLMULQDQ 0x00, \TMP4, \TMP2 # TMP2 = (a1+a0)*(b1+b0)
1116 pxor \TMP1, \TMP6
1117 pxor \XMM4, \XMMDst
1118 pxor \XMM1, \TMP2
1119 pxor \TMP6, \TMP2
1120 pxor \XMMDst, \TMP2
1121 # middle section of the temp results combined as in karatsuba algorithm
1122 movdqa \TMP2, \TMP4
1123 pslldq $8, \TMP4 # left shift TMP4 2 DWs
1124 psrldq $8, \TMP2 # right shift TMP2 2 DWs
1125 pxor \TMP4, \XMMDst
1126 pxor \TMP2, \TMP6
1127 # TMP6:XMMDst holds the result of the accumulated carry-less multiplications
1128 # first phase of the reduction
1129 movdqa \XMMDst, \TMP2
1130 movdqa \XMMDst, \TMP3
1131 movdqa \XMMDst, \TMP4
1132 # move XMMDst into TMP2, TMP3, TMP4 in order to perform 3 shifts independently
1133 pslld $31, \TMP2 # packed right shifting << 31
1134 pslld $30, \TMP3 # packed right shifting << 30
1135 pslld $25, \TMP4 # packed right shifting << 25
1136 pxor \TMP3, \TMP2 # xor the shifted versions
1137 pxor \TMP4, \TMP2
1138 movdqa \TMP2, \TMP7
1139 psrldq $4, \TMP7 # right shift TMP7 1 DW
1140 pslldq $12, \TMP2 # left shift TMP2 3 DWs
1141 pxor \TMP2, \XMMDst
1142
1143 # second phase of the reduction
1144 movdqa \XMMDst, \TMP2
1145 # make 3 copies of XMMDst for doing 3 shift operations
1146 movdqa \XMMDst, \TMP3
1147 movdqa \XMMDst, \TMP4
1148 psrld $1, \TMP2 # packed left shift >> 1
1149 psrld $2, \TMP3 # packed left shift >> 2
1150 psrld $7, \TMP4 # packed left shift >> 7
1151 pxor \TMP3, \TMP2 # xor the shifted versions
1152 pxor \TMP4, \TMP2
1153 pxor \TMP7, \TMP2
1154 pxor \TMP2, \XMMDst
1155 pxor \TMP6, \XMMDst # reduced result is in XMMDst
1156 .endm
1157
1158 /* Encryption of a single block done*/
1159 .macro ENCRYPT_SINGLE_BLOCK XMM0 TMP1
1160
1161 pxor (%arg1), \XMM0
1162 movaps 16(%arg1), \TMP1
1163 AESENC \TMP1, \XMM0
1164 movaps 32(%arg1), \TMP1
1165 AESENC \TMP1, \XMM0
1166 movaps 48(%arg1), \TMP1
1167 AESENC \TMP1, \XMM0
1168 movaps 64(%arg1), \TMP1
1169 AESENC \TMP1, \XMM0
1170 movaps 80(%arg1), \TMP1
1171 AESENC \TMP1, \XMM0
1172 movaps 96(%arg1), \TMP1
1173 AESENC \TMP1, \XMM0
1174 movaps 112(%arg1), \TMP1
1175 AESENC \TMP1, \XMM0
1176 movaps 128(%arg1), \TMP1
1177 AESENC \TMP1, \XMM0
1178 movaps 144(%arg1), \TMP1
1179 AESENC \TMP1, \XMM0
1180 movaps 160(%arg1), \TMP1
1181 AESENCLAST \TMP1, \XMM0
1182 .endm
1183
1184
1185 /*****************************************************************************
1186 * void aesni_gcm_dec(void *aes_ctx, // AES Key schedule. Starts on a 16 byte boundary.
1187 * u8 *out, // Plaintext output. Encrypt in-place is allowed.
1188 * const u8 *in, // Ciphertext input
1189 * u64 plaintext_len, // Length of data in bytes for decryption.
1190 * u8 *iv, // Pre-counter block j0: 4 byte salt (from Security Association)
1191 * // concatenated with 8 byte Initialisation Vector (from IPSec ESP Payload)
1192 * // concatenated with 0x00000001. 16-byte aligned pointer.
1193 * u8 *hash_subkey, // H, the Hash sub key input. Data starts on a 16-byte boundary.
1194 * const u8 *aad, // Additional Authentication Data (AAD)
1195 * u64 aad_len, // Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 bytes
1196 * u8 *auth_tag, // Authenticated Tag output. The driver will compare this to the
1197 * // given authentication tag and only return the plaintext if they match.
1198 * u64 auth_tag_len); // Authenticated Tag Length in bytes. Valid values are 16
1199 * // (most likely), 12 or 8.
1200 *
1201 * Assumptions:
1202 *
1203 * keys:
1204 * keys are pre-expanded and aligned to 16 bytes. we are using the first
1205 * set of 11 keys in the data structure void *aes_ctx
1206 *
1207 * iv:
1208 * 0 1 2 3
1209 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1210 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1211 * | Salt (From the SA) |
1212 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1213 * | Initialization Vector |
1214 * | (This is the sequence number from IPSec header) |
1215 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1216 * | 0x1 |
1217 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1218 *
1219 *
1220 *
1221 * AAD:
1222 * AAD padded to 128 bits with 0
1223 * for example, assume AAD is a u32 vector
1224 *
1225 * if AAD is 8 bytes:
1226 * AAD[3] = {A0, A1};
1227 * padded AAD in xmm register = {A1 A0 0 0}
1228 *
1229 * 0 1 2 3
1230 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1231 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1232 * | SPI (A1) |
1233 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1234 * | 32-bit Sequence Number (A0) |
1235 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1236 * | 0x0 |
1237 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1238 *
1239 * AAD Format with 32-bit Sequence Number
1240 *
1241 * if AAD is 12 bytes:
1242 * AAD[3] = {A0, A1, A2};
1243 * padded AAD in xmm register = {A2 A1 A0 0}
1244 *
1245 * 0 1 2 3
1246 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1247 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1248 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1249 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1250 * | SPI (A2) |
1251 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1252 * | 64-bit Extended Sequence Number {A1,A0} |
1253 * | |
1254 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1255 * | 0x0 |
1256 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1257 *
1258 * AAD Format with 64-bit Extended Sequence Number
1259 *
1260 * aadLen:
1261 * from the definition of the spec, aadLen can only be 8 or 12 bytes.
1262 * The code supports 16 too but for other sizes, the code will fail.
1263 *
1264 * TLen:
1265 * from the definition of the spec, TLen can only be 8, 12 or 16 bytes.
1266 * For other sizes, the code will fail.
1267 *
1268 * poly = x^128 + x^127 + x^126 + x^121 + 1
1269 *
1270 *****************************************************************************/
1271 ENTRY(aesni_gcm_dec)
1272 push %r12
1273 push %r13
1274 push %r14
1275 mov %rsp, %r14
1276 /*
1277 * states of %xmm registers %xmm6:%xmm15 not saved
1278 * all %xmm registers are clobbered
1279 */
1280 sub $VARIABLE_OFFSET, %rsp
1281 and $~63, %rsp # align rsp to 64 bytes
1282 mov %arg6, %r12
1283 movdqu (%r12), %xmm13 # %xmm13 = HashKey
1284 movdqa SHUF_MASK(%rip), %xmm2
1285 PSHUFB_XMM %xmm2, %xmm13
1286
1287
1288 # Precompute HashKey<<1 (mod poly) from the hash key (required for GHASH)
1289
1290 movdqa %xmm13, %xmm2
1291 psllq $1, %xmm13
1292 psrlq $63, %xmm2
1293 movdqa %xmm2, %xmm1
1294 pslldq $8, %xmm2
1295 psrldq $8, %xmm1
1296 por %xmm2, %xmm13
1297
1298 # Reduction
1299
1300 pshufd $0x24, %xmm1, %xmm2
1301 pcmpeqd TWOONE(%rip), %xmm2
1302 pand POLY(%rip), %xmm2
1303 pxor %xmm2, %xmm13 # %xmm13 holds the HashKey<<1 (mod poly)
1304
1305
1306 # Decrypt first few blocks
1307
1308 movdqa %xmm13, HashKey(%rsp) # store HashKey<<1 (mod poly)
1309 mov %arg4, %r13 # save the number of bytes of plaintext/ciphertext
1310 and $-16, %r13 # %r13 = %r13 - (%r13 mod 16)
1311 mov %r13, %r12
1312 and $(3<<4), %r12
1313 jz _initial_num_blocks_is_0_decrypt
1314 cmp $(2<<4), %r12
1315 jb _initial_num_blocks_is_1_decrypt
1316 je _initial_num_blocks_is_2_decrypt
1317 _initial_num_blocks_is_3_decrypt:
1318 INITIAL_BLOCKS_DEC 3, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1319 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 5, 678, dec
1320 sub $48, %r13
1321 jmp _initial_blocks_decrypted
1322 _initial_num_blocks_is_2_decrypt:
1323 INITIAL_BLOCKS_DEC 2, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1324 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 6, 78, dec
1325 sub $32, %r13
1326 jmp _initial_blocks_decrypted
1327 _initial_num_blocks_is_1_decrypt:
1328 INITIAL_BLOCKS_DEC 1, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1329 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 7, 8, dec
1330 sub $16, %r13
1331 jmp _initial_blocks_decrypted
1332 _initial_num_blocks_is_0_decrypt:
1333 INITIAL_BLOCKS_DEC 0, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1334 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 8, 0, dec
1335 _initial_blocks_decrypted:
1336 cmp $0, %r13
1337 je _zero_cipher_left_decrypt
1338 sub $64, %r13
1339 je _four_cipher_left_decrypt
1340 _decrypt_by_4:
1341 GHASH_4_ENCRYPT_4_PARALLEL_DEC %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, \
1342 %xmm14, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, dec
1343 add $64, %r11
1344 sub $64, %r13
1345 jne _decrypt_by_4
1346 _four_cipher_left_decrypt:
1347 GHASH_LAST_4 %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, \
1348 %xmm15, %xmm1, %xmm2, %xmm3, %xmm4, %xmm8
1349 _zero_cipher_left_decrypt:
1350 mov %arg4, %r13
1351 and $15, %r13 # %r13 = arg4 (mod 16)
1352 je _multiple_of_16_bytes_decrypt
1353
1354 # Handle the last <16 byte block separately
1355
1356 paddd ONE(%rip), %xmm0 # increment CNT to get Yn
1357 movdqa SHUF_MASK(%rip), %xmm10
1358 PSHUFB_XMM %xmm10, %xmm0
1359
1360 ENCRYPT_SINGLE_BLOCK %xmm0, %xmm1 # E(K, Yn)
1361 sub $16, %r11
1362 add %r13, %r11
1363 movdqu (%arg3,%r11,1), %xmm1 # receive the last <16 byte block
1364 lea SHIFT_MASK+16(%rip), %r12
1365 sub %r13, %r12
1366 # adjust the shuffle mask pointer to be able to shift 16-%r13 bytes
1367 # (%r13 is the number of bytes in plaintext mod 16)
1368 movdqu (%r12), %xmm2 # get the appropriate shuffle mask
1369 PSHUFB_XMM %xmm2, %xmm1 # right shift 16-%r13 butes
1370
1371 movdqa %xmm1, %xmm2
1372 pxor %xmm1, %xmm0 # Ciphertext XOR E(K, Yn)
1373 movdqu ALL_F-SHIFT_MASK(%r12), %xmm1
1374 # get the appropriate mask to mask out top 16-%r13 bytes of %xmm0
1375 pand %xmm1, %xmm0 # mask out top 16-%r13 bytes of %xmm0
1376 pand %xmm1, %xmm2
1377 movdqa SHUF_MASK(%rip), %xmm10
1378 PSHUFB_XMM %xmm10 ,%xmm2
1379
1380 pxor %xmm2, %xmm8
1381 GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
1382 # GHASH computation for the last <16 byte block
1383 sub %r13, %r11
1384 add $16, %r11
1385
1386 # output %r13 bytes
1387 MOVQ_R64_XMM %xmm0, %rax
1388 cmp $8, %r13
1389 jle _less_than_8_bytes_left_decrypt
1390 mov %rax, (%arg2 , %r11, 1)
1391 add $8, %r11
1392 psrldq $8, %xmm0
1393 MOVQ_R64_XMM %xmm0, %rax
1394 sub $8, %r13
1395 _less_than_8_bytes_left_decrypt:
1396 mov %al, (%arg2, %r11, 1)
1397 add $1, %r11
1398 shr $8, %rax
1399 sub $1, %r13
1400 jne _less_than_8_bytes_left_decrypt
1401 _multiple_of_16_bytes_decrypt:
1402 mov arg8, %r12 # %r13 = aadLen (number of bytes)
1403 shl $3, %r12 # convert into number of bits
1404 movd %r12d, %xmm15 # len(A) in %xmm15
1405 shl $3, %arg4 # len(C) in bits (*128)
1406 MOVQ_R64_XMM %arg4, %xmm1
1407 pslldq $8, %xmm15 # %xmm15 = len(A)||0x0000000000000000
1408 pxor %xmm1, %xmm15 # %xmm15 = len(A)||len(C)
1409 pxor %xmm15, %xmm8
1410 GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
1411 # final GHASH computation
1412 movdqa SHUF_MASK(%rip), %xmm10
1413 PSHUFB_XMM %xmm10, %xmm8
1414
1415 mov %arg5, %rax # %rax = *Y0
1416 movdqu (%rax), %xmm0 # %xmm0 = Y0
1417 ENCRYPT_SINGLE_BLOCK %xmm0, %xmm1 # E(K, Y0)
1418 pxor %xmm8, %xmm0
1419 _return_T_decrypt:
1420 mov arg9, %r10 # %r10 = authTag
1421 mov arg10, %r11 # %r11 = auth_tag_len
1422 cmp $16, %r11
1423 je _T_16_decrypt
1424 cmp $12, %r11
1425 je _T_12_decrypt
1426 _T_8_decrypt:
1427 MOVQ_R64_XMM %xmm0, %rax
1428 mov %rax, (%r10)
1429 jmp _return_T_done_decrypt
1430 _T_12_decrypt:
1431 MOVQ_R64_XMM %xmm0, %rax
1432 mov %rax, (%r10)
1433 psrldq $8, %xmm0
1434 movd %xmm0, %eax
1435 mov %eax, 8(%r10)
1436 jmp _return_T_done_decrypt
1437 _T_16_decrypt:
1438 movdqu %xmm0, (%r10)
1439 _return_T_done_decrypt:
1440 mov %r14, %rsp
1441 pop %r14
1442 pop %r13
1443 pop %r12
1444 ret
1445 ENDPROC(aesni_gcm_dec)
1446
1447
1448 /*****************************************************************************
1449 * void aesni_gcm_enc(void *aes_ctx, // AES Key schedule. Starts on a 16 byte boundary.
1450 * u8 *out, // Ciphertext output. Encrypt in-place is allowed.
1451 * const u8 *in, // Plaintext input
1452 * u64 plaintext_len, // Length of data in bytes for encryption.
1453 * u8 *iv, // Pre-counter block j0: 4 byte salt (from Security Association)
1454 * // concatenated with 8 byte Initialisation Vector (from IPSec ESP Payload)
1455 * // concatenated with 0x00000001. 16-byte aligned pointer.
1456 * u8 *hash_subkey, // H, the Hash sub key input. Data starts on a 16-byte boundary.
1457 * const u8 *aad, // Additional Authentication Data (AAD)
1458 * u64 aad_len, // Length of AAD in bytes. With RFC4106 this is going to be 8 or 12 bytes
1459 * u8 *auth_tag, // Authenticated Tag output.
1460 * u64 auth_tag_len); // Authenticated Tag Length in bytes. Valid values are 16 (most likely),
1461 * // 12 or 8.
1462 *
1463 * Assumptions:
1464 *
1465 * keys:
1466 * keys are pre-expanded and aligned to 16 bytes. we are using the
1467 * first set of 11 keys in the data structure void *aes_ctx
1468 *
1469 *
1470 * iv:
1471 * 0 1 2 3
1472 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1473 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1474 * | Salt (From the SA) |
1475 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1476 * | Initialization Vector |
1477 * | (This is the sequence number from IPSec header) |
1478 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1479 * | 0x1 |
1480 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1481 *
1482 *
1483 *
1484 * AAD:
1485 * AAD padded to 128 bits with 0
1486 * for example, assume AAD is a u32 vector
1487 *
1488 * if AAD is 8 bytes:
1489 * AAD[3] = {A0, A1};
1490 * padded AAD in xmm register = {A1 A0 0 0}
1491 *
1492 * 0 1 2 3
1493 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1494 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1495 * | SPI (A1) |
1496 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1497 * | 32-bit Sequence Number (A0) |
1498 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1499 * | 0x0 |
1500 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1501 *
1502 * AAD Format with 32-bit Sequence Number
1503 *
1504 * if AAD is 12 bytes:
1505 * AAD[3] = {A0, A1, A2};
1506 * padded AAD in xmm register = {A2 A1 A0 0}
1507 *
1508 * 0 1 2 3
1509 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1510 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1511 * | SPI (A2) |
1512 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1513 * | 64-bit Extended Sequence Number {A1,A0} |
1514 * | |
1515 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1516 * | 0x0 |
1517 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1518 *
1519 * AAD Format with 64-bit Extended Sequence Number
1520 *
1521 * aadLen:
1522 * from the definition of the spec, aadLen can only be 8 or 12 bytes.
1523 * The code supports 16 too but for other sizes, the code will fail.
1524 *
1525 * TLen:
1526 * from the definition of the spec, TLen can only be 8, 12 or 16 bytes.
1527 * For other sizes, the code will fail.
1528 *
1529 * poly = x^128 + x^127 + x^126 + x^121 + 1
1530 ***************************************************************************/
1531 ENTRY(aesni_gcm_enc)
1532 push %r12
1533 push %r13
1534 push %r14
1535 mov %rsp, %r14
1536 #
1537 # states of %xmm registers %xmm6:%xmm15 not saved
1538 # all %xmm registers are clobbered
1539 #
1540 sub $VARIABLE_OFFSET, %rsp
1541 and $~63, %rsp
1542 mov %arg6, %r12
1543 movdqu (%r12), %xmm13
1544 movdqa SHUF_MASK(%rip), %xmm2
1545 PSHUFB_XMM %xmm2, %xmm13
1546
1547
1548 # precompute HashKey<<1 mod poly from the HashKey (required for GHASH)
1549
1550 movdqa %xmm13, %xmm2
1551 psllq $1, %xmm13
1552 psrlq $63, %xmm2
1553 movdqa %xmm2, %xmm1
1554 pslldq $8, %xmm2
1555 psrldq $8, %xmm1
1556 por %xmm2, %xmm13
1557
1558 # reduce HashKey<<1
1559
1560 pshufd $0x24, %xmm1, %xmm2
1561 pcmpeqd TWOONE(%rip), %xmm2
1562 pand POLY(%rip), %xmm2
1563 pxor %xmm2, %xmm13
1564 movdqa %xmm13, HashKey(%rsp)
1565 mov %arg4, %r13 # %xmm13 holds HashKey<<1 (mod poly)
1566 and $-16, %r13
1567 mov %r13, %r12
1568
1569 # Encrypt first few blocks
1570
1571 and $(3<<4), %r12
1572 jz _initial_num_blocks_is_0_encrypt
1573 cmp $(2<<4), %r12
1574 jb _initial_num_blocks_is_1_encrypt
1575 je _initial_num_blocks_is_2_encrypt
1576 _initial_num_blocks_is_3_encrypt:
1577 INITIAL_BLOCKS_ENC 3, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1578 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 5, 678, enc
1579 sub $48, %r13
1580 jmp _initial_blocks_encrypted
1581 _initial_num_blocks_is_2_encrypt:
1582 INITIAL_BLOCKS_ENC 2, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1583 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 6, 78, enc
1584 sub $32, %r13
1585 jmp _initial_blocks_encrypted
1586 _initial_num_blocks_is_1_encrypt:
1587 INITIAL_BLOCKS_ENC 1, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1588 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 7, 8, enc
1589 sub $16, %r13
1590 jmp _initial_blocks_encrypted
1591 _initial_num_blocks_is_0_encrypt:
1592 INITIAL_BLOCKS_ENC 0, %xmm9, %xmm10, %xmm13, %xmm11, %xmm12, %xmm0, \
1593 %xmm1, %xmm2, %xmm3, %xmm4, %xmm8, %xmm5, %xmm6, 8, 0, enc
1594 _initial_blocks_encrypted:
1595
1596 # Main loop - Encrypt remaining blocks
1597
1598 cmp $0, %r13
1599 je _zero_cipher_left_encrypt
1600 sub $64, %r13
1601 je _four_cipher_left_encrypt
1602 _encrypt_by_4_encrypt:
1603 GHASH_4_ENCRYPT_4_PARALLEL_ENC %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, \
1604 %xmm14, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7, %xmm8, enc
1605 add $64, %r11
1606 sub $64, %r13
1607 jne _encrypt_by_4_encrypt
1608 _four_cipher_left_encrypt:
1609 GHASH_LAST_4 %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14, \
1610 %xmm15, %xmm1, %xmm2, %xmm3, %xmm4, %xmm8
1611 _zero_cipher_left_encrypt:
1612 mov %arg4, %r13
1613 and $15, %r13 # %r13 = arg4 (mod 16)
1614 je _multiple_of_16_bytes_encrypt
1615
1616 # Handle the last <16 Byte block separately
1617 paddd ONE(%rip), %xmm0 # INCR CNT to get Yn
1618 movdqa SHUF_MASK(%rip), %xmm10
1619 PSHUFB_XMM %xmm10, %xmm0
1620
1621
1622 ENCRYPT_SINGLE_BLOCK %xmm0, %xmm1 # Encrypt(K, Yn)
1623 sub $16, %r11
1624 add %r13, %r11
1625 movdqu (%arg3,%r11,1), %xmm1 # receive the last <16 byte blocks
1626 lea SHIFT_MASK+16(%rip), %r12
1627 sub %r13, %r12
1628 # adjust the shuffle mask pointer to be able to shift 16-r13 bytes
1629 # (%r13 is the number of bytes in plaintext mod 16)
1630 movdqu (%r12), %xmm2 # get the appropriate shuffle mask
1631 PSHUFB_XMM %xmm2, %xmm1 # shift right 16-r13 byte
1632 pxor %xmm1, %xmm0 # Plaintext XOR Encrypt(K, Yn)
1633 movdqu ALL_F-SHIFT_MASK(%r12), %xmm1
1634 # get the appropriate mask to mask out top 16-r13 bytes of xmm0
1635 pand %xmm1, %xmm0 # mask out top 16-r13 bytes of xmm0
1636 movdqa SHUF_MASK(%rip), %xmm10
1637 PSHUFB_XMM %xmm10,%xmm0
1638
1639 pxor %xmm0, %xmm8
1640 GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
1641 # GHASH computation for the last <16 byte block
1642 sub %r13, %r11
1643 add $16, %r11
1644
1645 movdqa SHUF_MASK(%rip), %xmm10
1646 PSHUFB_XMM %xmm10, %xmm0
1647
1648 # shuffle xmm0 back to output as ciphertext
1649
1650 # Output %r13 bytes
1651 MOVQ_R64_XMM %xmm0, %rax
1652 cmp $8, %r13
1653 jle _less_than_8_bytes_left_encrypt
1654 mov %rax, (%arg2 , %r11, 1)
1655 add $8, %r11
1656 psrldq $8, %xmm0
1657 MOVQ_R64_XMM %xmm0, %rax
1658 sub $8, %r13
1659 _less_than_8_bytes_left_encrypt:
1660 mov %al, (%arg2, %r11, 1)
1661 add $1, %r11
1662 shr $8, %rax
1663 sub $1, %r13
1664 jne _less_than_8_bytes_left_encrypt
1665 _multiple_of_16_bytes_encrypt:
1666 mov arg8, %r12 # %r12 = addLen (number of bytes)
1667 shl $3, %r12
1668 movd %r12d, %xmm15 # len(A) in %xmm15
1669 shl $3, %arg4 # len(C) in bits (*128)
1670 MOVQ_R64_XMM %arg4, %xmm1
1671 pslldq $8, %xmm15 # %xmm15 = len(A)||0x0000000000000000
1672 pxor %xmm1, %xmm15 # %xmm15 = len(A)||len(C)
1673 pxor %xmm15, %xmm8
1674 GHASH_MUL %xmm8, %xmm13, %xmm9, %xmm10, %xmm11, %xmm5, %xmm6
1675 # final GHASH computation
1676 movdqa SHUF_MASK(%rip), %xmm10
1677 PSHUFB_XMM %xmm10, %xmm8 # perform a 16 byte swap
1678
1679 mov %arg5, %rax # %rax = *Y0
1680 movdqu (%rax), %xmm0 # %xmm0 = Y0
1681 ENCRYPT_SINGLE_BLOCK %xmm0, %xmm15 # Encrypt(K, Y0)
1682 pxor %xmm8, %xmm0
1683 _return_T_encrypt:
1684 mov arg9, %r10 # %r10 = authTag
1685 mov arg10, %r11 # %r11 = auth_tag_len
1686 cmp $16, %r11
1687 je _T_16_encrypt
1688 cmp $12, %r11
1689 je _T_12_encrypt
1690 _T_8_encrypt:
1691 MOVQ_R64_XMM %xmm0, %rax
1692 mov %rax, (%r10)
1693 jmp _return_T_done_encrypt
1694 _T_12_encrypt:
1695 MOVQ_R64_XMM %xmm0, %rax
1696 mov %rax, (%r10)
1697 psrldq $8, %xmm0
1698 movd %xmm0, %eax
1699 mov %eax, 8(%r10)
1700 jmp _return_T_done_encrypt
1701 _T_16_encrypt:
1702 movdqu %xmm0, (%r10)
1703 _return_T_done_encrypt:
1704 mov %r14, %rsp
1705 pop %r14
1706 pop %r13
1707 pop %r12
1708 ret
1709 ENDPROC(aesni_gcm_enc)
1710
1711 #endif
1712
1713
1714 .align 4
1715 _key_expansion_128:
1716 _key_expansion_256a:
1717 pshufd $0b11111111, %xmm1, %xmm1
1718 shufps $0b00010000, %xmm0, %xmm4
1719 pxor %xmm4, %xmm0
1720 shufps $0b10001100, %xmm0, %xmm4
1721 pxor %xmm4, %xmm0
1722 pxor %xmm1, %xmm0
1723 movaps %xmm0, (TKEYP)
1724 add $0x10, TKEYP
1725 ret
1726 ENDPROC(_key_expansion_128)
1727 ENDPROC(_key_expansion_256a)
1728
1729 .align 4
1730 _key_expansion_192a:
1731 pshufd $0b01010101, %xmm1, %xmm1
1732 shufps $0b00010000, %xmm0, %xmm4
1733 pxor %xmm4, %xmm0
1734 shufps $0b10001100, %xmm0, %xmm4
1735 pxor %xmm4, %xmm0
1736 pxor %xmm1, %xmm0
1737
1738 movaps %xmm2, %xmm5
1739 movaps %xmm2, %xmm6
1740 pslldq $4, %xmm5
1741 pshufd $0b11111111, %xmm0, %xmm3
1742 pxor %xmm3, %xmm2
1743 pxor %xmm5, %xmm2
1744
1745 movaps %xmm0, %xmm1
1746 shufps $0b01000100, %xmm0, %xmm6
1747 movaps %xmm6, (TKEYP)
1748 shufps $0b01001110, %xmm2, %xmm1
1749 movaps %xmm1, 0x10(TKEYP)
1750 add $0x20, TKEYP
1751 ret
1752 ENDPROC(_key_expansion_192a)
1753
1754 .align 4
1755 _key_expansion_192b:
1756 pshufd $0b01010101, %xmm1, %xmm1
1757 shufps $0b00010000, %xmm0, %xmm4
1758 pxor %xmm4, %xmm0
1759 shufps $0b10001100, %xmm0, %xmm4
1760 pxor %xmm4, %xmm0
1761 pxor %xmm1, %xmm0
1762
1763 movaps %xmm2, %xmm5
1764 pslldq $4, %xmm5
1765 pshufd $0b11111111, %xmm0, %xmm3
1766 pxor %xmm3, %xmm2
1767 pxor %xmm5, %xmm2
1768
1769 movaps %xmm0, (TKEYP)
1770 add $0x10, TKEYP
1771 ret
1772 ENDPROC(_key_expansion_192b)
1773
1774 .align 4
1775 _key_expansion_256b:
1776 pshufd $0b10101010, %xmm1, %xmm1
1777 shufps $0b00010000, %xmm2, %xmm4
1778 pxor %xmm4, %xmm2
1779 shufps $0b10001100, %xmm2, %xmm4
1780 pxor %xmm4, %xmm2
1781 pxor %xmm1, %xmm2
1782 movaps %xmm2, (TKEYP)
1783 add $0x10, TKEYP
1784 ret
1785 ENDPROC(_key_expansion_256b)
1786
1787 /*
1788 * int aesni_set_key(struct crypto_aes_ctx *ctx, const u8 *in_key,
1789 * unsigned int key_len)
1790 */
1791 ENTRY(aesni_set_key)
1792 #ifndef __x86_64__
1793 pushl KEYP
1794 movl 8(%esp), KEYP # ctx
1795 movl 12(%esp), UKEYP # in_key
1796 movl 16(%esp), %edx # key_len
1797 #endif
1798 movups (UKEYP), %xmm0 # user key (first 16 bytes)
1799 movaps %xmm0, (KEYP)
1800 lea 0x10(KEYP), TKEYP # key addr
1801 movl %edx, 480(KEYP)
1802 pxor %xmm4, %xmm4 # xmm4 is assumed 0 in _key_expansion_x
1803 cmp $24, %dl
1804 jb .Lenc_key128
1805 je .Lenc_key192
1806 movups 0x10(UKEYP), %xmm2 # other user key
1807 movaps %xmm2, (TKEYP)
1808 add $0x10, TKEYP
1809 AESKEYGENASSIST 0x1 %xmm2 %xmm1 # round 1
1810 call _key_expansion_256a
1811 AESKEYGENASSIST 0x1 %xmm0 %xmm1
1812 call _key_expansion_256b
1813 AESKEYGENASSIST 0x2 %xmm2 %xmm1 # round 2
1814 call _key_expansion_256a
1815 AESKEYGENASSIST 0x2 %xmm0 %xmm1
1816 call _key_expansion_256b
1817 AESKEYGENASSIST 0x4 %xmm2 %xmm1 # round 3
1818 call _key_expansion_256a
1819 AESKEYGENASSIST 0x4 %xmm0 %xmm1
1820 call _key_expansion_256b
1821 AESKEYGENASSIST 0x8 %xmm2 %xmm1 # round 4
1822 call _key_expansion_256a
1823 AESKEYGENASSIST 0x8 %xmm0 %xmm1
1824 call _key_expansion_256b
1825 AESKEYGENASSIST 0x10 %xmm2 %xmm1 # round 5
1826 call _key_expansion_256a
1827 AESKEYGENASSIST 0x10 %xmm0 %xmm1
1828 call _key_expansion_256b
1829 AESKEYGENASSIST 0x20 %xmm2 %xmm1 # round 6
1830 call _key_expansion_256a
1831 AESKEYGENASSIST 0x20 %xmm0 %xmm1
1832 call _key_expansion_256b
1833 AESKEYGENASSIST 0x40 %xmm2 %xmm1 # round 7
1834 call _key_expansion_256a
1835 jmp .Ldec_key
1836 .Lenc_key192:
1837 movq 0x10(UKEYP), %xmm2 # other user key
1838 AESKEYGENASSIST 0x1 %xmm2 %xmm1 # round 1
1839 call _key_expansion_192a
1840 AESKEYGENASSIST 0x2 %xmm2 %xmm1 # round 2
1841 call _key_expansion_192b
1842 AESKEYGENASSIST 0x4 %xmm2 %xmm1 # round 3
1843 call _key_expansion_192a
1844 AESKEYGENASSIST 0x8 %xmm2 %xmm1 # round 4
1845 call _key_expansion_192b
1846 AESKEYGENASSIST 0x10 %xmm2 %xmm1 # round 5
1847 call _key_expansion_192a
1848 AESKEYGENASSIST 0x20 %xmm2 %xmm1 # round 6
1849 call _key_expansion_192b
1850 AESKEYGENASSIST 0x40 %xmm2 %xmm1 # round 7
1851 call _key_expansion_192a
1852 AESKEYGENASSIST 0x80 %xmm2 %xmm1 # round 8
1853 call _key_expansion_192b
1854 jmp .Ldec_key
1855 .Lenc_key128:
1856 AESKEYGENASSIST 0x1 %xmm0 %xmm1 # round 1
1857 call _key_expansion_128
1858 AESKEYGENASSIST 0x2 %xmm0 %xmm1 # round 2
1859 call _key_expansion_128
1860 AESKEYGENASSIST 0x4 %xmm0 %xmm1 # round 3
1861 call _key_expansion_128
1862 AESKEYGENASSIST 0x8 %xmm0 %xmm1 # round 4
1863 call _key_expansion_128
1864 AESKEYGENASSIST 0x10 %xmm0 %xmm1 # round 5
1865 call _key_expansion_128
1866 AESKEYGENASSIST 0x20 %xmm0 %xmm1 # round 6
1867 call _key_expansion_128
1868 AESKEYGENASSIST 0x40 %xmm0 %xmm1 # round 7
1869 call _key_expansion_128
1870 AESKEYGENASSIST 0x80 %xmm0 %xmm1 # round 8
1871 call _key_expansion_128
1872 AESKEYGENASSIST 0x1b %xmm0 %xmm1 # round 9
1873 call _key_expansion_128
1874 AESKEYGENASSIST 0x36 %xmm0 %xmm1 # round 10
1875 call _key_expansion_128
1876 .Ldec_key:
1877 sub $0x10, TKEYP
1878 movaps (KEYP), %xmm0
1879 movaps (TKEYP), %xmm1
1880 movaps %xmm0, 240(TKEYP)
1881 movaps %xmm1, 240(KEYP)
1882 add $0x10, KEYP
1883 lea 240-16(TKEYP), UKEYP
1884 .align 4
1885 .Ldec_key_loop:
1886 movaps (KEYP), %xmm0
1887 AESIMC %xmm0 %xmm1
1888 movaps %xmm1, (UKEYP)
1889 add $0x10, KEYP
1890 sub $0x10, UKEYP
1891 cmp TKEYP, KEYP
1892 jb .Ldec_key_loop
1893 xor AREG, AREG
1894 #ifndef __x86_64__
1895 popl KEYP
1896 #endif
1897 ret
1898 ENDPROC(aesni_set_key)
1899
1900 /*
1901 * void aesni_enc(struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
1902 */
1903 ENTRY(aesni_enc)
1904 #ifndef __x86_64__
1905 pushl KEYP
1906 pushl KLEN
1907 movl 12(%esp), KEYP
1908 movl 16(%esp), OUTP
1909 movl 20(%esp), INP
1910 #endif
1911 movl 480(KEYP), KLEN # key length
1912 movups (INP), STATE # input
1913 call _aesni_enc1
1914 movups STATE, (OUTP) # output
1915 #ifndef __x86_64__
1916 popl KLEN
1917 popl KEYP
1918 #endif
1919 ret
1920 ENDPROC(aesni_enc)
1921
1922 /*
1923 * _aesni_enc1: internal ABI
1924 * input:
1925 * KEYP: key struct pointer
1926 * KLEN: round count
1927 * STATE: initial state (input)
1928 * output:
1929 * STATE: finial state (output)
1930 * changed:
1931 * KEY
1932 * TKEYP (T1)
1933 */
1934 .align 4
1935 _aesni_enc1:
1936 movaps (KEYP), KEY # key
1937 mov KEYP, TKEYP
1938 pxor KEY, STATE # round 0
1939 add $0x30, TKEYP
1940 cmp $24, KLEN
1941 jb .Lenc128
1942 lea 0x20(TKEYP), TKEYP
1943 je .Lenc192
1944 add $0x20, TKEYP
1945 movaps -0x60(TKEYP), KEY
1946 AESENC KEY STATE
1947 movaps -0x50(TKEYP), KEY
1948 AESENC KEY STATE
1949 .align 4
1950 .Lenc192:
1951 movaps -0x40(TKEYP), KEY
1952 AESENC KEY STATE
1953 movaps -0x30(TKEYP), KEY
1954 AESENC KEY STATE
1955 .align 4
1956 .Lenc128:
1957 movaps -0x20(TKEYP), KEY
1958 AESENC KEY STATE
1959 movaps -0x10(TKEYP), KEY
1960 AESENC KEY STATE
1961 movaps (TKEYP), KEY
1962 AESENC KEY STATE
1963 movaps 0x10(TKEYP), KEY
1964 AESENC KEY STATE
1965 movaps 0x20(TKEYP), KEY
1966 AESENC KEY STATE
1967 movaps 0x30(TKEYP), KEY
1968 AESENC KEY STATE
1969 movaps 0x40(TKEYP), KEY
1970 AESENC KEY STATE
1971 movaps 0x50(TKEYP), KEY
1972 AESENC KEY STATE
1973 movaps 0x60(TKEYP), KEY
1974 AESENC KEY STATE
1975 movaps 0x70(TKEYP), KEY
1976 AESENCLAST KEY STATE
1977 ret
1978 ENDPROC(_aesni_enc1)
1979
1980 /*
1981 * _aesni_enc4: internal ABI
1982 * input:
1983 * KEYP: key struct pointer
1984 * KLEN: round count
1985 * STATE1: initial state (input)
1986 * STATE2
1987 * STATE3
1988 * STATE4
1989 * output:
1990 * STATE1: finial state (output)
1991 * STATE2
1992 * STATE3
1993 * STATE4
1994 * changed:
1995 * KEY
1996 * TKEYP (T1)
1997 */
1998 .align 4
1999 _aesni_enc4:
2000 movaps (KEYP), KEY # key
2001 mov KEYP, TKEYP
2002 pxor KEY, STATE1 # round 0
2003 pxor KEY, STATE2
2004 pxor KEY, STATE3
2005 pxor KEY, STATE4
2006 add $0x30, TKEYP
2007 cmp $24, KLEN
2008 jb .L4enc128
2009 lea 0x20(TKEYP), TKEYP
2010 je .L4enc192
2011 add $0x20, TKEYP
2012 movaps -0x60(TKEYP), KEY
2013 AESENC KEY STATE1
2014 AESENC KEY STATE2
2015 AESENC KEY STATE3
2016 AESENC KEY STATE4
2017 movaps -0x50(TKEYP), KEY
2018 AESENC KEY STATE1
2019 AESENC KEY STATE2
2020 AESENC KEY STATE3
2021 AESENC KEY STATE4
2022 #.align 4
2023 .L4enc192:
2024 movaps -0x40(TKEYP), KEY
2025 AESENC KEY STATE1
2026 AESENC KEY STATE2
2027 AESENC KEY STATE3
2028 AESENC KEY STATE4
2029 movaps -0x30(TKEYP), KEY
2030 AESENC KEY STATE1
2031 AESENC KEY STATE2
2032 AESENC KEY STATE3
2033 AESENC KEY STATE4
2034 #.align 4
2035 .L4enc128:
2036 movaps -0x20(TKEYP), KEY
2037 AESENC KEY STATE1
2038 AESENC KEY STATE2
2039 AESENC KEY STATE3
2040 AESENC KEY STATE4
2041 movaps -0x10(TKEYP), KEY
2042 AESENC KEY STATE1
2043 AESENC KEY STATE2
2044 AESENC KEY STATE3
2045 AESENC KEY STATE4
2046 movaps (TKEYP), KEY
2047 AESENC KEY STATE1
2048 AESENC KEY STATE2
2049 AESENC KEY STATE3
2050 AESENC KEY STATE4
2051 movaps 0x10(TKEYP), KEY
2052 AESENC KEY STATE1
2053 AESENC KEY STATE2
2054 AESENC KEY STATE3
2055 AESENC KEY STATE4
2056 movaps 0x20(TKEYP), KEY
2057 AESENC KEY STATE1
2058 AESENC KEY STATE2
2059 AESENC KEY STATE3
2060 AESENC KEY STATE4
2061 movaps 0x30(TKEYP), KEY
2062 AESENC KEY STATE1
2063 AESENC KEY STATE2
2064 AESENC KEY STATE3
2065 AESENC KEY STATE4
2066 movaps 0x40(TKEYP), KEY
2067 AESENC KEY STATE1
2068 AESENC KEY STATE2
2069 AESENC KEY STATE3
2070 AESENC KEY STATE4
2071 movaps 0x50(TKEYP), KEY
2072 AESENC KEY STATE1
2073 AESENC KEY STATE2
2074 AESENC KEY STATE3
2075 AESENC KEY STATE4
2076 movaps 0x60(TKEYP), KEY
2077 AESENC KEY STATE1
2078 AESENC KEY STATE2
2079 AESENC KEY STATE3
2080 AESENC KEY STATE4
2081 movaps 0x70(TKEYP), KEY
2082 AESENCLAST KEY STATE1 # last round
2083 AESENCLAST KEY STATE2
2084 AESENCLAST KEY STATE3
2085 AESENCLAST KEY STATE4
2086 ret
2087 ENDPROC(_aesni_enc4)
2088
2089 /*
2090 * void aesni_dec (struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src)
2091 */
2092 ENTRY(aesni_dec)
2093 #ifndef __x86_64__
2094 pushl KEYP
2095 pushl KLEN
2096 movl 12(%esp), KEYP
2097 movl 16(%esp), OUTP
2098 movl 20(%esp), INP
2099 #endif
2100 mov 480(KEYP), KLEN # key length
2101 add $240, KEYP
2102 movups (INP), STATE # input
2103 call _aesni_dec1
2104 movups STATE, (OUTP) #output
2105 #ifndef __x86_64__
2106 popl KLEN
2107 popl KEYP
2108 #endif
2109 ret
2110 ENDPROC(aesni_dec)
2111
2112 /*
2113 * _aesni_dec1: internal ABI
2114 * input:
2115 * KEYP: key struct pointer
2116 * KLEN: key length
2117 * STATE: initial state (input)
2118 * output:
2119 * STATE: finial state (output)
2120 * changed:
2121 * KEY
2122 * TKEYP (T1)
2123 */
2124 .align 4
2125 _aesni_dec1:
2126 movaps (KEYP), KEY # key
2127 mov KEYP, TKEYP
2128 pxor KEY, STATE # round 0
2129 add $0x30, TKEYP
2130 cmp $24, KLEN
2131 jb .Ldec128
2132 lea 0x20(TKEYP), TKEYP
2133 je .Ldec192
2134 add $0x20, TKEYP
2135 movaps -0x60(TKEYP), KEY
2136 AESDEC KEY STATE
2137 movaps -0x50(TKEYP), KEY
2138 AESDEC KEY STATE
2139 .align 4
2140 .Ldec192:
2141 movaps -0x40(TKEYP), KEY
2142 AESDEC KEY STATE
2143 movaps -0x30(TKEYP), KEY
2144 AESDEC KEY STATE
2145 .align 4
2146 .Ldec128:
2147 movaps -0x20(TKEYP), KEY
2148 AESDEC KEY STATE
2149 movaps -0x10(TKEYP), KEY
2150 AESDEC KEY STATE
2151 movaps (TKEYP), KEY
2152 AESDEC KEY STATE
2153 movaps 0x10(TKEYP), KEY
2154 AESDEC KEY STATE
2155 movaps 0x20(TKEYP), KEY
2156 AESDEC KEY STATE
2157 movaps 0x30(TKEYP), KEY
2158 AESDEC KEY STATE
2159 movaps 0x40(TKEYP), KEY
2160 AESDEC KEY STATE
2161 movaps 0x50(TKEYP), KEY
2162 AESDEC KEY STATE
2163 movaps 0x60(TKEYP), KEY
2164 AESDEC KEY STATE
2165 movaps 0x70(TKEYP), KEY
2166 AESDECLAST KEY STATE
2167 ret
2168 ENDPROC(_aesni_dec1)
2169
2170 /*
2171 * _aesni_dec4: internal ABI
2172 * input:
2173 * KEYP: key struct pointer
2174 * KLEN: key length
2175 * STATE1: initial state (input)
2176 * STATE2
2177 * STATE3
2178 * STATE4
2179 * output:
2180 * STATE1: finial state (output)
2181 * STATE2
2182 * STATE3
2183 * STATE4
2184 * changed:
2185 * KEY
2186 * TKEYP (T1)
2187 */
2188 .align 4
2189 _aesni_dec4:
2190 movaps (KEYP), KEY # key
2191 mov KEYP, TKEYP
2192 pxor KEY, STATE1 # round 0
2193 pxor KEY, STATE2
2194 pxor KEY, STATE3
2195 pxor KEY, STATE4
2196 add $0x30, TKEYP
2197 cmp $24, KLEN
2198 jb .L4dec128
2199 lea 0x20(TKEYP), TKEYP
2200 je .L4dec192
2201 add $0x20, TKEYP
2202 movaps -0x60(TKEYP), KEY
2203 AESDEC KEY STATE1
2204 AESDEC KEY STATE2
2205 AESDEC KEY STATE3
2206 AESDEC KEY STATE4
2207 movaps -0x50(TKEYP), KEY
2208 AESDEC KEY STATE1
2209 AESDEC KEY STATE2
2210 AESDEC KEY STATE3
2211 AESDEC KEY STATE4
2212 .align 4
2213 .L4dec192:
2214 movaps -0x40(TKEYP), KEY
2215 AESDEC KEY STATE1
2216 AESDEC KEY STATE2
2217 AESDEC KEY STATE3
2218 AESDEC KEY STATE4
2219 movaps -0x30(TKEYP), KEY
2220 AESDEC KEY STATE1
2221 AESDEC KEY STATE2
2222 AESDEC KEY STATE3
2223 AESDEC KEY STATE4
2224 .align 4
2225 .L4dec128:
2226 movaps -0x20(TKEYP), KEY
2227 AESDEC KEY STATE1
2228 AESDEC KEY STATE2
2229 AESDEC KEY STATE3
2230 AESDEC KEY STATE4
2231 movaps -0x10(TKEYP), KEY
2232 AESDEC KEY STATE1
2233 AESDEC KEY STATE2
2234 AESDEC KEY STATE3
2235 AESDEC KEY STATE4
2236 movaps (TKEYP), KEY
2237 AESDEC KEY STATE1
2238 AESDEC KEY STATE2
2239 AESDEC KEY STATE3
2240 AESDEC KEY STATE4
2241 movaps 0x10(TKEYP), KEY
2242 AESDEC KEY STATE1
2243 AESDEC KEY STATE2
2244 AESDEC KEY STATE3
2245 AESDEC KEY STATE4
2246 movaps 0x20(TKEYP), KEY
2247 AESDEC KEY STATE1
2248 AESDEC KEY STATE2
2249 AESDEC KEY STATE3
2250 AESDEC KEY STATE4
2251 movaps 0x30(TKEYP), KEY
2252 AESDEC KEY STATE1
2253 AESDEC KEY STATE2
2254 AESDEC KEY STATE3
2255 AESDEC KEY STATE4
2256 movaps 0x40(TKEYP), KEY
2257 AESDEC KEY STATE1
2258 AESDEC KEY STATE2
2259 AESDEC KEY STATE3
2260 AESDEC KEY STATE4
2261 movaps 0x50(TKEYP), KEY
2262 AESDEC KEY STATE1
2263 AESDEC KEY STATE2
2264 AESDEC KEY STATE3
2265 AESDEC KEY STATE4
2266 movaps 0x60(TKEYP), KEY
2267 AESDEC KEY STATE1
2268 AESDEC KEY STATE2
2269 AESDEC KEY STATE3
2270 AESDEC KEY STATE4
2271 movaps 0x70(TKEYP), KEY
2272 AESDECLAST KEY STATE1 # last round
2273 AESDECLAST KEY STATE2
2274 AESDECLAST KEY STATE3
2275 AESDECLAST KEY STATE4
2276 ret
2277 ENDPROC(_aesni_dec4)
2278
2279 /*
2280 * void aesni_ecb_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2281 * size_t len)
2282 */
2283 ENTRY(aesni_ecb_enc)
2284 #ifndef __x86_64__
2285 pushl LEN
2286 pushl KEYP
2287 pushl KLEN
2288 movl 16(%esp), KEYP
2289 movl 20(%esp), OUTP
2290 movl 24(%esp), INP
2291 movl 28(%esp), LEN
2292 #endif
2293 test LEN, LEN # check length
2294 jz .Lecb_enc_ret
2295 mov 480(KEYP), KLEN
2296 cmp $16, LEN
2297 jb .Lecb_enc_ret
2298 cmp $64, LEN
2299 jb .Lecb_enc_loop1
2300 .align 4
2301 .Lecb_enc_loop4:
2302 movups (INP), STATE1
2303 movups 0x10(INP), STATE2
2304 movups 0x20(INP), STATE3
2305 movups 0x30(INP), STATE4
2306 call _aesni_enc4
2307 movups STATE1, (OUTP)
2308 movups STATE2, 0x10(OUTP)
2309 movups STATE3, 0x20(OUTP)
2310 movups STATE4, 0x30(OUTP)
2311 sub $64, LEN
2312 add $64, INP
2313 add $64, OUTP
2314 cmp $64, LEN
2315 jge .Lecb_enc_loop4
2316 cmp $16, LEN
2317 jb .Lecb_enc_ret
2318 .align 4
2319 .Lecb_enc_loop1:
2320 movups (INP), STATE1
2321 call _aesni_enc1
2322 movups STATE1, (OUTP)
2323 sub $16, LEN
2324 add $16, INP
2325 add $16, OUTP
2326 cmp $16, LEN
2327 jge .Lecb_enc_loop1
2328 .Lecb_enc_ret:
2329 #ifndef __x86_64__
2330 popl KLEN
2331 popl KEYP
2332 popl LEN
2333 #endif
2334 ret
2335 ENDPROC(aesni_ecb_enc)
2336
2337 /*
2338 * void aesni_ecb_dec(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2339 * size_t len);
2340 */
2341 ENTRY(aesni_ecb_dec)
2342 #ifndef __x86_64__
2343 pushl LEN
2344 pushl KEYP
2345 pushl KLEN
2346 movl 16(%esp), KEYP
2347 movl 20(%esp), OUTP
2348 movl 24(%esp), INP
2349 movl 28(%esp), LEN
2350 #endif
2351 test LEN, LEN
2352 jz .Lecb_dec_ret
2353 mov 480(KEYP), KLEN
2354 add $240, KEYP
2355 cmp $16, LEN
2356 jb .Lecb_dec_ret
2357 cmp $64, LEN
2358 jb .Lecb_dec_loop1
2359 .align 4
2360 .Lecb_dec_loop4:
2361 movups (INP), STATE1
2362 movups 0x10(INP), STATE2
2363 movups 0x20(INP), STATE3
2364 movups 0x30(INP), STATE4
2365 call _aesni_dec4
2366 movups STATE1, (OUTP)
2367 movups STATE2, 0x10(OUTP)
2368 movups STATE3, 0x20(OUTP)
2369 movups STATE4, 0x30(OUTP)
2370 sub $64, LEN
2371 add $64, INP
2372 add $64, OUTP
2373 cmp $64, LEN
2374 jge .Lecb_dec_loop4
2375 cmp $16, LEN
2376 jb .Lecb_dec_ret
2377 .align 4
2378 .Lecb_dec_loop1:
2379 movups (INP), STATE1
2380 call _aesni_dec1
2381 movups STATE1, (OUTP)
2382 sub $16, LEN
2383 add $16, INP
2384 add $16, OUTP
2385 cmp $16, LEN
2386 jge .Lecb_dec_loop1
2387 .Lecb_dec_ret:
2388 #ifndef __x86_64__
2389 popl KLEN
2390 popl KEYP
2391 popl LEN
2392 #endif
2393 ret
2394 ENDPROC(aesni_ecb_dec)
2395
2396 /*
2397 * void aesni_cbc_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2398 * size_t len, u8 *iv)
2399 */
2400 ENTRY(aesni_cbc_enc)
2401 #ifndef __x86_64__
2402 pushl IVP
2403 pushl LEN
2404 pushl KEYP
2405 pushl KLEN
2406 movl 20(%esp), KEYP
2407 movl 24(%esp), OUTP
2408 movl 28(%esp), INP
2409 movl 32(%esp), LEN
2410 movl 36(%esp), IVP
2411 #endif
2412 cmp $16, LEN
2413 jb .Lcbc_enc_ret
2414 mov 480(KEYP), KLEN
2415 movups (IVP), STATE # load iv as initial state
2416 .align 4
2417 .Lcbc_enc_loop:
2418 movups (INP), IN # load input
2419 pxor IN, STATE
2420 call _aesni_enc1
2421 movups STATE, (OUTP) # store output
2422 sub $16, LEN
2423 add $16, INP
2424 add $16, OUTP
2425 cmp $16, LEN
2426 jge .Lcbc_enc_loop
2427 movups STATE, (IVP)
2428 .Lcbc_enc_ret:
2429 #ifndef __x86_64__
2430 popl KLEN
2431 popl KEYP
2432 popl LEN
2433 popl IVP
2434 #endif
2435 ret
2436 ENDPROC(aesni_cbc_enc)
2437
2438 /*
2439 * void aesni_cbc_dec(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2440 * size_t len, u8 *iv)
2441 */
2442 ENTRY(aesni_cbc_dec)
2443 #ifndef __x86_64__
2444 pushl IVP
2445 pushl LEN
2446 pushl KEYP
2447 pushl KLEN
2448 movl 20(%esp), KEYP
2449 movl 24(%esp), OUTP
2450 movl 28(%esp), INP
2451 movl 32(%esp), LEN
2452 movl 36(%esp), IVP
2453 #endif
2454 cmp $16, LEN
2455 jb .Lcbc_dec_just_ret
2456 mov 480(KEYP), KLEN
2457 add $240, KEYP
2458 movups (IVP), IV
2459 cmp $64, LEN
2460 jb .Lcbc_dec_loop1
2461 .align 4
2462 .Lcbc_dec_loop4:
2463 movups (INP), IN1
2464 movaps IN1, STATE1
2465 movups 0x10(INP), IN2
2466 movaps IN2, STATE2
2467 #ifdef __x86_64__
2468 movups 0x20(INP), IN3
2469 movaps IN3, STATE3
2470 movups 0x30(INP), IN4
2471 movaps IN4, STATE4
2472 #else
2473 movups 0x20(INP), IN1
2474 movaps IN1, STATE3
2475 movups 0x30(INP), IN2
2476 movaps IN2, STATE4
2477 #endif
2478 call _aesni_dec4
2479 pxor IV, STATE1
2480 #ifdef __x86_64__
2481 pxor IN1, STATE2
2482 pxor IN2, STATE3
2483 pxor IN3, STATE4
2484 movaps IN4, IV
2485 #else
2486 pxor IN1, STATE4
2487 movaps IN2, IV
2488 movups (INP), IN1
2489 pxor IN1, STATE2
2490 movups 0x10(INP), IN2
2491 pxor IN2, STATE3
2492 #endif
2493 movups STATE1, (OUTP)
2494 movups STATE2, 0x10(OUTP)
2495 movups STATE3, 0x20(OUTP)
2496 movups STATE4, 0x30(OUTP)
2497 sub $64, LEN
2498 add $64, INP
2499 add $64, OUTP
2500 cmp $64, LEN
2501 jge .Lcbc_dec_loop4
2502 cmp $16, LEN
2503 jb .Lcbc_dec_ret
2504 .align 4
2505 .Lcbc_dec_loop1:
2506 movups (INP), IN
2507 movaps IN, STATE
2508 call _aesni_dec1
2509 pxor IV, STATE
2510 movups STATE, (OUTP)
2511 movaps IN, IV
2512 sub $16, LEN
2513 add $16, INP
2514 add $16, OUTP
2515 cmp $16, LEN
2516 jge .Lcbc_dec_loop1
2517 .Lcbc_dec_ret:
2518 movups IV, (IVP)
2519 .Lcbc_dec_just_ret:
2520 #ifndef __x86_64__
2521 popl KLEN
2522 popl KEYP
2523 popl LEN
2524 popl IVP
2525 #endif
2526 ret
2527 ENDPROC(aesni_cbc_dec)
2528
2529 #ifdef __x86_64__
2530 .align 16
2531 .Lbswap_mask:
2532 .byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
2533
2534 /*
2535 * _aesni_inc_init: internal ABI
2536 * setup registers used by _aesni_inc
2537 * input:
2538 * IV
2539 * output:
2540 * CTR: == IV, in little endian
2541 * TCTR_LOW: == lower qword of CTR
2542 * INC: == 1, in little endian
2543 * BSWAP_MASK == endian swapping mask
2544 */
2545 .align 4
2546 _aesni_inc_init:
2547 movaps .Lbswap_mask, BSWAP_MASK
2548 movaps IV, CTR
2549 PSHUFB_XMM BSWAP_MASK CTR
2550 mov $1, TCTR_LOW
2551 MOVQ_R64_XMM TCTR_LOW INC
2552 MOVQ_R64_XMM CTR TCTR_LOW
2553 ret
2554 ENDPROC(_aesni_inc_init)
2555
2556 /*
2557 * _aesni_inc: internal ABI
2558 * Increase IV by 1, IV is in big endian
2559 * input:
2560 * IV
2561 * CTR: == IV, in little endian
2562 * TCTR_LOW: == lower qword of CTR
2563 * INC: == 1, in little endian
2564 * BSWAP_MASK == endian swapping mask
2565 * output:
2566 * IV: Increase by 1
2567 * changed:
2568 * CTR: == output IV, in little endian
2569 * TCTR_LOW: == lower qword of CTR
2570 */
2571 .align 4
2572 _aesni_inc:
2573 paddq INC, CTR
2574 add $1, TCTR_LOW
2575 jnc .Linc_low
2576 pslldq $8, INC
2577 paddq INC, CTR
2578 psrldq $8, INC
2579 .Linc_low:
2580 movaps CTR, IV
2581 PSHUFB_XMM BSWAP_MASK IV
2582 ret
2583 ENDPROC(_aesni_inc)
2584
2585 /*
2586 * void aesni_ctr_enc(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2587 * size_t len, u8 *iv)
2588 */
2589 ENTRY(aesni_ctr_enc)
2590 cmp $16, LEN
2591 jb .Lctr_enc_just_ret
2592 mov 480(KEYP), KLEN
2593 movups (IVP), IV
2594 call _aesni_inc_init
2595 cmp $64, LEN
2596 jb .Lctr_enc_loop1
2597 .align 4
2598 .Lctr_enc_loop4:
2599 movaps IV, STATE1
2600 call _aesni_inc
2601 movups (INP), IN1
2602 movaps IV, STATE2
2603 call _aesni_inc
2604 movups 0x10(INP), IN2
2605 movaps IV, STATE3
2606 call _aesni_inc
2607 movups 0x20(INP), IN3
2608 movaps IV, STATE4
2609 call _aesni_inc
2610 movups 0x30(INP), IN4
2611 call _aesni_enc4
2612 pxor IN1, STATE1
2613 movups STATE1, (OUTP)
2614 pxor IN2, STATE2
2615 movups STATE2, 0x10(OUTP)
2616 pxor IN3, STATE3
2617 movups STATE3, 0x20(OUTP)
2618 pxor IN4, STATE4
2619 movups STATE4, 0x30(OUTP)
2620 sub $64, LEN
2621 add $64, INP
2622 add $64, OUTP
2623 cmp $64, LEN
2624 jge .Lctr_enc_loop4
2625 cmp $16, LEN
2626 jb .Lctr_enc_ret
2627 .align 4
2628 .Lctr_enc_loop1:
2629 movaps IV, STATE
2630 call _aesni_inc
2631 movups (INP), IN
2632 call _aesni_enc1
2633 pxor IN, STATE
2634 movups STATE, (OUTP)
2635 sub $16, LEN
2636 add $16, INP
2637 add $16, OUTP
2638 cmp $16, LEN
2639 jge .Lctr_enc_loop1
2640 .Lctr_enc_ret:
2641 movups IV, (IVP)
2642 .Lctr_enc_just_ret:
2643 ret
2644 ENDPROC(aesni_ctr_enc)
2645
2646 /*
2647 * _aesni_gf128mul_x_ble: internal ABI
2648 * Multiply in GF(2^128) for XTS IVs
2649 * input:
2650 * IV: current IV
2651 * GF128MUL_MASK == mask with 0x87 and 0x01
2652 * output:
2653 * IV: next IV
2654 * changed:
2655 * CTR: == temporary value
2656 */
2657 #define _aesni_gf128mul_x_ble() \
2658 pshufd $0x13, IV, CTR; \
2659 paddq IV, IV; \
2660 psrad $31, CTR; \
2661 pand GF128MUL_MASK, CTR; \
2662 pxor CTR, IV;
2663
2664 /*
2665 * void aesni_xts_crypt8(struct crypto_aes_ctx *ctx, const u8 *dst, u8 *src,
2666 * bool enc, u8 *iv)
2667 */
2668 ENTRY(aesni_xts_crypt8)
2669 cmpb $0, %cl
2670 movl $0, %ecx
2671 movl $240, %r10d
2672 leaq _aesni_enc4, %r11
2673 leaq _aesni_dec4, %rax
2674 cmovel %r10d, %ecx
2675 cmoveq %rax, %r11
2676
2677 movdqa .Lgf128mul_x_ble_mask, GF128MUL_MASK
2678 movups (IVP), IV
2679
2680 mov 480(KEYP), KLEN
2681 addq %rcx, KEYP
2682
2683 movdqa IV, STATE1
2684 movdqu 0x00(INP), INC
2685 pxor INC, STATE1
2686 movdqu IV, 0x00(OUTP)
2687
2688 _aesni_gf128mul_x_ble()
2689 movdqa IV, STATE2
2690 movdqu 0x10(INP), INC
2691 pxor INC, STATE2
2692 movdqu IV, 0x10(OUTP)
2693
2694 _aesni_gf128mul_x_ble()
2695 movdqa IV, STATE3
2696 movdqu 0x20(INP), INC
2697 pxor INC, STATE3
2698 movdqu IV, 0x20(OUTP)
2699
2700 _aesni_gf128mul_x_ble()
2701 movdqa IV, STATE4
2702 movdqu 0x30(INP), INC
2703 pxor INC, STATE4
2704 movdqu IV, 0x30(OUTP)
2705
2706 call *%r11
2707
2708 movdqu 0x00(OUTP), INC
2709 pxor INC, STATE1
2710 movdqu STATE1, 0x00(OUTP)
2711
2712 _aesni_gf128mul_x_ble()
2713 movdqa IV, STATE1
2714 movdqu 0x40(INP), INC
2715 pxor INC, STATE1
2716 movdqu IV, 0x40(OUTP)
2717
2718 movdqu 0x10(OUTP), INC
2719 pxor INC, STATE2
2720 movdqu STATE2, 0x10(OUTP)
2721
2722 _aesni_gf128mul_x_ble()
2723 movdqa IV, STATE2
2724 movdqu 0x50(INP), INC
2725 pxor INC, STATE2
2726 movdqu IV, 0x50(OUTP)
2727
2728 movdqu 0x20(OUTP), INC
2729 pxor INC, STATE3
2730 movdqu STATE3, 0x20(OUTP)
2731
2732 _aesni_gf128mul_x_ble()
2733 movdqa IV, STATE3
2734 movdqu 0x60(INP), INC
2735 pxor INC, STATE3
2736 movdqu IV, 0x60(OUTP)
2737
2738 movdqu 0x30(OUTP), INC
2739 pxor INC, STATE4
2740 movdqu STATE4, 0x30(OUTP)
2741
2742 _aesni_gf128mul_x_ble()
2743 movdqa IV, STATE4
2744 movdqu 0x70(INP), INC
2745 pxor INC, STATE4
2746 movdqu IV, 0x70(OUTP)
2747
2748 _aesni_gf128mul_x_ble()
2749 movups IV, (IVP)
2750
2751 call *%r11
2752
2753 movdqu 0x40(OUTP), INC
2754 pxor INC, STATE1
2755 movdqu STATE1, 0x40(OUTP)
2756
2757 movdqu 0x50(OUTP), INC
2758 pxor INC, STATE2
2759 movdqu STATE2, 0x50(OUTP)
2760
2761 movdqu 0x60(OUTP), INC
2762 pxor INC, STATE3
2763 movdqu STATE3, 0x60(OUTP)
2764
2765 movdqu 0x70(OUTP), INC
2766 pxor INC, STATE4
2767 movdqu STATE4, 0x70(OUTP)
2768
2769 ret
2770 ENDPROC(aesni_xts_crypt8)
2771
2772 #endif
Linux kernel - Deliverables
This page took 0.095254 seconds and 6 git commands to generate.