src/home/homework-fscrypt.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <linux/fs.h>
   4 #include <openssl/evp.h>
   5 #include <openssl/sha.h>
   6 #include <sys/ioctl.h>
   7 #include <sys/xattr.h>
   8
   9 #include "errno-util.h"
  10 #include "fd-util.h"
  11 #include "hexdecoct.h"
  12 #include "homework-fscrypt.h"
  13 #include "homework-mount.h"
  14 #include "homework-quota.h"
  15 #include "memory-util.h"
  16 #include "missing_keyctl.h"
  17 #include "missing_syscall.h"
  18 #include "mkdir.h"
  19 #include "mount-util.h"
  20 #include "nulstr-util.h"
  21 #include "openssl-util.h"
  22 #include "parse-util.h"
  23 #include "process-util.h"
  24 #include "random-util.h"
  25 #include "rm-rf.h"
  26 #include "stdio-util.h"
  27 #include "strv.h"
  28 #include "tmpfile-util.h"
  29 #include "user-util.h"
  30 #include "xattr-util.h"
  31
  32 static int fscrypt_upload_volume_key(
  33                 const uint8_t key_descriptor[static FS_KEY_DESCRIPTOR_SIZE],
  34                 const void *volume_key,
  35                 size_t volume_key_size,
  36                 key_serial_t where) {
  37
  38         _cleanup_free_ char *hex = NULL;
  39         const char *description;
  40         struct fscrypt_key key;
  41         key_serial_t serial;
  42
  43         assert(key_descriptor);
  44         assert(volume_key);
  45         assert(volume_key_size > 0);
  46
  47         if (volume_key_size > sizeof(key.raw))
  48                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Volume key too long.");
  49
  50         hex = hexmem(key_descriptor, FS_KEY_DESCRIPTOR_SIZE);
  51         if (!hex)
  52                 return log_oom();
  53
  54         description = strjoina("fscrypt:", hex);
  55
  56         key = (struct fscrypt_key) {
  57                 .size = volume_key_size,
  58         };
  59         memcpy(key.raw, volume_key, volume_key_size);
  60
  61         /* Upload to the kernel */
  62         serial = add_key("logon", description, &key, sizeof(key), where);
  63         explicit_bzero_safe(&key, sizeof(key));
  64
  65         if (serial < 0)
  66                 return log_error_errno(errno, "Failed to install master key in keyring: %m");
  67
  68         log_info("Uploaded encryption key to kernel.");
  69
  70         return 0;
  71 }
  72
  73 static void calculate_key_descriptor(
  74                 const void *key,
  75                 size_t key_size,
  76                 uint8_t ret_key_descriptor[static FS_KEY_DESCRIPTOR_SIZE]) {
  77
  78         uint8_t hashed[512 / 8] = {}, hashed2[512 / 8] = {};
  79
  80         /* Derive the key descriptor from the volume key via double SHA512, in order to be compatible with e4crypt */
  81
  82         assert_se(SHA512(key, key_size, hashed) == hashed);
  83         assert_se(SHA512(hashed, sizeof(hashed), hashed2) == hashed2);
  84
  85         assert_cc(sizeof(hashed2) >= FS_KEY_DESCRIPTOR_SIZE);
  86
  87         memcpy(ret_key_descriptor, hashed2, FS_KEY_DESCRIPTOR_SIZE);
  88 }
  89
  90 static int fscrypt_slot_try_one(
  91                 const char *password,
  92                 const void *salt, size_t salt_size,
  93                 const void *encrypted, size_t encrypted_size,
  94                 const uint8_t match_key_descriptor[static FS_KEY_DESCRIPTOR_SIZE],
  95                 void **ret_decrypted, size_t *ret_decrypted_size) {
  96
  97
  98         _cleanup_(EVP_CIPHER_CTX_freep) EVP_CIPHER_CTX *context = NULL;
  99         _cleanup_(erase_and_freep) void *decrypted = NULL;
 100         uint8_t key_descriptor[FS_KEY_DESCRIPTOR_SIZE];
 101         int decrypted_size_out1, decrypted_size_out2;
 102         uint8_t derived[512 / 8] = {};
 103         size_t decrypted_size;
 104         const EVP_CIPHER *cc;
 105         int r;
 106
 107         assert(password);
 108         assert(salt);
 109         assert(salt_size > 0);
 110         assert(encrypted);
 111         assert(encrypted_size > 0);
 112         assert(match_key_descriptor);
 113
 114         /* Our construction is like this:
 115          *
 116          *   1. In each key slot we store a salt value plus the encrypted volume key
 117          *
 118          *   2. Unlocking is via calculating PBKDF2-HMAC-SHA512 of the supplied password (in combination with
 119          *      the salt), then using the first 256 bit of the hash as key for decrypting the encrypted
 120          *      volume key in AES256 counter mode.
 121          *
 122          *   3. Writing a password is similar: calculate PBKDF2-HMAC-SHA512 of the supplied password (in
 123          *      combination with the salt), then encrypt the volume key in AES256 counter mode with the
 124          *      resulting hash.
 125          */
 126
 127         if (PKCS5_PBKDF2_HMAC(
 128                             password, strlen(password),
 129                             salt, salt_size,
 130                             0xFFFF, EVP_sha512(),
 131                             sizeof(derived), derived) != 1) {
 132                 r = log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "PBKDF2 failed");
 133                 goto finish;
 134         }
 135
 136         context = EVP_CIPHER_CTX_new();
 137         if (!context) {
 138                 r = log_oom();
 139                 goto finish;
 140         }
 141
 142         /* We use AES256 in counter mode */
 143         assert_se(cc = EVP_aes_256_ctr());
 144
 145         /* We only use the first half of the derived key */
 146         assert(sizeof(derived) >= (size_t) EVP_CIPHER_key_length(cc));
 147
 148         if (EVP_DecryptInit_ex(context, cc, NULL, derived, NULL) != 1)  {
 149                 r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to initialize decryption context.");
 150                 goto finish;
 151         }
 152
 153         /* Flush out the derived key now, we don't need it anymore */
 154         explicit_bzero_safe(derived, sizeof(derived));
 155
 156         decrypted_size = encrypted_size + EVP_CIPHER_key_length(cc) * 2;
 157         decrypted = malloc(decrypted_size);
 158         if (!decrypted)
 159                 return log_oom();
 160
 161         if (EVP_DecryptUpdate(context, (uint8_t*) decrypted, &decrypted_size_out1, encrypted, encrypted_size) != 1)
 162                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to decrypt volume key.");
 163
 164         assert((size_t) decrypted_size_out1 <= decrypted_size);
 165
 166         if (EVP_DecryptFinal_ex(context, (uint8_t*) decrypted_size + decrypted_size_out1, &decrypted_size_out2) != 1)
 167                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to finish decryption of volume key.");
 168
 169         assert((size_t) decrypted_size_out1 + (size_t) decrypted_size_out2 < decrypted_size);
 170         decrypted_size = (size_t) decrypted_size_out1 + (size_t) decrypted_size_out2;
 171
 172         calculate_key_descriptor(decrypted, decrypted_size, key_descriptor);
 173
 174         if (memcmp(key_descriptor, match_key_descriptor, FS_KEY_DESCRIPTOR_SIZE) != 0)
 175                 return -ENOANO; /* don't log here */
 176
 177         r = fscrypt_upload_volume_key(key_descriptor, decrypted, decrypted_size, KEY_SPEC_THREAD_KEYRING);
 178         if (r < 0)
 179                 return r;
 180
 181         if (ret_decrypted)
 182                 *ret_decrypted = TAKE_PTR(decrypted);
 183         if (ret_decrypted_size)
 184                 *ret_decrypted_size = decrypted_size;
 185
 186         return 0;
 187
 188 finish:
 189         explicit_bzero_safe(derived, sizeof(derived));
 190         return r;
 191 }
 192
 193 static int fscrypt_slot_try_many(
 194                 char **passwords,
 195                 const void *salt, size_t salt_size,
 196                 const void *encrypted, size_t encrypted_size,
 197                 const uint8_t match_key_descriptor[static FS_KEY_DESCRIPTOR_SIZE],
 198                 void **ret_decrypted, size_t *ret_decrypted_size) {
 199
 200         int r;
 201
 202         STRV_FOREACH(i, passwords) {
 203                 r = fscrypt_slot_try_one(*i, salt, salt_size, encrypted, encrypted_size, match_key_descriptor, ret_decrypted, ret_decrypted_size);
 204                 if (r != -ENOANO)
 205                         return r;
 206         }
 207
 208         return -ENOANO;
 209 }
 210
 211 static int fscrypt_setup(
 212                 const PasswordCache *cache,
 213                 char **password,
 214                 HomeSetup *setup,
 215                 void **ret_volume_key,
 216                 size_t *ret_volume_key_size) {
 217
 218         _cleanup_free_ char *xattr_buf = NULL;
 219         int r;
 220
 221         assert(setup);
 222         assert(setup->root_fd >= 0);
 223
 224         r = flistxattr_malloc(setup->root_fd, &xattr_buf);
 225         if (r < 0)
 226                 return log_error_errno(errno, "Failed to retrieve xattr list: %m");
 227
 228         NULSTR_FOREACH(xa, xattr_buf) {
 229                 _cleanup_free_ void *salt = NULL, *encrypted = NULL;
 230                 _cleanup_free_ char *value = NULL;
 231                 size_t salt_size, encrypted_size;
 232                 const char *nr, *e;
 233                 char **list;
 234                 int n;
 235
 236                 /* Check if this xattr has the format 'trusted.fscrypt_slot<nr>' where '<nr>' is a 32bit unsigned integer */
 237                 nr = startswith(xa, "trusted.fscrypt_slot");
 238                 if (!nr)
 239                         continue;
 240                 if (safe_atou32(nr, NULL) < 0)
 241                         continue;
 242
 243                 n = fgetxattr_malloc(setup->root_fd, xa, &value);
 244                 if (n == -ENODATA) /* deleted by now? */
 245                         continue;
 246                 if (n < 0)
 247                         return log_error_errno(n, "Failed to read %s xattr: %m", xa);
 248
 249                 e = memchr(value, ':', n);
 250                 if (!e)
 251                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "xattr %s lacks ':' separator: %m", xa);
 252
 253                 r = unbase64mem(value, e - value, &salt, &salt_size);
 254                 if (r < 0)
 255                         return log_error_errno(r, "Failed to decode salt of %s: %m", xa);
 256                 r = unbase64mem(e+1, n - (e - value) - 1, &encrypted, &encrypted_size);
 257                 if (r < 0)
 258                         return log_error_errno(r, "Failed to decode encrypted key of %s: %m", xa);
 259
 260                 r = -ENOANO;
 261                 FOREACH_POINTER(list, cache->pkcs11_passwords, cache->fido2_passwords, password) {
 262                         r = fscrypt_slot_try_many(
 263                                         list,
 264                                         salt, salt_size,
 265                                         encrypted, encrypted_size,
 266                                         setup->fscrypt_key_descriptor,
 267                                         ret_volume_key, ret_volume_key_size);
 268                         if (r != -ENOANO)
 269                                 break;
 270                 }
 271                 if (r < 0) {
 272                         if (r != -ENOANO)
 273                                 return r;
 274                 } else
 275                         return 0;
 276         }
 277
 278         return log_error_errno(SYNTHETIC_ERRNO(ENOKEY), "Failed to set up home directory with provided passwords.");
 279 }
 280
 281 int home_setup_fscrypt(
 282                 UserRecord *h,
 283                 HomeSetup *setup,
 284                 const PasswordCache *cache) {
 285
 286         _cleanup_(erase_and_freep) void *volume_key = NULL;
 287         struct fscrypt_policy policy = {};
 288         size_t volume_key_size = 0;
 289         const char *ip;
 290         int r;
 291
 292         assert(h);
 293         assert(user_record_storage(h) == USER_FSCRYPT);
 294         assert(setup);
 295         assert(setup->root_fd < 0);
 296
 297         assert_se(ip = user_record_image_path(h));
 298
 299         setup->root_fd = open(ip, O_RDONLY|O_CLOEXEC|O_DIRECTORY);
 300         if (setup->root_fd < 0)
 301                 return log_error_errno(errno, "Failed to open home directory: %m");
 302
 303         if (ioctl(setup->root_fd, FS_IOC_GET_ENCRYPTION_POLICY, &policy) < 0) {
 304                 if (errno == ENODATA)
 305                         return log_error_errno(errno, "Home directory %s is not encrypted.", ip);
 306                 if (ERRNO_IS_NOT_SUPPORTED(errno)) {
 307                         log_error_errno(errno, "File system does not support fscrypt: %m");
 308                         return -ENOLINK; /* make recognizable */
 309                 }
 310                 return log_error_errno(errno, "Failed to acquire encryption policy of %s: %m", ip);
 311         }
 312
 313         memcpy(setup->fscrypt_key_descriptor, policy.master_key_descriptor, FS_KEY_DESCRIPTOR_SIZE);
 314
 315         r = fscrypt_setup(
 316                         cache,
 317                         h->password,
 318                         setup,
 319                         &volume_key,
 320                         &volume_key_size);
 321         if (r < 0)
 322                 return r;
 323
 324         /* Also install the access key in the user's own keyring */
 325
 326         if (uid_is_valid(h->uid)) {
 327                 r = safe_fork("(sd-addkey)",
 328                               FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG|FORK_LOG|FORK_WAIT|FORK_REOPEN_LOG,
 329                               NULL);
 330                 if (r < 0)
 331                         return log_error_errno(r, "Failed install encryption key in user's keyring: %m");
 332                 if (r == 0) {
 333                         gid_t gid;
 334
 335                         /* Child */
 336
 337                         gid = user_record_gid(h);
 338                         if (setresgid(gid, gid, gid) < 0) {
 339                                 log_error_errno(errno, "Failed to change GID to " GID_FMT ": %m", gid);
 340                                 _exit(EXIT_FAILURE);
 341                         }
 342
 343                         if (setgroups(0, NULL) < 0) {
 344                                 log_error_errno(errno, "Failed to reset auxiliary groups list: %m");
 345                                 _exit(EXIT_FAILURE);
 346                         }
 347
 348                         if (setresuid(h->uid, h->uid, h->uid) < 0) {
 349                                 log_error_errno(errno, "Failed to change UID to " UID_FMT ": %m", h->uid);
 350                                 _exit(EXIT_FAILURE);
 351                         }
 352
 353                         r = fscrypt_upload_volume_key(
 354                                         setup->fscrypt_key_descriptor,
 355                                         volume_key,
 356                                         volume_key_size,
 357                                         KEY_SPEC_USER_KEYRING);
 358                         if (r < 0)
 359                                 _exit(EXIT_FAILURE);
 360
 361                         _exit(EXIT_SUCCESS);
 362                 }
 363         }
 364
 365         /* We'll bind mount the image directory to a new mount point where we'll start adjusting it. Only
 366          * once that's complete we'll move the thing to its final place eventually. */
 367         r = home_unshare_and_mkdir();
 368         if (r < 0)
 369                 return r;
 370
 371         r = mount_follow_verbose(LOG_ERR, ip, HOME_RUNTIME_WORK_DIR, NULL, MS_BIND, NULL);
 372         if (r < 0)
 373                 return r;
 374
 375         setup->undo_mount = true;
 376
 377         /* Turn off any form of propagation for this */
 378         r = mount_nofollow_verbose(LOG_ERR, NULL, HOME_RUNTIME_WORK_DIR, NULL, MS_PRIVATE, NULL);
 379         if (r < 0)
 380                 return r;
 381
 382         /* Adjust MS_SUID and similar flags */
 383         r = mount_nofollow_verbose(LOG_ERR, NULL, HOME_RUNTIME_WORK_DIR, NULL, MS_BIND|MS_REMOUNT|user_record_mount_flags(h), NULL);
 384         if (r < 0)
 385                 return r;
 386
 387         safe_close(setup->root_fd);
 388         setup->root_fd = open(HOME_RUNTIME_WORK_DIR, O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOFOLLOW);
 389         if (setup->root_fd < 0)
 390                 return log_error_errno(errno, "Failed to open home directory: %m");
 391
 392         return 0;
 393 }
 394
 395 static int fscrypt_slot_set(
 396                 int root_fd,
 397                 const void *volume_key,
 398                 size_t volume_key_size,
 399                 const char *password,
 400                 uint32_t nr) {
 401
 402         _cleanup_free_ char *salt_base64 = NULL, *encrypted_base64 = NULL, *joined = NULL;
 403         char label[STRLEN("trusted.fscrypt_slot") + DECIMAL_STR_MAX(nr) + 1];
 404         _cleanup_(EVP_CIPHER_CTX_freep) EVP_CIPHER_CTX *context = NULL;
 405         int r, encrypted_size_out1, encrypted_size_out2;
 406         uint8_t salt[64], derived[512 / 8] = {};
 407         _cleanup_free_ void *encrypted = NULL;
 408         const EVP_CIPHER *cc;
 409         size_t encrypted_size;
 410
 411         r = crypto_random_bytes(salt, sizeof(salt));
 412         if (r < 0)
 413                 return log_error_errno(r, "Failed to generate salt: %m");
 414
 415         if (PKCS5_PBKDF2_HMAC(
 416                             password, strlen(password),
 417                             salt, sizeof(salt),
 418                             0xFFFF, EVP_sha512(),
 419                             sizeof(derived), derived) != 1) {
 420                 r = log_error_errno(SYNTHETIC_ERRNO(ENOTRECOVERABLE), "PBKDF2 failed");
 421                 goto finish;
 422         }
 423
 424         context = EVP_CIPHER_CTX_new();
 425         if (!context) {
 426                 r = log_oom();
 427                 goto finish;
 428         }
 429
 430         /* We use AES256 in counter mode */
 431         cc = EVP_aes_256_ctr();
 432
 433         /* We only use the first half of the derived key */
 434         assert(sizeof(derived) >= (size_t) EVP_CIPHER_key_length(cc));
 435
 436         if (EVP_EncryptInit_ex(context, cc, NULL, derived, NULL) != 1)  {
 437                 r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to initialize encryption context.");
 438                 goto finish;
 439         }
 440
 441         /* Flush out the derived key now, we don't need it anymore */
 442         explicit_bzero_safe(derived, sizeof(derived));
 443
 444         encrypted_size = volume_key_size + EVP_CIPHER_key_length(cc) * 2;
 445         encrypted = malloc(encrypted_size);
 446         if (!encrypted)
 447                 return log_oom();
 448
 449         if (EVP_EncryptUpdate(context, (uint8_t*) encrypted, &encrypted_size_out1, volume_key, volume_key_size) != 1)
 450                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to encrypt volume key.");
 451
 452         assert((size_t) encrypted_size_out1 <= encrypted_size);
 453
 454         if (EVP_EncryptFinal_ex(context, (uint8_t*) encrypted_size + encrypted_size_out1, &encrypted_size_out2) != 1)
 455                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to finish encryption of volume key.");
 456
 457         assert((size_t) encrypted_size_out1 + (size_t) encrypted_size_out2 < encrypted_size);
 458         encrypted_size = (size_t) encrypted_size_out1 + (size_t) encrypted_size_out2;
 459
 460         r = base64mem(salt, sizeof(salt), &salt_base64);
 461         if (r < 0)
 462                 return log_oom();
 463
 464         r = base64mem(encrypted, encrypted_size, &encrypted_base64);
 465         if (r < 0)
 466                 return log_oom();
 467
 468         joined = strjoin(salt_base64, ":", encrypted_base64);
 469         if (!joined)
 470                 return log_oom();
 471
 472         xsprintf(label, "trusted.fscrypt_slot%" PRIu32, nr);
 473         if (fsetxattr(root_fd, label, joined, strlen(joined), 0) < 0)
 474                 return log_error_errno(errno, "Failed to write xattr %s: %m", label);
 475
 476         log_info("Written key slot %s.", label);
 477
 478         return 0;
 479
 480 finish:
 481         explicit_bzero_safe(derived, sizeof(derived));
 482         return r;
 483 }
 484
 485 int home_create_fscrypt(
 486                 UserRecord *h,
 487                 HomeSetup *setup,
 488                 char **effective_passwords,
 489                 UserRecord **ret_home) {
 490
 491         _cleanup_(rm_rf_physical_and_freep) char *temporary = NULL;
 492         _cleanup_(user_record_unrefp) UserRecord *new_home = NULL;
 493         _cleanup_(erase_and_freep) void *volume_key = NULL;
 494         _cleanup_close_ int mount_fd = -1;
 495         struct fscrypt_policy policy = {};
 496         size_t volume_key_size = 512 / 8;
 497         _cleanup_free_ char *d = NULL;
 498         uint32_t nr = 0;
 499         const char *ip;
 500         int r;
 501
 502         assert(h);
 503         assert(user_record_storage(h) == USER_FSCRYPT);
 504         assert(setup);
 505         assert(ret_home);
 506
 507         assert_se(ip = user_record_image_path(h));
 508
 509         r = tempfn_random(ip, "homework", &d);
 510         if (r < 0)
 511                 return log_error_errno(r, "Failed to allocate temporary directory: %m");
 512
 513         (void) mkdir_parents(d, 0755);
 514
 515         if (mkdir(d, 0700) < 0)
 516                 return log_error_errno(errno, "Failed to create temporary home directory %s: %m", d);
 517
 518         temporary = TAKE_PTR(d); /* Needs to be destroyed now */
 519
 520         r = home_unshare_and_mkdir();
 521         if (r < 0)
 522                 return r;
 523
 524         setup->root_fd = open(temporary, O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOFOLLOW);
 525         if (setup->root_fd < 0)
 526                 return log_error_errno(errno, "Failed to open temporary home directory: %m");
 527
 528         if (ioctl(setup->root_fd, FS_IOC_GET_ENCRYPTION_POLICY, &policy) < 0) {
 529                 if (ERRNO_IS_NOT_SUPPORTED(errno)) {
 530                         log_error_errno(errno, "File system does not support fscrypt: %m");
 531                         return -ENOLINK; /* make recognizable */
 532                 }
 533                 if (errno != ENODATA)
 534                         return log_error_errno(errno, "Failed to get fscrypt policy of directory: %m");
 535         } else
 536                 return log_error_errno(SYNTHETIC_ERRNO(EBUSY), "Parent of %s already encrypted, refusing.", d);
 537
 538         volume_key = malloc(volume_key_size);
 539         if (!volume_key)
 540                 return log_oom();
 541
 542         r = crypto_random_bytes(volume_key, volume_key_size);
 543         if (r < 0)
 544                 return log_error_errno(r, "Failed to acquire volume key: %m");
 545
 546         log_info("Generated volume key of size %zu.", volume_key_size);
 547
 548         policy = (struct fscrypt_policy) {
 549                 .contents_encryption_mode = FS_ENCRYPTION_MODE_AES_256_XTS,
 550                 .filenames_encryption_mode = FS_ENCRYPTION_MODE_AES_256_CTS,
 551                 .flags = FS_POLICY_FLAGS_PAD_32,
 552         };
 553
 554         calculate_key_descriptor(volume_key, volume_key_size, policy.master_key_descriptor);
 555
 556         r = fscrypt_upload_volume_key(policy.master_key_descriptor, volume_key, volume_key_size, KEY_SPEC_THREAD_KEYRING);
 557         if (r < 0)
 558                 return r;
 559
 560         log_info("Uploaded volume key to kernel.");
 561
 562         if (ioctl(setup->root_fd, FS_IOC_SET_ENCRYPTION_POLICY, &policy) < 0)
 563                 return log_error_errno(errno, "Failed to set fscrypt policy on directory: %m");
 564
 565         log_info("Encryption policy set.");
 566
 567         STRV_FOREACH(i, effective_passwords) {
 568                 r = fscrypt_slot_set(setup->root_fd, volume_key, volume_key_size, *i, nr);
 569                 if (r < 0)
 570                         return r;
 571
 572                 nr++;
 573         }
 574
 575         (void) home_update_quota_classic(h, temporary);
 576
 577         r = home_shift_uid(setup->root_fd, HOME_RUNTIME_WORK_DIR, h->uid, h->uid, &mount_fd);
 578         if (r > 0)
 579                 setup->undo_mount = true; /* If uidmaps worked we have a mount to undo again */
 580
 581         if (mount_fd >= 0) {
 582                 /* If we have established a new mount, then we can use that as new root fd to our home directory. */
 583                 safe_close(setup->root_fd);
 584
 585                 setup->root_fd = fd_reopen(mount_fd, O_RDONLY|O_CLOEXEC|O_DIRECTORY);
 586                 if (setup->root_fd < 0)
 587                         return log_error_errno(setup->root_fd, "Unable to convert mount fd into proper directory fd: %m");
 588
 589                 mount_fd = safe_close(mount_fd);
 590         }
 591
 592         r = home_populate(h, setup->root_fd);
 593         if (r < 0)
 594                 return r;
 595
 596         r = home_sync_and_statfs(setup->root_fd, NULL);
 597         if (r < 0)
 598                 return r;
 599
 600         r = user_record_clone(h, USER_RECORD_LOAD_MASK_SECRET|USER_RECORD_PERMISSIVE, &new_home);
 601         if (r < 0)
 602                 return log_error_errno(r, "Failed to clone record: %m");
 603
 604         r = user_record_add_binding(
 605                         new_home,
 606                         USER_FSCRYPT,
 607                         ip,
 608                         SD_ID128_NULL,
 609                         SD_ID128_NULL,
 610                         SD_ID128_NULL,
 611                         NULL,
 612                         NULL,
 613                         UINT64_MAX,
 614                         NULL,
 615                         NULL,
 616                         h->uid,
 617                         (gid_t) h->uid);
 618         if (r < 0)
 619                 return log_error_errno(r, "Failed to add binding to record: %m");
 620
 621         setup->root_fd = safe_close(setup->root_fd);
 622
 623         r = home_setup_undo_mount(setup, LOG_ERR);
 624         if (r < 0)
 625                 return r;
 626
 627         if (rename(temporary, ip) < 0)
 628                 return log_error_errno(errno, "Failed to rename %s to %s: %m", temporary, ip);
 629
 630         temporary = mfree(temporary);
 631
 632         log_info("Everything completed.");
 633
 634         *ret_home = TAKE_PTR(new_home);
 635         return 0;
 636 }
 637
 638 int home_passwd_fscrypt(
 639                 UserRecord *h,
 640                 HomeSetup *setup,
 641                 const PasswordCache *cache,         /* the passwords acquired via PKCS#11/FIDO2 security tokens */
 642                 char **effective_passwords          /* new passwords */) {
 643
 644         _cleanup_(erase_and_freep) void *volume_key = NULL;
 645         _cleanup_free_ char *xattr_buf = NULL;
 646         size_t volume_key_size = 0;
 647         uint32_t slot = 0;
 648         int r;
 649
 650         assert(h);
 651         assert(user_record_storage(h) == USER_FSCRYPT);
 652         assert(setup);
 653
 654         r = fscrypt_setup(
 655                         cache,
 656                         h->password,
 657                         setup,
 658                         &volume_key,
 659                         &volume_key_size);
 660         if (r < 0)
 661                 return r;
 662
 663         STRV_FOREACH(p, effective_passwords) {
 664                 r = fscrypt_slot_set(setup->root_fd, volume_key, volume_key_size, *p, slot);
 665                 if (r < 0)
 666                         return r;
 667
 668                 slot++;
 669         }
 670
 671         r = flistxattr_malloc(setup->root_fd, &xattr_buf);
 672         if (r < 0)
 673                 return log_error_errno(errno, "Failed to retrieve xattr list: %m");
 674
 675         NULSTR_FOREACH(xa, xattr_buf) {
 676                 const char *nr;
 677                 uint32_t z;
 678
 679                 /* Check if this xattr has the format 'trusted.fscrypt_slot<nr>' where '<nr>' is a 32bit unsigned integer */
 680                 nr = startswith(xa, "trusted.fscrypt_slot");
 681                 if (!nr)
 682                         continue;
 683                 if (safe_atou32(nr, &z) < 0)
 684                         continue;
 685
 686                 if (z < slot)
 687                         continue;
 688
 689                 if (fremovexattr(setup->root_fd, xa) < 0)
 690                         if (errno != ENODATA)
 691                                 log_warning_errno(errno, "Failed to remove xattr %s: %m", xa);
 692         }
 693
 694         return 0;
 695 }