Merge tag 'hwmon-for-linus-v4.14-rc4' of git://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-2.6.git] / crypto / cbc.c
1 /*
2  * CBC: Cipher Block Chaining mode
3  *
4  * Copyright (c) 2006-2016 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/algapi.h>
14 #include <crypto/cbc.h>
15 #include <crypto/internal/skcipher.h>
16 #include <linux/err.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/log2.h>
20 #include <linux/module.h>
21 #include <linux/slab.h>
22
23 struct crypto_cbc_ctx {
24         struct crypto_cipher *child;
25 };
26
27 static int crypto_cbc_setkey(struct crypto_skcipher *parent, const u8 *key,
28                              unsigned int keylen)
29 {
30         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(parent);
31         struct crypto_cipher *child = ctx->child;
32         int err;
33
34         crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
35         crypto_cipher_set_flags(child, crypto_skcipher_get_flags(parent) &
36                                        CRYPTO_TFM_REQ_MASK);
37         err = crypto_cipher_setkey(child, key, keylen);
38         crypto_skcipher_set_flags(parent, crypto_cipher_get_flags(child) &
39                                           CRYPTO_TFM_RES_MASK);
40         return err;
41 }
42
43 static inline void crypto_cbc_encrypt_one(struct crypto_skcipher *tfm,
44                                           const u8 *src, u8 *dst)
45 {
46         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
47
48         crypto_cipher_encrypt_one(ctx->child, dst, src);
49 }
50
51 static int crypto_cbc_encrypt(struct skcipher_request *req)
52 {
53         return crypto_cbc_encrypt_walk(req, crypto_cbc_encrypt_one);
54 }
55
56 static inline void crypto_cbc_decrypt_one(struct crypto_skcipher *tfm,
57                                           const u8 *src, u8 *dst)
58 {
59         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
60
61         crypto_cipher_decrypt_one(ctx->child, dst, src);
62 }
63
64 static int crypto_cbc_decrypt(struct skcipher_request *req)
65 {
66         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
67         struct skcipher_walk walk;
68         int err;
69
70         err = skcipher_walk_virt(&walk, req, false);
71
72         while (walk.nbytes) {
73                 err = crypto_cbc_decrypt_blocks(&walk, tfm,
74                                                 crypto_cbc_decrypt_one);
75                 err = skcipher_walk_done(&walk, err);
76         }
77
78         return err;
79 }
80
81 static int crypto_cbc_init_tfm(struct crypto_skcipher *tfm)
82 {
83         struct skcipher_instance *inst = skcipher_alg_instance(tfm);
84         struct crypto_spawn *spawn = skcipher_instance_ctx(inst);
85         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
86         struct crypto_cipher *cipher;
87
88         cipher = crypto_spawn_cipher(spawn);
89         if (IS_ERR(cipher))
90                 return PTR_ERR(cipher);
91
92         ctx->child = cipher;
93         return 0;
94 }
95
96 static void crypto_cbc_exit_tfm(struct crypto_skcipher *tfm)
97 {
98         struct crypto_cbc_ctx *ctx = crypto_skcipher_ctx(tfm);
99
100         crypto_free_cipher(ctx->child);
101 }
102
103 static void crypto_cbc_free(struct skcipher_instance *inst)
104 {
105         crypto_drop_skcipher(skcipher_instance_ctx(inst));
106         kfree(inst);
107 }
108
109 static int crypto_cbc_create(struct crypto_template *tmpl, struct rtattr **tb)
110 {
111         struct skcipher_instance *inst;
112         struct crypto_attr_type *algt;
113         struct crypto_spawn *spawn;
114         struct crypto_alg *alg;
115         u32 mask;
116         int err;
117
118         err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SKCIPHER);
119         if (err)
120                 return err;
121
122         inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
123         if (!inst)
124                 return -ENOMEM;
125
126         algt = crypto_get_attr_type(tb);
127         err = PTR_ERR(algt);
128         if (IS_ERR(algt))
129                 goto err_free_inst;
130
131         mask = CRYPTO_ALG_TYPE_MASK |
132                 crypto_requires_off(algt->type, algt->mask,
133                                     CRYPTO_ALG_NEED_FALLBACK);
134
135         alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, mask);
136         err = PTR_ERR(alg);
137         if (IS_ERR(alg))
138                 goto err_free_inst;
139
140         spawn = skcipher_instance_ctx(inst);
141         err = crypto_init_spawn(spawn, alg, skcipher_crypto_instance(inst),
142                                 CRYPTO_ALG_TYPE_MASK);
143         crypto_mod_put(alg);
144         if (err)
145                 goto err_free_inst;
146
147         err = crypto_inst_setname(skcipher_crypto_instance(inst), "cbc", alg);
148         if (err)
149                 goto err_drop_spawn;
150
151         err = -EINVAL;
152         if (!is_power_of_2(alg->cra_blocksize))
153                 goto err_drop_spawn;
154
155         inst->alg.base.cra_priority = alg->cra_priority;
156         inst->alg.base.cra_blocksize = alg->cra_blocksize;
157         inst->alg.base.cra_alignmask = alg->cra_alignmask;
158
159         inst->alg.ivsize = alg->cra_blocksize;
160         inst->alg.min_keysize = alg->cra_cipher.cia_min_keysize;
161         inst->alg.max_keysize = alg->cra_cipher.cia_max_keysize;
162
163         inst->alg.base.cra_ctxsize = sizeof(struct crypto_cbc_ctx);
164
165         inst->alg.init = crypto_cbc_init_tfm;
166         inst->alg.exit = crypto_cbc_exit_tfm;
167
168         inst->alg.setkey = crypto_cbc_setkey;
169         inst->alg.encrypt = crypto_cbc_encrypt;
170         inst->alg.decrypt = crypto_cbc_decrypt;
171
172         inst->free = crypto_cbc_free;
173
174         err = skcipher_register_instance(tmpl, inst);
175         if (err)
176                 goto err_drop_spawn;
177
178 out:
179         return err;
180
181 err_drop_spawn:
182         crypto_drop_spawn(spawn);
183 err_free_inst:
184         kfree(inst);
185         goto out;
186 }
187
188 static struct crypto_template crypto_cbc_tmpl = {
189         .name = "cbc",
190         .create = crypto_cbc_create,
191         .module = THIS_MODULE,
192 };
193
194 static int __init crypto_cbc_module_init(void)
195 {
196         return crypto_register_template(&crypto_cbc_tmpl);
197 }
198
199 static void __exit crypto_cbc_module_exit(void)
200 {
201         crypto_unregister_template(&crypto_cbc_tmpl);
202 }
203
204 module_init(crypto_cbc_module_init);
205 module_exit(crypto_cbc_module_exit);
206
207 MODULE_LICENSE("GPL");
208 MODULE_DESCRIPTION("CBC block cipher algorithm");
209 MODULE_ALIAS_CRYPTO("cbc");