projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Pull trivial into test branch
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / ecryptfs / keystore.c
1 /**
2 * eCryptfs: Linux filesystem encryption layer
3 * In-kernel key management code. Includes functions to parse and
4 * write authentication token-related packets with the underlying
5 * file.
6 *
7 * Copyright (C) 2004-2006 International Business Machines Corp.
8 * Author(s): Michael A. Halcrow <mhalcrow@us.ibm.com>
9 * Michael C. Thompson <mcthomps@us.ibm.com>
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of the
14 * License, or (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
24 * 02111-1307, USA.
25 */
26
27 #include <linux/string.h>
28 #include <linux/sched.h>
29 #include <linux/syscalls.h>
30 #include <linux/pagemap.h>
31 #include <linux/key.h>
32 #include <linux/random.h>
33 #include <linux/crypto.h>
34 #include <linux/scatterlist.h>
35 #include "ecryptfs_kernel.h"
36
37 /**
38 * request_key returned an error instead of a valid key address;
39 * determine the type of error, make appropriate log entries, and
40 * return an error code.
41 */
42 int process_request_key_err(long err_code)
43 {
44 int rc = 0;
45
46 switch (err_code) {
47 case ENOKEY:
48 ecryptfs_printk(KERN_WARNING, "No key\n");
49 rc = -ENOENT;
50 break;
51 case EKEYEXPIRED:
52 ecryptfs_printk(KERN_WARNING, "Key expired\n");
53 rc = -ETIME;
54 break;
55 case EKEYREVOKED:
56 ecryptfs_printk(KERN_WARNING, "Key revoked\n");
57 rc = -EINVAL;
58 break;
59 default:
60 ecryptfs_printk(KERN_WARNING, "Unknown error code: "
61 "[0x%.16x]\n", err_code);
62 rc = -EINVAL;
63 }
64 return rc;
65 }
66
67 static void wipe_auth_tok_list(struct list_head *auth_tok_list_head)
68 {
69 struct list_head *walker;
70 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
71
72 walker = auth_tok_list_head->next;
73 while (walker != auth_tok_list_head) {
74 auth_tok_list_item =
75 list_entry(walker, struct ecryptfs_auth_tok_list_item,
76 list);
77 walker = auth_tok_list_item->list.next;
78 memset(auth_tok_list_item, 0,
79 sizeof(struct ecryptfs_auth_tok_list_item));
80 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
81 auth_tok_list_item);
82 }
83 }
84
85 struct kmem_cache *ecryptfs_auth_tok_list_item_cache;
86
87 /**
88 * parse_packet_length
89 * @data: Pointer to memory containing length at offset
90 * @size: This function writes the decoded size to this memory
91 * address; zero on error
92 * @length_size: The number of bytes occupied by the encoded length
93 *
94 * Returns Zero on success
95 */
96 static int parse_packet_length(unsigned char *data, size_t *size,
97 size_t *length_size)
98 {
99 int rc = 0;
100
101 (*length_size) = 0;
102 (*size) = 0;
103 if (data[0] < 192) {
104 /* One-byte length */
105 (*size) = data[0];
106 (*length_size) = 1;
107 } else if (data[0] < 224) {
108 /* Two-byte length */
109 (*size) = ((data[0] - 192) * 256);
110 (*size) += (data[1] + 192);
111 (*length_size) = 2;
112 } else if (data[0] == 255) {
113 /* Five-byte length; we're not supposed to see this */
114 ecryptfs_printk(KERN_ERR, "Five-byte packet length not "
115 "supported\n");
116 rc = -EINVAL;
117 goto out;
118 } else {
119 ecryptfs_printk(KERN_ERR, "Error parsing packet length\n");
120 rc = -EINVAL;
121 goto out;
122 }
123 out:
124 return rc;
125 }
126
127 /**
128 * write_packet_length
129 * @dest: The byte array target into which to write the
130 * length. Must have at least 5 bytes allocated.
131 * @size: The length to write.
132 * @packet_size_length: The number of bytes used to encode the
133 * packet length is written to this address.
134 *
135 * Returns zero on success; non-zero on error.
136 */
137 static int write_packet_length(char *dest, size_t size,
138 size_t *packet_size_length)
139 {
140 int rc = 0;
141
142 if (size < 192) {
143 dest[0] = size;
144 (*packet_size_length) = 1;
145 } else if (size < 65536) {
146 dest[0] = (((size - 192) / 256) + 192);
147 dest[1] = ((size - 192) % 256);
148 (*packet_size_length) = 2;
149 } else {
150 rc = -EINVAL;
151 ecryptfs_printk(KERN_WARNING,
152 "Unsupported packet size: [%d]\n", size);
153 }
154 return rc;
155 }
156
157 /**
158 * parse_tag_3_packet
159 * @crypt_stat: The cryptographic context to modify based on packet
160 * contents.
161 * @data: The raw bytes of the packet.
162 * @auth_tok_list: eCryptfs parses packets into authentication tokens;
163 * a new authentication token will be placed at the end
164 * of this list for this packet.
165 * @new_auth_tok: Pointer to a pointer to memory that this function
166 * allocates; sets the memory address of the pointer to
167 * NULL on error. This object is added to the
168 * auth_tok_list.
169 * @packet_size: This function writes the size of the parsed packet
170 * into this memory location; zero on error.
171 * @max_packet_size: maximum number of bytes to parse
172 *
173 * Returns zero on success; non-zero on error.
174 */
175 static int
176 parse_tag_3_packet(struct ecryptfs_crypt_stat *crypt_stat,
177 unsigned char *data, struct list_head *auth_tok_list,
178 struct ecryptfs_auth_tok **new_auth_tok,
179 size_t *packet_size, size_t max_packet_size)
180 {
181 int rc = 0;
182 size_t body_size;
183 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
184 size_t length_size;
185
186 (*packet_size) = 0;
187 (*new_auth_tok) = NULL;
188
189 /* we check that:
190 * one byte for the Tag 3 ID flag
191 * two bytes for the body size
192 * do not exceed the maximum_packet_size
193 */
194 if (unlikely((*packet_size) + 3 > max_packet_size)) {
195 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
196 rc = -EINVAL;
197 goto out;
198 }
199
200 /* check for Tag 3 identifyer - one byte */
201 if (data[(*packet_size)++] != ECRYPTFS_TAG_3_PACKET_TYPE) {
202 ecryptfs_printk(KERN_ERR, "Enter w/ first byte != 0x%.2x\n",
203 ECRYPTFS_TAG_3_PACKET_TYPE);
204 rc = -EINVAL;
205 goto out;
206 }
207 /* Released: wipe_auth_tok_list called in ecryptfs_parse_packet_set or
208 * at end of function upon failure */
209 auth_tok_list_item =
210 kmem_cache_alloc(ecryptfs_auth_tok_list_item_cache, GFP_KERNEL);
211 if (!auth_tok_list_item) {
212 ecryptfs_printk(KERN_ERR, "Unable to allocate memory\n");
213 rc = -ENOMEM;
214 goto out;
215 }
216 memset(auth_tok_list_item, 0,
217 sizeof(struct ecryptfs_auth_tok_list_item));
218 (*new_auth_tok) = &auth_tok_list_item->auth_tok;
219
220 /* check for body size - one to two bytes */
221 rc = parse_packet_length(&data[(*packet_size)], &body_size,
222 &length_size);
223 if (rc) {
224 ecryptfs_printk(KERN_WARNING, "Error parsing packet length; "
225 "rc = [%d]\n", rc);
226 goto out_free;
227 }
228 if (unlikely(body_size < (0x05 + ECRYPTFS_SALT_SIZE))) {
229 ecryptfs_printk(KERN_WARNING, "Invalid body size ([%d])\n",
230 body_size);
231 rc = -EINVAL;
232 goto out_free;
233 }
234 (*packet_size) += length_size;
235
236 /* now we know the length of the remainting Tag 3 packet size:
237 * 5 fix bytes for: version string, cipher, S2K ID, hash algo,
238 * number of hash iterations
239 * ECRYPTFS_SALT_SIZE bytes for salt
240 * body_size bytes minus the stuff above is the encrypted key size
241 */
242 if (unlikely((*packet_size) + body_size > max_packet_size)) {
243 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
244 rc = -EINVAL;
245 goto out_free;
246 }
247
248 /* There are 5 characters of additional information in the
249 * packet */
250 (*new_auth_tok)->session_key.encrypted_key_size =
251 body_size - (0x05 + ECRYPTFS_SALT_SIZE);
252 ecryptfs_printk(KERN_DEBUG, "Encrypted key size = [%d]\n",
253 (*new_auth_tok)->session_key.encrypted_key_size);
254
255 /* Version 4 (from RFC2440) - one byte */
256 if (unlikely(data[(*packet_size)++] != 0x04)) {
257 ecryptfs_printk(KERN_DEBUG, "Unknown version number "
258 "[%d]\n", data[(*packet_size) - 1]);
259 rc = -EINVAL;
260 goto out_free;
261 }
262
263 /* cipher - one byte */
264 ecryptfs_cipher_code_to_string(crypt_stat->cipher,
265 (u16)data[(*packet_size)]);
266 /* A little extra work to differentiate among the AES key
267 * sizes; see RFC2440 */
268 switch(data[(*packet_size)++]) {
269 case RFC2440_CIPHER_AES_192:
270 crypt_stat->key_size = 24;
271 break;
272 default:
273 crypt_stat->key_size =
274 (*new_auth_tok)->session_key.encrypted_key_size;
275 }
276 ecryptfs_init_crypt_ctx(crypt_stat);
277 /* S2K identifier 3 (from RFC2440) */
278 if (unlikely(data[(*packet_size)++] != 0x03)) {
279 ecryptfs_printk(KERN_ERR, "Only S2K ID 3 is currently "
280 "supported\n");
281 rc = -ENOSYS;
282 goto out_free;
283 }
284
285 /* TODO: finish the hash mapping */
286 /* hash algorithm - one byte */
287 switch (data[(*packet_size)++]) {
288 case 0x01: /* See RFC2440 for these numbers and their mappings */
289 /* Choose MD5 */
290 /* salt - ECRYPTFS_SALT_SIZE bytes */
291 memcpy((*new_auth_tok)->token.password.salt,
292 &data[(*packet_size)], ECRYPTFS_SALT_SIZE);
293 (*packet_size) += ECRYPTFS_SALT_SIZE;
294
295 /* This conversion was taken straight from RFC2440 */
296 /* number of hash iterations - one byte */
297 (*new_auth_tok)->token.password.hash_iterations =
298 ((u32) 16 + (data[(*packet_size)] & 15))
299 << ((data[(*packet_size)] >> 4) + 6);
300 (*packet_size)++;
301
302 /* encrypted session key -
303 * (body_size-5-ECRYPTFS_SALT_SIZE) bytes */
304 memcpy((*new_auth_tok)->session_key.encrypted_key,
305 &data[(*packet_size)],
306 (*new_auth_tok)->session_key.encrypted_key_size);
307 (*packet_size) +=
308 (*new_auth_tok)->session_key.encrypted_key_size;
309 (*new_auth_tok)->session_key.flags &=
310 ~ECRYPTFS_CONTAINS_DECRYPTED_KEY;
311 (*new_auth_tok)->session_key.flags |=
312 ECRYPTFS_CONTAINS_ENCRYPTED_KEY;
313 (*new_auth_tok)->token.password.hash_algo = 0x01;
314 break;
315 default:
316 ecryptfs_printk(KERN_ERR, "Unsupported hash algorithm: "
317 "[%d]\n", data[(*packet_size) - 1]);
318 rc = -ENOSYS;
319 goto out_free;
320 }
321 (*new_auth_tok)->token_type = ECRYPTFS_PASSWORD;
322 /* TODO: Parametarize; we might actually want userspace to
323 * decrypt the session key. */
324 ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
325 ECRYPTFS_USERSPACE_SHOULD_TRY_TO_DECRYPT);
326 ECRYPTFS_CLEAR_FLAG((*new_auth_tok)->session_key.flags,
327 ECRYPTFS_USERSPACE_SHOULD_TRY_TO_ENCRYPT);
328 list_add(&auth_tok_list_item->list, auth_tok_list);
329 goto out;
330 out_free:
331 (*new_auth_tok) = NULL;
332 memset(auth_tok_list_item, 0,
333 sizeof(struct ecryptfs_auth_tok_list_item));
334 kmem_cache_free(ecryptfs_auth_tok_list_item_cache,
335 auth_tok_list_item);
336 out:
337 if (rc)
338 (*packet_size) = 0;
339 return rc;
340 }
341
342 /**
343 * parse_tag_11_packet
344 * @data: The raw bytes of the packet
345 * @contents: This function writes the data contents of the literal
346 * packet into this memory location
347 * @max_contents_bytes: The maximum number of bytes that this function
348 * is allowed to write into contents
349 * @tag_11_contents_size: This function writes the size of the parsed
350 * contents into this memory location; zero on
351 * error
352 * @packet_size: This function writes the size of the parsed packet
353 * into this memory location; zero on error
354 * @max_packet_size: maximum number of bytes to parse
355 *
356 * Returns zero on success; non-zero on error.
357 */
358 static int
359 parse_tag_11_packet(unsigned char *data, unsigned char *contents,
360 size_t max_contents_bytes, size_t *tag_11_contents_size,
361 size_t *packet_size, size_t max_packet_size)
362 {
363 int rc = 0;
364 size_t body_size;
365 size_t length_size;
366
367 (*packet_size) = 0;
368 (*tag_11_contents_size) = 0;
369
370 /* check that:
371 * one byte for the Tag 11 ID flag
372 * two bytes for the Tag 11 length
373 * do not exceed the maximum_packet_size
374 */
375 if (unlikely((*packet_size) + 3 > max_packet_size)) {
376 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
377 rc = -EINVAL;
378 goto out;
379 }
380
381 /* check for Tag 11 identifyer - one byte */
382 if (data[(*packet_size)++] != ECRYPTFS_TAG_11_PACKET_TYPE) {
383 ecryptfs_printk(KERN_WARNING,
384 "Invalid tag 11 packet format\n");
385 rc = -EINVAL;
386 goto out;
387 }
388
389 /* get Tag 11 content length - one or two bytes */
390 rc = parse_packet_length(&data[(*packet_size)], &body_size,
391 &length_size);
392 if (rc) {
393 ecryptfs_printk(KERN_WARNING,
394 "Invalid tag 11 packet format\n");
395 goto out;
396 }
397 (*packet_size) += length_size;
398
399 if (body_size < 13) {
400 ecryptfs_printk(KERN_WARNING, "Invalid body size ([%d])\n",
401 body_size);
402 rc = -EINVAL;
403 goto out;
404 }
405 /* We have 13 bytes of surrounding packet values */
406 (*tag_11_contents_size) = (body_size - 13);
407
408 /* now we know the length of the remainting Tag 11 packet size:
409 * 14 fix bytes for: special flag one, special flag two,
410 * 12 skipped bytes
411 * body_size bytes minus the stuff above is the Tag 11 content
412 */
413 /* FIXME why is the body size one byte smaller than the actual
414 * size of the body?
415 * this seems to be an error here as well as in
416 * write_tag_11_packet() */
417 if (unlikely((*packet_size) + body_size + 1 > max_packet_size)) {
418 ecryptfs_printk(KERN_ERR, "Packet size exceeds max\n");
419 rc = -EINVAL;
420 goto out;
421 }
422
423 /* special flag one - one byte */
424 if (data[(*packet_size)++] != 0x62) {
425 ecryptfs_printk(KERN_WARNING, "Unrecognizable packet\n");
426 rc = -EINVAL;
427 goto out;
428 }
429
430 /* special flag two - one byte */
431 if (data[(*packet_size)++] != 0x08) {
432 ecryptfs_printk(KERN_WARNING, "Unrecognizable packet\n");
433 rc = -EINVAL;
434 goto out;
435 }
436
437 /* skip the next 12 bytes */
438 (*packet_size) += 12; /* We don't care about the filename or
439 * the timestamp */
440
441 /* get the Tag 11 contents - tag_11_contents_size bytes */
442 memcpy(contents, &data[(*packet_size)], (*tag_11_contents_size));
443 (*packet_size) += (*tag_11_contents_size);
444
445 out:
446 if (rc) {
447 (*packet_size) = 0;
448 (*tag_11_contents_size) = 0;
449 }
450 return rc;
451 }
452
453 /**
454 * decrypt_session_key - Decrypt the session key with the given auth_tok.
455 *
456 * Returns Zero on success; non-zero error otherwise.
457 */
458 static int decrypt_session_key(struct ecryptfs_auth_tok *auth_tok,
459 struct ecryptfs_crypt_stat *crypt_stat)
460 {
461 struct ecryptfs_password *password_s_ptr;
462 struct scatterlist src_sg[2], dst_sg[2];
463 struct mutex *tfm_mutex = NULL;
464 /* TODO: Use virt_to_scatterlist for these */
465 char *encrypted_session_key;
466 char *session_key;
467 struct blkcipher_desc desc = {
468 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
469 };
470 int rc = 0;
471
472 password_s_ptr = &auth_tok->token.password;
473 if (ECRYPTFS_CHECK_FLAG(password_s_ptr->flags,
474 ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET))
475 ecryptfs_printk(KERN_DEBUG, "Session key encryption key "
476 "set; skipping key generation\n");
477 ecryptfs_printk(KERN_DEBUG, "Session key encryption key (size [%d])"
478 ":\n",
479 password_s_ptr->session_key_encryption_key_bytes);
480 if (ecryptfs_verbosity > 0)
481 ecryptfs_dump_hex(password_s_ptr->session_key_encryption_key,
482 password_s_ptr->
483 session_key_encryption_key_bytes);
484 if (!strcmp(crypt_stat->cipher,
485 crypt_stat->mount_crypt_stat->global_default_cipher_name)
486 && crypt_stat->mount_crypt_stat->global_key_tfm) {
487 desc.tfm = crypt_stat->mount_crypt_stat->global_key_tfm;
488 tfm_mutex = &crypt_stat->mount_crypt_stat->global_key_tfm_mutex;
489 } else {
490 char *full_alg_name;
491
492 rc = ecryptfs_crypto_api_algify_cipher_name(&full_alg_name,
493 crypt_stat->cipher,
494 "ecb");
495 if (rc)
496 goto out;
497 desc.tfm = crypto_alloc_blkcipher(full_alg_name, 0,
498 CRYPTO_ALG_ASYNC);
499 kfree(full_alg_name);
500 if (IS_ERR(desc.tfm)) {
501 rc = PTR_ERR(desc.tfm);
502 printk(KERN_ERR "Error allocating crypto context; "
503 "rc = [%d]\n", rc);
504 goto out;
505 }
506 crypto_blkcipher_set_flags(desc.tfm, CRYPTO_TFM_REQ_WEAK_KEY);
507 }
508 if (tfm_mutex)
509 mutex_lock(tfm_mutex);
510 rc = crypto_blkcipher_setkey(desc.tfm,
511 password_s_ptr->session_key_encryption_key,
512 crypt_stat->key_size);
513 if (rc < 0) {
514 printk(KERN_ERR "Error setting key for crypto context\n");
515 rc = -EINVAL;
516 goto out_free_tfm;
517 }
518 /* TODO: virt_to_scatterlist */
519 encrypted_session_key = (char *)__get_free_page(GFP_KERNEL);
520 if (!encrypted_session_key) {
521 ecryptfs_printk(KERN_ERR, "Out of memory\n");
522 rc = -ENOMEM;
523 goto out_free_tfm;
524 }
525 session_key = (char *)__get_free_page(GFP_KERNEL);
526 if (!session_key) {
527 kfree(encrypted_session_key);
528 ecryptfs_printk(KERN_ERR, "Out of memory\n");
529 rc = -ENOMEM;
530 goto out_free_tfm;
531 }
532 memcpy(encrypted_session_key, auth_tok->session_key.encrypted_key,
533 auth_tok->session_key.encrypted_key_size);
534 src_sg[0].page = virt_to_page(encrypted_session_key);
535 src_sg[0].offset = 0;
536 BUG_ON(auth_tok->session_key.encrypted_key_size > PAGE_CACHE_SIZE);
537 src_sg[0].length = auth_tok->session_key.encrypted_key_size;
538 dst_sg[0].page = virt_to_page(session_key);
539 dst_sg[0].offset = 0;
540 auth_tok->session_key.decrypted_key_size =
541 auth_tok->session_key.encrypted_key_size;
542 dst_sg[0].length = auth_tok->session_key.encrypted_key_size;
543 rc = crypto_blkcipher_decrypt(&desc, dst_sg, src_sg,
544 auth_tok->session_key.encrypted_key_size);
545 if (rc) {
546 printk(KERN_ERR "Error decrypting; rc = [%d]\n", rc);
547 goto out_free_memory;
548 }
549 auth_tok->session_key.decrypted_key_size =
550 auth_tok->session_key.encrypted_key_size;
551 memcpy(auth_tok->session_key.decrypted_key, session_key,
552 auth_tok->session_key.decrypted_key_size);
553 auth_tok->session_key.flags |= ECRYPTFS_CONTAINS_DECRYPTED_KEY;
554 memcpy(crypt_stat->key, auth_tok->session_key.decrypted_key,
555 auth_tok->session_key.decrypted_key_size);
556 ECRYPTFS_SET_FLAG(crypt_stat->flags, ECRYPTFS_KEY_VALID);
557 ecryptfs_printk(KERN_DEBUG, "Decrypted session key:\n");
558 if (ecryptfs_verbosity > 0)
559 ecryptfs_dump_hex(crypt_stat->key,
560 crypt_stat->key_size);
561 out_free_memory:
562 memset(encrypted_session_key, 0, PAGE_CACHE_SIZE);
563 free_page((unsigned long)encrypted_session_key);
564 memset(session_key, 0, PAGE_CACHE_SIZE);
565 free_page((unsigned long)session_key);
566 out_free_tfm:
567 if (tfm_mutex)
568 mutex_unlock(tfm_mutex);
569 else
570 crypto_free_blkcipher(desc.tfm);
571 out:
572 return rc;
573 }
574
575 /**
576 * ecryptfs_parse_packet_set
577 * @dest: The header page in memory
578 * @version: Version of file format, to guide parsing behavior
579 *
580 * Get crypt_stat to have the file's session key if the requisite key
581 * is available to decrypt the session key.
582 *
583 * Returns Zero if a valid authentication token was retrieved and
584 * processed; negative value for file not encrypted or for error
585 * conditions.
586 */
587 int ecryptfs_parse_packet_set(struct ecryptfs_crypt_stat *crypt_stat,
588 unsigned char *src,
589 struct dentry *ecryptfs_dentry)
590 {
591 size_t i = 0;
592 int rc = 0;
593 size_t found_auth_tok = 0;
594 size_t next_packet_is_auth_tok_packet;
595 char sig[ECRYPTFS_SIG_SIZE_HEX];
596 struct list_head auth_tok_list;
597 struct list_head *walker;
598 struct ecryptfs_auth_tok *chosen_auth_tok = NULL;
599 struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
600 &ecryptfs_superblock_to_private(
601 ecryptfs_dentry->d_sb)->mount_crypt_stat;
602 struct ecryptfs_auth_tok *candidate_auth_tok = NULL;
603 size_t packet_size;
604 struct ecryptfs_auth_tok *new_auth_tok;
605 unsigned char sig_tmp_space[ECRYPTFS_SIG_SIZE];
606 size_t tag_11_contents_size;
607 size_t tag_11_packet_size;
608
609 INIT_LIST_HEAD(&auth_tok_list);
610 /* Parse the header to find as many packets as we can, these will be
611 * added the our &auth_tok_list */
612 next_packet_is_auth_tok_packet = 1;
613 while (next_packet_is_auth_tok_packet) {
614 size_t max_packet_size = ((PAGE_CACHE_SIZE - 8) - i);
615
616 switch (src[i]) {
617 case ECRYPTFS_TAG_3_PACKET_TYPE:
618 rc = parse_tag_3_packet(crypt_stat,
619 (unsigned char *)&src[i],
620 &auth_tok_list, &new_auth_tok,
621 &packet_size, max_packet_size);
622 if (rc) {
623 ecryptfs_printk(KERN_ERR, "Error parsing "
624 "tag 3 packet\n");
625 rc = -EIO;
626 goto out_wipe_list;
627 }
628 i += packet_size;
629 rc = parse_tag_11_packet((unsigned char *)&src[i],
630 sig_tmp_space,
631 ECRYPTFS_SIG_SIZE,
632 &tag_11_contents_size,
633 &tag_11_packet_size,
634 max_packet_size);
635 if (rc) {
636 ecryptfs_printk(KERN_ERR, "No valid "
637 "(ecryptfs-specific) literal "
638 "packet containing "
639 "authentication token "
640 "signature found after "
641 "tag 3 packet\n");
642 rc = -EIO;
643 goto out_wipe_list;
644 }
645 i += tag_11_packet_size;
646 if (ECRYPTFS_SIG_SIZE != tag_11_contents_size) {
647 ecryptfs_printk(KERN_ERR, "Expected "
648 "signature of size [%d]; "
649 "read size [%d]\n",
650 ECRYPTFS_SIG_SIZE,
651 tag_11_contents_size);
652 rc = -EIO;
653 goto out_wipe_list;
654 }
655 ecryptfs_to_hex(new_auth_tok->token.password.signature,
656 sig_tmp_space, tag_11_contents_size);
657 new_auth_tok->token.password.signature[
658 ECRYPTFS_PASSWORD_SIG_SIZE] = '\0';
659 ECRYPTFS_SET_FLAG(crypt_stat->flags,
660 ECRYPTFS_ENCRYPTED);
661 break;
662 case ECRYPTFS_TAG_11_PACKET_TYPE:
663 ecryptfs_printk(KERN_WARNING, "Invalid packet set "
664 "(Tag 11 not allowed by itself)\n");
665 rc = -EIO;
666 goto out_wipe_list;
667 break;
668 default:
669 ecryptfs_printk(KERN_DEBUG, "No packet at offset "
670 "[%d] of the file header; hex value of "
671 "character is [0x%.2x]\n", i, src[i]);
672 next_packet_is_auth_tok_packet = 0;
673 }
674 }
675 if (list_empty(&auth_tok_list)) {
676 rc = -EINVAL; /* Do not support non-encrypted files in
677 * the 0.1 release */
678 goto out;
679 }
680 /* If we have a global auth tok, then we should try to use
681 * it */
682 if (mount_crypt_stat->global_auth_tok) {
683 memcpy(sig, mount_crypt_stat->global_auth_tok_sig,
684 ECRYPTFS_SIG_SIZE_HEX);
685 chosen_auth_tok = mount_crypt_stat->global_auth_tok;
686 } else
687 BUG(); /* We should always have a global auth tok in
688 * the 0.1 release */
689 /* Scan list to see if our chosen_auth_tok works */
690 list_for_each(walker, &auth_tok_list) {
691 struct ecryptfs_auth_tok_list_item *auth_tok_list_item;
692 auth_tok_list_item =
693 list_entry(walker, struct ecryptfs_auth_tok_list_item,
694 list);
695 candidate_auth_tok = &auth_tok_list_item->auth_tok;
696 if (unlikely(ecryptfs_verbosity > 0)) {
697 ecryptfs_printk(KERN_DEBUG,
698 "Considering cadidate auth tok:\n");
699 ecryptfs_dump_auth_tok(candidate_auth_tok);
700 }
701 /* TODO: Replace ECRYPTFS_SIG_SIZE_HEX w/ dynamic value */
702 if (candidate_auth_tok->token_type == ECRYPTFS_PASSWORD
703 && !strncmp(candidate_auth_tok->token.password.signature,
704 sig, ECRYPTFS_SIG_SIZE_HEX)) {
705 found_auth_tok = 1;
706 goto leave_list;
707 /* TODO: Transfer the common salt into the
708 * crypt_stat salt */
709 }
710 }
711 leave_list:
712 if (!found_auth_tok) {
713 ecryptfs_printk(KERN_ERR, "Could not find authentication "
714 "token on temporary list for sig [%.*s]\n",
715 ECRYPTFS_SIG_SIZE_HEX, sig);
716 rc = -EIO;
717 goto out_wipe_list;
718 } else {
719 memcpy(&(candidate_auth_tok->token.password),
720 &(chosen_auth_tok->token.password),
721 sizeof(struct ecryptfs_password));
722 rc = decrypt_session_key(candidate_auth_tok, crypt_stat);
723 if (rc) {
724 ecryptfs_printk(KERN_ERR, "Error decrypting the "
725 "session key\n");
726 goto out_wipe_list;
727 }
728 rc = ecryptfs_compute_root_iv(crypt_stat);
729 if (rc) {
730 ecryptfs_printk(KERN_ERR, "Error computing "
731 "the root IV\n");
732 goto out_wipe_list;
733 }
734 }
735 rc = ecryptfs_init_crypt_ctx(crypt_stat);
736 if (rc) {
737 ecryptfs_printk(KERN_ERR, "Error initializing crypto "
738 "context for cipher [%s]; rc = [%d]\n",
739 crypt_stat->cipher, rc);
740 }
741 out_wipe_list:
742 wipe_auth_tok_list(&auth_tok_list);
743 out:
744 return rc;
745 }
746
747 /**
748 * write_tag_11_packet
749 * @dest: Target into which Tag 11 packet is to be written
750 * @max: Maximum packet length
751 * @contents: Byte array of contents to copy in
752 * @contents_length: Number of bytes in contents
753 * @packet_length: Length of the Tag 11 packet written; zero on error
754 *
755 * Returns zero on success; non-zero on error.
756 */
757 static int
758 write_tag_11_packet(char *dest, int max, char *contents, size_t contents_length,
759 size_t *packet_length)
760 {
761 int rc = 0;
762 size_t packet_size_length;
763
764 (*packet_length) = 0;
765 if ((13 + contents_length) > max) {
766 rc = -EINVAL;
767 ecryptfs_printk(KERN_ERR, "Packet length larger than "
768 "maximum allowable\n");
769 goto out;
770 }
771 /* General packet header */
772 /* Packet tag */
773 dest[(*packet_length)++] = ECRYPTFS_TAG_11_PACKET_TYPE;
774 /* Packet length */
775 rc = write_packet_length(&dest[(*packet_length)],
776 (13 + contents_length), &packet_size_length);
777 if (rc) {
778 ecryptfs_printk(KERN_ERR, "Error generating tag 11 packet "
779 "header; cannot generate packet length\n");
780 goto out;
781 }
782 (*packet_length) += packet_size_length;
783 /* Tag 11 specific */
784 /* One-octet field that describes how the data is formatted */
785 dest[(*packet_length)++] = 0x62; /* binary data */
786 /* One-octet filename length followed by filename */
787 dest[(*packet_length)++] = 8;
788 memcpy(&dest[(*packet_length)], "_CONSOLE", 8);
789 (*packet_length) += 8;
790 /* Four-octet number indicating modification date */
791 memset(&dest[(*packet_length)], 0x00, 4);
792 (*packet_length) += 4;
793 /* Remainder is literal data */
794 memcpy(&dest[(*packet_length)], contents, contents_length);
795 (*packet_length) += contents_length;
796 out:
797 if (rc)
798 (*packet_length) = 0;
799 return rc;
800 }
801
802 /**
803 * write_tag_3_packet
804 * @dest: Buffer into which to write the packet
805 * @max: Maximum number of bytes that can be written
806 * @auth_tok: Authentication token
807 * @crypt_stat: The cryptographic context
808 * @key_rec: encrypted key
809 * @packet_size: This function will write the number of bytes that end
810 * up constituting the packet; set to zero on error
811 *
812 * Returns zero on success; non-zero on error.
813 */
814 static int
815 write_tag_3_packet(char *dest, size_t max, struct ecryptfs_auth_tok *auth_tok,
816 struct ecryptfs_crypt_stat *crypt_stat,
817 struct ecryptfs_key_record *key_rec, size_t *packet_size)
818 {
819 size_t i;
820 size_t signature_is_valid = 0;
821 size_t encrypted_session_key_valid = 0;
822 char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
823 struct scatterlist dest_sg[2];
824 struct scatterlist src_sg[2];
825 struct mutex *tfm_mutex = NULL;
826 size_t key_rec_size;
827 size_t packet_size_length;
828 size_t cipher_code;
829 struct blkcipher_desc desc = {
830 .tfm = NULL,
831 .flags = CRYPTO_TFM_REQ_MAY_SLEEP
832 };
833 int rc = 0;
834
835 (*packet_size) = 0;
836 /* Check for a valid signature on the auth_tok */
837 for (i = 0; i < ECRYPTFS_SIG_SIZE_HEX; i++)
838 signature_is_valid |= auth_tok->token.password.signature[i];
839 if (!signature_is_valid)
840 BUG();
841 ecryptfs_from_hex((*key_rec).sig, auth_tok->token.password.signature,
842 ECRYPTFS_SIG_SIZE);
843 encrypted_session_key_valid = 0;
844 for (i = 0; i < crypt_stat->key_size; i++)
845 encrypted_session_key_valid |=
846 auth_tok->session_key.encrypted_key[i];
847 if (encrypted_session_key_valid) {
848 memcpy((*key_rec).enc_key,
849 auth_tok->session_key.encrypted_key,
850 auth_tok->session_key.encrypted_key_size);
851 goto encrypted_session_key_set;
852 }
853 if (auth_tok->session_key.encrypted_key_size == 0)
854 auth_tok->session_key.encrypted_key_size =
855 crypt_stat->key_size;
856 if (crypt_stat->key_size == 24
857 && strcmp("aes", crypt_stat->cipher) == 0) {
858 memset((crypt_stat->key + 24), 0, 8);
859 auth_tok->session_key.encrypted_key_size = 32;
860 }
861 (*key_rec).enc_key_size =
862 auth_tok->session_key.encrypted_key_size;
863 if (ECRYPTFS_CHECK_FLAG(auth_tok->token.password.flags,
864 ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET)) {
865 ecryptfs_printk(KERN_DEBUG, "Using previously generated "
866 "session key encryption key of size [%d]\n",
867 auth_tok->token.password.
868 session_key_encryption_key_bytes);
869 memcpy(session_key_encryption_key,
870 auth_tok->token.password.session_key_encryption_key,
871 crypt_stat->key_size);
872 ecryptfs_printk(KERN_DEBUG,
873 "Cached session key " "encryption key: \n");
874 if (ecryptfs_verbosity > 0)
875 ecryptfs_dump_hex(session_key_encryption_key, 16);
876 }
877 if (unlikely(ecryptfs_verbosity > 0)) {
878 ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");
879 ecryptfs_dump_hex(session_key_encryption_key, 16);
880 }
881 rc = virt_to_scatterlist(crypt_stat->key,
882 (*key_rec).enc_key_size, src_sg, 2);
883 if (!rc) {
884 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
885 "for crypt_stat session key\n");
886 rc = -ENOMEM;
887 goto out;
888 }
889 rc = virt_to_scatterlist((*key_rec).enc_key,
890 (*key_rec).enc_key_size, dest_sg, 2);
891 if (!rc) {
892 ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
893 "for crypt_stat encrypted session key\n");
894 rc = -ENOMEM;
895 goto out;
896 }
897 if (!strcmp(crypt_stat->cipher,
898 crypt_stat->mount_crypt_stat->global_default_cipher_name)
899 && crypt_stat->mount_crypt_stat->global_key_tfm) {
900 desc.tfm = crypt_stat->mount_crypt_stat->global_key_tfm;
901 tfm_mutex = &crypt_stat->mount_crypt_stat->global_key_tfm_mutex;
902 } else {
903 char *full_alg_name;
904
905 rc = ecryptfs_crypto_api_algify_cipher_name(&full_alg_name,
906 crypt_stat->cipher,
907 "ecb");
908 if (rc)
909 goto out;
910 desc.tfm = crypto_alloc_blkcipher(full_alg_name, 0,
911 CRYPTO_ALG_ASYNC);
912 kfree(full_alg_name);
913 if (IS_ERR(desc.tfm)) {
914 rc = PTR_ERR(desc.tfm);
915 ecryptfs_printk(KERN_ERR, "Could not initialize crypto "
916 "context for cipher [%s]; rc = [%d]\n",
917 crypt_stat->cipher, rc);
918 goto out;
919 }
920 crypto_blkcipher_set_flags(desc.tfm, CRYPTO_TFM_REQ_WEAK_KEY);
921 }
922 if (tfm_mutex)
923 mutex_lock(tfm_mutex);
924 rc = crypto_blkcipher_setkey(desc.tfm, session_key_encryption_key,
925 crypt_stat->key_size);
926 if (rc < 0) {
927 if (tfm_mutex)
928 mutex_unlock(tfm_mutex);
929 ecryptfs_printk(KERN_ERR, "Error setting key for crypto "
930 "context; rc = [%d]\n", rc);
931 goto out;
932 }
933 rc = 0;
934 ecryptfs_printk(KERN_DEBUG, "Encrypting [%d] bytes of the key\n",
935 crypt_stat->key_size);
936 rc = crypto_blkcipher_encrypt(&desc, dest_sg, src_sg,
937 (*key_rec).enc_key_size);
938 if (rc) {
939 printk(KERN_ERR "Error encrypting; rc = [%d]\n", rc);
940 goto out;
941 }
942 if (tfm_mutex)
943 mutex_unlock(tfm_mutex);
944 ecryptfs_printk(KERN_DEBUG, "This should be the encrypted key:\n");
945 if (ecryptfs_verbosity > 0)
946 ecryptfs_dump_hex((*key_rec).enc_key,
947 (*key_rec).enc_key_size);
948 encrypted_session_key_set:
949 /* Now we have a valid key_rec. Append it to the
950 * key_rec set. */
951 key_rec_size = (sizeof(struct ecryptfs_key_record)
952 - ECRYPTFS_MAX_ENCRYPTED_KEY_BYTES
953 + ((*key_rec).enc_key_size));
954 /* TODO: Include a packet size limit as a parameter to this
955 * function once we have multi-packet headers (for versions
956 * later than 0.1 */
957 if (key_rec_size >= ECRYPTFS_MAX_KEYSET_SIZE) {
958 ecryptfs_printk(KERN_ERR, "Keyset too large\n");
959 rc = -EINVAL;
960 goto out;
961 }
962 /* TODO: Packet size limit */
963 /* We have 5 bytes of surrounding packet data */
964 if ((0x05 + ECRYPTFS_SALT_SIZE
965 + (*key_rec).enc_key_size) >= max) {
966 ecryptfs_printk(KERN_ERR, "Authentication token is too "
967 "large\n");
968 rc = -EINVAL;
969 goto out;
970 }
971 /* This format is inspired by OpenPGP; see RFC 2440
972 * packet tag 3 */
973 dest[(*packet_size)++] = ECRYPTFS_TAG_3_PACKET_TYPE;
974 /* ver+cipher+s2k+hash+salt+iter+enc_key */
975 rc = write_packet_length(&dest[(*packet_size)],
976 (0x05 + ECRYPTFS_SALT_SIZE
977 + (*key_rec).enc_key_size),
978 &packet_size_length);
979 if (rc) {
980 ecryptfs_printk(KERN_ERR, "Error generating tag 3 packet "
981 "header; cannot generate packet length\n");
982 goto out;
983 }
984 (*packet_size) += packet_size_length;
985 dest[(*packet_size)++] = 0x04; /* version 4 */
986 cipher_code = ecryptfs_code_for_cipher_string(crypt_stat);
987 if (cipher_code == 0) {
988 ecryptfs_printk(KERN_WARNING, "Unable to generate code for "
989 "cipher [%s]\n", crypt_stat->cipher);
990 rc = -EINVAL;
991 goto out;
992 }
993 dest[(*packet_size)++] = cipher_code;
994 dest[(*packet_size)++] = 0x03; /* S2K */
995 dest[(*packet_size)++] = 0x01; /* MD5 (TODO: parameterize) */
996 memcpy(&dest[(*packet_size)], auth_tok->token.password.salt,
997 ECRYPTFS_SALT_SIZE);
998 (*packet_size) += ECRYPTFS_SALT_SIZE; /* salt */
999 dest[(*packet_size)++] = 0x60; /* hash iterations (65536) */
1000 memcpy(&dest[(*packet_size)], (*key_rec).enc_key,
1001 (*key_rec).enc_key_size);
1002 (*packet_size) += (*key_rec).enc_key_size;
1003 out:
1004 if (desc.tfm && !tfm_mutex)
1005 crypto_free_blkcipher(desc.tfm);
1006 if (rc)
1007 (*packet_size) = 0;
1008 return rc;
1009 }
1010
1011 /**
1012 * ecryptfs_generate_key_packet_set
1013 * @dest: Virtual address from which to write the key record set
1014 * @crypt_stat: The cryptographic context from which the
1015 * authentication tokens will be retrieved
1016 * @ecryptfs_dentry: The dentry, used to retrieve the mount crypt stat
1017 * for the global parameters
1018 * @len: The amount written
1019 * @max: The maximum amount of data allowed to be written
1020 *
1021 * Generates a key packet set and writes it to the virtual address
1022 * passed in.
1023 *
1024 * Returns zero on success; non-zero on error.
1025 */
1026 int
1027 ecryptfs_generate_key_packet_set(char *dest_base,
1028 struct ecryptfs_crypt_stat *crypt_stat,
1029 struct dentry *ecryptfs_dentry, size_t *len,
1030 size_t max)
1031 {
1032 int rc = 0;
1033 struct ecryptfs_auth_tok *auth_tok;
1034 struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
1035 &ecryptfs_superblock_to_private(
1036 ecryptfs_dentry->d_sb)->mount_crypt_stat;
1037 size_t written;
1038 struct ecryptfs_key_record key_rec;
1039
1040 (*len) = 0;
1041 if (mount_crypt_stat->global_auth_tok) {
1042 auth_tok = mount_crypt_stat->global_auth_tok;
1043 if (auth_tok->token_type == ECRYPTFS_PASSWORD) {
1044 rc = write_tag_3_packet((dest_base + (*len)),
1045 max, auth_tok,
1046 crypt_stat, &key_rec,
1047 &written);
1048 if (rc) {
1049 ecryptfs_printk(KERN_WARNING, "Error "
1050 "writing tag 3 packet\n");
1051 goto out;
1052 }
1053 (*len) += written;
1054 /* Write auth tok signature packet */
1055 rc = write_tag_11_packet(
1056 (dest_base + (*len)),
1057 (max - (*len)),
1058 key_rec.sig, ECRYPTFS_SIG_SIZE, &written);
1059 if (rc) {
1060 ecryptfs_printk(KERN_ERR, "Error writing "
1061 "auth tok signature packet\n");
1062 goto out;
1063 }
1064 (*len) += written;
1065 } else {
1066 ecryptfs_printk(KERN_WARNING, "Unsupported "
1067 "authentication token type\n");
1068 rc = -EINVAL;
1069 goto out;
1070 }
1071 if (rc) {
1072 ecryptfs_printk(KERN_WARNING, "Error writing "
1073 "authentication token packet with sig "
1074 "= [%s]\n",
1075 mount_crypt_stat->global_auth_tok_sig);
1076 rc = -EIO;
1077 goto out;
1078 }
1079 } else
1080 BUG();
1081 if (likely((max - (*len)) > 0)) {
1082 dest_base[(*len)] = 0x00;
1083 } else {
1084 ecryptfs_printk(KERN_ERR, "Error writing boundary byte\n");
1085 rc = -EIO;
1086 }
1087 out:
1088 if (rc)
1089 (*len) = 0;
1090 return rc;
1091 }
kernel source for telekom puls (alcatel/mediatek)