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  *              Trevor S. Highland <trevor.highland@gmail.com>
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License as
  14  * published by the Free Software Foundation; either version 2 of the
  15  * License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  25  * 02111-1307, USA.
  26  */
  27
  28 #include <linux/string.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 /**
  68  * parse_packet_length
  69  * @data: Pointer to memory containing length at offset
  70  * @size: This function writes the decoded size to this memory
  71  *        address; zero on error
  72  * @length_size: The number of bytes occupied by the encoded length
  73  *
  74  * Returns zero on success; non-zero on error
  75  */
  76 static int parse_packet_length(unsigned char *data, size_t *size,
  77                                size_t *length_size)
  78 {
  79         int rc = 0;
  80
  81         (*length_size) = 0;
  82         (*size) = 0;
  83         if (data[0] < 192) {
  84                 /* One-byte length */
  85                 (*size) = (unsigned char)data[0];
  86                 (*length_size) = 1;
  87         } else if (data[0] < 224) {
  88                 /* Two-byte length */
  89                 (*size) = (((unsigned char)(data[0]) - 192) * 256);
  90                 (*size) += ((unsigned char)(data[1]) + 192);
  91                 (*length_size) = 2;
  92         } else if (data[0] == 255) {
  93                 /* Five-byte length; we're not supposed to see this */
  94                 ecryptfs_printk(KERN_ERR, "Five-byte packet length not "
  95                                 "supported\n");
  96                 rc = -EINVAL;
  97                 goto out;
  98         } else {
  99                 ecryptfs_printk(KERN_ERR, "Error parsing packet length\n");
 100                 rc = -EINVAL;
 101                 goto out;
 102         }
 103 out:
 104         return rc;
 105 }
 106
 107 /**
 108  * write_packet_length
 109  * @dest: The byte array target into which to write the length. Must
 110  *        have at least 5 bytes allocated.
 111  * @size: The length to write.
 112  * @packet_size_length: The number of bytes used to encode the packet
 113  *                      length is written to this address.
 114  *
 115  * Returns zero on success; non-zero on error.
 116  */
 117 static int write_packet_length(char *dest, size_t size,
 118                                size_t *packet_size_length)
 119 {
 120         int rc = 0;
 121
 122         if (size < 192) {
 123                 dest[0] = size;
 124                 (*packet_size_length) = 1;
 125         } else if (size < 65536) {
 126                 dest[0] = (((size - 192) / 256) + 192);
 127                 dest[1] = ((size - 192) % 256);
 128                 (*packet_size_length) = 2;
 129         } else {
 130                 rc = -EINVAL;
 131                 ecryptfs_printk(KERN_WARNING,
 132                                 "Unsupported packet size: [%d]\n", size);
 133         }
 134         return rc;
 135 }
 136
 137 static int
 138 write_tag_64_packet(char *signature, struct ecryptfs_session_key *session_key,
 139                     char **packet, size_t *packet_len)
 140 {
 141         size_t i = 0;
 142         size_t data_len;
 143         size_t packet_size_len;
 144         char *message;
 145         int rc;
 146
 147         /*
 148          *              ***** TAG 64 Packet Format *****
 149          *    | Content Type                       | 1 byte       |
 150          *    | Key Identifier Size                | 1 or 2 bytes |
 151          *    | Key Identifier                     | arbitrary    |
 152          *    | Encrypted File Encryption Key Size | 1 or 2 bytes |
 153          *    | Encrypted File Encryption Key      | arbitrary    |
 154          */
 155         data_len = (5 + ECRYPTFS_SIG_SIZE_HEX
 156                     + session_key->encrypted_key_size);
 157         *packet = kmalloc(data_len, GFP_KERNEL);
 158         message = *packet;
 159         if (!message) {
 160                 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
 161                 rc = -ENOMEM;
 162                 goto out;
 163         }
 164         message[i++] = ECRYPTFS_TAG_64_PACKET_TYPE;
 165         rc = write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
 166                                  &packet_size_len);
 167         if (rc) {
 168                 ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
 169                                 "header; cannot generate packet length\n");
 170                 goto out;
 171         }
 172         i += packet_size_len;
 173         memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
 174         i += ECRYPTFS_SIG_SIZE_HEX;
 175         rc = write_packet_length(&message[i], session_key->encrypted_key_size,
 176                                  &packet_size_len);
 177         if (rc) {
 178                 ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
 179                                 "header; cannot generate packet length\n");
 180                 goto out;
 181         }
 182         i += packet_size_len;
 183         memcpy(&message[i], session_key->encrypted_key,
 184                session_key->encrypted_key_size);
 185         i += session_key->encrypted_key_size;
 186         *packet_len = i;
 187 out:
 188         return rc;
 189 }
 190
 191 static int
 192 parse_tag_65_packet(struct ecryptfs_session_key *session_key, u16 *cipher_code,
 193                     struct ecryptfs_message *msg)
 194 {
 195         size_t i = 0;
 196         char *data;
 197         size_t data_len;
 198         size_t m_size;
 199         size_t message_len;
 200         u16 checksum = 0;
 201         u16 expected_checksum = 0;
 202         int rc;
 203
 204         /*
 205          *              ***** TAG 65 Packet Format *****
 206          *         | Content Type             | 1 byte       |
 207          *         | Status Indicator         | 1 byte       |
 208          *         | File Encryption Key Size | 1 or 2 bytes |
 209          *         | File Encryption Key      | arbitrary    |
 210          */
 211         message_len = msg->data_len;
 212         data = msg->data;
 213         if (message_len < 4) {
 214                 rc = -EIO;
 215                 goto out;
 216         }
 217         if (data[i++] != ECRYPTFS_TAG_65_PACKET_TYPE) {
 218                 ecryptfs_printk(KERN_ERR, "Type should be ECRYPTFS_TAG_65\n");
 219                 rc = -EIO;
 220                 goto out;
 221         }
 222         if (data[i++]) {
 223                 ecryptfs_printk(KERN_ERR, "Status indicator has non-zero value "
 224                                 "[%d]\n", data[i-1]);
 225                 rc = -EIO;
 226                 goto out;
 227         }
 228         rc = parse_packet_length(&data[i], &m_size, &data_len);
 229         if (rc) {
 230                 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
 231                                 "rc = [%d]\n", rc);
 232                 goto out;
 233         }
 234         i += data_len;
 235         if (message_len < (i + m_size)) {
 236                 ecryptfs_printk(KERN_ERR, "The received netlink message is "
 237                                 "shorter than expected\n");
 238                 rc = -EIO;
 239                 goto out;
 240         }
 241         if (m_size < 3) {
 242                 ecryptfs_printk(KERN_ERR,
 243                                 "The decrypted key is not long enough to "
 244                                 "include a cipher code and checksum\n");
 245                 rc = -EIO;
 246                 goto out;
 247         }
 248         *cipher_code = data[i++];
 249         /* The decrypted key includes 1 byte cipher code and 2 byte checksum */
 250         session_key->decrypted_key_size = m_size - 3;
 251         if (session_key->decrypted_key_size > ECRYPTFS_MAX_KEY_BYTES) {
 252                 ecryptfs_printk(KERN_ERR, "key_size [%d] larger than "
 253                                 "the maximum key size [%d]\n",
 254                                 session_key->decrypted_key_size,
 255                                 ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
 256                 rc = -EIO;
 257                 goto out;
 258         }
 259         memcpy(session_key->decrypted_key, &data[i],
 260                session_key->decrypted_key_size);
 261         i += session_key->decrypted_key_size;
 262         expected_checksum += (unsigned char)(data[i++]) << 8;
 263         expected_checksum += (unsigned char)(data[i++]);
 264         for (i = 0; i < session_key->decrypted_key_size; i++)
 265                 checksum += session_key->decrypted_key[i];
 266         if (expected_checksum != checksum) {
 267                 ecryptfs_printk(KERN_ERR, "Invalid checksum for file "
 268                                 "encryption  key; expected [%x]; calculated "
 269                                 "[%x]\n", expected_checksum, checksum);
 270                 rc = -EIO;
 271         }
 272 out:
 273         return rc;
 274 }
 275
 276
 277 static int
 278 write_tag_66_packet(char *signature, size_t cipher_code,
 279                     struct ecryptfs_crypt_stat *crypt_stat, char **packet,
 280                     size_t *packet_len)
 281 {
 282         size_t i = 0;
 283         size_t j;
 284         size_t data_len;
 285         size_t checksum = 0;
 286         size_t packet_size_len;
 287         char *message;
 288         int rc;
 289
 290         /*
 291          *              ***** TAG 66 Packet Format *****
 292          *         | Content Type             | 1 byte       |
 293          *         | Key Identifier Size      | 1 or 2 bytes |
 294          *         | Key Identifier           | arbitrary    |
 295          *         | File Encryption Key Size | 1 or 2 bytes |
 296          *         | File Encryption Key      | arbitrary    |
 297          */
 298         data_len = (5 + ECRYPTFS_SIG_SIZE_HEX + crypt_stat->key_size);
 299         *packet = kmalloc(data_len, GFP_KERNEL);
 300         message = *packet;
 301         if (!message) {
 302                 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
 303                 rc = -ENOMEM;
 304                 goto out;
 305         }
 306         message[i++] = ECRYPTFS_TAG_66_PACKET_TYPE;
 307         rc = write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
 308                                  &packet_size_len);
 309         if (rc) {
 310                 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
 311                                 "header; cannot generate packet length\n");
 312                 goto out;
 313         }
 314         i += packet_size_len;
 315         memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
 316         i += ECRYPTFS_SIG_SIZE_HEX;
 317         /* The encrypted key includes 1 byte cipher code and 2 byte checksum */
 318         rc = write_packet_length(&message[i], crypt_stat->key_size + 3,
 319                                  &packet_size_len);
 320         if (rc) {
 321                 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
 322                                 "header; cannot generate packet length\n");
 323                 goto out;
 324         }
 325         i += packet_size_len;
 326         message[i++] = cipher_code;
 327         memcpy(&message[i], crypt_stat->key, crypt_stat->key_size);
 328         i += crypt_stat->key_size;
 329         for (j = 0; j < crypt_stat->key_size; j++)
 330                 checksum += crypt_stat->key[j];
 331         message[i++] = (checksum / 256) % 256;
 332         message[i++] = (checksum % 256);
 333         *packet_len = i;
 334 out:
 335         return rc;
 336 }
 337
 338 static int
 339 parse_tag_67_packet(struct ecryptfs_key_record *key_rec,
 340                     struct ecryptfs_message *msg)
 341 {
 342         size_t i = 0;
 343         char *data;
 344         size_t data_len;
 345         size_t message_len;
 346         int rc;
 347
 348         /*
 349          *              ***** TAG 65 Packet Format *****
 350          *    | Content Type                       | 1 byte       |
 351          *    | Status Indicator                   | 1 byte       |
 352          *    | Encrypted File Encryption Key Size | 1 or 2 bytes |
 353          *    | Encrypted File Encryption Key      | arbitrary    |
 354          */
 355         message_len = msg->data_len;
 356         data = msg->data;
 357         /* verify that everything through the encrypted FEK size is present */
 358         if (message_len < 4) {
 359                 rc = -EIO;
 360                 goto out;
 361         }
 362         if (data[i++] != ECRYPTFS_TAG_67_PACKET_TYPE) {
 363                 ecryptfs_printk(KERN_ERR, "Type should be ECRYPTFS_TAG_67\n");
 364                 rc = -EIO;
 365                 goto out;
 366         }
 367         if (data[i++]) {
 368                 ecryptfs_printk(KERN_ERR, "Status indicator has non zero value"
 369                                 " [%d]\n", data[i-1]);
 370                 rc = -EIO;
 371                 goto out;
 372         }
 373         rc = parse_packet_length(&data[i], &key_rec->enc_key_size, &data_len);
 374         if (rc) {
 375                 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
 376                                 "rc = [%d]\n", rc);
 377                 goto out;
 378         }
 379         i += data_len;
 380         if (message_len < (i + key_rec->enc_key_size)) {
 381                 ecryptfs_printk(KERN_ERR, "message_len [%d]; max len is [%d]\n",
 382                                 message_len, (i + key_rec->enc_key_size));
 383                 rc = -EIO;
 384                 goto out;
 385         }
 386         if (key_rec->enc_key_size > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
 387                 ecryptfs_printk(KERN_ERR, "Encrypted key_size [%d] larger than "
 388                                 "the maximum key size [%d]\n",
 389                                 key_rec->enc_key_size,
 390                                 ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
 391                 rc = -EIO;
 392                 goto out;
 393         }
 394         memcpy(key_rec->enc_key, &data[i], key_rec->enc_key_size);
 395 out:
 396         return rc;
 397 }
 398
 399 /**
 400  * decrypt_pki_encrypted_session_key - Decrypt the session key with the given auth_tok.
 401  * @auth_tok: The key authentication token used to decrypt the session key
 402  * @crypt_stat: The cryptographic context
 403  *
 404  * Returns zero on success; non-zero error otherwise.
 405  */
 406 static int
 407 decrypt_pki_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
 408                                   struct ecryptfs_crypt_stat *crypt_stat)
 409 {
 410         u16 cipher_code = 0;
 411         struct ecryptfs_msg_ctx *msg_ctx;
 412         struct ecryptfs_message *msg = NULL;
 413         char *auth_tok_sig;
 414         char *netlink_message;
 415         size_t netlink_message_length;
 416         int rc;
 417
 418         if ((rc = ecryptfs_get_auth_tok_sig(&auth_tok_sig, auth_tok))) {
 419                 printk(KERN_ERR "Unrecognized auth tok type: [%d]\n",
 420                        auth_tok->token_type);
 421                 goto out;
 422         }
 423         rc = write_tag_64_packet(auth_tok_sig, &(auth_tok->session_key),
 424                                  &netlink_message, &netlink_message_length);
 425         if (rc) {
 426                 ecryptfs_printk(KERN_ERR, "Failed to write tag 64 packet");
 427                 goto out;
 428         }
 429         rc = ecryptfs_send_message(ecryptfs_transport, netlink_message,
 430                                    netlink_message_length, &msg_ctx);
 431         if (rc) {
 432                 ecryptfs_printk(KERN_ERR, "Error sending netlink message\n");
 433                 goto out;
 434         }
 435         rc = ecryptfs_wait_for_response(msg_ctx, &msg);
 436         if (rc) {
 437                 ecryptfs_printk(KERN_ERR, "Failed to receive tag 65 packet "
 438                                 "from the user space daemon\n");
 439                 rc = -EIO;
 440                 goto out;
 441         }
 442         rc = parse_tag_65_packet(&(auth_tok->session_key),
 443                                  &cipher_code, msg);
 444         if (rc) {
 445                 printk(KERN_ERR "Failed to parse tag 65 packet; rc = [%d]\n",
 446                        rc);
 447                 goto out;
 448         }
 449         auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
 450         memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
 451                auth_tok->session_key.decrypted_key_size);
 452         crypt_stat->key_size = auth_tok->session_key.decrypted_key_size;
 453         rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher, cipher_code);
 454         if (rc) {
 455                 ecryptfs_printk(KERN_ERR, "Cipher code [%d] is invalid\n",
 456                                 cipher_code)
 457                 goto out;
 458         }
 459         crypt_stat->flags |= ECRYPTFS_KEY_VALID;
 460         if (ecryptfs_verbosity > 0) {
 461                 ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
 462                 ecryptfs_dump_hex(crypt_stat->key,
 463                                   crypt_stat->key_size);
 464         }
 465 out:
 466         if (msg)
 467                 kfree(msg);
 468         return rc;
 469 }
 470
 471 static void wipe_auth_tok_list(struct list_head *auth_tok_list_head)
 472 {
 473         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
 474         struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;
 475
 476         list_for_each_entry_safe(auth_tok_list_item, auth_tok_list_item_tmp,
 477                                  auth_tok_list_head, list) {
 478                 list_del(&auth_tok_list_item->list);
 479                 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
 480                                 auth_tok_list_item);
 481         }
 482 }
 483
 484 struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
 485
 486 /**
 487  * parse_tag_1_packet
 488  * @crypt_stat: The cryptographic context to modify based on packet contents
 489  * @data: The raw bytes of the packet.
 490  * @auth_tok_list: eCryptfs parses packets into authentication tokens;
 491  *                 a new authentication token will be placed at the
 492  *                 end of this list for this packet.
 493  * @new_auth_tok: Pointer to a pointer to memory that this function
 494  *                allocates; sets the memory address of the pointer to
 495  *                NULL on error. This object is added to the
 496  *                auth_tok_list.
 497  * @packet_size: This function writes the size of the parsed packet
 498  *               into this memory location; zero on error.
 499  * @max_packet_size: The maximum allowable packet size
 500  *
 501  * Returns zero on success; non-zero on error.
 502  */
 503 static int
 504 parse_tag_1_packet(struct ecryptfs_crypt_stat *crypt_stat,
 505                    unsigned char *data, struct list_head *auth_tok_list,
 506                    struct ecryptfs_auth_tok **new_auth_tok,
 507                    size_t *packet_size, size_t max_packet_size)
 508 {
 509         size_t body_size;
 510         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
 511         size_t length_size;
 512         int rc = 0;
 513
 514         (*packet_size) = 0;
 515         (*new_auth_tok) = NULL;
 516         /**
 517          * This format is inspired by OpenPGP; see RFC 2440
 518          * packet tag 1
 519          *
 520          * Tag 1 identifier (1 byte)
 521          * Max Tag 1 packet size (max 3 bytes)
 522          * Version (1 byte)
 523          * Key identifier (8 bytes; ECRYPTFS_SIG_SIZE)
 524          * Cipher identifier (1 byte)
 525          * Encrypted key size (arbitrary)
 526          *
 527          * 12 bytes minimum packet size
 528          */
 529         if (unlikely(max_packet_size < 12)) {
 530                 printk(KERN_ERR "Invalid max packet size; must be >=12\n");
 531                 rc = -EINVAL;
 532                 goto out;
 533         }
 534         if (data[(*packet_size)++] != ECRYPTFS_TAG_1_PACKET_TYPE) {
 535                 printk(KERN_ERR "Enter w/ first byte != 0x%.2x\n",
 536                        ECRYPTFS_TAG_1_PACKET_TYPE);
 537                 rc = -EINVAL;
 538                 goto out;
 539         }
 540         /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
 541          * at end of function upon failure */
 542         auth_tok_list_item =
 543                 kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache,
 544                                   GFP_KERNEL);
 545         if (!auth_tok_list_item) {
 546                 printk(KERN_ERR "Unable to allocate memory\n");
 547                 rc = -ENOMEM;
 548                 goto out;
 549         }
 550         (*new_auth_tok) = &auth_tok_list_item->auth_tok;
 551         if ((rc = parse_packet_length(&data[(*packet_size)], &body_size,
 552                                       &length_size))) {
 553                 printk(KERN_WARNING "Error parsing packet length; "
 554                        "rc = [%d]\n", rc);
 555                 goto out_free;
 556         }
 557         if (unlikely(body_size < (ECRYPTFS_SIG_SIZE + 2))) {
 558                 printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
 559                 rc = -EINVAL;
 560                 goto out_free;
 561         }
 562         (*packet_size) += length_size;
 563         if (unlikely((*packet_size) + body_size > max_packet_size)) {
 564                 printk(KERN_WARNING "Packet size exceeds max\n");
 565                 rc = -EINVAL;
 566                 goto out_free;
 567         }
 568         if (unlikely(data[(*packet_size)++] != 0x03)) {
 569                 printk(KERN_WARNING "Unknown version number [%d]\n",
 570                        data[(*packet_size) - 1]);
 571                 rc = -EINVAL;
 572                 goto out_free;
 573         }
 574         ecryptfs_to_hex((*new_auth_tok)->token.private_key.signature,
 575                         &data[(*packet_size)], ECRYPTFS_SIG_SIZE);
 576         *packet_size += ECRYPTFS_SIG_SIZE;
 577         /* This byte is skipped because the kernel does not need to
 578          * know which public key encryption algorithm was used */
 579         (*packet_size)++;
 580         (*new_auth_tok)->session_key.encrypted_key_size =
 581                 body_size - (ECRYPTFS_SIG_SIZE + 2);
 582         if ((*new_auth_tok)->session_key.encrypted_key_size
 583             > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
 584                 printk(KERN_WARNING "Tag 1 packet contains key larger "
 585                        "than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES");
 586                 rc = -EINVAL;
 587                 goto out;
 588         }
 589         memcpy((*new_auth_tok)->session_key.encrypted_key,
 590                &data[(*packet_size)], (body_size - (ECRYPTFS_SIG_SIZE + 2)));
 591         (*packet_size) += (*new_auth_tok)->session_key.encrypted_key_size;
 592         (*new_auth_tok)->session_key.flags &=
 593                 ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
 594         (*new_auth_tok)->session_key.flags |=
 595                 ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
 596         (*new_auth_tok)->token_type = ECRYPTFS_PRIVATE_KEY;
 597         (*new_auth_tok)->flags = 0;
 598         (*new_auth_tok)->session_key.flags &=
 599                 ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
 600         (*new_auth_tok)->session_key.flags &=
 601                 ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
 602         list_add(&auth_tok_list_item->list, auth_tok_list);
 603         goto out;
 604 out_free:
 605         (*new_auth_tok) = NULL;
 606         memset(auth_tok_list_item, 0,
 607                sizeof(struct ecryptfs_auth_tok_list_item));
 608         kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
 609                         auth_tok_list_item);
 610 out:
 611         if (rc)
 612                 (*packet_size) = 0;
 613         return rc;
 614 }
 615
 616 /**
 617  * parse_tag_3_packet
 618  * @crypt_stat: The cryptographic context to modify based on packet
 619  *              contents.
 620  * @data: The raw bytes of the packet.
 621  * @auth_tok_list: eCryptfs parses packets into authentication tokens;
 622  *                 a new authentication token will be placed at the end
 623  *                 of this list for this packet.
 624  * @new_auth_tok: Pointer to a pointer to memory that this function
 625  *                allocates; sets the memory address of the pointer to
 626  *                NULL on error. This object is added to the
 627  *                auth_tok_list.
 628  * @packet_size: This function writes the size of the parsed packet
 629  *               into this memory location; zero on error.
 630  * @max_packet_size: maximum number of bytes to parse
 631  *
 632  * Returns zero on success; non-zero on error.
 633  */
 634 static int
 635 parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
 636                    unsigned char *data, struct list_head *auth_tok_list,
 637                    struct ecryptfs_auth_tok **new_auth_tok,
 638                    size_t *packet_size, size_t max_packet_size)
 639 {
 640         size_t body_size;
 641         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
 642         size_t length_size;
 643         int rc = 0;
 644
 645         (*packet_size) = 0;
 646         (*new_auth_tok) = NULL;
 647         /**
 648          *This format is inspired by OpenPGP; see RFC 2440
 649          * packet tag 3
 650          *
 651          * Tag 3 identifier (1 byte)
 652          * Max Tag 3 packet size (max 3 bytes)
 653          * Version (1 byte)
 654          * Cipher code (1 byte)
 655          * S2K specifier (1 byte)
 656          * Hash identifier (1 byte)
 657          * Salt (ECRYPTFS_SALT_SIZE)
 658          * Hash iterations (1 byte)
 659          * Encrypted key (arbitrary)
 660          *
 661          * (ECRYPTFS_SALT_SIZE + 7) minimum packet size
 662          */
 663         if (max_packet_size < (ECRYPTFS_SALT_SIZE + 7)) {
 664                 printk(KERN_ERR "Max packet size too large\n");
 665                 rc = -EINVAL;
 666                 goto out;
 667         }
 668         if (data[(*packet_size)++] != ECRYPTFS_TAG_3_PACKET_TYPE) {
 669                 printk(KERN_ERR "First byte != 0x%.2x; invalid packet\n",
 670                        ECRYPTFS_TAG_3_PACKET_TYPE);
 671                 rc = -EINVAL;
 672                 goto out;
 673         }
 674         /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
 675          * at end of function upon failure */
 676         auth_tok_list_item =
 677             kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
 678         if (!auth_tok_list_item) {
 679                 printk(KERN_ERR "Unable to allocate memory\n");
 680                 rc = -ENOMEM;
 681                 goto out;
 682         }
 683         (*new_auth_tok) = &auth_tok_list_item->auth_tok;
 684         if ((rc = parse_packet_length(&data[(*packet_size)], &body_size,
 685                                       &length_size))) {
 686                 printk(KERN_WARNING "Error parsing packet length; rc = [%d]\n",
 687                        rc);
 688                 goto out_free;
 689         }
 690         if (unlikely(body_size < (ECRYPTFS_SALT_SIZE + 5))) {
 691                 printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
 692                 rc = -EINVAL;
 693                 goto out_free;
 694         }
 695         (*packet_size) += length_size;
 696         if (unlikely((*packet_size) + body_size > max_packet_size)) {
 697                 printk(KERN_ERR "Packet size exceeds max\n");
 698                 rc = -EINVAL;
 699                 goto out_free;
 700         }
 701         (*new_auth_tok)->session_key.encrypted_key_size =
 702                 (body_size - (ECRYPTFS_SALT_SIZE + 5));
 703         if (unlikely(data[(*packet_size)++] != 0x04)) {
 704                 printk(KERN_WARNING "Unknown version number [%d]\n",
 705                        data[(*packet_size) - 1]);
 706                 rc = -EINVAL;
 707                 goto out_free;
 708         }
 709         ecryptfs_cipher_code_to_string(crypt_stat->cipher,
 710                                        (u16)data[(*packet_size)]);
 711         /* A little extra work to differentiate among the AES key
 712          * sizes; see RFC2440 */
 713         switch(data[(*packet_size)++]) {
 714         case RFC2440_CIPHER_AES_192:
 715                 crypt_stat->key_size = 24;
 716                 break;
 717         default:
 718                 crypt_stat->key_size =
 719                         (*new_auth_tok)->session_key.encrypted_key_size;
 720         }
 721         ecryptfs_init_crypt_ctx(crypt_stat);
 722         if (unlikely(data[(*packet_size)++] != 0x03)) {
 723                 printk(KERN_WARNING "Only S2K ID 3 is currently supported\n");
 724                 rc = -ENOSYS;
 725                 goto out_free;
 726         }
 727         /* TODO: finish the hash mapping */
 728         switch (data[(*packet_size)++]) {
 729         case 0x01: /* See RFC2440 for these numbers and their mappings */
 730                 /* Choose MD5 */
 731                 memcpy((*new_auth_tok)->token.password.salt,
 732                        &data[(*packet_size)], ECRYPTFS_SALT_SIZE);
 733                 (*packet_size) += ECRYPTFS_SALT_SIZE;
 734                 /* This conversion was taken straight from RFC2440 */
 735                 (*new_auth_tok)->token.password.hash_iterations =
 736                         ((u32) 16 + (data[(*packet_size)] & 15))
 737                                 << ((data[(*packet_size)] >> 4) + 6);
 738                 (*packet_size)++;
 739                 /* Friendly reminder:
 740                  * (*new_auth_tok)->session_key.encrypted_key_size =
 741                  *         (body_size - (ECRYPTFS_SALT_SIZE + 5)); */
 742                 memcpy((*new_auth_tok)->session_key.encrypted_key,
 743                        &data[(*packet_size)],
 744                        (*new_auth_tok)->session_key.encrypted_key_size);
 745                 (*packet_size) +=
 746                         (*new_auth_tok)->session_key.encrypted_key_size;
 747                 (*new_auth_tok)->session_key.flags &=
 748                         ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
 749                 (*new_auth_tok)->session_key.flags |=
 750                         ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
 751                 (*new_auth_tok)->token.password.hash_algo = 0x01; /* MD5 */
 752                 break;
 753         default:
 754                 ecryptfs_printk(KERN_ERR, "Unsupported hash algorithm: "
 755                                 "[%d]\n", data[(*packet_size) - 1]);
 756                 rc = -ENOSYS;
 757                 goto out_free;
 758         }
 759         (*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;
 760         /* TODO: Parametarize; we might actually want userspace to
 761          * decrypt the session key. */
 762         (*new_auth_tok)->session_key.flags &=
 763                             ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
 764         (*new_auth_tok)->session_key.flags &=
 765                             ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
 766         list_add(&auth_tok_list_item->list, auth_tok_list);
 767         goto out;
 768 out_free:
 769         (*new_auth_tok) = NULL;
 770         memset(auth_tok_list_item, 0,
 771                sizeof(struct ecryptfs_auth_tok_list_item));
 772         kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
 773                         auth_tok_list_item);
 774 out:
 775         if (rc)
 776                 (*packet_size) = 0;
 777         return rc;
 778 }
 779
 780 /**
 781  * parse_tag_11_packet
 782  * @data: The raw bytes of the packet
 783  * @contents: This function writes the data contents of the literal
 784  *            packet into this memory location
 785  * @max_contents_bytes: The maximum number of bytes that this function
 786  *                      is allowed to write into contents
 787  * @tag_11_contents_size: This function writes the size of the parsed
 788  *                        contents into this memory location; zero on
 789  *                        error
 790  * @packet_size: This function writes the size of the parsed packet
 791  *               into this memory location; zero on error
 792  * @max_packet_size: maximum number of bytes to parse
 793  *
 794  * Returns zero on success; non-zero on error.
 795  */
 796 static int
 797 parse_tag_11_packet(unsigned char *data, unsigned char *contents,
 798                     size_t max_contents_bytes, size_t *tag_11_contents_size,
 799                     size_t *packet_size, size_t max_packet_size)
 800 {
 801         size_t body_size;
 802         size_t length_size;
 803         int rc = 0;
 804
 805         (*packet_size) = 0;
 806         (*tag_11_contents_size) = 0;
 807         /* This format is inspired by OpenPGP; see RFC 2440
 808          * packet tag 11
 809          *
 810          * Tag 11 identifier (1 byte)
 811          * Max Tag 11 packet size (max 3 bytes)
 812          * Binary format specifier (1 byte)
 813          * Filename length (1 byte)
 814          * Filename ("_CONSOLE") (8 bytes)
 815          * Modification date (4 bytes)
 816          * Literal data (arbitrary)
 817          *
 818          * We need at least 16 bytes of data for the packet to even be
 819          * valid.
 820          */
 821         if (max_packet_size < 16) {
 822                 printk(KERN_ERR "Maximum packet size too small\n");
 823                 rc = -EINVAL;
 824                 goto out;
 825         }
 826         if (data[(*packet_size)++] != ECRYPTFS_TAG_11_PACKET_TYPE) {
 827                 printk(KERN_WARNING "Invalid tag 11 packet format\n");
 828                 rc = -EINVAL;
 829                 goto out;
 830         }
 831         if ((rc = parse_packet_length(&data[(*packet_size)], &body_size,
 832                                       &length_size))) {
 833                 printk(KERN_WARNING "Invalid tag 11 packet format\n");
 834                 goto out;
 835         }
 836         if (body_size < 14) {
 837                 printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
 838                 rc = -EINVAL;
 839                 goto out;
 840         }
 841         (*packet_size) += length_size;
 842         (*tag_11_contents_size) = (body_size - 14);
 843         if (unlikely((*packet_size) + body_size + 1 > max_packet_size)) {
 844                 printk(KERN_ERR "Packet size exceeds max\n");
 845                 rc = -EINVAL;
 846                 goto out;
 847         }
 848         if (data[(*packet_size)++] != 0x62) {
 849                 printk(KERN_WARNING "Unrecognizable packet\n");
 850                 rc = -EINVAL;
 851                 goto out;
 852         }
 853         if (data[(*packet_size)++] != 0x08) {
 854                 printk(KERN_WARNING "Unrecognizable packet\n");
 855                 rc = -EINVAL;
 856                 goto out;
 857         }
 858         (*packet_size) += 12; /* Ignore filename and modification date */
 859         memcpy(contents, &data[(*packet_size)], (*tag_11_contents_size));
 860         (*packet_size) += (*tag_11_contents_size);
 861 out:
 862         if (rc) {
 863                 (*packet_size) = 0;
 864                 (*tag_11_contents_size) = 0;
 865         }
 866         return rc;
 867 }
 868
 869 static int
 870 ecryptfs_find_global_auth_tok_for_sig(
 871         struct ecryptfs_global_auth_tok **global_auth_tok,
 872         struct ecryptfs_mount_crypt_stat *mount_crypt_stat, char *sig)
 873 {
 874         struct ecryptfs_global_auth_tok *walker;
 875         int rc = 0;
 876
 877         (*global_auth_tok) = NULL;
 878         mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
 879         list_for_each_entry(walker,
 880                             &mount_crypt_stat->global_auth_tok_list,
 881                             mount_crypt_stat_list) {
 882                 if (memcmp(walker->sig, sig, ECRYPTFS_SIG_SIZE_HEX) == 0) {
 883                         (*global_auth_tok) = walker;
 884                         goto out;
 885                 }
 886         }
 887         rc = -EINVAL;
 888 out:
 889         mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
 890         return rc;
 891 }
 892
 893 /**
 894  * ecryptfs_verify_version
 895  * @version: The version number to confirm
 896  *
 897  * Returns zero on good version; non-zero otherwise
 898  */
 899 static int ecryptfs_verify_version(u16 version)
 900 {
 901         int rc = 0;
 902         unsigned char major;
 903         unsigned char minor;
 904
 905         major = ((version >> 8) & 0xFF);
 906         minor = (version & 0xFF);
 907         if (major != ECRYPTFS_VERSION_MAJOR) {
 908                 ecryptfs_printk(KERN_ERR, "Major version number mismatch. "
 909                                 "Expected [%d]; got [%d]\n",
 910                                 ECRYPTFS_VERSION_MAJOR, major);
 911                 rc = -EINVAL;
 912                 goto out;
 913         }
 914         if (minor != ECRYPTFS_VERSION_MINOR) {
 915                 ecryptfs_printk(KERN_ERR, "Minor version number mismatch. "
 916                                 "Expected [%d]; got [%d]\n",
 917                                 ECRYPTFS_VERSION_MINOR, minor);
 918                 rc = -EINVAL;
 919                 goto out;
 920         }
 921 out:
 922         return rc;
 923 }
 924
 925 int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
 926                                       struct ecryptfs_auth_tok **auth_tok,
 927                                       char *sig)
 928 {
 929         int rc = 0;
 930
 931         (*auth_tok_key) = request_key(&key_type_user, sig, NULL);
 932         if (!(*auth_tok_key) || IS_ERR(*auth_tok_key)) {
 933                 printk(KERN_ERR "Could not find key with description: [%s]\n",
 934                        sig);
 935                 process_request_key_err(PTR_ERR(*auth_tok_key));
 936                 rc = -EINVAL;
 937                 goto out;
 938         }
 939         (*auth_tok) = ecryptfs_get_key_payload_data(*auth_tok_key);
 940         if (ecryptfs_verify_version((*auth_tok)->version)) {
 941                 printk(KERN_ERR
 942                        "Data structure version mismatch. "
 943                        "Userspace tools must match eCryptfs "
 944                        "kernel module with major version [%d] "
 945                        "and minor version [%d]\n",
 946                        ECRYPTFS_VERSION_MAJOR,
 947                        ECRYPTFS_VERSION_MINOR);
 948                 rc = -EINVAL;
 949                 goto out;
 950         }
 951         if ((*auth_tok)->token_type != ECRYPTFS_PASSWORD
 952             && (*auth_tok)->token_type != ECRYPTFS_PRIVATE_KEY) {
 953                 printk(KERN_ERR "Invalid auth_tok structure "
 954                        "returned from key query\n");
 955                 rc = -EINVAL;
 956                 goto out;
 957         }
 958 out:
 959         return rc;
 960 }
 961
 962 /**
 963  * ecryptfs_find_auth_tok_for_sig
 964  * @auth_tok: Set to the matching auth_tok; NULL if not found
 965  * @crypt_stat: inode crypt_stat crypto context
 966  * @sig: Sig of auth_tok to find
 967  *
 968  * For now, this function simply looks at the registered auth_tok's
 969  * linked off the mount_crypt_stat, so all the auth_toks that can be
 970  * used must be registered at mount time. This function could
 971  * potentially try a lot harder to find auth_tok's (e.g., by calling
 972  * out to ecryptfsd to dynamically retrieve an auth_tok object) so
 973  * that static registration of auth_tok's will no longer be necessary.
 974  *
 975  * Returns zero on no error; non-zero on error
 976  */
 977 static int
 978 ecryptfs_find_auth_tok_for_sig(
 979         struct ecryptfs_auth_tok **auth_tok,
 980         struct ecryptfs_crypt_stat *crypt_stat, char *sig)
 981 {
 982         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
 983                 crypt_stat->mount_crypt_stat;
 984         struct ecryptfs_global_auth_tok *global_auth_tok;
 985         int rc = 0;
 986
 987         (*auth_tok) = NULL;
 988         if (ecryptfs_find_global_auth_tok_for_sig(&global_auth_tok,
 989                                                   mount_crypt_stat, sig)) {
 990                 struct key *auth_tok_key;
 991
 992                 rc = ecryptfs_keyring_auth_tok_for_sig(&auth_tok_key, auth_tok,
 993                                                        sig);
 994         } else
 995                 (*auth_tok) = global_auth_tok->global_auth_tok;
 996         return rc;
 997 }
 998
 999 /**
1000  * decrypt_passphrase_encrypted_session_key - Decrypt the session key with the given auth_tok.
1001  * @auth_tok: The passphrase authentication token to use to encrypt the FEK
1002  * @crypt_stat: The cryptographic context
1003  *
1004  * Returns zero on success; non-zero error otherwise
1005  */
1006 static int
1007 decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
1008                                          struct ecryptfs_crypt_stat *crypt_stat)
1009 {
1010         struct scatterlist dst_sg;
1011         struct scatterlist src_sg;
1012         struct mutex *tfm_mutex = NULL;
1013         struct blkcipher_desc desc = {
1014                 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
1015         };
1016         int rc = 0;
1017
1018         if (unlikely(ecryptfs_verbosity > 0)) {
1019                 ecryptfs_printk(
1020                         KERN_DEBUG, "Session key encryption key (size [%d]):\n",
1021                         auth_tok->token.password.session_key_encryption_key_bytes);
1022                 ecryptfs_dump_hex(
1023                         auth_tok->token.password.session_key_encryption_key,
1024                         auth_tok->token.password.session_key_encryption_key_bytes);
1025         }
1026         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,
1027                                                         crypt_stat->cipher);
1028         if (unlikely(rc)) {
1029                 printk(KERN_ERR "Internal error whilst attempting to get "
1030                        "tfm and mutex for cipher name [%s]; rc = [%d]\n",
1031                        crypt_stat->cipher, rc);
1032                 goto out;
1033         }
1034         if ((rc = virt_to_scatterlist(auth_tok->session_key.encrypted_key,
1035                                       auth_tok->session_key.encrypted_key_size,
1036                                       &src_sg, 1)) != 1) {
1037                 printk(KERN_ERR "Internal error whilst attempting to convert "
1038                         "auth_tok->session_key.encrypted_key to scatterlist; "
1039                         "expected rc = 1; got rc = [%d]. "
1040                        "auth_tok->session_key.encrypted_key_size = [%d]\n", rc,
1041                         auth_tok->session_key.encrypted_key_size);
1042                 goto out;
1043         }
1044         auth_tok->session_key.decrypted_key_size =
1045                 auth_tok->session_key.encrypted_key_size;
1046         if ((rc = virt_to_scatterlist(auth_tok->session_key.decrypted_key,
1047                                       auth_tok->session_key.decrypted_key_size,
1048                                       &dst_sg, 1)) != 1) {
1049                 printk(KERN_ERR "Internal error whilst attempting to convert "
1050                         "auth_tok->session_key.decrypted_key to scatterlist; "
1051                         "expected rc = 1; got rc = [%d]\n", rc);
1052                 goto out;
1053         }
1054         mutex_lock(tfm_mutex);
1055         rc = crypto_blkcipher_setkey(
1056                 desc.tfm, auth_tok->token.password.session_key_encryption_key,
1057                 crypt_stat->key_size);
1058         if (unlikely(rc < 0)) {
1059                 mutex_unlock(tfm_mutex);
1060                 printk(KERN_ERR "Error setting key for crypto context\n");
1061                 rc = -EINVAL;
1062                 goto out;
1063         }
1064         rc = crypto_blkcipher_decrypt(&desc, &dst_sg, &src_sg,
1065                                       auth_tok->session_key.encrypted_key_size);
1066         mutex_unlock(tfm_mutex);
1067         if (unlikely(rc)) {
1068                 printk(KERN_ERR "Error decrypting; rc = [%d]\n", rc);
1069                 goto out;
1070         }
1071         auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1072         memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
1073                auth_tok->session_key.decrypted_key_size);
1074         crypt_stat->flags |= ECRYPTFS_KEY_VALID;
1075         if (unlikely(ecryptfs_verbosity > 0)) {
1076                 ecryptfs_printk(KERN_DEBUG, "FEK of size [%d]:\n",
1077                                 crypt_stat->key_size);
1078                 ecryptfs_dump_hex(crypt_stat->key,
1079                                   crypt_stat->key_size);
1080         }
1081 out:
1082         return rc;
1083 }
1084
1085 int ecryptfs_get_auth_tok_sig(char **sig, struct ecryptfs_auth_tok *auth_tok)
1086 {
1087         int rc = 0;
1088
1089         (*sig) = NULL;
1090         switch (auth_tok->token_type) {
1091         case ECRYPTFS_PASSWORD:
1092                 (*sig) = auth_tok->token.password.signature;
1093                 break;
1094         case ECRYPTFS_PRIVATE_KEY:
1095                 (*sig) = auth_tok->token.private_key.signature;
1096                 break;
1097         default:
1098                 printk(KERN_ERR "Cannot get sig for auth_tok of type [%d]\n",
1099                        auth_tok->token_type);
1100                 rc = -EINVAL;
1101         }
1102         return rc;
1103 }
1104
1105 /**
1106  * ecryptfs_parse_packet_set
1107  * @crypt_stat: The cryptographic context
1108  * @src: Virtual address of region of memory containing the packets
1109  * @ecryptfs_dentry: The eCryptfs dentry associated with the packet set
1110  *
1111  * Get crypt_stat to have the file's session key if the requisite key
1112  * is available to decrypt the session key.
1113  *
1114  * Returns Zero if a valid authentication token was retrieved and
1115  * processed; negative value for file not encrypted or for error
1116  * conditions.
1117  */
1118 int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
1119                               unsigned char *src,
1120                               struct dentry *ecryptfs_dentry)
1121 {
1122         size_t i = 0;
1123         size_t found_auth_tok;
1124         size_t next_packet_is_auth_tok_packet;
1125         struct list_head auth_tok_list;
1126         struct ecryptfs_auth_tok *matching_auth_tok = NULL;
1127         struct ecryptfs_auth_tok *candidate_auth_tok = NULL;
1128         char *candidate_auth_tok_sig;
1129         size_t packet_size;
1130         struct ecryptfs_auth_tok *new_auth_tok;
1131         unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE];
1132         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1133         size_t tag_11_contents_size;
1134         size_t tag_11_packet_size;
1135         int rc = 0;
1136
1137         INIT_LIST_HEAD(&auth_tok_list);
1138         /* Parse the header to find as many packets as we can; these will be
1139          * added the our &auth_tok_list */
1140         next_packet_is_auth_tok_packet = 1;
1141         while (next_packet_is_auth_tok_packet) {
1142                 size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i);
1143
1144                 switch (src[i]) {
1145                 case ECRYPTFS_TAG_3_PACKET_TYPE:
1146                         rc = parse_tag_3_packet(crypt_stat,
1147                                                 (unsigned char *)&src[i],
1148                                                 &auth_tok_list, &new_auth_tok,
1149                                                 &packet_size, max_packet_size);
1150                         if (rc) {
1151                                 ecryptfs_printk(KERN_ERR, "Error parsing "
1152                                                 "tag 3 packet\n");
1153                                 rc = -EIO;
1154                                 goto out_wipe_list;
1155                         }
1156                         i += packet_size;
1157                         rc = parse_tag_11_packet((unsigned char *)&src[i],
1158                                                  sig_tmp_space,
1159                                                  ECRYPTFS_SIG_SIZE,
1160                                                  &tag_11_contents_size,
1161                                                  &tag_11_packet_size,
1162                                                  max_packet_size);
1163                         if (rc) {
1164                                 ecryptfs_printk(KERN_ERR, "No valid "
1165                                                 "(ecryptfs-specific) literal "
1166                                                 "packet containing "
1167                                                 "authentication token "
1168                                                 "signature found after "
1169                                                 "tag 3 packet\n");
1170                                 rc = -EIO;
1171                                 goto out_wipe_list;
1172                         }
1173                         i += tag_11_packet_size;
1174                         if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {
1175                                 ecryptfs_printk(KERN_ERR, "Expected "
1176                                                 "signature of size [%d]; "
1177                                                 "read size [%d]\n",
1178                                                 ECRYPTFS_SIG_SIZE,
1179                                                 tag_11_contents_size);
1180                                 rc = -EIO;
1181                                 goto out_wipe_list;
1182                         }
1183                         ecryptfs_to_hex(new_auth_tok->token.password.signature,
1184                                         sig_tmp_space, tag_11_contents_size);
1185                         new_auth_tok->token.password.signature[
1186                                 ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';
1187                         crypt_stat->flags |= ECRYPTFS_ENCRYPTED;
1188                         break;
1189                 case ECRYPTFS_TAG_1_PACKET_TYPE:
1190                         rc = parse_tag_1_packet(crypt_stat,
1191                                                 (unsigned char *)&src[i],
1192                                                 &auth_tok_list, &new_auth_tok,
1193                                                 &packet_size, max_packet_size);
1194                         if (rc) {
1195                                 ecryptfs_printk(KERN_ERR, "Error parsing "
1196                                                 "tag 1 packet\n");
1197                                 rc = -EIO;
1198                                 goto out_wipe_list;
1199                         }
1200                         i += packet_size;
1201                         crypt_stat->flags |= ECRYPTFS_ENCRYPTED;
1202                         break;
1203                 case ECRYPTFS_TAG_11_PACKET_TYPE:
1204                         ecryptfs_printk(KERN_WARNING, "Invalid packet set "
1205                                         "(Tag 11 not allowed by itself)\n");
1206                         rc = -EIO;
1207                         goto out_wipe_list;
1208                         break;
1209                 default:
1210                         ecryptfs_printk(KERN_DEBUG, "No packet at offset "
1211                                         "[%d] of the file header; hex value of "
1212                                         "character is [0x%.2x]\n", i, src[i]);
1213                         next_packet_is_auth_tok_packet = 0;
1214                 }
1215         }
1216         if (list_empty(&auth_tok_list)) {
1217                 printk(KERN_ERR "The lower file appears to be a non-encrypted "
1218                        "eCryptfs file; this is not supported in this version "
1219                        "of the eCryptfs kernel module\n");
1220                 rc = -EINVAL;
1221                 goto out;
1222         }
1223         /* auth_tok_list contains the set of authentication tokens
1224          * parsed from the metadata. We need to find a matching
1225          * authentication token that has the secret component(s)
1226          * necessary to decrypt the EFEK in the auth_tok parsed from
1227          * the metadata. There may be several potential matches, but
1228          * just one will be sufficient to decrypt to get the FEK. */
1229 find_next_matching_auth_tok:
1230         found_auth_tok = 0;
1231         list_for_each_entry(auth_tok_list_item, &auth_tok_list, list) {
1232                 candidate_auth_tok = &auth_tok_list_item->auth_tok;
1233                 if (unlikely(ecryptfs_verbosity > 0)) {
1234                         ecryptfs_printk(KERN_DEBUG,
1235                                         "Considering cadidate auth tok:\n");
1236                         ecryptfs_dump_auth_tok(candidate_auth_tok);
1237                 }
1238                 if ((rc = ecryptfs_get_auth_tok_sig(&candidate_auth_tok_sig,
1239                                                     candidate_auth_tok))) {
1240                         printk(KERN_ERR
1241                                "Unrecognized candidate auth tok type: [%d]\n",
1242                                candidate_auth_tok->token_type);
1243                         rc = -EINVAL;
1244                         goto out_wipe_list;
1245                 }
1246                 if ((rc = ecryptfs_find_auth_tok_for_sig(
1247                              &matching_auth_tok, crypt_stat,
1248                              candidate_auth_tok_sig)))
1249                         rc = 0;
1250                 if (matching_auth_tok) {
1251                         found_auth_tok = 1;
1252                         goto found_matching_auth_tok;
1253                 }
1254         }
1255         if (!found_auth_tok) {
1256                 ecryptfs_printk(KERN_ERR, "Could not find a usable "
1257                                 "authentication token\n");
1258                 rc = -EIO;
1259                 goto out_wipe_list;
1260         }
1261 found_matching_auth_tok:
1262         if (candidate_auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
1263                 memcpy(&(candidate_auth_tok->token.private_key),
1264                        &(matching_auth_tok->token.private_key),
1265                        sizeof(struct ecryptfs_private_key));
1266                 rc = decrypt_pki_encrypted_session_key(candidate_auth_tok,
1267                                                        crypt_stat);
1268         } else if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD) {
1269                 memcpy(&(candidate_auth_tok->token.password),
1270                        &(matching_auth_tok->token.password),
1271                        sizeof(struct ecryptfs_password));
1272                 rc = decrypt_passphrase_encrypted_session_key(
1273                         candidate_auth_tok, crypt_stat);
1274         }
1275         if (rc) {
1276                 struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;
1277
1278                 ecryptfs_printk(KERN_WARNING, "Error decrypting the "
1279                                 "session key for authentication token with sig "
1280                                 "[%.*s]; rc = [%d]. Removing auth tok "
1281                                 "candidate from the list and searching for "
1282                                 "the next match.\n", candidate_auth_tok_sig,
1283                                 ECRYPTFS_SIG_SIZE_HEX, rc);
1284                 list_for_each_entry_safe(auth_tok_list_item,
1285                                          auth_tok_list_item_tmp,
1286                                          &auth_tok_list, list) {
1287                         if (candidate_auth_tok
1288                             == &auth_tok_list_item->auth_tok) {
1289                                 list_del(&auth_tok_list_item->list);
1290                                 kmem_cache_free(
1291                                         ecryptfs_auth_tok_list_item_cache,
1292                                         auth_tok_list_item);
1293                                 goto find_next_matching_auth_tok;
1294                         }
1295                 }
1296                 BUG();
1297         }
1298         rc = ecryptfs_compute_root_iv(crypt_stat);
1299         if (rc) {
1300                 ecryptfs_printk(KERN_ERR, "Error computing "
1301                                 "the root IV\n");
1302                 goto out_wipe_list;
1303         }
1304         rc = ecryptfs_init_crypt_ctx(crypt_stat);
1305         if (rc) {
1306                 ecryptfs_printk(KERN_ERR, "Error initializing crypto "
1307                                 "context for cipher [%s]; rc = [%d]\n",
1308                                 crypt_stat->cipher, rc);
1309         }
1310 out_wipe_list:
1311         wipe_auth_tok_list(&auth_tok_list);
1312 out:
1313         return rc;
1314 }
1315
1316 static int
1317 pki_encrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
1318                         struct ecryptfs_crypt_stat *crypt_stat,
1319                         struct ecryptfs_key_record *key_rec)
1320 {
1321         struct ecryptfs_msg_ctx *msg_ctx = NULL;
1322         char *netlink_payload;
1323         size_t netlink_payload_length;
1324         struct ecryptfs_message *msg;
1325         int rc;
1326
1327         rc = write_tag_66_packet(auth_tok->token.private_key.signature,
1328                                  ecryptfs_code_for_cipher_string(crypt_stat),
1329                                  crypt_stat, &netlink_payload,
1330                                  &netlink_payload_length);
1331         if (rc) {
1332                 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet\n");
1333                 goto out;
1334         }
1335         rc = ecryptfs_send_message(ecryptfs_transport, netlink_payload,
1336                                    netlink_payload_length, &msg_ctx);
1337         if (rc) {
1338                 ecryptfs_printk(KERN_ERR, "Error sending netlink message\n");
1339                 goto out;
1340         }
1341         rc = ecryptfs_wait_for_response(msg_ctx, &msg);
1342         if (rc) {
1343                 ecryptfs_printk(KERN_ERR, "Failed to receive tag 67 packet "
1344                                 "from the user space daemon\n");
1345                 rc = -EIO;
1346                 goto out;
1347         }
1348         rc = parse_tag_67_packet(key_rec, msg);
1349         if (rc)
1350                 ecryptfs_printk(KERN_ERR, "Error parsing tag 67 packet\n");
1351         kfree(msg);
1352 out:
1353         if (netlink_payload)
1354                 kfree(netlink_payload);
1355         return rc;
1356 }
1357 /**
1358  * write_tag_1_packet - Write an RFC2440-compatible tag 1 (public key) packet
1359  * @dest: Buffer into which to write the packet
1360  * @remaining_bytes: Maximum number of bytes that can be writtn
1361  * @auth_tok: The authentication token used for generating the tag 1 packet
1362  * @crypt_stat: The cryptographic context
1363  * @key_rec: The key record struct for the tag 1 packet
1364  * @packet_size: This function will write the number of bytes that end
1365  *               up constituting the packet; set to zero on error
1366  *
1367  * Returns zero on success; non-zero on error.
1368  */
1369 static int
1370 write_tag_1_packet(char *dest, size_t *remaining_bytes,
1371                    struct ecryptfs_auth_tok *auth_tok,
1372                    struct ecryptfs_crypt_stat *crypt_stat,
1373                    struct ecryptfs_key_record *key_rec, size_t *packet_size)
1374 {
1375         size_t i;
1376         size_t encrypted_session_key_valid = 0;
1377         size_t packet_size_length;
1378         size_t max_packet_size;
1379         int rc = 0;
1380
1381         (*packet_size) = 0;
1382         ecryptfs_from_hex(key_rec->sig, auth_tok->token.private_key.signature,
1383                           ECRYPTFS_SIG_SIZE);
1384         encrypted_session_key_valid = 0;
1385         for (i = 0; i < crypt_stat->key_size; i++)
1386                 encrypted_session_key_valid |=
1387                         auth_tok->session_key.encrypted_key[i];
1388         if (encrypted_session_key_valid) {
1389                 memcpy(key_rec->enc_key,
1390                        auth_tok->session_key.encrypted_key,
1391                        auth_tok->session_key.encrypted_key_size);
1392                 goto encrypted_session_key_set;
1393         }
1394         if (auth_tok->session_key.encrypted_key_size == 0)
1395                 auth_tok->session_key.encrypted_key_size =
1396                         auth_tok->token.private_key.key_size;
1397         rc = pki_encrypt_session_key(auth_tok, crypt_stat, key_rec);
1398         if (rc) {
1399                 ecryptfs_printk(KERN_ERR, "Failed to encrypt session key "
1400                                 "via a pki");
1401                 goto out;
1402         }
1403         if (ecryptfs_verbosity > 0) {
1404                 ecryptfs_printk(KERN_DEBUG, "Encrypted key:\n");
1405                 ecryptfs_dump_hex(key_rec->enc_key, key_rec->enc_key_size);
1406         }
1407 encrypted_session_key_set:
1408         /* This format is inspired by OpenPGP; see RFC 2440
1409          * packet tag 1 */
1410         max_packet_size = (1                         /* Tag 1 identifier */
1411                            + 3                       /* Max Tag 1 packet size */
1412                            + 1                       /* Version */
1413                            + ECRYPTFS_SIG_SIZE       /* Key identifier */
1414                            + 1                       /* Cipher identifier */
1415                            + key_rec->enc_key_size); /* Encrypted key size */
1416         if (max_packet_size > (*remaining_bytes)) {
1417                 printk(KERN_ERR "Packet length larger than maximum allowable; "
1418                        "need up to [%td] bytes, but there are only [%td] "
1419                        "available\n", max_packet_size, (*remaining_bytes));
1420                 rc = -EINVAL;
1421                 goto out;
1422         }
1423         dest[(*packet_size)++] = ECRYPTFS_TAG_1_PACKET_TYPE;
1424         rc = write_packet_length(&dest[(*packet_size)], (max_packet_size - 4),
1425                                  &packet_size_length);
1426         if (rc) {
1427                 ecryptfs_printk(KERN_ERR, "Error generating tag 1 packet "
1428                                 "header; cannot generate packet length\n");
1429                 goto out;
1430         }
1431         (*packet_size) += packet_size_length;
1432         dest[(*packet_size)++] = 0x03; /* version 3 */
1433         memcpy(&dest[(*packet_size)], key_rec->sig, ECRYPTFS_SIG_SIZE);
1434         (*packet_size) += ECRYPTFS_SIG_SIZE;
1435         dest[(*packet_size)++] = RFC2440_CIPHER_RSA;
1436         memcpy(&dest[(*packet_size)], key_rec->enc_key,
1437                key_rec->enc_key_size);
1438         (*packet_size) += key_rec->enc_key_size;
1439 out:
1440         if (rc)
1441                 (*packet_size) = 0;
1442         else
1443                 (*remaining_bytes) -= (*packet_size);
1444         return rc;
1445 }
1446
1447 /**
1448  * write_tag_11_packet
1449  * @dest: Target into which Tag 11 packet is to be written
1450  * @remaining_bytes: Maximum packet length
1451  * @contents: Byte array of contents to copy in
1452  * @contents_length: Number of bytes in contents
1453  * @packet_length: Length of the Tag 11 packet written; zero on error
1454  *
1455  * Returns zero on success; non-zero on error.
1456  */
1457 static int
1458 write_tag_11_packet(char *dest, size_t *remaining_bytes, char *contents,
1459                     size_t contents_length, size_t *packet_length)
1460 {
1461         size_t packet_size_length;
1462         size_t max_packet_size;
1463         int rc = 0;
1464
1465         (*packet_length) = 0;
1466         /* This format is inspired by OpenPGP; see RFC 2440
1467          * packet tag 11 */
1468         max_packet_size = (1                   /* Tag 11 identifier */
1469                            + 3                 /* Max Tag 11 packet size */
1470                            + 1                 /* Binary format specifier */
1471                            + 1                 /* Filename length */
1472                            + 8                 /* Filename ("_CONSOLE") */
1473                            + 4                 /* Modification date */
1474                            + contents_length); /* Literal data */
1475         if (max_packet_size > (*remaining_bytes)) {
1476                 printk(KERN_ERR "Packet length larger than maximum allowable; "
1477                        "need up to [%td] bytes, but there are only [%td] "
1478                        "available\n", max_packet_size, (*remaining_bytes));
1479                 rc = -EINVAL;
1480                 goto out;
1481         }
1482         dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE;
1483         rc = write_packet_length(&dest[(*packet_length)],
1484                                  (max_packet_size - 4), &packet_size_length);
1485         if (rc) {
1486                 printk(KERN_ERR "Error generating tag 11 packet header; cannot "
1487                        "generate packet length. rc = [%d]\n", rc);
1488                 goto out;
1489         }
1490         (*packet_length) += packet_size_length;
1491         dest[(*packet_length)++] = 0x62; /* binary data format specifier */
1492         dest[(*packet_length)++] = 8;
1493         memcpy(&dest[(*packet_length)], "_CONSOLE", 8);
1494         (*packet_length) += 8;
1495         memset(&dest[(*packet_length)], 0x00, 4);
1496         (*packet_length) += 4;
1497         memcpy(&dest[(*packet_length)], contents, contents_length);
1498         (*packet_length) += contents_length;
1499  out:
1500         if (rc)
1501                 (*packet_length) = 0;
1502         else
1503                 (*remaining_bytes) -= (*packet_length);
1504         return rc;
1505 }
1506
1507 /**
1508  * write_tag_3_packet
1509  * @dest: Buffer into which to write the packet
1510  * @remaining_bytes: Maximum number of bytes that can be written
1511  * @auth_tok: Authentication token
1512  * @crypt_stat: The cryptographic context
1513  * @key_rec: encrypted key
1514  * @packet_size: This function will write the number of bytes that end
1515  *               up constituting the packet; set to zero on error
1516  *
1517  * Returns zero on success; non-zero on error.
1518  */
1519 static int
1520 write_tag_3_packet(char *dest, size_t *remaining_bytes,
1521                    struct ecryptfs_auth_tok *auth_tok,
1522                    struct ecryptfs_crypt_stat *crypt_stat,
1523                    struct ecryptfs_key_record *key_rec, size_t *packet_size)
1524 {
1525         size_t i;
1526         size_t encrypted_session_key_valid = 0;
1527         char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
1528         struct scatterlist dst_sg;
1529         struct scatterlist src_sg;
1530         struct mutex *tfm_mutex = NULL;
1531         size_t cipher_code;
1532         size_t packet_size_length;
1533         size_t max_packet_size;
1534         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
1535                 crypt_stat->mount_crypt_stat;
1536         struct blkcipher_desc desc = {
1537                 .tfm = NULL,
1538                 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
1539         };
1540         int rc = 0;
1541
1542         (*packet_size) = 0;
1543         ecryptfs_from_hex(key_rec->sig, auth_tok->token.password.signature,
1544                           ECRYPTFS_SIG_SIZE);
1545         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,
1546                                                         crypt_stat->cipher);
1547         if (unlikely(rc)) {
1548                 printk(KERN_ERR "Internal error whilst attempting to get "
1549                        "tfm and mutex for cipher name [%s]; rc = [%d]\n",
1550                        crypt_stat->cipher, rc);
1551                 goto out;
1552         }
1553         if (mount_crypt_stat->global_default_cipher_key_size == 0) {
1554                 struct blkcipher_alg *alg = crypto_blkcipher_alg(desc.tfm);
1555
1556                 printk(KERN_WARNING "No key size specified at mount; "
1557                        "defaulting to [%d]\n", alg->max_keysize);
1558                 mount_crypt_stat->global_default_cipher_key_size =
1559                         alg->max_keysize;
1560         }
1561         if (crypt_stat->key_size == 0)
1562                 crypt_stat->key_size =
1563                         mount_crypt_stat->global_default_cipher_key_size;
1564         if (auth_tok->session_key.encrypted_key_size == 0)
1565                 auth_tok->session_key.encrypted_key_size =
1566                         crypt_stat->key_size;
1567         if (crypt_stat->key_size == 24
1568             && strcmp("aes", crypt_stat->cipher) == 0) {
1569                 memset((crypt_stat->key + 24), 0, 8);
1570                 auth_tok->session_key.encrypted_key_size = 32;
1571         } else
1572                 auth_tok->session_key.encrypted_key_size = crypt_stat->key_size;
1573         key_rec->enc_key_size =
1574                 auth_tok->session_key.encrypted_key_size;
1575         encrypted_session_key_valid = 0;
1576         for (i = 0; i < auth_tok->session_key.encrypted_key_size; i++)
1577                 encrypted_session_key_valid |=
1578                         auth_tok->session_key.encrypted_key[i];
1579         if (encrypted_session_key_valid) {
1580                 ecryptfs_printk(KERN_DEBUG, "encrypted_session_key_valid != 0; "
1581                                 "using auth_tok->session_key.encrypted_key, "
1582                                 "where key_rec->enc_key_size = [%d]\n",
1583                                 key_rec->enc_key_size);
1584                 memcpy(key_rec->enc_key,
1585                        auth_tok->session_key.encrypted_key,
1586                        key_rec->enc_key_size);
1587                 goto encrypted_session_key_set;
1588         }
1589         if (auth_tok->token.password.flags &
1590             ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET) {
1591                 ecryptfs_printk(KERN_DEBUG, "Using previously generated "
1592                                 "session key encryption key of size [%d]\n",
1593                                 auth_tok->token.password.
1594                                 session_key_encryption_key_bytes);
1595                 memcpy(session_key_encryption_key,
1596                        auth_tok->token.password.session_key_encryption_key,
1597                        crypt_stat->key_size);
1598                 ecryptfs_printk(KERN_DEBUG,
1599                                 "Cached session key " "encryption key: \n");
1600                 if (ecryptfs_verbosity > 0)
1601                         ecryptfs_dump_hex(session_key_encryption_key, 16);
1602         }
1603         if (unlikely(ecryptfs_verbosity > 0)) {
1604                 ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");
1605                 ecryptfs_dump_hex(session_key_encryption_key, 16);
1606         }
1607         if ((rc = virt_to_scatterlist(crypt_stat->key,
1608                                       key_rec->enc_key_size, &src_sg, 1))
1609             != 1) {
1610                 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
1611                                 "for crypt_stat session key; expected rc = 1; "
1612                                 "got rc = [%d]. key_rec->enc_key_size = [%d]\n",
1613                                 rc, key_rec->enc_key_size);
1614                 rc = -ENOMEM;
1615                 goto out;
1616         }
1617         if ((rc = virt_to_scatterlist(key_rec->enc_key,
1618                                       key_rec->enc_key_size, &dst_sg, 1))
1619             != 1) {
1620                 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
1621                                 "for crypt_stat encrypted session key; "
1622                                 "expected rc = 1; got rc = [%d]. "
1623                                 "key_rec->enc_key_size = [%d]\n", rc,
1624                                 key_rec->enc_key_size);
1625                 rc = -ENOMEM;
1626                 goto out;
1627         }
1628         mutex_lock(tfm_mutex);
1629         rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key,
1630                                      crypt_stat->key_size);
1631         if (rc < 0) {
1632                 mutex_unlock(tfm_mutex);
1633                 ecryptfs_printk(KERN_ERR, "Error setting key for crypto "
1634                                 "context; rc = [%d]\n", rc);
1635                 goto out;
1636         }
1637         rc = 0;
1638         ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n",
1639                         crypt_stat->key_size);
1640         rc = crypto_blkcipher_encrypt(&desc, &dst_sg, &src_sg,
1641                                       (*key_rec).enc_key_size);
1642         mutex_unlock(tfm_mutex);
1643         if (rc) {
1644                 printk(KERN_ERR "Error encrypting; rc = [%d]\n", rc);
1645                 goto out;
1646         }
1647         ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");
1648         if (ecryptfs_verbosity > 0) {
1649                 ecryptfs_printk(KERN_DEBUG, "EFEK of size [%d]:\n",
1650                                 key_rec->enc_key_size);
1651                 ecryptfs_dump_hex(key_rec->enc_key,
1652                                   key_rec->enc_key_size);
1653         }
1654 encrypted_session_key_set:
1655         /* This format is inspired by OpenPGP; see RFC 2440
1656          * packet tag 3 */
1657         max_packet_size = (1                         /* Tag 3 identifier */
1658                            + 3                       /* Max Tag 3 packet size */
1659                            + 1                       /* Version */
1660                            + 1                       /* Cipher code */
1661                            + 1                       /* S2K specifier */
1662                            + 1                       /* Hash identifier */
1663                            + ECRYPTFS_SALT_SIZE      /* Salt */
1664                            + 1                       /* Hash iterations */
1665                            + key_rec->enc_key_size); /* Encrypted key size */
1666         if (max_packet_size > (*remaining_bytes)) {
1667                 printk(KERN_ERR "Packet too large; need up to [%td] bytes, but "
1668                        "there are only [%td] available\n", max_packet_size,
1669                        (*remaining_bytes));
1670                 rc = -EINVAL;
1671                 goto out;
1672         }
1673         dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE;
1674         /* Chop off the Tag 3 identifier(1) and Tag 3 packet size(3)
1675          * to get the number of octets in the actual Tag 3 packet */
1676         rc = write_packet_length(&dest[(*packet_size)], (max_packet_size - 4),
1677                                  &packet_size_length);
1678         if (rc) {
1679                 printk(KERN_ERR "Error generating tag 3 packet header; cannot "
1680                        "generate packet length. rc = [%d]\n", rc);
1681                 goto out;
1682         }
1683         (*packet_size) += packet_size_length;
1684         dest[(*packet_size)++] = 0x04; /* version 4 */
1685         /* TODO: Break from RFC2440 so that arbitrary ciphers can be
1686          * specified with strings */
1687         cipher_code = ecryptfs_code_for_cipher_string(crypt_stat);
1688         if (cipher_code == 0) {
1689                 ecryptfs_printk(KERN_WARNING, "Unable to generate code for "
1690                                 "cipher [%s]\n", crypt_stat->cipher);
1691                 rc = -EINVAL;
1692                 goto out;
1693         }
1694         dest[(*packet_size)++] = cipher_code;
1695         dest[(*packet_size)++] = 0x03;  /* S2K */
1696         dest[(*packet_size)++] = 0x01;  /* MD5 (TODO: parameterize) */
1697         memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,
1698                ECRYPTFS_SALT_SIZE);
1699         (*packet_size) += ECRYPTFS_SALT_SIZE;   /* salt */
1700         dest[(*packet_size)++] = 0x60;  /* hash iterations (65536) */
1701         memcpy(&dest[(*packet_size)], key_rec->enc_key,
1702                key_rec->enc_key_size);
1703         (*packet_size) += key_rec->enc_key_size;
1704 out:
1705         if (rc)
1706                 (*packet_size) = 0;
1707         else
1708                 (*remaining_bytes) -= (*packet_size);
1709         return rc;
1710 }
1711
1712 struct kmem_cache *ecryptfs_key_record_cache;
1713
1714 /**
1715  * ecryptfs_generate_key_packet_set
1716  * @dest_base: Virtual address from which to write the key record set
1717  * @crypt_stat: The cryptographic context from which the
1718  *              authentication tokens will be retrieved
1719  * @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat
1720  *                   for the global parameters
1721  * @len: The amount written
1722  * @max: The maximum amount of data allowed to be written
1723  *
1724  * Generates a key packet set and writes it to the virtual address
1725  * passed in.
1726  *
1727  * Returns zero on success; non-zero on error.
1728  */
1729 int
1730 ecryptfs_generate_key_packet_set(char *dest_base,
1731                                  struct ecryptfs_crypt_stat *crypt_stat,
1732                                  struct dentry *ecryptfs_dentry, size_t *len,
1733                                  size_t max)
1734 {
1735         struct ecryptfs_auth_tok *auth_tok;
1736         struct ecryptfs_global_auth_tok *global_auth_tok;
1737         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
1738                 &ecryptfs_superblock_to_private(
1739                         ecryptfs_dentry->d_sb)->mount_crypt_stat;
1740         size_t written;
1741         struct ecryptfs_key_record *key_rec;
1742         struct ecryptfs_key_sig *key_sig;
1743         int rc = 0;
1744
1745         (*len) = 0;
1746         mutex_lock(&crypt_stat->keysig_list_mutex);
1747         key_rec = kmem_cache_alloc(ecryptfs_key_record_cache, GFP_KERNEL);
1748         if (!key_rec) {
1749                 rc = -ENOMEM;
1750                 goto out;
1751         }
1752         list_for_each_entry(key_sig, &crypt_stat->keysig_list,
1753                             crypt_stat_list) {
1754                 memset(key_rec, 0, sizeof(*key_rec));
1755                 rc = ecryptfs_find_global_auth_tok_for_sig(&global_auth_tok,
1756                                                            mount_crypt_stat,
1757                                                            key_sig->keysig);
1758                 if (rc) {
1759                         printk(KERN_ERR "Error attempting to get the global "
1760                                "auth_tok; rc = [%d]\n", rc);
1761                         goto out_free;
1762                 }
1763                 if (global_auth_tok->flags & ECRYPTFS_AUTH_TOK_INVALID) {
1764                         printk(KERN_WARNING
1765                                "Skipping invalid auth tok with sig = [%s]\n",
1766                                global_auth_tok->sig);
1767                         continue;
1768                 }
1769                 auth_tok = global_auth_tok->global_auth_tok;
1770                 if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
1771                         rc = write_tag_3_packet((dest_base + (*len)),
1772                                                 &max, auth_tok,
1773                                                 crypt_stat, key_rec,
1774                                                 &written);
1775                         if (rc) {
1776                                 ecryptfs_printk(KERN_WARNING, "Error "
1777                                                 "writing tag 3 packet\n");
1778                                 goto out_free;
1779                         }
1780                         (*len) += written;
1781                         /* Write auth tok signature packet */
1782                         rc = write_tag_11_packet((dest_base + (*len)), &max,
1783                                                  key_rec->sig,
1784                                                  ECRYPTFS_SIG_SIZE, &written);
1785                         if (rc) {
1786                                 ecryptfs_printk(KERN_ERR, "Error writing "
1787                                                 "auth tok signature packet\n");
1788                                 goto out_free;
1789                         }
1790                         (*len) += written;
1791                 } else if (auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
1792                         rc = write_tag_1_packet(dest_base + (*len),
1793                                                 &max, auth_tok,
1794                                                 crypt_stat, key_rec, &written);
1795                         if (rc) {
1796                                 ecryptfs_printk(KERN_WARNING, "Error "
1797                                                 "writing tag 1 packet\n");
1798                                 goto out_free;
1799                         }
1800                         (*len) += written;
1801                 } else {
1802                         ecryptfs_printk(KERN_WARNING, "Unsupported "
1803                                         "authentication token type\n");
1804                         rc = -EINVAL;
1805                         goto out_free;
1806                 }
1807         }
1808         if (likely(max > 0)) {
1809                 dest_base[(*len)] = 0x00;
1810         } else {
1811                 ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");
1812                 rc = -EIO;
1813         }
1814 out_free:
1815         kmem_cache_free(ecryptfs_key_record_cache, key_rec);
1816 out:
1817         if (rc)
1818                 (*len) = 0;
1819         mutex_unlock(&crypt_stat->keysig_list_mutex);
1820         return rc;
1821 }
1822
1823 struct kmem_cache *ecryptfs_key_sig_cache;
1824
1825 int ecryptfs_add_keysig(struct ecryptfs_crypt_stat *crypt_stat, char *sig)
1826 {
1827         struct ecryptfs_key_sig *new_key_sig;
1828         int rc = 0;
1829
1830         new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL);
1831         if (!new_key_sig) {
1832                 rc = -ENOMEM;
1833                 printk(KERN_ERR
1834                        "Error allocating from ecryptfs_key_sig_cache\n");
1835                 goto out;
1836         }
1837         memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX);
1838         mutex_lock(&crypt_stat->keysig_list_mutex);
1839         list_add(&new_key_sig->crypt_stat_list, &crypt_stat->keysig_list);
1840         mutex_unlock(&crypt_stat->keysig_list_mutex);
1841 out:
1842         return rc;
1843 }
1844
1845 struct kmem_cache *ecryptfs_global_auth_tok_cache;
1846
1847 int
1848 ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
1849                              char *sig)
1850 {
1851         struct ecryptfs_global_auth_tok *new_auth_tok;
1852         int rc = 0;
1853
1854         new_auth_tok = kmem_cache_alloc(ecryptfs_global_auth_tok_cache,
1855                                         GFP_KERNEL);
1856         if (!new_auth_tok) {
1857                 rc = -ENOMEM;
1858                 printk(KERN_ERR "Error allocating from "
1859                        "ecryptfs_global_auth_tok_cache\n");
1860                 goto out;
1861         }
1862         memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX);
1863         new_auth_tok->sig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
1864         mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
1865         list_add(&new_auth_tok->mount_crypt_stat_list,
1866                  &mount_crypt_stat->global_auth_tok_list);
1867         mount_crypt_stat->num_global_auth_toks++;
1868         mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
1869 out:
1870         return rc;
1871 }
1872