SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/ecryptfs/keystore.c

   1 /**
   2  * eCryptfs: Linux filesystem encryption layer
   3  * In-kernel key management code.  Includes functions to parse and
   4  * write authentication token-related packets with the underlying
   5  * file.
   6  *
   7  * Copyright (C) 2004-2006 International Business Machines Corp.
   8  *   Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
   9  *              Michael C. Thompson <mcthomps@us.ibm.com>
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License as
  13  * published by the Free Software Foundation; either version 2 of the
  14  * License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  24  * 02111-1307, USA.
  25  */
  26
  27 #include <linux/string.h>
  28 #include <linux/sched.h>
  29 #include <linux/syscalls.h>
  30 #include <linux/pagemap.h>
  31 #include <linux/key.h>
  32 #include <linux/random.h>
  33 #include <linux/crypto.h>
  34 #include <linux/scatterlist.h>
  35 #include "ecryptfs_kernel.h"
  36
  37 /**
  38  * request_key returned an error instead of a valid key address;
  39  * determine the type of error, make appropriate log entries, and
  40  * return an error code.
  41  */
  42 int process_request_key_err(long err_code)
  43 {
  44         int rc = 0;
  45
  46         switch (err_code) {
  47         case ENOKEY:
  48                 ecryptfs_printk(KERN_WARNING, "No key\n");
  49                 rc = -ENOENT;
  50                 break;
  51         case EKEYEXPIRED:
  52                 ecryptfs_printk(KERN_WARNING, "Key expired\n");
  53                 rc = -ETIME;
  54                 break;
  55         case EKEYREVOKED:
  56                 ecryptfs_printk(KERN_WARNING, "Key revoked\n");
  57                 rc = -EINVAL;
  58                 break;
  59         default:
  60                 ecryptfs_printk(KERN_WARNING, "Unknown error code: "
  61                                 "[0x%.16x]\n", err_code);
  62                 rc = -EINVAL;
  63         }
  64         return rc;
  65 }
  66
  67 static void wipe_auth_tok_list(struct list_head *auth_tok_list_head)
  68 {
  69         struct list_head *walker;
  70         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
  71
  72         walker = auth_tok_list_head->next;
  73         while (walker != auth_tok_list_head) {
  74                 auth_tok_list_item =
  75                     list_entry(walker, struct ecryptfs_auth_tok_list_item,
  76                                list);
  77                 walker = auth_tok_list_item->list.next;
  78                 memset(auth_tok_list_item, 0,
  79                        sizeof(struct ecryptfs_auth_tok_list_item));
  80                 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
  81                                 auth_tok_list_item);
  82         }
  83 }
  84
  85 struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
  86
  87 /**
  88  * parse_packet_length
  89  * @data: Pointer to memory containing length at offset
  90  * @size: This function writes the decoded size to this memory
  91  *        address; zero on error
  92  * @length_size: The number of bytes occupied by the encoded length
  93  *
  94  * Returns Zero on success
  95  */
  96 static int parse_packet_length(unsigned char *data, size_t *size,
  97                                size_t *length_size)
  98 {
  99         int rc = 0;
 100
 101         (*length_size) = 0;
 102         (*size) = 0;
 103         if (data[0] < 192) {
 104                 /* One-byte length */
 105                 (*size) = data[0];
 106                 (*length_size) = 1;
 107         } else if (data[0] < 224) {
 108                 /* Two-byte length */
 109                 (*size) = ((data[0] - 192) * 256);
 110                 (*size) += (data[1] + 192);
 111                 (*length_size) = 2;
 112         } else if (data[0] == 255) {
 113                 /* Five-byte length; we're not supposed to see this */
 114                 ecryptfs_printk(KERN_ERR, "Five-byte packet length not "
 115                                 "supported\n");
 116                 rc = -EINVAL;
 117                 goto out;
 118         } else {
 119                 ecryptfs_printk(KERN_ERR, "Error parsing packet length\n");
 120                 rc = -EINVAL;
 121                 goto out;
 122         }
 123 out:
 124         return rc;
 125 }
 126
 127 /**
 128  * write_packet_length
 129  * @dest: The byte array target into which to write the
 130  *       length. Must have at least 5 bytes allocated.
 131  * @size: The length to write.
 132  * @packet_size_length: The number of bytes used to encode the
 133  *                      packet length is written to this address.
 134  *
 135  * Returns zero on success; non-zero on error.
 136  */
 137 static int write_packet_length(char *dest, size_t size,
 138                                size_t *packet_size_length)
 139 {
 140         int rc = 0;
 141
 142         if (size < 192) {
 143                 dest[0] = size;
 144                 (*packet_size_length) = 1;
 145         } else if (size < 65536) {
 146                 dest[0] = (((size - 192) / 256) + 192);
 147                 dest[1] = ((size - 192) % 256);
 148                 (*packet_size_length) = 2;
 149         } else {
 150                 rc = -EINVAL;
 151                 ecryptfs_printk(KERN_WARNING,
 152                                 "Unsupported packet size: [%d]\n", size);
 153         }
 154         return rc;
 155 }
 156
 157 /**
 158  * parse_tag_3_packet
 159  * @crypt_stat: The cryptographic context to modify based on packet
 160  *              contents.
 161  * @data: The raw bytes of the packet.
 162  * @auth_tok_list: eCryptfs parses packets into authentication tokens;
 163  *                 a new authentication token will be placed at the end
 164  *                 of this list for this packet.
 165  * @new_auth_tok: Pointer to a pointer to memory that this function
 166  *                allocates; sets the memory address of the pointer to
 167  *                NULL on error. This object is added to the
 168  *                auth_tok_list.
 169  * @packet_size: This function writes the size of the parsed packet
 170  *               into this memory location; zero on error.
 171  * @max_packet_size: maximum number of bytes to parse
 172  *
 173  * Returns zero on success; non-zero on error.
 174  */
 175 static int
 176 parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
 177                    unsigned char *data, struct list_head *auth_tok_list,
 178                    struct ecryptfs_auth_tok **new_auth_tok,
 179                    size_t *packet_size, size_t max_packet_size)
 180 {
 181         int rc = 0;
 182         size_t body_size;
 183         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
 184         size_t length_size;
 185
 186         (*packet_size) = 0;
 187         (*new_auth_tok) = NULL;
 188
 189         /* we check that:
 190          *   one byte for the Tag 3 ID flag
 191          *   two bytes for the body size
 192          * do not exceed the maximum_packet_size
 193          */
 194         if (unlikely((*packet_size) + 3 > max_packet_size)) {
 195                 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
 196                 rc = -EINVAL;
 197                 goto out;
 198         }
 199
 200         /* check for Tag 3 identifyer - one byte */
 201         if (data[(*packet_size)++] != ECRYPTFS_TAG_3_PACKET_TYPE) {
 202                 ecryptfs_printk(KERN_ERR, "Enter w/ first byte != 0x%.2x\n",
 203                                 ECRYPTFS_TAG_3_PACKET_TYPE);
 204                 rc = -EINVAL;
 205                 goto out;
 206         }
 207         /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
 208          * at end of function upon failure */
 209         auth_tok_list_item =
 210             kmem_cache_alloc(ecryptfs_auth_tok_list_item_cache, SLAB_KERNEL);
 211         if (!auth_tok_list_item) {
 212                 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
 213                 rc = -ENOMEM;
 214                 goto out;
 215         }
 216         memset(auth_tok_list_item, 0,
 217                sizeof(struct ecryptfs_auth_tok_list_item));
 218         (*new_auth_tok) = &auth_tok_list_item->auth_tok;
 219
 220         /* check for body size - one to two bytes */
 221         rc = parse_packet_length(&data[(*packet_size)], &body_size,
 222                                  &length_size);
 223         if (rc) {
 224                 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
 225                                 "rc = [%d]\n", rc);
 226                 goto out_free;
 227         }
 228         if (unlikely(body_size < (0x05 + ECRYPTFS_SALT_SIZE))) {
 229                 ecryptfs_printk(KERN_WARNING, "Invalid body size ([%d])\n",
 230                                 body_size);
 231                 rc = -EINVAL;
 232                 goto out_free;
 233         }
 234         (*packet_size) += length_size;
 235
 236         /* now we know the length of the remainting Tag 3 packet size:
 237          *   5 fix bytes for: version string, cipher, S2K ID, hash algo,
 238          *                    number of hash iterations
 239          *   ECRYPTFS_SALT_SIZE bytes for salt
 240          *   body_size bytes minus the stuff above is the encrypted key size
 241          */
 242         if (unlikely((*packet_size) + body_size > max_packet_size)) {
 243                 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
 244                 rc = -EINVAL;
 245                 goto out_free;
 246         }
 247
 248         /* There are 5 characters of additional information in the
 249          * packet */
 250         (*new_auth_tok)->session_key.encrypted_key_size =
 251                 body_size - (0x05 + ECRYPTFS_SALT_SIZE);
 252         ecryptfs_printk(KERN_DEBUG, "Encrypted key size = [%d]\n",
 253                         (*new_auth_tok)->session_key.encrypted_key_size);
 254
 255         /* Version 4 (from RFC2440) - one byte */
 256         if (unlikely(data[(*packet_size)++] != 0x04)) {
 257                 ecryptfs_printk(KERN_DEBUG, "Unknown version number "
 258                                 "[%d]\n", data[(*packet_size) - 1]);
 259                 rc = -EINVAL;
 260                 goto out_free;
 261         }
 262
 263         /* cipher - one byte */
 264         ecryptfs_cipher_code_to_string(crypt_stat->cipher,
 265                                        (u16)data[(*packet_size)]);
 266         /* A little extra work to differentiate among the AES key
 267          * sizes; see RFC2440 */
 268         switch(data[(*packet_size)++]) {
 269         case RFC2440_CIPHER_AES_192:
 270                 crypt_stat->key_size = 24;
 271                 break;
 272         default:
 273                 crypt_stat->key_size =
 274                         (*new_auth_tok)->session_key.encrypted_key_size;
 275         }
 276         ecryptfs_init_crypt_ctx(crypt_stat);
 277         /* S2K identifier 3 (from RFC2440) */
 278         if (unlikely(data[(*packet_size)++] != 0x03)) {
 279                 ecryptfs_printk(KERN_ERR, "Only S2K ID 3 is currently "
 280                                 "supported\n");
 281                 rc = -ENOSYS;
 282                 goto out_free;
 283         }
 284
 285         /* TODO: finish the hash mapping */
 286         /* hash algorithm - one byte */
 287         switch (data[(*packet_size)++]) {
 288         case 0x01: /* See RFC2440 for these numbers and their mappings */
 289                 /* Choose MD5 */
 290                 /* salt - ECRYPTFS_SALT_SIZE bytes */
 291                 memcpy((*new_auth_tok)->token.password.salt,
 292                        &data[(*packet_size)], ECRYPTFS_SALT_SIZE);
 293                 (*packet_size) += ECRYPTFS_SALT_SIZE;
 294
 295                 /* This conversion was taken straight from RFC2440 */
 296                 /* number of hash iterations - one byte */
 297                 (*new_auth_tok)->token.password.hash_iterations =
 298                         ((u32) 16 + (data[(*packet_size)] & 15))
 299                                 << ((data[(*packet_size)] >> 4) + 6);
 300                 (*packet_size)++;
 301
 302                 /* encrypted session key -
 303                  *   (body_size-5-ECRYPTFS_SALT_SIZE) bytes */
 304                 memcpy((*new_auth_tok)->session_key.encrypted_key,
 305                        &data[(*packet_size)],
 306                        (*new_auth_tok)->session_key.encrypted_key_size);
 307                 (*packet_size) +=
 308                         (*new_auth_tok)->session_key.encrypted_key_size;
 309                 (*new_auth_tok)->session_key.flags &=
 310                         ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
 311                 (*new_auth_tok)->session_key.flags |=
 312                         ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
 313                 (*new_auth_tok)->token.password.hash_algo = 0x01;
 314                 break;
 315         default:
 316                 ecryptfs_printk(KERN_ERR, "Unsupported hash algorithm: "
 317                                 "[%d]\n", data[(*packet_size) - 1]);
 318                 rc = -ENOSYS;
 319                 goto out_free;
 320         }
 321         (*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;
 322         /* TODO: Parametarize; we might actually want userspace to
 323          * decrypt the session key. */
 324         ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
 325                             ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
 326         ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
 327                             ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
 328         list_add(&auth_tok_list_item->list, auth_tok_list);
 329         goto out;
 330 out_free:
 331         (*new_auth_tok) = NULL;
 332         memset(auth_tok_list_item, 0,
 333                sizeof(struct ecryptfs_auth_tok_list_item));
 334         kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
 335                         auth_tok_list_item);
 336 out:
 337         if (rc)
 338                 (*packet_size) = 0;
 339         return rc;
 340 }
 341
 342 /**
 343  * parse_tag_11_packet
 344  * @data: The raw bytes of the packet
 345  * @contents: This function writes the data contents of the literal
 346  *            packet into this memory location
 347  * @max_contents_bytes: The maximum number of bytes that this function
 348  *                      is allowed to write into contents
 349  * @tag_11_contents_size: This function writes the size of the parsed
 350  *                        contents into this memory location; zero on
 351  *                        error
 352  * @packet_size: This function writes the size of the parsed packet
 353  *               into this memory location; zero on error
 354  * @max_packet_size: maximum number of bytes to parse
 355  *
 356  * Returns zero on success; non-zero on error.
 357  */
 358 static int
 359 parse_tag_11_packet(unsigned char *data, unsigned char *contents,
 360                     size_t max_contents_bytes, size_t *tag_11_contents_size,
 361                     size_t *packet_size, size_t max_packet_size)
 362 {
 363         int rc = 0;
 364         size_t body_size;
 365         size_t length_size;
 366
 367         (*packet_size) = 0;
 368         (*tag_11_contents_size) = 0;
 369
 370         /* check that:
 371          *   one byte for the Tag 11 ID flag
 372          *   two bytes for the Tag 11 length
 373          * do not exceed the maximum_packet_size
 374          */
 375         if (unlikely((*packet_size) + 3 > max_packet_size)) {
 376                 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
 377                 rc = -EINVAL;
 378                 goto out;
 379         }
 380
 381         /* check for Tag 11 identifyer - one byte */
 382         if (data[(*packet_size)++] != ECRYPTFS_TAG_11_PACKET_TYPE) {
 383                 ecryptfs_printk(KERN_WARNING,
 384                                 "Invalid tag 11 packet format\n");
 385                 rc = -EINVAL;
 386                 goto out;
 387         }
 388
 389         /* get Tag 11 content length - one or two bytes */
 390         rc = parse_packet_length(&data[(*packet_size)], &body_size,
 391                                  &length_size);
 392         if (rc) {
 393                 ecryptfs_printk(KERN_WARNING,
 394                                 "Invalid tag 11 packet format\n");
 395                 goto out;
 396         }
 397         (*packet_size) += length_size;
 398
 399         if (body_size < 13) {
 400                 ecryptfs_printk(KERN_WARNING, "Invalid body size ([%d])\n",
 401                                 body_size);
 402                 rc = -EINVAL;
 403                 goto out;
 404         }
 405         /* We have 13 bytes of surrounding packet values */
 406         (*tag_11_contents_size) = (body_size - 13);
 407
 408         /* now we know the length of the remainting Tag 11 packet size:
 409          *   14 fix bytes for: special flag one, special flag two,
 410          *                     12 skipped bytes
 411          *   body_size bytes minus the stuff above is the Tag 11 content
 412          */
 413         /* FIXME why is the body size one byte smaller than the actual
 414          * size of the body?
 415          * this seems to be an error here as well as in
 416          * write_tag_11_packet() */
 417         if (unlikely((*packet_size) + body_size + 1 > max_packet_size)) {
 418                 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
 419                 rc = -EINVAL;
 420                 goto out;
 421         }
 422
 423         /* special flag one - one byte */
 424         if (data[(*packet_size)++] != 0x62) {
 425                 ecryptfs_printk(KERN_WARNING, "Unrecognizable packet\n");
 426                 rc = -EINVAL;
 427                 goto out;
 428         }
 429
 430         /* special flag two - one byte */
 431         if (data[(*packet_size)++] != 0x08) {
 432                 ecryptfs_printk(KERN_WARNING, "Unrecognizable packet\n");
 433                 rc = -EINVAL;
 434                 goto out;
 435         }
 436
 437         /* skip the next 12 bytes */
 438         (*packet_size) += 12; /* We don't care about the filename or
 439                                * the timestamp */
 440
 441         /* get the Tag 11 contents - tag_11_contents_size bytes */
 442         memcpy(contents, &data[(*packet_size)], (*tag_11_contents_size));
 443         (*packet_size) += (*tag_11_contents_size);
 444
 445 out:
 446         if (rc) {
 447                 (*packet_size) = 0;
 448                 (*tag_11_contents_size) = 0;
 449         }
 450         return rc;
 451 }
 452
 453 /**
 454  * decrypt_session_key - Decrypt the session key with the given auth_tok.
 455  *
 456  * Returns Zero on success; non-zero error otherwise.
 457  */
 458 static int decrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
 459                                struct ecryptfs_crypt_stat *crypt_stat)
 460 {
 461         int rc = 0;
 462         struct ecryptfs_password *password_s_ptr;
 463         struct crypto_tfm *tfm = NULL;
 464         struct scatterlist src_sg[2], dst_sg[2];
 465         struct mutex *tfm_mutex = NULL;
 466         /* TODO: Use virt_to_scatterlist for these */
 467         char *encrypted_session_key;
 468         char *session_key;
 469
 470         password_s_ptr = &auth_tok->token.password;
 471         if (ECRYPTFS_CHECK_FLAG(password_s_ptr->flags,
 472                                 ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET))
 473                 ecryptfs_printk(KERN_DEBUG, "Session key encryption key "
 474                                 "set; skipping key generation\n");
 475         ecryptfs_printk(KERN_DEBUG, "Session key encryption key (size [%d])"
 476                         ":\n",
 477                         password_s_ptr->session_key_encryption_key_bytes);
 478         if (ecryptfs_verbosity > 0)
 479                 ecryptfs_dump_hex(password_s_ptr->session_key_encryption_key,
 480                                   password_s_ptr->
 481                                   session_key_encryption_key_bytes);
 482         if (!strcmp(crypt_stat->cipher,
 483                     crypt_stat->mount_crypt_stat->global_default_cipher_name)
 484             && crypt_stat->mount_crypt_stat->global_key_tfm) {
 485                 tfm = crypt_stat->mount_crypt_stat->global_key_tfm;
 486                 tfm_mutex = &crypt_stat->mount_crypt_stat->global_key_tfm_mutex;
 487         } else {
 488                 tfm = crypto_alloc_tfm(crypt_stat->cipher,
 489                                        CRYPTO_TFM_REQ_WEAK_KEY);
 490                 if (!tfm) {
 491                         printk(KERN_ERR "Error allocating crypto context\n");
 492                         rc = -ENOMEM;
 493                         goto out;
 494                 }
 495         }
 496         if (password_s_ptr->session_key_encryption_key_bytes
 497             < crypto_tfm_alg_min_keysize(tfm)) {
 498                 printk(KERN_WARNING "Session key encryption key is [%d] bytes; "
 499                        "minimum keysize for selected cipher is [%d] bytes.\n",
 500                        password_s_ptr->session_key_encryption_key_bytes,
 501                        crypto_tfm_alg_min_keysize(tfm));
 502                 rc = -EINVAL;
 503                 goto out;
 504         }
 505         if (tfm_mutex)
 506                 mutex_lock(tfm_mutex);
 507         crypto_cipher_setkey(tfm, password_s_ptr->session_key_encryption_key,
 508                              crypt_stat->key_size);
 509         /* TODO: virt_to_scatterlist */
 510         encrypted_session_key = (char *)__get_free_page(GFP_KERNEL);
 511         if (!encrypted_session_key) {
 512                 ecryptfs_printk(KERN_ERR, "Out of memory\n");
 513                 rc = -ENOMEM;
 514                 goto out_free_tfm;
 515         }
 516         session_key = (char *)__get_free_page(GFP_KERNEL);
 517         if (!session_key) {
 518                 kfree(encrypted_session_key);
 519                 ecryptfs_printk(KERN_ERR, "Out of memory\n");
 520                 rc = -ENOMEM;
 521                 goto out_free_tfm;
 522         }
 523         memcpy(encrypted_session_key, auth_tok->session_key.encrypted_key,
 524                auth_tok->session_key.encrypted_key_size);
 525         src_sg[0].page = virt_to_page(encrypted_session_key);
 526         src_sg[0].offset = 0;
 527         BUG_ON(auth_tok->session_key.encrypted_key_size > PAGE_CACHE_SIZE);
 528         src_sg[0].length = auth_tok->session_key.encrypted_key_size;
 529         dst_sg[0].page = virt_to_page(session_key);
 530         dst_sg[0].offset = 0;
 531         auth_tok->session_key.decrypted_key_size =
 532             auth_tok->session_key.encrypted_key_size;
 533         dst_sg[0].length = auth_tok->session_key.encrypted_key_size;
 534         /* TODO: Handle error condition */
 535         crypto_cipher_decrypt(tfm, dst_sg, src_sg,
 536                               auth_tok->session_key.encrypted_key_size);
 537         auth_tok->session_key.decrypted_key_size =
 538             auth_tok->session_key.encrypted_key_size;
 539         memcpy(auth_tok->session_key.decrypted_key, session_key,
 540                auth_tok->session_key.decrypted_key_size);
 541         auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
 542         memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
 543                auth_tok->session_key.decrypted_key_size);
 544         ECRYPTFS_SET_FLAG(crypt_stat->flags, ECRYPTFS_KEY_VALID);
 545         ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
 546         if (ecryptfs_verbosity > 0)
 547                 ecryptfs_dump_hex(crypt_stat->key,
 548                                   crypt_stat->key_size);
 549         memset(encrypted_session_key, 0, PAGE_CACHE_SIZE);
 550         free_page((unsigned long)encrypted_session_key);
 551         memset(session_key, 0, PAGE_CACHE_SIZE);
 552         free_page((unsigned long)session_key);
 553 out_free_tfm:
 554         if (tfm_mutex)
 555                 mutex_unlock(tfm_mutex);
 556         else
 557                 crypto_free_tfm(tfm);
 558 out:
 559         return rc;
 560 }
 561
 562 /**
 563  * ecryptfs_parse_packet_set
 564  * @dest: The header page in memory
 565  * @version: Version of file format, to guide parsing behavior
 566  *
 567  * Get crypt_stat to have the file's session key if the requisite key
 568  * is available to decrypt the session key.
 569  *
 570  * Returns Zero if a valid authentication token was retrieved and
 571  * processed; negative value for file not encrypted or for error
 572  * conditions.
 573  */
 574 int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
 575                               unsigned char *src,
 576                               struct dentry *ecryptfs_dentry)
 577 {
 578         size_t i = 0;
 579         int rc = 0;
 580         size_t found_auth_tok = 0;
 581         size_t next_packet_is_auth_tok_packet;
 582         char sig[ECRYPTFS_SIG_SIZE_HEX];
 583         struct list_head auth_tok_list;
 584         struct list_head *walker;
 585         struct ecryptfs_auth_tok *chosen_auth_tok = NULL;
 586         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
 587                 &ecryptfs_superblock_to_private(
 588                         ecryptfs_dentry->d_sb)->mount_crypt_stat;
 589         struct ecryptfs_auth_tok *candidate_auth_tok = NULL;
 590         size_t packet_size;
 591         struct ecryptfs_auth_tok *new_auth_tok;
 592         unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE];
 593         size_t tag_11_contents_size;
 594         size_t tag_11_packet_size;
 595
 596         INIT_LIST_HEAD(&auth_tok_list);
 597         /* Parse the header to find as many packets as we can, these will be
 598          * added the our &auth_tok_list */
 599         next_packet_is_auth_tok_packet = 1;
 600         while (next_packet_is_auth_tok_packet) {
 601                 size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i);
 602
 603                 switch (src[i]) {
 604                 case ECRYPTFS_TAG_3_PACKET_TYPE:
 605                         rc = parse_tag_3_packet(crypt_stat,
 606                                                 (unsigned char *)&src[i],
 607                                                 &auth_tok_list, &new_auth_tok,
 608                                                 &packet_size, max_packet_size);
 609                         if (rc) {
 610                                 ecryptfs_printk(KERN_ERR, "Error parsing "
 611                                                 "tag 3 packet\n");
 612                                 rc = -EIO;
 613                                 goto out_wipe_list;
 614                         }
 615                         i += packet_size;
 616                         rc = parse_tag_11_packet((unsigned char *)&src[i],
 617                                                  sig_tmp_space,
 618                                                  ECRYPTFS_SIG_SIZE,
 619                                                  &tag_11_contents_size,
 620                                                  &tag_11_packet_size,
 621                                                  max_packet_size);
 622                         if (rc) {
 623                                 ecryptfs_printk(KERN_ERR, "No valid "
 624                                                 "(ecryptfs-specific) literal "
 625                                                 "packet containing "
 626                                                 "authentication token "
 627                                                 "signature found after "
 628                                                 "tag 3 packet\n");
 629                                 rc = -EIO;
 630                                 goto out_wipe_list;
 631                         }
 632                         i += tag_11_packet_size;
 633                         if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {
 634                                 ecryptfs_printk(KERN_ERR, "Expected "
 635                                                 "signature of size [%d]; "
 636                                                 "read size [%d]\n",
 637                                                 ECRYPTFS_SIG_SIZE,
 638                                                 tag_11_contents_size);
 639                                 rc = -EIO;
 640                                 goto out_wipe_list;
 641                         }
 642                         ecryptfs_to_hex(new_auth_tok->token.password.signature,
 643                                         sig_tmp_space, tag_11_contents_size);
 644                         new_auth_tok->token.password.signature[
 645                                 ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';
 646                         ECRYPTFS_SET_FLAG(crypt_stat->flags,
 647                                           ECRYPTFS_ENCRYPTED);
 648                         break;
 649                 case ECRYPTFS_TAG_11_PACKET_TYPE:
 650                         ecryptfs_printk(KERN_WARNING, "Invalid packet set "
 651                                         "(Tag 11 not allowed by itself)\n");
 652                         rc = -EIO;
 653                         goto out_wipe_list;
 654                         break;
 655                 default:
 656                         ecryptfs_printk(KERN_DEBUG, "No packet at offset "
 657                                         "[%d] of the file header; hex value of "
 658                                         "character is [0x%.2x]\n", i, src[i]);
 659                         next_packet_is_auth_tok_packet = 0;
 660                 }
 661         }
 662         if (list_empty(&auth_tok_list)) {
 663                 rc = -EINVAL; /* Do not support non-encrypted files in
 664                                * the 0.1 release */
 665                 goto out;
 666         }
 667         /* If we have a global auth tok, then we should try to use
 668          * it */
 669         if (mount_crypt_stat->global_auth_tok) {
 670                 memcpy(sig, mount_crypt_stat->global_auth_tok_sig,
 671                        ECRYPTFS_SIG_SIZE_HEX);
 672                 chosen_auth_tok = mount_crypt_stat->global_auth_tok;
 673         } else
 674                 BUG(); /* We should always have a global auth tok in
 675                         * the 0.1 release */
 676         /* Scan list to see if our chosen_auth_tok works */
 677         list_for_each(walker, &auth_tok_list) {
 678                 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
 679                 auth_tok_list_item =
 680                     list_entry(walker, struct ecryptfs_auth_tok_list_item,
 681                                list);
 682                 candidate_auth_tok = &auth_tok_list_item->auth_tok;
 683                 if (unlikely(ecryptfs_verbosity > 0)) {
 684                         ecryptfs_printk(KERN_DEBUG,
 685                                         "Considering cadidate auth tok:\n");
 686                         ecryptfs_dump_auth_tok(candidate_auth_tok);
 687                 }
 688                 /* TODO: Replace ECRYPTFS_SIG_SIZE_HEX w/ dynamic value */
 689                 if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD
 690                     && !strncmp(candidate_auth_tok->token.password.signature,
 691                                 sig, ECRYPTFS_SIG_SIZE_HEX)) {
 692                         found_auth_tok = 1;
 693                         goto leave_list;
 694                         /* TODO: Transfer the common salt into the
 695                          * crypt_stat salt */
 696                 }
 697         }
 698 leave_list:
 699         if (!found_auth_tok) {
 700                 ecryptfs_printk(KERN_ERR, "Could not find authentication "
 701                                 "token on temporary list for sig [%.*s]\n",
 702                                 ECRYPTFS_SIG_SIZE_HEX, sig);
 703                 rc = -EIO;
 704                 goto out_wipe_list;
 705         } else {
 706                 memcpy(&(candidate_auth_tok->token.password),
 707                        &(chosen_auth_tok->token.password),
 708                        sizeof(struct ecryptfs_password));
 709                 rc = decrypt_session_key(candidate_auth_tok, crypt_stat);
 710                 if (rc) {
 711                         ecryptfs_printk(KERN_ERR, "Error decrypting the "
 712                                         "session key\n");
 713                         goto out_wipe_list;
 714                 }
 715                 rc = ecryptfs_compute_root_iv(crypt_stat);
 716                 if (rc) {
 717                         ecryptfs_printk(KERN_ERR, "Error computing "
 718                                         "the root IV\n");
 719                         goto out_wipe_list;
 720                 }
 721         }
 722         rc = ecryptfs_init_crypt_ctx(crypt_stat);
 723         if (rc) {
 724                 ecryptfs_printk(KERN_ERR, "Error initializing crypto "
 725                                 "context for cipher [%s]; rc = [%d]\n",
 726                                 crypt_stat->cipher, rc);
 727         }
 728 out_wipe_list:
 729         wipe_auth_tok_list(&auth_tok_list);
 730 out:
 731         return rc;
 732 }
 733
 734 /**
 735  * write_tag_11_packet
 736  * @dest: Target into which Tag 11 packet is to be written
 737  * @max: Maximum packet length
 738  * @contents: Byte array of contents to copy in
 739  * @contents_length: Number of bytes in contents
 740  * @packet_length: Length of the Tag 11 packet written; zero on error
 741  *
 742  * Returns zero on success; non-zero on error.
 743  */
 744 static int
 745 write_tag_11_packet(char *dest, int max, char *contents, size_t contents_length,
 746                     size_t *packet_length)
 747 {
 748         int rc = 0;
 749         size_t packet_size_length;
 750
 751         (*packet_length) = 0;
 752         if ((13 + contents_length) > max) {
 753                 rc = -EINVAL;
 754                 ecryptfs_printk(KERN_ERR, "Packet length larger than "
 755                                 "maximum allowable\n");
 756                 goto out;
 757         }
 758         /* General packet header */
 759         /* Packet tag */
 760         dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE;
 761         /* Packet length */
 762         rc = write_packet_length(&dest[(*packet_length)],
 763                                  (13 + contents_length), &packet_size_length);
 764         if (rc) {
 765                 ecryptfs_printk(KERN_ERR, "Error generating tag 11 packet "
 766                                 "header; cannot generate packet length\n");
 767                 goto out;
 768         }
 769         (*packet_length) += packet_size_length;
 770         /* Tag 11 specific */
 771         /* One-octet field that describes how the data is formatted */
 772         dest[(*packet_length)++] = 0x62; /* binary data */
 773         /* One-octet filename length followed by filename */
 774         dest[(*packet_length)++] = 8;
 775         memcpy(&dest[(*packet_length)], "_CONSOLE", 8);
 776         (*packet_length) += 8;
 777         /* Four-octet number indicating modification date */
 778         memset(&dest[(*packet_length)], 0x00, 4);
 779         (*packet_length) += 4;
 780         /* Remainder is literal data */
 781         memcpy(&dest[(*packet_length)], contents, contents_length);
 782         (*packet_length) += contents_length;
 783  out:
 784         if (rc)
 785                 (*packet_length) = 0;
 786         return rc;
 787 }
 788
 789 /**
 790  * write_tag_3_packet
 791  * @dest: Buffer into which to write the packet
 792  * @max: Maximum number of bytes that can be written
 793  * @auth_tok: Authentication token
 794  * @crypt_stat: The cryptographic context
 795  * @key_rec: encrypted key
 796  * @packet_size: This function will write the number of bytes that end
 797  *               up constituting the packet; set to zero on error
 798  *
 799  * Returns zero on success; non-zero on error.
 800  */
 801 static int
 802 write_tag_3_packet(char *dest, size_t max, struct ecryptfs_auth_tok *auth_tok,
 803                    struct ecryptfs_crypt_stat *crypt_stat,
 804                    struct ecryptfs_key_record *key_rec, size_t *packet_size)
 805 {
 806         int rc = 0;
 807
 808         size_t i;
 809         size_t signature_is_valid = 0;
 810         size_t encrypted_session_key_valid = 0;
 811         char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
 812         struct scatterlist dest_sg[2];
 813         struct scatterlist src_sg[2];
 814         struct crypto_tfm *tfm = NULL;
 815         struct mutex *tfm_mutex = NULL;
 816         size_t key_rec_size;
 817         size_t packet_size_length;
 818         size_t cipher_code;
 819
 820         (*packet_size) = 0;
 821         /* Check for a valid signature on the auth_tok */
 822         for (i = 0; i < ECRYPTFS_SIG_SIZE_HEX; i++)
 823                 signature_is_valid |= auth_tok->token.password.signature[i];
 824         if (!signature_is_valid)
 825                 BUG();
 826         ecryptfs_from_hex((*key_rec).sig, auth_tok->token.password.signature,
 827                           ECRYPTFS_SIG_SIZE);
 828         encrypted_session_key_valid = 0;
 829         for (i = 0; i < crypt_stat->key_size; i++)
 830                 encrypted_session_key_valid |=
 831                         auth_tok->session_key.encrypted_key[i];
 832         if (encrypted_session_key_valid) {
 833                 memcpy((*key_rec).enc_key,
 834                        auth_tok->session_key.encrypted_key,
 835                        auth_tok->session_key.encrypted_key_size);
 836                 goto encrypted_session_key_set;
 837         }
 838         if (auth_tok->session_key.encrypted_key_size == 0)
 839                 auth_tok->session_key.encrypted_key_size =
 840                         crypt_stat->key_size;
 841         if (crypt_stat->key_size == 24
 842             && strcmp("aes", crypt_stat->cipher) == 0) {
 843                 memset((crypt_stat->key + 24), 0, 8);
 844                 auth_tok->session_key.encrypted_key_size = 32;
 845         }
 846         (*key_rec).enc_key_size =
 847                 auth_tok->session_key.encrypted_key_size;
 848         if (ECRYPTFS_CHECK_FLAG(auth_tok->token.password.flags,
 849                                 ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET)) {
 850                 ecryptfs_printk(KERN_DEBUG, "Using previously generated "
 851                                 "session key encryption key of size [%d]\n",
 852                                 auth_tok->token.password.
 853                                 session_key_encryption_key_bytes);
 854                 memcpy(session_key_encryption_key,
 855                        auth_tok->token.password.session_key_encryption_key,
 856                        crypt_stat->key_size);
 857                 ecryptfs_printk(KERN_DEBUG,
 858                                 "Cached session key " "encryption key: \n");
 859                 if (ecryptfs_verbosity > 0)
 860                         ecryptfs_dump_hex(session_key_encryption_key, 16);
 861         }
 862         if (unlikely(ecryptfs_verbosity > 0)) {
 863                 ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");
 864                 ecryptfs_dump_hex(session_key_encryption_key, 16);
 865         }
 866         rc = virt_to_scatterlist(crypt_stat->key,
 867                                  (*key_rec).enc_key_size, src_sg, 2);
 868         if (!rc) {
 869                 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
 870                                 "for crypt_stat session key\n");
 871                 rc = -ENOMEM;
 872                 goto out;
 873         }
 874         rc = virt_to_scatterlist((*key_rec).enc_key,
 875                                  (*key_rec).enc_key_size, dest_sg, 2);
 876         if (!rc) {
 877                 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
 878                                 "for crypt_stat encrypted session key\n");
 879                 rc = -ENOMEM;
 880                 goto out;
 881         }
 882         if (!strcmp(crypt_stat->cipher,
 883                     crypt_stat->mount_crypt_stat->global_default_cipher_name)
 884             && crypt_stat->mount_crypt_stat->global_key_tfm) {
 885                 tfm = crypt_stat->mount_crypt_stat->global_key_tfm;
 886                 tfm_mutex = &crypt_stat->mount_crypt_stat->global_key_tfm_mutex;
 887         } else
 888                 tfm = crypto_alloc_tfm(crypt_stat->cipher, 0);
 889         if (!tfm) {
 890                 ecryptfs_printk(KERN_ERR, "Could not initialize crypto "
 891                                 "context for cipher [%s]\n",
 892                                 crypt_stat->cipher);
 893                 rc = -EINVAL;
 894                 goto out;
 895         }
 896         if (tfm_mutex)
 897                 mutex_lock(tfm_mutex);
 898         rc = crypto_cipher_setkey(tfm, session_key_encryption_key,
 899                                   crypt_stat->key_size);
 900         if (rc < 0) {
 901                 if (tfm_mutex)
 902                         mutex_unlock(tfm_mutex);
 903                 ecryptfs_printk(KERN_ERR, "Error setting key for crypto "
 904                                 "context\n");
 905                 goto out;
 906         }
 907         rc = 0;
 908         ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n",
 909                         crypt_stat->key_size);
 910         crypto_cipher_encrypt(tfm, dest_sg, src_sg,
 911                               (*key_rec).enc_key_size);
 912         if (tfm_mutex)
 913                 mutex_unlock(tfm_mutex);
 914         ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");
 915         if (ecryptfs_verbosity > 0)
 916                 ecryptfs_dump_hex((*key_rec).enc_key,
 917                                   (*key_rec).enc_key_size);
 918 encrypted_session_key_set:
 919         /* Now we have a valid key_rec.  Append it to the
 920          * key_rec set. */
 921         key_rec_size = (sizeof(struct ecryptfs_key_record)
 922                         - ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES
 923                         + ((*key_rec).enc_key_size));
 924         /* TODO: Include a packet size limit as a parameter to this
 925          * function once we have multi-packet headers (for versions
 926          * later than 0.1 */
 927         if (key_rec_size >= ECRYPTFS_MAX_KEYSET_SIZE) {
 928                 ecryptfs_printk(KERN_ERR, "Keyset too large\n");
 929                 rc = -EINVAL;
 930                 goto out;
 931         }
 932         /* TODO: Packet size limit */
 933         /* We have 5 bytes of surrounding packet data */
 934         if ((0x05 + ECRYPTFS_SALT_SIZE
 935              + (*key_rec).enc_key_size) >= max) {
 936                 ecryptfs_printk(KERN_ERR, "Authentication token is too "
 937                                 "large\n");
 938                 rc = -EINVAL;
 939                 goto out;
 940         }
 941         /* This format is inspired by OpenPGP; see RFC 2440
 942          * packet tag 3 */
 943         dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE;
 944         /* ver+cipher+s2k+hash+salt+iter+enc_key */
 945         rc = write_packet_length(&dest[(*packet_size)],
 946                                  (0x05 + ECRYPTFS_SALT_SIZE
 947                                   + (*key_rec).enc_key_size),
 948                                  &packet_size_length);
 949         if (rc) {
 950                 ecryptfs_printk(KERN_ERR, "Error generating tag 3 packet "
 951                                 "header; cannot generate packet length\n");
 952                 goto out;
 953         }
 954         (*packet_size) += packet_size_length;
 955         dest[(*packet_size)++] = 0x04; /* version 4 */
 956         cipher_code = ecryptfs_code_for_cipher_string(crypt_stat);
 957         if (cipher_code == 0) {
 958                 ecryptfs_printk(KERN_WARNING, "Unable to generate code for "
 959                                 "cipher [%s]\n", crypt_stat->cipher);
 960                 rc = -EINVAL;
 961                 goto out;
 962         }
 963         dest[(*packet_size)++] = cipher_code;
 964         dest[(*packet_size)++] = 0x03;  /* S2K */
 965         dest[(*packet_size)++] = 0x01;  /* MD5 (TODO: parameterize) */
 966         memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,
 967                ECRYPTFS_SALT_SIZE);
 968         (*packet_size) += ECRYPTFS_SALT_SIZE;   /* salt */
 969         dest[(*packet_size)++] = 0x60;  /* hash iterations (65536) */
 970         memcpy(&dest[(*packet_size)], (*key_rec).enc_key,
 971                (*key_rec).enc_key_size);
 972         (*packet_size) += (*key_rec).enc_key_size;
 973 out:
 974         if (tfm && !tfm_mutex)
 975                 crypto_free_tfm(tfm);
 976         if (rc)
 977                 (*packet_size) = 0;
 978         return rc;
 979 }
 980
 981 /**
 982  * ecryptfs_generate_key_packet_set
 983  * @dest: Virtual address from which to write the key record set
 984  * @crypt_stat: The cryptographic context from which the
 985  *              authentication tokens will be retrieved
 986  * @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat
 987  *                   for the global parameters
 988  * @len: The amount written
 989  * @max: The maximum amount of data allowed to be written
 990  *
 991  * Generates a key packet set and writes it to the virtual address
 992  * passed in.
 993  *
 994  * Returns zero on success; non-zero on error.
 995  */
 996 int
 997 ecryptfs_generate_key_packet_set(char *dest_base,
 998                                  struct ecryptfs_crypt_stat *crypt_stat,
 999                                  struct dentry *ecryptfs_dentry, size_t *len,
1000                                  size_t max)
1001 {
1002         int rc = 0;
1003         struct ecryptfs_auth_tok *auth_tok;
1004         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
1005                 &ecryptfs_superblock_to_private(
1006                         ecryptfs_dentry->d_sb)->mount_crypt_stat;
1007         size_t written;
1008         struct ecryptfs_key_record key_rec;
1009
1010         (*len) = 0;
1011         if (mount_crypt_stat->global_auth_tok) {
1012                 auth_tok = mount_crypt_stat->global_auth_tok;
1013                 if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
1014                         rc = write_tag_3_packet((dest_base + (*len)),
1015                                                 max, auth_tok,
1016                                                 crypt_stat, &key_rec,
1017                                                 &written);
1018                         if (rc) {
1019                                 ecryptfs_printk(KERN_WARNING, "Error "
1020                                                 "writing tag 3 packet\n");
1021                                 goto out;
1022                         }
1023                         (*len) += written;
1024                         /* Write auth tok signature packet */
1025                         rc = write_tag_11_packet(
1026                                 (dest_base + (*len)),
1027                                 (max - (*len)),
1028                                 key_rec.sig, ECRYPTFS_SIG_SIZE, &written);
1029                         if (rc) {
1030                                 ecryptfs_printk(KERN_ERR, "Error writing "
1031                                                 "auth tok signature packet\n");
1032                                 goto out;
1033                         }
1034                         (*len) += written;
1035                 } else {
1036                         ecryptfs_printk(KERN_WARNING, "Unsupported "
1037                                         "authentication token type\n");
1038                         rc = -EINVAL;
1039                         goto out;
1040                 }
1041                 if (rc) {
1042                         ecryptfs_printk(KERN_WARNING, "Error writing "
1043                                         "authentication token packet with sig "
1044                                         "= [%s]\n",
1045                                         mount_crypt_stat->global_auth_tok_sig);
1046                         rc = -EIO;
1047                         goto out;
1048                 }
1049         } else
1050                 BUG();
1051         if (likely((max - (*len)) > 0)) {
1052                 dest_base[(*len)] = 0x00;
1053         } else {
1054                 ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");
1055                 rc = -EIO;
1056         }
1057 out:
1058         if (rc)
1059                 (*len) = 0;
1060         return rc;
1061 }