1
2 #include <linux/ceph/ceph_debug.h>
3
4 #include <linux/err.h>
5 #include <linux/scatterlist.h>
6 #include <linux/slab.h>
7 #include <crypto/hash.h>
8 #include <linux/key-type.h>
9
10 #include <keys/ceph-type.h>
11 #include <linux/ceph/decode.h>
12 #include "crypto.h"
13
ceph_crypto_key_clone(struct ceph_crypto_key * dst,const struct ceph_crypto_key * src)14 int ceph_crypto_key_clone(struct ceph_crypto_key *dst,
15 const struct ceph_crypto_key *src)
16 {
17 memcpy(dst, src, sizeof(struct ceph_crypto_key));
18 dst->key = kmalloc(src->len, GFP_NOFS);
19 if (!dst->key)
20 return -ENOMEM;
21 memcpy(dst->key, src->key, src->len);
22 return 0;
23 }
24
ceph_crypto_key_encode(struct ceph_crypto_key * key,void ** p,void * end)25 int ceph_crypto_key_encode(struct ceph_crypto_key *key, void **p, void *end)
26 {
27 if (*p + sizeof(u16) + sizeof(key->created) +
28 sizeof(u16) + key->len > end)
29 return -ERANGE;
30 ceph_encode_16(p, key->type);
31 ceph_encode_copy(p, &key->created, sizeof(key->created));
32 ceph_encode_16(p, key->len);
33 ceph_encode_copy(p, key->key, key->len);
34 return 0;
35 }
36
ceph_crypto_key_decode(struct ceph_crypto_key * key,void ** p,void * end)37 int ceph_crypto_key_decode(struct ceph_crypto_key *key, void **p, void *end)
38 {
39 ceph_decode_need(p, end, 2*sizeof(u16) + sizeof(key->created), bad);
40 key->type = ceph_decode_16(p);
41 ceph_decode_copy(p, &key->created, sizeof(key->created));
42 key->len = ceph_decode_16(p);
43 ceph_decode_need(p, end, key->len, bad);
44 key->key = kmalloc(key->len, GFP_NOFS);
45 if (!key->key)
46 return -ENOMEM;
47 ceph_decode_copy(p, key->key, key->len);
48 return 0;
49
50 bad:
51 dout("failed to decode crypto key\n");
52 return -EINVAL;
53 }
54
ceph_crypto_key_unarmor(struct ceph_crypto_key * key,const char * inkey)55 int ceph_crypto_key_unarmor(struct ceph_crypto_key *key, const char *inkey)
56 {
57 int inlen = strlen(inkey);
58 int blen = inlen * 3 / 4;
59 void *buf, *p;
60 int ret;
61
62 dout("crypto_key_unarmor %s\n", inkey);
63 buf = kmalloc(blen, GFP_NOFS);
64 if (!buf)
65 return -ENOMEM;
66 blen = ceph_unarmor(buf, inkey, inkey+inlen);
67 if (blen < 0) {
68 kfree(buf);
69 return blen;
70 }
71
72 p = buf;
73 ret = ceph_crypto_key_decode(key, &p, p + blen);
74 kfree(buf);
75 if (ret)
76 return ret;
77 dout("crypto_key_unarmor key %p type %d len %d\n", key,
78 key->type, key->len);
79 return 0;
80 }
81
82
83
84 #define AES_KEY_SIZE 16
85
ceph_crypto_alloc_cipher(void)86 static struct crypto_blkcipher *ceph_crypto_alloc_cipher(void)
87 {
88 return crypto_alloc_blkcipher("cbc(aes)", 0, CRYPTO_ALG_ASYNC);
89 }
90
91 static const u8 *aes_iv = (u8 *)CEPH_AES_IV;
92
ceph_aes_encrypt(const void * key,int key_len,void * dst,size_t * dst_len,const void * src,size_t src_len)93 static int ceph_aes_encrypt(const void *key, int key_len,
94 void *dst, size_t *dst_len,
95 const void *src, size_t src_len)
96 {
97 struct scatterlist sg_in[2], sg_out[1];
98 struct crypto_blkcipher *tfm = ceph_crypto_alloc_cipher();
99 struct blkcipher_desc desc = { .tfm = tfm, .flags = 0 };
100 int ret;
101 void *iv;
102 int ivsize;
103 size_t zero_padding = (0x10 - (src_len & 0x0f));
104 char pad[16];
105
106 if (IS_ERR(tfm))
107 return PTR_ERR(tfm);
108
109 memset(pad, zero_padding, zero_padding);
110
111 *dst_len = src_len + zero_padding;
112
113 crypto_blkcipher_setkey((void *)tfm, key, key_len);
114 sg_init_table(sg_in, 2);
115 sg_set_buf(&sg_in[0], src, src_len);
116 sg_set_buf(&sg_in[1], pad, zero_padding);
117 sg_init_table(sg_out, 1);
118 sg_set_buf(sg_out, dst, *dst_len);
119 iv = crypto_blkcipher_crt(tfm)->iv;
120 ivsize = crypto_blkcipher_ivsize(tfm);
121
122 memcpy(iv, aes_iv, ivsize);
123 /*
124 print_hex_dump(KERN_ERR, "enc key: ", DUMP_PREFIX_NONE, 16, 1,
125 key, key_len, 1);
126 print_hex_dump(KERN_ERR, "enc src: ", DUMP_PREFIX_NONE, 16, 1,
127 src, src_len, 1);
128 print_hex_dump(KERN_ERR, "enc pad: ", DUMP_PREFIX_NONE, 16, 1,
129 pad, zero_padding, 1);
130 */
131 ret = crypto_blkcipher_encrypt(&desc, sg_out, sg_in,
132 src_len + zero_padding);
133 crypto_free_blkcipher(tfm);
134 if (ret < 0)
135 pr_err("ceph_aes_crypt failed %d\n", ret);
136 /*
137 print_hex_dump(KERN_ERR, "enc out: ", DUMP_PREFIX_NONE, 16, 1,
138 dst, *dst_len, 1);
139 */
140 return 0;
141 }
142
ceph_aes_encrypt2(const void * key,int key_len,void * dst,size_t * dst_len,const void * src1,size_t src1_len,const void * src2,size_t src2_len)143 static int ceph_aes_encrypt2(const void *key, int key_len, void *dst,
144 size_t *dst_len,
145 const void *src1, size_t src1_len,
146 const void *src2, size_t src2_len)
147 {
148 struct scatterlist sg_in[3], sg_out[1];
149 struct crypto_blkcipher *tfm = ceph_crypto_alloc_cipher();
150 struct blkcipher_desc desc = { .tfm = tfm, .flags = 0 };
151 int ret;
152 void *iv;
153 int ivsize;
154 size_t zero_padding = (0x10 - ((src1_len + src2_len) & 0x0f));
155 char pad[16];
156
157 if (IS_ERR(tfm))
158 return PTR_ERR(tfm);
159
160 memset(pad, zero_padding, zero_padding);
161
162 *dst_len = src1_len + src2_len + zero_padding;
163
164 crypto_blkcipher_setkey((void *)tfm, key, key_len);
165 sg_init_table(sg_in, 3);
166 sg_set_buf(&sg_in[0], src1, src1_len);
167 sg_set_buf(&sg_in[1], src2, src2_len);
168 sg_set_buf(&sg_in[2], pad, zero_padding);
169 sg_init_table(sg_out, 1);
170 sg_set_buf(sg_out, dst, *dst_len);
171 iv = crypto_blkcipher_crt(tfm)->iv;
172 ivsize = crypto_blkcipher_ivsize(tfm);
173
174 memcpy(iv, aes_iv, ivsize);
175 /*
176 print_hex_dump(KERN_ERR, "enc key: ", DUMP_PREFIX_NONE, 16, 1,
177 key, key_len, 1);
178 print_hex_dump(KERN_ERR, "enc src1: ", DUMP_PREFIX_NONE, 16, 1,
179 src1, src1_len, 1);
180 print_hex_dump(KERN_ERR, "enc src2: ", DUMP_PREFIX_NONE, 16, 1,
181 src2, src2_len, 1);
182 print_hex_dump(KERN_ERR, "enc pad: ", DUMP_PREFIX_NONE, 16, 1,
183 pad, zero_padding, 1);
184 */
185 ret = crypto_blkcipher_encrypt(&desc, sg_out, sg_in,
186 src1_len + src2_len + zero_padding);
187 crypto_free_blkcipher(tfm);
188 if (ret < 0)
189 pr_err("ceph_aes_crypt2 failed %d\n", ret);
190 /*
191 print_hex_dump(KERN_ERR, "enc out: ", DUMP_PREFIX_NONE, 16, 1,
192 dst, *dst_len, 1);
193 */
194 return 0;
195 }
196
ceph_aes_decrypt(const void * key,int key_len,void * dst,size_t * dst_len,const void * src,size_t src_len)197 static int ceph_aes_decrypt(const void *key, int key_len,
198 void *dst, size_t *dst_len,
199 const void *src, size_t src_len)
200 {
201 struct scatterlist sg_in[1], sg_out[2];
202 struct crypto_blkcipher *tfm = ceph_crypto_alloc_cipher();
203 struct blkcipher_desc desc = { .tfm = tfm };
204 char pad[16];
205 void *iv;
206 int ivsize;
207 int ret;
208 int last_byte;
209
210 if (IS_ERR(tfm))
211 return PTR_ERR(tfm);
212
213 crypto_blkcipher_setkey((void *)tfm, key, key_len);
214 sg_init_table(sg_in, 1);
215 sg_init_table(sg_out, 2);
216 sg_set_buf(sg_in, src, src_len);
217 sg_set_buf(&sg_out[0], dst, *dst_len);
218 sg_set_buf(&sg_out[1], pad, sizeof(pad));
219
220 iv = crypto_blkcipher_crt(tfm)->iv;
221 ivsize = crypto_blkcipher_ivsize(tfm);
222
223 memcpy(iv, aes_iv, ivsize);
224
225 /*
226 print_hex_dump(KERN_ERR, "dec key: ", DUMP_PREFIX_NONE, 16, 1,
227 key, key_len, 1);
228 print_hex_dump(KERN_ERR, "dec in: ", DUMP_PREFIX_NONE, 16, 1,
229 src, src_len, 1);
230 */
231
232 ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, src_len);
233 crypto_free_blkcipher(tfm);
234 if (ret < 0) {
235 pr_err("ceph_aes_decrypt failed %d\n", ret);
236 return ret;
237 }
238
239 if (src_len <= *dst_len)
240 last_byte = ((char *)dst)[src_len - 1];
241 else
242 last_byte = pad[src_len - *dst_len - 1];
243 if (last_byte <= 16 && src_len >= last_byte) {
244 *dst_len = src_len - last_byte;
245 } else {
246 pr_err("ceph_aes_decrypt got bad padding %d on src len %d\n",
247 last_byte, (int)src_len);
248 return -EPERM; /* bad padding */
249 }
250 /*
251 print_hex_dump(KERN_ERR, "dec out: ", DUMP_PREFIX_NONE, 16, 1,
252 dst, *dst_len, 1);
253 */
254 return 0;
255 }
256
ceph_aes_decrypt2(const void * key,int key_len,void * dst1,size_t * dst1_len,void * dst2,size_t * dst2_len,const void * src,size_t src_len)257 static int ceph_aes_decrypt2(const void *key, int key_len,
258 void *dst1, size_t *dst1_len,
259 void *dst2, size_t *dst2_len,
260 const void *src, size_t src_len)
261 {
262 struct scatterlist sg_in[1], sg_out[3];
263 struct crypto_blkcipher *tfm = ceph_crypto_alloc_cipher();
264 struct blkcipher_desc desc = { .tfm = tfm };
265 char pad[16];
266 void *iv;
267 int ivsize;
268 int ret;
269 int last_byte;
270
271 if (IS_ERR(tfm))
272 return PTR_ERR(tfm);
273
274 sg_init_table(sg_in, 1);
275 sg_set_buf(sg_in, src, src_len);
276 sg_init_table(sg_out, 3);
277 sg_set_buf(&sg_out[0], dst1, *dst1_len);
278 sg_set_buf(&sg_out[1], dst2, *dst2_len);
279 sg_set_buf(&sg_out[2], pad, sizeof(pad));
280
281 crypto_blkcipher_setkey((void *)tfm, key, key_len);
282 iv = crypto_blkcipher_crt(tfm)->iv;
283 ivsize = crypto_blkcipher_ivsize(tfm);
284
285 memcpy(iv, aes_iv, ivsize);
286
287 /*
288 print_hex_dump(KERN_ERR, "dec key: ", DUMP_PREFIX_NONE, 16, 1,
289 key, key_len, 1);
290 print_hex_dump(KERN_ERR, "dec in: ", DUMP_PREFIX_NONE, 16, 1,
291 src, src_len, 1);
292 */
293
294 ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, src_len);
295 crypto_free_blkcipher(tfm);
296 if (ret < 0) {
297 pr_err("ceph_aes_decrypt failed %d\n", ret);
298 return ret;
299 }
300
301 if (src_len <= *dst1_len)
302 last_byte = ((char *)dst1)[src_len - 1];
303 else if (src_len <= *dst1_len + *dst2_len)
304 last_byte = ((char *)dst2)[src_len - *dst1_len - 1];
305 else
306 last_byte = pad[src_len - *dst1_len - *dst2_len - 1];
307 if (last_byte <= 16 && src_len >= last_byte) {
308 src_len -= last_byte;
309 } else {
310 pr_err("ceph_aes_decrypt got bad padding %d on src len %d\n",
311 last_byte, (int)src_len);
312 return -EPERM; /* bad padding */
313 }
314
315 if (src_len < *dst1_len) {
316 *dst1_len = src_len;
317 *dst2_len = 0;
318 } else {
319 *dst2_len = src_len - *dst1_len;
320 }
321 /*
322 print_hex_dump(KERN_ERR, "dec out1: ", DUMP_PREFIX_NONE, 16, 1,
323 dst1, *dst1_len, 1);
324 print_hex_dump(KERN_ERR, "dec out2: ", DUMP_PREFIX_NONE, 16, 1,
325 dst2, *dst2_len, 1);
326 */
327
328 return 0;
329 }
330
331
ceph_decrypt(struct ceph_crypto_key * secret,void * dst,size_t * dst_len,const void * src,size_t src_len)332 int ceph_decrypt(struct ceph_crypto_key *secret, void *dst, size_t *dst_len,
333 const void *src, size_t src_len)
334 {
335 switch (secret->type) {
336 case CEPH_CRYPTO_NONE:
337 if (*dst_len < src_len)
338 return -ERANGE;
339 memcpy(dst, src, src_len);
340 *dst_len = src_len;
341 return 0;
342
343 case CEPH_CRYPTO_AES:
344 return ceph_aes_decrypt(secret->key, secret->len, dst,
345 dst_len, src, src_len);
346
347 default:
348 return -EINVAL;
349 }
350 }
351
ceph_decrypt2(struct ceph_crypto_key * secret,void * dst1,size_t * dst1_len,void * dst2,size_t * dst2_len,const void * src,size_t src_len)352 int ceph_decrypt2(struct ceph_crypto_key *secret,
353 void *dst1, size_t *dst1_len,
354 void *dst2, size_t *dst2_len,
355 const void *src, size_t src_len)
356 {
357 size_t t;
358
359 switch (secret->type) {
360 case CEPH_CRYPTO_NONE:
361 if (*dst1_len + *dst2_len < src_len)
362 return -ERANGE;
363 t = min(*dst1_len, src_len);
364 memcpy(dst1, src, t);
365 *dst1_len = t;
366 src += t;
367 src_len -= t;
368 if (src_len) {
369 t = min(*dst2_len, src_len);
370 memcpy(dst2, src, t);
371 *dst2_len = t;
372 }
373 return 0;
374
375 case CEPH_CRYPTO_AES:
376 return ceph_aes_decrypt2(secret->key, secret->len,
377 dst1, dst1_len, dst2, dst2_len,
378 src, src_len);
379
380 default:
381 return -EINVAL;
382 }
383 }
384
ceph_encrypt(struct ceph_crypto_key * secret,void * dst,size_t * dst_len,const void * src,size_t src_len)385 int ceph_encrypt(struct ceph_crypto_key *secret, void *dst, size_t *dst_len,
386 const void *src, size_t src_len)
387 {
388 switch (secret->type) {
389 case CEPH_CRYPTO_NONE:
390 if (*dst_len < src_len)
391 return -ERANGE;
392 memcpy(dst, src, src_len);
393 *dst_len = src_len;
394 return 0;
395
396 case CEPH_CRYPTO_AES:
397 return ceph_aes_encrypt(secret->key, secret->len, dst,
398 dst_len, src, src_len);
399
400 default:
401 return -EINVAL;
402 }
403 }
404
ceph_encrypt2(struct ceph_crypto_key * secret,void * dst,size_t * dst_len,const void * src1,size_t src1_len,const void * src2,size_t src2_len)405 int ceph_encrypt2(struct ceph_crypto_key *secret, void *dst, size_t *dst_len,
406 const void *src1, size_t src1_len,
407 const void *src2, size_t src2_len)
408 {
409 switch (secret->type) {
410 case CEPH_CRYPTO_NONE:
411 if (*dst_len < src1_len + src2_len)
412 return -ERANGE;
413 memcpy(dst, src1, src1_len);
414 memcpy(dst + src1_len, src2, src2_len);
415 *dst_len = src1_len + src2_len;
416 return 0;
417
418 case CEPH_CRYPTO_AES:
419 return ceph_aes_encrypt2(secret->key, secret->len, dst, dst_len,
420 src1, src1_len, src2, src2_len);
421
422 default:
423 return -EINVAL;
424 }
425 }
426
ceph_key_instantiate(struct key * key,const void * data,size_t datalen)427 int ceph_key_instantiate(struct key *key, const void *data, size_t datalen)
428 {
429 struct ceph_crypto_key *ckey;
430 int ret;
431 void *p;
432
433 ret = -EINVAL;
434 if (datalen <= 0 || datalen > 32767 || !data)
435 goto err;
436
437 ret = key_payload_reserve(key, datalen);
438 if (ret < 0)
439 goto err;
440
441 ret = -ENOMEM;
442 ckey = kmalloc(sizeof(*ckey), GFP_KERNEL);
443 if (!ckey)
444 goto err;
445
446 /* TODO ceph_crypto_key_decode should really take const input */
447 p = (void*)data;
448 ret = ceph_crypto_key_decode(ckey, &p, (char*)data+datalen);
449 if (ret < 0)
450 goto err_ckey;
451
452 key->payload.data = ckey;
453 return 0;
454
455 err_ckey:
456 kfree(ckey);
457 err:
458 return ret;
459 }
460
ceph_key_match(const struct key * key,const void * description)461 int ceph_key_match(const struct key *key, const void *description)
462 {
463 return strcmp(key->description, description) == 0;
464 }
465
ceph_key_destroy(struct key * key)466 void ceph_key_destroy(struct key *key) {
467 struct ceph_crypto_key *ckey = key->payload.data;
468
469 ceph_crypto_key_destroy(ckey);
470 }
471
472 struct key_type key_type_ceph = {
473 .name = "ceph",
474 .instantiate = ceph_key_instantiate,
475 .match = ceph_key_match,
476 .destroy = ceph_key_destroy,
477 };
478
ceph_crypto_init(void)479 int ceph_crypto_init(void) {
480 return register_key_type(&key_type_ceph);
481 }
482
ceph_crypto_shutdown(void)483 void ceph_crypto_shutdown(void) {
484 unregister_key_type(&key_type_ceph);
485 }
486