Debian Codegraph @

src/config.c

raw
1 /*
2 * Copyright (c) 2020-2026 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 * SPDX-License-Identifier: BSD-2-Clause
6 */
7
8 #include "fido.h"
9 #include "fido/config.h"
10 #include "fido/es256.h"
11
12 #define CMD_ENABLE_ENTATTEST 0x01
13 #define CMD_TOGGLE_ALWAYS_UV 0x02
14 #define CMD_SET_PIN_MINLEN 0x03
15
16 static int
17 config_prepare_hmac(uint8_t subcmd, const cbor_item_t *item, fido_blob_t *hmac)
18 {
19 uint8_t prefix[32 + 2 * sizeof(uint8_t)], cbor[128];
20 size_t cbor_len = 0;
21
22 memset(prefix, 0xff, sizeof(prefix));
23 prefix[sizeof(prefix) - 2] = CTAP_CBOR_CONFIG;
24 prefix[sizeof(prefix) - 1] = subcmd;
25
26 if (item != NULL) {
27 if ((cbor_len = cbor_serialize(item, cbor, sizeof(cbor))) == 0) {
28 fido_log_debug("%s: cbor_serialize", __func__);
29 return -1;
30 }
31 }
32 if ((hmac->ptr = malloc(cbor_len + sizeof(prefix))) == NULL) {
33 fido_log_debug("%s: malloc", __func__);
34 return -1;
35 }
36 memcpy(hmac->ptr, prefix, sizeof(prefix));
37 memcpy(hmac->ptr + sizeof(prefix), cbor, cbor_len);
38 hmac->len = cbor_len + sizeof(prefix);
39
40 return 0;
41 }
42
43 static int
44 config_tx(fido_dev_t *dev, uint8_t subcmd, cbor_item_t **paramv, size_t paramc,
45 const char *pin, int *ms)
46 {
47 cbor_item_t *argv[4];
48 es256_pk_t *pk = NULL;
49 fido_blob_t *ecdh = NULL, f, hmac;
50 const uint8_t cmd = CTAP_CBOR_CONFIG;
51 int r = FIDO_ERR_INTERNAL;
52
53 memset(&f, 0, sizeof(f));
54 memset(&hmac, 0, sizeof(hmac));
55 memset(&argv, 0, sizeof(argv));
56
57 /* subCommand */
58 if ((argv[0] = cbor_build_uint8(subcmd)) == NULL) {
59 fido_log_debug("%s: cbor encode", __func__);
60 goto fail;
61 }
62
63 /* subCommandParams */
64 if (paramc != 0 &&
65 (argv[1] = cbor_flatten_vector(paramv, paramc)) == NULL) {
66 fido_log_debug("%s: cbor_flatten_vector", __func__);
67 goto fail;
68 }
69
70 /* pinProtocol, pinAuth */
71 if (pin != NULL || fido_dev_puat_blob(dev) != NULL ||
72 (fido_dev_supports_permissions(dev) && fido_dev_has_uv(dev))) {
73 if (config_prepare_hmac(subcmd, argv[1], &hmac) < 0) {
74 fido_log_debug("%s: config_prepare_hmac", __func__);
75 goto fail;
76 }
77
78 /* If available, prefer cached PUAT */
79 if (fido_dev_puat_blob(dev) == NULL &&
80 (r = fido_do_ecdh(dev, &pk, &ecdh, ms)) != FIDO_OK) {
81 fido_log_debug("%s: fido_do_ecdh", __func__);
82 goto fail;
83 }
84
85 if ((r = cbor_add_uv_params(dev, cmd, &hmac, pk, ecdh, pin,
86 NULL, &argv[3], &argv[2], ms)) != FIDO_OK) {
87 fido_log_debug("%s: cbor_add_uv_params", __func__);
88 goto fail;
89 }
90 }
91
92 /* framing and transmission */
93 if (cbor_build_frame(cmd, argv, nitems(argv), &f) < 0 ||
94 fido_tx(dev, CTAP_CMD_CBOR, f.ptr, f.len, ms) < 0) {
95 fido_log_debug("%s: fido_tx", __func__);
96 r = FIDO_ERR_TX;
97 goto fail;
98 }
99
100 r = FIDO_OK;
101 fail:
102 cbor_vector_free(argv, nitems(argv));
103 es256_pk_free(&pk);
104 fido_blob_free(&ecdh);
105 free(f.ptr);
106 free(hmac.ptr);
107
108 return r;
109 }
110
111 static int
112 config_enable_entattest_wait(fido_dev_t *dev, const char *pin, int *ms)
113 {
114 int r;
115
116 if ((r = config_tx(dev, CMD_ENABLE_ENTATTEST, NULL, 0, pin,
117 ms)) != FIDO_OK)
118 return r;
119
120 return fido_rx_cbor_status(dev, ms);
121 }
122
123 int
124 fido_dev_enable_entattest(fido_dev_t *dev, const char *pin)
125 {
126 int ms = dev->timeout_ms;
127
128 return (config_enable_entattest_wait(dev, pin, &ms));
129 }
130
131 static int
132 config_toggle_always_uv_wait(fido_dev_t *dev, const char *pin, int *ms)
133 {
134 int r;
135
136 if ((r = config_tx(dev, CMD_TOGGLE_ALWAYS_UV, NULL, 0, pin,
137 ms)) != FIDO_OK)
138 return r;
139
140 return (fido_rx_cbor_status(dev, ms));
141 }
142
143 int
144 fido_dev_toggle_always_uv(fido_dev_t *dev, const char *pin)
145 {
146 int ms = dev->timeout_ms;
147
148 return config_toggle_always_uv_wait(dev, pin, &ms);
149 }
150
151 static int
152 config_pin_minlen_tx(fido_dev_t *dev, size_t len, bool force,
153 const fido_str_array_t *rpid, const char *pin, int *ms)
154 {
155 cbor_item_t *argv[3];
156 int r;
157
158 memset(argv, 0, sizeof(argv));
159
160 if ((rpid == NULL && len == 0 && !force) || len > UINT8_MAX) {
161 r = FIDO_ERR_INVALID_ARGUMENT;
162 goto fail;
163 }
164 if (len && (argv[0] = cbor_build_uint8((uint8_t)len)) == NULL) {
165 fido_log_debug("%s: cbor_encode_uint8", __func__);
166 r = FIDO_ERR_INTERNAL;
167 goto fail;
168 }
169 if (rpid != NULL && (argv[1] = cbor_encode_str_array(rpid)) == NULL) {
170 fido_log_debug("%s: cbor_encode_str_array", __func__);
171 r = FIDO_ERR_INTERNAL;
172 goto fail;
173 }
174 if (force && (argv[2] = cbor_build_bool(true)) == NULL) {
175 fido_log_debug("%s: cbor_build_bool", __func__);
176 r = FIDO_ERR_INTERNAL;
177 goto fail;
178 }
179 if ((r = config_tx(dev, CMD_SET_PIN_MINLEN, argv, nitems(argv),
180 pin, ms)) != FIDO_OK) {
181 fido_log_debug("%s: config_tx", __func__);
182 goto fail;
183 }
184
185 fail:
186 cbor_vector_free(argv, nitems(argv));
187
188 return r;
189 }
190
191 static int
192 config_pin_minlen(fido_dev_t *dev, size_t len, bool force,
193 const fido_str_array_t *rpid, const char *pin, int *ms)
194 {
195 int r;
196
197 if ((r = config_pin_minlen_tx(dev, len, force, rpid, pin,
198 ms)) != FIDO_OK)
199 return r;
200
201 return fido_rx_cbor_status(dev, ms);
202 }
203
204 int
205 fido_dev_set_pin_minlen(fido_dev_t *dev, size_t len, const char *pin)
206 {
207 int ms = dev->timeout_ms;
208
209 return config_pin_minlen(dev, len, false, NULL, pin, &ms);
210 }
211
212 int
213 fido_dev_force_pin_change(fido_dev_t *dev, const char *pin)
214 {
215 int ms = dev->timeout_ms;
216
217 return config_pin_minlen(dev, 0, true, NULL, pin, &ms);
218 }
219
220 int
221 fido_dev_set_pin_minlen_rpid(fido_dev_t *dev, const char * const *rpid,
222 size_t n, const char *pin)
223 {
224 fido_str_array_t sa;
225 int ms = dev->timeout_ms;
226 int r;
227
228 memset(&sa, 0, sizeof(sa));
229 if (fido_str_array_pack(&sa, rpid, n) < 0) {
230 fido_log_debug("%s: fido_str_array_pack", __func__);
231 r = FIDO_ERR_INTERNAL;
232 goto fail;
233 }
234 r = config_pin_minlen(dev, 0, false, &sa, pin, &ms);
235 fail:
236 fido_str_array_free(&sa);
237
238 return r;
239 }