| blob | 3fecb2124c35a0b35b680a86216be0bd5a27e92d |
1 /*
2 * ChaCha20 256-bit cipher algorithm, RFC7539, ARM NEON functions
3 *
4 * Copyright (C) 2016 Linaro, Ltd. <ard.biesheuvel@linaro.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * Based on:
11 * ChaCha20 256-bit cipher algorithm, RFC7539, x64 SSE3 functions
12 *
13 * Copyright (C) 2015 Martin Willi
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 */
21 #include <linux/linkage.h>
23 .text
24 .fpu neon
25 .align 5
27 ENTRY(chacha20_block_xor_neon)
28 // r0: Input state matrix, s
29 // r1: 1 data block output, o
30 // r2: 1 data block input, i
32 //
33 // This function encrypts one ChaCha20 block by loading the state matrix
34 // in four NEON registers. It performs matrix operation on four words in
35 // parallel, but requireds shuffling to rearrange the words after each
36 // round.
37 //
39 // x0..3 = s0..3
40 add ip, r0, #0x20
41 vld1.32 {q0-q1}, [r0]
42 vld1.32 {q2-q3}, [ip]
44 vmov q8, q0
45 vmov q9, q1
46 vmov q10, q2
47 vmov q11, q3
49 mov r3, #10
51 .Ldoubleround:
52 // x0 += x1, x3 = rotl32(x3 ^ x0, 16)
53 vadd.i32 q0, q0, q1
54 veor q4, q3, q0
55 vshl.u32 q3, q4, #16
56 vsri.u32 q3, q4, #16
58 // x2 += x3, x1 = rotl32(x1 ^ x2, 12)
59 vadd.i32 q2, q2, q3
60 veor q4, q1, q2
61 vshl.u32 q1, q4, #12
62 vsri.u32 q1, q4, #20
64 // x0 += x1, x3 = rotl32(x3 ^ x0, 8)
65 vadd.i32 q0, q0, q1
66 veor q4, q3, q0
67 vshl.u32 q3, q4, #8
68 vsri.u32 q3, q4, #24
70 // x2 += x3, x1 = rotl32(x1 ^ x2, 7)
71 vadd.i32 q2, q2, q3
72 veor q4, q1, q2
73 vshl.u32 q1, q4, #7
74 vsri.u32 q1, q4, #25
76 // x1 = shuffle32(x1, MASK(0, 3, 2, 1))
77 vext.8 q1, q1, q1, #4
78 // x2 = shuffle32(x2, MASK(1, 0, 3, 2))
79 vext.8 q2, q2, q2, #8
80 // x3 = shuffle32(x3, MASK(2, 1, 0, 3))
81 vext.8 q3, q3, q3, #12
83 // x0 += x1, x3 = rotl32(x3 ^ x0, 16)
84 vadd.i32 q0, q0, q1
85 veor q4, q3, q0
86 vshl.u32 q3, q4, #16
87 vsri.u32 q3, q4, #16
89 // x2 += x3, x1 = rotl32(x1 ^ x2, 12)
90 vadd.i32 q2, q2, q3
91 veor q4, q1, q2
92 vshl.u32 q1, q4, #12
93 vsri.u32 q1, q4, #20
95 // x0 += x1, x3 = rotl32(x3 ^ x0, 8)
96 vadd.i32 q0, q0, q1
97 veor q4, q3, q0
98 vshl.u32 q3, q4, #8
99 vsri.u32 q3, q4, #24
101 // x2 += x3, x1 = rotl32(x1 ^ x2, 7)
102 vadd.i32 q2, q2, q3
103 veor q4, q1, q2
104 vshl.u32 q1, q4, #7
105 vsri.u32 q1, q4, #25
107 // x1 = shuffle32(x1, MASK(2, 1, 0, 3))
108 vext.8 q1, q1, q1, #12
109 // x2 = shuffle32(x2, MASK(1, 0, 3, 2))
110 vext.8 q2, q2, q2, #8
111 // x3 = shuffle32(x3, MASK(0, 3, 2, 1))
112 vext.8 q3, q3, q3, #4
114 subs r3, r3, #1
115 bne .Ldoubleround
117 add ip, r2, #0x20
118 vld1.8 {q4-q5}, [r2]
119 vld1.8 {q6-q7}, [ip]
121 // o0 = i0 ^ (x0 + s0)
122 vadd.i32 q0, q0, q8
123 veor q0, q0, q4
125 // o1 = i1 ^ (x1 + s1)
126 vadd.i32 q1, q1, q9
127 veor q1, q1, q5
129 // o2 = i2 ^ (x2 + s2)
130 vadd.i32 q2, q2, q10
131 veor q2, q2, q6
133 // o3 = i3 ^ (x3 + s3)
134 vadd.i32 q3, q3, q11
135 veor q3, q3, q7
137 add ip, r1, #0x20
138 vst1.8 {q0-q1}, [r1]
139 vst1.8 {q2-q3}, [ip]
141 bx lr
142 ENDPROC(chacha20_block_xor_neon)
144 .align 5
145 ENTRY(chacha20_4block_xor_neon)
146 push {r4-r6, lr}
147 mov ip, sp // preserve the stack pointer
148 sub r3, sp, #0x20 // allocate a 32 byte buffer
149 bic r3, r3, #0x1f // aligned to 32 bytes
150 mov sp, r3
152 // r0: Input state matrix, s
153 // r1: 4 data blocks output, o
154 // r2: 4 data blocks input, i
156 //
157 // This function encrypts four consecutive ChaCha20 blocks by loading
158 // the state matrix in NEON registers four times. The algorithm performs
159 // each operation on the corresponding word of each state matrix, hence
160 // requires no word shuffling. For final XORing step we transpose the
161 // matrix by interleaving 32- and then 64-bit words, which allows us to
162 // do XOR in NEON registers.
163 //
165 // x0..15[0-3] = s0..3[0..3]
166 add r3, r0, #0x20
167 vld1.32 {q0-q1}, [r0]
168 vld1.32 {q2-q3}, [r3]
170 adr r3, CTRINC
171 vdup.32 q15, d7[1]
172 vdup.32 q14, d7[0]
173 vld1.32 {q11}, [r3, :128]
174 vdup.32 q13, d6[1]
175 vdup.32 q12, d6[0]
176 vadd.i32 q12, q12, q11 // x12 += counter values 0-3
177 vdup.32 q11, d5[1]
178 vdup.32 q10, d5[0]
179 vdup.32 q9, d4[1]
180 vdup.32 q8, d4[0]
181 vdup.32 q7, d3[1]
182 vdup.32 q6, d3[0]
183 vdup.32 q5, d2[1]
184 vdup.32 q4, d2[0]
185 vdup.32 q3, d1[1]
186 vdup.32 q2, d1[0]
187 vdup.32 q1, d0[1]
188 vdup.32 q0, d0[0]
190 mov r3, #10
192 .Ldoubleround4:
193 // x0 += x4, x12 = rotl32(x12 ^ x0, 16)
194 // x1 += x5, x13 = rotl32(x13 ^ x1, 16)
195 // x2 += x6, x14 = rotl32(x14 ^ x2, 16)
196 // x3 += x7, x15 = rotl32(x15 ^ x3, 16)
197 vadd.i32 q0, q0, q4
198 vadd.i32 q1, q1, q5
199 vadd.i32 q2, q2, q6
200 vadd.i32 q3, q3, q7
202 veor q12, q12, q0
203 veor q13, q13, q1
204 veor q14, q14, q2
205 veor q15, q15, q3
207 vrev32.16 q12, q12
208 vrev32.16 q13, q13
209 vrev32.16 q14, q14
210 vrev32.16 q15, q15
212 // x8 += x12, x4 = rotl32(x4 ^ x8, 12)
213 // x9 += x13, x5 = rotl32(x5 ^ x9, 12)
214 // x10 += x14, x6 = rotl32(x6 ^ x10, 12)
215 // x11 += x15, x7 = rotl32(x7 ^ x11, 12)
216 vadd.i32 q8, q8, q12
217 vadd.i32 q9, q9, q13
218 vadd.i32 q10, q10, q14
219 vadd.i32 q11, q11, q15
221 vst1.32 {q8-q9}, [sp, :256]
223 veor q8, q4, q8
224 veor q9, q5, q9
225 vshl.u32 q4, q8, #12
226 vshl.u32 q5, q9, #12
227 vsri.u32 q4, q8, #20
228 vsri.u32 q5, q9, #20
230 veor q8, q6, q10
231 veor q9, q7, q11
232 vshl.u32 q6, q8, #12
233 vshl.u32 q7, q9, #12
234 vsri.u32 q6, q8, #20
235 vsri.u32 q7, q9, #20
237 // x0 += x4, x12 = rotl32(x12 ^ x0, 8)
238 // x1 += x5, x13 = rotl32(x13 ^ x1, 8)
239 // x2 += x6, x14 = rotl32(x14 ^ x2, 8)
240 // x3 += x7, x15 = rotl32(x15 ^ x3, 8)
241 vadd.i32 q0, q0, q4
242 vadd.i32 q1, q1, q5
243 vadd.i32 q2, q2, q6
244 vadd.i32 q3, q3, q7
246 veor q8, q12, q0
247 veor q9, q13, q1
248 vshl.u32 q12, q8, #8
249 vshl.u32 q13, q9, #8
250 vsri.u32 q12, q8, #24
251 vsri.u32 q13, q9, #24
253 veor q8, q14, q2
254 veor q9, q15, q3
255 vshl.u32 q14, q8, #8
256 vshl.u32 q15, q9, #8
257 vsri.u32 q14, q8, #24
258 vsri.u32 q15, q9, #24
260 vld1.32 {q8-q9}, [sp, :256]
262 // x8 += x12, x4 = rotl32(x4 ^ x8, 7)
263 // x9 += x13, x5 = rotl32(x5 ^ x9, 7)
264 // x10 += x14, x6 = rotl32(x6 ^ x10, 7)
265 // x11 += x15, x7 = rotl32(x7 ^ x11, 7)
266 vadd.i32 q8, q8, q12
267 vadd.i32 q9, q9, q13
268 vadd.i32 q10, q10, q14
269 vadd.i32 q11, q11, q15
271 vst1.32 {q8-q9}, [sp, :256]
273 veor q8, q4, q8
274 veor q9, q5, q9
275 vshl.u32 q4, q8, #7
276 vshl.u32 q5, q9, #7
277 vsri.u32 q4, q8, #25
278 vsri.u32 q5, q9, #25
280 veor q8, q6, q10
281 veor q9, q7, q11
282 vshl.u32 q6, q8, #7
283 vshl.u32 q7, q9, #7
284 vsri.u32 q6, q8, #25
285 vsri.u32 q7, q9, #25
287 vld1.32 {q8-q9}, [sp, :256]
289 // x0 += x5, x15 = rotl32(x15 ^ x0, 16)
290 // x1 += x6, x12 = rotl32(x12 ^ x1, 16)
291 // x2 += x7, x13 = rotl32(x13 ^ x2, 16)
292 // x3 += x4, x14 = rotl32(x14 ^ x3, 16)
293 vadd.i32 q0, q0, q5
294 vadd.i32 q1, q1, q6
295 vadd.i32 q2, q2, q7
296 vadd.i32 q3, q3, q4
298 veor q15, q15, q0
299 veor q12, q12, q1
300 veor q13, q13, q2
301 veor q14, q14, q3
303 vrev32.16 q15, q15
304 vrev32.16 q12, q12
305 vrev32.16 q13, q13
306 vrev32.16 q14, q14
308 // x10 += x15, x5 = rotl32(x5 ^ x10, 12)
309 // x11 += x12, x6 = rotl32(x6 ^ x11, 12)
310 // x8 += x13, x7 = rotl32(x7 ^ x8, 12)
311 // x9 += x14, x4 = rotl32(x4 ^ x9, 12)
312 vadd.i32 q10, q10, q15
313 vadd.i32 q11, q11, q12
314 vadd.i32 q8, q8, q13
315 vadd.i32 q9, q9, q14
317 vst1.32 {q8-q9}, [sp, :256]
319 veor q8, q7, q8
320 veor q9, q4, q9
321 vshl.u32 q7, q8, #12
322 vshl.u32 q4, q9, #12
323 vsri.u32 q7, q8, #20
324 vsri.u32 q4, q9, #20
326 veor q8, q5, q10
327 veor q9, q6, q11
328 vshl.u32 q5, q8, #12
329 vshl.u32 q6, q9, #12
330 vsri.u32 q5, q8, #20
331 vsri.u32 q6, q9, #20
333 // x0 += x5, x15 = rotl32(x15 ^ x0, 8)
334 // x1 += x6, x12 = rotl32(x12 ^ x1, 8)
335 // x2 += x7, x13 = rotl32(x13 ^ x2, 8)
336 // x3 += x4, x14 = rotl32(x14 ^ x3, 8)
337 vadd.i32 q0, q0, q5
338 vadd.i32 q1, q1, q6
339 vadd.i32 q2, q2, q7
340 vadd.i32 q3, q3, q4
342 veor q8, q15, q0
343 veor q9, q12, q1
344 vshl.u32 q15, q8, #8
345 vshl.u32 q12, q9, #8
346 vsri.u32 q15, q8, #24
347 vsri.u32 q12, q9, #24
349 veor q8, q13, q2
350 veor q9, q14, q3
351 vshl.u32 q13, q8, #8
352 vshl.u32 q14, q9, #8
353 vsri.u32 q13, q8, #24
354 vsri.u32 q14, q9, #24
356 vld1.32 {q8-q9}, [sp, :256]
358 // x10 += x15, x5 = rotl32(x5 ^ x10, 7)
359 // x11 += x12, x6 = rotl32(x6 ^ x11, 7)
360 // x8 += x13, x7 = rotl32(x7 ^ x8, 7)
361 // x9 += x14, x4 = rotl32(x4 ^ x9, 7)
362 vadd.i32 q10, q10, q15
363 vadd.i32 q11, q11, q12
364 vadd.i32 q8, q8, q13
365 vadd.i32 q9, q9, q14
367 vst1.32 {q8-q9}, [sp, :256]
369 veor q8, q7, q8
370 veor q9, q4, q9
371 vshl.u32 q7, q8, #7
372 vshl.u32 q4, q9, #7
373 vsri.u32 q7, q8, #25
374 vsri.u32 q4, q9, #25
376 veor q8, q5, q10
377 veor q9, q6, q11
378 vshl.u32 q5, q8, #7
379 vshl.u32 q6, q9, #7
380 vsri.u32 q5, q8, #25
381 vsri.u32 q6, q9, #25
383 subs r3, r3, #1
384 beq 0f
386 vld1.32 {q8-q9}, [sp, :256]
387 b .Ldoubleround4
389 // x0[0-3] += s0[0]
390 // x1[0-3] += s0[1]
391 // x2[0-3] += s0[2]
392 // x3[0-3] += s0[3]
393 0: ldmia r0!, {r3-r6}
394 vdup.32 q8, r3
395 vdup.32 q9, r4
396 vadd.i32 q0, q0, q8
397 vadd.i32 q1, q1, q9
398 vdup.32 q8, r5
399 vdup.32 q9, r6
400 vadd.i32 q2, q2, q8
401 vadd.i32 q3, q3, q9
403 // x4[0-3] += s1[0]
404 // x5[0-3] += s1[1]
405 // x6[0-3] += s1[2]
406 // x7[0-3] += s1[3]
407 ldmia r0!, {r3-r6}
408 vdup.32 q8, r3
409 vdup.32 q9, r4
410 vadd.i32 q4, q4, q8
411 vadd.i32 q5, q5, q9
412 vdup.32 q8, r5
413 vdup.32 q9, r6
414 vadd.i32 q6, q6, q8
415 vadd.i32 q7, q7, q9
417 // interleave 32-bit words in state n, n+1
418 vzip.32 q0, q1
419 vzip.32 q2, q3
420 vzip.32 q4, q5
421 vzip.32 q6, q7
423 // interleave 64-bit words in state n, n+2
424 vswp d1, d4
425 vswp d3, d6
426 vswp d9, d12
427 vswp d11, d14
429 // xor with corresponding input, write to output
430 vld1.8 {q8-q9}, [r2]!
431 veor q8, q8, q0
432 veor q9, q9, q4
433 vst1.8 {q8-q9}, [r1]!
435 vld1.32 {q8-q9}, [sp, :256]
437 // x8[0-3] += s2[0]
438 // x9[0-3] += s2[1]
439 // x10[0-3] += s2[2]
440 // x11[0-3] += s2[3]
441 ldmia r0!, {r3-r6}
442 vdup.32 q0, r3
443 vdup.32 q4, r4
444 vadd.i32 q8, q8, q0
445 vadd.i32 q9, q9, q4
446 vdup.32 q0, r5
447 vdup.32 q4, r6
448 vadd.i32 q10, q10, q0
449 vadd.i32 q11, q11, q4
451 // x12[0-3] += s3[0]
452 // x13[0-3] += s3[1]
453 // x14[0-3] += s3[2]
454 // x15[0-3] += s3[3]
455 ldmia r0!, {r3-r6}
456 vdup.32 q0, r3
457 vdup.32 q4, r4
458 adr r3, CTRINC
459 vadd.i32 q12, q12, q0
460 vld1.32 {q0}, [r3, :128]
461 vadd.i32 q13, q13, q4
462 vadd.i32 q12, q12, q0 // x12 += counter values 0-3
464 vdup.32 q0, r5
465 vdup.32 q4, r6
466 vadd.i32 q14, q14, q0
467 vadd.i32 q15, q15, q4
469 // interleave 32-bit words in state n, n+1
470 vzip.32 q8, q9
471 vzip.32 q10, q11
472 vzip.32 q12, q13
473 vzip.32 q14, q15
475 // interleave 64-bit words in state n, n+2
476 vswp d17, d20
477 vswp d19, d22
478 vswp d25, d28
479 vswp d27, d30
481 vmov q4, q1
483 vld1.8 {q0-q1}, [r2]!
484 veor q0, q0, q8
485 veor q1, q1, q12
486 vst1.8 {q0-q1}, [r1]!
488 vld1.8 {q0-q1}, [r2]!
489 veor q0, q0, q2
490 veor q1, q1, q6
491 vst1.8 {q0-q1}, [r1]!
493 vld1.8 {q0-q1}, [r2]!
494 veor q0, q0, q10
495 veor q1, q1, q14
496 vst1.8 {q0-q1}, [r1]!
498 vld1.8 {q0-q1}, [r2]!
499 veor q0, q0, q4
500 veor q1, q1, q5
501 vst1.8 {q0-q1}, [r1]!
503 vld1.8 {q0-q1}, [r2]!
504 veor q0, q0, q9
505 veor q1, q1, q13
506 vst1.8 {q0-q1}, [r1]!
508 vld1.8 {q0-q1}, [r2]!
509 veor q0, q0, q3
510 veor q1, q1, q7
511 vst1.8 {q0-q1}, [r1]!
513 vld1.8 {q0-q1}, [r2]
514 veor q0, q0, q11
515 veor q1, q1, q15
516 vst1.8 {q0-q1}, [r1]
518 mov sp, ip
519 pop {r4-r6, pc}
520 ENDPROC(chacha20_4block_xor_neon)
522 .align 4
523 CTRINC: .word 0, 1, 2, 3