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 goto out; 1546 } 1547 (*auth_tok) = ecryptfs_get_key_payload_data(*auth_tok_key); 1548 if (ecryptfs_verify_version((*auth_tok)->version)) { 1549 printk(KERN_ERR 1550 "Data structure version mismatch. " 1551 "Userspace tools must match eCryptfs " 1552 "kernel module with major version [%d] " 1553 "and minor version [%d]\n", 1554 ECRYPTFS_VERSION_MAJOR, 1555 ECRYPTFS_VERSION_MINOR); 1556 rc = -EINVAL; 1557 goto out; 1558 } 1559 if ((*auth_tok)->token_type != ECRYPTFS_PASSWORD 1560 && (*auth_tok)->token_type != ECRYPTFS_PRIVATE_KEY) { 1561 printk(KERN_ERR "Invalid auth_tok structure " 1562 "returned from key query\n"); 1563 rc = -EINVAL; 1564 goto out; 1565 } 1566 out: 1567 return rc; 1568 } 1569 1570 /** 1571 * decrypt_passphrase_encrypted_session_key - Decrypt the session key with the given auth_tok. 1572 * @auth_tok: The passphrase authentication token to use to encrypt the FEK 1573 * @crypt_stat: The cryptographic context 1574 * 1575 * Returns zero on success; non-zero error otherwise 1576 */ 1577 static int 1578 decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok, 1579 struct ecryptfs_crypt_stat *crypt_stat) 1580 { 1581 struct scatterlist dst_sg[2]; 1582 struct scatterlist src_sg[2]; 1583 struct mutex *tfm_mutex; 1584 struct blkcipher_desc desc = { 1585 .flags = CRYPTO_TFM_REQ_MAY_SLEEP 1586 }; 1587 int rc = 0; 1588 1589 if (unlikely(ecryptfs_verbosity > 0)) { 1590 ecryptfs_printk( 1591 KERN_DEBUG, "Session key encryption key (size [%d]):\n", 1592 auth_tok->token.password.session_key_encryption_key_bytes); 1593 ecryptfs_dump_hex( 1594 auth_tok->token.password.session_key_encryption_key, 1595 auth_tok->token.password.session_key_encryption_key_bytes); 1596 } 1597 rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex, 1598 crypt_stat->cipher); 1599 if (unlikely(rc)) { 1600 printk(KERN_ERR "Internal error whilst attempting to get " 1601 "tfm and mutex for cipher name [%s]; rc = [%d]\n", 1602 crypt_stat->cipher, rc); 1603 goto out; 1604 } 1605 rc = virt_to_scatterlist(auth_tok->session_key.encrypted_key, 1606 auth_tok->session_key.encrypted_key_size, 1607 src_sg, 2); 1608 if (rc < 1 || rc > 2) { 1609 printk(KERN_ERR "Internal error whilst attempting to convert " 1610 "auth_tok->session_key.encrypted_key to scatterlist; " 1611 "expected rc = 1; got rc = [%d]. " 1612 "auth_tok->session_key.encrypted_key_size = [%d]\n", rc, 1613 auth_tok->session_key.encrypted_key_size); 1614 goto out; 1615 } 1616 auth_tok->session_key.decrypted_key_size = 1617 auth_tok->session_key.encrypted_key_size; 1618 rc = virt_to_scatterlist(auth_tok->session_key.decrypted_key, 1619 auth_tok->session_key.decrypted_key_size, 1620 dst_sg, 2); 1621 if (rc < 1 || rc > 2) { 1622 printk(KERN_ERR "Internal error whilst attempting to convert " 1623 "auth_tok->session_key.decrypted_key to scatterlist; " 1624 "expected rc = 1; got rc = [%d]\n", rc); 1625 goto out; 1626 } 1627 mutex_lock(tfm_mutex); 1628 rc = crypto_blkcipher_setkey( 1629 desc.tfm, auth_tok->token.password.session_key_encryption_key, 1630 crypt_stat->key_size); 1631 if (unlikely(rc < 0)) { 1632 mutex_unlock(tfm_mutex); 1633 printk(KERN_ERR "Error setting key for crypto context\n"); 1634 rc = -EINVAL; 1635 goto out; 1636 } 1637 rc = crypto_blkcipher_decrypt(&desc, dst_sg, src_sg, 1638 auth_tok->session_key.encrypted_key_size); 1639 mutex_unlock(tfm_mutex); 1640 if (unlikely(rc)) { 1641 printk(KERN_ERR "Error decrypting; rc = [%d]\n", rc); 1642 goto out; 1643 } 1644 auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY; 1645 memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key, 1646 auth_tok->session_key.decrypted_key_size); 1647 crypt_stat->flags |= ECRYPTFS_KEY_VALID; 1648 if (unlikely(ecryptfs_verbosity > 0)) { 1649 ecryptfs_printk(KERN_DEBUG, "FEK of size [%d]:\n", 1650 crypt_stat->key_size); 1651 ecryptfs_dump_hex(crypt_stat->key, 1652 crypt_stat->key_size); 1653 } 1654 out: 1655 return rc; 1656 } 1657 1658 /** 1659 * ecryptfs_parse_packet_set 1660 * @crypt_stat: The cryptographic context 1661 * @src: Virtual address of region of memory containing the packets 1662 * @ecryptfs_dentry: The eCryptfs dentry associated with the packet set 1663 * 1664 * Get crypt_stat to have the file's session key if the requisite key 1665 * is available to decrypt the session key. 1666 * 1667 * Returns Zero if a valid authentication token was retrieved and 1668 * processed; negative value for file not encrypted or for error 1669 * conditions. 1670 */ 1671 int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat, 1672 unsigned char *src, 1673 struct dentry *ecryptfs_dentry) 1674 { 1675 size_t i = 0; 1676 size_t found_auth_tok; 1677 size_t next_packet_is_auth_tok_packet; 1678 struct list_head auth_tok_list; 1679 struct ecryptfs_auth_tok *matching_auth_tok; 1680 struct ecryptfs_auth_tok *candidate_auth_tok; 1681 char *candidate_auth_tok_sig; 1682 size_t packet_size; 1683 struct ecryptfs_auth_tok *new_auth_tok; 1684 unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE]; 1685 struct ecryptfs_auth_tok_list_item *auth_tok_list_item; 1686 size_t tag_11_contents_size; 1687 size_t tag_11_packet_size; 1688 int rc = 0; 1689 1690 INIT_LIST_HEAD(&auth_tok_list); 1691 /* Parse the header to find as many packets as we can; these will be 1692 * added the our &auth_tok_list */ 1693 next_packet_is_auth_tok_packet = 1; 1694 while (next_packet_is_auth_tok_packet) { 1695 size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i); 1696 1697 switch (src[i]) { 1698 case ECRYPTFS_TAG_3_PACKET_TYPE: 1699 rc = parse_tag_3_packet(crypt_stat, 1700 (unsigned char *)&src[i], 1701 &auth_tok_list, &new_auth_tok, 1702 &packet_size, max_packet_size); 1703 if (rc) { 1704 ecryptfs_printk(KERN_ERR, "Error parsing " 1705 "tag 3 packet\n"); 1706 rc = -EIO; 1707 goto out_wipe_list; 1708 } 1709 i += packet_size; 1710 rc = parse_tag_11_packet((unsigned char *)&src[i], 1711 sig_tmp_space, 1712 ECRYPTFS_SIG_SIZE, 1713 &tag_11_contents_size, 1714 &tag_11_packet_size, 1715 max_packet_size); 1716 if (rc) { 1717 ecryptfs_printk(KERN_ERR, "No valid " 1718 "(ecryptfs-specific) literal " 1719 "packet containing " 1720 "authentication token " 1721 "signature found after " 1722 "tag 3 packet\n"); 1723 rc = -EIO; 1724 goto out_wipe_list; 1725 } 1726 i += tag_11_packet_size; 1727 if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) { 1728 ecryptfs_printk(KERN_ERR, "Expected " 1729 "signature of size [%d]; " 1730 "read size [%d]\n", 1731 ECRYPTFS_SIG_SIZE, 1732 tag_11_contents_size); 1733 rc = -EIO; 1734 goto out_wipe_list; 1735 } 1736 ecryptfs_to_hex(new_auth_tok->token.password.signature, 1737 sig_tmp_space, tag_11_contents_size); 1738 new_auth_tok->token.password.signature[ 1739 ECRYPTFS_PASSWORD_SIG_SIZE] = '\0'; 1740 crypt_stat->flags |= ECRYPTFS_ENCRYPTED; 1741 break; 1742 case ECRYPTFS_TAG_1_PACKET_TYPE: 1743 rc = parse_tag_1_packet(crypt_stat, 1744 (unsigned char *)&src[i], 1745 &auth_tok_list, &new_auth_tok, 1746 &packet_size, max_packet_size); 1747 if (rc) { 1748 ecryptfs_printk(KERN_ERR, "Error parsing " 1749 "tag 1 packet\n"); 1750 rc = -EIO; 1751 goto out_wipe_list; 1752 } 1753 i += packet_size; 1754 crypt_stat->flags |= ECRYPTFS_ENCRYPTED; 1755 break; 1756 case ECRYPTFS_TAG_11_PACKET_TYPE: 1757 ecryptfs_printk(KERN_WARNING, "Invalid packet set " 1758 "(Tag 11 not allowed by itself)\n"); 1759 rc = -EIO; 1760 goto out_wipe_list; 1761 break; 1762 default: 1763 ecryptfs_printk(KERN_DEBUG, "No packet at offset " 1764 "[%d] of the file header; hex value of " 1765 "character is [0x%.2x]\n", i, src[i]); 1766 next_packet_is_auth_tok_packet = 0; 1767 } 1768 } 1769 if (list_empty(&auth_tok_list)) { 1770 printk(KERN_ERR "The lower file appears to be a non-encrypted " 1771 "eCryptfs file; this is not supported in this version " 1772 "of the eCryptfs kernel module\n"); 1773 rc = -EINVAL; 1774 goto out; 1775 } 1776 /* auth_tok_list contains the set of authentication tokens 1777 * parsed from the metadata. We need to find a matching 1778 * authentication token that has the secret component(s) 1779 * necessary to decrypt the EFEK in the auth_tok parsed from 1780 * the metadata. There may be several potential matches, but 1781 * just one will be sufficient to decrypt to get the FEK. */ 1782 find_next_matching_auth_tok: 1783 found_auth_tok = 0; 1784 list_for_each_entry(auth_tok_list_item, &auth_tok_list, list) { 1785 candidate_auth_tok = &auth_tok_list_item->auth_tok; 1786 if (unlikely(ecryptfs_verbosity > 0)) { 1787 ecryptfs_printk(KERN_DEBUG, 1788 "Considering cadidate auth tok:\n"); 1789 ecryptfs_dump_auth_tok(candidate_auth_tok); 1790 } 1791 rc = ecryptfs_get_auth_tok_sig(&candidate_auth_tok_sig, 1792 candidate_auth_tok); 1793 if (rc) { 1794 printk(KERN_ERR 1795 "Unrecognized candidate auth tok type: [%d]\n", 1796 candidate_auth_tok->token_type); 1797 rc = -EINVAL; 1798 goto out_wipe_list; 1799 } 1800 ecryptfs_find_auth_tok_for_sig(&matching_auth_tok, 1801 crypt_stat->mount_crypt_stat, 1802 candidate_auth_tok_sig); 1803 if (matching_auth_tok) { 1804 found_auth_tok = 1; 1805 goto found_matching_auth_tok; 1806 } 1807 } 1808 if (!found_auth_tok) { 1809 ecryptfs_printk(KERN_ERR, "Could not find a usable " 1810 "authentication token\n"); 1811 rc = -EIO; 1812 goto out_wipe_list; 1813 } 1814 found_matching_auth_tok: 1815 if (candidate_auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) { 1816 memcpy(&(candidate_auth_tok->token.private_key), 1817 &(matching_auth_tok->token.private_key), 1818 sizeof(struct ecryptfs_private_key)); 1819 rc = decrypt_pki_encrypted_session_key(candidate_auth_tok, 1820 crypt_stat); 1821 } else if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD) { 1822 memcpy(&(candidate_auth_tok->token.password), 1823 &(matching_auth_tok->token.password), 1824 sizeof(struct ecryptfs_password)); 1825 rc = decrypt_passphrase_encrypted_session_key( 1826 candidate_auth_tok, crypt_stat); 1827 } 1828 if (rc) { 1829 struct ecryptfs_auth_tok_list_item *auth_tok_list_item_tmp; 1830 1831 ecryptfs_printk(KERN_WARNING, "Error decrypting the " 1832 "session key for authentication token with sig " 1833 "[%.*s]; rc = [%d]. Removing auth tok " 1834 "candidate from the list and searching for " 1835 "the next match.\n", candidate_auth_tok_sig, 1836 ECRYPTFS_SIG_SIZE_HEX, rc); 1837 list_for_each_entry_safe(auth_tok_list_item, 1838 auth_tok_list_item_tmp, 1839 &auth_tok_list, list) { 1840 if (candidate_auth_tok 1841 == &auth_tok_list_item->auth_tok) { 1842 list_del(&auth_tok_list_item->list); 1843 kmem_cache_free( 1844 ecryptfs_auth_tok_list_item_cache, 1845 auth_tok_list_item); 1846 goto find_next_matching_auth_tok; 1847 } 1848 } 1849 BUG(); 1850 } 1851 rc = ecryptfs_compute_root_iv(crypt_stat); 1852 if (rc) { 1853 ecryptfs_printk(KERN_ERR, "Error computing " 1854 "the root IV\n"); 1855 goto out_wipe_list; 1856 } 1857 rc = ecryptfs_init_crypt_ctx(crypt_stat); 1858 if (rc) { 1859 ecryptfs_printk(KERN_ERR, "Error initializing crypto " 1860 "context for cipher [%s]; rc = [%d]\n", 1861 crypt_stat->cipher, rc); 1862 } 1863 out_wipe_list: 1864 wipe_auth_tok_list(&auth_tok_list); 1865 out: 1866 return rc; 1867 } 1868 1869 static int 1870 pki_encrypt_session_key(struct ecryptfs_auth_tok *auth_tok, 1871 struct ecryptfs_crypt_stat *crypt_stat, 1872 struct ecryptfs_key_record *key_rec) 1873 { 1874 struct ecryptfs_msg_ctx *msg_ctx = NULL; 1875 char *payload = NULL; 1876 size_t payload_len; 1877 struct ecryptfs_message *msg; 1878 int rc; 1879 1880 rc = write_tag_66_packet(auth_tok->token.private_key.signature, 1881 ecryptfs_code_for_cipher_string( 1882 crypt_stat->cipher, 1883 crypt_stat->key_size), 1884 crypt_stat, &payload, &payload_len); 1885 if (rc) { 1886 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet\n"); 1887 goto out; 1888 } 1889 rc = ecryptfs_send_message(payload, payload_len, &msg_ctx); 1890 if (rc) { 1891 ecryptfs_printk(KERN_ERR, "Error sending message to " 1892 "ecryptfsd\n"); 1893 goto out; 1894 } 1895 rc = ecryptfs_wait_for_response(msg_ctx, &msg); 1896 if (rc) { 1897 ecryptfs_printk(KERN_ERR, "Failed to receive tag 67 packet " 1898 "from the user space daemon\n"); 1899 rc = -EIO; 1900 goto out; 1901 } 1902 rc = parse_tag_67_packet(key_rec, msg); 1903 if (rc) 1904 ecryptfs_printk(KERN_ERR, "Error parsing tag 67 packet\n"); 1905 kfree(msg); 1906 out: 1907 kfree(payload); 1908 return rc; 1909 } 1910 /** 1911 * write_tag_1_packet - Write an RFC2440-compatible tag 1 (public key) packet 1912 * @dest: Buffer into which to write the packet 1913 * @remaining_bytes: Maximum number of bytes that can be writtn 1914 * @auth_tok: The authentication token used for generating the tag 1 packet 1915 * @crypt_stat: The cryptographic context 1916 * @key_rec: The key record struct for the tag 1 packet 1917 * @packet_size: This function will write the number of bytes that end 1918 * up constituting the packet; set to zero on error 1919 * 1920 * Returns zero on success; non-zero on error. 1921 */ 1922 static int 1923 write_tag_1_packet(char *dest, size_t *remaining_bytes, 1924 struct ecryptfs_auth_tok *auth_tok, 1925 struct ecryptfs_crypt_stat *crypt_stat, 1926 struct ecryptfs_key_record *key_rec, size_t *packet_size) 1927 { 1928 size_t i; 1929 size_t encrypted_session_key_valid = 0; 1930 size_t packet_size_length; 1931 size_t max_packet_size; 1932 int rc = 0; 1933 1934 (*packet_size) = 0; 1935 ecryptfs_from_hex(key_rec->sig, auth_tok->token.private_key.signature, 1936 ECRYPTFS_SIG_SIZE); 1937 encrypted_session_key_valid = 0; 1938 for (i = 0; i < crypt_stat->key_size; i++) 1939 encrypted_session_key_valid |= 1940 auth_tok->session_key.encrypted_key[i]; 1941 if (encrypted_session_key_valid) { 1942 memcpy(key_rec->enc_key, 1943 auth_tok->session_key.encrypted_key, 1944 auth_tok->session_key.encrypted_key_size); 1945 goto encrypted_session_key_set; 1946 } 1947 if (auth_tok->session_key.encrypted_key_size == 0) 1948 auth_tok->session_key.encrypted_key_size = 1949 auth_tok->token.private_key.key_size; 1950 rc = pki_encrypt_session_key(auth_tok, crypt_stat, key_rec); 1951 if (rc) { 1952 printk(KERN_ERR "Failed to encrypt session key via a key " 1953 "module; rc = [%d]\n", rc); 1954 goto out; 1955 } 1956 if (ecryptfs_verbosity > 0) { 1957 ecryptfs_printk(KERN_DEBUG, "Encrypted key:\n"); 1958 ecryptfs_dump_hex(key_rec->enc_key, key_rec->enc_key_size); 1959 } 1960 encrypted_session_key_set: 1961 /* This format is inspired by OpenPGP; see RFC 2440 1962 * packet tag 1 */ 1963 max_packet_size = (1 /* Tag 1 identifier */ 1964 + 3 /* Max Tag 1 packet size */ 1965 + 1 /* Version */ 1966 + ECRYPTFS_SIG_SIZE /* Key identifier */ 1967 + 1 /* Cipher identifier */ 1968 + key_rec->enc_key_size); /* Encrypted key size */ 1969 if (max_packet_size > (*remaining_bytes)) { 1970 printk(KERN_ERR "Packet length larger than maximum allowable; " 1971 "need up to [%td] bytes, but there are only [%td] " 1972 "available\n", max_packet_size, (*remaining_bytes)); 1973 rc = -EINVAL; 1974 goto out; 1975 } 1976 dest[(*packet_size)++] = ECRYPTFS_TAG_1_PACKET_TYPE; 1977 rc = ecryptfs_write_packet_length(&dest[(*packet_size)], 1978 (max_packet_size - 4), 1979 &packet_size_length); 1980 if (rc) { 1981 ecryptfs_printk(KERN_ERR, "Error generating tag 1 packet " 1982 "header; cannot generate packet length\n"); 1983 goto out; 1984 } 1985 (*packet_size) += packet_size_length; 1986 dest[(*packet_size)++] = 0x03; /* version 3 */ 1987 memcpy(&dest[(*packet_size)], key_rec->sig, ECRYPTFS_SIG_SIZE); 1988 (*packet_size) += ECRYPTFS_SIG_SIZE; 1989 dest[(*packet_size)++] = RFC2440_CIPHER_RSA; 1990 memcpy(&dest[(*packet_size)], key_rec->enc_key, 1991 key_rec->enc_key_size); 1992 (*packet_size) += key_rec->enc_key_size; 1993 out: 1994 if (rc) 1995 (*packet_size) = 0; 1996 else 1997 (*remaining_bytes) -= (*packet_size); 1998 return rc; 1999 } 2000 2001 /** 2002 * write_tag_11_packet 2003 * @dest: Target into which Tag 11 packet is to be written 2004 * @remaining_bytes: Maximum packet length 2005 * @contents: Byte array of contents to copy in 2006 * @contents_length: Number of bytes in contents 2007 * @packet_length: Length of the Tag 11 packet written; zero on error 2008 * 2009 * Returns zero on success; non-zero on error. 2010 */ 2011 static int 2012 write_tag_11_packet(char *dest, size_t *remaining_bytes, char *contents, 2013 size_t contents_length, size_t *packet_length) 2014 { 2015 size_t packet_size_length; 2016 size_t max_packet_size; 2017 int rc = 0; 2018 2019 (*packet_length) = 0; 2020 /* This format is inspired by OpenPGP; see RFC 2440 2021 * packet tag 11 */ 2022 max_packet_size = (1 /* Tag 11 identifier */ 2023 + 3 /* Max Tag 11 packet size */ 2024 + 1 /* Binary format specifier */ 2025 + 1 /* Filename length */ 2026 + 8 /* Filename ("_CONSOLE") */ 2027 + 4 /* Modification date */ 2028 + contents_length); /* Literal data */ 2029 if (max_packet_size > (*remaining_bytes)) { 2030 printk(KERN_ERR "Packet length larger than maximum allowable; " 2031 "need up to [%td] bytes, but there are only [%td] " 2032 "available\n", max_packet_size, (*remaining_bytes)); 2033 rc = -EINVAL; 2034 goto out; 2035 } 2036 dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE; 2037 rc = ecryptfs_write_packet_length(&dest[(*packet_length)], 2038 (max_packet_size - 4), 2039 &packet_size_length); 2040 if (rc) { 2041 printk(KERN_ERR "Error generating tag 11 packet header; cannot " 2042 "generate packet length. rc = [%d]\n", rc); 2043 goto out; 2044 } 2045 (*packet_length) += packet_size_length; 2046 dest[(*packet_length)++] = 0x62; /* binary data format specifier */ 2047 dest[(*packet_length)++] = 8; 2048 memcpy(&dest[(*packet_length)], "_CONSOLE", 8); 2049 (*packet_length) += 8; 2050 memset(&dest[(*packet_length)], 0x00, 4); 2051 (*packet_length) += 4; 2052 memcpy(&dest[(*packet_length)], contents, contents_length); 2053 (*packet_length) += contents_length; 2054 out: 2055 if (rc) 2056 (*packet_length) = 0; 2057 else 2058 (*remaining_bytes) -= (*packet_length); 2059 return rc; 2060 } 2061 2062 /** 2063 * write_tag_3_packet 2064 * @dest: Buffer into which to write the packet 2065 * @remaining_bytes: Maximum number of bytes that can be written 2066 * @auth_tok: Authentication token 2067 * @crypt_stat: The cryptographic context 2068 * @key_rec: encrypted key 2069 * @packet_size: This function will write the number of bytes that end 2070 * up constituting the packet; set to zero on error 2071 * 2072 * Returns zero on success; non-zero on error. 2073 */ 2074 static int 2075 write_tag_3_packet(char *dest, size_t *remaining_bytes, 2076 struct ecryptfs_auth_tok *auth_tok, 2077 struct ecryptfs_crypt_stat *crypt_stat, 2078 struct ecryptfs_key_record *key_rec, size_t *packet_size) 2079 { 2080 size_t i; 2081 size_t encrypted_session_key_valid = 0; 2082 char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES]; 2083 struct scatterlist dst_sg[2]; 2084 struct scatterlist src_sg[2]; 2085 struct mutex *tfm_mutex = NULL; 2086 u8 cipher_code; 2087 size_t packet_size_length; 2088 size_t max_packet_size; 2089 struct ecryptfs_mount_crypt_stat *mount_crypt_stat = 2090 crypt_stat->mount_crypt_stat; 2091 struct blkcipher_desc desc = { 2092 .tfm = NULL, 2093 .flags = CRYPTO_TFM_REQ_MAY_SLEEP 2094 }; 2095 int rc = 0; 2096 2097 (*packet_size) = 0; 2098 ecryptfs_from_hex(key_rec->sig, auth_tok->token.password.signature, 2099 ECRYPTFS_SIG_SIZE); 2100 rc = ecryptfs_get_tfm_and_mutex_for_cipher_name(&desc.tfm, &tfm_mutex, 2101 crypt_stat->cipher); 2102 if (unlikely(rc)) { 2103 printk(KERN_ERR "Internal error whilst attempting to get " 2104 "tfm and mutex for cipher name [%s]; rc = [%d]\n", 2105 crypt_stat->cipher, rc); 2106 goto out; 2107 } 2108 if (mount_crypt_stat->global_default_cipher_key_size == 0) { 2109 struct blkcipher_alg *alg = crypto_blkcipher_alg(desc.tfm); 2110 2111 printk(KERN_WARNING "No key size specified at mount; " 2112 "defaulting to [%d]\n", alg->max_keysize); 2113 mount_crypt_stat->global_default_cipher_key_size = 2114 alg->max_keysize; 2115 } 2116 if (crypt_stat->key_size == 0) 2117 crypt_stat->key_size = 2118 mount_crypt_stat->global_default_cipher_key_size; 2119 if (auth_tok->session_key.encrypted_key_size == 0) 2120 auth_tok->session_key.encrypted_key_size = 2121 crypt_stat->key_size; 2122 if (crypt_stat->key_size == 24 2123 && strcmp("aes", crypt_stat->cipher) == 0) { 2124 memset((crypt_stat->key + 24), 0, 8); 2125 auth_tok->session_key.encrypted_key_size = 32; 2126 } else 2127 auth_tok->session_key.encrypted_key_size = crypt_stat->key_size; 2128 key_rec->enc_key_size = 2129 auth_tok->session_key.encrypted_key_size; 2130 encrypted_session_key_valid = 0; 2131 for (i = 0; i < auth_tok->session_key.encrypted_key_size; i++) 2132 encrypted_session_key_valid |= 2133 auth_tok->session_key.encrypted_key[i]; 2134 if (encrypted_session_key_valid) { 2135 ecryptfs_printk(KERN_DEBUG, "encrypted_session_key_valid != 0; " 2136 "using auth_tok->session_key.encrypted_key, " 2137 "where key_rec->enc_key_size = [%d]\n", 2138 key_rec->enc_key_size); 2139 memcpy(key_rec->enc_key, 2140 auth_tok->session_key.encrypted_key, 2141 key_rec->enc_key_size); 2142 goto encrypted_session_key_set; 2143 } 2144 if (auth_tok->token.password.flags & 2145 ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET) { 2146 ecryptfs_printk(KERN_DEBUG, "Using previously generated " 2147 "session key encryption key of size [%d]\n", 2148 auth_tok->token.password. 2149 session_key_encryption_key_bytes); 2150 memcpy(session_key_encryption_key, 2151 auth_tok->token.password.session_key_encryption_key, 2152 crypt_stat->key_size); 2153 ecryptfs_printk(KERN_DEBUG, 2154 "Cached session key " "encryption key: \n"); 2155 if (ecryptfs_verbosity > 0) 2156 ecryptfs_dump_hex(session_key_encryption_key, 16); 2157 } 2158 if (unlikely(ecryptfs_verbosity > 0)) { 2159 ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n"); 2160 ecryptfs_dump_hex(session_key_encryption_key, 16); 2161 } 2162 rc = virt_to_scatterlist(crypt_stat->key, key_rec->enc_key_size, 2163 src_sg, 2); 2164 if (rc < 1 || rc > 2) { 2165 ecryptfs_printk(KERN_ERR, "Error generating scatterlist " 2166 "for crypt_stat session key; expected rc = 1; " 2167 "got rc = [%d]. key_rec->enc_key_size = [%d]\n", 2168 rc, key_rec->enc_key_size); 2169 rc = -ENOMEM; 2170 goto out; 2171 } 2172 rc = virt_to_scatterlist(key_rec->enc_key, key_rec->enc_key_size, 2173 dst_sg, 2); 2174 if (rc < 1 || rc > 2) { 2175 ecryptfs_printk(KERN_ERR, "Error generating scatterlist " 2176 "for crypt_stat encrypted session key; " 2177 "expected rc = 1; got rc = [%d]. " 2178 "key_rec->enc_key_size = [%d]\n", rc, 2179 key_rec->enc_key_size); 2180 rc = -ENOMEM; 2181 goto out; 2182 } 2183 mutex_lock(tfm_mutex); 2184 rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key, 2185 crypt_stat->key_size); 2186 if (rc < 0) { 2187 mutex_unlock(tfm_mutex); 2188 ecryptfs_printk(KERN_ERR, "Error setting key for crypto " 2189 "context; rc = [%d]\n", rc); 2190 goto out; 2191 } 2192 rc = 0; 2193 ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n", 2194 crypt_stat->key_size); 2195 rc = crypto_blkcipher_encrypt(&desc, dst_sg, src_sg, 2196 (*key_rec).enc_key_size); 2197 mutex_unlock(tfm_mutex); 2198 if (rc) { 2199 printk(KERN_ERR "Error encrypting; rc = [%d]\n", rc); 2200 goto out; 2201 } 2202 ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n"); 2203 if (ecryptfs_verbosity > 0) { 2204 ecryptfs_printk(KERN_DEBUG, "EFEK of size [%d]:\n", 2205 key_rec->enc_key_size); 2206 ecryptfs_dump_hex(key_rec->enc_key, 2207 key_rec->enc_key_size); 2208 } 2209 encrypted_session_key_set: 2210 /* This format is inspired by OpenPGP; see RFC 2440 2211 * packet tag 3 */ 2212 max_packet_size = (1 /* Tag 3 identifier */ 2213 + 3 /* Max Tag 3 packet size */ 2214 + 1 /* Version */ 2215 + 1 /* Cipher code */ 2216 + 1 /* S2K specifier */ 2217 + 1 /* Hash identifier */ 2218 + ECRYPTFS_SALT_SIZE /* Salt */ 2219 + 1 /* Hash iterations */ 2220 + key_rec->enc_key_size); /* Encrypted key size */ 2221 if (max_packet_size > (*remaining_bytes)) { 2222 printk(KERN_ERR "Packet too large; need up to [%td] bytes, but " 2223 "there are only [%td] available\n", max_packet_size, 2224 (*remaining_bytes)); 2225 rc = -EINVAL; 2226 goto out; 2227 } 2228 dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE; 2229 /* Chop off the Tag 3 identifier(1) and Tag 3 packet size(3) 2230 * to get the number of octets in the actual Tag 3 packet */ 2231 rc = ecryptfs_write_packet_length(&dest[(*packet_size)], 2232 (max_packet_size - 4), 2233 &packet_size_length); 2234 if (rc) { 2235 printk(KERN_ERR "Error generating tag 3 packet header; cannot " 2236 "generate packet length. rc = [%d]\n", rc); 2237 goto out; 2238 } 2239 (*packet_size) += packet_size_length; 2240 dest[(*packet_size)++] = 0x04; /* version 4 */ 2241 /* TODO: Break from RFC2440 so that arbitrary ciphers can be 2242 * specified with strings */ 2243 cipher_code = ecryptfs_code_for_cipher_string(crypt_stat->cipher, 2244 crypt_stat->key_size); 2245 if (cipher_code == 0) { 2246 ecryptfs_printk(KERN_WARNING, "Unable to generate code for " 2247 "cipher [%s]\n", crypt_stat->cipher); 2248 rc = -EINVAL; 2249 goto out; 2250 } 2251 dest[(*packet_size)++] = cipher_code; 2252 dest[(*packet_size)++] = 0x03; /* S2K */ 2253 dest[(*packet_size)++] = 0x01; /* MD5 (TODO: parameterize) */ 2254 memcpy(&dest[(*packet_size)], auth_tok->token.password.salt, 2255 ECRYPTFS_SALT_SIZE); 2256 (*packet_size) += ECRYPTFS_SALT_SIZE; /* salt */ 2257 dest[(*packet_size)++] = 0x60; /* hash iterations (65536) */ 2258 memcpy(&dest[(*packet_size)], key_rec->enc_key, 2259 key_rec->enc_key_size); 2260 (*packet_size) += key_rec->enc_key_size; 2261 out: 2262 if (rc) 2263 (*packet_size) = 0; 2264 else 2265 (*remaining_bytes) -= (*packet_size); 2266 return rc; 2267 } 2268 2269 struct kmem_cache *ecryptfs_key_record_cache; 2270 2271 /** 2272 * ecryptfs_generate_key_packet_set 2273 * @dest_base: Virtual address from which to write the key record set 2274 * @crypt_stat: The cryptographic context from which the 2275 * authentication tokens will be retrieved 2276 * @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat 2277 * for the global parameters 2278 * @len: The amount written 2279 * @max: The maximum amount of data allowed to be written 2280 * 2281 * Generates a key packet set and writes it to the virtual address 2282 * passed in. 2283 * 2284 * Returns zero on success; non-zero on error. 2285 */ 2286 int 2287 ecryptfs_generate_key_packet_set(char *dest_base, 2288 struct ecryptfs_crypt_stat *crypt_stat, 2289 struct dentry *ecryptfs_dentry, size_t *len, 2290 size_t max) 2291 { 2292 struct ecryptfs_auth_tok *auth_tok; 2293 struct ecryptfs_global_auth_tok *global_auth_tok; 2294 struct ecryptfs_mount_crypt_stat *mount_crypt_stat = 2295 &ecryptfs_superblock_to_private( 2296 ecryptfs_dentry->d_sb)->mount_crypt_stat; 2297 size_t written; 2298 struct ecryptfs_key_record *key_rec; 2299 struct ecryptfs_key_sig *key_sig; 2300 int rc = 0; 2301 2302 (*len) = 0; 2303 mutex_lock(&crypt_stat->keysig_list_mutex); 2304 key_rec = kmem_cache_alloc(ecryptfs_key_record_cache, GFP_KERNEL); 2305 if (!key_rec) { 2306 rc = -ENOMEM; 2307 goto out; 2308 } 2309 list_for_each_entry(key_sig, &crypt_stat->keysig_list, 2310 crypt_stat_list) { 2311 memset(key_rec, 0, sizeof(*key_rec)); 2312 rc = ecryptfs_find_global_auth_tok_for_sig(&global_auth_tok, 2313 mount_crypt_stat, 2314 key_sig->keysig); 2315 if (rc) { 2316 printk(KERN_ERR "Error attempting to get the global " 2317 "auth_tok; rc = [%d]\n", rc); 2318 goto out_free; 2319 } 2320 if (global_auth_tok->flags & ECRYPTFS_AUTH_TOK_INVALID) { 2321 printk(KERN_WARNING 2322 "Skipping invalid auth tok with sig = [%s]\n", 2323 global_auth_tok->sig); 2324 continue; 2325 } 2326 auth_tok = global_auth_tok->global_auth_tok; 2327 if (auth_tok->token_type == ECRYPTFS_PASSWORD) { 2328 rc = write_tag_3_packet((dest_base + (*len)), 2329 &max, auth_tok, 2330 crypt_stat, key_rec, 2331 &written); 2332 if (rc) { 2333 ecryptfs_printk(KERN_WARNING, "Error " 2334 "writing tag 3 packet\n"); 2335 goto out_free; 2336 } 2337 (*len) += written; 2338 /* Write auth tok signature packet */ 2339 rc = write_tag_11_packet((dest_base + (*len)), &max, 2340 key_rec->sig, 2341 ECRYPTFS_SIG_SIZE, &written); 2342 if (rc) { 2343 ecryptfs_printk(KERN_ERR, "Error writing " 2344 "auth tok signature packet\n"); 2345 goto out_free; 2346 } 2347 (*len) += written; 2348 } else if (auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) { 2349 rc = write_tag_1_packet(dest_base + (*len), 2350 &max, auth_tok, 2351 crypt_stat, key_rec, &written); 2352 if (rc) { 2353 ecryptfs_printk(KERN_WARNING, "Error " 2354 "writing tag 1 packet\n"); 2355 goto out_free; 2356 } 2357 (*len) += written; 2358 } else { 2359 ecryptfs_printk(KERN_WARNING, "Unsupported " 2360 "authentication token type\n"); 2361 rc = -EINVAL; 2362 goto out_free; 2363 } 2364 } 2365 if (likely(max > 0)) { 2366 dest_base[(*len)] = 0x00; 2367 } else { 2368 ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n"); 2369 rc = -EIO; 2370 } 2371 out_free: 2372 kmem_cache_free(ecryptfs_key_record_cache, key_rec); 2373 out: 2374 if (rc) 2375 (*len) = 0; 2376 mutex_unlock(&crypt_stat->keysig_list_mutex); 2377 return rc; 2378 } 2379 2380 struct kmem_cache *ecryptfs_key_sig_cache; 2381 2382 int ecryptfs_add_keysig(struct ecryptfs_crypt_stat *crypt_stat, char *sig) 2383 { 2384 struct ecryptfs_key_sig *new_key_sig; 2385 2386 new_key_sig = kmem_cache_alloc(ecryptfs_key_sig_cache, GFP_KERNEL); 2387 if (!new_key_sig) { 2388 printk(KERN_ERR 2389 "Error allocating from ecryptfs_key_sig_cache\n"); 2390 return -ENOMEM; 2391 } 2392 memcpy(new_key_sig->keysig, sig, ECRYPTFS_SIG_SIZE_HEX); 2393 /* Caller must hold keysig_list_mutex */ 2394 list_add(&new_key_sig->crypt_stat_list, &crypt_stat->keysig_list); 2395 2396 return 0; 2397 } 2398 2399 struct kmem_cache *ecryptfs_global_auth_tok_cache; 2400 2401 int 2402 ecryptfs_add_global_auth_tok(struct ecryptfs_mount_crypt_stat *mount_crypt_stat, 2403 char *sig, u32 global_auth_tok_flags) 2404 { 2405 struct ecryptfs_global_auth_tok *new_auth_tok; 2406 int rc = 0; 2407 2408 new_auth_tok = kmem_cache_zalloc(ecryptfs_global_auth_tok_cache, 2409 GFP_KERNEL); 2410 if (!new_auth_tok) { 2411 rc = -ENOMEM; 2412 printk(KERN_ERR "Error allocating from " 2413 "ecryptfs_global_auth_tok_cache\n"); 2414 goto out; 2415 } 2416 memcpy(new_auth_tok->sig, sig, ECRYPTFS_SIG_SIZE_HEX); 2417 new_auth_tok->flags = global_auth_tok_flags; 2418 new_auth_tok->sig[ECRYPTFS_SIG_SIZE_HEX] = '\0'; 2419 mutex_lock(&mount_crypt_stat->global_auth_tok_list_mutex); 2420 list_add(&new_auth_tok->mount_crypt_stat_list, 2421 &mount_crypt_stat->global_auth_tok_list); 2422 mount_crypt_stat->num_global_auth_toks++; 2423 mutex_unlock(&mount_crypt_stat->global_auth_tok_list_mutex); 2424 out: 2425 return rc; 2426 } 2427 2428