HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/user-record.c

140,494 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 16e95463613a25f4c3d006f84f47bc70aa4392a2

Lines 2001–2961 of 2,961

        assert(h);
 
        /* We return a value here that can be cast without loss into size_t which is what libcrypsetup expects */
 
        if (h->luks_volume_key_size == UINT64_MAX)
                return 256 / 8;
 
        return MIN(h->luks_volume_key_size, SIZE_MAX);
}
 
const char* user_record_luks_pbkdf_type(UserRecord *h) {
        assert(h);
 
        return h->luks_pbkdf_type ?: "argon2id";
}
 
uint64_t user_record_luks_pbkdf_force_iterations(UserRecord *h) {
        assert(h);
 
        /* propagate default "benchmark" mode as itself */
        if (h->luks_pbkdf_force_iterations == UINT64_MAX)
                return UINT64_MAX;
 
        /* clamp everything else to actually accepted number of iterations of libcryptsetup */
        return CLAMP(h->luks_pbkdf_force_iterations, 1U, UINT32_MAX);
}
 
uint64_t user_record_luks_pbkdf_time_cost_usec(UserRecord *h) {
        assert(h);
 
        /* Returns a value with ms granularity, since that's what libcryptsetup expects */
 
        if (h->luks_pbkdf_time_cost_usec == UINT64_MAX)
                return 500 * USEC_PER_MSEC; /* We default to 500ms, in contrast to libcryptsetup's 2s, which is just awfully slow on every login */
 
        return MIN(DIV_ROUND_UP(h->luks_pbkdf_time_cost_usec, USEC_PER_MSEC), UINT32_MAX) * USEC_PER_MSEC;
}
 
uint64_t user_record_luks_pbkdf_memory_cost(UserRecord *h) {
        assert(h);
 
        /* Returns a value with kb granularity, since that's what libcryptsetup expects */
        if (h->luks_pbkdf_memory_cost == UINT64_MAX)
                return streq(user_record_luks_pbkdf_type(h), "pbkdf2") ? 0 : /* doesn't apply for simple pbkdf2 */
                        64*1024*1024; /* We default to 64M, since this should work on smaller systems too */
 
        return MIN(DIV_ROUND_UP(h->luks_pbkdf_memory_cost, 1024), UINT32_MAX) * 1024;
}
 
uint64_t user_record_luks_pbkdf_parallel_threads(UserRecord *h) {
        assert(h);
 
        if (h->luks_pbkdf_parallel_threads == UINT64_MAX)
                return streq(user_record_luks_pbkdf_type(h), "pbkdf2") ? 0 : /* doesn't apply for simple pbkdf2 */
                        1; /* We default to 1, since this should work on smaller systems too */
 
        return MIN(h->luks_pbkdf_parallel_threads, UINT32_MAX);
}
 
uint64_t user_record_luks_sector_size(UserRecord *h) {
        assert(h);
 
        if (h->luks_sector_size == UINT64_MAX)
                return 512;
 
        /* Allow up to 4K due to dm-crypt support and 4K alignment by the homed LUKS backend */
        return CLAMP(UINT64_C(1) << (63 - __builtin_clzll(h->luks_sector_size)), 512U, 4096U);
}
 
const char* user_record_luks_pbkdf_hash_algorithm(UserRecord *h) {
        assert(h);
 
        return h->luks_pbkdf_hash_algorithm ?: "sha512";
}
 
gid_t user_record_gid(UserRecord *h) {
        assert(h);
 
        if (gid_is_valid(h->gid))
                return h->gid;
 
        return (gid_t) h->uid;
}
 
UserDisposition user_record_disposition(UserRecord *h) {
        assert(h);
 
        if (h->disposition >= 0)
                return h->disposition;
 
        /* If not declared, derive from UID */
 
        if (!uid_is_valid(h->uid))
                return _USER_DISPOSITION_INVALID;
 
        if (user_record_is_root(h) || user_record_is_nobody(h))
                return USER_INTRINSIC;
 
        if (uid_is_system(h->uid))
                return USER_SYSTEM;
 
        if (uid_is_dynamic(h->uid) || uid_is_greeter(h->uid))
                return USER_DYNAMIC;
 
        if (uid_is_container(h->uid))
                return USER_CONTAINER;
 
        if (uid_is_foreign(h->uid))
                return USER_FOREIGN;
 
        if (h->uid > INT32_MAX)
                return USER_RESERVED;
 
        return USER_REGULAR;
}
 
int user_record_removable(UserRecord *h) {
        UserStorage storage;
        assert(h);
 
        if (h->removable >= 0)
                return h->removable;
 
        /* Refuse to decide for classic records */
        storage = user_record_storage(h);
        if (h->storage < 0 || h->storage == USER_CLASSIC)
                return -1;
 
        /* For now consider only LUKS home directories with a reference by path as removable */
        return storage == USER_LUKS && user_record_image_is_blockdev(h);
}
 
uint64_t user_record_ratelimit_interval_usec(UserRecord *h) {
        assert(h);
 
        if (h->ratelimit_interval_usec == UINT64_MAX)
                return DEFAULT_RATELIMIT_INTERVAL_USEC;
 
        return h->ratelimit_interval_usec;
}
 
uint64_t user_record_ratelimit_burst(UserRecord *h) {
        assert(h);
 
        if (h->ratelimit_burst == UINT64_MAX)
                return DEFAULT_RATELIMIT_BURST;
 
        return h->ratelimit_burst;
}
 
bool user_record_can_authenticate(UserRecord *h) {
        assert(h);
 
        /* Returns true if there's some form of property configured that the user can authenticate against */
 
        if (h->n_pkcs11_encrypted_key > 0)
                return true;
 
        if (h->n_fido2_hmac_salt > 0)
                return true;
 
        return !strv_isempty(h->hashed_password);
}
 
bool user_record_drop_caches(UserRecord *h) {
        assert(h);
 
        if (h->drop_caches >= 0)
                return h->drop_caches;
 
        /* By default drop caches on fscrypt, not otherwise. */
        return user_record_storage(h) == USER_FSCRYPT;
}
 
AutoResizeMode user_record_auto_resize_mode(UserRecord *h) {
        assert(h);
 
        if (h->auto_resize_mode >= 0)
                return h->auto_resize_mode;
 
        return user_record_storage(h) == USER_LUKS ? AUTO_RESIZE_SHRINK_AND_GROW : AUTO_RESIZE_OFF;
}
 
uint64_t user_record_rebalance_weight(UserRecord *h) {
        assert(h);
 
        if (h->rebalance_weight == REBALANCE_WEIGHT_UNSET)
                return REBALANCE_WEIGHT_DEFAULT;
 
        return h->rebalance_weight;
}
 
static uint64_t parse_caps_strv(char **l) {
        uint64_t c = 0;
        int r;
 
        STRV_FOREACH(i, l) {
                r = capability_from_name(*i);
                if (r < 0)
                        log_debug_errno(r, "Don't know capability '%s', ignoring: %m", *i);
                else
                        c |= UINT64_C(1) << r;
        }
 
        return c;
}
 
uint64_t user_record_capability_bounding_set(UserRecord *h) {
        assert(h);
 
        /* Returns UINT64_MAX if no bounding set is configured (!) */
 
        if (!h->capability_bounding_set)
                return UINT64_MAX;
 
        return parse_caps_strv(h->capability_bounding_set);
}
 
uint64_t user_record_capability_ambient_set(UserRecord *h) {
        assert(h);
 
        /* Returns UINT64_MAX if no ambient set is configured (!) */
 
        if (!h->capability_ambient_set)
                return UINT64_MAX;
 
        return parse_caps_strv(h->capability_ambient_set) & user_record_capability_bounding_set(h);
}
 
int user_record_languages(UserRecord *h, char ***ret) {
        _cleanup_strv_free_ char **l = NULL;
        int r;
 
        assert(h);
        assert(ret);
 
        if (h->preferred_language) {
                l = strv_new(h->preferred_language);
                if (!l)
                        return -ENOMEM;
        }
 
        r = strv_extend_strv(&l, h->additional_languages, /* filter_duplicates= */ true);
        if (r < 0)
                return r;
 
        *ret = TAKE_PTR(l);
        return 0;
}
 
uint32_t user_record_tmp_limit_scale(UserRecord *h) {
        assert(h);
 
        if (h->tmp_limit.is_set)
                return h->tmp_limit.limit_scale;
 
        /* By default grant regular users only 80% quota */
        if (user_record_disposition(h) == USER_REGULAR)
                return UINT32_SCALE_FROM_PERCENT(80);
 
        return UINT32_MAX;
}
 
uint32_t user_record_dev_shm_limit_scale(UserRecord *h) {
        assert(h);
 
        if (h->dev_shm_limit.is_set)
                return h->dev_shm_limit.limit_scale;
 
        /* By default grant regular users only 80% quota */
        if (user_record_disposition(h) == USER_REGULAR)
                return UINT32_SCALE_FROM_PERCENT(80);
 
        return UINT32_MAX;
}
 
const char** user_record_self_modifiable_fields(UserRecord *h) {
        /* As a rule of thumb: a setting is safe if it cannot be used by a
         * user to give themselves some unfair advantage over other users on
         * a given system. */
        static const char *const default_fields[] = {
                /* For display purposes */
                "realName",
                "emailAddress", /* Just the $EMAIL env var */
                "iconName",
                "location",
 
                /* Basic account settings */
                "shell",
                "umask",
                "environment",
                "timeZone",
                "preferredLanguage",
                "additionalLanguages",
                "preferredSessionLauncher",
                "preferredSessionType",
                "defaultArea",
 
                /* Authentication methods */
                "pkcs11TokenUri",
                "fido2HmacCredential",
                "recoveryKeyType",
 
                "lastChangeUSec", /* Necessary to be able to change record at all */
                "lastPasswordChangeUSec", /* Ditto, but for authentication methods */
                NULL
        };
 
        assert(h);
 
        /* Note: if the self_modifiable_fields field in UserRecord is NULL we'll apply a default, if we have
         * one. If it is a non-NULL empty strv, we'll report it as explicit empty list. When the field is
         * NULL and we have no default list we'll return NULL. */
 
        /* Note that we intentionally distinguish between NULL and an empty array here */
        if (h->self_modifiable_fields)
                return (const char**) h->self_modifiable_fields;
 
        return user_record_disposition(h) == USER_REGULAR ? (const char**) default_fields : NULL;
}
 
const char** user_record_self_modifiable_blobs(UserRecord *h) {
        static const char *const default_blobs[] = {
                /* For display purposes */
                "avatar",
                "login-background",
                NULL
        };
 
        assert(h);
 
        /* Note that we intentionally distinguish between NULL and an empty array here */
        if (h->self_modifiable_blobs)
                return (const char**) h->self_modifiable_blobs;
 
        return user_record_disposition(h) == USER_REGULAR ? (const char**) default_blobs : NULL;
}
 
const char** user_record_self_modifiable_privileged(UserRecord *h) {
        static const char *const default_fields[] = {
                /* For display purposes */
                "passwordHint",
 
                /* Authentication methods */
                "hashedPassword",
                "pkcs11EncryptedKey",
                "fido2HmacSalt",
                "recoveryKey",
 
                "sshAuthorizedKeys", /* Basically just ~/.ssh/authorized_keys */
                NULL
        };
 
        assert(h);
 
        /* Note that we intentionally distinguish between NULL and an empty array here */
        if (h->self_modifiable_privileged)
                return (const char**) h->self_modifiable_privileged;
 
        return user_record_disposition(h) == USER_REGULAR ? (const char**) default_fields : NULL;
}
 
static int remove_self_modifiable_json_fields_common(UserRecord *current, sd_json_variant **target) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *blobs = NULL;
        char **allowed;
        int r;
 
        assert(current);
        assert(target);
 
        if (!sd_json_variant_is_object(*target))
                return -EINVAL;
 
        v = sd_json_variant_ref(*target);
 
        /* Handle basic fields */
        allowed = (char**) user_record_self_modifiable_fields(current);
        r = sd_json_variant_filter(&v, allowed);
        if (r < 0)
                return r;
 
        /* Handle blobs */
        blobs = sd_json_variant_ref(sd_json_variant_by_key(v, "blobManifest"));
        if (blobs) {
                /* The blobManifest contains the sha256 hashes of the blobs,
                 * which are enforced by the service managing the user. So, by
                 * comparing the blob manifests like this, we're actually comparing
                 * the contents of the blob directories & files */
 
                allowed = (char**) user_record_self_modifiable_blobs(current);
                r = sd_json_variant_filter(&blobs, allowed);
                if (r < 0)
                        return r;
 
                if (sd_json_variant_is_blank_object(blobs))
                        r = sd_json_variant_filter(&v, STRV_MAKE("blobManifest"));
                else
                        r = sd_json_variant_set_field(&v, "blobManifest", blobs);
                if (r < 0)
                        return r;
        }
 
        return json_variant_unref_and_replace(*target, v);
}
 
static int remove_self_modifiable_json_fields(UserRecord *current, UserRecord *h, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL, *privileged = NULL;
        sd_json_variant *per_machine;
        char **allowed;
        int r;
 
        assert(current);
        assert(h);
        assert(ret);
 
        r = user_group_record_mangle(h->json, USER_RECORD_EXTRACT_SIGNABLE|USER_RECORD_PERMISSIVE, &v, NULL);
        if (r < 0)
                return r;
 
        /* Handle the regular section */
        r = remove_self_modifiable_json_fields_common(current, &v);
        if (r < 0)
                return r;
 
        /* Handle the perMachine section */
        per_machine = sd_json_variant_by_key(v, "perMachine");
        if (per_machine) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *new_per_machine = NULL;
                sd_json_variant *e;
 
                if (!sd_json_variant_is_array(per_machine))
                        return -EINVAL;
 
                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;
 
                        r = per_machine_match(e, 0);
                        if (r < 0)
                                return r;
                        if (r == 0) {
                                /* It's only permissible to change anything inside of matching perMachine sections */
                                r = sd_json_variant_append_array(&new_per_machine, e);
                                if (r < 0)
                                        return r;
                                continue;
                        }
 
                        z = sd_json_variant_ref(e);
 
                        r = remove_self_modifiable_json_fields_common(current, &z);
                        if (r < 0)
                                return r;
 
                        if (!sd_json_variant_is_blank_object(z)) {
                                r = sd_json_variant_append_array(&new_per_machine, z);
                                if (r < 0)
                                        return r;
                        }
                }
 
                if (sd_json_variant_is_blank_array(new_per_machine))
                        r = sd_json_variant_filter(&v, STRV_MAKE("perMachine"));
                else
                        r = sd_json_variant_set_field(&v, "perMachine", new_per_machine);
                if (r < 0)
                        return r;
        }
 
        /* Handle the privileged section */
        privileged = sd_json_variant_ref(sd_json_variant_by_key(v, "privileged"));
        if (privileged) {
                allowed = (char**) user_record_self_modifiable_privileged(current);
                r = sd_json_variant_filter(&privileged, allowed);
                if (r < 0)
                        return r;
 
                if (sd_json_variant_is_blank_object(privileged))
                        r = sd_json_variant_filter(&v, STRV_MAKE("privileged"));
                else
                        r = sd_json_variant_set_field(&v, "privileged", privileged);
                if (r < 0)
                        return r;
        }
 
        return json_variant_unref_and_replace(*ret, v);
}
 
int user_record_self_changes_allowed(UserRecord *current, UserRecord *incoming) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *vc = NULL, *vi = NULL;
        int r;
 
        assert(current);
        assert(incoming);
 
        /* We remove the fields that the user is allowed to change and then
         * compare the resulting JSON records. If they are not equal, that
         * means a disallowed field has been changed and thus we should
         * require administrator permission to apply the changes. */
 
        r = remove_self_modifiable_json_fields(current, current, &vc);
        if (r < 0)
                return r;
 
        /* Note that we use `current` as the source of the allowlist, and not
         * `incoming`. This prevents the user from adding fields. Consider a
         * scenario that would've been possible if we had messed up this check:
         *
         * 1) A user starts out with no group memberships and no custom allowlist.
         *    Thus, this user is not an administrator, and the `memberOf` and
         *    `selfModifiableFields` fields are unset in their record.
         * 2) This user crafts a request to add the following to their record:
         *    { "memberOf": ["wheel"], "selfModifiableFields": ["memberOf", "selfModifiableFields"] }
         * 3) We remove the `memberOf` and `selfModifiabileFields` fields from `incoming`
         * 4) `current` and `incoming` compare as equal, so we let the change happen
         * 5) the user has granted themselves administrator privileges
         */
        r = remove_self_modifiable_json_fields(current, incoming, &vi);
        if (r < 0)
                return r;
 
        return sd_json_variant_equal(vc, vi);
}
 
uint64_t user_record_ratelimit_next_try(UserRecord *h) {
        assert(h);
 
        /* Calculates when the it's possible to login next. Returns:
         *
         * UINT64_MAX → Nothing known
         * 0          → Right away
         * Any other  → Next time in CLOCK_REALTIME in usec (which could be in the past)
         */
 
        if (h->ratelimit_begin_usec == UINT64_MAX ||
            h->ratelimit_count == UINT64_MAX)
                return UINT64_MAX;
 
        if (h->ratelimit_begin_usec > now(CLOCK_REALTIME)) /* If the ratelimit time is in the future, then
                                                            * the local clock is probably incorrect. Let's
                                                            * not refuse login then. */
                return UINT64_MAX;
 
        if (h->ratelimit_count < user_record_ratelimit_burst(h))
                return 0;
 
        return usec_add(h->ratelimit_begin_usec, user_record_ratelimit_interval_usec(h));
}
 
bool user_record_equal(UserRecord *a, UserRecord *b) {
        assert(a);
        assert(b);
 
        /* We assume that when a record is modified its JSON data is updated at the same time, hence it's
         * sufficient to compare the JSON data. */
 
        return sd_json_variant_equal(a->json, b->json);
}
 
bool user_record_compatible(UserRecord *a, UserRecord *b) {
        assert(a);
        assert(b);
 
        /* If either lacks the regular section, we can't really decide, let's hence say they are
         * incompatible. */
        if (!(a->mask & b->mask & USER_RECORD_REGULAR))
                return false;
 
        return streq_ptr(a->user_name, b->user_name) &&
                streq_ptr(a->realm, b->realm);
}
 
int user_record_compare_last_change(UserRecord *a, UserRecord *b) {
        assert(a);
        assert(b);
 
        if (a->last_change_usec == b->last_change_usec)
                return 0;
 
        /* Always consider a record with a timestamp newer than one without */
        if (a->last_change_usec == UINT64_MAX)
                return -1;
        if (b->last_change_usec == UINT64_MAX)
                return 1;
 
        return CMP(a->last_change_usec, b->last_change_usec);
}
 
int user_record_clone(UserRecord *h, UserRecordLoadFlags flags, UserRecord **ret) {
        _cleanup_(user_record_unrefp) UserRecord *c = NULL;
        int r;
 
        assert(h);
        assert(ret);
 
        c = user_record_new();
        if (!c)
                return -ENOMEM;
 
        r = user_record_load(c, h->json, flags);
        if (r < 0)
                return r;
 
        *ret = TAKE_PTR(c);
        return 0;
}
 
int user_record_masked_equal(UserRecord *a, UserRecord *b, UserRecordMask mask) {
        _cleanup_(user_record_unrefp) UserRecord *x = NULL, *y = NULL;
        int r;
 
        assert(a);
        assert(b);
 
        /* Compares the two records, but ignores anything not listed in the specified mask */
 
        if ((a->mask & ~mask) != 0) {
                r = user_record_clone(a, USER_RECORD_ALLOW(mask) | USER_RECORD_STRIP(~mask & _USER_RECORD_MASK_MAX) | USER_RECORD_PERMISSIVE, &x);
                if (r < 0)
                        return r;
 
                a = x;
        }
 
        if ((b->mask & ~mask) != 0) {
                r = user_record_clone(b, USER_RECORD_ALLOW(mask) | USER_RECORD_STRIP(~mask & _USER_RECORD_MASK_MAX) | USER_RECORD_PERMISSIVE, &y);
                if (r < 0)
                        return r;
 
                b = y;
        }
 
        return user_record_equal(a, b);
}
 
int user_record_test_blocked(UserRecord *h) {
        usec_t n;
 
        /* Checks whether access to the specified user shall be allowed at the moment. Returns:
         *
         *          -ESTALE: Record is from the future
         *          -ENOLCK: Record is blocked
         *          -EL2HLT: Record is not valid yet
         *          -EL3HLT: Record is not valid anymore
         *
         */
 
        assert(h);
 
        if (h->locked > 0)
                return -ENOLCK;
 
        n = now(CLOCK_REALTIME);
 
        if (h->not_before_usec != UINT64_MAX && n < h->not_before_usec)
                return -EL2HLT;
        if (h->not_after_usec != UINT64_MAX && n > h->not_after_usec)
                return -EL3HLT;
 
        if (h->last_change_usec != UINT64_MAX &&
            h->last_change_usec > n) /* Complain during log-ins when the record is from the future */
                return -ESTALE;
 
        return 0;
}
 
int user_record_test_password_change_required(UserRecord *h) {
        bool change_permitted;
        usec_t n;
 
        assert(h);
 
        /* Checks whether the user must change the password when logging in
 
            -EKEYREVOKED: Change password now because admin said so
             -EOWNERDEAD: Change password now because it expired
           -EKEYREJECTED: Password is expired, no changing is allowed
            -EKEYEXPIRED: Password is about to expire, warn user
               -ENETDOWN: Record has expiration info but no password change timestamp
                  -EROFS: No password change required nor permitted
                 -ESTALE: RTC likely incorrect, last password change is in the future
                       0: No password change required, but permitted
         */
 
        /* If a password change request has been set explicitly, it overrides everything */
        if (h->password_change_now > 0)
                return -EKEYREVOKED;
 
        n = now(CLOCK_REALTIME);
 
        /* Password change in the future? Then our RTC is likely incorrect */
        if (h->last_password_change_usec != UINT64_MAX &&
            h->last_password_change_usec > n &&
            (h->password_change_min_usec != UINT64_MAX ||
             h->password_change_max_usec != UINT64_MAX ||
             h->password_change_inactive_usec != UINT64_MAX))
            return -ESTALE;
 
        /* Then, let's check if password changing is currently allowed at all */
        if (h->password_change_min_usec != UINT64_MAX) {
 
                /* Expiry configured but no password change timestamp known? */
                if (h->last_password_change_usec == UINT64_MAX)
                        return -ENETDOWN;
 
                if (h->password_change_min_usec >= UINT64_MAX - h->last_password_change_usec)
                        change_permitted = false;
                else
                        change_permitted = n >= h->last_password_change_usec + h->password_change_min_usec;
 
        } else
                change_permitted = true;
 
        /* Let's check whether the password has expired.  */
        if (!(h->password_change_max_usec == UINT64_MAX ||
              h->password_change_max_usec >= UINT64_MAX - h->last_password_change_usec)) {
 
                uint64_t change_before;
 
                /* Expiry configured but no password change timestamp known? */
                if (h->last_password_change_usec == UINT64_MAX)
                        return -ENETDOWN;
 
                /* Password is in inactive phase? */
                if (h->password_change_inactive_usec != UINT64_MAX &&
                    h->password_change_inactive_usec < UINT64_MAX - h->password_change_max_usec) {
                        usec_t added;
 
                        added = h->password_change_inactive_usec + h->password_change_max_usec;
                        if (added < UINT64_MAX - h->last_password_change_usec &&
                            n >= h->last_password_change_usec + added)
                                return -EKEYREJECTED;
                }
 
                /* Password needs to be changed now? */
                change_before = h->last_password_change_usec + h->password_change_max_usec;
                if (n >= change_before)
                        return change_permitted ? -EOWNERDEAD : -EKEYREJECTED;
 
                /* Warn user? */
                if (h->password_change_warn_usec != UINT64_MAX &&
                    (change_before < h->password_change_warn_usec ||
                     n >= change_before - h->password_change_warn_usec))
                        return change_permitted ? -EKEYEXPIRED : -EROFS;
        }
 
        /* No password changing necessary */
        return change_permitted ? 0 : -EROFS;
}
 
bool user_record_is_root(const UserRecord *u) {
        assert(u);
 
        return u->uid == 0 || streq_ptr(u->user_name, "root");
}
 
bool user_record_is_nobody(const UserRecord *u) {
        assert(u);
 
        return u->uid == UID_NOBODY || STRPTR_IN_SET(u->user_name, NOBODY_USER_NAME, "nobody");
}
 
bool user_record_matches_user_name(const UserRecord *u, const char *user_name) {
        assert(u);
        assert(user_name);
 
        if (streq_ptr(u->user_name, user_name))
                return true;
 
        if (streq_ptr(u->user_name_and_realm_auto, user_name))
                return true;
 
        if (strv_contains(u->aliases, user_name))
                return true;
 
        if (record_name_matches_alias_realm(user_name, (char * const*) u->aliases, u->realm))
                return true;
 
        return false;
}
 
bool record_name_matches_alias_realm(const char *name, char * const *aliases, const char *realm) {
        const char *suffix;
 
        assert(name);
 
        suffix = strrchr(name, '@');
        if (!suffix || !streq_ptr(suffix + 1, realm))
                return false;
 
        STRV_FOREACH(a, aliases)
                if (startswith(name, *a) == suffix)
                        return true;
 
        return false;
}
 
int suitable_blob_filename(const char *name) {
        /* Enforces filename requirements as described in docs/USER_RECORD_BULK_DIRS.md */
        return filename_is_valid(name) &&
               in_charset(name, URI_UNRESERVED) &&
               name[0] != '.';
}
 
bool userdb_match_is_set(const UserDBMatch *match) {
        if (!match)
                return false;
 
        return !strv_isempty(match->fuzzy_names) ||
                !FLAGS_SET(match->disposition_mask, USER_DISPOSITION_MASK_ALL) ||
                match->uid_min > 0 ||
                match->uid_max < UID_INVALID-1 ||
                !sd_id128_is_null(match->uuid);
}
 
void userdb_match_done(UserDBMatch *match) {
        assert(match);
        strv_free(match->fuzzy_names);
}
 
bool user_name_fuzzy_match(const char *names[], size_t n_names, char **matches) {
        assert(names || n_names == 0);
 
        /* Checks if any of the user record strings in the names[] array matches any of the search strings in
         * the matches** strv fuzzily. */
 
        FOREACH_ARRAY(n, names, n_names) {
                if (!*n)
                        continue;
 
                _cleanup_free_ char *lcn = strdup(*n);
                if (!lcn)
                        return -ENOMEM;
 
                ascii_strlower(lcn);
 
                STRV_FOREACH(i, matches) {
                        _cleanup_free_ char *lc = strdup(*i);
                        if (!lc)
                                return -ENOMEM;
 
                        ascii_strlower(lc);
 
                        /* First do substring check */
                        if (strstr(lcn, lc))
                                return true;
 
                        /* Then do some fuzzy string comparison (but only if the needle is non-trivially long) */
                        if (strlen(lc) >= 5 && strlevenshtein(lcn, lc) < 3)
                                return true;
                }
        }
 
        return false;
}
 
bool user_record_match(UserRecord *u, const UserDBMatch *match) {
        assert(u);
 
        if (!match)
                return true;
 
        if (!uid_is_valid(u->uid))
                return false;
 
        if (u->uid < match->uid_min || u->uid > match->uid_max)
                return false;
 
        if (!BIT_SET(match->disposition_mask, user_record_disposition(u)))
                return false;
 
        if (!sd_id128_is_null(match->uuid) && !sd_id128_equal(match->uuid, u->uuid))
                return false;
 
        if (!strv_isempty(match->fuzzy_names)) {
 
                /* Note this array of names is sparse, i.e. various entries listed in it will be
                 * NULL. Because of that we are not using a NULL terminated strv here, but a regular
                 * array. */
                const char* names[] = {
                        u->user_name,
                        user_record_user_name_and_realm(u),
                        u->real_name,
                        u->email_address,
                        u->cifs_user_name,
                };
 
                if (!user_name_fuzzy_match(names, ELEMENTSOF(names), match->fuzzy_names) &&
                    !user_name_fuzzy_match((const char**) u->aliases, strv_length(u->aliases), match->fuzzy_names))
                        return false;
        }
 
        return true;
}
 
int json_dispatch_dispositions_mask(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        uint64_t *mask = ASSERT_PTR(userdata);
 
        if (sd_json_variant_is_null(variant)) {
                *mask = UINT64_MAX;
                return 0;
        }
 
        if (!sd_json_variant_is_array(variant))
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array.", strna(name));
 
        uint64_t m = 0;
        for (size_t i = 0; i < sd_json_variant_elements(variant); i++) {
                sd_json_variant *e;
                const char *a;
 
                e = sd_json_variant_by_index(variant, i);
                if (!sd_json_variant_is_string(e))
                        return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not an array of strings.", strna(name));
 
                assert_se(a = sd_json_variant_string(e));
 
                UserDisposition d = user_disposition_from_string(a);
                if (d < 0)
                        return json_log(e, flags, d, "JSON field '%s' contains an invalid user disposition type: %s", strna(name), a);
 
                m |= INDEX_TO_MASK(uint64_t, d);
        }
 
        *mask = m;
        return 0;
}
 
static const char* const user_storage_table[_USER_STORAGE_MAX] = {
        [USER_CLASSIC]   = "classic",
        [USER_LUKS]      = "luks",
        [USER_DIRECTORY] = "directory",
        [USER_SUBVOLUME] = "subvolume",
        [USER_FSCRYPT]   = "fscrypt",
        [USER_CIFS]      = "cifs",
};
 
DEFINE_STRING_TABLE_LOOKUP(user_storage, UserStorage);
 
static const char* const user_disposition_table[_USER_DISPOSITION_MAX] = {
        [USER_INTRINSIC] = "intrinsic",
        [USER_SYSTEM]    = "system",
        [USER_DYNAMIC]   = "dynamic",
        [USER_REGULAR]   = "regular",
        [USER_CONTAINER] = "container",
        [USER_FOREIGN]   = "foreign",
        [USER_RESERVED]  = "reserved",
};
 
DEFINE_STRING_TABLE_LOOKUP(user_disposition, UserDisposition);
 
static const char* const auto_resize_mode_table[_AUTO_RESIZE_MODE_MAX] = {
        [AUTO_RESIZE_OFF]             = "off",
        [AUTO_RESIZE_GROW]            = "grow",
        [AUTO_RESIZE_SHRINK_AND_GROW] = "shrink-and-grow",
};
 
DEFINE_STRING_TABLE_LOOKUP(auto_resize_mode, AutoResizeMode);