eip93-aead.c

  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
 30void 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
 43static 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 */
 59static 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
 80static 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
 89static 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
160static 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
174static 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
186static 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
216static 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
236static 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 */
261struct 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
289struct 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
317struct 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
345struct 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
373struct 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
402struct 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
431struct 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
460struct 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
489struct 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
517struct 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
545struct 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
573struct 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
601struct 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
629struct 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
657struct 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
685struct 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};