src/cryptsetup.c

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