lib/luks2/luks2_token.c

   1 /*
   2  * LUKS - Linux Unified Key Setup v2, token handling
   3  *
   4  * Copyright (C) 2016-2023 Red Hat, Inc. All rights reserved.
   5  * Copyright (C) 2016-2023 Milan Broz
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <ctype.h>
  23 #include <dlfcn.h>
  24
  25 #include "luks2_internal.h"
  26
  27 #if USE_EXTERNAL_TOKENS
  28 static bool external_tokens_enabled = true;
  29 #else
  30 static bool external_tokens_enabled = false;
  31 #endif
  32
  33 static struct crypt_token_handler_internal token_handlers[LUKS2_TOKENS_MAX] = {
  34         /* keyring builtin token */
  35         {
  36           .version = 1,
  37           .u = {
  38                   .v1 = { .name = LUKS2_TOKEN_KEYRING,
  39                           .open = keyring_open,
  40                           .buffer_free = keyring_buffer_free,
  41                           .validate = keyring_validate,
  42                           .dump = keyring_dump }
  43                }
  44         }
  45 };
  46
  47 void crypt_token_external_disable(void)
  48 {
  49         external_tokens_enabled = false;
  50 }
  51
  52 const char *crypt_token_external_path(void)
  53 {
  54         return external_tokens_enabled ? EXTERNAL_LUKS2_TOKENS_PATH : NULL;
  55 }
  56
  57 #if USE_EXTERNAL_TOKENS
  58 static void *token_dlvsym(struct crypt_device *cd,
  59                 void *handle,
  60                 const char *symbol,
  61                 const char *version)
  62 {
  63         char *error;
  64         void *sym;
  65
  66 #ifdef HAVE_DLVSYM
  67         log_dbg(cd, "Loading symbol %s@%s.", symbol, version);
  68         sym = dlvsym(handle, symbol, version);
  69 #else
  70         log_dbg(cd, "Loading default version of symbol %s.", symbol);
  71         sym = dlsym(handle, symbol);
  72 #endif
  73         error = dlerror();
  74
  75         if (error)
  76                 log_dbg(cd, "%s", error);
  77
  78         return sym;
  79 }
  80 #endif
  81
  82 static bool token_validate_v1(struct crypt_device *cd, const crypt_token_handler *h)
  83 {
  84         if (!h)
  85                 return false;
  86
  87         if (!h->name) {
  88                 log_dbg(cd, "Error: token handler does not provide name attribute.");
  89                 return false;
  90         }
  91
  92         if (!h->open) {
  93                 log_dbg(cd, "Error: token handler does not provide open function.");
  94                 return false;
  95         }
  96
  97         return true;
  98 }
  99
 100 #if USE_EXTERNAL_TOKENS
 101 static bool token_validate_v2(struct crypt_device *cd, const struct crypt_token_handler_internal *h)
 102 {
 103         if (!h)
 104                 return false;
 105
 106         if (!token_validate_v1(cd, &h->u.v1))
 107                 return false;
 108
 109         if (!h->u.v2.version) {
 110                 log_dbg(cd, "Error: token handler does not provide " CRYPT_TOKEN_ABI_VERSION " function.");
 111                 return false;
 112         }
 113
 114         return true;
 115 }
 116
 117 static bool external_token_name_valid(const char *name)
 118 {
 119         if (!*name || strlen(name) > LUKS2_TOKEN_NAME_MAX)
 120                 return false;
 121
 122         while (*name) {
 123                 if (!isalnum(*name) && *name != '-' && *name != '_')
 124                         return false;
 125                 name++;
 126         }
 127
 128         return true;
 129 }
 130 #endif
 131
 132 static int
 133 crypt_token_load_external(struct crypt_device *cd, const char *name, struct crypt_token_handler_internal *ret)
 134 {
 135 #if USE_EXTERNAL_TOKENS
 136         struct crypt_token_handler_v2 *token;
 137         void *h;
 138         char buf[PATH_MAX];
 139         int r;
 140
 141         if (!external_tokens_enabled)
 142                 return -ENOTSUP;
 143
 144         if (!ret || !name)
 145                 return -EINVAL;
 146
 147         if (!external_token_name_valid(name)) {
 148                 log_dbg(cd, "External token name (%.*s) invalid.", LUKS2_TOKEN_NAME_MAX, name);
 149                 return -EINVAL;
 150         }
 151
 152         token = &ret->u.v2;
 153
 154         r = snprintf(buf, sizeof(buf), "%s/libcryptsetup-token-%s.so", crypt_token_external_path(), name);
 155         if (r < 0 || (size_t)r >= sizeof(buf))
 156                 return -EINVAL;
 157
 158         assert(*buf == '/');
 159
 160         log_dbg(cd, "Trying to load %s.", buf);
 161
 162         h = dlopen(buf, RTLD_LAZY);
 163         if (!h) {
 164                 log_dbg(cd, "%s", dlerror());
 165                 return -EINVAL;
 166         }
 167         dlerror();
 168
 169         token->name = strdup(name);
 170         token->open = token_dlvsym(cd, h, CRYPT_TOKEN_ABI_OPEN, CRYPT_TOKEN_ABI_VERSION1);
 171         token->buffer_free = token_dlvsym(cd, h, CRYPT_TOKEN_ABI_BUFFER_FREE, CRYPT_TOKEN_ABI_VERSION1);
 172         token->validate = token_dlvsym(cd, h, CRYPT_TOKEN_ABI_VALIDATE, CRYPT_TOKEN_ABI_VERSION1);
 173         token->dump = token_dlvsym(cd, h, CRYPT_TOKEN_ABI_DUMP, CRYPT_TOKEN_ABI_VERSION1);
 174         token->open_pin = token_dlvsym(cd, h, CRYPT_TOKEN_ABI_OPEN_PIN, CRYPT_TOKEN_ABI_VERSION1);
 175         token->version = token_dlvsym(cd, h, CRYPT_TOKEN_ABI_VERSION, CRYPT_TOKEN_ABI_VERSION1);
 176
 177         if (!token_validate_v2(cd, ret)) {
 178                 free(CONST_CAST(void *)token->name);
 179                 dlclose(h);
 180                 memset(token, 0, sizeof(*token));
 181                 return -EINVAL;
 182         }
 183
 184         /* Token loaded, possible error here means only debug message fail and can be ignored */
 185         r = snprintf(buf, sizeof(buf), "%s", token->version() ?: "");
 186         if (r < 0 || (size_t)r >= sizeof(buf))
 187                 *buf = '\0';
 188
 189         log_dbg(cd, "Token handler %s-%s loaded successfully.", token->name, buf);
 190
 191         token->dlhandle = h;
 192         ret->version = 2;
 193
 194         return 0;
 195 #else
 196         return -ENOTSUP;
 197 #endif
 198 }
 199
 200 static int is_builtin_candidate(const char *type)
 201 {
 202         return !strncmp(type, LUKS2_BUILTIN_TOKEN_PREFIX, LUKS2_BUILTIN_TOKEN_PREFIX_LEN);
 203 }
 204
 205 static int crypt_token_find_free(struct crypt_device *cd, const char *name, int *index)
 206 {
 207         int i;
 208
 209         if (is_builtin_candidate(name)) {
 210                 log_dbg(cd, "'" LUKS2_BUILTIN_TOKEN_PREFIX "' is reserved prefix for builtin tokens.");
 211                 return -EINVAL;
 212         }
 213
 214         for (i = 0; i < LUKS2_TOKENS_MAX && token_handlers[i].u.v1.name; i++) {
 215                 if (!strcmp(token_handlers[i].u.v1.name, name)) {
 216                         log_dbg(cd, "Keyslot handler %s is already registered.", name);
 217                         return -EINVAL;
 218                 }
 219         }
 220
 221         if (i == LUKS2_TOKENS_MAX)
 222                 return -EINVAL;
 223
 224         if (index)
 225                 *index = i;
 226
 227         return 0;
 228 }
 229
 230 int crypt_token_register(const crypt_token_handler *handler)
 231 {
 232         int i, r;
 233
 234         if (!token_validate_v1(NULL, handler))
 235                 return -EINVAL;
 236
 237         r = crypt_token_find_free(NULL, handler->name, &i);
 238         if (r < 0)
 239                 return r;
 240
 241         token_handlers[i].version = 1;
 242         token_handlers[i].u.v1 = *handler;
 243         return 0;
 244 }
 245
 246 void crypt_token_unload_external_all(struct crypt_device *cd)
 247 {
 248 #if USE_EXTERNAL_TOKENS
 249         int i;
 250
 251         for (i = LUKS2_TOKENS_MAX - 1; i >= 0; i--) {
 252                 if (token_handlers[i].version < 2)
 253                         continue;
 254
 255                 log_dbg(cd, "Unloading %s token handler.", token_handlers[i].u.v2.name);
 256
 257                 free(CONST_CAST(void *)token_handlers[i].u.v2.name);
 258
 259                 if (dlclose(CONST_CAST(void *)token_handlers[i].u.v2.dlhandle))
 260                         log_dbg(cd, "%s", dlerror());
 261         }
 262 #endif
 263 }
 264
 265 static const void
 266 *LUKS2_token_handler_type(struct crypt_device *cd, const char *type)
 267 {
 268         int i;
 269
 270         for (i = 0; i < LUKS2_TOKENS_MAX && token_handlers[i].u.v1.name; i++)
 271                 if (!strcmp(token_handlers[i].u.v1.name, type))
 272                         return &token_handlers[i].u;
 273
 274         if (i >= LUKS2_TOKENS_MAX)
 275                 return NULL;
 276
 277         if (is_builtin_candidate(type))
 278                 return NULL;
 279
 280         if (crypt_token_load_external(cd, type, &token_handlers[i]))
 281                 return NULL;
 282
 283         return &token_handlers[i].u;
 284 }
 285
 286 static const void
 287 *LUKS2_token_handler(struct crypt_device *cd, int token)
 288 {
 289         struct luks2_hdr *hdr;
 290         json_object *jobj1, *jobj2;
 291
 292         if (token < 0)
 293                 return NULL;
 294
 295         if (!(hdr = crypt_get_hdr(cd, CRYPT_LUKS2)))
 296                 return NULL;
 297
 298         if (!(jobj1 = LUKS2_get_token_jobj(hdr, token)))
 299                 return NULL;
 300
 301         if (!json_object_object_get_ex(jobj1, "type", &jobj2))
 302                 return NULL;
 303
 304         return LUKS2_token_handler_type(cd, json_object_get_string(jobj2));
 305 }
 306
 307 static int LUKS2_token_find_free(struct luks2_hdr *hdr)
 308 {
 309         int i;
 310
 311         for (i = 0; i < LUKS2_TOKENS_MAX; i++)
 312                 if (!LUKS2_get_token_jobj(hdr, i))
 313                         return i;
 314
 315         return -EINVAL;
 316 }
 317
 318 int LUKS2_token_create(struct crypt_device *cd,
 319         struct luks2_hdr *hdr,
 320         int token,
 321         const char *json,
 322         int commit)
 323 {
 324         const crypt_token_handler *h;
 325         json_object *jobj_tokens, *jobj_type, *jobj;
 326         enum json_tokener_error jerr;
 327         char num[16];
 328
 329         if (token == CRYPT_ANY_TOKEN) {
 330                 if (!json)
 331                         return -EINVAL;
 332                 token = LUKS2_token_find_free(hdr);
 333         }
 334
 335         if (token < 0 || token >= LUKS2_TOKENS_MAX)
 336                 return -EINVAL;
 337
 338         if (!json_object_object_get_ex(hdr->jobj, "tokens", &jobj_tokens))
 339                 return -EINVAL;
 340
 341         if (snprintf(num, sizeof(num), "%d", token) < 0)
 342                 return -EINVAL;
 343
 344         /* Remove token */
 345         if (!json)
 346                 json_object_object_del(jobj_tokens, num);
 347         else {
 348
 349                 jobj = json_tokener_parse_verbose(json, &jerr);
 350                 if (!jobj) {
 351                         log_dbg(cd, "Token JSON parse failed.");
 352                         return -EINVAL;
 353                 }
 354
 355                 if (LUKS2_token_validate(cd, hdr->jobj, jobj, num)) {
 356                         json_object_put(jobj);
 357                         return -EINVAL;
 358                 }
 359
 360                 json_object_object_get_ex(jobj, "type", &jobj_type);
 361                 h = LUKS2_token_handler_type(cd, json_object_get_string(jobj_type));
 362
 363                 if (is_builtin_candidate(json_object_get_string(jobj_type)) && !h) {
 364                         log_dbg(cd, "%s is builtin token candidate with missing handler",
 365                                 json_object_get_string(jobj_type));
 366                         json_object_put(jobj);
 367                         return -EINVAL;
 368                 }
 369
 370                 if (h && h->validate && h->validate(cd, json)) {
 371                         json_object_put(jobj);
 372                         log_dbg(cd, "Token type %s validation failed.", h->name);
 373                         return -EINVAL;
 374                 }
 375
 376                 json_object_object_add(jobj_tokens, num, jobj);
 377                 if (LUKS2_check_json_size(cd, hdr)) {
 378                         log_dbg(cd, "Not enough space in header json area for new token.");
 379                         json_object_object_del(jobj_tokens, num);
 380                         return -ENOSPC;
 381                 }
 382         }
 383
 384         if (commit)
 385                 return LUKS2_hdr_write(cd, hdr) ?: token;
 386
 387         return token;
 388 }
 389
 390 crypt_token_info LUKS2_token_status(struct crypt_device *cd,
 391         struct luks2_hdr *hdr,
 392         int token,
 393         const char **type)
 394 {
 395         const char *tmp;
 396         const crypt_token_handler *th;
 397         json_object *jobj_type, *jobj_token;
 398
 399         if (token < 0 || token >= LUKS2_TOKENS_MAX)
 400                 return CRYPT_TOKEN_INVALID;
 401
 402         if (!(jobj_token = LUKS2_get_token_jobj(hdr, token)))
 403                 return CRYPT_TOKEN_INACTIVE;
 404
 405         json_object_object_get_ex(jobj_token, "type", &jobj_type);
 406         tmp = json_object_get_string(jobj_type);
 407
 408         if ((th = LUKS2_token_handler_type(cd, tmp))) {
 409                 if (type)
 410                         *type = th->name;
 411                 return is_builtin_candidate(tmp) ? CRYPT_TOKEN_INTERNAL : CRYPT_TOKEN_EXTERNAL;
 412         }
 413
 414         if (type)
 415                 *type = tmp;
 416
 417         return is_builtin_candidate(tmp) ? CRYPT_TOKEN_INTERNAL_UNKNOWN : CRYPT_TOKEN_EXTERNAL_UNKNOWN;
 418 }
 419
 420 static const char *token_json_to_string(json_object *jobj_token)
 421 {
 422         return json_object_to_json_string_ext(jobj_token,
 423                 JSON_C_TO_STRING_PLAIN | JSON_C_TO_STRING_NOSLASHESCAPE);
 424 }
 425
 426 static int token_is_usable(struct luks2_hdr *hdr, json_object *jobj_token, int segment,
 427                            crypt_keyslot_priority minimal_priority, bool requires_keyslot)
 428 {
 429         crypt_keyslot_priority keyslot_priority;
 430         json_object *jobj_array;
 431         int i, keyslot, len, r = -ENOENT;
 432
 433         if (!jobj_token)
 434                 return -EINVAL;
 435
 436         if (!json_object_object_get_ex(jobj_token, "keyslots", &jobj_array))
 437                 return -EINVAL;
 438
 439         if (segment < 0 && segment != CRYPT_ANY_SEGMENT)
 440                 return -EINVAL;
 441
 442         /* no assigned keyslot returns -ENOENT even for CRYPT_ANY_SEGMENT */
 443         len = json_object_array_length(jobj_array);
 444         if (len < 0)
 445                 return -ENOENT;
 446
 447         if (!requires_keyslot)
 448                 return 0;
 449
 450         if (!len)
 451                 return -ENOENT;
 452
 453         for (i = 0; i < len; i++) {
 454                 keyslot = atoi(json_object_get_string(json_object_array_get_idx(jobj_array, i)));
 455
 456                 keyslot_priority = LUKS2_keyslot_priority_get(hdr, keyslot);
 457                 if (keyslot_priority == CRYPT_SLOT_PRIORITY_INVALID)
 458                         return -EINVAL;
 459
 460                 if (keyslot_priority < minimal_priority)
 461                         continue;
 462
 463                 r = LUKS2_keyslot_for_segment(hdr, keyslot, segment);
 464                 if (r != -ENOENT)
 465                         return r;
 466         }
 467
 468         return r;
 469 }
 470
 471 static int translate_errno(struct crypt_device *cd, int ret_val, const char *type)
 472 {
 473         if ((ret_val > 0 || ret_val == -EINVAL || ret_val == -EPERM) && !is_builtin_candidate(type)) {
 474                 log_dbg(cd, "%s token handler returned %d. Changing to %d.", type, ret_val, -ENOENT);
 475                 ret_val = -ENOENT;
 476         }
 477
 478         return ret_val;
 479 }
 480
 481 static int token_open(struct crypt_device *cd,
 482         struct luks2_hdr *hdr,
 483         int token,
 484         json_object *jobj_token,
 485         const char *type,
 486         int segment,
 487         crypt_keyslot_priority priority,
 488         const char *pin,
 489         size_t pin_size,
 490         char **buffer,
 491         size_t *buffer_len,
 492         void *usrptr,
 493         bool requires_keyslot)
 494 {
 495         const struct crypt_token_handler_v2 *h;
 496         json_object *jobj_type;
 497         int r;
 498
 499         assert(token >= 0);
 500         assert(jobj_token);
 501         assert(priority >= 0);
 502
 503         if (type) {
 504                 if (!json_object_object_get_ex(jobj_token, "type", &jobj_type))
 505                         return -EINVAL;
 506                 if (strcmp(type, json_object_get_string(jobj_type)))
 507                         return -ENOENT;
 508         }
 509
 510         r = token_is_usable(hdr, jobj_token, segment, priority, requires_keyslot);
 511         if (r < 0) {
 512                 if (r == -ENOENT)
 513                         log_dbg(cd, "Token %d unusable for segment %d with desired keyslot priority %d.",
 514                                 token, segment, priority);
 515                 return r;
 516         }
 517
 518         if (!(h = LUKS2_token_handler(cd, token)))
 519                 return -ENOENT;
 520
 521         if (h->validate && h->validate(cd, token_json_to_string(jobj_token))) {
 522                 log_dbg(cd, "Token %d (%s) validation failed.", token, h->name);
 523                 return -ENOENT;
 524         }
 525
 526         if (pin && !h->open_pin)
 527                 r = -ENOENT;
 528         else if (pin)
 529                 r = translate_errno(cd, h->open_pin(cd, token, pin, pin_size, buffer, buffer_len, usrptr), h->name);
 530         else
 531                 r = translate_errno(cd, h->open(cd, token, buffer, buffer_len, usrptr), h->name);
 532         if (r < 0)
 533                 log_dbg(cd, "Token %d (%s) open failed with %d.", token, h->name, r);
 534
 535         return r;
 536 }
 537
 538 static void LUKS2_token_buffer_free(struct crypt_device *cd,
 539                 int token,
 540                 void *buffer,
 541                 size_t buffer_len)
 542 {
 543         const crypt_token_handler *h = LUKS2_token_handler(cd, token);
 544
 545         if (h && h->buffer_free)
 546                 h->buffer_free(buffer, buffer_len);
 547         else {
 548                 crypt_safe_memzero(buffer, buffer_len);
 549                 free(buffer);
 550         }
 551 }
 552
 553 static bool break_loop_retval(int r)
 554 {
 555         if (r == -ENOENT || r == -EPERM || r == -EAGAIN || r == -ENOANO)
 556                 return false;
 557         return true;
 558 }
 559
 560 static void update_return_errno(int r, int *stored)
 561 {
 562         if (*stored == -ENOANO)
 563                 return;
 564         else if (r == -ENOANO)
 565                 *stored = r;
 566         else if (r == -EAGAIN && *stored != -ENOANO)
 567                 *stored = r;
 568         else if (r == -EPERM && (*stored != -ENOANO && *stored != -EAGAIN))
 569                 *stored = r;
 570 }
 571
 572 static int LUKS2_keyslot_open_by_token(struct crypt_device *cd,
 573         struct luks2_hdr *hdr,
 574         int token,
 575         int segment,
 576         crypt_keyslot_priority priority,
 577         const char *buffer,
 578         size_t buffer_len,
 579         struct volume_key **vk)
 580 {
 581         crypt_keyslot_priority keyslot_priority;
 582         json_object *jobj_token, *jobj_token_keyslots, *jobj_type, *jobj;
 583         unsigned int num = 0;
 584         int i, r = -ENOENT, stored_retval = -ENOENT;
 585
 586         jobj_token = LUKS2_get_token_jobj(hdr, token);
 587         if (!jobj_token)
 588                 return -EINVAL;
 589
 590         if (!json_object_object_get_ex(jobj_token, "type", &jobj_type))
 591                 return -EINVAL;
 592
 593         json_object_object_get_ex(jobj_token, "keyslots", &jobj_token_keyslots);
 594         if (!jobj_token_keyslots)
 595                 return -EINVAL;
 596
 597         /* Try to open keyslot referenced in token */
 598         for (i = 0; i < (int) json_object_array_length(jobj_token_keyslots) && r < 0; i++) {
 599                 jobj = json_object_array_get_idx(jobj_token_keyslots, i);
 600                 num = atoi(json_object_get_string(jobj));
 601                 keyslot_priority = LUKS2_keyslot_priority_get(hdr, num);
 602                 if (keyslot_priority == CRYPT_SLOT_PRIORITY_INVALID)
 603                         return -EINVAL;
 604                 if (keyslot_priority < priority)
 605                         continue;
 606                 log_dbg(cd, "Trying to open keyslot %u with token %d (type %s).",
 607                         num, token, json_object_get_string(jobj_type));
 608                 r = LUKS2_keyslot_open(cd, num, segment, buffer, buffer_len, vk);
 609                 /* short circuit on fatal error */
 610                 if (r < 0 && r != -EPERM && r != -ENOENT)
 611                         return r;
 612                 /* save -EPERM in case no other keyslot is usable */
 613                 if (r == -EPERM)
 614                         stored_retval = r;
 615         }
 616
 617         if (r < 0)
 618                 return stored_retval;
 619
 620         return num;
 621 }
 622
 623 static bool token_is_blocked(int token, uint32_t *block_list)
 624 {
 625         /* it is safe now, but have assert in case LUKS2_TOKENS_MAX grows */
 626         assert(token >= 0 && (size_t)token < BITFIELD_SIZE(block_list));
 627
 628         return (*block_list & (UINT32_C(1) << token));
 629 }
 630
 631 static void token_block(int token, uint32_t *block_list)
 632 {
 633         /* it is safe now, but have assert in case LUKS2_TOKENS_MAX grows */
 634         assert(token >= 0 && (size_t)token < BITFIELD_SIZE(block_list));
 635
 636         *block_list |= (UINT32_C(1) << token);
 637 }
 638
 639 static int token_open_priority(struct crypt_device *cd,
 640         struct luks2_hdr *hdr,
 641         json_object *jobj_tokens,
 642         const char *type,
 643         int segment,
 644         crypt_keyslot_priority priority,
 645         const char *pin,
 646         size_t pin_size,
 647         void *usrptr,
 648         int *stored_retval,
 649         uint32_t *block_list,
 650         struct volume_key **vk)
 651 {
 652         char *buffer;
 653         size_t buffer_size;
 654         int token, r;
 655
 656         assert(stored_retval);
 657         assert(block_list);
 658
 659         json_object_object_foreach(jobj_tokens, slot, val) {
 660                 token = atoi(slot);
 661                 if (token_is_blocked(token, block_list))
 662                         continue;
 663                 r = token_open(cd, hdr, token, val, type, segment, priority, pin, pin_size, &buffer, &buffer_size, usrptr, true);
 664                 if (!r) {
 665                         r = LUKS2_keyslot_open_by_token(cd, hdr, token, segment, priority,
 666                                                         buffer, buffer_size, vk);
 667                         LUKS2_token_buffer_free(cd, token, buffer, buffer_size);
 668                 }
 669
 670                 if (r == -ENOANO)
 671                         token_block(token, block_list);
 672
 673                 if (break_loop_retval(r))
 674                         return r;
 675
 676                 update_return_errno(r, stored_retval);
 677         }
 678
 679         return *stored_retval;
 680 }
 681
 682 static int token_open_any(struct crypt_device *cd, struct luks2_hdr *hdr, const char *type, int segment,
 683                           const char *pin, size_t pin_size, void *usrptr, struct volume_key **vk)
 684 {
 685         json_object *jobj_tokens;
 686         int r, retval = -ENOENT;
 687         uint32_t blocked = 0; /* bitmap with tokens blocked from loop by returning -ENOANO (wrong/missing pin) */
 688
 689         json_object_object_get_ex(hdr->jobj, "tokens", &jobj_tokens);
 690
 691         /* passing usrptr for CRYPT_ANY_TOKEN does not make sense without specific type */
 692         if (!type)
 693                 usrptr = NULL;
 694
 695         r = token_open_priority(cd, hdr, jobj_tokens, type, segment, CRYPT_SLOT_PRIORITY_PREFER,
 696                                 pin, pin_size, usrptr, &retval, &blocked, vk);
 697         if (break_loop_retval(r))
 698                 return r;
 699
 700         return token_open_priority(cd, hdr, jobj_tokens, type, segment, CRYPT_SLOT_PRIORITY_NORMAL,
 701                                    pin, pin_size, usrptr, &retval, &blocked, vk);
 702 }
 703
 704 int LUKS2_token_unlock_key(struct crypt_device *cd,
 705         struct luks2_hdr *hdr,
 706         int token,
 707         const char *type,
 708         const char *pin,
 709         size_t pin_size,
 710         int segment,
 711         void *usrptr,
 712         struct volume_key **vk)
 713 {
 714         char *buffer;
 715         size_t buffer_size;
 716         json_object *jobj_token;
 717         int r = -ENOENT;
 718
 719         assert(vk);
 720
 721         if (segment == CRYPT_DEFAULT_SEGMENT)
 722                 segment = LUKS2_get_default_segment(hdr);
 723
 724         if (segment < 0 && segment != CRYPT_ANY_SEGMENT)
 725                 return -EINVAL;
 726
 727         if (token >= 0 && token < LUKS2_TOKENS_MAX) {
 728                 if ((jobj_token = LUKS2_get_token_jobj(hdr, token))) {
 729                         r = token_open(cd, hdr, token, jobj_token, type, segment, CRYPT_SLOT_PRIORITY_IGNORE,
 730                                        pin, pin_size, &buffer, &buffer_size, usrptr, true);
 731                         if (!r) {
 732                                 r = LUKS2_keyslot_open_by_token(cd, hdr, token, segment, CRYPT_SLOT_PRIORITY_IGNORE,
 733                                                                 buffer, buffer_size, vk);
 734                                 LUKS2_token_buffer_free(cd, token, buffer, buffer_size);
 735                         }
 736                 }
 737         } else if (token == CRYPT_ANY_TOKEN)
 738                 /*
 739                  * return priorities (ordered form least to most significant):
 740                  * ENOENT - unusable for activation (no token handler, invalid token metadata, not assigned to volume segment, etc)
 741                  * EPERM  - usable but token provided passphrase did not unlock any assigned keyslot
 742                  * EAGAIN - usable but not ready (token HW is missing)
 743                  * ENOANO - ready, but token pin is wrong or missing
 744                  *
 745                  * success (>= 0) or any other negative errno short-circuits token activation loop
 746                  * immediately
 747                  */
 748                 r = token_open_any(cd, hdr, type, segment, pin, pin_size, usrptr, vk);
 749         else
 750                 r = -EINVAL;
 751
 752         return r;
 753 }
 754
 755 int LUKS2_token_open_and_activate(struct crypt_device *cd,
 756         struct luks2_hdr *hdr,
 757         int token,
 758         const char *name,
 759         const char *type,
 760         const char *pin,
 761         size_t pin_size,
 762         uint32_t flags,
 763         void *usrptr)
 764 {
 765         bool use_keyring;
 766         int keyslot, r, segment;
 767         struct volume_key *vk = NULL;
 768
 769         if (flags & CRYPT_ACTIVATE_ALLOW_UNBOUND_KEY)
 770                 segment = CRYPT_ANY_SEGMENT;
 771         else
 772                 segment = CRYPT_DEFAULT_SEGMENT;
 773
 774         r = LUKS2_token_unlock_key(cd, hdr, token, type, pin, pin_size, segment, usrptr, &vk);
 775         if (r < 0)
 776                 return r;
 777
 778         assert(vk);
 779
 780         keyslot = r;
 781
 782         if (!crypt_use_keyring_for_vk(cd))
 783                 use_keyring = false;
 784         else
 785                 use_keyring = ((name && !crypt_is_cipher_null(crypt_get_cipher(cd))) ||
 786                                (flags & CRYPT_ACTIVATE_KEYRING_KEY));
 787
 788         if (use_keyring) {
 789                 if (!(r = LUKS2_volume_key_load_in_keyring_by_keyslot(cd, hdr, vk, keyslot)))
 790                         flags |= CRYPT_ACTIVATE_KEYRING_KEY;
 791         }
 792
 793         if (r >= 0 && name)
 794                 r = LUKS2_activate(cd, name, vk, flags);
 795
 796         if (r < 0)
 797                 crypt_drop_keyring_key(cd, vk);
 798         crypt_free_volume_key(vk);
 799
 800         return r < 0 ? r : keyslot;
 801 }
 802
 803 void LUKS2_token_dump(struct crypt_device *cd, int token)
 804 {
 805         const crypt_token_handler *h;
 806         json_object *jobj_token;
 807
 808         h = LUKS2_token_handler(cd, token);
 809         if (h && h->dump) {
 810                 jobj_token = LUKS2_get_token_jobj(crypt_get_hdr(cd, CRYPT_LUKS2), token);
 811                 if (jobj_token)
 812                         h->dump(cd, json_object_to_json_string_ext(jobj_token,
 813                                 JSON_C_TO_STRING_PLAIN | JSON_C_TO_STRING_NOSLASHESCAPE));
 814         }
 815 }
 816
 817 int LUKS2_token_json_get(struct luks2_hdr *hdr, int token, const char **json)
 818 {
 819         json_object *jobj_token;
 820
 821         jobj_token = LUKS2_get_token_jobj(hdr, token);
 822         if (!jobj_token)
 823                 return -EINVAL;
 824
 825         *json = token_json_to_string(jobj_token);
 826         return 0;
 827 }
 828
 829 static int assign_one_keyslot(struct crypt_device *cd, struct luks2_hdr *hdr,
 830                               int token, int keyslot, int assign)
 831 {
 832         json_object *jobj1, *jobj_token, *jobj_token_keyslots;
 833         char num[16];
 834
 835         log_dbg(cd, "Keyslot %i %s token %i.", keyslot, assign ? "assigned to" : "unassigned from", token);
 836
 837         jobj_token = LUKS2_get_token_jobj(hdr, token);
 838         if (!jobj_token)
 839                 return -EINVAL;
 840
 841         json_object_object_get_ex(jobj_token, "keyslots", &jobj_token_keyslots);
 842         if (!jobj_token_keyslots)
 843                 return -EINVAL;
 844
 845         if (snprintf(num, sizeof(num), "%d", keyslot) < 0)
 846                 return -EINVAL;
 847
 848         if (assign) {
 849                 jobj1 = LUKS2_array_jobj(jobj_token_keyslots, num);
 850                 if (!jobj1)
 851                         json_object_array_add(jobj_token_keyslots, json_object_new_string(num));
 852         } else {
 853                 jobj1 = LUKS2_array_remove(jobj_token_keyslots, num);
 854                 if (jobj1)
 855                         json_object_object_add(jobj_token, "keyslots", jobj1);
 856         }
 857
 858         return 0;
 859 }
 860
 861 static int assign_one_token(struct crypt_device *cd, struct luks2_hdr *hdr,
 862                             int keyslot, int token, int assign)
 863 {
 864         json_object *jobj_keyslots;
 865         int r = 0;
 866
 867         if (!LUKS2_get_token_jobj(hdr, token))
 868                 return -EINVAL;
 869
 870         if (keyslot == CRYPT_ANY_SLOT) {
 871                 json_object_object_get_ex(hdr->jobj, "keyslots", &jobj_keyslots);
 872
 873                 json_object_object_foreach(jobj_keyslots, key, val) {
 874                         UNUSED(val);
 875                         r = assign_one_keyslot(cd, hdr, token, atoi(key), assign);
 876                         if (r < 0)
 877                                 break;
 878                 }
 879         } else
 880                 r = assign_one_keyslot(cd, hdr, token, keyslot, assign);
 881
 882         return r;
 883 }
 884
 885 int LUKS2_token_assign(struct crypt_device *cd, struct luks2_hdr *hdr,
 886                         int keyslot, int token, int assign, int commit)
 887 {
 888         json_object *jobj_tokens;
 889         int r = 0;
 890
 891         if ((keyslot < 0 && keyslot != CRYPT_ANY_SLOT) || keyslot >= LUKS2_KEYSLOTS_MAX ||
 892             (token < 0 && token != CRYPT_ANY_TOKEN) || token >= LUKS2_TOKENS_MAX)
 893                 return -EINVAL;
 894
 895         if (token == CRYPT_ANY_TOKEN) {
 896                 json_object_object_get_ex(hdr->jobj, "tokens", &jobj_tokens);
 897
 898                 json_object_object_foreach(jobj_tokens, key, val) {
 899                         UNUSED(val);
 900                         r = assign_one_token(cd, hdr, keyslot, atoi(key), assign);
 901                         if (r < 0)
 902                                 break;
 903                 }
 904         } else
 905                 r = assign_one_token(cd, hdr, keyslot, token, assign);
 906
 907         if (r < 0)
 908                 return r;
 909
 910         if (commit)
 911                 return LUKS2_hdr_write(cd, hdr) ?: token;
 912
 913         return token;
 914 }
 915
 916 static int token_is_assigned(struct luks2_hdr *hdr, int keyslot, int token)
 917 {
 918         int i;
 919         json_object *jobj, *jobj_token_keyslots,
 920                     *jobj_token = LUKS2_get_token_jobj(hdr, token);
 921
 922         if (!jobj_token)
 923                 return -ENOENT;
 924
 925         json_object_object_get_ex(jobj_token, "keyslots", &jobj_token_keyslots);
 926
 927         for (i = 0; i < (int) json_object_array_length(jobj_token_keyslots); i++) {
 928                 jobj = json_object_array_get_idx(jobj_token_keyslots, i);
 929                 if (keyslot == atoi(json_object_get_string(jobj)))
 930                         return 0;
 931         }
 932
 933         return -ENOENT;
 934 }
 935
 936 int LUKS2_token_is_assigned(struct luks2_hdr *hdr, int keyslot, int token)
 937 {
 938         if (keyslot < 0 || keyslot >= LUKS2_KEYSLOTS_MAX || token < 0 || token >= LUKS2_TOKENS_MAX)
 939                 return -EINVAL;
 940
 941         return token_is_assigned(hdr, keyslot, token);
 942 }
 943
 944 int LUKS2_tokens_count(struct luks2_hdr *hdr)
 945 {
 946         json_object *jobj_tokens = LUKS2_get_tokens_jobj(hdr);
 947         if (!jobj_tokens)
 948                 return -EINVAL;
 949
 950         return json_object_object_length(jobj_tokens);
 951 }
 952
 953 int LUKS2_token_assignment_copy(struct crypt_device *cd,
 954                         struct luks2_hdr *hdr,
 955                         int keyslot_from,
 956                         int keyslot_to,
 957                         int commit)
 958 {
 959         int i, r;
 960
 961         if (keyslot_from < 0 || keyslot_from >= LUKS2_KEYSLOTS_MAX || keyslot_to < 0 || keyslot_to >= LUKS2_KEYSLOTS_MAX)
 962                 return -EINVAL;
 963
 964         r = LUKS2_tokens_count(hdr);
 965         if (r <= 0)
 966                 return r;
 967
 968         for (i = 0; i < LUKS2_TOKENS_MAX; i++) {
 969                 if (!token_is_assigned(hdr, keyslot_from, i)) {
 970                         if ((r = assign_one_token(cd, hdr, keyslot_to, i, 1)))
 971                                 return r;
 972                 }
 973         }
 974
 975         return commit ? LUKS2_hdr_write(cd, hdr) : 0;
 976 }
 977
 978 int LUKS2_token_unlock_passphrase(struct crypt_device *cd,
 979         struct luks2_hdr *hdr,
 980         int token,
 981         const char *type,
 982         const char *pin,
 983         size_t pin_size,
 984         void *usrptr,
 985         char **passphrase,
 986         size_t *passphrase_size)
 987 {
 988         char *buffer;
 989         size_t buffer_size;
 990         json_object *jobj_token, *jobj_tokens;
 991         int r = -ENOENT, retval = -ENOENT;
 992
 993         if (!hdr)
 994                 return -EINVAL;
 995
 996         if (token >= 0 && token < LUKS2_TOKENS_MAX) {
 997                 if ((jobj_token = LUKS2_get_token_jobj(hdr, token)))
 998                         r = token_open(cd, hdr, token, jobj_token, type, CRYPT_ANY_SEGMENT, CRYPT_SLOT_PRIORITY_IGNORE,
 999                                        pin, pin_size, &buffer, &buffer_size, usrptr, false);
1000         } else if (token == CRYPT_ANY_TOKEN) {
1001                 json_object_object_get_ex(hdr->jobj, "tokens", &jobj_tokens);
1002
1003                 if (!type)
1004                         usrptr = NULL;
1005
1006                 json_object_object_foreach(jobj_tokens, slot, val) {
1007                         token = atoi(slot);
1008                         r = token_open(cd, hdr, token, val, type, CRYPT_ANY_SEGMENT, CRYPT_SLOT_PRIORITY_IGNORE,
1009                                        pin, pin_size, &buffer, &buffer_size, usrptr, false);
1010
1011                         /*
1012                          * return priorities (ordered form least to most significant):
1013                          * ENOENT - unusable for activation (no token handler, invalid token metadata, etc)
1014                          * EAGAIN - usable but not ready (token HW is missing)
1015                          * ENOANO - ready, but token pin is wrong or missing
1016                          *
1017                          * success (>= 0) or any other negative errno short-circuits token activation loop
1018                          * immediately
1019                          */
1020                         if (break_loop_retval(r))
1021                                 goto out;
1022
1023                         update_return_errno(r, &retval);
1024                 }
1025                 r = retval;
1026         } else
1027                 r = -EINVAL;
1028 out:
1029         if (!r) {
1030                 *passphrase = crypt_safe_alloc(buffer_size);
1031                 if (*passphrase) {
1032                         memcpy(*passphrase, buffer, buffer_size);
1033                         *passphrase_size = buffer_size;
1034                 } else
1035                         r = -ENOMEM;
1036                 LUKS2_token_buffer_free(cd, token, buffer, buffer_size);
1037         }
1038
1039         if (!r)
1040                 return token;
1041
1042         return r;
1043 }