fs/ecryptfs/keystore.c

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