contrib/libfido2/src/bio.c

   1 /*
   2  * Copyright (c) 2019 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 "fido.h"
   8 #include "fido/bio.h"
   9 #include "fido/es256.h"
  10
  11 #define CMD_ENROLL_BEGIN        0x01
  12 #define CMD_ENROLL_NEXT         0x02
  13 #define CMD_ENROLL_CANCEL       0x03
  14 #define CMD_ENUM                0x04
  15 #define CMD_SET_NAME            0x05
  16 #define CMD_ENROLL_REMOVE       0x06
  17 #define CMD_GET_INFO            0x07
  18
  19 static int
  20 bio_prepare_hmac(uint8_t cmd, cbor_item_t **argv, size_t argc,
  21     cbor_item_t **param, fido_blob_t *hmac_data)
  22 {
  23         const uint8_t    prefix[2] = { 0x01 /* modality */, cmd };
  24         int              ok = -1;
  25         size_t           cbor_alloc_len;
  26         size_t           cbor_len;
  27         unsigned char   *cbor = NULL;
  28
  29         if (argv == NULL || param == NULL)
  30                 return (fido_blob_set(hmac_data, prefix, sizeof(prefix)));
  31
  32         if ((*param = cbor_flatten_vector(argv, argc)) == NULL) {
  33                 fido_log_debug("%s: cbor_flatten_vector", __func__);
  34                 goto fail;
  35         }
  36
  37         if ((cbor_len = cbor_serialize_alloc(*param, &cbor,
  38             &cbor_alloc_len)) == 0 || cbor_len > SIZE_MAX - sizeof(prefix)) {
  39                 fido_log_debug("%s: cbor_serialize_alloc", __func__);
  40                 goto fail;
  41         }
  42
  43         if ((hmac_data->ptr = malloc(cbor_len + sizeof(prefix))) == NULL) {
  44                 fido_log_debug("%s: malloc", __func__);
  45                 goto fail;
  46         }
  47
  48         memcpy(hmac_data->ptr, prefix, sizeof(prefix));
  49         memcpy(hmac_data->ptr + sizeof(prefix), cbor, cbor_len);
  50         hmac_data->len = cbor_len + sizeof(prefix);
  51
  52         ok = 0;
  53 fail:
  54         free(cbor);
  55
  56         return (ok);
  57 }
  58
  59 static int
  60 bio_tx(fido_dev_t *dev, uint8_t subcmd, cbor_item_t **sub_argv, size_t sub_argc,
  61     const char *pin, const fido_blob_t *token, int *ms)
  62 {
  63         cbor_item_t     *argv[5];
  64         es256_pk_t      *pk = NULL;
  65         fido_blob_t     *ecdh = NULL;
  66         fido_blob_t      f;
  67         fido_blob_t      hmac;
  68         const uint8_t    cmd = CTAP_CBOR_BIO_ENROLL_PRE;
  69         int              r = FIDO_ERR_INTERNAL;
  70
  71         memset(&f, 0, sizeof(f));
  72         memset(&hmac, 0, sizeof(hmac));
  73         memset(&argv, 0, sizeof(argv));
  74
  75         /* modality, subCommand */
  76         if ((argv[0] = cbor_build_uint8(1)) == NULL ||
  77             (argv[1] = cbor_build_uint8(subcmd)) == NULL) {
  78                 fido_log_debug("%s: cbor encode", __func__);
  79                 goto fail;
  80         }
  81
  82         /* subParams */
  83         if (pin || token) {
  84                 if (bio_prepare_hmac(subcmd, sub_argv, sub_argc, &argv[2],
  85                     &hmac) < 0) {
  86                         fido_log_debug("%s: bio_prepare_hmac", __func__);
  87                         goto fail;
  88                 }
  89         }
  90
  91         /* pinProtocol, pinAuth */
  92         if (pin) {
  93                 if ((r = fido_do_ecdh(dev, &pk, &ecdh, ms)) != FIDO_OK) {
  94                         fido_log_debug("%s: fido_do_ecdh", __func__);
  95                         goto fail;
  96                 }
  97                 if ((r = cbor_add_uv_params(dev, cmd, &hmac, pk, ecdh, pin,
  98                     NULL, &argv[4], &argv[3], ms)) != FIDO_OK) {
  99                         fido_log_debug("%s: cbor_add_uv_params", __func__);
 100                         goto fail;
 101                 }
 102         } else if (token) {
 103                 if ((argv[3] = cbor_encode_pin_opt(dev)) == NULL ||
 104                     (argv[4] = cbor_encode_pin_auth(dev, token, &hmac)) == NULL) {
 105                         fido_log_debug("%s: encode pin", __func__);
 106                         goto fail;
 107                 }
 108         }
 109
 110         /* framing and transmission */
 111         if (cbor_build_frame(cmd, argv, nitems(argv), &f) < 0 ||
 112             fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
 113                 fido_log_debug("%s: fido_tx", __func__);
 114                 r = FIDO_ERR_TX;
 115                 goto fail;
 116         }
 117
 118         r = FIDO_OK;
 119 fail:
 120         cbor_vector_free(argv, nitems(argv));
 121         es256_pk_free(&pk);
 122         fido_blob_free(&ecdh);
 123         free(f.ptr);
 124         free(hmac.ptr);
 125
 126         return (r);
 127 }
 128
 129 static void
 130 bio_reset_template(fido_bio_template_t *t)
 131 {
 132         free(t->name);
 133         t->name = NULL;
 134         fido_blob_reset(&t->id);
 135 }
 136
 137 static void
 138 bio_reset_template_array(fido_bio_template_array_t *ta)
 139 {
 140         for (size_t i = 0; i < ta->n_alloc; i++)
 141                 bio_reset_template(&ta->ptr[i]);
 142
 143         free(ta->ptr);
 144         ta->ptr = NULL;
 145         memset(ta, 0, sizeof(*ta));
 146 }
 147
 148 static int
 149 decode_template(const cbor_item_t *key, const cbor_item_t *val, void *arg)
 150 {
 151         fido_bio_template_t *t = arg;
 152
 153         if (cbor_isa_uint(key) == false ||
 154             cbor_int_get_width(key) != CBOR_INT_8) {
 155                 fido_log_debug("%s: cbor type", __func__);
 156                 return (0); /* ignore */
 157         }
 158
 159         switch (cbor_get_uint8(key)) {
 160         case 1: /* id */
 161                 return (fido_blob_decode(val, &t->id));
 162         case 2: /* name */
 163                 return (cbor_string_copy(val, &t->name));
 164         }
 165
 166         return (0); /* ignore */
 167 }
 168
 169 static int
 170 decode_template_array(const cbor_item_t *item, void *arg)
 171 {
 172         fido_bio_template_array_t *ta = arg;
 173
 174         if (cbor_isa_map(item) == false ||
 175             cbor_map_is_definite(item) == false) {
 176                 fido_log_debug("%s: cbor type", __func__);
 177                 return (-1);
 178         }
 179
 180         if (ta->n_rx >= ta->n_alloc) {
 181                 fido_log_debug("%s: n_rx >= n_alloc", __func__);
 182                 return (-1);
 183         }
 184
 185         if (cbor_map_iter(item, &ta->ptr[ta->n_rx], decode_template) < 0) {
 186                 fido_log_debug("%s: decode_template", __func__);
 187                 return (-1);
 188         }
 189
 190         ta->n_rx++;
 191
 192         return (0);
 193 }
 194
 195 static int
 196 bio_parse_template_array(const cbor_item_t *key, const cbor_item_t *val,
 197     void *arg)
 198 {
 199         fido_bio_template_array_t *ta = arg;
 200
 201         if (cbor_isa_uint(key) == false ||
 202             cbor_int_get_width(key) != CBOR_INT_8 ||
 203             cbor_get_uint8(key) != 7) {
 204                 fido_log_debug("%s: cbor type", __func__);
 205                 return (0); /* ignore */
 206         }
 207
 208         if (cbor_isa_array(val) == false ||
 209             cbor_array_is_definite(val) == false) {
 210                 fido_log_debug("%s: cbor type", __func__);
 211                 return (-1);
 212         }
 213
 214         if (ta->ptr != NULL || ta->n_alloc != 0 || ta->n_rx != 0) {
 215                 fido_log_debug("%s: ptr != NULL || n_alloc != 0 || n_rx != 0",
 216                     __func__);
 217                 return (-1);
 218         }
 219
 220         if ((ta->ptr = calloc(cbor_array_size(val), sizeof(*ta->ptr))) == NULL)
 221                 return (-1);
 222
 223         ta->n_alloc = cbor_array_size(val);
 224
 225         if (cbor_array_iter(val, ta, decode_template_array) < 0) {
 226                 fido_log_debug("%s: decode_template_array", __func__);
 227                 return (-1);
 228         }
 229
 230         return (0);
 231 }
 232
 233 static int
 234 bio_rx_template_array(fido_dev_t *dev, fido_bio_template_array_t *ta, int *ms)
 235 {
 236         unsigned char   reply[FIDO_MAXMSG];
 237         int             reply_len;
 238         int             r;
 239
 240         bio_reset_template_array(ta);
 241
 242         if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
 243             ms)) < 0) {
 244                 fido_log_debug("%s: fido_rx", __func__);
 245                 return (FIDO_ERR_RX);
 246         }
 247
 248         if ((r = cbor_parse_reply(reply, (size_t)reply_len, ta,
 249             bio_parse_template_array)) != FIDO_OK) {
 250                 fido_log_debug("%s: bio_parse_template_array" , __func__);
 251                 return (r);
 252         }
 253
 254         return (FIDO_OK);
 255 }
 256
 257 static int
 258 bio_get_template_array_wait(fido_dev_t *dev, fido_bio_template_array_t *ta,
 259     const char *pin, int *ms)
 260 {
 261         int r;
 262
 263         if ((r = bio_tx(dev, CMD_ENUM, NULL, 0, pin, NULL, ms)) != FIDO_OK ||
 264             (r = bio_rx_template_array(dev, ta, ms)) != FIDO_OK)
 265                 return (r);
 266
 267         return (FIDO_OK);
 268 }
 269
 270 int
 271 fido_bio_dev_get_template_array(fido_dev_t *dev, fido_bio_template_array_t *ta,
 272     const char *pin)
 273 {
 274         int ms = dev->timeout_ms;
 275
 276         if (pin == NULL)
 277                 return (FIDO_ERR_INVALID_ARGUMENT);
 278
 279         return (bio_get_template_array_wait(dev, ta, pin, &ms));
 280 }
 281
 282 static int
 283 bio_set_template_name_wait(fido_dev_t *dev, const fido_bio_template_t *t,
 284     const char *pin, int *ms)
 285 {
 286         cbor_item_t     *argv[2];
 287         int              r = FIDO_ERR_INTERNAL;
 288
 289         memset(&argv, 0, sizeof(argv));
 290
 291         if ((argv[0] = fido_blob_encode(&t->id)) == NULL ||
 292             (argv[1] = cbor_build_string(t->name)) == NULL) {
 293                 fido_log_debug("%s: cbor encode", __func__);
 294                 goto fail;
 295         }
 296
 297         if ((r = bio_tx(dev, CMD_SET_NAME, argv, 2, pin, NULL,
 298             ms)) != FIDO_OK ||
 299             (r = fido_rx_cbor_status(dev, ms)) != FIDO_OK) {
 300                 fido_log_debug("%s: tx/rx", __func__);
 301                 goto fail;
 302         }
 303
 304         r = FIDO_OK;
 305 fail:
 306         cbor_vector_free(argv, nitems(argv));
 307
 308         return (r);
 309 }
 310
 311 int
 312 fido_bio_dev_set_template_name(fido_dev_t *dev, const fido_bio_template_t *t,
 313     const char *pin)
 314 {
 315         int ms = dev->timeout_ms;
 316
 317         if (pin == NULL || t->name == NULL)
 318                 return (FIDO_ERR_INVALID_ARGUMENT);
 319
 320         return (bio_set_template_name_wait(dev, t, pin, &ms));
 321 }
 322
 323 static void
 324 bio_reset_enroll(fido_bio_enroll_t *e)
 325 {
 326         e->remaining_samples = 0;
 327         e->last_status = 0;
 328
 329         if (e->token)
 330                 fido_blob_free(&e->token);
 331 }
 332
 333 static int
 334 bio_parse_enroll_status(const cbor_item_t *key, const cbor_item_t *val,
 335     void *arg)
 336 {
 337         fido_bio_enroll_t *e = arg;
 338         uint64_t x;
 339
 340         if (cbor_isa_uint(key) == false ||
 341             cbor_int_get_width(key) != CBOR_INT_8) {
 342                 fido_log_debug("%s: cbor type", __func__);
 343                 return (0); /* ignore */
 344         }
 345
 346         switch (cbor_get_uint8(key)) {
 347         case 5:
 348                 if (cbor_decode_uint64(val, &x) < 0 || x > UINT8_MAX) {
 349                         fido_log_debug("%s: cbor_decode_uint64", __func__);
 350                         return (-1);
 351                 }
 352                 e->last_status = (uint8_t)x;
 353                 break;
 354         case 6:
 355                 if (cbor_decode_uint64(val, &x) < 0 || x > UINT8_MAX) {
 356                         fido_log_debug("%s: cbor_decode_uint64", __func__);
 357                         return (-1);
 358                 }
 359                 e->remaining_samples = (uint8_t)x;
 360                 break;
 361         default:
 362                 return (0); /* ignore */
 363         }
 364
 365         return (0);
 366 }
 367
 368 static int
 369 bio_parse_template_id(const cbor_item_t *key, const cbor_item_t *val,
 370     void *arg)
 371 {
 372         fido_blob_t *id = arg;
 373
 374         if (cbor_isa_uint(key) == false ||
 375             cbor_int_get_width(key) != CBOR_INT_8 ||
 376             cbor_get_uint8(key) != 4) {
 377                 fido_log_debug("%s: cbor type", __func__);
 378                 return (0); /* ignore */
 379         }
 380
 381         return (fido_blob_decode(val, id));
 382 }
 383
 384 static int
 385 bio_rx_enroll_begin(fido_dev_t *dev, fido_bio_template_t *t,
 386     fido_bio_enroll_t *e, int *ms)
 387 {
 388         unsigned char   reply[FIDO_MAXMSG];
 389         int             reply_len;
 390         int             r;
 391
 392         bio_reset_template(t);
 393
 394         e->remaining_samples = 0;
 395         e->last_status = 0;
 396
 397         if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
 398             ms)) < 0) {
 399                 fido_log_debug("%s: fido_rx", __func__);
 400                 return (FIDO_ERR_RX);
 401         }
 402
 403         if ((r = cbor_parse_reply(reply, (size_t)reply_len, e,
 404             bio_parse_enroll_status)) != FIDO_OK) {
 405                 fido_log_debug("%s: bio_parse_enroll_status", __func__);
 406                 return (r);
 407         }
 408         if ((r = cbor_parse_reply(reply, (size_t)reply_len, &t->id,
 409             bio_parse_template_id)) != FIDO_OK) {
 410                 fido_log_debug("%s: bio_parse_template_id", __func__);
 411                 return (r);
 412         }
 413
 414         return (FIDO_OK);
 415 }
 416
 417 static int
 418 bio_enroll_begin_wait(fido_dev_t *dev, fido_bio_template_t *t,
 419     fido_bio_enroll_t *e, uint32_t timo_ms, int *ms)
 420 {
 421         cbor_item_t     *argv[3];
 422         const uint8_t    cmd = CMD_ENROLL_BEGIN;
 423         int              r = FIDO_ERR_INTERNAL;
 424
 425         memset(&argv, 0, sizeof(argv));
 426
 427         if ((argv[2] = cbor_build_uint(timo_ms)) == NULL) {
 428                 fido_log_debug("%s: cbor encode", __func__);
 429                 goto fail;
 430         }
 431
 432         if ((r = bio_tx(dev, cmd, argv, 3, NULL, e->token, ms)) != FIDO_OK ||
 433             (r = bio_rx_enroll_begin(dev, t, e, ms)) != FIDO_OK) {
 434                 fido_log_debug("%s: tx/rx", __func__);
 435                 goto fail;
 436         }
 437
 438         r = FIDO_OK;
 439 fail:
 440         cbor_vector_free(argv, nitems(argv));
 441
 442         return (r);
 443 }
 444
 445 int
 446 fido_bio_dev_enroll_begin(fido_dev_t *dev, fido_bio_template_t *t,
 447     fido_bio_enroll_t *e, uint32_t timo_ms, const char *pin)
 448 {
 449         es256_pk_t      *pk = NULL;
 450         fido_blob_t     *ecdh = NULL;
 451         fido_blob_t     *token = NULL;
 452         int              ms = dev->timeout_ms;
 453         int              r;
 454
 455         if (pin == NULL || e->token != NULL)
 456                 return (FIDO_ERR_INVALID_ARGUMENT);
 457
 458         if ((token = fido_blob_new()) == NULL) {
 459                 r = FIDO_ERR_INTERNAL;
 460                 goto fail;
 461         }
 462
 463         if ((r = fido_do_ecdh(dev, &pk, &ecdh, &ms)) != FIDO_OK) {
 464                 fido_log_debug("%s: fido_do_ecdh", __func__);
 465                 goto fail;
 466         }
 467
 468         if ((r = fido_dev_get_uv_token(dev, CTAP_CBOR_BIO_ENROLL_PRE, pin, ecdh,
 469             pk, NULL, token, &ms)) != FIDO_OK) {
 470                 fido_log_debug("%s: fido_dev_get_uv_token", __func__);
 471                 goto fail;
 472         }
 473
 474         e->token = token;
 475         token = NULL;
 476 fail:
 477         es256_pk_free(&pk);
 478         fido_blob_free(&ecdh);
 479         fido_blob_free(&token);
 480
 481         if (r != FIDO_OK)
 482                 return (r);
 483
 484         return (bio_enroll_begin_wait(dev, t, e, timo_ms, &ms));
 485 }
 486
 487 static int
 488 bio_rx_enroll_continue(fido_dev_t *dev, fido_bio_enroll_t *e, int *ms)
 489 {
 490         unsigned char   reply[FIDO_MAXMSG];
 491         int             reply_len;
 492         int             r;
 493
 494         e->remaining_samples = 0;
 495         e->last_status = 0;
 496
 497         if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
 498             ms)) < 0) {
 499                 fido_log_debug("%s: fido_rx", __func__);
 500                 return (FIDO_ERR_RX);
 501         }
 502
 503         if ((r = cbor_parse_reply(reply, (size_t)reply_len, e,
 504             bio_parse_enroll_status)) != FIDO_OK) {
 505                 fido_log_debug("%s: bio_parse_enroll_status", __func__);
 506                 return (r);
 507         }
 508
 509         return (FIDO_OK);
 510 }
 511
 512 static int
 513 bio_enroll_continue_wait(fido_dev_t *dev, const fido_bio_template_t *t,
 514     fido_bio_enroll_t *e, uint32_t timo_ms, int *ms)
 515 {
 516         cbor_item_t     *argv[3];
 517         const uint8_t    cmd = CMD_ENROLL_NEXT;
 518         int              r = FIDO_ERR_INTERNAL;
 519
 520         memset(&argv, 0, sizeof(argv));
 521
 522         if ((argv[0] = fido_blob_encode(&t->id)) == NULL ||
 523             (argv[2] = cbor_build_uint(timo_ms)) == NULL) {
 524                 fido_log_debug("%s: cbor encode", __func__);
 525                 goto fail;
 526         }
 527
 528         if ((r = bio_tx(dev, cmd, argv, 3, NULL, e->token, ms)) != FIDO_OK ||
 529             (r = bio_rx_enroll_continue(dev, e, ms)) != FIDO_OK) {
 530                 fido_log_debug("%s: tx/rx", __func__);
 531                 goto fail;
 532         }
 533
 534         r = FIDO_OK;
 535 fail:
 536         cbor_vector_free(argv, nitems(argv));
 537
 538         return (r);
 539 }
 540
 541 int
 542 fido_bio_dev_enroll_continue(fido_dev_t *dev, const fido_bio_template_t *t,
 543     fido_bio_enroll_t *e, uint32_t timo_ms)
 544 {
 545         int ms = dev->timeout_ms;
 546
 547         if (e->token == NULL)
 548                 return (FIDO_ERR_INVALID_ARGUMENT);
 549
 550         return (bio_enroll_continue_wait(dev, t, e, timo_ms, &ms));
 551 }
 552
 553 static int
 554 bio_enroll_cancel_wait(fido_dev_t *dev, int *ms)
 555 {
 556         const uint8_t   cmd = CMD_ENROLL_CANCEL;
 557         int             r;
 558
 559         if ((r = bio_tx(dev, cmd, NULL, 0, NULL, NULL, ms)) != FIDO_OK ||
 560             (r = fido_rx_cbor_status(dev, ms)) != FIDO_OK) {
 561                 fido_log_debug("%s: tx/rx", __func__);
 562                 return (r);
 563         }
 564
 565         return (FIDO_OK);
 566 }
 567
 568 int
 569 fido_bio_dev_enroll_cancel(fido_dev_t *dev)
 570 {
 571         int ms = dev->timeout_ms;
 572
 573         return (bio_enroll_cancel_wait(dev, &ms));
 574 }
 575
 576 static int
 577 bio_enroll_remove_wait(fido_dev_t *dev, const fido_bio_template_t *t,
 578     const char *pin, int *ms)
 579 {
 580         cbor_item_t     *argv[1];
 581         const uint8_t    cmd = CMD_ENROLL_REMOVE;
 582         int              r = FIDO_ERR_INTERNAL;
 583
 584         memset(&argv, 0, sizeof(argv));
 585
 586         if ((argv[0] = fido_blob_encode(&t->id)) == NULL) {
 587                 fido_log_debug("%s: cbor encode", __func__);
 588                 goto fail;
 589         }
 590
 591         if ((r = bio_tx(dev, cmd, argv, 1, pin, NULL, ms)) != FIDO_OK ||
 592             (r = fido_rx_cbor_status(dev, ms)) != FIDO_OK) {
 593                 fido_log_debug("%s: tx/rx", __func__);
 594                 goto fail;
 595         }
 596
 597         r = FIDO_OK;
 598 fail:
 599         cbor_vector_free(argv, nitems(argv));
 600
 601         return (r);
 602 }
 603
 604 int
 605 fido_bio_dev_enroll_remove(fido_dev_t *dev, const fido_bio_template_t *t,
 606     const char *pin)
 607 {
 608         int ms = dev->timeout_ms;
 609
 610         return (bio_enroll_remove_wait(dev, t, pin, &ms));
 611 }
 612
 613 static void
 614 bio_reset_info(fido_bio_info_t *i)
 615 {
 616         i->type = 0;
 617         i->max_samples = 0;
 618 }
 619
 620 static int
 621 bio_parse_info(const cbor_item_t *key, const cbor_item_t *val, void *arg)
 622 {
 623         fido_bio_info_t *i = arg;
 624         uint64_t         x;
 625
 626         if (cbor_isa_uint(key) == false ||
 627             cbor_int_get_width(key) != CBOR_INT_8) {
 628                 fido_log_debug("%s: cbor type", __func__);
 629                 return (0); /* ignore */
 630         }
 631
 632         switch (cbor_get_uint8(key)) {
 633         case 2:
 634                 if (cbor_decode_uint64(val, &x) < 0 || x > UINT8_MAX) {
 635                         fido_log_debug("%s: cbor_decode_uint64", __func__);
 636                         return (-1);
 637                 }
 638                 i->type = (uint8_t)x;
 639                 break;
 640         case 3:
 641                 if (cbor_decode_uint64(val, &x) < 0 || x > UINT8_MAX) {
 642                         fido_log_debug("%s: cbor_decode_uint64", __func__);
 643                         return (-1);
 644                 }
 645                 i->max_samples = (uint8_t)x;
 646                 break;
 647         default:
 648                 return (0); /* ignore */
 649         }
 650
 651         return (0);
 652 }
 653
 654 static int
 655 bio_rx_info(fido_dev_t *dev, fido_bio_info_t *i, int *ms)
 656 {
 657         unsigned char   reply[FIDO_MAXMSG];
 658         int             reply_len;
 659         int             r;
 660
 661         bio_reset_info(i);
 662
 663         if ((reply_len = fido_rx(dev, CTAP_CMD_CBOR, &reply, sizeof(reply),
 664             ms)) < 0) {
 665                 fido_log_debug("%s: fido_rx", __func__);
 666                 return (FIDO_ERR_RX);
 667         }
 668
 669         if ((r = cbor_parse_reply(reply, (size_t)reply_len, i,
 670             bio_parse_info)) != FIDO_OK) {
 671                 fido_log_debug("%s: bio_parse_info" , __func__);
 672                 return (r);
 673         }
 674
 675         return (FIDO_OK);
 676 }
 677
 678 static int
 679 bio_get_info_wait(fido_dev_t *dev, fido_bio_info_t *i, int *ms)
 680 {
 681         int r;
 682
 683         if ((r = bio_tx(dev, CMD_GET_INFO, NULL, 0, NULL, NULL,
 684             ms)) != FIDO_OK ||
 685             (r = bio_rx_info(dev, i, ms)) != FIDO_OK) {
 686                 fido_log_debug("%s: tx/rx", __func__);
 687                 return (r);
 688         }
 689
 690         return (FIDO_OK);
 691 }
 692
 693 int
 694 fido_bio_dev_get_info(fido_dev_t *dev, fido_bio_info_t *i)
 695 {
 696         int ms = dev->timeout_ms;
 697
 698         return (bio_get_info_wait(dev, i, &ms));
 699 }
 700
 701 const char *
 702 fido_bio_template_name(const fido_bio_template_t *t)
 703 {
 704         return (t->name);
 705 }
 706
 707 const unsigned char *
 708 fido_bio_template_id_ptr(const fido_bio_template_t *t)
 709 {
 710         return (t->id.ptr);
 711 }
 712
 713 size_t
 714 fido_bio_template_id_len(const fido_bio_template_t *t)
 715 {
 716         return (t->id.len);
 717 }
 718
 719 size_t
 720 fido_bio_template_array_count(const fido_bio_template_array_t *ta)
 721 {
 722         return (ta->n_rx);
 723 }
 724
 725 fido_bio_template_array_t *
 726 fido_bio_template_array_new(void)
 727 {
 728         return (calloc(1, sizeof(fido_bio_template_array_t)));
 729 }
 730
 731 fido_bio_template_t *
 732 fido_bio_template_new(void)
 733 {
 734         return (calloc(1, sizeof(fido_bio_template_t)));
 735 }
 736
 737 void
 738 fido_bio_template_array_free(fido_bio_template_array_t **tap)
 739 {
 740         fido_bio_template_array_t *ta;
 741
 742         if (tap == NULL || (ta = *tap) == NULL)
 743                 return;
 744
 745         bio_reset_template_array(ta);
 746         free(ta);
 747         *tap = NULL;
 748 }
 749
 750 void
 751 fido_bio_template_free(fido_bio_template_t **tp)
 752 {
 753         fido_bio_template_t *t;
 754
 755         if (tp == NULL || (t = *tp) == NULL)
 756                 return;
 757
 758         bio_reset_template(t);
 759         free(t);
 760         *tp = NULL;
 761 }
 762
 763 int
 764 fido_bio_template_set_name(fido_bio_template_t *t, const char *name)
 765 {
 766         free(t->name);
 767         t->name = NULL;
 768
 769         if (name && (t->name = strdup(name)) == NULL)
 770                 return (FIDO_ERR_INTERNAL);
 771
 772         return (FIDO_OK);
 773 }
 774
 775 int
 776 fido_bio_template_set_id(fido_bio_template_t *t, const unsigned char *ptr,
 777     size_t len)
 778 {
 779         fido_blob_reset(&t->id);
 780
 781         if (ptr && fido_blob_set(&t->id, ptr, len) < 0)
 782                 return (FIDO_ERR_INTERNAL);
 783
 784         return (FIDO_OK);
 785 }
 786
 787 const fido_bio_template_t *
 788 fido_bio_template(const fido_bio_template_array_t *ta, size_t idx)
 789 {
 790         if (idx >= ta->n_alloc)
 791                 return (NULL);
 792
 793         return (&ta->ptr[idx]);
 794 }
 795
 796 fido_bio_enroll_t *
 797 fido_bio_enroll_new(void)
 798 {
 799         return (calloc(1, sizeof(fido_bio_enroll_t)));
 800 }
 801
 802 fido_bio_info_t *
 803 fido_bio_info_new(void)
 804 {
 805         return (calloc(1, sizeof(fido_bio_info_t)));
 806 }
 807
 808 uint8_t
 809 fido_bio_info_type(const fido_bio_info_t *i)
 810 {
 811         return (i->type);
 812 }
 813
 814 uint8_t
 815 fido_bio_info_max_samples(const fido_bio_info_t *i)
 816 {
 817         return (i->max_samples);
 818 }
 819
 820 void
 821 fido_bio_enroll_free(fido_bio_enroll_t **ep)
 822 {
 823         fido_bio_enroll_t *e;
 824
 825         if (ep == NULL || (e = *ep) == NULL)
 826                 return;
 827
 828         bio_reset_enroll(e);
 829
 830         free(e);
 831         *ep = NULL;
 832 }
 833
 834 void
 835 fido_bio_info_free(fido_bio_info_t **ip)
 836 {
 837         fido_bio_info_t *i;
 838
 839         if (ip == NULL || (i = *ip) == NULL)
 840                 return;
 841
 842         free(i);
 843         *ip = NULL;
 844 }
 845
 846 uint8_t
 847 fido_bio_enroll_remaining_samples(const fido_bio_enroll_t *e)
 848 {
 849         return (e->remaining_samples);
 850 }
 851
 852 uint8_t
 853 fido_bio_enroll_last_status(const fido_bio_enroll_t *e)
 854 {
 855         return (e->last_status);
 856 }