HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/home/user-record-util.c
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;
}