1 /* 2 * Copyright (c) 2020 Yubico AB. All rights reserved. 3 * Use of this source code is governed by a BSD-style 4 * license that can be found in the LICENSE file. 5 */ 6 7 #include <openssl/sha.h> 8 9 #include "fido.h" 10 #include "fido/es256.h" 11 12 #define LARGEBLOB_DIGEST_LENGTH 16 13 #define LARGEBLOB_NONCE_LENGTH 12 14 #define LARGEBLOB_TAG_LENGTH 16 15 16 typedef struct largeblob { 17 size_t origsiz; 18 fido_blob_t ciphertext; 19 fido_blob_t nonce; 20 } largeblob_t; 21 22 static largeblob_t * 23 largeblob_new(void) 24 { 25 return calloc(1, sizeof(largeblob_t)); 26 } 27 28 static void 29 largeblob_reset(largeblob_t *blob) 30 { 31 fido_blob_reset(&blob->ciphertext); 32 fido_blob_reset(&blob->nonce); 33 blob->origsiz = 0; 34 } 35 36 static void 37 largeblob_free(largeblob_t **blob_ptr) 38 { 39 largeblob_t *blob; 40 41 if (blob_ptr == NULL || (blob = *blob_ptr) == NULL) 42 return; 43 largeblob_reset(blob); 44 free(blob); 45 *blob_ptr = NULL; 46 } 47 48 static int 49 largeblob_aad(fido_blob_t *aad, uint64_t size) 50 { 51 uint8_t buf[4 + sizeof(uint64_t)]; 52 53 buf[0] = 0x62; /* b */ 54 buf[1] = 0x6c; /* l */ 55 buf[2] = 0x6f; /* o */ 56 buf[3] = 0x62; /* b */ 57 size = htole64(size); 58 memcpy(&buf[4], &size, sizeof(uint64_t)); 59 60 return fido_blob_set(aad, buf, sizeof(buf)); 61 } 62 63 static fido_blob_t * 64 largeblob_decrypt(const largeblob_t *blob, const fido_blob_t *key) 65 { 66 fido_blob_t *plaintext = NULL, *aad = NULL; 67 int ok = -1; 68 69 if ((plaintext = fido_blob_new()) == NULL || 70 (aad = fido_blob_new()) == NULL) { 71 fido_log_debug("%s: fido_blob_new", __func__); 72 goto fail; 73 } 74 if (largeblob_aad(aad, blob->origsiz) < 0) { 75 fido_log_debug("%s: largeblob_aad", __func__); 76 goto fail; 77 } 78 if (aes256_gcm_dec(key, &blob->nonce, aad, &blob->ciphertext, 79 plaintext) < 0) { 80 fido_log_debug("%s: aes256_gcm_dec", __func__); 81 goto fail; 82 } 83 84 ok = 0; 85 fail: 86 fido_blob_free(&aad); 87 88 if (ok < 0) 89 fido_blob_free(&plaintext); 90 91 return plaintext; 92 } 93 94 static int 95 largeblob_get_nonce(largeblob_t *blob) 96 { 97 uint8_t buf[LARGEBLOB_NONCE_LENGTH]; 98 int ok = -1; 99 100 if (fido_get_random(buf, sizeof(buf)) < 0) { 101 fido_log_debug("%s: fido_get_random", __func__); 102 goto fail; 103 } 104 if (fido_blob_set(&blob->nonce, buf, sizeof(buf)) < 0) { 105 fido_log_debug("%s: fido_blob_set", __func__); 106 goto fail; 107 } 108 109 ok = 0; 110 fail: 111 explicit_bzero(buf, sizeof(buf)); 112 113 return ok; 114 } 115 116 static int 117 largeblob_seal(largeblob_t *blob, const fido_blob_t *body, 118 const fido_blob_t *key) 119 { 120 fido_blob_t *plaintext = NULL, *aad = NULL; 121 int ok = -1; 122 123 if ((plaintext = fido_blob_new()) == NULL || 124 (aad = fido_blob_new()) == NULL) { 125 fido_log_debug("%s: fido_blob_new", __func__); 126 goto fail; 127 } 128 if (fido_compress(plaintext, body) != FIDO_OK) { 129 fido_log_debug("%s: fido_compress", __func__); 130 goto fail; 131 } 132 if (largeblob_aad(aad, body->len) < 0) { 133 fido_log_debug("%s: largeblob_aad", __func__); 134 goto fail; 135 } 136 if (largeblob_get_nonce(blob) < 0) { 137 fido_log_debug("%s: largeblob_get_nonce", __func__); 138 goto fail; 139 } 140 if (aes256_gcm_enc(key, &blob->nonce, aad, plaintext, 141 &blob->ciphertext) < 0) { 142 fido_log_debug("%s: aes256_gcm_enc", __func__); 143 goto fail; 144 } 145 blob->origsiz = body->len; 146 147 ok = 0; 148 fail: 149 fido_blob_free(&plaintext); 150 fido_blob_free(&aad); 151 152 return ok; 153 } 154 155 static int 156 largeblob_get_tx(fido_dev_t *dev, size_t offset, size_t count) 157 { 158 fido_blob_t f; 159 cbor_item_t *argv[3]; 160 int r; 161 162 memset(argv, 0, sizeof(argv)); 163 memset(&f, 0, sizeof(f)); 164 165 if ((argv[0] = cbor_build_uint(count)) == NULL || 166 (argv[2] = cbor_build_uint(offset)) == NULL) { 167 fido_log_debug("%s: cbor encode", __func__); 168 r = FIDO_ERR_INTERNAL; 169 goto fail; 170 } 171 if (cbor_build_frame(CTAP_CBOR_LARGEBLOB, argv, nitems(argv), &f) < 0 || 172 fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len) < 0) { 173 fido_log_debug("%s: fido_tx", __func__); 174 r = FIDO_ERR_TX; 175 goto fail; 176 } 177 178 r = FIDO_OK; 179 fail: 180 cbor_vector_free(argv, nitems(argv)); 181 free(f.ptr); 182 183 return r; 184 } 185 186 static int 187 parse_largeblob_reply(const cbor_item_t *key, const cbor_item_t *val, 188 void *arg) 189 { 190 if (cbor_isa_uint(key) == false || 191 cbor_int_get_width(key) != CBOR_INT_8 || 192 cbor_get_uint8(key) != 1) { 193 fido_log_debug("%s: cbor type", __func__); 194 return 0; /* ignore */ 195 } 196 197 return fido_blob_decode(val, arg); 198 } 199 200 static int 201 largeblob_get_rx(fido_dev_t *dev, fido_blob_t **chunk, int ms) 202 { 203 unsigned char reply[FIDO_MAXMSG]; 204 int reply_len, r; 205 206 *chunk = NULL; 207 if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply), 208 ms)) < 0) { 209 fido_log_debug("%s: fido_rx", __func__); 210 return FIDO_ERR_RX; 211 } 212 if ((*chunk = fido_blob_new()) == NULL) { 213 fido_log_debug("%s: fido_blob_new", __func__); 214 return FIDO_ERR_INTERNAL; 215 } 216 if ((r = cbor_parse_reply(reply, (size_t)reply_len, *chunk, 217 parse_largeblob_reply)) != FIDO_OK) { 218 fido_log_debug("%s: parse_largeblob_reply", __func__); 219 fido_blob_free(chunk); 220 return r; 221 } 222 223 return FIDO_OK; 224 } 225 226 static cbor_item_t * 227 largeblob_array_load(const uint8_t *ptr, size_t len) 228 { 229 struct cbor_load_result cbor; 230 cbor_item_t *item; 231 232 if (len < LARGEBLOB_DIGEST_LENGTH) { 233 fido_log_debug("%s: len", __func__); 234 return NULL; 235 } 236 len -= LARGEBLOB_DIGEST_LENGTH; 237 if ((item = cbor_load(ptr, len, &cbor)) == NULL) { 238 fido_log_debug("%s: cbor_load", __func__); 239 return NULL; 240 } 241 if (!cbor_isa_array(item) || !cbor_array_is_definite(item)) { 242 fido_log_debug("%s: cbor type", __func__); 243 cbor_decref(&item); 244 return NULL; 245 } 246 247 return item; 248 } 249 250 static size_t 251 get_chunklen(fido_dev_t *dev) 252 { 253 uint64_t maxchunklen; 254 255 if ((maxchunklen = fido_dev_maxmsgsize(dev)) > SIZE_MAX) 256 maxchunklen = SIZE_MAX; 257 if (maxchunklen > FIDO_MAXMSG) 258 maxchunklen = FIDO_MAXMSG; 259 maxchunklen = maxchunklen > 64 ? maxchunklen - 64 : 0; 260 261 return (size_t)maxchunklen; 262 } 263 264 static int 265 largeblob_do_decode(const cbor_item_t *key, const cbor_item_t *val, void *arg) 266 { 267 largeblob_t *blob = arg; 268 uint64_t origsiz; 269 270 if (cbor_isa_uint(key) == false || 271 cbor_int_get_width(key) != CBOR_INT_8) { 272 fido_log_debug("%s: cbor type", __func__); 273 return 0; /* ignore */ 274 } 275 276 switch (cbor_get_uint8(key)) { 277 case 1: /* ciphertext */ 278 if (fido_blob_decode(val, &blob->ciphertext) < 0 || 279 blob->ciphertext.len < LARGEBLOB_TAG_LENGTH) 280 return -1; 281 return 0; 282 case 2: /* nonce */ 283 if (fido_blob_decode(val, &blob->nonce) < 0 || 284 blob->nonce.len != LARGEBLOB_NONCE_LENGTH) 285 return -1; 286 return 0; 287 case 3: /* origSize */ 288 if (!cbor_isa_uint(val) || 289 (origsiz = cbor_get_int(val)) > SIZE_MAX) 290 return -1; 291 blob->origsiz = (size_t)origsiz; 292 return 0; 293 default: /* ignore */ 294 fido_log_debug("%s: cbor type", __func__); 295 return 0; 296 } 297 } 298 299 static int 300 largeblob_decode(largeblob_t *blob, const cbor_item_t *item) 301 { 302 if (!cbor_isa_map(item) || !cbor_map_is_definite(item)) { 303 fido_log_debug("%s: cbor type", __func__); 304 return -1; 305 } 306 if (cbor_map_iter(item, blob, largeblob_do_decode) < 0) { 307 fido_log_debug("%s: cbor_map_iter", __func__); 308 return -1; 309 } 310 if (fido_blob_is_empty(&blob->ciphertext) || 311 fido_blob_is_empty(&blob->nonce) || blob->origsiz == 0) { 312 fido_log_debug("%s: incomplete blob", __func__); 313 return -1; 314 } 315 316 return 0; 317 } 318 319 static cbor_item_t * 320 largeblob_encode(const fido_blob_t *body, const fido_blob_t *key) 321 { 322 largeblob_t *blob; 323 cbor_item_t *argv[3], *item = NULL; 324 325 memset(argv, 0, sizeof(argv)); 326 if ((blob = largeblob_new()) == NULL || 327 largeblob_seal(blob, body, key) < 0) { 328 fido_log_debug("%s: largeblob_seal", __func__); 329 goto fail; 330 } 331 if ((argv[0] = fido_blob_encode(&blob->ciphertext)) == NULL || 332 (argv[1] = fido_blob_encode(&blob->nonce)) == NULL || 333 (argv[2] = cbor_build_uint(blob->origsiz)) == NULL) { 334 fido_log_debug("%s: cbor encode", __func__); 335 goto fail; 336 } 337 item = cbor_flatten_vector(argv, nitems(argv)); 338 fail: 339 cbor_vector_free(argv, nitems(argv)); 340 largeblob_free(&blob); 341 342 return item; 343 } 344 345 static int 346 largeblob_array_lookup(fido_blob_t *out, size_t *idx, const cbor_item_t *item, 347 const fido_blob_t *key) 348 { 349 cbor_item_t **v; 350 fido_blob_t *plaintext = NULL; 351 largeblob_t blob; 352 int r; 353 354 memset(&blob, 0, sizeof(blob)); 355 if (idx != NULL) 356 *idx = 0; 357 if ((v = cbor_array_handle(item)) == NULL) 358 return FIDO_ERR_INVALID_ARGUMENT; 359 for (size_t i = 0; i < cbor_array_size(item); i++) { 360 if (largeblob_decode(&blob, v[i]) < 0 || 361 (plaintext = largeblob_decrypt(&blob, key)) == NULL) { 362 fido_log_debug("%s: largeblob_decode", __func__); 363 largeblob_reset(&blob); 364 continue; 365 } 366 if (idx != NULL) 367 *idx = i; 368 break; 369 } 370 if (plaintext == NULL) { 371 fido_log_debug("%s: not found", __func__); 372 return FIDO_ERR_NOTFOUND; 373 } 374 if (out != NULL) 375 r = fido_uncompress(out, plaintext, blob.origsiz); 376 else 377 r = FIDO_OK; 378 379 fido_blob_free(&plaintext); 380 largeblob_reset(&blob); 381 382 return r; 383 } 384 385 static int 386 largeblob_array_digest(u_char out[LARGEBLOB_DIGEST_LENGTH], const u_char *data, 387 size_t len) 388 { 389 u_char dgst[SHA256_DIGEST_LENGTH]; 390 391 if (data == NULL || len == 0) 392 return -1; 393 if (SHA256(data, len, dgst) != dgst) 394 return -1; 395 memcpy(out, dgst, LARGEBLOB_DIGEST_LENGTH); 396 397 return 0; 398 } 399 400 static int 401 largeblob_array_check(const fido_blob_t *array) 402 { 403 u_char expected_hash[LARGEBLOB_DIGEST_LENGTH]; 404 size_t body_len; 405 406 fido_log_xxd(array->ptr, array->len, __func__); 407 if (array->len < sizeof(expected_hash)) { 408 fido_log_debug("%s: len %zu", __func__, array->len); 409 return -1; 410 } 411 body_len = array->len - sizeof(expected_hash); 412 if (largeblob_array_digest(expected_hash, array->ptr, body_len) < 0) { 413 fido_log_debug("%s: largeblob_array_digest", __func__); 414 return -1; 415 } 416 417 return timingsafe_bcmp(expected_hash, array->ptr + body_len, 418 sizeof(expected_hash)); 419 } 420 421 static int 422 largeblob_get_array(fido_dev_t *dev, cbor_item_t **item) 423 { 424 fido_blob_t *array, *chunk = NULL; 425 size_t n; 426 int r; 427 428 *item = NULL; 429 if ((n = get_chunklen(dev)) == 0) 430 return FIDO_ERR_INVALID_ARGUMENT; 431 if ((array = fido_blob_new()) == NULL) 432 return FIDO_ERR_INTERNAL; 433 do { 434 fido_blob_free(&chunk); 435 if ((r = largeblob_get_tx(dev, array->len, n)) != FIDO_OK || 436 (r = largeblob_get_rx(dev, &chunk, -1)) != FIDO_OK) { 437 fido_log_debug("%s: largeblob_get_wait %zu/%zu", 438 __func__, array->len, n); 439 goto fail; 440 } 441 if (fido_blob_append(array, chunk->ptr, chunk->len) < 0) { 442 fido_log_debug("%s: fido_blob_append", __func__); 443 r = FIDO_ERR_INTERNAL; 444 goto fail; 445 } 446 } while (chunk->len == n); 447 448 if (largeblob_array_check(array) != 0) 449 *item = cbor_new_definite_array(0); /* per spec */ 450 else 451 *item = largeblob_array_load(array->ptr, array->len); 452 if (*item == NULL) 453 r = FIDO_ERR_INTERNAL; 454 else 455 r = FIDO_OK; 456 fail: 457 fido_blob_free(&array); 458 fido_blob_free(&chunk); 459 460 return r; 461 } 462 463 static int 464 prepare_hmac(size_t offset, const u_char *data, size_t len, fido_blob_t *hmac) 465 { 466 uint8_t buf[32 + 2 + sizeof(uint32_t) + SHA256_DIGEST_LENGTH]; 467 uint32_t u32_offset; 468 469 if (data == NULL || len == 0) { 470 fido_log_debug("%s: invalid data=%p, len=%zu", __func__, 471 (const void *)data, len); 472 return -1; 473 } 474 if (offset > UINT32_MAX) { 475 fido_log_debug("%s: invalid offset=%zu", __func__, offset); 476 return -1; 477 } 478 479 memset(buf, 0xff, 32); 480 buf[32] = CTAP_CBOR_LARGEBLOB; 481 buf[33] = 0x00; 482 u32_offset = htole32((uint32_t)offset); 483 memcpy(&buf[34], &u32_offset, sizeof(uint32_t)); 484 if (SHA256(data, len, &buf[38]) != &buf[38]) { 485 fido_log_debug("%s: SHA256", __func__); 486 return -1; 487 } 488 489 return fido_blob_set(hmac, buf, sizeof(buf)); 490 } 491 492 static int 493 largeblob_set_tx(fido_dev_t *dev, const fido_blob_t *token, const u_char *chunk, 494 size_t chunk_len, size_t offset, size_t totalsiz) 495 { 496 fido_blob_t *hmac = NULL, f; 497 cbor_item_t *argv[6]; 498 int r; 499 500 memset(argv, 0, sizeof(argv)); 501 memset(&f, 0, sizeof(f)); 502 503 if ((argv[1] = cbor_build_bytestring(chunk, chunk_len)) == NULL || 504 (argv[2] = cbor_build_uint(offset)) == NULL || 505 (offset == 0 && (argv[3] = cbor_build_uint(totalsiz)) == NULL)) { 506 fido_log_debug("%s: cbor encode", __func__); 507 r = FIDO_ERR_INTERNAL; 508 goto fail; 509 } 510 if (token != NULL) { 511 if ((hmac = fido_blob_new()) == NULL || 512 prepare_hmac(offset, chunk, chunk_len, hmac) < 0 || 513 (argv[4] = cbor_encode_pin_auth(dev, token, hmac)) == NULL || 514 (argv[5] = cbor_encode_pin_opt(dev)) == NULL) { 515 fido_log_debug("%s: cbor_encode_pin_auth", __func__); 516 r = FIDO_ERR_INTERNAL; 517 goto fail; 518 } 519 } 520 if (cbor_build_frame(CTAP_CBOR_LARGEBLOB, argv, nitems(argv), &f) < 0 || 521 fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len) < 0) { 522 fido_log_debug("%s: fido_tx", __func__); 523 r = FIDO_ERR_TX; 524 goto fail; 525 } 526 527 r = FIDO_OK; 528 fail: 529 cbor_vector_free(argv, nitems(argv)); 530 fido_blob_free(&hmac); 531 free(f.ptr); 532 533 return r; 534 } 535 536 static int 537 largeblob_get_uv_token(fido_dev_t *dev, const char *pin, fido_blob_t **token) 538 { 539 es256_pk_t *pk = NULL; 540 fido_blob_t *ecdh = NULL; 541 int r; 542 543 if ((*token = fido_blob_new()) == NULL) 544 return FIDO_ERR_INTERNAL; 545 if ((r = fido_do_ecdh(dev, &pk, &ecdh)) != FIDO_OK) { 546 fido_log_debug("%s: fido_do_ecdh", __func__); 547 goto fail; 548 } 549 if ((r = fido_dev_get_uv_token(dev, CTAP_CBOR_LARGEBLOB, pin, ecdh, pk, 550 NULL, *token)) != FIDO_OK) { 551 fido_log_debug("%s: fido_dev_get_uv_token", __func__); 552 goto fail; 553 } 554 555 r = FIDO_OK; 556 fail: 557 if (r != FIDO_OK) 558 fido_blob_free(token); 559 560 fido_blob_free(&ecdh); 561 es256_pk_free(&pk); 562 563 return r; 564 } 565 566 static int 567 largeblob_set_array(fido_dev_t *dev, const cbor_item_t *item, const char *pin) 568 { 569 unsigned char dgst[SHA256_DIGEST_LENGTH]; 570 fido_blob_t cbor, *token = NULL; 571 size_t chunklen, maxchunklen, totalsize; 572 int r; 573 574 memset(&cbor, 0, sizeof(cbor)); 575 576 if ((maxchunklen = get_chunklen(dev)) == 0) { 577 fido_log_debug("%s: maxchunklen=%zu", __func__, maxchunklen); 578 r = FIDO_ERR_INVALID_ARGUMENT; 579 goto fail; 580 } 581 if (!cbor_isa_array(item) || !cbor_array_is_definite(item)) { 582 fido_log_debug("%s: cbor type", __func__); 583 r = FIDO_ERR_INVALID_ARGUMENT; 584 goto fail; 585 } 586 if ((fido_blob_serialise(&cbor, item)) < 0) { 587 fido_log_debug("%s: fido_blob_serialise", __func__); 588 r = FIDO_ERR_INTERNAL; 589 goto fail; 590 } 591 if (cbor.len > SIZE_MAX - sizeof(dgst)) { 592 fido_log_debug("%s: cbor.len=%zu", __func__, cbor.len); 593 r = FIDO_ERR_INVALID_ARGUMENT; 594 goto fail; 595 } 596 if (SHA256(cbor.ptr, cbor.len, dgst) != dgst) { 597 fido_log_debug("%s: SHA256", __func__); 598 r = FIDO_ERR_INTERNAL; 599 goto fail; 600 } 601 totalsize = cbor.len + sizeof(dgst) - 16; /* the first 16 bytes only */ 602 if (pin != NULL || fido_dev_supports_permissions(dev)) { 603 if ((r = largeblob_get_uv_token(dev, pin, &token)) != FIDO_OK) { 604 fido_log_debug("%s: largeblob_get_uv_token", __func__); 605 goto fail; 606 } 607 } 608 for (size_t offset = 0; offset < cbor.len; offset += chunklen) { 609 if ((chunklen = cbor.len - offset) > maxchunklen) 610 chunklen = maxchunklen; 611 if ((r = largeblob_set_tx(dev, token, cbor.ptr + offset, 612 chunklen, offset, totalsize)) != FIDO_OK || 613 (r = fido_rx_cbor_status(dev, -1)) != FIDO_OK) { 614 fido_log_debug("%s: body", __func__); 615 goto fail; 616 } 617 } 618 if ((r = largeblob_set_tx(dev, token, dgst, sizeof(dgst) - 16, cbor.len, 619 totalsize)) != FIDO_OK || 620 (r = fido_rx_cbor_status(dev, -1)) != FIDO_OK) { 621 fido_log_debug("%s: dgst", __func__); 622 goto fail; 623 } 624 625 r = FIDO_OK; 626 fail: 627 fido_blob_free(&token); 628 fido_blob_reset(&cbor); 629 630 return r; 631 } 632 633 static int 634 largeblob_add(fido_dev_t *dev, const fido_blob_t *key, cbor_item_t *item, 635 const char *pin) 636 { 637 cbor_item_t *array = NULL; 638 size_t idx; 639 int r; 640 641 if ((r = largeblob_get_array(dev, &array)) != FIDO_OK) { 642 fido_log_debug("%s: largeblob_get_array", __func__); 643 goto fail; 644 } 645 646 switch (r = largeblob_array_lookup(NULL, &idx, array, key)) { 647 case FIDO_OK: 648 if (!cbor_array_replace(array, idx, item)) { 649 r = FIDO_ERR_INTERNAL; 650 goto fail; 651 } 652 break; 653 case FIDO_ERR_NOTFOUND: 654 if (cbor_array_append(&array, item) < 0) { 655 r = FIDO_ERR_INTERNAL; 656 goto fail; 657 } 658 break; 659 default: 660 fido_log_debug("%s: largeblob_array_lookup", __func__); 661 goto fail; 662 } 663 664 if ((r = largeblob_set_array(dev, array, pin)) != FIDO_OK) { 665 fido_log_debug("%s: largeblob_set_array", __func__); 666 goto fail; 667 } 668 669 r = FIDO_OK; 670 fail: 671 if (array != NULL) 672 cbor_decref(&array); 673 674 return r; 675 } 676 677 static int 678 largeblob_drop(fido_dev_t *dev, const fido_blob_t *key, const char *pin) 679 { 680 cbor_item_t *array = NULL; 681 size_t idx; 682 int r; 683 684 if ((r = largeblob_get_array(dev, &array)) != FIDO_OK) { 685 fido_log_debug("%s: largeblob_get_array", __func__); 686 goto fail; 687 } 688 if ((r = largeblob_array_lookup(NULL, &idx, array, key)) != FIDO_OK) { 689 fido_log_debug("%s: largeblob_array_lookup", __func__); 690 goto fail; 691 } 692 if (cbor_array_drop(&array, idx) < 0) { 693 fido_log_debug("%s: cbor_array_drop", __func__); 694 r = FIDO_ERR_INTERNAL; 695 goto fail; 696 } 697 if ((r = largeblob_set_array(dev, array, pin)) != FIDO_OK) { 698 fido_log_debug("%s: largeblob_set_array", __func__); 699 goto fail; 700 } 701 702 r = FIDO_OK; 703 fail: 704 if (array != NULL) 705 cbor_decref(&array); 706 707 return r; 708 } 709 710 int 711 fido_dev_largeblob_get(fido_dev_t *dev, const unsigned char *key_ptr, 712 size_t key_len, unsigned char **blob_ptr, size_t *blob_len) 713 { 714 cbor_item_t *item = NULL; 715 fido_blob_t key, body; 716 int r; 717 718 memset(&key, 0, sizeof(key)); 719 memset(&body, 0, sizeof(body)); 720 721 if (key_len != 32) { 722 fido_log_debug("%s: invalid key len %zu", __func__, key_len); 723 return FIDO_ERR_INVALID_ARGUMENT; 724 } 725 if (blob_ptr == NULL || blob_len == NULL) { 726 fido_log_debug("%s: invalid blob_ptr=%p, blob_len=%p", __func__, 727 (const void *)blob_ptr, (const void *)blob_len); 728 return FIDO_ERR_INVALID_ARGUMENT; 729 } 730 *blob_ptr = NULL; 731 *blob_len = 0; 732 if (fido_blob_set(&key, key_ptr, key_len) < 0) { 733 fido_log_debug("%s: fido_blob_set", __func__); 734 return FIDO_ERR_INTERNAL; 735 } 736 if ((r = largeblob_get_array(dev, &item)) != FIDO_OK) { 737 fido_log_debug("%s: largeblob_get_array", __func__); 738 goto fail; 739 } 740 if ((r = largeblob_array_lookup(&body, NULL, item, &key)) != FIDO_OK) 741 fido_log_debug("%s: largeblob_array_lookup", __func__); 742 else { 743 *blob_ptr = body.ptr; 744 *blob_len = body.len; 745 } 746 fail: 747 if (item != NULL) 748 cbor_decref(&item); 749 750 fido_blob_reset(&key); 751 752 return r; 753 } 754 755 int 756 fido_dev_largeblob_set(fido_dev_t *dev, const unsigned char *key_ptr, 757 size_t key_len, const unsigned char *blob_ptr, size_t blob_len, 758 const char *pin) 759 { 760 cbor_item_t *item = NULL; 761 fido_blob_t key, body; 762 int r; 763 764 memset(&key, 0, sizeof(key)); 765 memset(&body, 0, sizeof(body)); 766 767 if (key_len != 32) { 768 fido_log_debug("%s: invalid key len %zu", __func__, key_len); 769 return FIDO_ERR_INVALID_ARGUMENT; 770 } 771 if (blob_ptr == NULL || blob_len == 0) { 772 fido_log_debug("%s: invalid blob_ptr=%p, blob_len=%zu", __func__, 773 (const void *)blob_ptr, blob_len); 774 return FIDO_ERR_INVALID_ARGUMENT; 775 } 776 if (fido_blob_set(&key, key_ptr, key_len) < 0 || 777 fido_blob_set(&body, blob_ptr, blob_len) < 0) { 778 fido_log_debug("%s: fido_blob_set", __func__); 779 r = FIDO_ERR_INTERNAL; 780 goto fail; 781 } 782 if ((item = largeblob_encode(&body, &key)) == NULL) { 783 fido_log_debug("%s: largeblob_encode", __func__); 784 r = FIDO_ERR_INTERNAL; 785 goto fail; 786 } 787 if ((r = largeblob_add(dev, &key, item, pin)) != FIDO_OK) 788 fido_log_debug("%s: largeblob_add", __func__); 789 fail: 790 if (item != NULL) 791 cbor_decref(&item); 792 793 fido_blob_reset(&key); 794 fido_blob_reset(&body); 795 796 return r; 797 } 798 799 int 800 fido_dev_largeblob_remove(fido_dev_t *dev, const unsigned char *key_ptr, 801 size_t key_len, const char *pin) 802 { 803 fido_blob_t key; 804 int r; 805 806 memset(&key, 0, sizeof(key)); 807 808 if (key_len != 32) { 809 fido_log_debug("%s: invalid key len %zu", __func__, key_len); 810 return FIDO_ERR_INVALID_ARGUMENT; 811 } 812 if (fido_blob_set(&key, key_ptr, key_len) < 0) { 813 fido_log_debug("%s: fido_blob_set", __func__); 814 return FIDO_ERR_INTERNAL; 815 } 816 if ((r = largeblob_drop(dev, &key, pin)) != FIDO_OK) 817 fido_log_debug("%s: largeblob_drop", __func__); 818 819 fido_blob_reset(&key); 820 821 return r; 822 } 823 824 int 825 fido_dev_largeblob_get_array(fido_dev_t *dev, unsigned char **cbor_ptr, 826 size_t *cbor_len) 827 { 828 cbor_item_t *item = NULL; 829 fido_blob_t cbor; 830 int r; 831 832 memset(&cbor, 0, sizeof(cbor)); 833 834 if (cbor_ptr == NULL || cbor_len == NULL) { 835 fido_log_debug("%s: invalid cbor_ptr=%p, cbor_len=%p", __func__, 836 (const void *)cbor_ptr, (const void *)cbor_len); 837 return FIDO_ERR_INVALID_ARGUMENT; 838 } 839 *cbor_ptr = NULL; 840 *cbor_len = 0; 841 if ((r = largeblob_get_array(dev, &item)) != FIDO_OK) { 842 fido_log_debug("%s: largeblob_get_array", __func__); 843 return r; 844 } 845 if (fido_blob_serialise(&cbor, item) < 0) { 846 fido_log_debug("%s: fido_blob_serialise", __func__); 847 r = FIDO_ERR_INTERNAL; 848 } else { 849 *cbor_ptr = cbor.ptr; 850 *cbor_len = cbor.len; 851 } 852 853 cbor_decref(&item); 854 855 return r; 856 } 857 858 int 859 fido_dev_largeblob_set_array(fido_dev_t *dev, const unsigned char *cbor_ptr, 860 size_t cbor_len, const char *pin) 861 { 862 cbor_item_t *item = NULL; 863 struct cbor_load_result cbor_result; 864 int r; 865 866 if (cbor_ptr == NULL || cbor_len == 0) { 867 fido_log_debug("%s: invalid cbor_ptr=%p, cbor_len=%zu", __func__, 868 (const void *)cbor_ptr, cbor_len); 869 return FIDO_ERR_INVALID_ARGUMENT; 870 } 871 if ((item = cbor_load(cbor_ptr, cbor_len, &cbor_result)) == NULL) { 872 fido_log_debug("%s: cbor_load", __func__); 873 return FIDO_ERR_INVALID_ARGUMENT; 874 } 875 if ((r = largeblob_set_array(dev, item, pin)) != FIDO_OK) 876 fido_log_debug("%s: largeblob_set_array", __func__); 877 878 cbor_decref(&item); 879 880 return r; 881 } 882