Lines Matching defs:assert
18 fido_assert_t *assert = arg;
34 if (assert->stmt_len != 0 || assert->stmt_cnt != 1 ||
35 (size_t)n < assert->stmt_cnt) {
37 __func__, assert->stmt_len, assert->stmt_cnt, (size_t)n);
41 if (fido_assert_set_count(assert, (size_t)n) != FIDO_OK) {
46 assert->stmt_len = 0; /* XXX */
85 fido_dev_get_assert_tx(fido_dev_t *dev, fido_assert_t *assert,
89 fido_opt_t uv = assert->uv;
98 if (assert->rp_id == NULL || assert->cdh.ptr == NULL) {
100 (void *)assert->rp_id, (void *)assert->cdh.ptr);
105 if ((argv[0] = cbor_build_string(assert->rp_id)) == NULL ||
106 (argv[1] = fido_blob_encode(&assert->cdh)) == NULL) {
113 if (assert->allow_list.len) {
114 const fido_blob_array_t *cl = &assert->allow_list;
122 if (assert->ext.mask)
123 if ((argv[3] = cbor_encode_assert_ext(dev, &assert->ext, ecdh,
133 if ((r = cbor_add_uv_params(dev, cmd, &assert->cdh, pk, ecdh,
134 pin, assert->rp_id, &argv[5], &argv[6], ms)) != FIDO_OK) {
142 if (assert->up != FIDO_OPT_OMIT || uv != FIDO_OPT_OMIT)
143 if ((argv[4] = cbor_encode_assert_opt(assert->up, uv)) == NULL) {
166 fido_dev_get_assert_rx(fido_dev_t *dev, fido_assert_t *assert, int *ms)
172 fido_assert_reset_rx(assert);
186 if ((assert->stmt = calloc(1, sizeof(fido_assert_stmt))) == NULL) {
190 assert->stmt_len = 0;
191 assert->stmt_cnt = 1;
194 if ((r = cbor_parse_reply(msg, (size_t)msglen, assert,
201 if ((r = cbor_parse_reply(msg, (size_t)msglen, &assert->stmt[0],
206 assert->stmt_len = 1;
229 fido_get_next_assert_rx(fido_dev_t *dev, fido_assert_t *assert, int *ms)
247 if (assert->stmt_len >= assert->stmt_cnt) {
249 assert->stmt_len, assert->stmt_cnt);
255 &assert->stmt[assert->stmt_len], parse_assert_reply)) != FIDO_OK) {
268 fido_dev_get_assert_wait(fido_dev_t *dev, fido_assert_t *assert,
273 if ((r = fido_dev_get_assert_tx(dev, assert, pk, ecdh, pin,
275 (r = fido_dev_get_assert_rx(dev, assert, ms)) != FIDO_OK)
278 while (assert->stmt_len < assert->stmt_cnt) {
280 (r = fido_get_next_assert_rx(dev, assert, ms)) != FIDO_OK)
282 assert->stmt_len++;
289 decrypt_hmac_secrets(const fido_dev_t *dev, fido_assert_t *assert,
292 for (size_t i = 0; i < assert->stmt_cnt; i++) {
293 fido_assert_stmt *stmt = &assert->stmt[i];
309 fido_dev_get_assert(fido_dev_t *dev, fido_assert_t *assert, const char *pin)
318 return (fido_winhello_get_assert(dev, assert, pin, ms));
321 if (assert->rp_id == NULL || assert->cdh.ptr == NULL) {
323 (void *)assert->rp_id, (void *)assert->cdh.ptr);
328 if (pin != NULL || assert->ext.mask != 0)
330 return (u2f_authenticate(dev, assert, &ms));
333 if (pin != NULL || (assert->uv == FIDO_OPT_TRUE &&
335 (assert->ext.mask & FIDO_EXT_HMAC_SECRET)) {
342 r = fido_dev_get_assert_wait(dev, assert, pk, ecdh, pin, &ms);
343 if (r == FIDO_OK && (assert->ext.mask & FIDO_EXT_HMAC_SECRET))
344 if (decrypt_hmac_secrets(dev, assert, ecdh) < 0) {
498 fido_assert_verify(const fido_assert_t *assert, size_t idx, int cose_alg,
510 if (idx >= assert->stmt_len || pk == NULL) {
515 stmt = &assert->stmt[idx];
518 if (assert->cdh.ptr == NULL || assert->rp_id == NULL ||
521 __func__, (void *)assert->cdh.ptr, assert->rp_id,
527 if (fido_check_flags(stmt->authdata.flags, assert->up,
528 assert->uv) < 0) {
534 if (check_extensions(stmt->authdata_ext.mask, assert->ext.mask) < 0) {
540 if (fido_check_rp_id(assert->rp_id, stmt->authdata.rp_id_hash) != 0) {
546 if (fido_get_signed_hash(cose_alg, &dgst, &assert->cdh,
584 fido_assert_set_clientdata(fido_assert_t *assert, const unsigned char *data,
587 if (!fido_blob_is_empty(&assert->cdh) ||
588 fido_blob_set(&assert->cd, data, data_len) < 0) {
591 if (fido_sha256(&assert->cdh, data, data_len) < 0) {
592 fido_blob_reset(&assert->cd);
600 fido_assert_set_clientdata_hash(fido_assert_t *assert,
603 if (!fido_blob_is_empty(&assert->cd) ||
604 fido_blob_set(&assert->cdh, hash, hash_len) < 0)
611 fido_assert_set_hmac_salt(fido_assert_t *assert, const unsigned char *salt,
615 fido_blob_set(&assert->ext.hmac_salt, salt, salt_len) < 0)
622 fido_assert_set_hmac_secret(fido_assert_t *assert, size_t idx,
625 if (idx >= assert->stmt_len || (secret_len != 32 && secret_len != 64) ||
626 fido_blob_set(&assert->stmt[idx].hmac_secret, secret,
634 fido_assert_set_rp(fido_assert_t *assert, const char *id)
636 if (assert->rp_id != NULL) {
637 free(assert->rp_id);
638 assert->rp_id = NULL;
644 if ((assert->rp_id = strdup(id)) == NULL)
652 fido_assert_set_winhello_appid(fido_assert_t *assert, const char *id)
654 if (assert->appid != NULL) {
655 free(assert->appid);
656 assert->appid = NULL;
662 if ((assert->appid = strdup(id)) == NULL)
669 fido_assert_set_winhello_appid(fido_assert_t *assert, const char *id)
671 (void)assert;
679 fido_assert_allow_cred(fido_assert_t *assert, const unsigned char *ptr,
688 if (assert->allow_list.len == SIZE_MAX) {
694 recallocarray(assert->allow_list.ptr, assert->allow_list.len,
695 assert->allow_list.len + 1, sizeof(fido_blob_t))) == NULL) {
700 list_ptr[assert->allow_list.len++] = id;
701 assert->allow_list.ptr = list_ptr;
711 fido_assert_empty_allow_list(fido_assert_t *assert)
713 fido_free_blob_array(&assert->allow_list);
714 memset(&assert->allow_list, 0, sizeof(assert->allow_list));
720 fido_assert_set_extensions(fido_assert_t *assert, int ext)
723 assert->ext.mask = 0;
727 assert->ext.mask |= ext;
734 fido_assert_set_options(fido_assert_t *assert, bool up, bool uv)
736 assert->up = up ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
737 assert->uv = uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
743 fido_assert_set_up(fido_assert_t *assert, fido_opt_t up)
745 assert->up = up;
751 fido_assert_set_uv(fido_assert_t *assert, fido_opt_t uv)
753 assert->uv = uv;
759 fido_assert_clientdata_hash_ptr(const fido_assert_t *assert)
761 return (assert->cdh.ptr);
765 fido_assert_clientdata_hash_len(const fido_assert_t *assert)
767 return (assert->cdh.len);
777 fido_assert_reset_tx(fido_assert_t *assert)
779 free(assert->rp_id);
780 free(assert->appid);
781 fido_blob_reset(&assert->cd);
782 fido_blob_reset(&assert->cdh);
783 fido_blob_reset(&assert->ext.hmac_salt);
784 fido_assert_empty_allow_list(assert);
785 memset(&assert->ext, 0, sizeof(assert->ext));
786 assert->rp_id = NULL;
787 assert->appid = NULL;
788 assert->up = FIDO_OPT_OMIT;
789 assert->uv = FIDO_OPT_OMIT;
801 fido_assert_reset_rx(fido_assert_t *assert)
803 for (size_t i = 0; i < assert->stmt_cnt; i++) {
804 free(assert->stmt[i].user.icon);
805 free(assert->stmt[i].user.name);
806 free(assert->stmt[i].user.display_name);
807 fido_blob_reset(&assert->stmt[i].user.id);
808 fido_blob_reset(&assert->stmt[i].id);
809 fido_blob_reset(&assert->stmt[i].hmac_secret);
810 fido_blob_reset(&assert->stmt[i].authdata_cbor);
811 fido_blob_reset(&assert->stmt[i].authdata_raw);
812 fido_blob_reset(&assert->stmt[i].largeblob_key);
813 fido_blob_reset(&assert->stmt[i].sig);
814 fido_assert_reset_extattr(&assert->stmt[i].authdata_ext);
815 memset(&assert->stmt[i], 0, sizeof(assert->stmt[i]));
817 free(assert->stmt);
818 assert->stmt = NULL;
819 assert->stmt_len = 0;
820 assert->stmt_cnt = 0;
826 fido_assert_t *assert;
828 if (assert_p == NULL || (assert = *assert_p) == NULL)
830 fido_assert_reset_tx(assert);
831 fido_assert_reset_rx(assert);
832 free(assert);
837 fido_assert_count(const fido_assert_t *assert)
839 return (assert->stmt_len);
843 fido_assert_rp_id(const fido_assert_t *assert)
845 return (assert->rp_id);
849 fido_assert_flags(const fido_assert_t *assert, size_t idx)
851 if (idx >= assert->stmt_len)
854 return (assert->stmt[idx].authdata.flags);
858 fido_assert_sigcount(const fido_assert_t *assert, size_t idx)
860 if (idx >= assert->stmt_len)
863 return (assert->stmt[idx].authdata.sigcount);
867 fido_assert_authdata_ptr(const fido_assert_t *assert, size_t idx)
869 if (idx >= assert->stmt_len)
872 return (assert->stmt[idx].authdata_cbor.ptr);
876 fido_assert_authdata_len(const fido_assert_t *assert, size_t idx)
878 if (idx >= assert->stmt_len)
881 return (assert->stmt[idx].authdata_cbor.len);
885 fido_assert_authdata_raw_ptr(const fido_assert_t *assert, size_t idx)
887 if (idx >= assert->stmt_len)
890 return (assert->stmt[idx].authdata_raw.ptr);
894 fido_assert_authdata_raw_len(const fido_assert_t *assert, size_t idx)
896 if (idx >= assert->stmt_len)
899 return (assert->stmt[idx].authdata_raw.len);
903 fido_assert_sig_ptr(const fido_assert_t *assert, size_t idx)
905 if (idx >= assert->stmt_len)
908 return (assert->stmt[idx].sig.ptr);
912 fido_assert_sig_len(const fido_assert_t *assert, size_t idx)
914 if (idx >= assert->stmt_len)
917 return (assert->stmt[idx].sig.len);
921 fido_assert_id_ptr(const fido_assert_t *assert, size_t idx)
923 if (idx >= assert->stmt_len)
926 return (assert->stmt[idx].id.ptr);
930 fido_assert_id_len(const fido_assert_t *assert, size_t idx)
932 if (idx >= assert->stmt_len)
935 return (assert->stmt[idx].id.len);
939 fido_assert_user_id_ptr(const fido_assert_t *assert, size_t idx)
941 if (idx >= assert->stmt_len)
944 return (assert->stmt[idx].user.id.ptr);
948 fido_assert_user_id_len(const fido_assert_t *assert, size_t idx)
950 if (idx >= assert->stmt_len)
953 return (assert->stmt[idx].user.id.len);
957 fido_assert_user_icon(const fido_assert_t *assert, size_t idx)
959 if (idx >= assert->stmt_len)
962 return (assert->stmt[idx].user.icon);
966 fido_assert_user_name(const fido_assert_t *assert, size_t idx)
968 if (idx >= assert->stmt_len)
971 return (assert->stmt[idx].user.name);
975 fido_assert_user_display_name(const fido_assert_t *assert, size_t idx)
977 if (idx >= assert->stmt_len)
980 return (assert->stmt[idx].user.display_name);
984 fido_assert_hmac_secret_ptr(const fido_assert_t *assert, size_t idx)
986 if (idx >= assert->stmt_len)
989 return (assert->stmt[idx].hmac_secret.ptr);
993 fido_assert_hmac_secret_len(const fido_assert_t *assert, size_t idx)
995 if (idx >= assert->stmt_len)
998 return (assert->stmt[idx].hmac_secret.len);
1002 fido_assert_largeblob_key_ptr(const fido_assert_t *assert, size_t idx)
1004 if (idx >= assert->stmt_len)
1007 return (assert->stmt[idx].largeblob_key.ptr);
1011 fido_assert_largeblob_key_len(const fido_assert_t *assert, size_t idx)
1013 if (idx >= assert->stmt_len)
1016 return (assert->stmt[idx].largeblob_key.len);
1020 fido_assert_blob_ptr(const fido_assert_t *assert, size_t idx)
1022 if (idx >= assert->stmt_len)
1025 return (assert->stmt[idx].authdata_ext.blob.ptr);
1029 fido_assert_blob_len(const fido_assert_t *assert, size_t idx)
1031 if (idx >= assert->stmt_len)
1034 return (assert->stmt[idx].authdata_ext.blob.len);
1047 fido_assert_set_authdata(fido_assert_t *assert, size_t idx,
1055 if (idx >= assert->stmt_len || ptr == NULL || len == 0)
1058 stmt = &assert->stmt[idx];
1092 fido_assert_set_authdata_raw(fido_assert_t *assert, size_t idx,
1099 if (idx >= assert->stmt_len || ptr == NULL || len == 0)
1102 stmt = &assert->stmt[idx];
1149 fido_assert_set_count(fido_assert_t *assert, size_t n)
1160 new_stmt = recallocarray(assert->stmt, assert->stmt_cnt, n,
1165 assert->stmt = new_stmt;
1166 assert->stmt_cnt = n;
1167 assert->stmt_len = n;