crypto/block-luks.c

   1 /*
   2  * QEMU Crypto block device encryption LUKS format
   3  *
   4  * Copyright (c) 2015-2016 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "qapi/error.h"
  23 #include "qemu/bswap.h"
  24
  25 #include "block-luks.h"
  26
  27 #include "crypto/hash.h"
  28 #include "crypto/afsplit.h"
  29 #include "crypto/pbkdf.h"
  30 #include "crypto/secret.h"
  31 #include "crypto/random.h"
  32 #include "qemu/uuid.h"
  33
  34 #include "qemu/coroutine.h"
  35 #include "qemu/bitmap.h"
  36
  37 /*
  38  * Reference for the LUKS format implemented here is
  39  *
  40  *   docs/on-disk-format.pdf
  41  *
  42  * in 'cryptsetup' package source code
  43  *
  44  * This file implements the 1.2.1 specification, dated
  45  * Oct 16, 2011.
  46  */
  47
  48 typedef struct QCryptoBlockLUKS QCryptoBlockLUKS;
  49 typedef struct QCryptoBlockLUKSHeader QCryptoBlockLUKSHeader;
  50 typedef struct QCryptoBlockLUKSKeySlot QCryptoBlockLUKSKeySlot;
  51
  52
  53 /* The following constants are all defined by the LUKS spec */
  54 #define QCRYPTO_BLOCK_LUKS_VERSION 1
  55
  56 #define QCRYPTO_BLOCK_LUKS_MAGIC_LEN 6
  57 #define QCRYPTO_BLOCK_LUKS_CIPHER_NAME_LEN 32
  58 #define QCRYPTO_BLOCK_LUKS_CIPHER_MODE_LEN 32
  59 #define QCRYPTO_BLOCK_LUKS_HASH_SPEC_LEN 32
  60 #define QCRYPTO_BLOCK_LUKS_DIGEST_LEN 20
  61 #define QCRYPTO_BLOCK_LUKS_SALT_LEN 32
  62 #define QCRYPTO_BLOCK_LUKS_UUID_LEN 40
  63 #define QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS 8
  64 #define QCRYPTO_BLOCK_LUKS_STRIPES 4000
  65 #define QCRYPTO_BLOCK_LUKS_MIN_SLOT_KEY_ITERS 1000
  66 #define QCRYPTO_BLOCK_LUKS_MIN_MASTER_KEY_ITERS 1000
  67 #define QCRYPTO_BLOCK_LUKS_KEY_SLOT_OFFSET 4096
  68
  69 #define QCRYPTO_BLOCK_LUKS_KEY_SLOT_DISABLED 0x0000DEAD
  70 #define QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED 0x00AC71F3
  71
  72 #define QCRYPTO_BLOCK_LUKS_SECTOR_SIZE 512LL
  73
  74 #define QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS 2000
  75 #define QCRYPTO_BLOCK_LUKS_ERASE_ITERATIONS 40
  76
  77 static const char qcrypto_block_luks_magic[QCRYPTO_BLOCK_LUKS_MAGIC_LEN] = {
  78     'L', 'U', 'K', 'S', 0xBA, 0xBE
  79 };
  80
  81 typedef struct QCryptoBlockLUKSNameMap QCryptoBlockLUKSNameMap;
  82 struct QCryptoBlockLUKSNameMap {
  83     const char *name;
  84     int id;
  85 };
  86
  87 typedef struct QCryptoBlockLUKSCipherSizeMap QCryptoBlockLUKSCipherSizeMap;
  88 struct QCryptoBlockLUKSCipherSizeMap {
  89     uint32_t key_bytes;
  90     int id;
  91 };
  92 typedef struct QCryptoBlockLUKSCipherNameMap QCryptoBlockLUKSCipherNameMap;
  93 struct QCryptoBlockLUKSCipherNameMap {
  94     const char *name;
  95     const QCryptoBlockLUKSCipherSizeMap *sizes;
  96 };
  97
  98
  99 static const QCryptoBlockLUKSCipherSizeMap
 100 qcrypto_block_luks_cipher_size_map_aes[] = {
 101     { 16, QCRYPTO_CIPHER_ALG_AES_128 },
 102     { 24, QCRYPTO_CIPHER_ALG_AES_192 },
 103     { 32, QCRYPTO_CIPHER_ALG_AES_256 },
 104     { 0, 0 },
 105 };
 106
 107 static const QCryptoBlockLUKSCipherSizeMap
 108 qcrypto_block_luks_cipher_size_map_cast5[] = {
 109     { 16, QCRYPTO_CIPHER_ALG_CAST5_128 },
 110     { 0, 0 },
 111 };
 112
 113 static const QCryptoBlockLUKSCipherSizeMap
 114 qcrypto_block_luks_cipher_size_map_serpent[] = {
 115     { 16, QCRYPTO_CIPHER_ALG_SERPENT_128 },
 116     { 24, QCRYPTO_CIPHER_ALG_SERPENT_192 },
 117     { 32, QCRYPTO_CIPHER_ALG_SERPENT_256 },
 118     { 0, 0 },
 119 };
 120
 121 static const QCryptoBlockLUKSCipherSizeMap
 122 qcrypto_block_luks_cipher_size_map_twofish[] = {
 123     { 16, QCRYPTO_CIPHER_ALG_TWOFISH_128 },
 124     { 24, QCRYPTO_CIPHER_ALG_TWOFISH_192 },
 125     { 32, QCRYPTO_CIPHER_ALG_TWOFISH_256 },
 126     { 0, 0 },
 127 };
 128
 129 static const QCryptoBlockLUKSCipherNameMap
 130 qcrypto_block_luks_cipher_name_map[] = {
 131     { "aes", qcrypto_block_luks_cipher_size_map_aes },
 132     { "cast5", qcrypto_block_luks_cipher_size_map_cast5 },
 133     { "serpent", qcrypto_block_luks_cipher_size_map_serpent },
 134     { "twofish", qcrypto_block_luks_cipher_size_map_twofish },
 135 };
 136
 137
 138 /*
 139  * This struct is written to disk in big-endian format,
 140  * but operated upon in native-endian format.
 141  */
 142 struct QCryptoBlockLUKSKeySlot {
 143     /* state of keyslot, enabled/disable */
 144     uint32_t active;
 145     /* iterations for PBKDF2 */
 146     uint32_t iterations;
 147     /* salt for PBKDF2 */
 148     uint8_t salt[QCRYPTO_BLOCK_LUKS_SALT_LEN];
 149     /* start sector of key material */
 150     uint32_t key_offset_sector;
 151     /* number of anti-forensic stripes */
 152     uint32_t stripes;
 153 };
 154
 155 QEMU_BUILD_BUG_ON(sizeof(struct QCryptoBlockLUKSKeySlot) != 48);
 156
 157
 158 /*
 159  * This struct is written to disk in big-endian format,
 160  * but operated upon in native-endian format.
 161  */
 162 struct QCryptoBlockLUKSHeader {
 163     /* 'L', 'U', 'K', 'S', '0xBA', '0xBE' */
 164     char magic[QCRYPTO_BLOCK_LUKS_MAGIC_LEN];
 165
 166     /* LUKS version, currently 1 */
 167     uint16_t version;
 168
 169     /* cipher name specification (aes, etc) */
 170     char cipher_name[QCRYPTO_BLOCK_LUKS_CIPHER_NAME_LEN];
 171
 172     /* cipher mode specification (cbc-plain, xts-essiv:sha256, etc) */
 173     char cipher_mode[QCRYPTO_BLOCK_LUKS_CIPHER_MODE_LEN];
 174
 175     /* hash specification (sha256, etc) */
 176     char hash_spec[QCRYPTO_BLOCK_LUKS_HASH_SPEC_LEN];
 177
 178     /* start offset of the volume data (in 512 byte sectors) */
 179     uint32_t payload_offset_sector;
 180
 181     /* Number of key bytes */
 182     uint32_t master_key_len;
 183
 184     /* master key checksum after PBKDF2 */
 185     uint8_t master_key_digest[QCRYPTO_BLOCK_LUKS_DIGEST_LEN];
 186
 187     /* salt for master key PBKDF2 */
 188     uint8_t master_key_salt[QCRYPTO_BLOCK_LUKS_SALT_LEN];
 189
 190     /* iterations for master key PBKDF2 */
 191     uint32_t master_key_iterations;
 192
 193     /* UUID of the partition in standard ASCII representation */
 194     uint8_t uuid[QCRYPTO_BLOCK_LUKS_UUID_LEN];
 195
 196     /* key slots */
 197     QCryptoBlockLUKSKeySlot key_slots[QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS];
 198 };
 199
 200 QEMU_BUILD_BUG_ON(sizeof(struct QCryptoBlockLUKSHeader) != 592);
 201
 202
 203 struct QCryptoBlockLUKS {
 204     QCryptoBlockLUKSHeader header;
 205
 206     /* Main encryption algorithm used for encryption*/
 207     QCryptoCipherAlgorithm cipher_alg;
 208
 209     /* Mode of encryption for the selected encryption algorithm */
 210     QCryptoCipherMode cipher_mode;
 211
 212     /* Initialization vector generation algorithm */
 213     QCryptoIVGenAlgorithm ivgen_alg;
 214
 215     /* Hash algorithm used for IV generation*/
 216     QCryptoHashAlgorithm ivgen_hash_alg;
 217
 218     /*
 219      * Encryption algorithm used for IV generation.
 220      * Usually the same as main encryption algorithm
 221      */
 222     QCryptoCipherAlgorithm ivgen_cipher_alg;
 223
 224     /* Hash algorithm used in pbkdf2 function */
 225     QCryptoHashAlgorithm hash_alg;
 226
 227     /* Name of the secret that was used to open the image */
 228     char *secret;
 229 };
 230
 231
 232 static int qcrypto_block_luks_cipher_name_lookup(const char *name,
 233                                                  QCryptoCipherMode mode,
 234                                                  uint32_t key_bytes,
 235                                                  Error **errp)
 236 {
 237     const QCryptoBlockLUKSCipherNameMap *map =
 238         qcrypto_block_luks_cipher_name_map;
 239     size_t maplen = G_N_ELEMENTS(qcrypto_block_luks_cipher_name_map);
 240     size_t i, j;
 241
 242     if (mode == QCRYPTO_CIPHER_MODE_XTS) {
 243         key_bytes /= 2;
 244     }
 245
 246     for (i = 0; i < maplen; i++) {
 247         if (!g_str_equal(map[i].name, name)) {
 248             continue;
 249         }
 250         for (j = 0; j < map[i].sizes[j].key_bytes; j++) {
 251             if (map[i].sizes[j].key_bytes == key_bytes) {
 252                 return map[i].sizes[j].id;
 253             }
 254         }
 255     }
 256
 257     error_setg(errp, "Algorithm %s with key size %d bytes not supported",
 258                name, key_bytes);
 259     return 0;
 260 }
 261
 262 static const char *
 263 qcrypto_block_luks_cipher_alg_lookup(QCryptoCipherAlgorithm alg,
 264                                      Error **errp)
 265 {
 266     const QCryptoBlockLUKSCipherNameMap *map =
 267         qcrypto_block_luks_cipher_name_map;
 268     size_t maplen = G_N_ELEMENTS(qcrypto_block_luks_cipher_name_map);
 269     size_t i, j;
 270     for (i = 0; i < maplen; i++) {
 271         for (j = 0; j < map[i].sizes[j].key_bytes; j++) {
 272             if (map[i].sizes[j].id == alg) {
 273                 return map[i].name;
 274             }
 275         }
 276     }
 277
 278     error_setg(errp, "Algorithm '%s' not supported",
 279                QCryptoCipherAlgorithm_str(alg));
 280     return NULL;
 281 }
 282
 283 /* XXX replace with qapi_enum_parse() in future, when we can
 284  * make that function emit a more friendly error message */
 285 static int qcrypto_block_luks_name_lookup(const char *name,
 286                                           const QEnumLookup *map,
 287                                           const char *type,
 288                                           Error **errp)
 289 {
 290     int ret = qapi_enum_parse(map, name, -1, NULL);
 291
 292     if (ret < 0) {
 293         error_setg(errp, "%s %s not supported", type, name);
 294         return 0;
 295     }
 296     return ret;
 297 }
 298
 299 #define qcrypto_block_luks_cipher_mode_lookup(name, errp)               \
 300     qcrypto_block_luks_name_lookup(name,                                \
 301                                    &QCryptoCipherMode_lookup,           \
 302                                    "Cipher mode",                       \
 303                                    errp)
 304
 305 #define qcrypto_block_luks_hash_name_lookup(name, errp)                 \
 306     qcrypto_block_luks_name_lookup(name,                                \
 307                                    &QCryptoHashAlgorithm_lookup,        \
 308                                    "Hash algorithm",                    \
 309                                    errp)
 310
 311 #define qcrypto_block_luks_ivgen_name_lookup(name, errp)                \
 312     qcrypto_block_luks_name_lookup(name,                                \
 313                                    &QCryptoIVGenAlgorithm_lookup,       \
 314                                    "IV generator",                      \
 315                                    errp)
 316
 317
 318 static bool
 319 qcrypto_block_luks_has_format(const uint8_t *buf,
 320                               size_t buf_size)
 321 {
 322     const QCryptoBlockLUKSHeader *luks_header = (const void *)buf;
 323
 324     if (buf_size >= offsetof(QCryptoBlockLUKSHeader, cipher_name) &&
 325         memcmp(luks_header->magic, qcrypto_block_luks_magic,
 326                QCRYPTO_BLOCK_LUKS_MAGIC_LEN) == 0 &&
 327         be16_to_cpu(luks_header->version) == QCRYPTO_BLOCK_LUKS_VERSION) {
 328         return true;
 329     } else {
 330         return false;
 331     }
 332 }
 333
 334
 335 /**
 336  * Deal with a quirk of dm-crypt usage of ESSIV.
 337  *
 338  * When calculating ESSIV IVs, the cipher length used by ESSIV
 339  * may be different from the cipher length used for the block
 340  * encryption, becauses dm-crypt uses the hash digest length
 341  * as the key size. ie, if you have AES 128 as the block cipher
 342  * and SHA 256 as ESSIV hash, then ESSIV will use AES 256 as
 343  * the cipher since that gets a key length matching the digest
 344  * size, not AES 128 with truncated digest as might be imagined
 345  */
 346 static QCryptoCipherAlgorithm
 347 qcrypto_block_luks_essiv_cipher(QCryptoCipherAlgorithm cipher,
 348                                 QCryptoHashAlgorithm hash,
 349                                 Error **errp)
 350 {
 351     size_t digestlen = qcrypto_hash_digest_len(hash);
 352     size_t keylen = qcrypto_cipher_get_key_len(cipher);
 353     if (digestlen == keylen) {
 354         return cipher;
 355     }
 356
 357     switch (cipher) {
 358     case QCRYPTO_CIPHER_ALG_AES_128:
 359     case QCRYPTO_CIPHER_ALG_AES_192:
 360     case QCRYPTO_CIPHER_ALG_AES_256:
 361         if (digestlen == qcrypto_cipher_get_key_len(
 362                 QCRYPTO_CIPHER_ALG_AES_128)) {
 363             return QCRYPTO_CIPHER_ALG_AES_128;
 364         } else if (digestlen == qcrypto_cipher_get_key_len(
 365                        QCRYPTO_CIPHER_ALG_AES_192)) {
 366             return QCRYPTO_CIPHER_ALG_AES_192;
 367         } else if (digestlen == qcrypto_cipher_get_key_len(
 368                        QCRYPTO_CIPHER_ALG_AES_256)) {
 369             return QCRYPTO_CIPHER_ALG_AES_256;
 370         } else {
 371             error_setg(errp, "No AES cipher with key size %zu available",
 372                        digestlen);
 373             return 0;
 374         }
 375         break;
 376     case QCRYPTO_CIPHER_ALG_SERPENT_128:
 377     case QCRYPTO_CIPHER_ALG_SERPENT_192:
 378     case QCRYPTO_CIPHER_ALG_SERPENT_256:
 379         if (digestlen == qcrypto_cipher_get_key_len(
 380                 QCRYPTO_CIPHER_ALG_SERPENT_128)) {
 381             return QCRYPTO_CIPHER_ALG_SERPENT_128;
 382         } else if (digestlen == qcrypto_cipher_get_key_len(
 383                        QCRYPTO_CIPHER_ALG_SERPENT_192)) {
 384             return QCRYPTO_CIPHER_ALG_SERPENT_192;
 385         } else if (digestlen == qcrypto_cipher_get_key_len(
 386                        QCRYPTO_CIPHER_ALG_SERPENT_256)) {
 387             return QCRYPTO_CIPHER_ALG_SERPENT_256;
 388         } else {
 389             error_setg(errp, "No Serpent cipher with key size %zu available",
 390                        digestlen);
 391             return 0;
 392         }
 393         break;
 394     case QCRYPTO_CIPHER_ALG_TWOFISH_128:
 395     case QCRYPTO_CIPHER_ALG_TWOFISH_192:
 396     case QCRYPTO_CIPHER_ALG_TWOFISH_256:
 397         if (digestlen == qcrypto_cipher_get_key_len(
 398                 QCRYPTO_CIPHER_ALG_TWOFISH_128)) {
 399             return QCRYPTO_CIPHER_ALG_TWOFISH_128;
 400         } else if (digestlen == qcrypto_cipher_get_key_len(
 401                        QCRYPTO_CIPHER_ALG_TWOFISH_192)) {
 402             return QCRYPTO_CIPHER_ALG_TWOFISH_192;
 403         } else if (digestlen == qcrypto_cipher_get_key_len(
 404                        QCRYPTO_CIPHER_ALG_TWOFISH_256)) {
 405             return QCRYPTO_CIPHER_ALG_TWOFISH_256;
 406         } else {
 407             error_setg(errp, "No Twofish cipher with key size %zu available",
 408                        digestlen);
 409             return 0;
 410         }
 411         break;
 412     default:
 413         error_setg(errp, "Cipher %s not supported with essiv",
 414                    QCryptoCipherAlgorithm_str(cipher));
 415         return 0;
 416     }
 417 }
 418
 419 /*
 420  * Returns number of sectors needed to store the key material
 421  * given number of anti forensic stripes
 422  */
 423 static int
 424 qcrypto_block_luks_splitkeylen_sectors(const QCryptoBlockLUKS *luks,
 425                                        unsigned int header_sectors,
 426                                        unsigned int stripes)
 427 {
 428     /*
 429      * This calculation doesn't match that shown in the spec,
 430      * but instead follows the cryptsetup implementation.
 431      */
 432
 433     size_t splitkeylen = luks->header.master_key_len * stripes;
 434
 435     /* First align the key material size to block size*/
 436     size_t splitkeylen_sectors =
 437         DIV_ROUND_UP(splitkeylen, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE);
 438
 439     /* Then also align the key material size to the size of the header */
 440     return ROUND_UP(splitkeylen_sectors, header_sectors);
 441 }
 442
 443 /*
 444  * Stores the main LUKS header, taking care of endianess
 445  */
 446 static int
 447 qcrypto_block_luks_store_header(QCryptoBlock *block,
 448                                 QCryptoBlockWriteFunc writefunc,
 449                                 void *opaque,
 450                                 Error **errp)
 451 {
 452     const QCryptoBlockLUKS *luks = block->opaque;
 453     Error *local_err = NULL;
 454     size_t i;
 455     g_autofree QCryptoBlockLUKSHeader *hdr_copy = NULL;
 456
 457     /* Create a copy of the header */
 458     hdr_copy = g_new0(QCryptoBlockLUKSHeader, 1);
 459     memcpy(hdr_copy, &luks->header, sizeof(QCryptoBlockLUKSHeader));
 460
 461     /*
 462      * Everything on disk uses Big Endian (tm), so flip header fields
 463      * before writing them
 464      */
 465     cpu_to_be16s(&hdr_copy->version);
 466     cpu_to_be32s(&hdr_copy->payload_offset_sector);
 467     cpu_to_be32s(&hdr_copy->master_key_len);
 468     cpu_to_be32s(&hdr_copy->master_key_iterations);
 469
 470     for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
 471         cpu_to_be32s(&hdr_copy->key_slots[i].active);
 472         cpu_to_be32s(&hdr_copy->key_slots[i].iterations);
 473         cpu_to_be32s(&hdr_copy->key_slots[i].key_offset_sector);
 474         cpu_to_be32s(&hdr_copy->key_slots[i].stripes);
 475     }
 476
 477     /* Write out the partition header and key slot headers */
 478     writefunc(block, 0, (const uint8_t *)hdr_copy, sizeof(*hdr_copy),
 479               opaque, &local_err);
 480
 481     if (local_err) {
 482         error_propagate(errp, local_err);
 483         return -1;
 484     }
 485     return 0;
 486 }
 487
 488 /*
 489  * Loads the main LUKS header,and byteswaps it to native endianess
 490  * And run basic sanity checks on it
 491  */
 492 static int
 493 qcrypto_block_luks_load_header(QCryptoBlock *block,
 494                                 QCryptoBlockReadFunc readfunc,
 495                                 void *opaque,
 496                                 Error **errp)
 497 {
 498     ssize_t rv;
 499     size_t i;
 500     QCryptoBlockLUKS *luks = block->opaque;
 501
 502     /*
 503      * Read the entire LUKS header, minus the key material from
 504      * the underlying device
 505      */
 506     rv = readfunc(block, 0,
 507                   (uint8_t *)&luks->header,
 508                   sizeof(luks->header),
 509                   opaque,
 510                   errp);
 511     if (rv < 0) {
 512         return rv;
 513     }
 514
 515     /*
 516      * The header is always stored in big-endian format, so
 517      * convert everything to native
 518      */
 519     be16_to_cpus(&luks->header.version);
 520     be32_to_cpus(&luks->header.payload_offset_sector);
 521     be32_to_cpus(&luks->header.master_key_len);
 522     be32_to_cpus(&luks->header.master_key_iterations);
 523
 524     for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
 525         be32_to_cpus(&luks->header.key_slots[i].active);
 526         be32_to_cpus(&luks->header.key_slots[i].iterations);
 527         be32_to_cpus(&luks->header.key_slots[i].key_offset_sector);
 528         be32_to_cpus(&luks->header.key_slots[i].stripes);
 529     }
 530
 531     return 0;
 532 }
 533
 534 /*
 535  * Does basic sanity checks on the LUKS header
 536  */
 537 static int
 538 qcrypto_block_luks_check_header(const QCryptoBlockLUKS *luks, Error **errp)
 539 {
 540     size_t i, j;
 541
 542     unsigned int header_sectors = QCRYPTO_BLOCK_LUKS_KEY_SLOT_OFFSET /
 543         QCRYPTO_BLOCK_LUKS_SECTOR_SIZE;
 544
 545     if (memcmp(luks->header.magic, qcrypto_block_luks_magic,
 546                QCRYPTO_BLOCK_LUKS_MAGIC_LEN) != 0) {
 547         error_setg(errp, "Volume is not in LUKS format");
 548         return -1;
 549     }
 550
 551     if (luks->header.version != QCRYPTO_BLOCK_LUKS_VERSION) {
 552         error_setg(errp, "LUKS version %" PRIu32 " is not supported",
 553                    luks->header.version);
 554         return -1;
 555     }
 556
 557     /* Check all keyslots for corruption  */
 558     for (i = 0 ; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS ; i++) {
 559
 560         const QCryptoBlockLUKSKeySlot *slot1 = &luks->header.key_slots[i];
 561         unsigned int start1 = slot1->key_offset_sector;
 562         unsigned int len1 =
 563             qcrypto_block_luks_splitkeylen_sectors(luks,
 564                                                    header_sectors,
 565                                                    slot1->stripes);
 566
 567         if (slot1->stripes == 0) {
 568             error_setg(errp, "Keyslot %zu is corrupted (stripes == 0)", i);
 569             return -1;
 570         }
 571
 572         if (slot1->active != QCRYPTO_BLOCK_LUKS_KEY_SLOT_DISABLED &&
 573             slot1->active != QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED) {
 574             error_setg(errp,
 575                        "Keyslot %zu state (active/disable) is corrupted", i);
 576             return -1;
 577         }
 578
 579         if (start1 + len1 > luks->header.payload_offset_sector) {
 580             error_setg(errp,
 581                        "Keyslot %zu is overlapping with the encrypted payload",
 582                        i);
 583             return -1;
 584         }
 585
 586         for (j = i + 1 ; j < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS ; j++) {
 587             const QCryptoBlockLUKSKeySlot *slot2 = &luks->header.key_slots[j];
 588             unsigned int start2 = slot2->key_offset_sector;
 589             unsigned int len2 =
 590                 qcrypto_block_luks_splitkeylen_sectors(luks,
 591                                                        header_sectors,
 592                                                        slot2->stripes);
 593
 594             if (start1 + len1 > start2 && start2 + len2 > start1) {
 595                 error_setg(errp,
 596                            "Keyslots %zu and %zu are overlapping in the header",
 597                            i, j);
 598                 return -1;
 599             }
 600         }
 601
 602     }
 603     return 0;
 604 }
 605
 606 /*
 607  * Parses the crypto parameters that are stored in the LUKS header
 608  */
 609
 610 static int
 611 qcrypto_block_luks_parse_header(QCryptoBlockLUKS *luks, Error **errp)
 612 {
 613     g_autofree char *cipher_mode = g_strdup(luks->header.cipher_mode);
 614     char *ivgen_name, *ivhash_name;
 615     Error *local_err = NULL;
 616
 617     /*
 618      * The cipher_mode header contains a string that we have
 619      * to further parse, of the format
 620      *
 621      *    <cipher-mode>-<iv-generator>[:<iv-hash>]
 622      *
 623      * eg  cbc-essiv:sha256, cbc-plain64
 624      */
 625     ivgen_name = strchr(cipher_mode, '-');
 626     if (!ivgen_name) {
 627         error_setg(errp, "Unexpected cipher mode string format %s",
 628                    luks->header.cipher_mode);
 629         return -1;
 630     }
 631     *ivgen_name = '\0';
 632     ivgen_name++;
 633
 634     ivhash_name = strchr(ivgen_name, ':');
 635     if (!ivhash_name) {
 636         luks->ivgen_hash_alg = 0;
 637     } else {
 638         *ivhash_name = '\0';
 639         ivhash_name++;
 640
 641         luks->ivgen_hash_alg = qcrypto_block_luks_hash_name_lookup(ivhash_name,
 642                                                                    &local_err);
 643         if (local_err) {
 644             error_propagate(errp, local_err);
 645             return -1;
 646         }
 647     }
 648
 649     luks->cipher_mode = qcrypto_block_luks_cipher_mode_lookup(cipher_mode,
 650                                                               &local_err);
 651     if (local_err) {
 652         error_propagate(errp, local_err);
 653         return -1;
 654     }
 655
 656     luks->cipher_alg =
 657             qcrypto_block_luks_cipher_name_lookup(luks->header.cipher_name,
 658                                                   luks->cipher_mode,
 659                                                   luks->header.master_key_len,
 660                                                   &local_err);
 661     if (local_err) {
 662         error_propagate(errp, local_err);
 663         return -1;
 664     }
 665
 666     luks->hash_alg =
 667             qcrypto_block_luks_hash_name_lookup(luks->header.hash_spec,
 668                                                 &local_err);
 669     if (local_err) {
 670         error_propagate(errp, local_err);
 671         return -1;
 672     }
 673
 674     luks->ivgen_alg = qcrypto_block_luks_ivgen_name_lookup(ivgen_name,
 675                                                            &local_err);
 676     if (local_err) {
 677         error_propagate(errp, local_err);
 678         return -1;
 679     }
 680
 681     if (luks->ivgen_alg == QCRYPTO_IVGEN_ALG_ESSIV) {
 682         if (!ivhash_name) {
 683             error_setg(errp, "Missing IV generator hash specification");
 684             return -1;
 685         }
 686         luks->ivgen_cipher_alg =
 687                 qcrypto_block_luks_essiv_cipher(luks->cipher_alg,
 688                                                 luks->ivgen_hash_alg,
 689                                                 &local_err);
 690         if (local_err) {
 691             error_propagate(errp, local_err);
 692             return -1;
 693         }
 694     } else {
 695
 696         /*
 697          * Note we parsed the ivhash_name earlier in the cipher_mode
 698          * spec string even with plain/plain64 ivgens, but we
 699          * will ignore it, since it is irrelevant for these ivgens.
 700          * This is for compat with dm-crypt which will silently
 701          * ignore hash names with these ivgens rather than report
 702          * an error about the invalid usage
 703          */
 704         luks->ivgen_cipher_alg = luks->cipher_alg;
 705     }
 706     return 0;
 707 }
 708
 709 /*
 710  * Given a key slot,  user password, and the master key,
 711  * will store the encrypted master key there, and update the
 712  * in-memory header. User must then write the in-memory header
 713  *
 714  * Returns:
 715  *    0 if the keyslot was written successfully
 716  *      with the provided password
 717  *   -1 if a fatal error occurred while storing the key
 718  */
 719 static int
 720 qcrypto_block_luks_store_key(QCryptoBlock *block,
 721                              unsigned int slot_idx,
 722                              const char *password,
 723                              uint8_t *masterkey,
 724                              uint64_t iter_time,
 725                              QCryptoBlockWriteFunc writefunc,
 726                              void *opaque,
 727                              Error **errp)
 728 {
 729     QCryptoBlockLUKS *luks = block->opaque;
 730     QCryptoBlockLUKSKeySlot *slot;
 731     g_autofree uint8_t *splitkey = NULL;
 732     size_t splitkeylen;
 733     g_autofree uint8_t *slotkey = NULL;
 734     g_autoptr(QCryptoCipher) cipher = NULL;
 735     g_autoptr(QCryptoIVGen) ivgen = NULL;
 736     Error *local_err = NULL;
 737     uint64_t iters;
 738     int ret = -1;
 739
 740     assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);
 741     slot = &luks->header.key_slots[slot_idx];
 742     if (qcrypto_random_bytes(slot->salt,
 743                              QCRYPTO_BLOCK_LUKS_SALT_LEN,
 744                              errp) < 0) {
 745         goto cleanup;
 746     }
 747
 748     splitkeylen = luks->header.master_key_len * slot->stripes;
 749
 750     /*
 751      * Determine how many iterations are required to
 752      * hash the user password while consuming 1 second of compute
 753      * time
 754      */
 755     iters = qcrypto_pbkdf2_count_iters(luks->hash_alg,
 756                                        (uint8_t *)password, strlen(password),
 757                                        slot->salt,
 758                                        QCRYPTO_BLOCK_LUKS_SALT_LEN,
 759                                        luks->header.master_key_len,
 760                                        &local_err);
 761     if (local_err) {
 762         error_propagate(errp, local_err);
 763         goto cleanup;
 764     }
 765
 766     if (iters > (ULLONG_MAX / iter_time)) {
 767         error_setg_errno(errp, ERANGE,
 768                          "PBKDF iterations %llu too large to scale",
 769                          (unsigned long long)iters);
 770         goto cleanup;
 771     }
 772
 773     /* iter_time was in millis, but count_iters reported for secs */
 774     iters = iters * iter_time / 1000;
 775
 776     if (iters > UINT32_MAX) {
 777         error_setg_errno(errp, ERANGE,
 778                          "PBKDF iterations %llu larger than %u",
 779                          (unsigned long long)iters, UINT32_MAX);
 780         goto cleanup;
 781     }
 782
 783     slot->iterations =
 784         MAX(iters, QCRYPTO_BLOCK_LUKS_MIN_SLOT_KEY_ITERS);
 785
 786
 787     /*
 788      * Generate a key that we'll use to encrypt the master
 789      * key, from the user's password
 790      */
 791     slotkey = g_new0(uint8_t, luks->header.master_key_len);
 792     if (qcrypto_pbkdf2(luks->hash_alg,
 793                        (uint8_t *)password, strlen(password),
 794                        slot->salt,
 795                        QCRYPTO_BLOCK_LUKS_SALT_LEN,
 796                        slot->iterations,
 797                        slotkey, luks->header.master_key_len,
 798                        errp) < 0) {
 799         goto cleanup;
 800     }
 801
 802
 803     /*
 804      * Setup the encryption objects needed to encrypt the
 805      * master key material
 806      */
 807     cipher = qcrypto_cipher_new(luks->cipher_alg,
 808                                 luks->cipher_mode,
 809                                 slotkey, luks->header.master_key_len,
 810                                 errp);
 811     if (!cipher) {
 812         goto cleanup;
 813     }
 814
 815     ivgen = qcrypto_ivgen_new(luks->ivgen_alg,
 816                               luks->ivgen_cipher_alg,
 817                               luks->ivgen_hash_alg,
 818                               slotkey, luks->header.master_key_len,
 819                               errp);
 820     if (!ivgen) {
 821         goto cleanup;
 822     }
 823
 824     /*
 825      * Before storing the master key, we need to vastly
 826      * increase its size, as protection against forensic
 827      * disk data recovery
 828      */
 829     splitkey = g_new0(uint8_t, splitkeylen);
 830
 831     if (qcrypto_afsplit_encode(luks->hash_alg,
 832                                luks->header.master_key_len,
 833                                slot->stripes,
 834                                masterkey,
 835                                splitkey,
 836                                errp) < 0) {
 837         goto cleanup;
 838     }
 839
 840     /*
 841      * Now we encrypt the split master key with the key generated
 842      * from the user's password, before storing it
 843      */
 844     if (qcrypto_block_cipher_encrypt_helper(cipher, block->niv, ivgen,
 845                                             QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
 846                                             0,
 847                                             splitkey,
 848                                             splitkeylen,
 849                                             errp) < 0) {
 850         goto cleanup;
 851     }
 852
 853     /* Write out the slot's master key material. */
 854     if (writefunc(block,
 855                   slot->key_offset_sector *
 856                   QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
 857                   splitkey, splitkeylen,
 858                   opaque,
 859                   errp) != splitkeylen) {
 860         goto cleanup;
 861     }
 862
 863     slot->active = QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED;
 864
 865     if (qcrypto_block_luks_store_header(block,  writefunc, opaque, errp) < 0) {
 866         goto cleanup;
 867     }
 868
 869     ret = 0;
 870
 871 cleanup:
 872     if (slotkey) {
 873         memset(slotkey, 0, luks->header.master_key_len);
 874     }
 875     if (splitkey) {
 876         memset(splitkey, 0, splitkeylen);
 877     }
 878     return ret;
 879 }
 880
 881 /*
 882  * Given a key slot, and user password, this will attempt to unlock
 883  * the master encryption key from the key slot.
 884  *
 885  * Returns:
 886  *    0 if the key slot is disabled, or key could not be decrypted
 887  *      with the provided password
 888  *    1 if the key slot is enabled, and key decrypted successfully
 889  *      with the provided password
 890  *   -1 if a fatal error occurred loading the key
 891  */
 892 static int
 893 qcrypto_block_luks_load_key(QCryptoBlock *block,
 894                             size_t slot_idx,
 895                             const char *password,
 896                             uint8_t *masterkey,
 897                             QCryptoBlockReadFunc readfunc,
 898                             void *opaque,
 899                             Error **errp)
 900 {
 901     QCryptoBlockLUKS *luks = block->opaque;
 902     const QCryptoBlockLUKSKeySlot *slot;
 903     g_autofree uint8_t *splitkey = NULL;
 904     size_t splitkeylen;
 905     g_autofree uint8_t *possiblekey = NULL;
 906     ssize_t rv;
 907     g_autoptr(QCryptoCipher) cipher = NULL;
 908     uint8_t keydigest[QCRYPTO_BLOCK_LUKS_DIGEST_LEN];
 909     g_autoptr(QCryptoIVGen) ivgen = NULL;
 910     size_t niv;
 911
 912     assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);
 913     slot = &luks->header.key_slots[slot_idx];
 914     if (slot->active != QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED) {
 915         return 0;
 916     }
 917
 918     splitkeylen = luks->header.master_key_len * slot->stripes;
 919     splitkey = g_new0(uint8_t, splitkeylen);
 920     possiblekey = g_new0(uint8_t, luks->header.master_key_len);
 921
 922     /*
 923      * The user password is used to generate a (possible)
 924      * decryption key. This may or may not successfully
 925      * decrypt the master key - we just blindly assume
 926      * the key is correct and validate the results of
 927      * decryption later.
 928      */
 929     if (qcrypto_pbkdf2(luks->hash_alg,
 930                        (const uint8_t *)password, strlen(password),
 931                        slot->salt, QCRYPTO_BLOCK_LUKS_SALT_LEN,
 932                        slot->iterations,
 933                        possiblekey, luks->header.master_key_len,
 934                        errp) < 0) {
 935         return -1;
 936     }
 937
 938     /*
 939      * We need to read the master key material from the
 940      * LUKS key material header. What we're reading is
 941      * not the raw master key, but rather the data after
 942      * it has been passed through AFSplit and the result
 943      * then encrypted.
 944      */
 945     rv = readfunc(block,
 946                   slot->key_offset_sector * QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
 947                   splitkey, splitkeylen,
 948                   opaque,
 949                   errp);
 950     if (rv < 0) {
 951         return -1;
 952     }
 953
 954
 955     /* Setup the cipher/ivgen that we'll use to try to decrypt
 956      * the split master key material */
 957     cipher = qcrypto_cipher_new(luks->cipher_alg,
 958                                 luks->cipher_mode,
 959                                 possiblekey,
 960                                 luks->header.master_key_len,
 961                                 errp);
 962     if (!cipher) {
 963         return -1;
 964     }
 965
 966     niv = qcrypto_cipher_get_iv_len(luks->cipher_alg,
 967                                     luks->cipher_mode);
 968
 969     ivgen = qcrypto_ivgen_new(luks->ivgen_alg,
 970                               luks->ivgen_cipher_alg,
 971                               luks->ivgen_hash_alg,
 972                               possiblekey,
 973                               luks->header.master_key_len,
 974                               errp);
 975     if (!ivgen) {
 976         return -1;
 977     }
 978
 979
 980     /*
 981      * The master key needs to be decrypted in the same
 982      * way that the block device payload will be decrypted
 983      * later. In particular we'll be using the IV generator
 984      * to reset the encryption cipher every time the master
 985      * key crosses a sector boundary.
 986      */
 987     if (qcrypto_block_cipher_decrypt_helper(cipher,
 988                                             niv,
 989                                             ivgen,
 990                                             QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
 991                                             0,
 992                                             splitkey,
 993                                             splitkeylen,
 994                                             errp) < 0) {
 995         return -1;
 996     }
 997
 998     /*
 999      * Now we've decrypted the split master key, join
1000      * it back together to get the actual master key.
1001      */
1002     if (qcrypto_afsplit_decode(luks->hash_alg,
1003                                luks->header.master_key_len,
1004                                slot->stripes,
1005                                splitkey,
1006                                masterkey,
1007                                errp) < 0) {
1008         return -1;
1009     }
1010
1011
1012     /*
1013      * We still don't know that the masterkey we got is valid,
1014      * because we just blindly assumed the user's password
1015      * was correct. This is where we now verify it. We are
1016      * creating a hash of the master key using PBKDF and
1017      * then comparing that to the hash stored in the key slot
1018      * header
1019      */
1020     if (qcrypto_pbkdf2(luks->hash_alg,
1021                        masterkey,
1022                        luks->header.master_key_len,
1023                        luks->header.master_key_salt,
1024                        QCRYPTO_BLOCK_LUKS_SALT_LEN,
1025                        luks->header.master_key_iterations,
1026                        keydigest,
1027                        G_N_ELEMENTS(keydigest),
1028                        errp) < 0) {
1029         return -1;
1030     }
1031
1032     if (memcmp(keydigest, luks->header.master_key_digest,
1033                QCRYPTO_BLOCK_LUKS_DIGEST_LEN) == 0) {
1034         /* Success, we got the right master key */
1035         return 1;
1036     }
1037
1038     /* Fail, user's password was not valid for this key slot,
1039      * tell caller to try another slot */
1040     return 0;
1041 }
1042
1043
1044 /*
1045  * Given a user password, this will iterate over all key
1046  * slots and try to unlock each active key slot using the
1047  * password until it successfully obtains a master key.
1048  *
1049  * Returns 0 if a key was loaded, -1 if no keys could be loaded
1050  */
1051 static int
1052 qcrypto_block_luks_find_key(QCryptoBlock *block,
1053                             const char *password,
1054                             uint8_t *masterkey,
1055                             QCryptoBlockReadFunc readfunc,
1056                             void *opaque,
1057                             Error **errp)
1058 {
1059     size_t i;
1060     int rv;
1061
1062     for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
1063         rv = qcrypto_block_luks_load_key(block,
1064                                          i,
1065                                          password,
1066                                          masterkey,
1067                                          readfunc,
1068                                          opaque,
1069                                          errp);
1070         if (rv < 0) {
1071             goto error;
1072         }
1073         if (rv == 1) {
1074             return 0;
1075         }
1076     }
1077
1078     error_setg(errp, "Invalid password, cannot unlock any keyslot");
1079  error:
1080     return -1;
1081 }
1082
1083 /*
1084  * Returns true if a slot i is marked as active
1085  * (contains encrypted copy of the master key)
1086  */
1087 static bool
1088 qcrypto_block_luks_slot_active(const QCryptoBlockLUKS *luks,
1089                                unsigned int slot_idx)
1090 {
1091     uint32_t val;
1092
1093     assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);
1094     val = luks->header.key_slots[slot_idx].active;
1095     return val == QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED;
1096 }
1097
1098 /*
1099  * Returns the number of slots that are marked as active
1100  * (slots that contain encrypted copy of the master key)
1101  */
1102 static unsigned int
1103 qcrypto_block_luks_count_active_slots(const QCryptoBlockLUKS *luks)
1104 {
1105     size_t i = 0;
1106     unsigned int ret = 0;
1107
1108     for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
1109         if (qcrypto_block_luks_slot_active(luks, i)) {
1110             ret++;
1111         }
1112     }
1113     return ret;
1114 }
1115
1116 /*
1117  * Finds first key slot which is not active
1118  * Returns the key slot index, or -1 if it doesn't exist
1119  */
1120 static int
1121 qcrypto_block_luks_find_free_keyslot(const QCryptoBlockLUKS *luks)
1122 {
1123     size_t i;
1124
1125     for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
1126         if (!qcrypto_block_luks_slot_active(luks, i)) {
1127             return i;
1128         }
1129     }
1130     return -1;
1131 }
1132
1133 /*
1134  * Erases an keyslot given its index
1135  * Returns:
1136  *    0 if the keyslot was erased successfully
1137  *   -1 if a error occurred while erasing the keyslot
1138  *
1139  */
1140 static int
1141 qcrypto_block_luks_erase_key(QCryptoBlock *block,
1142                              unsigned int slot_idx,
1143                              QCryptoBlockWriteFunc writefunc,
1144                              void *opaque,
1145                              Error **errp)
1146 {
1147     QCryptoBlockLUKS *luks = block->opaque;
1148     QCryptoBlockLUKSKeySlot *slot;
1149     g_autofree uint8_t *garbagesplitkey = NULL;
1150     size_t splitkeylen;
1151     size_t i;
1152     Error *local_err = NULL;
1153     int ret;
1154
1155     assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);
1156     slot = &luks->header.key_slots[slot_idx];
1157
1158     splitkeylen = luks->header.master_key_len * slot->stripes;
1159     assert(splitkeylen > 0);
1160
1161     garbagesplitkey = g_new0(uint8_t, splitkeylen);
1162
1163     /* Reset the key slot header */
1164     memset(slot->salt, 0, QCRYPTO_BLOCK_LUKS_SALT_LEN);
1165     slot->iterations = 0;
1166     slot->active = QCRYPTO_BLOCK_LUKS_KEY_SLOT_DISABLED;
1167
1168     ret = qcrypto_block_luks_store_header(block, writefunc,
1169                                           opaque, &local_err);
1170
1171     if (ret < 0) {
1172         error_propagate(errp, local_err);
1173     }
1174     /*
1175      * Now try to erase the key material, even if the header
1176      * update failed
1177      */
1178     for (i = 0; i < QCRYPTO_BLOCK_LUKS_ERASE_ITERATIONS; i++) {
1179         if (qcrypto_random_bytes(garbagesplitkey,
1180                                  splitkeylen, &local_err) < 0) {
1181             /*
1182              * If we failed to get the random data, still write
1183              * at least zeros to the key slot at least once
1184              */
1185             error_propagate(errp, local_err);
1186
1187             if (i > 0) {
1188                 return -1;
1189             }
1190         }
1191         if (writefunc(block,
1192                       slot->key_offset_sector * QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
1193                       garbagesplitkey,
1194                       splitkeylen,
1195                       opaque,
1196                       &local_err) != splitkeylen) {
1197             error_propagate(errp, local_err);
1198             return -1;
1199         }
1200     }
1201     return ret;
1202 }
1203
1204 static int
1205 qcrypto_block_luks_open(QCryptoBlock *block,
1206                         QCryptoBlockOpenOptions *options,
1207                         const char *optprefix,
1208                         QCryptoBlockReadFunc readfunc,
1209                         void *opaque,
1210                         unsigned int flags,
1211                         size_t n_threads,
1212                         Error **errp)
1213 {
1214     QCryptoBlockLUKS *luks = NULL;
1215     g_autofree uint8_t *masterkey = NULL;
1216     g_autofree char *password = NULL;
1217
1218     if (!(flags & QCRYPTO_BLOCK_OPEN_NO_IO)) {
1219         if (!options->u.luks.key_secret) {
1220             error_setg(errp, "Parameter '%skey-secret' is required for cipher",
1221                        optprefix ? optprefix : "");
1222             return -1;
1223         }
1224         password = qcrypto_secret_lookup_as_utf8(
1225             options->u.luks.key_secret, errp);
1226         if (!password) {
1227             return -1;
1228         }
1229     }
1230
1231     luks = g_new0(QCryptoBlockLUKS, 1);
1232     block->opaque = luks;
1233     luks->secret = g_strdup(options->u.luks.key_secret);
1234
1235     if (qcrypto_block_luks_load_header(block, readfunc, opaque, errp) < 0) {
1236         goto fail;
1237     }
1238
1239     if (qcrypto_block_luks_check_header(luks, errp) < 0) {
1240         goto fail;
1241     }
1242
1243     if (qcrypto_block_luks_parse_header(luks, errp) < 0) {
1244         goto fail;
1245     }
1246
1247     if (!(flags & QCRYPTO_BLOCK_OPEN_NO_IO)) {
1248         /* Try to find which key slot our password is valid for
1249          * and unlock the master key from that slot.
1250          */
1251
1252         masterkey = g_new0(uint8_t, luks->header.master_key_len);
1253
1254         if (qcrypto_block_luks_find_key(block,
1255                                         password,
1256                                         masterkey,
1257                                         readfunc, opaque,
1258                                         errp) < 0) {
1259             goto fail;
1260         }
1261
1262         /* We have a valid master key now, so can setup the
1263          * block device payload decryption objects
1264          */
1265         block->kdfhash = luks->hash_alg;
1266         block->niv = qcrypto_cipher_get_iv_len(luks->cipher_alg,
1267                                                luks->cipher_mode);
1268
1269         block->ivgen = qcrypto_ivgen_new(luks->ivgen_alg,
1270                                          luks->ivgen_cipher_alg,
1271                                          luks->ivgen_hash_alg,
1272                                          masterkey,
1273                                          luks->header.master_key_len,
1274                                          errp);
1275         if (!block->ivgen) {
1276             goto fail;
1277         }
1278
1279         if (qcrypto_block_init_cipher(block,
1280                                       luks->cipher_alg,
1281                                       luks->cipher_mode,
1282                                       masterkey,
1283                                       luks->header.master_key_len,
1284                                       n_threads,
1285                                       errp) < 0) {
1286             goto fail;
1287         }
1288     }
1289
1290     block->sector_size = QCRYPTO_BLOCK_LUKS_SECTOR_SIZE;
1291     block->payload_offset = luks->header.payload_offset_sector *
1292         block->sector_size;
1293
1294     return 0;
1295
1296  fail:
1297     qcrypto_block_free_cipher(block);
1298     qcrypto_ivgen_free(block->ivgen);
1299     g_free(luks->secret);
1300     g_free(luks);
1301     return -1;
1302 }
1303
1304
1305 static void
1306 qcrypto_block_luks_uuid_gen(uint8_t *uuidstr)
1307 {
1308     QemuUUID uuid;
1309     qemu_uuid_generate(&uuid);
1310     qemu_uuid_unparse(&uuid, (char *)uuidstr);
1311 }
1312
1313 static int
1314 qcrypto_block_luks_create(QCryptoBlock *block,
1315                           QCryptoBlockCreateOptions *options,
1316                           const char *optprefix,
1317                           QCryptoBlockInitFunc initfunc,
1318                           QCryptoBlockWriteFunc writefunc,
1319                           void *opaque,
1320                           Error **errp)
1321 {
1322     QCryptoBlockLUKS *luks;
1323     QCryptoBlockCreateOptionsLUKS luks_opts;
1324     Error *local_err = NULL;
1325     g_autofree uint8_t *masterkey = NULL;
1326     size_t header_sectors;
1327     size_t split_key_sectors;
1328     size_t i;
1329     g_autofree char *password = NULL;
1330     const char *cipher_alg;
1331     const char *cipher_mode;
1332     const char *ivgen_alg;
1333     const char *ivgen_hash_alg = NULL;
1334     const char *hash_alg;
1335     g_autofree char *cipher_mode_spec = NULL;
1336     uint64_t iters;
1337
1338     memcpy(&luks_opts, &options->u.luks, sizeof(luks_opts));
1339     if (!luks_opts.has_iter_time) {
1340         luks_opts.iter_time = QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS;
1341     }
1342     if (!luks_opts.has_cipher_alg) {
1343         luks_opts.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256;
1344     }
1345     if (!luks_opts.has_cipher_mode) {
1346         luks_opts.cipher_mode = QCRYPTO_CIPHER_MODE_XTS;
1347     }
1348     if (!luks_opts.has_ivgen_alg) {
1349         luks_opts.ivgen_alg = QCRYPTO_IVGEN_ALG_PLAIN64;
1350     }
1351     if (!luks_opts.has_hash_alg) {
1352         luks_opts.hash_alg = QCRYPTO_HASH_ALG_SHA256;
1353     }
1354     if (luks_opts.ivgen_alg == QCRYPTO_IVGEN_ALG_ESSIV) {
1355         if (!luks_opts.has_ivgen_hash_alg) {
1356             luks_opts.ivgen_hash_alg = QCRYPTO_HASH_ALG_SHA256;
1357             luks_opts.has_ivgen_hash_alg = true;
1358         }
1359     }
1360
1361     luks = g_new0(QCryptoBlockLUKS, 1);
1362     block->opaque = luks;
1363
1364     luks->cipher_alg = luks_opts.cipher_alg;
1365     luks->cipher_mode = luks_opts.cipher_mode;
1366     luks->ivgen_alg = luks_opts.ivgen_alg;
1367     luks->ivgen_hash_alg = luks_opts.ivgen_hash_alg;
1368     luks->hash_alg = luks_opts.hash_alg;
1369
1370
1371     /* Note we're allowing ivgen_hash_alg to be set even for
1372      * non-essiv iv generators that don't need a hash. It will
1373      * be silently ignored, for compatibility with dm-crypt */
1374
1375     if (!options->u.luks.key_secret) {
1376         error_setg(errp, "Parameter '%skey-secret' is required for cipher",
1377                    optprefix ? optprefix : "");
1378         goto error;
1379     }
1380     luks->secret = g_strdup(options->u.luks.key_secret);
1381
1382     password = qcrypto_secret_lookup_as_utf8(luks_opts.key_secret, errp);
1383     if (!password) {
1384         goto error;
1385     }
1386
1387
1388     memcpy(luks->header.magic, qcrypto_block_luks_magic,
1389            QCRYPTO_BLOCK_LUKS_MAGIC_LEN);
1390
1391     /* We populate the header in native endianness initially and
1392      * then convert everything to big endian just before writing
1393      * it out to disk
1394      */
1395     luks->header.version = QCRYPTO_BLOCK_LUKS_VERSION;
1396     qcrypto_block_luks_uuid_gen(luks->header.uuid);
1397
1398     cipher_alg = qcrypto_block_luks_cipher_alg_lookup(luks_opts.cipher_alg,
1399                                                       errp);
1400     if (!cipher_alg) {
1401         goto error;
1402     }
1403
1404     cipher_mode = QCryptoCipherMode_str(luks_opts.cipher_mode);
1405     ivgen_alg = QCryptoIVGenAlgorithm_str(luks_opts.ivgen_alg);
1406     if (luks_opts.has_ivgen_hash_alg) {
1407         ivgen_hash_alg = QCryptoHashAlgorithm_str(luks_opts.ivgen_hash_alg);
1408         cipher_mode_spec = g_strdup_printf("%s-%s:%s", cipher_mode, ivgen_alg,
1409                                            ivgen_hash_alg);
1410     } else {
1411         cipher_mode_spec = g_strdup_printf("%s-%s", cipher_mode, ivgen_alg);
1412     }
1413     hash_alg = QCryptoHashAlgorithm_str(luks_opts.hash_alg);
1414
1415
1416     if (strlen(cipher_alg) >= QCRYPTO_BLOCK_LUKS_CIPHER_NAME_LEN) {
1417         error_setg(errp, "Cipher name '%s' is too long for LUKS header",
1418                    cipher_alg);
1419         goto error;
1420     }
1421     if (strlen(cipher_mode_spec) >= QCRYPTO_BLOCK_LUKS_CIPHER_MODE_LEN) {
1422         error_setg(errp, "Cipher mode '%s' is too long for LUKS header",
1423                    cipher_mode_spec);
1424         goto error;
1425     }
1426     if (strlen(hash_alg) >= QCRYPTO_BLOCK_LUKS_HASH_SPEC_LEN) {
1427         error_setg(errp, "Hash name '%s' is too long for LUKS header",
1428                    hash_alg);
1429         goto error;
1430     }
1431
1432     if (luks_opts.ivgen_alg == QCRYPTO_IVGEN_ALG_ESSIV) {
1433         luks->ivgen_cipher_alg =
1434                 qcrypto_block_luks_essiv_cipher(luks_opts.cipher_alg,
1435                                                 luks_opts.ivgen_hash_alg,
1436                                                 &local_err);
1437         if (local_err) {
1438             error_propagate(errp, local_err);
1439             goto error;
1440         }
1441     } else {
1442         luks->ivgen_cipher_alg = luks_opts.cipher_alg;
1443     }
1444
1445     strcpy(luks->header.cipher_name, cipher_alg);
1446     strcpy(luks->header.cipher_mode, cipher_mode_spec);
1447     strcpy(luks->header.hash_spec, hash_alg);
1448
1449     luks->header.master_key_len =
1450         qcrypto_cipher_get_key_len(luks_opts.cipher_alg);
1451
1452     if (luks_opts.cipher_mode == QCRYPTO_CIPHER_MODE_XTS) {
1453         luks->header.master_key_len *= 2;
1454     }
1455
1456     /* Generate the salt used for hashing the master key
1457      * with PBKDF later
1458      */
1459     if (qcrypto_random_bytes(luks->header.master_key_salt,
1460                              QCRYPTO_BLOCK_LUKS_SALT_LEN,
1461                              errp) < 0) {
1462         goto error;
1463     }
1464
1465     /* Generate random master key */
1466     masterkey = g_new0(uint8_t, luks->header.master_key_len);
1467     if (qcrypto_random_bytes(masterkey,
1468                              luks->header.master_key_len, errp) < 0) {
1469         goto error;
1470     }
1471
1472
1473     /* Setup the block device payload encryption objects */
1474     if (qcrypto_block_init_cipher(block, luks_opts.cipher_alg,
1475                                   luks_opts.cipher_mode, masterkey,
1476                                   luks->header.master_key_len, 1, errp) < 0) {
1477         goto error;
1478     }
1479
1480     block->kdfhash = luks_opts.hash_alg;
1481     block->niv = qcrypto_cipher_get_iv_len(luks_opts.cipher_alg,
1482                                            luks_opts.cipher_mode);
1483     block->ivgen = qcrypto_ivgen_new(luks_opts.ivgen_alg,
1484                                      luks->ivgen_cipher_alg,
1485                                      luks_opts.ivgen_hash_alg,
1486                                      masterkey, luks->header.master_key_len,
1487                                      errp);
1488
1489     if (!block->ivgen) {
1490         goto error;
1491     }
1492
1493
1494     /* Determine how many iterations we need to hash the master
1495      * key, in order to have 1 second of compute time used
1496      */
1497     iters = qcrypto_pbkdf2_count_iters(luks_opts.hash_alg,
1498                                        masterkey, luks->header.master_key_len,
1499                                        luks->header.master_key_salt,
1500                                        QCRYPTO_BLOCK_LUKS_SALT_LEN,
1501                                        QCRYPTO_BLOCK_LUKS_DIGEST_LEN,
1502                                        &local_err);
1503     if (local_err) {
1504         error_propagate(errp, local_err);
1505         goto error;
1506     }
1507
1508     if (iters > (ULLONG_MAX / luks_opts.iter_time)) {
1509         error_setg_errno(errp, ERANGE,
1510                          "PBKDF iterations %llu too large to scale",
1511                          (unsigned long long)iters);
1512         goto error;
1513     }
1514
1515     /* iter_time was in millis, but count_iters reported for secs */
1516     iters = iters * luks_opts.iter_time / 1000;
1517
1518     /* Why /= 8 ?  That matches cryptsetup, but there's no
1519      * explanation why they chose /= 8... Probably so that
1520      * if all 8 keyslots are active we only spend 1 second
1521      * in total time to check all keys */
1522     iters /= 8;
1523     if (iters > UINT32_MAX) {
1524         error_setg_errno(errp, ERANGE,
1525                          "PBKDF iterations %llu larger than %u",
1526                          (unsigned long long)iters, UINT32_MAX);
1527         goto error;
1528     }
1529     iters = MAX(iters, QCRYPTO_BLOCK_LUKS_MIN_MASTER_KEY_ITERS);
1530     luks->header.master_key_iterations = iters;
1531
1532     /* Hash the master key, saving the result in the LUKS
1533      * header. This hash is used when opening the encrypted
1534      * device to verify that the user password unlocked a
1535      * valid master key
1536      */
1537     if (qcrypto_pbkdf2(luks_opts.hash_alg,
1538                        masterkey, luks->header.master_key_len,
1539                        luks->header.master_key_salt,
1540                        QCRYPTO_BLOCK_LUKS_SALT_LEN,
1541                        luks->header.master_key_iterations,
1542                        luks->header.master_key_digest,
1543                        QCRYPTO_BLOCK_LUKS_DIGEST_LEN,
1544                        errp) < 0) {
1545         goto error;
1546     }
1547
1548     /* start with the sector that follows the header*/
1549     header_sectors = QCRYPTO_BLOCK_LUKS_KEY_SLOT_OFFSET /
1550         QCRYPTO_BLOCK_LUKS_SECTOR_SIZE;
1551
1552     split_key_sectors =
1553         qcrypto_block_luks_splitkeylen_sectors(luks,
1554                                                header_sectors,
1555                                                QCRYPTO_BLOCK_LUKS_STRIPES);
1556
1557     for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
1558         QCryptoBlockLUKSKeySlot *slot = &luks->header.key_slots[i];
1559         slot->active = QCRYPTO_BLOCK_LUKS_KEY_SLOT_DISABLED;
1560
1561         slot->key_offset_sector = header_sectors + i * split_key_sectors;
1562         slot->stripes = QCRYPTO_BLOCK_LUKS_STRIPES;
1563     }
1564
1565     /* The total size of the LUKS headers is the partition header + key
1566      * slot headers, rounded up to the nearest sector, combined with
1567      * the size of each master key material region, also rounded up
1568      * to the nearest sector */
1569     luks->header.payload_offset_sector = header_sectors +
1570             QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS * split_key_sectors;
1571
1572     block->sector_size = QCRYPTO_BLOCK_LUKS_SECTOR_SIZE;
1573     block->payload_offset = luks->header.payload_offset_sector *
1574         block->sector_size;
1575
1576     /* Reserve header space to match payload offset */
1577     initfunc(block, block->payload_offset, opaque, &local_err);
1578     if (local_err) {
1579         error_propagate(errp, local_err);
1580         goto error;
1581     }
1582
1583
1584     /* populate the slot 0 with the password encrypted master key*/
1585     /* This will also store the header */
1586     if (qcrypto_block_luks_store_key(block,
1587                                      0,
1588                                      password,
1589                                      masterkey,
1590                                      luks_opts.iter_time,
1591                                      writefunc,
1592                                      opaque,
1593                                      errp) < 0) {
1594         goto error;
1595     }
1596
1597     memset(masterkey, 0, luks->header.master_key_len);
1598
1599     return 0;
1600
1601  error:
1602     if (masterkey) {
1603         memset(masterkey, 0, luks->header.master_key_len);
1604     }
1605
1606     qcrypto_block_free_cipher(block);
1607     qcrypto_ivgen_free(block->ivgen);
1608
1609     g_free(luks->secret);
1610     g_free(luks);
1611     return -1;
1612 }
1613
1614 static int
1615 qcrypto_block_luks_amend_add_keyslot(QCryptoBlock *block,
1616                                      QCryptoBlockReadFunc readfunc,
1617                                      QCryptoBlockWriteFunc writefunc,
1618                                      void *opaque,
1619                                      QCryptoBlockAmendOptionsLUKS *opts_luks,
1620                                      bool force,
1621                                      Error **errp)
1622 {
1623     QCryptoBlockLUKS *luks = block->opaque;
1624     uint64_t iter_time = opts_luks->has_iter_time ?
1625                          opts_luks->iter_time :
1626                          QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS;
1627     int keyslot;
1628     g_autofree char *old_password = NULL;
1629     g_autofree char *new_password = NULL;
1630     g_autofree uint8_t *master_key = NULL;
1631
1632     char *secret = opts_luks->has_secret ? opts_luks->secret : luks->secret;
1633
1634     if (!opts_luks->has_new_secret) {
1635         error_setg(errp, "'new-secret' is required to activate a keyslot");
1636         return -1;
1637     }
1638     if (opts_luks->has_old_secret) {
1639         error_setg(errp,
1640                    "'old-secret' must not be given when activating keyslots");
1641         return -1;
1642     }
1643
1644     if (opts_luks->has_keyslot) {
1645         keyslot = opts_luks->keyslot;
1646         if (keyslot < 0 || keyslot >= QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS) {
1647             error_setg(errp,
1648                        "Invalid keyslot %u specified, must be between 0 and %u",
1649                        keyslot, QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS - 1);
1650             return -1;
1651         }
1652     } else {
1653         keyslot = qcrypto_block_luks_find_free_keyslot(luks);
1654         if (keyslot == -1) {
1655             error_setg(errp,
1656                        "Can't add a keyslot - all keyslots are in use");
1657             return -1;
1658         }
1659     }
1660
1661     if (!force && qcrypto_block_luks_slot_active(luks, keyslot)) {
1662         error_setg(errp,
1663                    "Refusing to overwrite active keyslot %i - "
1664                    "please erase it first",
1665                    keyslot);
1666         return -1;
1667     }
1668
1669     /* Locate the password that will be used to retrieve the master key */
1670     old_password = qcrypto_secret_lookup_as_utf8(secret, errp);
1671     if (!old_password) {
1672         return -1;
1673     }
1674
1675     /* Retrieve the master key */
1676     master_key = g_new0(uint8_t, luks->header.master_key_len);
1677
1678     if (qcrypto_block_luks_find_key(block, old_password, master_key,
1679                                     readfunc, opaque, errp) < 0) {
1680         error_append_hint(errp, "Failed to retrieve the master key");
1681         return -1;
1682     }
1683
1684     /* Locate the new password*/
1685     new_password = qcrypto_secret_lookup_as_utf8(opts_luks->new_secret, errp);
1686     if (!new_password) {
1687         return -1;
1688     }
1689
1690     /* Now set the new keyslots */
1691     if (qcrypto_block_luks_store_key(block, keyslot, new_password, master_key,
1692                                      iter_time, writefunc, opaque, errp)) {
1693         error_append_hint(errp, "Failed to write to keyslot %i", keyslot);
1694         return -1;
1695     }
1696     return 0;
1697 }
1698
1699 static int
1700 qcrypto_block_luks_amend_erase_keyslots(QCryptoBlock *block,
1701                                         QCryptoBlockReadFunc readfunc,
1702                                         QCryptoBlockWriteFunc writefunc,
1703                                         void *opaque,
1704                                         QCryptoBlockAmendOptionsLUKS *opts_luks,
1705                                         bool force,
1706                                         Error **errp)
1707 {
1708     QCryptoBlockLUKS *luks = block->opaque;
1709     g_autofree uint8_t *tmpkey = NULL;
1710     g_autofree char *old_password = NULL;
1711
1712     if (opts_luks->has_new_secret) {
1713         error_setg(errp,
1714                    "'new-secret' must not be given when erasing keyslots");
1715         return -1;
1716     }
1717     if (opts_luks->has_iter_time) {
1718         error_setg(errp,
1719                    "'iter-time' must not be given when erasing keyslots");
1720         return -1;
1721     }
1722     if (opts_luks->has_secret) {
1723         error_setg(errp,
1724                    "'secret' must not be given when erasing keyslots");
1725         return -1;
1726     }
1727
1728     /* Load the old password if given */
1729     if (opts_luks->has_old_secret) {
1730         old_password = qcrypto_secret_lookup_as_utf8(opts_luks->old_secret,
1731                                                      errp);
1732         if (!old_password) {
1733             return -1;
1734         }
1735
1736         /*
1737          * Allocate a temporary key buffer that we will need when
1738          * checking if slot matches the given old password
1739          */
1740         tmpkey = g_new0(uint8_t, luks->header.master_key_len);
1741     }
1742
1743     /* Erase an explicitly given keyslot */
1744     if (opts_luks->has_keyslot) {
1745         int keyslot = opts_luks->keyslot;
1746
1747         if (keyslot < 0 || keyslot >= QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS) {
1748             error_setg(errp,
1749                        "Invalid keyslot %i specified, must be between 0 and %i",
1750                        keyslot, QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS - 1);
1751             return -1;
1752         }
1753
1754         if (opts_luks->has_old_secret) {
1755             int rv = qcrypto_block_luks_load_key(block,
1756                                                  keyslot,
1757                                                  old_password,
1758                                                  tmpkey,
1759                                                  readfunc,
1760                                                  opaque,
1761                                                  errp);
1762             if (rv == -1) {
1763                 return -1;
1764             } else if (rv == 0) {
1765                 error_setg(errp,
1766                            "Given keyslot %i doesn't contain the given "
1767                            "old password for erase operation",
1768                            keyslot);
1769                 return -1;
1770             }
1771         }
1772
1773         if (!force && !qcrypto_block_luks_slot_active(luks, keyslot)) {
1774             error_setg(errp,
1775                        "Given keyslot %i is already erased (inactive) ",
1776                        keyslot);
1777             return -1;
1778         }
1779
1780         if (!force && qcrypto_block_luks_count_active_slots(luks) == 1) {
1781             error_setg(errp,
1782                        "Attempt to erase the only active keyslot %i "
1783                        "which will erase all the data in the image "
1784                        "irreversibly - refusing operation",
1785                        keyslot);
1786             return -1;
1787         }
1788
1789         if (qcrypto_block_luks_erase_key(block, keyslot,
1790                                          writefunc, opaque, errp)) {
1791             error_append_hint(errp, "Failed to erase keyslot %i", keyslot);
1792             return -1;
1793         }
1794
1795     /* Erase all keyslots that match the given old password */
1796     } else if (opts_luks->has_old_secret) {
1797
1798         unsigned long slots_to_erase_bitmap = 0;
1799         size_t i;
1800         int slot_count;
1801
1802         assert(QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS <=
1803                sizeof(slots_to_erase_bitmap) * 8);
1804
1805         for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
1806             int rv = qcrypto_block_luks_load_key(block,
1807                                                  i,
1808                                                  old_password,
1809                                                  tmpkey,
1810                                                  readfunc,
1811                                                  opaque,
1812                                                  errp);
1813             if (rv == -1) {
1814                 return -1;
1815             } else if (rv == 1) {
1816                 bitmap_set(&slots_to_erase_bitmap, i, 1);
1817             }
1818         }
1819
1820         slot_count = bitmap_count_one(&slots_to_erase_bitmap,
1821                                       QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);
1822         if (slot_count == 0) {
1823             error_setg(errp,
1824                        "No keyslots match given (old) password for erase operation");
1825             return -1;
1826         }
1827
1828         if (!force &&
1829             slot_count == qcrypto_block_luks_count_active_slots(luks)) {
1830             error_setg(errp,
1831                        "All the active keyslots match the (old) password that "
1832                        "was given and erasing them will erase all the data in "
1833                        "the image irreversibly - refusing operation");
1834             return -1;
1835         }
1836
1837         /* Now apply the update */
1838         for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
1839             if (!test_bit(i, &slots_to_erase_bitmap)) {
1840                 continue;
1841             }
1842             if (qcrypto_block_luks_erase_key(block, i, writefunc,
1843                 opaque, errp)) {
1844                 error_append_hint(errp, "Failed to erase keyslot %zu", i);
1845                 return -1;
1846             }
1847         }
1848     } else {
1849         error_setg(errp,
1850                    "To erase keyslot(s), either explicit keyslot index "
1851                    "or the password currently contained in them must be given");
1852         return -1;
1853     }
1854     return 0;
1855 }
1856
1857 static int
1858 qcrypto_block_luks_amend_options(QCryptoBlock *block,
1859                                  QCryptoBlockReadFunc readfunc,
1860                                  QCryptoBlockWriteFunc writefunc,
1861                                  void *opaque,
1862                                  QCryptoBlockAmendOptions *options,
1863                                  bool force,
1864                                  Error **errp)
1865 {
1866     QCryptoBlockAmendOptionsLUKS *opts_luks = &options->u.luks;
1867
1868     switch (opts_luks->state) {
1869     case Q_CRYPTO_BLOCKLUKS_KEYSLOT_STATE_ACTIVE:
1870         return qcrypto_block_luks_amend_add_keyslot(block, readfunc,
1871                                                     writefunc, opaque,
1872                                                     opts_luks, force, errp);
1873     case Q_CRYPTO_BLOCKLUKS_KEYSLOT_STATE_INACTIVE:
1874         return qcrypto_block_luks_amend_erase_keyslots(block, readfunc,
1875                                                        writefunc, opaque,
1876                                                        opts_luks, force, errp);
1877     default:
1878         g_assert_not_reached();
1879     }
1880 }
1881
1882 static int qcrypto_block_luks_get_info(QCryptoBlock *block,
1883                                        QCryptoBlockInfo *info,
1884                                        Error **errp)
1885 {
1886     QCryptoBlockLUKS *luks = block->opaque;
1887     QCryptoBlockInfoLUKSSlot *slot;
1888     QCryptoBlockInfoLUKSSlotList *slots = NULL, **prev = &info->u.luks.slots;
1889     size_t i;
1890
1891     info->u.luks.cipher_alg = luks->cipher_alg;
1892     info->u.luks.cipher_mode = luks->cipher_mode;
1893     info->u.luks.ivgen_alg = luks->ivgen_alg;
1894     if (info->u.luks.ivgen_alg == QCRYPTO_IVGEN_ALG_ESSIV) {
1895         info->u.luks.has_ivgen_hash_alg = true;
1896         info->u.luks.ivgen_hash_alg = luks->ivgen_hash_alg;
1897     }
1898     info->u.luks.hash_alg = luks->hash_alg;
1899     info->u.luks.payload_offset = block->payload_offset;
1900     info->u.luks.master_key_iters = luks->header.master_key_iterations;
1901     info->u.luks.uuid = g_strndup((const char *)luks->header.uuid,
1902                                   sizeof(luks->header.uuid));
1903
1904     for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {
1905         slots = g_new0(QCryptoBlockInfoLUKSSlotList, 1);
1906         *prev = slots;
1907
1908         slots->value = slot = g_new0(QCryptoBlockInfoLUKSSlot, 1);
1909         slot->active = luks->header.key_slots[i].active ==
1910             QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED;
1911         slot->key_offset = luks->header.key_slots[i].key_offset_sector
1912              * QCRYPTO_BLOCK_LUKS_SECTOR_SIZE;
1913         if (slot->active) {
1914             slot->has_iters = true;
1915             slot->iters = luks->header.key_slots[i].iterations;
1916             slot->has_stripes = true;
1917             slot->stripes = luks->header.key_slots[i].stripes;
1918         }
1919
1920         prev = &slots->next;
1921     }
1922
1923     return 0;
1924 }
1925
1926
1927 static void qcrypto_block_luks_cleanup(QCryptoBlock *block)
1928 {
1929     QCryptoBlockLUKS *luks = block->opaque;
1930     if (luks) {
1931         g_free(luks->secret);
1932         g_free(luks);
1933     }
1934 }
1935
1936
1937 static int
1938 qcrypto_block_luks_decrypt(QCryptoBlock *block,
1939                            uint64_t offset,
1940                            uint8_t *buf,
1941                            size_t len,
1942                            Error **errp)
1943 {
1944     assert(QEMU_IS_ALIGNED(offset, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE));
1945     assert(QEMU_IS_ALIGNED(len, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE));
1946     return qcrypto_block_decrypt_helper(block,
1947                                         QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
1948                                         offset, buf, len, errp);
1949 }
1950
1951
1952 static int
1953 qcrypto_block_luks_encrypt(QCryptoBlock *block,
1954                            uint64_t offset,
1955                            uint8_t *buf,
1956                            size_t len,
1957                            Error **errp)
1958 {
1959     assert(QEMU_IS_ALIGNED(offset, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE));
1960     assert(QEMU_IS_ALIGNED(len, QCRYPTO_BLOCK_LUKS_SECTOR_SIZE));
1961     return qcrypto_block_encrypt_helper(block,
1962                                         QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
1963                                         offset, buf, len, errp);
1964 }
1965
1966
1967 const QCryptoBlockDriver qcrypto_block_driver_luks = {
1968     .open = qcrypto_block_luks_open,
1969     .create = qcrypto_block_luks_create,
1970     .amend = qcrypto_block_luks_amend_options,
1971     .get_info = qcrypto_block_luks_get_info,
1972     .cleanup = qcrypto_block_luks_cleanup,
1973     .decrypt = qcrypto_block_luks_decrypt,
1974     .encrypt = qcrypto_block_luks_encrypt,
1975     .has_format = qcrypto_block_luks_has_format,
1976 };