20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/rtnetlink.h>
23 #include <linux/slab.h>
52 aead_request_complete(req, err);
58 unsigned int authkeylen;
59 unsigned int enckeylen;
63 struct rtattr *rta = (
void *)key;
80 if (keylen < enckeylen)
86 crypto_ahash_set_flags(auth, crypto_aead_get_flags(authenc) &
89 crypto_aead_set_flags(authenc, crypto_ahash_get_flags(auth) &
96 crypto_ablkcipher_set_flags(enc, crypto_aead_get_flags(authenc) &
98 err = crypto_ablkcipher_setkey(enc, key + authkeylen, enckeylen);
99 crypto_aead_set_flags(authenc, crypto_ablkcipher_get_flags(enc) &
114 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
122 ahash_request_set_crypt(ahreq, areq_ctx->
sg, ahreq->
result,
124 ahash_request_set_callback(ahreq, aead_request_flags(req) &
134 crypto_aead_authsize(authenc), 1);
137 authenc_request_complete(req, err);
143 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
153 crypto_aead_authsize(authenc), 1);
156 aead_request_complete(req, err);
163 unsigned int authsize;
166 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
170 unsigned int cryptlen = req->
cryptlen;
175 ahash_request_set_crypt(ahreq, areq_ctx->
sg, ahreq->
result,
177 ahash_request_set_callback(ahreq, aead_request_flags(req) &
185 authsize = crypto_aead_authsize(authenc);
186 cryptlen -= authsize;
187 ihash = ahreq->
result + authsize;
195 abreq = aead_request_ctx(req);
196 ablkcipher_request_set_tfm(abreq, ctx->
enc);
197 ablkcipher_request_set_callback(abreq, aead_request_flags(req),
198 req->
base.complete, req->
base.data);
199 ablkcipher_request_set_crypt(abreq, req->
src, req->
dst,
202 err = crypto_ablkcipher_decrypt(abreq);
205 authenc_request_complete(req, err);
212 unsigned int authsize;
215 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
219 unsigned int cryptlen = req->
cryptlen;
224 authsize = crypto_aead_authsize(authenc);
225 cryptlen -= authsize;
226 ihash = ahreq->
result + authsize;
234 abreq = aead_request_ctx(req);
235 ablkcipher_request_set_tfm(abreq, ctx->
enc);
236 ablkcipher_request_set_callback(abreq, aead_request_flags(req),
237 req->
base.complete, req->
base.data);
238 ablkcipher_request_set_crypt(abreq, req->
src, req->
dst,
241 err = crypto_ablkcipher_decrypt(abreq);
244 authenc_request_complete(req, err);
249 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
257 hash = (
u8 *)
ALIGN((
unsigned long)hash + crypto_ahash_alignmask(auth),
258 crypto_ahash_alignmask(auth) + 1);
260 ahash_request_set_tfm(ahreq, auth);
262 err = crypto_ahash_init(ahreq);
266 ahash_request_set_crypt(ahreq, req->
assoc, hash, req->
assoclen);
267 ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
270 err = crypto_ahash_update(ahreq);
274 ahash_request_set_crypt(ahreq, areq_ctx->
sg, hash,
276 ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
286 static u8 *crypto_authenc_ahash(
struct aead_request *req,
unsigned int flags)
288 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
293 u8 *hash = areq_ctx->
tail;
296 hash = (
u8 *)
ALIGN((
unsigned long)hash + crypto_ahash_alignmask(auth),
297 crypto_ahash_alignmask(auth) + 1);
299 ahash_request_set_tfm(ahreq, auth);
300 ahash_request_set_crypt(ahreq, areq_ctx->
sg, hash,
302 ahash_request_set_callback(ahreq, aead_request_flags(req) & flags,
315 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
321 unsigned int ivsize = crypto_aead_ivsize(authenc);
322 unsigned int cryptlen = req->
cryptlen;
333 sg_set_buf(cipher, iv, ivsize);
334 scatterwalk_crypto_chain(cipher, dst, vdst == iv + ivsize, 2);
340 authenc_ahash_fn = crypto_authenc_ahash;
342 sg_set_page(asg, sg_page(assoc), assoc->
length, assoc->
offset);
343 scatterwalk_crypto_chain(asg, dst, 0, 2);
351 areq_ctx->
complete = authenc_geniv_ahash_done;
354 hash = authenc_ahash_fn(req, flags);
356 return PTR_ERR(hash);
359 crypto_aead_authsize(authenc), 1);
369 struct crypto_aead *authenc = crypto_aead_reqtfm(areq);
372 u8 *iv = (
u8 *)(abreq + 1) +
373 crypto_ablkcipher_reqsize(ctx->
enc);
375 err = crypto_authenc_genicv(areq, iv, 0);
378 authenc_request_complete(areq, err);
381 static int crypto_authenc_encrypt(
struct aead_request *req)
383 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
388 unsigned int cryptlen = req->
cryptlen;
391 u8 *iv = (
u8 *)abreq - crypto_ablkcipher_ivsize(enc);
394 ablkcipher_request_set_tfm(abreq, enc);
395 ablkcipher_request_set_callback(abreq, aead_request_flags(req),
396 crypto_authenc_encrypt_done, req);
397 ablkcipher_request_set_crypt(abreq, req->
src, dst, cryptlen, req->
iv);
399 memcpy(iv, req->
iv, crypto_aead_ivsize(authenc));
401 err = crypto_ablkcipher_encrypt(abreq);
416 err = crypto_authenc_genicv(areq, greq->
giv, 0);
419 authenc_request_complete(areq, err);
424 struct crypto_aead *authenc = aead_givcrypt_reqtfm(req);
431 skcipher_givcrypt_set_tfm(greq, ctx->
enc);
432 skcipher_givcrypt_set_callback(greq, aead_request_flags(areq),
433 crypto_authenc_givencrypt_done, areq);
434 skcipher_givcrypt_set_crypt(greq, areq->
src, areq->
dst, areq->
cryptlen,
436 skcipher_givcrypt_set_giv(greq, iv, req->
seq);
438 err = crypto_skcipher_givencrypt(greq);
445 static int crypto_authenc_verify(
struct aead_request *req,
448 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
452 unsigned int authsize;
454 areq_ctx->
complete = authenc_verify_ahash_done;
459 return PTR_ERR(ohash);
461 authsize = crypto_aead_authsize(authenc);
462 ihash = ohash + authsize;
468 static int crypto_authenc_iverify(
struct aead_request *req,
u8 *iv,
469 unsigned int cryptlen)
471 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
477 unsigned int ivsize = crypto_aead_ivsize(authenc);
487 sg_set_buf(cipher, iv, ivsize);
488 scatterwalk_crypto_chain(cipher, src, vsrc == iv + ivsize, 2);
494 authenc_ahash_fn = crypto_authenc_ahash;
496 sg_set_page(asg, sg_page(assoc), assoc->
length, assoc->
offset);
497 scatterwalk_crypto_chain(asg, src, 0, 2);
505 return crypto_authenc_verify(req, authenc_ahash_fn);
508 static int crypto_authenc_decrypt(
struct aead_request *req)
510 struct crypto_aead *authenc = crypto_aead_reqtfm(req);
513 unsigned int cryptlen = req->
cryptlen;
514 unsigned int authsize = crypto_aead_authsize(authenc);
518 if (cryptlen < authsize)
520 cryptlen -= authsize;
522 err = crypto_authenc_iverify(req, iv, cryptlen);
526 ablkcipher_request_set_tfm(abreq, ctx->
enc);
527 ablkcipher_request_set_callback(abreq, aead_request_flags(req),
528 req->
base.complete, req->
base.data);
529 ablkcipher_request_set_crypt(abreq, req->
src, req->
dst, cryptlen, iv);
531 return crypto_ablkcipher_decrypt(abreq);
534 static int crypto_authenc_init_tfm(
struct crypto_tfm *tfm)
543 auth = crypto_spawn_ahash(&ictx->
auth);
545 return PTR_ERR(auth);
547 enc = crypto_spawn_skcipher(&ictx->
enc);
555 ctx->
reqoff =
ALIGN(2 * crypto_ahash_digestsize(auth) +
556 crypto_ahash_alignmask(auth),
557 crypto_ahash_alignmask(auth) + 1) +
558 crypto_ablkcipher_ivsize(enc);
563 crypto_ahash_reqsize(auth) +
566 crypto_ablkcipher_reqsize(enc));
571 crypto_free_ahash(auth);
575 static void crypto_authenc_exit_tfm(
struct crypto_tfm *tfm)
579 crypto_free_ahash(ctx->
auth);
580 crypto_free_ablkcipher(ctx->
enc);
591 const char *enc_name;
605 return ERR_CAST(auth);
607 auth_base = &auth->
base;
610 err = PTR_ERR(enc_name);
611 if (IS_ERR(enc_name))
614 inst = kzalloc(
sizeof(*inst) +
sizeof(*ctx),
GFP_KERNEL);
619 ctx = crypto_instance_ctx(inst);
625 crypto_set_skcipher_spawn(&ctx->
enc, inst);
627 crypto_requires_sync(algt->
type,
632 enc = crypto_skcipher_spawn_alg(&ctx->
enc);
653 inst->
alg.cra_aead.ivsize = enc->cra_ablkcipher.ivsize;
658 inst->
alg.cra_init = crypto_authenc_init_tfm;
659 inst->
alg.cra_exit = crypto_authenc_exit_tfm;
661 inst->
alg.cra_aead.setkey = crypto_authenc_setkey;
662 inst->
alg.cra_aead.encrypt = crypto_authenc_encrypt;
663 inst->
alg.cra_aead.decrypt = crypto_authenc_decrypt;
664 inst->
alg.cra_aead.givencrypt = crypto_authenc_givencrypt;
671 crypto_drop_skcipher(&ctx->
enc);
673 crypto_drop_ahash(&ctx->
auth);
685 crypto_drop_skcipher(&ctx->
enc);
686 crypto_drop_ahash(&ctx->
auth);
692 .alloc = crypto_authenc_alloc,
693 .free = crypto_authenc_free,
697 static int __init crypto_authenc_module_init(
void)
702 static void __exit crypto_authenc_module_exit(
void)