xref: /openbmc/linux/crypto/authenc.c (revision b6dcefde)
1 /*
2  * Authenc: Simple AEAD wrapper for IPsec
3  *
4  * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the Free
8  * Software Foundation; either version 2 of the License, or (at your option)
9  * any later version.
10  *
11  */
12 
13 #include <crypto/aead.h>
14 #include <crypto/internal/hash.h>
15 #include <crypto/internal/skcipher.h>
16 #include <crypto/authenc.h>
17 #include <crypto/scatterwalk.h>
18 #include <linux/err.h>
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/rtnetlink.h>
23 #include <linux/slab.h>
24 #include <linux/spinlock.h>
25 
26 typedef u8 *(*authenc_ahash_t)(struct aead_request *req, unsigned int flags);
27 
28 struct authenc_instance_ctx {
29 	struct crypto_ahash_spawn auth;
30 	struct crypto_skcipher_spawn enc;
31 };
32 
33 struct crypto_authenc_ctx {
34 	unsigned int reqoff;
35 	struct crypto_ahash *auth;
36 	struct crypto_ablkcipher *enc;
37 };
38 
39 struct authenc_request_ctx {
40 	unsigned int cryptlen;
41 	struct scatterlist *sg;
42 	struct scatterlist asg[2];
43 	struct scatterlist cipher[2];
44 	crypto_completion_t complete;
45 	crypto_completion_t update_complete;
46 	char tail[];
47 };
48 
49 static int crypto_authenc_setkey(struct crypto_aead *authenc, const u8 *key,
50 				 unsigned int keylen)
51 {
52 	unsigned int authkeylen;
53 	unsigned int enckeylen;
54 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
55 	struct crypto_ahash *auth = ctx->auth;
56 	struct crypto_ablkcipher *enc = ctx->enc;
57 	struct rtattr *rta = (void *)key;
58 	struct crypto_authenc_key_param *param;
59 	int err = -EINVAL;
60 
61 	if (!RTA_OK(rta, keylen))
62 		goto badkey;
63 	if (rta->rta_type != CRYPTO_AUTHENC_KEYA_PARAM)
64 		goto badkey;
65 	if (RTA_PAYLOAD(rta) < sizeof(*param))
66 		goto badkey;
67 
68 	param = RTA_DATA(rta);
69 	enckeylen = be32_to_cpu(param->enckeylen);
70 
71 	key += RTA_ALIGN(rta->rta_len);
72 	keylen -= RTA_ALIGN(rta->rta_len);
73 
74 	if (keylen < enckeylen)
75 		goto badkey;
76 
77 	authkeylen = keylen - enckeylen;
78 
79 	crypto_ahash_clear_flags(auth, CRYPTO_TFM_REQ_MASK);
80 	crypto_ahash_set_flags(auth, crypto_aead_get_flags(authenc) &
81 				    CRYPTO_TFM_REQ_MASK);
82 	err = crypto_ahash_setkey(auth, key, authkeylen);
83 	crypto_aead_set_flags(authenc, crypto_ahash_get_flags(auth) &
84 				       CRYPTO_TFM_RES_MASK);
85 
86 	if (err)
87 		goto out;
88 
89 	crypto_ablkcipher_clear_flags(enc, CRYPTO_TFM_REQ_MASK);
90 	crypto_ablkcipher_set_flags(enc, crypto_aead_get_flags(authenc) &
91 					 CRYPTO_TFM_REQ_MASK);
92 	err = crypto_ablkcipher_setkey(enc, key + authkeylen, enckeylen);
93 	crypto_aead_set_flags(authenc, crypto_ablkcipher_get_flags(enc) &
94 				       CRYPTO_TFM_RES_MASK);
95 
96 out:
97 	return err;
98 
99 badkey:
100 	crypto_aead_set_flags(authenc, CRYPTO_TFM_RES_BAD_KEY_LEN);
101 	goto out;
102 }
103 
104 static void authenc_chain(struct scatterlist *head, struct scatterlist *sg,
105 			  int chain)
106 {
107 	if (chain) {
108 		head->length += sg->length;
109 		sg = scatterwalk_sg_next(sg);
110 	}
111 
112 	if (sg)
113 		scatterwalk_sg_chain(head, 2, sg);
114 	else
115 		sg_mark_end(head);
116 }
117 
118 static void authenc_geniv_ahash_update_done(struct crypto_async_request *areq,
119 					    int err)
120 {
121 	struct aead_request *req = areq->data;
122 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
123 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
124 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
125 	struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
126 
127 	if (err)
128 		goto out;
129 
130 	ahash_request_set_crypt(ahreq, areq_ctx->sg, ahreq->result,
131 				areq_ctx->cryptlen);
132 	ahash_request_set_callback(ahreq, aead_request_flags(req) &
133 					  CRYPTO_TFM_REQ_MAY_SLEEP,
134 				   areq_ctx->complete, req);
135 
136 	err = crypto_ahash_finup(ahreq);
137 	if (err)
138 		goto out;
139 
140 	scatterwalk_map_and_copy(ahreq->result, areq_ctx->sg,
141 				 areq_ctx->cryptlen,
142 				 crypto_aead_authsize(authenc), 1);
143 
144 out:
145 	aead_request_complete(req, err);
146 }
147 
148 static void authenc_geniv_ahash_done(struct crypto_async_request *areq, int err)
149 {
150 	struct aead_request *req = areq->data;
151 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
152 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
153 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
154 	struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
155 
156 	if (err)
157 		goto out;
158 
159 	scatterwalk_map_and_copy(ahreq->result, areq_ctx->sg,
160 				 areq_ctx->cryptlen,
161 				 crypto_aead_authsize(authenc), 1);
162 
163 out:
164 	aead_request_complete(req, err);
165 }
166 
167 static void authenc_verify_ahash_update_done(struct crypto_async_request *areq,
168 					     int err)
169 {
170 	u8 *ihash;
171 	unsigned int authsize;
172 	struct ablkcipher_request *abreq;
173 	struct aead_request *req = areq->data;
174 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
175 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
176 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
177 	struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
178 
179 	if (err)
180 		goto out;
181 
182 	ahash_request_set_crypt(ahreq, areq_ctx->sg, ahreq->result,
183 				areq_ctx->cryptlen);
184 	ahash_request_set_callback(ahreq, aead_request_flags(req) &
185 					  CRYPTO_TFM_REQ_MAY_SLEEP,
186 				   areq_ctx->complete, req);
187 
188 	err = crypto_ahash_finup(ahreq);
189 	if (err)
190 		goto out;
191 
192 	authsize = crypto_aead_authsize(authenc);
193 	ihash = ahreq->result + authsize;
194 	scatterwalk_map_and_copy(ihash, areq_ctx->sg, areq_ctx->cryptlen,
195 				 authsize, 0);
196 
197 	err = memcmp(ihash, ahreq->result, authsize) ? -EBADMSG: 0;
198 	if (err)
199 		goto out;
200 
201 	abreq = aead_request_ctx(req);
202 	ablkcipher_request_set_tfm(abreq, ctx->enc);
203 	ablkcipher_request_set_callback(abreq, aead_request_flags(req),
204 					req->base.complete, req->base.data);
205 	ablkcipher_request_set_crypt(abreq, req->src, req->dst,
206 				     req->cryptlen, req->iv);
207 
208 	err = crypto_ablkcipher_decrypt(abreq);
209 
210 out:
211 	aead_request_complete(req, err);
212 }
213 
214 static void authenc_verify_ahash_done(struct crypto_async_request *areq,
215 				      int err)
216 {
217 	u8 *ihash;
218 	unsigned int authsize;
219 	struct ablkcipher_request *abreq;
220 	struct aead_request *req = areq->data;
221 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
222 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
223 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
224 	struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
225 
226 	if (err)
227 		goto out;
228 
229 	authsize = crypto_aead_authsize(authenc);
230 	ihash = ahreq->result + authsize;
231 	scatterwalk_map_and_copy(ihash, areq_ctx->sg, areq_ctx->cryptlen,
232 				 authsize, 0);
233 
234 	err = memcmp(ihash, ahreq->result, authsize) ? -EBADMSG: 0;
235 	if (err)
236 		goto out;
237 
238 	abreq = aead_request_ctx(req);
239 	ablkcipher_request_set_tfm(abreq, ctx->enc);
240 	ablkcipher_request_set_callback(abreq, aead_request_flags(req),
241 					req->base.complete, req->base.data);
242 	ablkcipher_request_set_crypt(abreq, req->src, req->dst,
243 				     req->cryptlen, req->iv);
244 
245 	err = crypto_ablkcipher_decrypt(abreq);
246 
247 out:
248 	aead_request_complete(req, err);
249 }
250 
251 static u8 *crypto_authenc_ahash_fb(struct aead_request *req, unsigned int flags)
252 {
253 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
254 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
255 	struct crypto_ahash *auth = ctx->auth;
256 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
257 	struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
258 	u8 *hash = areq_ctx->tail;
259 	int err;
260 
261 	hash = (u8 *)ALIGN((unsigned long)hash + crypto_ahash_alignmask(auth),
262 			    crypto_ahash_alignmask(auth) + 1);
263 
264 	ahash_request_set_tfm(ahreq, auth);
265 
266 	err = crypto_ahash_init(ahreq);
267 	if (err)
268 		return ERR_PTR(err);
269 
270 	ahash_request_set_crypt(ahreq, req->assoc, hash, req->assoclen);
271 	ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
272 				   areq_ctx->update_complete, req);
273 
274 	err = crypto_ahash_update(ahreq);
275 	if (err)
276 		return ERR_PTR(err);
277 
278 	ahash_request_set_crypt(ahreq, areq_ctx->sg, hash,
279 				areq_ctx->cryptlen);
280 	ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
281 				   areq_ctx->complete, req);
282 
283 	err = crypto_ahash_finup(ahreq);
284 	if (err)
285 		return ERR_PTR(err);
286 
287 	return hash;
288 }
289 
290 static u8 *crypto_authenc_ahash(struct aead_request *req, unsigned int flags)
291 {
292 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
293 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
294 	struct crypto_ahash *auth = ctx->auth;
295 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
296 	struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
297 	u8 *hash = areq_ctx->tail;
298 	int err;
299 
300 	hash = (u8 *)ALIGN((unsigned long)hash + crypto_ahash_alignmask(auth),
301 			   crypto_ahash_alignmask(auth) + 1);
302 
303 	ahash_request_set_tfm(ahreq, auth);
304 	ahash_request_set_crypt(ahreq, areq_ctx->sg, hash,
305 				areq_ctx->cryptlen);
306 	ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
307 				   areq_ctx->complete, req);
308 
309 	err = crypto_ahash_digest(ahreq);
310 	if (err)
311 		return ERR_PTR(err);
312 
313 	return hash;
314 }
315 
316 static int crypto_authenc_genicv(struct aead_request *req, u8 *iv,
317 				 unsigned int flags)
318 {
319 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
320 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
321 	struct scatterlist *dst = req->dst;
322 	struct scatterlist *assoc = req->assoc;
323 	struct scatterlist *cipher = areq_ctx->cipher;
324 	struct scatterlist *asg = areq_ctx->asg;
325 	unsigned int ivsize = crypto_aead_ivsize(authenc);
326 	unsigned int cryptlen = req->cryptlen;
327 	authenc_ahash_t authenc_ahash_fn = crypto_authenc_ahash_fb;
328 	struct page *dstp;
329 	u8 *vdst;
330 	u8 *hash;
331 
332 	dstp = sg_page(dst);
333 	vdst = PageHighMem(dstp) ? NULL : page_address(dstp) + dst->offset;
334 
335 	if (ivsize) {
336 		sg_init_table(cipher, 2);
337 		sg_set_buf(cipher, iv, ivsize);
338 		authenc_chain(cipher, dst, vdst == iv + ivsize);
339 		dst = cipher;
340 		cryptlen += ivsize;
341 	}
342 
343 	if (sg_is_last(assoc)) {
344 		authenc_ahash_fn = crypto_authenc_ahash;
345 		sg_init_table(asg, 2);
346 		sg_set_page(asg, sg_page(assoc), assoc->length, assoc->offset);
347 		authenc_chain(asg, dst, 0);
348 		dst = asg;
349 		cryptlen += req->assoclen;
350 	}
351 
352 	areq_ctx->cryptlen = cryptlen;
353 	areq_ctx->sg = dst;
354 
355 	areq_ctx->complete = authenc_geniv_ahash_done;
356 	areq_ctx->update_complete = authenc_geniv_ahash_update_done;
357 
358 	hash = authenc_ahash_fn(req, flags);
359 	if (IS_ERR(hash))
360 		return PTR_ERR(hash);
361 
362 	scatterwalk_map_and_copy(hash, dst, cryptlen,
363 				 crypto_aead_authsize(authenc), 1);
364 	return 0;
365 }
366 
367 static void crypto_authenc_encrypt_done(struct crypto_async_request *req,
368 					int err)
369 {
370 	struct aead_request *areq = req->data;
371 
372 	if (!err) {
373 		struct crypto_aead *authenc = crypto_aead_reqtfm(areq);
374 		struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
375 		struct ablkcipher_request *abreq = aead_request_ctx(areq);
376 		u8 *iv = (u8 *)(abreq + 1) +
377 			 crypto_ablkcipher_reqsize(ctx->enc);
378 
379 		err = crypto_authenc_genicv(areq, iv, 0);
380 	}
381 
382 	aead_request_complete(areq, err);
383 }
384 
385 static int crypto_authenc_encrypt(struct aead_request *req)
386 {
387 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
388 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
389 	struct ablkcipher_request *abreq = aead_request_ctx(req);
390 	struct crypto_ablkcipher *enc = ctx->enc;
391 	struct scatterlist *dst = req->dst;
392 	unsigned int cryptlen = req->cryptlen;
393 	u8 *iv = (u8 *)(abreq + 1) + crypto_ablkcipher_reqsize(enc);
394 	int err;
395 
396 	ablkcipher_request_set_tfm(abreq, enc);
397 	ablkcipher_request_set_callback(abreq, aead_request_flags(req),
398 					crypto_authenc_encrypt_done, req);
399 	ablkcipher_request_set_crypt(abreq, req->src, dst, cryptlen, req->iv);
400 
401 	memcpy(iv, req->iv, crypto_aead_ivsize(authenc));
402 
403 	err = crypto_ablkcipher_encrypt(abreq);
404 	if (err)
405 		return err;
406 
407 	return crypto_authenc_genicv(req, iv, CRYPTO_TFM_REQ_MAY_SLEEP);
408 }
409 
410 static void crypto_authenc_givencrypt_done(struct crypto_async_request *req,
411 					   int err)
412 {
413 	struct aead_request *areq = req->data;
414 
415 	if (!err) {
416 		struct skcipher_givcrypt_request *greq = aead_request_ctx(areq);
417 
418 		err = crypto_authenc_genicv(areq, greq->giv, 0);
419 	}
420 
421 	aead_request_complete(areq, err);
422 }
423 
424 static int crypto_authenc_givencrypt(struct aead_givcrypt_request *req)
425 {
426 	struct crypto_aead *authenc = aead_givcrypt_reqtfm(req);
427 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
428 	struct aead_request *areq = &req->areq;
429 	struct skcipher_givcrypt_request *greq = aead_request_ctx(areq);
430 	u8 *iv = req->giv;
431 	int err;
432 
433 	skcipher_givcrypt_set_tfm(greq, ctx->enc);
434 	skcipher_givcrypt_set_callback(greq, aead_request_flags(areq),
435 				       crypto_authenc_givencrypt_done, areq);
436 	skcipher_givcrypt_set_crypt(greq, areq->src, areq->dst, areq->cryptlen,
437 				    areq->iv);
438 	skcipher_givcrypt_set_giv(greq, iv, req->seq);
439 
440 	err = crypto_skcipher_givencrypt(greq);
441 	if (err)
442 		return err;
443 
444 	return crypto_authenc_genicv(areq, iv, CRYPTO_TFM_REQ_MAY_SLEEP);
445 }
446 
447 static int crypto_authenc_verify(struct aead_request *req,
448 				 authenc_ahash_t authenc_ahash_fn)
449 {
450 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
451 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
452 	u8 *ohash;
453 	u8 *ihash;
454 	unsigned int authsize;
455 
456 	areq_ctx->complete = authenc_verify_ahash_done;
457 	areq_ctx->complete = authenc_verify_ahash_update_done;
458 
459 	ohash = authenc_ahash_fn(req, CRYPTO_TFM_REQ_MAY_SLEEP);
460 	if (IS_ERR(ohash))
461 		return PTR_ERR(ohash);
462 
463 	authsize = crypto_aead_authsize(authenc);
464 	ihash = ohash + authsize;
465 	scatterwalk_map_and_copy(ihash, areq_ctx->sg, areq_ctx->cryptlen,
466 				 authsize, 0);
467 	return memcmp(ihash, ohash, authsize) ? -EBADMSG: 0;
468 }
469 
470 static int crypto_authenc_iverify(struct aead_request *req, u8 *iv,
471 				  unsigned int cryptlen)
472 {
473 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
474 	struct authenc_request_ctx *areq_ctx = aead_request_ctx(req);
475 	struct scatterlist *src = req->src;
476 	struct scatterlist *assoc = req->assoc;
477 	struct scatterlist *cipher = areq_ctx->cipher;
478 	struct scatterlist *asg = areq_ctx->asg;
479 	unsigned int ivsize = crypto_aead_ivsize(authenc);
480 	authenc_ahash_t authenc_ahash_fn = crypto_authenc_ahash_fb;
481 	struct page *srcp;
482 	u8 *vsrc;
483 
484 	srcp = sg_page(src);
485 	vsrc = PageHighMem(srcp) ? NULL : page_address(srcp) + src->offset;
486 
487 	if (ivsize) {
488 		sg_init_table(cipher, 2);
489 		sg_set_buf(cipher, iv, ivsize);
490 		authenc_chain(cipher, src, vsrc == iv + ivsize);
491 		src = cipher;
492 		cryptlen += ivsize;
493 	}
494 
495 	if (sg_is_last(assoc)) {
496 		authenc_ahash_fn = crypto_authenc_ahash;
497 		sg_init_table(asg, 2);
498 		sg_set_page(asg, sg_page(assoc), assoc->length, assoc->offset);
499 		authenc_chain(asg, src, 0);
500 		src = asg;
501 		cryptlen += req->assoclen;
502 	}
503 
504 	areq_ctx->cryptlen = cryptlen;
505 	areq_ctx->sg = src;
506 
507 	return crypto_authenc_verify(req, authenc_ahash_fn);
508 }
509 
510 static int crypto_authenc_decrypt(struct aead_request *req)
511 {
512 	struct crypto_aead *authenc = crypto_aead_reqtfm(req);
513 	struct crypto_authenc_ctx *ctx = crypto_aead_ctx(authenc);
514 	struct ablkcipher_request *abreq = aead_request_ctx(req);
515 	unsigned int cryptlen = req->cryptlen;
516 	unsigned int authsize = crypto_aead_authsize(authenc);
517 	u8 *iv = req->iv;
518 	int err;
519 
520 	if (cryptlen < authsize)
521 		return -EINVAL;
522 	cryptlen -= authsize;
523 
524 	err = crypto_authenc_iverify(req, iv, cryptlen);
525 	if (err)
526 		return err;
527 
528 	ablkcipher_request_set_tfm(abreq, ctx->enc);
529 	ablkcipher_request_set_callback(abreq, aead_request_flags(req),
530 					req->base.complete, req->base.data);
531 	ablkcipher_request_set_crypt(abreq, req->src, req->dst, cryptlen, iv);
532 
533 	return crypto_ablkcipher_decrypt(abreq);
534 }
535 
536 static int crypto_authenc_init_tfm(struct crypto_tfm *tfm)
537 {
538 	struct crypto_instance *inst = crypto_tfm_alg_instance(tfm);
539 	struct authenc_instance_ctx *ictx = crypto_instance_ctx(inst);
540 	struct crypto_authenc_ctx *ctx = crypto_tfm_ctx(tfm);
541 	struct crypto_ahash *auth;
542 	struct crypto_ablkcipher *enc;
543 	int err;
544 
545 	auth = crypto_spawn_ahash(&ictx->auth);
546 	if (IS_ERR(auth))
547 		return PTR_ERR(auth);
548 
549 	ctx->reqoff = ALIGN(2 * crypto_ahash_digestsize(auth) +
550 			    crypto_ahash_alignmask(auth),
551 			    crypto_ahash_alignmask(auth) + 1);
552 
553 	enc = crypto_spawn_skcipher(&ictx->enc);
554 	err = PTR_ERR(enc);
555 	if (IS_ERR(enc))
556 		goto err_free_ahash;
557 
558 	ctx->auth = auth;
559 	ctx->enc = enc;
560 
561 	tfm->crt_aead.reqsize = max_t(unsigned int,
562 				crypto_ahash_reqsize(auth) + ctx->reqoff +
563 				sizeof(struct authenc_request_ctx) +
564 				sizeof(struct ahash_request),
565 				sizeof(struct skcipher_givcrypt_request) +
566 				crypto_ablkcipher_reqsize(enc) +
567 				crypto_ablkcipher_ivsize(enc));
568 
569 	return 0;
570 
571 err_free_ahash:
572 	crypto_free_ahash(auth);
573 	return err;
574 }
575 
576 static void crypto_authenc_exit_tfm(struct crypto_tfm *tfm)
577 {
578 	struct crypto_authenc_ctx *ctx = crypto_tfm_ctx(tfm);
579 
580 	crypto_free_ahash(ctx->auth);
581 	crypto_free_ablkcipher(ctx->enc);
582 }
583 
584 static struct crypto_instance *crypto_authenc_alloc(struct rtattr **tb)
585 {
586 	struct crypto_attr_type *algt;
587 	struct crypto_instance *inst;
588 	struct hash_alg_common *auth;
589 	struct crypto_alg *auth_base;
590 	struct crypto_alg *enc;
591 	struct authenc_instance_ctx *ctx;
592 	const char *enc_name;
593 	int err;
594 
595 	algt = crypto_get_attr_type(tb);
596 	err = PTR_ERR(algt);
597 	if (IS_ERR(algt))
598 		return ERR_PTR(err);
599 
600 	if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask)
601 		return ERR_PTR(-EINVAL);
602 
603 	auth = ahash_attr_alg(tb[1], CRYPTO_ALG_TYPE_HASH,
604 			       CRYPTO_ALG_TYPE_AHASH_MASK);
605 	if (IS_ERR(auth))
606 		return ERR_PTR(PTR_ERR(auth));
607 
608 	auth_base = &auth->base;
609 
610 	enc_name = crypto_attr_alg_name(tb[2]);
611 	err = PTR_ERR(enc_name);
612 	if (IS_ERR(enc_name))
613 		goto out_put_auth;
614 
615 	inst = kzalloc(sizeof(*inst) + sizeof(*ctx), GFP_KERNEL);
616 	err = -ENOMEM;
617 	if (!inst)
618 		goto out_put_auth;
619 
620 	ctx = crypto_instance_ctx(inst);
621 
622 	err = crypto_init_ahash_spawn(&ctx->auth, auth, inst);
623 	if (err)
624 		goto err_free_inst;
625 
626 	crypto_set_skcipher_spawn(&ctx->enc, inst);
627 	err = crypto_grab_skcipher(&ctx->enc, enc_name, 0,
628 				   crypto_requires_sync(algt->type,
629 							algt->mask));
630 	if (err)
631 		goto err_drop_auth;
632 
633 	enc = crypto_skcipher_spawn_alg(&ctx->enc);
634 
635 	err = -ENAMETOOLONG;
636 	if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME,
637 		     "authenc(%s,%s)", auth_base->cra_name, enc->cra_name) >=
638 	    CRYPTO_MAX_ALG_NAME)
639 		goto err_drop_enc;
640 
641 	if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME,
642 		     "authenc(%s,%s)", auth_base->cra_driver_name,
643 		     enc->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
644 		goto err_drop_enc;
645 
646 	inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD;
647 	inst->alg.cra_flags |= enc->cra_flags & CRYPTO_ALG_ASYNC;
648 	inst->alg.cra_priority = enc->cra_priority *
649 				 10 + auth_base->cra_priority;
650 	inst->alg.cra_blocksize = enc->cra_blocksize;
651 	inst->alg.cra_alignmask = auth_base->cra_alignmask | enc->cra_alignmask;
652 	inst->alg.cra_type = &crypto_aead_type;
653 
654 	inst->alg.cra_aead.ivsize = enc->cra_ablkcipher.ivsize;
655 	inst->alg.cra_aead.maxauthsize = auth->digestsize;
656 
657 	inst->alg.cra_ctxsize = sizeof(struct crypto_authenc_ctx);
658 
659 	inst->alg.cra_init = crypto_authenc_init_tfm;
660 	inst->alg.cra_exit = crypto_authenc_exit_tfm;
661 
662 	inst->alg.cra_aead.setkey = crypto_authenc_setkey;
663 	inst->alg.cra_aead.encrypt = crypto_authenc_encrypt;
664 	inst->alg.cra_aead.decrypt = crypto_authenc_decrypt;
665 	inst->alg.cra_aead.givencrypt = crypto_authenc_givencrypt;
666 
667 out:
668 	crypto_mod_put(auth_base);
669 	return inst;
670 
671 err_drop_enc:
672 	crypto_drop_skcipher(&ctx->enc);
673 err_drop_auth:
674 	crypto_drop_ahash(&ctx->auth);
675 err_free_inst:
676 	kfree(inst);
677 out_put_auth:
678 	inst = ERR_PTR(err);
679 	goto out;
680 }
681 
682 static void crypto_authenc_free(struct crypto_instance *inst)
683 {
684 	struct authenc_instance_ctx *ctx = crypto_instance_ctx(inst);
685 
686 	crypto_drop_skcipher(&ctx->enc);
687 	crypto_drop_ahash(&ctx->auth);
688 	kfree(inst);
689 }
690 
691 static struct crypto_template crypto_authenc_tmpl = {
692 	.name = "authenc",
693 	.alloc = crypto_authenc_alloc,
694 	.free = crypto_authenc_free,
695 	.module = THIS_MODULE,
696 };
697 
698 static int __init crypto_authenc_module_init(void)
699 {
700 	return crypto_register_template(&crypto_authenc_tmpl);
701 }
702 
703 static void __exit crypto_authenc_module_exit(void)
704 {
705 	crypto_unregister_template(&crypto_authenc_tmpl);
706 }
707 
708 module_init(crypto_authenc_module_init);
709 module_exit(crypto_authenc_module_exit);
710 
711 MODULE_LICENSE("GPL");
712 MODULE_DESCRIPTION("Simple AEAD wrapper for IPsec");
713