lib/luks1/keymanage.c

   1 /*
   2  * LUKS - Linux Unified Key Setup
   3  *
   4  * Copyright (C) 2004-2006 Clemens Fruhwirth <clemens@endorphin.org>
   5  * Copyright (C) 2009-2020 Red Hat, Inc. All rights reserved.
   6  * Copyright (C) 2013-2020 Milan Broz
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <netinet/in.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <ctype.h>
  32 #include <assert.h>
  33 #include <uuid/uuid.h>
  34
  35 #include "luks.h"
  36 #include "af.h"
  37 #include "internal.h"
  38
  39 int LUKS_keyslot_area(const struct luks_phdr *hdr,
  40         int keyslot,
  41         uint64_t *offset,
  42         uint64_t *length)
  43 {
  44         if(keyslot >= LUKS_NUMKEYS || keyslot < 0)
  45                 return -EINVAL;
  46
  47         *offset = (uint64_t)hdr->keyblock[keyslot].keyMaterialOffset * SECTOR_SIZE;
  48         *length = AF_split_sectors(hdr->keyBytes, LUKS_STRIPES) * SECTOR_SIZE;
  49
  50         return 0;
  51 }
  52
  53 /* insertsort: because the array has 8 elements and it's mostly sorted. that's why */
  54 static void LUKS_sort_keyslots(const struct luks_phdr *hdr, int *array)
  55 {
  56         int i, j, x;
  57
  58         for (i = 1; i < LUKS_NUMKEYS; i++) {
  59                 j = i;
  60                 while (j > 0 && hdr->keyblock[array[j-1]].keyMaterialOffset > hdr->keyblock[array[j]].keyMaterialOffset) {
  61                         x = array[j];
  62                         array[j] = array[j-1];
  63                         array[j-1] = x;
  64                         j--;
  65                 }
  66         }
  67 }
  68
  69 size_t LUKS_device_sectors(const struct luks_phdr *hdr)
  70 {
  71         int sorted_areas[LUKS_NUMKEYS] = { 0, 1, 2, 3, 4, 5, 6, 7 };
  72
  73         LUKS_sort_keyslots(hdr, sorted_areas);
  74
  75         return hdr->keyblock[sorted_areas[LUKS_NUMKEYS-1]].keyMaterialOffset + AF_split_sectors(hdr->keyBytes, LUKS_STRIPES);
  76 }
  77
  78 size_t LUKS_keyslots_offset(const struct luks_phdr *hdr)
  79 {
  80         int sorted_areas[LUKS_NUMKEYS] = { 0, 1, 2, 3, 4, 5, 6, 7 };
  81
  82         LUKS_sort_keyslots(hdr, sorted_areas);
  83
  84         return hdr->keyblock[sorted_areas[0]].keyMaterialOffset;
  85 }
  86
  87 static int LUKS_check_device_size(struct crypt_device *ctx, const struct luks_phdr *hdr, int falloc)
  88 {
  89         struct device *device = crypt_metadata_device(ctx);
  90         uint64_t dev_sectors, hdr_sectors;
  91
  92         if (!hdr->keyBytes)
  93                 return -EINVAL;
  94
  95         if (device_size(device, &dev_sectors)) {
  96                 log_dbg(ctx, "Cannot get device size for device %s.", device_path(device));
  97                 return -EIO;
  98         }
  99
 100         dev_sectors >>= SECTOR_SHIFT;
 101         hdr_sectors = LUKS_device_sectors(hdr);
 102         log_dbg(ctx, "Key length %u, device size %" PRIu64 " sectors, header size %"
 103                 PRIu64 " sectors.", hdr->keyBytes, dev_sectors, hdr_sectors);
 104
 105         if (hdr_sectors > dev_sectors) {
 106                 /* If it is header file, increase its size */
 107                 if (falloc && !device_fallocate(device, hdr_sectors << SECTOR_SHIFT))
 108                         return 0;
 109
 110                 log_err(ctx, _("Device %s is too small. (LUKS1 requires at least %" PRIu64 " bytes.)"),
 111                         device_path(device), hdr_sectors * SECTOR_SIZE);
 112                 return -EINVAL;
 113         }
 114
 115         return 0;
 116 }
 117
 118 static int LUKS_check_keyslots(struct crypt_device *ctx, const struct luks_phdr *phdr)
 119 {
 120         int i, prev, next, sorted_areas[LUKS_NUMKEYS] = { 0, 1, 2, 3, 4, 5, 6, 7 };
 121         uint32_t secs_per_stripes = AF_split_sectors(phdr->keyBytes, LUKS_STRIPES);
 122
 123         LUKS_sort_keyslots(phdr, sorted_areas);
 124
 125         /* Check keyslot to prevent access outside of header and keyslot area */
 126         for (i = 0; i < LUKS_NUMKEYS; i++) {
 127                 /* enforce stripes == 4000 */
 128                 if (phdr->keyblock[i].stripes != LUKS_STRIPES) {
 129                         log_dbg(ctx, "Invalid stripes count %u in keyslot %u.",
 130                                 phdr->keyblock[i].stripes, i);
 131                         log_err(ctx, _("LUKS keyslot %u is invalid."), i);
 132                         return -1;
 133                 }
 134
 135                 /* First sectors is the header itself */
 136                 if (phdr->keyblock[i].keyMaterialOffset * SECTOR_SIZE < sizeof(*phdr)) {
 137                         log_dbg(ctx, "Invalid offset %u in keyslot %u.",
 138                                 phdr->keyblock[i].keyMaterialOffset, i);
 139                         log_err(ctx, _("LUKS keyslot %u is invalid."), i);
 140                         return -1;
 141                 }
 142
 143                 /* Ignore following check for detached header where offset can be zero. */
 144                 if (phdr->payloadOffset == 0)
 145                         continue;
 146
 147                 if (phdr->payloadOffset <= phdr->keyblock[i].keyMaterialOffset) {
 148                         log_dbg(ctx, "Invalid offset %u in keyslot %u (beyond data area offset %u).",
 149                                 phdr->keyblock[i].keyMaterialOffset, i,
 150                                 phdr->payloadOffset);
 151                         log_err(ctx, _("LUKS keyslot %u is invalid."), i);
 152                         return -1;
 153                 }
 154
 155                 if (phdr->payloadOffset < (phdr->keyblock[i].keyMaterialOffset + secs_per_stripes)) {
 156                         log_dbg(ctx, "Invalid keyslot size %u (offset %u, stripes %u) in "
 157                                 "keyslot %u (beyond data area offset %u).",
 158                                 secs_per_stripes,
 159                                 phdr->keyblock[i].keyMaterialOffset,
 160                                 phdr->keyblock[i].stripes,
 161                                 i, phdr->payloadOffset);
 162                         log_err(ctx, _("LUKS keyslot %u is invalid."), i);
 163                         return -1;
 164                 }
 165         }
 166
 167         /* check no keyslot overlaps with each other */
 168         for (i = 1; i < LUKS_NUMKEYS; i++) {
 169                 prev = sorted_areas[i-1];
 170                 next = sorted_areas[i];
 171                 if (phdr->keyblock[next].keyMaterialOffset <
 172                     (phdr->keyblock[prev].keyMaterialOffset + secs_per_stripes)) {
 173                         log_dbg(ctx, "Not enough space in LUKS keyslot %d.", prev);
 174                         log_err(ctx, _("LUKS keyslot %u is invalid."), prev);
 175                         return -1;
 176                 }
 177         }
 178         /* do not check last keyslot on purpose, it must be tested in device size check */
 179
 180         return 0;
 181 }
 182
 183 static const char *dbg_slot_state(crypt_keyslot_info ki)
 184 {
 185         switch(ki) {
 186         case CRYPT_SLOT_INACTIVE:
 187                 return "INACTIVE";
 188         case CRYPT_SLOT_ACTIVE:
 189                 return "ACTIVE";
 190         case CRYPT_SLOT_ACTIVE_LAST:
 191                 return "ACTIVE_LAST";
 192         case CRYPT_SLOT_INVALID:
 193         default:
 194                 return "INVALID";
 195         }
 196 }
 197
 198 int LUKS_hdr_backup(const char *backup_file, struct crypt_device *ctx)
 199 {
 200         struct device *device = crypt_metadata_device(ctx);
 201         struct luks_phdr hdr;
 202         int fd, devfd, r = 0;
 203         size_t hdr_size;
 204         size_t buffer_size;
 205         ssize_t ret;
 206         char *buffer = NULL;
 207
 208         r = LUKS_read_phdr(&hdr, 1, 0, ctx);
 209         if (r)
 210                 return r;
 211
 212         hdr_size = LUKS_device_sectors(&hdr) << SECTOR_SHIFT;
 213         buffer_size = size_round_up(hdr_size, crypt_getpagesize());
 214
 215         buffer = crypt_safe_alloc(buffer_size);
 216         if (!buffer || hdr_size < LUKS_ALIGN_KEYSLOTS || hdr_size > buffer_size) {
 217                 r = -ENOMEM;
 218                 goto out;
 219         }
 220
 221         log_dbg(ctx, "Storing backup of header (%zu bytes) and keyslot area (%zu bytes).",
 222                 sizeof(hdr), hdr_size - LUKS_ALIGN_KEYSLOTS);
 223
 224         log_dbg(ctx, "Output backup file size: %zu bytes.", buffer_size);
 225
 226         devfd = device_open(ctx, device, O_RDONLY);
 227         if (devfd < 0) {
 228                 log_err(ctx, _("Device %s is not a valid LUKS device."), device_path(device));
 229                 r = -EINVAL;
 230                 goto out;
 231         }
 232
 233         if (read_lseek_blockwise(devfd, device_block_size(ctx, device), device_alignment(device),
 234                            buffer, hdr_size, 0) < (ssize_t)hdr_size) {
 235                 r = -EIO;
 236                 goto out;
 237         }
 238
 239         /* Wipe unused area, so backup cannot contain old signatures */
 240         if (hdr.keyblock[0].keyMaterialOffset * SECTOR_SIZE == LUKS_ALIGN_KEYSLOTS)
 241                 memset(buffer + sizeof(hdr), 0, LUKS_ALIGN_KEYSLOTS - sizeof(hdr));
 242
 243         fd = open(backup_file, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR);
 244         if (fd == -1) {
 245                 if (errno == EEXIST)
 246                         log_err(ctx, _("Requested header backup file %s already exists."), backup_file);
 247                 else
 248                         log_err(ctx, _("Cannot create header backup file %s."), backup_file);
 249                 r = -EINVAL;
 250                 goto out;
 251         }
 252         ret = write_buffer(fd, buffer, buffer_size);
 253         close(fd);
 254         if (ret < (ssize_t)buffer_size) {
 255                 log_err(ctx, _("Cannot write header backup file %s."), backup_file);
 256                 r = -EIO;
 257                 goto out;
 258         }
 259
 260         r = 0;
 261 out:
 262         crypt_safe_memzero(&hdr, sizeof(hdr));
 263         crypt_safe_free(buffer);
 264         return r;
 265 }
 266
 267 int LUKS_hdr_restore(
 268         const char *backup_file,
 269         struct luks_phdr *hdr,
 270         struct crypt_device *ctx)
 271 {
 272         struct device *device = crypt_metadata_device(ctx);
 273         int fd, r = 0, devfd = -1, diff_uuid = 0;
 274         ssize_t ret, buffer_size = 0;
 275         char *buffer = NULL, msg[200];
 276         struct luks_phdr hdr_file;
 277
 278         r = LUKS_read_phdr_backup(backup_file, &hdr_file, 0, ctx);
 279         if (r == -ENOENT)
 280                 return r;
 281
 282         if (!r)
 283                 buffer_size = LUKS_device_sectors(&hdr_file) << SECTOR_SHIFT;
 284
 285         if (r || buffer_size < LUKS_ALIGN_KEYSLOTS) {
 286                 log_err(ctx, _("Backup file does not contain valid LUKS header."));
 287                 r = -EINVAL;
 288                 goto out;
 289         }
 290
 291         buffer = crypt_safe_alloc(buffer_size);
 292         if (!buffer) {
 293                 r = -ENOMEM;
 294                 goto out;
 295         }
 296
 297         fd = open(backup_file, O_RDONLY);
 298         if (fd == -1) {
 299                 log_err(ctx, _("Cannot open header backup file %s."), backup_file);
 300                 r = -EINVAL;
 301                 goto out;
 302         }
 303
 304         ret = read_buffer(fd, buffer, buffer_size);
 305         close(fd);
 306         if (ret < buffer_size) {
 307                 log_err(ctx, _("Cannot read header backup file %s."), backup_file);
 308                 r = -EIO;
 309                 goto out;
 310         }
 311
 312         r = LUKS_read_phdr(hdr, 0, 0, ctx);
 313         if (r == 0) {
 314                 log_dbg(ctx, "Device %s already contains LUKS header, checking UUID and offset.", device_path(device));
 315                 if(hdr->payloadOffset != hdr_file.payloadOffset ||
 316                    hdr->keyBytes != hdr_file.keyBytes) {
 317                         log_err(ctx, _("Data offset or key size differs on device and backup, restore failed."));
 318                         r = -EINVAL;
 319                         goto out;
 320                 }
 321                 if (memcmp(hdr->uuid, hdr_file.uuid, UUID_STRING_L))
 322                         diff_uuid = 1;
 323         }
 324
 325         if (snprintf(msg, sizeof(msg), _("Device %s %s%s"), device_path(device),
 326                  r ? _("does not contain LUKS header. Replacing header can destroy data on that device.") :
 327                      _("already contains LUKS header. Replacing header will destroy existing keyslots."),
 328                      diff_uuid ? _("\nWARNING: real device header has different UUID than backup!") : "") < 0) {
 329                 r = -ENOMEM;
 330                 goto out;
 331         }
 332
 333         if (!crypt_confirm(ctx, msg)) {
 334                 r = -EINVAL;
 335                 goto out;
 336         }
 337
 338         log_dbg(ctx, "Storing backup of header (%zu bytes) and keyslot area (%zu bytes) to device %s.",
 339                 sizeof(*hdr), buffer_size - LUKS_ALIGN_KEYSLOTS, device_path(device));
 340
 341         devfd = device_open(ctx, device, O_RDWR);
 342         if (devfd < 0) {
 343                 if (errno == EACCES)
 344                         log_err(ctx, _("Cannot write to device %s, permission denied."),
 345                                 device_path(device));
 346                 else
 347                         log_err(ctx, _("Cannot open device %s."), device_path(device));
 348                 r = -EINVAL;
 349                 goto out;
 350         }
 351
 352         if (write_lseek_blockwise(devfd, device_block_size(ctx, device), device_alignment(device),
 353                             buffer, buffer_size, 0) < buffer_size) {
 354                 r = -EIO;
 355                 goto out;
 356         }
 357
 358         /* Be sure to reload new data */
 359         r = LUKS_read_phdr(hdr, 1, 0, ctx);
 360 out:
 361         device_sync(ctx, device);
 362         crypt_safe_free(buffer);
 363         return r;
 364 }
 365
 366 /* This routine should do some just basic recovery for known problems. */
 367 static int _keyslot_repair(struct luks_phdr *phdr, struct crypt_device *ctx)
 368 {
 369         struct luks_phdr temp_phdr;
 370         const unsigned char *sector = (const unsigned char*)phdr;
 371         struct volume_key *vk;
 372         int i, bad, r, need_write = 0;
 373
 374         if (phdr->keyBytes != 16 && phdr->keyBytes != 32 && phdr->keyBytes != 64) {
 375                 log_err(ctx, _("Non standard key size, manual repair required."));
 376                 return -EINVAL;
 377         }
 378         /* cryptsetup 1.0 did not align to 4k, cannot repair this one */
 379         if (LUKS_keyslots_offset(phdr) < (LUKS_ALIGN_KEYSLOTS / SECTOR_SIZE)) {
 380                 log_err(ctx, _("Non standard keyslots alignment, manual repair required."));
 381                 return -EINVAL;
 382         }
 383
 384         r = LUKS_check_cipher(ctx, phdr->keyBytes, phdr->cipherName, phdr->cipherMode);
 385         if (r < 0)
 386                 return -EINVAL;
 387
 388         vk = crypt_alloc_volume_key(phdr->keyBytes, NULL);
 389
 390         log_verbose(ctx, _("Repairing keyslots."));
 391
 392         log_dbg(ctx, "Generating second header with the same parameters for check.");
 393         /* cipherName, cipherMode, hashSpec, uuid are already null terminated */
 394         /* payloadOffset - cannot check */
 395         r = LUKS_generate_phdr(&temp_phdr, vk, phdr->cipherName, phdr->cipherMode,
 396                                phdr->hashSpec, phdr->uuid,
 397                                phdr->payloadOffset * SECTOR_SIZE, 0, 0, ctx);
 398         if (r < 0)
 399                 goto out;
 400
 401         for(i = 0; i < LUKS_NUMKEYS; ++i) {
 402                 if (phdr->keyblock[i].active == LUKS_KEY_ENABLED)  {
 403                         log_dbg(ctx, "Skipping repair for active keyslot %i.", i);
 404                         continue;
 405                 }
 406
 407                 bad = 0;
 408                 if (phdr->keyblock[i].keyMaterialOffset != temp_phdr.keyblock[i].keyMaterialOffset) {
 409                         log_err(ctx, _("Keyslot %i: offset repaired (%u -> %u)."), i,
 410                                 (unsigned)phdr->keyblock[i].keyMaterialOffset,
 411                                 (unsigned)temp_phdr.keyblock[i].keyMaterialOffset);
 412                         phdr->keyblock[i].keyMaterialOffset = temp_phdr.keyblock[i].keyMaterialOffset;
 413                         bad = 1;
 414                 }
 415
 416                 if (phdr->keyblock[i].stripes != temp_phdr.keyblock[i].stripes) {
 417                         log_err(ctx, _("Keyslot %i: stripes repaired (%u -> %u)."), i,
 418                                 (unsigned)phdr->keyblock[i].stripes,
 419                                 (unsigned)temp_phdr.keyblock[i].stripes);
 420                         phdr->keyblock[i].stripes = temp_phdr.keyblock[i].stripes;
 421                         bad = 1;
 422                 }
 423
 424                 /* Known case - MSDOS partition table signature */
 425                 if (i == 6 && sector[0x1fe] == 0x55 && sector[0x1ff] == 0xaa) {
 426                         log_err(ctx, _("Keyslot %i: bogus partition signature."), i);
 427                         bad = 1;
 428                 }
 429
 430                 if(bad) {
 431                         log_err(ctx, _("Keyslot %i: salt wiped."), i);
 432                         phdr->keyblock[i].active = LUKS_KEY_DISABLED;
 433                         memset(&phdr->keyblock[i].passwordSalt, 0x00, LUKS_SALTSIZE);
 434                         phdr->keyblock[i].passwordIterations = 0;
 435                 }
 436
 437                 if (bad)
 438                         need_write = 1;
 439         }
 440
 441         /*
 442          * check repair result before writing because repair can't fix out of order
 443          * keyslot offsets and would corrupt header again
 444          */
 445         if (LUKS_check_keyslots(ctx, phdr))
 446                 r = -EINVAL;
 447         else if (need_write) {
 448                 log_verbose(ctx, _("Writing LUKS header to disk."));
 449                 r = LUKS_write_phdr(phdr, ctx);
 450         }
 451 out:
 452         if (r)
 453                 log_err(ctx, _("Repair failed."));
 454         crypt_free_volume_key(vk);
 455         crypt_safe_memzero(&temp_phdr, sizeof(temp_phdr));
 456         return r;
 457 }
 458
 459 static int _check_and_convert_hdr(const char *device,
 460                                   struct luks_phdr *hdr,
 461                                   int require_luks_device,
 462                                   int repair,
 463                                   struct crypt_device *ctx)
 464 {
 465         int r = 0;
 466         unsigned int i;
 467         char luksMagic[] = LUKS_MAGIC;
 468
 469         if(memcmp(hdr->magic, luksMagic, LUKS_MAGIC_L)) { /* Check magic */
 470                 log_dbg(ctx, "LUKS header not detected.");
 471                 if (require_luks_device)
 472                         log_err(ctx, _("Device %s is not a valid LUKS device."), device);
 473                 return -EINVAL;
 474         } else if((hdr->version = ntohs(hdr->version)) != 1) {  /* Convert every uint16/32_t item from network byte order */
 475                 log_err(ctx, _("Unsupported LUKS version %d."), hdr->version);
 476                 return -EINVAL;
 477         }
 478
 479         hdr->hashSpec[LUKS_HASHSPEC_L - 1] = '\0';
 480         if (crypt_hmac_size(hdr->hashSpec) < LUKS_DIGESTSIZE) {
 481                 log_err(ctx, _("Requested LUKS hash %s is not supported."), hdr->hashSpec);
 482                 return -EINVAL;
 483         }
 484
 485         /* Header detected */
 486         hdr->payloadOffset      = ntohl(hdr->payloadOffset);
 487         hdr->keyBytes           = ntohl(hdr->keyBytes);
 488         hdr->mkDigestIterations = ntohl(hdr->mkDigestIterations);
 489
 490         for(i = 0; i < LUKS_NUMKEYS; ++i) {
 491                 hdr->keyblock[i].active             = ntohl(hdr->keyblock[i].active);
 492                 hdr->keyblock[i].passwordIterations = ntohl(hdr->keyblock[i].passwordIterations);
 493                 hdr->keyblock[i].keyMaterialOffset  = ntohl(hdr->keyblock[i].keyMaterialOffset);
 494                 hdr->keyblock[i].stripes            = ntohl(hdr->keyblock[i].stripes);
 495         }
 496
 497         if (LUKS_check_keyslots(ctx, hdr))
 498                 r = -EINVAL;
 499
 500         /* Avoid unterminated strings */
 501         hdr->cipherName[LUKS_CIPHERNAME_L - 1] = '\0';
 502         hdr->cipherMode[LUKS_CIPHERMODE_L - 1] = '\0';
 503         hdr->uuid[UUID_STRING_L - 1] = '\0';
 504
 505         if (repair) {
 506                 if (r == -EINVAL)
 507                         r = _keyslot_repair(hdr, ctx);
 508                 else
 509                         log_verbose(ctx, _("No known problems detected for LUKS header."));
 510         }
 511
 512         return r;
 513 }
 514
 515 static void _to_lower(char *str, unsigned max_len)
 516 {
 517         for(; *str && max_len; str++, max_len--)
 518                 if (isupper(*str))
 519                         *str = tolower(*str);
 520 }
 521
 522 static void LUKS_fix_header_compatible(struct luks_phdr *header)
 523 {
 524         /* Old cryptsetup expects "sha1", gcrypt allows case insensitive names,
 525          * so always convert hash to lower case in header */
 526         _to_lower(header->hashSpec, LUKS_HASHSPEC_L);
 527
 528         /* ECB mode does not use IV but dmcrypt silently allows it.
 529          * Drop any IV here if ECB is used (that is not secure anyway).*/
 530         if (!strncmp(header->cipherMode, "ecb-", 4)) {
 531                 memset(header->cipherMode, 0, LUKS_CIPHERMODE_L);
 532                 strcpy(header->cipherMode, "ecb");
 533         }
 534 }
 535
 536 int LUKS_read_phdr_backup(const char *backup_file,
 537                           struct luks_phdr *hdr,
 538                           int require_luks_device,
 539                           struct crypt_device *ctx)
 540 {
 541         ssize_t hdr_size = sizeof(struct luks_phdr);
 542         int devfd = 0, r = 0;
 543
 544         log_dbg(ctx, "Reading LUKS header of size %d from backup file %s",
 545                 (int)hdr_size, backup_file);
 546
 547         devfd = open(backup_file, O_RDONLY);
 548         if (devfd == -1) {
 549                 log_err(ctx, _("Cannot open header backup file %s."), backup_file);
 550                 return -ENOENT;
 551         }
 552
 553         if (read_buffer(devfd, hdr, hdr_size) < hdr_size)
 554                 r = -EIO;
 555         else {
 556                 LUKS_fix_header_compatible(hdr);
 557                 r = _check_and_convert_hdr(backup_file, hdr,
 558                                            require_luks_device, 0, ctx);
 559         }
 560
 561         close(devfd);
 562         return r;
 563 }
 564
 565 int LUKS_read_phdr(struct luks_phdr *hdr,
 566                    int require_luks_device,
 567                    int repair,
 568                    struct crypt_device *ctx)
 569 {
 570         int devfd, r = 0;
 571         struct device *device = crypt_metadata_device(ctx);
 572         ssize_t hdr_size = sizeof(struct luks_phdr);
 573
 574         /* LUKS header starts at offset 0, first keyslot on LUKS_ALIGN_KEYSLOTS */
 575         assert(sizeof(struct luks_phdr) <= LUKS_ALIGN_KEYSLOTS);
 576
 577         /* Stripes count cannot be changed without additional code fixes yet */
 578         assert(LUKS_STRIPES == 4000);
 579
 580         if (repair && !require_luks_device)
 581                 return -EINVAL;
 582
 583         log_dbg(ctx, "Reading LUKS header of size %zu from device %s",
 584                 hdr_size, device_path(device));
 585
 586         devfd = device_open(ctx, device, O_RDONLY);
 587         if (devfd < 0) {
 588                 log_err(ctx, _("Cannot open device %s."), device_path(device));
 589                 return -EINVAL;
 590         }
 591
 592         if (read_lseek_blockwise(devfd, device_block_size(ctx, device), device_alignment(device),
 593                            hdr, hdr_size, 0) < hdr_size)
 594                 r = -EIO;
 595         else
 596                 r = _check_and_convert_hdr(device_path(device), hdr, require_luks_device,
 597                                            repair, ctx);
 598
 599         if (!r)
 600                 r = LUKS_check_device_size(ctx, hdr, 0);
 601
 602         /*
 603          * Cryptsetup 1.0.0 did not align keyslots to 4k (very rare version).
 604          * Disable direct-io to avoid possible IO errors if underlying device
 605          * has bigger sector size.
 606          */
 607         if (!r && hdr->keyblock[0].keyMaterialOffset * SECTOR_SIZE < LUKS_ALIGN_KEYSLOTS) {
 608                 log_dbg(ctx, "Old unaligned LUKS keyslot detected, disabling direct-io.");
 609                 device_disable_direct_io(device);
 610         }
 611
 612         return r;
 613 }
 614
 615 int LUKS_write_phdr(struct luks_phdr *hdr,
 616                     struct crypt_device *ctx)
 617 {
 618         struct device *device = crypt_metadata_device(ctx);
 619         ssize_t hdr_size = sizeof(struct luks_phdr);
 620         int devfd = 0;
 621         unsigned int i;
 622         struct luks_phdr convHdr;
 623         int r;
 624
 625         log_dbg(ctx, "Updating LUKS header of size %zu on device %s",
 626                 sizeof(struct luks_phdr), device_path(device));
 627
 628         r = LUKS_check_device_size(ctx, hdr, 1);
 629         if (r)
 630                 return r;
 631
 632         devfd = device_open(ctx, device, O_RDWR);
 633         if (devfd < 0) {
 634                 if (errno == EACCES)
 635                         log_err(ctx, _("Cannot write to device %s, permission denied."),
 636                                 device_path(device));
 637                 else
 638                         log_err(ctx, _("Cannot open device %s."), device_path(device));
 639                 return -EINVAL;
 640         }
 641
 642         memcpy(&convHdr, hdr, hdr_size);
 643         memset(&convHdr._padding, 0, sizeof(convHdr._padding));
 644
 645         /* Convert every uint16/32_t item to network byte order */
 646         convHdr.version            = htons(hdr->version);
 647         convHdr.payloadOffset      = htonl(hdr->payloadOffset);
 648         convHdr.keyBytes           = htonl(hdr->keyBytes);
 649         convHdr.mkDigestIterations = htonl(hdr->mkDigestIterations);
 650         for(i = 0; i < LUKS_NUMKEYS; ++i) {
 651                 convHdr.keyblock[i].active             = htonl(hdr->keyblock[i].active);
 652                 convHdr.keyblock[i].passwordIterations = htonl(hdr->keyblock[i].passwordIterations);
 653                 convHdr.keyblock[i].keyMaterialOffset  = htonl(hdr->keyblock[i].keyMaterialOffset);
 654                 convHdr.keyblock[i].stripes            = htonl(hdr->keyblock[i].stripes);
 655         }
 656
 657         r = write_lseek_blockwise(devfd, device_block_size(ctx, device), device_alignment(device),
 658                             &convHdr, hdr_size, 0) < hdr_size ? -EIO : 0;
 659         if (r)
 660                 log_err(ctx, _("Error during update of LUKS header on device %s."), device_path(device));
 661
 662         device_sync(ctx, device);
 663
 664         /* Re-read header from disk to be sure that in-memory and on-disk data are the same. */
 665         if (!r) {
 666                 r = LUKS_read_phdr(hdr, 1, 0, ctx);
 667                 if (r)
 668                         log_err(ctx, _("Error re-reading LUKS header after update on device %s."),
 669                                 device_path(device));
 670         }
 671
 672         return r;
 673 }
 674
 675 /* Check that kernel supports requested cipher by decryption of one sector */
 676 int LUKS_check_cipher(struct crypt_device *ctx, size_t keylength, const char *cipher, const char *cipher_mode)
 677 {
 678         int r;
 679         struct volume_key *empty_key;
 680         char buf[SECTOR_SIZE];
 681
 682         log_dbg(ctx, "Checking if cipher %s-%s is usable.", cipher, cipher_mode);
 683
 684         empty_key = crypt_alloc_volume_key(keylength, NULL);
 685         if (!empty_key)
 686                 return -ENOMEM;
 687
 688         /* No need to get KEY quality random but it must avoid known weak keys. */
 689         r = crypt_random_get(ctx, empty_key->key, empty_key->keylength, CRYPT_RND_NORMAL);
 690         if (!r)
 691                 r = LUKS_decrypt_from_storage(buf, sizeof(buf), cipher, cipher_mode, empty_key, 0, ctx);
 692
 693         crypt_free_volume_key(empty_key);
 694         crypt_safe_memzero(buf, sizeof(buf));
 695         return r;
 696 }
 697
 698 int LUKS_generate_phdr(struct luks_phdr *header,
 699         const struct volume_key *vk,
 700         const char *cipherName,
 701         const char *cipherMode,
 702         const char *hashSpec,
 703         const char *uuid,
 704         uint64_t data_offset,        /* in bytes */
 705         uint64_t align_offset,       /* in bytes */
 706         uint64_t required_alignment, /* in bytes */
 707         struct crypt_device *ctx)
 708 {
 709         int i, r;
 710         size_t keyslot_sectors, header_sectors;
 711         uuid_t partitionUuid;
 712         struct crypt_pbkdf_type *pbkdf;
 713         double PBKDF2_temp;
 714         char luksMagic[] = LUKS_MAGIC;
 715
 716         if (data_offset % SECTOR_SIZE || align_offset % SECTOR_SIZE ||
 717             required_alignment % SECTOR_SIZE)
 718                 return -EINVAL;
 719
 720         memset(header, 0, sizeof(struct luks_phdr));
 721
 722         keyslot_sectors = AF_split_sectors(vk->keylength, LUKS_STRIPES);
 723         header_sectors = LUKS_ALIGN_KEYSLOTS / SECTOR_SIZE;
 724
 725         for (i = 0; i < LUKS_NUMKEYS; i++) {
 726                 header->keyblock[i].active = LUKS_KEY_DISABLED;
 727                 header->keyblock[i].keyMaterialOffset = header_sectors;
 728                 header->keyblock[i].stripes = LUKS_STRIPES;
 729                 header_sectors = size_round_up(header_sectors + keyslot_sectors,
 730                                                LUKS_ALIGN_KEYSLOTS / SECTOR_SIZE);
 731         }
 732         /* In sector is now size of all keyslot material space */
 733
 734         /* Data offset has priority */
 735         if (data_offset)
 736                 header->payloadOffset = data_offset / SECTOR_SIZE;
 737         else if (required_alignment) {
 738                 header->payloadOffset = size_round_up(header_sectors, (required_alignment / SECTOR_SIZE));
 739                 header->payloadOffset += (align_offset / SECTOR_SIZE);
 740         } else
 741                 header->payloadOffset = 0;
 742
 743         if (header->payloadOffset && header->payloadOffset < header_sectors) {
 744                 log_err(ctx, _("Data offset for LUKS header must be "
 745                                "either 0 or higher than header size."));
 746                 return -EINVAL;
 747         }
 748
 749         if (crypt_hmac_size(hashSpec) < LUKS_DIGESTSIZE) {
 750                 log_err(ctx, _("Requested LUKS hash %s is not supported."), hashSpec);
 751                 return -EINVAL;
 752         }
 753
 754         if (uuid && uuid_parse(uuid, partitionUuid) == -1) {
 755                 log_err(ctx, _("Wrong LUKS UUID format provided."));
 756                 return -EINVAL;
 757         }
 758         if (!uuid)
 759                 uuid_generate(partitionUuid);
 760
 761         /* Set Magic */
 762         memcpy(header->magic,luksMagic,LUKS_MAGIC_L);
 763         header->version=1;
 764         strncpy(header->cipherName,cipherName,LUKS_CIPHERNAME_L-1);
 765         strncpy(header->cipherMode,cipherMode,LUKS_CIPHERMODE_L-1);
 766         strncpy(header->hashSpec,hashSpec,LUKS_HASHSPEC_L-1);
 767
 768         header->keyBytes=vk->keylength;
 769
 770         LUKS_fix_header_compatible(header);
 771
 772         log_dbg(ctx, "Generating LUKS header version %d using hash %s, %s, %s, MK %d bytes",
 773                 header->version, header->hashSpec ,header->cipherName, header->cipherMode,
 774                 header->keyBytes);
 775
 776         r = crypt_random_get(ctx, header->mkDigestSalt, LUKS_SALTSIZE, CRYPT_RND_SALT);
 777         if(r < 0) {
 778                 log_err(ctx, _("Cannot create LUKS header: reading random salt failed."));
 779                 return r;
 780         }
 781
 782         /* Compute master key digest */
 783         pbkdf = crypt_get_pbkdf(ctx);
 784         r = crypt_benchmark_pbkdf_internal(ctx, pbkdf, vk->keylength);
 785         if (r < 0)
 786                 return r;
 787         assert(pbkdf->iterations);
 788
 789         if (pbkdf->flags & CRYPT_PBKDF_NO_BENCHMARK && pbkdf->time_ms == 0)
 790                 PBKDF2_temp = LUKS_MKD_ITERATIONS_MIN;
 791         else    /* iterations per ms * LUKS_MKD_ITERATIONS_MS */
 792                 PBKDF2_temp = (double)pbkdf->iterations * LUKS_MKD_ITERATIONS_MS / pbkdf->time_ms;
 793
 794         if (PBKDF2_temp > (double)UINT32_MAX)
 795                 return -EINVAL;
 796         header->mkDigestIterations = at_least((uint32_t)PBKDF2_temp, LUKS_MKD_ITERATIONS_MIN);
 797         assert(header->mkDigestIterations);
 798
 799         r = crypt_pbkdf(CRYPT_KDF_PBKDF2, header->hashSpec, vk->key,vk->keylength,
 800                         header->mkDigestSalt, LUKS_SALTSIZE,
 801                         header->mkDigest,LUKS_DIGESTSIZE,
 802                         header->mkDigestIterations, 0, 0);
 803         if (r < 0) {
 804                 log_err(ctx, _("Cannot create LUKS header: header digest failed (using hash %s)."),
 805                         header->hashSpec);
 806                 return r;
 807         }
 808
 809         uuid_unparse(partitionUuid, header->uuid);
 810
 811         log_dbg(ctx, "Data offset %d, UUID %s, digest iterations %" PRIu32,
 812                 header->payloadOffset, header->uuid, header->mkDigestIterations);
 813
 814         return 0;
 815 }
 816
 817 int LUKS_hdr_uuid_set(
 818         struct luks_phdr *hdr,
 819         const char *uuid,
 820         struct crypt_device *ctx)
 821 {
 822         uuid_t partitionUuid;
 823
 824         if (uuid && uuid_parse(uuid, partitionUuid) == -1) {
 825                 log_err(ctx, _("Wrong LUKS UUID format provided."));
 826                 return -EINVAL;
 827         }
 828         if (!uuid)
 829                 uuid_generate(partitionUuid);
 830
 831         uuid_unparse(partitionUuid, hdr->uuid);
 832
 833         return LUKS_write_phdr(hdr, ctx);
 834 }
 835
 836 int LUKS_set_key(unsigned int keyIndex,
 837                  const char *password, size_t passwordLen,
 838                  struct luks_phdr *hdr, struct volume_key *vk,
 839                  struct crypt_device *ctx)
 840 {
 841         struct volume_key *derived_key;
 842         char *AfKey = NULL;
 843         size_t AFEKSize;
 844         struct crypt_pbkdf_type *pbkdf;
 845         int r;
 846
 847         if(hdr->keyblock[keyIndex].active != LUKS_KEY_DISABLED) {
 848                 log_err(ctx, _("Key slot %d active, purge first."), keyIndex);
 849                 return -EINVAL;
 850         }
 851
 852         /* LUKS keyslot has always at least 4000 stripes according to specification */
 853         if(hdr->keyblock[keyIndex].stripes < 4000) {
 854                 log_err(ctx, _("Key slot %d material includes too few stripes. Header manipulation?"),
 855                         keyIndex);
 856                  return -EINVAL;
 857         }
 858
 859         log_dbg(ctx, "Calculating data for key slot %d", keyIndex);
 860         pbkdf = crypt_get_pbkdf(ctx);
 861         r = crypt_benchmark_pbkdf_internal(ctx, pbkdf, vk->keylength);
 862         if (r < 0)
 863                 return r;
 864         assert(pbkdf->iterations);
 865
 866         /*
 867          * Final iteration count is at least LUKS_SLOT_ITERATIONS_MIN
 868          */
 869         hdr->keyblock[keyIndex].passwordIterations =
 870                 at_least(pbkdf->iterations, LUKS_SLOT_ITERATIONS_MIN);
 871         log_dbg(ctx, "Key slot %d use %" PRIu32 " password iterations.", keyIndex,
 872                 hdr->keyblock[keyIndex].passwordIterations);
 873
 874         derived_key = crypt_alloc_volume_key(hdr->keyBytes, NULL);
 875         if (!derived_key)
 876                 return -ENOMEM;
 877
 878         r = crypt_random_get(ctx, hdr->keyblock[keyIndex].passwordSalt,
 879                        LUKS_SALTSIZE, CRYPT_RND_SALT);
 880         if (r < 0)
 881                 goto out;
 882
 883         r = crypt_pbkdf(CRYPT_KDF_PBKDF2, hdr->hashSpec, password, passwordLen,
 884                         hdr->keyblock[keyIndex].passwordSalt, LUKS_SALTSIZE,
 885                         derived_key->key, hdr->keyBytes,
 886                         hdr->keyblock[keyIndex].passwordIterations, 0, 0);
 887         if (r < 0)
 888                 goto out;
 889
 890         /*
 891          * AF splitting, the masterkey stored in vk->key is split to AfKey
 892          */
 893         assert(vk->keylength == hdr->keyBytes);
 894         AFEKSize = AF_split_sectors(vk->keylength, hdr->keyblock[keyIndex].stripes) * SECTOR_SIZE;
 895         AfKey = crypt_safe_alloc(AFEKSize);
 896         if (!AfKey) {
 897                 r = -ENOMEM;
 898                 goto out;
 899         }
 900
 901         log_dbg(ctx, "Using hash %s for AF in key slot %d, %d stripes",
 902                 hdr->hashSpec, keyIndex, hdr->keyblock[keyIndex].stripes);
 903         r = AF_split(ctx, vk->key, AfKey, vk->keylength, hdr->keyblock[keyIndex].stripes, hdr->hashSpec);
 904         if (r < 0)
 905                 goto out;
 906
 907         log_dbg(ctx, "Updating key slot %d [0x%04x] area.", keyIndex,
 908                 hdr->keyblock[keyIndex].keyMaterialOffset << 9);
 909         /* Encryption via dm */
 910         r = LUKS_encrypt_to_storage(AfKey,
 911                                     AFEKSize,
 912                                     hdr->cipherName, hdr->cipherMode,
 913                                     derived_key,
 914                                     hdr->keyblock[keyIndex].keyMaterialOffset,
 915                                     ctx);
 916         if (r < 0)
 917                 goto out;
 918
 919         /* Mark the key as active in phdr */
 920         r = LUKS_keyslot_set(hdr, (int)keyIndex, 1, ctx);
 921         if (r < 0)
 922                 goto out;
 923
 924         r = LUKS_write_phdr(hdr, ctx);
 925         if (r < 0)
 926                 goto out;
 927
 928         r = 0;
 929 out:
 930         crypt_safe_free(AfKey);
 931         crypt_free_volume_key(derived_key);
 932         return r;
 933 }
 934
 935 /* Check whether a volume key is invalid. */
 936 int LUKS_verify_volume_key(const struct luks_phdr *hdr,
 937                            const struct volume_key *vk)
 938 {
 939         char checkHashBuf[LUKS_DIGESTSIZE];
 940
 941         if (crypt_pbkdf(CRYPT_KDF_PBKDF2, hdr->hashSpec, vk->key, vk->keylength,
 942                         hdr->mkDigestSalt, LUKS_SALTSIZE,
 943                         checkHashBuf, LUKS_DIGESTSIZE,
 944                         hdr->mkDigestIterations, 0, 0) < 0)
 945                 return -EINVAL;
 946
 947         if (memcmp(checkHashBuf, hdr->mkDigest, LUKS_DIGESTSIZE))
 948                 return -EPERM;
 949
 950         return 0;
 951 }
 952
 953 /* Try to open a particular key slot */
 954 static int LUKS_open_key(unsigned int keyIndex,
 955                   const char *password,
 956                   size_t passwordLen,
 957                   struct luks_phdr *hdr,
 958                   struct volume_key *vk,
 959                   struct crypt_device *ctx)
 960 {
 961         crypt_keyslot_info ki = LUKS_keyslot_info(hdr, keyIndex);
 962         struct volume_key *derived_key;
 963         char *AfKey;
 964         size_t AFEKSize;
 965         int r;
 966
 967         log_dbg(ctx, "Trying to open key slot %d [%s].", keyIndex,
 968                 dbg_slot_state(ki));
 969
 970         if (ki < CRYPT_SLOT_ACTIVE)
 971                 return -ENOENT;
 972
 973         derived_key = crypt_alloc_volume_key(hdr->keyBytes, NULL);
 974         if (!derived_key)
 975                 return -ENOMEM;
 976
 977         assert(vk->keylength == hdr->keyBytes);
 978         AFEKSize = AF_split_sectors(vk->keylength, hdr->keyblock[keyIndex].stripes) * SECTOR_SIZE;
 979         AfKey = crypt_safe_alloc(AFEKSize);
 980         if (!AfKey) {
 981                 r = -ENOMEM;
 982                 goto out;
 983         }
 984
 985         r = crypt_pbkdf(CRYPT_KDF_PBKDF2, hdr->hashSpec, password, passwordLen,
 986                         hdr->keyblock[keyIndex].passwordSalt, LUKS_SALTSIZE,
 987                         derived_key->key, hdr->keyBytes,
 988                         hdr->keyblock[keyIndex].passwordIterations, 0, 0);
 989         if (r < 0) {
 990                 log_err(ctx, _("Cannot open keyslot (using hash %s)."), hdr->hashSpec);
 991                 goto out;
 992         }
 993
 994         log_dbg(ctx, "Reading key slot %d area.", keyIndex);
 995         r = LUKS_decrypt_from_storage(AfKey,
 996                                       AFEKSize,
 997                                       hdr->cipherName, hdr->cipherMode,
 998                                       derived_key,
 999                                       hdr->keyblock[keyIndex].keyMaterialOffset,
1000                                       ctx);
1001         if (r < 0)
1002                 goto out;
1003
1004         r = AF_merge(ctx, AfKey, vk->key, vk->keylength, hdr->keyblock[keyIndex].stripes, hdr->hashSpec);
1005         if (r < 0)
1006                 goto out;
1007
1008         r = LUKS_verify_volume_key(hdr, vk);
1009
1010         /* Allow only empty passphrase with null cipher */
1011         if (!r && !strcmp(hdr->cipherName, "cipher_null") && passwordLen)
1012                 r = -EPERM;
1013 out:
1014         crypt_safe_free(AfKey);
1015         crypt_free_volume_key(derived_key);
1016         return r;
1017 }
1018
1019 int LUKS_open_key_with_hdr(int keyIndex,
1020                            const char *password,
1021                            size_t passwordLen,
1022                            struct luks_phdr *hdr,
1023                            struct volume_key **vk,
1024                            struct crypt_device *ctx)
1025 {
1026         unsigned int i, tried = 0;
1027         int r;
1028
1029         *vk = crypt_alloc_volume_key(hdr->keyBytes, NULL);
1030
1031         if (keyIndex >= 0) {
1032                 r = LUKS_open_key(keyIndex, password, passwordLen, hdr, *vk, ctx);
1033                 return (r < 0) ? r : keyIndex;
1034         }
1035
1036         for (i = 0; i < LUKS_NUMKEYS; i++) {
1037                 r = LUKS_open_key(i, password, passwordLen, hdr, *vk, ctx);
1038                 if(r == 0)
1039                         return i;
1040
1041                 /* Do not retry for errors that are no -EPERM or -ENOENT,
1042                    former meaning password wrong, latter key slot inactive */
1043                 if ((r != -EPERM) && (r != -ENOENT))
1044                         return r;
1045                 if (r == -EPERM)
1046                         tried++;
1047         }
1048         /* Warning, early returns above */
1049         return tried ? -EPERM : -ENOENT;
1050 }
1051
1052 int LUKS_del_key(unsigned int keyIndex,
1053                  struct luks_phdr *hdr,
1054                  struct crypt_device *ctx)
1055 {
1056         struct device *device = crypt_metadata_device(ctx);
1057         unsigned int startOffset, endOffset;
1058         int r;
1059
1060         r = LUKS_read_phdr(hdr, 1, 0, ctx);
1061         if (r)
1062                 return r;
1063
1064         r = LUKS_keyslot_set(hdr, keyIndex, 0, ctx);
1065         if (r) {
1066                 log_err(ctx, _("Key slot %d is invalid, please select keyslot between 0 and %d."),
1067                         keyIndex, LUKS_NUMKEYS - 1);
1068                 return r;
1069         }
1070
1071         /* secure deletion of key material */
1072         startOffset = hdr->keyblock[keyIndex].keyMaterialOffset;
1073         endOffset = startOffset + AF_split_sectors(hdr->keyBytes, hdr->keyblock[keyIndex].stripes);
1074
1075         r = crypt_wipe_device(ctx, device, CRYPT_WIPE_SPECIAL, startOffset * SECTOR_SIZE,
1076                               (endOffset - startOffset) * SECTOR_SIZE,
1077                               (endOffset - startOffset) * SECTOR_SIZE, NULL, NULL);
1078         if (r) {
1079                 if (r == -EACCES) {
1080                         log_err(ctx, _("Cannot write to device %s, permission denied."),
1081                                 device_path(device));
1082                         r = -EINVAL;
1083                 } else
1084                         log_err(ctx, _("Cannot wipe device %s."),
1085                                 device_path(device));
1086                 return r;
1087         }
1088
1089         /* Wipe keyslot info */
1090         memset(&hdr->keyblock[keyIndex].passwordSalt, 0, LUKS_SALTSIZE);
1091         hdr->keyblock[keyIndex].passwordIterations = 0;
1092
1093         r = LUKS_write_phdr(hdr, ctx);
1094
1095         return r;
1096 }
1097
1098 crypt_keyslot_info LUKS_keyslot_info(struct luks_phdr *hdr, int keyslot)
1099 {
1100         int i;
1101
1102         if(keyslot >= LUKS_NUMKEYS || keyslot < 0)
1103                 return CRYPT_SLOT_INVALID;
1104
1105         if (hdr->keyblock[keyslot].active == LUKS_KEY_DISABLED)
1106                 return CRYPT_SLOT_INACTIVE;
1107
1108         if (hdr->keyblock[keyslot].active != LUKS_KEY_ENABLED)
1109                 return CRYPT_SLOT_INVALID;
1110
1111         for(i = 0; i < LUKS_NUMKEYS; i++)
1112                 if(i != keyslot && hdr->keyblock[i].active == LUKS_KEY_ENABLED)
1113                         return CRYPT_SLOT_ACTIVE;
1114
1115         return CRYPT_SLOT_ACTIVE_LAST;
1116 }
1117
1118 int LUKS_keyslot_find_empty(struct luks_phdr *hdr)
1119 {
1120         int i;
1121
1122         for (i = 0; i < LUKS_NUMKEYS; i++)
1123                 if(hdr->keyblock[i].active == LUKS_KEY_DISABLED)
1124                         break;
1125
1126         if (i == LUKS_NUMKEYS)
1127                 return -EINVAL;
1128
1129         return i;
1130 }
1131
1132 int LUKS_keyslot_active_count(struct luks_phdr *hdr)
1133 {
1134         int i, num = 0;
1135
1136         for (i = 0; i < LUKS_NUMKEYS; i++)
1137                 if(hdr->keyblock[i].active == LUKS_KEY_ENABLED)
1138                         num++;
1139
1140         return num;
1141 }
1142
1143 int LUKS_keyslot_set(struct luks_phdr *hdr, int keyslot, int enable, struct crypt_device *ctx)
1144 {
1145         crypt_keyslot_info ki = LUKS_keyslot_info(hdr, keyslot);
1146
1147         if (ki == CRYPT_SLOT_INVALID)
1148                 return -EINVAL;
1149
1150         hdr->keyblock[keyslot].active = enable ? LUKS_KEY_ENABLED : LUKS_KEY_DISABLED;
1151         log_dbg(ctx, "Key slot %d was %s in LUKS header.", keyslot, enable ? "enabled" : "disabled");
1152         return 0;
1153 }
1154
1155 int LUKS1_activate(struct crypt_device *cd,
1156                    const char *name,
1157                    struct volume_key *vk,
1158                    uint32_t flags)
1159 {
1160         int r;
1161         struct crypt_dm_active_device dmd = {
1162                 .flags = flags,
1163                 .uuid = crypt_get_uuid(cd),
1164         };
1165
1166         r = dm_crypt_target_set(&dmd.segment, 0, dmd.size, crypt_data_device(cd),
1167                         vk, crypt_get_cipher_spec(cd), crypt_get_iv_offset(cd),
1168                         crypt_get_data_offset(cd), crypt_get_integrity(cd),
1169                         crypt_get_integrity_tag_size(cd), crypt_get_sector_size(cd));
1170         if (!r)
1171                 r = create_or_reload_device(cd, name, CRYPT_LUKS1, &dmd);
1172
1173         dm_targets_free(cd, &dmd);
1174
1175         return r;
1176 }
1177
1178 int LUKS_wipe_header_areas(struct luks_phdr *hdr,
1179         struct crypt_device *ctx)
1180 {
1181         int i, r;
1182         uint64_t offset, length;
1183         size_t wipe_block;
1184
1185         /* Wipe complete header, keyslots and padding areas with zeroes. */
1186         offset = 0;
1187         length = (uint64_t)hdr->payloadOffset * SECTOR_SIZE;
1188         wipe_block = 1024 * 1024;
1189
1190         /* On detached header or bogus header, wipe at least the first 4k */
1191         if (length == 0 || length > (LUKS_MAX_KEYSLOT_SIZE * LUKS_NUMKEYS)) {
1192                 length = 4096;
1193                 wipe_block = 4096;
1194         }
1195
1196         log_dbg(ctx, "Wiping LUKS areas (0x%06" PRIx64 " - 0x%06" PRIx64") with zeroes.",
1197                 offset, length + offset);
1198
1199         r = crypt_wipe_device(ctx, crypt_metadata_device(ctx), CRYPT_WIPE_ZERO,
1200                               offset, length, wipe_block, NULL, NULL);
1201         if (r < 0)
1202                 return r;
1203
1204         /* Wipe keyslots areas */
1205         wipe_block = 1024 * 1024;
1206         for (i = 0; i < LUKS_NUMKEYS; i++) {
1207                 r = LUKS_keyslot_area(hdr, i, &offset, &length);
1208                 if (r < 0)
1209                         return r;
1210
1211                 /* Ignore too big LUKS1 keyslots here */
1212                 if (length > LUKS_MAX_KEYSLOT_SIZE ||
1213                     offset > (LUKS_MAX_KEYSLOT_SIZE - length))
1214                         continue;
1215
1216                 if (length == 0 || offset < 4096)
1217                         return -EINVAL;
1218
1219                 log_dbg(ctx, "Wiping keyslot %i area (0x%06" PRIx64 " - 0x%06" PRIx64") with random data.",
1220                         i, offset, length + offset);
1221
1222                 r = crypt_wipe_device(ctx, crypt_metadata_device(ctx), CRYPT_WIPE_RANDOM,
1223                                 offset, length, wipe_block, NULL, NULL);
1224                 if (r < 0)
1225                         return r;
1226         }
1227
1228         return r;
1229 }
1230
1231 int LUKS_keyslot_pbkdf(struct luks_phdr *hdr, int keyslot, struct crypt_pbkdf_type *pbkdf)
1232 {
1233         if (LUKS_keyslot_info(hdr, keyslot) < CRYPT_SLOT_ACTIVE)
1234                 return -EINVAL;
1235
1236         pbkdf->type = CRYPT_KDF_PBKDF2;
1237         pbkdf->hash = hdr->hashSpec;
1238         pbkdf->iterations = hdr->keyblock[keyslot].passwordIterations;
1239         pbkdf->max_memory_kb = 0;
1240         pbkdf->parallel_threads = 0;
1241         pbkdf->time_ms = 0;
1242         pbkdf->flags = 0;
1243         return 0;
1244 }