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