lib/libzfs/libzfs_crypto.c

   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         if (!key)
 787                 return (ENOMEM);
 788
 789         switch (format) {
 790         case ZFS_KEYFORMAT_RAW:
 791                 memcpy(key, key_material, WRAPPING_KEY_LEN);
 792                 break;
 793         case ZFS_KEYFORMAT_HEX:
 794                 ret = hex_key_to_raw((char *)key_material,
 795                     WRAPPING_KEY_LEN * 2, key);
 796                 if (ret != 0) {
 797                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 798                             "Invalid hex key provided."));
 799                         goto error;
 800                 }
 801                 break;
 802         case ZFS_KEYFORMAT_PASSPHRASE:
 803                 salt = LE_64(salt);
 804
 805                 ret = PKCS5_PBKDF2_HMAC_SHA1((char *)key_material,
 806                     strlen((char *)key_material), ((uint8_t *)&salt),
 807                     sizeof (uint64_t), iters, WRAPPING_KEY_LEN, key);
 808                 if (ret != 1) {
 809                         ret = EIO;
 810                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 811                             "Failed to generate key from passphrase."));
 812                         goto error;
 813                 }
 814                 break;
 815         default:
 816                 ret = EINVAL;
 817                 goto error;
 818         }
 819
 820         *key_out = key;
 821         return (0);
 822
 823 error:
 824         free(key);
 825
 826         *key_out = NULL;
 827         return (ret);
 828 }
 829
 830 static boolean_t
 831 encryption_feature_is_enabled(zpool_handle_t *zph)
 832 {
 833         nvlist_t *features;
 834         uint64_t feat_refcount;
 835
 836         /* check that features can be enabled */
 837         if (zpool_get_prop_int(zph, ZPOOL_PROP_VERSION, NULL)
 838             < SPA_VERSION_FEATURES)
 839                 return (B_FALSE);
 840
 841         /* check for crypto feature */
 842         features = zpool_get_features(zph);
 843         if (!features || nvlist_lookup_uint64(features,
 844             spa_feature_table[SPA_FEATURE_ENCRYPTION].fi_guid,
 845             &feat_refcount) != 0)
 846                 return (B_FALSE);
 847
 848         return (B_TRUE);
 849 }
 850
 851 static int
 852 populate_create_encryption_params_nvlists(libzfs_handle_t *hdl,
 853     zfs_handle_t *zhp, boolean_t newkey, zfs_keyformat_t keyformat,
 854     char *keylocation, nvlist_t *props, uint8_t **wkeydata, uint_t *wkeylen)
 855 {
 856         int ret;
 857         uint64_t iters = 0, salt = 0;
 858         uint8_t *key_material = NULL;
 859         size_t key_material_len = 0;
 860         uint8_t *key_data = NULL;
 861         const char *fsname = (zhp) ? zfs_get_name(zhp) : NULL;
 862
 863         /* get key material from keyformat and keylocation */
 864         ret = get_key_material(hdl, B_TRUE, newkey, keyformat, keylocation,
 865             fsname, &key_material, &key_material_len, NULL);
 866         if (ret != 0)
 867                 goto error;
 868
 869         /* passphrase formats require a salt and pbkdf2 iters property */
 870         if (keyformat == ZFS_KEYFORMAT_PASSPHRASE) {
 871                 /* always generate a new salt */
 872                 ret = pkcs11_get_urandom((uint8_t *)&salt, sizeof (uint64_t));
 873                 if (ret != sizeof (uint64_t)) {
 874                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 875                             "Failed to generate salt."));
 876                         goto error;
 877                 }
 878
 879                 ret = nvlist_add_uint64(props,
 880                     zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), salt);
 881                 if (ret != 0) {
 882                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 883                             "Failed to add salt to properties."));
 884                         goto error;
 885                 }
 886
 887                 /*
 888                  * If not otherwise specified, use the default number of
 889                  * pbkdf2 iterations. If specified, we have already checked
 890                  * that the given value is greater than MIN_PBKDF2_ITERATIONS
 891                  * during zfs_valid_proplist().
 892                  */
 893                 ret = nvlist_lookup_uint64(props,
 894                     zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &iters);
 895                 if (ret == ENOENT) {
 896                         iters = DEFAULT_PBKDF2_ITERATIONS;
 897                         ret = nvlist_add_uint64(props,
 898                             zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), iters);
 899                         if (ret != 0)
 900                                 goto error;
 901                 } else if (ret != 0) {
 902                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 903                             "Failed to get pbkdf2 iterations."));
 904                         goto error;
 905                 }
 906         } else {
 907                 /* check that pbkdf2iters was not specified by the user */
 908                 ret = nvlist_lookup_uint64(props,
 909                     zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &iters);
 910                 if (ret == 0) {
 911                         ret = EINVAL;
 912                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 913                             "Cannot specify pbkdf2iters with a non-passphrase "
 914                             "keyformat."));
 915                         goto error;
 916                 }
 917         }
 918
 919         /* derive a key from the key material */
 920         ret = derive_key(hdl, keyformat, iters, key_material, salt, &key_data);
 921         if (ret != 0)
 922                 goto error;
 923
 924         free(key_material);
 925
 926         *wkeydata = key_data;
 927         *wkeylen = WRAPPING_KEY_LEN;
 928         return (0);
 929
 930 error:
 931         if (key_material != NULL)
 932                 free(key_material);
 933         if (key_data != NULL)
 934                 free(key_data);
 935
 936         *wkeydata = NULL;
 937         *wkeylen = 0;
 938         return (ret);
 939 }
 940
 941 static boolean_t
 942 proplist_has_encryption_props(nvlist_t *props)
 943 {
 944         int ret;
 945         uint64_t intval;
 946         char *strval;
 947
 948         ret = nvlist_lookup_uint64(props,
 949             zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &intval);
 950         if (ret == 0 && intval != ZIO_CRYPT_OFF)
 951                 return (B_TRUE);
 952
 953         ret = nvlist_lookup_string(props,
 954             zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &strval);
 955         if (ret == 0 && strcmp(strval, "none") != 0)
 956                 return (B_TRUE);
 957
 958         ret = nvlist_lookup_uint64(props,
 959             zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &intval);
 960         if (ret == 0)
 961                 return (B_TRUE);
 962
 963         ret = nvlist_lookup_uint64(props,
 964             zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &intval);
 965         if (ret == 0)
 966                 return (B_TRUE);
 967
 968         return (B_FALSE);
 969 }
 970
 971 int
 972 zfs_crypto_get_encryption_root(zfs_handle_t *zhp, boolean_t *is_encroot,
 973     char *buf)
 974 {
 975         int ret;
 976         char prop_encroot[MAXNAMELEN];
 977
 978         /* if the dataset isn't encrypted, just return */
 979         if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) == ZIO_CRYPT_OFF) {
 980                 *is_encroot = B_FALSE;
 981                 if (buf != NULL)
 982                         buf[0] = '\0';
 983                 return (0);
 984         }
 985
 986         ret = zfs_prop_get(zhp, ZFS_PROP_ENCRYPTION_ROOT, prop_encroot,
 987             sizeof (prop_encroot), NULL, NULL, 0, B_TRUE);
 988         if (ret != 0) {
 989                 *is_encroot = B_FALSE;
 990                 if (buf != NULL)
 991                         buf[0] = '\0';
 992                 return (ret);
 993         }
 994
 995         *is_encroot = strcmp(prop_encroot, zfs_get_name(zhp)) == 0;
 996         if (buf != NULL)
 997                 strcpy(buf, prop_encroot);
 998
 999         return (0);
1000 }
1001
1002 int
1003 zfs_crypto_create(libzfs_handle_t *hdl, char *parent_name, nvlist_t *props,
1004     nvlist_t *pool_props, boolean_t stdin_available, uint8_t **wkeydata_out,
1005     uint_t *wkeylen_out)
1006 {
1007         int ret;
1008         char errbuf[1024];
1009         uint64_t crypt = ZIO_CRYPT_INHERIT, pcrypt = ZIO_CRYPT_INHERIT;
1010         uint64_t keyformat = ZFS_KEYFORMAT_NONE;
1011         char *keylocation = NULL;
1012         zfs_handle_t *pzhp = NULL;
1013         uint8_t *wkeydata = NULL;
1014         uint_t wkeylen = 0;
1015         boolean_t local_crypt = B_TRUE;
1016
1017         (void) snprintf(errbuf, sizeof (errbuf),
1018             dgettext(TEXT_DOMAIN, "Encryption create error"));
1019
1020         /* lookup crypt from props */
1021         ret = nvlist_lookup_uint64(props,
1022             zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &crypt);
1023         if (ret != 0)
1024                 local_crypt = B_FALSE;
1025
1026         /* lookup key location and format from props */
1027         (void) nvlist_lookup_uint64(props,
1028             zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat);
1029         (void) nvlist_lookup_string(props,
1030             zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);
1031
1032         if (parent_name != NULL) {
1033                 /* get a reference to parent dataset */
1034                 pzhp = make_dataset_handle(hdl, parent_name);
1035                 if (pzhp == NULL) {
1036                         ret = ENOENT;
1037                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1038                             "Failed to lookup parent."));
1039                         goto out;
1040                 }
1041
1042                 /* Lookup parent's crypt */
1043                 pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION);
1044
1045                 /* Params require the encryption feature */
1046                 if (!encryption_feature_is_enabled(pzhp->zpool_hdl)) {
1047                         if (proplist_has_encryption_props(props)) {
1048                                 ret = EINVAL;
1049                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1050                                     "Encryption feature not enabled."));
1051                                 goto out;
1052                         }
1053
1054                         ret = 0;
1055                         goto out;
1056                 }
1057         } else {
1058                 /*
1059                  * special case for root dataset where encryption feature
1060                  * feature won't be on disk yet
1061                  */
1062                 if (!nvlist_exists(pool_props, "feature@encryption")) {
1063                         if (proplist_has_encryption_props(props)) {
1064                                 ret = EINVAL;
1065                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1066                                     "Encryption feature not enabled."));
1067                                 goto out;
1068                         }
1069
1070                         ret = 0;
1071                         goto out;
1072                 }
1073
1074                 pcrypt = ZIO_CRYPT_OFF;
1075         }
1076
1077         /* Get the inherited encryption property if we don't have it locally */
1078         if (!local_crypt)
1079                 crypt = pcrypt;
1080
1081         /*
1082          * At this point crypt should be the actual encryption value. If
1083          * encryption is off just verify that no encryption properties have
1084          * been specified and return.
1085          */
1086         if (crypt == ZIO_CRYPT_OFF) {
1087                 if (proplist_has_encryption_props(props)) {
1088                         ret = EINVAL;
1089                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1090                             "Encryption must be turned on to set encryption "
1091                             "properties."));
1092                         goto out;
1093                 }
1094
1095                 ret = 0;
1096                 goto out;
1097         }
1098
1099         /*
1100          * If we have a parent crypt it is valid to specify encryption alone.
1101          * This will result in a child that is encrypted with the chosen
1102          * encryption suite that will also inherit the parent's key. If
1103          * the parent is not encrypted we need an encryption suite provided.
1104          */
1105         if (pcrypt == ZIO_CRYPT_OFF && keylocation == NULL &&
1106             keyformat == ZFS_KEYFORMAT_NONE) {
1107                 ret = EINVAL;
1108                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1109                     "Keyformat required for new encryption root."));
1110                 goto out;
1111         }
1112
1113         /*
1114          * Specifying a keylocation implies this will be a new encryption root.
1115          * Check that a keyformat is also specified.
1116          */
1117         if (keylocation != NULL && keyformat == ZFS_KEYFORMAT_NONE) {
1118                 ret = EINVAL;
1119                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1120                     "Keyformat required for new encryption root."));
1121                 goto out;
1122         }
1123
1124         /* default to prompt if no keylocation is specified */
1125         if (keyformat != ZFS_KEYFORMAT_NONE && keylocation == NULL) {
1126                 keylocation = "prompt";
1127                 ret = nvlist_add_string(props,
1128                     zfs_prop_to_name(ZFS_PROP_KEYLOCATION), keylocation);
1129                 if (ret != 0)
1130                         goto out;
1131         }
1132
1133         /*
1134          * If a local key is provided, this dataset will be a new
1135          * encryption root. Populate the encryption params.
1136          */
1137         if (keylocation != NULL) {
1138                 /*
1139                  * 'zfs recv -o keylocation=prompt' won't work because stdin
1140                  * is being used by the send stream, so we disallow it.
1141                  */
1142                 if (!stdin_available && strcmp(keylocation, "prompt") == 0) {
1143                         ret = EINVAL;
1144                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Cannot use "
1145                             "'prompt' keylocation because stdin is in use."));
1146                         goto out;
1147                 }
1148
1149                 ret = populate_create_encryption_params_nvlists(hdl, NULL,
1150                     B_TRUE, keyformat, keylocation, props, &wkeydata,
1151                     &wkeylen);
1152                 if (ret != 0)
1153                         goto out;
1154         }
1155
1156         if (pzhp != NULL)
1157                 zfs_close(pzhp);
1158
1159         *wkeydata_out = wkeydata;
1160         *wkeylen_out = wkeylen;
1161         return (0);
1162
1163 out:
1164         if (pzhp != NULL)
1165                 zfs_close(pzhp);
1166         if (wkeydata != NULL)
1167                 free(wkeydata);
1168
1169         *wkeydata_out = NULL;
1170         *wkeylen_out = 0;
1171         return (ret);
1172 }
1173
1174 int
1175 zfs_crypto_clone_check(libzfs_handle_t *hdl, zfs_handle_t *origin_zhp,
1176     char *parent_name, nvlist_t *props)
1177 {
1178         (void) origin_zhp, (void) parent_name;
1179         char errbuf[1024];
1180
1181         (void) snprintf(errbuf, sizeof (errbuf),
1182             dgettext(TEXT_DOMAIN, "Encryption clone error"));
1183
1184         /*
1185          * No encryption properties should be specified. They will all be
1186          * inherited from the origin dataset.
1187          */
1188         if (nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYFORMAT)) ||
1189             nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYLOCATION)) ||
1190             nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_ENCRYPTION)) ||
1191             nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS))) {
1192                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1193                     "Encryption properties must inherit from origin dataset."));
1194                 return (EINVAL);
1195         }
1196
1197         return (0);
1198 }
1199
1200 typedef struct loadkeys_cbdata {
1201         uint64_t cb_numfailed;
1202         uint64_t cb_numattempted;
1203 } loadkey_cbdata_t;
1204
1205 static int
1206 load_keys_cb(zfs_handle_t *zhp, void *arg)
1207 {
1208         int ret;
1209         boolean_t is_encroot;
1210         loadkey_cbdata_t *cb = arg;
1211         uint64_t keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
1212
1213         /* only attempt to load keys for encryption roots */
1214         ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);
1215         if (ret != 0 || !is_encroot)
1216                 goto out;
1217
1218         /* don't attempt to load already loaded keys */
1219         if (keystatus == ZFS_KEYSTATUS_AVAILABLE)
1220                 goto out;
1221
1222         /* Attempt to load the key. Record status in cb. */
1223         cb->cb_numattempted++;
1224
1225         ret = zfs_crypto_load_key(zhp, B_FALSE, NULL);
1226         if (ret)
1227                 cb->cb_numfailed++;
1228
1229 out:
1230         (void) zfs_iter_filesystems(zhp, load_keys_cb, cb);
1231         zfs_close(zhp);
1232
1233         /* always return 0, since this function is best effort */
1234         return (0);
1235 }
1236
1237 /*
1238  * This function is best effort. It attempts to load all the keys for the given
1239  * filesystem and all of its children.
1240  */
1241 int
1242 zfs_crypto_attempt_load_keys(libzfs_handle_t *hdl, const char *fsname)
1243 {
1244         int ret;
1245         zfs_handle_t *zhp = NULL;
1246         loadkey_cbdata_t cb = { 0 };
1247
1248         zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
1249         if (zhp == NULL) {
1250                 ret = ENOENT;
1251                 goto error;
1252         }
1253
1254         ret = load_keys_cb(zfs_handle_dup(zhp), &cb);
1255         if (ret)
1256                 goto error;
1257
1258         (void) printf(gettext("%llu / %llu keys successfully loaded\n"),
1259             (u_longlong_t)(cb.cb_numattempted - cb.cb_numfailed),
1260             (u_longlong_t)cb.cb_numattempted);
1261
1262         if (cb.cb_numfailed != 0) {
1263                 ret = -1;
1264                 goto error;
1265         }
1266
1267         zfs_close(zhp);
1268         return (0);
1269
1270 error:
1271         if (zhp != NULL)
1272                 zfs_close(zhp);
1273         return (ret);
1274 }
1275
1276 int
1277 zfs_crypto_load_key(zfs_handle_t *zhp, boolean_t noop,
1278     const char *alt_keylocation)
1279 {
1280         int ret, attempts = 0;
1281         char errbuf[1024];
1282         uint64_t keystatus, iters = 0, salt = 0;
1283         uint64_t keyformat = ZFS_KEYFORMAT_NONE;
1284         char prop_keylocation[MAXNAMELEN];
1285         char prop_encroot[MAXNAMELEN];
1286         const char *keylocation = NULL;
1287         uint8_t *key_material = NULL, *key_data = NULL;
1288         size_t key_material_len;
1289         boolean_t is_encroot, can_retry = B_FALSE, correctible = B_FALSE;
1290
1291         (void) snprintf(errbuf, sizeof (errbuf),
1292             dgettext(TEXT_DOMAIN, "Key load error"));
1293
1294         /* check that encryption is enabled for the pool */
1295         if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {
1296                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1297                     "Encryption feature not enabled."));
1298                 ret = EINVAL;
1299                 goto error;
1300         }
1301
1302         /* Fetch the keyformat. Check that the dataset is encrypted. */
1303         keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT);
1304         if (keyformat == ZFS_KEYFORMAT_NONE) {
1305                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1306                     "'%s' is not encrypted."), zfs_get_name(zhp));
1307                 ret = EINVAL;
1308                 goto error;
1309         }
1310
1311         /*
1312          * Fetch the key location. Check that we are working with an
1313          * encryption root.
1314          */
1315         ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot);
1316         if (ret != 0) {
1317                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1318                     "Failed to get encryption root for '%s'."),
1319                     zfs_get_name(zhp));
1320                 goto error;
1321         } else if (!is_encroot) {
1322                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1323                     "Keys must be loaded for encryption root of '%s' (%s)."),
1324                     zfs_get_name(zhp), prop_encroot);
1325                 ret = EINVAL;
1326                 goto error;
1327         }
1328
1329         /*
1330          * if the caller has elected to override the keylocation property
1331          * use that instead
1332          */
1333         if (alt_keylocation != NULL) {
1334                 keylocation = alt_keylocation;
1335         } else {
1336                 ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION, prop_keylocation,
1337                     sizeof (prop_keylocation), NULL, NULL, 0, B_TRUE);
1338                 if (ret != 0) {
1339                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1340                             "Failed to get keylocation for '%s'."),
1341                             zfs_get_name(zhp));
1342                         goto error;
1343                 }
1344
1345                 keylocation = prop_keylocation;
1346         }
1347
1348         /* check that the key is unloaded unless this is a noop */
1349         if (!noop) {
1350                 keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
1351                 if (keystatus == ZFS_KEYSTATUS_AVAILABLE) {
1352                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1353                             "Key already loaded for '%s'."), zfs_get_name(zhp));
1354                         ret = EEXIST;
1355                         goto error;
1356                 }
1357         }
1358
1359         /* passphrase formats require a salt and pbkdf2_iters property */
1360         if (keyformat == ZFS_KEYFORMAT_PASSPHRASE) {
1361                 salt = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_SALT);
1362                 iters = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_ITERS);
1363         }
1364
1365 try_again:
1366         /* fetching and deriving the key are correctable errors. set the flag */
1367         correctible = B_TRUE;
1368
1369         /* get key material from key format and location */
1370         ret = get_key_material(zhp->zfs_hdl, B_FALSE, B_FALSE, keyformat,
1371             keylocation, zfs_get_name(zhp), &key_material, &key_material_len,
1372             &can_retry);
1373         if (ret != 0)
1374                 goto error;
1375
1376         /* derive a key from the key material */
1377         ret = derive_key(zhp->zfs_hdl, keyformat, iters, key_material, salt,
1378             &key_data);
1379         if (ret != 0)
1380                 goto error;
1381
1382         correctible = B_FALSE;
1383
1384         /* pass the wrapping key and noop flag to the ioctl */
1385         ret = lzc_load_key(zhp->zfs_name, noop, key_data, WRAPPING_KEY_LEN);
1386         if (ret != 0) {
1387                 switch (ret) {
1388                 case EPERM:
1389                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1390                             "Permission denied."));
1391                         break;
1392                 case EINVAL:
1393                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1394                             "Invalid parameters provided for dataset %s."),
1395                             zfs_get_name(zhp));
1396                         break;
1397                 case EEXIST:
1398                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1399                             "Key already loaded for '%s'."), zfs_get_name(zhp));
1400                         break;
1401                 case EBUSY:
1402                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1403                             "'%s' is busy."), zfs_get_name(zhp));
1404                         break;
1405                 case EACCES:
1406                         correctible = B_TRUE;
1407                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1408                             "Incorrect key provided for '%s'."),
1409                             zfs_get_name(zhp));
1410                         break;
1411                 }
1412                 goto error;
1413         }
1414
1415         free(key_material);
1416         free(key_data);
1417
1418         return (0);
1419
1420 error:
1421         zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
1422         if (key_material != NULL) {
1423                 free(key_material);
1424                 key_material = NULL;
1425         }
1426         if (key_data != NULL) {
1427                 free(key_data);
1428                 key_data = NULL;
1429         }
1430
1431         /*
1432          * Here we decide if it is ok to allow the user to retry entering their
1433          * key. The can_retry flag will be set if the user is entering their
1434          * key from an interactive prompt. The correctable flag will only be
1435          * set if an error that occurred could be corrected by retrying. Both
1436          * flags are needed to allow the user to attempt key entry again
1437          */
1438         attempts++;
1439         if (can_retry && correctible && attempts < MAX_KEY_PROMPT_ATTEMPTS)
1440                 goto try_again;
1441
1442         return (ret);
1443 }
1444
1445 int
1446 zfs_crypto_unload_key(zfs_handle_t *zhp)
1447 {
1448         int ret;
1449         char errbuf[1024];
1450         char prop_encroot[MAXNAMELEN];
1451         uint64_t keystatus, keyformat;
1452         boolean_t is_encroot;
1453
1454         (void) snprintf(errbuf, sizeof (errbuf),
1455             dgettext(TEXT_DOMAIN, "Key unload error"));
1456
1457         /* check that encryption is enabled for the pool */
1458         if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {
1459                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1460                     "Encryption feature not enabled."));
1461                 ret = EINVAL;
1462                 goto error;
1463         }
1464
1465         /* Fetch the keyformat. Check that the dataset is encrypted. */
1466         keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT);
1467         if (keyformat == ZFS_KEYFORMAT_NONE) {
1468                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1469                     "'%s' is not encrypted."), zfs_get_name(zhp));
1470                 ret = EINVAL;
1471                 goto error;
1472         }
1473
1474         /*
1475          * Fetch the key location. Check that we are working with an
1476          * encryption root.
1477          */
1478         ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot);
1479         if (ret != 0) {
1480                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1481                     "Failed to get encryption root for '%s'."),
1482                     zfs_get_name(zhp));
1483                 goto error;
1484         } else if (!is_encroot) {
1485                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1486                     "Keys must be unloaded for encryption root of '%s' (%s)."),
1487                     zfs_get_name(zhp), prop_encroot);
1488                 ret = EINVAL;
1489                 goto error;
1490         }
1491
1492         /* check that the key is loaded */
1493         keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
1494         if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
1495                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1496                     "Key already unloaded for '%s'."), zfs_get_name(zhp));
1497                 ret = EACCES;
1498                 goto error;
1499         }
1500
1501         /* call the ioctl */
1502         ret = lzc_unload_key(zhp->zfs_name);
1503
1504         if (ret != 0) {
1505                 switch (ret) {
1506                 case EPERM:
1507                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1508                             "Permission denied."));
1509                         break;
1510                 case EACCES:
1511                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1512                             "Key already unloaded for '%s'."),
1513                             zfs_get_name(zhp));
1514                         break;
1515                 case EBUSY:
1516                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1517                             "'%s' is busy."), zfs_get_name(zhp));
1518                         break;
1519                 }
1520                 zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
1521         }
1522
1523         return (ret);
1524
1525 error:
1526         zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
1527         return (ret);
1528 }
1529
1530 static int
1531 zfs_crypto_verify_rewrap_nvlist(zfs_handle_t *zhp, nvlist_t *props,
1532     nvlist_t **props_out, char *errbuf)
1533 {
1534         int ret;
1535         nvpair_t *elem = NULL;
1536         zfs_prop_t prop;
1537         nvlist_t *new_props = NULL;
1538
1539         new_props = fnvlist_alloc();
1540
1541         /*
1542          * loop through all provided properties, we should only have
1543          * keyformat, keylocation and pbkdf2iters. The actual validation of
1544          * values is done by zfs_valid_proplist().
1545          */
1546         while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
1547                 const char *propname = nvpair_name(elem);
1548                 prop = zfs_name_to_prop(propname);
1549
1550                 switch (prop) {
1551                 case ZFS_PROP_PBKDF2_ITERS:
1552                 case ZFS_PROP_KEYFORMAT:
1553                 case ZFS_PROP_KEYLOCATION:
1554                         break;
1555                 default:
1556                         ret = EINVAL;
1557                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1558                             "Only keyformat, keylocation and pbkdf2iters may "
1559                             "be set with this command."));
1560                         goto error;
1561                 }
1562         }
1563
1564         new_props = zfs_valid_proplist(zhp->zfs_hdl, zhp->zfs_type, props,
1565             zfs_prop_get_int(zhp, ZFS_PROP_ZONED), NULL, zhp->zpool_hdl,
1566             B_TRUE, errbuf);
1567         if (new_props == NULL) {
1568                 ret = EINVAL;
1569                 goto error;
1570         }
1571
1572         *props_out = new_props;
1573         return (0);
1574
1575 error:
1576         nvlist_free(new_props);
1577         *props_out = NULL;
1578         return (ret);
1579 }
1580
1581 int
1582 zfs_crypto_rewrap(zfs_handle_t *zhp, nvlist_t *raw_props, boolean_t inheritkey)
1583 {
1584         int ret;
1585         char errbuf[1024];
1586         boolean_t is_encroot;
1587         nvlist_t *props = NULL;
1588         uint8_t *wkeydata = NULL;
1589         uint_t wkeylen = 0;
1590         dcp_cmd_t cmd = (inheritkey) ? DCP_CMD_INHERIT : DCP_CMD_NEW_KEY;
1591         uint64_t crypt, pcrypt, keystatus, pkeystatus;
1592         uint64_t keyformat = ZFS_KEYFORMAT_NONE;
1593         zfs_handle_t *pzhp = NULL;
1594         char *keylocation = NULL;
1595         char origin_name[MAXNAMELEN];
1596         char prop_keylocation[MAXNAMELEN];
1597         char parent_name[ZFS_MAX_DATASET_NAME_LEN];
1598
1599         (void) snprintf(errbuf, sizeof (errbuf),
1600             dgettext(TEXT_DOMAIN, "Key change error"));
1601
1602         /* check that encryption is enabled for the pool */
1603         if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {
1604                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1605                     "Encryption feature not enabled."));
1606                 ret = EINVAL;
1607                 goto error;
1608         }
1609
1610         /* get crypt from dataset */
1611         crypt = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION);
1612         if (crypt == ZIO_CRYPT_OFF) {
1613                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1614                     "Dataset not encrypted."));
1615                 ret = EINVAL;
1616                 goto error;
1617         }
1618
1619         /* get the encryption root of the dataset */
1620         ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);
1621         if (ret != 0) {
1622                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1623                     "Failed to get encryption root for '%s'."),
1624                     zfs_get_name(zhp));
1625                 goto error;
1626         }
1627
1628         /* Clones use their origin's key and cannot rewrap it */
1629         ret = zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin_name,
1630             sizeof (origin_name), NULL, NULL, 0, B_TRUE);
1631         if (ret == 0 && strcmp(origin_name, "") != 0) {
1632                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1633                     "Keys cannot be changed on clones."));
1634                 ret = EINVAL;
1635                 goto error;
1636         }
1637
1638         /*
1639          * If the user wants to use the inheritkey variant of this function
1640          * we don't need to collect any crypto arguments.
1641          */
1642         if (!inheritkey) {
1643                 /* validate the provided properties */
1644                 ret = zfs_crypto_verify_rewrap_nvlist(zhp, raw_props, &props,
1645                     errbuf);
1646                 if (ret != 0)
1647                         goto error;
1648
1649                 /*
1650                  * Load keyformat and keylocation from the nvlist. Fetch from
1651                  * the dataset properties if not specified.
1652                  */
1653                 (void) nvlist_lookup_uint64(props,
1654                     zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat);
1655                 (void) nvlist_lookup_string(props,
1656                     zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);
1657
1658                 if (is_encroot) {
1659                         /*
1660                          * If this is already an encryption root, just keep
1661                          * any properties not set by the user.
1662                          */
1663                         if (keyformat == ZFS_KEYFORMAT_NONE) {
1664                                 keyformat = zfs_prop_get_int(zhp,
1665                                     ZFS_PROP_KEYFORMAT);
1666                                 ret = nvlist_add_uint64(props,
1667                                     zfs_prop_to_name(ZFS_PROP_KEYFORMAT),
1668                                     keyformat);
1669                                 if (ret != 0) {
1670                                         zfs_error_aux(zhp->zfs_hdl,
1671                                             dgettext(TEXT_DOMAIN, "Failed to "
1672                                             "get existing keyformat "
1673                                             "property."));
1674                                         goto error;
1675                                 }
1676                         }
1677
1678                         if (keylocation == NULL) {
1679                                 ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION,
1680                                     prop_keylocation, sizeof (prop_keylocation),
1681                                     NULL, NULL, 0, B_TRUE);
1682                                 if (ret != 0) {
1683                                         zfs_error_aux(zhp->zfs_hdl,
1684                                             dgettext(TEXT_DOMAIN, "Failed to "
1685                                             "get existing keylocation "
1686                                             "property."));
1687                                         goto error;
1688                                 }
1689
1690                                 keylocation = prop_keylocation;
1691                         }
1692                 } else {
1693                         /* need a new key for non-encryption roots */
1694                         if (keyformat == ZFS_KEYFORMAT_NONE) {
1695                                 ret = EINVAL;
1696                                 zfs_error_aux(zhp->zfs_hdl,
1697                                     dgettext(TEXT_DOMAIN, "Keyformat required "
1698                                     "for new encryption root."));
1699                                 goto error;
1700                         }
1701
1702                         /* default to prompt if no keylocation is specified */
1703                         if (keylocation == NULL) {
1704                                 keylocation = "prompt";
1705                                 ret = nvlist_add_string(props,
1706                                     zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
1707                                     keylocation);
1708                                 if (ret != 0)
1709                                         goto error;
1710                         }
1711                 }
1712
1713                 /* fetch the new wrapping key and associated properties */
1714                 ret = populate_create_encryption_params_nvlists(zhp->zfs_hdl,
1715                     zhp, B_TRUE, keyformat, keylocation, props, &wkeydata,
1716                     &wkeylen);
1717                 if (ret != 0)
1718                         goto error;
1719         } else {
1720                 /* check that zhp is an encryption root */
1721                 if (!is_encroot) {
1722                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1723                             "Key inheritting can only be performed on "
1724                             "encryption roots."));
1725                         ret = EINVAL;
1726                         goto error;
1727                 }
1728
1729                 /* get the parent's name */
1730                 ret = zfs_parent_name(zhp, parent_name, sizeof (parent_name));
1731                 if (ret != 0) {
1732                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1733                             "Root dataset cannot inherit key."));
1734                         ret = EINVAL;
1735                         goto error;
1736                 }
1737
1738                 /* get a handle to the parent */
1739                 pzhp = make_dataset_handle(zhp->zfs_hdl, parent_name);
1740                 if (pzhp == NULL) {
1741                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1742                             "Failed to lookup parent."));
1743                         ret = ENOENT;
1744                         goto error;
1745                 }
1746
1747                 /* parent must be encrypted */
1748                 pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION);
1749                 if (pcrypt == ZIO_CRYPT_OFF) {
1750                         zfs_error_aux(pzhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1751                             "Parent must be encrypted."));
1752                         ret = EINVAL;
1753                         goto error;
1754                 }
1755
1756                 /* check that the parent's key is loaded */
1757                 pkeystatus = zfs_prop_get_int(pzhp, ZFS_PROP_KEYSTATUS);
1758                 if (pkeystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
1759                         zfs_error_aux(pzhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1760                             "Parent key must be loaded."));
1761                         ret = EACCES;
1762                         goto error;
1763                 }
1764         }
1765
1766         /* check that the key is loaded */
1767         keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
1768         if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
1769                 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1770                     "Key must be loaded."));
1771                 ret = EACCES;
1772                 goto error;
1773         }
1774
1775         /* call the ioctl */
1776         ret = lzc_change_key(zhp->zfs_name, cmd, props, wkeydata, wkeylen);
1777         if (ret != 0) {
1778                 switch (ret) {
1779                 case EPERM:
1780                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1781                             "Permission denied."));
1782                         break;
1783                 case EINVAL:
1784                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1785                             "Invalid properties for key change."));
1786                         break;
1787                 case EACCES:
1788                         zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
1789                             "Key is not currently loaded."));
1790                         break;
1791                 }
1792                 zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
1793         }
1794
1795         if (pzhp != NULL)
1796                 zfs_close(pzhp);
1797         if (props != NULL)
1798                 nvlist_free(props);
1799         if (wkeydata != NULL)
1800                 free(wkeydata);
1801
1802         return (ret);
1803
1804 error:
1805         if (pzhp != NULL)
1806                 zfs_close(pzhp);
1807         if (props != NULL)
1808                 nvlist_free(props);
1809         if (wkeydata != NULL)
1810                 free(wkeydata);
1811
1812         zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
1813         return (ret);
1814 }