Annotation of src/usr.bin/ssh/sk-usbhid.c, Revision 1.18
1.1 djm 1: /*
2: * Copyright (c) 2019 Markus Friedl
3: *
4: * Permission to use, copy, modify, and distribute this software for any
5: * purpose with or without fee is hereby granted, provided that the above
6: * copyright notice and this permission notice appear in all copies.
7: *
8: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15: */
16:
17: #include <stdint.h>
18: #include <stdlib.h>
19: #include <string.h>
20: #include <stdio.h>
21: #include <stddef.h>
22: #include <stdarg.h>
1.17 djm 23: #include <sha2.h>
1.1 djm 24:
1.7 naddy 25: #ifdef WITH_OPENSSL
1.1 djm 26: #include <openssl/opensslv.h>
27: #include <openssl/crypto.h>
28: #include <openssl/bn.h>
29: #include <openssl/ec.h>
30: #include <openssl/ecdsa.h>
1.17 djm 31: #include <openssl/evp.h>
1.7 naddy 32: #endif /* WITH_OPENSSL */
1.1 djm 33:
34: #include <fido.h>
1.9 djm 35: #include <fido/credman.h>
1.1 djm 36:
37: #ifndef SK_STANDALONE
1.15 djm 38: # include "log.h"
39: # include "xmalloc.h"
40: /*
41: * If building as part of OpenSSH, then rename exported functions.
42: * This must be done before including sk-api.h.
43: */
44: # define sk_api_version ssh_sk_api_version
45: # define sk_enroll ssh_sk_enroll
46: # define sk_sign ssh_sk_sign
47: # define sk_load_resident_keys ssh_sk_load_resident_keys
48: #endif /* !SK_STANDALONE */
49:
50: #include "sk-api.h"
1.1 djm 51:
52: /* #define SK_DEBUG 1 */
53:
1.18 ! djm 54: #ifdef SK_DEBUG
! 55: #define SSH_FIDO_INIT_ARG FIDO_DEBUG
! 56: #else
! 57: #define SSH_FIDO_INIT_ARG 0
! 58: #endif
! 59:
1.1 djm 60: #define MAX_FIDO_DEVICES 256
61:
62: /* Compatibility with OpenSSH 1.0.x */
63: #if (OPENSSL_VERSION_NUMBER < 0x10100000L)
64: #define ECDSA_SIG_get0(sig, pr, ps) \
65: do { \
66: (*pr) = sig->r; \
67: (*ps) = sig->s; \
68: } while (0)
69: #endif
70:
71: /* Return the version of the middleware API */
72: uint32_t sk_api_version(void);
73:
74: /* Enroll a U2F key (private key generation) */
1.12 djm 75: int sk_enroll(uint32_t alg, const uint8_t *challenge, size_t challenge_len,
1.10 djm 76: const char *application, uint8_t flags, const char *pin,
1.12 djm 77: struct sk_option **options, struct sk_enroll_response **enroll_response);
1.1 djm 78:
79: /* Sign a challenge */
1.12 djm 80: int sk_sign(uint32_t alg, const uint8_t *message, size_t message_len,
1.1 djm 81: const char *application, const uint8_t *key_handle, size_t key_handle_len,
1.12 djm 82: uint8_t flags, const char *pin, struct sk_option **options,
83: struct sk_sign_response **sign_response);
1.1 djm 84:
1.9 djm 85: /* Load resident keys */
1.12 djm 86: int sk_load_resident_keys(const char *pin, struct sk_option **options,
1.9 djm 87: struct sk_resident_key ***rks, size_t *nrks);
88:
1.1 djm 89: static void skdebug(const char *func, const char *fmt, ...)
90: __attribute__((__format__ (printf, 2, 3)));
91:
92: static void
93: skdebug(const char *func, const char *fmt, ...)
94: {
95: #if !defined(SK_STANDALONE)
96: char *msg;
97: va_list ap;
98:
99: va_start(ap, fmt);
100: xvasprintf(&msg, fmt, ap);
101: va_end(ap);
1.2 djm 102: debug("%s: %s", func, msg);
1.1 djm 103: free(msg);
104: #elif defined(SK_DEBUG)
105: va_list ap;
106:
107: va_start(ap, fmt);
108: fprintf(stderr, "%s: ", func);
109: vfprintf(stderr, fmt, ap);
110: fputc('\n', stderr);
111: va_end(ap);
112: #else
113: (void)func; /* XXX */
114: (void)fmt; /* XXX */
115: #endif
116: }
117:
118: uint32_t
119: sk_api_version(void)
120: {
1.15 djm 121: return SSH_SK_VERSION_MAJOR;
1.1 djm 122: }
123:
124: /* Select the first identified FIDO device attached to the system */
125: static char *
126: pick_first_device(void)
127: {
128: char *ret = NULL;
129: fido_dev_info_t *devlist = NULL;
130: size_t olen = 0;
131: int r;
132: const fido_dev_info_t *di;
133:
134: if ((devlist = fido_dev_info_new(1)) == NULL) {
135: skdebug(__func__, "fido_dev_info_new failed");
136: goto out;
137: }
138: if ((r = fido_dev_info_manifest(devlist, 1, &olen)) != FIDO_OK) {
139: skdebug(__func__, "fido_dev_info_manifest failed: %s",
140: fido_strerr(r));
141: goto out;
142: }
143: if (olen != 1) {
144: skdebug(__func__, "fido_dev_info_manifest bad len %zu", olen);
145: goto out;
146: }
147: di = fido_dev_info_ptr(devlist, 0);
148: if ((ret = strdup(fido_dev_info_path(di))) == NULL) {
149: skdebug(__func__, "fido_dev_info_path failed");
150: goto out;
151: }
152: out:
153: fido_dev_info_free(&devlist, 1);
154: return ret;
155: }
156:
157: /* Check if the specified key handle exists on a given device. */
158: static int
159: try_device(fido_dev_t *dev, const uint8_t *message, size_t message_len,
160: const char *application, const uint8_t *key_handle, size_t key_handle_len)
161: {
162: fido_assert_t *assert = NULL;
163: int r = FIDO_ERR_INTERNAL;
164:
165: if ((assert = fido_assert_new()) == NULL) {
166: skdebug(__func__, "fido_assert_new failed");
167: goto out;
168: }
169: if ((r = fido_assert_set_clientdata_hash(assert, message,
170: message_len)) != FIDO_OK) {
171: skdebug(__func__, "fido_assert_set_clientdata_hash: %s",
172: fido_strerr(r));
173: goto out;
174: }
175: if ((r = fido_assert_set_rp(assert, application)) != FIDO_OK) {
176: skdebug(__func__, "fido_assert_set_rp: %s", fido_strerr(r));
177: goto out;
178: }
179: if ((r = fido_assert_allow_cred(assert, key_handle,
180: key_handle_len)) != FIDO_OK) {
181: skdebug(__func__, "fido_assert_allow_cred: %s", fido_strerr(r));
182: goto out;
183: }
184: if ((r = fido_assert_set_up(assert, FIDO_OPT_FALSE)) != FIDO_OK) {
185: skdebug(__func__, "fido_assert_up: %s", fido_strerr(r));
186: goto out;
187: }
188: r = fido_dev_get_assert(dev, assert, NULL);
189: skdebug(__func__, "fido_dev_get_assert: %s", fido_strerr(r));
1.3 djm 190: if (r == FIDO_ERR_USER_PRESENCE_REQUIRED) {
191: /* U2F tokens may return this */
192: r = FIDO_OK;
193: }
1.1 djm 194: out:
195: fido_assert_free(&assert);
196:
197: return r != FIDO_OK ? -1 : 0;
198: }
199:
200: /* Iterate over configured devices looking for a specific key handle */
201: static fido_dev_t *
1.12 djm 202: find_device(const char *path, const uint8_t *message, size_t message_len,
203: const char *application, const uint8_t *key_handle, size_t key_handle_len)
1.1 djm 204: {
205: fido_dev_info_t *devlist = NULL;
206: fido_dev_t *dev = NULL;
1.4 deraadt 207: size_t devlist_len = 0, i;
1.1 djm 208: int r;
209:
1.12 djm 210: if (path != NULL) {
211: if ((dev = fido_dev_new()) == NULL) {
212: skdebug(__func__, "fido_dev_new failed");
213: return NULL;
214: }
215: if ((r = fido_dev_open(dev, path)) != FIDO_OK) {
216: skdebug(__func__, "fido_dev_open failed");
217: fido_dev_free(&dev);
218: return NULL;
219: }
220: return dev;
221: }
222:
1.1 djm 223: if ((devlist = fido_dev_info_new(MAX_FIDO_DEVICES)) == NULL) {
224: skdebug(__func__, "fido_dev_info_new failed");
225: goto out;
226: }
227: if ((r = fido_dev_info_manifest(devlist, MAX_FIDO_DEVICES,
228: &devlist_len)) != FIDO_OK) {
229: skdebug(__func__, "fido_dev_info_manifest: %s", fido_strerr(r));
230: goto out;
231: }
232:
233: skdebug(__func__, "found %zu device(s)", devlist_len);
234:
1.4 deraadt 235: for (i = 0; i < devlist_len; i++) {
1.1 djm 236: const fido_dev_info_t *di = fido_dev_info_ptr(devlist, i);
237:
238: if (di == NULL) {
239: skdebug(__func__, "fido_dev_info_ptr %zu failed", i);
240: continue;
241: }
242: if ((path = fido_dev_info_path(di)) == NULL) {
243: skdebug(__func__, "fido_dev_info_path %zu failed", i);
244: continue;
245: }
246: skdebug(__func__, "trying device %zu: %s", i, path);
247: if ((dev = fido_dev_new()) == NULL) {
248: skdebug(__func__, "fido_dev_new failed");
249: continue;
250: }
251: if ((r = fido_dev_open(dev, path)) != FIDO_OK) {
252: skdebug(__func__, "fido_dev_open failed");
253: fido_dev_free(&dev);
254: continue;
255: }
256: if (try_device(dev, message, message_len, application,
257: key_handle, key_handle_len) == 0) {
258: skdebug(__func__, "found key");
259: break;
260: }
261: fido_dev_close(dev);
262: fido_dev_free(&dev);
263: }
264:
265: out:
266: if (devlist != NULL)
267: fido_dev_info_free(&devlist, MAX_FIDO_DEVICES);
268:
269: return dev;
270: }
271:
1.7 naddy 272: #ifdef WITH_OPENSSL
1.1 djm 273: /*
274: * The key returned via fido_cred_pubkey_ptr() is in affine coordinates,
275: * but the API expects a SEC1 octet string.
276: */
277: static int
1.9 djm 278: pack_public_key_ecdsa(const fido_cred_t *cred,
279: struct sk_enroll_response *response)
1.1 djm 280: {
281: const uint8_t *ptr;
282: BIGNUM *x = NULL, *y = NULL;
283: EC_POINT *q = NULL;
284: EC_GROUP *g = NULL;
285: int ret = -1;
286:
287: response->public_key = NULL;
288: response->public_key_len = 0;
289:
1.5 djm 290: if ((x = BN_new()) == NULL ||
291: (y = BN_new()) == NULL ||
1.1 djm 292: (g = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1)) == NULL ||
293: (q = EC_POINT_new(g)) == NULL) {
294: skdebug(__func__, "libcrypto setup failed");
295: goto out;
296: }
297: if ((ptr = fido_cred_pubkey_ptr(cred)) == NULL) {
298: skdebug(__func__, "fido_cred_pubkey_ptr failed");
299: goto out;
300: }
301: if (fido_cred_pubkey_len(cred) != 64) {
302: skdebug(__func__, "bad fido_cred_pubkey_len %zu",
303: fido_cred_pubkey_len(cred));
304: goto out;
305: }
306:
307: if (BN_bin2bn(ptr, 32, x) == NULL ||
308: BN_bin2bn(ptr + 32, 32, y) == NULL) {
309: skdebug(__func__, "BN_bin2bn failed");
310: goto out;
311: }
1.5 djm 312: if (EC_POINT_set_affine_coordinates_GFp(g, q, x, y, NULL) != 1) {
1.1 djm 313: skdebug(__func__, "EC_POINT_set_affine_coordinates_GFp failed");
314: goto out;
315: }
316: response->public_key_len = EC_POINT_point2oct(g, q,
1.5 djm 317: POINT_CONVERSION_UNCOMPRESSED, NULL, 0, NULL);
1.1 djm 318: if (response->public_key_len == 0 || response->public_key_len > 2048) {
319: skdebug(__func__, "bad pubkey length %zu",
320: response->public_key_len);
321: goto out;
322: }
323: if ((response->public_key = malloc(response->public_key_len)) == NULL) {
324: skdebug(__func__, "malloc pubkey failed");
325: goto out;
326: }
327: if (EC_POINT_point2oct(g, q, POINT_CONVERSION_UNCOMPRESSED,
1.5 djm 328: response->public_key, response->public_key_len, NULL) == 0) {
1.1 djm 329: skdebug(__func__, "EC_POINT_point2oct failed");
330: goto out;
331: }
332: /* success */
333: ret = 0;
334: out:
335: if (ret != 0 && response->public_key != NULL) {
336: memset(response->public_key, 0, response->public_key_len);
337: free(response->public_key);
338: response->public_key = NULL;
339: }
340: EC_POINT_free(q);
341: EC_GROUP_free(g);
1.5 djm 342: BN_clear_free(x);
343: BN_clear_free(y);
1.1 djm 344: return ret;
345: }
1.7 naddy 346: #endif /* WITH_OPENSSL */
1.1 djm 347:
348: static int
1.9 djm 349: pack_public_key_ed25519(const fido_cred_t *cred,
350: struct sk_enroll_response *response)
1.1 djm 351: {
352: const uint8_t *ptr;
353: size_t len;
354: int ret = -1;
355:
356: response->public_key = NULL;
357: response->public_key_len = 0;
358:
359: if ((len = fido_cred_pubkey_len(cred)) != 32) {
360: skdebug(__func__, "bad fido_cred_pubkey_len len %zu", len);
361: goto out;
362: }
363: if ((ptr = fido_cred_pubkey_ptr(cred)) == NULL) {
364: skdebug(__func__, "fido_cred_pubkey_ptr failed");
365: goto out;
366: }
367: response->public_key_len = len;
368: if ((response->public_key = malloc(response->public_key_len)) == NULL) {
369: skdebug(__func__, "malloc pubkey failed");
370: goto out;
371: }
372: memcpy(response->public_key, ptr, len);
373: ret = 0;
374: out:
375: if (ret != 0)
376: free(response->public_key);
377: return ret;
378: }
379:
380: static int
1.12 djm 381: pack_public_key(uint32_t alg, const fido_cred_t *cred,
1.9 djm 382: struct sk_enroll_response *response)
1.1 djm 383: {
384: switch(alg) {
1.7 naddy 385: #ifdef WITH_OPENSSL
1.15 djm 386: case SSH_SK_ECDSA:
1.1 djm 387: return pack_public_key_ecdsa(cred, response);
1.7 naddy 388: #endif /* WITH_OPENSSL */
1.15 djm 389: case SSH_SK_ED25519:
1.1 djm 390: return pack_public_key_ed25519(cred, response);
391: default:
392: return -1;
393: }
394: }
395:
1.11 djm 396: static int
397: fidoerr_to_skerr(int fidoerr)
398: {
399: switch (fidoerr) {
400: case FIDO_ERR_UNSUPPORTED_OPTION:
1.15 djm 401: case FIDO_ERR_UNSUPPORTED_ALGORITHM:
1.11 djm 402: return SSH_SK_ERR_UNSUPPORTED;
403: case FIDO_ERR_PIN_REQUIRED:
404: case FIDO_ERR_PIN_INVALID:
405: return SSH_SK_ERR_PIN_REQUIRED;
406: default:
407: return -1;
408: }
409: }
410:
1.12 djm 411: static int
412: check_enroll_options(struct sk_option **options, char **devicep,
413: uint8_t *user_id, size_t user_id_len)
414: {
415: size_t i;
416:
417: if (options == NULL)
418: return 0;
419: for (i = 0; options[i] != NULL; i++) {
420: if (strcmp(options[i]->name, "device") == 0) {
421: if ((*devicep = strdup(options[i]->value)) == NULL) {
422: skdebug(__func__, "strdup device failed");
423: return -1;
424: }
425: skdebug(__func__, "requested device %s", *devicep);
1.14 djm 426: } else if (strcmp(options[i]->name, "user") == 0) {
1.12 djm 427: if (strlcpy(user_id, options[i]->value, user_id_len) >=
428: user_id_len) {
429: skdebug(__func__, "user too long");
430: return -1;
431: }
432: skdebug(__func__, "requested user %s",
433: (char *)user_id);
434: } else {
435: skdebug(__func__, "requested unsupported option %s",
436: options[i]->name);
437: if (options[i]->required) {
438: skdebug(__func__, "unknown required option");
439: return -1;
440: }
441: }
442: }
443: return 0;
444: }
445:
1.1 djm 446: int
1.12 djm 447: sk_enroll(uint32_t alg, const uint8_t *challenge, size_t challenge_len,
1.10 djm 448: const char *application, uint8_t flags, const char *pin,
1.12 djm 449: struct sk_option **options, struct sk_enroll_response **enroll_response)
1.1 djm 450: {
451: fido_cred_t *cred = NULL;
452: fido_dev_t *dev = NULL;
453: const uint8_t *ptr;
454: uint8_t user_id[32];
455: struct sk_enroll_response *response = NULL;
456: size_t len;
457: int cose_alg;
1.11 djm 458: int ret = SSH_SK_ERR_GENERAL;
1.1 djm 459: int r;
460: char *device = NULL;
461:
1.18 ! djm 462: fido_init(SSH_FIDO_INIT_ARG);
! 463:
1.6 markus 464: if (enroll_response == NULL) {
465: skdebug(__func__, "enroll_response == NULL");
1.1 djm 466: goto out;
467: }
1.12 djm 468: memset(user_id, 0, sizeof(user_id));
469: if (check_enroll_options(options, &device,
470: user_id, sizeof(user_id)) != 0)
471: goto out; /* error already logged */
472:
1.6 markus 473: *enroll_response = NULL;
1.1 djm 474: switch(alg) {
1.7 naddy 475: #ifdef WITH_OPENSSL
1.15 djm 476: case SSH_SK_ECDSA:
1.1 djm 477: cose_alg = COSE_ES256;
478: break;
1.7 naddy 479: #endif /* WITH_OPENSSL */
1.15 djm 480: case SSH_SK_ED25519:
1.1 djm 481: cose_alg = COSE_EDDSA;
482: break;
483: default:
484: skdebug(__func__, "unsupported key type %d", alg);
485: goto out;
486: }
1.12 djm 487: if (device == NULL && (device = pick_first_device()) == NULL) {
1.15 djm 488: ret = SSH_SK_ERR_DEVICE_NOT_FOUND;
1.1 djm 489: skdebug(__func__, "pick_first_device failed");
490: goto out;
491: }
492: skdebug(__func__, "using device %s", device);
493: if ((cred = fido_cred_new()) == NULL) {
494: skdebug(__func__, "fido_cred_new failed");
495: goto out;
496: }
497: if ((r = fido_cred_set_type(cred, cose_alg)) != FIDO_OK) {
498: skdebug(__func__, "fido_cred_set_type: %s", fido_strerr(r));
499: goto out;
500: }
501: if ((r = fido_cred_set_clientdata_hash(cred, challenge,
502: challenge_len)) != FIDO_OK) {
503: skdebug(__func__, "fido_cred_set_clientdata_hash: %s",
504: fido_strerr(r));
1.8 djm 505: goto out;
506: }
1.15 djm 507: if ((r = fido_cred_set_rk(cred, (flags & SSH_SK_RESIDENT_KEY) != 0 ?
1.8 djm 508: FIDO_OPT_TRUE : FIDO_OPT_OMIT)) != FIDO_OK) {
509: skdebug(__func__, "fido_cred_set_rk: %s", fido_strerr(r));
1.1 djm 510: goto out;
511: }
512: if ((r = fido_cred_set_user(cred, user_id, sizeof(user_id),
513: "openssh", "openssh", NULL)) != FIDO_OK) {
514: skdebug(__func__, "fido_cred_set_user: %s", fido_strerr(r));
515: goto out;
516: }
517: if ((r = fido_cred_set_rp(cred, application, NULL)) != FIDO_OK) {
518: skdebug(__func__, "fido_cred_set_rp: %s", fido_strerr(r));
519: goto out;
520: }
521: if ((dev = fido_dev_new()) == NULL) {
522: skdebug(__func__, "fido_dev_new failed");
523: goto out;
524: }
525: if ((r = fido_dev_open(dev, device)) != FIDO_OK) {
526: skdebug(__func__, "fido_dev_open: %s", fido_strerr(r));
527: goto out;
528: }
1.11 djm 529: if ((r = fido_dev_make_cred(dev, cred, pin)) != FIDO_OK) {
1.1 djm 530: skdebug(__func__, "fido_dev_make_cred: %s", fido_strerr(r));
1.11 djm 531: ret = fidoerr_to_skerr(r);
1.1 djm 532: goto out;
533: }
534: if (fido_cred_x5c_ptr(cred) != NULL) {
535: if ((r = fido_cred_verify(cred)) != FIDO_OK) {
536: skdebug(__func__, "fido_cred_verify: %s",
537: fido_strerr(r));
538: goto out;
539: }
540: } else {
541: skdebug(__func__, "self-attested credential");
542: if ((r = fido_cred_verify_self(cred)) != FIDO_OK) {
543: skdebug(__func__, "fido_cred_verify_self: %s",
544: fido_strerr(r));
545: goto out;
546: }
547: }
548: if ((response = calloc(1, sizeof(*response))) == NULL) {
549: skdebug(__func__, "calloc response failed");
550: goto out;
551: }
552: if (pack_public_key(alg, cred, response) != 0) {
553: skdebug(__func__, "pack_public_key failed");
554: goto out;
555: }
556: if ((ptr = fido_cred_id_ptr(cred)) != NULL) {
557: len = fido_cred_id_len(cred);
558: if ((response->key_handle = calloc(1, len)) == NULL) {
559: skdebug(__func__, "calloc key handle failed");
560: goto out;
561: }
562: memcpy(response->key_handle, ptr, len);
563: response->key_handle_len = len;
564: }
565: if ((ptr = fido_cred_sig_ptr(cred)) != NULL) {
566: len = fido_cred_sig_len(cred);
567: if ((response->signature = calloc(1, len)) == NULL) {
568: skdebug(__func__, "calloc signature failed");
569: goto out;
570: }
571: memcpy(response->signature, ptr, len);
572: response->signature_len = len;
573: }
574: if ((ptr = fido_cred_x5c_ptr(cred)) != NULL) {
575: len = fido_cred_x5c_len(cred);
1.16 djm 576: debug3("%s: attestation cert len=%zu", __func__, len);
1.1 djm 577: if ((response->attestation_cert = calloc(1, len)) == NULL) {
578: skdebug(__func__, "calloc attestation cert failed");
579: goto out;
580: }
581: memcpy(response->attestation_cert, ptr, len);
582: response->attestation_cert_len = len;
583: }
1.6 markus 584: *enroll_response = response;
1.1 djm 585: response = NULL;
586: ret = 0;
587: out:
588: free(device);
589: if (response != NULL) {
590: free(response->public_key);
591: free(response->key_handle);
592: free(response->signature);
593: free(response->attestation_cert);
594: free(response);
595: }
596: if (dev != NULL) {
597: fido_dev_close(dev);
598: fido_dev_free(&dev);
599: }
600: if (cred != NULL) {
601: fido_cred_free(&cred);
602: }
603: return ret;
604: }
605:
1.7 naddy 606: #ifdef WITH_OPENSSL
1.1 djm 607: static int
608: pack_sig_ecdsa(fido_assert_t *assert, struct sk_sign_response *response)
609: {
610: ECDSA_SIG *sig = NULL;
611: const BIGNUM *sig_r, *sig_s;
612: const unsigned char *cp;
613: size_t sig_len;
614: int ret = -1;
615:
616: cp = fido_assert_sig_ptr(assert, 0);
617: sig_len = fido_assert_sig_len(assert, 0);
618: if ((sig = d2i_ECDSA_SIG(NULL, &cp, sig_len)) == NULL) {
619: skdebug(__func__, "d2i_ECDSA_SIG failed");
620: goto out;
621: }
622: ECDSA_SIG_get0(sig, &sig_r, &sig_s);
623: response->sig_r_len = BN_num_bytes(sig_r);
624: response->sig_s_len = BN_num_bytes(sig_s);
625: if ((response->sig_r = calloc(1, response->sig_r_len)) == NULL ||
626: (response->sig_s = calloc(1, response->sig_s_len)) == NULL) {
627: skdebug(__func__, "calloc signature failed");
628: goto out;
629: }
630: BN_bn2bin(sig_r, response->sig_r);
631: BN_bn2bin(sig_s, response->sig_s);
632: ret = 0;
633: out:
634: ECDSA_SIG_free(sig);
635: if (ret != 0) {
636: free(response->sig_r);
637: free(response->sig_s);
638: response->sig_r = NULL;
639: response->sig_s = NULL;
640: }
641: return ret;
642: }
1.7 naddy 643: #endif /* WITH_OPENSSL */
1.1 djm 644:
645: static int
646: pack_sig_ed25519(fido_assert_t *assert, struct sk_sign_response *response)
647: {
648: const unsigned char *ptr;
649: size_t len;
650: int ret = -1;
651:
652: ptr = fido_assert_sig_ptr(assert, 0);
653: len = fido_assert_sig_len(assert, 0);
654: if (len != 64) {
655: skdebug(__func__, "bad length %zu", len);
656: goto out;
657: }
658: response->sig_r_len = len;
659: if ((response->sig_r = calloc(1, response->sig_r_len)) == NULL) {
660: skdebug(__func__, "calloc signature failed");
661: goto out;
662: }
663: memcpy(response->sig_r, ptr, len);
664: ret = 0;
665: out:
666: if (ret != 0) {
667: free(response->sig_r);
668: response->sig_r = NULL;
669: }
670: return ret;
671: }
672:
673: static int
1.12 djm 674: pack_sig(uint32_t alg, fido_assert_t *assert,
675: struct sk_sign_response *response)
1.1 djm 676: {
677: switch(alg) {
1.7 naddy 678: #ifdef WITH_OPENSSL
1.15 djm 679: case SSH_SK_ECDSA:
1.1 djm 680: return pack_sig_ecdsa(assert, response);
1.7 naddy 681: #endif /* WITH_OPENSSL */
1.15 djm 682: case SSH_SK_ED25519:
1.1 djm 683: return pack_sig_ed25519(assert, response);
684: default:
685: return -1;
686: }
687: }
688:
1.12 djm 689: /* Checks sk_options for sk_sign() and sk_load_resident_keys() */
690: static int
691: check_sign_load_resident_options(struct sk_option **options, char **devicep)
692: {
693: size_t i;
694:
695: if (options == NULL)
696: return 0;
697: for (i = 0; options[i] != NULL; i++) {
698: if (strcmp(options[i]->name, "device") == 0) {
699: if ((*devicep = strdup(options[i]->value)) == NULL) {
700: skdebug(__func__, "strdup device failed");
701: return -1;
702: }
703: skdebug(__func__, "requested device %s", *devicep);
704: } else {
705: skdebug(__func__, "requested unsupported option %s",
706: options[i]->name);
707: if (options[i]->required) {
708: skdebug(__func__, "unknown required option");
709: return -1;
710: }
711: }
712: }
713: return 0;
714: }
715:
1.17 djm 716: /* Calculate SHA256(m) */
717: static int
718: sha256_mem(const void *m, size_t mlen, u_char *d, size_t dlen)
719: {
720: #ifdef WITH_OPENSSL
721: u_int mdlen;
722: #endif
723:
724: if (dlen != 32)
725: return -1;
726: #ifdef WITH_OPENSSL
727: mdlen = dlen;
728: if (!EVP_Digest(m, mlen, d, &mdlen, EVP_sha256(), NULL))
729: return -1;
730: #else
731: SHA256Data(m, mlen, d);
732: #endif
733: return 0;
734: }
735:
1.1 djm 736: int
1.17 djm 737: sk_sign(uint32_t alg, const uint8_t *data, size_t datalen,
1.1 djm 738: const char *application,
739: const uint8_t *key_handle, size_t key_handle_len,
1.12 djm 740: uint8_t flags, const char *pin, struct sk_option **options,
741: struct sk_sign_response **sign_response)
1.1 djm 742: {
743: fido_assert_t *assert = NULL;
1.12 djm 744: char *device = NULL;
1.1 djm 745: fido_dev_t *dev = NULL;
746: struct sk_sign_response *response = NULL;
1.17 djm 747: uint8_t message[32];
1.11 djm 748: int ret = SSH_SK_ERR_GENERAL;
1.1 djm 749: int r;
750:
1.18 ! djm 751: fido_init(SSH_FIDO_INIT_ARG);
1.1 djm 752:
753: if (sign_response == NULL) {
754: skdebug(__func__, "sign_response == NULL");
755: goto out;
756: }
757: *sign_response = NULL;
1.12 djm 758: if (check_sign_load_resident_options(options, &device) != 0)
759: goto out; /* error already logged */
1.17 djm 760: /* hash data to be signed before it goes to the security key */
761: if ((r = sha256_mem(data, datalen, message, sizeof(message))) != 0) {
762: skdebug(__func__, "hash message failed");
763: goto out;
764: }
765: if ((dev = find_device(device, message, sizeof(message),
1.12 djm 766: application, key_handle, key_handle_len)) == NULL) {
1.1 djm 767: skdebug(__func__, "couldn't find device for key handle");
768: goto out;
769: }
770: if ((assert = fido_assert_new()) == NULL) {
771: skdebug(__func__, "fido_assert_new failed");
772: goto out;
773: }
774: if ((r = fido_assert_set_clientdata_hash(assert, message,
1.17 djm 775: sizeof(message))) != FIDO_OK) {
1.1 djm 776: skdebug(__func__, "fido_assert_set_clientdata_hash: %s",
777: fido_strerr(r));
778: goto out;
779: }
780: if ((r = fido_assert_set_rp(assert, application)) != FIDO_OK) {
781: skdebug(__func__, "fido_assert_set_rp: %s", fido_strerr(r));
782: goto out;
783: }
784: if ((r = fido_assert_allow_cred(assert, key_handle,
785: key_handle_len)) != FIDO_OK) {
786: skdebug(__func__, "fido_assert_allow_cred: %s", fido_strerr(r));
787: goto out;
788: }
789: if ((r = fido_assert_set_up(assert,
1.15 djm 790: (flags & SSH_SK_USER_PRESENCE_REQD) ?
1.1 djm 791: FIDO_OPT_TRUE : FIDO_OPT_FALSE)) != FIDO_OK) {
792: skdebug(__func__, "fido_assert_set_up: %s", fido_strerr(r));
793: goto out;
794: }
795: if ((r = fido_dev_get_assert(dev, assert, NULL)) != FIDO_OK) {
796: skdebug(__func__, "fido_dev_get_assert: %s", fido_strerr(r));
797: goto out;
798: }
799: if ((response = calloc(1, sizeof(*response))) == NULL) {
800: skdebug(__func__, "calloc response failed");
801: goto out;
802: }
803: response->flags = fido_assert_flags(assert, 0);
804: response->counter = fido_assert_sigcount(assert, 0);
805: if (pack_sig(alg, assert, response) != 0) {
806: skdebug(__func__, "pack_sig failed");
807: goto out;
808: }
809: *sign_response = response;
810: response = NULL;
811: ret = 0;
812: out:
1.17 djm 813: explicit_bzero(message, sizeof(message));
1.12 djm 814: free(device);
1.1 djm 815: if (response != NULL) {
816: free(response->sig_r);
817: free(response->sig_s);
818: free(response);
819: }
820: if (dev != NULL) {
821: fido_dev_close(dev);
822: fido_dev_free(&dev);
823: }
824: if (assert != NULL) {
825: fido_assert_free(&assert);
826: }
827: return ret;
828: }
1.9 djm 829:
830: static int
831: read_rks(const char *devpath, const char *pin,
832: struct sk_resident_key ***rksp, size_t *nrksp)
833: {
1.11 djm 834: int ret = SSH_SK_ERR_GENERAL, r = -1;
1.9 djm 835: fido_dev_t *dev = NULL;
836: fido_credman_metadata_t *metadata = NULL;
837: fido_credman_rp_t *rp = NULL;
838: fido_credman_rk_t *rk = NULL;
839: size_t i, j, nrp, nrk;
840: const fido_cred_t *cred;
841: struct sk_resident_key *srk = NULL, **tmp;
842:
843: if ((dev = fido_dev_new()) == NULL) {
844: skdebug(__func__, "fido_dev_new failed");
1.11 djm 845: return ret;
1.9 djm 846: }
847: if ((r = fido_dev_open(dev, devpath)) != FIDO_OK) {
848: skdebug(__func__, "fido_dev_open %s failed: %s",
849: devpath, fido_strerr(r));
850: fido_dev_free(&dev);
1.11 djm 851: return ret;
1.9 djm 852: }
853: if ((metadata = fido_credman_metadata_new()) == NULL) {
854: skdebug(__func__, "alloc failed");
855: goto out;
856: }
857:
858: if ((r = fido_credman_get_dev_metadata(dev, metadata, pin)) != 0) {
859: if (r == FIDO_ERR_INVALID_COMMAND) {
860: skdebug(__func__, "device %s does not support "
861: "resident keys", devpath);
1.11 djm 862: ret = 0;
1.9 djm 863: goto out;
864: }
865: skdebug(__func__, "get metadata for %s failed: %s",
866: devpath, fido_strerr(r));
1.12 djm 867: ret = fidoerr_to_skerr(r);
1.9 djm 868: goto out;
869: }
870: skdebug(__func__, "existing %llu, remaining %llu",
871: (unsigned long long)fido_credman_rk_existing(metadata),
872: (unsigned long long)fido_credman_rk_remaining(metadata));
873: if ((rp = fido_credman_rp_new()) == NULL) {
874: skdebug(__func__, "alloc rp failed");
875: goto out;
876: }
877: if ((r = fido_credman_get_dev_rp(dev, rp, pin)) != 0) {
878: skdebug(__func__, "get RPs for %s failed: %s",
879: devpath, fido_strerr(r));
880: goto out;
881: }
882: nrp = fido_credman_rp_count(rp);
883: skdebug(__func__, "Device %s has resident keys for %zu RPs",
884: devpath, nrp);
885:
886: /* Iterate over RP IDs that have resident keys */
887: for (i = 0; i < nrp; i++) {
888: skdebug(__func__, "rp %zu: name=\"%s\" id=\"%s\" hashlen=%zu",
889: i, fido_credman_rp_name(rp, i), fido_credman_rp_id(rp, i),
890: fido_credman_rp_id_hash_len(rp, i));
891:
892: /* Skip non-SSH RP IDs */
893: if (strncasecmp(fido_credman_rp_id(rp, i), "ssh:", 4) != 0)
894: continue;
895:
896: fido_credman_rk_free(&rk);
897: if ((rk = fido_credman_rk_new()) == NULL) {
898: skdebug(__func__, "alloc rk failed");
899: goto out;
900: }
901: if ((r = fido_credman_get_dev_rk(dev, fido_credman_rp_id(rp, i),
902: rk, pin)) != 0) {
903: skdebug(__func__, "get RKs for %s slot %zu failed: %s",
904: devpath, i, fido_strerr(r));
905: goto out;
906: }
907: nrk = fido_credman_rk_count(rk);
908: skdebug(__func__, "RP \"%s\" has %zu resident keys",
909: fido_credman_rp_id(rp, i), nrk);
910:
911: /* Iterate over resident keys for this RP ID */
912: for (j = 0; j < nrk; j++) {
913: if ((cred = fido_credman_rk(rk, j)) == NULL) {
914: skdebug(__func__, "no RK in slot %zu", j);
915: continue;
916: }
917: skdebug(__func__, "Device %s RP \"%s\" slot %zu: "
918: "type %d", devpath, fido_credman_rp_id(rp, i), j,
919: fido_cred_type(cred));
920:
921: /* build response entry */
922: if ((srk = calloc(1, sizeof(*srk))) == NULL ||
923: (srk->key.key_handle = calloc(1,
924: fido_cred_id_len(cred))) == NULL ||
925: (srk->application = strdup(fido_credman_rp_id(rp,
926: i))) == NULL) {
927: skdebug(__func__, "alloc sk_resident_key");
928: goto out;
929: }
930:
931: srk->key.key_handle_len = fido_cred_id_len(cred);
932: memcpy(srk->key.key_handle,
933: fido_cred_id_ptr(cred),
934: srk->key.key_handle_len);
935:
936: switch (fido_cred_type(cred)) {
937: case COSE_ES256:
1.15 djm 938: srk->alg = SSH_SK_ECDSA;
1.9 djm 939: break;
940: case COSE_EDDSA:
1.15 djm 941: srk->alg = SSH_SK_ED25519;
1.9 djm 942: break;
943: default:
944: skdebug(__func__, "unsupported key type %d",
945: fido_cred_type(cred));
1.15 djm 946: goto out; /* XXX free rk and continue */
1.9 djm 947: }
948:
949: if ((r = pack_public_key(srk->alg, cred,
950: &srk->key)) != 0) {
951: skdebug(__func__, "pack public key failed");
952: goto out;
953: }
954: /* append */
955: if ((tmp = recallocarray(*rksp, *nrksp, (*nrksp) + 1,
956: sizeof(**rksp))) == NULL) {
957: skdebug(__func__, "alloc rksp");
958: goto out;
959: }
960: *rksp = tmp;
961: (*rksp)[(*nrksp)++] = srk;
962: srk = NULL;
963: }
964: }
965: /* Success */
1.11 djm 966: ret = 0;
1.9 djm 967: out:
968: if (srk != NULL) {
969: free(srk->application);
970: freezero(srk->key.public_key, srk->key.public_key_len);
971: freezero(srk->key.key_handle, srk->key.key_handle_len);
972: freezero(srk, sizeof(*srk));
973: }
974: fido_credman_rp_free(&rp);
975: fido_credman_rk_free(&rk);
976: fido_dev_close(dev);
977: fido_dev_free(&dev);
978: fido_credman_metadata_free(&metadata);
1.11 djm 979: return ret;
1.9 djm 980: }
981:
982: int
1.12 djm 983: sk_load_resident_keys(const char *pin, struct sk_option **options,
1.9 djm 984: struct sk_resident_key ***rksp, size_t *nrksp)
985: {
1.11 djm 986: int ret = SSH_SK_ERR_GENERAL, r = -1;
1.9 djm 987: fido_dev_info_t *devlist = NULL;
988: size_t i, ndev = 0, nrks = 0;
989: const fido_dev_info_t *di;
990: struct sk_resident_key **rks = NULL;
1.12 djm 991: char *device = NULL;
1.9 djm 992: *rksp = NULL;
993: *nrksp = 0;
1.18 ! djm 994:
! 995: fido_init(SSH_FIDO_INIT_ARG);
1.9 djm 996:
1.12 djm 997: if (check_sign_load_resident_options(options, &device) != 0)
998: goto out; /* error already logged */
999: if (device != NULL) {
1000: skdebug(__func__, "trying %s", device);
1001: if ((r = read_rks(device, pin, &rks, &nrks)) != 0) {
1.13 djm 1002: skdebug(__func__, "read_rks failed for %s", device);
1.12 djm 1003: ret = r;
1004: goto out;
1005: }
1006: } else {
1007: /* Try all devices */
1008: if ((devlist = fido_dev_info_new(MAX_FIDO_DEVICES)) == NULL) {
1009: skdebug(__func__, "fido_dev_info_new failed");
1010: goto out;
1011: }
1012: if ((r = fido_dev_info_manifest(devlist,
1013: MAX_FIDO_DEVICES, &ndev)) != FIDO_OK) {
1014: skdebug(__func__, "fido_dev_info_manifest failed: %s",
1015: fido_strerr(r));
1016: goto out;
1017: }
1018: for (i = 0; i < ndev; i++) {
1019: if ((di = fido_dev_info_ptr(devlist, i)) == NULL) {
1020: skdebug(__func__, "no dev info at %zu", i);
1021: continue;
1022: }
1023: skdebug(__func__, "trying %s", fido_dev_info_path(di));
1024: if ((r = read_rks(fido_dev_info_path(di), pin,
1025: &rks, &nrks)) != 0) {
1026: skdebug(__func__, "read_rks failed for %s",
1027: fido_dev_info_path(di));
1028: /* remember last error */
1029: ret = r;
1030: continue;
1031: }
1.9 djm 1032: }
1033: }
1.12 djm 1034: /* success, unless we have no keys but a specific error */
1035: if (nrks > 0 || ret == SSH_SK_ERR_GENERAL)
1036: ret = 0;
1.9 djm 1037: *rksp = rks;
1038: *nrksp = nrks;
1039: rks = NULL;
1040: nrks = 0;
1041: out:
1.12 djm 1042: free(device);
1.9 djm 1043: for (i = 0; i < nrks; i++) {
1044: free(rks[i]->application);
1045: freezero(rks[i]->key.public_key, rks[i]->key.public_key_len);
1046: freezero(rks[i]->key.key_handle, rks[i]->key.key_handle_len);
1047: freezero(rks[i], sizeof(*rks[i]));
1048: }
1049: free(rks);
1050: fido_dev_info_free(&devlist, MAX_FIDO_DEVICES);
1.11 djm 1051: return ret;
1.9 djm 1052: }
1053:
![[BACK]](/icons/back.gif){kind=icon}
Return to sk-usbhid.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / ssh