luks/luks.h

   1 #ifndef INCLUDED_CRYPTSETUP_LUKS_LUKS_H
   2 #define INCLUDED_CRYPTSETUP_LUKS_LUKS_H
   3
   4 /*
   5  * LUKS partition header
   6  */
   7
   8 #include "libcryptsetup.h"
   9
  10 #define LUKS_CIPHERNAME_L 32
  11 #define LUKS_CIPHERMODE_L 32
  12 #define LUKS_HASHSPEC_L 32
  13 #define LUKS_DIGESTSIZE 20 // since SHA1
  14 #define LUKS_HMACSIZE 32
  15 #define LUKS_SALTSIZE 32
  16 #define LUKS_NUMKEYS 8
  17
  18 // Numbers of iterations for the master key digest
  19 #define LUKS_MKD_ITER 10
  20
  21 // LUKS_KT defines Key types
  22
  23 #define LUKS_KEY_DISABLED_OLD 0
  24 #define LUKS_KEY_ENABLED_OLD 0xCAFE
  25
  26 #define LUKS_KEY_DISABLED 0x0000DEAD
  27 #define LUKS_KEY_ENABLED  0x00AC71F3
  28
  29 #define LUKS_STRIPES 4000
  30
  31 // partition header starts with magic
  32
  33 #define LUKS_MAGIC {'L','U','K','S', 0xba, 0xbe};
  34 #define LUKS_MAGIC_L 6
  35
  36 #define LUKS_PHDR_SIZE (sizeof(struct luks_phdr)/SECTOR_SIZE+1)
  37
  38 /* Actually we need only 37, but we don't want struct autoaligning to kick in */
  39 #define UUID_STRING_L 40
  40
  41 /* Offset to align kesylot area */
  42 #define LUKS_ALIGN_KEYSLOTS 4096
  43
  44 /* Any integer values are stored in network byte order on disk and must be
  45 converted */
  46
  47 struct luks_phdr {
  48         char            magic[LUKS_MAGIC_L];
  49         uint16_t        version;
  50         char            cipherName[LUKS_CIPHERNAME_L];
  51         char            cipherMode[LUKS_CIPHERMODE_L];
  52         char            hashSpec[LUKS_HASHSPEC_L];
  53         uint32_t        payloadOffset;
  54         uint32_t        keyBytes;
  55         char            mkDigest[LUKS_DIGESTSIZE];
  56         char            mkDigestSalt[LUKS_SALTSIZE];
  57         uint32_t        mkDigestIterations;
  58         char            uuid[UUID_STRING_L];
  59
  60         struct {
  61                 uint32_t active;
  62
  63                 /* parameters used for password processing */
  64                 uint32_t passwordIterations;
  65                 char     passwordSalt[LUKS_SALTSIZE];
  66
  67                 /* parameters used for AF store/load */
  68                 uint32_t keyMaterialOffset;
  69                 uint32_t stripes;
  70         } keyblock[LUKS_NUMKEYS];
  71
  72         /* Align it to 512 sector size */
  73         char            _padding[432];
  74 };
  75
  76 struct luks_masterkey {
  77         size_t keyLength;
  78         char key[];
  79 };
  80
  81 struct luks_masterkey *LUKS_alloc_masterkey(int keylength, const char *key);
  82 void LUKS_dealloc_masterkey(struct luks_masterkey *mk);
  83 struct luks_masterkey *LUKS_generate_masterkey(int keylength);
  84 int LUKS_verify_master_key(const struct luks_phdr *hdr,
  85                            const struct luks_masterkey *mk);
  86
  87 int LUKS_generate_phdr(
  88         struct luks_phdr *header,
  89         const struct luks_masterkey *mk,
  90         const char *cipherName,
  91         const char *cipherMode,
  92         const char *hashSpec,
  93         const char *uuid,
  94         unsigned int stripes,
  95         unsigned int alignPayload,
  96         struct crypt_device *ctx);
  97
  98 int LUKS_read_phdr(
  99         const char *device,
 100         struct luks_phdr *hdr,
 101         int require_luks_device,
 102         struct crypt_device *ctx);
 103
 104 int LUKS_read_phdr_backup(
 105         const char *backup_file,
 106         const char *device,
 107         struct luks_phdr *hdr,
 108         int require_luks_device,
 109         struct crypt_device *ctx);
 110
 111 int LUKS_hdr_backup(
 112         const char *backup_file,
 113         const char *device,
 114         struct luks_phdr *hdr,
 115         struct crypt_device *ctx);
 116
 117 int LUKS_hdr_restore(
 118         const char *backup_file,
 119         const char *device,
 120         struct luks_phdr *hdr,
 121         struct crypt_device *ctx);
 122
 123 int LUKS_write_phdr(
 124         const char *device,
 125         struct luks_phdr *hdr,
 126         struct crypt_device *ctx);
 127
 128 int LUKS_set_key(
 129         const char *device,
 130         unsigned int keyIndex,
 131         const char *password,
 132         size_t passwordLen,
 133         struct luks_phdr *hdr,
 134         struct luks_masterkey *mk,
 135         uint32_t iteration_time_ms,
 136         uint64_t *PBKDF2_per_sec,
 137         struct crypt_device *ctx);
 138
 139 int LUKS_open_key(
 140         const char *device,
 141         unsigned int keyIndex,
 142         const char *password,
 143         size_t passwordLen,
 144         struct luks_phdr *hdr,
 145         struct luks_masterkey *mk,
 146         struct crypt_device *ctx);
 147
 148 int LUKS_open_key_with_hdr(
 149         const char *device,
 150         int keyIndex,
 151         const char *password,
 152         size_t passwordLen,
 153         struct luks_phdr *hdr,
 154         struct luks_masterkey **mk,
 155         struct crypt_device *ctx);
 156
 157 int LUKS_del_key(
 158         const char *device,
 159         unsigned int keyIndex,
 160         struct luks_phdr *hdr,
 161         struct crypt_device *ctx);
 162
 163 crypt_keyslot_info LUKS_keyslot_info(struct luks_phdr *hdr, int keyslot);
 164 int LUKS_keyslot_find_empty(struct luks_phdr *hdr);
 165 int LUKS_keyslot_active_count(struct luks_phdr *hdr);
 166 int LUKS_keyslot_set(struct luks_phdr *hdr, int keyslot, int enable);
 167
 168 int LUKS_encrypt_to_storage(
 169         char *src, size_t srcLength,
 170         struct luks_phdr *hdr,
 171         char *key, size_t keyLength,
 172         const char *device,
 173         unsigned int sector,
 174         struct crypt_device *ctx);
 175
 176 int LUKS_decrypt_from_storage(
 177         char *dst, size_t dstLength,
 178         struct luks_phdr *hdr,
 179         char *key, size_t keyLength,
 180         const char *device,
 181         unsigned int sector,
 182         struct crypt_device *ctx);
 183
 184 #endif