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 <linux/slab.h>
  36 #include "ecryptfs_kernel.h"
  37
  38 /**
  39  * request_key returned an error instead of a valid key address;
  40  * determine the type of error, make appropriate log entries, and
  41  * return an error code.
  42  */
  43 static int process_request_key_err(long err_code)
  44 {
  45         int rc = 0;
  46
  47         switch (err_code) {
  48         case -ENOKEY:
  49                 ecryptfs_printk(KERN_WARNING, "No key\n");
  50                 rc = -ENOENT;
  51                 break;
  52         case -EKEYEXPIRED:
  53                 ecryptfs_printk(KERN_WARNING, "Key expired\n");
  54                 rc = -ETIME;
  55                 break;
  56         case -EKEYREVOKED:
  57                 ecryptfs_printk(KERN_WARNING, "Key revoked\n");
  58                 rc = -EINVAL;
  59                 break;
  60         default:
  61                 ecryptfs_printk(KERN_WARNING, "Unknown error code: "
  62                                 "[0x%.16x]\n", err_code);
  63                 rc = -EINVAL;
  64         }
  65         return rc;
  66 }
  67
  68 /**
  69  * ecryptfs_parse_packet_length
  70  * @data: Pointer to memory containing length at offset
  71  * @size: This function writes the decoded size to this memory
  72  *        address; zero on error
  73  * @length_size: The number of bytes occupied by the encoded length
  74  *
  75  * Returns zero on success; non-zero on error
  76  */
  77 int ecryptfs_parse_packet_length(unsigned char *data, size_t *size,
  78                                  size_t *length_size)
  79 {
  80         int rc = 0;
  81
  82         (*length_size) = 0;
  83         (*size) = 0;
  84         if (data[0] < 192) {
  85                 /* One-byte length */
  86                 (*size) = (unsigned char)data[0];
  87                 (*length_size) = 1;
  88         } else if (data[0] < 224) {
  89                 /* Two-byte length */
  90                 (*size) = (((unsigned char)(data[0]) - 192) * 256);
  91                 (*size) += ((unsigned char)(data[1]) + 192);
  92                 (*length_size) = 2;
  93         } else if (data[0] == 255) {
  94                 /* Five-byte length; we're not supposed to see this */
  95                 ecryptfs_printk(KERN_ERR, "Five-byte packet length not "
  96                                 "supported\n");
  97                 rc = -EINVAL;
  98                 goto out;
  99         } else {
 100                 ecryptfs_printk(KERN_ERR, "Error parsing packet length\n");
 101                 rc = -EINVAL;
 102                 goto out;
 103         }
 104 out:
 105         return rc;
 106 }
 107
 108 /**
 109  * ecryptfs_write_packet_length
 110  * @dest: The byte array target into which to write the length. Must
 111  *        have at least 5 bytes allocated.
 112  * @size: The length to write.
 113  * @packet_size_length: The number of bytes used to encode the packet
 114  *                      length is written to this address.
 115  *
 116  * Returns zero on success; non-zero on error.
 117  */
 118 int ecryptfs_write_packet_length(char *dest, size_t size,
 119                                  size_t *packet_size_length)
 120 {
 121         int rc = 0;
 122
 123         if (size < 192) {
 124                 dest[0] = size;
 125                 (*packet_size_length) = 1;
 126         } else if (size < 65536) {
 127                 dest[0] = (((size - 192) / 256) + 192);
 128                 dest[1] = ((size - 192) % 256);
 129                 (*packet_size_length) = 2;
 130         } else {
 131                 rc = -EINVAL;
 132                 ecryptfs_printk(KERN_WARNING,
 133                                 "Unsupported packet size: [%d]\n", size);
 134         }
 135         return rc;
 136 }
 137
 138 static int
 139 write_tag_64_packet(char *signature, struct ecryptfs_session_key *session_key,
 140                     char **packet, size_t *packet_len)
 141 {
 142         size_t i = 0;
 143         size_t data_len;
 144         size_t packet_size_len;
 145         char *message;
 146         int rc;
 147
 148         /*
 149          *              ***** TAG 64 Packet Format *****
 150          *    | Content Type                       | 1 byte       |
 151          *    | Key Identifier Size                | 1 or 2 bytes |
 152          *    | Key Identifier                     | arbitrary    |
 153          *    | Encrypted File Encryption Key Size | 1 or 2 bytes |
 154          *    | Encrypted File Encryption Key      | arbitrary    |
 155          */
 156         data_len = (5 + ECRYPTFS_SIG_SIZE_HEX
 157                     + session_key->encrypted_key_size);
 158         *packet = kmalloc(data_len, GFP_KERNEL);
 159         message = *packet;
 160         if (!message) {
 161                 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
 162                 rc = -ENOMEM;
 163                 goto out;
 164         }
 165         message[i++] = ECRYPTFS_TAG_64_PACKET_TYPE;
 166         rc = ecryptfs_write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
 167                                           &packet_size_len);
 168         if (rc) {
 169                 ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
 170                                 "header; cannot generate packet length\n");
 171                 goto out;
 172         }
 173         i += packet_size_len;
 174         memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
 175         i += ECRYPTFS_SIG_SIZE_HEX;
 176         rc = ecryptfs_write_packet_length(&message[i],
 177                                           session_key->encrypted_key_size,
 178                                           &packet_size_len);
 179         if (rc) {
 180                 ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
 181                                 "header; cannot generate packet length\n");
 182                 goto out;
 183         }
 184         i += packet_size_len;
 185         memcpy(&message[i], session_key->encrypted_key,
 186                session_key->encrypted_key_size);
 187         i += session_key->encrypted_key_size;
 188         *packet_len = i;
 189 out:
 190         return rc;
 191 }
 192
 193 static int
 194 parse_tag_65_packet(struct ecryptfs_session_key *session_key, u8 *cipher_code,
 195                     struct ecryptfs_message *msg)
 196 {
 197         size_t i = 0;
 198         char *data;
 199         size_t data_len;
 200         size_t m_size;
 201         size_t message_len;
 202         u16 checksum = 0;
 203         u16 expected_checksum = 0;
 204         int rc;
 205
 206         /*
 207          *              ***** TAG 65 Packet Format *****
 208          *         | Content Type             | 1 byte       |
 209          *         | Status Indicator         | 1 byte       |
 210          *         | File Encryption Key Size | 1 or 2 bytes |
 211          *         | File Encryption Key      | arbitrary    |
 212          */
 213         message_len = msg->data_len;
 214         data = msg->data;
 215         if (message_len < 4) {
 216                 rc = -EIO;
 217                 goto out;
 218         }
 219         if (data[i++] != ECRYPTFS_TAG_65_PACKET_TYPE) {
 220                 ecryptfs_printk(KERN_ERR, "Type should be ECRYPTFS_TAG_65\n");
 221                 rc = -EIO;
 222                 goto out;
 223         }
 224         if (data[i++]) {
 225                 ecryptfs_printk(KERN_ERR, "Status indicator has non-zero value "
 226                                 "[%d]\n", data[i-1]);
 227                 rc = -EIO;
 228                 goto out;
 229         }
 230         rc = ecryptfs_parse_packet_length(&data[i], &m_size, &data_len);
 231         if (rc) {
 232                 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
 233                                 "rc = [%d]\n", rc);
 234                 goto out;
 235         }
 236         i += data_len;
 237         if (message_len < (i + m_size)) {
 238                 ecryptfs_printk(KERN_ERR, "The message received from ecryptfsd "
 239                                 "is shorter than expected\n");
 240                 rc = -EIO;
 241                 goto out;
 242         }
 243         if (m_size < 3) {
 244                 ecryptfs_printk(KERN_ERR,
 245                                 "The decrypted key is not long enough to "
 246                                 "include a cipher code and checksum\n");
 247                 rc = -EIO;
 248                 goto out;
 249         }
 250         *cipher_code = data[i++];
 251         /* The decrypted key includes 1 byte cipher code and 2 byte checksum */
 252         session_key->decrypted_key_size = m_size - 3;
 253         if (session_key->decrypted_key_size > ECRYPTFS_MAX_KEY_BYTES) {
 254                 ecryptfs_printk(KERN_ERR, "key_size [%d] larger than "
 255                                 "the maximum key size [%d]\n",
 256                                 session_key->decrypted_key_size,
 257                                 ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
 258                 rc = -EIO;
 259                 goto out;
 260         }
 261         memcpy(session_key->decrypted_key, &data[i],
 262                session_key->decrypted_key_size);
 263         i += session_key->decrypted_key_size;
 264         expected_checksum += (unsigned char)(data[i++]) << 8;
 265         expected_checksum += (unsigned char)(data[i++]);
 266         for (i = 0; i < session_key->decrypted_key_size; i++)
 267                 checksum += session_key->decrypted_key[i];
 268         if (expected_checksum != checksum) {
 269                 ecryptfs_printk(KERN_ERR, "Invalid checksum for file "
 270                                 "encryption  key; expected [%x]; calculated "
 271                                 "[%x]\n", expected_checksum, checksum);
 272                 rc = -EIO;
 273         }
 274 out:
 275         return rc;
 276 }
 277
 278
 279 static int
 280 write_tag_66_packet(char *signature, u8 cipher_code,
 281                     struct ecryptfs_crypt_stat *crypt_stat, char **packet,
 282                     size_t *packet_len)
 283 {
 284         size_t i = 0;
 285         size_t j;
 286         size_t data_len;
 287         size_t checksum = 0;
 288         size_t packet_size_len;
 289         char *message;
 290         int rc;
 291
 292         /*
 293          *              ***** TAG 66 Packet Format *****
 294          *         | Content Type             | 1 byte       |
 295          *         | Key Identifier Size      | 1 or 2 bytes |
 296          *         | Key Identifier           | arbitrary    |
 297          *         | File Encryption Key Size | 1 or 2 bytes |
 298          *         | File Encryption Key      | arbitrary    |
 299          */
 300         data_len = (5 + ECRYPTFS_SIG_SIZE_HEX + crypt_stat->key_size);
 301         *packet = kmalloc(data_len, GFP_KERNEL);
 302         message = *packet;
 303         if (!message) {
 304                 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
 305                 rc = -ENOMEM;
 306                 goto out;
 307         }
 308         message[i++] = ECRYPTFS_TAG_66_PACKET_TYPE;
 309         rc = ecryptfs_write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
 310                                           &packet_size_len);
 311         if (rc) {
 312                 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
 313                                 "header; cannot generate packet length\n");
 314                 goto out;
 315         }
 316         i += packet_size_len;
 317         memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
 318         i += ECRYPTFS_SIG_SIZE_HEX;
 319         /* The encrypted key includes 1 byte cipher code and 2 byte checksum */
 320         rc = ecryptfs_write_packet_length(&message[i], crypt_stat->key_size + 3,
 321                                           &packet_size_len);
 322         if (rc) {
 323                 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
 324                                 "header; cannot generate packet length\n");
 325                 goto out;
 326         }
 327         i += packet_size_len;
 328         message[i++] = cipher_code;
 329         memcpy(&message[i], crypt_stat->key, crypt_stat->key_size);
 330         i += crypt_stat->key_size;
 331         for (j = 0; j < crypt_stat->key_size; j++)
 332                 checksum += crypt_stat->key[j];
 333         message[i++] = (checksum / 256) % 256;
 334         message[i++] = (checksum % 256);
 335         *packet_len = i;
 336 out:
 337         return rc;
 338 }
 339
 340 static int
 341 parse_tag_67_packet(struct ecryptfs_key_record *key_rec,
 342                     struct ecryptfs_message *msg)
 343 {
 344         size_t i = 0;
 345         char *data;
 346         size_t data_len;
 347         size_t message_len;
 348         int rc;
 349
 350         /*
 351          *              ***** TAG 65 Packet Format *****
 352          *    | Content Type                       | 1 byte       |
 353          *    | Status Indicator                   | 1 byte       |
 354          *    | Encrypted File Encryption Key Size | 1 or 2 bytes |
 355          *    | Encrypted File Encryption Key      | arbitrary    |
 356          */
 357         message_len = msg->data_len;
 358         data = msg->data;
 359         /* verify that everything through the encrypted FEK size is present */
 360         if (message_len < 4) {
 361                 rc = -EIO;
 362                 printk(KERN_ERR "%s: message_len is [%zd]; minimum acceptable "
 363                        "message length is [%d]\n", __func__, message_len, 4);
 364                 goto out;
 365         }
 366         if (data[i++] != ECRYPTFS_TAG_67_PACKET_TYPE) {
 367                 rc = -EIO;
 368                 printk(KERN_ERR "%s: Type should be ECRYPTFS_TAG_67\n",
 369                        __func__);
 370                 goto out;
 371         }
 372         if (data[i++]) {
 373                 rc = -EIO;
 374                 printk(KERN_ERR "%s: Status indicator has non zero "
 375                        "value [%d]\n", __func__, data[i-1]);
 376
 377                 goto out;
 378         }
 379         rc = ecryptfs_parse_packet_length(&data[i], &key_rec->enc_key_size,
 380                                           &data_len);
 381         if (rc) {
 382                 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
 383                                 "rc = [%d]\n", rc);
 384                 goto out;
 385         }
 386         i += data_len;
 387         if (message_len < (i + key_rec->enc_key_size)) {
 388                 rc = -EIO;
 389                 printk(KERN_ERR "%s: message_len [%zd]; max len is [%zd]\n",
 390                        __func__, message_len, (i + key_rec->enc_key_size));
 391                 goto out;
 392         }
 393         if (key_rec->enc_key_size > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
 394                 rc = -EIO;
 395                 printk(KERN_ERR "%s: Encrypted key_size [%zd] larger than "
 396                        "the maximum key size [%d]\n", __func__,
 397                        key_rec->enc_key_size,
 398                        ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
 399                 goto out;
 400         }
 401         memcpy(key_rec->enc_key, &data[i], key_rec->enc_key_size);
 402 out:
 403         return rc;
 404 }
 405
 406 static int
 407 ecryptfs_find_global_auth_tok_for_sig(
 408         struct ecryptfs_global_auth_tok **global_auth_tok,
 409         struct ecryptfs_mount_crypt_stat *mount_crypt_stat, char *sig)
 410 {
 411         struct ecryptfs_global_auth_tok *walker;
 412         int rc = 0;
 413
 414         (*global_auth_tok) = NULL;
 415         mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
 416         list_for_each_entry(walker,
 417                             &mount_crypt_stat->global_auth_tok_list,
 418                             mount_crypt_stat_list) {
 419                 if (memcmp(walker->sig, sig, ECRYPTFS_SIG_SIZE_HEX) == 0) {
 420                         rc = key_validate(walker->global_auth_tok_key);
 421                         if (!rc)
 422                                 (*global_auth_tok) = walker;
 423                         goto out;
 424                 }
 425         }
 426         rc = -EINVAL;
 427 out:
 428         mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
 429         return rc;
 430 }
 431
 432 /**
 433  * ecryptfs_find_auth_tok_for_sig
 434  * @auth_tok: Set to the matching auth_tok; NULL if not found
 435  * @crypt_stat: inode crypt_stat crypto context
 436  * @sig: Sig of auth_tok to find
 437  *
 438  * For now, this function simply looks at the registered auth_tok's
 439  * linked off the mount_crypt_stat, so all the auth_toks that can be
 440  * used must be registered at mount time. This function could
 441  * potentially try a lot harder to find auth_tok's (e.g., by calling
 442  * out to ecryptfsd to dynamically retrieve an auth_tok object) so
 443  * that static registration of auth_tok's will no longer be necessary.
 444  *
 445  * Returns zero on no error; non-zero on error
 446  */
 447 static int
 448 ecryptfs_find_auth_tok_for_sig(
 449         struct ecryptfs_auth_tok **auth_tok,
 450         struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
 451         char *sig)
 452 {
 453         struct ecryptfs_global_auth_tok *global_auth_tok;
 454         int rc = 0;
 455
 456         (*auth_tok) = NULL;
 457         if (ecryptfs_find_global_auth_tok_for_sig(&global_auth_tok,
 458                                                   mount_crypt_stat, sig)) {
 459                 struct key *auth_tok_key;
 460
 461                 rc = ecryptfs_keyring_auth_tok_for_sig(&auth_tok_key, auth_tok,
 462                                                        sig);
 463         } else
 464                 (*auth_tok) = global_auth_tok->global_auth_tok;
 465         return rc;
 466 }
 467
 468 /**
 469  * write_tag_70_packet can gobble a lot of stack space. We stuff most
 470  * of the function's parameters in a kmalloc'd struct to help reduce
 471  * eCryptfs' overall stack usage.
 472  */
 473 struct ecryptfs_write_tag_70_packet_silly_stack {
 474         u8 cipher_code;
 475         size_t max_packet_size;
 476         size_t packet_size_len;
 477         size_t block_aligned_filename_size;
 478         size_t block_size;
 479         size_t i;
 480         size_t j;
 481         size_t num_rand_bytes;
 482         struct mutex *tfm_mutex;
 483         char *block_aligned_filename;
 484         struct ecryptfs_auth_tok *auth_tok;
 485         struct scatterlist src_sg;
 486         struct scatterlist dst_sg;
 487         struct blkcipher_desc desc;
 488         char iv[ECRYPTFS_MAX_IV_BYTES];
 489         char hash[ECRYPTFS_TAG_70_DIGEST_SIZE];
 490         char tmp_hash[ECRYPTFS_TAG_70_DIGEST_SIZE];
 491         struct hash_desc hash_desc;
 492         struct scatterlist hash_sg;
 493 };
 494
 495 /**
 496  * write_tag_70_packet - Write encrypted filename (EFN) packet against FNEK
 497  * @filename: NULL-terminated filename string
 498  *
 499  * This is the simplest mechanism for achieving filename encryption in
 500  * eCryptfs. It encrypts the given filename with the mount-wide
 501  * filename encryption key (FNEK) and stores it in a packet to @dest,
 502  * which the callee will encode and write directly into the dentry
 503  * name.
 504  */
 505 int
 506 ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
 507                              size_t *packet_size,
 508                              struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
 509                              char *filename, size_t filename_size)
 510 {
 511         struct ecryptfs_write_tag_70_packet_silly_stack *s;
 512         int rc = 0;
 513
 514         s = kmalloc(sizeof(*s), GFP_KERNEL);
 515         if (!s) {
 516                 printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
 517                        "[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
 518                 rc = -ENOMEM;
 519                 goto out;
 520         }
 521         s->desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 522         (*packet_size) = 0;
 523         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(
 524                 &s->desc.tfm,
 525                 &s->tfm_mutex, mount_crypt_stat->global_default_fn_cipher_name);
 526         if (unlikely(rc)) {
 527                 printk(KERN_ERR "Internal error whilst attempting to get "
 528                        "tfm and mutex for cipher name [%s]; rc = [%d]\n",
 529                        mount_crypt_stat->global_default_fn_cipher_name, rc);
 530                 goto out;
 531         }
 532         mutex_lock(s->tfm_mutex);
 533         s->block_size = crypto_blkcipher_blocksize(s->desc.tfm);
 534         /* Plus one for the \0 separator between the random prefix
 535          * and the plaintext filename */
 536         s->num_rand_bytes = (ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES + 1);
 537         s->block_aligned_filename_size = (s->num_rand_bytes + filename_size);
 538         if ((s->block_aligned_filename_size % s->block_size) != 0) {
 539                 s->num_rand_bytes += (s->block_size
 540                                       - (s->block_aligned_filename_size
 541                                          % s->block_size));
 542                 s->block_aligned_filename_size = (s->num_rand_bytes
 543                                                   + filename_size);
 544         }
 545         /* Octet 0: Tag 70 identifier
 546          * Octets 1-N1: Tag 70 packet size (includes cipher identifier
 547          *              and block-aligned encrypted filename size)
 548          * Octets N1-N2: FNEK sig (ECRYPTFS_SIG_SIZE)
 549          * Octet N2-N3: Cipher identifier (1 octet)
 550          * Octets N3-N4: Block-aligned encrypted filename
 551          *  - Consists of a minimum number of random characters, a \0
 552          *    separator, and then the filename */
 553         s->max_packet_size = (1                   /* Tag 70 identifier */
 554                               + 3                 /* Max Tag 70 packet size */
 555                               + ECRYPTFS_SIG_SIZE /* FNEK sig */
 556                               + 1                 /* Cipher identifier */
 557                               + s->block_aligned_filename_size);
 558         if (dest == NULL) {
 559                 (*packet_size) = s->max_packet_size;
 560                 goto out_unlock;
 561         }
 562         if (s->max_packet_size > (*remaining_bytes)) {
 563                 printk(KERN_WARNING "%s: Require [%zd] bytes to write; only "
 564                        "[%zd] available\n", __func__, s->max_packet_size,
 565                        (*remaining_bytes));
 566                 rc = -EINVAL;
 567                 goto out_unlock;
 568         }
 569         s->block_aligned_filename = kzalloc(s->block_aligned_filename_size,
 570                                             GFP_KERNEL);
 571         if (!s->block_aligned_filename) {
 572                 printk(KERN_ERR "%s: Out of kernel memory whilst attempting to "
 573                        "kzalloc [%zd] bytes\n", __func__,
 574                        s->block_aligned_filename_size);
 575                 rc = -ENOMEM;
 576                 goto out_unlock;
 577         }
 578         s->i = 0;
 579         dest[s->i++] = ECRYPTFS_TAG_70_PACKET_TYPE;
 580         rc = ecryptfs_write_packet_length(&dest[s->i],
 581                                           (ECRYPTFS_SIG_SIZE
 582                                            + 1 /* Cipher code */
 583                                            + s->block_aligned_filename_size),
 584                                           &s->packet_size_len);
 585         if (rc) {
 586                 printk(KERN_ERR "%s: Error generating tag 70 packet "
 587                        "header; cannot generate packet length; rc = [%d]\n",
 588                        __func__, rc);
 589                 goto out_free_unlock;
 590         }
 591         s->i += s->packet_size_len;
 592         ecryptfs_from_hex(&dest[s->i],
 593                           mount_crypt_stat->global_default_fnek_sig,
 594                           ECRYPTFS_SIG_SIZE);
 595         s->i += ECRYPTFS_SIG_SIZE;
 596         s->cipher_code = ecryptfs_code_for_cipher_string(
 597                 mount_crypt_stat->global_default_fn_cipher_name,
 598                 mount_crypt_stat->global_default_fn_cipher_key_bytes);
 599         if (s->cipher_code == 0) {
 600                 printk(KERN_WARNING "%s: Unable to generate code for "
 601                        "cipher [%s] with key bytes [%zd]\n", __func__,
 602                        mount_crypt_stat->global_default_fn_cipher_name,
 603                        mount_crypt_stat->global_default_fn_cipher_key_bytes);
 604                 rc = -EINVAL;
 605                 goto out_free_unlock;
 606         }
 607         dest[s->i++] = s->cipher_code;
 608         rc = ecryptfs_find_auth_tok_for_sig(
 609                 &s->auth_tok, mount_crypt_stat,
 610                 mount_crypt_stat->global_default_fnek_sig);
 611         if (rc) {
 612                 printk(KERN_ERR "%s: Error attempting to find auth tok for "
 613                        "fnek sig [%s]; rc = [%d]\n", __func__,
 614                        mount_crypt_stat->global_default_fnek_sig, rc);
 615                 goto out_free_unlock;
 616         }
 617         /* TODO: Support other key modules than passphrase for
 618          * filename encryption */
 619         if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {
 620                 rc = -EOPNOTSUPP;
 621                 printk(KERN_INFO "%s: Filename encryption only supports "
 622                        "password tokens\n", __func__);
 623                 goto out_free_unlock;
 624         }
 625         sg_init_one(
 626                 &s->hash_sg,
 627                 (u8 *)s->auth_tok->token.password.session_key_encryption_key,
 628                 s->auth_tok->token.password.session_key_encryption_key_bytes);
 629         s->hash_desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 630         s->hash_desc.tfm = crypto_alloc_hash(ECRYPTFS_TAG_70_DIGEST, 0,
 631                                              CRYPTO_ALG_ASYNC);
 632         if (IS_ERR(s->hash_desc.tfm)) {
 633                         rc = PTR_ERR(s->hash_desc.tfm);
 634                         printk(KERN_ERR "%s: Error attempting to "
 635                                "allocate hash crypto context; rc = [%d]\n",
 636                                __func__, rc);
 637                         goto out_free_unlock;
 638         }
 639         rc = crypto_hash_init(&s->hash_desc);
 640         if (rc) {
 641                 printk(KERN_ERR
 642                        "%s: Error initializing crypto hash; rc = [%d]\n",
 643                        __func__, rc);
 644                 goto out_release_free_unlock;
 645         }
 646         rc = crypto_hash_update(
 647                 &s->hash_desc, &s->hash_sg,
 648                 s->auth_tok->token.password.session_key_encryption_key_bytes);
 649         if (rc) {
 650                 printk(KERN_ERR
 651                        "%s: Error updating crypto hash; rc = [%d]\n",
 652                        __func__, rc);
 653                 goto out_release_free_unlock;
 654         }
 655         rc = crypto_hash_final(&s->hash_desc, s->hash);
 656         if (rc) {
 657                 printk(KERN_ERR
 658                        "%s: Error finalizing crypto hash; rc = [%d]\n",
 659                        __func__, rc);
 660                 goto out_release_free_unlock;
 661         }
 662         for (s->j = 0; s->j < (s->num_rand_bytes - 1); s->j++) {
 663                 s->block_aligned_filename[s->j] =
 664                         s->hash[(s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)];
 665                 if ((s->j % ECRYPTFS_TAG_70_DIGEST_SIZE)
 666                     == (ECRYPTFS_TAG_70_DIGEST_SIZE - 1)) {
 667                         sg_init_one(&s->hash_sg, (u8 *)s->hash,
 668                                     ECRYPTFS_TAG_70_DIGEST_SIZE);
 669                         rc = crypto_hash_init(&s->hash_desc);
 670                         if (rc) {
 671                                 printk(KERN_ERR
 672                                        "%s: Error initializing crypto hash; "
 673                                        "rc = [%d]\n", __func__, rc);
 674                                 goto out_release_free_unlock;
 675                         }
 676                         rc = crypto_hash_update(&s->hash_desc, &s->hash_sg,
 677                                                 ECRYPTFS_TAG_70_DIGEST_SIZE);
 678                         if (rc) {
 679                                 printk(KERN_ERR
 680                                        "%s: Error updating crypto hash; "
 681                                        "rc = [%d]\n", __func__, rc);
 682                                 goto out_release_free_unlock;
 683                         }
 684                         rc = crypto_hash_final(&s->hash_desc, s->tmp_hash);
 685                         if (rc) {
 686                                 printk(KERN_ERR
 687                                        "%s: Error finalizing crypto hash; "
 688                                        "rc = [%d]\n", __func__, rc);
 689                                 goto out_release_free_unlock;
 690                         }
 691                         memcpy(s->hash, s->tmp_hash,
 692                                ECRYPTFS_TAG_70_DIGEST_SIZE);
 693                 }
 694                 if (s->block_aligned_filename[s->j] == '\0')
 695                         s->block_aligned_filename[s->j] = ECRYPTFS_NON_NULL;
 696         }
 697         memcpy(&s->block_aligned_filename[s->num_rand_bytes], filename,
 698                filename_size);
 699         rc = virt_to_scatterlist(s->block_aligned_filename,
 700                                  s->block_aligned_filename_size, &s->src_sg, 1);
 701         if (rc != 1) {
 702                 printk(KERN_ERR "%s: Internal error whilst attempting to "
 703                        "convert filename memory to scatterlist; "
 704                        "expected rc = 1; got rc = [%d]. "
 705                        "block_aligned_filename_size = [%zd]\n", __func__, rc,
 706                        s->block_aligned_filename_size);
 707                 goto out_release_free_unlock;
 708         }
 709         rc = virt_to_scatterlist(&dest[s->i], s->block_aligned_filename_size,
 710                                  &s->dst_sg, 1);
 711         if (rc != 1) {
 712                 printk(KERN_ERR "%s: Internal error whilst attempting to "
 713                        "convert encrypted filename memory to scatterlist; "
 714                        "expected rc = 1; got rc = [%d]. "
 715                        "block_aligned_filename_size = [%zd]\n", __func__, rc,
 716                        s->block_aligned_filename_size);
 717                 goto out_release_free_unlock;
 718         }
 719         /* The characters in the first block effectively do the job
 720          * of the IV here, so we just use 0's for the IV. Note the
 721          * constraint that ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES
 722          * >= ECRYPTFS_MAX_IV_BYTES. */
 723         memset(s->iv, 0, ECRYPTFS_MAX_IV_BYTES);
 724         s->desc.info = s->iv;
 725         rc = crypto_blkcipher_setkey(
 726                 s->desc.tfm,
 727                 s->auth_tok->token.password.session_key_encryption_key,
 728                 mount_crypt_stat->global_default_fn_cipher_key_bytes);
 729         if (rc < 0) {
 730                 printk(KERN_ERR "%s: Error setting key for crypto context; "
 731                        "rc = [%d]. s->auth_tok->token.password.session_key_"
 732                        "encryption_key = [0x%p]; mount_crypt_stat->"
 733                        "global_default_fn_cipher_key_bytes = [%zd]\n", __func__,
 734                        rc,
 735                        s->auth_tok->token.password.session_key_encryption_key,
 736                        mount_crypt_stat->global_default_fn_cipher_key_bytes);
 737                 goto out_release_free_unlock;
 738         }
 739         rc = crypto_blkcipher_encrypt_iv(&s->desc, &s->dst_sg, &s->src_sg,
 740                                          s->block_aligned_filename_size);
 741         if (rc) {
 742                 printk(KERN_ERR "%s: Error attempting to encrypt filename; "
 743                        "rc = [%d]\n", __func__, rc);
 744                 goto out_release_free_unlock;
 745         }
 746         s->i += s->block_aligned_filename_size;
 747         (*packet_size) = s->i;
 748         (*remaining_bytes) -= (*packet_size);
 749 out_release_free_unlock:
 750         crypto_free_hash(s->hash_desc.tfm);
 751 out_free_unlock:
 752         kzfree(s->block_aligned_filename);
 753 out_unlock:
 754         mutex_unlock(s->tfm_mutex);
 755 out:
 756         kfree(s);
 757         return rc;
 758 }
 759
 760 struct ecryptfs_parse_tag_70_packet_silly_stack {
 761         u8 cipher_code;
 762         size_t max_packet_size;
 763         size_t packet_size_len;
 764         size_t parsed_tag_70_packet_size;
 765         size_t block_aligned_filename_size;
 766         size_t block_size;
 767         size_t i;
 768         struct mutex *tfm_mutex;
 769         char *decrypted_filename;
 770         struct ecryptfs_auth_tok *auth_tok;
 771         struct scatterlist src_sg;
 772         struct scatterlist dst_sg;
 773         struct blkcipher_desc desc;
 774         char fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX + 1];
 775         char iv[ECRYPTFS_MAX_IV_BYTES];
 776         char cipher_string[ECRYPTFS_MAX_CIPHER_NAME_SIZE];
 777 };
 778
 779 /**
 780  * parse_tag_70_packet - Parse and process FNEK-encrypted passphrase packet
 781  * @filename: This function kmalloc's the memory for the filename
 782  * @filename_size: This function sets this to the amount of memory
 783  *                 kmalloc'd for the filename
 784  * @packet_size: This function sets this to the the number of octets
 785  *               in the packet parsed
 786  * @mount_crypt_stat: The mount-wide cryptographic context
 787  * @data: The memory location containing the start of the tag 70
 788  *        packet
 789  * @max_packet_size: The maximum legal size of the packet to be parsed
 790  *                   from @data
 791  *
 792  * Returns zero on success; non-zero otherwise
 793  */
 794 int
 795 ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
 796                              size_t *packet_size,
 797                              struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
 798                              char *data, size_t max_packet_size)
 799 {
 800         struct ecryptfs_parse_tag_70_packet_silly_stack *s;
 801         int rc = 0;
 802
 803         (*packet_size) = 0;
 804         (*filename_size) = 0;
 805         (*filename) = NULL;
 806         s = kmalloc(sizeof(*s), GFP_KERNEL);
 807         if (!s) {
 808                 printk(KERN_ERR "%s: Out of memory whilst trying to kmalloc "
 809                        "[%zd] bytes of kernel memory\n", __func__, sizeof(*s));
 810                 rc = -ENOMEM;
 811                 goto out;
 812         }
 813         s->desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
 814         if (max_packet_size < (1 + 1 + ECRYPTFS_SIG_SIZE + 1 + 1)) {
 815                 printk(KERN_WARNING "%s: max_packet_size is [%zd]; it must be "
 816                        "at least [%d]\n", __func__, max_packet_size,
 817                         (1 + 1 + ECRYPTFS_SIG_SIZE + 1 + 1));
 818                 rc = -EINVAL;
 819                 goto out;
 820         }
 821         /* Octet 0: Tag 70 identifier
 822          * Octets 1-N1: Tag 70 packet size (includes cipher identifier
 823          *              and block-aligned encrypted filename size)
 824          * Octets N1-N2: FNEK sig (ECRYPTFS_SIG_SIZE)
 825          * Octet N2-N3: Cipher identifier (1 octet)
 826          * Octets N3-N4: Block-aligned encrypted filename
 827          *  - Consists of a minimum number of random numbers, a \0
 828          *    separator, and then the filename */
 829         if (data[(*packet_size)++] != ECRYPTFS_TAG_70_PACKET_TYPE) {
 830                 printk(KERN_WARNING "%s: Invalid packet tag [0x%.2x]; must be "
 831                        "tag [0x%.2x]\n", __func__,
 832                        data[((*packet_size) - 1)], ECRYPTFS_TAG_70_PACKET_TYPE);
 833                 rc = -EINVAL;
 834                 goto out;
 835         }
 836         rc = ecryptfs_parse_packet_length(&data[(*packet_size)],
 837                                           &s->parsed_tag_70_packet_size,
 838                                           &s->packet_size_len);
 839         if (rc) {
 840                 printk(KERN_WARNING "%s: Error parsing packet length; "
 841                        "rc = [%d]\n", __func__, rc);
 842                 goto out;
 843         }
 844         s->block_aligned_filename_size = (s->parsed_tag_70_packet_size
 845                                           - ECRYPTFS_SIG_SIZE - 1);
 846         if ((1 + s->packet_size_len + s->parsed_tag_70_packet_size)
 847             > max_packet_size) {
 848                 printk(KERN_WARNING "%s: max_packet_size is [%zd]; real packet "
 849                        "size is [%zd]\n", __func__, max_packet_size,
 850                        (1 + s->packet_size_len + 1
 851                         + s->block_aligned_filename_size));
 852                 rc = -EINVAL;
 853                 goto out;
 854         }
 855         (*packet_size) += s->packet_size_len;
 856         ecryptfs_to_hex(s->fnek_sig_hex, &data[(*packet_size)],
 857                         ECRYPTFS_SIG_SIZE);
 858         s->fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX] = '\0';
 859         (*packet_size) += ECRYPTFS_SIG_SIZE;
 860         s->cipher_code = data[(*packet_size)++];
 861         rc = ecryptfs_cipher_code_to_string(s->cipher_string, s->cipher_code);
 862         if (rc) {
 863                 printk(KERN_WARNING "%s: Cipher code [%d] is invalid\n",
 864                        __func__, s->cipher_code);
 865                 goto out;
 866         }
 867         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&s->desc.tfm,
 868                                                         &s->tfm_mutex,
 869                                                         s->cipher_string);
 870         if (unlikely(rc)) {
 871                 printk(KERN_ERR "Internal error whilst attempting to get "
 872                        "tfm and mutex for cipher name [%s]; rc = [%d]\n",
 873                        s->cipher_string, rc);
 874                 goto out;
 875         }
 876         mutex_lock(s->tfm_mutex);
 877         rc = virt_to_scatterlist(&data[(*packet_size)],
 878                                  s->block_aligned_filename_size, &s->src_sg, 1);
 879         if (rc != 1) {
 880                 printk(KERN_ERR "%s: Internal error whilst attempting to "
 881                        "convert encrypted filename memory to scatterlist; "
 882                        "expected rc = 1; got rc = [%d]. "
 883                        "block_aligned_filename_size = [%zd]\n", __func__, rc,
 884                        s->block_aligned_filename_size);
 885                 goto out_unlock;
 886         }
 887         (*packet_size) += s->block_aligned_filename_size;
 888         s->decrypted_filename = kmalloc(s->block_aligned_filename_size,
 889                                         GFP_KERNEL);
 890         if (!s->decrypted_filename) {
 891                 printk(KERN_ERR "%s: Out of memory whilst attempting to "
 892                        "kmalloc [%zd] bytes\n", __func__,
 893                        s->block_aligned_filename_size);
 894                 rc = -ENOMEM;
 895                 goto out_unlock;
 896         }
 897         rc = virt_to_scatterlist(s->decrypted_filename,
 898                                  s->block_aligned_filename_size, &s->dst_sg, 1);
 899         if (rc != 1) {
 900                 printk(KERN_ERR "%s: Internal error whilst attempting to "
 901                        "convert decrypted filename memory to scatterlist; "
 902                        "expected rc = 1; got rc = [%d]. "
 903                        "block_aligned_filename_size = [%zd]\n", __func__, rc,
 904                        s->block_aligned_filename_size);
 905                 goto out_free_unlock;
 906         }
 907         /* The characters in the first block effectively do the job of
 908          * the IV here, so we just use 0's for the IV. Note the
 909          * constraint that ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES
 910          * >= ECRYPTFS_MAX_IV_BYTES. */
 911         memset(s->iv, 0, ECRYPTFS_MAX_IV_BYTES);
 912         s->desc.info = s->iv;
 913         rc = ecryptfs_find_auth_tok_for_sig(&s->auth_tok, mount_crypt_stat,
 914                                             s->fnek_sig_hex);
 915         if (rc) {
 916                 printk(KERN_ERR "%s: Error attempting to find auth tok for "
 917                        "fnek sig [%s]; rc = [%d]\n", __func__, s->fnek_sig_hex,
 918                        rc);
 919                 goto out_free_unlock;
 920         }
 921         /* TODO: Support other key modules than passphrase for
 922          * filename encryption */
 923         if (s->auth_tok->token_type != ECRYPTFS_PASSWORD) {
 924                 rc = -EOPNOTSUPP;
 925                 printk(KERN_INFO "%s: Filename encryption only supports "
 926                        "password tokens\n", __func__);
 927                 goto out_free_unlock;
 928         }
 929         rc = crypto_blkcipher_setkey(
 930                 s->desc.tfm,
 931                 s->auth_tok->token.password.session_key_encryption_key,
 932                 mount_crypt_stat->global_default_fn_cipher_key_bytes);
 933         if (rc < 0) {
 934                 printk(KERN_ERR "%s: Error setting key for crypto context; "
 935                        "rc = [%d]. s->auth_tok->token.password.session_key_"
 936                        "encryption_key = [0x%p]; mount_crypt_stat->"
 937                        "global_default_fn_cipher_key_bytes = [%zd]\n", __func__,
 938                        rc,
 939                        s->auth_tok->token.password.session_key_encryption_key,
 940                        mount_crypt_stat->global_default_fn_cipher_key_bytes);
 941                 goto out_free_unlock;
 942         }
 943         rc = crypto_blkcipher_decrypt_iv(&s->desc, &s->dst_sg, &s->src_sg,
 944                                          s->block_aligned_filename_size);
 945         if (rc) {
 946                 printk(KERN_ERR "%s: Error attempting to decrypt filename; "
 947                        "rc = [%d]\n", __func__, rc);
 948                 goto out_free_unlock;
 949         }
 950         s->i = 0;
 951         while (s->decrypted_filename[s->i] != '\0'
 952                && s->i < s->block_aligned_filename_size)
 953                 s->i++;
 954         if (s->i == s->block_aligned_filename_size) {
 955                 printk(KERN_WARNING "%s: Invalid tag 70 packet; could not "
 956                        "find valid separator between random characters and "
 957                        "the filename\n", __func__);
 958                 rc = -EINVAL;
 959                 goto out_free_unlock;
 960         }
 961         s->i++;
 962         (*filename_size) = (s->block_aligned_filename_size - s->i);
 963         if (!((*filename_size) > 0 && (*filename_size < PATH_MAX))) {
 964                 printk(KERN_WARNING "%s: Filename size is [%zd], which is "
 965                        "invalid\n", __func__, (*filename_size));
 966                 rc = -EINVAL;
 967                 goto out_free_unlock;
 968         }
 969         (*filename) = kmalloc(((*filename_size) + 1), GFP_KERNEL);
 970         if (!(*filename)) {
 971                 printk(KERN_ERR "%s: Out of memory whilst attempting to "
 972                        "kmalloc [%zd] bytes\n", __func__,
 973                        ((*filename_size) + 1));
 974                 rc = -ENOMEM;
 975                 goto out_free_unlock;
 976         }
 977         memcpy((*filename), &s->decrypted_filename[s->i], (*filename_size));
 978         (*filename)[(*filename_size)] = '\0';
 979 out_free_unlock:
 980         kfree(s->decrypted_filename);
 981 out_unlock:
 982         mutex_unlock(s->tfm_mutex);
 983 out:
 984         if (rc) {
 985                 (*packet_size) = 0;
 986                 (*filename_size) = 0;
 987                 (*filename) = NULL;
 988         }
 989         kfree(s);
 990         return rc;
 991 }
 992
 993 static int
 994 ecryptfs_get_auth_tok_sig(char **sig, struct ecryptfs_auth_tok *auth_tok)
 995 {
 996         int rc = 0;
 997
 998         (*sig) = NULL;
 999         switch (auth_tok->token_type) {
1000         case ECRYPTFS_PASSWORD:
1001                 (*sig) = auth_tok->token.password.signature;
1002                 break;
1003         case ECRYPTFS_PRIVATE_KEY:
1004                 (*sig) = auth_tok->token.private_key.signature;
1005                 break;
1006         default:
1007                 printk(KERN_ERR "Cannot get sig for auth_tok of type [%d]\n",
1008                        auth_tok->token_type);
1009                 rc = -EINVAL;
1010         }
1011         return rc;
1012 }
1013
1014 /**
1015  * decrypt_pki_encrypted_session_key - Decrypt the session key with the given auth_tok.
1016  * @auth_tok: The key authentication token used to decrypt the session key
1017  * @crypt_stat: The cryptographic context
1018  *
1019  * Returns zero on success; non-zero error otherwise.
1020  */
1021 static int
1022 decrypt_pki_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
1023                                   struct ecryptfs_crypt_stat *crypt_stat)
1024 {
1025         u8 cipher_code = 0;
1026         struct ecryptfs_msg_ctx *msg_ctx;
1027         struct ecryptfs_message *msg = NULL;
1028         char *auth_tok_sig;
1029         char *payload;
1030         size_t payload_len;
1031         int rc;
1032
1033         rc = ecryptfs_get_auth_tok_sig(&auth_tok_sig, auth_tok);
1034         if (rc) {
1035                 printk(KERN_ERR "Unrecognized auth tok type: [%d]\n",
1036                        auth_tok->token_type);
1037                 goto out;
1038         }
1039         rc = write_tag_64_packet(auth_tok_sig, &(auth_tok->session_key),
1040                                  &payload, &payload_len);
1041         if (rc) {
1042                 ecryptfs_printk(KERN_ERR, "Failed to write tag 64 packet\n");
1043                 goto out;
1044         }
1045         rc = ecryptfs_send_message(payload, payload_len, &msg_ctx);
1046         if (rc) {
1047                 ecryptfs_printk(KERN_ERR, "Error sending message to "
1048                                 "ecryptfsd\n");
1049                 goto out;
1050         }
1051         rc = ecryptfs_wait_for_response(msg_ctx, &msg);
1052         if (rc) {
1053                 ecryptfs_printk(KERN_ERR, "Failed to receive tag 65 packet "
1054                                 "from the user space daemon\n");
1055                 rc = -EIO;
1056                 goto out;
1057         }
1058         rc = parse_tag_65_packet(&(auth_tok->session_key),
1059                                  &cipher_code, msg);
1060         if (rc) {
1061                 printk(KERN_ERR "Failed to parse tag 65 packet; rc = [%d]\n",
1062                        rc);
1063                 goto out;
1064         }
1065         auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1066         memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
1067                auth_tok->session_key.decrypted_key_size);
1068         crypt_stat->key_size = auth_tok->session_key.decrypted_key_size;
1069         rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher, cipher_code);
1070         if (rc) {
1071                 ecryptfs_printk(KERN_ERR, "Cipher code [%d] is invalid\n",
1072                                 cipher_code)
1073                 goto out;
1074         }
1075         crypt_stat->flags |= ECRYPTFS_KEY_VALID;
1076         if (ecryptfs_verbosity > 0) {
1077                 ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
1078                 ecryptfs_dump_hex(crypt_stat->key,
1079                                   crypt_stat->key_size);
1080         }
1081 out:
1082         if (msg)
1083                 kfree(msg);
1084         return rc;
1085 }
1086
1087 static void wipe_auth_tok_list(struct list_head *auth_tok_list_head)
1088 {
1089         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1090         struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;
1091
1092         list_for_each_entry_safe(auth_tok_list_item, auth_tok_list_item_tmp,
1093                                  auth_tok_list_head, list) {
1094                 list_del(&auth_tok_list_item->list);
1095                 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
1096                                 auth_tok_list_item);
1097         }
1098 }
1099
1100 struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
1101
1102 /**
1103  * parse_tag_1_packet
1104  * @crypt_stat: The cryptographic context to modify based on packet contents
1105  * @data: The raw bytes of the packet.
1106  * @auth_tok_list: eCryptfs parses packets into authentication tokens;
1107  *                 a new authentication token will be placed at the
1108  *                 end of this list for this packet.
1109  * @new_auth_tok: Pointer to a pointer to memory that this function
1110  *                allocates; sets the memory address of the pointer to
1111  *                NULL on error. This object is added to the
1112  *                auth_tok_list.
1113  * @packet_size: This function writes the size of the parsed packet
1114  *               into this memory location; zero on error.
1115  * @max_packet_size: The maximum allowable packet size
1116  *
1117  * Returns zero on success; non-zero on error.
1118  */
1119 static int
1120 parse_tag_1_packet(struct ecryptfs_crypt_stat *crypt_stat,
1121                    unsigned char *data, struct list_head *auth_tok_list,
1122                    struct ecryptfs_auth_tok **new_auth_tok,
1123                    size_t *packet_size, size_t max_packet_size)
1124 {
1125         size_t body_size;
1126         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1127         size_t length_size;
1128         int rc = 0;
1129
1130         (*packet_size) = 0;
1131         (*new_auth_tok) = NULL;
1132         /**
1133          * This format is inspired by OpenPGP; see RFC 2440
1134          * packet tag 1
1135          *
1136          * Tag 1 identifier (1 byte)
1137          * Max Tag 1 packet size (max 3 bytes)
1138          * Version (1 byte)
1139          * Key identifier (8 bytes; ECRYPTFS_SIG_SIZE)
1140          * Cipher identifier (1 byte)
1141          * Encrypted key size (arbitrary)
1142          *
1143          * 12 bytes minimum packet size
1144          */
1145         if (unlikely(max_packet_size < 12)) {
1146                 printk(KERN_ERR "Invalid max packet size; must be >=12\n");
1147                 rc = -EINVAL;
1148                 goto out;
1149         }
1150         if (data[(*packet_size)++] != ECRYPTFS_TAG_1_PACKET_TYPE) {
1151                 printk(KERN_ERR "Enter w/ first byte != 0x%.2x\n",
1152                        ECRYPTFS_TAG_1_PACKET_TYPE);
1153                 rc = -EINVAL;
1154                 goto out;
1155         }
1156         /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
1157          * at end of function upon failure */
1158         auth_tok_list_item =
1159                 kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache,
1160                                   GFP_KERNEL);
1161         if (!auth_tok_list_item) {
1162                 printk(KERN_ERR "Unable to allocate memory\n");
1163                 rc = -ENOMEM;
1164                 goto out;
1165         }
1166         (*new_auth_tok) = &auth_tok_list_item->auth_tok;
1167         rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,
1168                                           &length_size);
1169         if (rc) {
1170                 printk(KERN_WARNING "Error parsing packet length; "
1171                        "rc = [%d]\n", rc);
1172                 goto out_free;
1173         }
1174         if (unlikely(body_size < (ECRYPTFS_SIG_SIZE + 2))) {
1175                 printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
1176                 rc = -EINVAL;
1177                 goto out_free;
1178         }
1179         (*packet_size) += length_size;
1180         if (unlikely((*packet_size) + body_size > max_packet_size)) {
1181                 printk(KERN_WARNING "Packet size exceeds max\n");
1182                 rc = -EINVAL;
1183                 goto out_free;
1184         }
1185         if (unlikely(data[(*packet_size)++] != 0x03)) {
1186                 printk(KERN_WARNING "Unknown version number [%d]\n",
1187                        data[(*packet_size) - 1]);
1188                 rc = -EINVAL;
1189                 goto out_free;
1190         }
1191         ecryptfs_to_hex((*new_auth_tok)->token.private_key.signature,
1192                         &data[(*packet_size)], ECRYPTFS_SIG_SIZE);
1193         *packet_size += ECRYPTFS_SIG_SIZE;
1194         /* This byte is skipped because the kernel does not need to
1195          * know which public key encryption algorithm was used */
1196         (*packet_size)++;
1197         (*new_auth_tok)->session_key.encrypted_key_size =
1198                 body_size - (ECRYPTFS_SIG_SIZE + 2);
1199         if ((*new_auth_tok)->session_key.encrypted_key_size
1200             > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
1201                 printk(KERN_WARNING "Tag 1 packet contains key larger "
1202                        "than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES");
1203                 rc = -EINVAL;
1204                 goto out;
1205         }
1206         memcpy((*new_auth_tok)->session_key.encrypted_key,
1207                &data[(*packet_size)], (body_size - (ECRYPTFS_SIG_SIZE + 2)));
1208         (*packet_size) += (*new_auth_tok)->session_key.encrypted_key_size;
1209         (*new_auth_tok)->session_key.flags &=
1210                 ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1211         (*new_auth_tok)->session_key.flags |=
1212                 ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
1213         (*new_auth_tok)->token_type = ECRYPTFS_PRIVATE_KEY;
1214         (*new_auth_tok)->flags = 0;
1215         (*new_auth_tok)->session_key.flags &=
1216                 ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
1217         (*new_auth_tok)->session_key.flags &=
1218                 ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
1219         list_add(&auth_tok_list_item->list, auth_tok_list);
1220         goto out;
1221 out_free:
1222         (*new_auth_tok) = NULL;
1223         memset(auth_tok_list_item, 0,
1224                sizeof(struct ecryptfs_auth_tok_list_item));
1225         kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
1226                         auth_tok_list_item);
1227 out:
1228         if (rc)
1229                 (*packet_size) = 0;
1230         return rc;
1231 }
1232
1233 /**
1234  * parse_tag_3_packet
1235  * @crypt_stat: The cryptographic context to modify based on packet
1236  *              contents.
1237  * @data: The raw bytes of the packet.
1238  * @auth_tok_list: eCryptfs parses packets into authentication tokens;
1239  *                 a new authentication token will be placed at the end
1240  *                 of this list for this packet.
1241  * @new_auth_tok: Pointer to a pointer to memory that this function
1242  *                allocates; sets the memory address of the pointer to
1243  *                NULL on error. This object is added to the
1244  *                auth_tok_list.
1245  * @packet_size: This function writes the size of the parsed packet
1246  *               into this memory location; zero on error.
1247  * @max_packet_size: maximum number of bytes to parse
1248  *
1249  * Returns zero on success; non-zero on error.
1250  */
1251 static int
1252 parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
1253                    unsigned char *data, struct list_head *auth_tok_list,
1254                    struct ecryptfs_auth_tok **new_auth_tok,
1255                    size_t *packet_size, size_t max_packet_size)
1256 {
1257         size_t body_size;
1258         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1259         size_t length_size;
1260         int rc = 0;
1261
1262         (*packet_size) = 0;
1263         (*new_auth_tok) = NULL;
1264         /**
1265          *This format is inspired by OpenPGP; see RFC 2440
1266          * packet tag 3
1267          *
1268          * Tag 3 identifier (1 byte)
1269          * Max Tag 3 packet size (max 3 bytes)
1270          * Version (1 byte)
1271          * Cipher code (1 byte)
1272          * S2K specifier (1 byte)
1273          * Hash identifier (1 byte)
1274          * Salt (ECRYPTFS_SALT_SIZE)
1275          * Hash iterations (1 byte)
1276          * Encrypted key (arbitrary)
1277          *
1278          * (ECRYPTFS_SALT_SIZE + 7) minimum packet size
1279          */
1280         if (max_packet_size < (ECRYPTFS_SALT_SIZE + 7)) {
1281                 printk(KERN_ERR "Max packet size too large\n");
1282                 rc = -EINVAL;
1283                 goto out;
1284         }
1285         if (data[(*packet_size)++] != ECRYPTFS_TAG_3_PACKET_TYPE) {
1286                 printk(KERN_ERR "First byte != 0x%.2x; invalid packet\n",
1287                        ECRYPTFS_TAG_3_PACKET_TYPE);
1288                 rc = -EINVAL;
1289                 goto out;
1290         }
1291         /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
1292          * at end of function upon failure */
1293         auth_tok_list_item =
1294             kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
1295         if (!auth_tok_list_item) {
1296                 printk(KERN_ERR "Unable to allocate memory\n");
1297                 rc = -ENOMEM;
1298                 goto out;
1299         }
1300         (*new_auth_tok) = &auth_tok_list_item->auth_tok;
1301         rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,
1302                                           &length_size);
1303         if (rc) {
1304                 printk(KERN_WARNING "Error parsing packet length; rc = [%d]\n",
1305                        rc);
1306                 goto out_free;
1307         }
1308         if (unlikely(body_size < (ECRYPTFS_SALT_SIZE + 5))) {
1309                 printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
1310                 rc = -EINVAL;
1311                 goto out_free;
1312         }
1313         (*packet_size) += length_size;
1314         if (unlikely((*packet_size) + body_size > max_packet_size)) {
1315                 printk(KERN_ERR "Packet size exceeds max\n");
1316                 rc = -EINVAL;
1317                 goto out_free;
1318         }
1319         (*new_auth_tok)->session_key.encrypted_key_size =
1320                 (body_size - (ECRYPTFS_SALT_SIZE + 5));
1321         if ((*new_auth_tok)->session_key.encrypted_key_size
1322             > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
1323                 printk(KERN_WARNING "Tag 3 packet contains key larger "
1324                        "than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES\n");
1325                 rc = -EINVAL;
1326                 goto out_free;
1327         }
1328         if (unlikely(data[(*packet_size)++] != 0x04)) {
1329                 printk(KERN_WARNING "Unknown version number [%d]\n",
1330                        data[(*packet_size) - 1]);
1331                 rc = -EINVAL;
1332                 goto out_free;
1333         }
1334         rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher,
1335                                             (u16)data[(*packet_size)]);
1336         if (rc)
1337                 goto out_free;
1338         /* A little extra work to differentiate among the AES key
1339          * sizes; see RFC2440 */
1340         switch(data[(*packet_size)++]) {
1341         case RFC2440_CIPHER_AES_192:
1342                 crypt_stat->key_size = 24;
1343                 break;
1344         default:
1345                 crypt_stat->key_size =
1346                         (*new_auth_tok)->session_key.encrypted_key_size;
1347         }
1348         rc = ecryptfs_init_crypt_ctx(crypt_stat);
1349         if (rc)
1350                 goto out_free;
1351         if (unlikely(data[(*packet_size)++] != 0x03)) {
1352                 printk(KERN_WARNING "Only S2K ID 3 is currently supported\n");
1353                 rc = -ENOSYS;
1354                 goto out_free;
1355         }
1356         /* TODO: finish the hash mapping */
1357         switch (data[(*packet_size)++]) {
1358         case 0x01: /* See RFC2440 for these numbers and their mappings */
1359                 /* Choose MD5 */
1360                 memcpy((*new_auth_tok)->token.password.salt,
1361                        &data[(*packet_size)], ECRYPTFS_SALT_SIZE);
1362                 (*packet_size) += ECRYPTFS_SALT_SIZE;
1363                 /* This conversion was taken straight from RFC2440 */
1364                 (*new_auth_tok)->token.password.hash_iterations =
1365                         ((u32) 16 + (data[(*packet_size)] & 15))
1366                                 << ((data[(*packet_size)] >> 4) + 6);
1367                 (*packet_size)++;
1368                 /* Friendly reminder:
1369                  * (*new_auth_tok)->session_key.encrypted_key_size =
1370                  *         (body_size - (ECRYPTFS_SALT_SIZE + 5)); */
1371                 memcpy((*new_auth_tok)->session_key.encrypted_key,
1372                        &data[(*packet_size)],
1373                        (*new_auth_tok)->session_key.encrypted_key_size);
1374                 (*packet_size) +=
1375                         (*new_auth_tok)->session_key.encrypted_key_size;
1376                 (*new_auth_tok)->session_key.flags &=
1377                         ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1378                 (*new_auth_tok)->session_key.flags |=
1379                         ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
1380                 (*new_auth_tok)->token.password.hash_algo = 0x01; /* MD5 */
1381                 break;
1382         default:
1383                 ecryptfs_printk(KERN_ERR, "Unsupported hash algorithm: "
1384                                 "[%d]\n", data[(*packet_size) - 1]);
1385                 rc = -ENOSYS;
1386                 goto out_free;
1387         }
1388         (*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;
1389         /* TODO: Parametarize; we might actually want userspace to
1390          * decrypt the session key. */
1391         (*new_auth_tok)->session_key.flags &=
1392                             ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
1393         (*new_auth_tok)->session_key.flags &=
1394                             ~(ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
1395         list_add(&auth_tok_list_item->list, auth_tok_list);
1396         goto out;
1397 out_free:
1398         (*new_auth_tok) = NULL;
1399         memset(auth_tok_list_item, 0,
1400                sizeof(struct ecryptfs_auth_tok_list_item));
1401         kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
1402                         auth_tok_list_item);
1403 out:
1404         if (rc)
1405                 (*packet_size) = 0;
1406         return rc;
1407 }
1408
1409 /**
1410  * parse_tag_11_packet
1411  * @data: The raw bytes of the packet
1412  * @contents: This function writes the data contents of the literal
1413  *            packet into this memory location
1414  * @max_contents_bytes: The maximum number of bytes that this function
1415  *                      is allowed to write into contents
1416  * @tag_11_contents_size: This function writes the size of the parsed
1417  *                        contents into this memory location; zero on
1418  *                        error
1419  * @packet_size: This function writes the size of the parsed packet
1420  *               into this memory location; zero on error
1421  * @max_packet_size: maximum number of bytes to parse
1422  *
1423  * Returns zero on success; non-zero on error.
1424  */
1425 static int
1426 parse_tag_11_packet(unsigned char *data, unsigned char *contents,
1427                     size_t max_contents_bytes, size_t *tag_11_contents_size,
1428                     size_t *packet_size, size_t max_packet_size)
1429 {
1430         size_t body_size;
1431         size_t length_size;
1432         int rc = 0;
1433
1434         (*packet_size) = 0;
1435         (*tag_11_contents_size) = 0;
1436         /* This format is inspired by OpenPGP; see RFC 2440
1437          * packet tag 11
1438          *
1439          * Tag 11 identifier (1 byte)
1440          * Max Tag 11 packet size (max 3 bytes)
1441          * Binary format specifier (1 byte)
1442          * Filename length (1 byte)
1443          * Filename ("_CONSOLE") (8 bytes)
1444          * Modification date (4 bytes)
1445          * Literal data (arbitrary)
1446          *
1447          * We need at least 16 bytes of data for the packet to even be
1448          * valid.
1449          */
1450         if (max_packet_size < 16) {
1451                 printk(KERN_ERR "Maximum packet size too small\n");
1452                 rc = -EINVAL;
1453                 goto out;
1454         }
1455         if (data[(*packet_size)++] != ECRYPTFS_TAG_11_PACKET_TYPE) {
1456                 printk(KERN_WARNING "Invalid tag 11 packet format\n");
1457                 rc = -EINVAL;
1458                 goto out;
1459         }
1460         rc = ecryptfs_parse_packet_length(&data[(*packet_size)], &body_size,
1461                                           &length_size);
1462         if (rc) {
1463                 printk(KERN_WARNING "Invalid tag 11 packet format\n");
1464                 goto out;
1465         }
1466         if (body_size < 14) {
1467                 printk(KERN_WARNING "Invalid body size ([%td])\n", body_size);
1468                 rc = -EINVAL;
1469                 goto out;
1470         }
1471         (*packet_size) += length_size;
1472         (*tag_11_contents_size) = (body_size - 14);
1473         if (unlikely((*packet_size) + body_size + 1 > max_packet_size)) {
1474                 printk(KERN_ERR "Packet size exceeds max\n");
1475                 rc = -EINVAL;
1476                 goto out;
1477         }
1478         if (unlikely((*tag_11_contents_size) > max_contents_bytes)) {
1479                 printk(KERN_ERR "Literal data section in tag 11 packet exceeds "
1480                        "expected size\n");
1481                 rc = -EINVAL;
1482                 goto out;
1483         }
1484         if (data[(*packet_size)++] != 0x62) {
1485                 printk(KERN_WARNING "Unrecognizable packet\n");
1486                 rc = -EINVAL;
1487                 goto out;
1488         }
1489         if (data[(*packet_size)++] != 0x08) {
1490                 printk(KERN_WARNING "Unrecognizable packet\n");
1491                 rc = -EINVAL;
1492                 goto out;
1493         }
1494         (*packet_size) += 12; /* Ignore filename and modification date */
1495         memcpy(contents, &data[(*packet_size)], (*tag_11_contents_size));
1496         (*packet_size) += (*tag_11_contents_size);
1497 out:
1498         if (rc) {
1499                 (*packet_size) = 0;
1500                 (*tag_11_contents_size) = 0;
1501         }
1502         return rc;
1503 }
1504
1505 /**
1506  * ecryptfs_verify_version
1507  * @version: The version number to confirm
1508  *
1509  * Returns zero on good version; non-zero otherwise
1510  */
1511 static int ecryptfs_verify_version(u16 version)
1512 {
1513         int rc = 0;
1514         unsigned char major;
1515         unsigned char minor;
1516
1517         major = ((version >> 8) & 0xFF);
1518         minor = (version & 0xFF);
1519         if (major != ECRYPTFS_VERSION_MAJOR) {
1520                 ecryptfs_printk(KERN_ERR, "Major version number mismatch. "
1521                                 "Expected [%d]; got [%d]\n",
1522                                 ECRYPTFS_VERSION_MAJOR, major);
1523                 rc = -EINVAL;
1524                 goto out;
1525         }
1526         if (minor != ECRYPTFS_VERSION_MINOR) {
1527                 ecryptfs_printk(KERN_ERR, "Minor version number mismatch. "
1528                                 "Expected [%d]; got [%d]\n",
1529                                 ECRYPTFS_VERSION_MINOR, minor);
1530                 rc = -EINVAL;
1531                 goto out;
1532         }
1533 out:
1534         return rc;
1535 }
1536
1537 int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
1538                                       struct ecryptfs_auth_tok **auth_tok,
1539                                       char *sig)
1540 {
1541         int rc = 0;
1542
1543         (*auth_tok_key) = request_key(&key_type_user, sig, NULL);
1544         if (!(*auth_tok_key) || IS_ERR(*auth_tok_key)) {
1545                 printk(KERN_ERR "Could not find key with description: [%s]\n",
1546                        sig);
1547                 rc = process_request_key_err(PTR_ERR(*auth_tok_key));
1548                 goto out;
1549         }
1550         (*auth_tok) = ecryptfs_get_key_payload_data(*auth_tok_key);
1551         if (ecryptfs_verify_version((*auth_tok)->version)) {
1552                 printk(KERN_ERR
1553                        "Data structure version mismatch. "
1554                        "Userspace tools must match eCryptfs "
1555                        "kernel module with major version [%d] "
1556                        "and minor version [%d]\n",
1557                        ECRYPTFS_VERSION_MAJOR,
1558                        ECRYPTFS_VERSION_MINOR);
1559                 rc = -EINVAL;
1560                 goto out;
1561         }
1562         if ((*auth_tok)->token_type != ECRYPTFS_PASSWORD
1563             && (*auth_tok)->token_type != ECRYPTFS_PRIVATE_KEY) {
1564                 printk(KERN_ERR "Invalid auth_tok structure "
1565                        "returned from key query\n");
1566                 rc = -EINVAL;
1567                 goto out;
1568         }
1569 out:
1570         return rc;
1571 }
1572
1573 /**
1574  * decrypt_passphrase_encrypted_session_key - Decrypt the session key with the given auth_tok.
1575  * @auth_tok: The passphrase authentication token to use to encrypt the FEK
1576  * @crypt_stat: The cryptographic context
1577  *
1578  * Returns zero on success; non-zero error otherwise
1579  */
1580 static int
1581 decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
1582                                          struct ecryptfs_crypt_stat *crypt_stat)
1583 {
1584         struct scatterlist dst_sg[2];
1585         struct scatterlist src_sg[2];
1586         struct mutex *tfm_mutex;
1587         struct blkcipher_desc desc = {
1588                 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
1589         };
1590         int rc = 0;
1591
1592         if (unlikely(ecryptfs_verbosity > 0)) {
1593                 ecryptfs_printk(
1594                         KERN_DEBUG, "Session key encryption key (size [%d]):\n",
1595                         auth_tok->token.password.session_key_encryption_key_bytes);
1596                 ecryptfs_dump_hex(
1597                         auth_tok->token.password.session_key_encryption_key,
1598                         auth_tok->token.password.session_key_encryption_key_bytes);
1599         }
1600         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,
1601                                                         crypt_stat->cipher);
1602         if (unlikely(rc)) {
1603                 printk(KERN_ERR "Internal error whilst attempting to get "
1604                        "tfm and mutex for cipher name [%s]; rc = [%d]\n",
1605                        crypt_stat->cipher, rc);
1606                 goto out;
1607         }
1608         rc = virt_to_scatterlist(auth_tok->session_key.encrypted_key,
1609                                  auth_tok->session_key.encrypted_key_size,
1610                                  src_sg, 2);
1611         if (rc < 1 || rc > 2) {
1612                 printk(KERN_ERR "Internal error whilst attempting to convert "
1613                         "auth_tok->session_key.encrypted_key to scatterlist; "
1614                         "expected rc = 1; got rc = [%d]. "
1615                        "auth_tok->session_key.encrypted_key_size = [%d]\n", rc,
1616                         auth_tok->session_key.encrypted_key_size);
1617                 goto out;
1618         }
1619         auth_tok->session_key.decrypted_key_size =
1620                 auth_tok->session_key.encrypted_key_size;
1621         rc = virt_to_scatterlist(auth_tok->session_key.decrypted_key,
1622                                  auth_tok->session_key.decrypted_key_size,
1623                                  dst_sg, 2);
1624         if (rc < 1 || rc > 2) {
1625                 printk(KERN_ERR "Internal error whilst attempting to convert "
1626                         "auth_tok->session_key.decrypted_key to scatterlist; "
1627                         "expected rc = 1; got rc = [%d]\n", rc);
1628                 goto out;
1629         }
1630         mutex_lock(tfm_mutex);
1631         rc = crypto_blkcipher_setkey(
1632                 desc.tfm, auth_tok->token.password.session_key_encryption_key,
1633                 crypt_stat->key_size);
1634         if (unlikely(rc < 0)) {
1635                 mutex_unlock(tfm_mutex);
1636                 printk(KERN_ERR "Error setting key for crypto context\n");
1637                 rc = -EINVAL;
1638                 goto out;
1639         }
1640         rc = crypto_blkcipher_decrypt(&desc, dst_sg, src_sg,
1641                                       auth_tok->session_key.encrypted_key_size);
1642         mutex_unlock(tfm_mutex);
1643         if (unlikely(rc)) {
1644                 printk(KERN_ERR "Error decrypting; rc = [%d]\n", rc);
1645                 goto out;
1646         }
1647         auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1648         memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
1649                auth_tok->session_key.decrypted_key_size);
1650         crypt_stat->flags |= ECRYPTFS_KEY_VALID;
1651         if (unlikely(ecryptfs_verbosity > 0)) {
1652                 ecryptfs_printk(KERN_DEBUG, "FEK of size [%d]:\n",
1653                                 crypt_stat->key_size);
1654                 ecryptfs_dump_hex(crypt_stat->key,
1655                                   crypt_stat->key_size);
1656         }
1657 out:
1658         return rc;
1659 }
1660
1661 /**
1662  * ecryptfs_parse_packet_set
1663  * @crypt_stat: The cryptographic context
1664  * @src: Virtual address of region of memory containing the packets
1665  * @ecryptfs_dentry: The eCryptfs dentry associated with the packet set
1666  *
1667  * Get crypt_stat to have the file's session key if the requisite key
1668  * is available to decrypt the session key.
1669  *
1670  * Returns Zero if a valid authentication token was retrieved and
1671  * processed; negative value for file not encrypted or for error
1672  * conditions.
1673  */
1674 int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
1675                               unsigned char *src,
1676                               struct dentry *ecryptfs_dentry)
1677 {
1678         size_t i = 0;
1679         size_t found_auth_tok;
1680         size_t next_packet_is_auth_tok_packet;
1681         struct list_head auth_tok_list;
1682         struct ecryptfs_auth_tok *matching_auth_tok;
1683         struct ecryptfs_auth_tok *candidate_auth_tok;
1684         char *candidate_auth_tok_sig;
1685         size_t packet_size;
1686         struct ecryptfs_auth_tok *new_auth_tok;
1687         unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE];
1688         struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1689         size_t tag_11_contents_size;
1690         size_t tag_11_packet_size;
1691         int rc = 0;
1692
1693         INIT_LIST_HEAD(&auth_tok_list);
1694         /* Parse the header to find as many packets as we can; these will be
1695          * added the our &auth_tok_list */
1696         next_packet_is_auth_tok_packet = 1;
1697         while (next_packet_is_auth_tok_packet) {
1698                 size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i);
1699
1700                 switch (src[i]) {
1701                 case ECRYPTFS_TAG_3_PACKET_TYPE:
1702                         rc = parse_tag_3_packet(crypt_stat,
1703                                                 (unsigned char *)&src[i],
1704                                                 &auth_tok_list, &new_auth_tok,
1705                                                 &packet_size, max_packet_size);
1706                         if (rc) {
1707                                 ecryptfs_printk(KERN_ERR, "Error parsing "
1708                                                 "tag 3 packet\n");
1709                                 rc = -EIO;
1710                                 goto out_wipe_list;
1711                         }
1712                         i += packet_size;
1713                         rc = parse_tag_11_packet((unsigned char *)&src[i],
1714                                                  sig_tmp_space,
1715                                                  ECRYPTFS_SIG_SIZE,
1716                                                  &tag_11_contents_size,
1717                                                  &tag_11_packet_size,
1718                                                  max_packet_size);
1719                         if (rc) {
1720                                 ecryptfs_printk(KERN_ERR, "No valid "
1721                                                 "(ecryptfs-specific) literal "
1722                                                 "packet containing "
1723                                                 "authentication token "
1724                                                 "signature found after "
1725                                                 "tag 3 packet\n");
1726                                 rc = -EIO;
1727                                 goto out_wipe_list;
1728                         }
1729                         i += tag_11_packet_size;
1730                         if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {
1731                                 ecryptfs_printk(KERN_ERR, "Expected "
1732                                                 "signature of size [%d]; "
1733                                                 "read size [%d]\n",
1734                                                 ECRYPTFS_SIG_SIZE,
1735                                                 tag_11_contents_size);
1736                                 rc = -EIO;
1737                                 goto out_wipe_list;
1738                         }
1739                         ecryptfs_to_hex(new_auth_tok->token.password.signature,
1740                                         sig_tmp_space, tag_11_contents_size);
1741                         new_auth_tok->token.password.signature[
1742                                 ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';
1743                         crypt_stat->flags |= ECRYPTFS_ENCRYPTED;
1744                         break;
1745                 case ECRYPTFS_TAG_1_PACKET_TYPE:
1746                         rc = parse_tag_1_packet(crypt_stat,
1747                                                 (unsigned char *)&src[i],
1748                                                 &auth_tok_list, &new_auth_tok,
1749                                                 &packet_size, max_packet_size);
1750                         if (rc) {
1751                                 ecryptfs_printk(KERN_ERR, "Error parsing "
1752                                                 "tag 1 packet\n");
1753                                 rc = -EIO;
1754                                 goto out_wipe_list;
1755                         }
1756                         i += packet_size;
1757                         crypt_stat->flags |= ECRYPTFS_ENCRYPTED;
1758                         break;
1759                 case ECRYPTFS_TAG_11_PACKET_TYPE:
1760                         ecryptfs_printk(KERN_WARNING, "Invalid packet set "
1761                                         "(Tag 11 not allowed by itself)\n");
1762                         rc = -EIO;
1763                         goto out_wipe_list;
1764                         break;
1765                 default:
1766                         ecryptfs_printk(KERN_DEBUG, "No packet at offset "
1767                                         "[%d] of the file header; hex value of "
1768                                         "character is [0x%.2x]\n", i, src[i]);
1769                         next_packet_is_auth_tok_packet = 0;
1770                 }
1771         }
1772         if (list_empty(&auth_tok_list)) {
1773                 printk(KERN_ERR "The lower file appears to be a non-encrypted "
1774                        "eCryptfs file; this is not supported in this version "
1775                        "of the eCryptfs kernel module\n");
1776                 rc = -EINVAL;
1777                 goto out;
1778         }
1779         /* auth_tok_list contains the set of authentication tokens
1780          * parsed from the metadata. We need to find a matching
1781          * authentication token that has the secret component(s)
1782          * necessary to decrypt the EFEK in the auth_tok parsed from
1783          * the metadata. There may be several potential matches, but
1784          * just one will be sufficient to decrypt to get the FEK. */
1785 find_next_matching_auth_tok:
1786         found_auth_tok = 0;
1787         list_for_each_entry(auth_tok_list_item, &auth_tok_list, list) {
1788                 candidate_auth_tok = &auth_tok_list_item->auth_tok;
1789                 if (unlikely(ecryptfs_verbosity > 0)) {
1790                         ecryptfs_printk(KERN_DEBUG,
1791                                         "Considering cadidate auth tok:\n");
1792                         ecryptfs_dump_auth_tok(candidate_auth_tok);
1793                 }
1794                 rc = ecryptfs_get_auth_tok_sig(&candidate_auth_tok_sig,
1795                                                candidate_auth_tok);
1796                 if (rc) {
1797                         printk(KERN_ERR
1798                                "Unrecognized candidate auth tok type: [%d]\n",
1799                                candidate_auth_tok->token_type);
1800                         rc = -EINVAL;
1801                         goto out_wipe_list;
1802                 }
1803                 ecryptfs_find_auth_tok_for_sig(&matching_auth_tok,
1804                                                crypt_stat->mount_crypt_stat,
1805                                                candidate_auth_tok_sig);
1806                 if (matching_auth_tok) {
1807                         found_auth_tok = 1;
1808                         goto found_matching_auth_tok;
1809                 }
1810         }
1811         if (!found_auth_tok) {
1812                 ecryptfs_printk(KERN_ERR, "Could not find a usable "
1813                                 "authentication token\n");
1814                 rc = -EIO;
1815                 goto out_wipe_list;
1816         }
1817 found_matching_auth_tok:
1818         if (candidate_auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
1819                 memcpy(&(candidate_auth_tok->token.private_key),
1820                        &(matching_auth_tok->token.private_key),
1821                        sizeof(struct ecryptfs_private_key));
1822                 rc = decrypt_pki_encrypted_session_key(candidate_auth_tok,
1823                                                        crypt_stat);
1824         } else if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD) {
1825                 memcpy(&(candidate_auth_tok->token.password),
1826                        &(matching_auth_tok->token.password),
1827                        sizeof(struct ecryptfs_password));
1828                 rc = decrypt_passphrase_encrypted_session_key(
1829                         candidate_auth_tok, crypt_stat);
1830         }
1831         if (rc) {
1832                 struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp;
1833
1834                 ecryptfs_printk(KERN_WARNING, "Error decrypting the "
1835                                 "session key for authentication token with sig "
1836                                 "[%.*s]; rc = [%d]. Removing auth tok "
1837                                 "candidate from the list and searching for "
1838                                 "the next match.\n", candidate_auth_tok_sig,
1839                                 ECRYPTFS_SIG_SIZE_HEX, rc);
1840                 list_for_each_entry_safe(auth_tok_list_item,
1841                                          auth_tok_list_item_tmp,
1842                                          &auth_tok_list, list) {
1843                         if (candidate_auth_tok
1844                             == &auth_tok_list_item->auth_tok) {
1845                                 list_del(&auth_tok_list_item->list);
1846                                 kmem_cache_free(
1847                                         ecryptfs_auth_tok_list_item_cache,
1848                                         auth_tok_list_item);
1849                                 goto find_next_matching_auth_tok;
1850                         }
1851                 }
1852                 BUG();
1853         }
1854         rc = ecryptfs_compute_root_iv(crypt_stat);
1855         if (rc) {
1856                 ecryptfs_printk(KERN_ERR, "Error computing "
1857                                 "the root IV\n");
1858                 goto out_wipe_list;
1859         }
1860         rc = ecryptfs_init_crypt_ctx(crypt_stat);
1861         if (rc) {
1862                 ecryptfs_printk(KERN_ERR, "Error initializing crypto "
1863                                 "context for cipher [%s]; rc = [%d]\n",
1864                                 crypt_stat->cipher, rc);
1865         }
1866 out_wipe_list:
1867         wipe_auth_tok_list(&auth_tok_list);
1868 out:
1869         return rc;
1870 }
1871
1872 static int
1873 pki_encrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
1874                         struct ecryptfs_crypt_stat *crypt_stat,
1875                         struct ecryptfs_key_record *key_rec)
1876 {
1877         struct ecryptfs_msg_ctx *msg_ctx = NULL;
1878         char *payload = NULL;
1879         size_t payload_len;
1880         struct ecryptfs_message *msg;
1881         int rc;
1882
1883         rc = write_tag_66_packet(auth_tok->token.private_key.signature,
1884                                  ecryptfs_code_for_cipher_string(
1885                                          crypt_stat->cipher,
1886                                          crypt_stat->key_size),
1887                                  crypt_stat, &payload, &payload_len);
1888         if (rc) {
1889                 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet\n");
1890                 goto out;
1891         }
1892         rc = ecryptfs_send_message(payload, payload_len, &msg_ctx);
1893         if (rc) {
1894                 ecryptfs_printk(KERN_ERR, "Error sending message to "
1895                                 "ecryptfsd\n");
1896                 goto out;
1897         }
1898         rc = ecryptfs_wait_for_response(msg_ctx, &msg);
1899         if (rc) {
1900                 ecryptfs_printk(KERN_ERR, "Failed to receive tag 67 packet "
1901                                 "from the user space daemon\n");
1902                 rc = -EIO;
1903                 goto out;
1904         }
1905         rc = parse_tag_67_packet(key_rec, msg);
1906         if (rc)
1907                 ecryptfs_printk(KERN_ERR, "Error parsing tag 67 packet\n");
1908         kfree(msg);
1909 out:
1910         kfree(payload);
1911         return rc;
1912 }
1913 /**
1914  * write_tag_1_packet - Write an RFC2440-compatible tag 1 (public key) packet
1915  * @dest: Buffer into which to write the packet
1916  * @remaining_bytes: Maximum number of bytes that can be writtn
1917  * @auth_tok: The authentication token used for generating the tag 1 packet
1918  * @crypt_stat: The cryptographic context
1919  * @key_rec: The key record struct for the tag 1 packet
1920  * @packet_size: This function will write the number of bytes that end
1921  *               up constituting the packet; set to zero on error
1922  *
1923  * Returns zero on success; non-zero on error.
1924  */
1925 static int
1926 write_tag_1_packet(char *dest, size_t *remaining_bytes,
1927                    struct ecryptfs_auth_tok *auth_tok,
1928                    struct ecryptfs_crypt_stat *crypt_stat,
1929                    struct ecryptfs_key_record *key_rec, size_t *packet_size)
1930 {
1931         size_t i;
1932         size_t encrypted_session_key_valid = 0;
1933         size_t packet_size_length;
1934         size_t max_packet_size;
1935         int rc = 0;
1936
1937         (*packet_size) = 0;
1938         ecryptfs_from_hex(key_rec->sig, auth_tok->token.private_key.signature,
1939                           ECRYPTFS_SIG_SIZE);
1940         encrypted_session_key_valid = 0;
1941         for (i = 0; i < crypt_stat->key_size; i++)
1942                 encrypted_session_key_valid |=
1943                         auth_tok->session_key.encrypted_key[i];
1944         if (encrypted_session_key_valid) {
1945                 memcpy(key_rec->enc_key,
1946                        auth_tok->session_key.encrypted_key,
1947                        auth_tok->session_key.encrypted_key_size);
1948                 goto encrypted_session_key_set;
1949         }
1950         if (auth_tok->session_key.encrypted_key_size == 0)
1951                 auth_tok->session_key.encrypted_key_size =
1952                         auth_tok->token.private_key.key_size;
1953         rc = pki_encrypt_session_key(auth_tok, crypt_stat, key_rec);
1954         if (rc) {
1955                 printk(KERN_ERR "Failed to encrypt session key via a key "
1956                        "module; rc = [%d]\n", rc);
1957                 goto out;
1958         }
1959         if (ecryptfs_verbosity > 0) {
1960                 ecryptfs_printk(KERN_DEBUG, "Encrypted key:\n");
1961                 ecryptfs_dump_hex(key_rec->enc_key, key_rec->enc_key_size);
1962         }
1963 encrypted_session_key_set:
1964         /* This format is inspired by OpenPGP; see RFC 2440
1965          * packet tag 1 */
1966         max_packet_size = (1                         /* Tag 1 identifier */
1967                            + 3                       /* Max Tag 1 packet size */
1968                            + 1                       /* Version */
1969                            + ECRYPTFS_SIG_SIZE       /* Key identifier */
1970                            + 1                       /* Cipher identifier */
1971                            + key_rec->enc_key_size); /* Encrypted key size */
1972         if (max_packet_size > (*remaining_bytes)) {
1973                 printk(KERN_ERR "Packet length larger than maximum allowable; "
1974                        "need up to [%td] bytes, but there are only [%td] "
1975                        "available\n", max_packet_size, (*remaining_bytes));
1976                 rc = -EINVAL;
1977                 goto out;
1978         }
1979         dest[(*packet_size)++] = ECRYPTFS_TAG_1_PACKET_TYPE;
1980         rc = ecryptfs_write_packet_length(&dest[(*packet_size)],
1981                                           (max_packet_size - 4),
1982                                           &packet_size_length);
1983         if (rc) {
1984                 ecryptfs_printk(KERN_ERR, "Error generating tag 1 packet "
1985                                 "header; cannot generate packet length\n");
1986                 goto out;
1987         }
1988         (*packet_size) += packet_size_length;
1989         dest[(*packet_size)++] = 0x03; /* version 3 */
1990         memcpy(&dest[(*packet_size)], key_rec->sig, ECRYPTFS_SIG_SIZE);
1991         (*packet_size) += ECRYPTFS_SIG_SIZE;
1992         dest[(*packet_size)++] = RFC2440_CIPHER_RSA;
1993         memcpy(&dest[(*packet_size)], key_rec->enc_key,
1994                key_rec->enc_key_size);
1995         (*packet_size) += key_rec->enc_key_size;
1996 out:
1997         if (rc)
1998                 (*packet_size) = 0;
1999         else
2000                 (*remaining_bytes) -= (*packet_size);
2001         return rc;
2002 }
2003
2004 /**
2005  * write_tag_11_packet
2006  * @dest: Target into which Tag 11 packet is to be written
2007  * @remaining_bytes: Maximum packet length
2008  * @contents: Byte array of contents to copy in
2009  * @contents_length: Number of bytes in contents
2010  * @packet_length: Length of the Tag 11 packet written; zero on error
2011  *
2012  * Returns zero on success; non-zero on error.
2013  */
2014 static int
2015 write_tag_11_packet(char *dest, size_t *remaining_bytes, char *contents,
2016                     size_t contents_length, size_t *packet_length)
2017 {
2018         size_t packet_size_length;
2019         size_t max_packet_size;
2020         int rc = 0;
2021
2022         (*packet_length) = 0;
2023         /* This format is inspired by OpenPGP; see RFC 2440
2024          * packet tag 11 */
2025         max_packet_size = (1                   /* Tag 11 identifier */
2026                            + 3                 /* Max Tag 11 packet size */
2027                            + 1                 /* Binary format specifier */
2028                            + 1                 /* Filename length */
2029                            + 8                 /* Filename ("_CONSOLE") */
2030                            + 4                 /* Modification date */
2031                            + contents_length); /* Literal data */
2032         if (max_packet_size > (*remaining_bytes)) {
2033                 printk(KERN_ERR "Packet length larger than maximum allowable; "
2034                        "need up to [%td] bytes, but there are only [%td] "
2035                        "available\n", max_packet_size, (*remaining_bytes));
2036                 rc = -EINVAL;
2037                 goto out;
2038         }
2039         dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE;
2040         rc = ecryptfs_write_packet_length(&dest[(*packet_length)],
2041                                           (max_packet_size - 4),
2042                                           &packet_size_length);
2043         if (rc) {
2044                 printk(KERN_ERR "Error generating tag 11 packet header; cannot "
2045                        "generate packet length. rc = [%d]\n", rc);
2046                 goto out;
2047         }
2048         (*packet_length) += packet_size_length;
2049         dest[(*packet_length)++] = 0x62; /* binary data format specifier */
2050         dest[(*packet_length)++] = 8;
2051         memcpy(&dest[(*packet_length)], "_CONSOLE", 8);
2052         (*packet_length) += 8;
2053         memset(&dest[(*packet_length)], 0x00, 4);
2054         (*packet_length) += 4;
2055         memcpy(&dest[(*packet_length)], contents, contents_length);
2056         (*packet_length) += contents_length;
2057  out:
2058         if (rc)
2059                 (*packet_length) = 0;
2060         else
2061                 (*remaining_bytes) -= (*packet_length);
2062         return rc;
2063 }
2064
2065 /**
2066  * write_tag_3_packet
2067  * @dest: Buffer into which to write the packet
2068  * @remaining_bytes: Maximum number of bytes that can be written
2069  * @auth_tok: Authentication token
2070  * @crypt_stat: The cryptographic context
2071  * @key_rec: encrypted key
2072  * @packet_size: This function will write the number of bytes that end
2073  *               up constituting the packet; set to zero on error
2074  *
2075  * Returns zero on success; non-zero on error.
2076  */
2077 static int
2078 write_tag_3_packet(char *dest, size_t *remaining_bytes,
2079                    struct ecryptfs_auth_tok *auth_tok,
2080                    struct ecryptfs_crypt_stat *crypt_stat,
2081                    struct ecryptfs_key_record *key_rec, size_t *packet_size)
2082 {
2083         size_t i;
2084         size_t encrypted_session_key_valid = 0;
2085         char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
2086         struct scatterlist dst_sg[2];
2087         struct scatterlist src_sg[2];
2088         struct mutex *tfm_mutex = NULL;
2089         u8 cipher_code;
2090         size_t packet_size_length;
2091         size_t max_packet_size;
2092         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
2093                 crypt_stat->mount_crypt_stat;
2094         struct blkcipher_desc desc = {
2095                 .tfm = NULL,
2096                 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
2097         };
2098         int rc = 0;
2099
2100         (*packet_size) = 0;
2101         ecryptfs_from_hex(key_rec->sig, auth_tok->token.password.signature,
2102                           ECRYPTFS_SIG_SIZE);
2103         rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex,
2104                                                         crypt_stat->cipher);
2105         if (unlikely(rc)) {
2106                 printk(KERN_ERR "Internal error whilst attempting to get "
2107                        "tfm and mutex for cipher name [%s]; rc = [%d]\n",
2108                        crypt_stat->cipher, rc);
2109                 goto out;
2110         }
2111         if (mount_crypt_stat->global_default_cipher_key_size == 0) {
2112                 struct blkcipher_alg *alg = crypto_blkcipher_alg(desc.tfm);
2113
2114                 printk(KERN_WARNING "No key size specified at mount; "
2115                        "defaulting to [%d]\n", alg->max_keysize);
2116                 mount_crypt_stat->global_default_cipher_key_size =
2117                         alg->max_keysize;
2118         }
2119         if (crypt_stat->key_size == 0)
2120                 crypt_stat->key_size =
2121                         mount_crypt_stat->global_default_cipher_key_size;
2122         if (auth_tok->session_key.encrypted_key_size == 0)
2123                 auth_tok->session_key.encrypted_key_size =
2124                         crypt_stat->key_size;
2125         if (crypt_stat->key_size == 24
2126             && strcmp("aes", crypt_stat->cipher) == 0) {
2127                 memset((crypt_stat->key + 24), 0, 8);
2128                 auth_tok->session_key.encrypted_key_size = 32;
2129         } else
2130                 auth_tok->session_key.encrypted_key_size = crypt_stat->key_size;
2131         key_rec->enc_key_size =
2132                 auth_tok->session_key.encrypted_key_size;
2133         encrypted_session_key_valid = 0;
2134         for (i = 0; i < auth_tok->session_key.encrypted_key_size; i++)
2135                 encrypted_session_key_valid |=
2136                         auth_tok->session_key.encrypted_key[i];
2137         if (encrypted_session_key_valid) {
2138                 ecryptfs_printk(KERN_DEBUG, "encrypted_session_key_valid != 0; "
2139                                 "using auth_tok->session_key.encrypted_key, "
2140                                 "where key_rec->enc_key_size = [%d]\n",
2141                                 key_rec->enc_key_size);
2142                 memcpy(key_rec->enc_key,
2143                        auth_tok->session_key.encrypted_key,
2144                        key_rec->enc_key_size);
2145                 goto encrypted_session_key_set;
2146         }
2147         if (auth_tok->token.password.flags &
2148             ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET) {
2149                 ecryptfs_printk(KERN_DEBUG, "Using previously generated "
2150                                 "session key encryption key of size [%d]\n",
2151                                 auth_tok->token.password.
2152                                 session_key_encryption_key_bytes);
2153                 memcpy(session_key_encryption_key,
2154                        auth_tok->token.password.session_key_encryption_key,
2155                        crypt_stat->key_size);
2156                 ecryptfs_printk(KERN_DEBUG,
2157                                 "Cached session key " "encryption key: \n");
2158                 if (ecryptfs_verbosity > 0)
2159                         ecryptfs_dump_hex(session_key_encryption_key, 16);
2160         }
2161         if (unlikely(ecryptfs_verbosity > 0)) {
2162                 ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");
2163                 ecryptfs_dump_hex(session_key_encryption_key, 16);
2164         }
2165         rc = virt_to_scatterlist(crypt_stat->key, key_rec->enc_key_size,
2166                                  src_sg, 2);
2167         if (rc < 1 || rc > 2) {
2168                 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
2169                                 "for crypt_stat session key; expected rc = 1; "
2170                                 "got rc = [%d]. key_rec->enc_key_size = [%d]\n",
2171                                 rc, key_rec->enc_key_size);
2172                 rc = -ENOMEM;
2173                 goto out;
2174         }
2175         rc = virt_to_scatterlist(key_rec->enc_key, key_rec->enc_key_size,
2176                                  dst_sg, 2);
2177         if (rc < 1 || rc > 2) {
2178                 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
2179                                 "for crypt_stat encrypted session key; "
2180                                 "expected rc = 1; got rc = [%d]. "
2181                                 "key_rec->enc_key_size = [%d]\n", rc,
2182                                 key_rec->enc_key_size);
2183                 rc = -ENOMEM;
2184                 goto out;
2185         }
2186         mutex_lock(tfm_mutex);
2187         rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key,
2188                                      crypt_stat->key_size);
2189         if (rc < 0) {
2190                 mutex_unlock(tfm_mutex);
2191                 ecryptfs_printk(KERN_ERR, "Error setting key for crypto "
2192                                 "context; rc = [%d]\n", rc);
2193                 goto out;
2194         }
2195         rc = 0;
2196         ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n",
2197                         crypt_stat->key_size);
2198         rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg,
2199                                       (*key_rec).enc_key_size);
2200         mutex_unlock(tfm_mutex);
2201         if (rc) {
2202                 printk(KERN_ERR "Error encrypting; rc = [%d]\n", rc);
2203                 goto out;
2204         }
2205         ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");
2206         if (ecryptfs_verbosity > 0) {
2207                 ecryptfs_printk(KERN_DEBUG, "EFEK of size [%d]:\n",
2208                                 key_rec->enc_key_size);
2209                 ecryptfs_dump_hex(key_rec->enc_key,
2210                                   key_rec->enc_key_size);
2211         }
2212 encrypted_session_key_set:
2213         /* This format is inspired by OpenPGP; see RFC 2440
2214          * packet tag 3 */
2215         max_packet_size = (1                         /* Tag 3 identifier */
2216                            + 3                       /* Max Tag 3 packet size */
2217                            + 1                       /* Version */
2218                            + 1                       /* Cipher code */
2219                            + 1                       /* S2K specifier */
2220                            + 1                       /* Hash identifier */
2221                            + ECRYPTFS_SALT_SIZE      /* Salt */
2222                            + 1                       /* Hash iterations */
2223                            + key_rec->enc_key_size); /* Encrypted key size */
2224         if (max_packet_size > (*remaining_bytes)) {
2225                 printk(KERN_ERR "Packet too large; need up to [%td] bytes, but "
2226                        "there are only [%td] available\n", max_packet_size,
2227                        (*remaining_bytes));
2228                 rc = -EINVAL;
2229                 goto out;
2230         }
2231         dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE;
2232         /* Chop off the Tag 3 identifier(1) and Tag 3 packet size(3)
2233          * to get the number of octets in the actual Tag 3 packet */
2234         rc = ecryptfs_write_packet_length(&dest[(*packet_size)],
2235                                           (max_packet_size - 4),
2236                                           &packet_size_length);
2237         if (rc) {
2238                 printk(KERN_ERR "Error generating tag 3 packet header; cannot "
2239                        "generate packet length. rc = [%d]\n", rc);
2240                 goto out;
2241         }
2242         (*packet_size) += packet_size_length;
2243         dest[(*packet_size)++] = 0x04; /* version 4 */
2244         /* TODO: Break from RFC2440 so that arbitrary ciphers can be
2245          * specified with strings */
2246         cipher_code = ecryptfs_code_for_cipher_string(crypt_stat->cipher,
2247                                                       crypt_stat->key_size);
2248         if (cipher_code == 0) {
2249                 ecryptfs_printk(KERN_WARNING, "Unable to generate code for "
2250                                 "cipher [%s]\n", crypt_stat->cipher);
2251                 rc = -EINVAL;
2252                 goto out;
2253         }
2254         dest[(*packet_size)++] = cipher_code;
2255         dest[(*packet_size)++] = 0x03;  /* S2K */
2256         dest[(*packet_size)++] = 0x01;  /* MD5 (TODO: parameterize) */
2257         memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,
2258                ECRYPTFS_SALT_SIZE);
2259         (*packet_size) += ECRYPTFS_SALT_SIZE;   /* salt */
2260         dest[(*packet_size)++] = 0x60;  /* hash iterations (65536) */
2261         memcpy(&dest[(*packet_size)], key_rec->enc_key,
2262                key_rec->enc_key_size);
2263         (*packet_size) += key_rec->enc_key_size;
2264 out:
2265         if (rc)
2266                 (*packet_size) = 0;
2267         else
2268                 (*remaining_bytes) -= (*packet_size);
2269         return rc;
2270 }
2271
2272 struct kmem_cache *ecryptfs_key_record_cache;
2273
2274 /**
2275  * ecryptfs_generate_key_packet_set
2276  * @dest_base: Virtual address from which to write the key record set
2277  * @crypt_stat: The cryptographic context from which the
2278  *              authentication tokens will be retrieved
2279  * @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat
2280  *                   for the global parameters
2281  * @len: The amount written
2282  * @max: The maximum amount of data allowed to be written
2283  *
2284  * Generates a key packet set and writes it to the virtual address
2285  * passed in.
2286  *
2287  * Returns zero on success; non-zero on error.
2288  */
2289 int
2290 ecryptfs_generate_key_packet_set(char *dest_base,
2291                                  struct ecryptfs_crypt_stat *crypt_stat,
2292                                  struct dentry *ecryptfs_dentry, size_t *len,
2293                                  size_t max)
2294 {
2295         struct ecryptfs_auth_tok *auth_tok;
2296         struct ecryptfs_global_auth_tok *global_auth_tok;
2297         struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
2298                 &ecryptfs_superblock_to_private(
2299                         ecryptfs_dentry->d_sb)->mount_crypt_stat;
2300         size_t written;
2301         struct ecryptfs_key_record *key_rec;
2302         struct ecryptfs_key_sig *key_sig;
2303         int rc = 0;
2304
2305         (*len) = 0;
2306         mutex_lock(&crypt_stat->keysig_list_mutex);
2307         key_rec = kmem_cache_alloc(ecryptfs_key_record_cache, GFP_KERNEL);
2308         if (!key_rec) {
2309                 rc = -ENOMEM;
2310                 goto out;
2311         }
2312         list_for_each_entry(key_sig, &crypt_stat->keysig_list,
2313                             crypt_stat_list) {
2314                 memset(key_rec, 0, sizeof(*key_rec));
2315                 rc = ecryptfs_find_global_auth_tok_for_sig(&global_auth_tok,
2316                                                            mount_crypt_stat,
2317                                                            key_sig->keysig);
2318                 if (rc) {
2319                         printk(KERN_ERR "Error attempting to get the global "
2320                                "auth_tok; rc = [%d]\n", rc);
2321                         goto out_free;
2322                 }
2323                 if (global_auth_tok->flags & ECRYPTFS_AUTH_TOK_INVALID) {
2324                         printk(KERN_WARNING
2325                                "Skipping invalid auth tok with sig = [%s]\n",
2326                                global_auth_tok->sig);
2327                         continue;
2328                 }
2329                 auth_tok = global_auth_tok->global_auth_tok;
2330                 if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
2331                         rc = write_tag_3_packet((dest_base + (*len)),
2332                                                 &max, auth_tok,
2333                                                 crypt_stat, key_rec,
2334                                                 &written);
2335                         if (rc) {
2336                                 ecryptfs_printk(KERN_WARNING, "Error "
2337                                                 "writing tag 3 packet\n");
2338                                 goto out_free;
2339                         }
2340                         (*len) += written;
2341                         /* Write auth tok signature packet */
2342                         rc = write_tag_11_packet((dest_base + (*len)), &max,
2343                                                  key_rec->sig,
2344                                                  ECRYPTFS_SIG_SIZE, &written);
2345                         if (rc) {
2346                                 ecryptfs_printk(KERN_ERR, "Error writing "
2347                                                 "auth tok signature packet\n");
2348                                 goto out_free;
2349                         }
2350                         (*len) += written;
2351                 } else if (auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
2352                         rc = write_tag_1_packet(dest_base + (*len),
2353                                                 &max, auth_tok,
2354                                                 crypt_stat, key_rec, &written);
2355                         if (rc) {
2356                                 ecryptfs_printk(KERN_WARNING, "Error "
2357                                                 "writing tag 1 packet\n");
2358                                 goto out_free;
2359                         }
2360                         (*len) += written;
2361                 } else {
2362                         ecryptfs_printk(KERN_WARNING, "Unsupported "
2363                                         "authentication token type\n");
2364                         rc = -EINVAL;
2365                         goto out_free;
2366                 }
2367         }
2368         if (likely(max > 0)) {
2369                 dest_base[(*len)] = 0x00;
2370         } else {
2371                 ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");
2372                 rc = -EIO;
2373         }
2374 out_free:
2375         kmem_cache_free(ecryptfs_key_record_cache, key_rec);
2376 out:
2377         if (rc)
2378                 (*len) = 0;
2379         mutex_unlock(&crypt_stat->keysig_list_mutex);
2380         return rc;
2381 }
2382
2383 struct kmem_cache *ecryptfs_key_sig_cache;
2384
2385 int ecryptfs_add_keysig(struct ecryptfs_crypt_stat *crypt_stat, char *sig)
2386 {
2387         struct ecryptfs_key_sig *new_key_sig;
2388
2389         new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL);
2390         if (!new_key_sig) {
2391                 printk(KERN_ERR
2392                        "Error allocating from ecryptfs_key_sig_cache\n");
2393                 return -ENOMEM;
2394         }
2395         memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX);
2396         /* Caller must hold keysig_list_mutex */
2397         list_add(&new_key_sig->crypt_stat_list, &crypt_stat->keysig_list);
2398
2399         return 0;
2400 }
2401
2402 struct kmem_cache *ecryptfs_global_auth_tok_cache;
2403
2404 int
2405 ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
2406                              char *sig, u32 global_auth_tok_flags)
2407 {
2408         struct ecryptfs_global_auth_tok *new_auth_tok;
2409         int rc = 0;
2410
2411         new_auth_tok = kmem_cache_zalloc(ecryptfs_global_auth_tok_cache,
2412                                         GFP_KERNEL);
2413         if (!new_auth_tok) {
2414                 rc = -ENOMEM;
2415                 printk(KERN_ERR "Error allocating from "
2416                        "ecryptfs_global_auth_tok_cache\n");
2417                 goto out;
2418         }
2419         memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX);
2420         new_auth_tok->flags = global_auth_tok_flags;
2421         new_auth_tok->sig[ECRYPTFS_SIG_SIZE_HEX] = '\0';
2422         mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex);
2423         list_add(&new_auth_tok->mount_crypt_stat_list,
2424                  &mount_crypt_stat->global_auth_tok_list);
2425         mount_crypt_stat->num_global_auth_toks++;
2426         mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex);
2427 out:
2428         return rc;
2429 }
2430