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 "list.h"
   9 #include "loop-util.h"
  10 #include "macro.h"
  11
  12 typedef struct DissectedImage DissectedImage;
  13 typedef struct DissectedPartition DissectedPartition;
  14 typedef struct DecryptedImage DecryptedImage;
  15 typedef struct MountOptions MountOptions;
  16 typedef struct VeritySettings VeritySettings;
  17
  18 struct DissectedPartition {
  19         bool found:1;
  20         bool rw:1;
  21         int partno;        /* -1 if there was no partition and the images contains a file system directly */
  22         int architecture;  /* Intended architecture: either native, secondary or unset (-1). */
  23         sd_id128_t uuid;   /* Partition entry UUID as reported by the GPT */
  24         char *fstype;
  25         char *node;
  26         char *decrypted_node;
  27         char *decrypted_fstype;
  28         char *mount_options;
  29 };
  30
  31 typedef enum PartitionDesignator {
  32         PARTITION_ROOT,
  33         PARTITION_ROOT_SECONDARY,  /* Secondary architecture */
  34         PARTITION_USR,
  35         PARTITION_USR_SECONDARY,
  36         PARTITION_HOME,
  37         PARTITION_SRV,
  38         PARTITION_ESP,
  39         PARTITION_XBOOTLDR,
  40         PARTITION_SWAP,
  41         PARTITION_ROOT_VERITY, /* verity data for the PARTITION_ROOT partition */
  42         PARTITION_ROOT_SECONDARY_VERITY, /* verity data for the PARTITION_ROOT_SECONDARY partition */
  43         PARTITION_USR_VERITY,
  44         PARTITION_USR_SECONDARY_VERITY,
  45         PARTITION_TMP,
  46         PARTITION_VAR,
  47         _PARTITION_DESIGNATOR_MAX,
  48         _PARTITION_DESIGNATOR_INVALID = -1
  49 } PartitionDesignator;
  50
  51 static inline PartitionDesignator PARTITION_VERITY_OF(PartitionDesignator p) {
  52         switch (p) {
  53
  54         case PARTITION_ROOT:
  55                 return PARTITION_ROOT_VERITY;
  56
  57         case PARTITION_ROOT_SECONDARY:
  58                 return PARTITION_ROOT_SECONDARY_VERITY;
  59
  60         case PARTITION_USR:
  61                 return PARTITION_USR_VERITY;
  62
  63         case PARTITION_USR_SECONDARY:
  64                 return PARTITION_USR_SECONDARY_VERITY;
  65
  66         default:
  67                 return _PARTITION_DESIGNATOR_INVALID;
  68         }
  69 }
  70
  71 typedef enum DissectImageFlags {
  72         DISSECT_IMAGE_READ_ONLY           = 1 << 0,
  73         DISSECT_IMAGE_DISCARD_ON_LOOP     = 1 << 1,  /* Turn on "discard" if on a loop device and file system supports it */
  74         DISSECT_IMAGE_DISCARD             = 1 << 2,  /* Turn on "discard" if file system supports it, on all block devices */
  75         DISSECT_IMAGE_DISCARD_ON_CRYPTO   = 1 << 3,  /* Turn on "discard" also on crypto devices */
  76         DISSECT_IMAGE_DISCARD_ANY = DISSECT_IMAGE_DISCARD_ON_LOOP |
  77                                     DISSECT_IMAGE_DISCARD |
  78                                     DISSECT_IMAGE_DISCARD_ON_CRYPTO,
  79         DISSECT_IMAGE_GPT_ONLY            = 1 << 4,  /* Only recognize images with GPT partition tables */
  80         DISSECT_IMAGE_REQUIRE_ROOT        = 1 << 5,  /* Don't accept disks without root partition (and if no partition table or only single generic partition, assume it's root) */
  81         DISSECT_IMAGE_MOUNT_ROOT_ONLY     = 1 << 6,  /* Mount only the root and /usr partitions */
  82         DISSECT_IMAGE_MOUNT_NON_ROOT_ONLY = 1 << 7,  /* Mount only the non-root and non-/usr partitions */
  83         DISSECT_IMAGE_VALIDATE_OS         = 1 << 8,  /* Refuse mounting images that aren't identifiable as OS images */
  84         DISSECT_IMAGE_NO_UDEV             = 1 << 9,  /* Don't wait for udev initializing things */
  85         DISSECT_IMAGE_RELAX_VAR_CHECK     = 1 << 10, /* Don't insist that the UUID of /var is hashed from /etc/machine-id */
  86         DISSECT_IMAGE_FSCK                = 1 << 11, /* File system check the partition before mounting (no effect when combined with DISSECT_IMAGE_READ_ONLY) */
  87         DISSECT_IMAGE_NO_PARTITION_TABLE  = 1 << 12, /* Only recognize single file system images */
  88         DISSECT_IMAGE_VERITY_SHARE        = 1 << 13, /* When activating a verity device, reuse existing one if already open */
  89         DISSECT_IMAGE_MKDIR               = 1 << 14, /* Make directory to mount right before mounting, if missing */
  90 } DissectImageFlags;
  91
  92 struct DissectedImage {
  93         bool encrypted:1;
  94         bool verity:1;     /* verity available and usable */
  95         bool can_verity:1; /* verity available, but not necessarily used */
  96         bool single_file_system:1; /* MBR/GPT or single file system */
  97
  98         DissectedPartition partitions[_PARTITION_DESIGNATOR_MAX];
  99
 100         char *hostname;
 101         sd_id128_t machine_id;
 102         char **machine_info;
 103         char **os_release;
 104 };
 105
 106 struct MountOptions {
 107         PartitionDesignator partition_designator;
 108         char *options;
 109         LIST_FIELDS(MountOptions, mount_options);
 110 };
 111
 112 struct VeritySettings {
 113         /* Binary root hash for the Verity Merkle tree */
 114         void *root_hash;
 115         size_t root_hash_size;
 116
 117         /* PKCS#7 signature of the above */
 118         void *root_hash_sig;
 119         size_t root_hash_sig_size;
 120
 121         /* Path to the verity data file, if stored externally */
 122         char *data_path;
 123
 124         /* PARTITION_ROOT or PARTITION_USR, depending on what these Verity settings are for */
 125         PartitionDesignator designator;
 126 };
 127
 128 #define VERITY_SETTINGS_DEFAULT {                               \
 129                 .designator = _PARTITION_DESIGNATOR_INVALID     \
 130         }
 131
 132 MountOptions* mount_options_free_all(MountOptions *options);
 133 DEFINE_TRIVIAL_CLEANUP_FUNC(MountOptions*, mount_options_free_all);
 134 const char* mount_options_from_designator(const MountOptions *options, PartitionDesignator designator);
 135
 136 int probe_filesystem(const char *node, char **ret_fstype);
 137 int dissect_image(int fd, const VeritySettings *verity, const MountOptions *mount_options, DissectImageFlags flags, DissectedImage **ret);
 138 int dissect_image_and_warn(int fd, const char *name, const VeritySettings *verity, const MountOptions *mount_options, DissectImageFlags flags, DissectedImage **ret);
 139
 140 DissectedImage* dissected_image_unref(DissectedImage *m);
 141 DEFINE_TRIVIAL_CLEANUP_FUNC(DissectedImage*, dissected_image_unref);
 142
 143 int dissected_image_decrypt(DissectedImage *m, const char *passphrase, const VeritySettings *verity, DissectImageFlags flags, DecryptedImage **ret);
 144 int dissected_image_decrypt_interactively(DissectedImage *m, const char *passphrase, const VeritySettings *verity, DissectImageFlags flags, DecryptedImage **ret);
 145 int dissected_image_mount(DissectedImage *m, const char *dest, uid_t uid_shift, DissectImageFlags flags);
 146 int dissected_image_mount_and_warn(DissectedImage *m, const char *where, uid_t uid_shift, DissectImageFlags flags);
 147
 148 int dissected_image_acquire_metadata(DissectedImage *m);
 149
 150 DecryptedImage* decrypted_image_unref(DecryptedImage *p);
 151 DEFINE_TRIVIAL_CLEANUP_FUNC(DecryptedImage*, decrypted_image_unref);
 152 int decrypted_image_relinquish(DecryptedImage *d);
 153
 154 const char* partition_designator_to_string(PartitionDesignator d) _const_;
 155 PartitionDesignator partition_designator_from_string(const char *name) _pure_;
 156
 157 int verity_settings_load(VeritySettings *verity, const char *image, const char *root_hash_path, const char *root_hash_sig_path);
 158 void verity_settings_done(VeritySettings *verity);
 159
 160 bool dissected_image_can_do_verity(const DissectedImage *image, PartitionDesignator d);
 161 bool dissected_image_has_verity(const DissectedImage *image, PartitionDesignator d);
 162
 163 int mount_image_privately_interactively(const char *path, DissectImageFlags flags, char **ret_directory, LoopDevice **ret_loop_device, DecryptedImage **ret_decrypted_image);