1 /* 2 * linux/arch/arm64/crypto/aes-glue.c - wrapper code for ARMv8 AES 3 * 4 * Copyright (C) 2013 - 2017 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 11 #include <asm/neon.h> 12 #include <asm/hwcap.h> 13 #include <asm/simd.h> 14 #include <crypto/aes.h> 15 #include <crypto/internal/hash.h> 16 #include <crypto/internal/simd.h> 17 #include <crypto/internal/skcipher.h> 18 #include <linux/module.h> 19 #include <linux/cpufeature.h> 20 #include <crypto/xts.h> 21 22 #include "aes-ce-setkey.h" 23 #include "aes-ctr-fallback.h" 24 25 #ifdef USE_V8_CRYPTO_EXTENSIONS 26 #define MODE "ce" 27 #define PRIO 300 28 #define aes_setkey ce_aes_setkey 29 #define aes_expandkey ce_aes_expandkey 30 #define aes_ecb_encrypt ce_aes_ecb_encrypt 31 #define aes_ecb_decrypt ce_aes_ecb_decrypt 32 #define aes_cbc_encrypt ce_aes_cbc_encrypt 33 #define aes_cbc_decrypt ce_aes_cbc_decrypt 34 #define aes_ctr_encrypt ce_aes_ctr_encrypt 35 #define aes_xts_encrypt ce_aes_xts_encrypt 36 #define aes_xts_decrypt ce_aes_xts_decrypt 37 #define aes_mac_update ce_aes_mac_update 38 MODULE_DESCRIPTION("AES-ECB/CBC/CTR/XTS using ARMv8 Crypto Extensions"); 39 #else 40 #define MODE "neon" 41 #define PRIO 200 42 #define aes_setkey crypto_aes_set_key 43 #define aes_expandkey crypto_aes_expand_key 44 #define aes_ecb_encrypt neon_aes_ecb_encrypt 45 #define aes_ecb_decrypt neon_aes_ecb_decrypt 46 #define aes_cbc_encrypt neon_aes_cbc_encrypt 47 #define aes_cbc_decrypt neon_aes_cbc_decrypt 48 #define aes_ctr_encrypt neon_aes_ctr_encrypt 49 #define aes_xts_encrypt neon_aes_xts_encrypt 50 #define aes_xts_decrypt neon_aes_xts_decrypt 51 #define aes_mac_update neon_aes_mac_update 52 MODULE_DESCRIPTION("AES-ECB/CBC/CTR/XTS using ARMv8 NEON"); 53 MODULE_ALIAS_CRYPTO("ecb(aes)"); 54 MODULE_ALIAS_CRYPTO("cbc(aes)"); 55 MODULE_ALIAS_CRYPTO("ctr(aes)"); 56 MODULE_ALIAS_CRYPTO("xts(aes)"); 57 MODULE_ALIAS_CRYPTO("cmac(aes)"); 58 MODULE_ALIAS_CRYPTO("xcbc(aes)"); 59 MODULE_ALIAS_CRYPTO("cbcmac(aes)"); 60 #endif 61 62 MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>"); 63 MODULE_LICENSE("GPL v2"); 64 65 /* defined in aes-modes.S */ 66 asmlinkage void aes_ecb_encrypt(u8 out[], u8 const in[], u8 const rk[], 67 int rounds, int blocks, int first); 68 asmlinkage void aes_ecb_decrypt(u8 out[], u8 const in[], u8 const rk[], 69 int rounds, int blocks, int first); 70 71 asmlinkage void aes_cbc_encrypt(u8 out[], u8 const in[], u8 const rk[], 72 int rounds, int blocks, u8 iv[], int first); 73 asmlinkage void aes_cbc_decrypt(u8 out[], u8 const in[], u8 const rk[], 74 int rounds, int blocks, u8 iv[], int first); 75 76 asmlinkage void aes_ctr_encrypt(u8 out[], u8 const in[], u8 const rk[], 77 int rounds, int blocks, u8 ctr[], int first); 78 79 asmlinkage void aes_xts_encrypt(u8 out[], u8 const in[], u8 const rk1[], 80 int rounds, int blocks, u8 const rk2[], u8 iv[], 81 int first); 82 asmlinkage void aes_xts_decrypt(u8 out[], u8 const in[], u8 const rk1[], 83 int rounds, int blocks, u8 const rk2[], u8 iv[], 84 int first); 85 86 asmlinkage void aes_mac_update(u8 const in[], u32 const rk[], int rounds, 87 int blocks, u8 dg[], int enc_before, 88 int enc_after); 89 90 struct crypto_aes_xts_ctx { 91 struct crypto_aes_ctx key1; 92 struct crypto_aes_ctx __aligned(8) key2; 93 }; 94 95 struct mac_tfm_ctx { 96 struct crypto_aes_ctx key; 97 u8 __aligned(8) consts[]; 98 }; 99 100 struct mac_desc_ctx { 101 unsigned int len; 102 u8 dg[AES_BLOCK_SIZE]; 103 }; 104 105 static int skcipher_aes_setkey(struct crypto_skcipher *tfm, const u8 *in_key, 106 unsigned int key_len) 107 { 108 return aes_setkey(crypto_skcipher_tfm(tfm), in_key, key_len); 109 } 110 111 static int xts_set_key(struct crypto_skcipher *tfm, const u8 *in_key, 112 unsigned int key_len) 113 { 114 struct crypto_aes_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 115 int ret; 116 117 ret = xts_verify_key(tfm, in_key, key_len); 118 if (ret) 119 return ret; 120 121 ret = aes_expandkey(&ctx->key1, in_key, key_len / 2); 122 if (!ret) 123 ret = aes_expandkey(&ctx->key2, &in_key[key_len / 2], 124 key_len / 2); 125 if (!ret) 126 return 0; 127 128 crypto_skcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN); 129 return -EINVAL; 130 } 131 132 static int ecb_encrypt(struct skcipher_request *req) 133 { 134 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 135 struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); 136 int err, first, rounds = 6 + ctx->key_length / 4; 137 struct skcipher_walk walk; 138 unsigned int blocks; 139 140 err = skcipher_walk_virt(&walk, req, true); 141 142 kernel_neon_begin(); 143 for (first = 1; (blocks = (walk.nbytes / AES_BLOCK_SIZE)); first = 0) { 144 aes_ecb_encrypt(walk.dst.virt.addr, walk.src.virt.addr, 145 (u8 *)ctx->key_enc, rounds, blocks, first); 146 err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE); 147 } 148 kernel_neon_end(); 149 return err; 150 } 151 152 static int ecb_decrypt(struct skcipher_request *req) 153 { 154 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 155 struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); 156 int err, first, rounds = 6 + ctx->key_length / 4; 157 struct skcipher_walk walk; 158 unsigned int blocks; 159 160 err = skcipher_walk_virt(&walk, req, true); 161 162 kernel_neon_begin(); 163 for (first = 1; (blocks = (walk.nbytes / AES_BLOCK_SIZE)); first = 0) { 164 aes_ecb_decrypt(walk.dst.virt.addr, walk.src.virt.addr, 165 (u8 *)ctx->key_dec, rounds, blocks, first); 166 err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE); 167 } 168 kernel_neon_end(); 169 return err; 170 } 171 172 static int cbc_encrypt(struct skcipher_request *req) 173 { 174 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 175 struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); 176 int err, first, rounds = 6 + ctx->key_length / 4; 177 struct skcipher_walk walk; 178 unsigned int blocks; 179 180 err = skcipher_walk_virt(&walk, req, true); 181 182 kernel_neon_begin(); 183 for (first = 1; (blocks = (walk.nbytes / AES_BLOCK_SIZE)); first = 0) { 184 aes_cbc_encrypt(walk.dst.virt.addr, walk.src.virt.addr, 185 (u8 *)ctx->key_enc, rounds, blocks, walk.iv, 186 first); 187 err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE); 188 } 189 kernel_neon_end(); 190 return err; 191 } 192 193 static int cbc_decrypt(struct skcipher_request *req) 194 { 195 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 196 struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); 197 int err, first, rounds = 6 + ctx->key_length / 4; 198 struct skcipher_walk walk; 199 unsigned int blocks; 200 201 err = skcipher_walk_virt(&walk, req, true); 202 203 kernel_neon_begin(); 204 for (first = 1; (blocks = (walk.nbytes / AES_BLOCK_SIZE)); first = 0) { 205 aes_cbc_decrypt(walk.dst.virt.addr, walk.src.virt.addr, 206 (u8 *)ctx->key_dec, rounds, blocks, walk.iv, 207 first); 208 err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE); 209 } 210 kernel_neon_end(); 211 return err; 212 } 213 214 static int ctr_encrypt(struct skcipher_request *req) 215 { 216 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 217 struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); 218 int err, first, rounds = 6 + ctx->key_length / 4; 219 struct skcipher_walk walk; 220 int blocks; 221 222 err = skcipher_walk_virt(&walk, req, true); 223 224 first = 1; 225 kernel_neon_begin(); 226 while ((blocks = (walk.nbytes / AES_BLOCK_SIZE))) { 227 aes_ctr_encrypt(walk.dst.virt.addr, walk.src.virt.addr, 228 (u8 *)ctx->key_enc, rounds, blocks, walk.iv, 229 first); 230 err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE); 231 first = 0; 232 } 233 if (walk.nbytes) { 234 u8 __aligned(8) tail[AES_BLOCK_SIZE]; 235 unsigned int nbytes = walk.nbytes; 236 u8 *tdst = walk.dst.virt.addr; 237 u8 *tsrc = walk.src.virt.addr; 238 239 /* 240 * Tell aes_ctr_encrypt() to process a tail block. 241 */ 242 blocks = -1; 243 244 aes_ctr_encrypt(tail, NULL, (u8 *)ctx->key_enc, rounds, 245 blocks, walk.iv, first); 246 crypto_xor_cpy(tdst, tsrc, tail, nbytes); 247 err = skcipher_walk_done(&walk, 0); 248 } 249 kernel_neon_end(); 250 251 return err; 252 } 253 254 static int ctr_encrypt_sync(struct skcipher_request *req) 255 { 256 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 257 struct crypto_aes_ctx *ctx = crypto_skcipher_ctx(tfm); 258 259 if (!may_use_simd()) 260 return aes_ctr_encrypt_fallback(ctx, req); 261 262 return ctr_encrypt(req); 263 } 264 265 static int xts_encrypt(struct skcipher_request *req) 266 { 267 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 268 struct crypto_aes_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 269 int err, first, rounds = 6 + ctx->key1.key_length / 4; 270 struct skcipher_walk walk; 271 unsigned int blocks; 272 273 err = skcipher_walk_virt(&walk, req, true); 274 275 kernel_neon_begin(); 276 for (first = 1; (blocks = (walk.nbytes / AES_BLOCK_SIZE)); first = 0) { 277 aes_xts_encrypt(walk.dst.virt.addr, walk.src.virt.addr, 278 (u8 *)ctx->key1.key_enc, rounds, blocks, 279 (u8 *)ctx->key2.key_enc, walk.iv, first); 280 err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE); 281 } 282 kernel_neon_end(); 283 284 return err; 285 } 286 287 static int xts_decrypt(struct skcipher_request *req) 288 { 289 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 290 struct crypto_aes_xts_ctx *ctx = crypto_skcipher_ctx(tfm); 291 int err, first, rounds = 6 + ctx->key1.key_length / 4; 292 struct skcipher_walk walk; 293 unsigned int blocks; 294 295 err = skcipher_walk_virt(&walk, req, true); 296 297 kernel_neon_begin(); 298 for (first = 1; (blocks = (walk.nbytes / AES_BLOCK_SIZE)); first = 0) { 299 aes_xts_decrypt(walk.dst.virt.addr, walk.src.virt.addr, 300 (u8 *)ctx->key1.key_dec, rounds, blocks, 301 (u8 *)ctx->key2.key_enc, walk.iv, first); 302 err = skcipher_walk_done(&walk, walk.nbytes % AES_BLOCK_SIZE); 303 } 304 kernel_neon_end(); 305 306 return err; 307 } 308 309 static struct skcipher_alg aes_algs[] = { { 310 .base = { 311 .cra_name = "__ecb(aes)", 312 .cra_driver_name = "__ecb-aes-" MODE, 313 .cra_priority = PRIO, 314 .cra_flags = CRYPTO_ALG_INTERNAL, 315 .cra_blocksize = AES_BLOCK_SIZE, 316 .cra_ctxsize = sizeof(struct crypto_aes_ctx), 317 .cra_module = THIS_MODULE, 318 }, 319 .min_keysize = AES_MIN_KEY_SIZE, 320 .max_keysize = AES_MAX_KEY_SIZE, 321 .setkey = skcipher_aes_setkey, 322 .encrypt = ecb_encrypt, 323 .decrypt = ecb_decrypt, 324 }, { 325 .base = { 326 .cra_name = "__cbc(aes)", 327 .cra_driver_name = "__cbc-aes-" MODE, 328 .cra_priority = PRIO, 329 .cra_flags = CRYPTO_ALG_INTERNAL, 330 .cra_blocksize = AES_BLOCK_SIZE, 331 .cra_ctxsize = sizeof(struct crypto_aes_ctx), 332 .cra_module = THIS_MODULE, 333 }, 334 .min_keysize = AES_MIN_KEY_SIZE, 335 .max_keysize = AES_MAX_KEY_SIZE, 336 .ivsize = AES_BLOCK_SIZE, 337 .setkey = skcipher_aes_setkey, 338 .encrypt = cbc_encrypt, 339 .decrypt = cbc_decrypt, 340 }, { 341 .base = { 342 .cra_name = "__ctr(aes)", 343 .cra_driver_name = "__ctr-aes-" MODE, 344 .cra_priority = PRIO, 345 .cra_flags = CRYPTO_ALG_INTERNAL, 346 .cra_blocksize = 1, 347 .cra_ctxsize = sizeof(struct crypto_aes_ctx), 348 .cra_module = THIS_MODULE, 349 }, 350 .min_keysize = AES_MIN_KEY_SIZE, 351 .max_keysize = AES_MAX_KEY_SIZE, 352 .ivsize = AES_BLOCK_SIZE, 353 .chunksize = AES_BLOCK_SIZE, 354 .setkey = skcipher_aes_setkey, 355 .encrypt = ctr_encrypt, 356 .decrypt = ctr_encrypt, 357 }, { 358 .base = { 359 .cra_name = "ctr(aes)", 360 .cra_driver_name = "ctr-aes-" MODE, 361 .cra_priority = PRIO - 1, 362 .cra_blocksize = 1, 363 .cra_ctxsize = sizeof(struct crypto_aes_ctx), 364 .cra_module = THIS_MODULE, 365 }, 366 .min_keysize = AES_MIN_KEY_SIZE, 367 .max_keysize = AES_MAX_KEY_SIZE, 368 .ivsize = AES_BLOCK_SIZE, 369 .chunksize = AES_BLOCK_SIZE, 370 .setkey = skcipher_aes_setkey, 371 .encrypt = ctr_encrypt_sync, 372 .decrypt = ctr_encrypt_sync, 373 }, { 374 .base = { 375 .cra_name = "__xts(aes)", 376 .cra_driver_name = "__xts-aes-" MODE, 377 .cra_priority = PRIO, 378 .cra_flags = CRYPTO_ALG_INTERNAL, 379 .cra_blocksize = AES_BLOCK_SIZE, 380 .cra_ctxsize = sizeof(struct crypto_aes_xts_ctx), 381 .cra_module = THIS_MODULE, 382 }, 383 .min_keysize = 2 * AES_MIN_KEY_SIZE, 384 .max_keysize = 2 * AES_MAX_KEY_SIZE, 385 .ivsize = AES_BLOCK_SIZE, 386 .setkey = xts_set_key, 387 .encrypt = xts_encrypt, 388 .decrypt = xts_decrypt, 389 } }; 390 391 static int cbcmac_setkey(struct crypto_shash *tfm, const u8 *in_key, 392 unsigned int key_len) 393 { 394 struct mac_tfm_ctx *ctx = crypto_shash_ctx(tfm); 395 int err; 396 397 err = aes_expandkey(&ctx->key, in_key, key_len); 398 if (err) 399 crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN); 400 401 return err; 402 } 403 404 static void cmac_gf128_mul_by_x(be128 *y, const be128 *x) 405 { 406 u64 a = be64_to_cpu(x->a); 407 u64 b = be64_to_cpu(x->b); 408 409 y->a = cpu_to_be64((a << 1) | (b >> 63)); 410 y->b = cpu_to_be64((b << 1) ^ ((a >> 63) ? 0x87 : 0)); 411 } 412 413 static int cmac_setkey(struct crypto_shash *tfm, const u8 *in_key, 414 unsigned int key_len) 415 { 416 struct mac_tfm_ctx *ctx = crypto_shash_ctx(tfm); 417 be128 *consts = (be128 *)ctx->consts; 418 u8 *rk = (u8 *)ctx->key.key_enc; 419 int rounds = 6 + key_len / 4; 420 int err; 421 422 err = cbcmac_setkey(tfm, in_key, key_len); 423 if (err) 424 return err; 425 426 /* encrypt the zero vector */ 427 kernel_neon_begin(); 428 aes_ecb_encrypt(ctx->consts, (u8[AES_BLOCK_SIZE]){}, rk, rounds, 1, 1); 429 kernel_neon_end(); 430 431 cmac_gf128_mul_by_x(consts, consts); 432 cmac_gf128_mul_by_x(consts + 1, consts); 433 434 return 0; 435 } 436 437 static int xcbc_setkey(struct crypto_shash *tfm, const u8 *in_key, 438 unsigned int key_len) 439 { 440 static u8 const ks[3][AES_BLOCK_SIZE] = { 441 { [0 ... AES_BLOCK_SIZE - 1] = 0x1 }, 442 { [0 ... AES_BLOCK_SIZE - 1] = 0x2 }, 443 { [0 ... AES_BLOCK_SIZE - 1] = 0x3 }, 444 }; 445 446 struct mac_tfm_ctx *ctx = crypto_shash_ctx(tfm); 447 u8 *rk = (u8 *)ctx->key.key_enc; 448 int rounds = 6 + key_len / 4; 449 u8 key[AES_BLOCK_SIZE]; 450 int err; 451 452 err = cbcmac_setkey(tfm, in_key, key_len); 453 if (err) 454 return err; 455 456 kernel_neon_begin(); 457 aes_ecb_encrypt(key, ks[0], rk, rounds, 1, 1); 458 aes_ecb_encrypt(ctx->consts, ks[1], rk, rounds, 2, 0); 459 kernel_neon_end(); 460 461 return cbcmac_setkey(tfm, key, sizeof(key)); 462 } 463 464 static int mac_init(struct shash_desc *desc) 465 { 466 struct mac_desc_ctx *ctx = shash_desc_ctx(desc); 467 468 memset(ctx->dg, 0, AES_BLOCK_SIZE); 469 ctx->len = 0; 470 471 return 0; 472 } 473 474 static void mac_do_update(struct crypto_aes_ctx *ctx, u8 const in[], int blocks, 475 u8 dg[], int enc_before, int enc_after) 476 { 477 int rounds = 6 + ctx->key_length / 4; 478 479 if (may_use_simd()) { 480 kernel_neon_begin(); 481 aes_mac_update(in, ctx->key_enc, rounds, blocks, dg, enc_before, 482 enc_after); 483 kernel_neon_end(); 484 } else { 485 if (enc_before) 486 __aes_arm64_encrypt(ctx->key_enc, dg, dg, rounds); 487 488 while (blocks--) { 489 crypto_xor(dg, in, AES_BLOCK_SIZE); 490 in += AES_BLOCK_SIZE; 491 492 if (blocks || enc_after) 493 __aes_arm64_encrypt(ctx->key_enc, dg, dg, 494 rounds); 495 } 496 } 497 } 498 499 static int mac_update(struct shash_desc *desc, const u8 *p, unsigned int len) 500 { 501 struct mac_tfm_ctx *tctx = crypto_shash_ctx(desc->tfm); 502 struct mac_desc_ctx *ctx = shash_desc_ctx(desc); 503 504 while (len > 0) { 505 unsigned int l; 506 507 if ((ctx->len % AES_BLOCK_SIZE) == 0 && 508 (ctx->len + len) > AES_BLOCK_SIZE) { 509 510 int blocks = len / AES_BLOCK_SIZE; 511 512 len %= AES_BLOCK_SIZE; 513 514 mac_do_update(&tctx->key, p, blocks, ctx->dg, 515 (ctx->len != 0), (len != 0)); 516 517 p += blocks * AES_BLOCK_SIZE; 518 519 if (!len) { 520 ctx->len = AES_BLOCK_SIZE; 521 break; 522 } 523 ctx->len = 0; 524 } 525 526 l = min(len, AES_BLOCK_SIZE - ctx->len); 527 528 if (l <= AES_BLOCK_SIZE) { 529 crypto_xor(ctx->dg + ctx->len, p, l); 530 ctx->len += l; 531 len -= l; 532 p += l; 533 } 534 } 535 536 return 0; 537 } 538 539 static int cbcmac_final(struct shash_desc *desc, u8 *out) 540 { 541 struct mac_tfm_ctx *tctx = crypto_shash_ctx(desc->tfm); 542 struct mac_desc_ctx *ctx = shash_desc_ctx(desc); 543 544 mac_do_update(&tctx->key, NULL, 0, ctx->dg, 1, 0); 545 546 memcpy(out, ctx->dg, AES_BLOCK_SIZE); 547 548 return 0; 549 } 550 551 static int cmac_final(struct shash_desc *desc, u8 *out) 552 { 553 struct mac_tfm_ctx *tctx = crypto_shash_ctx(desc->tfm); 554 struct mac_desc_ctx *ctx = shash_desc_ctx(desc); 555 u8 *consts = tctx->consts; 556 557 if (ctx->len != AES_BLOCK_SIZE) { 558 ctx->dg[ctx->len] ^= 0x80; 559 consts += AES_BLOCK_SIZE; 560 } 561 562 mac_do_update(&tctx->key, consts, 1, ctx->dg, 0, 1); 563 564 memcpy(out, ctx->dg, AES_BLOCK_SIZE); 565 566 return 0; 567 } 568 569 static struct shash_alg mac_algs[] = { { 570 .base.cra_name = "cmac(aes)", 571 .base.cra_driver_name = "cmac-aes-" MODE, 572 .base.cra_priority = PRIO, 573 .base.cra_flags = CRYPTO_ALG_TYPE_SHASH, 574 .base.cra_blocksize = AES_BLOCK_SIZE, 575 .base.cra_ctxsize = sizeof(struct mac_tfm_ctx) + 576 2 * AES_BLOCK_SIZE, 577 .base.cra_module = THIS_MODULE, 578 579 .digestsize = AES_BLOCK_SIZE, 580 .init = mac_init, 581 .update = mac_update, 582 .final = cmac_final, 583 .setkey = cmac_setkey, 584 .descsize = sizeof(struct mac_desc_ctx), 585 }, { 586 .base.cra_name = "xcbc(aes)", 587 .base.cra_driver_name = "xcbc-aes-" MODE, 588 .base.cra_priority = PRIO, 589 .base.cra_flags = CRYPTO_ALG_TYPE_SHASH, 590 .base.cra_blocksize = AES_BLOCK_SIZE, 591 .base.cra_ctxsize = sizeof(struct mac_tfm_ctx) + 592 2 * AES_BLOCK_SIZE, 593 .base.cra_module = THIS_MODULE, 594 595 .digestsize = AES_BLOCK_SIZE, 596 .init = mac_init, 597 .update = mac_update, 598 .final = cmac_final, 599 .setkey = xcbc_setkey, 600 .descsize = sizeof(struct mac_desc_ctx), 601 }, { 602 .base.cra_name = "cbcmac(aes)", 603 .base.cra_driver_name = "cbcmac-aes-" MODE, 604 .base.cra_priority = PRIO, 605 .base.cra_flags = CRYPTO_ALG_TYPE_SHASH, 606 .base.cra_blocksize = 1, 607 .base.cra_ctxsize = sizeof(struct mac_tfm_ctx), 608 .base.cra_module = THIS_MODULE, 609 610 .digestsize = AES_BLOCK_SIZE, 611 .init = mac_init, 612 .update = mac_update, 613 .final = cbcmac_final, 614 .setkey = cbcmac_setkey, 615 .descsize = sizeof(struct mac_desc_ctx), 616 } }; 617 618 static struct simd_skcipher_alg *aes_simd_algs[ARRAY_SIZE(aes_algs)]; 619 620 static void aes_exit(void) 621 { 622 int i; 623 624 for (i = 0; i < ARRAY_SIZE(aes_simd_algs); i++) 625 if (aes_simd_algs[i]) 626 simd_skcipher_free(aes_simd_algs[i]); 627 628 crypto_unregister_shashes(mac_algs, ARRAY_SIZE(mac_algs)); 629 crypto_unregister_skciphers(aes_algs, ARRAY_SIZE(aes_algs)); 630 } 631 632 static int __init aes_init(void) 633 { 634 struct simd_skcipher_alg *simd; 635 const char *basename; 636 const char *algname; 637 const char *drvname; 638 int err; 639 int i; 640 641 err = crypto_register_skciphers(aes_algs, ARRAY_SIZE(aes_algs)); 642 if (err) 643 return err; 644 645 err = crypto_register_shashes(mac_algs, ARRAY_SIZE(mac_algs)); 646 if (err) 647 goto unregister_ciphers; 648 649 for (i = 0; i < ARRAY_SIZE(aes_algs); i++) { 650 if (!(aes_algs[i].base.cra_flags & CRYPTO_ALG_INTERNAL)) 651 continue; 652 653 algname = aes_algs[i].base.cra_name + 2; 654 drvname = aes_algs[i].base.cra_driver_name + 2; 655 basename = aes_algs[i].base.cra_driver_name; 656 simd = simd_skcipher_create_compat(algname, drvname, basename); 657 err = PTR_ERR(simd); 658 if (IS_ERR(simd)) 659 goto unregister_simds; 660 661 aes_simd_algs[i] = simd; 662 } 663 664 return 0; 665 666 unregister_simds: 667 aes_exit(); 668 unregister_ciphers: 669 crypto_unregister_skciphers(aes_algs, ARRAY_SIZE(aes_algs)); 670 return err; 671 } 672 673 #ifdef USE_V8_CRYPTO_EXTENSIONS 674 module_cpu_feature_match(AES, aes_init); 675 #else 676 module_init(aes_init); 677 EXPORT_SYMBOL(neon_aes_ecb_encrypt); 678 EXPORT_SYMBOL(neon_aes_cbc_encrypt); 679 #endif 680 module_exit(aes_exit); 681