libzfs_crypto.c

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

FreeBSD/Linux Kernel Cross Reference
sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c
