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