?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] eCryptfs: Public key; packet management
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / ecryptfs / keystore.c
blob558d538e2b1f4f1b817b8d6577f5143ee2487afd
1 /**
2 * eCryptfs: Linux filesystem encryption layer
3 * In-kernel key management code. Includes functions to parse and
4 * write authentication token-related packets with the underlying
5 * file.
6 *
7 * Copyright (C) 2004-2006 International Business Machines Corp.
8 * Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
9 * Michael C. Thompson <mcthomps@us.ibm.com>
10 * Trevor S. Highland <trevor.highland@gmail.com>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25 * 02111-1307, USA.
26 */
27
28 #include <linux/string.h>
29 #include <linux/sched.h>
30 #include <linux/syscalls.h>
31 #include <linux/pagemap.h>
32 #include <linux/key.h>
33 #include <linux/random.h>
34 #include <linux/crypto.h>
35 #include <linux/scatterlist.h>
36 #include "ecryptfs_kernel.h"
37
38 /**
39 * request_key returned an error instead of a valid key address;
40 * determine the type of error, make appropriate log entries, and
41 * return an error code.
42 */
43 int process_request_key_err(long err_code)
44 {
45 int rc = 0;
46
47 switch (err_code) {
48 case ENOKEY:
49 ecryptfs_printk(KERN_WARNING, "No key\n");
50 rc = -ENOENT;
51 break;
52 case EKEYEXPIRED:
53 ecryptfs_printk(KERN_WARNING, "Key expired\n");
54 rc = -ETIME;
55 break;
56 case EKEYREVOKED:
57 ecryptfs_printk(KERN_WARNING, "Key revoked\n");
58 rc = -EINVAL;
59 break;
60 default:
61 ecryptfs_printk(KERN_WARNING, "Unknown error code: "
62 "[0x%.16x]\n", err_code);
63 rc = -EINVAL;
64 }
65 return rc;
66 }
67
68 /**
69 * parse_packet_length
70 * @data: Pointer to memory containing length at offset
71 * @size: This function writes the decoded size to this memory
72 * address; zero on error
73 * @length_size: The number of bytes occupied by the encoded length
74 *
75 * Returns Zero on success
76 */
77 static int parse_packet_length(unsigned char *data, size_t *size,
78 size_t *length_size)
79 {
80 int rc = 0;
81
82 (*length_size) = 0;
83 (*size) = 0;
84 if (data[0] < 192) {
85 /* One-byte length */
86 (*size) = (unsigned char)data[0];
87 (*length_size) = 1;
88 } else if (data[0] < 224) {
89 /* Two-byte length */
90 (*size) = (((unsigned char)(data[0]) - 192) * 256);
91 (*size) += ((unsigned char)(data[1]) + 192);
92 (*length_size) = 2;
93 } else if (data[0] == 255) {
94 /* Five-byte length; we're not supposed to see this */
95 ecryptfs_printk(KERN_ERR, "Five-byte packet length not "
96 "supported\n");
97 rc = -EINVAL;
98 goto out;
99 } else {
100 ecryptfs_printk(KERN_ERR, "Error parsing packet length\n");
101 rc = -EINVAL;
102 goto out;
103 }
104 out:
105 return rc;
106 }
107
108 /**
109 * write_packet_length
110 * @dest: The byte array target into which to write the
111 * length. Must have at least 5 bytes allocated.
112 * @size: The length to write.
113 * @packet_size_length: The number of bytes used to encode the
114 * packet length is written to this address.
115 *
116 * Returns zero on success; non-zero on error.
117 */
118 static int write_packet_length(char *dest, size_t size,
119 size_t *packet_size_length)
120 {
121 int rc = 0;
122
123 if (size < 192) {
124 dest[0] = size;
125 (*packet_size_length) = 1;
126 } else if (size < 65536) {
127 dest[0] = (((size - 192) / 256) + 192);
128 dest[1] = ((size - 192) % 256);
129 (*packet_size_length) = 2;
130 } else {
131 rc = -EINVAL;
132 ecryptfs_printk(KERN_WARNING,
133 "Unsupported packet size: [%d]\n", size);
134 }
135 return rc;
136 }
137
138 static int
139 write_tag_64_packet(char *signature, struct ecryptfs_session_key *session_key,
140 char **packet, size_t *packet_len)
141 {
142 size_t i = 0;
143 size_t data_len;
144 size_t packet_size_len;
145 char *message;
146 int rc;
147
148 /*
149 * ***** TAG 64 Packet Format *****
150 * | Content Type | 1 byte |
151 * | Key Identifier Size | 1 or 2 bytes |
152 * | Key Identifier | arbitrary |
153 * | Encrypted File Encryption Key Size | 1 or 2 bytes |
154 * | Encrypted File Encryption Key | arbitrary |
155 */
156 data_len = (5 + ECRYPTFS_SIG_SIZE_HEX
157 + session_key->encrypted_key_size);
158 *packet = kmalloc(data_len, GFP_KERNEL);
159 message = *packet;
160 if (!message) {
161 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
162 rc = -ENOMEM;
163 goto out;
164 }
165 message[i++] = ECRYPTFS_TAG_64_PACKET_TYPE;
166 rc = write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
167 &packet_size_len);
168 if (rc) {
169 ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
170 "header; cannot generate packet length\n");
171 goto out;
172 }
173 i += packet_size_len;
174 memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
175 i += ECRYPTFS_SIG_SIZE_HEX;
176 rc = write_packet_length(&message[i], session_key->encrypted_key_size,
177 &packet_size_len);
178 if (rc) {
179 ecryptfs_printk(KERN_ERR, "Error generating tag 64 packet "
180 "header; cannot generate packet length\n");
181 goto out;
182 }
183 i += packet_size_len;
184 memcpy(&message[i], session_key->encrypted_key,
185 session_key->encrypted_key_size);
186 i += session_key->encrypted_key_size;
187 *packet_len = i;
188 out:
189 return rc;
190 }
191
192 static int
193 parse_tag_65_packet(struct ecryptfs_session_key *session_key, u16 *cipher_code,
194 struct ecryptfs_message *msg)
195 {
196 size_t i = 0;
197 char *data;
198 size_t data_len;
199 size_t m_size;
200 size_t message_len;
201 u16 checksum = 0;
202 u16 expected_checksum = 0;
203 int rc;
204
205 /*
206 * ***** TAG 65 Packet Format *****
207 * | Content Type | 1 byte |
208 * | Status Indicator | 1 byte |
209 * | File Encryption Key Size | 1 or 2 bytes |
210 * | File Encryption Key | arbitrary |
211 */
212 message_len = msg->data_len;
213 data = msg->data;
214 if (message_len < 4) {
215 rc = -EIO;
216 goto out;
217 }
218 if (data[i++] != ECRYPTFS_TAG_65_PACKET_TYPE) {
219 ecryptfs_printk(KERN_ERR, "Type should be ECRYPTFS_TAG_65\n");
220 rc = -EIO;
221 goto out;
222 }
223 if (data[i++]) {
224 ecryptfs_printk(KERN_ERR, "Status indicator has non-zero value "
225 "[%d]\n", data[i-1]);
226 rc = -EIO;
227 goto out;
228 }
229 rc = parse_packet_length(&data[i], &m_size, &data_len);
230 if (rc) {
231 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
232 "rc = [%d]\n", rc);
233 goto out;
234 }
235 i += data_len;
236 if (message_len < (i + m_size)) {
237 ecryptfs_printk(KERN_ERR, "The received netlink message is "
238 "shorter than expected\n");
239 rc = -EIO;
240 goto out;
241 }
242 if (m_size < 3) {
243 ecryptfs_printk(KERN_ERR,
244 "The decrypted key is not long enough to "
245 "include a cipher code and checksum\n");
246 rc = -EIO;
247 goto out;
248 }
249 *cipher_code = data[i++];
250 /* The decrypted key includes 1 byte cipher code and 2 byte checksum */
251 session_key->decrypted_key_size = m_size - 3;
252 if (session_key->decrypted_key_size > ECRYPTFS_MAX_KEY_BYTES) {
253 ecryptfs_printk(KERN_ERR, "key_size [%d] larger than "
254 "the maximum key size [%d]\n",
255 session_key->decrypted_key_size,
256 ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
257 rc = -EIO;
258 goto out;
259 }
260 memcpy(session_key->decrypted_key, &data[i],
261 session_key->decrypted_key_size);
262 i += session_key->decrypted_key_size;
263 expected_checksum += (unsigned char)(data[i++]) << 8;
264 expected_checksum += (unsigned char)(data[i++]);
265 for (i = 0; i < session_key->decrypted_key_size; i++)
266 checksum += session_key->decrypted_key[i];
267 if (expected_checksum != checksum) {
268 ecryptfs_printk(KERN_ERR, "Invalid checksum for file "
269 "encryption key; expected [%x]; calculated "
270 "[%x]\n", expected_checksum, checksum);
271 rc = -EIO;
272 }
273 out:
274 return rc;
275 }
276
277
278 static int
279 write_tag_66_packet(char *signature, size_t cipher_code,
280 struct ecryptfs_crypt_stat *crypt_stat, char **packet,
281 size_t *packet_len)
282 {
283 size_t i = 0;
284 size_t j;
285 size_t data_len;
286 size_t checksum = 0;
287 size_t packet_size_len;
288 char *message;
289 int rc;
290
291 /*
292 * ***** TAG 66 Packet Format *****
293 * | Content Type | 1 byte |
294 * | Key Identifier Size | 1 or 2 bytes |
295 * | Key Identifier | arbitrary |
296 * | File Encryption Key Size | 1 or 2 bytes |
297 * | File Encryption Key | arbitrary |
298 */
299 data_len = (5 + ECRYPTFS_SIG_SIZE_HEX + crypt_stat->key_size);
300 *packet = kmalloc(data_len, GFP_KERNEL);
301 message = *packet;
302 if (!message) {
303 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
304 rc = -ENOMEM;
305 goto out;
306 }
307 message[i++] = ECRYPTFS_TAG_66_PACKET_TYPE;
308 rc = write_packet_length(&message[i], ECRYPTFS_SIG_SIZE_HEX,
309 &packet_size_len);
310 if (rc) {
311 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
312 "header; cannot generate packet length\n");
313 goto out;
314 }
315 i += packet_size_len;
316 memcpy(&message[i], signature, ECRYPTFS_SIG_SIZE_HEX);
317 i += ECRYPTFS_SIG_SIZE_HEX;
318 /* The encrypted key includes 1 byte cipher code and 2 byte checksum */
319 rc = write_packet_length(&message[i], crypt_stat->key_size + 3,
320 &packet_size_len);
321 if (rc) {
322 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet "
323 "header; cannot generate packet length\n");
324 goto out;
325 }
326 i += packet_size_len;
327 message[i++] = cipher_code;
328 memcpy(&message[i], crypt_stat->key, crypt_stat->key_size);
329 i += crypt_stat->key_size;
330 for (j = 0; j < crypt_stat->key_size; j++)
331 checksum += crypt_stat->key[j];
332 message[i++] = (checksum / 256) % 256;
333 message[i++] = (checksum % 256);
334 *packet_len = i;
335 out:
336 return rc;
337 }
338
339 static int
340 parse_tag_67_packet(struct ecryptfs_key_record *key_rec,
341 struct ecryptfs_message *msg)
342 {
343 size_t i = 0;
344 char *data;
345 size_t data_len;
346 size_t message_len;
347 int rc;
348
349 /*
350 * ***** TAG 65 Packet Format *****
351 * | Content Type | 1 byte |
352 * | Status Indicator | 1 byte |
353 * | Encrypted File Encryption Key Size | 1 or 2 bytes |
354 * | Encrypted File Encryption Key | arbitrary |
355 */
356 message_len = msg->data_len;
357 data = msg->data;
358 /* verify that everything through the encrypted FEK size is present */
359 if (message_len < 4) {
360 rc = -EIO;
361 goto out;
362 }
363 if (data[i++] != ECRYPTFS_TAG_67_PACKET_TYPE) {
364 ecryptfs_printk(KERN_ERR, "Type should be ECRYPTFS_TAG_67\n");
365 rc = -EIO;
366 goto out;
367 }
368 if (data[i++]) {
369 ecryptfs_printk(KERN_ERR, "Status indicator has non zero value"
370 " [%d]\n", data[i-1]);
371 rc = -EIO;
372 goto out;
373 }
374 rc = parse_packet_length(&data[i], &key_rec->enc_key_size, &data_len);
375 if (rc) {
376 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
377 "rc = [%d]\n", rc);
378 goto out;
379 }
380 i += data_len;
381 if (message_len < (i + key_rec->enc_key_size)) {
382 ecryptfs_printk(KERN_ERR, "message_len [%d]; max len is [%d]\n",
383 message_len, (i + key_rec->enc_key_size));
384 rc = -EIO;
385 goto out;
386 }
387 if (key_rec->enc_key_size > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
388 ecryptfs_printk(KERN_ERR, "Encrypted key_size [%d] larger than "
389 "the maximum key size [%d]\n",
390 key_rec->enc_key_size,
391 ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES);
392 rc = -EIO;
393 goto out;
394 }
395 memcpy(key_rec->enc_key, &data[i], key_rec->enc_key_size);
396 out:
397 return rc;
398 }
399
400 /**
401 * decrypt_pki_encrypted_session_key - Decrypt the session key with
402 * the given auth_tok.
403 *
404 * Returns Zero on success; non-zero error otherwise.
405 */
406 static int decrypt_pki_encrypted_session_key(
407 struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
408 struct ecryptfs_auth_tok *auth_tok,
409 struct ecryptfs_crypt_stat *crypt_stat)
410 {
411 u16 cipher_code = 0;
412 struct ecryptfs_msg_ctx *msg_ctx;
413 struct ecryptfs_message *msg = NULL;
414 char *netlink_message;
415 size_t netlink_message_length;
416 int rc;
417
418 rc = write_tag_64_packet(mount_crypt_stat->global_auth_tok_sig,
419 &(auth_tok->session_key),
420 &netlink_message, &netlink_message_length);
421 if (rc) {
422 ecryptfs_printk(KERN_ERR, "Failed to write tag 64 packet");
423 goto out;
424 }
425 rc = ecryptfs_send_message(ecryptfs_transport, netlink_message,
426 netlink_message_length, &msg_ctx);
427 if (rc) {
428 ecryptfs_printk(KERN_ERR, "Error sending netlink message\n");
429 goto out;
430 }
431 rc = ecryptfs_wait_for_response(msg_ctx, &msg);
432 if (rc) {
433 ecryptfs_printk(KERN_ERR, "Failed to receive tag 65 packet "
434 "from the user space daemon\n");
435 rc = -EIO;
436 goto out;
437 }
438 rc = parse_tag_65_packet(&(auth_tok->session_key),
439 &cipher_code, msg);
440 if (rc) {
441 printk(KERN_ERR "Failed to parse tag 65 packet; rc = [%d]\n",
442 rc);
443 goto out;
444 }
445 auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
446 memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
447 auth_tok->session_key.decrypted_key_size);
448 crypt_stat->key_size = auth_tok->session_key.decrypted_key_size;
449 rc = ecryptfs_cipher_code_to_string(crypt_stat->cipher, cipher_code);
450 if (rc) {
451 ecryptfs_printk(KERN_ERR, "Cipher code [%d] is invalid\n",
452 cipher_code)
453 goto out;
454 }
455 crypt_stat->flags |= ECRYPTFS_KEY_VALID;
456 if (ecryptfs_verbosity > 0) {
457 ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
458 ecryptfs_dump_hex(crypt_stat->key,
459 crypt_stat->key_size);
460 }
461 out:
462 if (msg)
463 kfree(msg);
464 return rc;
465 }
466
467 static void wipe_auth_tok_list(struct list_head *auth_tok_list_head)
468 {
469 struct list_head *walker;
470 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
471
472 walker = auth_tok_list_head->next;
473 while (walker != auth_tok_list_head) {
474 auth_tok_list_item =
475 list_entry(walker, struct ecryptfs_auth_tok_list_item,
476 list);
477 walker = auth_tok_list_item->list.next;
478 memset(auth_tok_list_item, 0,
479 sizeof(struct ecryptfs_auth_tok_list_item));
480 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
481 auth_tok_list_item);
482 }
483 auth_tok_list_head->next = NULL;
484 }
485
486 struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
487
488
489 /**
490 * parse_tag_1_packet
491 * @crypt_stat: The cryptographic context to modify based on packet
492 * contents.
493 * @data: The raw bytes of the packet.
494 * @auth_tok_list: eCryptfs parses packets into authentication tokens;
495 * a new authentication token will be placed at the end
496 * of this list for this packet.
497 * @new_auth_tok: Pointer to a pointer to memory that this function
498 * allocates; sets the memory address of the pointer to
499 * NULL on error. This object is added to the
500 * auth_tok_list.
501 * @packet_size: This function writes the size of the parsed packet
502 * into this memory location; zero on error.
503 *
504 * Returns zero on success; non-zero on error.
505 */
506 static int
507 parse_tag_1_packet(struct ecryptfs_crypt_stat *crypt_stat,
508 unsigned char *data, struct list_head *auth_tok_list,
509 struct ecryptfs_auth_tok **new_auth_tok,
510 size_t *packet_size, size_t max_packet_size)
511 {
512 size_t body_size;
513 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
514 size_t length_size;
515 int rc = 0;
516
517 (*packet_size) = 0;
518 (*new_auth_tok) = NULL;
519
520 /* we check that:
521 * one byte for the Tag 1 ID flag
522 * two bytes for the body size
523 * do not exceed the maximum_packet_size
524 */
525 if (unlikely((*packet_size) + 3 > max_packet_size)) {
526 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
527 rc = -EINVAL;
528 goto out;
529 }
530 /* check for Tag 1 identifier - one byte */
531 if (data[(*packet_size)++] != ECRYPTFS_TAG_1_PACKET_TYPE) {
532 ecryptfs_printk(KERN_ERR, "Enter w/ first byte != 0x%.2x\n",
533 ECRYPTFS_TAG_1_PACKET_TYPE);
534 rc = -EINVAL;
535 goto out;
536 }
537 /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
538 * at end of function upon failure */
539 auth_tok_list_item =
540 kmem_cache_alloc(ecryptfs_auth_tok_list_item_cache,
541 GFP_KERNEL);
542 if (!auth_tok_list_item) {
543 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
544 rc = -ENOMEM;
545 goto out;
546 }
547 memset(auth_tok_list_item, 0,
548 sizeof(struct ecryptfs_auth_tok_list_item));
549 (*new_auth_tok) = &auth_tok_list_item->auth_tok;
550 /* check for body size - one to two bytes
551 *
552 * ***** TAG 1 Packet Format *****
553 * | version number | 1 byte |
554 * | key ID | 8 bytes |
555 * | public key algorithm | 1 byte |
556 * | encrypted session key | arbitrary |
557 */
558 rc = parse_packet_length(&data[(*packet_size)], &body_size,
559 &length_size);
560 if (rc) {
561 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
562 "rc = [%d]\n", rc);
563 goto out_free;
564 }
565 if (unlikely(body_size < (0x02 + ECRYPTFS_SIG_SIZE))) {
566 ecryptfs_printk(KERN_WARNING, "Invalid body size ([%d])\n",
567 body_size);
568 rc = -EINVAL;
569 goto out_free;
570 }
571 (*packet_size) += length_size;
572 if (unlikely((*packet_size) + body_size > max_packet_size)) {
573 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
574 rc = -EINVAL;
575 goto out_free;
576 }
577 /* Version 3 (from RFC2440) - one byte */
578 if (unlikely(data[(*packet_size)++] != 0x03)) {
579 ecryptfs_printk(KERN_DEBUG, "Unknown version number "
580 "[%d]\n", data[(*packet_size) - 1]);
581 rc = -EINVAL;
582 goto out_free;
583 }
584 /* Read Signature */
585 ecryptfs_to_hex((*new_auth_tok)->token.private_key.signature,
586 &data[(*packet_size)], ECRYPTFS_SIG_SIZE);
587 *packet_size += ECRYPTFS_SIG_SIZE;
588 /* This byte is skipped because the kernel does not need to
589 * know which public key encryption algorithm was used */
590 (*packet_size)++;
591 (*new_auth_tok)->session_key.encrypted_key_size =
592 body_size - (0x02 + ECRYPTFS_SIG_SIZE);
593 if ((*new_auth_tok)->session_key.encrypted_key_size
594 > ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES) {
595 ecryptfs_printk(KERN_ERR, "Tag 1 packet contains key larger "
596 "than ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES");
597 rc = -EINVAL;
598 goto out;
599 }
600 ecryptfs_printk(KERN_DEBUG, "Encrypted key size = [%d]\n",
601 (*new_auth_tok)->session_key.encrypted_key_size);
602 memcpy((*new_auth_tok)->session_key.encrypted_key,
603 &data[(*packet_size)], (body_size - 0x02 - ECRYPTFS_SIG_SIZE));
604 (*packet_size) += (*new_auth_tok)->session_key.encrypted_key_size;
605 (*new_auth_tok)->session_key.flags &=
606 ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
607 (*new_auth_tok)->session_key.flags |=
608 ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
609 (*new_auth_tok)->token_type = ECRYPTFS_PRIVATE_KEY;
610 ECRYPTFS_SET_FLAG((*new_auth_tok)->flags, ECRYPTFS_PRIVATE_KEY);
611 /* TODO: Why are we setting this flag here? Don't we want the
612 * userspace to decrypt the session key? */
613 ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
614 ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
615 ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
616 ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
617 list_add(&auth_tok_list_item->list, auth_tok_list);
618 goto out;
619 out_free:
620 (*new_auth_tok) = NULL;
621 memset(auth_tok_list_item, 0,
622 sizeof(struct ecryptfs_auth_tok_list_item));
623 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
624 auth_tok_list_item);
625 out:
626 if (rc)
627 (*packet_size) = 0;
628 return rc;
629 }
630
631 /**
632 * parse_tag_3_packet
633 * @crypt_stat: The cryptographic context to modify based on packet
634 * contents.
635 * @data: The raw bytes of the packet.
636 * @auth_tok_list: eCryptfs parses packets into authentication tokens;
637 * a new authentication token will be placed at the end
638 * of this list for this packet.
639 * @new_auth_tok: Pointer to a pointer to memory that this function
640 * allocates; sets the memory address of the pointer to
641 * NULL on error. This object is added to the
642 * auth_tok_list.
643 * @packet_size: This function writes the size of the parsed packet
644 * into this memory location; zero on error.
645 * @max_packet_size: maximum number of bytes to parse
646 *
647 * Returns zero on success; non-zero on error.
648 */
649 static int
650 parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
651 unsigned char *data, struct list_head *auth_tok_list,
652 struct ecryptfs_auth_tok **new_auth_tok,
653 size_t *packet_size, size_t max_packet_size)
654 {
655 size_t body_size;
656 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
657 size_t length_size;
658 int rc = 0;
659
660 (*packet_size) = 0;
661 (*new_auth_tok) = NULL;
662
663 /* we check that:
664 * one byte for the Tag 3 ID flag
665 * two bytes for the body size
666 * do not exceed the maximum_packet_size
667 */
668 if (unlikely((*packet_size) + 3 > max_packet_size)) {
669 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
670 rc = -EINVAL;
671 goto out;
672 }
673
674 /* check for Tag 3 identifyer - one byte */
675 if (data[(*packet_size)++] != ECRYPTFS_TAG_3_PACKET_TYPE) {
676 ecryptfs_printk(KERN_ERR, "Enter w/ first byte != 0x%.2x\n",
677 ECRYPTFS_TAG_3_PACKET_TYPE);
678 rc = -EINVAL;
679 goto out;
680 }
681 /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
682 * at end of function upon failure */
683 auth_tok_list_item =
684 kmem_cache_zalloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
685 if (!auth_tok_list_item) {
686 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
687 rc = -ENOMEM;
688 goto out;
689 }
690 (*new_auth_tok) = &auth_tok_list_item->auth_tok;
691
692 /* check for body size - one to two bytes */
693 rc = parse_packet_length(&data[(*packet_size)], &body_size,
694 &length_size);
695 if (rc) {
696 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
697 "rc = [%d]\n", rc);
698 goto out_free;
699 }
700 if (unlikely(body_size < (0x05 + ECRYPTFS_SALT_SIZE))) {
701 ecryptfs_printk(KERN_WARNING, "Invalid body size ([%d])\n",
702 body_size);
703 rc = -EINVAL;
704 goto out_free;
705 }
706 (*packet_size) += length_size;
707
708 /* now we know the length of the remainting Tag 3 packet size:
709 * 5 fix bytes for: version string, cipher, S2K ID, hash algo,
710 * number of hash iterations
711 * ECRYPTFS_SALT_SIZE bytes for salt
712 * body_size bytes minus the stuff above is the encrypted key size
713 */
714 if (unlikely((*packet_size) + body_size > max_packet_size)) {
715 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
716 rc = -EINVAL;
717 goto out_free;
718 }
719
720 /* There are 5 characters of additional information in the
721 * packet */
722 (*new_auth_tok)->session_key.encrypted_key_size =
723 body_size - (0x05 + ECRYPTFS_SALT_SIZE);
724 ecryptfs_printk(KERN_DEBUG, "Encrypted key size = [%d]\n",
725 (*new_auth_tok)->session_key.encrypted_key_size);
726
727 /* Version 4 (from RFC2440) - one byte */
728 if (unlikely(data[(*packet_size)++] != 0x04)) {
729 ecryptfs_printk(KERN_DEBUG, "Unknown version number "
730 "[%d]\n", data[(*packet_size) - 1]);
731 rc = -EINVAL;
732 goto out_free;
733 }
734
735 /* cipher - one byte */
736 ecryptfs_cipher_code_to_string(crypt_stat->cipher,
737 (u16)data[(*packet_size)]);
738 /* A little extra work to differentiate among the AES key
739 * sizes; see RFC2440 */
740 switch(data[(*packet_size)++]) {
741 case RFC2440_CIPHER_AES_192:
742 crypt_stat->key_size = 24;
743 break;
744 default:
745 crypt_stat->key_size =
746 (*new_auth_tok)->session_key.encrypted_key_size;
747 }
748 ecryptfs_init_crypt_ctx(crypt_stat);
749 /* S2K identifier 3 (from RFC2440) */
750 if (unlikely(data[(*packet_size)++] != 0x03)) {
751 ecryptfs_printk(KERN_ERR, "Only S2K ID 3 is currently "
752 "supported\n");
753 rc = -ENOSYS;
754 goto out_free;
755 }
756
757 /* TODO: finish the hash mapping */
758 /* hash algorithm - one byte */
759 switch (data[(*packet_size)++]) {
760 case 0x01: /* See RFC2440 for these numbers and their mappings */
761 /* Choose MD5 */
762 /* salt - ECRYPTFS_SALT_SIZE bytes */
763 memcpy((*new_auth_tok)->token.password.salt,
764 &data[(*packet_size)], ECRYPTFS_SALT_SIZE);
765 (*packet_size) += ECRYPTFS_SALT_SIZE;
766
767 /* This conversion was taken straight from RFC2440 */
768 /* number of hash iterations - one byte */
769 (*new_auth_tok)->token.password.hash_iterations =
770 ((u32) 16 + (data[(*packet_size)] & 15))
771 << ((data[(*packet_size)] >> 4) + 6);
772 (*packet_size)++;
773
774 /* encrypted session key -
775 * (body_size-5-ECRYPTFS_SALT_SIZE) bytes */
776 memcpy((*new_auth_tok)->session_key.encrypted_key,
777 &data[(*packet_size)],
778 (*new_auth_tok)->session_key.encrypted_key_size);
779 (*packet_size) +=
780 (*new_auth_tok)->session_key.encrypted_key_size;
781 (*new_auth_tok)->session_key.flags &=
782 ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
783 (*new_auth_tok)->session_key.flags |=
784 ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
785 (*new_auth_tok)->token.password.hash_algo = 0x01;
786 break;
787 default:
788 ecryptfs_printk(KERN_ERR, "Unsupported hash algorithm: "
789 "[%d]\n", data[(*packet_size) - 1]);
790 rc = -ENOSYS;
791 goto out_free;
792 }
793 (*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;
794 /* TODO: Parametarize; we might actually want userspace to
795 * decrypt the session key. */
796 ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
797 ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
798 ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
799 ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
800 list_add(&auth_tok_list_item->list, auth_tok_list);
801 goto out;
802 out_free:
803 (*new_auth_tok) = NULL;
804 memset(auth_tok_list_item, 0,
805 sizeof(struct ecryptfs_auth_tok_list_item));
806 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
807 auth_tok_list_item);
808 out:
809 if (rc)
810 (*packet_size) = 0;
811 return rc;
812 }
813
814 /**
815 * parse_tag_11_packet
816 * @data: The raw bytes of the packet
817 * @contents: This function writes the data contents of the literal
818 * packet into this memory location
819 * @max_contents_bytes: The maximum number of bytes that this function
820 * is allowed to write into contents
821 * @tag_11_contents_size: This function writes the size of the parsed
822 * contents into this memory location; zero on
823 * error
824 * @packet_size: This function writes the size of the parsed packet
825 * into this memory location; zero on error
826 * @max_packet_size: maximum number of bytes to parse
827 *
828 * Returns zero on success; non-zero on error.
829 */
830 static int
831 parse_tag_11_packet(unsigned char *data, unsigned char *contents,
832 size_t max_contents_bytes, size_t *tag_11_contents_size,
833 size_t *packet_size, size_t max_packet_size)
834 {
835 size_t body_size;
836 size_t length_size;
837 int rc = 0;
838
839 (*packet_size) = 0;
840 (*tag_11_contents_size) = 0;
841
842 /* check that:
843 * one byte for the Tag 11 ID flag
844 * two bytes for the Tag 11 length
845 * do not exceed the maximum_packet_size
846 */
847 if (unlikely((*packet_size) + 3 > max_packet_size)) {
848 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
849 rc = -EINVAL;
850 goto out;
851 }
852
853 /* check for Tag 11 identifyer - one byte */
854 if (data[(*packet_size)++] != ECRYPTFS_TAG_11_PACKET_TYPE) {
855 ecryptfs_printk(KERN_WARNING,
856 "Invalid tag 11 packet format\n");
857 rc = -EINVAL;
858 goto out;
859 }
860
861 /* get Tag 11 content length - one or two bytes */
862 rc = parse_packet_length(&data[(*packet_size)], &body_size,
863 &length_size);
864 if (rc) {
865 ecryptfs_printk(KERN_WARNING,
866 "Invalid tag 11 packet format\n");
867 goto out;
868 }
869 (*packet_size) += length_size;
870
871 if (body_size < 13) {
872 ecryptfs_printk(KERN_WARNING, "Invalid body size ([%d])\n",
873 body_size);
874 rc = -EINVAL;
875 goto out;
876 }
877 /* We have 13 bytes of surrounding packet values */
878 (*tag_11_contents_size) = (body_size - 13);
879
880 /* now we know the length of the remainting Tag 11 packet size:
881 * 14 fix bytes for: special flag one, special flag two,
882 * 12 skipped bytes
883 * body_size bytes minus the stuff above is the Tag 11 content
884 */
885 /* FIXME why is the body size one byte smaller than the actual
886 * size of the body?
887 * this seems to be an error here as well as in
888 * write_tag_11_packet() */
889 if (unlikely((*packet_size) + body_size + 1 > max_packet_size)) {
890 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
891 rc = -EINVAL;
892 goto out;
893 }
894
895 /* special flag one - one byte */
896 if (data[(*packet_size)++] != 0x62) {
897 ecryptfs_printk(KERN_WARNING, "Unrecognizable packet\n");
898 rc = -EINVAL;
899 goto out;
900 }
901
902 /* special flag two - one byte */
903 if (data[(*packet_size)++] != 0x08) {
904 ecryptfs_printk(KERN_WARNING, "Unrecognizable packet\n");
905 rc = -EINVAL;
906 goto out;
907 }
908
909 /* skip the next 12 bytes */
910 (*packet_size) += 12; /* We don't care about the filename or
911 * the timestamp */
912
913 /* get the Tag 11 contents - tag_11_contents_size bytes */
914 memcpy(contents, &data[(*packet_size)], (*tag_11_contents_size));
915 (*packet_size) += (*tag_11_contents_size);
916
917 out:
918 if (rc) {
919 (*packet_size) = 0;
920 (*tag_11_contents_size) = 0;
921 }
922 return rc;
923 }
924
925 /**
926 * decrypt_session_key - Decrypt the session key with the given auth_tok.
927 *
928 * Returns Zero on success; non-zero error otherwise.
929 */
930 static int decrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
931 struct ecryptfs_crypt_stat *crypt_stat)
932 {
933 struct ecryptfs_password *password_s_ptr;
934 struct scatterlist src_sg[2], dst_sg[2];
935 struct mutex *tfm_mutex = NULL;
936 char *encrypted_session_key;
937 char *session_key;
938 struct blkcipher_desc desc = {
939 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
940 };
941 int rc = 0;
942
943 password_s_ptr = &auth_tok->token.password;
944 if (ECRYPTFS_CHECK_FLAG(password_s_ptr->flags,
945 ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET))
946 ecryptfs_printk(KERN_DEBUG, "Session key encryption key "
947 "set; skipping key generation\n");
948 ecryptfs_printk(KERN_DEBUG, "Session key encryption key (size [%d])"
949 ":\n",
950 password_s_ptr->session_key_encryption_key_bytes);
951 if (ecryptfs_verbosity > 0)
952 ecryptfs_dump_hex(password_s_ptr->session_key_encryption_key,
953 password_s_ptr->
954 session_key_encryption_key_bytes);
955 if (!strcmp(crypt_stat->cipher,
956 crypt_stat->mount_crypt_stat->global_default_cipher_name)
957 && crypt_stat->mount_crypt_stat->global_key_tfm) {
958 desc.tfm = crypt_stat->mount_crypt_stat->global_key_tfm;
959 tfm_mutex = &crypt_stat->mount_crypt_stat->global_key_tfm_mutex;
960 } else {
961 char *full_alg_name;
962
963 rc = ecryptfs_crypto_api_algify_cipher_name(&full_alg_name,
964 crypt_stat->cipher,
965 "ecb");
966 if (rc)
967 goto out;
968 desc.tfm = crypto_alloc_blkcipher(full_alg_name, 0,
969 CRYPTO_ALG_ASYNC);
970 kfree(full_alg_name);
971 if (IS_ERR(desc.tfm)) {
972 rc = PTR_ERR(desc.tfm);
973 printk(KERN_ERR "Error allocating crypto context; "
974 "rc = [%d]\n", rc);
975 goto out;
976 }
977 crypto_blkcipher_set_flags(desc.tfm, CRYPTO_TFM_REQ_WEAK_KEY);
978 }
979 if (tfm_mutex)
980 mutex_lock(tfm_mutex);
981 rc = crypto_blkcipher_setkey(desc.tfm,
982 password_s_ptr->session_key_encryption_key,
983 crypt_stat->key_size);
984 if (rc < 0) {
985 printk(KERN_ERR "Error setting key for crypto context\n");
986 rc = -EINVAL;
987 goto out_free_tfm;
988 }
989 /* TODO: virt_to_scatterlist */
990 encrypted_session_key = (char *)__get_free_page(GFP_KERNEL);
991 if (!encrypted_session_key) {
992 ecryptfs_printk(KERN_ERR, "Out of memory\n");
993 rc = -ENOMEM;
994 goto out_free_tfm;
995 }
996 session_key = (char *)__get_free_page(GFP_KERNEL);
997 if (!session_key) {
998 kfree(encrypted_session_key);
999 ecryptfs_printk(KERN_ERR, "Out of memory\n");
1000 rc = -ENOMEM;
1001 goto out_free_tfm;
1002 }
1003 memcpy(encrypted_session_key, auth_tok->session_key.encrypted_key,
1004 auth_tok->session_key.encrypted_key_size);
1005 src_sg[0].page = virt_to_page(encrypted_session_key);
1006 src_sg[0].offset = 0;
1007 BUG_ON(auth_tok->session_key.encrypted_key_size > PAGE_CACHE_SIZE);
1008 src_sg[0].length = auth_tok->session_key.encrypted_key_size;
1009 dst_sg[0].page = virt_to_page(session_key);
1010 dst_sg[0].offset = 0;
1011 auth_tok->session_key.decrypted_key_size =
1012 auth_tok->session_key.encrypted_key_size;
1013 dst_sg[0].length = auth_tok->session_key.encrypted_key_size;
1014 rc = crypto_blkcipher_decrypt(&desc, dst_sg, src_sg,
1015 auth_tok->session_key.encrypted_key_size);
1016 if (rc) {
1017 printk(KERN_ERR "Error decrypting; rc = [%d]\n", rc);
1018 goto out_free_memory;
1019 }
1020 auth_tok->session_key.decrypted_key_size =
1021 auth_tok->session_key.encrypted_key_size;
1022 memcpy(auth_tok->session_key.decrypted_key, session_key,
1023 auth_tok->session_key.decrypted_key_size);
1024 auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
1025 memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
1026 auth_tok->session_key.decrypted_key_size);
1027 ECRYPTFS_SET_FLAG(crypt_stat->flags, ECRYPTFS_KEY_VALID);
1028 ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
1029 if (ecryptfs_verbosity > 0)
1030 ecryptfs_dump_hex(crypt_stat->key,
1031 crypt_stat->key_size);
1032 out_free_memory:
1033 memset(encrypted_session_key, 0, PAGE_CACHE_SIZE);
1034 free_page((unsigned long)encrypted_session_key);
1035 memset(session_key, 0, PAGE_CACHE_SIZE);
1036 free_page((unsigned long)session_key);
1037 out_free_tfm:
1038 if (tfm_mutex)
1039 mutex_unlock(tfm_mutex);
1040 else
1041 crypto_free_blkcipher(desc.tfm);
1042 out:
1043 return rc;
1044 }
1045
1046 /**
1047 * ecryptfs_parse_packet_set
1048 * @dest: The header page in memory
1049 * @version: Version of file format, to guide parsing behavior
1050 *
1051 * Get crypt_stat to have the file's session key if the requisite key
1052 * is available to decrypt the session key.
1053 *
1054 * Returns Zero if a valid authentication token was retrieved and
1055 * processed; negative value for file not encrypted or for error
1056 * conditions.
1057 */
1058 int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
1059 unsigned char *src,
1060 struct dentry *ecryptfs_dentry)
1061 {
1062 size_t i = 0;
1063 size_t found_auth_tok = 0;
1064 size_t next_packet_is_auth_tok_packet;
1065 char sig[ECRYPTFS_SIG_SIZE_HEX];
1066 struct list_head auth_tok_list;
1067 struct list_head *walker;
1068 struct ecryptfs_auth_tok *chosen_auth_tok = NULL;
1069 struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
1070 &ecryptfs_superblock_to_private(
1071 ecryptfs_dentry->d_sb)->mount_crypt_stat;
1072 struct ecryptfs_auth_tok *candidate_auth_tok = NULL;
1073 size_t packet_size;
1074 struct ecryptfs_auth_tok *new_auth_tok;
1075 unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE];
1076 size_t tag_11_contents_size;
1077 size_t tag_11_packet_size;
1078 int rc = 0;
1079
1080 INIT_LIST_HEAD(&auth_tok_list);
1081 /* Parse the header to find as many packets as we can, these will be
1082 * added the our &auth_tok_list */
1083 next_packet_is_auth_tok_packet = 1;
1084 while (next_packet_is_auth_tok_packet) {
1085 size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i);
1086
1087 switch (src[i]) {
1088 case ECRYPTFS_TAG_3_PACKET_TYPE:
1089 rc = parse_tag_3_packet(crypt_stat,
1090 (unsigned char *)&src[i],
1091 &auth_tok_list, &new_auth_tok,
1092 &packet_size, max_packet_size);
1093 if (rc) {
1094 ecryptfs_printk(KERN_ERR, "Error parsing "
1095 "tag 3 packet\n");
1096 rc = -EIO;
1097 goto out_wipe_list;
1098 }
1099 i += packet_size;
1100 rc = parse_tag_11_packet((unsigned char *)&src[i],
1101 sig_tmp_space,
1102 ECRYPTFS_SIG_SIZE,
1103 &tag_11_contents_size,
1104 &tag_11_packet_size,
1105 max_packet_size);
1106 if (rc) {
1107 ecryptfs_printk(KERN_ERR, "No valid "
1108 "(ecryptfs-specific) literal "
1109 "packet containing "
1110 "authentication token "
1111 "signature found after "
1112 "tag 3 packet\n");
1113 rc = -EIO;
1114 goto out_wipe_list;
1115 }
1116 i += tag_11_packet_size;
1117 if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {
1118 ecryptfs_printk(KERN_ERR, "Expected "
1119 "signature of size [%d]; "
1120 "read size [%d]\n",
1121 ECRYPTFS_SIG_SIZE,
1122 tag_11_contents_size);
1123 rc = -EIO;
1124 goto out_wipe_list;
1125 }
1126 ecryptfs_to_hex(new_auth_tok->token.password.signature,
1127 sig_tmp_space, tag_11_contents_size);
1128 new_auth_tok->token.password.signature[
1129 ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';
1130 ECRYPTFS_SET_FLAG(crypt_stat->flags,
1131 ECRYPTFS_ENCRYPTED);
1132 break;
1133 case ECRYPTFS_TAG_1_PACKET_TYPE:
1134 rc = parse_tag_1_packet(crypt_stat,
1135 (unsigned char *)&src[i],
1136 &auth_tok_list, &new_auth_tok,
1137 &packet_size, max_packet_size);
1138 if (rc) {
1139 ecryptfs_printk(KERN_ERR, "Error parsing "
1140 "tag 1 packet\n");
1141 rc = -EIO;
1142 goto out_wipe_list;
1143 }
1144 i += packet_size;
1145 ECRYPTFS_SET_FLAG(crypt_stat->flags,
1146 ECRYPTFS_ENCRYPTED);
1147 break;
1148 case ECRYPTFS_TAG_11_PACKET_TYPE:
1149 ecryptfs_printk(KERN_WARNING, "Invalid packet set "
1150 "(Tag 11 not allowed by itself)\n");
1151 rc = -EIO;
1152 goto out_wipe_list;
1153 break;
1154 default:
1155 ecryptfs_printk(KERN_DEBUG, "No packet at offset "
1156 "[%d] of the file header; hex value of "
1157 "character is [0x%.2x]\n", i, src[i]);
1158 next_packet_is_auth_tok_packet = 0;
1159 }
1160 }
1161 if (list_empty(&auth_tok_list)) {
1162 rc = -EINVAL; /* Do not support non-encrypted files in
1163 * the 0.1 release */
1164 goto out;
1165 }
1166 /* If we have a global auth tok, then we should try to use
1167 * it */
1168 if (mount_crypt_stat->global_auth_tok) {
1169 memcpy(sig, mount_crypt_stat->global_auth_tok_sig,
1170 ECRYPTFS_SIG_SIZE_HEX);
1171 chosen_auth_tok = mount_crypt_stat->global_auth_tok;
1172 } else
1173 BUG(); /* We should always have a global auth tok in
1174 * the 0.1 release */
1175 /* Scan list to see if our chosen_auth_tok works */
1176 list_for_each(walker, &auth_tok_list) {
1177 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
1178 auth_tok_list_item =
1179 list_entry(walker, struct ecryptfs_auth_tok_list_item,
1180 list);
1181 candidate_auth_tok = &auth_tok_list_item->auth_tok;
1182 if (unlikely(ecryptfs_verbosity > 0)) {
1183 ecryptfs_printk(KERN_DEBUG,
1184 "Considering cadidate auth tok:\n");
1185 ecryptfs_dump_auth_tok(candidate_auth_tok);
1186 }
1187 /* TODO: Replace ECRYPTFS_SIG_SIZE_HEX w/ dynamic value */
1188 if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD
1189 && !strncmp(candidate_auth_tok->token.password.signature,
1190 sig, ECRYPTFS_SIG_SIZE_HEX)) {
1191 found_auth_tok = 1;
1192 goto leave_list;
1193 /* TODO: Transfer the common salt into the
1194 * crypt_stat salt */
1195 } else if ((candidate_auth_tok->token_type
1196 == ECRYPTFS_PRIVATE_KEY)
1197 && !strncmp(candidate_auth_tok->token.private_key.signature,
1198 sig, ECRYPTFS_SIG_SIZE_HEX)) {
1199 found_auth_tok = 1;
1200 goto leave_list;
1201 }
1202 }
1203 if (!found_auth_tok) {
1204 ecryptfs_printk(KERN_ERR, "Could not find authentication "
1205 "token on temporary list for sig [%.*s]\n",
1206 ECRYPTFS_SIG_SIZE_HEX, sig);
1207 rc = -EIO;
1208 goto out_wipe_list;
1209 }
1210 leave_list:
1211 rc = -ENOTSUPP;
1212 if ((ECRYPTFS_CHECK_FLAG(candidate_auth_tok->flags,
1213 ECRYPTFS_PRIVATE_KEY))) {
1214 memcpy(&(candidate_auth_tok->token.private_key),
1215 &(chosen_auth_tok->token.private_key),
1216 sizeof(struct ecryptfs_private_key));
1217 rc = decrypt_pki_encrypted_session_key(mount_crypt_stat,
1218 candidate_auth_tok,
1219 crypt_stat);
1220 } else if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD) {
1221 memcpy(&(candidate_auth_tok->token.password),
1222 &(chosen_auth_tok->token.password),
1223 sizeof(struct ecryptfs_password));
1224 rc = decrypt_session_key(candidate_auth_tok, crypt_stat);
1225 }
1226 if (rc) {
1227 ecryptfs_printk(KERN_ERR, "Error decrypting the "
1228 "session key; rc = [%d]\n", rc);
1229 goto out_wipe_list;
1230 }
1231 rc = ecryptfs_compute_root_iv(crypt_stat);
1232 if (rc) {
1233 ecryptfs_printk(KERN_ERR, "Error computing "
1234 "the root IV\n");
1235 goto out_wipe_list;
1236 }
1237 rc = ecryptfs_init_crypt_ctx(crypt_stat);
1238 if (rc) {
1239 ecryptfs_printk(KERN_ERR, "Error initializing crypto "
1240 "context for cipher [%s]; rc = [%d]\n",
1241 crypt_stat->cipher, rc);
1242 }
1243 out_wipe_list:
1244 wipe_auth_tok_list(&auth_tok_list);
1245 out:
1246 return rc;
1247 }
1248 static int
1249 pki_encrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
1250 struct ecryptfs_crypt_stat *crypt_stat,
1251 struct ecryptfs_key_record *key_rec)
1252 {
1253 struct ecryptfs_msg_ctx *msg_ctx = NULL;
1254 char *netlink_payload;
1255 size_t netlink_payload_length;
1256 struct ecryptfs_message *msg;
1257 int rc;
1258
1259 rc = write_tag_66_packet(auth_tok->token.private_key.signature,
1260 ecryptfs_code_for_cipher_string(crypt_stat),
1261 crypt_stat, &netlink_payload,
1262 &netlink_payload_length);
1263 if (rc) {
1264 ecryptfs_printk(KERN_ERR, "Error generating tag 66 packet\n");
1265 goto out;
1266 }
1267 rc = ecryptfs_send_message(ecryptfs_transport, netlink_payload,
1268 netlink_payload_length, &msg_ctx);
1269 if (rc) {
1270 ecryptfs_printk(KERN_ERR, "Error sending netlink message\n");
1271 goto out;
1272 }
1273 rc = ecryptfs_wait_for_response(msg_ctx, &msg);
1274 if (rc) {
1275 ecryptfs_printk(KERN_ERR, "Failed to receive tag 67 packet "
1276 "from the user space daemon\n");
1277 rc = -EIO;
1278 goto out;
1279 }
1280 rc = parse_tag_67_packet(key_rec, msg);
1281 if (rc)
1282 ecryptfs_printk(KERN_ERR, "Error parsing tag 67 packet\n");
1283 kfree(msg);
1284 out:
1285 if (netlink_payload)
1286 kfree(netlink_payload);
1287 return rc;
1288 }
1289 /**
1290 * write_tag_1_packet - Write an RFC2440-compatible tag 1 (public key) packet
1291 * @dest: Buffer into which to write the packet
1292 * @max: Maximum number of bytes that can be writtn
1293 * @packet_size: This function will write the number of bytes that end
1294 * up constituting the packet; set to zero on error
1295 *
1296 * Returns zero on success; non-zero on error.
1297 */
1298 static int
1299 write_tag_1_packet(char *dest, size_t max, struct ecryptfs_auth_tok *auth_tok,
1300 struct ecryptfs_crypt_stat *crypt_stat,
1301 struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
1302 struct ecryptfs_key_record *key_rec, size_t *packet_size)
1303 {
1304 size_t i;
1305 size_t encrypted_session_key_valid = 0;
1306 size_t key_rec_size;
1307 size_t packet_size_length;
1308 int rc = 0;
1309
1310 (*packet_size) = 0;
1311 ecryptfs_from_hex(key_rec->sig, auth_tok->token.private_key.signature,
1312 ECRYPTFS_SIG_SIZE);
1313 encrypted_session_key_valid = 0;
1314 for (i = 0; i < crypt_stat->key_size; i++)
1315 encrypted_session_key_valid |=
1316 auth_tok->session_key.encrypted_key[i];
1317 if (encrypted_session_key_valid) {
1318 memcpy(key_rec->enc_key,
1319 auth_tok->session_key.encrypted_key,
1320 auth_tok->session_key.encrypted_key_size);
1321 goto encrypted_session_key_set;
1322 }
1323 if (auth_tok->session_key.encrypted_key_size == 0)
1324 auth_tok->session_key.encrypted_key_size =
1325 auth_tok->token.private_key.key_size;
1326 rc = pki_encrypt_session_key(auth_tok, crypt_stat, key_rec);
1327 if (rc) {
1328 ecryptfs_printk(KERN_ERR, "Failed to encrypt session key "
1329 "via a pki");
1330 goto out;
1331 }
1332 if (ecryptfs_verbosity > 0) {
1333 ecryptfs_printk(KERN_DEBUG, "Encrypted key:\n");
1334 ecryptfs_dump_hex(key_rec->enc_key, key_rec->enc_key_size);
1335 }
1336 encrypted_session_key_set:
1337 /* Now we have a valid key_rec. Append it to the
1338 * key_rec set. */
1339 key_rec_size = (sizeof(struct ecryptfs_key_record)
1340 - ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES
1341 + (key_rec->enc_key_size));
1342 /* TODO: Include a packet size limit as a parameter to this
1343 * function once we have multi-packet headers (for versions
1344 * later than 0.1 */
1345 if (key_rec_size >= ECRYPTFS_MAX_KEYSET_SIZE) {
1346 ecryptfs_printk(KERN_ERR, "Keyset too large\n");
1347 rc = -EINVAL;
1348 goto out;
1349 }
1350 /* ***** TAG 1 Packet Format *****
1351 * | version number | 1 byte |
1352 * | key ID | 8 bytes |
1353 * | public key algorithm | 1 byte |
1354 * | encrypted session key | arbitrary |
1355 */
1356 if ((0x02 + ECRYPTFS_SIG_SIZE + key_rec->enc_key_size) >= max) {
1357 ecryptfs_printk(KERN_ERR,
1358 "Authentication token is too large\n");
1359 rc = -EINVAL;
1360 goto out;
1361 }
1362 dest[(*packet_size)++] = ECRYPTFS_TAG_1_PACKET_TYPE;
1363 /* This format is inspired by OpenPGP; see RFC 2440
1364 * packet tag 1 */
1365 rc = write_packet_length(&dest[(*packet_size)],
1366 (0x02 + ECRYPTFS_SIG_SIZE +
1367 key_rec->enc_key_size),
1368 &packet_size_length);
1369 if (rc) {
1370 ecryptfs_printk(KERN_ERR, "Error generating tag 1 packet "
1371 "header; cannot generate packet length\n");
1372 goto out;
1373 }
1374 (*packet_size) += packet_size_length;
1375 dest[(*packet_size)++] = 0x03; /* version 3 */
1376 memcpy(&dest[(*packet_size)], key_rec->sig, ECRYPTFS_SIG_SIZE);
1377 (*packet_size) += ECRYPTFS_SIG_SIZE;
1378 dest[(*packet_size)++] = RFC2440_CIPHER_RSA;
1379 memcpy(&dest[(*packet_size)], key_rec->enc_key,
1380 key_rec->enc_key_size);
1381 (*packet_size) += key_rec->enc_key_size;
1382 out:
1383 if (rc)
1384 (*packet_size) = 0;
1385 return rc;
1386 }
1387
1388 /**
1389 * write_tag_11_packet
1390 * @dest: Target into which Tag 11 packet is to be written
1391 * @max: Maximum packet length
1392 * @contents: Byte array of contents to copy in
1393 * @contents_length: Number of bytes in contents
1394 * @packet_length: Length of the Tag 11 packet written; zero on error
1395 *
1396 * Returns zero on success; non-zero on error.
1397 */
1398 static int
1399 write_tag_11_packet(char *dest, int max, char *contents, size_t contents_length,
1400 size_t *packet_length)
1401 {
1402 size_t packet_size_length;
1403 int rc = 0;
1404
1405 (*packet_length) = 0;
1406 if ((13 + contents_length) > max) {
1407 rc = -EINVAL;
1408 ecryptfs_printk(KERN_ERR, "Packet length larger than "
1409 "maximum allowable\n");
1410 goto out;
1411 }
1412 /* General packet header */
1413 /* Packet tag */
1414 dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE;
1415 /* Packet length */
1416 rc = write_packet_length(&dest[(*packet_length)],
1417 (13 + contents_length), &packet_size_length);
1418 if (rc) {
1419 ecryptfs_printk(KERN_ERR, "Error generating tag 11 packet "
1420 "header; cannot generate packet length\n");
1421 goto out;
1422 }
1423 (*packet_length) += packet_size_length;
1424 /* Tag 11 specific */
1425 /* One-octet field that describes how the data is formatted */
1426 dest[(*packet_length)++] = 0x62; /* binary data */
1427 /* One-octet filename length followed by filename */
1428 dest[(*packet_length)++] = 8;
1429 memcpy(&dest[(*packet_length)], "_CONSOLE", 8);
1430 (*packet_length) += 8;
1431 /* Four-octet number indicating modification date */
1432 memset(&dest[(*packet_length)], 0x00, 4);
1433 (*packet_length) += 4;
1434 /* Remainder is literal data */
1435 memcpy(&dest[(*packet_length)], contents, contents_length);
1436 (*packet_length) += contents_length;
1437 out:
1438 if (rc)
1439 (*packet_length) = 0;
1440 return rc;
1441 }
1442
1443 /**
1444 * write_tag_3_packet
1445 * @dest: Buffer into which to write the packet
1446 * @max: Maximum number of bytes that can be written
1447 * @auth_tok: Authentication token
1448 * @crypt_stat: The cryptographic context
1449 * @key_rec: encrypted key
1450 * @packet_size: This function will write the number of bytes that end
1451 * up constituting the packet; set to zero on error
1452 *
1453 * Returns zero on success; non-zero on error.
1454 */
1455 static int
1456 write_tag_3_packet(char *dest, size_t max, struct ecryptfs_auth_tok *auth_tok,
1457 struct ecryptfs_crypt_stat *crypt_stat,
1458 struct ecryptfs_key_record *key_rec, size_t *packet_size)
1459 {
1460 size_t i;
1461 size_t encrypted_session_key_valid = 0;
1462 char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
1463 struct scatterlist dest_sg[2];
1464 struct scatterlist src_sg[2];
1465 struct mutex *tfm_mutex = NULL;
1466 size_t key_rec_size;
1467 size_t packet_size_length;
1468 size_t cipher_code;
1469 struct blkcipher_desc desc = {
1470 .tfm = NULL,
1471 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
1472 };
1473 int rc = 0;
1474
1475 (*packet_size) = 0;
1476 ecryptfs_from_hex(key_rec->sig, auth_tok->token.password.signature,
1477 ECRYPTFS_SIG_SIZE);
1478 encrypted_session_key_valid = 0;
1479 for (i = 0; i < crypt_stat->key_size; i++)
1480 encrypted_session_key_valid |=
1481 auth_tok->session_key.encrypted_key[i];
1482 if (encrypted_session_key_valid) {
1483 memcpy(key_rec->enc_key,
1484 auth_tok->session_key.encrypted_key,
1485 auth_tok->session_key.encrypted_key_size);
1486 goto encrypted_session_key_set;
1487 }
1488 if (auth_tok->session_key.encrypted_key_size == 0)
1489 auth_tok->session_key.encrypted_key_size =
1490 crypt_stat->key_size;
1491 if (crypt_stat->key_size == 24
1492 && strcmp("aes", crypt_stat->cipher) == 0) {
1493 memset((crypt_stat->key + 24), 0, 8);
1494 auth_tok->session_key.encrypted_key_size = 32;
1495 }
1496 key_rec->enc_key_size =
1497 auth_tok->session_key.encrypted_key_size;
1498 if (auth_tok->token.password.flags &
1499 ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET) {
1500 ecryptfs_printk(KERN_DEBUG, "Using previously generated "
1501 "session key encryption key of size [%d]\n",
1502 auth_tok->token.password.
1503 session_key_encryption_key_bytes);
1504 memcpy(session_key_encryption_key,
1505 auth_tok->token.password.session_key_encryption_key,
1506 crypt_stat->key_size);
1507 ecryptfs_printk(KERN_DEBUG,
1508 "Cached session key " "encryption key: \n");
1509 if (ecryptfs_verbosity > 0)
1510 ecryptfs_dump_hex(session_key_encryption_key, 16);
1511 }
1512 if (unlikely(ecryptfs_verbosity > 0)) {
1513 ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");
1514 ecryptfs_dump_hex(session_key_encryption_key, 16);
1515 }
1516 rc = virt_to_scatterlist(crypt_stat->key,
1517 key_rec->enc_key_size, src_sg, 2);
1518 if (!rc) {
1519 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
1520 "for crypt_stat session key\n");
1521 rc = -ENOMEM;
1522 goto out;
1523 }
1524 rc = virt_to_scatterlist(key_rec->enc_key,
1525 key_rec->enc_key_size, dest_sg, 2);
1526 if (!rc) {
1527 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
1528 "for crypt_stat encrypted session key\n");
1529 rc = -ENOMEM;
1530 goto out;
1531 }
1532 if (!strcmp(crypt_stat->cipher,
1533 crypt_stat->mount_crypt_stat->global_default_cipher_name)
1534 && crypt_stat->mount_crypt_stat->global_key_tfm) {
1535 desc.tfm = crypt_stat->mount_crypt_stat->global_key_tfm;
1536 tfm_mutex = &crypt_stat->mount_crypt_stat->global_key_tfm_mutex;
1537 } else {
1538 char *full_alg_name;
1539
1540 rc = ecryptfs_crypto_api_algify_cipher_name(&full_alg_name,
1541 crypt_stat->cipher,
1542 "ecb");
1543 if (rc)
1544 goto out;
1545 desc.tfm = crypto_alloc_blkcipher(full_alg_name, 0,
1546 CRYPTO_ALG_ASYNC);
1547 kfree(full_alg_name);
1548 if (IS_ERR(desc.tfm)) {
1549 rc = PTR_ERR(desc.tfm);
1550 ecryptfs_printk(KERN_ERR, "Could not initialize crypto "
1551 "context for cipher [%s]; rc = [%d]\n",
1552 crypt_stat->cipher, rc);
1553 goto out;
1554 }
1555 crypto_blkcipher_set_flags(desc.tfm, CRYPTO_TFM_REQ_WEAK_KEY);
1556 }
1557 if (tfm_mutex)
1558 mutex_lock(tfm_mutex);
1559 rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key,
1560 crypt_stat->key_size);
1561 if (rc < 0) {
1562 if (tfm_mutex)
1563 mutex_unlock(tfm_mutex);
1564 ecryptfs_printk(KERN_ERR, "Error setting key for crypto "
1565 "context; rc = [%d]\n", rc);
1566 goto out;
1567 }
1568 rc = 0;
1569 ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n",
1570 crypt_stat->key_size);
1571 rc = crypto_blkcipher_encrypt(&desc, dest_sg, src_sg,
1572 (*key_rec).enc_key_size);
1573 if (rc) {
1574 printk(KERN_ERR "Error encrypting; rc = [%d]\n", rc);
1575 goto out;
1576 }
1577 if (tfm_mutex)
1578 mutex_unlock(tfm_mutex);
1579 ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");
1580 if (ecryptfs_verbosity > 0)
1581 ecryptfs_dump_hex(key_rec->enc_key,
1582 key_rec->enc_key_size);
1583 encrypted_session_key_set:
1584 /* Now we have a valid key_rec. Append it to the
1585 * key_rec set. */
1586 key_rec_size = (sizeof(struct ecryptfs_key_record)
1587 - ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES
1588 + (key_rec->enc_key_size));
1589 /* TODO: Include a packet size limit as a parameter to this
1590 * function once we have multi-packet headers (for versions
1591 * later than 0.1 */
1592 if (key_rec_size >= ECRYPTFS_MAX_KEYSET_SIZE) {
1593 ecryptfs_printk(KERN_ERR, "Keyset too large\n");
1594 rc = -EINVAL;
1595 goto out;
1596 }
1597 /* TODO: Packet size limit */
1598 /* We have 5 bytes of surrounding packet data */
1599 if ((0x05 + ECRYPTFS_SALT_SIZE
1600 + key_rec->enc_key_size) >= max) {
1601 ecryptfs_printk(KERN_ERR, "Authentication token is too "
1602 "large\n");
1603 rc = -EINVAL;
1604 goto out;
1605 }
1606 /* This format is inspired by OpenPGP; see RFC 2440
1607 * packet tag 3 */
1608 dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE;
1609 /* ver+cipher+s2k+hash+salt+iter+enc_key */
1610 rc = write_packet_length(&dest[(*packet_size)],
1611 (0x05 + ECRYPTFS_SALT_SIZE
1612 + key_rec->enc_key_size),
1613 &packet_size_length);
1614 if (rc) {
1615 ecryptfs_printk(KERN_ERR, "Error generating tag 3 packet "
1616 "header; cannot generate packet length\n");
1617 goto out;
1618 }
1619 (*packet_size) += packet_size_length;
1620 dest[(*packet_size)++] = 0x04; /* version 4 */
1621 cipher_code = ecryptfs_code_for_cipher_string(crypt_stat);
1622 if (cipher_code == 0) {
1623 ecryptfs_printk(KERN_WARNING, "Unable to generate code for "
1624 "cipher [%s]\n", crypt_stat->cipher);
1625 rc = -EINVAL;
1626 goto out;
1627 }
1628 dest[(*packet_size)++] = cipher_code;
1629 dest[(*packet_size)++] = 0x03; /* S2K */
1630 dest[(*packet_size)++] = 0x01; /* MD5 (TODO: parameterize) */
1631 memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,
1632 ECRYPTFS_SALT_SIZE);
1633 (*packet_size) += ECRYPTFS_SALT_SIZE; /* salt */
1634 dest[(*packet_size)++] = 0x60; /* hash iterations (65536) */
1635 memcpy(&dest[(*packet_size)], key_rec->enc_key,
1636 key_rec->enc_key_size);
1637 (*packet_size) += key_rec->enc_key_size;
1638 out:
1639 if (desc.tfm && !tfm_mutex)
1640 crypto_free_blkcipher(desc.tfm);
1641 if (rc)
1642 (*packet_size) = 0;
1643 return rc;
1644 }
1645
1646 /**
1647 * ecryptfs_generate_key_packet_set
1648 * @dest: Virtual address from which to write the key record set
1649 * @crypt_stat: The cryptographic context from which the
1650 * authentication tokens will be retrieved
1651 * @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat
1652 * for the global parameters
1653 * @len: The amount written
1654 * @max: The maximum amount of data allowed to be written
1655 *
1656 * Generates a key packet set and writes it to the virtual address
1657 * passed in.
1658 *
1659 * Returns zero on success; non-zero on error.
1660 */
1661 int
1662 ecryptfs_generate_key_packet_set(char *dest_base,
1663 struct ecryptfs_crypt_stat *crypt_stat,
1664 struct dentry *ecryptfs_dentry, size_t *len,
1665 size_t max)
1666 {
1667 struct ecryptfs_auth_tok *auth_tok;
1668 struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
1669 &ecryptfs_superblock_to_private(
1670 ecryptfs_dentry->d_sb)->mount_crypt_stat;
1671 size_t written;
1672 struct ecryptfs_key_record key_rec;
1673 int rc = 0;
1674
1675 (*len) = 0;
1676 if (mount_crypt_stat->global_auth_tok) {
1677 auth_tok = mount_crypt_stat->global_auth_tok;
1678 if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
1679 rc = write_tag_3_packet((dest_base + (*len)),
1680 max, auth_tok,
1681 crypt_stat, &key_rec,
1682 &written);
1683 if (rc) {
1684 ecryptfs_printk(KERN_WARNING, "Error "
1685 "writing tag 3 packet\n");
1686 goto out;
1687 }
1688 (*len) += written;
1689 /* Write auth tok signature packet */
1690 rc = write_tag_11_packet(
1691 (dest_base + (*len)),
1692 (max - (*len)),
1693 key_rec.sig, ECRYPTFS_SIG_SIZE, &written);
1694 if (rc) {
1695 ecryptfs_printk(KERN_ERR, "Error writing "
1696 "auth tok signature packet\n");
1697 goto out;
1698 }
1699 (*len) += written;
1700 } else if (auth_tok->token_type == ECRYPTFS_PRIVATE_KEY) {
1701 rc = write_tag_1_packet(dest_base + (*len),
1702 max, auth_tok,
1703 crypt_stat,mount_crypt_stat,
1704 &key_rec, &written);
1705 if (rc) {
1706 ecryptfs_printk(KERN_WARNING, "Error "
1707 "writing tag 1 packet\n");
1708 goto out;
1709 }
1710 (*len) += written;
1711 } else {
1712 ecryptfs_printk(KERN_WARNING, "Unsupported "
1713 "authentication token type\n");
1714 rc = -EINVAL;
1715 goto out;
1716 }
1717 } else
1718 BUG();
1719 if (likely((max - (*len)) > 0)) {
1720 dest_base[(*len)] = 0x00;
1721 } else {
1722 ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");
1723 rc = -EIO;
1724 }
1725 out:
1726 if (rc)
1727 (*len) = 0;
1728 return rc;
1729 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree