net/ceph/crypto.c

   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
  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
  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
  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
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 461 int ceph_key_match(const struct key *key, const void *description)
 462 {
 463         return strcmp(key->description, description) == 0;
 464 }
 465
 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
 479 int ceph_crypto_init(void) {
 480         return register_key_type(&key_type_ceph);
 481 }
 482
 483 void ceph_crypto_shutdown(void) {
 484         unregister_key_type(&key_type_ceph);
 485 }