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