1 /* 2 * CDDL HEADER START 3 * 4 * This file and its contents are supplied under the terms of the 5 * Common Development and Distribution License ("CDDL"), version 1.0. 6 * You may only use this file in accordance with the terms of version 7 * 1.0 of the CDDL. 8 * 9 * A full copy of the text of the CDDL should have accompanied this 10 * source. A copy of the CDDL is also available via the Internet at 11 * http://www.illumos.org/license/CDDL. 12 * 13 * CDDL HEADER END 14 */ 15 16 /* 17 * Copyright (c) 2017, Datto, Inc. All rights reserved. 18 * Copyright 2020 Joyent, Inc. 19 */ 20 21 #include <sys/zfs_context.h> 22 #include <sys/fs/zfs.h> 23 #include <sys/dsl_crypt.h> 24 #include <libintl.h> 25 #include <termios.h> 26 #include <signal.h> 27 #include <errno.h> 28 #include <openssl/evp.h> 29 #if LIBFETCH_DYNAMIC 30 #include <dlfcn.h> 31 #endif 32 #if LIBFETCH_IS_FETCH 33 #include <sys/param.h> 34 #include <stdio.h> 35 #include <fetch.h> 36 #elif LIBFETCH_IS_LIBCURL 37 #include <curl/curl.h> 38 #endif 39 #include <libzfs.h> 40 #include "libzfs_impl.h" 41 #include "zfeature_common.h" 42 43 /* 44 * User keys are used to decrypt the master encryption keys of a dataset. This 45 * indirection allows a user to change his / her access key without having to 46 * re-encrypt the entire dataset. User keys can be provided in one of several 47 * ways. Raw keys are simply given to the kernel as is. Similarly, hex keys 48 * are converted to binary and passed into the kernel. Password based keys are 49 * a bit more complicated. Passwords alone do not provide suitable entropy for 50 * encryption and may be too short or too long to be used. In order to derive 51 * a more appropriate key we use a PBKDF2 function. This function is designed 52 * to take a (relatively) long time to calculate in order to discourage 53 * attackers from guessing from a list of common passwords. PBKDF2 requires 54 * 2 additional parameters. The first is the number of iterations to run, which 55 * will ultimately determine how long it takes to derive the resulting key from 56 * the password. The second parameter is a salt that is randomly generated for 57 * each dataset. The salt is used to "tweak" PBKDF2 such that a group of 58 * attackers cannot reasonably generate a table of commonly known passwords to 59 * their output keys and expect it work for all past and future PBKDF2 users. 60 * We store the salt as a hidden property of the dataset (although it is 61 * technically ok if the salt is known to the attacker). 62 */ 63 64 #define MIN_PASSPHRASE_LEN 8 65 #define MAX_PASSPHRASE_LEN 512 66 #define MAX_KEY_PROMPT_ATTEMPTS 3 67 68 static int caught_interrupt; 69 70 static int get_key_material_file(libzfs_handle_t *, const char *, const char *, 71 zfs_keyformat_t, boolean_t, uint8_t **, size_t *); 72 static int get_key_material_https(libzfs_handle_t *, const char *, const char *, 73 zfs_keyformat_t, boolean_t, uint8_t **, size_t *); 74 75 static zfs_uri_handler_t uri_handlers[] = { 76 { "file", get_key_material_file }, 77 { "https", get_key_material_https }, 78 { "http", get_key_material_https }, 79 { NULL, NULL } 80 }; 81 82 static int 83 pkcs11_get_urandom(uint8_t *buf, size_t bytes) 84 { 85 int rand; 86 ssize_t bytes_read = 0; 87 88 rand = open("/dev/urandom", O_RDONLY | O_CLOEXEC); 89 90 if (rand < 0) 91 return (rand); 92 93 while (bytes_read < bytes) { 94 ssize_t rc = read(rand, buf + bytes_read, bytes - bytes_read); 95 if (rc < 0) 96 break; 97 bytes_read += rc; 98 } 99 100 (void) close(rand); 101 102 return (bytes_read); 103 } 104 105 static int 106 zfs_prop_parse_keylocation(libzfs_handle_t *restrict hdl, const char *str, 107 zfs_keylocation_t *restrict locp, char **restrict schemep) 108 { 109 *locp = ZFS_KEYLOCATION_NONE; 110 *schemep = NULL; 111 112 if (strcmp("prompt", str) == 0) { 113 *locp = ZFS_KEYLOCATION_PROMPT; 114 return (0); 115 } 116 117 regmatch_t pmatch[2]; 118 119 if (regexec(&hdl->libzfs_urire, str, ARRAY_SIZE(pmatch), 120 pmatch, 0) == 0) { 121 size_t scheme_len; 122 123 if (pmatch[1].rm_so == -1) { 124 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 125 "Invalid URI")); 126 return (EINVAL); 127 } 128 129 scheme_len = pmatch[1].rm_eo - pmatch[1].rm_so; 130 131 *schemep = calloc(1, scheme_len + 1); 132 if (*schemep == NULL) { 133 int ret = errno; 134 135 errno = 0; 136 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 137 "Invalid URI")); 138 return (ret); 139 } 140 141 (void) memcpy(*schemep, str + pmatch[1].rm_so, scheme_len); 142 *locp = ZFS_KEYLOCATION_URI; 143 return (0); 144 } 145 146 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Invalid keylocation")); 147 return (EINVAL); 148 } 149 150 static int 151 hex_key_to_raw(char *hex, int hexlen, uint8_t *out) 152 { 153 int ret, i; 154 unsigned int c; 155 156 for (i = 0; i < hexlen; i += 2) { 157 if (!isxdigit(hex[i]) || !isxdigit(hex[i + 1])) { 158 ret = EINVAL; 159 goto error; 160 } 161 162 ret = sscanf(&hex[i], "%02x", &c); 163 if (ret != 1) { 164 ret = EINVAL; 165 goto error; 166 } 167 168 out[i / 2] = c; 169 } 170 171 return (0); 172 173 error: 174 return (ret); 175 } 176 177 178 static void 179 catch_signal(int sig) 180 { 181 caught_interrupt = sig; 182 } 183 184 static const char * 185 get_format_prompt_string(zfs_keyformat_t format) 186 { 187 switch (format) { 188 case ZFS_KEYFORMAT_RAW: 189 return ("raw key"); 190 case ZFS_KEYFORMAT_HEX: 191 return ("hex key"); 192 case ZFS_KEYFORMAT_PASSPHRASE: 193 return ("passphrase"); 194 default: 195 /* shouldn't happen */ 196 return (NULL); 197 } 198 } 199 200 /* do basic validation of the key material */ 201 static int 202 validate_key(libzfs_handle_t *hdl, zfs_keyformat_t keyformat, 203 const char *key, size_t keylen, boolean_t do_verify) 204 { 205 switch (keyformat) { 206 case ZFS_KEYFORMAT_RAW: 207 /* verify the key length is correct */ 208 if (keylen < WRAPPING_KEY_LEN) { 209 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 210 "Raw key too short (expected %u)."), 211 WRAPPING_KEY_LEN); 212 return (EINVAL); 213 } 214 215 if (keylen > WRAPPING_KEY_LEN) { 216 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 217 "Raw key too long (expected %u)."), 218 WRAPPING_KEY_LEN); 219 return (EINVAL); 220 } 221 break; 222 case ZFS_KEYFORMAT_HEX: 223 /* verify the key length is correct */ 224 if (keylen < WRAPPING_KEY_LEN * 2) { 225 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 226 "Hex key too short (expected %u)."), 227 WRAPPING_KEY_LEN * 2); 228 return (EINVAL); 229 } 230 231 if (keylen > WRAPPING_KEY_LEN * 2) { 232 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 233 "Hex key too long (expected %u)."), 234 WRAPPING_KEY_LEN * 2); 235 return (EINVAL); 236 } 237 238 /* check for invalid hex digits */ 239 for (size_t i = 0; i < WRAPPING_KEY_LEN * 2; i++) { 240 if (!isxdigit(key[i])) { 241 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 242 "Invalid hex character detected.")); 243 return (EINVAL); 244 } 245 } 246 break; 247 case ZFS_KEYFORMAT_PASSPHRASE: 248 /* 249 * Verify the length is within bounds when setting a new key, 250 * but not when loading an existing key. 251 */ 252 if (!do_verify) 253 break; 254 if (keylen > MAX_PASSPHRASE_LEN) { 255 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 256 "Passphrase too long (max %u)."), 257 MAX_PASSPHRASE_LEN); 258 return (EINVAL); 259 } 260 261 if (keylen < MIN_PASSPHRASE_LEN) { 262 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 263 "Passphrase too short (min %u)."), 264 MIN_PASSPHRASE_LEN); 265 return (EINVAL); 266 } 267 break; 268 default: 269 /* can't happen, checked above */ 270 break; 271 } 272 273 return (0); 274 } 275 276 static int 277 libzfs_getpassphrase(zfs_keyformat_t keyformat, boolean_t is_reenter, 278 boolean_t new_key, const char *fsname, 279 char **restrict res, size_t *restrict reslen) 280 { 281 FILE *f = stdin; 282 size_t buflen = 0; 283 ssize_t bytes; 284 int ret = 0; 285 struct termios old_term, new_term; 286 struct sigaction act, osigint, osigtstp; 287 288 *res = NULL; 289 *reslen = 0; 290 291 /* 292 * handle SIGINT and ignore SIGSTP. This is necessary to 293 * restore the state of the terminal. 294 */ 295 caught_interrupt = 0; 296 act.sa_flags = 0; 297 (void) sigemptyset(&act.sa_mask); 298 act.sa_handler = catch_signal; 299 300 (void) sigaction(SIGINT, &act, &osigint); 301 act.sa_handler = SIG_IGN; 302 (void) sigaction(SIGTSTP, &act, &osigtstp); 303 304 (void) printf("%s %s%s", 305 is_reenter ? "Re-enter" : "Enter", 306 new_key ? "new " : "", 307 get_format_prompt_string(keyformat)); 308 if (fsname != NULL) 309 (void) printf(" for '%s'", fsname); 310 (void) fputc(':', stdout); 311 (void) fflush(stdout); 312 313 /* disable the terminal echo for key input */ 314 (void) tcgetattr(fileno(f), &old_term); 315 316 new_term = old_term; 317 new_term.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL); 318 319 ret = tcsetattr(fileno(f), TCSAFLUSH, &new_term); 320 if (ret != 0) { 321 ret = errno; 322 errno = 0; 323 goto out; 324 } 325 326 bytes = getline(res, &buflen, f); 327 if (bytes < 0) { 328 ret = errno; 329 errno = 0; 330 goto out; 331 } 332 333 /* trim the ending newline if it exists */ 334 if (bytes > 0 && (*res)[bytes - 1] == '\n') { 335 (*res)[bytes - 1] = '\0'; 336 bytes--; 337 } 338 339 *reslen = bytes; 340 341 out: 342 /* reset the terminal */ 343 (void) tcsetattr(fileno(f), TCSAFLUSH, &old_term); 344 (void) sigaction(SIGINT, &osigint, NULL); 345 (void) sigaction(SIGTSTP, &osigtstp, NULL); 346 347 /* if we caught a signal, re-throw it now */ 348 if (caught_interrupt != 0) 349 (void) kill(getpid(), caught_interrupt); 350 351 /* print the newline that was not echo'd */ 352 (void) printf("\n"); 353 354 return (ret); 355 } 356 357 static int 358 get_key_interactive(libzfs_handle_t *restrict hdl, const char *fsname, 359 zfs_keyformat_t keyformat, boolean_t confirm_key, boolean_t newkey, 360 uint8_t **restrict outbuf, size_t *restrict len_out) 361 { 362 char *buf = NULL, *buf2 = NULL; 363 size_t buflen = 0, buf2len = 0; 364 int ret = 0; 365 366 ASSERT(isatty(fileno(stdin))); 367 368 /* raw keys cannot be entered on the terminal */ 369 if (keyformat == ZFS_KEYFORMAT_RAW) { 370 ret = EINVAL; 371 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 372 "Cannot enter raw keys on the terminal")); 373 goto out; 374 } 375 376 /* prompt for the key */ 377 if ((ret = libzfs_getpassphrase(keyformat, B_FALSE, newkey, fsname, 378 &buf, &buflen)) != 0) { 379 free(buf); 380 buf = NULL; 381 buflen = 0; 382 goto out; 383 } 384 385 if (!confirm_key) 386 goto out; 387 388 if ((ret = validate_key(hdl, keyformat, buf, buflen, confirm_key)) != 389 0) { 390 free(buf); 391 return (ret); 392 } 393 394 ret = libzfs_getpassphrase(keyformat, B_TRUE, newkey, fsname, &buf2, 395 &buf2len); 396 if (ret != 0) { 397 free(buf); 398 free(buf2); 399 buf = buf2 = NULL; 400 buflen = buf2len = 0; 401 goto out; 402 } 403 404 if (buflen != buf2len || strcmp(buf, buf2) != 0) { 405 free(buf); 406 buf = NULL; 407 buflen = 0; 408 409 ret = EINVAL; 410 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 411 "Provided keys do not match.")); 412 } 413 414 free(buf2); 415 416 out: 417 *outbuf = (uint8_t *)buf; 418 *len_out = buflen; 419 return (ret); 420 } 421 422 static int 423 get_key_material_raw(FILE *fd, zfs_keyformat_t keyformat, 424 uint8_t **buf, size_t *len_out) 425 { 426 int ret = 0; 427 size_t buflen = 0; 428 429 *len_out = 0; 430 431 /* read the key material */ 432 if (keyformat != ZFS_KEYFORMAT_RAW) { 433 ssize_t bytes; 434 435 bytes = getline((char **)buf, &buflen, fd); 436 if (bytes < 0) { 437 ret = errno; 438 errno = 0; 439 goto out; 440 } 441 442 /* trim the ending newline if it exists */ 443 if (bytes > 0 && (*buf)[bytes - 1] == '\n') { 444 (*buf)[bytes - 1] = '\0'; 445 bytes--; 446 } 447 448 *len_out = bytes; 449 } else { 450 size_t n; 451 452 /* 453 * Raw keys may have newline characters in them and so can't 454 * use getline(). Here we attempt to read 33 bytes so that we 455 * can properly check the key length (the file should only have 456 * 32 bytes). 457 */ 458 *buf = malloc((WRAPPING_KEY_LEN + 1) * sizeof (uint8_t)); 459 if (*buf == NULL) { 460 ret = ENOMEM; 461 goto out; 462 } 463 464 n = fread(*buf, 1, WRAPPING_KEY_LEN + 1, fd); 465 if (n == 0 || ferror(fd)) { 466 /* size errors are handled by the calling function */ 467 free(*buf); 468 *buf = NULL; 469 ret = errno; 470 errno = 0; 471 goto out; 472 } 473 474 *len_out = n; 475 } 476 out: 477 return (ret); 478 } 479 480 static int 481 get_key_material_file(libzfs_handle_t *hdl, const char *uri, 482 const char *fsname, zfs_keyformat_t keyformat, boolean_t newkey, 483 uint8_t **restrict buf, size_t *restrict len_out) 484 { 485 (void) fsname, (void) newkey; 486 FILE *f = NULL; 487 int ret = 0; 488 489 if (strlen(uri) < 7) 490 return (EINVAL); 491 492 if ((f = fopen(uri + 7, "re")) == NULL) { 493 ret = errno; 494 errno = 0; 495 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 496 "Failed to open key material file: %s"), strerror(ret)); 497 return (ret); 498 } 499 500 ret = get_key_material_raw(f, keyformat, buf, len_out); 501 502 (void) fclose(f); 503 504 return (ret); 505 } 506 507 static int 508 get_key_material_https(libzfs_handle_t *hdl, const char *uri, 509 const char *fsname, zfs_keyformat_t keyformat, boolean_t newkey, 510 uint8_t **restrict buf, size_t *restrict len_out) 511 { 512 (void) fsname, (void) newkey; 513 int ret = 0; 514 FILE *key = NULL; 515 boolean_t is_http = strncmp(uri, "http:", strlen("http:")) == 0; 516 517 if (strlen(uri) < (is_http ? 7 : 8)) { 518 ret = EINVAL; 519 goto end; 520 } 521 522 #if LIBFETCH_DYNAMIC 523 #define LOAD_FUNCTION(func) \ 524 __typeof__(func) *func = dlsym(hdl->libfetch, #func); 525 526 if (hdl->libfetch == NULL) 527 hdl->libfetch = dlopen(LIBFETCH_SONAME, RTLD_LAZY); 528 529 if (hdl->libfetch == NULL) { 530 hdl->libfetch = (void *)-1; 531 char *err = dlerror(); 532 if (err) 533 hdl->libfetch_load_error = strdup(err); 534 } 535 536 if (hdl->libfetch == (void *)-1) { 537 ret = ENOSYS; 538 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 539 "Couldn't load %s: %s"), 540 LIBFETCH_SONAME, hdl->libfetch_load_error ?: "(?)"); 541 goto end; 542 } 543 544 boolean_t ok; 545 #if LIBFETCH_IS_FETCH 546 LOAD_FUNCTION(fetchGetURL); 547 char *fetchLastErrString = dlsym(hdl->libfetch, "fetchLastErrString"); 548 549 ok = fetchGetURL && fetchLastErrString; 550 #elif LIBFETCH_IS_LIBCURL 551 LOAD_FUNCTION(curl_easy_init); 552 LOAD_FUNCTION(curl_easy_setopt); 553 LOAD_FUNCTION(curl_easy_perform); 554 LOAD_FUNCTION(curl_easy_cleanup); 555 LOAD_FUNCTION(curl_easy_strerror); 556 LOAD_FUNCTION(curl_easy_getinfo); 557 558 ok = curl_easy_init && curl_easy_setopt && curl_easy_perform && 559 curl_easy_cleanup && curl_easy_strerror && curl_easy_getinfo; 560 #endif 561 if (!ok) { 562 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 563 "keylocation=%s back-end %s missing symbols."), 564 is_http ? "http://" : "https://", LIBFETCH_SONAME); 565 ret = ENOSYS; 566 goto end; 567 } 568 #endif 569 570 #if LIBFETCH_IS_FETCH 571 key = fetchGetURL(uri, ""); 572 if (key == NULL) { 573 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 574 "Couldn't GET %s: %s"), 575 uri, fetchLastErrString); 576 ret = ENETDOWN; 577 } 578 #elif LIBFETCH_IS_LIBCURL 579 CURL *curl = curl_easy_init(); 580 if (curl == NULL) { 581 ret = ENOTSUP; 582 goto end; 583 } 584 585 int kfd = -1; 586 #ifdef O_TMPFILE 587 kfd = open(getenv("TMPDIR") ?: "/tmp", 588 O_RDWR | O_TMPFILE | O_EXCL | O_CLOEXEC, 0600); 589 if (kfd != -1) 590 goto kfdok; 591 #endif 592 593 char *path; 594 if (asprintf(&path, 595 "%s/libzfs-XXXXXXXX.https", getenv("TMPDIR") ?: "/tmp") == -1) { 596 ret = ENOMEM; 597 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "%s"), 598 strerror(ret)); 599 goto end; 600 } 601 602 kfd = mkostemps(path, strlen(".https"), O_CLOEXEC); 603 if (kfd == -1) { 604 ret = errno; 605 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 606 "Couldn't create temporary file %s: %s"), 607 path, strerror(ret)); 608 free(path); 609 goto end; 610 } 611 (void) unlink(path); 612 free(path); 613 614 kfdok: 615 if ((key = fdopen(kfd, "r+")) == NULL) { 616 ret = errno; 617 (void) close(kfd); 618 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 619 "Couldn't reopen temporary file: %s"), strerror(ret)); 620 goto end; 621 } 622 623 char errbuf[CURL_ERROR_SIZE] = ""; 624 char *cainfo = getenv("SSL_CA_CERT_FILE"); /* matches fetch(3) */ 625 char *capath = getenv("SSL_CA_CERT_PATH"); /* matches fetch(3) */ 626 char *clcert = getenv("SSL_CLIENT_CERT_FILE"); /* matches fetch(3) */ 627 char *clkey = getenv("SSL_CLIENT_KEY_FILE"); /* matches fetch(3) */ 628 (void) curl_easy_setopt(curl, CURLOPT_URL, uri); 629 (void) curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); 630 (void) curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, 30000L); 631 (void) curl_easy_setopt(curl, CURLOPT_WRITEDATA, key); 632 (void) curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errbuf); 633 if (cainfo != NULL) 634 (void) curl_easy_setopt(curl, CURLOPT_CAINFO, cainfo); 635 if (capath != NULL) 636 (void) curl_easy_setopt(curl, CURLOPT_CAPATH, capath); 637 if (clcert != NULL) 638 (void) curl_easy_setopt(curl, CURLOPT_SSLCERT, clcert); 639 if (clkey != NULL) 640 (void) curl_easy_setopt(curl, CURLOPT_SSLKEY, clkey); 641 642 CURLcode res = curl_easy_perform(curl); 643 644 if (res != CURLE_OK) { 645 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 646 "Failed to connect to %s: %s"), 647 uri, strlen(errbuf) ? errbuf : curl_easy_strerror(res)); 648 ret = ENETDOWN; 649 } else { 650 long resp = 200; 651 (void) curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &resp); 652 653 if (resp < 200 || resp >= 300) { 654 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 655 "Couldn't GET %s: %ld"), 656 uri, resp); 657 ret = ENOENT; 658 } else 659 rewind(key); 660 } 661 662 curl_easy_cleanup(curl); 663 #else 664 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 665 "No keylocation=%s back-end."), is_http ? "http://" : "https://"); 666 ret = ENOSYS; 667 #endif 668 669 end: 670 if (ret == 0) 671 ret = get_key_material_raw(key, keyformat, buf, len_out); 672 673 if (key != NULL) 674 fclose(key); 675 676 return (ret); 677 } 678 679 /* 680 * Attempts to fetch key material, no matter where it might live. The key 681 * material is allocated and returned in km_out. *can_retry_out will be set 682 * to B_TRUE if the user is providing the key material interactively, allowing 683 * for re-entry attempts. 684 */ 685 static int 686 get_key_material(libzfs_handle_t *hdl, boolean_t do_verify, boolean_t newkey, 687 zfs_keyformat_t keyformat, const char *keylocation, const char *fsname, 688 uint8_t **km_out, size_t *kmlen_out, boolean_t *can_retry_out) 689 { 690 int ret; 691 zfs_keylocation_t keyloc = ZFS_KEYLOCATION_NONE; 692 uint8_t *km = NULL; 693 size_t kmlen = 0; 694 char *uri_scheme = NULL; 695 zfs_uri_handler_t *handler = NULL; 696 boolean_t can_retry = B_FALSE; 697 698 /* verify and parse the keylocation */ 699 ret = zfs_prop_parse_keylocation(hdl, keylocation, &keyloc, 700 &uri_scheme); 701 if (ret != 0) 702 goto error; 703 704 /* open the appropriate file descriptor */ 705 switch (keyloc) { 706 case ZFS_KEYLOCATION_PROMPT: 707 if (isatty(fileno(stdin))) { 708 can_retry = keyformat != ZFS_KEYFORMAT_RAW; 709 ret = get_key_interactive(hdl, fsname, keyformat, 710 do_verify, newkey, &km, &kmlen); 711 } else { 712 /* fetch the key material into the buffer */ 713 ret = get_key_material_raw(stdin, keyformat, &km, 714 &kmlen); 715 } 716 717 if (ret != 0) 718 goto error; 719 720 break; 721 case ZFS_KEYLOCATION_URI: 722 ret = ENOTSUP; 723 724 for (handler = uri_handlers; handler->zuh_scheme != NULL; 725 handler++) { 726 if (strcmp(handler->zuh_scheme, uri_scheme) != 0) 727 continue; 728 729 if ((ret = handler->zuh_handler(hdl, keylocation, 730 fsname, keyformat, newkey, &km, &kmlen)) != 0) 731 goto error; 732 733 break; 734 } 735 736 if (ret == ENOTSUP) { 737 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 738 "URI scheme is not supported")); 739 goto error; 740 } 741 742 break; 743 default: 744 ret = EINVAL; 745 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 746 "Invalid keylocation.")); 747 goto error; 748 } 749 750 if ((ret = validate_key(hdl, keyformat, (const char *)km, kmlen, 751 do_verify)) != 0) 752 goto error; 753 754 *km_out = km; 755 *kmlen_out = kmlen; 756 if (can_retry_out != NULL) 757 *can_retry_out = can_retry; 758 759 free(uri_scheme); 760 return (0); 761 762 error: 763 free(km); 764 765 *km_out = NULL; 766 *kmlen_out = 0; 767 768 if (can_retry_out != NULL) 769 *can_retry_out = can_retry; 770 771 free(uri_scheme); 772 return (ret); 773 } 774 775 static int 776 derive_key(libzfs_handle_t *hdl, zfs_keyformat_t format, uint64_t iters, 777 uint8_t *key_material, uint64_t salt, 778 uint8_t **key_out) 779 { 780 int ret; 781 uint8_t *key; 782 783 *key_out = NULL; 784 785 key = zfs_alloc(hdl, WRAPPING_KEY_LEN); 786 787 switch (format) { 788 case ZFS_KEYFORMAT_RAW: 789 memcpy(key, key_material, WRAPPING_KEY_LEN); 790 break; 791 case ZFS_KEYFORMAT_HEX: 792 ret = hex_key_to_raw((char *)key_material, 793 WRAPPING_KEY_LEN * 2, key); 794 if (ret != 0) { 795 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 796 "Invalid hex key provided.")); 797 goto error; 798 } 799 break; 800 case ZFS_KEYFORMAT_PASSPHRASE: 801 salt = LE_64(salt); 802 803 ret = PKCS5_PBKDF2_HMAC_SHA1((char *)key_material, 804 strlen((char *)key_material), ((uint8_t *)&salt), 805 sizeof (uint64_t), iters, WRAPPING_KEY_LEN, key); 806 if (ret != 1) { 807 ret = EIO; 808 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 809 "Failed to generate key from passphrase.")); 810 goto error; 811 } 812 break; 813 default: 814 ret = EINVAL; 815 goto error; 816 } 817 818 *key_out = key; 819 return (0); 820 821 error: 822 free(key); 823 824 *key_out = NULL; 825 return (ret); 826 } 827 828 static boolean_t 829 encryption_feature_is_enabled(zpool_handle_t *zph) 830 { 831 nvlist_t *features; 832 uint64_t feat_refcount; 833 834 /* check that features can be enabled */ 835 if (zpool_get_prop_int(zph, ZPOOL_PROP_VERSION, NULL) 836 < SPA_VERSION_FEATURES) 837 return (B_FALSE); 838 839 /* check for crypto feature */ 840 features = zpool_get_features(zph); 841 if (!features || nvlist_lookup_uint64(features, 842 spa_feature_table[SPA_FEATURE_ENCRYPTION].fi_guid, 843 &feat_refcount) != 0) 844 return (B_FALSE); 845 846 return (B_TRUE); 847 } 848 849 static int 850 populate_create_encryption_params_nvlists(libzfs_handle_t *hdl, 851 zfs_handle_t *zhp, boolean_t newkey, zfs_keyformat_t keyformat, 852 char *keylocation, nvlist_t *props, uint8_t **wkeydata, uint_t *wkeylen) 853 { 854 int ret; 855 uint64_t iters = 0, salt = 0; 856 uint8_t *key_material = NULL; 857 size_t key_material_len = 0; 858 uint8_t *key_data = NULL; 859 const char *fsname = (zhp) ? zfs_get_name(zhp) : NULL; 860 861 /* get key material from keyformat and keylocation */ 862 ret = get_key_material(hdl, B_TRUE, newkey, keyformat, keylocation, 863 fsname, &key_material, &key_material_len, NULL); 864 if (ret != 0) 865 goto error; 866 867 /* passphrase formats require a salt and pbkdf2 iters property */ 868 if (keyformat == ZFS_KEYFORMAT_PASSPHRASE) { 869 /* always generate a new salt */ 870 ret = pkcs11_get_urandom((uint8_t *)&salt, sizeof (uint64_t)); 871 if (ret != sizeof (uint64_t)) { 872 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 873 "Failed to generate salt.")); 874 goto error; 875 } 876 877 ret = nvlist_add_uint64(props, 878 zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), salt); 879 if (ret != 0) { 880 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 881 "Failed to add salt to properties.")); 882 goto error; 883 } 884 885 /* 886 * If not otherwise specified, use the default number of 887 * pbkdf2 iterations. If specified, we have already checked 888 * that the given value is greater than MIN_PBKDF2_ITERATIONS 889 * during zfs_valid_proplist(). 890 */ 891 ret = nvlist_lookup_uint64(props, 892 zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &iters); 893 if (ret == ENOENT) { 894 iters = DEFAULT_PBKDF2_ITERATIONS; 895 ret = nvlist_add_uint64(props, 896 zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), iters); 897 if (ret != 0) 898 goto error; 899 } else if (ret != 0) { 900 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 901 "Failed to get pbkdf2 iterations.")); 902 goto error; 903 } 904 } else { 905 /* check that pbkdf2iters was not specified by the user */ 906 ret = nvlist_lookup_uint64(props, 907 zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &iters); 908 if (ret == 0) { 909 ret = EINVAL; 910 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 911 "Cannot specify pbkdf2iters with a non-passphrase " 912 "keyformat.")); 913 goto error; 914 } 915 } 916 917 /* derive a key from the key material */ 918 ret = derive_key(hdl, keyformat, iters, key_material, salt, &key_data); 919 if (ret != 0) 920 goto error; 921 922 free(key_material); 923 924 *wkeydata = key_data; 925 *wkeylen = WRAPPING_KEY_LEN; 926 return (0); 927 928 error: 929 if (key_material != NULL) 930 free(key_material); 931 if (key_data != NULL) 932 free(key_data); 933 934 *wkeydata = NULL; 935 *wkeylen = 0; 936 return (ret); 937 } 938 939 static boolean_t 940 proplist_has_encryption_props(nvlist_t *props) 941 { 942 int ret; 943 uint64_t intval; 944 char *strval; 945 946 ret = nvlist_lookup_uint64(props, 947 zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &intval); 948 if (ret == 0 && intval != ZIO_CRYPT_OFF) 949 return (B_TRUE); 950 951 ret = nvlist_lookup_string(props, 952 zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &strval); 953 if (ret == 0 && strcmp(strval, "none") != 0) 954 return (B_TRUE); 955 956 ret = nvlist_lookup_uint64(props, 957 zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &intval); 958 if (ret == 0) 959 return (B_TRUE); 960 961 ret = nvlist_lookup_uint64(props, 962 zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &intval); 963 if (ret == 0) 964 return (B_TRUE); 965 966 return (B_FALSE); 967 } 968 969 int 970 zfs_crypto_get_encryption_root(zfs_handle_t *zhp, boolean_t *is_encroot, 971 char *buf) 972 { 973 int ret; 974 char prop_encroot[MAXNAMELEN]; 975 976 /* if the dataset isn't encrypted, just return */ 977 if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) == ZIO_CRYPT_OFF) { 978 *is_encroot = B_FALSE; 979 if (buf != NULL) 980 buf[0] = '\0'; 981 return (0); 982 } 983 984 ret = zfs_prop_get(zhp, ZFS_PROP_ENCRYPTION_ROOT, prop_encroot, 985 sizeof (prop_encroot), NULL, NULL, 0, B_TRUE); 986 if (ret != 0) { 987 *is_encroot = B_FALSE; 988 if (buf != NULL) 989 buf[0] = '\0'; 990 return (ret); 991 } 992 993 *is_encroot = strcmp(prop_encroot, zfs_get_name(zhp)) == 0; 994 if (buf != NULL) 995 strcpy(buf, prop_encroot); 996 997 return (0); 998 } 999 1000 int 1001 zfs_crypto_create(libzfs_handle_t *hdl, char *parent_name, nvlist_t *props, 1002 nvlist_t *pool_props, boolean_t stdin_available, uint8_t **wkeydata_out, 1003 uint_t *wkeylen_out) 1004 { 1005 int ret; 1006 char errbuf[1024]; 1007 uint64_t crypt = ZIO_CRYPT_INHERIT, pcrypt = ZIO_CRYPT_INHERIT; 1008 uint64_t keyformat = ZFS_KEYFORMAT_NONE; 1009 char *keylocation = NULL; 1010 zfs_handle_t *pzhp = NULL; 1011 uint8_t *wkeydata = NULL; 1012 uint_t wkeylen = 0; 1013 boolean_t local_crypt = B_TRUE; 1014 1015 (void) snprintf(errbuf, sizeof (errbuf), 1016 dgettext(TEXT_DOMAIN, "Encryption create error")); 1017 1018 /* lookup crypt from props */ 1019 ret = nvlist_lookup_uint64(props, 1020 zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &crypt); 1021 if (ret != 0) 1022 local_crypt = B_FALSE; 1023 1024 /* lookup key location and format from props */ 1025 (void) nvlist_lookup_uint64(props, 1026 zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat); 1027 (void) nvlist_lookup_string(props, 1028 zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation); 1029 1030 if (parent_name != NULL) { 1031 /* get a reference to parent dataset */ 1032 pzhp = make_dataset_handle(hdl, parent_name); 1033 if (pzhp == NULL) { 1034 ret = ENOENT; 1035 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1036 "Failed to lookup parent.")); 1037 goto out; 1038 } 1039 1040 /* Lookup parent's crypt */ 1041 pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION); 1042 1043 /* Params require the encryption feature */ 1044 if (!encryption_feature_is_enabled(pzhp->zpool_hdl)) { 1045 if (proplist_has_encryption_props(props)) { 1046 ret = EINVAL; 1047 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1048 "Encryption feature not enabled.")); 1049 goto out; 1050 } 1051 1052 ret = 0; 1053 goto out; 1054 } 1055 } else { 1056 /* 1057 * special case for root dataset where encryption feature 1058 * feature won't be on disk yet 1059 */ 1060 if (!nvlist_exists(pool_props, "feature@encryption")) { 1061 if (proplist_has_encryption_props(props)) { 1062 ret = EINVAL; 1063 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1064 "Encryption feature not enabled.")); 1065 goto out; 1066 } 1067 1068 ret = 0; 1069 goto out; 1070 } 1071 1072 pcrypt = ZIO_CRYPT_OFF; 1073 } 1074 1075 /* Get the inherited encryption property if we don't have it locally */ 1076 if (!local_crypt) 1077 crypt = pcrypt; 1078 1079 /* 1080 * At this point crypt should be the actual encryption value. If 1081 * encryption is off just verify that no encryption properties have 1082 * been specified and return. 1083 */ 1084 if (crypt == ZIO_CRYPT_OFF) { 1085 if (proplist_has_encryption_props(props)) { 1086 ret = EINVAL; 1087 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1088 "Encryption must be turned on to set encryption " 1089 "properties.")); 1090 goto out; 1091 } 1092 1093 ret = 0; 1094 goto out; 1095 } 1096 1097 /* 1098 * If we have a parent crypt it is valid to specify encryption alone. 1099 * This will result in a child that is encrypted with the chosen 1100 * encryption suite that will also inherit the parent's key. If 1101 * the parent is not encrypted we need an encryption suite provided. 1102 */ 1103 if (pcrypt == ZIO_CRYPT_OFF && keylocation == NULL && 1104 keyformat == ZFS_KEYFORMAT_NONE) { 1105 ret = EINVAL; 1106 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1107 "Keyformat required for new encryption root.")); 1108 goto out; 1109 } 1110 1111 /* 1112 * Specifying a keylocation implies this will be a new encryption root. 1113 * Check that a keyformat is also specified. 1114 */ 1115 if (keylocation != NULL && keyformat == ZFS_KEYFORMAT_NONE) { 1116 ret = EINVAL; 1117 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1118 "Keyformat required for new encryption root.")); 1119 goto out; 1120 } 1121 1122 /* default to prompt if no keylocation is specified */ 1123 if (keyformat != ZFS_KEYFORMAT_NONE && keylocation == NULL) { 1124 keylocation = "prompt"; 1125 ret = nvlist_add_string(props, 1126 zfs_prop_to_name(ZFS_PROP_KEYLOCATION), keylocation); 1127 if (ret != 0) 1128 goto out; 1129 } 1130 1131 /* 1132 * If a local key is provided, this dataset will be a new 1133 * encryption root. Populate the encryption params. 1134 */ 1135 if (keylocation != NULL) { 1136 /* 1137 * 'zfs recv -o keylocation=prompt' won't work because stdin 1138 * is being used by the send stream, so we disallow it. 1139 */ 1140 if (!stdin_available && strcmp(keylocation, "prompt") == 0) { 1141 ret = EINVAL; 1142 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Cannot use " 1143 "'prompt' keylocation because stdin is in use.")); 1144 goto out; 1145 } 1146 1147 ret = populate_create_encryption_params_nvlists(hdl, NULL, 1148 B_TRUE, keyformat, keylocation, props, &wkeydata, 1149 &wkeylen); 1150 if (ret != 0) 1151 goto out; 1152 } 1153 1154 if (pzhp != NULL) 1155 zfs_close(pzhp); 1156 1157 *wkeydata_out = wkeydata; 1158 *wkeylen_out = wkeylen; 1159 return (0); 1160 1161 out: 1162 if (pzhp != NULL) 1163 zfs_close(pzhp); 1164 if (wkeydata != NULL) 1165 free(wkeydata); 1166 1167 *wkeydata_out = NULL; 1168 *wkeylen_out = 0; 1169 return (ret); 1170 } 1171 1172 int 1173 zfs_crypto_clone_check(libzfs_handle_t *hdl, zfs_handle_t *origin_zhp, 1174 char *parent_name, nvlist_t *props) 1175 { 1176 (void) origin_zhp, (void) parent_name; 1177 char errbuf[1024]; 1178 1179 (void) snprintf(errbuf, sizeof (errbuf), 1180 dgettext(TEXT_DOMAIN, "Encryption clone error")); 1181 1182 /* 1183 * No encryption properties should be specified. They will all be 1184 * inherited from the origin dataset. 1185 */ 1186 if (nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYFORMAT)) || 1187 nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYLOCATION)) || 1188 nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_ENCRYPTION)) || 1189 nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS))) { 1190 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1191 "Encryption properties must inherit from origin dataset.")); 1192 return (EINVAL); 1193 } 1194 1195 return (0); 1196 } 1197 1198 typedef struct loadkeys_cbdata { 1199 uint64_t cb_numfailed; 1200 uint64_t cb_numattempted; 1201 } loadkey_cbdata_t; 1202 1203 static int 1204 load_keys_cb(zfs_handle_t *zhp, void *arg) 1205 { 1206 int ret; 1207 boolean_t is_encroot; 1208 loadkey_cbdata_t *cb = arg; 1209 uint64_t keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS); 1210 1211 /* only attempt to load keys for encryption roots */ 1212 ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL); 1213 if (ret != 0 || !is_encroot) 1214 goto out; 1215 1216 /* don't attempt to load already loaded keys */ 1217 if (keystatus == ZFS_KEYSTATUS_AVAILABLE) 1218 goto out; 1219 1220 /* Attempt to load the key. Record status in cb. */ 1221 cb->cb_numattempted++; 1222 1223 ret = zfs_crypto_load_key(zhp, B_FALSE, NULL); 1224 if (ret) 1225 cb->cb_numfailed++; 1226 1227 out: 1228 (void) zfs_iter_filesystems(zhp, load_keys_cb, cb); 1229 zfs_close(zhp); 1230 1231 /* always return 0, since this function is best effort */ 1232 return (0); 1233 } 1234 1235 /* 1236 * This function is best effort. It attempts to load all the keys for the given 1237 * filesystem and all of its children. 1238 */ 1239 int 1240 zfs_crypto_attempt_load_keys(libzfs_handle_t *hdl, const char *fsname) 1241 { 1242 int ret; 1243 zfs_handle_t *zhp = NULL; 1244 loadkey_cbdata_t cb = { 0 }; 1245 1246 zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME); 1247 if (zhp == NULL) { 1248 ret = ENOENT; 1249 goto error; 1250 } 1251 1252 ret = load_keys_cb(zfs_handle_dup(zhp), &cb); 1253 if (ret) 1254 goto error; 1255 1256 (void) printf(gettext("%llu / %llu keys successfully loaded\n"), 1257 (u_longlong_t)(cb.cb_numattempted - cb.cb_numfailed), 1258 (u_longlong_t)cb.cb_numattempted); 1259 1260 if (cb.cb_numfailed != 0) { 1261 ret = -1; 1262 goto error; 1263 } 1264 1265 zfs_close(zhp); 1266 return (0); 1267 1268 error: 1269 if (zhp != NULL) 1270 zfs_close(zhp); 1271 return (ret); 1272 } 1273 1274 int 1275 zfs_crypto_load_key(zfs_handle_t *zhp, boolean_t noop, 1276 const char *alt_keylocation) 1277 { 1278 int ret, attempts = 0; 1279 char errbuf[1024]; 1280 uint64_t keystatus, iters = 0, salt = 0; 1281 uint64_t keyformat = ZFS_KEYFORMAT_NONE; 1282 char prop_keylocation[MAXNAMELEN]; 1283 char prop_encroot[MAXNAMELEN]; 1284 const char *keylocation = NULL; 1285 uint8_t *key_material = NULL, *key_data = NULL; 1286 size_t key_material_len; 1287 boolean_t is_encroot, can_retry = B_FALSE, correctible = B_FALSE; 1288 1289 (void) snprintf(errbuf, sizeof (errbuf), 1290 dgettext(TEXT_DOMAIN, "Key load error")); 1291 1292 /* check that encryption is enabled for the pool */ 1293 if (!encryption_feature_is_enabled(zhp->zpool_hdl)) { 1294 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1295 "Encryption feature not enabled.")); 1296 ret = EINVAL; 1297 goto error; 1298 } 1299 1300 /* Fetch the keyformat. Check that the dataset is encrypted. */ 1301 keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT); 1302 if (keyformat == ZFS_KEYFORMAT_NONE) { 1303 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1304 "'%s' is not encrypted."), zfs_get_name(zhp)); 1305 ret = EINVAL; 1306 goto error; 1307 } 1308 1309 /* 1310 * Fetch the key location. Check that we are working with an 1311 * encryption root. 1312 */ 1313 ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot); 1314 if (ret != 0) { 1315 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1316 "Failed to get encryption root for '%s'."), 1317 zfs_get_name(zhp)); 1318 goto error; 1319 } else if (!is_encroot) { 1320 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1321 "Keys must be loaded for encryption root of '%s' (%s)."), 1322 zfs_get_name(zhp), prop_encroot); 1323 ret = EINVAL; 1324 goto error; 1325 } 1326 1327 /* 1328 * if the caller has elected to override the keylocation property 1329 * use that instead 1330 */ 1331 if (alt_keylocation != NULL) { 1332 keylocation = alt_keylocation; 1333 } else { 1334 ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION, prop_keylocation, 1335 sizeof (prop_keylocation), NULL, NULL, 0, B_TRUE); 1336 if (ret != 0) { 1337 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1338 "Failed to get keylocation for '%s'."), 1339 zfs_get_name(zhp)); 1340 goto error; 1341 } 1342 1343 keylocation = prop_keylocation; 1344 } 1345 1346 /* check that the key is unloaded unless this is a noop */ 1347 if (!noop) { 1348 keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS); 1349 if (keystatus == ZFS_KEYSTATUS_AVAILABLE) { 1350 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1351 "Key already loaded for '%s'."), zfs_get_name(zhp)); 1352 ret = EEXIST; 1353 goto error; 1354 } 1355 } 1356 1357 /* passphrase formats require a salt and pbkdf2_iters property */ 1358 if (keyformat == ZFS_KEYFORMAT_PASSPHRASE) { 1359 salt = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_SALT); 1360 iters = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_ITERS); 1361 } 1362 1363 try_again: 1364 /* fetching and deriving the key are correctable errors. set the flag */ 1365 correctible = B_TRUE; 1366 1367 /* get key material from key format and location */ 1368 ret = get_key_material(zhp->zfs_hdl, B_FALSE, B_FALSE, keyformat, 1369 keylocation, zfs_get_name(zhp), &key_material, &key_material_len, 1370 &can_retry); 1371 if (ret != 0) 1372 goto error; 1373 1374 /* derive a key from the key material */ 1375 ret = derive_key(zhp->zfs_hdl, keyformat, iters, key_material, salt, 1376 &key_data); 1377 if (ret != 0) 1378 goto error; 1379 1380 correctible = B_FALSE; 1381 1382 /* pass the wrapping key and noop flag to the ioctl */ 1383 ret = lzc_load_key(zhp->zfs_name, noop, key_data, WRAPPING_KEY_LEN); 1384 if (ret != 0) { 1385 switch (ret) { 1386 case EPERM: 1387 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1388 "Permission denied.")); 1389 break; 1390 case EINVAL: 1391 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1392 "Invalid parameters provided for dataset %s."), 1393 zfs_get_name(zhp)); 1394 break; 1395 case EEXIST: 1396 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1397 "Key already loaded for '%s'."), zfs_get_name(zhp)); 1398 break; 1399 case EBUSY: 1400 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1401 "'%s' is busy."), zfs_get_name(zhp)); 1402 break; 1403 case EACCES: 1404 correctible = B_TRUE; 1405 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1406 "Incorrect key provided for '%s'."), 1407 zfs_get_name(zhp)); 1408 break; 1409 } 1410 goto error; 1411 } 1412 1413 free(key_material); 1414 free(key_data); 1415 1416 return (0); 1417 1418 error: 1419 zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf); 1420 if (key_material != NULL) { 1421 free(key_material); 1422 key_material = NULL; 1423 } 1424 if (key_data != NULL) { 1425 free(key_data); 1426 key_data = NULL; 1427 } 1428 1429 /* 1430 * Here we decide if it is ok to allow the user to retry entering their 1431 * key. The can_retry flag will be set if the user is entering their 1432 * key from an interactive prompt. The correctable flag will only be 1433 * set if an error that occurred could be corrected by retrying. Both 1434 * flags are needed to allow the user to attempt key entry again 1435 */ 1436 attempts++; 1437 if (can_retry && correctible && attempts < MAX_KEY_PROMPT_ATTEMPTS) 1438 goto try_again; 1439 1440 return (ret); 1441 } 1442 1443 int 1444 zfs_crypto_unload_key(zfs_handle_t *zhp) 1445 { 1446 int ret; 1447 char errbuf[1024]; 1448 char prop_encroot[MAXNAMELEN]; 1449 uint64_t keystatus, keyformat; 1450 boolean_t is_encroot; 1451 1452 (void) snprintf(errbuf, sizeof (errbuf), 1453 dgettext(TEXT_DOMAIN, "Key unload error")); 1454 1455 /* check that encryption is enabled for the pool */ 1456 if (!encryption_feature_is_enabled(zhp->zpool_hdl)) { 1457 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1458 "Encryption feature not enabled.")); 1459 ret = EINVAL; 1460 goto error; 1461 } 1462 1463 /* Fetch the keyformat. Check that the dataset is encrypted. */ 1464 keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT); 1465 if (keyformat == ZFS_KEYFORMAT_NONE) { 1466 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1467 "'%s' is not encrypted."), zfs_get_name(zhp)); 1468 ret = EINVAL; 1469 goto error; 1470 } 1471 1472 /* 1473 * Fetch the key location. Check that we are working with an 1474 * encryption root. 1475 */ 1476 ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot); 1477 if (ret != 0) { 1478 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1479 "Failed to get encryption root for '%s'."), 1480 zfs_get_name(zhp)); 1481 goto error; 1482 } else if (!is_encroot) { 1483 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1484 "Keys must be unloaded for encryption root of '%s' (%s)."), 1485 zfs_get_name(zhp), prop_encroot); 1486 ret = EINVAL; 1487 goto error; 1488 } 1489 1490 /* check that the key is loaded */ 1491 keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS); 1492 if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) { 1493 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1494 "Key already unloaded for '%s'."), zfs_get_name(zhp)); 1495 ret = EACCES; 1496 goto error; 1497 } 1498 1499 /* call the ioctl */ 1500 ret = lzc_unload_key(zhp->zfs_name); 1501 1502 if (ret != 0) { 1503 switch (ret) { 1504 case EPERM: 1505 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1506 "Permission denied.")); 1507 break; 1508 case EACCES: 1509 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1510 "Key already unloaded for '%s'."), 1511 zfs_get_name(zhp)); 1512 break; 1513 case EBUSY: 1514 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1515 "'%s' is busy."), zfs_get_name(zhp)); 1516 break; 1517 } 1518 zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf); 1519 } 1520 1521 return (ret); 1522 1523 error: 1524 zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf); 1525 return (ret); 1526 } 1527 1528 static int 1529 zfs_crypto_verify_rewrap_nvlist(zfs_handle_t *zhp, nvlist_t *props, 1530 nvlist_t **props_out, char *errbuf) 1531 { 1532 int ret; 1533 nvpair_t *elem = NULL; 1534 zfs_prop_t prop; 1535 nvlist_t *new_props = NULL; 1536 1537 new_props = fnvlist_alloc(); 1538 1539 /* 1540 * loop through all provided properties, we should only have 1541 * keyformat, keylocation and pbkdf2iters. The actual validation of 1542 * values is done by zfs_valid_proplist(). 1543 */ 1544 while ((elem = nvlist_next_nvpair(props, elem)) != NULL) { 1545 const char *propname = nvpair_name(elem); 1546 prop = zfs_name_to_prop(propname); 1547 1548 switch (prop) { 1549 case ZFS_PROP_PBKDF2_ITERS: 1550 case ZFS_PROP_KEYFORMAT: 1551 case ZFS_PROP_KEYLOCATION: 1552 break; 1553 default: 1554 ret = EINVAL; 1555 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1556 "Only keyformat, keylocation and pbkdf2iters may " 1557 "be set with this command.")); 1558 goto error; 1559 } 1560 } 1561 1562 new_props = zfs_valid_proplist(zhp->zfs_hdl, zhp->zfs_type, props, 1563 zfs_prop_get_int(zhp, ZFS_PROP_ZONED), NULL, zhp->zpool_hdl, 1564 B_TRUE, errbuf); 1565 if (new_props == NULL) { 1566 ret = EINVAL; 1567 goto error; 1568 } 1569 1570 *props_out = new_props; 1571 return (0); 1572 1573 error: 1574 nvlist_free(new_props); 1575 *props_out = NULL; 1576 return (ret); 1577 } 1578 1579 int 1580 zfs_crypto_rewrap(zfs_handle_t *zhp, nvlist_t *raw_props, boolean_t inheritkey) 1581 { 1582 int ret; 1583 char errbuf[1024]; 1584 boolean_t is_encroot; 1585 nvlist_t *props = NULL; 1586 uint8_t *wkeydata = NULL; 1587 uint_t wkeylen = 0; 1588 dcp_cmd_t cmd = (inheritkey) ? DCP_CMD_INHERIT : DCP_CMD_NEW_KEY; 1589 uint64_t crypt, pcrypt, keystatus, pkeystatus; 1590 uint64_t keyformat = ZFS_KEYFORMAT_NONE; 1591 zfs_handle_t *pzhp = NULL; 1592 char *keylocation = NULL; 1593 char origin_name[MAXNAMELEN]; 1594 char prop_keylocation[MAXNAMELEN]; 1595 char parent_name[ZFS_MAX_DATASET_NAME_LEN]; 1596 1597 (void) snprintf(errbuf, sizeof (errbuf), 1598 dgettext(TEXT_DOMAIN, "Key change error")); 1599 1600 /* check that encryption is enabled for the pool */ 1601 if (!encryption_feature_is_enabled(zhp->zpool_hdl)) { 1602 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1603 "Encryption feature not enabled.")); 1604 ret = EINVAL; 1605 goto error; 1606 } 1607 1608 /* get crypt from dataset */ 1609 crypt = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION); 1610 if (crypt == ZIO_CRYPT_OFF) { 1611 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1612 "Dataset not encrypted.")); 1613 ret = EINVAL; 1614 goto error; 1615 } 1616 1617 /* get the encryption root of the dataset */ 1618 ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL); 1619 if (ret != 0) { 1620 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1621 "Failed to get encryption root for '%s'."), 1622 zfs_get_name(zhp)); 1623 goto error; 1624 } 1625 1626 /* Clones use their origin's key and cannot rewrap it */ 1627 ret = zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin_name, 1628 sizeof (origin_name), NULL, NULL, 0, B_TRUE); 1629 if (ret == 0 && strcmp(origin_name, "") != 0) { 1630 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1631 "Keys cannot be changed on clones.")); 1632 ret = EINVAL; 1633 goto error; 1634 } 1635 1636 /* 1637 * If the user wants to use the inheritkey variant of this function 1638 * we don't need to collect any crypto arguments. 1639 */ 1640 if (!inheritkey) { 1641 /* validate the provided properties */ 1642 ret = zfs_crypto_verify_rewrap_nvlist(zhp, raw_props, &props, 1643 errbuf); 1644 if (ret != 0) 1645 goto error; 1646 1647 /* 1648 * Load keyformat and keylocation from the nvlist. Fetch from 1649 * the dataset properties if not specified. 1650 */ 1651 (void) nvlist_lookup_uint64(props, 1652 zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat); 1653 (void) nvlist_lookup_string(props, 1654 zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation); 1655 1656 if (is_encroot) { 1657 /* 1658 * If this is already an encryption root, just keep 1659 * any properties not set by the user. 1660 */ 1661 if (keyformat == ZFS_KEYFORMAT_NONE) { 1662 keyformat = zfs_prop_get_int(zhp, 1663 ZFS_PROP_KEYFORMAT); 1664 ret = nvlist_add_uint64(props, 1665 zfs_prop_to_name(ZFS_PROP_KEYFORMAT), 1666 keyformat); 1667 if (ret != 0) { 1668 zfs_error_aux(zhp->zfs_hdl, 1669 dgettext(TEXT_DOMAIN, "Failed to " 1670 "get existing keyformat " 1671 "property.")); 1672 goto error; 1673 } 1674 } 1675 1676 if (keylocation == NULL) { 1677 ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION, 1678 prop_keylocation, sizeof (prop_keylocation), 1679 NULL, NULL, 0, B_TRUE); 1680 if (ret != 0) { 1681 zfs_error_aux(zhp->zfs_hdl, 1682 dgettext(TEXT_DOMAIN, "Failed to " 1683 "get existing keylocation " 1684 "property.")); 1685 goto error; 1686 } 1687 1688 keylocation = prop_keylocation; 1689 } 1690 } else { 1691 /* need a new key for non-encryption roots */ 1692 if (keyformat == ZFS_KEYFORMAT_NONE) { 1693 ret = EINVAL; 1694 zfs_error_aux(zhp->zfs_hdl, 1695 dgettext(TEXT_DOMAIN, "Keyformat required " 1696 "for new encryption root.")); 1697 goto error; 1698 } 1699 1700 /* default to prompt if no keylocation is specified */ 1701 if (keylocation == NULL) { 1702 keylocation = "prompt"; 1703 ret = nvlist_add_string(props, 1704 zfs_prop_to_name(ZFS_PROP_KEYLOCATION), 1705 keylocation); 1706 if (ret != 0) 1707 goto error; 1708 } 1709 } 1710 1711 /* fetch the new wrapping key and associated properties */ 1712 ret = populate_create_encryption_params_nvlists(zhp->zfs_hdl, 1713 zhp, B_TRUE, keyformat, keylocation, props, &wkeydata, 1714 &wkeylen); 1715 if (ret != 0) 1716 goto error; 1717 } else { 1718 /* check that zhp is an encryption root */ 1719 if (!is_encroot) { 1720 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1721 "Key inheritting can only be performed on " 1722 "encryption roots.")); 1723 ret = EINVAL; 1724 goto error; 1725 } 1726 1727 /* get the parent's name */ 1728 ret = zfs_parent_name(zhp, parent_name, sizeof (parent_name)); 1729 if (ret != 0) { 1730 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1731 "Root dataset cannot inherit key.")); 1732 ret = EINVAL; 1733 goto error; 1734 } 1735 1736 /* get a handle to the parent */ 1737 pzhp = make_dataset_handle(zhp->zfs_hdl, parent_name); 1738 if (pzhp == NULL) { 1739 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1740 "Failed to lookup parent.")); 1741 ret = ENOENT; 1742 goto error; 1743 } 1744 1745 /* parent must be encrypted */ 1746 pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION); 1747 if (pcrypt == ZIO_CRYPT_OFF) { 1748 zfs_error_aux(pzhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1749 "Parent must be encrypted.")); 1750 ret = EINVAL; 1751 goto error; 1752 } 1753 1754 /* check that the parent's key is loaded */ 1755 pkeystatus = zfs_prop_get_int(pzhp, ZFS_PROP_KEYSTATUS); 1756 if (pkeystatus == ZFS_KEYSTATUS_UNAVAILABLE) { 1757 zfs_error_aux(pzhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1758 "Parent key must be loaded.")); 1759 ret = EACCES; 1760 goto error; 1761 } 1762 } 1763 1764 /* check that the key is loaded */ 1765 keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS); 1766 if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) { 1767 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1768 "Key must be loaded.")); 1769 ret = EACCES; 1770 goto error; 1771 } 1772 1773 /* call the ioctl */ 1774 ret = lzc_change_key(zhp->zfs_name, cmd, props, wkeydata, wkeylen); 1775 if (ret != 0) { 1776 switch (ret) { 1777 case EPERM: 1778 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1779 "Permission denied.")); 1780 break; 1781 case EINVAL: 1782 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1783 "Invalid properties for key change.")); 1784 break; 1785 case EACCES: 1786 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 1787 "Key is not currently loaded.")); 1788 break; 1789 } 1790 zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf); 1791 } 1792 1793 if (pzhp != NULL) 1794 zfs_close(pzhp); 1795 if (props != NULL) 1796 nvlist_free(props); 1797 if (wkeydata != NULL) 1798 free(wkeydata); 1799 1800 return (ret); 1801 1802 error: 1803 if (pzhp != NULL) 1804 zfs_close(pzhp); 1805 if (props != NULL) 1806 nvlist_free(props); 1807 if (wkeydata != NULL) 1808 free(wkeydata); 1809 1810 zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf); 1811 return (ret); 1812 } 1813