HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/libfido2-util.c

66,562 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 3824c06bad71f440f568a16c58c8beb51f0e4968

Lines 1001–1570 of 1,570

                                        "Token PIN is currently blocked, please remove and reinsert token.");
        if (r == FIDO_ERR_UV_BLOCKED)
                return log_notice_errno(SYNTHETIC_ERRNO(EPERM),
                                        "Token verification is currently blocked, please remove and reinsert token.");
        if (r == FIDO_ERR_ACTION_TIMEOUT)
                return log_error_errno(SYNTHETIC_ERRNO(ENOSTR),
                                       "Token action timeout. (User didn't interact with token quickly enough.)");
        if (r == FIDO_ERR_UNSUPPORTED_ALGORITHM)
                return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                       "Token doesn't support credential algorithm %s.", fido2_algorithm_to_string(cred_alg));
        if (r == FIDO_ERR_PIN_INVALID)
                return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                       "PIN incorrect.");
        if (r != FIDO_OK)
                return log_error_errno(SYNTHETIC_ERRNO(EIO),
                                       "Failed to generate FIDO2 credential: %s", sym_fido_strerr(r));
 
        cid = sym_fido_cred_id_ptr(c);
        if (!cid)
                return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to get FIDO2 credential ID.");
 
        cid_size = sym_fido_cred_id_len(c);
 
        a = sym_fido_assert_new();
        if (!a)
                return log_oom();
 
        r = sym_fido_assert_set_extensions(a, FIDO_EXT_HMAC_SECRET);
        if (r != FIDO_OK)
                return log_error_errno(SYNTHETIC_ERRNO(EIO),
                                       "Failed to enable HMAC-SECRET extension on FIDO2 assertion: %s", sym_fido_strerr(r));
 
        r = sym_fido_assert_set_hmac_salt(a, salt->iov_base, salt->iov_len);
        if (r != FIDO_OK)
                return log_error_errno(SYNTHETIC_ERRNO(EIO),
                                       "Failed to set salt on FIDO2 assertion: %s", sym_fido_strerr(r));
 
        r = fido2_assert_set_basic_properties(a, rp_id, cid, cid_size);
        if (r < 0)
                return r;
 
        log_info("Generating secret key on FIDO2 security token.");
 
        if (has_up) {
                r = sym_fido_assert_set_up(a, FLAGS_SET(lock_with, FIDO2ENROLL_UP) ? FIDO_OPT_TRUE : FIDO_OPT_FALSE);
                if (r != FIDO_OK)
                        return log_error_errno(SYNTHETIC_ERRNO(EIO),
                                               "Failed to %s FIDO2 user presence test: %s",
                                               enable_disable(FLAGS_SET(lock_with, FIDO2ENROLL_UP)),
                                               sym_fido_strerr(r));
 
                if (FLAGS_SET(lock_with, FIDO2ENROLL_UP))
                        log_notice("%s%sIn order to allow secret key generation, please confirm presence on security token.",
                                   emoji_enabled() ? glyph(GLYPH_TOUCH) : "",
                                   emoji_enabled() ? " " : "");
        }
 
        if (has_uv) {
                r = sym_fido_assert_set_uv(a, FLAGS_SET(lock_with, FIDO2ENROLL_UV) ? FIDO_OPT_TRUE : FIDO_OPT_FALSE);
                if (r != FIDO_OK)
                        return log_error_errno(SYNTHETIC_ERRNO(EIO),
                                               "Failed to %s FIDO user verification: %s",
                                               enable_disable(FLAGS_SET(lock_with, FIDO2ENROLL_UV)),
                                               sym_fido_strerr(r));
 
                if (FLAGS_SET(lock_with, FIDO2ENROLL_UV))
                        log_notice("%s%sIn order to allow secret key generation, please verify user on security token.",
                                   emoji_enabled() ? glyph(GLYPH_TOUCH) : "",
                                   emoji_enabled() ? " " : "");
        }
 
        for (;;) {
                bool retry_with_up = false, retry_with_pin = false;
 
                r = sym_fido_dev_get_assert(d, a, FLAGS_SET(lock_with, FIDO2ENROLL_PIN) ? used_pin : NULL);
 
                switch (r) {
 
                case FIDO_ERR_UP_REQUIRED:
                        /* If the token asks for "up" when we turn off, then this might be a feature that
                         * isn't optional. Let's enable it */
 
                        if (!has_up)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Token asks for user presence test but doesn't advertise 'up' feature.");
 
                        if (FLAGS_SET(lock_with, FIDO2ENROLL_UP))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Token asks for user presence test but was already enabled.");
 
                        log_notice("%s%sLocking without user presence test requested, but FIDO2 device %s requires it, enabling.",
                                   emoji_enabled() ? glyph(GLYPH_TOUCH) : "",
                                   emoji_enabled() ? " " : "",
                                   device);
 
                        retry_with_up = true;
                        break;
 
                case FIDO_ERR_UNSUPPORTED_OPTION:
                        /* AuthenTrend ATKey.Pro says it supports "up", but if we disable it it will fail
                         * with FIDO_ERR_UNSUPPORTED_OPTION, probably because it isn't actually
                         * optional. Let's see if turning it on works. This is very similar to the
                         * FIDO_ERR_UP_REQUIRED case, but since the error is so vague we implement it
                         * slightly more defensively. */
 
                        if (has_up && !FLAGS_SET(lock_with, FIDO2ENROLL_UP)) {
                                log_notice("%s%sGot unsupported option error when user presence test is turned off. Trying with user presence test turned on.",
                                           emoji_enabled() ? glyph(GLYPH_TOUCH) : "",
                                           emoji_enabled() ? " " : "");
                                retry_with_up = true;
                        }
 
                        break;
 
                case FIDO_ERR_PIN_REQUIRED:
                        if (!has_client_pin)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Token asks for client PIN check but doesn't advertise 'clientPin' feature.");
 
                        if (FLAGS_SET(lock_with, FIDO2ENROLL_PIN))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Token asks for user client PIN check but was already enabled.");
 
                        log_debug("Token requires PIN for assertion, enabling.");
                        retry_with_pin = true;
                        break;
 
                default:
                        ;
                }
 
                if (!retry_with_up && !retry_with_pin)
                        break;
 
                if (retry_with_up) {
                        r = sym_fido_assert_set_up(a, FIDO_OPT_TRUE);
                        if (r != FIDO_OK)
                                return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to enable FIDO2 user presence test: %s", sym_fido_strerr(r));
 
                        lock_with |= FIDO2ENROLL_UP;
                }
 
                if (retry_with_pin)
                        lock_with |= FIDO2ENROLL_PIN;
        }
 
        if (r == FIDO_ERR_ACTION_TIMEOUT)
                return log_error_errno(SYNTHETIC_ERRNO(ENOSTR),
                                       "Token action timeout. (User didn't interact with token quickly enough.)");
        if (r != FIDO_OK)
                return log_error_errno(SYNTHETIC_ERRNO(EIO),
                                       "Failed to ask token for assertion: %s", sym_fido_strerr(r));
 
        secret = sym_fido_assert_hmac_secret_ptr(a, 0);
        if (!secret)
                return log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to retrieve HMAC secret.");
 
        secret_size = sym_fido_assert_hmac_secret_len(a, 0);
        /* Should never be zero, sanity check */
        assert(secret_size > 0);
 
        secret_copy = memdup(secret, secret_size);
        if (!secret_copy)
                return log_oom();
 
        cid_copy = memdup(cid, cid_size);
        if (!cid_copy)
                return log_oom();
 
        *ret_cid = TAKE_PTR(cid_copy);
        *ret_cid_size = cid_size;
        *ret_secret = TAKE_PTR(secret_copy);
        *ret_secret_size = secret_size;
 
        if (ret_usedpin)
                *ret_usedpin = TAKE_PTR(used_pin);
 
        if (ret_locked_with)
                *ret_locked_with = lock_with;
 
        return 0;
}
#endif
 
#if HAVE_LIBFIDO2
static int check_device_is_fido2_with_hmac_secret(
                const char *path,
                bool *ret_has_rk,
                bool *ret_has_client_pin,
                bool *ret_has_up,
                bool *ret_has_uv,
                bool *ret_has_always_uv) {
 
        _cleanup_(fido_dev_free_wrapper) fido_dev_t *d = NULL;
        int r;
 
        d = sym_fido_dev_new();
        if (!d)
                return log_oom();
 
        r = sym_fido_dev_open(d, path);
        if (r != FIDO_OK)
                return log_error_errno(SYNTHETIC_ERRNO(EIO),
                                       "Failed to open FIDO2 device %s: %s", path, sym_fido_strerr(r));
 
        r = verify_features(d, path, LOG_DEBUG, ret_has_rk, ret_has_client_pin, ret_has_up, ret_has_uv, ret_has_always_uv);
        if (r == -ENODEV) { /* Not a FIDO2 device, or not implementing 'hmac-secret' */
                if (ret_has_rk)
                        *ret_has_rk = false;
                if (ret_has_client_pin)
                        *ret_has_client_pin = false;
                if (ret_has_up)
                        *ret_has_up = false;
                if (ret_has_uv)
                        *ret_has_uv = false;
                if (ret_has_always_uv)
                        *ret_has_always_uv = false;
                return false;
        }
        if (r < 0)
                return r;
 
        return true;
}
#endif
 
int fido2_list_devices(void) {
#if HAVE_LIBFIDO2
        _cleanup_(table_unrefp) Table *t = NULL;
 
        size_t allocated = 64, found = 0;
        fido_dev_info_t *di = NULL;
        int r;
 
        r = dlopen_libfido2(LOG_ERR);
        if (r < 0)
                return r;
 
        di = sym_fido_dev_info_new(allocated);
        if (!di)
                return log_oom();
 
        r = sym_fido_dev_info_manifest(di, allocated, &found);
        if (r == FIDO_ERR_INTERNAL || (r == FIDO_OK && found == 0)) {
                /* The library returns FIDO_ERR_INTERNAL when no devices are found. I wish it wouldn't. */
                log_info("No FIDO2 devices found.");
                r = 0;
                goto finish;
        }
        if (r != FIDO_OK) {
                r = log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to enumerate FIDO2 devices: %s", sym_fido_strerr(r));
                goto finish;
        }
 
        t = table_new("path", "manufacturer", "product", "compatible", "rk", "clientpin", "up", "uv", "alwaysuv");
        if (!t) {
                r = log_oom();
                goto finish;
        }
 
        for (size_t i = 0; i < found; i++) {
                const fido_dev_info_t *entry;
                bool has_rk, has_client_pin, has_up, has_uv, has_always_uv;
 
                entry = sym_fido_dev_info_ptr(di, i);
                if (!entry) {
                        r = log_error_errno(SYNTHETIC_ERRNO(EIO),
                                            "Failed to get device information for FIDO device %zu.", i);
                        goto finish;
                }
 
                r = check_device_is_fido2_with_hmac_secret(sym_fido_dev_info_path(entry), &has_rk, &has_client_pin, &has_up, &has_uv, &has_always_uv);
                if (r < 0)
                        goto finish;
                bool compatible = r > 0;
 
                r = table_add_many(
                                t,
                                TABLE_PATH, sym_fido_dev_info_path(entry),
                                TABLE_STRING, sym_fido_dev_info_manufacturer_string(entry),
                                TABLE_STRING, sym_fido_dev_info_product_string(entry),
                                TABLE_BOOLEAN_CHECKMARK, compatible,
                                TABLE_BOOLEAN_CHECKMARK, has_rk,
                                TABLE_BOOLEAN_CHECKMARK, has_client_pin,
                                TABLE_BOOLEAN_CHECKMARK, has_up,
                                TABLE_BOOLEAN_CHECKMARK, has_uv,
                                TABLE_BOOLEAN_CHECKMARK, has_always_uv);
                if (r < 0) {
                        table_log_add_error(r);
                        goto finish;
                }
        }
 
        r = table_print_or_warn(t);
        if (r < 0)
                goto finish;
 
        if (!table_isempty(t))
                printf("\n"
                       "%1$sLegend: RK        %2$s Resident key%3$s\n"
                       "%1$s        CLIENTPIN %2$s PIN request%3$s\n"
                       "%1$s        UP        %2$s User presence%3$s\n"
                       "%1$s        UV        %2$s User verification%3$s\n"
                       "%1$s        AlwaysUV  %2$s User verification Required%3$s\n",
                       ansi_grey(),
                       glyph(GLYPH_ARROW_RIGHT),
                       ansi_normal());
 
        r = 0;
 
finish:
        sym_fido_dev_info_free(&di, allocated);
        return r;
#else
        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                               "FIDO2 tokens not supported on this build.");
#endif
}
 
void fido2_device_info_done(Fido2DeviceInfo *d) {
        assert(d);
 
        d->path = mfree(d->path);
        d->manufacturer = mfree(d->manufacturer);
        d->product = mfree(d->product);
}
 
void fido2_device_info_free_many(Fido2DeviceInfo *a, size_t n) {
        FOREACH_ARRAY(i, a, n)
                fido2_device_info_done(i);
 
        free(a);
}
 
int fido2_enumerate_devices(Fido2DeviceInfo **ret, size_t *ret_n) {
#if HAVE_LIBFIDO2
        Fido2DeviceInfo *devices = NULL;
        size_t n_devices = 0, allocated = 64, found = 0;
        fido_dev_info_t *di = NULL;
        int r;
 
        CLEANUP_ARRAY(devices, n_devices, fido2_device_info_free_many);
 
        assert(ret);
        assert(ret_n);
 
        r = dlopen_libfido2(LOG_ERR);
        if (r < 0)
                return r;
 
        di = sym_fido_dev_info_new(allocated);
        if (!di)
                return log_oom();
 
        r = sym_fido_dev_info_manifest(di, allocated, &found);
        if (r == FIDO_ERR_INTERNAL || (r == FIDO_OK && found == 0)) {
                /* The library returns FIDO_ERR_INTERNAL when no devices are found. I wish it wouldn't. */
                r = 0;
                goto finish;
        }
        if (r != FIDO_OK) {
                r = log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to enumerate FIDO2 devices: %s", sym_fido_strerr(r));
                goto finish;
        }
 
        for (size_t i = 0; i < found; i++) {
                bool has_rk, has_client_pin, has_up, has_uv, has_always_uv;
                const fido_dev_info_t *entry;
                const char *path;
 
                entry = sym_fido_dev_info_ptr(di, i);
                if (!entry) {
                        r = log_error_errno(SYNTHETIC_ERRNO(EIO),
                                            "Failed to get device information for FIDO device %zu.", i);
                        goto finish;
                }
 
                path = sym_fido_dev_info_path(entry);
 
                r = check_device_is_fido2_with_hmac_secret(path, &has_rk, &has_client_pin, &has_up, &has_uv, &has_always_uv);
                if (r < 0)
                        goto finish;
                if (r == 0) /* Not a FIDO2 device suitable for enrollment, skip it */
                        continue;
 
                if (!GREEDY_REALLOC(devices, n_devices + 1)) {
                        r = log_oom();
                        goto finish;
                }
 
                Fido2DeviceInfo *d = devices + n_devices;
                *d = (Fido2DeviceInfo) {};
 
                /* The manufacturer / product strings are optional (NULL when the device doesn't report
                 * them), but a failure to duplicate any string is a genuine OOM and thus fatal. */
                if (strdup_to(&d->path, path) < 0 ||
                    strdup_to(&d->manufacturer, empty_to_null(sym_fido_dev_info_manufacturer_string(entry))) < 0 ||
                    strdup_to(&d->product, empty_to_null(sym_fido_dev_info_product_string(entry))) < 0) {
                        fido2_device_info_done(d);
                        r = log_oom();
                        goto finish;
                }
 
                n_devices++;
        }
 
        r = 0;
 
finish:
        sym_fido_dev_info_free(&di, allocated);
        if (r < 0)
                return r;
 
        *ret = TAKE_PTR(devices);
        *ret_n = n_devices;
        return 0;
#else
        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                               "FIDO2 tokens not supported on this build.");
#endif
}
 
int fido2_find_device_auto(char **ret) {
#if HAVE_LIBFIDO2
        _cleanup_free_ char *copy = NULL;
        size_t di_size = 64, found = 0;
        const fido_dev_info_t *entry;
        fido_dev_info_t *di = NULL;
        const char *path;
        int r;
 
        r = dlopen_libfido2(LOG_ERR);
        if (r < 0)
                return r;
 
        di = sym_fido_dev_info_new(di_size);
        if (!di)
                return log_oom();
 
        r = sym_fido_dev_info_manifest(di, di_size, &found);
        if (r == FIDO_ERR_INTERNAL || (r == FIDO_OK && found == 0)) {
                /* The library returns FIDO_ERR_INTERNAL when no devices are found. I wish it wouldn't. */
                r = log_error_errno(SYNTHETIC_ERRNO(ENODEV), "No FIDO devices found.");
                goto finish;
        }
        if (r != FIDO_OK) {
                r = log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to enumerate FIDO devices: %s", sym_fido_strerr(r));
                goto finish;
        }
        if (found > 1) {
                r = log_error_errno(SYNTHETIC_ERRNO(ENOTUNIQ), "More than one FIDO device found.");
                goto finish;
        }
 
        entry = sym_fido_dev_info_ptr(di, 0);
        if (!entry) {
                r = log_error_errno(SYNTHETIC_ERRNO(EIO),
                                    "Failed to get device information for FIDO device 0.");
                goto finish;
        }
 
        r = check_device_is_fido2_with_hmac_secret(
                        sym_fido_dev_info_path(entry),
                        /* ret_has_rk= */ NULL,
                        /* ret_has_client_pin= */ NULL,
                        /* ret_has_up= */ NULL,
                        /* ret_has_uv= */ NULL,
                        /* ret_has_always_uv= */ NULL);
        if (r < 0)
                goto finish;
        if (!r) {
                r = log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "FIDO device discovered does not implement FIDO2 with 'hmac-secret' extension.");
                goto finish;
        }
 
        path = sym_fido_dev_info_path(entry);
        if (!path) {
                r = log_error_errno(SYNTHETIC_ERRNO(EIO),
                                    "Failed to query FIDO device path.");
                goto finish;
        }
 
        copy = strdup(path);
        if (!copy) {
                r = log_oom();
                goto finish;
        }
 
        *ret = TAKE_PTR(copy);
        r = 0;
 
finish:
        sym_fido_dev_info_free(&di, di_size);
        return r;
#else
        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                               "FIDO2 tokens not supported on this build.");
#endif
}
 
int fido2_have_device(const char *device) {
#if HAVE_LIBFIDO2
        size_t allocated = 64, found = 0;
        fido_dev_info_t *di = NULL;
        int r;
 
        /* Return == 0 if not devices are found, > 0 if at least one is found */
 
        r = dlopen_libfido2(LOG_ERR);
        if (r < 0)
                return r;
 
        if (device) {
                if (access(device, F_OK) < 0) {
                        if (errno == ENOENT)
                                return 0;
 
                        return log_error_errno(errno, "Failed to determine whether device '%s' exists: %m", device);
                }
 
                return 1;
        }
 
        di = sym_fido_dev_info_new(allocated);
        if (!di)
                return log_oom();
 
        r = sym_fido_dev_info_manifest(di, allocated, &found);
        if (r == FIDO_ERR_INTERNAL) {
                /* The library returns FIDO_ERR_INTERNAL when no devices are found. I wish it wouldn't. */
                r = 0;
                goto finish;
        }
        if (r != FIDO_OK) {
                r = log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to enumerate FIDO2 devices: %s", sym_fido_strerr(r));
                goto finish;
        }
 
        r = found;
 
finish:
        sym_fido_dev_info_free(&di, allocated);
        return r;
#else
        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                               "FIDO2 tokens not supported on this build.");
#endif
}
 
#if HAVE_LIBFIDO2
int parse_fido2_algorithm(const char *s, int *ret) {
        int a;
 
        assert(s);
 
        if (streq(s, "es256"))
                a = COSE_ES256;
        else if (streq(s, "rs256"))
                a = COSE_RS256;
        else if (streq(s, "eddsa"))
                a = COSE_EDDSA;
        else
                return -EINVAL;
 
        if (ret)
                *ret = a;
        return 0;
}
#endif