1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2019 - 2021 4 * 5 * Richard van Schagen <vschagen@icloud.com> 6 * Christian Marangi <ansuelsmth@gmail.com> 7 */ 8 9 #include <crypto/aead.h> 10 #include <crypto/aes.h> 11 #include <crypto/authenc.h> 12 #include <crypto/ctr.h> 13 #include <crypto/hmac.h> 14 #include <crypto/internal/aead.h> 15 #include <crypto/md5.h> 16 #include <crypto/null.h> 17 #include <crypto/sha1.h> 18 #include <crypto/sha2.h> 19 20 #include <crypto/internal/des.h> 21 22 #include <linux/crypto.h> 23 #include <linux/dma-mapping.h> 24 25 #include "eip93-aead.h" 26 #include "eip93-cipher.h" 27 #include "eip93-common.h" 28 #include "eip93-regs.h" 29 30 void eip93_aead_handle_result(struct crypto_async_request *async, int err) 31 { 32 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(async->tfm); 33 struct eip93_device *eip93 = ctx->eip93; 34 struct aead_request *req = aead_request_cast(async); 35 struct eip93_cipher_reqctx *rctx = aead_request_ctx(req); 36 37 eip93_unmap_dma(eip93, rctx, req->src, req->dst); 38 eip93_handle_result(eip93, rctx, req->iv); 39 40 aead_request_complete(req, err); 41 } 42 43 static int eip93_aead_send_req(struct crypto_async_request *async) 44 { 45 struct aead_request *req = aead_request_cast(async); 46 struct eip93_cipher_reqctx *rctx = aead_request_ctx(req); 47 int err; 48 49 err = check_valid_request(rctx); 50 if (err) { 51 aead_request_complete(req, err); 52 return err; 53 } 54 55 return eip93_send_req(async, req->iv, rctx); 56 } 57 58 /* Crypto aead API functions */ 59 static int eip93_aead_cra_init(struct crypto_tfm *tfm) 60 { 61 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm); 62 struct eip93_alg_template *tmpl = container_of(tfm->__crt_alg, 63 struct eip93_alg_template, alg.aead.base); 64 65 crypto_aead_set_reqsize(__crypto_aead_cast(tfm), 66 sizeof(struct eip93_cipher_reqctx)); 67 68 ctx->eip93 = tmpl->eip93; 69 ctx->flags = tmpl->flags; 70 ctx->type = tmpl->type; 71 ctx->set_assoc = true; 72 73 ctx->sa_record = kzalloc_obj(*ctx->sa_record); 74 if (!ctx->sa_record) 75 return -ENOMEM; 76 77 return 0; 78 } 79 80 static void eip93_aead_cra_exit(struct crypto_tfm *tfm) 81 { 82 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm); 83 84 dma_unmap_single(ctx->eip93->dev, ctx->sa_record_base, 85 sizeof(*ctx->sa_record), DMA_TO_DEVICE); 86 kfree(ctx->sa_record); 87 } 88 89 static int eip93_aead_setkey(struct crypto_aead *ctfm, const u8 *key, 90 unsigned int len) 91 { 92 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm); 93 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm); 94 struct crypto_authenc_keys keys; 95 struct sa_record *sa_record = ctx->sa_record; 96 u32 nonce = 0; 97 int ret; 98 99 if (crypto_authenc_extractkeys(&keys, key, len)) 100 return -EINVAL; 101 102 if (IS_RFC3686(ctx->flags)) { 103 if (keys.enckeylen < CTR_RFC3686_NONCE_SIZE) 104 return -EINVAL; 105 106 keys.enckeylen -= CTR_RFC3686_NONCE_SIZE; 107 memcpy(&nonce, keys.enckey + keys.enckeylen, 108 CTR_RFC3686_NONCE_SIZE); 109 } 110 111 switch ((ctx->flags & EIP93_ALG_MASK)) { 112 case EIP93_ALG_DES: 113 ret = verify_aead_des_key(ctfm, keys.enckey, keys.enckeylen); 114 if (ret) 115 return ret; 116 117 break; 118 case EIP93_ALG_3DES: 119 if (keys.enckeylen != DES3_EDE_KEY_SIZE) 120 return -EINVAL; 121 122 ret = verify_aead_des3_key(ctfm, keys.enckey, keys.enckeylen); 123 if (ret) 124 return ret; 125 126 break; 127 case EIP93_ALG_AES: 128 ret = aes_check_keylen(keys.enckeylen); 129 if (ret) 130 return ret; 131 132 break; 133 } 134 135 ctx->blksize = crypto_aead_blocksize(ctfm); 136 /* Encryption key */ 137 eip93_set_sa_record(sa_record, keys.enckeylen, ctx->flags); 138 sa_record->sa_cmd0_word &= ~EIP93_SA_CMD_OPCODE; 139 sa_record->sa_cmd0_word |= FIELD_PREP(EIP93_SA_CMD_OPCODE, 140 EIP93_SA_CMD_OPCODE_BASIC_OUT_ENC_HASH); 141 sa_record->sa_cmd0_word &= ~EIP93_SA_CMD_DIGEST_LENGTH; 142 sa_record->sa_cmd0_word |= FIELD_PREP(EIP93_SA_CMD_DIGEST_LENGTH, 143 ctx->authsize / sizeof(u32)); 144 145 memcpy(sa_record->sa_key, keys.enckey, keys.enckeylen); 146 ctx->sa_nonce = nonce; 147 sa_record->sa_nonce = nonce; 148 149 /* authentication key */ 150 ret = eip93_hmac_setkey(ctx->flags, keys.authkey, keys.authkeylen, 151 ctx->authsize, sa_record->sa_i_digest, 152 sa_record->sa_o_digest, false); 153 154 ctx->set_assoc = true; 155 156 return ret; 157 } 158 159 static int eip93_aead_setauthsize(struct crypto_aead *ctfm, 160 unsigned int authsize) 161 { 162 struct crypto_tfm *tfm = crypto_aead_tfm(ctfm); 163 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm); 164 165 ctx->authsize = authsize; 166 ctx->sa_record->sa_cmd0_word &= ~EIP93_SA_CMD_DIGEST_LENGTH; 167 ctx->sa_record->sa_cmd0_word |= FIELD_PREP(EIP93_SA_CMD_DIGEST_LENGTH, 168 ctx->authsize / sizeof(u32)); 169 170 return 0; 171 } 172 173 static void eip93_aead_setassoc(struct eip93_crypto_ctx *ctx, 174 struct aead_request *req) 175 { 176 struct sa_record *sa_record = ctx->sa_record; 177 178 sa_record->sa_cmd1_word &= ~EIP93_SA_CMD_HASH_CRYPT_OFFSET; 179 sa_record->sa_cmd1_word |= FIELD_PREP(EIP93_SA_CMD_HASH_CRYPT_OFFSET, 180 req->assoclen / sizeof(u32)); 181 182 ctx->assoclen = req->assoclen; 183 } 184 185 static int eip93_aead_crypt(struct aead_request *req) 186 { 187 struct eip93_cipher_reqctx *rctx = aead_request_ctx(req); 188 struct crypto_async_request *async = &req->base; 189 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 190 struct crypto_aead *aead = crypto_aead_reqtfm(req); 191 int ret; 192 193 ctx->sa_record_base = dma_map_single(ctx->eip93->dev, ctx->sa_record, 194 sizeof(*ctx->sa_record), DMA_TO_DEVICE); 195 ret = dma_mapping_error(ctx->eip93->dev, ctx->sa_record_base); 196 if (ret) 197 return ret; 198 199 rctx->textsize = req->cryptlen; 200 rctx->blksize = ctx->blksize; 201 rctx->assoclen = req->assoclen; 202 rctx->authsize = ctx->authsize; 203 rctx->sg_src = req->src; 204 rctx->sg_dst = req->dst; 205 rctx->ivsize = crypto_aead_ivsize(aead); 206 rctx->desc_flags = EIP93_DESC_AEAD; 207 rctx->sa_record_base = ctx->sa_record_base; 208 209 if (IS_DECRYPT(rctx->flags)) 210 rctx->textsize -= rctx->authsize; 211 212 return eip93_aead_send_req(async); 213 } 214 215 static int eip93_aead_encrypt(struct aead_request *req) 216 { 217 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 218 struct eip93_cipher_reqctx *rctx = aead_request_ctx(req); 219 220 rctx->flags = ctx->flags; 221 rctx->flags |= EIP93_ENCRYPT; 222 if (ctx->set_assoc) { 223 eip93_aead_setassoc(ctx, req); 224 ctx->set_assoc = false; 225 } 226 227 if (req->assoclen != ctx->assoclen) { 228 dev_err(ctx->eip93->dev, "Request AAD length error\n"); 229 return -EINVAL; 230 } 231 232 return eip93_aead_crypt(req); 233 } 234 235 static int eip93_aead_decrypt(struct aead_request *req) 236 { 237 struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(req->base.tfm); 238 struct eip93_cipher_reqctx *rctx = aead_request_ctx(req); 239 240 ctx->sa_record->sa_cmd0_word |= EIP93_SA_CMD_DIRECTION_IN; 241 ctx->sa_record->sa_cmd1_word &= ~(EIP93_SA_CMD_COPY_PAD | 242 EIP93_SA_CMD_COPY_DIGEST); 243 244 rctx->flags = ctx->flags; 245 rctx->flags |= EIP93_DECRYPT; 246 if (ctx->set_assoc) { 247 eip93_aead_setassoc(ctx, req); 248 ctx->set_assoc = false; 249 } 250 251 if (req->assoclen != ctx->assoclen) { 252 dev_err(ctx->eip93->dev, "Request AAD length error\n"); 253 return -EINVAL; 254 } 255 256 return eip93_aead_crypt(req); 257 } 258 259 /* Available authenc algorithms in this module */ 260 struct eip93_alg_template eip93_alg_authenc_hmac_md5_cbc_aes = { 261 .type = EIP93_ALG_TYPE_AEAD, 262 .flags = EIP93_HASH_HMAC | EIP93_HASH_MD5 | EIP93_MODE_CBC | EIP93_ALG_AES, 263 .alg.aead = { 264 .setkey = eip93_aead_setkey, 265 .encrypt = eip93_aead_encrypt, 266 .decrypt = eip93_aead_decrypt, 267 .ivsize = AES_BLOCK_SIZE, 268 .setauthsize = eip93_aead_setauthsize, 269 .maxauthsize = MD5_DIGEST_SIZE, 270 .base = { 271 .cra_name = "authenc(hmac(md5),cbc(aes))", 272 .cra_driver_name = 273 "authenc(hmac(md5-eip93), cbc(aes-eip93))", 274 .cra_priority = EIP93_CRA_PRIORITY, 275 .cra_flags = CRYPTO_ALG_ASYNC | 276 CRYPTO_ALG_KERN_DRIVER_ONLY | 277 CRYPTO_ALG_ALLOCATES_MEMORY, 278 .cra_blocksize = AES_BLOCK_SIZE, 279 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 280 .cra_alignmask = 0, 281 .cra_init = eip93_aead_cra_init, 282 .cra_exit = eip93_aead_cra_exit, 283 .cra_module = THIS_MODULE, 284 }, 285 }, 286 }; 287 288 struct eip93_alg_template eip93_alg_authenc_hmac_sha1_cbc_aes = { 289 .type = EIP93_ALG_TYPE_AEAD, 290 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA1 | EIP93_MODE_CBC | EIP93_ALG_AES, 291 .alg.aead = { 292 .setkey = eip93_aead_setkey, 293 .encrypt = eip93_aead_encrypt, 294 .decrypt = eip93_aead_decrypt, 295 .ivsize = AES_BLOCK_SIZE, 296 .setauthsize = eip93_aead_setauthsize, 297 .maxauthsize = SHA1_DIGEST_SIZE, 298 .base = { 299 .cra_name = "authenc(hmac(sha1),cbc(aes))", 300 .cra_driver_name = 301 "authenc(hmac(sha1-eip93),cbc(aes-eip93))", 302 .cra_priority = EIP93_CRA_PRIORITY, 303 .cra_flags = CRYPTO_ALG_ASYNC | 304 CRYPTO_ALG_KERN_DRIVER_ONLY | 305 CRYPTO_ALG_ALLOCATES_MEMORY, 306 .cra_blocksize = AES_BLOCK_SIZE, 307 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 308 .cra_alignmask = 0, 309 .cra_init = eip93_aead_cra_init, 310 .cra_exit = eip93_aead_cra_exit, 311 .cra_module = THIS_MODULE, 312 }, 313 }, 314 }; 315 316 struct eip93_alg_template eip93_alg_authenc_hmac_sha224_cbc_aes = { 317 .type = EIP93_ALG_TYPE_AEAD, 318 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA224 | EIP93_MODE_CBC | EIP93_ALG_AES, 319 .alg.aead = { 320 .setkey = eip93_aead_setkey, 321 .encrypt = eip93_aead_encrypt, 322 .decrypt = eip93_aead_decrypt, 323 .ivsize = AES_BLOCK_SIZE, 324 .setauthsize = eip93_aead_setauthsize, 325 .maxauthsize = SHA224_DIGEST_SIZE, 326 .base = { 327 .cra_name = "authenc(hmac(sha224),cbc(aes))", 328 .cra_driver_name = 329 "authenc(hmac(sha224-eip93),cbc(aes-eip93))", 330 .cra_priority = EIP93_CRA_PRIORITY, 331 .cra_flags = CRYPTO_ALG_ASYNC | 332 CRYPTO_ALG_KERN_DRIVER_ONLY | 333 CRYPTO_ALG_ALLOCATES_MEMORY, 334 .cra_blocksize = AES_BLOCK_SIZE, 335 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 336 .cra_alignmask = 0, 337 .cra_init = eip93_aead_cra_init, 338 .cra_exit = eip93_aead_cra_exit, 339 .cra_module = THIS_MODULE, 340 }, 341 }, 342 }; 343 344 struct eip93_alg_template eip93_alg_authenc_hmac_sha256_cbc_aes = { 345 .type = EIP93_ALG_TYPE_AEAD, 346 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA256 | EIP93_MODE_CBC | EIP93_ALG_AES, 347 .alg.aead = { 348 .setkey = eip93_aead_setkey, 349 .encrypt = eip93_aead_encrypt, 350 .decrypt = eip93_aead_decrypt, 351 .ivsize = AES_BLOCK_SIZE, 352 .setauthsize = eip93_aead_setauthsize, 353 .maxauthsize = SHA256_DIGEST_SIZE, 354 .base = { 355 .cra_name = "authenc(hmac(sha256),cbc(aes))", 356 .cra_driver_name = 357 "authenc(hmac(sha256-eip93),cbc(aes-eip93))", 358 .cra_priority = EIP93_CRA_PRIORITY, 359 .cra_flags = CRYPTO_ALG_ASYNC | 360 CRYPTO_ALG_KERN_DRIVER_ONLY | 361 CRYPTO_ALG_ALLOCATES_MEMORY, 362 .cra_blocksize = AES_BLOCK_SIZE, 363 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 364 .cra_alignmask = 0, 365 .cra_init = eip93_aead_cra_init, 366 .cra_exit = eip93_aead_cra_exit, 367 .cra_module = THIS_MODULE, 368 }, 369 }, 370 }; 371 372 struct eip93_alg_template eip93_alg_authenc_hmac_md5_rfc3686_aes = { 373 .type = EIP93_ALG_TYPE_AEAD, 374 .flags = EIP93_HASH_HMAC | EIP93_HASH_MD5 | 375 EIP93_MODE_CTR | EIP93_MODE_RFC3686 | EIP93_ALG_AES, 376 .alg.aead = { 377 .setkey = eip93_aead_setkey, 378 .encrypt = eip93_aead_encrypt, 379 .decrypt = eip93_aead_decrypt, 380 .ivsize = CTR_RFC3686_IV_SIZE, 381 .setauthsize = eip93_aead_setauthsize, 382 .maxauthsize = MD5_DIGEST_SIZE, 383 .base = { 384 .cra_name = "authenc(hmac(md5),rfc3686(ctr(aes)))", 385 .cra_driver_name = 386 "authenc(hmac(md5-eip93),rfc3686(ctr(aes-eip93)))", 387 .cra_priority = EIP93_CRA_PRIORITY, 388 .cra_flags = CRYPTO_ALG_ASYNC | 389 CRYPTO_ALG_KERN_DRIVER_ONLY | 390 CRYPTO_ALG_ALLOCATES_MEMORY, 391 .cra_blocksize = 1, 392 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 393 .cra_alignmask = 0, 394 .cra_init = eip93_aead_cra_init, 395 .cra_exit = eip93_aead_cra_exit, 396 .cra_module = THIS_MODULE, 397 }, 398 }, 399 }; 400 401 struct eip93_alg_template eip93_alg_authenc_hmac_sha1_rfc3686_aes = { 402 .type = EIP93_ALG_TYPE_AEAD, 403 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA1 | 404 EIP93_MODE_CTR | EIP93_MODE_RFC3686 | EIP93_ALG_AES, 405 .alg.aead = { 406 .setkey = eip93_aead_setkey, 407 .encrypt = eip93_aead_encrypt, 408 .decrypt = eip93_aead_decrypt, 409 .ivsize = CTR_RFC3686_IV_SIZE, 410 .setauthsize = eip93_aead_setauthsize, 411 .maxauthsize = SHA1_DIGEST_SIZE, 412 .base = { 413 .cra_name = "authenc(hmac(sha1),rfc3686(ctr(aes)))", 414 .cra_driver_name = 415 "authenc(hmac(sha1-eip93),rfc3686(ctr(aes-eip93)))", 416 .cra_priority = EIP93_CRA_PRIORITY, 417 .cra_flags = CRYPTO_ALG_ASYNC | 418 CRYPTO_ALG_KERN_DRIVER_ONLY | 419 CRYPTO_ALG_ALLOCATES_MEMORY, 420 .cra_blocksize = 1, 421 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 422 .cra_alignmask = 0, 423 .cra_init = eip93_aead_cra_init, 424 .cra_exit = eip93_aead_cra_exit, 425 .cra_module = THIS_MODULE, 426 }, 427 }, 428 }; 429 430 struct eip93_alg_template eip93_alg_authenc_hmac_sha224_rfc3686_aes = { 431 .type = EIP93_ALG_TYPE_AEAD, 432 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA224 | 433 EIP93_MODE_CTR | EIP93_MODE_RFC3686 | EIP93_ALG_AES, 434 .alg.aead = { 435 .setkey = eip93_aead_setkey, 436 .encrypt = eip93_aead_encrypt, 437 .decrypt = eip93_aead_decrypt, 438 .ivsize = CTR_RFC3686_IV_SIZE, 439 .setauthsize = eip93_aead_setauthsize, 440 .maxauthsize = SHA224_DIGEST_SIZE, 441 .base = { 442 .cra_name = "authenc(hmac(sha224),rfc3686(ctr(aes)))", 443 .cra_driver_name = 444 "authenc(hmac(sha224-eip93),rfc3686(ctr(aes-eip93)))", 445 .cra_priority = EIP93_CRA_PRIORITY, 446 .cra_flags = CRYPTO_ALG_ASYNC | 447 CRYPTO_ALG_KERN_DRIVER_ONLY | 448 CRYPTO_ALG_ALLOCATES_MEMORY, 449 .cra_blocksize = 1, 450 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 451 .cra_alignmask = 0, 452 .cra_init = eip93_aead_cra_init, 453 .cra_exit = eip93_aead_cra_exit, 454 .cra_module = THIS_MODULE, 455 }, 456 }, 457 }; 458 459 struct eip93_alg_template eip93_alg_authenc_hmac_sha256_rfc3686_aes = { 460 .type = EIP93_ALG_TYPE_AEAD, 461 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA256 | 462 EIP93_MODE_CTR | EIP93_MODE_RFC3686 | EIP93_ALG_AES, 463 .alg.aead = { 464 .setkey = eip93_aead_setkey, 465 .encrypt = eip93_aead_encrypt, 466 .decrypt = eip93_aead_decrypt, 467 .ivsize = CTR_RFC3686_IV_SIZE, 468 .setauthsize = eip93_aead_setauthsize, 469 .maxauthsize = SHA256_DIGEST_SIZE, 470 .base = { 471 .cra_name = "authenc(hmac(sha256),rfc3686(ctr(aes)))", 472 .cra_driver_name = 473 "authenc(hmac(sha256-eip93),rfc3686(ctr(aes-eip93)))", 474 .cra_priority = EIP93_CRA_PRIORITY, 475 .cra_flags = CRYPTO_ALG_ASYNC | 476 CRYPTO_ALG_KERN_DRIVER_ONLY | 477 CRYPTO_ALG_ALLOCATES_MEMORY, 478 .cra_blocksize = 1, 479 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 480 .cra_alignmask = 0, 481 .cra_init = eip93_aead_cra_init, 482 .cra_exit = eip93_aead_cra_exit, 483 .cra_module = THIS_MODULE, 484 }, 485 }, 486 }; 487 488 struct eip93_alg_template eip93_alg_authenc_hmac_md5_cbc_des = { 489 .type = EIP93_ALG_TYPE_AEAD, 490 .flags = EIP93_HASH_HMAC | EIP93_HASH_MD5 | EIP93_MODE_CBC | EIP93_ALG_DES, 491 .alg.aead = { 492 .setkey = eip93_aead_setkey, 493 .encrypt = eip93_aead_encrypt, 494 .decrypt = eip93_aead_decrypt, 495 .ivsize = DES_BLOCK_SIZE, 496 .setauthsize = eip93_aead_setauthsize, 497 .maxauthsize = MD5_DIGEST_SIZE, 498 .base = { 499 .cra_name = "authenc(hmac(md5),cbc(des))", 500 .cra_driver_name = 501 "authenc(hmac(md5-eip93),cbc(des-eip93))", 502 .cra_priority = EIP93_CRA_PRIORITY, 503 .cra_flags = CRYPTO_ALG_ASYNC | 504 CRYPTO_ALG_KERN_DRIVER_ONLY | 505 CRYPTO_ALG_ALLOCATES_MEMORY, 506 .cra_blocksize = DES_BLOCK_SIZE, 507 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 508 .cra_alignmask = 0, 509 .cra_init = eip93_aead_cra_init, 510 .cra_exit = eip93_aead_cra_exit, 511 .cra_module = THIS_MODULE, 512 }, 513 }, 514 }; 515 516 struct eip93_alg_template eip93_alg_authenc_hmac_sha1_cbc_des = { 517 .type = EIP93_ALG_TYPE_AEAD, 518 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA1 | EIP93_MODE_CBC | EIP93_ALG_DES, 519 .alg.aead = { 520 .setkey = eip93_aead_setkey, 521 .encrypt = eip93_aead_encrypt, 522 .decrypt = eip93_aead_decrypt, 523 .ivsize = DES_BLOCK_SIZE, 524 .setauthsize = eip93_aead_setauthsize, 525 .maxauthsize = SHA1_DIGEST_SIZE, 526 .base = { 527 .cra_name = "authenc(hmac(sha1),cbc(des))", 528 .cra_driver_name = 529 "authenc(hmac(sha1-eip93),cbc(des-eip93))", 530 .cra_priority = EIP93_CRA_PRIORITY, 531 .cra_flags = CRYPTO_ALG_ASYNC | 532 CRYPTO_ALG_KERN_DRIVER_ONLY | 533 CRYPTO_ALG_ALLOCATES_MEMORY, 534 .cra_blocksize = DES_BLOCK_SIZE, 535 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 536 .cra_alignmask = 0, 537 .cra_init = eip93_aead_cra_init, 538 .cra_exit = eip93_aead_cra_exit, 539 .cra_module = THIS_MODULE, 540 }, 541 }, 542 }; 543 544 struct eip93_alg_template eip93_alg_authenc_hmac_sha224_cbc_des = { 545 .type = EIP93_ALG_TYPE_AEAD, 546 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA224 | EIP93_MODE_CBC | EIP93_ALG_DES, 547 .alg.aead = { 548 .setkey = eip93_aead_setkey, 549 .encrypt = eip93_aead_encrypt, 550 .decrypt = eip93_aead_decrypt, 551 .ivsize = DES_BLOCK_SIZE, 552 .setauthsize = eip93_aead_setauthsize, 553 .maxauthsize = SHA224_DIGEST_SIZE, 554 .base = { 555 .cra_name = "authenc(hmac(sha224),cbc(des))", 556 .cra_driver_name = 557 "authenc(hmac(sha224-eip93),cbc(des-eip93))", 558 .cra_priority = EIP93_CRA_PRIORITY, 559 .cra_flags = CRYPTO_ALG_ASYNC | 560 CRYPTO_ALG_KERN_DRIVER_ONLY | 561 CRYPTO_ALG_ALLOCATES_MEMORY, 562 .cra_blocksize = DES_BLOCK_SIZE, 563 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 564 .cra_alignmask = 0, 565 .cra_init = eip93_aead_cra_init, 566 .cra_exit = eip93_aead_cra_exit, 567 .cra_module = THIS_MODULE, 568 }, 569 }, 570 }; 571 572 struct eip93_alg_template eip93_alg_authenc_hmac_sha256_cbc_des = { 573 .type = EIP93_ALG_TYPE_AEAD, 574 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA256 | EIP93_MODE_CBC | EIP93_ALG_DES, 575 .alg.aead = { 576 .setkey = eip93_aead_setkey, 577 .encrypt = eip93_aead_encrypt, 578 .decrypt = eip93_aead_decrypt, 579 .ivsize = DES_BLOCK_SIZE, 580 .setauthsize = eip93_aead_setauthsize, 581 .maxauthsize = SHA256_DIGEST_SIZE, 582 .base = { 583 .cra_name = "authenc(hmac(sha256),cbc(des))", 584 .cra_driver_name = 585 "authenc(hmac(sha256-eip93),cbc(des-eip93))", 586 .cra_priority = EIP93_CRA_PRIORITY, 587 .cra_flags = CRYPTO_ALG_ASYNC | 588 CRYPTO_ALG_KERN_DRIVER_ONLY | 589 CRYPTO_ALG_ALLOCATES_MEMORY, 590 .cra_blocksize = DES_BLOCK_SIZE, 591 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 592 .cra_alignmask = 0, 593 .cra_init = eip93_aead_cra_init, 594 .cra_exit = eip93_aead_cra_exit, 595 .cra_module = THIS_MODULE, 596 }, 597 }, 598 }; 599 600 struct eip93_alg_template eip93_alg_authenc_hmac_md5_cbc_des3_ede = { 601 .type = EIP93_ALG_TYPE_AEAD, 602 .flags = EIP93_HASH_HMAC | EIP93_HASH_MD5 | EIP93_MODE_CBC | EIP93_ALG_3DES, 603 .alg.aead = { 604 .setkey = eip93_aead_setkey, 605 .encrypt = eip93_aead_encrypt, 606 .decrypt = eip93_aead_decrypt, 607 .ivsize = DES3_EDE_BLOCK_SIZE, 608 .setauthsize = eip93_aead_setauthsize, 609 .maxauthsize = MD5_DIGEST_SIZE, 610 .base = { 611 .cra_name = "authenc(hmac(md5),cbc(des3_ede))", 612 .cra_driver_name = 613 "authenc(hmac(md5-eip93),cbc(des3_ede-eip93))", 614 .cra_priority = EIP93_CRA_PRIORITY, 615 .cra_flags = CRYPTO_ALG_ASYNC | 616 CRYPTO_ALG_KERN_DRIVER_ONLY | 617 CRYPTO_ALG_ALLOCATES_MEMORY, 618 .cra_blocksize = DES3_EDE_BLOCK_SIZE, 619 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 620 .cra_alignmask = 0x0, 621 .cra_init = eip93_aead_cra_init, 622 .cra_exit = eip93_aead_cra_exit, 623 .cra_module = THIS_MODULE, 624 }, 625 }, 626 }; 627 628 struct eip93_alg_template eip93_alg_authenc_hmac_sha1_cbc_des3_ede = { 629 .type = EIP93_ALG_TYPE_AEAD, 630 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA1 | EIP93_MODE_CBC | EIP93_ALG_3DES, 631 .alg.aead = { 632 .setkey = eip93_aead_setkey, 633 .encrypt = eip93_aead_encrypt, 634 .decrypt = eip93_aead_decrypt, 635 .ivsize = DES3_EDE_BLOCK_SIZE, 636 .setauthsize = eip93_aead_setauthsize, 637 .maxauthsize = SHA1_DIGEST_SIZE, 638 .base = { 639 .cra_name = "authenc(hmac(sha1),cbc(des3_ede))", 640 .cra_driver_name = 641 "authenc(hmac(sha1-eip93),cbc(des3_ede-eip93))", 642 .cra_priority = EIP93_CRA_PRIORITY, 643 .cra_flags = CRYPTO_ALG_ASYNC | 644 CRYPTO_ALG_KERN_DRIVER_ONLY | 645 CRYPTO_ALG_ALLOCATES_MEMORY, 646 .cra_blocksize = DES3_EDE_BLOCK_SIZE, 647 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 648 .cra_alignmask = 0x0, 649 .cra_init = eip93_aead_cra_init, 650 .cra_exit = eip93_aead_cra_exit, 651 .cra_module = THIS_MODULE, 652 }, 653 }, 654 }; 655 656 struct eip93_alg_template eip93_alg_authenc_hmac_sha224_cbc_des3_ede = { 657 .type = EIP93_ALG_TYPE_AEAD, 658 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA224 | EIP93_MODE_CBC | EIP93_ALG_3DES, 659 .alg.aead = { 660 .setkey = eip93_aead_setkey, 661 .encrypt = eip93_aead_encrypt, 662 .decrypt = eip93_aead_decrypt, 663 .ivsize = DES3_EDE_BLOCK_SIZE, 664 .setauthsize = eip93_aead_setauthsize, 665 .maxauthsize = SHA224_DIGEST_SIZE, 666 .base = { 667 .cra_name = "authenc(hmac(sha224),cbc(des3_ede))", 668 .cra_driver_name = 669 "authenc(hmac(sha224-eip93),cbc(des3_ede-eip93))", 670 .cra_priority = EIP93_CRA_PRIORITY, 671 .cra_flags = CRYPTO_ALG_ASYNC | 672 CRYPTO_ALG_KERN_DRIVER_ONLY | 673 CRYPTO_ALG_ALLOCATES_MEMORY, 674 .cra_blocksize = DES3_EDE_BLOCK_SIZE, 675 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 676 .cra_alignmask = 0x0, 677 .cra_init = eip93_aead_cra_init, 678 .cra_exit = eip93_aead_cra_exit, 679 .cra_module = THIS_MODULE, 680 }, 681 }, 682 }; 683 684 struct eip93_alg_template eip93_alg_authenc_hmac_sha256_cbc_des3_ede = { 685 .type = EIP93_ALG_TYPE_AEAD, 686 .flags = EIP93_HASH_HMAC | EIP93_HASH_SHA256 | EIP93_MODE_CBC | EIP93_ALG_3DES, 687 .alg.aead = { 688 .setkey = eip93_aead_setkey, 689 .encrypt = eip93_aead_encrypt, 690 .decrypt = eip93_aead_decrypt, 691 .ivsize = DES3_EDE_BLOCK_SIZE, 692 .setauthsize = eip93_aead_setauthsize, 693 .maxauthsize = SHA256_DIGEST_SIZE, 694 .base = { 695 .cra_name = "authenc(hmac(sha256),cbc(des3_ede))", 696 .cra_driver_name = 697 "authenc(hmac(sha256-eip93),cbc(des3_ede-eip93))", 698 .cra_priority = EIP93_CRA_PRIORITY, 699 .cra_flags = CRYPTO_ALG_ASYNC | 700 CRYPTO_ALG_KERN_DRIVER_ONLY | 701 CRYPTO_ALG_ALLOCATES_MEMORY, 702 .cra_blocksize = DES3_EDE_BLOCK_SIZE, 703 .cra_ctxsize = sizeof(struct eip93_crypto_ctx), 704 .cra_alignmask = 0x0, 705 .cra_init = eip93_aead_cra_init, 706 .cra_exit = eip93_aead_cra_exit, 707 .cra_module = THIS_MODULE, 708 }, 709 }, 710 }; 711