2 * CBC: Cipher Block Chaining mode
4 * Copyright (c) 2006-2016 Herbert Xu <herbert@gondor.apana.org.au>
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)
13 #include <crypto/cbc.h>
14 #include <crypto/internal/skcipher.h>
15 #include <linux/err.h>
16 #include <linux/init.h>
17 #include <linux/kernel.h>
18 #include <linux/log2.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
22 struct crypto_cbc_ctx
{
23 struct crypto_cipher
*child
;
26 static int crypto_cbc_setkey(struct crypto_skcipher
*parent
, const u8
*key
,
29 struct crypto_cbc_ctx
*ctx
= crypto_skcipher_ctx(parent
);
30 struct crypto_cipher
*child
= ctx
->child
;
33 crypto_cipher_clear_flags(child
, CRYPTO_TFM_REQ_MASK
);
34 crypto_cipher_set_flags(child
, crypto_skcipher_get_flags(parent
) &
36 err
= crypto_cipher_setkey(child
, key
, keylen
);
37 crypto_skcipher_set_flags(parent
, crypto_cipher_get_flags(child
) &
42 static inline void crypto_cbc_encrypt_one(struct crypto_skcipher
*tfm
,
43 const u8
*src
, u8
*dst
)
45 struct crypto_cbc_ctx
*ctx
= crypto_skcipher_ctx(tfm
);
47 crypto_cipher_encrypt_one(ctx
->child
, dst
, src
);
50 static int crypto_cbc_encrypt(struct skcipher_request
*req
)
52 return crypto_cbc_encrypt_walk(req
, crypto_cbc_encrypt_one
);
55 static inline void crypto_cbc_decrypt_one(struct crypto_skcipher
*tfm
,
56 const u8
*src
, u8
*dst
)
58 struct crypto_cbc_ctx
*ctx
= crypto_skcipher_ctx(tfm
);
60 crypto_cipher_decrypt_one(ctx
->child
, dst
, src
);
63 static int crypto_cbc_decrypt(struct skcipher_request
*req
)
65 struct crypto_skcipher
*tfm
= crypto_skcipher_reqtfm(req
);
66 struct skcipher_walk walk
;
69 err
= skcipher_walk_virt(&walk
, req
, false);
72 err
= crypto_cbc_decrypt_blocks(&walk
, tfm
,
73 crypto_cbc_decrypt_one
);
74 err
= skcipher_walk_done(&walk
, err
);
80 static int crypto_cbc_init_tfm(struct crypto_skcipher
*tfm
)
82 struct skcipher_instance
*inst
= skcipher_alg_instance(tfm
);
83 struct crypto_spawn
*spawn
= skcipher_instance_ctx(inst
);
84 struct crypto_cbc_ctx
*ctx
= crypto_skcipher_ctx(tfm
);
85 struct crypto_cipher
*cipher
;
87 cipher
= crypto_spawn_cipher(spawn
);
89 return PTR_ERR(cipher
);
95 static void crypto_cbc_exit_tfm(struct crypto_skcipher
*tfm
)
97 struct crypto_cbc_ctx
*ctx
= crypto_skcipher_ctx(tfm
);
99 crypto_free_cipher(ctx
->child
);
102 static void crypto_cbc_free(struct skcipher_instance
*inst
)
104 crypto_drop_skcipher(skcipher_instance_ctx(inst
));
108 static int crypto_cbc_create(struct crypto_template
*tmpl
, struct rtattr
**tb
)
110 struct skcipher_instance
*inst
;
111 struct crypto_spawn
*spawn
;
112 struct crypto_alg
*alg
;
115 err
= crypto_check_attr_type(tb
, CRYPTO_ALG_TYPE_SKCIPHER
);
119 inst
= kzalloc(sizeof(*inst
) + sizeof(*spawn
), GFP_KERNEL
);
123 alg
= crypto_get_attr_alg(tb
, CRYPTO_ALG_TYPE_CIPHER
,
124 CRYPTO_ALG_TYPE_MASK
);
129 spawn
= skcipher_instance_ctx(inst
);
130 err
= crypto_init_spawn(spawn
, alg
, skcipher_crypto_instance(inst
),
131 CRYPTO_ALG_TYPE_MASK
);
136 err
= crypto_inst_setname(skcipher_crypto_instance(inst
), "cbc", alg
);
141 if (!is_power_of_2(alg
->cra_blocksize
))
144 inst
->alg
.base
.cra_priority
= alg
->cra_priority
;
145 inst
->alg
.base
.cra_blocksize
= alg
->cra_blocksize
;
146 inst
->alg
.base
.cra_alignmask
= alg
->cra_alignmask
;
148 /* We access the data as u32s when xoring. */
149 inst
->alg
.base
.cra_alignmask
|= __alignof__(u32
) - 1;
151 inst
->alg
.ivsize
= alg
->cra_blocksize
;
152 inst
->alg
.min_keysize
= alg
->cra_cipher
.cia_min_keysize
;
153 inst
->alg
.max_keysize
= alg
->cra_cipher
.cia_max_keysize
;
155 inst
->alg
.base
.cra_ctxsize
= sizeof(struct crypto_cbc_ctx
);
157 inst
->alg
.init
= crypto_cbc_init_tfm
;
158 inst
->alg
.exit
= crypto_cbc_exit_tfm
;
160 inst
->alg
.setkey
= crypto_cbc_setkey
;
161 inst
->alg
.encrypt
= crypto_cbc_encrypt
;
162 inst
->alg
.decrypt
= crypto_cbc_decrypt
;
164 inst
->free
= crypto_cbc_free
;
166 err
= skcipher_register_instance(tmpl
, inst
);
174 crypto_drop_spawn(spawn
);
180 static struct crypto_template crypto_cbc_tmpl
= {
182 .create
= crypto_cbc_create
,
183 .module
= THIS_MODULE
,
186 static int __init
crypto_cbc_module_init(void)
188 return crypto_register_template(&crypto_cbc_tmpl
);
191 static void __exit
crypto_cbc_module_exit(void)
193 crypto_unregister_template(&crypto_cbc_tmpl
);
196 module_init(crypto_cbc_module_init
);
197 module_exit(crypto_cbc_module_exit
);
199 MODULE_LICENSE("GPL");
200 MODULE_DESCRIPTION("CBC block cipher algorithm");
201 MODULE_ALIAS_CRYPTO("cbc");