_ Git - BearSSL/blob - 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