19#include <winpr/sysinfo.h>
21#include <freerdp/config.h>
27#include <fido/credman.h>
30#include <winpr/assert.h>
31#include <winpr/endian.h>
32#include <winpr/wlog.h>
34#include <freerdp/channels/log.h>
35#include <freerdp/channels/rdpewa.h>
36#include <freerdp/event.h>
38#include "rdpewa_cbor.h"
39#include "rdpewa_fido.h"
40#include <rdpewa-common.h>
42#include <winpr/thread.h>
43#include <winpr/synch.h>
45#define TAG CHANNELS_TAG("rdpewa.client")
48#define RDPEWA_MAX_DEVICES 64
55 fido_assert_t* assert;
60static bool rdpewa_fido_get_pin(rdpContext* context,
char** pin)
65 freerdp* instance = context->instance;
69 const bool rc = instance && instance->AuthenticateEx &&
70 instance->AuthenticateEx(instance, &u, &p, &d, AUTH_FIDO_PIN) && p;
83static bool rdpewa_fido_uv_failed(
int result)
85 return (result == FIDO_ERR_UV_BLOCKED) || (result == FIDO_ERR_UV_INVALID);
88static DWORD WINAPI rdpewa_fido_makecred_thread(LPVOID arg)
90 RDPEWA_FIDO_ASYNC* a = (RDPEWA_FIDO_ASYNC*)arg;
91 a->result = fido_dev_make_cred(a->dev, a->cred, a->pin);
95static DWORD WINAPI rdpewa_fido_getassert_thread(LPVOID arg)
97 RDPEWA_FIDO_ASYNC* a = (RDPEWA_FIDO_ASYNC*)arg;
98 a->result = fido_dev_get_assert(a->dev, a->assert, a->pin);
102static bool notify(rdpContext* context, UINT64
id,
bool cancel)
105 UserNotificationEventArgs e = WINPR_C_ARRAY_INIT;
106 EventArgsInit(&e, RDPEWA_CHANNEL_NAME);
110 e.message =
"Touch the security key";
112 e.cancelPreviousNotification = cancel;
115 const int rc = PubSub_OnUserNotification(context->pubSub, context, &e);
119static bool notifyWait(rdpContext* context, HANDLE ft, fido_dev_t* dev)
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);
130 const bool rc = (status == WAIT_OBJECT_0);
132 fido_dev_cancel(dev);
134 (void)WaitForSingleObject(ft, INFINITE);
143static int rdpewa_fido_select_device(rdpContext* context, fido_dev_t** devs,
size_t ndevs,
150 for (
size_t i = 0; i < ndevs; i++)
154 int r = fido_dev_get_touch_begin(devs[i]);
156 WLog_DBG(TAG,
"Device %" PRIuz
": fido_dev_get_touch_begin: %s", i, fido_strerr(r));
160 const UINT64
id = winpr_GetTickCount64NS();
161 (void)notify(context,
id,
false);
165 int iterations = timeout_sec * 5;
166 for (
int iter = 0; iter < iterations && selected < 0; iter++)
168 for (
size_t i = 0; i < ndevs; i++)
174 int r = fido_dev_get_touch_status(devs[i], &touched, 200);
175 if (r == FIDO_OK && touched)
177 WLog_DBG(TAG,
"Device %" PRIuz
" was touched", i);
178 selected = WINPR_ASSERTING_INT_CAST(
int, i);
184 (void)notify(context,
id,
true);
191static void rdpewa_fido_fill_device_info(fido_dev_t* dev,
const char* path,
192 const char* manufacturer,
const char* product,
199 .maxSerializedLargeBlobArray = 1024,
200 .providerType =
"Hid",
201 .providerName =
"FreeRDPFidoProvider",
202 .uvStatus = fido_dev_has_uv(dev) ? 1 : 0,
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);
212 fido_cbor_info_t* ci = fido_cbor_info_new();
213 if (ci && fido_dev_get_cbor_info(dev, ci) == FIDO_OK)
215 uint64_t msgsz = fido_cbor_info_maxmsgsiz(ci);
216 if (msgsz > 0 && msgsz <= UINT32_MAX)
217 info->maxMsgSize = (UINT32)msgsz;
219 uint64_t lblob = fido_cbor_info_maxlargeblob(ci);
220 if (lblob > 0 && lblob <= UINT32_MAX)
221 info->maxSerializedLargeBlobArray = (UINT32)lblob;
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);
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++)
235 if (strcmp(transports[i],
"usb") == 0)
236 info->transports |= 1;
237 else if (strcmp(transports[i],
"nfc") == 0)
238 info->transports |= 2;
239 else if (strcmp(transports[i],
"ble") == 0)
240 info->transports |= 4;
244 fido_cbor_info_free(&ci);
256 WLog_DBG(TAG,
"Enumerating FIDO2 devices...");
258 fido_dev_t* dev =
nullptr;
259 fido_dev_info_t* devlist = fido_dev_info_new(RDPEWA_MAX_DEVICES);
264 int r = fido_dev_info_manifest(devlist, RDPEWA_MAX_DEVICES, &ndevs);
265 if (r != FIDO_OK || ndevs == 0)
267 WLog_WARN(TAG,
"No FIDO2 authenticators found (r=%d, ndevs=%" PRIuz
")", r, ndevs);
268 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
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);
279 WLog_DBG(TAG,
"Found %" PRIuz
" FIDO2 device(s), opening device %" PRIuz
": '%s'", ndevs, idx,
283 const char* mfr = fido_dev_info_manufacturer_string(di);
284 const char* prod = fido_dev_info_product_string(di);
286 dev = fido_dev_new();
289 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
293 r = fido_dev_open(dev, path);
296 WLog_ERR(TAG,
"Failed to open FIDO2 device '%s': %s", path, fido_strerr(r));
298 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
303 rdpewa_fido_fill_device_info(dev, path, mfr, prod, devInfo);
305 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
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)
318 fido_dev_t* dev =
nullptr;
320 fido_cred_t* cred =
nullptr;
324 WINPR_ASSERT(ctapData);
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))
330 WLog_ERR(TAG,
"Invalid CTAP MakeCredential CBOR data");
334 cred = fido_cred_new();
339 fido_cred_set_type(cred, COSE_ES256);
341 const size_t mapSize = cbor_map_size(root);
342 struct cbor_pair* pairs = cbor_map_handle(root);
344 for (
size_t i = 0; i < mapSize; i++)
346 if (!cbor_isa_uint(pairs[i].key))
349 uint64_t k = cbor_get_int(pairs[i].key);
350 cbor_item_t* v = pairs[i].value;
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));
360 case CTAP_MAKECRED_RP:
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);
368 for (
size_t j = 0; j < rpSize; j++)
370 if (!cbor_isa_string(rpPairs[j].key))
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))
379 rpId = strndup((
const char*)cbor_string_handle(rpPairs[j].value),
380 cbor_string_length(rpPairs[j].value));
382 else if (rkl == 4 && memcmp(rk,
"name", 4) == 0 &&
383 cbor_isa_string(rpPairs[j].value))
386 rpName = strndup((
const char*)cbor_string_handle(rpPairs[j].value),
387 cbor_string_length(rpPairs[j].value));
392 fido_cred_set_rp(cred, rpId, rpName);
399 case CTAP_MAKECRED_USER:
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);
409 for (
size_t j = 0; j < uSize; j++)
411 if (!cbor_isa_string(uPairs[j].key))
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))
419 userId = cbor_bytestring_handle(uPairs[j].value);
420 userIdLen = cbor_bytestring_length(uPairs[j].value);
422 else if (ukl == 4 && memcmp(uk,
"name", 4) == 0 &&
423 cbor_isa_string(uPairs[j].value))
426 userName = strndup((
const char*)cbor_string_handle(uPairs[j].value),
427 cbor_string_length(uPairs[j].value));
429 else if (ukl == 11 && memcmp(uk,
"displayName", 11) == 0 &&
430 cbor_isa_string(uPairs[j].value))
432 free(userDisplayName);
434 strndup((
const char*)cbor_string_handle(uPairs[j].value),
435 cbor_string_length(uPairs[j].value));
439 if (userId && userIdLen > 0)
440 fido_cred_set_user(cred, userId, userIdLen, userName, userDisplayName,
444 free(userDisplayName);
448 case CTAP_MAKECRED_PUB_KEY_CRED_PARAMS:
449 if (cbor_isa_array(v) && cbor_array_size(v) > 0)
451 cbor_item_t* first = cbor_array_get(v, 0);
453 if (first && cbor_isa_map(first))
455 const size_t pSize = cbor_map_size(first);
456 struct cbor_pair* pPairs = cbor_map_handle(first);
458 for (
size_t j = 0; j < pSize; j++)
460 if (!cbor_isa_string(pPairs[j].key))
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))
468 WINPR_ASSERTING_INT_CAST(
int, cbor_get_int(pPairs[j].value));
469 if (cbor_isa_negint(pPairs[j].value))
471 fido_cred_set_type(cred, alg);
481 case CTAP_MAKECRED_EXCLUDE_LIST:
482 if (cbor_isa_array(v))
484 for (
size_t j = 0; j < cbor_array_size(v); j++)
486 cbor_item_t* credDesc = cbor_array_get(v, j);
487 if (credDesc && cbor_isa_map(credDesc))
489 const size_t cdSize = cbor_map_size(credDesc);
490 struct cbor_pair* cdPairs = cbor_map_handle(credDesc);
492 for (
size_t m = 0; m < cdSize; m++)
494 if (!cbor_isa_string(cdPairs[m].key))
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))
502 fido_cred_exclude(cred,
503 cbor_bytestring_handle(cdPairs[m].value),
504 cbor_bytestring_length(cdPairs[m].value));
510 cbor_decref(&credDesc);
515 case CTAP_MAKECRED_OPTIONS:
518 const size_t oSize = cbor_map_size(v);
519 struct cbor_pair* oPairs = cbor_map_handle(v);
521 for (
size_t j = 0; j < oSize; j++)
523 if (!cbor_isa_string(oPairs[j].key))
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))
531 if (okl == 2 && memcmp(ok,
"rk", 2) == 0)
532 fido_cred_set_rk(cred, cbor_get_bool(oPairs[j].value) ? FIDO_OPT_TRUE
534 else if (okl == 2 && memcmp(ok,
"uv", 2) == 0)
536 uv = cbor_get_bool(oPairs[j].value);
537 fido_cred_set_uv(cred, uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE);
550 dev = rdpewa_fido_open_device(&devInfo, 0, &ndevs);
553 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
557 int r = FIDO_ERR_INTERNAL;
561 fido_dev_t** devs = (fido_dev_t**)calloc(ndevs,
sizeof(*devs));
563 if (!devs || !devInfos)
567 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
571 devInfos[0] = devInfo;
573 for (
size_t i = 1; i < ndevs; i++)
574 devs[i] = rdpewa_fido_open_device(&devInfos[i], (
int)i,
nullptr);
576 int sel = rdpewa_fido_select_device(context, devs, ndevs, 30);
580 devInfo = devInfos[sel];
586 for (
size_t i = 0; i < ndevs; i++)
588 if (devs[i] && (
int)i != sel)
590 fido_dev_cancel(devs[i]);
591 fido_dev_close(devs[i]);
592 fido_dev_free(&devs[i]);
601 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
608 const bool useUv = uv && fido_dev_has_uv(dev);
609 if (fido_dev_has_pin(dev) && !useUv && !rdpewa_fido_get_pin(context, &pin))
611 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
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))
627 if (useUv && rdpewa_fido_uv_failed(r) && fido_dev_has_pin(dev))
629 if (!rdpewa_fido_get_pin(context, &pin))
631 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
636 fta.result = FIDO_ERR_INTERNAL;
637 ft = CreateThread(
nullptr, 0, rdpewa_fido_makecred_thread, &fta, 0,
nullptr);
638 if (!notifyWait(context, ft, dev))
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);
657 cbor_item_t* respMap = cbor_new_definite_map(3);
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 }))
667 cbor_decref(&fmtKey);
668 cbor_decref(&fmtVal);
669 cbor_decref(&respMap);
672 cbor_decref(&fmtKey);
673 cbor_decref(&fmtVal);
676 cbor_item_t* adKey = cbor_build_uint8(2);
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 }))
683 cbor_decref(&respMap);
691 const unsigned char* rawAttStmt = fido_cred_attstmt_ptr(cred);
692 size_t rawAttStmtLen = fido_cred_attstmt_len(cred);
693 if (rawAttStmt && rawAttStmtLen > 0)
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)
701 WLog_ERR(TAG,
"Failed to parse raw attStmt CBOR");
705 cbor_decref(&respMap);
709 if (!cbor_map_add(respMap, (
struct cbor_pair){ .key = asKey, .value = asVal }))
713 cbor_decref(&respMap);
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 }))
729 cbor_decref(&respMap);
737 unsigned char* ctapBuf =
nullptr;
738 size_t ctapBufLen = 0;
739 ctapBufLen = cbor_serialize_alloc(respMap, &ctapBuf, &ctapBufLen);
740 cbor_decref(&respMap);
742 if (ctapBufLen == 0 || !ctapBuf)
745 ret = rdpewa_cbor_encode_webauthn_response(S_OK, 0x00, ctapBuf, ctapBufLen, &devInfo);
752 fido_cred_free(&cred);
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)
768 fido_dev_t* dev =
nullptr;
770 fido_assert_t* assert =
nullptr;
774 WINPR_ASSERT(ctapData);
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))
780 WLog_ERR(TAG,
"Invalid CTAP GetAssertion CBOR data");
784 assert = fido_assert_new();
788 const size_t mapSize = cbor_map_size(root);
789 struct cbor_pair* pairs = cbor_map_handle(root);
791 for (
size_t i = 0; i < mapSize; i++)
793 if (!cbor_isa_uint(pairs[i].key))
796 uint64_t k = cbor_get_int(pairs[i].key);
797 cbor_item_t* v = pairs[i].value;
801 case CTAP_GETASSERT_RP_ID:
802 if (cbor_isa_string(v))
804 char* rpId = strndup((
const char*)cbor_string_handle(v), cbor_string_length(v));
807 fido_assert_set_rp(assert, rpId);
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));
819 case CTAP_GETASSERT_ALLOW_LIST:
820 if (cbor_isa_array(v))
822 for (
size_t j = 0; j < cbor_array_size(v); j++)
824 cbor_item_t* credDesc = cbor_array_get(v, j);
825 if (credDesc && cbor_isa_map(credDesc))
827 const size_t cdSize = cbor_map_size(credDesc);
828 struct cbor_pair* cdPairs = cbor_map_handle(credDesc);
830 for (
size_t m = 0; m < cdSize; m++)
832 if (!cbor_isa_string(cdPairs[m].key))
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))
840 fido_assert_allow_cred(
841 assert, cbor_bytestring_handle(cdPairs[m].value),
842 cbor_bytestring_length(cdPairs[m].value));
848 cbor_decref(&credDesc);
853 case CTAP_GETASSERT_OPTIONS:
856 const size_t oSize = cbor_map_size(v);
857 struct cbor_pair* oPairs = cbor_map_handle(v);
859 for (
size_t j = 0; j < oSize; j++)
861 if (!cbor_isa_string(oPairs[j].key))
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))
869 if (okl == 2 && memcmp(ok,
"up", 2) == 0)
870 fido_assert_set_up(assert, cbor_get_bool(oPairs[j].value)
873 else if (okl == 2 && memcmp(ok,
"uv", 2) == 0)
875 uv = cbor_get_bool(oPairs[j].value);
876 fido_assert_set_uv(assert, uv ? FIDO_OPT_TRUE : FIDO_OPT_FALSE);
889 int r = FIDO_ERR_NO_CREDENTIALS;
890 dev = rdpewa_fido_open_device(&devInfo, 0, &ndevs);
893 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
899 fido_dev_t** devs = (fido_dev_t**)calloc(ndevs,
sizeof(*devs));
901 if (!devs || !devInfos)
905 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
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);
914 int sel = rdpewa_fido_select_device(context, devs, ndevs, 30);
918 devInfo = devInfos[sel];
924 for (
size_t i = 0; i < ndevs; i++)
926 if (devs[i] && (
int)i != sel)
928 fido_dev_cancel(devs[i]);
929 fido_dev_close(devs[i]);
930 fido_dev_free(&devs[i]);
939 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
946 const bool useUv = uv && fido_dev_has_uv(dev);
947 if (fido_dev_has_pin(dev) && !useUv && !rdpewa_fido_get_pin(context, &pin))
949 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
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))
965 if (useUv && rdpewa_fido_uv_failed(r) && fido_dev_has_pin(dev))
967 if (!rdpewa_fido_get_pin(context, &pin))
969 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
974 fta.result = FIDO_ERR_INTERNAL;
975 ft = CreateThread(
nullptr, 0, rdpewa_fido_getassert_thread, &fta, 0,
nullptr);
976 if (!notifyWait(context, ft, dev))
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);
993 if (fido_assert_count(assert) == 0)
995 ret = rdpewa_cbor_encode_webauthn_response(E_FAIL, 0x01,
nullptr, 0, &devInfo);
1001 if (fido_assert_user_id_len(assert, 0) > 0)
1003 cbor_item_t* respMap = cbor_new_definite_map(nkeys);
1008 if (fido_assert_id_len(assert, 0) > 0)
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");
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 }))
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);
1032 cbor_decref(&cidKey);
1033 cbor_decref(&cidVal);
1034 cbor_decref(&ctypeKey);
1035 cbor_decref(&ctypeVal);
1036 cbor_decref(&credKey);
1037 cbor_decref(&credMap);
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 }))
1046 cbor_decref(&adKey);
1047 cbor_decref(&adVal);
1048 cbor_decref(&respMap);
1051 cbor_decref(&adKey);
1052 cbor_decref(&adVal);
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 }))
1060 cbor_decref(&sigKey);
1061 cbor_decref(&sigVal);
1062 cbor_decref(&respMap);
1065 cbor_decref(&sigKey);
1066 cbor_decref(&sigVal);
1069 if (fido_assert_user_id_len(assert, 0) > 0)
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));
1077 if (!cbor_map_add(uMap, (
struct cbor_pair){ .key = uidKey, .value = uidVal }))
1079 cbor_decref(&uidKey);
1080 cbor_decref(&uidVal);
1083 cbor_decref(&respMap);
1086 cbor_decref(&uidKey);
1087 cbor_decref(&uidVal);
1089 if (!cbor_map_add(respMap, (
struct cbor_pair){ .key = uKey, .value = uMap }))
1093 cbor_decref(&respMap);
1100 unsigned char* ctapBuf =
nullptr;
1101 size_t ctapBufLen = 0;
1102 ctapBufLen = cbor_serialize_alloc(respMap, &ctapBuf, &ctapBufLen);
1103 cbor_decref(&respMap);
1105 if (ctapBufLen == 0 || !ctapBuf)
1108 ret = rdpewa_cbor_encode_webauthn_response(S_OK, 0x00, ctapBuf, ctapBufLen, &devInfo);
1115 fido_assert_free(&assert);
1118 fido_dev_close(dev);
1119 fido_dev_free(&dev);
1126 WINPR_ASSERT(request);
1128 if (!request->request || request->requestLen < 1)
1130 WLog_ERR(TAG,
"Empty request payload for WEB_AUTHN command");
1134 BYTE subCommand = request->request[0];
1135 const BYTE* ctapData = request->request + 1;
1136 size_t ctapLen = request->requestLen - 1;
1138 WLog_DBG(TAG,
"WebAuthn sub-command 0x%02" PRIx8
" ctapLen=%" PRIuz, subCommand, ctapLen);
1142 case CTAPCBOR_CMD_MAKE_CREDENTIAL:
1143 return rdpewa_fido_make_credential(context, ctapData, ctapLen, request->flags);
1145 case CTAPCBOR_CMD_GET_ASSERTION:
1146 return rdpewa_fido_get_assertion(context, ctapData, ctapLen, request->flags);
1149 WLog_ERR(TAG,
"Unknown WebAuthn sub-command 0x%02" PRIx8, subCommand);
1154wStream* rdpewa_fido_is_uvpaa(
void)
1156 WLog_DBG(TAG,
"IUVPAA: checking for platform authenticators");
1158 fido_dev_info_t* devlist = fido_dev_info_new(RDPEWA_MAX_DEVICES);
1160 return rdpewa_cbor_encode_simple_response(S_OK, 0);
1163 int r = fido_dev_info_manifest(devlist, RDPEWA_MAX_DEVICES, &ndevs);
1164 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
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);
1172wStream* rdpewa_fido_api_version(
void)
1174 WLog_DBG(TAG,
"API_VERSION: reporting version 4");
1177 return rdpewa_cbor_encode_simple_response(S_OK, 4);
1180wStream* rdpewa_fido_get_authenticator_list(
void)
1182 WLog_DBG(TAG,
"GET_AUTHENTICATOR_LIST: enumerating authenticators");
1184 fido_dev_info_t* devlist = fido_dev_info_new(RDPEWA_MAX_DEVICES);
1186 return rdpewa_cbor_encode_hresult_response(S_OK);
1189 int r = fido_dev_info_manifest(devlist, RDPEWA_MAX_DEVICES, &ndevs);
1190 if (r != FIDO_OK || ndevs == 0)
1192 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
1193 return rdpewa_cbor_encode_hresult_response(S_OK);
1197 cbor_item_t* arr = cbor_new_definite_array(ndevs);
1200 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
1204 for (
size_t i = 0; i < ndevs; i++)
1206 const fido_dev_info_t* di = fido_dev_info_ptr(devlist, i);
1207 cbor_item_t* entry = cbor_new_definite_map(4);
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 }))
1218 cbor_decref(&entry);
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 }))
1232 cbor_decref(&entry);
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 }))
1245 cbor_decref(&entry);
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 }))
1258 cbor_decref(&entry);
1264 if (!cbor_array_push(arr, entry))
1266 cbor_decref(&entry);
1269 cbor_decref(&entry);
1272 fido_dev_info_free(&devlist, RDPEWA_MAX_DEVICES);
1274 size_t cborLen = cbor_serialized_size(arr);
1282 wStream* s = Stream_New(
nullptr, 4 + cborLen);
1289 Stream_Write_UINT32(s, (UINT32)S_OK);
1290 if (cbor_serialize(arr, Stream_Pointer(s), cborLen) == 0)
1293 Stream_Free(s, TRUE);
1296 Stream_Seek(s, cborLen);
1301wStream* rdpewa_fido_get_credentials(rdpContext* context,
const char* rpId)
1303 WINPR_UNUSED(context);
1305 if (!rpId || !rpId[0])
1307 WLog_WARN(TAG,
"GET_CREDENTIALS: no rpId provided");
1308 return rdpewa_cbor_encode_hresult_response(S_OK);
1311 WLog_DBG(TAG,
"GET_CREDENTIALS: querying credentials for rpId '%s'", rpId);
1316 fido_dev_t* dev = rdpewa_fido_open_device(&devInfo, 0, &ndevs);
1318 return rdpewa_cbor_encode_hresult_response(S_OK);
1320 cbor_item_t* arr = cbor_new_definite_array(0);
1323 fido_dev_close(dev);
1324 fido_dev_free(&dev);
1328 for (
size_t devIdx = 0; devIdx < ndevs; devIdx++)
1332 fido_dev_close(dev);
1333 fido_dev_free(&dev);
1334 dev = rdpewa_fido_open_device(&devInfo, (
int)devIdx,
nullptr);
1339 if (!fido_dev_supports_credman(dev))
1342 "GET_CREDENTIALS: device %" PRIuz
" does not support credential management",
1352 if (fido_dev_has_pin(dev))
1354 WLog_DBG(TAG,
"GET_CREDENTIALS: device %" PRIuz
" requires PIN, skipping", devIdx);
1358 const char* pin =
nullptr;
1360 fido_credman_rk_t* rk = fido_credman_rk_new();
1364 int r = fido_credman_get_dev_rk(dev, rpId, rk, pin);
1367 WLog_DBG(TAG,
"GET_CREDENTIALS: device %" PRIuz
": %s", devIdx, fido_strerr(r));
1368 fido_credman_rk_free(&rk);
1372 size_t ncreds = fido_credman_rk_count(rk);
1373 WLog_DBG(TAG,
"GET_CREDENTIALS: device %" PRIuz
": found %" PRIuz
" credentials", devIdx,
1376 for (
size_t i = 0; i < ncreds; i++)
1378 const fido_cred_t* cred = fido_credman_rk(rk, i);
1382 cbor_item_t* entry = cbor_new_definite_map(4);
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 }))
1392 cbor_decref(&entry);
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 }))
1404 cbor_decref(&entry);
1410 cbor_item_t* k2 = cbor_build_uint8(2);
1411 cbor_item_t* rpMap = cbor_new_definite_map(1);
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 }))
1420 cbor_decref(&rpMap);
1421 cbor_decref(&entry);
1428 if (!cbor_map_add(entry, (
struct cbor_pair){ .key = k2, .value = rpMap }))
1431 cbor_decref(&rpMap);
1432 cbor_decref(&entry);
1436 cbor_decref(&rpMap);
1438 cbor_item_t* k3 = cbor_build_uint8(3);
1439 cbor_item_t* userMap = cbor_new_definite_map(2);
1441 cbor_item_t* uk = cbor_build_string(
"id");
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 }))
1449 cbor_decref(&userMap);
1450 cbor_decref(&entry);
1456 const char* uname = fido_cred_user_name(cred);
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 }))
1466 cbor_decref(&userMap);
1467 cbor_decref(&entry);
1475 if (!cbor_map_add(entry, (
struct cbor_pair){ .key = k3, .value = userMap }))
1478 cbor_decref(&userMap);
1479 cbor_decref(&entry);
1483 cbor_decref(&userMap);
1485 if (!cbor_array_push(arr, entry))
1487 cbor_decref(&entry);
1490 cbor_decref(&entry);
1493 fido_credman_rk_free(&rk);
1498 fido_dev_close(dev);
1499 fido_dev_free(&dev);
1502 size_t cborLen = cbor_serialized_size(arr);
1509 wStream* s = Stream_New(
nullptr, 4 + cborLen);
1516 Stream_Write_UINT32(s, (UINT32)S_OK);
1517 if (cbor_serialize(arr, Stream_Pointer(s), cborLen) == 0)
1520 Stream_Free(s, TRUE);
1523 Stream_Seek(s, cborLen);
Device info for the response map.
Decoded MS-RDPEWA request message.