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