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
eip93_aead_handle_result(struct crypto_async_request * async,int err)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
eip93_aead_send_req(struct crypto_async_request * async)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 */
eip93_aead_cra_init(struct crypto_tfm * tfm)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
eip93_aead_cra_exit(struct crypto_tfm * tfm)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
eip93_aead_setkey(struct crypto_aead * ctfm,const u8 * key,unsigned int len)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
eip93_aead_setauthsize(struct crypto_aead * ctfm,unsigned int authsize)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
eip93_aead_setassoc(struct eip93_crypto_ctx * ctx,struct aead_request * req)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
eip93_aead_crypt(struct aead_request * req)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
eip93_aead_encrypt(struct aead_request * req)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
eip93_aead_decrypt(struct aead_request * req)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