]>
Commit | Line | Data |
---|---|---|
0a270321 HX |
1 | /* |
2 | * seqiv: Sequence Number IV Generator | |
3 | * | |
4 | * This generator generates an IV based on a sequence number by xoring it | |
5 | * with a salt. This algorithm is mainly useful for CTR and similar modes. | |
6 | * | |
7 | * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify it | |
10 | * under the terms of the GNU General Public License as published by the Free | |
11 | * Software Foundation; either version 2 of the License, or (at your option) | |
12 | * any later version. | |
13 | * | |
14 | */ | |
15 | ||
661cfd0e | 16 | #include <crypto/internal/geniv.h> |
856e3f40 | 17 | #include <crypto/scatterwalk.h> |
3a01d0ee | 18 | #include <crypto/skcipher.h> |
0a270321 HX |
19 | #include <linux/err.h> |
20 | #include <linux/init.h> | |
21 | #include <linux/kernel.h> | |
22 | #include <linux/module.h> | |
5a0e3ad6 | 23 | #include <linux/slab.h> |
0a270321 HX |
24 | #include <linux/string.h> |
25 | ||
0677157b HX |
26 | static void seqiv_free(struct crypto_instance *inst); |
27 | ||
856e3f40 HX |
28 | static void seqiv_aead_encrypt_complete2(struct aead_request *req, int err) |
29 | { | |
30 | struct aead_request *subreq = aead_request_ctx(req); | |
31 | struct crypto_aead *geniv; | |
32 | ||
33 | if (err == -EINPROGRESS) | |
34 | return; | |
35 | ||
36 | if (err) | |
37 | goto out; | |
38 | ||
39 | geniv = crypto_aead_reqtfm(req); | |
40 | memcpy(req->iv, subreq->iv, crypto_aead_ivsize(geniv)); | |
41 | ||
42 | out: | |
43 | kzfree(subreq->iv); | |
44 | } | |
45 | ||
46 | static void seqiv_aead_encrypt_complete(struct crypto_async_request *base, | |
47 | int err) | |
48 | { | |
49 | struct aead_request *req = base->data; | |
50 | ||
51 | seqiv_aead_encrypt_complete2(req, err); | |
52 | aead_request_complete(req, err); | |
53 | } | |
54 | ||
856e3f40 HX |
55 | static int seqiv_aead_encrypt(struct aead_request *req) |
56 | { | |
57 | struct crypto_aead *geniv = crypto_aead_reqtfm(req); | |
659e7f52 | 58 | struct aead_geniv_ctx *ctx = crypto_aead_ctx(geniv); |
856e3f40 HX |
59 | struct aead_request *subreq = aead_request_ctx(req); |
60 | crypto_completion_t compl; | |
61 | void *data; | |
62 | u8 *info; | |
dd04446e | 63 | unsigned int ivsize = 8; |
856e3f40 HX |
64 | int err; |
65 | ||
dd04446e HX |
66 | if (req->cryptlen < ivsize) |
67 | return -EINVAL; | |
68 | ||
659e7f52 | 69 | aead_request_set_tfm(subreq, ctx->child); |
856e3f40 HX |
70 | |
71 | compl = req->base.complete; | |
72 | data = req->base.data; | |
73 | info = req->iv; | |
74 | ||
856e3f40 | 75 | if (req->src != req->dst) { |
8d605398 | 76 | SYNC_SKCIPHER_REQUEST_ON_STACK(nreq, ctx->sknull); |
856e3f40 | 77 | |
8d605398 | 78 | skcipher_request_set_sync_tfm(nreq, ctx->sknull); |
ef22871f HX |
79 | skcipher_request_set_callback(nreq, req->base.flags, |
80 | NULL, NULL); | |
81 | skcipher_request_set_crypt(nreq, req->src, req->dst, | |
82 | req->assoclen + req->cryptlen, | |
83 | NULL); | |
84 | ||
85 | err = crypto_skcipher_encrypt(nreq); | |
856e3f40 HX |
86 | if (err) |
87 | return err; | |
88 | } | |
89 | ||
90 | if (unlikely(!IS_ALIGNED((unsigned long)info, | |
91 | crypto_aead_alignmask(geniv) + 1))) { | |
7e33d4d4 Y |
92 | info = kmemdup(req->iv, ivsize, req->base.flags & |
93 | CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL : | |
94 | GFP_ATOMIC); | |
856e3f40 HX |
95 | if (!info) |
96 | return -ENOMEM; | |
97 | ||
856e3f40 HX |
98 | compl = seqiv_aead_encrypt_complete; |
99 | data = req; | |
100 | } | |
101 | ||
102 | aead_request_set_callback(subreq, req->base.flags, compl, data); | |
103 | aead_request_set_crypt(subreq, req->dst, req->dst, | |
104 | req->cryptlen - ivsize, info); | |
374d4ad1 | 105 | aead_request_set_ad(subreq, req->assoclen + ivsize); |
856e3f40 HX |
106 | |
107 | crypto_xor(info, ctx->salt, ivsize); | |
108 | scatterwalk_map_and_copy(info, req->dst, req->assoclen, ivsize, 1); | |
109 | ||
110 | err = crypto_aead_encrypt(subreq); | |
111 | if (unlikely(info != req->iv)) | |
112 | seqiv_aead_encrypt_complete2(req, err); | |
113 | return err; | |
114 | } | |
115 | ||
856e3f40 HX |
116 | static int seqiv_aead_decrypt(struct aead_request *req) |
117 | { | |
118 | struct crypto_aead *geniv = crypto_aead_reqtfm(req); | |
659e7f52 | 119 | struct aead_geniv_ctx *ctx = crypto_aead_ctx(geniv); |
856e3f40 HX |
120 | struct aead_request *subreq = aead_request_ctx(req); |
121 | crypto_completion_t compl; | |
122 | void *data; | |
dd04446e HX |
123 | unsigned int ivsize = 8; |
124 | ||
125 | if (req->cryptlen < ivsize + crypto_aead_authsize(geniv)) | |
126 | return -EINVAL; | |
856e3f40 | 127 | |
659e7f52 | 128 | aead_request_set_tfm(subreq, ctx->child); |
856e3f40 HX |
129 | |
130 | compl = req->base.complete; | |
131 | data = req->base.data; | |
132 | ||
856e3f40 HX |
133 | aead_request_set_callback(subreq, req->base.flags, compl, data); |
134 | aead_request_set_crypt(subreq, req->src, req->dst, | |
135 | req->cryptlen - ivsize, req->iv); | |
374d4ad1 | 136 | aead_request_set_ad(subreq, req->assoclen + ivsize); |
856e3f40 HX |
137 | |
138 | scatterwalk_map_and_copy(req->iv, req->src, req->assoclen, ivsize, 0); | |
856e3f40 HX |
139 | |
140 | return crypto_aead_decrypt(subreq); | |
141 | } | |
142 | ||
0677157b | 143 | static int seqiv_aead_create(struct crypto_template *tmpl, struct rtattr **tb) |
14df4d80 | 144 | { |
856e3f40 | 145 | struct aead_instance *inst; |
0677157b | 146 | int err; |
14df4d80 | 147 | |
0677157b | 148 | inst = aead_geniv_alloc(tmpl, tb, 0, 0); |
14df4d80 HX |
149 | |
150 | if (IS_ERR(inst)) | |
0677157b HX |
151 | return PTR_ERR(inst); |
152 | ||
0677157b | 153 | err = -EINVAL; |
dd04446e | 154 | if (inst->alg.ivsize != sizeof(u64)) |
0677157b | 155 | goto free_inst; |
c0ecf891 | 156 | |
b7dcfab4 | 157 | inst->alg.encrypt = seqiv_aead_encrypt; |
856e3f40 | 158 | inst->alg.decrypt = seqiv_aead_decrypt; |
14df4d80 | 159 | |
659e7f52 HX |
160 | inst->alg.init = aead_init_geniv; |
161 | inst->alg.exit = aead_exit_geniv; | |
856e3f40 | 162 | |
659e7f52 | 163 | inst->alg.base.cra_ctxsize = sizeof(struct aead_geniv_ctx); |
5964f26c | 164 | inst->alg.base.cra_ctxsize += inst->alg.ivsize; |
856e3f40 | 165 | |
0677157b HX |
166 | err = aead_register_instance(tmpl, inst); |
167 | if (err) | |
168 | goto free_inst; | |
169 | ||
14df4d80 | 170 | out: |
0677157b HX |
171 | return err; |
172 | ||
173 | free_inst: | |
174 | aead_geniv_free(inst); | |
175 | goto out; | |
14df4d80 HX |
176 | } |
177 | ||
0677157b | 178 | static int seqiv_create(struct crypto_template *tmpl, struct rtattr **tb) |
14df4d80 HX |
179 | { |
180 | struct crypto_attr_type *algt; | |
14df4d80 HX |
181 | |
182 | algt = crypto_get_attr_type(tb); | |
14df4d80 | 183 | if (IS_ERR(algt)) |
0677157b | 184 | return PTR_ERR(algt); |
14df4d80 HX |
185 | |
186 | if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK) | |
3a01d0ee | 187 | return -EINVAL; |
14df4d80 | 188 | |
3a01d0ee | 189 | return seqiv_aead_create(tmpl, tb); |
14df4d80 HX |
190 | } |
191 | ||
192 | static void seqiv_free(struct crypto_instance *inst) | |
193 | { | |
3a01d0ee | 194 | aead_geniv_free(aead_instance(inst)); |
14df4d80 HX |
195 | } |
196 | ||
0a270321 HX |
197 | static struct crypto_template seqiv_tmpl = { |
198 | .name = "seqiv", | |
0677157b | 199 | .create = seqiv_create, |
14df4d80 | 200 | .free = seqiv_free, |
0a270321 HX |
201 | .module = THIS_MODULE, |
202 | }; | |
203 | ||
204 | static int __init seqiv_module_init(void) | |
205 | { | |
8a2cd1c4 | 206 | return crypto_register_template(&seqiv_tmpl); |
0a270321 HX |
207 | } |
208 | ||
209 | static void __exit seqiv_module_exit(void) | |
210 | { | |
211 | crypto_unregister_template(&seqiv_tmpl); | |
212 | } | |
213 | ||
214 | module_init(seqiv_module_init); | |
215 | module_exit(seqiv_module_exit); | |
216 | ||
217 | MODULE_LICENSE("GPL"); | |
218 | MODULE_DESCRIPTION("Sequence Number IV Generator"); | |
4943ba16 | 219 | MODULE_ALIAS_CRYPTO("seqiv"); |