src/shared/dissect-image.h

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 #pragma once
   3
   4 #include <stdbool.h>
   5
   6 #include "sd-id128.h"
   7
   8 #include "architecture.h"
   9 #include "env-util.h"
  10 #include "gpt.h"
  11 #include "list.h"
  12 #include "loop-util.h"
  13 #include "macro.h"
  14 #include "os-util.h"
  15 #include "strv.h"
  16
  17 typedef struct DissectedImage DissectedImage;
  18 typedef struct DissectedPartition DissectedPartition;
  19 typedef struct DecryptedImage DecryptedImage;
  20 typedef struct MountOptions MountOptions;
  21 typedef struct VeritySettings VeritySettings;
  22
  23 struct DissectedPartition {
  24         bool found:1;
  25         bool ignored:1;
  26         bool rw:1;
  27         bool growfs:1;
  28         int partno;                 /* -1 if there was no partition and the images contains a file system directly */
  29         Architecture architecture;  /* Intended architecture: either native, secondary or unset ARCHITECTURE_INVALID. */
  30         sd_id128_t uuid;            /* Partition entry UUID as reported by the GPT */
  31         char *fstype;
  32         char *node;
  33         char *label;
  34         char *decrypted_node;
  35         char *decrypted_fstype;
  36         char *mount_options;
  37         int mount_node_fd;
  38         uint64_t size;
  39         uint64_t offset;
  40         uint64_t gpt_flags;
  41         int fsmount_fd;
  42 };
  43
  44 #define DISSECTED_PARTITION_NULL                                        \
  45         ((DissectedPartition) {                                         \
  46                 .partno = -1,                                           \
  47                 .architecture = _ARCHITECTURE_INVALID,                  \
  48                 .mount_node_fd = -EBADF,                                \
  49                 .fsmount_fd = -EBADF,                                   \
  50         })
  51 #define TAKE_PARTITION(p)                                       \
  52         ({                                                      \
  53                 DissectedPartition *_pp = &(p), _p = *_pp;      \
  54                 *_pp = DISSECTED_PARTITION_NULL;                \
  55                 _p;                                             \
  56         })
  57
  58 typedef enum DissectImageFlags {
  59         DISSECT_IMAGE_DEVICE_READ_ONLY          = 1 << 0,  /* Make device read-only */
  60         DISSECT_IMAGE_DISCARD_ON_LOOP           = 1 << 1,  /* Turn on "discard" if on a loop device and file system supports it */
  61         DISSECT_IMAGE_DISCARD                   = 1 << 2,  /* Turn on "discard" if file system supports it, on all block devices */
  62         DISSECT_IMAGE_DISCARD_ON_CRYPTO         = 1 << 3,  /* Turn on "discard" also on crypto devices */
  63         DISSECT_IMAGE_DISCARD_ANY               = DISSECT_IMAGE_DISCARD_ON_LOOP |
  64                                                   DISSECT_IMAGE_DISCARD |
  65                                                   DISSECT_IMAGE_DISCARD_ON_CRYPTO,
  66         DISSECT_IMAGE_GPT_ONLY                  = 1 << 4,  /* Only recognize images with GPT partition tables */
  67         DISSECT_IMAGE_GENERIC_ROOT              = 1 << 5,  /* If no partition table or only single generic partition, assume it's the root fs */
  68         DISSECT_IMAGE_MOUNT_ROOT_ONLY           = 1 << 6,  /* Mount only the root and /usr partitions */
  69         DISSECT_IMAGE_MOUNT_NON_ROOT_ONLY       = 1 << 7,  /* Mount only the non-root and non-/usr partitions */
  70         DISSECT_IMAGE_VALIDATE_OS               = 1 << 8,  /* Refuse mounting images that aren't identifiable as OS images */
  71         DISSECT_IMAGE_VALIDATE_OS_EXT           = 1 << 9,  /* Refuse mounting images that aren't identifiable as OS extension images */
  72         DISSECT_IMAGE_RELAX_VAR_CHECK           = 1 << 10, /* Don't insist that the UUID of /var is hashed from /etc/machine-id */
  73         DISSECT_IMAGE_FSCK                      = 1 << 11, /* File system check the partition before mounting (no effect when combined with DISSECT_IMAGE_READ_ONLY) */
  74         DISSECT_IMAGE_NO_PARTITION_TABLE        = 1 << 12, /* Only recognize single file system images */
  75         DISSECT_IMAGE_VERITY_SHARE              = 1 << 13, /* When activating a verity device, reuse existing one if already open */
  76         DISSECT_IMAGE_MKDIR                     = 1 << 14, /* Make top-level directory to mount right before mounting, if missing */
  77         DISSECT_IMAGE_USR_NO_ROOT               = 1 << 15, /* If no root fs is in the image, but /usr is, then allow this (so that we can mount the rootfs as tmpfs or so */
  78         DISSECT_IMAGE_REQUIRE_ROOT              = 1 << 16, /* Don't accept disks without root partition (or at least /usr partition if DISSECT_IMAGE_USR_NO_ROOT is set) */
  79         DISSECT_IMAGE_MOUNT_READ_ONLY           = 1 << 17, /* Make mounts read-only */
  80         DISSECT_IMAGE_READ_ONLY                 = DISSECT_IMAGE_DEVICE_READ_ONLY |
  81                                                   DISSECT_IMAGE_MOUNT_READ_ONLY,
  82         DISSECT_IMAGE_GROWFS                    = 1 << 18, /* Grow file systems in partitions marked for that to the size of the partitions after mount */
  83         DISSECT_IMAGE_MOUNT_IDMAPPED            = 1 << 19, /* Mount mounts with kernel 5.12-style userns ID mapping, if file system type doesn't support uid=/gid= */
  84         DISSECT_IMAGE_ADD_PARTITION_DEVICES     = 1 << 20, /* Create partition devices via BLKPG_ADD_PARTITION */
  85         DISSECT_IMAGE_PIN_PARTITION_DEVICES     = 1 << 21, /* Open dissected partitions and decrypted partitions and pin them by fd */
  86         DISSECT_IMAGE_RELAX_EXTENSION_CHECK     = 1 << 22, /* Don't insist that the extension-release file name matches the image name */
  87         DISSECT_IMAGE_DISKSEQ_DEVNODE           = 1 << 23, /* Prefer /dev/disk/by-diskseq/… device nodes */
  88         DISSECT_IMAGE_ALLOW_EMPTY               = 1 << 24, /* Allow that no usable partitions is present */
  89         DISSECT_IMAGE_TRY_ATOMIC_MOUNT_EXCHANGE = 1 << 25, /* Try to mount the image beneath the specified mountpoint, rather than on top of it, and then umount the top */
  90         DISSECT_IMAGE_ALLOW_USERSPACE_VERITY    = 1 << 26, /* Allow userspace verity keyring in /etc/verity.d/ and related dirs */
  91         DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH    = 1 << 27, /* Allow interactive authorization when going through mountfsd */
  92 } DissectImageFlags;
  93
  94 struct DissectedImage {
  95         bool encrypted:1;
  96         bool has_verity:1;         /* verity available in image, but not necessarily used */
  97         bool has_verity_sig:1;     /* pkcs#7 signature embedded in image */
  98         bool verity_ready:1;       /* verity available, fully specified and usable */
  99         bool verity_sig_ready:1;   /* verity signature logic, fully specified and usable */
 100         bool single_file_system:1; /* MBR/GPT or single file system */
 101
 102         LoopDevice *loop;
 103         DissectedPartition partitions[_PARTITION_DESIGNATOR_MAX];
 104         DecryptedImage *decrypted_image;
 105
 106         uint32_t sector_size;
 107         uint64_t image_size;
 108
 109         char *image_name;
 110         sd_id128_t image_uuid;
 111
 112         /* Meta information extracted from /etc/os-release and similar */
 113         char *hostname;
 114         sd_id128_t machine_id;
 115         char **machine_info;
 116         char **os_release;
 117         char **initrd_release;
 118         char **confext_release;
 119         char **sysext_release;
 120         int has_init_system;
 121 };
 122
 123 struct MountOptions {
 124         PartitionDesignator partition_designator;
 125         char *options;
 126         LIST_FIELDS(MountOptions, mount_options);
 127 };
 128
 129 struct VeritySettings {
 130         /* Binary root hash for the Verity Merkle tree */
 131         void *root_hash;
 132         size_t root_hash_size;
 133
 134         /* PKCS#7 signature of the above */
 135         void *root_hash_sig;
 136         size_t root_hash_sig_size;
 137
 138         /* Path to the verity data file, if stored externally */
 139         char *data_path;
 140
 141         /* PARTITION_ROOT or PARTITION_USR, depending on what these Verity settings are for */
 142         PartitionDesignator designator;
 143 };
 144
 145 #define VERITY_SETTINGS_DEFAULT {                               \
 146                 .designator = _PARTITION_DESIGNATOR_INVALID     \
 147         }
 148
 149 /* We include image-policy.h down here, since ImagePolicy wants a complete definition of PartitionDesignator first. */
 150 #include "image-policy.h"
 151
 152 MountOptions* mount_options_free_all(MountOptions *options);
 153 DEFINE_TRIVIAL_CLEANUP_FUNC(MountOptions*, mount_options_free_all);
 154 const char* mount_options_from_designator(const MountOptions *options, PartitionDesignator designator);
 155
 156 int probe_filesystem_full(int fd, const char *path, uint64_t offset, uint64_t size, char **ret_fstype);
 157 static inline int probe_filesystem(const char *path, char **ret_fstype) {
 158         return probe_filesystem_full(-1, path, 0, UINT64_MAX, ret_fstype);
 159 }
 160
 161 int dissect_log_error(int log_level, int r, const char *name, const VeritySettings *verity);
 162 int dissect_image_file(const char *path, const VeritySettings *verity, const MountOptions *mount_options, const ImagePolicy *image_policy, DissectImageFlags flags, DissectedImage **ret);
 163 int dissect_image_file_and_warn(const char *path, const VeritySettings *verity, const MountOptions *mount_options, const ImagePolicy *image_policy, DissectImageFlags flags, DissectedImage **ret);
 164 int dissect_loop_device(LoopDevice *loop, const VeritySettings *verity, const MountOptions *mount_options, const ImagePolicy *image_policy, DissectImageFlags flags, DissectedImage **ret);
 165 int dissect_loop_device_and_warn(LoopDevice *loop, const VeritySettings *verity, const MountOptions *mount_options, const ImagePolicy *image_policy, DissectImageFlags flags, DissectedImage **ret);
 166
 167 void dissected_image_close(DissectedImage *m);
 168 DissectedImage* dissected_image_unref(DissectedImage *m);
 169 DEFINE_TRIVIAL_CLEANUP_FUNC(DissectedImage*, dissected_image_unref);
 170
 171 int dissected_image_decrypt(DissectedImage *m, const char *passphrase, const VeritySettings *verity, DissectImageFlags flags);
 172 int dissected_image_decrypt_interactively(DissectedImage *m, const char *passphrase, const VeritySettings *verity, DissectImageFlags flags);
 173 int dissected_image_mount(DissectedImage *m, const char *dest, uid_t uid_shift, uid_t uid_range, int userns_fd, DissectImageFlags flags);
 174 int dissected_image_mount_and_warn(DissectedImage *m, const char *where, uid_t uid_shift, uid_t uid_range, int userns_fd, DissectImageFlags flags);
 175
 176 int dissected_image_acquire_metadata(DissectedImage *m, int userns_fd, DissectImageFlags extra_flags);
 177
 178 Architecture dissected_image_architecture(DissectedImage *m);
 179
 180 static inline bool dissected_image_is_bootable_os(DissectedImage *m) {
 181         return m && m->has_init_system > 0;
 182 }
 183
 184 static inline bool dissected_image_is_bootable_uefi(DissectedImage *m) {
 185         return m && m->partitions[PARTITION_ESP].found && dissected_image_is_bootable_os(m);
 186 }
 187
 188 static inline bool dissected_image_is_portable(DissectedImage *m) {
 189         return m && strv_env_pairs_get(m->os_release, "PORTABLE_PREFIXES");
 190 }
 191
 192 static inline bool dissected_image_is_initrd(DissectedImage *m) {
 193         return m && !strv_isempty(m->initrd_release);
 194 }
 195
 196 DecryptedImage* decrypted_image_ref(DecryptedImage *p);
 197 DecryptedImage* decrypted_image_unref(DecryptedImage *p);
 198 DEFINE_TRIVIAL_CLEANUP_FUNC(DecryptedImage*, decrypted_image_unref);
 199
 200 int dissected_image_relinquish(DissectedImage *m);
 201
 202 int verity_settings_load(VeritySettings *verity, const char *image, const char *root_hash_path, const char *root_hash_sig_path);
 203
 204 static inline bool verity_settings_set(const VeritySettings *settings) {
 205         return settings &&
 206                 (settings->root_hash_size > 0 ||
 207                  (settings->root_hash_sig_size > 0 ||
 208                   settings->data_path));
 209 }
 210
 211 void verity_settings_done(VeritySettings *verity);
 212
 213 static inline bool verity_settings_data_covers(const VeritySettings *verity, PartitionDesignator d) {
 214         /* Returns true if the verity settings contain sufficient information to cover the specified partition */
 215         return verity &&
 216                 ((d >= 0 && verity->designator == d) || (d == PARTITION_ROOT && verity->designator < 0)) &&
 217                 verity->root_hash &&
 218                 verity->data_path;
 219 }
 220
 221 int dissected_image_load_verity_sig_partition(DissectedImage *m, int fd, VeritySettings *verity);
 222
 223 bool dissected_image_verity_candidate(const DissectedImage *image, PartitionDesignator d);
 224 bool dissected_image_verity_ready(const DissectedImage *image, PartitionDesignator d);
 225 bool dissected_image_verity_sig_ready(const DissectedImage *image, PartitionDesignator d);
 226
 227 int mount_image_privately_interactively(const char *path, const ImagePolicy *image_policy, DissectImageFlags flags, char **ret_directory, int *ret_dir_fd, LoopDevice **ret_loop_device);
 228
 229 int verity_dissect_and_mount(int src_fd, const char *src, const char *dest, const MountOptions *options, const ImagePolicy *image_policy, const char *required_host_os_release_id, const char *required_host_os_release_version_id, const char *required_host_os_release_sysext_level, const char *required_host_os_release_confext_level, const char *required_sysext_scope, DissectedImage **ret_image);
 230
 231 int dissect_fstype_ok(const char *fstype);
 232
 233 int probe_sector_size(int fd, uint32_t *ret);
 234 int probe_sector_size_prefer_ioctl(int fd, uint32_t *ret);
 235
 236 int partition_pick_mount_options(PartitionDesignator d, const char *fstype, bool rw, bool discard, char **ret_options, unsigned long *ret_ms_flags);
 237
 238 static inline const char *dissected_partition_fstype(const DissectedPartition *m) {
 239         assert(m);
 240
 241         return m->decrypted_node ? m->decrypted_fstype : m->fstype;
 242 }
 243
 244 int get_common_dissect_directory(char **ret);
 245
 246 int mountfsd_mount_image(const char *path, int userns_fd, const ImagePolicy *image_policy, DissectImageFlags flags, DissectedImage **ret);