reflect fido's 3-state booleans

examples/assert.c

@@ -132,10 +132,13 @@ verify_assert(int type, const unsigned char *authdata_ptr, size_t authdata_len,
 		errx(1, "fido_assert_set_extensions: %s (0x%x)", fido_strerr(r),
 		    r);
 
-	/* options */
-	r = fido_assert_set_options(assert, up, uv);
-	if (r != FIDO_OK)
-		errx(1, "fido_assert_set_options: %s (0x%x)", fido_strerr(r), r);
+	/* user presence */
+	if (up && (r = fido_assert_set_up(assert, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_assert_set_up: %s (0x%x)", fido_strerr(r), r);
+
+	/* user verification */
+	if (uv && (r = fido_assert_set_uv(assert, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_assert_set_uv: %s (0x%x)", fido_strerr(r), r);
 
 	/* sig */
 	r = fido_assert_set_sig(assert, 0, sig_ptr, sig_len);
@@ -260,10 +263,13 @@ main(int argc, char **argv)
 		errx(1, "fido_assert_set_extensions: %s (0x%x)", fido_strerr(r),
 		    r);
 
-	/* options */
-	r = fido_assert_set_options(assert, up, uv);
-	if (r != FIDO_OK)
-		errx(1, "fido_assert_set_options: %s (0x%x)", fido_strerr(r), r);
+	/* user presence */
+	if (up && (r = fido_assert_set_up(assert, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_assert_set_up: %s (0x%x)", fido_strerr(r), r);
+
+	/* user verification */
+	if (uv && (r = fido_assert_set_uv(assert, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_assert_set_uv: %s (0x%x)", fido_strerr(r), r);
 
 	r = fido_dev_get_assert(dev, assert, pin);
 	if (r != FIDO_OK)

examples/cred.c

@@ -80,10 +80,13 @@ verify_cred(int type, const char *fmt, const unsigned char *authdata_ptr,
 	if (r != FIDO_OK)
 		errx(1, "fido_cred_set_extensions: %s (0x%x)", fido_strerr(r), r);
 
-	/* options */
-	r = fido_cred_set_options(cred, rk, uv);
-	if (r != FIDO_OK)
-		errx(1, "fido_cred_set_options: %s (0x%x)", fido_strerr(r), r);
+	/* resident key */
+	if (rk && (r = fido_cred_set_rk(cred, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_cred_set_rk: %s (0x%x)", fido_strerr(r), r);
+
+	/* user verification */
+	if (uv && (r = fido_cred_set_uv(cred, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_cred_set_uv: %s (0x%x)", fido_strerr(r), r);
 
 	/* x509 */
 	r = fido_cred_set_x509(cred, x509_ptr, x509_len);
@@ -243,10 +246,13 @@ main(int argc, char **argv)
 	if (r != FIDO_OK)
 		errx(1, "fido_cred_set_extensions: %s (0x%x)", fido_strerr(r), r);
 
-	/* options */
-	r = fido_cred_set_options(cred, rk, uv);
-	if (r != FIDO_OK)
-		errx(1, "fido_cred_set_options: %s (0x%x)", fido_strerr(r), r);
+	/* resident key */
+	if (rk && (r = fido_cred_set_rk(cred, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_cred_set_rk: %s (0x%x)", fido_strerr(r), r);
+
+	/* user verification */
+	if (uv && (r = fido_cred_set_uv(cred, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_cred_set_uv: %s (0x%x)", fido_strerr(r), r);
 
 	r = fido_dev_make_cred(dev, cred, pin);
 	if (r != FIDO_OK)

fuzz/fuzz_assert.c

@@ -374,7 +374,10 @@ get_assert(fido_assert_t *assert, uint8_t u2f, const struct blob *cdh,
 	fido_assert_set_clientdata_hash(assert, cdh->body, cdh->len);
 	fido_assert_set_rp(assert, rp_id);
 	fido_assert_set_extensions(assert, ext);
-	fido_assert_set_options(assert, up & 1, uv & 1);
+	if (up & 1)
+		fido_assert_set_up(assert, FIDO_OPT_TRUE);
+	if (uv & 1)
+		fido_assert_set_uv(assert, FIDO_OPT_TRUE);
 	/* XXX reuse cred as hmac salt to keep struct param small */
 	fido_assert_set_hmac_salt(assert, cred->body, cred->len);
 
@@ -402,7 +405,8 @@ verify_assert(int type, const unsigned char *cdh_ptr, size_t cdh_len,
 	fido_assert_set_count(assert, 1);
 	fido_assert_set_authdata(assert, 0, authdata_ptr, authdata_len);
 	fido_assert_set_extensions(assert, ext);
-	fido_assert_set_options(assert, up & 1, uv & 1);
+	if (up & 1) fido_assert_set_up(assert, FIDO_OPT_TRUE);
+	if (uv & 1) fido_assert_set_uv(assert, FIDO_OPT_TRUE);
 	fido_assert_set_sig(assert, 0, sig_ptr, sig_len);
 	fido_assert_verify(assert, 0, type, pk);
 

fuzz/fuzz_cred.c

@@ -716,7 +716,10 @@ make_cred(fido_cred_t *cred, uint8_t u2f, int type, const struct blob *cdh,
 	fido_cred_set_user(cred, user_id->body, user_id->len, user_name,
 	    user_nick, user_icon);
 	fido_cred_set_extensions(cred, ext);
-	fido_cred_set_options(cred, rk & 1, uv & 1);
+	if (rk & 1)
+		fido_cred_set_rk(cred, FIDO_OPT_TRUE);
+	if (uv & 1)
+		fido_cred_set_uv(cred, FIDO_OPT_TRUE);
 
 	fido_dev_make_cred(dev, cred, u2f & 1 ? NULL : pin);
 
@@ -744,10 +747,13 @@ verify_cred(int type, const unsigned char *cdh_ptr, size_t cdh_len,
 	fido_cred_set_rp(cred, rp_id, rp_name);
 	fido_cred_set_authdata(cred, authdata_ptr, authdata_len);
 	fido_cred_set_extensions(cred, ext);
-	fido_cred_set_options(cred, rk & 1, uv & 1);
 	fido_cred_set_x509(cred, x5c_ptr, x5c_len);
 	fido_cred_set_sig(cred, sig_ptr, sig_len);
 
+	if (rk & 1)
+		fido_cred_set_rk(cred, FIDO_OPT_TRUE);
+	if (uv & 1)
+		fido_cred_set_uv(cred, FIDO_OPT_TRUE);
 	if (fmt)
 		fido_cred_set_fmt(cred, fmt);
 

man/CMakeLists.txt

@@ -65,7 +65,8 @@ list(APPEND MAN_ALIAS
 	fido_assert_set fido_assert_set_count
 	fido_assert_set fido_assert_set_extensions
 	fido_assert_set fido_assert_set_hmac_salt
-	fido_assert_set fido_assert_set_options
+	fido_assert_set fido_assert_set_up
+	fido_assert_set fido_assert_set_uv
 	fido_assert_set fido_assert_set_rp
 	fido_assert_set fido_assert_set_sig
 	fido_cred fido_cred_authdata_len
@@ -87,7 +88,8 @@ list(APPEND MAN_ALIAS
 	fido_cred_set fido_cred_set_clientdata_hash
 	fido_cred_set fido_cred_set_extensions
 	fido_cred_set fido_cred_set_fmt
-	fido_cred_set fido_cred_set_options
+	fido_cred_set fido_cred_set_rk
+	fido_cred_set fido_cred_set_uv
 	fido_cred_set fido_cred_set_rp
 	fido_cred_set fido_cred_set_sig
 	fido_cred_set fido_cred_set_type

man/fido_assert_set.3

@@ -12,12 +12,20 @@
 .Nm fido_assert_set_count ,
 .Nm fido_assert_set_extensions ,
 .Nm fido_assert_set_hmac_salt ,
-.Nm fido_assert_set_options ,
+.Nm fido_assert_set_up ,
+.Nm fido_assert_set_uv ,
 .Nm fido_assert_set_rp ,
 .Nm fido_assert_set_sig
 .Nd set parameters of a FIDO 2 assertion
 .Sh SYNOPSIS
 .In fido.h
+.Bd -literal
+typedef enum {
+	FIDO_OPT_OMIT = 0, /* use authenticator's default */
+	FIDO_OPT_FALSE,    /* explicitly set option to false */
+        FIDO_OPT_TRUE,     /* explicitly set option to true */
+} fido_opt_t;
+.Ed
 .Ft int
 .Fn fido_assert_set_authdata "fido_assert_t *assert" " size_t idx" "const unsigned char *ptr" "size_t len"
 .Ft int
@@ -29,7 +37,9 @@
 .Ft int
 .Fn fido_assert_set_hmac_salt "fido_assert_t *assert" "const unsigned char *ptr" "size_t len"
 .Ft int
-.Fn fido_assert_set_options "fido_assert_t *assert" "bool up" "bool uv"
+.Fn fido_assert_set_up "fido_assert_t *assert" "fido_opt_t up"
+.Ft int
+.Fn fido_assert_set_uv "fido_assert_t *assert" "fido_opt_t uv"
 .Ft int
 .Fn fido_assert_set_rp "fido_assert_t *assert" "const char *id"
 .Ft int
@@ -127,15 +137,19 @@ is zero, the extensions of
 are cleared.
 .Pp
 The
-.Fn fido_assert_set_options
-function sets the
+.Fn fido_assert_set_up
+and
+.Fn fido_assert_set_uv
+functions set the
 .Fa up
 (user presence) and
 .Fa uv
 (user verification)
 attributes of
 .Fa assert .
-Both are off by default.
+Both are
+.Dv FIDO_OPT_OMIT
+by default, allowing the authenticator to use its default settings.
 .Pp
 Use of the
 .Nm

man/fido_cred_set.3

@@ -14,12 +14,20 @@
 .Nm fido_cred_set_rp ,
 .Nm fido_cred_set_user ,
 .Nm fido_cred_set_extensions ,
-.Nm fido_cred_set_options ,
+.Nm fido_cred_set_rk ,
+.Nm fido_cred_set uv ,
 .Nm fido_cred_set_fmt ,
 .Nm fido_cred_set_type
 .Nd set parameters of a FIDO 2 credential
 .Sh SYNOPSIS
 .In fido.h
+.Bd -literal
+typedef enum {
+	FIDO_OPT_OMIT = 0, /* use authenticator's default */
+	FIDO_OPT_FALSE,    /* explicitly set option to false */
+        FIDO_OPT_TRUE,     /* explicitly set option to true */
+} fido_opt_t;
+.Ed
 .Ft int
 .Fn fido_cred_set_authdata "fido_cred_t *cred" "const unsigned char *ptr" "size_t len"
 .Ft int
@@ -35,7 +43,9 @@
 .Ft int
 .Fn fido_cred_set_extensions "fido_cred_t *cred" "int flags"
 .Ft int
-.Fn fido_cred_set_options "fido_cred_t *cred" "bool rk" "bool uv"
+.Fn fido_cred_set_rk "fido_cred_t *cred" "fido_opt_t rk"
+.Ft int
+.Fn fido_cred_set_uv "fido_cred_t *cred" "fido_opt_t uv"
 .Ft int
 .Fn fido_cred_set_fmt "fido_cred_t *cred" "const char *ptr"
 .Ft int
@@ -135,8 +145,10 @@ is zero, the extensions of
 are cleared.
 .Pp
 The
-.Fn fido_cred_set_options
-function sets the
+.Fn fido_cred_set_rk
+and
+.Fn fido_cred_set_uv
+functions set the
 .Em rk
 (resident key)
 and
@@ -144,7 +156,9 @@ and
 (user verification)
 attributes of
 .Fa cred .
-Both are off by default.
+Both are
+.Dv FIDO_OPT_OMIT
+by default, allowing the authenticator to use its default settings.
 .Pp
 The
 .Fn fido_cred_set_fmt

regress/assert.c

@@ -250,7 +250,8 @@ valid_assert(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_OK);
 	free_assert(a);
@@ -270,7 +271,8 @@ no_cdh(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256,
 	    pk) == FIDO_ERR_INVALID_ARGUMENT);
@@ -291,7 +293,8 @@ no_rp(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256,
 	    pk) == FIDO_ERR_INVALID_ARGUMENT);
@@ -311,7 +314,8 @@ no_authdata(void)
 	assert(fido_assert_set_clientdata_hash(a, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_assert_set_rp(a, "localhost") == FIDO_OK);
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256,
 	    pk) == FIDO_ERR_INVALID_ARGUMENT);
@@ -333,7 +337,8 @@ no_sig(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256,
 	    pk) == FIDO_ERR_INVALID_ARGUMENT);
 	free_assert(a);
@@ -360,7 +365,8 @@ junk_cdh(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_ERR_INVALID_SIG);
 	free_assert(a);
@@ -382,7 +388,8 @@ junk_rp(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256,
 	    pk) == FIDO_ERR_INVALID_PARAM);
@@ -429,7 +436,8 @@ junk_sig(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, junk, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_ERR_INVALID_SIG);
 	free_assert(a);
@@ -451,14 +459,17 @@ wrong_options(void)
 	assert(fido_assert_set_count(a, 1) == FIDO_OK);
 	assert(fido_assert_set_authdata(a, 0, authdata,
 	    sizeof(authdata)) == FIDO_OK);
-	assert(fido_assert_set_options(a, true, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_TRUE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_set_sig(a, 0, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256,
 	    pk) == FIDO_ERR_INVALID_PARAM);
-	assert(fido_assert_set_options(a, false, true) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_TRUE) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256,
 	    pk) == FIDO_ERR_INVALID_PARAM);
-	assert(fido_assert_set_options(a, false, false) == FIDO_OK);
+	assert(fido_assert_set_up(a, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_assert_set_uv(a, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_assert_verify(a, 0, COSE_ES256, pk) == FIDO_OK);
 	free_assert(a);
 	free_es256_pk(pk);

regress/cred.c

@@ -365,7 +365,8 @@ valid_cred(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -386,7 +387,8 @@ no_cdh(void)
 	assert(fido_cred_set_type(c, COSE_ES256) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -407,7 +409,8 @@ no_rp_id(void)
 	assert(fido_cred_set_type(c, COSE_ES256) == FIDO_OK);
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -429,7 +432,8 @@ no_rp_name(void)
 	assert(fido_cred_set_rp(c, rp_id, NULL) == FIDO_OK);
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -450,7 +454,8 @@ no_authdata(void)
 	assert(fido_cred_set_type(c, COSE_ES256) == FIDO_OK);
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -472,7 +477,8 @@ no_x509(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
 	assert(fido_cred_verify(c) == FIDO_ERR_INVALID_ARGUMENT);
@@ -493,7 +499,8 @@ no_sig(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
 	assert(fido_cred_verify(c) == FIDO_ERR_INVALID_ARGUMENT);
@@ -514,7 +521,8 @@ no_fmt(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_verify(c) == FIDO_ERR_INVALID_ARGUMENT);
@@ -535,7 +543,8 @@ wrong_options(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, true) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_TRUE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -563,7 +572,8 @@ junk_cdh(void)
 	assert(fido_cred_set_clientdata_hash(c, junk, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -586,7 +596,8 @@ junk_rp_id(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, "potato", rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -608,7 +619,8 @@ junk_rp_name(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, "potato") == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -669,7 +681,8 @@ junk_sig(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, junk, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -698,7 +711,8 @@ junk_x509(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_OK);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, junk, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);
@@ -722,7 +736,8 @@ invalid_type(void)
 	assert(fido_cred_set_clientdata_hash(c, cdh, sizeof(cdh)) == FIDO_OK);
 	assert(fido_cred_set_rp(c, rp_id, rp_name) == FIDO_OK);
 	assert(fido_cred_set_authdata(c, authdata, sizeof(authdata)) == FIDO_ERR_INVALID_ARGUMENT);
-	assert(fido_cred_set_options(c, false, false) == FIDO_OK);
+	assert(fido_cred_set_rk(c, FIDO_OPT_FALSE) == FIDO_OK);
+	assert(fido_cred_set_uv(c, FIDO_OPT_FALSE) == FIDO_OK);
 	assert(fido_cred_set_x509(c, x509, sizeof(x509)) == FIDO_OK);
 	assert(fido_cred_set_sig(c, sig, sizeof(sig)) == FIDO_OK);
 	assert(fido_cred_set_fmt(c, "packed") == FIDO_OK);

src/assert.c

@@ -102,8 +102,7 @@ fido_dev_get_assert_tx(fido_dev_t *dev, fido_assert_t *assert,
 	}
 
 	if ((argv[0] = cbor_build_string(assert->rp_id)) == NULL ||
-	    (argv[1] = fido_blob_encode(&assert->cdh)) == NULL ||
-	    (argv[4] = encode_assert_options(assert->up, assert->uv)) == NULL) {
+	    (argv[1] = fido_blob_encode(&assert->cdh)) == NULL) {
 		log_debug("%s: cbor encode", __func__);
 		r = FIDO_ERR_INTERNAL;
 		goto fail;
@@ -128,6 +127,15 @@ fido_dev_get_assert_tx(fido_dev_t *dev, fido_assert_t *assert,
 			goto fail;
 		}
 
+	/* options */
+	if (assert->up != FIDO_OPT_OMIT || assert->uv != FIDO_OPT_OMIT)
+		if ((argv[4] = encode_assert_options(assert->up,
+		    assert->uv)) == NULL) {
+			log_debug("%s: encode_assert_options", __func__);
+			r = FIDO_ERR_INTERNAL;
+			goto fail;
+		}
+
 	/* pin authentication */
 	if (pin) {
 		if (pk == NULL || ecdh == NULL) {
@@ -326,14 +334,16 @@ fail:
 }
 
 static int
-check_flags(uint8_t flags, bool up, bool uv)
+check_flags(uint8_t flags, fido_opt_t up, fido_opt_t uv)
 {
-	if (up == true && (flags & CTAP_AUTHDATA_USER_PRESENT) == 0) {
+	if (up == FIDO_OPT_TRUE &&
+	    (flags & CTAP_AUTHDATA_USER_PRESENT) == 0) {
 		log_debug("%s: CTAP_AUTHDATA_USER_PRESENT", __func__);
 		return (-1); /* user not present */
 	}
 
-	if (uv == true && (flags & CTAP_AUTHDATA_USER_VERIFIED) == 0) {
+	if (uv == FIDO_OPT_TRUE &&
+	    (flags & CTAP_AUTHDATA_USER_VERIFIED) == 0) {
 		log_debug("%s: CTAP_AUTHDATA_USER_VERIFIED", __func__);
 		return (-1); /* user not verified */
 	}
@@ -687,8 +697,24 @@ fido_assert_set_extensions(fido_assert_t *assert, int ext)
 
 int
 fido_assert_set_options(fido_assert_t *assert, bool up, bool uv)
+{
+	assert->up = up ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
+	assert->uv = uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
+
+	return (FIDO_OK);
+}
+
+int
+fido_assert_set_up(fido_assert_t *assert, fido_opt_t up)
 {
 	assert->up = up;
+
+	return (FIDO_OK);
+}
+
+int
+fido_assert_set_uv(fido_assert_t *assert, fido_opt_t uv)
+{
 	assert->uv = uv;
 
 	return (FIDO_OK);
@@ -725,8 +751,8 @@ fido_assert_reset_tx(fido_assert_t *assert)
 	memset(&assert->allow_list, 0, sizeof(assert->allow_list));
 
 	assert->rp_id = NULL;
-	assert->up = false;
-	assert->uv = false;
+	assert->up = FIDO_OPT_OMIT;
+	assert->uv = FIDO_OPT_OMIT;
 	assert->ext = 0;
 }
 

src/cbor.c

@@ -276,7 +276,7 @@ fail:
 }
 
 int
-cbor_add_bool(cbor_item_t *item, const char *key, bool value)
+cbor_add_bool(cbor_item_t *item, const char *key, fido_opt_t value)
 {
 	struct cbor_pair pair;
 	int ok = -1;
@@ -284,7 +284,7 @@ cbor_add_bool(cbor_item_t *item, const char *key, bool value)
 	memset(&pair, 0, sizeof(pair));
 
 	if ((pair.key = cbor_build_string(key)) == NULL ||
-	    (pair.value = cbor_build_bool(value)) == NULL) {
+	    (pair.value = cbor_build_bool(value == FIDO_OPT_TRUE)) == NULL) {
 		log_debug("%s: cbor_build", __func__);
 		goto fail;
 	}
@@ -545,15 +545,15 @@ encode_extensions(int ext)
 }
 
 cbor_item_t *
-encode_options(bool rk, bool uv)
+encode_options(fido_opt_t rk, fido_opt_t uv)
 {
 	cbor_item_t *item = NULL;
 
 	if ((item = cbor_new_definite_map(2)) == NULL)
 		return (NULL);
 
-	if (cbor_add_bool(item, "rk", rk) < 0 ||
-	    cbor_add_bool(item, "uv", uv) < 0) {
+	if ((rk != FIDO_OPT_OMIT && cbor_add_bool(item, "rk", rk) < 0) ||
+	    (uv != FIDO_OPT_OMIT && cbor_add_bool(item, "uv", uv) < 0)) {
 		cbor_decref(&item);
 		return (NULL);
 	}
@@ -562,15 +562,15 @@ encode_options(bool rk, bool uv)
 }
 
 cbor_item_t *
-encode_assert_options(bool up, bool uv)
+encode_assert_options(fido_opt_t up, fido_opt_t uv)
 {
 	cbor_item_t *item = NULL;
 
 	if ((item = cbor_new_definite_map(2)) == NULL)
 		return (NULL);
 
-	if (cbor_add_bool(item, "up", up) < 0 ||
-	    cbor_add_bool(item, "uv", uv) < 0) {
+	if ((up != FIDO_OPT_OMIT && cbor_add_bool(item, "up", up) < 0) ||
+	    (uv != FIDO_OPT_OMIT && cbor_add_bool(item, "uv", uv) < 0)) {
 		cbor_decref(&item);
 		return (NULL);
 	}

src/cred.c

@@ -85,7 +85,7 @@ fido_dev_make_cred_tx(fido_dev_t *dev, fido_cred_t *cred, const char *pin)
 		}
 
 	/* options */
-	if (cred->rk || cred->uv)
+	if (cred->rk != FIDO_OPT_OMIT || cred->uv != FIDO_OPT_OMIT)
 		if ((argv[6] = encode_options(cred->rk, cred->uv)) == NULL) {
 			log_debug("%s: encode_options", __func__);
 			r = FIDO_ERR_INTERNAL;
@@ -175,7 +175,7 @@ int
 fido_dev_make_cred(fido_dev_t *dev, fido_cred_t *cred, const char *pin)
 {
 	if (fido_dev_is_fido2(dev) == false) {
-		if (pin != NULL || cred->rk == true || cred->ext != 0)
+		if (pin != NULL || cred->rk == FIDO_OPT_TRUE || cred->ext != 0)
 			return (FIDO_ERR_UNSUPPORTED_OPTION);
 		return (u2f_register(dev, cred, -1));
 	}
@@ -184,9 +184,10 @@ fido_dev_make_cred(fido_dev_t *dev, fido_cred_t *cred, const char *pin)
 }
 
 static int
-check_flags(uint8_t flags, bool uv)
+check_flags(uint8_t flags, fido_opt_t uv)
 {
-	if (uv == true && (flags & CTAP_AUTHDATA_USER_VERIFIED) == 0) {
+	if (uv == FIDO_OPT_TRUE &&
+	    (flags & CTAP_AUTHDATA_USER_VERIFIED) == 0) {
 		log_debug("%s: CTAP_AUTHDATA_USER_VERIFIED", __func__);
 		return (-1);
 	}
@@ -439,8 +440,8 @@ fido_cred_reset_tx(fido_cred_t *cred)
 
 	cred->type = 0;
 	cred->ext = 0;
-	cred->rk = false;
-	cred->uv = false;
+	cred->rk = FIDO_OPT_OMIT;
+	cred->uv = FIDO_OPT_OMIT;
 }
 
 static void
@@ -698,8 +699,24 @@ fido_cred_set_extensions(fido_cred_t *cred, int ext)
 
 int
 fido_cred_set_options(fido_cred_t *cred, bool rk, bool uv)
+{
+	cred->rk = rk ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
+	cred->uv = uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE;
+
+	return (FIDO_OK);
+}
+
+int
+fido_cred_set_rk(fido_cred_t *cred, fido_opt_t rk)
 {
 	cred->rk = rk;
+
+	return (FIDO_OK);
+}
+
+int
+fido_cred_set_uv(fido_cred_t *cred, fido_opt_t uv)
+{
 	cred->uv = uv;
 
 	return (FIDO_OK);

src/export.gnu

@@ -1,5 +1,10 @@
 {
 	global:
+		eddsa_pk_free;
+		eddsa_pk_from_EVP_PKEY;
+		eddsa_pk_from_ptr;
+		eddsa_pk_new;
+		eddsa_pk_to_EVP_PKEY;
 		es256_pk_free;
 		es256_pk_from_EC_KEY;
 		es256_pk_from_ptr;
@@ -27,6 +32,8 @@
 		fido_assert_set_options;
 		fido_assert_set_rp;
 		fido_assert_set_sig;
+		fido_assert_set_up;
+		fido_assert_set_uv;
 		fido_assert_sig_len;
 		fido_assert_sig_ptr;
 		fido_assert_user_display_name;
@@ -69,10 +76,12 @@
 		fido_cred_set_extensions;
 		fido_cred_set_fmt;
 		fido_cred_set_options;
+		fido_cred_set_rk;
 		fido_cred_set_rp;
 		fido_cred_set_sig;
 		fido_cred_set_type;
 		fido_cred_set_user;
+		fido_cred_set_uv;
 		fido_cred_set_x509;
 		fido_cred_sig_len;
 		fido_cred_sig_ptr;
@@ -114,11 +123,6 @@
 		rs256_pk_from_RSA;
 		rs256_pk_new;
 		rs256_pk_to_EVP_PKEY;
-		eddsa_pk_new;
-		eddsa_pk_from_EVP_PKEY;
-		eddsa_pk_from_ptr;
-		eddsa_pk_to_EVP_PKEY;
-		eddsa_pk_free;
 	local:
 		*;
 };

src/export.llvm

@@ -1,3 +1,8 @@
+_eddsa_pk_free
+_eddsa_pk_from_EVP_PKEY
+_eddsa_pk_from_ptr
+_eddsa_pk_new
+_eddsa_pk_to_EVP_PKEY
 _es256_pk_free
 _es256_pk_from_EC_KEY
 _es256_pk_from_ptr
@@ -25,6 +30,8 @@ _fido_assert_set_hmac_salt
 _fido_assert_set_options
 _fido_assert_set_rp
 _fido_assert_set_sig
+_fido_assert_set_up
+_fido_assert_set_uv
 _fido_assert_sig_len
 _fido_assert_sig_ptr
 _fido_assert_user_display_name
@@ -67,10 +74,12 @@ _fido_cred_set_clientdata_hash
 _fido_cred_set_extensions
 _fido_cred_set_fmt
 _fido_cred_set_options
+_fido_cred_set_rk
 _fido_cred_set_rp
 _fido_cred_set_sig
 _fido_cred_set_type
 _fido_cred_set_user
+_fido_cred_set_uv
 _fido_cred_set_x509
 _fido_cred_sig_len
 _fido_cred_sig_ptr
@@ -112,8 +121,3 @@ _rs256_pk_from_ptr
 _rs256_pk_from_RSA
 _rs256_pk_new
 _rs256_pk_to_EVP_PKEY
-_eddsa_pk_new
-_eddsa_pk_from_EVP_PKEY
-_eddsa_pk_from_ptr
-_eddsa_pk_to_EVP_PKEY
-_eddsa_pk_free

src/export.msvc

@@ -1,4 +1,9 @@
 EXPORTS
+eddsa_pk_free
+eddsa_pk_from_EVP_PKEY
+eddsa_pk_from_ptr
+eddsa_pk_new
+eddsa_pk_to_EVP_PKEY
 es256_pk_free
 es256_pk_from_EC_KEY
 es256_pk_from_ptr
@@ -26,6 +31,8 @@ fido_assert_set_hmac_salt
 fido_assert_set_options
 fido_assert_set_rp
 fido_assert_set_sig
+fido_assert_set_up
+fido_assert_set_uv
 fido_assert_sig_len
 fido_assert_sig_ptr
 fido_assert_user_display_name
@@ -68,10 +75,12 @@ fido_cred_set_clientdata_hash
 fido_cred_set_extensions
 fido_cred_set_fmt
 fido_cred_set_options
+fido_cred_set_rk
 fido_cred_set_rp
 fido_cred_set_sig
 fido_cred_set_type
 fido_cred_set_user
+fido_cred_set_uv
 fido_cred_set_x509
 fido_cred_sig_len
 fido_cred_sig_ptr
@@ -113,8 +122,3 @@ rs256_pk_from_ptr
 rs256_pk_from_RSA
 rs256_pk_new
 rs256_pk_to_EVP_PKEY
-eddsa_pk_new
-eddsa_pk_from_EVP_PKEY
-eddsa_pk_from_ptr
-eddsa_pk_to_EVP_PKEY
-eddsa_pk_free

src/extern.h

@@ -12,13 +12,13 @@ int aes256_cbc_dec(const fido_blob_t *, const fido_blob_t *, fido_blob_t *);
 int aes256_cbc_enc(const fido_blob_t *, const fido_blob_t *, fido_blob_t *);
 
 /* cbor encoding functions */
-cbor_item_t *encode_assert_options(bool, bool);
+cbor_item_t *encode_assert_options(fido_opt_t, fido_opt_t);
 cbor_item_t *encode_change_pin_auth(const fido_blob_t *, const fido_blob_t *,
     const fido_blob_t *);
 cbor_item_t *encode_extensions(int);
 cbor_item_t *encode_hmac_secret_param(const fido_blob_t *, const es256_pk_t *,
     const fido_blob_t *);
-cbor_item_t *encode_options(bool, bool);
+cbor_item_t *encode_options(fido_opt_t, fido_opt_t);
 cbor_item_t *encode_pin_auth(const fido_blob_t *, const fido_blob_t *);
 cbor_item_t *encode_pin_enc(const fido_blob_t *, const fido_blob_t *);
 cbor_item_t *encode_pin_hash_enc(const fido_blob_t *, const fido_blob_t *);
@@ -46,7 +46,7 @@ int rs256_pk_decode(const cbor_item_t *, rs256_pk_t *);
 int eddsa_pk_decode(const cbor_item_t *, eddsa_pk_t *);
 
 /* auxiliary cbor routines */
-int cbor_add_bool(cbor_item_t *, const char *, bool);
+int cbor_add_bool(cbor_item_t *, const char *, fido_opt_t);
 int cbor_add_bytestring(cbor_item_t *, const char *, const unsigned char *,
     size_t);
 int cbor_add_string(cbor_item_t *, const char *, const char *);

src/fido.h

@@ -26,6 +26,12 @@ typedef struct fido_dev_io {
 	fido_dev_io_write_t *write;
 } fido_dev_io_t;
 
+typedef enum {
+	FIDO_OPT_OMIT = 0, /* use authenticator's default */
+	FIDO_OPT_FALSE,    /* explicitly set option to false */
+        FIDO_OPT_TRUE,     /* explicitly set option to true */
+} fido_opt_t;
+
 #ifdef _FIDO_INTERNAL
 #include <cbor.h>
 #include <limits.h>
@@ -110,8 +116,10 @@ int fido_assert_set_clientdata_hash(fido_assert_t *, const unsigned char *,
 int fido_assert_set_count(fido_assert_t *, size_t);
 int fido_assert_set_extensions(fido_assert_t *, int);
 int fido_assert_set_hmac_salt(fido_assert_t *, const unsigned char *, size_t);
-int fido_assert_set_options(fido_assert_t *, bool, bool);
+int fido_assert_set_options(fido_assert_t *, bool, bool) __attribute__((__deprecated__));
 int fido_assert_set_rp(fido_assert_t *, const char *);
+int fido_assert_set_up(fido_assert_t *, fido_opt_t);
+int fido_assert_set_uv(fido_assert_t *, fido_opt_t);
 int fido_assert_set_sig(fido_assert_t *, size_t, const unsigned char *, size_t);
 int fido_assert_verify(const fido_assert_t *, size_t, int, const void *);
 int fido_cred_exclude(fido_cred_t *, const unsigned char *, size_t);
@@ -119,8 +127,10 @@ int fido_cred_set_authdata(fido_cred_t *, const unsigned char *, size_t);
 int fido_cred_set_clientdata_hash(fido_cred_t *, const unsigned char *, size_t);
 int fido_cred_set_extensions(fido_cred_t *, int);
 int fido_cred_set_fmt(fido_cred_t *, const char *);
-int fido_cred_set_options(fido_cred_t *, bool, bool);
+int fido_cred_set_options(fido_cred_t *, bool, bool) __attribute__((__deprecated__));
+int fido_cred_set_rk(fido_cred_t *, fido_opt_t);
 int fido_cred_set_rp(fido_cred_t *, const char *, const char *);
+int fido_cred_set_uv(fido_cred_t *, fido_opt_t);
 int fido_cred_set_sig(fido_cred_t *, const unsigned char *, size_t);
 int fido_cred_set_type(fido_cred_t *, int);
 int fido_cred_set_user(fido_cred_t *, const unsigned char *, size_t,

src/types.h

@@ -79,8 +79,8 @@ typedef struct fido_cred {
 	fido_rp_t         rp;            /* relying party */
 	fido_user_t       user;          /* user entity */
 	fido_blob_array_t excl;          /* list of credential ids to exclude */
-	bool              rk;            /* resident key */
-	bool              uv;            /* user verification */
+	fido_opt_t        rk;            /* resident key */
+	fido_opt_t        uv;            /* user verification */
 	int               ext;           /* enabled extensions */
 	int               type;          /* cose algorithm */
 	char             *fmt;           /* credential format */
@@ -107,8 +107,8 @@ typedef struct fido_assert {
 	fido_blob_t        cdh;          /* client data hash */
 	fido_blob_t        hmac_salt;    /* optional hmac-secret salt */
 	fido_blob_array_t  allow_list;   /* list of allowed credentials */
-	bool               up;           /* user presence */
-	bool               uv;           /* user verification */
+	fido_opt_t         up;           /* user presence */
+	fido_opt_t         uv;           /* user verification */
 	int                ext;          /* enabled extensions */
 	fido_assert_stmt  *stmt;         /* array of expected assertions */
 	size_t             stmt_cnt;     /* number of allocated assertions */

src/u2f.c

@@ -535,7 +535,7 @@ u2f_register(fido_dev_t *dev, fido_cred_t *cred, int ms)
 	int		 found;
 	int		 r;
 
-	if (cred->rk || cred->uv) {
+	if (cred->rk == FIDO_OPT_TRUE || cred->uv == FIDO_OPT_TRUE) {
 		log_debug("%s: rk=%d, uv=%d", __func__, cred->rk, cred->uv);
 		return (FIDO_ERR_UNSUPPORTED_OPTION);
 	}
@@ -624,7 +624,7 @@ u2f_authenticate_single(fido_dev_t *dev, const fido_blob_t *key_id,
 		goto fail;
 	}
 
-	if (fa->up == false) {
+	if (fa->up == FIDO_OPT_FALSE) {
 		log_debug("%s: checking for key existence only", __func__);
 		r = FIDO_ERR_USER_PRESENCE_REQUIRED;
 		goto fail;
@@ -664,7 +664,7 @@ u2f_authenticate(fido_dev_t *dev, fido_assert_t *fa, int ms)
 	int	nauth_ok = 0;
 	int	r;
 
-	if (fa->uv || fa->allow_list.ptr == NULL) {
+	if (fa->uv == FIDO_OPT_TRUE || fa->allow_list.ptr == NULL) {
 		log_debug("%s: uv=%d, allow_list=%p", __func__, fa->uv,
 		    (void *)fa->allow_list.ptr);
 		return (FIDO_ERR_UNSUPPORTED_OPTION);

tools/assert_get.c

@@ -51,10 +51,14 @@ prepare_assert(FILE *in_f, bool rk, bool up, bool uv, bool debug)
 
 	if ((r = fido_assert_set_clientdata_hash(assert, cdh.ptr,
 	    cdh.len)) != FIDO_OK ||
-	    (r = fido_assert_set_rp(assert, rpid)) != FIDO_OK ||
-	    (r = fido_assert_set_options(assert, up, uv)) != FIDO_OK)
+	    (r = fido_assert_set_rp(assert, rpid)) != FIDO_OK)
 		errx(1, "fido_assert_set: %s", fido_strerr(r));
 
+	if (up && (r = fido_assert_set_up(assert, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_assert_set_up: %s", fido_strerr(r));
+	if (uv && (r = fido_assert_set_uv(assert, FIDO_OPT_TRUE)) != FIDO_OK)
+		errx(1, "fido_assert_set_uv: %s", fido_strerr(r));
+
 	if (rk == false && (r = fido_assert_allow_cred(assert, id.ptr,
 	    id.len)) != FIDO_OK)
 		errx(1, "fido_assert_allow_cred: %s", fido_strerr(r));