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