src/cryptsetup.c

   1 /*
   2  * cryptsetup - setup cryptographic volumes for dm-crypt
   3  *
   4  * Copyright (C) 2004, Christophe Saout <christophe@saout.de>
   5  * Copyright (C) 2004-2007, Clemens Fruhwirth <clemens@endorphin.org>
   6  * Copyright (C) 2009-2012, Red Hat, Inc. All rights reserved.
   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  * version 2 as published by the Free Software Foundation.
  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 "cryptsetup.h"
  23
  24 static const char *opt_cipher = NULL;
  25 static const char *opt_hash = NULL;
  26 static int opt_verify_passphrase = 0;
  27
  28 static const char *opt_key_file = NULL;
  29 static int opt_keyfiles_count = 0;
  30 static const char *opt_keyfiles[MAX_KEYFILES];
  31
  32 static const char *opt_master_key_file = NULL;
  33 static const char *opt_header_backup_file = NULL;
  34 static const char *opt_uuid = NULL;
  35 static const char *opt_header_device = NULL;
  36 static int opt_key_size = 0;
  37 static long opt_keyfile_size = 0;
  38 static long opt_new_keyfile_size = 0;
  39 static long opt_keyfile_offset = 0;
  40 static long opt_new_keyfile_offset = 0;
  41 static int opt_key_slot = CRYPT_ANY_SLOT;
  42 static uint64_t opt_size = 0;
  43 static uint64_t opt_offset = 0;
  44 static uint64_t opt_skip = 0;
  45 static int opt_skip_valid = 0;
  46 static int opt_readonly = 0;
  47 static int opt_iteration_time = DEFAULT_LUKS1_ITER_TIME;
  48 static int opt_version_mode = 0;
  49 static int opt_timeout = 0;
  50 static int opt_tries = 3;
  51 static int opt_align_payload = 0;
  52 static int opt_random = 0;
  53 static int opt_urandom = 0;
  54 static int opt_dump_master_key = 0;
  55 static int opt_shared = 0;
  56 static int opt_allow_discards = 0;
  57 static int opt_test_passphrase = 0;
  58 static int opt_hidden = 0;
  59
  60 static const char **action_argv;
  61 static int action_argc;
  62 static const char *null_action_argv[] = {NULL, NULL};
  63
  64 static int action_create(int arg);
  65 static int action_remove(int arg);
  66 static int action_resize(int arg);
  67 static int action_status(int arg);
  68 static int action_benchmark(int arg);
  69 static int action_luksFormat(int arg);
  70 static int action_luksOpen(int arg);
  71 static int action_luksAddKey(int arg);
  72 static int action_luksKillSlot(int arg);
  73 static int action_luksRemoveKey(int arg);
  74 static int action_luksChangeKey(int arg);
  75 static int action_isLuks(int arg);
  76 static int action_luksUUID(int arg);
  77 static int action_luksDump(int arg);
  78 static int action_luksSuspend(int arg);
  79 static int action_luksResume(int arg);
  80 static int action_luksBackup(int arg);
  81 static int action_luksRestore(int arg);
  82 static int action_loopaesOpen(int arg);
  83 static int action_luksRepair(int arg);
  84 static int action_tcryptOpen(int arg);
  85 static int action_tcryptDump(int arg);
  86
  87 static struct action_type {
  88         const char *type;
  89         int (*handler)(int);
  90         int arg;
  91         int required_action_argc;
  92         int required_memlock;
  93         const char *arg_desc;
  94         const char *desc;
  95 } action_types[] = {
  96         { "create",     action_create,          0, 2, 1, N_("<name> <device>"),N_("create device") },
  97         { "remove",     action_remove,          0, 1, 1, N_("<name>"), N_("remove device") },
  98         { "resize",     action_resize,          0, 1, 1, N_("<name>"), N_("resize active device") },
  99         { "status",     action_status,          0, 1, 0, N_("<name>"), N_("show device status") },
 100         { "benchmark",  action_benchmark,       0, 0, 0, N_("<name>"), N_("benchmark cipher") },
 101         { "repair",     action_luksRepair,      0, 1, 1, N_("<device>"), N_("try to repair on-disk metadata") },
 102         { "luksFormat", action_luksFormat,      0, 1, 1, N_("<device> [<new key file>]"), N_("formats a LUKS device") },
 103         { "luksOpen",   action_luksOpen,        0, 2, 1, N_("<device> <name> "), N_("open LUKS device as mapping <name>") },
 104         { "luksAddKey", action_luksAddKey,      0, 1, 1, N_("<device> [<new key file>]"), N_("add key to LUKS device") },
 105         { "luksRemoveKey",action_luksRemoveKey, 0, 1, 1, N_("<device> [<key file>]"), N_("removes supplied key or key file from LUKS device") },
 106         { "luksChangeKey",action_luksChangeKey, 0, 1, 1, N_("<device> [<key file>]"), N_("changes supplied key or key file of LUKS device") },
 107         { "luksKillSlot",  action_luksKillSlot, 0, 2, 1, N_("<device> <key slot>"), N_("wipes key with number <key slot> from LUKS device") },
 108         { "luksUUID",   action_luksUUID,        0, 1, 0, N_("<device>"), N_("print UUID of LUKS device") },
 109         { "isLuks",     action_isLuks,          0, 1, 0, N_("<device>"), N_("tests <device> for LUKS partition header") },
 110         { "luksClose",  action_remove,          0, 1, 1, N_("<name>"), N_("remove LUKS mapping") },
 111         { "luksDump",   action_luksDump,        0, 1, 1, N_("<device>"), N_("dump LUKS partition information") },
 112         { "luksSuspend",action_luksSuspend,     0, 1, 1, N_("<device>"), N_("Suspend LUKS device and wipe key (all IOs are frozen).") },
 113         { "luksResume", action_luksResume,      0, 1, 1, N_("<device>"), N_("Resume suspended LUKS device.") },
 114         { "luksHeaderBackup",action_luksBackup, 0, 1, 1, N_("<device>"), N_("Backup LUKS device header and keyslots") },
 115         { "luksHeaderRestore",action_luksRestore,0,1, 1, N_("<device>"), N_("Restore LUKS device header and keyslots") },
 116         { "loopaesOpen",action_loopaesOpen,     0, 2, 1, N_("<device> <name> "), N_("open loop-AES device as mapping <name>") },
 117         { "loopaesClose",action_remove,         0, 1, 1, N_("<name>"), N_("remove loop-AES mapping") },
 118         { "tcryptOpen", action_tcryptOpen,      0, 2, 1, N_("<device> <name> "), N_("open TCRYPT device as mapping <name>") },
 119         { "tcryptDump", action_tcryptDump,      0, 1, 1, N_("<device>"), N_("dump TCRYPT device information") },
 120         { NULL, NULL, 0, 0, 0, NULL, NULL }
 121 };
 122
 123 static int _verify_passphrase(int def)
 124 {
 125         /* Batch mode switch off verify - if not overrided by -y */
 126         if (opt_verify_passphrase)
 127                 def = 1;
 128         else if (opt_batch_mode)
 129                 def = 0;
 130
 131         /* Non-tty input doesn't allow verify */
 132         if (def && !isatty(STDIN_FILENO)) {
 133                 if (opt_verify_passphrase)
 134                         log_err(_("Can't do passphrase verification on non-tty inputs.\n"));
 135                 def = 0;
 136         }
 137
 138         return def;
 139 }
 140
 141 static int action_create(int arg __attribute__((unused)))
 142 {
 143         struct crypt_device *cd = NULL;
 144         char cipher[MAX_CIPHER_LEN], cipher_mode[MAX_CIPHER_LEN];
 145         struct crypt_params_plain params = {
 146                 .hash = opt_hash ?: DEFAULT_PLAIN_HASH,
 147                 .skip = opt_skip,
 148                 .offset = opt_offset,
 149                 .size = opt_size,
 150         };
 151         char *password = NULL;
 152         size_t passwordLen;
 153         size_t key_size = (opt_key_size ?: DEFAULT_PLAIN_KEYBITS) / 8;
 154         uint32_t activate_flags = 0;
 155         int r;
 156
 157         if (params.hash && !strcmp(params.hash, "plain"))
 158                 params.hash = NULL;
 159
 160         /* FIXME: temporary hack */
 161         if (opt_key_file && strcmp(opt_key_file, "-"))
 162                 params.hash = NULL;
 163
 164         if ((opt_keyfile_offset || opt_keyfile_size) && opt_key_file)
 165                 log_std(("Ignoring keyfile offset and size options, keyfile read "
 166                          "size is always the same as encryption key size.\n"));
 167
 168         r = crypt_parse_name_and_mode(opt_cipher ?: DEFAULT_CIPHER(PLAIN),
 169                                       cipher, NULL, cipher_mode);
 170         if (r < 0) {
 171                 log_err("No known cipher specification pattern detected.\n");
 172                 goto out;
 173         }
 174
 175         if ((r = crypt_init(&cd, action_argv[1])))
 176                 goto out;
 177
 178         crypt_set_timeout(cd, opt_timeout);
 179         crypt_set_password_retry(cd, opt_tries);
 180
 181         r = crypt_format(cd, CRYPT_PLAIN,
 182                          cipher, cipher_mode,
 183                          NULL, NULL,
 184                          key_size,
 185                          &params);
 186         if (r < 0)
 187                 goto out;
 188
 189         if (opt_readonly)
 190                 activate_flags |= CRYPT_ACTIVATE_READONLY;
 191
 192         if (opt_shared)
 193                 activate_flags |= CRYPT_ACTIVATE_SHARED;
 194
 195         if (opt_allow_discards)
 196                 activate_flags |= CRYPT_ACTIVATE_ALLOW_DISCARDS;
 197
 198         if (opt_key_file)
 199                 /* With hashing, read the whole keyfile */
 200                 r = crypt_activate_by_keyfile_offset(cd, action_argv[0],
 201                         CRYPT_ANY_SLOT, opt_key_file,
 202                         params.hash ? 0 : key_size, 0,
 203                         activate_flags);
 204         else {
 205                 r = crypt_get_key(_("Enter passphrase: "),
 206                                   &password, &passwordLen,
 207                                   opt_keyfile_offset, opt_keyfile_size,
 208                                   NULL, opt_timeout,
 209                                   _verify_passphrase(0),
 210                                   cd);
 211                 if (r < 0)
 212                         goto out;
 213
 214                 r = crypt_activate_by_passphrase(cd, action_argv[0],
 215                         CRYPT_ANY_SLOT, password, passwordLen, activate_flags);
 216         }
 217 out:
 218         crypt_free(cd);
 219         crypt_safe_free(password);
 220
 221         return r;
 222 }
 223
 224 static int action_loopaesOpen(int arg __attribute__((unused)))
 225 {
 226         struct crypt_device *cd = NULL;
 227         struct crypt_params_loopaes params = {
 228                 .hash = opt_hash ?: NULL,
 229                 .offset = opt_offset,
 230                 .skip = opt_skip_valid ? opt_skip : opt_offset,
 231         };
 232         unsigned int key_size = (opt_key_size ?: DEFAULT_LOOPAES_KEYBITS) / 8;
 233         uint32_t activate_flags = 0;
 234         int r;
 235
 236         if (!opt_key_file) {
 237                 log_err(_("Option --key-file is required.\n"));
 238                 return -EINVAL;
 239         }
 240
 241         if (opt_readonly)
 242                 activate_flags |= CRYPT_ACTIVATE_READONLY;
 243
 244         if (opt_allow_discards)
 245                 activate_flags |= CRYPT_ACTIVATE_ALLOW_DISCARDS;
 246
 247         if ((r = crypt_init(&cd, action_argv[0])))
 248                 goto out;
 249
 250         r = crypt_format(cd, CRYPT_LOOPAES, opt_cipher ?: DEFAULT_LOOPAES_CIPHER,
 251                          NULL, NULL, NULL, key_size, &params);
 252         if (r < 0)
 253                 goto out;
 254
 255         r = crypt_activate_by_keyfile_offset(cd, action_argv[1], CRYPT_ANY_SLOT,
 256                                       opt_key_file, opt_keyfile_size,
 257                                       opt_keyfile_size, activate_flags);
 258 out:
 259         crypt_free(cd);
 260
 261         return r;
 262 }
 263
 264 static int action_tcryptOpen(int arg __attribute__((unused)))
 265 {
 266         struct crypt_device *cd = NULL;
 267         struct crypt_params_tcrypt params = {
 268                 .keyfiles = opt_keyfiles,
 269                 .keyfiles_count = opt_keyfiles_count,
 270                 .flags = CRYPT_TCRYPT_LEGACY_MODES,
 271         };
 272         const char *activated_name;
 273         uint32_t flags = 0;
 274         int r;
 275
 276         activated_name = opt_test_passphrase ? NULL : action_argv[1];
 277
 278         if ((r = crypt_init(&cd, action_argv[0])))
 279                 goto out;
 280
 281         /* TCRYPT header is encrypted, get passphrase now */
 282         r = crypt_get_key(_("Enter passphrase: "),
 283                           CONST_CAST(char**)&params.passphrase,
 284                           &params.passphrase_size, 0, 0, NULL, opt_timeout,
 285                           _verify_passphrase(0), cd);
 286         if (r < 0)
 287                 goto out;
 288
 289         if (opt_hidden)
 290                 params.flags |= CRYPT_TCRYPT_HIDDEN_HEADER;
 291
 292         r = crypt_load(cd, CRYPT_TCRYPT, &params);
 293         if (r < 0)
 294                 goto out;
 295
 296         if (opt_readonly)
 297                 flags |= CRYPT_ACTIVATE_READONLY;
 298
 299         if (activated_name)
 300                 r = crypt_activate_by_volume_key(cd, activated_name, NULL, 0, flags);
 301 out:
 302         crypt_free(cd);
 303         crypt_safe_free(CONST_CAST(char*)params.passphrase);
 304         return r;
 305 }
 306
 307 static int action_tcryptDump(int arg __attribute__((unused)))
 308 {
 309         struct crypt_device *cd = NULL;
 310         struct crypt_params_tcrypt params = {
 311                 .keyfiles = opt_keyfiles,
 312                 .keyfiles_count = opt_keyfiles_count,
 313                 .flags = CRYPT_TCRYPT_LEGACY_MODES,
 314         };
 315         int r;
 316
 317         if ((r = crypt_init(&cd, action_argv[0])))
 318                 goto out;
 319
 320         /* TCRYPT header is encrypted, get passphrase now */
 321         r = crypt_get_key(_("Enter passphrase: "),
 322                           CONST_CAST(char**)&params.passphrase,
 323                           &params.passphrase_size, 0, 0, NULL, opt_timeout,
 324                           _verify_passphrase(0), cd);
 325         if (r < 0)
 326                 goto out;
 327
 328         if (opt_hidden)
 329                 params.flags |= CRYPT_TCRYPT_HIDDEN_HEADER;
 330
 331         r = crypt_load(cd, CRYPT_TCRYPT, &params);
 332         if (r < 0)
 333                 goto out;
 334
 335         r = crypt_dump(cd);
 336 out:
 337         crypt_free(cd);
 338         crypt_safe_free(CONST_CAST(char*)params.passphrase);
 339         return r;
 340 }
 341
 342 static int action_remove(int arg __attribute__((unused)))
 343 {
 344         struct crypt_device *cd = NULL;
 345         int r;
 346
 347         r = crypt_init_by_name(&cd, action_argv[0]);
 348         if (r == 0)
 349                 r = crypt_deactivate(cd, action_argv[0]);
 350
 351         crypt_free(cd);
 352         return r;
 353 }
 354
 355 static int action_resize(int arg __attribute__((unused)))
 356 {
 357         struct crypt_device *cd = NULL;
 358         int r;
 359
 360         r = crypt_init_by_name_and_header(&cd, action_argv[0], opt_header_device);
 361         if (r == 0)
 362                 r = crypt_resize(cd, action_argv[0], opt_size);
 363
 364         crypt_free(cd);
 365         return r;
 366 }
 367
 368 static int action_status(int arg __attribute__((unused)))
 369 {
 370         crypt_status_info ci;
 371         struct crypt_active_device cad;
 372         struct crypt_device *cd = NULL;
 373         struct stat st;
 374         char *backing_file;
 375         const char *device;
 376         int path = 0, r = 0;
 377
 378         /* perhaps a path, not a dm device name */
 379         if (strchr(action_argv[0], '/') && !stat(action_argv[0], &st))
 380                 path = 1;
 381
 382         ci = crypt_status(NULL, action_argv[0]);
 383         switch (ci) {
 384         case CRYPT_INVALID:
 385                 r = -EINVAL;
 386                 break;
 387         case CRYPT_INACTIVE:
 388                 if (path)
 389                         log_std("%s is inactive.\n", action_argv[0]);
 390                 else
 391                         log_std("%s/%s is inactive.\n", crypt_get_dir(), action_argv[0]);
 392                 r = -ENODEV;
 393                 break;
 394         case CRYPT_ACTIVE:
 395         case CRYPT_BUSY:
 396                 if (path)
 397                         log_std("%s is active%s.\n", action_argv[0],
 398                                 ci == CRYPT_BUSY ? " and is in use" : "");
 399                 else
 400                         log_std("%s/%s is active%s.\n", crypt_get_dir(), action_argv[0],
 401                                 ci == CRYPT_BUSY ? " and is in use" : "");
 402
 403                 r = crypt_init_by_name_and_header(&cd, action_argv[0], opt_header_device);
 404                 if (r < 0 || !crypt_get_type(cd))
 405                         goto out;
 406
 407                 log_std("  type:    %s\n", crypt_get_type(cd));
 408
 409                 r = crypt_get_active_device(cd, action_argv[0], &cad);
 410                 if (r < 0)
 411                         goto out;
 412
 413                 log_std("  cipher:  %s-%s\n", crypt_get_cipher(cd), crypt_get_cipher_mode(cd));
 414                 log_std("  keysize: %d bits\n", crypt_get_volume_key_size(cd) * 8);
 415                 device = crypt_get_device_name(cd);
 416                 log_std("  device:  %s\n", device);
 417                 if (crypt_loop_device(device)) {
 418                         backing_file = crypt_loop_backing_file(device);
 419                         log_std("  loop:    %s\n", backing_file);
 420                         free(backing_file);
 421                 }
 422                 log_std("  offset:  %" PRIu64 " sectors\n", cad.offset);
 423                 log_std("  size:    %" PRIu64 " sectors\n", cad.size);
 424                 if (cad.iv_offset)
 425                         log_std("  skipped: %" PRIu64 " sectors\n", cad.iv_offset);
 426                 log_std("  mode:    %s\n", cad.flags & CRYPT_ACTIVATE_READONLY ?
 427                                            "readonly" : "read/write");
 428                 if (cad.flags & CRYPT_ACTIVATE_ALLOW_DISCARDS)
 429                         log_std("  flags:   discards\n");
 430         }
 431 out:
 432         crypt_free(cd);
 433         if (r == -ENOTSUP)
 434                 r = 0;
 435         return r;
 436 }
 437
 438 static int action_benchmark(int arg __attribute__((unused)))
 439 {
 440         static struct {
 441                 char *cipher;
 442                 char *mode;
 443                 size_t key_size;
 444                 size_t iv_size;
 445         } bciphers[] = {
 446                 { "aes",     "cbc", 16, 16 },
 447                 { "serpent", "cbc", 16, 16 },
 448                 { "twofish", "cbc", 16, 16 },
 449                 { "aes",     "cbc", 32, 16 },
 450                 { "serpent", "cbc", 32, 16 },
 451                 { "twofish", "cbc", 32, 16 },
 452                 { "aes",     "xts", 32, 16 },
 453                 { "serpent", "xts", 32, 16 },
 454                 { "twofish", "xts", 32, 16 },
 455                 { "aes",     "xts", 64, 16 },
 456                 { "serpent", "xts", 64, 16 },
 457                 { "twofish", "xts", 64, 16 },
 458                 {  NULL, NULL, 0, 0 }
 459         };
 460         char *header = "# Tests are approximate using memory only (no storage IO).\n"
 461                         "# Algorithm | Key | Encryption | Decryption\n";
 462         char cipher[MAX_CIPHER_LEN], cipher_mode[MAX_CIPHER_LEN];
 463         double enc_mbr = 0, dec_mbr = 0;
 464         int key_size = (opt_key_size ?: DEFAULT_PLAIN_KEYBITS);
 465         int iv_size = 16, skipped = 0;
 466         int buffer_size = 1024 * 1024;
 467         char *c;
 468         int i, r;
 469
 470         if (opt_cipher) {
 471                 r = crypt_parse_name_and_mode(opt_cipher, cipher, NULL, cipher_mode);
 472                 if (r < 0) {
 473                         log_err(_("No known cipher specification pattern detected.\n"));
 474                         return r;
 475                 }
 476                 if ((c  = strchr(cipher_mode, '-')))
 477                         *c = '\0';
 478
 479                 /* FIXME: not really clever :) */
 480                 if (strstr(cipher, "des"))
 481                         iv_size = 8;
 482
 483                 r = crypt_benchmark(NULL, cipher, cipher_mode,
 484                                     key_size / 8, iv_size, buffer_size,
 485                                     &enc_mbr, &dec_mbr);
 486                 if (!r) {
 487                         log_std("%s", header);
 488                         strncat(cipher, "-", MAX_CIPHER_LEN);
 489                         strncat(cipher, cipher_mode, MAX_CIPHER_LEN);
 490                         log_std("%11s  %4db  %5.1f MiB/s  %5.1f MiB/s\n",
 491                                 cipher, key_size, enc_mbr, dec_mbr);
 492                 } else if (r == -ENOENT)
 493                         log_err(_("Cipher %s is not available.\n"), opt_cipher);
 494         } else {
 495                 for (i = 0; bciphers[i].cipher; i++) {
 496                         r = crypt_benchmark(NULL, bciphers[i].cipher, bciphers[i].mode,
 497                                             bciphers[i].key_size, bciphers[i].iv_size,
 498                                             buffer_size, &enc_mbr, &dec_mbr);
 499                         if (r == -ENOTSUP)
 500                                 break;
 501                         if (r == -ENOENT)
 502                                 skipped++;
 503                         if (i == 0)
 504                                 log_std("%s", header);
 505
 506                         snprintf(cipher, MAX_CIPHER_LEN, "%s-%s",
 507                                  bciphers[i].cipher, bciphers[i].mode);
 508                         if (!r)
 509                                 log_std("%11s  %4db  %5.1f MiB/s  %5.1f MiB/s\n",
 510                                         cipher, bciphers[i].key_size*8, enc_mbr, dec_mbr);
 511                         else
 512                                 log_std("%11s  %4db %12s %12s\n", cipher,
 513                                         bciphers[i].key_size*8, _("N/A"), _("N/A"));
 514                 }
 515                 if (skipped && skipped == i)
 516                         r = -ENOTSUP;
 517         }
 518
 519         if (r == -ENOTSUP)
 520                 log_err( _("Required kernel crypto interface not available.\n"
 521                            "Ensure you have algif_skcipher kernel module loaded.\n"));
 522         return r;
 523 }
 524
 525 static int _read_mk(const char *file, char **key, int keysize)
 526 {
 527         int fd;
 528
 529         *key = crypt_safe_alloc(keysize);
 530         if (!*key)
 531                 return -ENOMEM;
 532
 533         fd = open(file, O_RDONLY);
 534         if (fd == -1) {
 535                 log_err("Cannot read keyfile %s.\n", file);
 536                 goto fail;
 537         }
 538         if ((read(fd, *key, keysize) != keysize)) {
 539                 log_err("Cannot read %d bytes from keyfile %s.\n", keysize, file);
 540                 close(fd);
 541                 goto fail;
 542         }
 543         close(fd);
 544         return 0;
 545 fail:
 546         crypt_safe_free(*key);
 547         *key = NULL;
 548         return -EINVAL;
 549 }
 550
 551 static int action_luksRepair(int arg __attribute__((unused)))
 552 {
 553         struct crypt_device *cd = NULL;
 554         int r;
 555
 556         if ((r = crypt_init(&cd, action_argv[0])))
 557                 goto out;
 558
 559         /* Currently only LUKS1 allows repair */
 560         crypt_set_log_callback(cd, quiet_log, NULL);
 561         r = crypt_load(cd, CRYPT_LUKS1, NULL);
 562         crypt_set_log_callback(cd, tool_log, NULL);
 563         if (r == 0) {
 564                 log_verbose( _("No known problems detected for LUKS header.\n"));
 565                 goto out;
 566         }
 567
 568         r = yesDialog(_("Really try to repair LUKS device header?"),
 569                        NULL) ? 0 : -EINVAL;
 570         if (r == 0)
 571                 r = crypt_repair(cd, CRYPT_LUKS1, NULL);
 572 out:
 573         crypt_free(cd);
 574         return r;
 575 }
 576
 577 static int action_luksFormat(int arg __attribute__((unused)))
 578 {
 579         int r = -EINVAL, keysize;
 580         const char *header_device;
 581         char *msg = NULL, *key = NULL, cipher [MAX_CIPHER_LEN], cipher_mode[MAX_CIPHER_LEN];
 582         char *password = NULL;
 583         size_t passwordLen;
 584         struct crypt_device *cd = NULL;
 585         struct crypt_params_luks1 params = {
 586                 .hash = opt_hash ?: DEFAULT_LUKS1_HASH,
 587                 .data_alignment = opt_align_payload,
 588                 .data_device = opt_header_device ? action_argv[0] : NULL,
 589         };
 590
 591         header_device = opt_header_device ?: action_argv[0];
 592
 593         if(asprintf(&msg, _("This will overwrite data on %s irrevocably."),
 594                     header_device) == -1) {
 595                 log_err(_("memory allocation error in action_luksFormat"));
 596                 r = -ENOMEM;
 597                 goto out;
 598         }
 599         r = yesDialog(msg, NULL) ? 0 : -EINVAL;
 600         free(msg);
 601         if (r < 0)
 602                 goto out;
 603
 604         r = crypt_parse_name_and_mode(opt_cipher ?: DEFAULT_CIPHER(LUKS1),
 605                                       cipher, NULL, cipher_mode);
 606         if (r < 0) {
 607                 log_err(_("No known cipher specification pattern detected.\n"));
 608                 goto out;
 609         }
 610
 611         if ((r = crypt_init(&cd, header_device))) {
 612                 if (opt_header_device)
 613                         log_err(_("Cannot use %s as on-disk header.\n"), header_device);
 614                 goto out;
 615         }
 616
 617         keysize = (opt_key_size ?: DEFAULT_LUKS1_KEYBITS) / 8;
 618
 619         crypt_set_timeout(cd, opt_timeout);
 620         if (opt_iteration_time)
 621                 crypt_set_iteration_time(cd, opt_iteration_time);
 622
 623         if (opt_random)
 624                 crypt_set_rng_type(cd, CRYPT_RNG_RANDOM);
 625         else if (opt_urandom)
 626                 crypt_set_rng_type(cd, CRYPT_RNG_URANDOM);
 627
 628         r = crypt_get_key(_("Enter LUKS passphrase: "), &password, &passwordLen,
 629                           opt_keyfile_offset, opt_keyfile_size, opt_key_file,
 630                           opt_timeout, _verify_passphrase(1), cd);
 631         if (r < 0)
 632                 goto out;
 633
 634         if (opt_master_key_file) {
 635                 r = _read_mk(opt_master_key_file, &key, keysize);
 636                 if (r < 0)
 637                         goto out;
 638         }
 639
 640         r = crypt_format(cd, CRYPT_LUKS1, cipher, cipher_mode,
 641                          opt_uuid, key, keysize, &params);
 642         if (r < 0)
 643                 goto out;
 644
 645         r = crypt_keyslot_add_by_volume_key(cd, opt_key_slot,
 646                                             key, keysize,
 647                                             password, passwordLen);
 648 out:
 649         crypt_free(cd);
 650         crypt_safe_free(key);
 651         crypt_safe_free(password);
 652
 653         return r;
 654 }
 655
 656 static int action_luksOpen(int arg __attribute__((unused)))
 657 {
 658         struct crypt_device *cd = NULL;
 659         const char *data_device, *header_device, *activated_name;
 660         char *key = NULL;
 661         uint32_t flags = 0;
 662         int r, keysize;
 663
 664         if (opt_header_device) {
 665                 header_device = uuid_or_device(opt_header_device);
 666                 data_device = action_argv[0];
 667         } else {
 668                 header_device = uuid_or_device(action_argv[0]);
 669                 data_device = NULL;
 670         }
 671
 672         activated_name = opt_test_passphrase ? NULL : action_argv[1];
 673
 674         if ((r = crypt_init(&cd, header_device)))
 675                 goto out;
 676
 677         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 678                 goto out;
 679
 680         if (data_device &&
 681             (r = crypt_set_data_device(cd, data_device)))
 682                 goto out;
 683
 684         if (!data_device && (crypt_get_data_offset(cd) < 8)) {
 685                 log_err(_("Reduced data offset is allowed only for detached LUKS header.\n"));
 686                 r = -EINVAL;
 687                 goto out;
 688         }
 689
 690         crypt_set_timeout(cd, opt_timeout);
 691         crypt_set_password_retry(cd, opt_tries);
 692         crypt_set_password_verify(cd, _verify_passphrase(0));
 693
 694         if (opt_iteration_time)
 695                 crypt_set_iteration_time(cd, opt_iteration_time);
 696
 697         if (opt_readonly)
 698                 flags |= CRYPT_ACTIVATE_READONLY;
 699
 700         if (opt_allow_discards)
 701                 flags |= CRYPT_ACTIVATE_ALLOW_DISCARDS;
 702
 703         if (opt_master_key_file) {
 704                 keysize = crypt_get_volume_key_size(cd);
 705                 r = _read_mk(opt_master_key_file, &key, keysize);
 706                 if (r < 0)
 707                         goto out;
 708                 r = crypt_activate_by_volume_key(cd, activated_name,
 709                                                  key, keysize, flags);
 710         } else if (opt_key_file) {
 711                 crypt_set_password_retry(cd, 1);
 712                 r = crypt_activate_by_keyfile_offset(cd, activated_name,
 713                         opt_key_slot, opt_key_file, opt_keyfile_size,
 714                         opt_keyfile_offset, flags);
 715         } else
 716                 r = crypt_activate_by_passphrase(cd, activated_name,
 717                         opt_key_slot, NULL, 0, flags);
 718 out:
 719         crypt_safe_free(key);
 720         crypt_free(cd);
 721         return r;
 722 }
 723
 724 static int verify_keyslot(struct crypt_device *cd, int key_slot,
 725                           char *msg_last, char *msg_pass,
 726                           const char *key_file, int keyfile_offset,
 727                           int keyfile_size)
 728 {
 729         crypt_keyslot_info ki;
 730         char *password = NULL;
 731         size_t passwordLen;
 732         int i, r;
 733
 734         ki = crypt_keyslot_status(cd, key_slot);
 735         if (ki == CRYPT_SLOT_ACTIVE_LAST && msg_last && !yesDialog(msg_last, NULL))
 736                 return -EPERM;
 737
 738         r = crypt_get_key(msg_pass, &password, &passwordLen,
 739                           keyfile_offset, keyfile_size, key_file, opt_timeout,
 740                           _verify_passphrase(0), cd);
 741         if(r < 0)
 742                 goto out;
 743
 744         if (ki == CRYPT_SLOT_ACTIVE_LAST) {
 745                 /* check the last keyslot */
 746                 r = crypt_activate_by_passphrase(cd, NULL, key_slot,
 747                                                  password, passwordLen, 0);
 748         } else {
 749                 /* try all other keyslots */
 750                 for (i = 0; i < crypt_keyslot_max(CRYPT_LUKS1); i++) {
 751                         if (i == key_slot)
 752                                 continue;
 753                         ki = crypt_keyslot_status(cd, key_slot);
 754                         if (ki == CRYPT_SLOT_ACTIVE)
 755                         r = crypt_activate_by_passphrase(cd, NULL, i,
 756                                                          password, passwordLen, 0);
 757                         if (r == i)
 758                                 break;
 759                 }
 760         }
 761
 762         if (r == -EPERM)
 763                 log_err(_("No key available with this passphrase.\n"));
 764 out:
 765         crypt_safe_free(password);
 766         return r;
 767 }
 768
 769 static int action_luksKillSlot(int arg __attribute__((unused)))
 770 {
 771         struct crypt_device *cd = NULL;
 772         int r;
 773
 774         if ((r = crypt_init(&cd, uuid_or_device(action_argv[0]))))
 775                 goto out;
 776
 777         crypt_set_confirm_callback(cd, yesDialog, NULL);
 778         crypt_set_timeout(cd, opt_timeout);
 779
 780         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 781                 goto out;
 782
 783         switch (crypt_keyslot_status(cd, opt_key_slot)) {
 784         case CRYPT_SLOT_ACTIVE_LAST:
 785         case CRYPT_SLOT_ACTIVE:
 786                 log_verbose(_("Key slot %d selected for deletion.\n"), opt_key_slot);
 787                 break;
 788         case CRYPT_SLOT_INACTIVE:
 789                 log_err(_("Key %d not active. Can't wipe.\n"), opt_key_slot);
 790         case CRYPT_SLOT_INVALID:
 791                 r = -EINVAL;
 792                 goto out;
 793         }
 794
 795         if (!opt_batch_mode) {
 796                 r = verify_keyslot(cd, opt_key_slot,
 797                         _("This is the last keyslot. Device will become unusable after purging this key."),
 798                         _("Enter any remaining LUKS passphrase: "),
 799                         opt_key_file, opt_keyfile_offset, opt_keyfile_size);
 800                 if (r < 0)
 801                         goto out;
 802         }
 803
 804         r = crypt_keyslot_destroy(cd, opt_key_slot);
 805 out:
 806         crypt_free(cd);
 807         return r;
 808 }
 809
 810 static int action_luksRemoveKey(int arg __attribute__((unused)))
 811 {
 812         struct crypt_device *cd = NULL;
 813         char *password = NULL;
 814         size_t passwordLen;
 815         int r;
 816
 817         if ((r = crypt_init(&cd, uuid_or_device(action_argv[0]))))
 818                 goto out;
 819
 820         crypt_set_confirm_callback(cd, yesDialog, NULL);
 821         crypt_set_timeout(cd, opt_timeout);
 822
 823         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 824                 goto out;
 825
 826         r = crypt_get_key(_("Enter LUKS passphrase to be deleted: "),
 827                       &password, &passwordLen,
 828                       opt_keyfile_offset, opt_keyfile_size, opt_key_file,
 829                       opt_timeout,
 830                       _verify_passphrase(0),
 831                       cd);
 832         if(r < 0)
 833                 goto out;
 834
 835         r = crypt_activate_by_passphrase(cd, NULL, CRYPT_ANY_SLOT,
 836                                          password, passwordLen, 0);
 837         if (r < 0)
 838                 goto out;
 839
 840         opt_key_slot = r;
 841         log_verbose(_("Key slot %d selected for deletion.\n"), opt_key_slot);
 842
 843         if (crypt_keyslot_status(cd, opt_key_slot) == CRYPT_SLOT_ACTIVE_LAST &&
 844             !yesDialog(_("This is the last keyslot. "
 845                           "Device will become unusable after purging this key."),
 846                         NULL)) {
 847                 r = -EPERM;
 848                 goto out;
 849         }
 850
 851         r = crypt_keyslot_destroy(cd, opt_key_slot);
 852 out:
 853         crypt_safe_free(password);
 854         crypt_free(cd);
 855         return r;
 856 }
 857
 858 static int action_luksAddKey(int arg __attribute__((unused)))
 859 {
 860         int r = -EINVAL, keysize = 0;
 861         char *key = NULL;
 862         const char *opt_new_key_file = (action_argc > 1 ? action_argv[1] : NULL);
 863         struct crypt_device *cd = NULL;
 864
 865         if ((r = crypt_init(&cd, uuid_or_device(action_argv[0]))))
 866                 goto out;
 867
 868         crypt_set_confirm_callback(cd, yesDialog, NULL);
 869
 870         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 871                 goto out;
 872
 873         keysize = crypt_get_volume_key_size(cd);
 874         /* FIXME: lib cannot properly set verification for new/old passphrase */
 875         crypt_set_password_verify(cd, _verify_passphrase(0));
 876         crypt_set_timeout(cd, opt_timeout);
 877         if (opt_iteration_time)
 878                 crypt_set_iteration_time(cd, opt_iteration_time);
 879
 880         if (opt_master_key_file) {
 881                 r = _read_mk(opt_master_key_file, &key, keysize);
 882                 if (r < 0)
 883                         goto out;
 884                 //FIXME: process keyfile arg
 885                 r = crypt_keyslot_add_by_volume_key(cd, opt_key_slot,
 886                                                     key, keysize, NULL, 0);
 887         } else if (opt_key_file || opt_new_key_file) {
 888                 r = crypt_keyslot_add_by_keyfile_offset(cd, opt_key_slot,
 889                         opt_key_file, opt_keyfile_size, opt_keyfile_offset,
 890                         opt_new_key_file, opt_new_keyfile_size, opt_new_keyfile_offset);
 891         } else {
 892                 r = crypt_keyslot_add_by_passphrase(cd, opt_key_slot,
 893                                                     NULL, 0, NULL, 0);
 894         }
 895 out:
 896         crypt_free(cd);
 897         crypt_safe_free(key);
 898         return r;
 899 }
 900
 901 static int _slots_full(struct crypt_device *cd)
 902 {
 903         int i;
 904
 905         for (i = 0; i < crypt_keyslot_max(crypt_get_type(cd)); i++)
 906                 if (crypt_keyslot_status(cd, i) == CRYPT_SLOT_INACTIVE)
 907                         return 0;
 908         return 1;
 909 }
 910
 911 static int action_luksChangeKey(int arg __attribute__((unused)))
 912 {
 913         const char *opt_new_key_file = (action_argc > 1 ? action_argv[1] : NULL);
 914         struct crypt_device *cd = NULL;
 915         char *vk = NULL, *password = NULL;
 916         size_t passwordLen = 0;
 917         size_t vk_size;
 918         int new_key_slot, old_key_slot, r;
 919
 920         if ((r = crypt_init(&cd, uuid_or_device(action_argv[0]))))
 921                 goto out;
 922
 923         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 924                 goto out;
 925
 926         if (opt_iteration_time)
 927                 crypt_set_iteration_time(cd, opt_iteration_time);
 928
 929         r = crypt_get_key(_("Enter LUKS passphrase to be changed: "),
 930                       &password, &passwordLen,
 931                       opt_keyfile_offset, opt_keyfile_size, opt_key_file,
 932                       opt_timeout, _verify_passphrase(0), cd);
 933         if (r < 0)
 934                 goto out;
 935
 936         vk_size = crypt_get_volume_key_size(cd);
 937         vk = crypt_safe_alloc(vk_size);
 938         if (!vk) {
 939                 r = -ENOMEM;
 940                 goto out;
 941         }
 942
 943         r = crypt_volume_key_get(cd, opt_key_slot, vk, &vk_size,
 944                                  password, passwordLen);
 945         if (r < 0) {
 946                 if (opt_key_slot != CRYPT_ANY_SLOT)
 947                         log_err(_("No key available with this passphrase.\n"));
 948                 goto out;
 949         }
 950
 951         if (opt_key_slot != CRYPT_ANY_SLOT || _slots_full(cd)) {
 952                 log_dbg("Key slot %d is going to be overwritten (%s).",
 953                         r, opt_key_slot != CRYPT_ANY_SLOT ?
 954                         "explicit key slot specified" : "no free key slot");
 955                 old_key_slot = r;
 956                 new_key_slot = r;
 957         } else {
 958                 log_dbg("Allocating new key slot.");
 959                 old_key_slot = r;
 960                 new_key_slot = CRYPT_ANY_SLOT;
 961         }
 962
 963         crypt_safe_free(password);
 964         password = NULL;
 965         passwordLen = 0;
 966         r = crypt_get_key(_("Enter new LUKS passphrase: "),
 967                           &password, &passwordLen,
 968                           opt_new_keyfile_offset, opt_new_keyfile_size,
 969                           opt_new_key_file,
 970                           opt_timeout, _verify_passphrase(0), cd);
 971         if (r < 0)
 972                 goto out;
 973
 974         if (new_key_slot == old_key_slot) {
 975                 (void)crypt_keyslot_destroy(cd, old_key_slot);
 976                 r = crypt_keyslot_add_by_volume_key(cd, new_key_slot,
 977                                                     vk, vk_size,
 978                                                     password, passwordLen);
 979                 if (r >= 0)
 980                         log_verbose(_("Key slot %d changed.\n"), r);
 981         } else {
 982                 r = crypt_keyslot_add_by_volume_key(cd, CRYPT_ANY_SLOT,
 983                                                     vk, vk_size,
 984                                                     password, passwordLen);
 985                 if (r >= 0) {
 986                         log_verbose(_("Replaced with key slot %d.\n"), r);
 987                         r = crypt_keyslot_destroy(cd, old_key_slot);
 988                 }
 989         }
 990         if (r < 0)
 991                 log_err(_("Failed to swap new key slot.\n"));
 992 out:
 993         crypt_safe_free(vk);
 994         crypt_safe_free(password);
 995         crypt_free(cd);
 996         return r;
 997 }
 998
 999 static int action_isLuks(int arg __attribute__((unused)))
1000 {
1001         struct crypt_device *cd = NULL;
1002         int r;
1003
1004         if ((r = crypt_init(&cd, action_argv[0])))
1005                 goto out;
1006
1007         crypt_set_log_callback(cd, quiet_log, NULL);
1008         r = crypt_load(cd, CRYPT_LUKS1, NULL);
1009 out:
1010         crypt_free(cd);
1011         return r;
1012 }
1013
1014 static int action_luksUUID(int arg __attribute__((unused)))
1015 {
1016         struct crypt_device *cd = NULL;
1017         const char *existing_uuid = NULL;
1018         int r;
1019
1020         if ((r = crypt_init(&cd, action_argv[0])))
1021                 goto out;
1022
1023         crypt_set_confirm_callback(cd, yesDialog, NULL);
1024
1025         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
1026                 goto out;
1027
1028         if (opt_uuid)
1029                 r = crypt_set_uuid(cd, opt_uuid);
1030         else {
1031                 existing_uuid = crypt_get_uuid(cd);
1032                 log_std("%s\n", existing_uuid ?: "");
1033                 r = existing_uuid ? 0 : 1;
1034         }
1035 out:
1036         crypt_free(cd);
1037         return r;
1038 }
1039
1040 static int luksDump_with_volume_key(struct crypt_device *cd)
1041 {
1042         char *vk = NULL, *password = NULL;
1043         size_t passwordLen = 0;
1044         size_t vk_size;
1045         unsigned i;
1046         int r;
1047
1048         crypt_set_confirm_callback(cd, yesDialog, NULL);
1049         if (!yesDialog(
1050             _("LUKS header dump with volume key is sensitive information\n"
1051               "which allows access to encrypted partition without passphrase.\n"
1052               "This dump should be always stored encrypted on safe place."),
1053               NULL))
1054                 return -EPERM;
1055
1056         vk_size = crypt_get_volume_key_size(cd);
1057         vk = crypt_safe_alloc(vk_size);
1058         if (!vk)
1059                 return -ENOMEM;
1060
1061         r = crypt_get_key(_("Enter LUKS passphrase: "), &password, &passwordLen,
1062                           opt_keyfile_offset, opt_keyfile_size, opt_key_file,
1063                           opt_timeout, 0, cd);
1064         if (r < 0)
1065                 goto out;
1066
1067         r = crypt_volume_key_get(cd, CRYPT_ANY_SLOT, vk, &vk_size,
1068                                  password, passwordLen);
1069         if (r < 0)
1070                 goto out;
1071
1072         log_std("LUKS header information for %s\n", crypt_get_device_name(cd));
1073         log_std("Cipher name:   \t%s\n", crypt_get_cipher(cd));
1074         log_std("Cipher mode:   \t%s\n", crypt_get_cipher_mode(cd));
1075         log_std("Payload offset:\t%d\n", (int)crypt_get_data_offset(cd));
1076         log_std("UUID:          \t%s\n", crypt_get_uuid(cd));
1077         log_std("MK bits:       \t%d\n", (int)vk_size * 8);
1078         log_std("MK dump:\t");
1079
1080         for(i = 0; i < vk_size; i++) {
1081                 if (i && !(i % 16))
1082                         log_std("\n\t\t");
1083                 log_std("%02hhx ", (char)vk[i]);
1084         }
1085         log_std("\n");
1086
1087 out:
1088         crypt_safe_free(password);
1089         crypt_safe_free(vk);
1090         return r;
1091 }
1092
1093 static int action_luksDump(int arg __attribute__((unused)))
1094 {
1095         struct crypt_device *cd = NULL;
1096         int r;
1097
1098         if ((r = crypt_init(&cd, uuid_or_device(action_argv[0]))))
1099                 goto out;
1100
1101         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
1102                 goto out;
1103
1104         if (opt_dump_master_key)
1105                 r = luksDump_with_volume_key(cd);
1106         else
1107                 r = crypt_dump(cd);
1108 out:
1109         crypt_free(cd);
1110         return r;
1111 }
1112
1113 static int action_luksSuspend(int arg __attribute__((unused)))
1114 {
1115         struct crypt_device *cd = NULL;
1116         int r;
1117
1118         r = crypt_init_by_name_and_header(&cd, action_argv[0], opt_header_device);
1119         if (!r)
1120                 r = crypt_suspend(cd, action_argv[0]);
1121
1122         crypt_free(cd);
1123         return r;
1124 }
1125
1126 static int action_luksResume(int arg __attribute__((unused)))
1127 {
1128         struct crypt_device *cd = NULL;
1129         int r;
1130
1131         if ((r = crypt_init_by_name_and_header(&cd, action_argv[0], opt_header_device)))
1132                 goto out;
1133
1134         crypt_set_timeout(cd, opt_timeout);
1135         crypt_set_password_retry(cd, opt_tries);
1136         crypt_set_password_verify(cd, _verify_passphrase(0));
1137
1138         if (opt_key_file)
1139                 r = crypt_resume_by_keyfile_offset(cd, action_argv[0], CRYPT_ANY_SLOT,
1140                         opt_key_file, opt_keyfile_size, opt_keyfile_offset);
1141         else
1142                 r = crypt_resume_by_passphrase(cd, action_argv[0], CRYPT_ANY_SLOT,
1143                                                NULL, 0);
1144 out:
1145         crypt_free(cd);
1146         return r;
1147 }
1148
1149 static int action_luksBackup(int arg __attribute__((unused)))
1150 {
1151         struct crypt_device *cd = NULL;
1152         int r;
1153
1154         if (!opt_header_backup_file) {
1155                 log_err(_("Option --header-backup-file is required.\n"));
1156                 return -EINVAL;
1157         }
1158
1159         if ((r = crypt_init(&cd, uuid_or_device(action_argv[0]))))
1160                 goto out;
1161
1162         crypt_set_confirm_callback(cd, yesDialog, NULL);
1163
1164         r = crypt_header_backup(cd, CRYPT_LUKS1, opt_header_backup_file);
1165 out:
1166         crypt_free(cd);
1167         return r;
1168 }
1169
1170 static int action_luksRestore(int arg __attribute__((unused)))
1171 {
1172         struct crypt_device *cd = NULL;
1173         int r = 0;
1174
1175         if (!opt_header_backup_file) {
1176                 log_err(_("Option --header-backup-file is required.\n"));
1177                 return -EINVAL;
1178         }
1179
1180         if ((r = crypt_init(&cd, action_argv[0])))
1181                 goto out;
1182
1183         crypt_set_confirm_callback(cd, yesDialog, NULL);
1184         r = crypt_header_restore(cd, CRYPT_LUKS1, opt_header_backup_file);
1185 out:
1186         crypt_free(cd);
1187         return r;
1188 }
1189
1190 static void help(poptContext popt_context,
1191                  enum poptCallbackReason reason __attribute__((unused)),
1192                  struct poptOption *key,
1193                  const char *arg __attribute__((unused)),
1194                  void *data __attribute__((unused)))
1195 {
1196         if (key->shortName == '?') {
1197                 struct action_type *action;
1198
1199                 log_std("%s\n",PACKAGE_STRING);
1200
1201                 poptPrintHelp(popt_context, stdout, 0);
1202
1203                 log_std(_("\n"
1204                          "<action> is one of:\n"));
1205
1206                 for(action = action_types; action->type; action++)
1207                         log_std("\t%s %s - %s\n", action->type, _(action->arg_desc), _(action->desc));
1208
1209                 log_std(_("\n"
1210                          "<name> is the device to create under %s\n"
1211                          "<device> is the encrypted device\n"
1212                          "<key slot> is the LUKS key slot number to modify\n"
1213                          "<key file> optional key file for the new key for luksAddKey action\n"),
1214                         crypt_get_dir());
1215
1216                 log_std(_("\nDefault compiled-in key and passphrase parameters:\n"
1217                          "\tMaximum keyfile size: %dkB, "
1218                          "Maximum interactive passphrase length %d (characters)\n"
1219                          "Default PBKDF2 iteration time for LUKS: %d (ms)\n"),
1220                          DEFAULT_KEYFILE_SIZE_MAXKB, DEFAULT_PASSPHRASE_SIZE_MAX,
1221                          DEFAULT_LUKS1_ITER_TIME);
1222
1223                 log_std(_("\nDefault compiled-in device cipher parameters:\n"
1224                          "\tloop-AES: %s, Key %d bits\n"
1225                          "\tplain: %s, Key: %d bits, Password hashing: %s\n"
1226                          "\tLUKS1: %s, Key: %d bits, LUKS header hashing: %s, RNG: %s\n"),
1227                          DEFAULT_LOOPAES_CIPHER, DEFAULT_LOOPAES_KEYBITS,
1228                          DEFAULT_CIPHER(PLAIN), DEFAULT_PLAIN_KEYBITS, DEFAULT_PLAIN_HASH,
1229                          DEFAULT_CIPHER(LUKS1), DEFAULT_LUKS1_KEYBITS, DEFAULT_LUKS1_HASH,
1230                          DEFAULT_RNG);
1231                 exit(EXIT_SUCCESS);
1232         } else
1233                 usage(popt_context, EXIT_SUCCESS, NULL, NULL);
1234 }
1235
1236 static int run_action(struct action_type *action)
1237 {
1238         int r;
1239
1240         log_dbg("Running command %s.", action->type);
1241
1242         if (action->required_memlock)
1243                 crypt_memory_lock(NULL, 1);
1244
1245         r = action->handler(action->arg);
1246
1247         if (action->required_memlock)
1248                 crypt_memory_lock(NULL, 0);
1249
1250         /* Some functions returns keyslot # */
1251         if (r > 0)
1252                 r = 0;
1253
1254         show_status(r);
1255         return translate_errno(r);
1256 }
1257
1258 int main(int argc, const char **argv)
1259 {
1260         static char *popt_tmp;
1261         static struct poptOption popt_help_options[] = {
1262                 { NULL,    '\0', POPT_ARG_CALLBACK, help, 0, NULL,                         NULL },
1263                 { "help",  '?',  POPT_ARG_NONE,     NULL, 0, N_("Show this help message"), NULL },
1264                 { "usage", '\0', POPT_ARG_NONE,     NULL, 0, N_("Display brief usage"),    NULL },
1265                 POPT_TABLEEND
1266         };
1267         static struct poptOption popt_options[] = {
1268                 { NULL,                '\0', POPT_ARG_INCLUDE_TABLE, popt_help_options, 0, N_("Help options:"), NULL },
1269                 { "version",           '\0', POPT_ARG_NONE, &opt_version_mode,          0, N_("Print package version"), NULL },
1270                 { "verbose",           'v',  POPT_ARG_NONE, &opt_verbose,               0, N_("Shows more detailed error messages"), NULL },
1271                 { "debug",             '\0', POPT_ARG_NONE, &opt_debug,                 0, N_("Show debug messages"), NULL },
1272                 { "cipher",            'c',  POPT_ARG_STRING, &opt_cipher,              0, N_("The cipher used to encrypt the disk (see /proc/crypto)"), NULL },
1273                 { "hash",              'h',  POPT_ARG_STRING, &opt_hash,                0, N_("The hash used to create the encryption key from the passphrase"), NULL },
1274                 { "verify-passphrase", 'y',  POPT_ARG_NONE, &opt_verify_passphrase,     0, N_("Verifies the passphrase by asking for it twice"), NULL },
1275                 { "key-file",          'd',  POPT_ARG_STRING, &opt_key_file,            5, N_("Read the key from a file."), NULL },
1276                 { "master-key-file",  '\0',  POPT_ARG_STRING, &opt_master_key_file,     0, N_("Read the volume (master) key from file."), NULL },
1277                 { "dump-master-key",  '\0',  POPT_ARG_NONE, &opt_dump_master_key,       0, N_("Dump volume (master) key instead of keyslots info."), NULL },
1278                 { "key-size",          's',  POPT_ARG_INT, &opt_key_size,               0, N_("The size of the encryption key"), N_("BITS") },
1279                 { "keyfile-size",      'l',  POPT_ARG_LONG, &opt_keyfile_size,          0, N_("Limits the read from keyfile"), N_("bytes") },
1280                 { "keyfile-offset",   '\0',  POPT_ARG_LONG, &opt_keyfile_offset,        0, N_("Number of bytes to skip in keyfile"), N_("bytes") },
1281                 { "new-keyfile-size", '\0',  POPT_ARG_LONG, &opt_new_keyfile_size,      0, N_("Limits the read from newly added keyfile"), N_("bytes") },
1282                 { "new-keyfile-offset",'\0', POPT_ARG_LONG, &opt_new_keyfile_offset,    0, N_("Number of bytes to skip in newly added keyfile"), N_("bytes") },
1283                 { "key-slot",          'S',  POPT_ARG_INT, &opt_key_slot,               0, N_("Slot number for new key (default is first free)"), NULL },
1284                 { "size",              'b',  POPT_ARG_STRING, &popt_tmp,                1, N_("The size of the device"), N_("SECTORS") },
1285                 { "offset",            'o',  POPT_ARG_STRING, &popt_tmp,                2, N_("The start offset in the backend device"), N_("SECTORS") },
1286                 { "skip",              'p',  POPT_ARG_STRING, &popt_tmp,                3, N_("How many sectors of the encrypted data to skip at the beginning"), N_("SECTORS") },
1287                 { "readonly",          'r',  POPT_ARG_NONE, &opt_readonly,              0, N_("Create a readonly mapping"), NULL },
1288                 { "iter-time",         'i',  POPT_ARG_INT, &opt_iteration_time,         0, N_("PBKDF2 iteration time for LUKS (in ms)"), N_("msecs") },
1289                 { "batch-mode",        'q',  POPT_ARG_NONE, &opt_batch_mode,            0, N_("Do not ask for confirmation"), NULL },
1290                 { "timeout",           't',  POPT_ARG_INT, &opt_timeout,                0, N_("Timeout for interactive passphrase prompt (in seconds)"), N_("secs") },
1291                 { "tries",             'T',  POPT_ARG_INT, &opt_tries,                  0, N_("How often the input of the passphrase can be retried"), NULL },
1292                 { "align-payload",     '\0', POPT_ARG_INT, &opt_align_payload,          0, N_("Align payload at <n> sector boundaries - for luksFormat"), N_("SECTORS") },
1293                 { "header-backup-file",'\0', POPT_ARG_STRING, &opt_header_backup_file,  0, N_("File with LUKS header and keyslots backup."), NULL },
1294                 { "use-random",        '\0', POPT_ARG_NONE, &opt_random,                0, N_("Use /dev/random for generating volume key."), NULL },
1295                 { "use-urandom",       '\0', POPT_ARG_NONE, &opt_urandom,               0, N_("Use /dev/urandom for generating volume key."), NULL },
1296                 { "shared",            '\0', POPT_ARG_NONE, &opt_shared,                0, N_("Share device with another non-overlapping crypt segment."), NULL },
1297                 { "uuid",              '\0', POPT_ARG_STRING, &opt_uuid,                0, N_("UUID for device to use."), NULL },
1298                 { "allow-discards",    '\0', POPT_ARG_NONE, &opt_allow_discards,        0, N_("Allow discards (aka TRIM) requests for device."), NULL },
1299                 { "header",            '\0', POPT_ARG_STRING, &opt_header_device,       0, N_("Device or file with separated LUKS header."), NULL },
1300                 { "test-passphrase",   '\0', POPT_ARG_NONE, &opt_test_passphrase,       0, N_("Do not activate device, just check passphrase."), NULL },
1301                 { "hidden",            '\0', POPT_ARG_NONE, &opt_hidden,               0, N_("Use hidden header (hiden TCRYPT device) ."), NULL },
1302                 POPT_TABLEEND
1303         };
1304         poptContext popt_context;
1305         struct action_type *action;
1306         const char *aname;
1307         int r;
1308
1309         crypt_set_log_callback(NULL, tool_log, NULL);
1310
1311         setlocale(LC_ALL, "");
1312         bindtextdomain(PACKAGE, LOCALEDIR);
1313         textdomain(PACKAGE);
1314
1315         crypt_fips_self_check(NULL);
1316
1317         popt_context = poptGetContext(PACKAGE, argc, argv, popt_options, 0);
1318         poptSetOtherOptionHelp(popt_context,
1319                                _("[OPTION...] <action> <action-specific>"));
1320
1321         while((r = poptGetNextOpt(popt_context)) > 0) {
1322                 unsigned long long ull_value;
1323                 char *endp;
1324
1325                 if (r == 5) {
1326                         if (opt_keyfiles_count < MAX_KEYFILES)
1327                                 opt_keyfiles[opt_keyfiles_count++] = poptGetOptArg(popt_context);
1328                         continue;
1329                 }
1330
1331                 errno = 0;
1332                 ull_value = strtoull(popt_tmp, &endp, 0);
1333                 if (*endp || !*popt_tmp ||
1334                     (errno == ERANGE && ull_value == ULLONG_MAX) ||
1335                     (errno != 0 && ull_value == 0))
1336                         r = POPT_ERROR_BADNUMBER;
1337
1338                 switch(r) {
1339                         case 1:
1340                                 opt_size = ull_value;
1341                                 break;
1342                         case 2:
1343                                 opt_offset = ull_value;
1344                                 break;
1345                         case 3:
1346                                 opt_skip = ull_value;
1347                                 opt_skip_valid = 1;
1348                                 break;
1349                 }
1350
1351                 if (r < 0)
1352                         break;
1353         }
1354
1355         if (r < -1)
1356                 usage(popt_context, EXIT_FAILURE, poptStrerror(r),
1357                       poptBadOption(popt_context, POPT_BADOPTION_NOALIAS));
1358         if (opt_version_mode) {
1359                 log_std("%s %s\n", PACKAGE_NAME, PACKAGE_VERSION);
1360                 poptFreeContext(popt_context);
1361                 exit(EXIT_SUCCESS);
1362         }
1363
1364         if (!(aname = poptGetArg(popt_context)))
1365                 usage(popt_context, EXIT_FAILURE, _("Argument <action> missing."),
1366                       poptGetInvocationName(popt_context));
1367         for(action = action_types; action->type; action++)
1368                 if (strcmp(action->type, aname) == 0)
1369                         break;
1370         if (!action->type)
1371                 usage(popt_context, EXIT_FAILURE, _("Unknown action."),
1372                       poptGetInvocationName(popt_context));
1373
1374         action_argc = 0;
1375         action_argv = poptGetArgs(popt_context);
1376         /* Make return values of poptGetArgs more consistent in case of remaining argc = 0 */
1377         if(!action_argv)
1378                 action_argv = null_action_argv;
1379
1380         /* Count args, somewhat unnice, change? */
1381         while(action_argv[action_argc] != NULL)
1382                 action_argc++;
1383
1384         if(action_argc < action->required_action_argc) {
1385                 char buf[128];
1386                 snprintf(buf, 128,_("%s: requires %s as arguments"), action->type, action->arg_desc);
1387                 usage(popt_context, EXIT_FAILURE, buf,
1388                       poptGetInvocationName(popt_context));
1389         }
1390
1391         /* FIXME: rewrite this from scratch */
1392
1393         if (opt_shared && strcmp(aname, "create"))
1394                 usage(popt_context, EXIT_FAILURE,
1395                       _("Option --shared is allowed only for create operation.\n"),
1396                       poptGetInvocationName(popt_context));
1397
1398         if (opt_allow_discards &&
1399             strcmp(aname, "luksOpen") &&
1400             strcmp(aname, "create") &&
1401             strcmp(aname, "loopaesOpen"))
1402                 usage(popt_context, EXIT_FAILURE,
1403                       _("Option --allow-discards is allowed only for luksOpen, loopaesOpen and create operation.\n"),
1404                       poptGetInvocationName(popt_context));
1405
1406         if (opt_key_size &&
1407            strcmp(aname, "luksFormat") &&
1408            strcmp(aname, "create") &&
1409            strcmp(aname, "loopaesOpen") &&
1410            strcmp(aname, "benchmark"))
1411                 usage(popt_context, EXIT_FAILURE,
1412                       _("Option --key-size is allowed only for luksFormat, create, loopaesOpen and benchmark.\n"
1413                         "To limit read from keyfile use --keyfile-size=(bytes)."),
1414                       poptGetInvocationName(popt_context));
1415
1416         if (opt_test_passphrase &&
1417            strcmp(aname, "luksOpen") &&
1418            strcmp(aname, "tcryptOpen"))
1419                 usage(popt_context, EXIT_FAILURE,
1420                       _("Option --test-passphrase is allowed only for luksOpen and tcryptOpen.\n"),
1421                       poptGetInvocationName(popt_context));
1422
1423         if (opt_key_size % 8)
1424                 usage(popt_context, EXIT_FAILURE,
1425                       _("Key size must be a multiple of 8 bits"),
1426                       poptGetInvocationName(popt_context));
1427
1428         if (!strcmp(aname, "luksKillSlot") && action_argc > 1)
1429                 opt_key_slot = atoi(action_argv[1]);
1430         if (opt_key_slot != CRYPT_ANY_SLOT &&
1431             (opt_key_slot < 0 || opt_key_slot >= crypt_keyslot_max(CRYPT_LUKS1)))
1432                 usage(popt_context, EXIT_FAILURE, _("Key slot is invalid."),
1433                       poptGetInvocationName(popt_context));
1434
1435         if ((!strcmp(aname, "luksRemoveKey") ||
1436              !strcmp(aname, "luksFormat")) &&
1437              action_argc > 1) {
1438                 if (opt_key_file)
1439                         log_err(_("Option --key-file takes precedence over specified key file argument.\n"));
1440                 else
1441                         opt_key_file = action_argv[1];
1442         }
1443
1444         if (opt_keyfile_size < 0 || opt_new_keyfile_size < 0 || opt_key_size < 0 ||
1445             opt_keyfile_offset < 0 || opt_new_keyfile_offset < 0)
1446                 usage(popt_context, EXIT_FAILURE,
1447                       _("Negative number for option not permitted."),
1448                       poptGetInvocationName(popt_context));
1449
1450         if (opt_random && opt_urandom)
1451                 usage(popt_context, EXIT_FAILURE, _("Only one of --use-[u]random options is allowed."),
1452                       poptGetInvocationName(popt_context));
1453
1454         if ((opt_random || opt_urandom) && strcmp(aname, "luksFormat"))
1455                 usage(popt_context, EXIT_FAILURE, _("Option --use-[u]random is allowed only for luksFormat."),
1456                       poptGetInvocationName(popt_context));
1457
1458         if (opt_uuid && strcmp(aname, "luksFormat") && strcmp(aname, "luksUUID"))
1459                 usage(popt_context, EXIT_FAILURE, _("Option --uuid is allowed only for luksFormat and luksUUID."),
1460                       poptGetInvocationName(popt_context));
1461
1462         if (opt_align_payload && strcmp(aname, "luksFormat"))
1463                 usage(popt_context, EXIT_FAILURE, _("Option --align-payload is allowed only for luksFormat."),
1464                       poptGetInvocationName(popt_context));
1465
1466         if (opt_skip && strcmp(aname, "create") && strcmp(aname, "loopaesOpen"))
1467                 usage(popt_context, EXIT_FAILURE,
1468                 _("Option --skip is supported only for create and loopaesOpen commands.\n"),
1469                 poptGetInvocationName(popt_context));
1470
1471         if (opt_offset && strcmp(aname, "create") && strcmp(aname, "loopaesOpen"))
1472                 usage(popt_context, EXIT_FAILURE,
1473                 _("Option --offset is supported only for create and loopaesOpen commands.\n"),
1474                 poptGetInvocationName(popt_context));
1475
1476         if (opt_hidden && strcmp(aname, "tcryptOpen") && strcmp(aname, "tcryptDump"))
1477                 usage(popt_context, EXIT_FAILURE,
1478                 _("Option --hidden is supported only for TCRYPT commands.\n"),
1479                 poptGetInvocationName(popt_context));
1480
1481         if (opt_debug) {
1482                 opt_verbose = 1;
1483                 crypt_set_debug_level(-1);
1484                 dbg_version_and_cmd(argc, argv);
1485         }
1486
1487         r = run_action(action);
1488         poptFreeContext(popt_context);
1489         return r;
1490 }