tests/api-test.c

   1 /*
   2  * cryptsetup library API check functions
   3  *
   4  * Copyright (C) 2009-2012 Red Hat, Inc. All rights reserved.
   5  * Copyright (C) 2009-2012, Milan Broz
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <linux/fs.h>
  28 #include <errno.h>
  29 #include <assert.h>
  30 #include <signal.h>
  31 #include <sys/stat.h>
  32 #include <sys/ioctl.h>
  33 #include <libdevmapper.h>
  34
  35 #include "luks.h"
  36 #include "libcryptsetup.h"
  37 #include "utils_loop.h"
  38
  39 #define DMDIR "/dev/mapper/"
  40
  41 #define DEVICE_1_UUID "28632274-8c8a-493f-835b-da802e1c576b"
  42 #define DEVICE_EMPTY_name "crypt_zero"
  43 #define DEVICE_EMPTY DMDIR DEVICE_EMPTY_name
  44 #define DEVICE_ERROR_name "crypt_error"
  45 #define DEVICE_ERROR DMDIR DEVICE_ERROR_name
  46
  47 #define CDEVICE_1 "ctest1"
  48 #define CDEVICE_2 "ctest2"
  49 #define CDEVICE_WRONG "O_o"
  50 #define H_DEVICE "head_ok"
  51 #define H_DEVICE_WRONG "head_wr"
  52 #define L_DEVICE_1S "luks_onesec"
  53 #define L_DEVICE_0S "luks_zerosec"
  54 #define L_DEVICE_WRONG "luks_wr"
  55 #define L_DEVICE_OK "luks_ok"
  56 #define EVL_HEADER_1 "evil_hdr-luks_hdr_damage"
  57 #define EVL_HEADER_2 "evil_hdr-payload_overwrite"
  58 #define EVL_HEADER_3 "evil_hdr-stripes_payload_dmg"
  59 #define EVL_HEADER_4 "evil_hdr-small_luks_device"
  60 #define VALID_HEADER "valid_header_file"
  61 #define BACKUP_FILE "csetup_backup_file"
  62 #define IMAGE1 "compatimage.img"
  63 #define IMAGE_EMPTY "empty.img"
  64
  65 #define KEYFILE1 "key1.file"
  66 #define KEY1 "compatkey"
  67
  68 #define KEYFILE2 "key2.file"
  69 #define KEY2 "0123456789abcdef"
  70
  71 #define PASSPHRASE "blabla"
  72
  73 #define DEVICE_TEST_UUID "12345678-1234-1234-1234-123456789abc"
  74
  75 #define DEVICE_WRONG "/dev/Ooo_"
  76 #define DEVICE_CHAR "/dev/zero"
  77 #define THE_LFILE_TEMPLATE "cryptsetup-tstlp.XXXXXX"
  78
  79 #define SECTOR_SHIFT 9L
  80 #define SECTOR_SIZE 512
  81 #define TST_LOOP_FILE_SIZE (((1<<20)*50)>>SECTOR_SHIFT)
  82 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
  83 #define DIV_ROUND_UP_MODULO(n,d) (DIV_ROUND_UP(n,d)*(d))
  84 #define LUKS_PHDR_SIZE_B 1024
  85
  86 static int _debug   = 0;
  87 static int _verbose = 1;
  88 static int _fips_mode = 0;
  89
  90 static int _quit = 0;
  91
  92 static char global_log[4096];
  93 static int global_lines = 0;
  94
  95 static char *DEVICE_1 = NULL;
  96 static char *DEVICE_2 = NULL;
  97 static char *THE_LOOP_DEV = NULL;
  98
  99 static char *tmp_file_1 = NULL;
 100 static char *test_loop_file = NULL;
 101 static uint64_t t_dev_offset = 0;
 102
 103 static int _system(const char*, int);
 104
 105 // Helpers
 106
 107 static int device_size(const char *device, uint64_t *size)
 108 {
 109         int devfd, r = 0;
 110
 111         devfd = open(device, O_RDONLY);
 112         if(devfd == -1)
 113                 return -EINVAL;
 114
 115         if (ioctl(devfd, BLKGETSIZE64, size) < 0)
 116                 r = -EINVAL;
 117         close(devfd);
 118         return r;
 119 }
 120
 121 static int fips_mode(void)
 122 {
 123         int fd;
 124         char buf = 0;
 125
 126         fd = open("/proc/sys/crypto/fips_enabled", O_RDONLY);
 127
 128         if (fd < 0)
 129                 return 0;
 130
 131         if (read(fd, &buf, 1) != 1)
 132                 buf = '0';
 133
 134         close(fd);
 135
 136         return (buf == '1');
 137 }
 138
 139 static int get_luks_offsets(int metadata_device,
 140                             size_t keylength,
 141                             unsigned int alignpayload_sec,
 142                             unsigned int alignoffset_sec,
 143                             uint64_t *r_header_size,
 144                             uint64_t *r_payload_offset)
 145 {
 146         int i;
 147         uint64_t current_sector;
 148         uint32_t sectors_per_stripes_set;
 149
 150         if (!keylength)
 151                 return -1;
 152
 153         sectors_per_stripes_set = DIV_ROUND_UP(keylength*LUKS_STRIPES, SECTOR_SIZE);
 154         printf("sectors_per_stripes %" PRIu32 "\n", sectors_per_stripes_set);
 155         current_sector = DIV_ROUND_UP_MODULO(DIV_ROUND_UP(LUKS_PHDR_SIZE_B, SECTOR_SIZE),
 156                         LUKS_ALIGN_KEYSLOTS / SECTOR_SIZE);
 157         for(i=0;i < (LUKS_NUMKEYS - 1);i++)
 158                 current_sector = DIV_ROUND_UP_MODULO(current_sector + sectors_per_stripes_set,
 159                                 LUKS_ALIGN_KEYSLOTS / SECTOR_SIZE);
 160         if (r_header_size)
 161                 *r_header_size = current_sector + sectors_per_stripes_set;
 162
 163         current_sector = DIV_ROUND_UP_MODULO(current_sector + sectors_per_stripes_set,
 164                                 LUKS_ALIGN_KEYSLOTS / SECTOR_SIZE);
 165
 166         if (r_payload_offset) {
 167                 if (metadata_device)
 168                         *r_payload_offset = alignpayload_sec;
 169                 else
 170                         *r_payload_offset = DIV_ROUND_UP_MODULO(current_sector, alignpayload_sec)
 171                                 + alignoffset_sec;
 172         }
 173
 174         return 0;
 175 }
 176
 177 /*
 178  * Creates dm-linear target over the test loop device. Offset is held in
 179  * global variables so that size can be tested whether it fits into remaining
 180  * size of the loop device or not
 181  */
 182 static int create_dmdevice_over_loop(const char *dm_name, const uint64_t size)
 183 {
 184         char cmd[128];
 185         int r;
 186         uint64_t r_size;
 187
 188         if(device_size(THE_LOOP_DEV, &r_size) < 0 || r_size <= t_dev_offset || !size)
 189                 return -1;
 190         if ((r_size - t_dev_offset) < size) {
 191                 printf("No enough space on backing loop device\n.");
 192                 return -2;
 193         }
 194         snprintf(cmd, sizeof(cmd),
 195                  "dmsetup create %s --table \"0 %" PRIu64 " linear %s %" PRIu64 "\"",
 196                  dm_name, size, THE_LOOP_DEV, t_dev_offset);
 197         if  (!(r = _system(cmd, 1))) {
 198                 t_dev_offset += size;
 199         }
 200         return r;
 201 }
 202
 203 // TODO some utility to remove dmdevice over the loop file
 204
 205 // Get key from kernel dm mapping table using dm-ioctl
 206 static int _get_key_dm(const char *name, char *buffer, unsigned int buffer_size)
 207 {
 208         struct dm_task *dmt;
 209         struct dm_info dmi;
 210         uint64_t start, length;
 211         char *target_type, *key, *params;
 212         void *next = NULL;
 213         int r = -EINVAL;
 214
 215         if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
 216                 goto out;
 217         if (!dm_task_set_name(dmt, name))
 218                 goto out;
 219         if (!dm_task_run(dmt))
 220                 goto out;
 221         if (!dm_task_get_info(dmt, &dmi))
 222                 goto out;
 223         if (!dmi.exists)
 224                 goto out;
 225
 226         next = dm_get_next_target(dmt, next, &start, &length, &target_type, &params);
 227         if (!target_type || strcmp(target_type, "crypt") != 0)
 228                 goto out;
 229
 230         (void)strsep(&params, " "); /* rcipher */
 231         key = strsep(&params, " ");
 232
 233         if (buffer_size <= strlen(key))
 234                 goto out;
 235
 236         strncpy(buffer, key, buffer_size);
 237         r = 0;
 238 out:
 239         if (dmt)
 240                 dm_task_destroy(dmt);
 241
 242         return r;
 243 }
 244
 245 static int _prepare_keyfile(const char *name, const char *passphrase, int size)
 246 {
 247         int fd, r;
 248
 249         fd = open(name, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR);
 250         if (fd != -1) {
 251                 r = write(fd, passphrase, size);
 252                 close(fd);
 253         } else
 254                 r = 0;
 255
 256         return r == size ? 0 : 1;
 257 }
 258
 259 static void _remove_keyfiles(void)
 260 {
 261         remove(KEYFILE1);
 262         remove(KEYFILE2);
 263 }
 264
 265 // Decode key from its hex representation
 266 static int crypt_decode_key(char *key, const char *hex, unsigned int size)
 267 {
 268         char buffer[3];
 269         char *endp;
 270         unsigned int i;
 271
 272         buffer[2] = '\0';
 273
 274         for (i = 0; i < size; i++) {
 275                 buffer[0] = *hex++;
 276                 buffer[1] = *hex++;
 277
 278                 key[i] = (unsigned char)strtoul(buffer, &endp, 16);
 279
 280                 if (endp != &buffer[2])
 281                         return -1;
 282         }
 283
 284         if (*hex != '\0')
 285                 return -1;
 286
 287         return 0;
 288 }
 289
 290 static void cmdLineLog(int level, const char *msg)
 291 {
 292         strncat(global_log, msg, sizeof(global_log) - strlen(global_log));
 293         global_lines++;
 294 }
 295
 296 static void new_log(int level, const char *msg, void *usrptr)
 297 {
 298         if (_debug)
 299                 printf("LOG: %s", msg);
 300         cmdLineLog(level, msg);
 301 }
 302
 303 static void reset_log(void)
 304 {
 305         memset(global_log, 0, sizeof(global_log));
 306         global_lines = 0;
 307 }
 308
 309 static int _system(const char *command, int warn)
 310 {
 311         int r;
 312         if (_debug)
 313                 printf("Running system: %s\n", command);
 314         if ((r=system(command)) < 0 && warn)
 315                 printf("System command failed: %s", command);
 316         return r;
 317 }
 318
 319 static void _cleanup_dmdevices(void)
 320 {
 321         struct stat st;
 322
 323         if (!stat(DMDIR H_DEVICE, &st)) {
 324                 _system("dmsetup remove " H_DEVICE, 0);
 325         }
 326         if (!stat(DMDIR H_DEVICE_WRONG, &st)) {
 327                 _system("dmsetup remove " H_DEVICE_WRONG, 0);
 328         }
 329         if (!stat(DMDIR L_DEVICE_0S, &st)) {
 330                 _system("dmsetup remove " L_DEVICE_0S, 0);
 331         }
 332         if (!stat(DMDIR L_DEVICE_1S, &st)) {
 333                 _system("dmsetup remove " L_DEVICE_1S, 0);
 334         }
 335         if (!stat(DMDIR L_DEVICE_WRONG, &st)) {
 336                 _system("dmsetup remove " L_DEVICE_WRONG, 0);
 337         }
 338         if (!stat(DMDIR L_DEVICE_OK, &st)) {
 339                 _system("dmsetup remove " L_DEVICE_OK, 0);
 340         }
 341
 342         t_dev_offset = 0;
 343 }
 344
 345 static void _cleanup(void)
 346 {
 347         struct stat st;
 348
 349         //_system("udevadm settle", 0);
 350
 351         if (!stat(DMDIR CDEVICE_1, &st))
 352                 _system("dmsetup remove " CDEVICE_1, 0);
 353
 354         if (!stat(DMDIR CDEVICE_2, &st))
 355                 _system("dmsetup remove " CDEVICE_2, 0);
 356
 357         if (!stat(DEVICE_EMPTY, &st))
 358                 _system("dmsetup remove " DEVICE_EMPTY_name, 0);
 359
 360         if (!stat(DEVICE_ERROR, &st))
 361                 _system("dmsetup remove " DEVICE_ERROR_name, 0);
 362
 363         _cleanup_dmdevices();
 364
 365         if (crypt_loop_device(THE_LOOP_DEV))
 366                 crypt_loop_detach(THE_LOOP_DEV);
 367
 368         if (crypt_loop_device(DEVICE_1))
 369                 crypt_loop_detach(DEVICE_1);
 370
 371         if (crypt_loop_device(DEVICE_2))
 372                 crypt_loop_detach(DEVICE_2);
 373
 374         _system("rm -f " IMAGE_EMPTY, 0);
 375         _system("rm -f " IMAGE1, 0);
 376
 377         remove(test_loop_file);
 378         remove(tmp_file_1);
 379
 380         remove(EVL_HEADER_1);
 381         remove(EVL_HEADER_2);
 382         remove(EVL_HEADER_3);
 383         remove(EVL_HEADER_4);
 384         remove(VALID_HEADER);
 385         remove(BACKUP_FILE);
 386
 387         _remove_keyfiles();
 388
 389         free(tmp_file_1);
 390         free(test_loop_file);
 391         free(THE_LOOP_DEV);
 392         free(DEVICE_1);
 393         free(DEVICE_2);
 394 }
 395
 396 static int _setup(void)
 397 {
 398         int fd, ro = 0;
 399         char cmd[128];
 400
 401         test_loop_file = strdup(THE_LFILE_TEMPLATE);
 402         if ((fd=mkstemp(test_loop_file)) == -1) {
 403                 printf("cannot create temporary file with template %s\n", test_loop_file);
 404                 return 1;
 405         }
 406         close(fd);
 407         snprintf(cmd, sizeof(cmd), "dd if=/dev/zero of=%s bs=%d count=%d 2>/dev/null",
 408                  test_loop_file, SECTOR_SIZE, TST_LOOP_FILE_SIZE);
 409         if (_system(cmd, 1))
 410                 return 1;
 411
 412         if (!THE_LOOP_DEV)
 413                 THE_LOOP_DEV = crypt_loop_get_device();
 414         if (!THE_LOOP_DEV) {
 415                 printf("Cannot find free loop device.\n");
 416                 return 1;
 417         }
 418         if (crypt_loop_device(THE_LOOP_DEV)) {
 419                 fd = crypt_loop_attach(THE_LOOP_DEV, test_loop_file, 0, 0, &ro);
 420                 close(fd);
 421         }
 422
 423         tmp_file_1 = strdup(THE_LFILE_TEMPLATE);
 424         if ((fd=mkstemp(tmp_file_1)) == -1) {
 425                 printf("cannot create temporary file with template %s\n", tmp_file_1);
 426                 return 1;
 427         }
 428         close(fd);
 429         snprintf(cmd, sizeof(cmd), "dd if=/dev/zero of=%s bs=%d count=%d 2>/dev/null",
 430                  tmp_file_1, SECTOR_SIZE, 10);
 431         if (_system(cmd, 1))
 432                 return 1;
 433
 434         _system("dmsetup create " DEVICE_EMPTY_name " --table \"0 10000 zero\"", 1);
 435         _system("dmsetup create " DEVICE_ERROR_name " --table \"0 10000 error\"", 1);
 436         if (!DEVICE_1)
 437                 DEVICE_1 = crypt_loop_get_device();
 438         if (!DEVICE_1) {
 439                 printf("Cannot find free loop device.\n");
 440                 return 1;
 441         }
 442         if (crypt_loop_device(DEVICE_1)) {
 443                 _system(" [ ! -e " IMAGE1 " ] && bzip2 -dk " IMAGE1 ".bz2", 1);
 444                 fd = crypt_loop_attach(DEVICE_1, IMAGE1, 0, 0, &ro);
 445                 close(fd);
 446         }
 447         if (!DEVICE_2)
 448                 DEVICE_2 = crypt_loop_get_device();
 449         if (!DEVICE_2) {
 450                 printf("Cannot find free loop device.\n");
 451                 return 1;
 452         }
 453         if (crypt_loop_device(DEVICE_2)) {
 454                 _system("dd if=/dev/zero of=" IMAGE_EMPTY " bs=1M count=4 2>/dev/null", 1);
 455                 fd = crypt_loop_attach(DEVICE_2, IMAGE_EMPTY, 0, 0, &ro);
 456                 close(fd);
 457         }
 458         /* Keymaterial offset is less than 8 sectors */
 459         _system(" [ ! -e " EVL_HEADER_1 " ] && bzip2 -dk " EVL_HEADER_1 ".bz2", 1);
 460         /* keymaterial offset aims into payload area */
 461         _system(" [ ! -e " EVL_HEADER_2 " ] && bzip2 -dk " EVL_HEADER_2 ".bz2", 1);
 462         /* keymaterial offset is valid, number of stripes causes payload area to be overwriten */
 463         _system(" [ ! -e " EVL_HEADER_3 " ] && bzip2 -dk " EVL_HEADER_3 ".bz2", 1);
 464         /* luks device header for data and header on same device. payloadOffset is greater than
 465          * device size (crypt_load() test) */
 466         _system(" [ ! -e " EVL_HEADER_4 " ] && bzip2 -dk " EVL_HEADER_4 ".bz2", 1);
 467         /* valid header: payloadOffset=4096, key_size=32,
 468          * volume_key = bb21158c733229347bd4e681891e213d94c685be6a5b84818afe7a78a6de7a1a */
 469         _system(" [ ! -e " VALID_HEADER " ] && bzip2 -dk " VALID_HEADER ".bz2", 1);
 470
 471         /* Prepare tcrypt images */
 472         _system(" [ ! -d tcrypt-images ] && tar xjf tcrypt-images.tar.bz2 2>/dev/null", 1);
 473
 474         _system("modprobe dm-crypt", 0);
 475         _system("modprobe dm-verity", 0);
 476
 477         _fips_mode = fips_mode();
 478         if (_debug)
 479                 printf("FIPS MODE: %d\n", _fips_mode);
 480
 481         return 0;
 482 }
 483
 484 static void check_ok(int status, int line, const char *func)
 485 {
 486         char buf[256];
 487
 488         if (status) {
 489                 crypt_get_error(buf, sizeof(buf));
 490                 printf("FAIL line %d [%s]: code %d, %s\n", line, func, status, buf);
 491                 _cleanup();
 492                 exit(-1);
 493         }
 494 }
 495
 496 static void check_ko(int status, int line, const char *func)
 497 {
 498         char buf[256];
 499
 500         memset(buf, 0, sizeof(buf));
 501         crypt_get_error(buf, sizeof(buf));
 502         if (status >= 0) {
 503                 printf("FAIL line %d [%s]: code %d, %s\n", line, func, status, buf);
 504                 _cleanup();
 505                 exit(-1);
 506         } else if (_verbose)
 507                 printf("   => errno %d, errmsg: %s\n", status, buf);
 508 }
 509
 510 static void check_equal(int line, const char *func, int64_t x, int64_t y)
 511 {
 512         printf("FAIL line %d [%s]: expected equal values differs: %"
 513                 PRIi64 " != %" PRIi64 "\n", line, func, x, y);
 514         _cleanup();
 515         exit(-1);
 516 }
 517
 518 static void xlog(const char *msg, const char *tst, const char *func, int line, const char *txt)
 519 {
 520         if (_verbose) {
 521                 if (txt)
 522                         printf(" [%s,%s:%d] %s [%s]\n", msg, func, line, tst, txt);
 523                 else
 524                         printf(" [%s,%s:%d] %s\n", msg, func, line, tst);
 525         }
 526         if (_quit) {
 527                 if (_verbose)
 528                         printf("Interrupted by a signal.\n");
 529                 _cleanup();
 530                 exit(-1);
 531         }
 532 }
 533
 534 /* crypt_device context must be "cd" to parse error properly here */
 535 #define OK_(x)          do { xlog("(success)", #x, __FUNCTION__, __LINE__, NULL); \
 536                              check_ok((x), __LINE__, __FUNCTION__); \
 537                         } while(0)
 538 #define FAIL_(x, y)     do { xlog("(fail)   ", #x, __FUNCTION__, __LINE__, y); \
 539                              check_ko((x), __LINE__, __FUNCTION__); \
 540                         } while(0)
 541 #define EQ_(x, y)       do { xlog("(equal)  ", #x " == " #y, __FUNCTION__, __LINE__, NULL); \
 542                              int64_t _x = (x), _y = (y); \
 543                              if (_x != _y) check_equal(__LINE__, __FUNCTION__, _x, _y); \
 544                         } while(0)
 545 #define RUN_(x, y)              do { printf("%s: %s\n", #x, (y)); x(); } while (0)
 546
 547 static void AddDevicePlain(void)
 548 {
 549         struct crypt_device *cd;
 550         struct crypt_params_plain params = {
 551                 .hash = "sha1",
 552                 .skip = 0,
 553                 .offset = 0,
 554                 .size = 0
 555         };
 556         int fd;
 557         char key[128], key2[128], path[128];
 558
 559         const char *passphrase = PASSPHRASE;
 560         // hashed hex version of PASSPHRASE
 561         const char *mk_hex = "bb21158c733229347bd4e681891e213d94c685be6a5b84818afe7a78a6de7a1a";
 562         size_t key_size = strlen(mk_hex) / 2;
 563         const char *cipher = "aes";
 564         const char *cipher_mode = "cbc-essiv:sha256";
 565
 566         uint64_t size, r_size;
 567
 568         crypt_decode_key(key, mk_hex, key_size);
 569         FAIL_(crypt_init(&cd, ""), "empty device string");
 570         FAIL_(crypt_init(&cd, DEVICE_WRONG), "nonexistent device name ");
 571         FAIL_(crypt_init(&cd, DEVICE_CHAR), "character device as backing device");
 572         OK_(crypt_init(&cd, tmp_file_1));
 573         crypt_free(cd);
 574
 575         // test crypt_format, crypt_get_cipher, crypt_get_cipher_mode, crypt_get_volume_key_size
 576         OK_(crypt_init(&cd,DEVICE_1));
 577         params.skip = 3;
 578         params.offset = 42;
 579         FAIL_(crypt_format(cd,CRYPT_PLAIN,NULL,cipher_mode,NULL,NULL,key_size,&params),"cipher param is null");
 580         FAIL_(crypt_format(cd,CRYPT_PLAIN,cipher,NULL,NULL,NULL,key_size,&params),"cipher_mode param is null");
 581         OK_(crypt_format(cd,CRYPT_PLAIN,cipher,cipher_mode,NULL,NULL,key_size,&params));
 582         OK_(strcmp(cipher_mode,crypt_get_cipher_mode(cd)));
 583         OK_(strcmp(cipher,crypt_get_cipher(cd)));
 584         EQ_((int)key_size, crypt_get_volume_key_size(cd));
 585         EQ_(params.skip, crypt_get_iv_offset(cd));
 586         EQ_(params.offset, crypt_get_data_offset(cd));
 587         params.skip = 0;
 588         params.offset = 0;
 589
 590         // crypt_set_uuid()
 591         FAIL_(crypt_set_uuid(cd,DEVICE_1_UUID),"can't set uuid to plain device");
 592
 593         crypt_free(cd);
 594
 595         // default is "plain" hash - no password hash
 596         OK_(crypt_init(&cd, DEVICE_1));
 597         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, NULL));
 598         FAIL_(crypt_activate_by_volume_key(cd, NULL, key, key_size, 0), "cannot verify key with plain");
 599         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
 600         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 601         OK_(crypt_deactivate(cd, CDEVICE_1));
 602         crypt_free(cd);
 603
 604         // test boundaries in offset parameter
 605         device_size(DEVICE_1,&size);
 606         params.hash = NULL;
 607         // zero sectors length
 608         params.offset = size >> SECTOR_SHIFT;
 609         OK_(crypt_init(&cd, DEVICE_1));
 610         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 611         EQ_(crypt_get_data_offset(cd),params.offset);
 612         // device size is 0 sectors
 613         FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0), "invalid device size (0 blocks)");
 614         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
 615         // data part of crypt device is of 1 sector size
 616         params.offset = (size >> SECTOR_SHIFT) - 1;
 617         crypt_free(cd);
 618
 619         OK_(crypt_init(&cd, DEVICE_1));
 620         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 621         OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0));
 622         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 623         snprintf(path, sizeof(path), "%s/%s", crypt_get_dir(), CDEVICE_1);
 624         if (device_size(path, &r_size) >= 0)
 625                 EQ_(r_size>>SECTOR_SHIFT, 1);
 626         OK_(crypt_deactivate(cd, CDEVICE_1));
 627         crypt_free(cd);
 628
 629         // size > device_size
 630         params.offset = 0;
 631         params.size = (size >> SECTOR_SHIFT) + 1;
 632         crypt_init(&cd, DEVICE_1);
 633         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 634         FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0),"Device too small");
 635         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
 636         crypt_free(cd);
 637
 638         // offset == device_size (autodetect size)
 639         params.offset = (size >> SECTOR_SHIFT);
 640         params.size = 0;
 641         crypt_init(&cd, DEVICE_1);
 642         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 643         FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0),"Device too small");
 644         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
 645         crypt_free(cd);
 646
 647         // offset == device_size (user defined size)
 648         params.offset = (size >> SECTOR_SHIFT);
 649         params.size = 123;
 650         crypt_init(&cd, DEVICE_1);
 651         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 652         FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0),"Device too small");
 653         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
 654         crypt_free(cd);
 655
 656         // offset+size > device_size
 657         params.offset = 42;
 658         params.size = (size >> SECTOR_SHIFT) - params.offset + 1;
 659         crypt_init(&cd, DEVICE_1);
 660         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 661         FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0),"Offset and size are beyond device real size");
 662         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
 663         crypt_free(cd);
 664
 665         // offset+size == device_size
 666         params.offset = 42;
 667         params.size = (size >> SECTOR_SHIFT) - params.offset;
 668         crypt_init(&cd, DEVICE_1);
 669         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 670         OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0));
 671         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 672         if (!device_size(path, &r_size))
 673                 EQ_((r_size >> SECTOR_SHIFT),params.size);
 674         OK_(crypt_deactivate(cd,CDEVICE_1));
 675
 676         crypt_free(cd);
 677         params.hash = "sha1";
 678         params.offset = 0;
 679         params.size = 0;
 680         params.skip = 0;
 681
 682         // Now use hashed password
 683         OK_(crypt_init(&cd, DEVICE_1));
 684         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 685         FAIL_(crypt_activate_by_passphrase(cd, NULL, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0),
 686               "cannot verify passphrase with plain" );
 687         OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0));
 688
 689         // device status check
 690         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 691         snprintf(path, sizeof(path), "%s/%s", crypt_get_dir(), CDEVICE_1);
 692         fd = open(path, O_RDONLY);
 693         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_BUSY);
 694         FAIL_(crypt_deactivate(cd, CDEVICE_1), "Device is busy");
 695         close(fd);
 696         OK_(crypt_deactivate(cd, CDEVICE_1));
 697         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
 698         crypt_free(cd);
 699
 700         // crypt_init_by_name_and_header
 701         OK_(crypt_init(&cd,DEVICE_1));
 702         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 703         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
 704         crypt_free(cd);
 705
 706         FAIL_(crypt_init_by_name_and_header(&cd, CDEVICE_1, H_DEVICE),"can't init plain device by header device");
 707         OK_(crypt_init_by_name(&cd, CDEVICE_1));
 708         OK_(strcmp(cipher_mode,crypt_get_cipher_mode(cd)));
 709         OK_(strcmp(cipher,crypt_get_cipher(cd)));
 710         EQ_((int)key_size, crypt_get_volume_key_size(cd));
 711         EQ_(params.skip, crypt_get_iv_offset(cd));
 712         EQ_(params.offset, crypt_get_data_offset(cd));
 713         OK_(crypt_deactivate(cd, CDEVICE_1));
 714         crypt_free(cd);
 715
 716         OK_(crypt_init(&cd,DEVICE_1));
 717         OK_(crypt_format(cd,CRYPT_PLAIN,cipher,cipher_mode,NULL,NULL,key_size,&params));
 718         params.size = 0;
 719         params.offset = 0;
 720
 721         // crypt_set_data_device
 722         FAIL_(crypt_set_data_device(cd,H_DEVICE),"can't set data device for plain device");
 723
 724         // crypt_get_type
 725         OK_(strcmp(crypt_get_type(cd),CRYPT_PLAIN));
 726
 727         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
 728         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 729
 730         // crypt_resize()
 731         OK_(crypt_resize(cd,CDEVICE_1,size>>SECTOR_SHIFT)); // same size
 732         if (!device_size(path,&r_size))
 733                 EQ_(r_size, size);
 734
 735         // size overlaps
 736         FAIL_(crypt_resize(cd, CDEVICE_1, (uint64_t)-1),"Backing device is too small");
 737         FAIL_(crypt_resize(cd, CDEVICE_1, (size>>SECTOR_SHIFT)+1),"crypt device overlaps backing device");
 738
 739         // resize ok
 740         OK_(crypt_resize(cd,CDEVICE_1, 123));
 741         if (!device_size(path,&r_size))
 742                 EQ_(r_size>>SECTOR_SHIFT, 123);
 743         OK_(crypt_resize(cd,CDEVICE_1,0)); // full size (autodetect)
 744         if (!device_size(path,&r_size))
 745                 EQ_(r_size, size);
 746         OK_(crypt_deactivate(cd,CDEVICE_1));
 747         EQ_(crypt_status(cd,CDEVICE_1),CRYPT_INACTIVE);
 748         crypt_free(cd);
 749
 750         // offset tests
 751         OK_(crypt_init(&cd,DEVICE_1));
 752         params.offset = 42;
 753         params.size = (size>>SECTOR_SHIFT) - params.offset - 10;
 754         OK_(crypt_format(cd,CRYPT_PLAIN,cipher,cipher_mode,NULL,NULL,key_size,&params));
 755         OK_(crypt_activate_by_volume_key(cd,CDEVICE_1,key,key_size,0));
 756         if (!device_size(path,&r_size))
 757                 EQ_(r_size>>SECTOR_SHIFT, params.size);
 758         // resize to fill remaining capacity
 759         OK_(crypt_resize(cd,CDEVICE_1,params.size + 10));
 760         if (!device_size(path,&r_size))
 761                 EQ_(r_size>>SECTOR_SHIFT, params.size + 10);
 762
 763         // 1 sector beyond real size
 764         FAIL_(crypt_resize(cd,CDEVICE_1,params.size + 11), "new device size overlaps backing device"); // with respect to offset
 765         if (!device_size(path,&r_size))
 766                 EQ_(r_size>>SECTOR_SHIFT, params.size + 10);
 767         EQ_(crypt_status(cd,CDEVICE_1),CRYPT_ACTIVE);
 768         fd = open(path, O_RDONLY);
 769         close(fd);
 770         OK_(fd < 0);
 771
 772         // resize to minimal size
 773         OK_(crypt_resize(cd,CDEVICE_1, 1)); // minimal device size
 774         if (!device_size(path,&r_size))
 775                 EQ_(r_size>>SECTOR_SHIFT, 1);
 776         // use size of backing device (autodetect with respect to offset)
 777         OK_(crypt_resize(cd,CDEVICE_1,0));
 778         if (!device_size(path,&r_size))
 779                 EQ_(r_size>>SECTOR_SHIFT, (size >> SECTOR_SHIFT)- 42);
 780         OK_(crypt_deactivate(cd,CDEVICE_1));
 781         crypt_free(cd);
 782
 783         params.size = 0;
 784         params.offset = 0;
 785         OK_(crypt_init(&cd,DEVICE_1));
 786         OK_(crypt_format(cd,CRYPT_PLAIN,cipher,cipher_mode,NULL,NULL,key_size,&params));
 787         OK_(crypt_activate_by_volume_key(cd,CDEVICE_1,key,key_size,0));
 788
 789         // suspend/resume tests
 790         FAIL_(crypt_suspend(cd,CDEVICE_1),"cannot suspend plain device");
 791         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 792         FAIL_(crypt_resume_by_passphrase(cd,CDEVICE_1,CRYPT_ANY_SLOT,passphrase, strlen(passphrase)),"cannot resume plain device");
 793         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 794
 795         // retrieve volume key check
 796         if (!_fips_mode) {
 797                 memset(key2, 0, key_size);
 798                 key_size--;
 799                 // small buffer
 800                 FAIL_(crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key2, &key_size, passphrase, strlen(passphrase)), "small buffer");
 801                 key_size++;
 802                 OK_(crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key2, &key_size, passphrase, strlen(passphrase)));
 803
 804                 OK_(memcmp(key, key2, key_size));
 805         }
 806         OK_(strcmp(cipher, crypt_get_cipher(cd)));
 807         OK_(strcmp(cipher_mode, crypt_get_cipher_mode(cd)));
 808         EQ_((int)key_size, crypt_get_volume_key_size(cd));
 809         EQ_(0, crypt_get_data_offset(cd));
 810         OK_(crypt_deactivate(cd, CDEVICE_1));
 811
 812         // now with keyfile
 813         OK_(_prepare_keyfile(KEYFILE1, KEY1, strlen(KEY1)));
 814         OK_(_prepare_keyfile(KEYFILE2, KEY2, strlen(KEY2)));
 815         FAIL_(crypt_activate_by_keyfile(cd, NULL, CRYPT_ANY_SLOT, KEYFILE1, 0, 0), "cannot verify key with plain");
 816         EQ_(0, crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 0, 0));
 817         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 818         OK_(crypt_deactivate(cd, CDEVICE_1));
 819         FAIL_(crypt_activate_by_keyfile_offset(cd, NULL, CRYPT_ANY_SLOT, KEYFILE1, 0, strlen(KEY1) + 1, 0), "cannot seek");
 820         EQ_(0, crypt_activate_by_keyfile_offset(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 0, 0, 0));
 821         OK_(crypt_deactivate(cd, CDEVICE_1));
 822         _remove_keyfiles();
 823         crypt_free(cd);
 824
 825         OK_(crypt_init(&cd,DEVICE_1));
 826         OK_(crypt_format(cd,CRYPT_PLAIN,cipher,cipher_mode,NULL,NULL,key_size,&params));
 827
 828         // crypt_keyslot_*()
 829         FAIL_(crypt_keyslot_add_by_passphrase(cd,CRYPT_ANY_SLOT,passphrase,strlen(passphrase),passphrase,strlen(passphrase)), "can't add keyslot to plain device");
 830         FAIL_(crypt_keyslot_add_by_volume_key(cd,CRYPT_ANY_SLOT ,key,key_size,passphrase,strlen(passphrase)),"can't add keyslot to plain device");
 831         FAIL_(crypt_keyslot_add_by_keyfile(cd,CRYPT_ANY_SLOT,KEYFILE1,strlen(KEY1),KEYFILE2,strlen(KEY2)),"can't add keyslot to plain device");
 832         FAIL_(crypt_keyslot_destroy(cd,1),"can't manipulate keyslots on plain device");
 833         EQ_(crypt_keyslot_status(cd, 0), CRYPT_SLOT_INVALID);
 834         _remove_keyfiles();
 835
 836         crypt_free(cd);
 837 }
 838
 839 #define CALLBACK_ERROR "calback_error xyz"
 840 static int pass_callback_err(const char *msg, char *buf, size_t length, void *usrptr)
 841 {
 842         struct crypt_device *cd = usrptr;
 843
 844         assert(cd);
 845         assert(length);
 846         assert(msg);
 847
 848         crypt_log(cd, CRYPT_LOG_ERROR, CALLBACK_ERROR);
 849         return -EINVAL;
 850 }
 851
 852 static int pass_callback_ok(const char *msg, char *buf, size_t length, void *usrptr)
 853 {
 854         assert(length);
 855         assert(msg);
 856         strcpy(buf, PASSPHRASE);
 857         return strlen(buf);
 858 }
 859
 860 static void CallbacksTest(void)
 861 {
 862         struct crypt_device *cd;
 863         struct crypt_params_plain params = {
 864                 .hash = "sha1",
 865                 .skip = 0,
 866                 .offset = 0,
 867         };
 868
 869         size_t key_size = 256 / 8;
 870         const char *cipher = "aes";
 871         const char *cipher_mode = "cbc-essiv:sha256";
 872         const char *passphrase = PASSPHRASE;
 873         char buf1[256] = {0}, buf2[256] = {0};
 874
 875         OK_(crypt_init(&cd, DEVICE_1));
 876         crypt_set_log_callback(cd, &new_log, NULL);
 877         //crypt_set_log_callback(cd, NULL, NULL);
 878
 879         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &params));
 880
 881         OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0));
 882         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 883         OK_(crypt_deactivate(cd, CDEVICE_1));
 884
 885         reset_log();
 886         crypt_set_password_callback(cd, pass_callback_err, cd);
 887         FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, NULL, 0, 0), "callback fails");
 888         EQ_(strncmp(global_log, CALLBACK_ERROR, strlen(CALLBACK_ERROR)), 0);
 889
 890         crypt_set_password_callback(cd, pass_callback_ok, NULL);
 891         OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, NULL, 0, 0));
 892         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 893         OK_(crypt_deactivate(cd, CDEVICE_1));
 894
 895         // Check error reporting.
 896         // This must fail and create error message
 897         crypt_deactivate(cd, CDEVICE_1);
 898
 899         // Here context must be the same
 900         crypt_get_error(buf1, sizeof(buf1));
 901         crypt_last_error(cd, buf2, sizeof(buf2));
 902         OK_(!*buf1);
 903         OK_(!*buf2);
 904         OK_(strcmp(buf1, buf2));
 905
 906         crypt_get_error(buf1, sizeof(buf1));
 907         crypt_last_error(cd, buf2, sizeof(buf2));
 908         OK_(*buf1);
 909         OK_(*buf2);
 910
 911         crypt_free(cd);
 912 }
 913
 914 static void UseLuksDevice(void)
 915 {
 916         struct crypt_device *cd;
 917         char key[128];
 918         size_t key_size;
 919
 920         OK_(crypt_init(&cd, DEVICE_1));
 921         OK_(crypt_load(cd, CRYPT_LUKS1, NULL));
 922         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
 923         OK_(crypt_activate_by_passphrase(cd, NULL, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0));
 924         OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0));
 925         FAIL_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0), "already open");
 926         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 927         OK_(crypt_deactivate(cd, CDEVICE_1));
 928         FAIL_(crypt_deactivate(cd, CDEVICE_1), "no such device");
 929
 930         key_size = 16;
 931         OK_(strcmp("aes", crypt_get_cipher(cd)));
 932         OK_(strcmp("cbc-essiv:sha256", crypt_get_cipher_mode(cd)));
 933         OK_(strcmp(DEVICE_1_UUID, crypt_get_uuid(cd)));
 934         EQ_((int)key_size, crypt_get_volume_key_size(cd));
 935         EQ_(1032, crypt_get_data_offset(cd));
 936
 937         if (!_fips_mode) {
 938                 EQ_(0, crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key, &key_size, KEY1, strlen(KEY1)));
 939                 OK_(crypt_volume_key_verify(cd, key, key_size));
 940                 OK_(crypt_activate_by_volume_key(cd, NULL, key, key_size, 0));
 941                 OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
 942                 EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
 943                 OK_(crypt_deactivate(cd, CDEVICE_1));
 944
 945                 key[1] = ~key[1];
 946                 FAIL_(crypt_volume_key_verify(cd, key, key_size), "key mismatch");
 947                 FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0), "key mismatch");
 948         }
 949         crypt_free(cd);
 950 }
 951
 952 static void SuspendDevice(void)
 953 {
 954         int suspend_status;
 955         struct crypt_device *cd;
 956
 957         OK_(crypt_init(&cd, DEVICE_1));
 958         OK_(crypt_load(cd, CRYPT_LUKS1, NULL));
 959         OK_(crypt_activate_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1), 0));
 960
 961         suspend_status = crypt_suspend(cd, CDEVICE_1);
 962         if (suspend_status == -ENOTSUP) {
 963                 printf("WARNING: Suspend/Resume not supported, skipping test.\n");
 964                 goto out;
 965         }
 966         OK_(suspend_status);
 967         FAIL_(crypt_suspend(cd, CDEVICE_1), "already suspended");
 968
 969         FAIL_(crypt_resume_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1)-1), "wrong key");
 970         OK_(crypt_resume_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1)));
 971         FAIL_(crypt_resume_by_passphrase(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEY1, strlen(KEY1)), "not suspended");
 972
 973         OK_(_prepare_keyfile(KEYFILE1, KEY1, strlen(KEY1)));
 974         OK_(crypt_suspend(cd, CDEVICE_1));
 975         FAIL_(crypt_resume_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1 "blah", 0), "wrong keyfile");
 976         FAIL_(crypt_resume_by_keyfile_offset(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 1, 0), "wrong key");
 977         OK_(crypt_resume_by_keyfile_offset(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 0, 0));
 978         FAIL_(crypt_resume_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 0), "not suspended");
 979         _remove_keyfiles();
 980 out:
 981         OK_(crypt_deactivate(cd, CDEVICE_1));
 982         crypt_free(cd);
 983 }
 984
 985 static void AddDeviceLuks(void)
 986 {
 987         struct crypt_device *cd;
 988         struct crypt_params_luks1 params = {
 989                 .hash = "sha512",
 990                 .data_alignment = 2048, // 4M, data offset will be 4096
 991                 .data_device = DEVICE_2
 992         };
 993         char key[128], key2[128];
 994
 995         const char *passphrase = "blabla", *passphrase2 = "nsdkFI&Y#.sd";
 996         const char *mk_hex = "bb21158c733229347bd4e681891e213d94c685be6a5b84818afe7a78a6de7a1a";
 997         size_t key_size = strlen(mk_hex) / 2;
 998         const char *cipher = "aes";
 999         const char *cipher_mode = "cbc-essiv:sha256";
1000         uint64_t r_payload_offset, r_header_size, r_size_1;
1001
1002         crypt_decode_key(key, mk_hex, key_size);
1003
1004         // init test devices
1005         OK_(get_luks_offsets(1, key_size, 0, 0, &r_header_size, &r_payload_offset));
1006         OK_(create_dmdevice_over_loop(H_DEVICE, r_header_size));
1007         OK_(create_dmdevice_over_loop(H_DEVICE_WRONG, r_header_size - 1));
1008
1009         // format
1010         OK_(crypt_init(&cd, DMDIR H_DEVICE_WRONG));
1011         params.data_alignment = 0;
1012         FAIL_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params), "Not enough space for keyslots material");
1013         crypt_free(cd);
1014
1015         // test payload_offset = 0 for encrypted device with external header device
1016         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1017         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1018         EQ_(crypt_get_data_offset(cd), 0);
1019         crypt_free(cd);
1020
1021         params.data_alignment = 0;
1022         params.data_device = NULL;
1023
1024         // test payload_offset = 0. format() should look up alignment offset from device topology
1025         OK_(crypt_init(&cd, DEVICE_2));
1026         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1027         OK_(!(crypt_get_data_offset(cd) > 0));
1028         crypt_free(cd);
1029
1030         /*
1031          * test limit values for backing device size
1032          */
1033         params.data_alignment = 4096;
1034         OK_(get_luks_offsets(0, key_size, params.data_alignment, 0, NULL, &r_payload_offset));
1035         OK_(create_dmdevice_over_loop(L_DEVICE_0S, r_payload_offset));
1036         OK_(create_dmdevice_over_loop(L_DEVICE_1S, r_payload_offset + 1));
1037         //OK_(create_dmdevice_over_loop(L_DEVICE_WRONG, r_payload_offset - 1));
1038         OK_(create_dmdevice_over_loop(L_DEVICE_WRONG, 2050 - 1)); //FIXME last keyslot - 1 sector
1039
1040         // 1 sector less than required
1041         OK_(crypt_init(&cd, DMDIR L_DEVICE_WRONG));
1042         FAIL_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params), "Device too small");
1043         crypt_free(cd);
1044
1045         // 0 sectors for encrypted area
1046         OK_(crypt_init(&cd, DMDIR L_DEVICE_0S));
1047         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1048         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0), "Encrypted area too small");
1049         crypt_free(cd);
1050
1051         // 1 sector for encrypted area
1052         OK_(crypt_init(&cd, DMDIR L_DEVICE_1S));
1053         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1054         EQ_(crypt_get_data_offset(cd), params.data_alignment);
1055         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1056         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1057         OK_(device_size(DMDIR CDEVICE_1, &r_size_1));
1058         EQ_(r_size_1, SECTOR_SIZE);
1059         OK_(crypt_deactivate(cd, CDEVICE_1));
1060         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
1061         // restrict format only to empty context
1062         FAIL_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params), "Context is already formated");
1063         FAIL_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, NULL), "Context is already formated");
1064         // change data device to wrong one
1065         OK_(crypt_set_data_device(cd, DMDIR L_DEVICE_0S));
1066         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0), "Device too small");
1067         OK_(crypt_set_data_device(cd, DMDIR L_DEVICE_1S));
1068         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1069         OK_(crypt_deactivate(cd, CDEVICE_1));
1070         crypt_free(cd);
1071
1072         params.data_alignment = 0;
1073         params.data_device = DEVICE_2;
1074
1075         // generate keyslot material at the end of luks header
1076         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1077         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1078         EQ_(crypt_keyslot_add_by_volume_key(cd, 7, key, key_size, passphrase, strlen(passphrase)), 7);
1079         EQ_(crypt_activate_by_passphrase(cd, CDEVICE_1, 7, passphrase, strlen(passphrase) ,0), 7);
1080         crypt_free(cd);
1081         OK_(crypt_init_by_name_and_header(&cd, CDEVICE_1, DMDIR H_DEVICE));
1082         FAIL_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params), "Context is already formated");
1083         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1084         OK_(crypt_deactivate(cd, CDEVICE_1));
1085         crypt_free(cd);
1086
1087         params.data_alignment = 2048;
1088         params.data_device = NULL;
1089
1090         // test uuid mismatch and _init_by_name_and_header
1091         OK_(crypt_init(&cd, DMDIR L_DEVICE_1S));
1092         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1093         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1094         crypt_free(cd);
1095         params.data_alignment = 0;
1096         params.data_device = DEVICE_2;
1097         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1098         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1099         crypt_free(cd);
1100         // there we've got uuid mismatch
1101         OK_(crypt_init_by_name_and_header(&cd, CDEVICE_1, DMDIR H_DEVICE));
1102         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1103         OK_(!!crypt_get_type(cd));
1104         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0), "Device is active");
1105         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_2, key, key_size, 0), "Device is active");
1106         EQ_(crypt_status(cd, CDEVICE_2), CRYPT_INACTIVE);
1107         OK_(crypt_deactivate(cd, CDEVICE_1));
1108         crypt_free(cd);
1109
1110         params.data_device = NULL;
1111
1112         OK_(crypt_init(&cd, DEVICE_2));
1113         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1114
1115         // even with no keyslots defined it can be activated by volume key
1116         OK_(crypt_volume_key_verify(cd, key, key_size));
1117         OK_(crypt_activate_by_volume_key(cd, CDEVICE_2, key, key_size, 0));
1118         EQ_(crypt_status(cd, CDEVICE_2), CRYPT_ACTIVE);
1119         OK_(crypt_deactivate(cd, CDEVICE_2));
1120
1121         // now with keyslot
1122         EQ_(7, crypt_keyslot_add_by_volume_key(cd, 7, key, key_size, passphrase, strlen(passphrase)));
1123         EQ_(CRYPT_SLOT_ACTIVE_LAST, crypt_keyslot_status(cd, 7));
1124         EQ_(7, crypt_activate_by_passphrase(cd, CDEVICE_2, CRYPT_ANY_SLOT, passphrase, strlen(passphrase), 0));
1125         EQ_(crypt_status(cd, CDEVICE_2), CRYPT_ACTIVE);
1126         OK_(crypt_deactivate(cd, CDEVICE_2));
1127
1128         crypt_set_iteration_time(cd, 1);
1129         EQ_(1, crypt_keyslot_add_by_volume_key(cd, 1, key, key_size, KEY1, strlen(KEY1)));
1130         OK_(_prepare_keyfile(KEYFILE1, KEY1, strlen(KEY1)));
1131         OK_(_prepare_keyfile(KEYFILE2, KEY2, strlen(KEY2)));
1132         EQ_(2, crypt_keyslot_add_by_keyfile(cd, 2, KEYFILE1, 0, KEYFILE2, 0));
1133         FAIL_(crypt_keyslot_add_by_keyfile_offset(cd, 3, KEYFILE1, 0, 1, KEYFILE2, 0, 1), "wrong key");
1134         EQ_(3, crypt_keyslot_add_by_keyfile_offset(cd, 3, KEYFILE1, 0, 0, KEYFILE2, 0, 1));
1135         EQ_(4, crypt_keyslot_add_by_keyfile_offset(cd, 4, KEYFILE2, 0, 1, KEYFILE1, 0, 1));
1136         FAIL_(crypt_activate_by_keyfile(cd, CDEVICE_2, CRYPT_ANY_SLOT, KEYFILE2, strlen(KEY2)-1, 0), "key mismatch");
1137         EQ_(2, crypt_activate_by_keyfile(cd, NULL, CRYPT_ANY_SLOT, KEYFILE2, 0, 0));
1138         EQ_(3, crypt_activate_by_keyfile_offset(cd, NULL, CRYPT_ANY_SLOT, KEYFILE2, 0, 1, 0));
1139         EQ_(4, crypt_activate_by_keyfile_offset(cd, NULL, CRYPT_ANY_SLOT, KEYFILE1, 0, 1, 0));
1140         FAIL_(crypt_activate_by_keyfile_offset(cd, CDEVICE_2, CRYPT_ANY_SLOT, KEYFILE2, strlen(KEY2), 2, 0), "not enough data");
1141         FAIL_(crypt_activate_by_keyfile_offset(cd, CDEVICE_2, CRYPT_ANY_SLOT, KEYFILE2, 0, strlen(KEY2) + 1, 0), "cannot seek");
1142         FAIL_(crypt_activate_by_keyfile_offset(cd, CDEVICE_2, CRYPT_ANY_SLOT, KEYFILE2, 0, 2, 0), "wrong key");
1143         EQ_(2, crypt_activate_by_keyfile(cd, CDEVICE_2, CRYPT_ANY_SLOT, KEYFILE2, 0, 0));
1144         OK_(crypt_keyslot_destroy(cd, 1));
1145         OK_(crypt_keyslot_destroy(cd, 2));
1146         OK_(crypt_keyslot_destroy(cd, 3));
1147         OK_(crypt_keyslot_destroy(cd, 4));
1148         OK_(crypt_deactivate(cd, CDEVICE_2));
1149         _remove_keyfiles();
1150
1151         FAIL_(crypt_keyslot_add_by_volume_key(cd, 7, key, key_size, passphrase, strlen(passphrase)), "slot used");
1152         key[1] = ~key[1];
1153         FAIL_(crypt_keyslot_add_by_volume_key(cd, 6, key, key_size, passphrase, strlen(passphrase)), "key mismatch");
1154         key[1] = ~key[1];
1155         EQ_(6, crypt_keyslot_add_by_volume_key(cd, 6, key, key_size, passphrase, strlen(passphrase)));
1156         EQ_(CRYPT_SLOT_ACTIVE, crypt_keyslot_status(cd, 6));
1157
1158         FAIL_(crypt_keyslot_destroy(cd, 8), "invalid keyslot");
1159         FAIL_(crypt_keyslot_destroy(cd, CRYPT_ANY_SLOT), "invalid keyslot");
1160         FAIL_(crypt_keyslot_destroy(cd, 0), "keyslot not used");
1161         OK_(crypt_keyslot_destroy(cd, 7));
1162         EQ_(CRYPT_SLOT_INACTIVE, crypt_keyslot_status(cd, 7));
1163         EQ_(CRYPT_SLOT_ACTIVE_LAST, crypt_keyslot_status(cd, 6));
1164
1165         EQ_(7, crypt_keyslot_change_by_passphrase(cd, 6, 7, passphrase, strlen(passphrase), passphrase2, strlen(passphrase2)));
1166         EQ_(CRYPT_SLOT_ACTIVE_LAST, crypt_keyslot_status(cd, 7));
1167         EQ_(7, crypt_activate_by_passphrase(cd, NULL, 7, passphrase2, strlen(passphrase2), 0));
1168         EQ_(6, crypt_keyslot_change_by_passphrase(cd, CRYPT_ANY_SLOT, 6, passphrase2, strlen(passphrase2), passphrase, strlen(passphrase)));
1169
1170         if (!_fips_mode) {
1171                 EQ_(6, crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key2, &key_size, passphrase, strlen(passphrase)));
1172                 OK_(crypt_volume_key_verify(cd, key2, key_size));
1173
1174                 OK_(memcmp(key, key2, key_size));
1175         }
1176         OK_(strcmp(cipher, crypt_get_cipher(cd)));
1177         OK_(strcmp(cipher_mode, crypt_get_cipher_mode(cd)));
1178         EQ_((int)key_size, crypt_get_volume_key_size(cd));
1179         EQ_(4096, crypt_get_data_offset(cd));
1180         OK_(strcmp(DEVICE_2, crypt_get_device_name(cd)));
1181
1182         reset_log();
1183         crypt_set_log_callback(cd, &new_log, NULL);
1184         OK_(crypt_dump(cd));
1185         OK_(!(global_lines != 0));
1186         crypt_set_log_callback(cd, NULL, NULL);
1187         reset_log();
1188
1189         FAIL_(crypt_set_uuid(cd, "blah"), "wrong UUID format");
1190         OK_(crypt_set_uuid(cd, DEVICE_TEST_UUID));
1191         OK_(strcmp(DEVICE_TEST_UUID, crypt_get_uuid(cd)));
1192
1193         FAIL_(crypt_deactivate(cd, CDEVICE_2), "not active");
1194         crypt_free(cd);
1195         _cleanup_dmdevices();
1196 }
1197
1198 static void UseTempVolumes(void)
1199 {
1200         struct crypt_device *cd;
1201         char tmp[256];
1202
1203         // Tepmporary device without keyslot but with on-disk LUKS header
1204         OK_(crypt_init(&cd, DEVICE_2));
1205         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_2, NULL, 0, 0), "not yet formatted");
1206         OK_(crypt_format(cd, CRYPT_LUKS1, "aes", "cbc-essiv:sha256", NULL, NULL, 16, NULL));
1207         OK_(crypt_activate_by_volume_key(cd, CDEVICE_2, NULL, 0, 0));
1208         EQ_(crypt_status(cd, CDEVICE_2), CRYPT_ACTIVE);
1209         crypt_free(cd);
1210
1211         OK_(crypt_init_by_name(&cd, CDEVICE_2));
1212         OK_(crypt_deactivate(cd, CDEVICE_2));
1213         crypt_free(cd);
1214
1215         // Dirty checks: device without UUID
1216         // we should be able to remove it but not manuipulate with it
1217         snprintf(tmp, sizeof(tmp), "dmsetup create %s --table \""
1218                 "0 100 crypt aes-cbc-essiv:sha256 deadbabedeadbabedeadbabedeadbabe 0 "
1219                 "%s 2048\"", CDEVICE_2, DEVICE_2);
1220         _system(tmp, 1);
1221         OK_(crypt_init_by_name(&cd, CDEVICE_2));
1222         OK_(crypt_deactivate(cd, CDEVICE_2));
1223         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_2, NULL, 0, 0), "No known device type");
1224         crypt_free(cd);
1225
1226         // Dirty checks: device with UUID but LUKS header key fingerprint must fail)
1227         snprintf(tmp, sizeof(tmp), "dmsetup create %s --table \""
1228                 "0 100 crypt aes-cbc-essiv:sha256 deadbabedeadbabedeadbabedeadbabe 0 "
1229                 "%s 2048\" -u CRYPT-LUKS1-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-ctest1",
1230                  CDEVICE_2, DEVICE_2);
1231         _system(tmp, 1);
1232         OK_(crypt_init_by_name(&cd, CDEVICE_2));
1233         OK_(crypt_deactivate(cd, CDEVICE_2));
1234         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_2, NULL, 0, 0), "wrong volume key");
1235         crypt_free(cd);
1236
1237         // No slots
1238         OK_(crypt_init(&cd, DEVICE_2));
1239         OK_(crypt_load(cd, CRYPT_LUKS1, NULL));
1240         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_2, NULL, 0, 0), "volume key is lost");
1241         crypt_free(cd);
1242
1243         // Plain device
1244         OK_(crypt_init(&cd, DEVICE_2));
1245         OK_(crypt_format(cd, CRYPT_PLAIN, "aes", "cbc-essiv:sha256", NULL, NULL, 16, NULL));
1246         FAIL_(crypt_activate_by_volume_key(cd, NULL, "xxx", 3, 0), "cannot verify key with plain");
1247         FAIL_(crypt_volume_key_verify(cd, "xxx", 3), "cannot verify key with plain");
1248         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_2, "xxx", 3, 0), "wrong key lenght");
1249         OK_(crypt_activate_by_volume_key(cd, CDEVICE_2, "volumekeyvolumek", 16, 0));
1250         EQ_(crypt_status(cd, CDEVICE_2), CRYPT_ACTIVE);
1251         OK_(crypt_deactivate(cd, CDEVICE_2));
1252         crypt_free(cd);
1253 }
1254
1255 static void LuksHeaderRestore(void)
1256 {
1257         struct crypt_device *cd;
1258         struct crypt_params_luks1 params = {
1259                 .hash = "sha512",
1260                 .data_alignment = 2048, // 4M, data offset will be 4096
1261         };
1262         struct crypt_params_plain pl_params = {
1263                 .hash = "sha1",
1264                 .skip = 0,
1265                 .offset = 0,
1266                 .size = 0
1267         };
1268         char key[128], key2[128], cmd[256];
1269
1270         const char *mk_hex = "bb21158c733229347bd4e681891e213d94c685be6a5b84818afe7a78a6de7a1a";
1271         size_t key_size = strlen(mk_hex) / 2;
1272         const char *cipher = "aes";
1273         const char *cipher_mode = "cbc-essiv:sha256";
1274         uint64_t r_payload_offset;
1275
1276         crypt_decode_key(key, mk_hex, key_size);
1277
1278         OK_(get_luks_offsets(0, key_size, params.data_alignment, 0, NULL, &r_payload_offset));
1279         OK_(create_dmdevice_over_loop(L_DEVICE_OK, r_payload_offset + 5000));
1280
1281         // do not restore header over plain device
1282         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1283         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, NULL, key_size, &pl_params));
1284         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1285         FAIL_(crypt_header_restore(cd, CRYPT_PLAIN, VALID_HEADER), "Cannot restore header to PLAIN type device");
1286         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, VALID_HEADER), "Cannot restore header over PLAIN type device");
1287         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1288         OK_(crypt_deactivate(cd, CDEVICE_1));
1289         crypt_free(cd);
1290
1291         // invalid headers
1292         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1293         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1294         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_1), "Header corrupted");
1295         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_2), "Header corrupted");
1296         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_3), "Header corrupted");
1297         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_4), "Header too small");
1298         OK_(crypt_header_restore(cd, CRYPT_LUKS1, VALID_HEADER));
1299         // wipe valid luks header
1300         snprintf(cmd, sizeof(cmd), "dd if=/dev/zero of=" DMDIR L_DEVICE_OK " bs=512 count=%" PRIu64 " 2>/dev/null", r_payload_offset);
1301         OK_(_system(cmd, 1));
1302         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_1), "Header corrupted");
1303         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_2), "Header corrupted");
1304         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_3), "Header corrupted");
1305         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, EVL_HEADER_4), "Header too small");
1306         OK_(crypt_header_restore(cd, CRYPT_LUKS1, VALID_HEADER));
1307         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1308         OK_(crypt_deactivate(cd, CDEVICE_1));
1309         crypt_free(cd);
1310
1311         // volume key_size mismatch
1312         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1313         memcpy(key2, key, key_size - 1);
1314         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key2, key_size - 1, &params));
1315         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, VALID_HEADER), "Volume keysize mismatch");
1316         crypt_free(cd);
1317
1318         // payload offset mismatch
1319         params.data_alignment = 8192;
1320         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1321         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1322         FAIL_(crypt_header_restore(cd, CRYPT_LUKS1, VALID_HEADER), "Payload offset mismatch");
1323         //_system("dmsetup table;sleep 1",1);
1324         crypt_free(cd);
1325
1326         _cleanup_dmdevices();
1327 }
1328
1329 static void LuksHeaderLoad(void)
1330 {
1331         struct crypt_device *cd;
1332         struct crypt_params_luks1 params = {
1333                 .hash = "sha512",
1334                 .data_alignment = 2048,
1335         };
1336         struct crypt_params_plain pl_params = {
1337                 .hash = "sha1",
1338                 .skip = 0,
1339                 .offset = 0,
1340                 .size = 0
1341         };
1342         char key[128], cmd[256];
1343
1344         const char *mk_hex = "bb21158c733229347bd4e681891e213d94c685be6a5b84818afe7a78a6de7a1a";
1345         size_t key_size = strlen(mk_hex) / 2;
1346         const char *cipher = "aes";
1347         const char *cipher_mode = "cbc-essiv:sha256";
1348         uint64_t r_payload_offset, r_header_size;
1349
1350         crypt_decode_key(key, mk_hex, key_size);
1351
1352         // prepare test env
1353         OK_(get_luks_offsets(0, key_size, params.data_alignment, 0, &r_header_size, &r_payload_offset));
1354         // external header device
1355         OK_(create_dmdevice_over_loop(H_DEVICE, r_header_size));
1356         // prepared header on a device too small to contain header and payload
1357         //OK_(create_dmdevice_over_loop(H_DEVICE_WRONG, r_payload_offset - 1));
1358         OK_(create_dmdevice_over_loop(H_DEVICE_WRONG, 2050 - 1)); //FIXME
1359         //snprintf(cmd, sizeof(cmd), "dd if=" EVL_HEADER_4 " of=" DMDIR H_DEVICE_WRONG " bs=512 count=%" PRIu64, r_payload_offset - 1);
1360         snprintf(cmd, sizeof(cmd), "dd if=" EVL_HEADER_4 " of=" DMDIR H_DEVICE_WRONG " bs=512 count=%d 2>/dev/null", 2050 - 1);
1361         OK_(_system(cmd, 1));
1362         // some device
1363         OK_(create_dmdevice_over_loop(L_DEVICE_OK, r_payload_offset + 1000));
1364         // 1 sector device
1365         OK_(create_dmdevice_over_loop(L_DEVICE_1S, r_payload_offset + 1));
1366         // 0 sectors device for payload
1367         OK_(create_dmdevice_over_loop(L_DEVICE_0S, r_payload_offset));
1368
1369         // valid metadata and device size
1370         params.data_alignment = 0;
1371         params.data_device = DMDIR L_DEVICE_OK;
1372         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1373         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1374         crypt_free(cd);
1375         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1376         OK_(crypt_load(cd, CRYPT_LUKS1, NULL));
1377         OK_(crypt_set_data_device(cd, DMDIR L_DEVICE_OK));
1378         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1379         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1380         OK_(crypt_deactivate(cd, CDEVICE_1));
1381         crypt_free(cd);
1382
1383         // bad header: device too small (payloadOffset > device_size)
1384         OK_(crypt_init(&cd, DMDIR H_DEVICE_WRONG));
1385         FAIL_(crypt_load(cd, CRYPT_LUKS1, NULL), "Device too small");
1386         OK_(!!crypt_get_type(cd));
1387         crypt_free(cd);
1388
1389         // 0 secs for encrypted data area
1390         params.data_alignment = 2048;
1391         params.data_device = NULL;
1392         OK_(crypt_init(&cd, DMDIR L_DEVICE_0S));
1393         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1394         crypt_free(cd);
1395         // load should be ok
1396         OK_(crypt_init(&cd, DMDIR L_DEVICE_0S));
1397         OK_(crypt_load(cd, CRYPT_LUKS1, NULL));
1398         FAIL_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0), "Device too small");
1399         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_INACTIVE);
1400         crypt_free(cd);
1401
1402         // damaged header
1403         OK_(_system("dd if=/dev/zero of=" DMDIR L_DEVICE_OK " bs=512 count=8 2>/dev/null", 1));
1404         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1405         FAIL_(crypt_load(cd, CRYPT_LUKS1, NULL), "Header not found");
1406         crypt_free(cd);
1407
1408         // plain device
1409         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1410         FAIL_(crypt_load(cd, CRYPT_PLAIN, NULL), "Can't load nonLUKS device type");
1411         crypt_free(cd);
1412         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1413         OK_(crypt_format(cd, CRYPT_PLAIN, cipher, cipher_mode, NULL, key, key_size, &pl_params));
1414         FAIL_(crypt_load(cd, CRYPT_LUKS1, NULL), "Can't load over nonLUKS device type");
1415         crypt_free(cd);
1416
1417         _cleanup_dmdevices();
1418 }
1419
1420 static void LuksHeaderBackup(void)
1421 {
1422         struct crypt_device *cd;
1423         struct crypt_params_luks1 params = {
1424                 .hash = "sha512",
1425                 .data_alignment = 2048,
1426         };
1427         char key[128];
1428
1429         const char *mk_hex = "bb21158c733229347bd4e681891e213d94c685be6a5b84818afe7a78a6de7a1a";
1430         size_t key_size = strlen(mk_hex) / 2;
1431         const char *cipher = "aes";
1432         const char *cipher_mode = "cbc-essiv:sha256";
1433         uint64_t r_payload_offset;
1434
1435         crypt_decode_key(key, mk_hex, key_size);
1436
1437         OK_(get_luks_offsets(0, key_size, params.data_alignment, 0, NULL, &r_payload_offset));
1438         OK_(create_dmdevice_over_loop(L_DEVICE_OK, r_payload_offset + 1));
1439
1440         // create LUKS device and backup the header
1441         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1442         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1443         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1444         OK_(crypt_header_backup(cd, CRYPT_LUKS1, BACKUP_FILE));
1445         OK_(crypt_deactivate(cd, CDEVICE_1));
1446         crypt_free(cd);
1447
1448         // restore header from backup
1449         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1450         OK_(crypt_header_restore(cd, CRYPT_LUKS1, BACKUP_FILE));
1451         OK_(crypt_load(cd, CRYPT_LUKS1, NULL));
1452         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1453         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1454         OK_(crypt_deactivate(cd, CDEVICE_1));
1455         crypt_free(cd);
1456
1457         _cleanup_dmdevices();
1458 }
1459
1460 static void ResizeDeviceLuks(void)
1461 {
1462         struct crypt_device *cd;
1463         struct crypt_params_luks1 params = {
1464                 .hash = "sha512",
1465                 .data_alignment = 2048,
1466         };
1467         char key[128];
1468
1469         const char *mk_hex = "bb21158c733229347bd4e681891e213d94c685be6a5b84818afe7a78a6de7a1a";
1470         size_t key_size = strlen(mk_hex) / 2;
1471         const char *cipher = "aes";
1472         const char *cipher_mode = "cbc-essiv:sha256";
1473         uint64_t r_payload_offset, r_header_size, r_size;
1474
1475         crypt_decode_key(key, mk_hex, key_size);
1476
1477         // prepare env
1478         OK_(get_luks_offsets(0, key_size, params.data_alignment, 0, NULL, &r_payload_offset));
1479         OK_(get_luks_offsets(1, key_size, 0, 0, &r_header_size, NULL));
1480         OK_(create_dmdevice_over_loop(H_DEVICE, r_header_size));
1481         OK_(create_dmdevice_over_loop(L_DEVICE_OK, r_payload_offset + 1000));
1482         OK_(create_dmdevice_over_loop(L_DEVICE_0S, 1000));
1483
1484         // test header and encrypted payload all in one device
1485         OK_(crypt_init(&cd, DMDIR L_DEVICE_OK));
1486         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1487         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1488         OK_(crypt_resize(cd, CDEVICE_1, 42));
1489         if (!device_size(DMDIR CDEVICE_1, &r_size))
1490                 EQ_(42, r_size >> SECTOR_SHIFT);
1491         // autodetect encrypted device area size
1492         OK_(crypt_resize(cd, CDEVICE_1, 0));
1493         if (!device_size(DMDIR CDEVICE_1, &r_size))
1494                 EQ_(1000, r_size >> SECTOR_SHIFT);
1495         FAIL_(crypt_resize(cd, CDEVICE_1, 1001), "Device too small");
1496         if (!device_size(DMDIR CDEVICE_1, &r_size))
1497                 EQ_(1000, r_size >> SECTOR_SHIFT);
1498         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1499         OK_(crypt_deactivate(cd, CDEVICE_1));
1500         crypt_free(cd);
1501
1502         params.data_alignment = 0;
1503         params.data_device = DMDIR L_DEVICE_0S;
1504         // test case for external header
1505         OK_(crypt_init(&cd, DMDIR H_DEVICE));
1506         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1507         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, key, key_size, 0));
1508         OK_(crypt_resize(cd, CDEVICE_1, 666));
1509         if (!device_size(DMDIR CDEVICE_1, &r_size))
1510                 EQ_(666, r_size >> SECTOR_SHIFT);
1511         // autodetect encrypted device size
1512         OK_(crypt_resize(cd, CDEVICE_1, 0));
1513         if (!device_size(DMDIR CDEVICE_1, &r_size))
1514                 EQ_(1000, r_size >> SECTOR_SHIFT);
1515         FAIL_(crypt_resize(cd, CDEVICE_1, 1001), "Device too small");
1516         if (!device_size(DMDIR CDEVICE_1, &r_size))
1517                 EQ_(1000, r_size >> SECTOR_SHIFT);
1518         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1519         OK_(crypt_deactivate(cd, CDEVICE_1));
1520         crypt_free(cd);
1521
1522         _cleanup_dmdevices();
1523 }
1524
1525 static void HashDevicePlain(void)
1526 {
1527         struct crypt_device *cd;
1528         struct crypt_params_plain params = {
1529                 .hash = NULL,
1530                 .skip = 0,
1531                 .offset = 0,
1532         };
1533
1534         size_t key_size;
1535         const char *mk_hex, *keystr;
1536         char key[256];
1537
1538         OK_(crypt_init(&cd, DEVICE_1));
1539         OK_(crypt_format(cd, CRYPT_PLAIN, "aes", "cbc-essiv:sha256", NULL, NULL, 16, &params));
1540
1541         // hash PLAIN, short key
1542         OK_(_prepare_keyfile(KEYFILE1, "tooshort", 8));
1543         FAIL_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 16, 0), "not enough data in keyfile");
1544         _remove_keyfiles();
1545
1546         // hash PLAIN, exact key
1547         //         0 1 2 3 4 5 6 7 8 9 a b c d e f
1548         mk_hex = "caffeecaffeecaffeecaffeecaffee88";
1549         key_size = 16;
1550         crypt_decode_key(key, mk_hex, key_size);
1551         OK_(_prepare_keyfile(KEYFILE1, key, key_size));
1552         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, key_size, 0));
1553         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1554         OK_(strcmp(key, mk_hex));
1555         OK_(crypt_deactivate(cd, CDEVICE_1));
1556
1557         // Limit plain key
1558         mk_hex = "caffeecaffeecaffeecaffeeca000000";
1559         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, key_size - 3, 0));
1560         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1561         OK_(strcmp(key, mk_hex));
1562         OK_(crypt_deactivate(cd, CDEVICE_1));
1563
1564         _remove_keyfiles();
1565
1566         // hash PLAIN, long key
1567         //         0 1 2 3 4 5 6 7 8 9 a b c d e f
1568         mk_hex = "caffeecaffeecaffeecaffeecaffee88babebabe";
1569         key_size = 16;
1570         crypt_decode_key(key, mk_hex, key_size);
1571         OK_(_prepare_keyfile(KEYFILE1, key, strlen(mk_hex) / 2));
1572         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, key_size, 0));
1573         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1574         FAIL_(strcmp(key, mk_hex), "only key length used");
1575         OK_(strncmp(key, mk_hex, key_size));
1576         OK_(crypt_deactivate(cd, CDEVICE_1));
1577
1578
1579         // Now without explicit limit
1580         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 0, 0));
1581         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1582         FAIL_(strcmp(key, mk_hex), "only key length used");
1583         OK_(strncmp(key, mk_hex, key_size));
1584         OK_(crypt_deactivate(cd, CDEVICE_1));
1585         crypt_free(cd);
1586
1587         _remove_keyfiles();
1588
1589         // hash sha256
1590         params.hash = "sha256";
1591         OK_(crypt_init(&cd, DEVICE_1));
1592         OK_(crypt_format(cd, CRYPT_PLAIN, "aes", "cbc-essiv:sha256", NULL, NULL, 16, &params));
1593
1594         //         0 1 2 3 4 5 6 7 8 9 a b c d e f
1595         mk_hex = "c62e4615bd39e222572f3a1bf7c2132e";
1596         keystr = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
1597         key_size = strlen(keystr); // 32
1598         OK_(_prepare_keyfile(KEYFILE1, keystr, strlen(keystr)));
1599         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, key_size, 0));
1600         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1601         OK_(strcmp(key, mk_hex));
1602         OK_(crypt_deactivate(cd, CDEVICE_1));
1603
1604         // Read full keyfile
1605         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 0, 0));
1606         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1607         OK_(strcmp(key, mk_hex));
1608         OK_(crypt_deactivate(cd, CDEVICE_1));
1609
1610         _remove_keyfiles();
1611
1612         // Limit keyfile read
1613         keystr = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxAAAAAAAA";
1614         OK_(_prepare_keyfile(KEYFILE1, keystr, strlen(keystr)));
1615         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, key_size, 0));
1616         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1617         OK_(strcmp(key, mk_hex));
1618         OK_(crypt_deactivate(cd, CDEVICE_1));
1619
1620         // Full keyfile
1621         OK_(crypt_activate_by_keyfile(cd, CDEVICE_1, CRYPT_ANY_SLOT, KEYFILE1, 0, 0));
1622         OK_(_get_key_dm(CDEVICE_1, key, sizeof(key)));
1623         OK_(strcmp(key, "0e49cb34a1dee1df33f6505e4de44a66"));
1624         OK_(crypt_deactivate(cd, CDEVICE_1));
1625
1626         _remove_keyfiles();
1627
1628         // FIXME: add keyfile="-" tests somehow
1629
1630         crypt_free(cd);
1631 }
1632
1633 static void VerityTest(void)
1634 {
1635         struct crypt_device *cd;
1636         const char *salt_hex =  "20c28ffc129c12360ba6ceea2b6cf04e89c2b41cfe6b8439eb53c1897f50df7b";
1637         const char *root_hex =  "ab018b003a967fc782effb293b6dccb60b4f40c06bf80d16391acf686d28b5d6";
1638         char salt[256], root_hash[256];
1639         struct crypt_active_device cad;
1640         struct crypt_params_verity params = {
1641                 .data_device = DEVICE_EMPTY,
1642                 .salt = salt,
1643                 .data_size = 0, /* whole device */
1644                 .hash_area_offset = 0,
1645                 .flags = CRYPT_VERITY_CREATE_HASH,
1646         };
1647
1648         crypt_decode_key(salt, salt_hex, strlen(salt_hex) / 2);
1649         crypt_decode_key(root_hash, root_hex, strlen(root_hex) / 2);
1650
1651         /* Format */
1652         OK_(crypt_init(&cd, DEVICE_2));
1653
1654         /* block size */
1655         params.data_block_size = 333;
1656         FAIL_(crypt_format(cd, CRYPT_VERITY, NULL, NULL, NULL, NULL, 0, &params),
1657                 "Unsupppored block size.");
1658         params.data_block_size = 4096;
1659         params.hash_block_size = 333;
1660         FAIL_(crypt_format(cd, CRYPT_VERITY, NULL, NULL, NULL, NULL, 0, &params),
1661                 "Unsupppored block size.");
1662         params.hash_block_size = 4096;
1663
1664         /* salt size */
1665         params.salt_size = 257;
1666         FAIL_(crypt_format(cd, CRYPT_VERITY, NULL, NULL, NULL, NULL, 0, &params),
1667                 "Too large salt.");
1668         params.salt_size = 32;
1669
1670         /* hash_type */
1671         params.hash_type = 3;
1672         FAIL_(crypt_format(cd, CRYPT_VERITY, NULL, NULL, NULL, NULL, 0, &params),
1673                 "Unsupported hash type.");
1674         params.hash_type = 1;
1675         params.hash_name = "blah";
1676         FAIL_(crypt_format(cd, CRYPT_VERITY, NULL, NULL, NULL, NULL, 0, &params),
1677                 "Unsupported hash name.");
1678         params.hash_name = "sha256";
1679
1680         OK_(crypt_format(cd, CRYPT_VERITY, NULL, NULL, NULL, NULL, 0, &params));
1681         crypt_free(cd);
1682
1683         /* Verify */
1684         OK_(crypt_init(&cd, DEVICE_2));
1685         memset(&params, 0, sizeof(params));
1686         params.data_device = DEVICE_EMPTY;
1687         params.flags = CRYPT_VERITY_CHECK_HASH;
1688         OK_(crypt_load(cd, CRYPT_VERITY, &params));
1689
1690         /* check verity params */
1691         EQ_(crypt_get_volume_key_size(cd), 32);
1692         OK_(strcmp(CRYPT_VERITY, crypt_get_type(cd)));
1693         memset(&params, 0, sizeof(params));
1694         OK_(crypt_get_verity_info(cd, &params));
1695         OK_(strcmp("sha256", params.hash_name));
1696         EQ_(strlen(salt_hex) / 2, params.salt_size);
1697         OK_(memcmp(salt, params.salt, params.salt_size));
1698         EQ_(4096, params.data_block_size);
1699         EQ_(4096, params.hash_block_size);
1700         EQ_(1, params.hash_type);
1701         EQ_(crypt_get_volume_key_size(cd), 32);
1702
1703         OK_(crypt_activate_by_volume_key(cd, NULL, root_hash, 32, 0));
1704         OK_(crypt_set_data_device(cd, DEVICE_1));
1705         FAIL_(crypt_activate_by_volume_key(cd, NULL, root_hash, 32, 0), "Data corrupted");;
1706
1707         OK_(crypt_set_data_device(cd, DEVICE_EMPTY));
1708         if (crypt_activate_by_volume_key(cd, CDEVICE_1, root_hash, 32,
1709             CRYPT_ACTIVATE_READONLY) == -ENOTSUP) {
1710                 printf("WARNING: kernel dm-verity not supported, skipping test.\n");
1711                 crypt_free(cd);
1712                 return;
1713         }
1714         OK_(crypt_get_active_device(cd, CDEVICE_1, &cad));
1715         EQ_(CRYPT_ACTIVATE_READONLY, cad.flags);
1716         crypt_free(cd);
1717
1718         OK_(crypt_init_by_name(&cd, CDEVICE_1));
1719         OK_(crypt_deactivate(cd, CDEVICE_1));
1720
1721         /* hash fail */
1722         root_hash[1] = ~root_hash[1];
1723         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, root_hash, 32, CRYPT_ACTIVATE_READONLY));
1724         OK_(crypt_get_active_device(cd, CDEVICE_1, &cad));
1725         EQ_(CRYPT_ACTIVATE_READONLY|CRYPT_ACTIVATE_CORRUPTED, cad.flags);
1726         OK_(crypt_deactivate(cd, CDEVICE_1));
1727         root_hash[1] = ~root_hash[1];
1728
1729         /* data fail */
1730         OK_(crypt_set_data_device(cd, DEVICE_1));
1731         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, root_hash, 32, CRYPT_ACTIVATE_READONLY));
1732         OK_(crypt_get_active_device(cd, CDEVICE_1, &cad));
1733         EQ_(CRYPT_ACTIVATE_READONLY|CRYPT_ACTIVATE_CORRUPTED, cad.flags);
1734         OK_(crypt_deactivate(cd, CDEVICE_1));
1735
1736         crypt_free(cd);
1737 }
1738
1739 static void TcryptTest(void)
1740 {
1741         struct crypt_device *cd = NULL;
1742         struct crypt_active_device cad;
1743         const char *passphrase = "aaaaaaaaaaaa";
1744         const char *kf1 = "tcrypt-images/keyfile1";
1745         const char *kf2 = "tcrypt-images/keyfile2";
1746         const char *keyfiles[] = { kf1, kf2 };
1747         struct crypt_params_tcrypt params = {
1748                 .passphrase = passphrase,
1749                 .passphrase_size = strlen(passphrase),
1750                 .keyfiles = keyfiles,
1751                 .keyfiles_count = 2,
1752         };
1753         double enc_mbr = 0, dec_mbr = 0;
1754         const char *tcrypt_dev = "tcrypt-images/tck_5-sha512-xts-aes";
1755         size_t key_size = 64;
1756         char key[key_size], key_def[key_size];
1757         const char *key_hex =
1758                 "98dee64abe44bbf41d171c1f7b3e8eacda6d6b01f459097459a167f8c2872a96"
1759                 "3979531d1cdc18af62757cf22286f16f8583d848524f128d7594ac2082668c73";
1760         int r;
1761
1762         crypt_decode_key(key_def, key_hex, strlen(key_hex) / 2);
1763
1764         // First ensure we can use af_alg skcipher interface
1765         r = crypt_benchmark(NULL, "aes", "xts", 512, 16, 1024, &enc_mbr, &dec_mbr);
1766         if (r == -ENOTSUP || r == -ENOENT) {
1767                 printf("WARNING: algif_skcipher interface not present, skipping test.\n");
1768                 return;
1769         }
1770
1771         OK_(crypt_init(&cd, tcrypt_dev));
1772         params.passphrase_size--;
1773         FAIL_(crypt_load(cd, CRYPT_TCRYPT, &params), "Wrong passphrase");
1774         params.passphrase_size++;
1775         OK_(crypt_load(cd, CRYPT_TCRYPT, &params));
1776
1777         // check params after load
1778         OK_(strcmp("xts-plain64", crypt_get_cipher_mode(cd)));
1779         OK_(strcmp("aes", crypt_get_cipher(cd)));
1780         EQ_(key_size, crypt_get_volume_key_size(cd));
1781         EQ_(256, crypt_get_iv_offset(cd));
1782         EQ_(256, crypt_get_data_offset(cd));
1783
1784         memset(key, 0, key_size);
1785         if (!_fips_mode) {
1786                 key_size--;
1787                 // small buffer
1788                 FAIL_(crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key, &key_size, NULL, 0), "small buffer");
1789                 key_size++;
1790                 OK_(crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key, &key_size, NULL, 0));
1791                 OK_(memcmp(key, key_def, key_size));
1792         }
1793
1794         reset_log();
1795         crypt_set_log_callback(cd, &new_log, NULL);
1796         OK_(crypt_dump(cd));
1797         OK_(!(global_lines != 0));
1798         crypt_set_log_callback(cd, NULL, NULL);
1799         reset_log();
1800
1801         OK_(crypt_activate_by_volume_key(cd, CDEVICE_1, NULL, 0, CRYPT_ACTIVATE_READONLY));
1802         crypt_free(cd);
1803
1804         OK_(crypt_init_by_name_and_header(&cd, CDEVICE_1, NULL));
1805         EQ_(crypt_status(cd, CDEVICE_1), CRYPT_ACTIVE);
1806
1807         FAIL_(crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key, &key_size, NULL, 0), "Need crypt_load");
1808
1809         // check params after init_by_name
1810         OK_(strcmp("xts-plain64", crypt_get_cipher_mode(cd)));
1811         OK_(strcmp("aes", crypt_get_cipher(cd)));
1812         EQ_(key_size, crypt_get_volume_key_size(cd));
1813         EQ_(256, crypt_get_iv_offset(cd));
1814         EQ_(256, crypt_get_data_offset(cd));
1815
1816         OK_(crypt_get_active_device(cd, CDEVICE_1, &cad));
1817         EQ_(CRYPT_ACTIVATE_READONLY, cad.flags);
1818         EQ_(256, cad.offset);
1819         EQ_(256, cad.iv_offset);
1820         EQ_(72, cad.size);
1821
1822         OK_(crypt_deactivate(cd, CDEVICE_1));
1823         crypt_free(cd);
1824 }
1825
1826 // Check that gcrypt is properly initialised in format
1827 static void NonFIPSAlg(void)
1828 {
1829         struct crypt_device *cd;
1830         struct crypt_params_luks1 params = {0};
1831         char key[128] = "";
1832         size_t key_size = 128;
1833         const char *cipher = "aes";
1834         const char *cipher_mode = "cbc-essiv:sha256";
1835         int ret;
1836
1837         OK_(crypt_init(&cd, DEVICE_2));
1838         params.hash = "sha256";
1839         OK_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params));
1840         FAIL_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params),
1841               "Already formatted.");
1842         crypt_free(cd);
1843
1844         params.hash = "whirlpool";
1845         OK_(crypt_init(&cd, DEVICE_2));
1846         ret = crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params);
1847         if (ret < 0) {
1848                 printf("WARNING: whirlpool not supported, skipping test.\n");
1849                 crypt_free(cd);
1850                 return;
1851         }
1852         crypt_free(cd);
1853
1854         params.hash = "md5";
1855         OK_(crypt_init(&cd, DEVICE_2));
1856         FAIL_(crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode, NULL, key, key_size, &params),
1857               "MD5 unsupported, too short");
1858         crypt_free(cd);
1859 }
1860
1861 static void int_handler(int sig __attribute__((__unused__)))
1862 {
1863         _quit++;
1864 }
1865
1866 int main(int argc, char *argv[])
1867 {
1868         struct sigaction sa = { .sa_handler = int_handler };
1869         int i;
1870
1871         if (getuid() != 0) {
1872                 printf("You must be root to run this test.\n");
1873                 exit(0);
1874         }
1875
1876         for (i = 1; i < argc; i++) {
1877                 if (!strcmp("-v", argv[i]) || !strcmp("--verbose", argv[i]))
1878                         _verbose = 1;
1879                 else if (!strcmp("--debug", argv[i]))
1880                         _debug = _verbose = 1;
1881         }
1882
1883         /* Handle interrupt properly */
1884         sigaction(SIGINT, &sa, NULL);
1885         sigaction(SIGTERM, &sa, NULL);
1886
1887         _cleanup();
1888         if (_setup())
1889                 goto out;
1890
1891         crypt_set_debug_level(_debug ? CRYPT_DEBUG_ALL : CRYPT_DEBUG_NONE);
1892
1893         RUN_(NonFIPSAlg, "Crypto is properly initialised in format"); //must be the first!
1894         RUN_(AddDevicePlain, "plain device API creation exercise");
1895         RUN_(HashDevicePlain, "plain device API hash test");
1896         RUN_(AddDeviceLuks, "Format and use LUKS device");
1897         RUN_(LuksHeaderLoad, "test header load");
1898         RUN_(LuksHeaderRestore, "test LUKS header restore");
1899         RUN_(LuksHeaderBackup, "test LUKS header backup");
1900         RUN_(ResizeDeviceLuks, "Luks device resize tests");
1901         RUN_(UseLuksDevice, "Use pre-formated LUKS device");
1902         RUN_(SuspendDevice, "Suspend/Resume test");
1903         RUN_(UseTempVolumes, "Format and use temporary encrypted device");
1904         RUN_(CallbacksTest, "API callbacks test");
1905         RUN_(VerityTest, "DM verity test");
1906         RUN_(TcryptTest, "Tcrypt API test");
1907 out:
1908         _cleanup();
1909         return 0;
1910 }