CoCalc -- eip93-aead.c

GitHub Repository: torvalds/linux
Path: blob/master/drivers/crypto/inside-secure/eip93/eip93-aead.c
²⁶²⁸⁵ views
1
// SPDX-License-Identifier: GPL-2.0
2
/*
3
 * Copyright (C) 2019 - 2021
4
 *
5
 * Richard van Schagen <[email protected]>
6
 * Christian Marangi <[email protected]
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

713
Product

Resources

Company
