1 /** 2 * AMCC SoC PPC4xx Crypto Driver 3 * 4 * Copyright (c) 2008 Applied Micro Circuits Corporation. 5 * All rights reserved. James Hsiao <jhsiao@amcc.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * This file implements the Linux crypto algorithms. 18 */ 19 20 #include <linux/kernel.h> 21 #include <linux/interrupt.h> 22 #include <linux/spinlock_types.h> 23 #include <linux/scatterlist.h> 24 #include <linux/crypto.h> 25 #include <linux/hash.h> 26 #include <crypto/internal/hash.h> 27 #include <linux/dma-mapping.h> 28 #include <crypto/algapi.h> 29 #include <crypto/aead.h> 30 #include <crypto/aes.h> 31 #include <crypto/gcm.h> 32 #include <crypto/sha.h> 33 #include <crypto/ctr.h> 34 #include "crypto4xx_reg_def.h" 35 #include "crypto4xx_core.h" 36 #include "crypto4xx_sa.h" 37 38 static void set_dynamic_sa_command_0(struct dynamic_sa_ctl *sa, u32 save_h, 39 u32 save_iv, u32 ld_h, u32 ld_iv, 40 u32 hdr_proc, u32 h, u32 c, u32 pad_type, 41 u32 op_grp, u32 op, u32 dir) 42 { 43 sa->sa_command_0.w = 0; 44 sa->sa_command_0.bf.save_hash_state = save_h; 45 sa->sa_command_0.bf.save_iv = save_iv; 46 sa->sa_command_0.bf.load_hash_state = ld_h; 47 sa->sa_command_0.bf.load_iv = ld_iv; 48 sa->sa_command_0.bf.hdr_proc = hdr_proc; 49 sa->sa_command_0.bf.hash_alg = h; 50 sa->sa_command_0.bf.cipher_alg = c; 51 sa->sa_command_0.bf.pad_type = pad_type & 3; 52 sa->sa_command_0.bf.extend_pad = pad_type >> 2; 53 sa->sa_command_0.bf.op_group = op_grp; 54 sa->sa_command_0.bf.opcode = op; 55 sa->sa_command_0.bf.dir = dir; 56 } 57 58 static void set_dynamic_sa_command_1(struct dynamic_sa_ctl *sa, u32 cm, 59 u32 hmac_mc, u32 cfb, u32 esn, 60 u32 sn_mask, u32 mute, u32 cp_pad, 61 u32 cp_pay, u32 cp_hdr) 62 { 63 sa->sa_command_1.w = 0; 64 sa->sa_command_1.bf.crypto_mode31 = (cm & 4) >> 2; 65 sa->sa_command_1.bf.crypto_mode9_8 = cm & 3; 66 sa->sa_command_1.bf.feedback_mode = cfb, 67 sa->sa_command_1.bf.sa_rev = 1; 68 sa->sa_command_1.bf.hmac_muting = hmac_mc; 69 sa->sa_command_1.bf.extended_seq_num = esn; 70 sa->sa_command_1.bf.seq_num_mask = sn_mask; 71 sa->sa_command_1.bf.mutable_bit_proc = mute; 72 sa->sa_command_1.bf.copy_pad = cp_pad; 73 sa->sa_command_1.bf.copy_payload = cp_pay; 74 sa->sa_command_1.bf.copy_hdr = cp_hdr; 75 } 76 77 int crypto4xx_encrypt(struct ablkcipher_request *req) 78 { 79 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 80 unsigned int ivlen = crypto_ablkcipher_ivsize( 81 crypto_ablkcipher_reqtfm(req)); 82 __le32 iv[ivlen]; 83 84 if (ivlen) 85 crypto4xx_memcpy_to_le32(iv, req->info, ivlen); 86 87 return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst, 88 req->nbytes, iv, ivlen, ctx->sa_out, ctx->sa_len, 0); 89 } 90 91 int crypto4xx_decrypt(struct ablkcipher_request *req) 92 { 93 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 94 unsigned int ivlen = crypto_ablkcipher_ivsize( 95 crypto_ablkcipher_reqtfm(req)); 96 __le32 iv[ivlen]; 97 98 if (ivlen) 99 crypto4xx_memcpy_to_le32(iv, req->info, ivlen); 100 101 return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst, 102 req->nbytes, iv, ivlen, ctx->sa_in, ctx->sa_len, 0); 103 } 104 105 /** 106 * AES Functions 107 */ 108 static int crypto4xx_setkey_aes(struct crypto_ablkcipher *cipher, 109 const u8 *key, 110 unsigned int keylen, 111 unsigned char cm, 112 u8 fb) 113 { 114 struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher); 115 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm); 116 struct dynamic_sa_ctl *sa; 117 int rc; 118 119 if (keylen != AES_KEYSIZE_256 && 120 keylen != AES_KEYSIZE_192 && keylen != AES_KEYSIZE_128) { 121 crypto_ablkcipher_set_flags(cipher, 122 CRYPTO_TFM_RES_BAD_KEY_LEN); 123 return -EINVAL; 124 } 125 126 /* Create SA */ 127 if (ctx->sa_in || ctx->sa_out) 128 crypto4xx_free_sa(ctx); 129 130 rc = crypto4xx_alloc_sa(ctx, SA_AES128_LEN + (keylen-16) / 4); 131 if (rc) 132 return rc; 133 134 /* Setup SA */ 135 sa = ctx->sa_in; 136 137 set_dynamic_sa_command_0(sa, SA_NOT_SAVE_HASH, SA_NOT_SAVE_IV, 138 SA_LOAD_HASH_FROM_SA, SA_LOAD_IV_FROM_STATE, 139 SA_NO_HEADER_PROC, SA_HASH_ALG_NULL, 140 SA_CIPHER_ALG_AES, SA_PAD_TYPE_ZERO, 141 SA_OP_GROUP_BASIC, SA_OPCODE_DECRYPT, 142 DIR_INBOUND); 143 144 set_dynamic_sa_command_1(sa, cm, SA_HASH_MODE_HASH, 145 fb, SA_EXTENDED_SN_OFF, 146 SA_SEQ_MASK_OFF, SA_MC_ENABLE, 147 SA_NOT_COPY_PAD, SA_NOT_COPY_PAYLOAD, 148 SA_NOT_COPY_HDR); 149 crypto4xx_memcpy_to_le32(get_dynamic_sa_key_field(sa), 150 key, keylen); 151 sa->sa_contents.w = SA_AES_CONTENTS | (keylen << 2); 152 sa->sa_command_1.bf.key_len = keylen >> 3; 153 154 memcpy(ctx->sa_out, ctx->sa_in, ctx->sa_len * 4); 155 sa = ctx->sa_out; 156 sa->sa_command_0.bf.dir = DIR_OUTBOUND; 157 158 return 0; 159 } 160 161 int crypto4xx_setkey_aes_cbc(struct crypto_ablkcipher *cipher, 162 const u8 *key, unsigned int keylen) 163 { 164 return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_CBC, 165 CRYPTO_FEEDBACK_MODE_NO_FB); 166 } 167 168 int crypto4xx_setkey_aes_cfb(struct crypto_ablkcipher *cipher, 169 const u8 *key, unsigned int keylen) 170 { 171 return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_CFB, 172 CRYPTO_FEEDBACK_MODE_128BIT_CFB); 173 } 174 175 int crypto4xx_setkey_aes_ecb(struct crypto_ablkcipher *cipher, 176 const u8 *key, unsigned int keylen) 177 { 178 return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_ECB, 179 CRYPTO_FEEDBACK_MODE_NO_FB); 180 } 181 182 int crypto4xx_setkey_aes_ofb(struct crypto_ablkcipher *cipher, 183 const u8 *key, unsigned int keylen) 184 { 185 return crypto4xx_setkey_aes(cipher, key, keylen, CRYPTO_MODE_OFB, 186 CRYPTO_FEEDBACK_MODE_64BIT_OFB); 187 } 188 189 int crypto4xx_setkey_rfc3686(struct crypto_ablkcipher *cipher, 190 const u8 *key, unsigned int keylen) 191 { 192 struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher); 193 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm); 194 int rc; 195 196 rc = crypto4xx_setkey_aes(cipher, key, keylen - CTR_RFC3686_NONCE_SIZE, 197 CRYPTO_MODE_CTR, CRYPTO_FEEDBACK_MODE_NO_FB); 198 if (rc) 199 return rc; 200 201 ctx->iv_nonce = cpu_to_le32p((u32 *)&key[keylen - 202 CTR_RFC3686_NONCE_SIZE]); 203 204 return 0; 205 } 206 207 int crypto4xx_rfc3686_encrypt(struct ablkcipher_request *req) 208 { 209 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 210 __le32 iv[AES_IV_SIZE / 4] = { 211 ctx->iv_nonce, 212 cpu_to_le32p((u32 *) req->info), 213 cpu_to_le32p((u32 *) (req->info + 4)), 214 cpu_to_le32(1) }; 215 216 return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst, 217 req->nbytes, iv, AES_IV_SIZE, 218 ctx->sa_out, ctx->sa_len, 0); 219 } 220 221 int crypto4xx_rfc3686_decrypt(struct ablkcipher_request *req) 222 { 223 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 224 __le32 iv[AES_IV_SIZE / 4] = { 225 ctx->iv_nonce, 226 cpu_to_le32p((u32 *) req->info), 227 cpu_to_le32p((u32 *) (req->info + 4)), 228 cpu_to_le32(1) }; 229 230 return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst, 231 req->nbytes, iv, AES_IV_SIZE, 232 ctx->sa_out, ctx->sa_len, 0); 233 } 234 235 static inline bool crypto4xx_aead_need_fallback(struct aead_request *req, 236 bool is_ccm, bool decrypt) 237 { 238 struct crypto_aead *aead = crypto_aead_reqtfm(req); 239 240 /* authsize has to be a multiple of 4 */ 241 if (aead->authsize & 3) 242 return true; 243 244 /* 245 * hardware does not handle cases where cryptlen 246 * is less than a block 247 */ 248 if (req->cryptlen < AES_BLOCK_SIZE) 249 return true; 250 251 /* assoc len needs to be a multiple of 4 */ 252 if (req->assoclen & 0x3) 253 return true; 254 255 /* CCM supports only counter field length of 2 and 4 bytes */ 256 if (is_ccm && !(req->iv[0] == 1 || req->iv[0] == 3)) 257 return true; 258 259 return false; 260 } 261 262 static int crypto4xx_aead_fallback(struct aead_request *req, 263 struct crypto4xx_ctx *ctx, bool do_decrypt) 264 { 265 char aead_req_data[sizeof(struct aead_request) + 266 crypto_aead_reqsize(ctx->sw_cipher.aead)] 267 __aligned(__alignof__(struct aead_request)); 268 269 struct aead_request *subreq = (void *) aead_req_data; 270 271 memset(subreq, 0, sizeof(aead_req_data)); 272 273 aead_request_set_tfm(subreq, ctx->sw_cipher.aead); 274 aead_request_set_callback(subreq, req->base.flags, 275 req->base.complete, req->base.data); 276 aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen, 277 req->iv); 278 aead_request_set_ad(subreq, req->assoclen); 279 return do_decrypt ? crypto_aead_decrypt(subreq) : 280 crypto_aead_encrypt(subreq); 281 } 282 283 static int crypto4xx_setup_fallback(struct crypto4xx_ctx *ctx, 284 struct crypto_aead *cipher, 285 const u8 *key, 286 unsigned int keylen) 287 { 288 int rc; 289 290 crypto_aead_clear_flags(ctx->sw_cipher.aead, CRYPTO_TFM_REQ_MASK); 291 crypto_aead_set_flags(ctx->sw_cipher.aead, 292 crypto_aead_get_flags(cipher) & CRYPTO_TFM_REQ_MASK); 293 rc = crypto_aead_setkey(ctx->sw_cipher.aead, key, keylen); 294 crypto_aead_clear_flags(cipher, CRYPTO_TFM_RES_MASK); 295 crypto_aead_set_flags(cipher, 296 crypto_aead_get_flags(ctx->sw_cipher.aead) & 297 CRYPTO_TFM_RES_MASK); 298 299 return rc; 300 } 301 302 /** 303 * AES-CCM Functions 304 */ 305 306 int crypto4xx_setkey_aes_ccm(struct crypto_aead *cipher, const u8 *key, 307 unsigned int keylen) 308 { 309 struct crypto_tfm *tfm = crypto_aead_tfm(cipher); 310 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm); 311 struct dynamic_sa_ctl *sa; 312 int rc = 0; 313 314 rc = crypto4xx_setup_fallback(ctx, cipher, key, keylen); 315 if (rc) 316 return rc; 317 318 if (ctx->sa_in || ctx->sa_out) 319 crypto4xx_free_sa(ctx); 320 321 rc = crypto4xx_alloc_sa(ctx, SA_AES128_CCM_LEN + (keylen - 16) / 4); 322 if (rc) 323 return rc; 324 325 /* Setup SA */ 326 sa = (struct dynamic_sa_ctl *) ctx->sa_in; 327 sa->sa_contents.w = SA_AES_CCM_CONTENTS | (keylen << 2); 328 329 set_dynamic_sa_command_0(sa, SA_SAVE_HASH, SA_NOT_SAVE_IV, 330 SA_LOAD_HASH_FROM_SA, SA_LOAD_IV_FROM_STATE, 331 SA_NO_HEADER_PROC, SA_HASH_ALG_CBC_MAC, 332 SA_CIPHER_ALG_AES, 333 SA_PAD_TYPE_ZERO, SA_OP_GROUP_BASIC, 334 SA_OPCODE_HASH_DECRYPT, DIR_INBOUND); 335 336 set_dynamic_sa_command_1(sa, CRYPTO_MODE_CTR, SA_HASH_MODE_HASH, 337 CRYPTO_FEEDBACK_MODE_NO_FB, SA_EXTENDED_SN_OFF, 338 SA_SEQ_MASK_OFF, SA_MC_ENABLE, 339 SA_NOT_COPY_PAD, SA_COPY_PAYLOAD, 340 SA_NOT_COPY_HDR); 341 342 sa->sa_command_1.bf.key_len = keylen >> 3; 343 344 crypto4xx_memcpy_to_le32(get_dynamic_sa_key_field(sa), key, keylen); 345 346 memcpy(ctx->sa_out, ctx->sa_in, ctx->sa_len * 4); 347 sa = (struct dynamic_sa_ctl *) ctx->sa_out; 348 349 set_dynamic_sa_command_0(sa, SA_SAVE_HASH, SA_NOT_SAVE_IV, 350 SA_LOAD_HASH_FROM_SA, SA_LOAD_IV_FROM_STATE, 351 SA_NO_HEADER_PROC, SA_HASH_ALG_CBC_MAC, 352 SA_CIPHER_ALG_AES, 353 SA_PAD_TYPE_ZERO, SA_OP_GROUP_BASIC, 354 SA_OPCODE_ENCRYPT_HASH, DIR_OUTBOUND); 355 356 set_dynamic_sa_command_1(sa, CRYPTO_MODE_CTR, SA_HASH_MODE_HASH, 357 CRYPTO_FEEDBACK_MODE_NO_FB, SA_EXTENDED_SN_OFF, 358 SA_SEQ_MASK_OFF, SA_MC_ENABLE, 359 SA_COPY_PAD, SA_COPY_PAYLOAD, 360 SA_NOT_COPY_HDR); 361 362 sa->sa_command_1.bf.key_len = keylen >> 3; 363 return 0; 364 } 365 366 static int crypto4xx_crypt_aes_ccm(struct aead_request *req, bool decrypt) 367 { 368 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 369 struct crypto_aead *aead = crypto_aead_reqtfm(req); 370 unsigned int len = req->cryptlen; 371 __le32 iv[16]; 372 u32 tmp_sa[ctx->sa_len * 4]; 373 struct dynamic_sa_ctl *sa = (struct dynamic_sa_ctl *)tmp_sa; 374 375 if (crypto4xx_aead_need_fallback(req, true, decrypt)) 376 return crypto4xx_aead_fallback(req, ctx, decrypt); 377 378 if (decrypt) 379 len -= crypto_aead_authsize(aead); 380 381 memcpy(tmp_sa, decrypt ? ctx->sa_in : ctx->sa_out, sizeof(tmp_sa)); 382 sa->sa_command_0.bf.digest_len = crypto_aead_authsize(aead) >> 2; 383 384 if (req->iv[0] == 1) { 385 /* CRYPTO_MODE_AES_ICM */ 386 sa->sa_command_1.bf.crypto_mode9_8 = 1; 387 } 388 389 iv[3] = cpu_to_le32(0); 390 crypto4xx_memcpy_to_le32(iv, req->iv, 16 - (req->iv[0] + 1)); 391 392 return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst, 393 len, iv, sizeof(iv), 394 sa, ctx->sa_len, req->assoclen); 395 } 396 397 int crypto4xx_encrypt_aes_ccm(struct aead_request *req) 398 { 399 return crypto4xx_crypt_aes_ccm(req, false); 400 } 401 402 int crypto4xx_decrypt_aes_ccm(struct aead_request *req) 403 { 404 return crypto4xx_crypt_aes_ccm(req, true); 405 } 406 407 int crypto4xx_setauthsize_aead(struct crypto_aead *cipher, 408 unsigned int authsize) 409 { 410 struct crypto_tfm *tfm = crypto_aead_tfm(cipher); 411 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm); 412 413 return crypto_aead_setauthsize(ctx->sw_cipher.aead, authsize); 414 } 415 416 /** 417 * AES-GCM Functions 418 */ 419 420 static int crypto4xx_aes_gcm_validate_keylen(unsigned int keylen) 421 { 422 switch (keylen) { 423 case 16: 424 case 24: 425 case 32: 426 return 0; 427 default: 428 return -EINVAL; 429 } 430 } 431 432 static int crypto4xx_compute_gcm_hash_key_sw(__le32 *hash_start, const u8 *key, 433 unsigned int keylen) 434 { 435 struct crypto_cipher *aes_tfm = NULL; 436 uint8_t src[16] = { 0 }; 437 int rc = 0; 438 439 aes_tfm = crypto_alloc_cipher("aes", 0, CRYPTO_ALG_ASYNC | 440 CRYPTO_ALG_NEED_FALLBACK); 441 if (IS_ERR(aes_tfm)) { 442 rc = PTR_ERR(aes_tfm); 443 pr_warn("could not load aes cipher driver: %d\n", rc); 444 return rc; 445 } 446 447 rc = crypto_cipher_setkey(aes_tfm, key, keylen); 448 if (rc) { 449 pr_err("setkey() failed: %d\n", rc); 450 goto out; 451 } 452 453 crypto_cipher_encrypt_one(aes_tfm, src, src); 454 crypto4xx_memcpy_to_le32(hash_start, src, 16); 455 out: 456 crypto_free_cipher(aes_tfm); 457 return rc; 458 } 459 460 int crypto4xx_setkey_aes_gcm(struct crypto_aead *cipher, 461 const u8 *key, unsigned int keylen) 462 { 463 struct crypto_tfm *tfm = crypto_aead_tfm(cipher); 464 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm); 465 struct dynamic_sa_ctl *sa; 466 int rc = 0; 467 468 if (crypto4xx_aes_gcm_validate_keylen(keylen) != 0) { 469 crypto_aead_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN); 470 return -EINVAL; 471 } 472 473 rc = crypto4xx_setup_fallback(ctx, cipher, key, keylen); 474 if (rc) 475 return rc; 476 477 if (ctx->sa_in || ctx->sa_out) 478 crypto4xx_free_sa(ctx); 479 480 rc = crypto4xx_alloc_sa(ctx, SA_AES128_GCM_LEN + (keylen - 16) / 4); 481 if (rc) 482 return rc; 483 484 sa = (struct dynamic_sa_ctl *) ctx->sa_in; 485 486 sa->sa_contents.w = SA_AES_GCM_CONTENTS | (keylen << 2); 487 set_dynamic_sa_command_0(sa, SA_SAVE_HASH, SA_NOT_SAVE_IV, 488 SA_LOAD_HASH_FROM_SA, SA_LOAD_IV_FROM_STATE, 489 SA_NO_HEADER_PROC, SA_HASH_ALG_GHASH, 490 SA_CIPHER_ALG_AES, SA_PAD_TYPE_ZERO, 491 SA_OP_GROUP_BASIC, SA_OPCODE_HASH_DECRYPT, 492 DIR_INBOUND); 493 set_dynamic_sa_command_1(sa, CRYPTO_MODE_CTR, SA_HASH_MODE_HASH, 494 CRYPTO_FEEDBACK_MODE_NO_FB, SA_EXTENDED_SN_OFF, 495 SA_SEQ_MASK_ON, SA_MC_DISABLE, 496 SA_NOT_COPY_PAD, SA_COPY_PAYLOAD, 497 SA_NOT_COPY_HDR); 498 499 sa->sa_command_1.bf.key_len = keylen >> 3; 500 501 crypto4xx_memcpy_to_le32(get_dynamic_sa_key_field(sa), 502 key, keylen); 503 504 rc = crypto4xx_compute_gcm_hash_key_sw(get_dynamic_sa_inner_digest(sa), 505 key, keylen); 506 if (rc) { 507 pr_err("GCM hash key setting failed = %d\n", rc); 508 goto err; 509 } 510 511 memcpy(ctx->sa_out, ctx->sa_in, ctx->sa_len * 4); 512 sa = (struct dynamic_sa_ctl *) ctx->sa_out; 513 sa->sa_command_0.bf.dir = DIR_OUTBOUND; 514 sa->sa_command_0.bf.opcode = SA_OPCODE_ENCRYPT_HASH; 515 516 return 0; 517 err: 518 crypto4xx_free_sa(ctx); 519 return rc; 520 } 521 522 static inline int crypto4xx_crypt_aes_gcm(struct aead_request *req, 523 bool decrypt) 524 { 525 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 526 unsigned int len = req->cryptlen; 527 __le32 iv[4]; 528 529 if (crypto4xx_aead_need_fallback(req, false, decrypt)) 530 return crypto4xx_aead_fallback(req, ctx, decrypt); 531 532 crypto4xx_memcpy_to_le32(iv, req->iv, GCM_AES_IV_SIZE); 533 iv[3] = cpu_to_le32(1); 534 535 if (decrypt) 536 len -= crypto_aead_authsize(crypto_aead_reqtfm(req)); 537 538 return crypto4xx_build_pd(&req->base, ctx, req->src, req->dst, 539 len, iv, sizeof(iv), 540 decrypt ? ctx->sa_in : ctx->sa_out, 541 ctx->sa_len, req->assoclen); 542 } 543 544 int crypto4xx_encrypt_aes_gcm(struct aead_request *req) 545 { 546 return crypto4xx_crypt_aes_gcm(req, false); 547 } 548 549 int crypto4xx_decrypt_aes_gcm(struct aead_request *req) 550 { 551 return crypto4xx_crypt_aes_gcm(req, true); 552 } 553 554 /** 555 * HASH SHA1 Functions 556 */ 557 static int crypto4xx_hash_alg_init(struct crypto_tfm *tfm, 558 unsigned int sa_len, 559 unsigned char ha, 560 unsigned char hm) 561 { 562 struct crypto_alg *alg = tfm->__crt_alg; 563 struct crypto4xx_alg *my_alg; 564 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(tfm); 565 struct dynamic_sa_hash160 *sa; 566 int rc; 567 568 my_alg = container_of(__crypto_ahash_alg(alg), struct crypto4xx_alg, 569 alg.u.hash); 570 ctx->dev = my_alg->dev; 571 572 /* Create SA */ 573 if (ctx->sa_in || ctx->sa_out) 574 crypto4xx_free_sa(ctx); 575 576 rc = crypto4xx_alloc_sa(ctx, sa_len); 577 if (rc) 578 return rc; 579 580 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), 581 sizeof(struct crypto4xx_ctx)); 582 sa = (struct dynamic_sa_hash160 *)ctx->sa_in; 583 set_dynamic_sa_command_0(&sa->ctrl, SA_SAVE_HASH, SA_NOT_SAVE_IV, 584 SA_NOT_LOAD_HASH, SA_LOAD_IV_FROM_SA, 585 SA_NO_HEADER_PROC, ha, SA_CIPHER_ALG_NULL, 586 SA_PAD_TYPE_ZERO, SA_OP_GROUP_BASIC, 587 SA_OPCODE_HASH, DIR_INBOUND); 588 set_dynamic_sa_command_1(&sa->ctrl, 0, SA_HASH_MODE_HASH, 589 CRYPTO_FEEDBACK_MODE_NO_FB, SA_EXTENDED_SN_OFF, 590 SA_SEQ_MASK_OFF, SA_MC_ENABLE, 591 SA_NOT_COPY_PAD, SA_NOT_COPY_PAYLOAD, 592 SA_NOT_COPY_HDR); 593 /* Need to zero hash digest in SA */ 594 memset(sa->inner_digest, 0, sizeof(sa->inner_digest)); 595 memset(sa->outer_digest, 0, sizeof(sa->outer_digest)); 596 597 return 0; 598 } 599 600 int crypto4xx_hash_init(struct ahash_request *req) 601 { 602 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 603 int ds; 604 struct dynamic_sa_ctl *sa; 605 606 sa = ctx->sa_in; 607 ds = crypto_ahash_digestsize( 608 __crypto_ahash_cast(req->base.tfm)); 609 sa->sa_command_0.bf.digest_len = ds >> 2; 610 sa->sa_command_0.bf.load_hash_state = SA_LOAD_HASH_FROM_SA; 611 612 return 0; 613 } 614 615 int crypto4xx_hash_update(struct ahash_request *req) 616 { 617 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req); 618 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 619 struct scatterlist dst; 620 unsigned int ds = crypto_ahash_digestsize(ahash); 621 622 sg_init_one(&dst, req->result, ds); 623 624 return crypto4xx_build_pd(&req->base, ctx, req->src, &dst, 625 req->nbytes, NULL, 0, ctx->sa_in, 626 ctx->sa_len, 0); 627 } 628 629 int crypto4xx_hash_final(struct ahash_request *req) 630 { 631 return 0; 632 } 633 634 int crypto4xx_hash_digest(struct ahash_request *req) 635 { 636 struct crypto_ahash *ahash = crypto_ahash_reqtfm(req); 637 struct crypto4xx_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 638 struct scatterlist dst; 639 unsigned int ds = crypto_ahash_digestsize(ahash); 640 641 sg_init_one(&dst, req->result, ds); 642 643 return crypto4xx_build_pd(&req->base, ctx, req->src, &dst, 644 req->nbytes, NULL, 0, ctx->sa_in, 645 ctx->sa_len, 0); 646 } 647 648 /** 649 * SHA1 Algorithm 650 */ 651 int crypto4xx_sha1_alg_init(struct crypto_tfm *tfm) 652 { 653 return crypto4xx_hash_alg_init(tfm, SA_HASH160_LEN, SA_HASH_ALG_SHA1, 654 SA_HASH_MODE_HASH); 655 } 656