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