HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/creds/creds.c

58,070 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 740a0321e661f6b5dbae2aca047746351ba635fd

Lines 1001–1458 of 1,458

                else if (sd_id128_in_set(arg_with_key, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_SCOPED))
                        arg_with_key = CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_SCOPED;
                else if (sd_id128_in_set(arg_with_key, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_WITH_PK, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_WITH_PK_SCOPED))
                        arg_with_key = CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_WITH_PK_SCOPED;
                else if (sd_id128_in_set(arg_with_key, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_PINNED_SRK, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_SCOPED_PINNED_SRK))
                        arg_with_key = CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_SCOPED_PINNED_SRK;
                else if (sd_id128_in_set(arg_with_key, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_WITH_PK_PINNED_SRK, CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_WITH_PK_SCOPED_PINNED_SRK))
                        arg_with_key = CRED_AES256_GCM_BY_HOST_AND_TPM2_HMAC_WITH_PK_SCOPED_PINNED_SRK;
                else
                        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Selected key not available in --uid= scoped mode, refusing.");
        }
 
        if (arg_tpm2_pcr_mask == UINT32_MAX)
                arg_tpm2_pcr_mask = 0;
        if (arg_tpm2_public_key_pcr_mask == UINT32_MAX)
                arg_tpm2_public_key_pcr_mask = UINT32_C(1) << TPM2_PCR_KERNEL_BOOT;
 
        r = sd_varlink_invocation(SD_VARLINK_ALLOW_ACCEPT);
        if (r < 0)
                return log_error_errno(r, "Failed to check if invoked in Varlink mode: %m");
        arg_varlink = r;
 
        *ret_args = option_parser_get_args(&opts);
        return 1;
}
 
#define TIMESTAMP_FRESH_MAX (30*USEC_PER_SEC)
 
static bool timestamp_is_fresh(usec_t x) {
        usec_t n = now(CLOCK_REALTIME);
 
        /* We'll only allow unprivileged encryption/decryption for somehwhat "fresh" timestamps */
 
        if (x > n)
                return x - n <= TIMESTAMP_FRESH_MAX;
        else
                return n - x <= TIMESTAMP_FRESH_MAX;
}
 
typedef enum CredentialScope {
        CREDENTIAL_SYSTEM,
        CREDENTIAL_USER,
        /* One day we should add more here, for example, per-app/per-service credentials */
        _CREDENTIAL_SCOPE_MAX,
        _CREDENTIAL_SCOPE_INVALID = -EINVAL,
} CredentialScope;
 
static const char* credential_scope_table[_CREDENTIAL_SCOPE_MAX] = {
        [CREDENTIAL_SYSTEM] = "system",
        [CREDENTIAL_USER]   = "user",
};
 
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(credential_scope, CredentialScope);
static JSON_DISPATCH_ENUM_DEFINE(dispatch_credential_scope, CredentialScope, credential_scope_from_string);
 
typedef struct MethodEncryptParameters {
        const char *name;
        const char *text;
        struct iovec data;
        uint64_t timestamp;
        uint64_t not_after;
        CredentialScope scope;
        sd_id128_t with_key;
        uid_t uid;
} MethodEncryptParameters;
 
static void method_encrypt_parameters_done(MethodEncryptParameters *p) {
        assert(p);
 
        iovec_done_erase(&p->data);
}
 
static int settle_scope(
                sd_varlink *link,
                CredentialScope *scope,
                uid_t *uid,
                CredentialFlags *flags,
                bool *any_scope_after_polkit) {
 
        uid_t peer_uid;
        int r;
 
        assert(link);
        assert(scope);
        assert(uid);
        assert(flags);
 
        r = sd_varlink_get_peer_uid(link, &peer_uid);
        if (r < 0)
                return r;
 
        if (*scope < 0) {
                if (uid_is_valid(*uid))
                        *scope = CREDENTIAL_USER;
                else {
                        *scope = CREDENTIAL_SYSTEM;  /* When encrypting, we spit out a system credential */
                        *uid = peer_uid;             /* When decrypting a user credential, use this UID */
                }
 
                if (peer_uid == 0)
                        *flags |= CREDENTIAL_ANY_SCOPE;
 
                if (any_scope_after_polkit)
                        *any_scope_after_polkit = true;
        } else if (*scope == CREDENTIAL_USER) {
                if (!uid_is_valid(*uid))
                        *uid = peer_uid;
        } else {
                assert(*scope == CREDENTIAL_SYSTEM);
                if (uid_is_valid(*uid))
                        return sd_varlink_error_invalid_parameter_name(link, "uid");
        }
 
        return 0;
}
 
static char normalize_separator(char c) {
        if (IN_SET(c, '-', '+', '_'))
                return '_';
 
        return c;
}
 
static bool enum_name_equal(const char *x, const char *y) {
        if (x == y)
                return true;
        if (!x || !y)
                return false;
 
        for (;; x++, y++) {
                char a = normalize_separator(*x), b = normalize_separator(*y);
                if (a != b)
                        return false;
                if (a == 0)
                        return true;
        }
}
 
static CredKeyType cred_key_type_from_string_harder(const char *s) {
        if (!s)
                return _CRED_KEY_TYPE_INVALID;
 
        CredKeyType t = cred_key_type_from_string(s);
        if (t >= 0)
                return t;
 
        /* Varlink doesn't like dashes and plusses in enum names. Try to match when considering them equal to underscores */
        for (t = 0; t < _CRED_KEY_TYPE_MAX; t++)
                if (enum_name_equal(cred_key_type_table[t], s))
                        return t;
 
        return _CRED_KEY_TYPE_INVALID;
}
 
static int dispatch_credential_key_type(
                const char *name,
                sd_json_variant *variant,
                sd_json_dispatch_flags_t flags,
                void *userdata) {
 
        sd_id128_t *id = ASSERT_PTR(userdata);
 
        if (sd_json_variant_is_null(variant)) {
                *id = SD_ID128_NULL;
                return 0;
        }
 
        const char *s = sd_json_variant_string(variant);
        if (isempty(s)) {
                *id = SD_ID128_NULL;
                return 0;
        }
 
        CredKeyType t = cred_key_type_from_string_harder(s);
        if (t < 0)
                return json_log(variant, flags, t, "JSON field '%s' is not a valid key type.", strna(name));
 
        *id = cred_key_id[t];
        return 0;
}
 
static int vl_method_encrypt(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "name",      SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(MethodEncryptParameters, name),      0 },
                { "text",      SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(MethodEncryptParameters, text),      0 },
                { "data",      SD_JSON_VARIANT_STRING,        json_dispatch_unbase64_iovec,  offsetof(MethodEncryptParameters, data),      0 },
                { "timestamp", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(MethodEncryptParameters, timestamp), 0 },
                { "notAfter",  _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(MethodEncryptParameters, not_after), 0 },
                { "scope",     SD_JSON_VARIANT_STRING,        dispatch_credential_scope,     offsetof(MethodEncryptParameters, scope),     0 },
                { "withKey",   SD_JSON_VARIANT_STRING,        dispatch_credential_key_type,  offsetof(MethodEncryptParameters, with_key),  SD_JSON_NULLABLE },
                { "uid",       _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uid_gid,      offsetof(MethodEncryptParameters, uid),       0 },
                VARLINK_DISPATCH_POLKIT_FIELD,
                {}
        };
        _cleanup_(method_encrypt_parameters_done) MethodEncryptParameters p = {
                .timestamp = UINT64_MAX,
                .not_after = UINT64_MAX,
                .scope = _CREDENTIAL_SCOPE_INVALID,
                .uid = UID_INVALID,
        };
        _cleanup_(iovec_done) struct iovec output = {};
        Hashmap **polkit_registry = ASSERT_PTR(userdata);
        CredentialFlags cflags = 0;
        bool timestamp_fresh;
        uid_t peer_uid;
        int r;
 
        assert(link);
 
        r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
        if (r != 0)
                return r;
 
        if (p.name && !credential_name_valid(p.name))
                return sd_varlink_error_invalid_parameter_name(link, "name");
        /* Specifying both or neither the text string and the binary data is not allowed */
        if (!!p.text == !!p.data.iov_base)
                return sd_varlink_error_invalid_parameter_name(link, "data");
        if (p.timestamp == UINT64_MAX) {
                p.timestamp = now(CLOCK_REALTIME);
                timestamp_fresh = true;
        } else
                timestamp_fresh = timestamp_is_fresh(p.timestamp);
        if (p.not_after != UINT64_MAX && p.not_after <= p.timestamp)
                return sd_varlink_error_invalid_parameter_name(link, "notAfter");
 
        r = settle_scope(link, &p.scope, &p.uid, &cflags, /* any_scope_after_polkit= */ NULL);
        if (r < 0)
                return r;
 
        r = sd_varlink_get_peer_uid(link, &peer_uid);
        if (r < 0)
                return r;
 
        /* Relax security requirements if peer wants to encrypt credentials for themselves */
        bool own_scope = p.scope == CREDENTIAL_USER && p.uid == peer_uid;
 
        if (!own_scope || !timestamp_fresh) {
                /* Insist on PK if client wants to encrypt for another user or the system, or if the timestamp was explicitly overridden. */
                r = varlink_verify_polkit_async(
                                link,
                                /* bus= */ NULL,
                                "io.systemd.credentials.encrypt",
                                /* details= */ NULL,
                                polkit_registry);
                if (r <= 0)
                        return r;
        }
 
        r = encrypt_credential_and_warn(
                        sd_id128_is_null(p.with_key) ? (p.scope == CREDENTIAL_USER ? _CRED_AUTO_SCOPED : _CRED_AUTO) : p.with_key,
                        p.name,
                        p.timestamp,
                        p.not_after,
                        arg_tpm2_device,
                        arg_tpm2_pcr_mask,
                        arg_tpm2_public_key,
                        arg_tpm2_public_key_pcr_mask,
                        p.uid,
                        p.text ? &IOVEC_MAKE_STRING(p.text) : &p.data,
                        cflags,
                        &output);
        if (r == -ESRCH)
                return sd_varlink_error(link, "io.systemd.Credentials.NoSuchUser", NULL);
        if (r < 0)
                return r;
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *reply = NULL;
 
        r = sd_json_buildo(&reply, JSON_BUILD_PAIR_IOVEC_BASE64("blob", &output));
        if (r < 0)
                return r;
 
        /* Let's also mark the (theoretically encrypted) reply as sensitive, in case the NULL encryption scheme was used. */
        sd_json_variant_sensitive(reply);
 
        return sd_varlink_reply(link, reply);
}
 
typedef struct MethodDecryptParameters {
        const char *name;
        struct iovec blob;
        uint64_t timestamp;
        CredentialScope scope;
        uid_t uid;
        int allow_null;
} MethodDecryptParameters;
 
static void method_decrypt_parameters_done(MethodDecryptParameters *p) {
        assert(p);
 
        iovec_done_erase(&p->blob);
}
 
static int vl_method_decrypt(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "name",      SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(MethodDecryptParameters, name),       0                 },
                { "blob",      SD_JSON_VARIANT_STRING,        json_dispatch_unbase64_iovec,  offsetof(MethodDecryptParameters, blob),       SD_JSON_MANDATORY },
                { "timestamp", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(MethodDecryptParameters, timestamp),  0                 },
                { "scope",     SD_JSON_VARIANT_STRING,        dispatch_credential_scope,     offsetof(MethodDecryptParameters, scope),      0                 },
                { "uid",       _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uid_gid,      offsetof(MethodDecryptParameters, uid),        0                 },
                { "allowNull", SD_JSON_VARIANT_BOOLEAN,       sd_json_dispatch_tristate,     offsetof(MethodDecryptParameters, allow_null), SD_JSON_NULLABLE  },
                VARLINK_DISPATCH_POLKIT_FIELD,
                {}
        };
        _cleanup_(method_decrypt_parameters_done) MethodDecryptParameters p = {
                .timestamp = UINT64_MAX,
                .scope = _CREDENTIAL_SCOPE_INVALID,
                .uid = UID_INVALID,
                .allow_null = -1,
        };
        bool timestamp_fresh, any_scope_after_polkit = false;
        _cleanup_(iovec_done_erase) struct iovec output = {};
        Hashmap **polkit_registry = ASSERT_PTR(userdata);
        CredentialFlags cflags = 0;
        uid_t peer_uid;
        int r;
 
        assert(link);
 
        r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
        if (r != 0)
                return r;
 
        if (p.name && !credential_name_valid(p.name))
                return sd_varlink_error_invalid_parameter_name(link, "name");
        if (p.timestamp == UINT64_MAX) {
                p.timestamp = now(CLOCK_REALTIME);
                timestamp_fresh = true;
        } else
                timestamp_fresh = timestamp_is_fresh(p.timestamp);
 
        r = settle_scope(link, &p.scope, &p.uid, &cflags, &any_scope_after_polkit);
        if (r < 0)
                return r;
 
        if (p.allow_null > 0)
                cflags |= CREDENTIAL_ALLOW_NULL;
        else if (p.allow_null == 0)
                cflags |= CREDENTIAL_REFUSE_NULL;
 
        r = sd_varlink_get_peer_uid(link, &peer_uid);
        if (r < 0)
                return r;
 
        /* Relax security requirements if peer wants to encrypt credentials for themselves */
        bool own_scope = p.scope == CREDENTIAL_USER && p.uid == peer_uid;
        bool ask_polkit = !own_scope || !timestamp_fresh;
        for (;;) {
                if (ask_polkit) {
                        r = varlink_verify_polkit_async(
                                        link,
                                        /* bus= */ NULL,
                                        "io.systemd.credentials.decrypt",
                                        /* details= */ NULL,
                                        polkit_registry);
                        if (r <= 0)
                                return r;
 
                        /* Now that we have authenticated, it's fine to allow unpriv clients access to system secrets */
                        if (any_scope_after_polkit)
                                cflags |= CREDENTIAL_ANY_SCOPE;
                }
 
                r = decrypt_credential_and_warn(
                                p.name,
                                p.timestamp,
                                arg_tpm2_device,
                                arg_tpm2_signature,
                                p.uid,
                                &p.blob,
                                cflags,
                                &output);
                if (r != -EMEDIUMTYPE || ask_polkit || !any_scope_after_polkit)
                        break;
 
                /* So the secret was apparently intended for the system. Let's retry decrypting it after
                 * acquiring polkit's permission. */
                ask_polkit = true;
        }
 
        if (ERRNO_IS_NEG_TPM2_UNSEAL_BAD_PCR(r))
                return sd_varlink_error(link, "io.systemd.Credentials.UnexpectedPCRState", NULL);
        if (r < 0) {
                const CredentialsVarlinkError *e = credentials_varlink_error_by_errno(r);
                if (e)
                        return sd_varlink_error(link, e->id, NULL);
 
                return r;
        }
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *reply = NULL;
 
        r = sd_json_buildo(&reply, JSON_BUILD_PAIR_IOVEC_BASE64("data", &output));
        if (r < 0)
                return r;
 
        sd_json_variant_sensitive(reply);
 
        return sd_varlink_reply(link, reply);
}
 
static int vl_server(void) {
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *varlink_server = NULL;
        _cleanup_hashmap_free_ Hashmap *polkit_registry = NULL;
        int r;
 
        /* Invocation as Varlink service */
 
        r = varlink_server_new(
                        &varlink_server,
                        SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA|SD_VARLINK_SERVER_INPUT_SENSITIVE,
                        &polkit_registry);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate Varlink server: %m");
 
        r = sd_varlink_server_add_interface(varlink_server, &vl_interface_io_systemd_Credentials);
        if (r < 0)
                return log_error_errno(r, "Failed to add Varlink interface: %m");
 
        r = sd_varlink_server_bind_method_many(
                        varlink_server,
                        "io.systemd.Credentials.Encrypt", vl_method_encrypt,
                        "io.systemd.Credentials.Decrypt", vl_method_decrypt);
        if (r < 0)
                return log_error_errno(r, "Failed to bind Varlink methods: %m");
 
        r = sd_varlink_server_loop_auto(varlink_server);
        if (r < 0)
                return log_error_errno(r, "Failed to run Varlink event loop: %m");
 
        return 0;
}
 
static int run(int argc, char *argv[]) {
        int r;
 
        LIBCRYPTO_NOTE(suggested);
        LIBMOUNT_NOTE(recommended);
        TPM2_NOTE(suggested);
 
        log_setup();
 
        char **args = NULL;
        r = parse_argv(argc, argv, &args);
        if (r <= 0)
                return r;
 
        if (arg_varlink)
                return vl_server();
 
        return dispatch_verb(args, NULL);
}
 
DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);