src/cryptsetup.c

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