]>
Commit | Line | Data |
---|---|---|
db131ef9 HX |
1 | /* |
2 | * ECB: Electronic CodeBook mode | |
3 | * | |
4 | * Copyright (c) 2006 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 <linux/err.h> | |
15 | #include <linux/init.h> | |
16 | #include <linux/kernel.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/scatterlist.h> | |
19 | #include <linux/slab.h> | |
20 | ||
21 | struct crypto_ecb_ctx { | |
22 | struct crypto_cipher *child; | |
23 | }; | |
24 | ||
25 | static int crypto_ecb_setkey(struct crypto_tfm *parent, const u8 *key, | |
26 | unsigned int keylen) | |
27 | { | |
28 | struct crypto_ecb_ctx *ctx = crypto_tfm_ctx(parent); | |
29 | struct crypto_cipher *child = ctx->child; | |
30 | int err; | |
31 | ||
32 | crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); | |
33 | crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) & | |
34 | CRYPTO_TFM_REQ_MASK); | |
35 | err = crypto_cipher_setkey(child, key, keylen); | |
36 | crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) & | |
37 | CRYPTO_TFM_RES_MASK); | |
38 | return err; | |
39 | } | |
40 | ||
41 | static int crypto_ecb_crypt(struct blkcipher_desc *desc, | |
42 | struct blkcipher_walk *walk, | |
43 | struct crypto_cipher *tfm, | |
44 | void (*fn)(struct crypto_tfm *, u8 *, const u8 *)) | |
45 | { | |
46 | int bsize = crypto_cipher_blocksize(tfm); | |
47 | unsigned int nbytes; | |
48 | int err; | |
49 | ||
50 | err = blkcipher_walk_virt(desc, walk); | |
51 | ||
52 | while ((nbytes = walk->nbytes)) { | |
53 | u8 *wsrc = walk->src.virt.addr; | |
54 | u8 *wdst = walk->dst.virt.addr; | |
55 | ||
56 | do { | |
57 | fn(crypto_cipher_tfm(tfm), wdst, wsrc); | |
5b37c19e | 58 | |
db131ef9 HX |
59 | wsrc += bsize; |
60 | wdst += bsize; | |
61 | } while ((nbytes -= bsize) >= bsize); | |
62 | ||
63 | err = blkcipher_walk_done(desc, walk, nbytes); | |
64 | } | |
65 | ||
66 | return err; | |
67 | } | |
68 | ||
69 | static int crypto_ecb_encrypt(struct blkcipher_desc *desc, | |
70 | struct scatterlist *dst, struct scatterlist *src, | |
71 | unsigned int nbytes) | |
72 | { | |
73 | struct blkcipher_walk walk; | |
74 | struct crypto_blkcipher *tfm = desc->tfm; | |
75 | struct crypto_ecb_ctx *ctx = crypto_blkcipher_ctx(tfm); | |
76 | struct crypto_cipher *child = ctx->child; | |
77 | ||
78 | blkcipher_walk_init(&walk, dst, src, nbytes); | |
79 | return crypto_ecb_crypt(desc, &walk, child, | |
80 | crypto_cipher_alg(child)->cia_encrypt); | |
81 | } | |
82 | ||
83 | static int crypto_ecb_decrypt(struct blkcipher_desc *desc, | |
84 | struct scatterlist *dst, struct scatterlist *src, | |
85 | unsigned int nbytes) | |
86 | { | |
87 | struct blkcipher_walk walk; | |
88 | struct crypto_blkcipher *tfm = desc->tfm; | |
89 | struct crypto_ecb_ctx *ctx = crypto_blkcipher_ctx(tfm); | |
90 | struct crypto_cipher *child = ctx->child; | |
91 | ||
92 | blkcipher_walk_init(&walk, dst, src, nbytes); | |
93 | return crypto_ecb_crypt(desc, &walk, child, | |
94 | crypto_cipher_alg(child)->cia_decrypt); | |
95 | } | |
96 | ||
97 | static int crypto_ecb_init_tfm(struct crypto_tfm *tfm) | |
98 | { | |
99 | struct crypto_instance *inst = (void *)tfm->__crt_alg; | |
100 | struct crypto_spawn *spawn = crypto_instance_ctx(inst); | |
101 | struct crypto_ecb_ctx *ctx = crypto_tfm_ctx(tfm); | |
2e306ee0 | 102 | struct crypto_cipher *cipher; |
db131ef9 | 103 | |
2e306ee0 HX |
104 | cipher = crypto_spawn_cipher(spawn); |
105 | if (IS_ERR(cipher)) | |
106 | return PTR_ERR(cipher); | |
db131ef9 | 107 | |
2e306ee0 | 108 | ctx->child = cipher; |
db131ef9 HX |
109 | return 0; |
110 | } | |
111 | ||
112 | static void crypto_ecb_exit_tfm(struct crypto_tfm *tfm) | |
113 | { | |
114 | struct crypto_ecb_ctx *ctx = crypto_tfm_ctx(tfm); | |
115 | crypto_free_cipher(ctx->child); | |
116 | } | |
117 | ||
ebc610e5 | 118 | static struct crypto_instance *crypto_ecb_alloc(struct rtattr **tb) |
db131ef9 HX |
119 | { |
120 | struct crypto_instance *inst; | |
121 | struct crypto_alg *alg; | |
ebc610e5 HX |
122 | int err; |
123 | ||
124 | err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER); | |
125 | if (err) | |
126 | return ERR_PTR(err); | |
db131ef9 | 127 | |
ebc610e5 HX |
128 | alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, |
129 | CRYPTO_ALG_TYPE_MASK); | |
db131ef9 | 130 | if (IS_ERR(alg)) |
e231c2ee | 131 | return ERR_CAST(alg); |
db131ef9 HX |
132 | |
133 | inst = crypto_alloc_instance("ecb", alg); | |
134 | if (IS_ERR(inst)) | |
135 | goto out_put_alg; | |
136 | ||
137 | inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; | |
138 | inst->alg.cra_priority = alg->cra_priority; | |
139 | inst->alg.cra_blocksize = alg->cra_blocksize; | |
140 | inst->alg.cra_alignmask = alg->cra_alignmask; | |
141 | inst->alg.cra_type = &crypto_blkcipher_type; | |
142 | ||
143 | inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; | |
144 | inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; | |
145 | ||
146 | inst->alg.cra_ctxsize = sizeof(struct crypto_ecb_ctx); | |
147 | ||
148 | inst->alg.cra_init = crypto_ecb_init_tfm; | |
149 | inst->alg.cra_exit = crypto_ecb_exit_tfm; | |
150 | ||
151 | inst->alg.cra_blkcipher.setkey = crypto_ecb_setkey; | |
152 | inst->alg.cra_blkcipher.encrypt = crypto_ecb_encrypt; | |
153 | inst->alg.cra_blkcipher.decrypt = crypto_ecb_decrypt; | |
154 | ||
155 | out_put_alg: | |
156 | crypto_mod_put(alg); | |
157 | return inst; | |
158 | } | |
159 | ||
160 | static void crypto_ecb_free(struct crypto_instance *inst) | |
161 | { | |
162 | crypto_drop_spawn(crypto_instance_ctx(inst)); | |
163 | kfree(inst); | |
164 | } | |
165 | ||
166 | static struct crypto_template crypto_ecb_tmpl = { | |
167 | .name = "ecb", | |
168 | .alloc = crypto_ecb_alloc, | |
169 | .free = crypto_ecb_free, | |
170 | .module = THIS_MODULE, | |
171 | }; | |
172 | ||
173 | static int __init crypto_ecb_module_init(void) | |
174 | { | |
175 | return crypto_register_template(&crypto_ecb_tmpl); | |
176 | } | |
177 | ||
178 | static void __exit crypto_ecb_module_exit(void) | |
179 | { | |
180 | crypto_unregister_template(&crypto_ecb_tmpl); | |
181 | } | |
182 | ||
183 | module_init(crypto_ecb_module_init); | |
184 | module_exit(crypto_ecb_module_exit); | |
185 | ||
186 | MODULE_LICENSE("GPL"); | |
187 | MODULE_DESCRIPTION("ECB block cipher algorithm"); | |
4943ba16 | 188 | MODULE_ALIAS_CRYPTO("ecb"); |