projects / BearSSL / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added generic EAX and CCM implementations.
[BearSSL] / src / symcipher / aes_pwr8_cbcdec.c
1 /*
2 * Copyright (c) 2017 Thomas Pornin <pornin@bolet.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25 #define BR_POWER_ASM_MACROS 1
26 #include "inner.h"
27
28 #if BR_POWER8
29
30 /* see bearssl_block.h */
31 void
32 br_aes_pwr8_cbcdec_init(br_aes_pwr8_cbcdec_keys *ctx,
33 const void *key, size_t len)
34 {
35 ctx->vtable = &br_aes_pwr8_cbcdec_vtable;
36 ctx->num_rounds = br_aes_pwr8_keysched(ctx->skey.skni, key, len);
37 }
38
39 static void
40 cbcdec_128(const unsigned char *sk,
41 const unsigned char *iv, unsigned char *buf, size_t num_blocks)
42 {
43 long cc0, cc1, cc2, cc3;
44
45 #if BR_POWER8_LE
46 static const uint32_t idx2be[] = {
47 0x03020100, 0x07060504, 0x0B0A0908, 0x0F0E0D0C
48 };
49 #endif
50
51 cc0 = 0;
52 cc1 = 16;
53 cc2 = 32;
54 cc3 = 48;
55 asm volatile (
56
57 /*
58 * Load subkeys into v0..v10
59 */
60 lxvw4x(32, %[cc0], %[sk])
61 addi(%[cc0], %[cc0], 16)
62 lxvw4x(33, %[cc0], %[sk])
63 addi(%[cc0], %[cc0], 16)
64 lxvw4x(34, %[cc0], %[sk])
65 addi(%[cc0], %[cc0], 16)
66 lxvw4x(35, %[cc0], %[sk])
67 addi(%[cc0], %[cc0], 16)
68 lxvw4x(36, %[cc0], %[sk])
69 addi(%[cc0], %[cc0], 16)
70 lxvw4x(37, %[cc0], %[sk])
71 addi(%[cc0], %[cc0], 16)
72 lxvw4x(38, %[cc0], %[sk])
73 addi(%[cc0], %[cc0], 16)
74 lxvw4x(39, %[cc0], %[sk])
75 addi(%[cc0], %[cc0], 16)
76 lxvw4x(40, %[cc0], %[sk])
77 addi(%[cc0], %[cc0], 16)
78 lxvw4x(41, %[cc0], %[sk])
79 addi(%[cc0], %[cc0], 16)
80 lxvw4x(42, %[cc0], %[sk])
81 li(%[cc0], 0)
82
83 #if BR_POWER8_LE
84 /*
85 * v15 = constant for byteswapping words
86 */
87 lxvw4x(47, 0, %[idx2be])
88 #endif
89 /*
90 * Load IV into v24.
91 */
92 lxvw4x(56, 0, %[iv])
93 #if BR_POWER8_LE
94 vperm(24, 24, 24, 15)
95 #endif
96
97 mtctr(%[num_blocks])
98 label(loop)
99 /*
100 * Load next ciphertext words in v16..v19. Also save them
101 * in v20..v23.
102 */
103 lxvw4x(48, %[cc0], %[buf])
104 lxvw4x(49, %[cc1], %[buf])
105 lxvw4x(50, %[cc2], %[buf])
106 lxvw4x(51, %[cc3], %[buf])
107 #if BR_POWER8_LE
108 vperm(16, 16, 16, 15)
109 vperm(17, 17, 17, 15)
110 vperm(18, 18, 18, 15)
111 vperm(19, 19, 19, 15)
112 #endif
113 vand(20, 16, 16)
114 vand(21, 17, 17)
115 vand(22, 18, 18)
116 vand(23, 19, 19)
117
118 /*
119 * Decrypt the blocks.
120 */
121 vxor(16, 16, 10)
122 vxor(17, 17, 10)
123 vxor(18, 18, 10)
124 vxor(19, 19, 10)
125 vncipher(16, 16, 9)
126 vncipher(17, 17, 9)
127 vncipher(18, 18, 9)
128 vncipher(19, 19, 9)
129 vncipher(16, 16, 8)
130 vncipher(17, 17, 8)
131 vncipher(18, 18, 8)
132 vncipher(19, 19, 8)
133 vncipher(16, 16, 7)
134 vncipher(17, 17, 7)
135 vncipher(18, 18, 7)
136 vncipher(19, 19, 7)
137 vncipher(16, 16, 6)
138 vncipher(17, 17, 6)
139 vncipher(18, 18, 6)
140 vncipher(19, 19, 6)
141 vncipher(16, 16, 5)
142 vncipher(17, 17, 5)
143 vncipher(18, 18, 5)
144 vncipher(19, 19, 5)
145 vncipher(16, 16, 4)
146 vncipher(17, 17, 4)
147 vncipher(18, 18, 4)
148 vncipher(19, 19, 4)
149 vncipher(16, 16, 3)
150 vncipher(17, 17, 3)
151 vncipher(18, 18, 3)
152 vncipher(19, 19, 3)
153 vncipher(16, 16, 2)
154 vncipher(17, 17, 2)
155 vncipher(18, 18, 2)
156 vncipher(19, 19, 2)
157 vncipher(16, 16, 1)
158 vncipher(17, 17, 1)
159 vncipher(18, 18, 1)
160 vncipher(19, 19, 1)
161 vncipherlast(16, 16, 0)
162 vncipherlast(17, 17, 0)
163 vncipherlast(18, 18, 0)
164 vncipherlast(19, 19, 0)
165
166 /*
167 * XOR decrypted blocks with IV / previous block.
168 */
169 vxor(16, 16, 24)
170 vxor(17, 17, 20)
171 vxor(18, 18, 21)
172 vxor(19, 19, 22)
173
174 /*
175 * Store back result (with byteswap)
176 */
177 #if BR_POWER8_LE
178 vperm(16, 16, 16, 15)
179 vperm(17, 17, 17, 15)
180 vperm(18, 18, 18, 15)
181 vperm(19, 19, 19, 15)
182 #endif
183 stxvw4x(48, %[cc0], %[buf])
184 stxvw4x(49, %[cc1], %[buf])
185 stxvw4x(50, %[cc2], %[buf])
186 stxvw4x(51, %[cc3], %[buf])
187
188 /*
189 * Fourth encrypted block is IV for next run.
190 */
191 vand(24, 23, 23)
192
193 addi(%[buf], %[buf], 64)
194
195 bdnz(loop)
196
197 : [cc0] "+b" (cc0), [cc1] "+b" (cc1), [cc2] "+b" (cc2), [cc3] "+b" (cc3),
198 [buf] "+b" (buf)
199 : [sk] "b" (sk), [iv] "b" (iv), [num_blocks] "b" (num_blocks >> 2)
200 #if BR_POWER8_LE
201 , [idx2be] "b" (idx2be)
202 #endif
203 : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9",
204 "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19",
205 "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29",
206 "ctr", "memory"
207 );
208 }
209
210 static void
211 cbcdec_192(const unsigned char *sk,
212 const unsigned char *iv, unsigned char *buf, size_t num_blocks)
213 {
214 long cc0, cc1, cc2, cc3;
215
216 #if BR_POWER8_LE
217 static const uint32_t idx2be[] = {
218 0x03020100, 0x07060504, 0x0B0A0908, 0x0F0E0D0C
219 };
220 #endif
221
222 cc0 = 0;
223 cc1 = 16;
224 cc2 = 32;
225 cc3 = 48;
226 asm volatile (
227
228 /*
229 * Load subkeys into v0..v12
230 */
231 lxvw4x(32, %[cc0], %[sk])
232 addi(%[cc0], %[cc0], 16)
233 lxvw4x(33, %[cc0], %[sk])
234 addi(%[cc0], %[cc0], 16)
235 lxvw4x(34, %[cc0], %[sk])
236 addi(%[cc0], %[cc0], 16)
237 lxvw4x(35, %[cc0], %[sk])
238 addi(%[cc0], %[cc0], 16)
239 lxvw4x(36, %[cc0], %[sk])
240 addi(%[cc0], %[cc0], 16)
241 lxvw4x(37, %[cc0], %[sk])
242 addi(%[cc0], %[cc0], 16)
243 lxvw4x(38, %[cc0], %[sk])
244 addi(%[cc0], %[cc0], 16)
245 lxvw4x(39, %[cc0], %[sk])
246 addi(%[cc0], %[cc0], 16)
247 lxvw4x(40, %[cc0], %[sk])
248 addi(%[cc0], %[cc0], 16)
249 lxvw4x(41, %[cc0], %[sk])
250 addi(%[cc0], %[cc0], 16)
251 lxvw4x(42, %[cc0], %[sk])
252 addi(%[cc0], %[cc0], 16)
253 lxvw4x(43, %[cc0], %[sk])
254 addi(%[cc0], %[cc0], 16)
255 lxvw4x(44, %[cc0], %[sk])
256 li(%[cc0], 0)
257
258 #if BR_POWER8_LE
259 /*
260 * v15 = constant for byteswapping words
261 */
262 lxvw4x(47, 0, %[idx2be])
263 #endif
264 /*
265 * Load IV into v24.
266 */
267 lxvw4x(56, 0, %[iv])
268 #if BR_POWER8_LE
269 vperm(24, 24, 24, 15)
270 #endif
271
272 mtctr(%[num_blocks])
273 label(loop)
274 /*
275 * Load next ciphertext words in v16..v19. Also save them
276 * in v20..v23.
277 */
278 lxvw4x(48, %[cc0], %[buf])
279 lxvw4x(49, %[cc1], %[buf])
280 lxvw4x(50, %[cc2], %[buf])
281 lxvw4x(51, %[cc3], %[buf])
282 #if BR_POWER8_LE
283 vperm(16, 16, 16, 15)
284 vperm(17, 17, 17, 15)
285 vperm(18, 18, 18, 15)
286 vperm(19, 19, 19, 15)
287 #endif
288 vand(20, 16, 16)
289 vand(21, 17, 17)
290 vand(22, 18, 18)
291 vand(23, 19, 19)
292
293 /*
294 * Decrypt the blocks.
295 */
296 vxor(16, 16, 12)
297 vxor(17, 17, 12)
298 vxor(18, 18, 12)
299 vxor(19, 19, 12)
300 vncipher(16, 16, 11)
301 vncipher(17, 17, 11)
302 vncipher(18, 18, 11)
303 vncipher(19, 19, 11)
304 vncipher(16, 16, 10)
305 vncipher(17, 17, 10)
306 vncipher(18, 18, 10)
307 vncipher(19, 19, 10)
308 vncipher(16, 16, 9)
309 vncipher(17, 17, 9)
310 vncipher(18, 18, 9)
311 vncipher(19, 19, 9)
312 vncipher(16, 16, 8)
313 vncipher(17, 17, 8)
314 vncipher(18, 18, 8)
315 vncipher(19, 19, 8)
316 vncipher(16, 16, 7)
317 vncipher(17, 17, 7)
318 vncipher(18, 18, 7)
319 vncipher(19, 19, 7)
320 vncipher(16, 16, 6)
321 vncipher(17, 17, 6)
322 vncipher(18, 18, 6)
323 vncipher(19, 19, 6)
324 vncipher(16, 16, 5)
325 vncipher(17, 17, 5)
326 vncipher(18, 18, 5)
327 vncipher(19, 19, 5)
328 vncipher(16, 16, 4)
329 vncipher(17, 17, 4)
330 vncipher(18, 18, 4)
331 vncipher(19, 19, 4)
332 vncipher(16, 16, 3)
333 vncipher(17, 17, 3)
334 vncipher(18, 18, 3)
335 vncipher(19, 19, 3)
336 vncipher(16, 16, 2)
337 vncipher(17, 17, 2)
338 vncipher(18, 18, 2)
339 vncipher(19, 19, 2)
340 vncipher(16, 16, 1)
341 vncipher(17, 17, 1)
342 vncipher(18, 18, 1)
343 vncipher(19, 19, 1)
344 vncipherlast(16, 16, 0)
345 vncipherlast(17, 17, 0)
346 vncipherlast(18, 18, 0)
347 vncipherlast(19, 19, 0)
348
349 /*
350 * XOR decrypted blocks with IV / previous block.
351 */
352 vxor(16, 16, 24)
353 vxor(17, 17, 20)
354 vxor(18, 18, 21)
355 vxor(19, 19, 22)
356
357 /*
358 * Store back result (with byteswap)
359 */
360 #if BR_POWER8_LE
361 vperm(16, 16, 16, 15)
362 vperm(17, 17, 17, 15)
363 vperm(18, 18, 18, 15)
364 vperm(19, 19, 19, 15)
365 #endif
366 stxvw4x(48, %[cc0], %[buf])
367 stxvw4x(49, %[cc1], %[buf])
368 stxvw4x(50, %[cc2], %[buf])
369 stxvw4x(51, %[cc3], %[buf])
370
371 /*
372 * Fourth encrypted block is IV for next run.
373 */
374 vand(24, 23, 23)
375
376 addi(%[buf], %[buf], 64)
377
378 bdnz(loop)
379
380 : [cc0] "+b" (cc0), [cc1] "+b" (cc1), [cc2] "+b" (cc2), [cc3] "+b" (cc3),
381 [buf] "+b" (buf)
382 : [sk] "b" (sk), [iv] "b" (iv), [num_blocks] "b" (num_blocks >> 2)
383 #if BR_POWER8_LE
384 , [idx2be] "b" (idx2be)
385 #endif
386 : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9",
387 "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19",
388 "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29",
389 "ctr", "memory"
390 );
391 }
392
393 static void
394 cbcdec_256(const unsigned char *sk,
395 const unsigned char *iv, unsigned char *buf, size_t num_blocks)
396 {
397 long cc0, cc1, cc2, cc3;
398
399 #if BR_POWER8_LE
400 static const uint32_t idx2be[] = {
401 0x03020100, 0x07060504, 0x0B0A0908, 0x0F0E0D0C
402 };
403 #endif
404
405 cc0 = 0;
406 cc1 = 16;
407 cc2 = 32;
408 cc3 = 48;
409 asm volatile (
410
411 /*
412 * Load subkeys into v0..v14
413 */
414 lxvw4x(32, %[cc0], %[sk])
415 addi(%[cc0], %[cc0], 16)
416 lxvw4x(33, %[cc0], %[sk])
417 addi(%[cc0], %[cc0], 16)
418 lxvw4x(34, %[cc0], %[sk])
419 addi(%[cc0], %[cc0], 16)
420 lxvw4x(35, %[cc0], %[sk])
421 addi(%[cc0], %[cc0], 16)
422 lxvw4x(36, %[cc0], %[sk])
423 addi(%[cc0], %[cc0], 16)
424 lxvw4x(37, %[cc0], %[sk])
425 addi(%[cc0], %[cc0], 16)
426 lxvw4x(38, %[cc0], %[sk])
427 addi(%[cc0], %[cc0], 16)
428 lxvw4x(39, %[cc0], %[sk])
429 addi(%[cc0], %[cc0], 16)
430 lxvw4x(40, %[cc0], %[sk])
431 addi(%[cc0], %[cc0], 16)
432 lxvw4x(41, %[cc0], %[sk])
433 addi(%[cc0], %[cc0], 16)
434 lxvw4x(42, %[cc0], %[sk])
435 addi(%[cc0], %[cc0], 16)
436 lxvw4x(43, %[cc0], %[sk])
437 addi(%[cc0], %[cc0], 16)
438 lxvw4x(44, %[cc0], %[sk])
439 addi(%[cc0], %[cc0], 16)
440 lxvw4x(45, %[cc0], %[sk])
441 addi(%[cc0], %[cc0], 16)
442 lxvw4x(46, %[cc0], %[sk])
443 li(%[cc0], 0)
444
445 #if BR_POWER8_LE
446 /*
447 * v15 = constant for byteswapping words
448 */
449 lxvw4x(47, 0, %[idx2be])
450 #endif
451 /*
452 * Load IV into v24.
453 */
454 lxvw4x(56, 0, %[iv])
455 #if BR_POWER8_LE
456 vperm(24, 24, 24, 15)
457 #endif
458
459 mtctr(%[num_blocks])
460 label(loop)
461 /*
462 * Load next ciphertext words in v16..v19. Also save them
463 * in v20..v23.
464 */
465 lxvw4x(48, %[cc0], %[buf])
466 lxvw4x(49, %[cc1], %[buf])
467 lxvw4x(50, %[cc2], %[buf])
468 lxvw4x(51, %[cc3], %[buf])
469 #if BR_POWER8_LE
470 vperm(16, 16, 16, 15)
471 vperm(17, 17, 17, 15)
472 vperm(18, 18, 18, 15)
473 vperm(19, 19, 19, 15)
474 #endif
475 vand(20, 16, 16)
476 vand(21, 17, 17)
477 vand(22, 18, 18)
478 vand(23, 19, 19)
479
480 /*
481 * Decrypt the blocks.
482 */
483 vxor(16, 16, 14)
484 vxor(17, 17, 14)
485 vxor(18, 18, 14)
486 vxor(19, 19, 14)
487 vncipher(16, 16, 13)
488 vncipher(17, 17, 13)
489 vncipher(18, 18, 13)
490 vncipher(19, 19, 13)
491 vncipher(16, 16, 12)
492 vncipher(17, 17, 12)
493 vncipher(18, 18, 12)
494 vncipher(19, 19, 12)
495 vncipher(16, 16, 11)
496 vncipher(17, 17, 11)
497 vncipher(18, 18, 11)
498 vncipher(19, 19, 11)
499 vncipher(16, 16, 10)
500 vncipher(17, 17, 10)
501 vncipher(18, 18, 10)
502 vncipher(19, 19, 10)
503 vncipher(16, 16, 9)
504 vncipher(17, 17, 9)
505 vncipher(18, 18, 9)
506 vncipher(19, 19, 9)
507 vncipher(16, 16, 8)
508 vncipher(17, 17, 8)
509 vncipher(18, 18, 8)
510 vncipher(19, 19, 8)
511 vncipher(16, 16, 7)
512 vncipher(17, 17, 7)
513 vncipher(18, 18, 7)
514 vncipher(19, 19, 7)
515 vncipher(16, 16, 6)
516 vncipher(17, 17, 6)
517 vncipher(18, 18, 6)
518 vncipher(19, 19, 6)
519 vncipher(16, 16, 5)
520 vncipher(17, 17, 5)
521 vncipher(18, 18, 5)
522 vncipher(19, 19, 5)
523 vncipher(16, 16, 4)
524 vncipher(17, 17, 4)
525 vncipher(18, 18, 4)
526 vncipher(19, 19, 4)
527 vncipher(16, 16, 3)
528 vncipher(17, 17, 3)
529 vncipher(18, 18, 3)
530 vncipher(19, 19, 3)
531 vncipher(16, 16, 2)
532 vncipher(17, 17, 2)
533 vncipher(18, 18, 2)
534 vncipher(19, 19, 2)
535 vncipher(16, 16, 1)
536 vncipher(17, 17, 1)
537 vncipher(18, 18, 1)
538 vncipher(19, 19, 1)
539 vncipherlast(16, 16, 0)
540 vncipherlast(17, 17, 0)
541 vncipherlast(18, 18, 0)
542 vncipherlast(19, 19, 0)
543
544 /*
545 * XOR decrypted blocks with IV / previous block.
546 */
547 vxor(16, 16, 24)
548 vxor(17, 17, 20)
549 vxor(18, 18, 21)
550 vxor(19, 19, 22)
551
552 /*
553 * Store back result (with byteswap)
554 */
555 #if BR_POWER8_LE
556 vperm(16, 16, 16, 15)
557 vperm(17, 17, 17, 15)
558 vperm(18, 18, 18, 15)
559 vperm(19, 19, 19, 15)
560 #endif
561 stxvw4x(48, %[cc0], %[buf])
562 stxvw4x(49, %[cc1], %[buf])
563 stxvw4x(50, %[cc2], %[buf])
564 stxvw4x(51, %[cc3], %[buf])
565
566 /*
567 * Fourth encrypted block is IV for next run.
568 */
569 vand(24, 23, 23)
570
571 addi(%[buf], %[buf], 64)
572
573 bdnz(loop)
574
575 : [cc0] "+b" (cc0), [cc1] "+b" (cc1), [cc2] "+b" (cc2), [cc3] "+b" (cc3),
576 [buf] "+b" (buf)
577 : [sk] "b" (sk), [iv] "b" (iv), [num_blocks] "b" (num_blocks >> 2)
578 #if BR_POWER8_LE
579 , [idx2be] "b" (idx2be)
580 #endif
581 : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9",
582 "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19",
583 "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29",
584 "ctr", "memory"
585 );
586 }
587
588 /* see bearssl_block.h */
589 void
590 br_aes_pwr8_cbcdec_run(const br_aes_pwr8_cbcdec_keys *ctx,
591 void *iv, void *data, size_t len)
592 {
593 unsigned char nextiv[16];
594 unsigned char *buf;
595
596 if (len == 0) {
597 return;
598 }
599 buf = data;
600 memcpy(nextiv, buf + len - 16, 16);
601 if (len >= 64) {
602 size_t num_blocks;
603 unsigned char tmp[16];
604
605 num_blocks = (len >> 4) & ~(size_t)3;
606 memcpy(tmp, buf + (num_blocks << 4) - 16, 16);
607 switch (ctx->num_rounds) {
608 case 10:
609 cbcdec_128(ctx->skey.skni, iv, buf, num_blocks);
610 break;
611 case 12:
612 cbcdec_192(ctx->skey.skni, iv, buf, num_blocks);
613 break;
614 default:
615 cbcdec_256(ctx->skey.skni, iv, buf, num_blocks);
616 break;
617 }
618 buf += num_blocks << 4;
619 len &= 63;
620 memcpy(iv, tmp, 16);
621 }
622 if (len > 0) {
623 unsigned char tmp[64];
624
625 memcpy(tmp, buf, len);
626 memset(tmp + len, 0, (sizeof tmp) - len);
627 switch (ctx->num_rounds) {
628 case 10:
629 cbcdec_128(ctx->skey.skni, iv, tmp, 4);
630 break;
631 case 12:
632 cbcdec_192(ctx->skey.skni, iv, tmp, 4);
633 break;
634 default:
635 cbcdec_256(ctx->skey.skni, iv, tmp, 4);
636 break;
637 }
638 memcpy(buf, tmp, len);
639 }
640 memcpy(iv, nextiv, 16);
641 }
642
643 /* see bearssl_block.h */
644 const br_block_cbcdec_class br_aes_pwr8_cbcdec_vtable = {
645 sizeof(br_aes_pwr8_cbcdec_keys),
646 16,
647 4,
648 (void (*)(const br_block_cbcdec_class **, const void *, size_t))
649 &br_aes_pwr8_cbcdec_init,
650 (void (*)(const br_block_cbcdec_class *const *, void *, void *, size_t))
651 &br_aes_pwr8_cbcdec_run
652 };
653
654 /* see bearssl_block.h */
655 const br_block_cbcdec_class *
656 br_aes_pwr8_cbcdec_get_vtable(void)
657 {
658 return br_aes_pwr8_supported() ? &br_aes_pwr8_cbcdec_vtable : NULL;
659 }
660
661 #else
662
663 /* see bearssl_block.h */
664 const br_block_cbcdec_class *
665 br_aes_pwr8_cbcdec_get_vtable(void)
666 {
667 return NULL;
668 }
669
670 #endif
The BearSSL library and tools.