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