FreeRDP
Loading...
Searching...
No Matches
rdpewa_fido.c
1
18
19#include <winpr/sysinfo.h>
20
21#include <freerdp/config.h>
22
23#include <string.h>
24#include <stdlib.h>
25
26#include <fido.h>
27#include <fido/credman.h>
28#include <cbor.h>
29
30#include <winpr/assert.h>
31#include <winpr/endian.h>
32#include <winpr/wlog.h>
33
34#include <freerdp/channels/log.h>
35#include <freerdp/channels/rdpewa.h>
36#include <freerdp/event.h>
37
38#include "rdpewa_cbor.h"
39#include "rdpewa_fido.h"
40#include <rdpewa-common.h>
41
42#include <winpr/thread.h>
43#include <winpr/synch.h>
44
45#define TAG CHANNELS_TAG("rdpewa.client")
46
48#define RDPEWA_MAX_DEVICES 64
49
51typedef struct
52{
53 fido_dev_t* dev;
54 fido_cred_t* cred;
55 fido_assert_t* assert;
56 const char* pin;
57 int result;
58} RDPEWA_FIDO_ASYNC;
59
60static bool rdpewa_fido_get_pin(rdpContext* context, char** pin)
61{
62 WINPR_ASSERT(pin);
63 *pin = nullptr;
64
65 freerdp* instance = context->instance;
66 char* u = nullptr;
67 char* p = nullptr;
68 char* d = nullptr;
69 const bool rc = instance && instance->AuthenticateEx &&
70 instance->AuthenticateEx(instance, &u, &p, &d, AUTH_FIDO_PIN) && p;
71 free(u);
72 free(d);
73 if (!rc)
74 {
75 winpr_zfree(p);
76 return false;
77 }
78
79 *pin = p;
80 return true;
81}
82
83static bool rdpewa_fido_uv_failed(int result)
84{
85 return (result == FIDO_ERR_UV_BLOCKED) || (result == FIDO_ERR_UV_INVALID);
86}
87
88static DWORD WINAPI rdpewa_fido_makecred_thread(LPVOID arg)
89{
90 RDPEWA_FIDO_ASYNC* a = (RDPEWA_FIDO_ASYNC*)arg;
91 a->result = fido_dev_make_cred(a->dev, a->cred, a->pin);
92 return 0;
93}
94
95static DWORD WINAPI rdpewa_fido_getassert_thread(LPVOID arg)
96{
97 RDPEWA_FIDO_ASYNC* a = (RDPEWA_FIDO_ASYNC*)arg;
98 a->result = fido_dev_get_assert(a->dev, a->assert, a->pin);
99 return 0;
100}
101
102static bool notify(rdpContext* context, UINT64 id, bool cancel)
103{
104 /* Fire-and-forget notification to the UI via PubSub */
105 UserNotificationEventArgs e = WINPR_C_ARRAY_INIT;
106 EventArgsInit(&e, RDPEWA_CHANNEL_NAME);
107 if (!cancel)
108 {
109 e.timeoutMS = 30000;
110 e.message = "Touch the security key";
111 }
112 e.cancelPreviousNotification = cancel;
113
114 e.messageID = id;
115 const int rc = PubSub_OnUserNotification(context->pubSub, context, &e);
116 return (rc >= 0);
117}
118
119static bool notifyWait(rdpContext* context, HANDLE ft, fido_dev_t* dev)
120{
121 if (!ft)
122 return false;
123
124 HANDLE hdl[] = { ft, freerdp_abort_event(context) };
125 const UINT64 id = winpr_GetTickCount64NS();
126 (void)notify(context, id, false);
127 const DWORD status = WaitForMultipleObjects(ARRAYSIZE(hdl), hdl, FALSE, INFINITE);
128 (void)notify(context, id, true);
129
130 const bool rc = (status == WAIT_OBJECT_0);
131 if (!rc)
132 fido_dev_cancel(dev);
133
134 (void)WaitForSingleObject(ft, INFINITE);
135 CloseHandle(ft);
136 return rc;
137}
143static int rdpewa_fido_select_device(rdpContext* context, fido_dev_t** devs, size_t ndevs,
144 int timeout_sec)
145{
146 if (ndevs == 1)
147 return 0; /* only one device, no selection needed */
148
149 /* Start touch request on all devices */
150 for (size_t i = 0; i < ndevs; i++)
151 {
152 if (devs[i])
153 {
154 int r = fido_dev_get_touch_begin(devs[i]);
155 if (r != FIDO_OK)
156 WLog_DBG(TAG, "Device %" PRIuz ": fido_dev_get_touch_begin: %s", i, fido_strerr(r));
157 }
158 }
159
160 const UINT64 id = winpr_GetTickCount64NS();
161 (void)notify(context, id, false);
162
163 /* Poll for touch with 200ms intervals */
164 int selected = -1;
165 int iterations = timeout_sec * 5; /* 200ms * 5 = 1 second */
166 for (int iter = 0; iter < iterations && selected < 0; iter++)
167 {
168 for (size_t i = 0; i < ndevs; i++)
169 {
170 if (!devs[i])
171 continue;
172
173 int touched = 0;
174 int r = fido_dev_get_touch_status(devs[i], &touched, 200);
175 if (r == FIDO_OK && touched)
176 {
177 WLog_DBG(TAG, "Device %" PRIuz " was touched", i);
178 selected = WINPR_ASSERTING_INT_CAST(int, i);
179 break;
180 }
181 }
182 }
183
184 (void)notify(context, id, true);
185 return selected;
186}
187
191static void rdpewa_fido_fill_device_info(fido_dev_t* dev, const char* path,
192 const char* manufacturer, const char* product,
193 RDPEWA_DEVICE_INFO* info)
194{
195 WINPR_ASSERT(dev);
196 WINPR_ASSERT(info);
197
198 *info = (RDPEWA_DEVICE_INFO){ .maxMsgSize = 1200,
199 .maxSerializedLargeBlobArray = 1024,
200 .providerType = "Hid",
201 .providerName = "FreeRDPFidoProvider",
202 .uvStatus = fido_dev_has_uv(dev) ? 1 : 0,
203 .uvRetries = 3 };
204
205 if (path)
206 strncpy(info->devicePath, path, sizeof(info->devicePath) - 1);
207 if (manufacturer && manufacturer[0])
208 strncpy(info->manufacturer, manufacturer, sizeof(info->manufacturer) - 1);
209 if (product && product[0])
210 strncpy(info->product, product, sizeof(info->product) - 1);
211
212 fido_cbor_info_t* ci = fido_cbor_info_new();
213 if (ci && fido_dev_get_cbor_info(dev, ci) == FIDO_OK)
214 {
215 uint64_t msgsz = fido_cbor_info_maxmsgsiz(ci);
216 if (msgsz > 0 && msgsz <= UINT32_MAX)
217 info->maxMsgSize = (UINT32)msgsz;
218
219 uint64_t lblob = fido_cbor_info_maxlargeblob(ci);
220 if (lblob > 0 && lblob <= UINT32_MAX)
221 info->maxSerializedLargeBlobArray = (UINT32)lblob;
222
223 const unsigned char* aaguid = fido_cbor_info_aaguid_ptr(ci);
224 size_t aaguidLen = fido_cbor_info_aaguid_len(ci);
225 if (aaguid && aaguidLen == 16)
226 memcpy(info->aaGuid, aaguid, 16);
227
228 size_t ntransports = fido_cbor_info_transports_len(ci);
229 char** transports = fido_cbor_info_transports_ptr(ci);
230 for (size_t i = 0; i < ntransports; i++)
231 {
232 if (!transports[i])
233 continue;
234
235 if (strcmp(transports[i], "usb") == 0)
236 info->transports |= 1; /* USB */
237 else if (strcmp(transports[i], "nfc") == 0)
238 info->transports |= 2; /* NFC */
239 else if (strcmp(transports[i], "ble") == 0)
240 info->transports |= 4; /* BLE */
241 }
242 }
243 if (ci)
244 fido_cbor_info_free(&ci);
245}
246
253static fido_dev_t* rdpewa_fido_open_device(RDPEWA_DEVICE_INFO* devInfo, int devIndex,
254 size_t* ndevsOut)
255{
256 WLog_DBG(TAG, "Enumerating FIDO2 devices...");
257
258 fido_dev_t* dev = nullptr;
259 fido_dev_info_t* devlist = fido_dev_info_new(RDPEWA_MAX_DEVICES);
260 if (!devlist)
261 return nullptr;
262
263 size_t ndevs = 0;
264 int r = fido_dev_info_manifest(devlist, RDPEWA_MAX_DEVICES, &ndevs);
265 if (r != FIDO_OK || ndevs == 0)
266 {
267 WLog_WARN(TAG, "No FIDO2 authenticators found (r=%d, ndevs=%" PRIuz ")", r, ndevs);
268 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
269 return nullptr;
270 }
271
272 if (ndevsOut)
273 *ndevsOut = ndevs;
274
275 size_t idx = (devIndex >= 0 && (size_t)devIndex < ndevs) ? (size_t)devIndex : 0;
276 const fido_dev_info_t* di = fido_dev_info_ptr(devlist, idx);
277 const char* path = fido_dev_info_path(di);
278
279 WLog_DBG(TAG, "Found %" PRIuz " FIDO2 device(s), opening device %" PRIuz ": '%s'", ndevs, idx,
280 path);
281
282 /* Get pointers to device info strings. These remain valid until fido_dev_info_free(). */
283 const char* mfr = fido_dev_info_manufacturer_string(di);
284 const char* prod = fido_dev_info_product_string(di);
285
286 dev = fido_dev_new();
287 if (!dev)
288 {
289 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
290 return nullptr;
291 }
292
293 r = fido_dev_open(dev, path);
294 if (r != FIDO_OK)
295 {
296 WLog_ERR(TAG, "Failed to open FIDO2 device '%s': %s", path, fido_strerr(r));
297 fido_dev_free(&dev);
298 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
299 return nullptr;
300 }
301
302 if (devInfo)
303 rdpewa_fido_fill_device_info(dev, path, mfr, prod, devInfo);
304
305 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
306 return dev;
307}
308
314WINPR_ATTR_MALLOC(Stream_Free, 1)
315static wStream* rdpewa_fido_make_credential(rdpContext* context, const BYTE* ctapData,
316 size_t ctapLen, WINPR_ATTR_UNUSED UINT32 flags)
317{
318 fido_dev_t* dev = nullptr;
319 RDPEWA_DEVICE_INFO devInfo = WINPR_C_ARRAY_INIT;
320 fido_cred_t* cred = nullptr;
321 wStream* ret = nullptr;
322 bool uv = false;
323
324 WINPR_ASSERT(ctapData);
325
326 struct cbor_load_result result = WINPR_C_ARRAY_INIT;
327 cbor_item_t* root = cbor_load(ctapData, ctapLen, &result);
328 if (!root || !cbor_isa_map(root))
329 {
330 WLog_ERR(TAG, "Invalid CTAP MakeCredential CBOR data");
331 goto out;
332 }
333
334 cred = fido_cred_new();
335 if (!cred)
336 goto out;
337
338 /* Default algorithm as fallback, overridden by pubKeyCredParams below if present */
339 fido_cred_set_type(cred, COSE_ES256);
340
341 const size_t mapSize = cbor_map_size(root);
342 struct cbor_pair* pairs = cbor_map_handle(root);
343
344 for (size_t i = 0; i < mapSize; i++)
345 {
346 if (!cbor_isa_uint(pairs[i].key))
347 continue;
348
349 uint64_t k = cbor_get_int(pairs[i].key);
350 cbor_item_t* v = pairs[i].value;
351
352 switch (k)
353 {
354 case CTAP_MAKECRED_CLIENT_DATA_HASH:
355 if (cbor_isa_bytestring(v))
356 fido_cred_set_clientdata_hash(cred, cbor_bytestring_handle(v),
357 cbor_bytestring_length(v));
358 break;
359
360 case CTAP_MAKECRED_RP:
361 if (cbor_isa_map(v))
362 {
363 char* rpId = nullptr;
364 char* rpName = nullptr;
365 const size_t rpSize = cbor_map_size(v);
366 struct cbor_pair* rpPairs = cbor_map_handle(v);
367
368 for (size_t j = 0; j < rpSize; j++)
369 {
370 if (!cbor_isa_string(rpPairs[j].key))
371 continue;
372
373 const char* rk = (const char*)cbor_string_handle(rpPairs[j].key);
374 size_t rkl = cbor_string_length(rpPairs[j].key);
375 if (rkl == 2 && memcmp(rk, "id", 2) == 0 &&
376 cbor_isa_string(rpPairs[j].value))
377 {
378 free(rpId);
379 rpId = strndup((const char*)cbor_string_handle(rpPairs[j].value),
380 cbor_string_length(rpPairs[j].value));
381 }
382 else if (rkl == 4 && memcmp(rk, "name", 4) == 0 &&
383 cbor_isa_string(rpPairs[j].value))
384 {
385 free(rpName);
386 rpName = strndup((const char*)cbor_string_handle(rpPairs[j].value),
387 cbor_string_length(rpPairs[j].value));
388 }
389 }
390
391 if (rpId)
392 fido_cred_set_rp(cred, rpId, rpName);
393
394 free(rpId);
395 free(rpName);
396 }
397 break;
398
399 case CTAP_MAKECRED_USER:
400 if (cbor_isa_map(v))
401 {
402 const unsigned char* userId = nullptr;
403 size_t userIdLen = 0;
404 char* userName = nullptr;
405 char* userDisplayName = nullptr;
406 const size_t uSize = cbor_map_size(v);
407 struct cbor_pair* uPairs = cbor_map_handle(v);
408
409 for (size_t j = 0; j < uSize; j++)
410 {
411 if (!cbor_isa_string(uPairs[j].key))
412 continue;
413
414 const char* uk = (const char*)cbor_string_handle(uPairs[j].key);
415 size_t ukl = cbor_string_length(uPairs[j].key);
416 if (ukl == 2 && memcmp(uk, "id", 2) == 0 &&
417 cbor_isa_bytestring(uPairs[j].value))
418 {
419 userId = cbor_bytestring_handle(uPairs[j].value);
420 userIdLen = cbor_bytestring_length(uPairs[j].value);
421 }
422 else if (ukl == 4 && memcmp(uk, "name", 4) == 0 &&
423 cbor_isa_string(uPairs[j].value))
424 {
425 free(userName);
426 userName = strndup((const char*)cbor_string_handle(uPairs[j].value),
427 cbor_string_length(uPairs[j].value));
428 }
429 else if (ukl == 11 && memcmp(uk, "displayName", 11) == 0 &&
430 cbor_isa_string(uPairs[j].value))
431 {
432 free(userDisplayName);
433 userDisplayName =
434 strndup((const char*)cbor_string_handle(uPairs[j].value),
435 cbor_string_length(uPairs[j].value));
436 }
437 }
438
439 if (userId && userIdLen > 0)
440 fido_cred_set_user(cred, userId, userIdLen, userName, userDisplayName,
441 nullptr);
442
443 free(userName);
444 free(userDisplayName);
445 }
446 break;
447
448 case CTAP_MAKECRED_PUB_KEY_CRED_PARAMS:
449 if (cbor_isa_array(v) && cbor_array_size(v) > 0)
450 {
451 cbor_item_t* first = cbor_array_get(v, 0);
452
453 if (first && cbor_isa_map(first))
454 {
455 const size_t pSize = cbor_map_size(first);
456 struct cbor_pair* pPairs = cbor_map_handle(first);
457
458 for (size_t j = 0; j < pSize; j++)
459 {
460 if (!cbor_isa_string(pPairs[j].key))
461 continue;
462
463 const char* pk = (const char*)cbor_string_handle(pPairs[j].key);
464 if (cbor_string_length(pPairs[j].key) == 3 &&
465 memcmp(pk, "alg", 3) == 0 && cbor_is_int(pPairs[j].value))
466 {
467 int alg =
468 WINPR_ASSERTING_INT_CAST(int, cbor_get_int(pPairs[j].value));
469 if (cbor_isa_negint(pPairs[j].value))
470 alg = -(alg + 1);
471 fido_cred_set_type(cred, alg);
472 }
473 }
474 }
475
476 if (first)
477 cbor_decref(&first);
478 }
479 break;
480
481 case CTAP_MAKECRED_EXCLUDE_LIST:
482 if (cbor_isa_array(v))
483 {
484 for (size_t j = 0; j < cbor_array_size(v); j++)
485 {
486 cbor_item_t* credDesc = cbor_array_get(v, j);
487 if (credDesc && cbor_isa_map(credDesc))
488 {
489 const size_t cdSize = cbor_map_size(credDesc);
490 struct cbor_pair* cdPairs = cbor_map_handle(credDesc);
491
492 for (size_t m = 0; m < cdSize; m++)
493 {
494 if (!cbor_isa_string(cdPairs[m].key))
495 continue;
496
497 const char* ck = (const char*)cbor_string_handle(cdPairs[m].key);
498 if (cbor_string_length(cdPairs[m].key) == 2 &&
499 memcmp(ck, "id", 2) == 0 &&
500 cbor_isa_bytestring(cdPairs[m].value))
501 {
502 fido_cred_exclude(cred,
503 cbor_bytestring_handle(cdPairs[m].value),
504 cbor_bytestring_length(cdPairs[m].value));
505 }
506 }
507 }
508
509 if (credDesc)
510 cbor_decref(&credDesc);
511 }
512 }
513 break;
514
515 case CTAP_MAKECRED_OPTIONS:
516 if (cbor_isa_map(v))
517 {
518 const size_t oSize = cbor_map_size(v);
519 struct cbor_pair* oPairs = cbor_map_handle(v);
520
521 for (size_t j = 0; j < oSize; j++)
522 {
523 if (!cbor_isa_string(oPairs[j].key))
524 continue;
525
526 const char* ok = (const char*)cbor_string_handle(oPairs[j].key);
527 size_t okl = cbor_string_length(oPairs[j].key);
528 if (!cbor_isa_float_ctrl(oPairs[j].value))
529 continue;
530
531 if (okl == 2 && memcmp(ok, "rk", 2) == 0)
532 fido_cred_set_rk(cred, cbor_get_bool(oPairs[j].value) ? FIDO_OPT_TRUE
533 : FIDO_OPT_FALSE);
534 else if (okl == 2 && memcmp(ok, "uv", 2) == 0)
535 {
536 uv = cbor_get_bool(oPairs[j].value);
537 fido_cred_set_uv(cred, uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE);
538 }
539 }
540 }
541 break;
542
543 default:
544 break;
545 }
546 }
547
548 /* Open all devices, let the user select by touch, then do the operation */
549 size_t ndevs = 0;
550 dev = rdpewa_fido_open_device(&devInfo, 0, &ndevs);
551 if (!dev)
552 {
553 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
554 goto out;
555 }
556
557 int r = FIDO_ERR_INTERNAL;
558 if (ndevs > 1)
559 {
560 /* Multiple devices: open all and let user select by touch. */
561 fido_dev_t** devs = (fido_dev_t**)calloc(ndevs, sizeof(*devs));
562 RDPEWA_DEVICE_INFO* devInfos = calloc(ndevs, sizeof(*devInfos));
563 if (!devs || !devInfos)
564 {
565 free((void*)devs);
566 free(devInfos);
567 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
568 goto out;
569 }
570 devs[0] = dev;
571 devInfos[0] = devInfo;
572
573 for (size_t i = 1; i < ndevs; i++)
574 devs[i] = rdpewa_fido_open_device(&devInfos[i], (int)i, nullptr);
575
576 int sel = rdpewa_fido_select_device(context, devs, ndevs, 30);
577 if (sel >= 0)
578 {
579 dev = devs[sel];
580 devInfo = devInfos[sel];
581 }
582 else
583 dev = nullptr;
584
585 /* Cancel and close non-selected devices */
586 for (size_t i = 0; i < ndevs; i++)
587 {
588 if (devs[i] && (int)i != sel)
589 {
590 fido_dev_cancel(devs[i]);
591 fido_dev_close(devs[i]);
592 fido_dev_free(&devs[i]);
593 }
594 }
595
596 free((void*)devs);
597 free(devInfos);
598
599 if (dev == nullptr)
600 {
601 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
602 goto out;
603 }
604 }
605
606 {
607 char* pin = nullptr;
608 const bool useUv = uv && fido_dev_has_uv(dev);
609 if (fido_dev_has_pin(dev) && !useUv && !rdpewa_fido_get_pin(context, &pin))
610 {
611 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
612 goto out;
613 }
614
615 /* Run fido in background (key starts blinking), notify via PubSub */
616 RDPEWA_FIDO_ASYNC fta = { dev, cred, nullptr, pin, FIDO_ERR_INTERNAL };
617 HANDLE ft = CreateThread(nullptr, 0, rdpewa_fido_makecred_thread, &fta, 0, nullptr);
618 if (!notifyWait(context, ft, dev))
619 {
620 winpr_zfree(pin);
621 goto out;
622 }
623
624 r = fta.result;
625 winpr_zfree(pin);
626
627 if (useUv && rdpewa_fido_uv_failed(r) && fido_dev_has_pin(dev))
628 {
629 if (!rdpewa_fido_get_pin(context, &pin))
630 {
631 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
632 goto out;
633 }
634
635 fta.pin = pin;
636 fta.result = FIDO_ERR_INTERNAL;
637 ft = CreateThread(nullptr, 0, rdpewa_fido_makecred_thread, &fta, 0, nullptr);
638 if (!notifyWait(context, ft, dev))
639 {
640 winpr_zfree(pin);
641 goto out;
642 }
643 r = fta.result;
644 winpr_zfree(pin);
645 }
646 }
647
648 if (r != FIDO_OK)
649 {
650 WLog_ERR(TAG, "fido_dev_make_cred failed: %s", fido_strerr(r));
651 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
652 goto out;
653 }
654
655 /* Encode the CTAP authenticator response (authData + fmt + attStmt) as CBOR.
656 * Use raw data from libfido2 to preserve exact authenticator output. */
657 cbor_item_t* respMap = cbor_new_definite_map(3);
658 if (!respMap)
659 goto out;
660
661 /* key 1: fmt */
662 cbor_item_t* fmtKey = cbor_build_uint8(1);
663 const char* fmt = fido_cred_fmt(cred);
664 cbor_item_t* fmtVal = cbor_build_string(fmt ? fmt : "none");
665 if (!cbor_map_add(respMap, (struct cbor_pair){ .key = fmtKey, .value = fmtVal }))
666 {
667 cbor_decref(&fmtKey);
668 cbor_decref(&fmtVal);
669 cbor_decref(&respMap);
670 goto out;
671 }
672 cbor_decref(&fmtKey);
673 cbor_decref(&fmtVal);
674
675 /* key 2: authData (raw bytes to preserve signature validity) */
676 cbor_item_t* adKey = cbor_build_uint8(2);
677 cbor_item_t* adVal =
678 cbor_build_bytestring(fido_cred_authdata_raw_ptr(cred), fido_cred_authdata_raw_len(cred));
679 if (!cbor_map_add(respMap, (struct cbor_pair){ .key = adKey, .value = adVal }))
680 {
681 cbor_decref(&adKey);
682 cbor_decref(&adVal);
683 cbor_decref(&respMap);
684 goto out;
685 }
686 cbor_decref(&adKey);
687 cbor_decref(&adVal);
688
689 /* key 3: attStmt, use raw attestation statement CBOR from authenticator.
690 * This preserves alg, sig, AND x5c certificate chain for packed attestation. */
691 const unsigned char* rawAttStmt = fido_cred_attstmt_ptr(cred);
692 size_t rawAttStmtLen = fido_cred_attstmt_len(cred);
693 if (rawAttStmt && rawAttStmtLen > 0)
694 {
695 /* The raw attstmt is already a CBOR-encoded map. Parse and re-attach it. */
696 struct cbor_load_result attResult = WINPR_C_ARRAY_INIT;
697 cbor_item_t* asKey = cbor_build_uint8(3);
698 cbor_item_t* asVal = cbor_load(rawAttStmt, rawAttStmtLen, &attResult);
699 if (!asVal || attResult.error.code != CBOR_ERR_NONE)
700 {
701 WLog_ERR(TAG, "Failed to parse raw attStmt CBOR");
702 if (asVal)
703 cbor_decref(&asVal);
704 cbor_decref(&asKey);
705 cbor_decref(&respMap);
706 goto out;
707 }
708
709 if (!cbor_map_add(respMap, (struct cbor_pair){ .key = asKey, .value = asVal }))
710 {
711 cbor_decref(&asKey);
712 cbor_decref(&asVal);
713 cbor_decref(&respMap);
714 goto out;
715 }
716
717 cbor_decref(&asKey);
718 cbor_decref(&asVal);
719 }
720 else
721 {
722 /* No attestation statement - use empty map */
723 cbor_item_t* asKey = cbor_build_uint8(3);
724 cbor_item_t* asVal = cbor_new_definite_map(0);
725 if (!cbor_map_add(respMap, (struct cbor_pair){ .key = asKey, .value = asVal }))
726 {
727 cbor_decref(&asKey);
728 cbor_decref(&asVal);
729 cbor_decref(&respMap);
730 goto out;
731 }
732
733 cbor_decref(&asKey);
734 cbor_decref(&asVal);
735 }
736
737 unsigned char* ctapBuf = nullptr;
738 size_t ctapBufLen = 0;
739 ctapBufLen = cbor_serialize_alloc(respMap, &ctapBuf, &ctapBufLen);
740 cbor_decref(&respMap);
741
742 if (ctapBufLen == 0 || !ctapBuf)
743 goto out;
744
745 ret = rdpewa_cbor_encode_webauthn_response(S_OK, 0x00, ctapBuf, ctapBufLen, &devInfo);
746 free(ctapBuf);
747
748out:
749 if (root)
750 cbor_decref(&root);
751 if (cred)
752 fido_cred_free(&cred);
753 if (dev)
754 {
755 fido_dev_close(dev);
756 fido_dev_free(&dev);
757 }
758 return ret;
759}
760
764WINPR_ATTR_MALLOC(Stream_Free, 1)
765static wStream* rdpewa_fido_get_assertion(rdpContext* context, const BYTE* ctapData, size_t ctapLen,
766 WINPR_ATTR_UNUSED UINT32 flags)
767{
768 fido_dev_t* dev = nullptr;
769 RDPEWA_DEVICE_INFO devInfo = WINPR_C_ARRAY_INIT;
770 fido_assert_t* assert = nullptr;
771 wStream* ret = nullptr;
772 bool uv = false;
773
774 WINPR_ASSERT(ctapData);
775
776 struct cbor_load_result result = WINPR_C_ARRAY_INIT;
777 cbor_item_t* root = cbor_load(ctapData, ctapLen, &result);
778 if (!root || !cbor_isa_map(root))
779 {
780 WLog_ERR(TAG, "Invalid CTAP GetAssertion CBOR data");
781 goto out;
782 }
783
784 assert = fido_assert_new();
785 if (!assert)
786 goto out;
787
788 const size_t mapSize = cbor_map_size(root);
789 struct cbor_pair* pairs = cbor_map_handle(root);
790
791 for (size_t i = 0; i < mapSize; i++)
792 {
793 if (!cbor_isa_uint(pairs[i].key))
794 continue;
795
796 uint64_t k = cbor_get_int(pairs[i].key);
797 cbor_item_t* v = pairs[i].value;
798
799 switch (k)
800 {
801 case CTAP_GETASSERT_RP_ID:
802 if (cbor_isa_string(v))
803 {
804 char* rpId = strndup((const char*)cbor_string_handle(v), cbor_string_length(v));
805 if (rpId)
806 {
807 fido_assert_set_rp(assert, rpId);
808 free(rpId);
809 }
810 }
811 break;
812
813 case CTAP_GETASSERT_CLIENT_DATA_HASH:
814 if (cbor_isa_bytestring(v))
815 fido_assert_set_clientdata_hash(assert, cbor_bytestring_handle(v),
816 cbor_bytestring_length(v));
817 break;
818
819 case CTAP_GETASSERT_ALLOW_LIST:
820 if (cbor_isa_array(v))
821 {
822 for (size_t j = 0; j < cbor_array_size(v); j++)
823 {
824 cbor_item_t* credDesc = cbor_array_get(v, j);
825 if (credDesc && cbor_isa_map(credDesc))
826 {
827 const size_t cdSize = cbor_map_size(credDesc);
828 struct cbor_pair* cdPairs = cbor_map_handle(credDesc);
829
830 for (size_t m = 0; m < cdSize; m++)
831 {
832 if (!cbor_isa_string(cdPairs[m].key))
833 continue;
834
835 const char* ck = (const char*)cbor_string_handle(cdPairs[m].key);
836 if (cbor_string_length(cdPairs[m].key) == 2 &&
837 memcmp(ck, "id", 2) == 0 &&
838 cbor_isa_bytestring(cdPairs[m].value))
839 {
840 fido_assert_allow_cred(
841 assert, cbor_bytestring_handle(cdPairs[m].value),
842 cbor_bytestring_length(cdPairs[m].value));
843 }
844 }
845 }
846
847 if (credDesc)
848 cbor_decref(&credDesc);
849 }
850 }
851 break;
852
853 case CTAP_GETASSERT_OPTIONS:
854 if (cbor_isa_map(v))
855 {
856 const size_t oSize = cbor_map_size(v);
857 struct cbor_pair* oPairs = cbor_map_handle(v);
858
859 for (size_t j = 0; j < oSize; j++)
860 {
861 if (!cbor_isa_string(oPairs[j].key))
862 continue;
863
864 const char* ok = (const char*)cbor_string_handle(oPairs[j].key);
865 size_t okl = cbor_string_length(oPairs[j].key);
866 if (!cbor_isa_float_ctrl(oPairs[j].value))
867 continue;
868
869 if (okl == 2 && memcmp(ok, "up", 2) == 0)
870 fido_assert_set_up(assert, cbor_get_bool(oPairs[j].value)
871 ? FIDO_OPT_TRUE
872 : FIDO_OPT_FALSE);
873 else if (okl == 2 && memcmp(ok, "uv", 2) == 0)
874 {
875 uv = cbor_get_bool(oPairs[j].value);
876 fido_assert_set_uv(assert, uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE);
877 }
878 }
879 }
880 break;
881
882 default:
883 break;
884 }
885 }
886
887 /* Open all devices, let the user select by touch, then do the operation */
888 size_t ndevs = 0;
889 int r = FIDO_ERR_NO_CREDENTIALS;
890 dev = rdpewa_fido_open_device(&devInfo, 0, &ndevs);
891 if (!dev)
892 {
893 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
894 goto out;
895 }
896
897 if (ndevs > 1)
898 {
899 fido_dev_t** devs = (fido_dev_t**)calloc(ndevs, sizeof(*devs));
900 RDPEWA_DEVICE_INFO* devInfos = calloc(ndevs, sizeof(*devInfos));
901 if (!devs || !devInfos)
902 {
903 free((void*)devs);
904 free(devInfos);
905 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
906 goto out;
907 }
908
909 devs[0] = dev;
910 devInfos[0] = devInfo;
911 for (size_t i = 1; i < ndevs; i++)
912 devs[i] = rdpewa_fido_open_device(&devInfos[i], (int)i, nullptr);
913
914 int sel = rdpewa_fido_select_device(context, devs, ndevs, 30);
915 if (sel >= 0)
916 {
917 dev = devs[sel];
918 devInfo = devInfos[sel];
919 }
920 else
921 dev = nullptr;
922
923 /* Cancel and close non-selected devices */
924 for (size_t i = 0; i < ndevs; i++)
925 {
926 if (devs[i] && (int)i != sel)
927 {
928 fido_dev_cancel(devs[i]);
929 fido_dev_close(devs[i]);
930 fido_dev_free(&devs[i]);
931 }
932 }
933
934 free((void*)devs);
935 free(devInfos);
936
937 if (dev == nullptr)
938 {
939 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
940 goto out;
941 }
942 }
943
944 {
945 char* pin = nullptr;
946 const bool useUv = uv && fido_dev_has_uv(dev);
947 if (fido_dev_has_pin(dev) && !useUv && !rdpewa_fido_get_pin(context, &pin))
948 {
949 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
950 goto out;
951 }
952
953 /* Run fido in background (key starts blinking), show prompt on this thread */
954 RDPEWA_FIDO_ASYNC fta = { dev, nullptr, assert, pin, FIDO_ERR_INTERNAL };
955 HANDLE ft = CreateThread(nullptr, 0, rdpewa_fido_getassert_thread, &fta, 0, nullptr);
956 if (!notifyWait(context, ft, dev))
957 {
958 winpr_zfree(pin);
959 goto out;
960 }
961
962 r = fta.result;
963 winpr_zfree(pin);
964
965 if (useUv && rdpewa_fido_uv_failed(r) && fido_dev_has_pin(dev))
966 {
967 if (!rdpewa_fido_get_pin(context, &pin))
968 {
969 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
970 goto out;
971 }
972
973 fta.pin = pin;
974 fta.result = FIDO_ERR_INTERNAL;
975 ft = CreateThread(nullptr, 0, rdpewa_fido_getassert_thread, &fta, 0, nullptr);
976 if (!notifyWait(context, ft, dev))
977 {
978 winpr_zfree(pin);
979 goto out;
980 }
981 r = fta.result;
982 winpr_zfree(pin);
983 }
984 }
985
986 if (r != FIDO_OK)
987 {
988 WLog_ERR(TAG, "fido_dev_get_assert failed: %s", fido_strerr(r));
989 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
990 goto out;
991 }
992
993 if (fido_assert_count(assert) == 0)
994 {
995 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01, nullptr, 0, &devInfo);
996 goto out;
997 }
998
999 /* Encode CTAP assertion response as CBOR map with integer keys per FIDO CTAP section 6.2 */
1000 size_t nkeys = 3; /* credential(1) + authData(2) + signature(3) */
1001 if (fido_assert_user_id_len(assert, 0) > 0)
1002 nkeys = 4; /* + user(4) */
1003 cbor_item_t* respMap = cbor_new_definite_map(nkeys);
1004 if (!respMap)
1005 goto out;
1006
1007 /* key 1: credential {id, type} */
1008 if (fido_assert_id_len(assert, 0) > 0)
1009 {
1010 cbor_item_t* credKey = cbor_build_uint8(1);
1011 cbor_item_t* credMap = cbor_new_definite_map(2);
1012 cbor_item_t* cidKey = cbor_build_string("id");
1013 cbor_item_t* cidVal =
1014 cbor_build_bytestring(fido_assert_id_ptr(assert, 0), fido_assert_id_len(assert, 0));
1015 cbor_item_t* ctypeKey = cbor_build_string("type");
1016 cbor_item_t* ctypeVal = cbor_build_string("public-key");
1017
1018 if (!cbor_map_add(credMap, (struct cbor_pair){ .key = cidKey, .value = cidVal }) ||
1019 !cbor_map_add(credMap, (struct cbor_pair){ .key = ctypeKey, .value = ctypeVal }) ||
1020 !cbor_map_add(respMap, (struct cbor_pair){ .key = credKey, .value = credMap }))
1021 {
1022 cbor_decref(&cidKey);
1023 cbor_decref(&cidVal);
1024 cbor_decref(&ctypeKey);
1025 cbor_decref(&ctypeVal);
1026 cbor_decref(&credKey);
1027 cbor_decref(&credMap);
1028 cbor_decref(&respMap);
1029 goto out;
1030 }
1031
1032 cbor_decref(&cidKey);
1033 cbor_decref(&cidVal);
1034 cbor_decref(&ctypeKey);
1035 cbor_decref(&ctypeVal);
1036 cbor_decref(&credKey);
1037 cbor_decref(&credMap);
1038 }
1039
1040 /* key 2: authData (raw) */
1041 cbor_item_t* adKey = cbor_build_uint8(2);
1042 cbor_item_t* adVal = cbor_build_bytestring(fido_assert_authdata_raw_ptr(assert, 0),
1043 fido_assert_authdata_raw_len(assert, 0));
1044 if (!cbor_map_add(respMap, (struct cbor_pair){ .key = adKey, .value = adVal }))
1045 {
1046 cbor_decref(&adKey);
1047 cbor_decref(&adVal);
1048 cbor_decref(&respMap);
1049 goto out;
1050 }
1051 cbor_decref(&adKey);
1052 cbor_decref(&adVal);
1053
1054 /* key 3: signature */
1055 cbor_item_t* sigKey = cbor_build_uint8(3);
1056 cbor_item_t* sigVal =
1057 cbor_build_bytestring(fido_assert_sig_ptr(assert, 0), fido_assert_sig_len(assert, 0));
1058 if (!cbor_map_add(respMap, (struct cbor_pair){ .key = sigKey, .value = sigVal }))
1059 {
1060 cbor_decref(&sigKey);
1061 cbor_decref(&sigVal);
1062 cbor_decref(&respMap);
1063 goto out;
1064 }
1065 cbor_decref(&sigKey);
1066 cbor_decref(&sigVal);
1067
1068 /* key 4: user -- id only */
1069 if (fido_assert_user_id_len(assert, 0) > 0)
1070 {
1071 cbor_item_t* uKey = cbor_build_uint8(4);
1072 cbor_item_t* uMap = cbor_new_definite_map(1);
1073 cbor_item_t* uidKey = cbor_build_string("id");
1074 cbor_item_t* uidVal = cbor_build_bytestring(fido_assert_user_id_ptr(assert, 0),
1075 fido_assert_user_id_len(assert, 0));
1076
1077 if (!cbor_map_add(uMap, (struct cbor_pair){ .key = uidKey, .value = uidVal }))
1078 {
1079 cbor_decref(&uidKey);
1080 cbor_decref(&uidVal);
1081 cbor_decref(&uKey);
1082 cbor_decref(&uMap);
1083 cbor_decref(&respMap);
1084 goto out;
1085 }
1086 cbor_decref(&uidKey);
1087 cbor_decref(&uidVal);
1088
1089 if (!cbor_map_add(respMap, (struct cbor_pair){ .key = uKey, .value = uMap }))
1090 {
1091 cbor_decref(&uKey);
1092 cbor_decref(&uMap);
1093 cbor_decref(&respMap);
1094 goto out;
1095 }
1096 cbor_decref(&uKey);
1097 cbor_decref(&uMap);
1098 }
1099
1100 unsigned char* ctapBuf = nullptr;
1101 size_t ctapBufLen = 0;
1102 ctapBufLen = cbor_serialize_alloc(respMap, &ctapBuf, &ctapBufLen);
1103 cbor_decref(&respMap);
1104
1105 if (ctapBufLen == 0 || !ctapBuf)
1106 goto out;
1107
1108 ret = rdpewa_cbor_encode_webauthn_response(S_OK, 0x00, ctapBuf, ctapBufLen, &devInfo);
1109 free(ctapBuf);
1110
1111out:
1112 if (root)
1113 cbor_decref(&root);
1114 if (assert)
1115 fido_assert_free(&assert);
1116 if (dev)
1117 {
1118 fido_dev_close(dev);
1119 fido_dev_free(&dev);
1120 }
1121 return ret;
1122}
1123
1124wStream* rdpewa_fido_webauthn(rdpContext* context, const RDPEWA_REQUEST* request)
1125{
1126 WINPR_ASSERT(request);
1127
1128 if (!request->request || request->requestLen < 1)
1129 {
1130 WLog_ERR(TAG, "Empty request payload for WEB_AUTHN command");
1131 return nullptr;
1132 }
1133
1134 BYTE subCommand = request->request[0];
1135 const BYTE* ctapData = request->request + 1;
1136 size_t ctapLen = request->requestLen - 1;
1137
1138 WLog_DBG(TAG, "WebAuthn sub-command 0x%02" PRIx8 " ctapLen=%" PRIuz, subCommand, ctapLen);
1139
1140 switch (subCommand)
1141 {
1142 case CTAPCBOR_CMD_MAKE_CREDENTIAL:
1143 return rdpewa_fido_make_credential(context, ctapData, ctapLen, request->flags);
1144
1145 case CTAPCBOR_CMD_GET_ASSERTION:
1146 return rdpewa_fido_get_assertion(context, ctapData, ctapLen, request->flags);
1147
1148 default:
1149 WLog_ERR(TAG, "Unknown WebAuthn sub-command 0x%02" PRIx8, subCommand);
1150 return nullptr;
1151 }
1152}
1153
1154wStream* rdpewa_fido_is_uvpaa(void)
1155{
1156 WLog_DBG(TAG, "IUVPAA: checking for platform authenticators");
1157
1158 fido_dev_info_t* devlist = fido_dev_info_new(RDPEWA_MAX_DEVICES);
1159 if (!devlist)
1160 return rdpewa_cbor_encode_simple_response(S_OK, 0);
1161
1162 size_t ndevs = 0;
1163 int r = fido_dev_info_manifest(devlist, RDPEWA_MAX_DEVICES, &ndevs);
1164 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
1165
1166 /* Report TRUE if at least one authenticator is found */
1167 UINT32 available = (r == FIDO_OK && ndevs > 0) ? 1 : 0;
1168 WLog_DBG(TAG, "IUVPAA: ndevs=%" PRIuz " available=%" PRIu32, ndevs, available);
1169 return rdpewa_cbor_encode_simple_response(S_OK, available);
1170}
1171
1172wStream* rdpewa_fido_api_version(void)
1173{
1174 WLog_DBG(TAG, "API_VERSION: reporting version 4");
1175
1176 /* Report API version 4 (consistent with Windows 11 / Server 2025) */
1177 return rdpewa_cbor_encode_simple_response(S_OK, 4);
1178}
1179
1180wStream* rdpewa_fido_get_authenticator_list(void)
1181{
1182 WLog_DBG(TAG, "GET_AUTHENTICATOR_LIST: enumerating authenticators");
1183
1184 fido_dev_info_t* devlist = fido_dev_info_new(RDPEWA_MAX_DEVICES);
1185 if (!devlist)
1186 return rdpewa_cbor_encode_hresult_response(S_OK);
1187
1188 size_t ndevs = 0;
1189 int r = fido_dev_info_manifest(devlist, RDPEWA_MAX_DEVICES, &ndevs);
1190 if (r != FIDO_OK || ndevs == 0)
1191 {
1192 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
1193 return rdpewa_cbor_encode_hresult_response(S_OK);
1194 }
1195
1196 /* Build CBOR array of authenticator maps per spec section 2.2.2.3 */
1197 cbor_item_t* arr = cbor_new_definite_array(ndevs);
1198 if (!arr)
1199 {
1200 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
1201 return nullptr;
1202 }
1203
1204 for (size_t i = 0; i < ndevs; i++)
1205 {
1206 const fido_dev_info_t* di = fido_dev_info_ptr(devlist, i);
1207 cbor_item_t* entry = cbor_new_definite_map(4);
1208 if (!entry)
1209 continue;
1210
1211 /* key 1: version */
1212 cbor_item_t* k1 = cbor_build_uint8(1);
1213 cbor_item_t* v1 = cbor_build_uint8(1);
1214 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k1, .value = v1 }))
1215 {
1216 cbor_decref(&k1);
1217 cbor_decref(&v1);
1218 cbor_decref(&entry);
1219 continue;
1220 }
1221 cbor_decref(&k1);
1222 cbor_decref(&v1);
1223
1224 /* key 3: authenticator name */
1225 const char* prod = fido_dev_info_product_string(di);
1226 cbor_item_t* k3 = cbor_build_uint8(3);
1227 cbor_item_t* v3 = cbor_build_string(prod ? prod : "FIDO2 Key");
1228 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k3, .value = v3 }))
1229 {
1230 cbor_decref(&k3);
1231 cbor_decref(&v3);
1232 cbor_decref(&entry);
1233 continue;
1234 }
1235 cbor_decref(&k3);
1236 cbor_decref(&v3);
1237
1238 /* key 4: authenticator logo (empty) */
1239 cbor_item_t* k4 = cbor_build_uint8(4);
1240 cbor_item_t* v4 = cbor_build_bytestring(nullptr, 0);
1241 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k4, .value = v4 }))
1242 {
1243 cbor_decref(&k4);
1244 cbor_decref(&v4);
1245 cbor_decref(&entry);
1246 continue;
1247 }
1248 cbor_decref(&k4);
1249 cbor_decref(&v4);
1250
1251 /* key 5: isLocked */
1252 cbor_item_t* k5 = cbor_build_uint8(5);
1253 cbor_item_t* v5 = cbor_build_bool(false);
1254 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k5, .value = v5 }))
1255 {
1256 cbor_decref(&k5);
1257 cbor_decref(&v5);
1258 cbor_decref(&entry);
1259 continue;
1260 }
1261 cbor_decref(&k5);
1262 cbor_decref(&v5);
1263
1264 if (!cbor_array_push(arr, entry))
1265 {
1266 cbor_decref(&entry);
1267 continue;
1268 }
1269 cbor_decref(&entry);
1270 }
1271
1272 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
1273
1274 size_t cborLen = cbor_serialized_size(arr);
1275 if (cborLen == 0)
1276 {
1277 cbor_decref(&arr);
1278 return nullptr;
1279 }
1280
1281 /* Response: 4-byte LE HRESULT + CBOR array */
1282 wStream* s = Stream_New(nullptr, 4 + cborLen);
1283 if (!s)
1284 {
1285 cbor_decref(&arr);
1286 return nullptr;
1287 }
1288
1289 Stream_Write_UINT32(s, (UINT32)S_OK);
1290 if (cbor_serialize(arr, Stream_Pointer(s), cborLen) == 0)
1291 {
1292 cbor_decref(&arr);
1293 Stream_Free(s, TRUE);
1294 return nullptr;
1295 }
1296 Stream_Seek(s, cborLen);
1297 cbor_decref(&arr);
1298 return s;
1299}
1300
1301wStream* rdpewa_fido_get_credentials(rdpContext* context, const char* rpId)
1302{
1303 WINPR_UNUSED(context);
1304
1305 if (!rpId || !rpId[0])
1306 {
1307 WLog_WARN(TAG, "GET_CREDENTIALS: no rpId provided");
1308 return rdpewa_cbor_encode_hresult_response(S_OK);
1309 }
1310
1311 WLog_DBG(TAG, "GET_CREDENTIALS: querying credentials for rpId '%s'", rpId);
1312
1313 /* Iterate all devices and collect credentials from each */
1314 size_t ndevs = 0;
1315 RDPEWA_DEVICE_INFO devInfo = WINPR_C_ARRAY_INIT;
1316 fido_dev_t* dev = rdpewa_fido_open_device(&devInfo, 0, &ndevs);
1317 if (!dev)
1318 return rdpewa_cbor_encode_hresult_response(S_OK);
1319
1320 cbor_item_t* arr = cbor_new_definite_array(0);
1321 if (!arr)
1322 {
1323 fido_dev_close(dev);
1324 fido_dev_free(&dev);
1325 return nullptr;
1326 }
1327
1328 for (size_t devIdx = 0; devIdx < ndevs; devIdx++)
1329 {
1330 if (devIdx > 0)
1331 {
1332 fido_dev_close(dev);
1333 fido_dev_free(&dev);
1334 dev = rdpewa_fido_open_device(&devInfo, (int)devIdx, nullptr);
1335 if (!dev)
1336 continue;
1337 }
1338
1339 if (!fido_dev_supports_credman(dev))
1340 {
1341 WLog_DBG(TAG,
1342 "GET_CREDENTIALS: device %" PRIuz " does not support credential management",
1343 devIdx);
1344 continue;
1345 }
1346
1347 /* Credential management requires a PIN token. We don't prompt for PIN here
1348 * since the platform handles credential selection differently. The server
1349 * sends allowList in command 5 and the authenticator handles it at touch time.
1350 * Only enumerate credentials from devices that don't require a PIN, to avoid
1351 * spamming the user with PIN prompts. */
1352 if (fido_dev_has_pin(dev))
1353 {
1354 WLog_DBG(TAG, "GET_CREDENTIALS: device %" PRIuz " requires PIN, skipping", devIdx);
1355 continue;
1356 }
1357
1358 const char* pin = nullptr;
1359
1360 fido_credman_rk_t* rk = fido_credman_rk_new();
1361 if (!rk)
1362 continue;
1363
1364 int r = fido_credman_get_dev_rk(dev, rpId, rk, pin);
1365 if (r != FIDO_OK)
1366 {
1367 WLog_DBG(TAG, "GET_CREDENTIALS: device %" PRIuz ": %s", devIdx, fido_strerr(r));
1368 fido_credman_rk_free(&rk);
1369 continue;
1370 }
1371
1372 size_t ncreds = fido_credman_rk_count(rk);
1373 WLog_DBG(TAG, "GET_CREDENTIALS: device %" PRIuz ": found %" PRIuz " credentials", devIdx,
1374 ncreds);
1375
1376 for (size_t i = 0; i < ncreds; i++)
1377 {
1378 const fido_cred_t* cred = fido_credman_rk(rk, i);
1379 if (!cred)
1380 continue;
1381
1382 cbor_item_t* entry = cbor_new_definite_map(4);
1383 if (!entry)
1384 continue;
1385
1386 cbor_item_t* k0 = cbor_build_uint8(0);
1387 cbor_item_t* v0 = cbor_build_uint8(4);
1388 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k0, .value = v0 }))
1389 {
1390 cbor_decref(&k0);
1391 cbor_decref(&v0);
1392 cbor_decref(&entry);
1393 continue;
1394 }
1395 cbor_decref(&k0);
1396 cbor_decref(&v0);
1397
1398 cbor_item_t* k1 = cbor_build_uint8(1);
1399 cbor_item_t* v1 = cbor_build_bytestring(fido_cred_id_ptr(cred), fido_cred_id_len(cred));
1400 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k1, .value = v1 }))
1401 {
1402 cbor_decref(&k1);
1403 cbor_decref(&v1);
1404 cbor_decref(&entry);
1405 continue;
1406 }
1407 cbor_decref(&k1);
1408 cbor_decref(&v1);
1409
1410 cbor_item_t* k2 = cbor_build_uint8(2);
1411 cbor_item_t* rpMap = cbor_new_definite_map(1);
1412 {
1413 cbor_item_t* rk2 = cbor_build_string("id");
1414 cbor_item_t* rv2 = cbor_build_string(rpId);
1415 if (!cbor_map_add(rpMap, (struct cbor_pair){ .key = rk2, .value = rv2 }))
1416 {
1417 cbor_decref(&rk2);
1418 cbor_decref(&rv2);
1419 cbor_decref(&k2);
1420 cbor_decref(&rpMap);
1421 cbor_decref(&entry);
1422 continue;
1423 }
1424 cbor_decref(&rk2);
1425 cbor_decref(&rv2);
1426 }
1427
1428 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k2, .value = rpMap }))
1429 {
1430 cbor_decref(&k2);
1431 cbor_decref(&rpMap);
1432 cbor_decref(&entry);
1433 continue;
1434 }
1435 cbor_decref(&k2);
1436 cbor_decref(&rpMap);
1437
1438 cbor_item_t* k3 = cbor_build_uint8(3);
1439 cbor_item_t* userMap = cbor_new_definite_map(2);
1440 {
1441 cbor_item_t* uk = cbor_build_string("id");
1442 cbor_item_t* uv =
1443 cbor_build_bytestring(fido_cred_user_id_ptr(cred), fido_cred_user_id_len(cred));
1444 if (!cbor_map_add(userMap, (struct cbor_pair){ .key = uk, .value = uv }))
1445 {
1446 cbor_decref(&uk);
1447 cbor_decref(&uv);
1448 cbor_decref(&k3);
1449 cbor_decref(&userMap);
1450 cbor_decref(&entry);
1451 continue;
1452 }
1453 cbor_decref(&uk);
1454 cbor_decref(&uv);
1455
1456 const char* uname = fido_cred_user_name(cred);
1457 if (uname)
1458 {
1459 cbor_item_t* unk = cbor_build_string("name");
1460 cbor_item_t* unv = cbor_build_string(uname);
1461 if (!cbor_map_add(userMap, (struct cbor_pair){ .key = unk, .value = unv }))
1462 {
1463 cbor_decref(&unk);
1464 cbor_decref(&unv);
1465 cbor_decref(&k3);
1466 cbor_decref(&userMap);
1467 cbor_decref(&entry);
1468 continue;
1469 }
1470 cbor_decref(&unk);
1471 cbor_decref(&unv);
1472 }
1473 }
1474
1475 if (!cbor_map_add(entry, (struct cbor_pair){ .key = k3, .value = userMap }))
1476 {
1477 cbor_decref(&k3);
1478 cbor_decref(&userMap);
1479 cbor_decref(&entry);
1480 continue;
1481 }
1482 cbor_decref(&k3);
1483 cbor_decref(&userMap);
1484
1485 if (!cbor_array_push(arr, entry))
1486 {
1487 cbor_decref(&entry);
1488 continue;
1489 }
1490 cbor_decref(&entry);
1491 }
1492
1493 fido_credman_rk_free(&rk);
1494 }
1495
1496 if (dev)
1497 {
1498 fido_dev_close(dev);
1499 fido_dev_free(&dev);
1500 }
1501
1502 size_t cborLen = cbor_serialized_size(arr);
1503 if (cborLen == 0)
1504 {
1505 cbor_decref(&arr);
1506 return nullptr;
1507 }
1508
1509 wStream* s = Stream_New(nullptr, 4 + cborLen);
1510 if (!s)
1511 {
1512 cbor_decref(&arr);
1513 return nullptr;
1514 }
1515
1516 Stream_Write_UINT32(s, (UINT32)S_OK);
1517 if (cbor_serialize(arr, Stream_Pointer(s), cborLen) == 0)
1518 {
1519 cbor_decref(&arr);
1520 Stream_Free(s, TRUE);
1521 return nullptr;
1522 }
1523 Stream_Seek(s, cborLen);
1524 cbor_decref(&arr);
1525 return s;
1526}
Device info for the response map.
Definition rdpewa_cbor.h:42
Decoded MS-RDPEWA request message.
Definition rdpewa_cbor.h:29