1/*
2 * Copyright (c) 2018-2023 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 <stdio.h>
10#include <stdlib.h>
11#include <string.h>
12#ifdef HAVE_UNISTD_H
13#include <unistd.h>
14#endif
15
16#include "../openbsd-compat/openbsd-compat.h"
17#include "extern.h"
18
19struct toggle {
20	fido_opt_t up;
21	fido_opt_t uv;
22	fido_opt_t pin;
23};
24
25static const char *
26opt2str(fido_opt_t v)
27{
28	switch (v) {
29	case FIDO_OPT_OMIT:
30		return "omit";
31	case FIDO_OPT_TRUE:
32		return "true";
33	case FIDO_OPT_FALSE:
34		return "false";
35	default:
36		return "unknown";
37	}
38}
39
40static void
41parse_toggle(const char *str, struct toggle *opt)
42{
43	fido_opt_t *k;
44	fido_opt_t  v;
45	char *assignment;
46	char *key;
47	char *val;
48
49	if ((assignment = strdup(str)) == NULL)
50		err(1, "strdup");
51	if ((val = strchr(assignment, '=')) == NULL)
52		errx(1, "invalid assignment '%s'", assignment);
53
54	key = assignment;
55	*val++ = '\0';
56
57	if (!strcmp(val, "true"))
58		v = FIDO_OPT_TRUE;
59	else if (!strcmp(val, "false"))
60		v = FIDO_OPT_FALSE;
61	else
62		errx(1, "unknown value '%s'", val);
63
64	if (!strcmp(key, "up"))
65		k = &opt->up;
66	else if (!strcmp(key, "uv"))
67		k = &opt->uv;
68	else if (!strcmp(key, "pin"))
69		k = &opt->pin;
70	else
71		errx(1, "unknown key '%s'", key);
72
73	free(assignment);
74
75	*k = v;
76}
77
78static fido_assert_t *
79prepare_assert(FILE *in_f, int flags, const struct toggle *opt)
80{
81	fido_assert_t *assert = NULL;
82	struct blob cdh;
83	struct blob id;
84	struct blob hmac_salt;
85	char *rpid = NULL;
86	int r;
87
88	memset(&cdh, 0, sizeof(cdh));
89	memset(&id, 0, sizeof(id));
90	memset(&hmac_salt, 0, sizeof(hmac_salt));
91
92	r = base64_read(in_f, &cdh);
93	r |= string_read(in_f, &rpid);
94	if ((flags & FLAG_RK) == 0)
95		r |= base64_read(in_f, &id);
96	if (flags & FLAG_HMAC)
97		r |= base64_read(in_f, &hmac_salt);
98	if (r < 0)
99		errx(1, "input error");
100
101	if (flags & FLAG_DEBUG) {
102		fprintf(stderr, "client data%s:\n",
103			flags & FLAG_CD ? "" : " hash");
104		xxd(cdh.ptr, cdh.len);
105		fprintf(stderr, "relying party id: %s\n", rpid);
106		if ((flags & FLAG_RK) == 0) {
107			fprintf(stderr, "credential id:\n");
108			xxd(id.ptr, id.len);
109		}
110		fprintf(stderr, "up=%s\n", opt2str(opt->up));
111		fprintf(stderr, "uv=%s\n", opt2str(opt->uv));
112		fprintf(stderr, "pin=%s\n", opt2str(opt->pin));
113	}
114
115	if ((assert = fido_assert_new()) == NULL)
116		errx(1, "fido_assert_new");
117
118	if (flags & FLAG_CD)
119		r = fido_assert_set_clientdata(assert, cdh.ptr, cdh.len);
120	else
121		r = fido_assert_set_clientdata_hash(assert, cdh.ptr, cdh.len);
122
123	if (r != FIDO_OK || (r = fido_assert_set_rp(assert, rpid)) != FIDO_OK)
124		errx(1, "fido_assert_set: %s", fido_strerr(r));
125	if ((r = fido_assert_set_up(assert, opt->up)) != FIDO_OK)
126		errx(1, "fido_assert_set_up: %s", fido_strerr(r));
127	if ((r = fido_assert_set_uv(assert, opt->uv)) != FIDO_OK)
128		errx(1, "fido_assert_set_uv: %s", fido_strerr(r));
129
130	if (flags & FLAG_HMAC) {
131		if ((r = fido_assert_set_extensions(assert,
132		    FIDO_EXT_HMAC_SECRET)) != FIDO_OK)
133			errx(1, "fido_assert_set_extensions: %s",
134			    fido_strerr(r));
135		if ((r = fido_assert_set_hmac_salt(assert, hmac_salt.ptr,
136		    hmac_salt.len)) != FIDO_OK)
137			errx(1, "fido_assert_set_hmac_salt: %s",
138			    fido_strerr(r));
139	}
140	if (flags & FLAG_LARGEBLOB) {
141		if ((r = fido_assert_set_extensions(assert,
142		    FIDO_EXT_LARGEBLOB_KEY)) != FIDO_OK)
143			errx(1, "fido_assert_set_extensions: %s", fido_strerr(r));
144	}
145	if ((flags & FLAG_RK) == 0) {
146		if ((r = fido_assert_allow_cred(assert, id.ptr,
147		    id.len)) != FIDO_OK)
148			errx(1, "fido_assert_allow_cred: %s", fido_strerr(r));
149	}
150
151	free(hmac_salt.ptr);
152	free(cdh.ptr);
153	free(id.ptr);
154	free(rpid);
155
156	return (assert);
157}
158
159static void
160print_assert(FILE *out_f, const fido_assert_t *assert, size_t idx, int flags)
161{
162	char *cdh = NULL;
163	char *authdata = NULL;
164	char *sig = NULL;
165	char *user_id = NULL;
166	char *hmac_secret = NULL;
167	char *key = NULL;
168	int r;
169
170	r = base64_encode(fido_assert_clientdata_hash_ptr(assert),
171	    fido_assert_clientdata_hash_len(assert), &cdh);
172	r |= base64_encode(fido_assert_authdata_ptr(assert, idx),
173	    fido_assert_authdata_len(assert, 0), &authdata);
174	r |= base64_encode(fido_assert_sig_ptr(assert, idx),
175	    fido_assert_sig_len(assert, idx), &sig);
176	if (flags & FLAG_RK)
177		r |= base64_encode(fido_assert_user_id_ptr(assert, idx),
178		    fido_assert_user_id_len(assert, idx), &user_id);
179	if (flags & FLAG_HMAC)
180		r |= base64_encode(fido_assert_hmac_secret_ptr(assert, idx),
181		    fido_assert_hmac_secret_len(assert, idx), &hmac_secret);
182	if (flags & FLAG_LARGEBLOB)
183		r |= base64_encode(fido_assert_largeblob_key_ptr(assert, idx),
184		    fido_assert_largeblob_key_len(assert, idx), &key);
185	if (r < 0)
186		errx(1, "output error");
187
188	fprintf(out_f, "%s\n", cdh);
189	fprintf(out_f, "%s\n", fido_assert_rp_id(assert));
190	fprintf(out_f, "%s\n", authdata);
191	fprintf(out_f, "%s\n", sig);
192	if (flags & FLAG_RK)
193		fprintf(out_f, "%s\n", user_id);
194	if (hmac_secret) {
195		fprintf(out_f, "%s\n", hmac_secret);
196		explicit_bzero(hmac_secret, strlen(hmac_secret));
197	}
198	if (key) {
199		fprintf(out_f, "%s\n", key);
200		explicit_bzero(key, strlen(key));
201	}
202
203	free(key);
204	free(hmac_secret);
205	free(cdh);
206	free(authdata);
207	free(sig);
208	free(user_id);
209}
210
211int
212assert_get(int argc, char **argv)
213{
214	fido_dev_t *dev = NULL;
215	fido_assert_t *assert = NULL;
216	struct toggle opt;
217	char prompt[1024];
218	char pin[128];
219	char *in_path = NULL;
220	char *out_path = NULL;
221	FILE *in_f = NULL;
222	FILE *out_f = NULL;
223	int flags = 0;
224	int ch;
225	int r;
226
227	opt.up = opt.uv = opt.pin = FIDO_OPT_OMIT;
228
229	while ((ch = getopt(argc, argv, "bdhi:o:prt:uvw")) != -1) {
230		switch (ch) {
231		case 'b':
232			flags |= FLAG_LARGEBLOB;
233			break;
234		case 'd':
235			flags |= FLAG_DEBUG;
236			break;
237		case 'h':
238			flags |= FLAG_HMAC;
239			break;
240		case 'i':
241			in_path = optarg;
242			break;
243		case 'o':
244			out_path = optarg;
245			break;
246		case 'p':
247			opt.up = FIDO_OPT_TRUE;
248			break;
249		case 'r':
250			flags |= FLAG_RK;
251			break;
252		case 't' :
253			parse_toggle(optarg, &opt);
254			break;
255		case 'u':
256			flags |= FLAG_U2F;
257			break;
258		case 'v':
259			/* -v implies both pin and uv for historical reasons */
260			opt.pin = FIDO_OPT_TRUE;
261			opt.uv = FIDO_OPT_TRUE;
262			break;
263		case 'w':
264			flags |= FLAG_CD;
265			break;
266		default:
267			usage();
268		}
269	}
270
271	argc -= optind;
272	argv += optind;
273
274	if (argc < 1)
275		usage();
276
277	in_f = open_read(in_path);
278	out_f = open_write(out_path);
279
280	fido_init((flags & FLAG_DEBUG) ? FIDO_DEBUG : 0);
281
282	assert = prepare_assert(in_f, flags, &opt);
283
284	dev = open_dev(argv[0]);
285	if (flags & FLAG_U2F)
286		fido_dev_force_u2f(dev);
287
288	if (opt.pin == FIDO_OPT_TRUE) {
289		r = snprintf(prompt, sizeof(prompt), "Enter PIN for %s: ",
290		    argv[0]);
291		if (r < 0 || (size_t)r >= sizeof(prompt))
292			errx(1, "snprintf");
293		if (!readpassphrase(prompt, pin, sizeof(pin), RPP_ECHO_OFF))
294			errx(1, "readpassphrase");
295		if (strlen(pin) < 4 || strlen(pin) > 63) {
296			explicit_bzero(pin, sizeof(pin));
297			errx(1, "invalid PIN length");
298		}
299		r = fido_dev_get_assert(dev, assert, pin);
300	} else
301		r = fido_dev_get_assert(dev, assert, NULL);
302
303	explicit_bzero(pin, sizeof(pin));
304
305	if (r != FIDO_OK)
306		errx(1, "fido_dev_get_assert: %s", fido_strerr(r));
307
308	if (flags & FLAG_RK) {
309		for (size_t idx = 0; idx < fido_assert_count(assert); idx++)
310			print_assert(out_f, assert, idx, flags);
311	} else {
312		if (fido_assert_count(assert) != 1)
313			errx(1, "fido_assert_count: %zu",
314			    fido_assert_count(assert));
315		print_assert(out_f, assert, 0, flags);
316	}
317
318	fido_dev_close(dev);
319	fido_dev_free(&dev);
320	fido_assert_free(&assert);
321
322	fclose(in_f);
323	fclose(out_f);
324	in_f = NULL;
325	out_f = NULL;
326
327	exit(0);
328}
329