1 /*
2 * f2fscrypt.c - f2fs encryption management utility
3 *
4 * Authors: Kinglong Mee <[email protected]>
5 *
6 * Copied from e4crypt that for ext4 filesystem.
7 * Authors: Michael Halcrow <[email protected]>,
8 * Ildar Muslukhov <[email protected]>
9 */
10 #ifndef _GNU_SOURCE
11 #define _GNU_SOURCE
12 #endif
13
14 #include <f2fs_fs.h>
15
16 #include <assert.h>
17 #include <errno.h>
18 #include <getopt.h>
19 #include <dirent.h>
20 #include <errno.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #ifdef HAVE_MNTENT_H
26 #include <mntent.h>
27 #endif
28 #include <sys/ioctl.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include <fcntl.h>
32 #include <termios.h>
33 #include <unistd.h>
34 #include <signal.h>
35 #ifdef __KERNEL__
36 #include <linux/fs.h>
37 #endif
38
39 #ifdef HAVE_UUID_UUID_H
40 #include <uuid/uuid.h>
41 #else
42 typedef unsigned char uuid_t[16];
43 #endif
44
45 #if !defined(HAVE_ADD_KEY) || !defined(HAVE_KEYCTL)
46 #include <sys/syscall.h>
47 #endif
48 #ifdef HAVE_SYS_KEY_H
49 #include <sys/key.h>
50 #endif
51
52 #define F2FS_MAX_KEY_SIZE 64
53 #define F2FS_MAX_PASSPHRASE_SIZE 1024
54 #define F2FS_MAX_SALT_SIZE 256
55
56 /* Encryption algorithms, key size and key reference len */
57 #define F2FS_ENCRYPTION_MODE_INVALID 0
58 #define F2FS_ENCRYPTION_MODE_AES_256_XTS 1
59 #define F2FS_ENCRYPTION_MODE_AES_256_GCM 2
60 #define F2FS_ENCRYPTION_MODE_AES_256_CBC 3
61 #define F2FS_ENCRYPTION_MODE_AES_256_CTS 4
62
63 #define F2FS_AES_256_XTS_KEY_SIZE 64
64 #define F2FS_AES_256_GCM_KEY_SIZE 32
65 #define F2FS_AES_256_CBC_KEY_SIZE 32
66 #define F2FS_AES_256_CTS_KEY_SIZE 32
67 #define F2FS_MAX_KEY_SIZE 64
68
69 /* Password derivation constants */
70 #define F2FS_MAX_PASSPHRASE_SIZE 1024
71 #define F2FS_MAX_SALT_SIZE 256
72 #define F2FS_PBKDF2_ITERATIONS 0xFFFF
73
74 /* special process keyring shortcut IDs */
75 #define KEY_SPEC_THREAD_KEYRING -1
76 #define KEY_SPEC_PROCESS_KEYRING -2
77 #define KEY_SPEC_SESSION_KEYRING -3
78 #define KEY_SPEC_USER_KEYRING -4
79 #define KEY_SPEC_USER_SESSION_KEYRING -5
80 #define KEY_SPEC_GROUP_KEYRING -6
81
82 #define KEYCTL_GET_KEYRING_ID 0
83 #define KEYCTL_JOIN_SESSION_KEYRING 1
84 #define KEYCTL_DESCRIBE 6
85 #define KEYCTL_SEARCH 10
86 #define KEYCTL_SESSION_TO_PARENT 18
87
88 /*
89 * File system encryption support
90 */
91 /* Policy provided via an ioctl on the topmost directory */
92 #define F2FS_KEY_DESCRIPTOR_SIZE 8
93 #define F2FS_KEY_REF_STR_BUF_SIZE ((F2FS_KEY_DESCRIPTOR_SIZE * 2) + 1)
94
95 struct f2fs_fscrypt_policy {
96 __u8 version;
97 __u8 contents_encryption_mode;
98 __u8 filenames_encryption_mode;
99 __u8 flags;
100 __u8 master_key_descriptor[F2FS_KEY_DESCRIPTOR_SIZE];
101 };
102
103 static_assert(sizeof(struct f2fs_fscrypt_policy) == 12, "");
104
105 #define F2FS_IOC_SET_ENCRYPTION_POLICY _IOR('f', 19, struct f2fs_fscrypt_policy)
106 #define F2FS_IOC_GET_ENCRYPTION_PWSALT _IOW('f', 20, __u8[16])
107 #define F2FS_IOC_GET_ENCRYPTION_POLICY _IOW('f', 21, struct f2fs_fscrypt_policy)
108
109 typedef int32_t key_serial_t;
110
111
112
113 #define OPT_VERBOSE 0x0001
114 #define OPT_QUIET 0x0002
115
116 struct f2fs_encryption_key {
117 __u32 mode;
118 char raw[F2FS_MAX_KEY_SIZE];
119 __u32 size;
120 };
121
122 static_assert(sizeof(struct f2fs_encryption_key) == 72, "");
123
124 int options;
125
126 extern void f2fs_sha512(const unsigned char *in, unsigned long in_size,
127 unsigned char *out);
128
129 #if !defined(HAVE_KEYCTL)
keyctl(int cmd,...)130 static long keyctl(int cmd, ...)
131 {
132 va_list va;
133 unsigned long arg2, arg3, arg4, arg5;
134
135 va_start(va, cmd);
136 arg2 = va_arg(va, unsigned long);
137 arg3 = va_arg(va, unsigned long);
138 arg4 = va_arg(va, unsigned long);
139 arg5 = va_arg(va, unsigned long);
140 va_end(va);
141 return syscall(__NR_keyctl, cmd, arg2, arg3, arg4, arg5);
142 }
143 #endif
144
145 #if !defined(HAVE_ADD_KEY)
add_key(const char * type,const char * description,const void * payload,size_t plen,key_serial_t keyring)146 static key_serial_t add_key(const char *type, const char *description,
147 const void *payload, size_t plen,
148 key_serial_t keyring)
149 {
150 return syscall(__NR_add_key, type, description, payload,
151 plen, keyring);
152 }
153 #endif
154
155 static const unsigned char *hexchars = (const unsigned char *) "0123456789abcdef";
156 static const size_t hexchars_size = 16;
157
158 #define SHA512_LENGTH 64
159 #define F2FS_KEY_TYPE_LOGON "logon"
160 #define F2FS_KEY_DESC_PREFIX "f2fs:"
161 #define F2FS_KEY_DESC_PREFIX_SIZE 5
162
int_log2(int arg)163 static int int_log2(int arg)
164 {
165 int l = 0;
166
167 arg >>= 1;
168 while (arg) {
169 l++;
170 arg >>= 1;
171 }
172 return l;
173 }
174
validate_paths(int argc,char * argv[],int path_start_index)175 static void validate_paths(int argc, char *argv[], int path_start_index)
176 {
177 int x;
178 int valid = 1;
179 struct stat st;
180
181 for (x = path_start_index; x < argc; x++) {
182 int ret = access(argv[x], W_OK);
183 if (ret) {
184 invalid:
185 perror(argv[x]);
186 valid = 0;
187 continue;
188 }
189 ret = stat(argv[x], &st);
190 if (ret < 0)
191 goto invalid;
192 if (!S_ISDIR(st.st_mode)) {
193 fprintf(stderr, "%s is not a directory\n", argv[x]);
194 goto invalid;
195 }
196 }
197 if (!valid)
198 exit(1);
199 }
200
hex2byte(const char * hex,size_t hex_size,unsigned char * bytes,size_t bytes_size)201 static int hex2byte(const char *hex, size_t hex_size, unsigned char *bytes,
202 size_t bytes_size)
203 {
204 size_t x;
205 unsigned char *h, *l;
206
207 if (hex_size % 2)
208 return -EINVAL;
209 for (x = 0; x < hex_size; x += 2) {
210 h = memchr(hexchars, hex[x], hexchars_size);
211 if (!h)
212 return -EINVAL;
213 l = memchr(hexchars, hex[x + 1], hexchars_size);
214 if (!l)
215 return -EINVAL;
216 if ((x >> 1) >= bytes_size)
217 return -EINVAL;
218 bytes[x >> 1] = (((unsigned char)(h - hexchars) << 4) +
219 (unsigned char)(l - hexchars));
220 }
221 return 0;
222 }
223
224 /*
225 * Salt handling
226 */
227 struct salt {
228 unsigned char *salt;
229 char key_ref_str[F2FS_KEY_REF_STR_BUF_SIZE];
230 unsigned char key_desc[F2FS_KEY_DESCRIPTOR_SIZE];
231 unsigned char key[F2FS_MAX_KEY_SIZE];
232 size_t salt_len;
233 };
234 struct salt *salt_list;
235 unsigned num_salt;
236 unsigned max_salt;
237 char in_passphrase[F2FS_MAX_PASSPHRASE_SIZE];
238
find_by_salt(unsigned char * salt,size_t salt_len)239 static struct salt *find_by_salt(unsigned char *salt, size_t salt_len)
240 {
241 unsigned int i;
242 struct salt *p;
243
244 for (i = 0, p = salt_list; i < num_salt; i++, p++)
245 if ((p->salt_len == salt_len) &&
246 !memcmp(p->salt, salt, salt_len))
247 return p;
248 return NULL;
249 }
250
add_salt(unsigned char * salt,size_t salt_len)251 static void add_salt(unsigned char *salt, size_t salt_len)
252 {
253 if (find_by_salt(salt, salt_len))
254 return;
255 if (num_salt >= max_salt) {
256 max_salt = num_salt + 10;
257 salt_list = realloc(salt_list, max_salt * sizeof(struct salt));
258 if (!salt_list) {
259 fprintf(stderr, "Couldn't allocate salt list\n");
260 exit(1);
261 }
262 }
263 salt_list[num_salt].salt = salt;
264 salt_list[num_salt].salt_len = salt_len;
265 num_salt++;
266 }
267
clear_secrets(void)268 static void clear_secrets(void)
269 {
270 if (salt_list) {
271 memset(salt_list, 0, sizeof(struct salt) * max_salt);
272 free(salt_list);
273 salt_list = NULL;
274 }
275 memset(in_passphrase, 0, sizeof(in_passphrase));
276 }
277
die_signal_handler(int UNUSED (signum),siginfo_t * UNUSED (siginfo),void * UNUSED (context))278 static void die_signal_handler(int UNUSED(signum),
279 siginfo_t *UNUSED(siginfo), void *UNUSED(context))
280 {
281 clear_secrets();
282 exit(-1);
283 }
284
sigcatcher_setup(void)285 static void sigcatcher_setup(void)
286 {
287 struct sigaction sa;
288
289 memset(&sa, 0, sizeof(struct sigaction));
290 sa.sa_sigaction = die_signal_handler;
291 sa.sa_flags = SA_SIGINFO;
292
293 sigaction(SIGHUP, &sa, 0);
294 sigaction(SIGINT, &sa, 0);
295 sigaction(SIGQUIT, &sa, 0);
296 sigaction(SIGFPE, &sa, 0);
297 sigaction(SIGILL, &sa, 0);
298 sigaction(SIGBUS, &sa, 0);
299 sigaction(SIGSEGV, &sa, 0);
300 sigaction(SIGABRT, &sa, 0);
301 sigaction(SIGPIPE, &sa, 0);
302 sigaction(SIGALRM, &sa, 0);
303 sigaction(SIGTERM, &sa, 0);
304 sigaction(SIGUSR1, &sa, 0);
305 sigaction(SIGUSR2, &sa, 0);
306 sigaction(SIGPOLL, &sa, 0);
307 sigaction(SIGPROF, &sa, 0);
308 sigaction(SIGSYS, &sa, 0);
309 sigaction(SIGTRAP, &sa, 0);
310 sigaction(SIGVTALRM, &sa, 0);
311 sigaction(SIGXCPU, &sa, 0);
312 sigaction(SIGXFSZ, &sa, 0);
313 }
314
315
316 #define PARSE_FLAGS_NOTSUPP_OK 0x0001
317 #define PARSE_FLAGS_FORCE_FN 0x0002
318
parse_salt(char * salt_str,int flags)319 static void parse_salt(char *salt_str, int flags)
320 {
321 unsigned char buf[F2FS_MAX_SALT_SIZE];
322 char *cp = salt_str;
323 unsigned char *salt_buf;
324 int fd, ret, salt_len = 0;
325
326 if (flags & PARSE_FLAGS_FORCE_FN)
327 goto salt_from_filename;
328 if (strncmp(cp, "s:", 2) == 0) {
329 cp += 2;
330 salt_len = strlen(cp);
331 if (salt_len >= F2FS_MAX_SALT_SIZE)
332 goto invalid_salt;
333 strncpy((char *) buf, cp, sizeof(buf));
334 } else if (cp[0] == '/') {
335 salt_from_filename:
336 fd = open(cp, O_RDONLY | O_DIRECTORY);
337 if (fd == -1 && errno == ENOTDIR)
338 fd = open(cp, O_RDONLY);
339 if (fd == -1) {
340 perror(cp);
341 exit(1);
342 }
343 ret = ioctl(fd, F2FS_IOC_GET_ENCRYPTION_PWSALT, &buf);
344 close(fd);
345 if (ret < 0) {
346 if (flags & PARSE_FLAGS_NOTSUPP_OK)
347 return;
348 perror("F2FS_IOC_GET_ENCRYPTION_PWSALT");
349 exit(1);
350 }
351 #ifdef HAVE_LIBUUID
352 if (options & OPT_VERBOSE) {
353 char tmp[80];
354 uuid_unparse(buf, tmp);
355 printf("%s has pw salt %s\n", cp, tmp);
356 }
357 #endif
358 salt_len = 16;
359 } else if (strncmp(cp, "f:", 2) == 0) {
360 cp += 2;
361 goto salt_from_filename;
362 } else if (strncmp(cp, "0x", 2) == 0) {
363 unsigned char *h, *l;
364
365 cp += 2;
366 if (strlen(cp) & 1)
367 goto invalid_salt;
368 while (*cp) {
369 if (salt_len >= F2FS_MAX_SALT_SIZE)
370 goto invalid_salt;
371 h = memchr(hexchars, *cp++, hexchars_size);
372 l = memchr(hexchars, *cp++, hexchars_size);
373 if (!h || !l)
374 goto invalid_salt;
375 buf[salt_len++] =
376 (((unsigned char)(h - hexchars) << 4) +
377 (unsigned char)(l - hexchars));
378 }
379 #ifdef HAVE_LIBUUID
380 } else if (uuid_parse(cp, buf) == 0) {
381 salt_len = 16;
382 #endif
383 } else {
384 invalid_salt:
385 fprintf(stderr, "Invalid salt: %s\n", salt_str);
386 exit(1);
387 }
388 salt_buf = malloc(salt_len);
389 if (!salt_buf) {
390 fprintf(stderr, "Couldn't allocate salt\n");
391 exit(1);
392 }
393 memcpy(salt_buf, buf, salt_len);
394 add_salt(salt_buf, salt_len);
395 }
396
set_policy(struct salt * set_salt,int pad,int argc,char * argv[],int path_start_index)397 static void set_policy(struct salt *set_salt, int pad,
398 int argc, char *argv[], int path_start_index)
399 {
400 struct salt *salt;
401 struct f2fs_fscrypt_policy policy;
402 uuid_t uu;
403 int fd;
404 int x;
405 int rc;
406
407 if ((pad != 4) && (pad != 8) &&
408 (pad != 16) && (pad != 32)) {
409 fprintf(stderr, "Invalid padding %d\n", pad);
410 exit(1);
411 }
412
413 for (x = path_start_index; x < argc; x++) {
414 fd = open(argv[x], O_DIRECTORY);
415 if (fd == -1) {
416 perror(argv[x]);
417 exit(1);
418 }
419 if (set_salt)
420 salt = set_salt;
421 else {
422 if (ioctl(fd, F2FS_IOC_GET_ENCRYPTION_PWSALT,
423 &uu) < 0) {
424 perror("F2FS_IOC_GET_ENCRYPTION_PWSALT");
425 exit(1);
426 }
427 salt = find_by_salt(uu, sizeof(uu));
428 if (!salt) {
429 fprintf(stderr, "Couldn't find salt!?!\n");
430 exit(1);
431 }
432 }
433 policy.version = 0;
434 policy.contents_encryption_mode =
435 F2FS_ENCRYPTION_MODE_AES_256_XTS;
436 policy.filenames_encryption_mode =
437 F2FS_ENCRYPTION_MODE_AES_256_CTS;
438 policy.flags = int_log2(pad >> 2);
439 memcpy(policy.master_key_descriptor, salt->key_desc,
440 F2FS_KEY_DESCRIPTOR_SIZE);
441 rc = ioctl(fd, F2FS_IOC_SET_ENCRYPTION_POLICY, &policy);
442 close(fd);
443 if (rc) {
444 printf("Error [%s] setting policy.\nThe key descriptor "
445 "[%s] may not match the existing encryption "
446 "context for directory [%s].\n",
447 strerror(errno), salt->key_ref_str, argv[x]);
448 continue;
449 }
450 printf("Key with descriptor [%s] applied to %s.\n",
451 salt->key_ref_str, argv[x]);
452 }
453 }
454
pbkdf2_sha512(const char * passphrase,struct salt * salt,unsigned int count,unsigned char derived_key[F2FS_MAX_KEY_SIZE])455 static void pbkdf2_sha512(const char *passphrase, struct salt *salt,
456 unsigned int count,
457 unsigned char derived_key[F2FS_MAX_KEY_SIZE])
458 {
459 size_t passphrase_size = strlen(passphrase);
460 unsigned char buf[SHA512_LENGTH + F2FS_MAX_PASSPHRASE_SIZE] = {0};
461 unsigned char tempbuf[SHA512_LENGTH] = {0};
462 char final[SHA512_LENGTH] = {0};
463 unsigned char saltbuf[F2FS_MAX_SALT_SIZE + F2FS_MAX_PASSPHRASE_SIZE] = {0};
464 int actual_buf_len = SHA512_LENGTH + passphrase_size;
465 int actual_saltbuf_len = F2FS_MAX_SALT_SIZE + passphrase_size;
466 unsigned int x, y;
467 __u32 *final_u32 = (__u32 *)final;
468 __u32 *temp_u32 = (__u32 *)tempbuf;
469
470 if (passphrase_size > F2FS_MAX_PASSPHRASE_SIZE) {
471 printf("Passphrase size is %zd; max is %d.\n", passphrase_size,
472 F2FS_MAX_PASSPHRASE_SIZE);
473 exit(1);
474 }
475 if (salt->salt_len > F2FS_MAX_SALT_SIZE) {
476 printf("Salt size is %zd; max is %d.\n", salt->salt_len,
477 F2FS_MAX_SALT_SIZE);
478 exit(1);
479 }
480 assert(F2FS_MAX_KEY_SIZE <= SHA512_LENGTH);
481
482 memcpy(saltbuf, salt->salt, salt->salt_len);
483 memcpy(&saltbuf[F2FS_MAX_SALT_SIZE], passphrase, passphrase_size);
484
485 memcpy(&buf[SHA512_LENGTH], passphrase, passphrase_size);
486
487 for (x = 0; x < count; ++x) {
488 if (x == 0) {
489 f2fs_sha512(saltbuf, actual_saltbuf_len, tempbuf);
490 } else {
491 /*
492 * buf: [previous hash || passphrase]
493 */
494 memcpy(buf, tempbuf, SHA512_LENGTH);
495 f2fs_sha512(buf, actual_buf_len, tempbuf);
496 }
497 for (y = 0; y < (sizeof(final) / sizeof(*final_u32)); ++y)
498 final_u32[y] = final_u32[y] ^ temp_u32[y];
499 }
500 memcpy(derived_key, final, F2FS_MAX_KEY_SIZE);
501 }
502
disable_echo(struct termios * saved_settings)503 static int disable_echo(struct termios *saved_settings)
504 {
505 struct termios current_settings;
506 int rc = 0;
507
508 rc = tcgetattr(0, ¤t_settings);
509 if (rc)
510 return rc;
511 *saved_settings = current_settings;
512 current_settings.c_lflag &= ~ECHO;
513 rc = tcsetattr(0, TCSANOW, ¤t_settings);
514
515 return rc;
516 }
517
get_passphrase(char * passphrase,int len)518 static void get_passphrase(char *passphrase, int len)
519 {
520 char *p;
521 struct termios current_settings;
522
523 assert(len > 0);
524 disable_echo(¤t_settings);
525 p = fgets(passphrase, len, stdin);
526 tcsetattr(0, TCSANOW, ¤t_settings);
527 printf("\n");
528 if (!p) {
529 printf("Aborting.\n");
530 exit(1);
531 }
532 p = strrchr(passphrase, '\n');
533 if (!p)
534 p = passphrase + len - 1;
535 *p = '\0';
536 }
537
538 struct keyring_map {
539 char name[4];
540 size_t name_len;
541 int code;
542 };
543
544 static const struct keyring_map keyrings[] = {
545 {"@us", 3, KEY_SPEC_USER_SESSION_KEYRING},
546 {"@u", 2, KEY_SPEC_USER_KEYRING},
547 {"@s", 2, KEY_SPEC_SESSION_KEYRING},
548 {"@g", 2, KEY_SPEC_GROUP_KEYRING},
549 {"@p", 2, KEY_SPEC_PROCESS_KEYRING},
550 {"@t", 2, KEY_SPEC_THREAD_KEYRING},
551 };
552
get_keyring_id(const char * keyring)553 static int get_keyring_id(const char *keyring)
554 {
555 unsigned int x;
556 char *end;
557
558 /*
559 * If no keyring is specified, by default use either the user
560 * session key ring or the session keyring. Fetching the
561 * session keyring will return the user session keyring if no
562 * session keyring has been set.
563 *
564 * We need to do this instead of simply adding the key to
565 * KEY_SPEC_SESSION_KEYRING since trying to add a key to a
566 * session keyring that does not yet exist will cause the
567 * kernel to create a session keyring --- which wil then get
568 * garbage collected as soon as f2fscrypt exits.
569 *
570 * The fact that the keyctl system call and the add_key system
571 * call treats KEY_SPEC_SESSION_KEYRING differently when a
572 * session keyring does not exist is very unfortunate and
573 * confusing, but so it goes...
574 */
575 if (keyring == NULL)
576 return keyctl(KEYCTL_GET_KEYRING_ID,
577 KEY_SPEC_SESSION_KEYRING, 0);
578 for (x = 0; x < (sizeof(keyrings) / sizeof(keyrings[0])); ++x) {
579 if (strcmp(keyring, keyrings[x].name) == 0) {
580 return keyrings[x].code;
581 }
582 }
583 x = strtoul(keyring, &end, 10);
584 if (*end == '\0') {
585 if (keyctl(KEYCTL_DESCRIBE, x, NULL, 0) < 0)
586 return 0;
587 return x;
588 }
589 return 0;
590 }
591
generate_key_ref_str(struct salt * salt)592 static void generate_key_ref_str(struct salt *salt)
593 {
594 unsigned char key_ref1[SHA512_LENGTH];
595 unsigned char key_ref2[SHA512_LENGTH];
596 int x;
597
598 f2fs_sha512(salt->key, F2FS_MAX_KEY_SIZE, key_ref1);
599 f2fs_sha512(key_ref1, SHA512_LENGTH, key_ref2);
600 memcpy(salt->key_desc, key_ref2, F2FS_KEY_DESCRIPTOR_SIZE);
601 for (x = 0; x < F2FS_KEY_DESCRIPTOR_SIZE; ++x) {
602 sprintf(&salt->key_ref_str[x * 2], "%02x",
603 salt->key_desc[x]);
604 }
605 salt->key_ref_str[F2FS_KEY_REF_STR_BUF_SIZE - 1] = '\0';
606 }
607
insert_key_into_keyring(const char * keyring,struct salt * salt)608 static void insert_key_into_keyring(const char *keyring, struct salt *salt)
609 {
610 int keyring_id = get_keyring_id(keyring);
611 struct f2fs_encryption_key key;
612 char key_ref_full[F2FS_KEY_DESC_PREFIX_SIZE +
613 F2FS_KEY_REF_STR_BUF_SIZE];
614 int rc;
615
616 if (keyring_id == 0) {
617 printf("Invalid keyring [%s].\n", keyring);
618 exit(1);
619 }
620 sprintf(key_ref_full, "%s%s", F2FS_KEY_DESC_PREFIX,
621 salt->key_ref_str);
622 rc = keyctl(KEYCTL_SEARCH, keyring_id, F2FS_KEY_TYPE_LOGON,
623 key_ref_full, 0);
624 if (rc != -1) {
625 if ((options & OPT_QUIET) == 0)
626 printf("Key with descriptor [%s] already exists\n",
627 salt->key_ref_str);
628 return;
629 } else if ((rc == -1) && (errno != ENOKEY)) {
630 printf("keyctl_search failed: %s\n", strerror(errno));
631 if (errno == -EINVAL)
632 printf("Keyring [%s] is not available.\n", keyring);
633 exit(1);
634 }
635 key.mode = F2FS_ENCRYPTION_MODE_AES_256_XTS;
636 memcpy(key.raw, salt->key, F2FS_MAX_KEY_SIZE);
637 key.size = F2FS_MAX_KEY_SIZE;
638 rc = add_key(F2FS_KEY_TYPE_LOGON, key_ref_full, (void *)&key,
639 sizeof(key), keyring_id);
640 if (rc == -1) {
641 if (errno == EDQUOT) {
642 printf("Error adding key to keyring; quota exceeded\n");
643 } else {
644 printf("Error adding key with key descriptor [%s]: "
645 "%s\n", salt->key_ref_str, strerror(errno));
646 }
647 exit(1);
648 } else {
649 if ((options & OPT_QUIET) == 0)
650 printf("Added key with descriptor [%s]\n",
651 salt->key_ref_str);
652 }
653 }
654
get_default_salts(void)655 static void get_default_salts(void)
656 {
657 FILE *f = setmntent("/etc/mtab", "r");
658 struct mntent *mnt;
659
660 while (f && ((mnt = getmntent(f)) != NULL)) {
661 if (strcmp(mnt->mnt_type, "f2fs") ||
662 access(mnt->mnt_dir, R_OK))
663 continue;
664 parse_salt(mnt->mnt_dir, PARSE_FLAGS_NOTSUPP_OK);
665 }
666 endmntent(f);
667 }
668
669 /* Functions which implement user commands */
670
671 struct cmd_desc {
672 const char *cmd_name;
673 void (*cmd_func)(int, char **, const struct cmd_desc *);
674 const char *cmd_desc;
675 const char *cmd_help;
676 int cmd_flags;
677 };
678
679 #define CMD_HIDDEN 0x0001
680
681 static void do_help(int argc, char **argv, const struct cmd_desc *cmd);
682
683 #define add_key_desc "adds a key to the user's keyring"
684 #define add_key_help \
685 "f2fscrypt add_key -S salt [ -k keyring ] [-v] [-q] [ path ... ]\n\n" \
686 "Prompts the user for a passphrase and inserts it into the specified\n" \
687 "keyring. If no keyring is specified, f2fscrypt will use the session\n" \
688 "keyring if it exists or the user session keyring if it does not.\n\n" \
689 "If one or more directory paths are specified, f2fscrypt will try to\n" \
690 "set the policy of those directories to use the key just entered by\n" \
691 "the user.\n"
692
do_add_key(int argc,char ** argv,const struct cmd_desc * cmd)693 static void do_add_key(int argc, char **argv, const struct cmd_desc *cmd)
694 {
695 struct salt *salt;
696 char *keyring = NULL;
697 int i, opt, pad = 4;
698 unsigned j;
699
700 while ((opt = getopt(argc, argv, "k:S:p:vq")) != -1) {
701 switch (opt) {
702 case 'k':
703 /* Specify a keyring. */
704 keyring = optarg;
705 break;
706 case 'p':
707 pad = atoi(optarg);
708 break;
709 case 'S':
710 /* Salt value for passphrase. */
711 parse_salt(optarg, 0);
712 break;
713 case 'v':
714 options |= OPT_VERBOSE;
715 break;
716 case 'q':
717 options |= OPT_QUIET;
718 break;
719 default:
720 fprintf(stderr, "Unrecognized option: %c\n", opt);
721 fallthrough;
722 case '?':
723 fputs("USAGE:\n ", stderr);
724 fputs(cmd->cmd_help, stderr);
725 exit(1);
726 }
727 }
728 if (num_salt == 0)
729 get_default_salts();
730 if (num_salt == 0) {
731 fprintf(stderr, "No salt values available\n");
732 exit(1);
733 }
734 validate_paths(argc, argv, optind);
735 for (i = optind; i < argc; i++)
736 parse_salt(argv[i], PARSE_FLAGS_FORCE_FN);
737 printf("Enter passphrase (echo disabled): ");
738 get_passphrase(in_passphrase, sizeof(in_passphrase));
739 for (j = 0, salt = salt_list; j < num_salt; j++, salt++) {
740 pbkdf2_sha512(in_passphrase, salt,
741 F2FS_PBKDF2_ITERATIONS, salt->key);
742 generate_key_ref_str(salt);
743 insert_key_into_keyring(keyring, salt);
744 }
745 if (optind != argc)
746 set_policy(NULL, pad, argc, argv, optind);
747 clear_secrets();
748 exit(0);
749 }
750
751 #define set_policy_desc "sets a policy for directories"
752 #define set_policy_help \
753 "f2fscrypt set_policy policy path ... \n\n" \
754 "Sets the policy for the directories specified on the command line.\n" \
755 "All directories must be empty to set the policy; if the directory\n" \
756 "already has a policy established, f2fscrypt will validate that it the\n" \
757 "policy matches what was specified. A policy is an encryption key\n" \
758 "identifier consisting of 16 hexadecimal characters.\n"
759
do_set_policy(int argc,char ** argv,const struct cmd_desc * cmd)760 static void do_set_policy(int argc, char **argv, const struct cmd_desc *cmd)
761 {
762 struct salt saltbuf;
763 int c, pad = 4;
764
765 while ((c = getopt (argc, argv, "p:")) != EOF) {
766 switch (c) {
767 case 'p':
768 pad = atoi(optarg);
769 break;
770 }
771 }
772
773 if (argc < optind + 2) {
774 fprintf(stderr, "Missing required argument(s).\n\n");
775 fputs("USAGE:\n ", stderr);
776 fputs(cmd->cmd_help, stderr);
777 exit(1);
778 }
779
780 if ((strlen(argv[optind]) != (F2FS_KEY_DESCRIPTOR_SIZE * 2)) ||
781 hex2byte(argv[optind], (F2FS_KEY_DESCRIPTOR_SIZE * 2),
782 saltbuf.key_desc, F2FS_KEY_DESCRIPTOR_SIZE)) {
783 printf("Invalid key descriptor [%s]. Valid characters "
784 "are 0-9 and a-f, lower case. "
785 "Length must be %d.\n",
786 argv[optind], (F2FS_KEY_DESCRIPTOR_SIZE * 2));
787 exit(1);
788 }
789 validate_paths(argc, argv, optind+1);
790 strcpy(saltbuf.key_ref_str, argv[optind]);
791 set_policy(&saltbuf, pad, argc, argv, optind+1);
792 exit(0);
793 }
794
795 #define get_policy_desc "get the encryption for directories"
796 #define get_policy_help \
797 "f2fscrypt get_policy path ... \n\n" \
798 "Gets the policy for the directories specified on the command line.\n"
799
do_get_policy(int argc,char ** argv,const struct cmd_desc * cmd)800 static void do_get_policy(int argc, char **argv, const struct cmd_desc *cmd)
801 {
802 struct f2fs_fscrypt_policy policy;
803 struct stat st;
804 int i, j, fd, rc;
805
806 if (argc < 2) {
807 fprintf(stderr, "Missing required argument(s).\n\n");
808 fputs("USAGE:\n ", stderr);
809 fputs(cmd->cmd_help, stderr);
810 exit(1);
811 }
812
813 for (i = 1; i < argc; i++) {
814 if (stat(argv[i], &st) < 0) {
815 perror(argv[i]);
816 continue;
817 }
818 fd = open(argv[i],
819 S_ISDIR(st.st_mode) ? O_DIRECTORY : O_RDONLY);
820 if (fd == -1) {
821 perror(argv[i]);
822 exit(1);
823 }
824 rc = ioctl(fd, F2FS_IOC_GET_ENCRYPTION_POLICY, &policy);
825 close(fd);
826 if (rc) {
827 printf("Error getting policy for %s: %s\n",
828 argv[i], strerror(errno));
829 continue;
830 }
831 printf("%s: ", argv[i]);
832 for (j = 0; j < F2FS_KEY_DESCRIPTOR_SIZE; j++) {
833 printf("%02x", (unsigned char) policy.master_key_descriptor[j]);
834 }
835 fputc('\n', stdout);
836 }
837 exit(0);
838 }
839
840 #define new_session_desc "give the invoking process a new session keyring"
841 #define new_session_help \
842 "f2fscrypt new_session\n\n" \
843 "Give the invoking process (typically a shell) a new session keyring,\n" \
844 "discarding its old session keyring.\n"
845
do_new_session(int argc,char ** UNUSED (argv),const struct cmd_desc * cmd)846 static void do_new_session(int argc, char **UNUSED(argv),
847 const struct cmd_desc *cmd)
848 {
849 long keyid, ret;
850
851 if (argc > 1) {
852 fputs("Excess arguments\n\n", stderr);
853 fputs(cmd->cmd_help, stderr);
854 exit(1);
855 }
856 keyid = keyctl(KEYCTL_JOIN_SESSION_KEYRING, NULL);
857 if (keyid < 0) {
858 perror("KEYCTL_JOIN_SESSION_KEYRING");
859 exit(1);
860 }
861 ret = keyctl(KEYCTL_SESSION_TO_PARENT, NULL);
862 if (ret < 0) {
863 perror("KEYCTL_SESSION_TO_PARENT");
864 exit(1);
865 }
866 printf("Switched invoking process to new session keyring %ld\n", keyid);
867 exit(0);
868 }
869
870 #define CMD(name) { #name, do_##name, name##_desc, name##_help, 0 }
871 #define _CMD(name) { #name, do_##name, NULL, NULL, CMD_HIDDEN }
872
873 const struct cmd_desc cmd_list[] = {
874 _CMD(help),
875 CMD(add_key),
876 CMD(get_policy),
877 CMD(new_session),
878 CMD(set_policy),
879 { NULL, NULL, NULL, NULL, 0 }
880 };
881
do_help(int argc,char ** argv,const struct cmd_desc * UNUSED (cmd))882 static void do_help(int argc, char **argv, const struct cmd_desc *UNUSED(cmd))
883 {
884 const struct cmd_desc *p;
885
886 if (argc > 1) {
887 for (p = cmd_list; p->cmd_name; p++) {
888 if (p->cmd_flags & CMD_HIDDEN)
889 continue;
890 if (strcmp(p->cmd_name, argv[1]) == 0) {
891 putc('\n', stdout);
892 fputs("USAGE:\n ", stdout);
893 fputs(p->cmd_help, stdout);
894 exit(0);
895 }
896 }
897 printf("Unknown command: %s\n\n", argv[1]);
898 }
899
900 fputs("Available commands:\n", stdout);
901 for (p = cmd_list; p->cmd_name; p++) {
902 if (p->cmd_flags & CMD_HIDDEN)
903 continue;
904 printf(" %-20s %s\n", p->cmd_name, p->cmd_desc);
905 }
906 printf("\nTo get more information on a command, "
907 "type 'f2fscrypt help cmd'\n");
908 exit(0);
909 }
910
main(int argc,char * argv[])911 int main(int argc, char *argv[])
912 {
913 const struct cmd_desc *cmd;
914
915 if (argc < 2)
916 do_help(argc, argv, cmd_list);
917
918 sigcatcher_setup();
919 for (cmd = cmd_list; cmd->cmd_name; cmd++) {
920 if (strcmp(cmd->cmd_name, argv[1]) == 0) {
921 cmd->cmd_func(argc-1, argv+1, cmd);
922 exit(0);
923 }
924 }
925 printf("Unknown command: %s\n\n", argv[1]);
926 do_help(1, argv, cmd_list);
927 return 0;
928 }
929