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