HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/home/user-record-util.c

56,019 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: b419a85b6842d69dd1c57cb0d3e0fe299295f016

Lines 1001–1589 of 1,589

        return 0;
}
 
int user_record_set_fido2_user_presence_permitted(UserRecord *h, int b) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        int r;
 
        assert(h);
 
        w = sd_json_variant_ref(sd_json_variant_by_key(h->json, "secret"));
 
        if (b < 0)
                r = sd_json_variant_filter(&w, STRV_MAKE("fido2UserPresencePermitted"));
        else
                r = sd_json_variant_set_field_boolean(&w, "fido2UserPresencePermitted", b);
        if (r < 0)
                return r;
 
        if (sd_json_variant_is_blank_object(w))
                r = sd_json_variant_filter(&h->json, STRV_MAKE("secret"));
        else {
                sd_json_variant_sensitive(w);
 
                r = sd_json_variant_set_field(&h->json, "secret", w);
        }
        if (r < 0)
                return r;
 
        h->fido2_user_presence_permitted = b;
 
        SET_FLAG(h->mask, USER_RECORD_SECRET, !sd_json_variant_is_blank_object(w));
        return 0;
}
 
int user_record_set_fido2_user_verification_permitted(UserRecord *h, int b) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        int r;
 
        assert(h);
 
        w = sd_json_variant_ref(sd_json_variant_by_key(h->json, "secret"));
 
        if (b < 0)
                r = sd_json_variant_filter(&w, STRV_MAKE("fido2UserVerificationPermitted"));
        else
                r = sd_json_variant_set_field_boolean(&w, "fido2UserVerificationPermitted", b);
        if (r < 0)
                return r;
 
        if (sd_json_variant_is_blank_object(w))
                r = sd_json_variant_filter(&h->json, STRV_MAKE("secret"));
        else {
                sd_json_variant_sensitive(w);
 
                r = sd_json_variant_set_field(&h->json, "secret", w);
        }
        if (r < 0)
                return r;
 
        h->fido2_user_verification_permitted = b;
 
        SET_FLAG(h->mask, USER_RECORD_SECRET, !sd_json_variant_is_blank_object(w));
        return 0;
}
 
static bool per_machine_entry_empty(sd_json_variant *v) {
        const char *k;
        _unused_ sd_json_variant *e;
 
        JSON_VARIANT_OBJECT_FOREACH(k, e, v)
                if (!STR_IN_SET(k, "matchMachineId", "matchHostname"))
                        return false;
 
        return true;
}
 
int user_record_set_password_change_now(UserRecord *h, int b) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        sd_json_variant *per_machine;
        int r;
 
        assert(h);
 
        w = sd_json_variant_ref(h->json);
 
        if (b < 0)
                r = sd_json_variant_filter(&w, STRV_MAKE("passwordChangeNow"));
        else
                r = sd_json_variant_set_field_boolean(&w, "passwordChangeNow", b);
        if (r < 0)
                return r;
 
        /* Also drop the field from all perMachine entries */
        per_machine = sd_json_variant_by_key(w, "perMachine");
        if (per_machine) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
                sd_json_variant *e;
 
                JSON_VARIANT_ARRAY_FOREACH(e, per_machine) {
                        _cleanup_(sd_json_variant_unrefp) sd_json_variant *z = NULL;
 
                        if (!sd_json_variant_is_object(e))
                                return -EINVAL;
 
                        z = sd_json_variant_ref(e);
 
                        r = sd_json_variant_filter(&z, STRV_MAKE("passwordChangeNow"));
                        if (r < 0)
                                return r;
 
                        if (per_machine_entry_empty(z))
                                continue;
 
                        r = sd_json_variant_append_array(&array, z);
                        if (r < 0)
                                return r;
                }
 
                if (sd_json_variant_is_blank_array(array))
                        r = sd_json_variant_filter(&w, STRV_MAKE("perMachine"));
                else
                        r = sd_json_variant_set_field(&w, "perMachine", array);
                if (r < 0)
                        return r;
 
                SET_FLAG(h->mask, USER_RECORD_PER_MACHINE, !sd_json_variant_is_blank_array(array));
        }
 
        h->password_change_now = b;
        return json_variant_unref_and_replace(h->json, w);
}
 
int user_record_merge_secret(UserRecord *h, UserRecord *secret) {
        int r;
 
        assert(h);
        assert(secret);
 
        /* Merges the secrets from 'secret' into 'h'. */
 
        r = user_record_set_password(h, secret->password, true);
        if (r < 0)
                return r;
 
        r = user_record_set_token_pin(h, secret->token_pin, true);
        if (r < 0)
                return r;
 
        if (secret->pkcs11_protected_authentication_path_permitted >= 0) {
                r = user_record_set_pkcs11_protected_authentication_path_permitted(
                                h,
                                secret->pkcs11_protected_authentication_path_permitted);
                if (r < 0)
                        return r;
        }
 
        if (secret->fido2_user_presence_permitted >= 0) {
                r = user_record_set_fido2_user_presence_permitted(
                                h,
                                secret->fido2_user_presence_permitted);
                if (r < 0)
                        return r;
        }
 
        if (secret->fido2_user_verification_permitted >= 0) {
                r = user_record_set_fido2_user_verification_permitted(
                                h,
                                secret->fido2_user_verification_permitted);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
int user_record_good_authentication(UserRecord *h) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL, *z = NULL;
        uint64_t counter, usec;
        sd_id128_t mid;
        int r;
 
        assert(h);
 
        switch (h->good_authentication_counter) {
        case UINT64_MAX:
                counter = 1;
                break;
        case UINT64_MAX-1:
                counter = h->good_authentication_counter; /* saturate */
                break;
        default:
                counter = h->good_authentication_counter + 1;
        }
 
        usec = now(CLOCK_REALTIME);
 
        r = sd_id128_get_machine(&mid);
        if (r < 0)
                return r;
 
        v = sd_json_variant_ref(h->json);
        w = sd_json_variant_ref(sd_json_variant_by_key(v, "status"));
        z = sd_json_variant_ref(sd_json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
 
        r = sd_json_variant_set_field_unsigned(&z, "goodAuthenticationCounter", counter);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field_unsigned(&z, "lastGoodAuthenticationUSec", usec);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field(&v, "status", w);
        if (r < 0)
                return r;
 
        h->good_authentication_counter = counter;
        h->last_good_authentication_usec = usec;
        h->mask |= USER_RECORD_STATUS;
        return json_variant_unref_and_replace(h->json, v);
}
 
int user_record_bad_authentication(UserRecord *h) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL, *z = NULL;
        uint64_t counter, usec;
        sd_id128_t mid;
        int r;
 
        assert(h);
 
        switch (h->bad_authentication_counter) {
        case UINT64_MAX:
                counter = 1;
                break;
        case UINT64_MAX-1:
                counter = h->bad_authentication_counter; /* saturate */
                break;
        default:
                counter = h->bad_authentication_counter + 1;
        }
 
        usec = now(CLOCK_REALTIME);
 
        r = sd_id128_get_machine(&mid);
        if (r < 0)
                return r;
 
        v = sd_json_variant_ref(h->json);
        w = sd_json_variant_ref(sd_json_variant_by_key(v, "status"));
        z = sd_json_variant_ref(sd_json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
 
        r = sd_json_variant_set_field_unsigned(&z, "badAuthenticationCounter", counter);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field_unsigned(&z, "lastBadAuthenticationUSec", usec);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field(&v, "status", w);
        if (r < 0)
                return r;
 
        h->bad_authentication_counter = counter;
        h->last_bad_authentication_usec = usec;
        h->mask |= USER_RECORD_STATUS;
        return json_variant_unref_and_replace(h->json, v);
}
 
int user_record_ratelimit(UserRecord *h) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *w = NULL, *z = NULL;
        usec_t usec, new_ratelimit_begin_usec, new_ratelimit_count;
        sd_id128_t mid;
        int r;
 
        assert(h);
 
        usec = now(CLOCK_REALTIME);
 
        if (h->ratelimit_begin_usec != UINT64_MAX && h->ratelimit_begin_usec > usec) {
                /* Hmm, start-time is after the current time? If so, the RTC most likely doesn't work. */
                new_ratelimit_begin_usec = usec;
                new_ratelimit_count = 1;
                log_debug("Rate limit timestamp is in the future, assuming incorrect system clock, resetting limit.");
        } else if (h->ratelimit_begin_usec == UINT64_MAX ||
                 usec_add(h->ratelimit_begin_usec, user_record_ratelimit_interval_usec(h)) <= usec) {
                /* Fresh start */
                new_ratelimit_begin_usec = usec;
                new_ratelimit_count = 1;
        } else if (h->ratelimit_count < user_record_ratelimit_burst(h)) {
                /* Count up */
                new_ratelimit_begin_usec = h->ratelimit_begin_usec;
                new_ratelimit_count = h->ratelimit_count + 1;
        } else
                /* Limit hit */
                return 0;
 
        r = sd_id128_get_machine(&mid);
        if (r < 0)
                return r;
 
        v = sd_json_variant_ref(h->json);
        w = sd_json_variant_ref(sd_json_variant_by_key(v, "status"));
        z = sd_json_variant_ref(sd_json_variant_by_key(w, SD_ID128_TO_STRING(mid)));
 
        r = sd_json_variant_set_field_unsigned(&z, "rateLimitBeginUSec", new_ratelimit_begin_usec);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field_unsigned(&z, "rateLimitCount", new_ratelimit_count);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field(&w, SD_ID128_TO_STRING(mid), z);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field(&v, "status", w);
        if (r < 0)
                return r;
 
        h->ratelimit_begin_usec = new_ratelimit_begin_usec;
        h->ratelimit_count = new_ratelimit_count;
        h->mask |= USER_RECORD_STATUS;
        json_variant_unref_and_replace(h->json, v);
        return 1;
}
 
int user_record_is_supported(UserRecord *hr, sd_bus_error *error) {
        assert(hr);
 
        if (hr->disposition >= 0 && hr->disposition != USER_REGULAR)
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot manage anything but regular users.");
 
        if (hr->storage >= 0 && !IN_SET(hr->storage, USER_LUKS, USER_DIRECTORY, USER_SUBVOLUME, USER_FSCRYPT, USER_CIFS))
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "User record has storage type this service cannot manage.");
 
        if (gid_is_valid(hr->gid) && hr->uid != (uid_t) hr->gid)
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "User record has to have matching UID/GID fields.");
 
        if (hr->service && !streq(hr->service, "io.systemd.Home"))
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Not accepted with service not matching io.systemd.Home.");
 
        if (hr->blob_directory) {
                /* This function is always called w/o binding section, so if hr->blob_dir is set then the caller set it themselves */
                assert((hr->mask & USER_RECORD_BINDING) == 0);
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot manage custom blob directories.");
        }
 
        if (sd_json_variant_by_key(hr->json, HOMEWORK_BLOB_FDMAP_FIELD))
                return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "User record contains unsafe internal fields.");
 
        return 0;
}
 
bool user_record_shall_rebalance(UserRecord *h) {
        assert(h);
 
        if (user_record_rebalance_weight(h) == REBALANCE_WEIGHT_OFF)
                return false;
 
        if (user_record_storage(h) != USER_LUKS)
                return false;
 
        if (!path_startswith(user_record_image_path(h), get_home_root())) /* This is the only pool we rebalance in */
                return false;
 
        return true;
}
 
int user_record_set_rebalance_weight(UserRecord *h, uint64_t weight) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_per_machine_array = NULL, *machine_id_variant = NULL,
                *machine_id_array = NULL, *per_machine_entry = NULL;
        _cleanup_free_ sd_json_variant **array = NULL;
        size_t idx = SIZE_MAX, n;
        sd_json_variant *per_machine;
        sd_id128_t mid;
        int r;
 
        assert(h);
 
        if (!h->json)
                return -EUNATCH;
 
        r = sd_id128_get_machine(&mid);
        if (r < 0)
                return r;
 
        r = sd_json_variant_new_id128(&machine_id_variant, mid);
        if (r < 0)
                return r;
 
        r = sd_json_variant_new_array(&machine_id_array, (sd_json_variant*[]) { machine_id_variant }, 1);
        if (r < 0)
                return r;
 
        per_machine = sd_json_variant_by_key(h->json, "perMachine");
        if (per_machine) {
                if (!sd_json_variant_is_array(per_machine))
                        return -EINVAL;
 
                n = sd_json_variant_elements(per_machine);
 
                array = new(sd_json_variant*, n + 1);
                if (!array)
                        return -ENOMEM;
 
                for (size_t i = 0; i < n; i++) {
                        sd_json_variant *m;
 
                        array[i] = sd_json_variant_by_index(per_machine, i);
 
                        if (!sd_json_variant_is_object(array[i]))
                                return -EINVAL;
 
                        m = sd_json_variant_by_key(array[i], "matchMachineId");
                        if (!m) {
                                /* No machineId field? Let's ignore this, but invalidate what we found so far */
                                idx = SIZE_MAX;
                                continue;
                        }
 
                        if (sd_json_variant_equal(m, machine_id_variant) ||
                            sd_json_variant_equal(m, machine_id_array)) {
                                /* Matches exactly what we are looking for. Let's use this */
                                idx = i;
                                continue;
                        }
 
                        r = per_machine_id_match(m, SD_JSON_PERMISSIVE);
                        if (r < 0)
                                return r;
                        if (r > 0)
                                /* Also matches what we are looking for, but with a broader match. In this
                                 * case let's ignore this entry, and add a new specific one to the end. */
                                idx = SIZE_MAX;
                }
 
                if (idx == SIZE_MAX)
                        idx = n++; /* Nothing suitable found, place new entry at end */
                else
                        per_machine_entry = sd_json_variant_ref(array[idx]);
 
        } else {
                array = new(sd_json_variant*, 1);
                if (!array)
                        return -ENOMEM;
 
                idx = 0;
                n = 1;
        }
 
        if (!per_machine_entry) {
                r = sd_json_variant_set_field(&per_machine_entry, "matchMachineId", machine_id_array);
                if (r < 0)
                        return r;
        }
 
        if (weight == REBALANCE_WEIGHT_UNSET)
                r = sd_json_variant_set_field(&per_machine_entry, "rebalanceWeight", NULL); /* set explicitly to NULL (so that the perMachine setting we are setting here can override the global setting) */
        else
                r = sd_json_variant_set_field_unsigned(&per_machine_entry, "rebalanceWeight", weight);
        if (r < 0)
                return r;
 
        assert(idx < n);
        array[idx] = per_machine_entry;
 
        r = sd_json_variant_new_array(&new_per_machine_array, array, n);
        if (r < 0)
                return r;
 
        r = sd_json_variant_set_field(&h->json, "perMachine", new_per_machine_array);
        if (r < 0)
                return r;
 
        h->rebalance_weight = weight;
        h->mask |= USER_RECORD_PER_MACHINE;
        return 0;
}
 
int user_record_ensure_blob_manifest(UserRecord *h, Hashmap *blobs, const char **ret_failed) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        _cleanup_hashmap_free_ Hashmap *manifest = NULL;
        const char *filename;
        void *key, *value;
        uint64_t total_size = 0;
        int r;
 
        assert(h);
        assert(h->json);
        assert(blobs);
        assert(ret_failed);
 
        /* Ensures that blobManifest exists (possibly creating it using the
         * contents of blobs), and that the set of keys in both hashmaps are
         * exactly the same. If it fails to handle one blob file, the filename
         * is put it ret_failed for nicer error reporting. ret_failed is a pointer
         * to the same memory blobs uses to store its keys, so it is valid for
         * as long as blobs is valid and the corresponding key isn't removed! */
 
        if (h->blob_manifest) {
                /* blobManifest already exists. In this case we verify
                 * that the sets of keys are equal and that's it */
 
                HASHMAP_FOREACH_KEY(value, key, h->blob_manifest)
                        if (!hashmap_contains(blobs, key))
                                return -EINVAL;
                HASHMAP_FOREACH_KEY(value, key, blobs)
                        if (!hashmap_contains(h->blob_manifest, key))
                                return -EINVAL;
 
                return 0;
        }
 
        /* blobManifest doesn't exist, so we need to create it */
 
        HASHMAP_FOREACH_KEY(value, filename, blobs) {
                _cleanup_free_ char *filename_dup = NULL;
                _cleanup_free_ uint8_t *hash = NULL;
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *hash_json = NULL;
                int fd = PTR_TO_FD(value);
                off_t initial, size;
 
                *ret_failed = filename;
 
                filename_dup = strdup(filename);
                if (!filename_dup)
                        return -ENOMEM;
 
                hash = malloc(SHA256_DIGEST_SIZE);
                if (!hash)
                        return -ENOMEM;
 
                initial = lseek(fd, 0, SEEK_CUR);
                if (initial < 0)
                        return -errno;
 
                r = sha256_fd(fd, BLOB_DIR_MAX_SIZE, hash);
                if (r < 0)
                        return r;
 
                size = lseek(fd, 0, SEEK_CUR);
                if (size < 0)
                        return -errno;
                if (!DEC_SAFE(&size, initial))
                        return -EOVERFLOW;
 
                if (!INC_SAFE(&total_size, size))
                        total_size = UINT64_MAX;
                if (total_size > BLOB_DIR_MAX_SIZE)
                        return -EFBIG;
 
                if (lseek(fd, initial, SEEK_SET) < 0)
                        return -errno;
 
                r = sd_json_variant_new_hex(&hash_json, hash, SHA256_DIGEST_SIZE);
                if (r < 0)
                        return r;
 
                r = hashmap_ensure_put(&manifest, &path_hash_ops_free_free, filename_dup, hash);
                if (r < 0)
                        return r;
                TAKE_PTR(filename_dup); /* Ownership transfers to hashmap */
                TAKE_PTR(hash);
 
                r = sd_json_variant_set_field(&v, filename, hash_json);
                if (r < 0)
                        return r;
 
                *ret_failed = NULL;
        }
 
        r = json_variant_set_field_non_null(&h->json, "blobManifest", v);
        if (r < 0)
                return r;
 
        h->blob_manifest = TAKE_PTR(manifest);
        return 0;
}