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                 if (_read_mk(opt_master_key_file, &key, keysize) < 0)
 647                         goto out;
 648
 649                 r = crypt_keyslot_add_by_volume_key(cd, opt_key_slot,
 650                                                     key, keysize, NULL, 0);
 651         } else if (opt_key_file || opt_new_key_file) {
 652                 r = crypt_keyslot_add_by_keyfile(cd, opt_key_slot,
 653                                                  opt_key_file, opt_keyfile_size,
 654                                                  opt_new_key_file, opt_new_keyfile_size);
 655         } else {
 656                 r = crypt_keyslot_add_by_passphrase(cd, opt_key_slot,
 657                                                     NULL, 0, NULL, 0);
 658         }
 659 out:
 660         crypt_free(cd);
 661         crypt_safe_free(key);
 662         return r;
 663 }
 664
 665 static int action_isLuks(int arg)
 666 {
 667         struct crypt_device *cd = NULL;
 668         int r;
 669
 670         if ((r = crypt_init(&cd, action_argv[0])))
 671                 goto out;
 672
 673         r = crypt_load(cd, CRYPT_LUKS1, NULL);
 674 out:
 675         crypt_free(cd);
 676         return r;
 677 }
 678
 679 static int action_luksUUID(int arg)
 680 {
 681         struct crypt_device *cd = NULL;
 682         const char *existing_uuid = NULL;
 683         int r;
 684
 685         if ((r = crypt_init(&cd, action_argv[0])))
 686                 goto out;
 687
 688         crypt_set_confirm_callback(cd, _yesDialog, NULL);
 689
 690         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 691                 goto out;
 692
 693         if (opt_uuid)
 694                 r = crypt_set_uuid(cd, opt_uuid);
 695         else {
 696                 existing_uuid = crypt_get_uuid(cd);
 697                 log_std("%s\n", existing_uuid ?: "");
 698                 r = existing_uuid ? 0 : 1;
 699         }
 700 out:
 701         crypt_free(cd);
 702         return r;
 703 }
 704
 705 static int luksDump_with_volume_key(struct crypt_device *cd)
 706 {
 707         char *vk = NULL, *password = NULL;
 708         unsigned int passwordLen = 0;
 709         size_t vk_size;
 710         int i, r;
 711
 712         crypt_set_confirm_callback(cd, _yesDialog, NULL);
 713         if (!_yesDialog(
 714             _("LUKS header dump with volume key is sensitive information\n"
 715               "which allows access to encrypted partition without passphrase.\n"
 716               "This dump should be always stored encrypted on safe place."),
 717               NULL))
 718                 return -EPERM;
 719
 720         vk_size = crypt_get_volume_key_size(cd);
 721         vk = crypt_safe_alloc(vk_size);
 722         if (!vk)
 723                 return -ENOMEM;
 724
 725         r = crypt_get_key(_("Enter LUKS passphrase: "), &password, &passwordLen,
 726                           opt_keyfile_size, opt_key_file, opt_timeout, 0, cd);
 727         if (r < 0)
 728                 goto out;
 729
 730         r = crypt_volume_key_get(cd, CRYPT_ANY_SLOT, vk, &vk_size,
 731                                  password, passwordLen);
 732         if (r < 0)
 733                 goto out;
 734
 735         log_std("LUKS header information for %s\n", crypt_get_device_name(cd));
 736         log_std("Cipher name:   \t%s\n", crypt_get_cipher(cd));
 737         log_std("Cipher mode:   \t%s\n", crypt_get_cipher_mode(cd));
 738         log_std("Payload offset:\t%d\n", crypt_get_data_offset(cd));
 739         log_std("UUID:          \t%s\n", crypt_get_uuid(cd));
 740         log_std("MK bits:       \t%d\n", vk_size * 8);
 741         log_std("MK dump:\t");
 742
 743         for(i = 0; i < vk_size; i++) {
 744                 if (i && !(i % 16))
 745                         log_std("\n\t\t");
 746                 log_std("%02hhx ", (char)vk[i]);
 747         }
 748         log_std("\n");
 749
 750 out:
 751         crypt_safe_free(password);
 752         crypt_safe_free(vk);
 753         return r;
 754 }
 755
 756 static int action_luksDump(int arg)
 757 {
 758         struct crypt_device *cd = NULL;
 759         int r;
 760
 761         if ((r = crypt_init(&cd, action_argv[0])))
 762                 goto out;
 763
 764         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 765                 goto out;
 766
 767         if (opt_dump_master_key)
 768                 r = luksDump_with_volume_key(cd);
 769         else
 770                 r = crypt_dump(cd);
 771 out:
 772         crypt_free(cd);
 773         return r;
 774 }
 775
 776 static int action_luksSuspend(int arg)
 777 {
 778         struct crypt_device *cd = NULL;
 779         int r;
 780
 781         r = crypt_init_by_name(&cd, action_argv[0]);
 782         if (!r)
 783                 r = crypt_suspend(cd, action_argv[0]);
 784
 785         crypt_free(cd);
 786         return r;
 787 }
 788
 789 static int action_luksResume(int arg)
 790 {
 791         struct crypt_device *cd = NULL;
 792         int r;
 793
 794         if ((r = crypt_init_by_name(&cd, action_argv[0])))
 795                 goto out;
 796
 797         if ((r = crypt_load(cd, CRYPT_LUKS1, NULL)))
 798                 goto out;
 799
 800         if (opt_key_file)
 801                 r = crypt_resume_by_keyfile(cd, action_argv[0], CRYPT_ANY_SLOT,
 802                                             opt_key_file, opt_keyfile_size);
 803         else
 804                 r = crypt_resume_by_passphrase(cd, action_argv[0], CRYPT_ANY_SLOT,
 805                                                NULL, 0);
 806 out:
 807         crypt_free(cd);
 808         return r;
 809 }
 810
 811 static int action_luksBackup(int arg)
 812 {
 813         struct crypt_device *cd = NULL;
 814         int r;
 815
 816         if (!opt_header_backup_file) {
 817                 log_err(_("Option --header-backup-file is required.\n"));
 818                 return -EINVAL;
 819         }
 820
 821         if ((r = crypt_init(&cd, action_argv[0])))
 822                 goto out;
 823
 824         crypt_set_confirm_callback(cd, _yesDialog, NULL);
 825
 826         r = crypt_header_backup(cd, CRYPT_LUKS1, opt_header_backup_file);
 827 out:
 828         crypt_free(cd);
 829         return r;
 830 }
 831
 832 static int action_luksRestore(int arg)
 833 {
 834         struct crypt_device *cd = NULL;
 835         int r = 0;
 836
 837         if (!opt_header_backup_file) {
 838                 log_err(_("Option --header-backup-file is required.\n"));
 839                 return -EINVAL;
 840         }
 841
 842         if ((r = crypt_init(&cd, action_argv[0])))
 843                 goto out;
 844
 845         crypt_set_confirm_callback(cd, _yesDialog, NULL);
 846         r = crypt_header_restore(cd, CRYPT_LUKS1, opt_header_backup_file);
 847 out:
 848         crypt_free(cd);
 849         return r;
 850 }
 851
 852 static __attribute__ ((noreturn)) void usage(poptContext popt_context,
 853                                              int exitcode, const char *error,
 854                                              const char *more)
 855 {
 856         poptPrintUsage(popt_context, stderr, 0);
 857         if (error)
 858                 log_err("%s: %s\n", more, error);
 859         exit(exitcode);
 860 }
 861
 862 static void help(poptContext popt_context, enum poptCallbackReason reason,
 863                  struct poptOption *key, const char * arg, void *data)
 864 {
 865         if (key->shortName == '?') {
 866                 struct action_type *action;
 867
 868                 log_std("%s\n",PACKAGE_STRING);
 869
 870                 poptPrintHelp(popt_context, stdout, 0);
 871
 872                 log_std(_("\n"
 873                          "<action> is one of:\n"));
 874
 875                 for(action = action_types; action->type; action++)
 876                         log_std("\t%s %s - %s\n", action->type, _(action->arg_desc), _(action->desc));
 877
 878                 log_std(_("\n"
 879                          "<name> is the device to create under %s\n"
 880                          "<device> is the encrypted device\n"
 881                          "<key slot> is the LUKS key slot number to modify\n"
 882                          "<key file> optional key file for the new key for luksAddKey action\n"),
 883                         crypt_get_dir());
 884
 885                 log_std(_("\nDefault compiled-in device cipher parameters:\n"
 886                          "\tplain: %s, Key: %d bits, Password hashing: %s\n"
 887                          "\tLUKS1: %s, Key: %d bits, LUKS header hashing: %s, RNG: %s\n"),
 888                          DEFAULT_CIPHER(PLAIN), DEFAULT_PLAIN_KEYBITS, DEFAULT_PLAIN_HASH,
 889                          DEFAULT_CIPHER(LUKS1), DEFAULT_LUKS1_KEYBITS, DEFAULT_LUKS1_HASH,
 890                          DEFAULT_RNG);
 891                 exit(EXIT_SUCCESS);
 892         } else
 893                 usage(popt_context, EXIT_SUCCESS, NULL, NULL);
 894 }
 895
 896 static void _dbg_version_and_cmd(int argc, char **argv)
 897 {
 898         int i;
 899
 900         log_std("# %s %s processing \"", PACKAGE_NAME, PACKAGE_VERSION);
 901         for (i = 0; i < argc; i++) {
 902                 if (i)
 903                         log_std(" ");
 904                 log_std(argv[i]);
 905         }
 906         log_std("\"\n");
 907 }
 908
 909 static int run_action(struct action_type *action)
 910 {
 911         int r;
 912
 913         log_dbg("Running command %s.", action->type);
 914
 915         if (action->required_memlock)
 916                 crypt_memory_lock(NULL, 1);
 917
 918         r = action->handler(action->arg);
 919
 920         if (action->required_memlock)
 921                 crypt_memory_lock(NULL, 0);
 922
 923         /* Some functions returns keyslot # */
 924         if (r > 0)
 925                 r = 0;
 926
 927         show_status(r);
 928
 929         /* Translate exit code to simple codes */
 930         switch (r) {
 931         case 0:         r = EXIT_SUCCESS; break;
 932         case -EEXIST:
 933         case -EBUSY:    r = 5; break;
 934         case -ENOTBLK:
 935         case -ENODEV:   r = 4; break;
 936         case -ENOMEM:   r = 3; break;
 937         case -EPERM:    r = 2; break;
 938         case -EINVAL:
 939         case -ENOENT:
 940         case -ENOSYS:
 941         default:        r = EXIT_FAILURE;
 942         }
 943         return r;
 944 }
 945
 946 int main(int argc, char **argv)
 947 {
 948         static char *popt_tmp;
 949         static struct poptOption popt_help_options[] = {
 950                 { NULL,    '\0', POPT_ARG_CALLBACK, help, 0, NULL,                         NULL },
 951                 { "help",  '?',  POPT_ARG_NONE,     NULL, 0, N_("Show this help message"), NULL },
 952                 { "usage", '\0', POPT_ARG_NONE,     NULL, 0, N_("Display brief usage"),    NULL },
 953                 POPT_TABLEEND
 954         };
 955         static struct poptOption popt_options[] = {
 956                 { NULL,                '\0', POPT_ARG_INCLUDE_TABLE, popt_help_options, 0, N_("Help options:"), NULL },
 957                 { "version",           '\0', POPT_ARG_NONE, &opt_version_mode,          0, N_("Print package version"), NULL },
 958                 { "verbose",           'v',  POPT_ARG_NONE, &opt_verbose,               0, N_("Shows more detailed error messages"), NULL },
 959                 { "debug",             '\0', POPT_ARG_NONE, &opt_debug,                 0, N_("Show debug messages"), NULL },
 960                 { "cipher",            'c',  POPT_ARG_STRING, &opt_cipher,              0, N_("The cipher used to encrypt the disk (see /proc/crypto)"), NULL },
 961                 { "hash",              'h',  POPT_ARG_STRING, &opt_hash,                0, N_("The hash used to create the encryption key from the passphrase"), NULL },
 962                 { "verify-passphrase", 'y',  POPT_ARG_NONE, &opt_verify_passphrase,     0, N_("Verifies the passphrase by asking for it twice"), NULL },
 963                 { "key-file",          'd',  POPT_ARG_STRING, &opt_key_file,            0, N_("Read the key from a file."), NULL },
 964                 { "master-key-file",  '\0',  POPT_ARG_STRING, &opt_master_key_file,     0, N_("Read the volume (master) key from file."), NULL },
 965                 { "dump-master-key",  '\0',  POPT_ARG_NONE, &opt_dump_master_key,       0, N_("Dump volume (master) key instead of keyslots info."), NULL },
 966                 { "key-size",          's',  POPT_ARG_INT, &opt_key_size,               0, N_("The size of the encryption key"), N_("BITS") },
 967                 { "keyfile-size",      'l',  POPT_ARG_INT, &opt_keyfile_size,           0, N_("Limits the read from keyfile"), N_("bytes") },
 968                 { "new-keyfile-size", '\0',  POPT_ARG_INT, &opt_new_keyfile_size,       0, N_("Limits the read from newly added keyfile"), N_("bytes") },
 969                 { "key-slot",          'S',  POPT_ARG_INT, &opt_key_slot,               0, N_("Slot number for new key (default is first free)"), NULL },
 970                 { "size",              'b',  POPT_ARG_STRING, &popt_tmp,                1, N_("The size of the device"), N_("SECTORS") },
 971                 { "offset",            'o',  POPT_ARG_STRING, &popt_tmp,                2, N_("The start offset in the backend device"), N_("SECTORS") },
 972                 { "skip",              'p',  POPT_ARG_STRING, &popt_tmp,                3, N_("How many sectors of the encrypted data to skip at the beginning"), N_("SECTORS") },
 973                 { "readonly",          'r',  POPT_ARG_NONE, &opt_readonly,              0, N_("Create a readonly mapping"), NULL },
 974                 { "iter-time",         'i',  POPT_ARG_INT, &opt_iteration_time,         0, N_("PBKDF2 iteration time for LUKS (in ms)"), N_("msecs") },
 975                 { "batch-mode",        'q',  POPT_ARG_NONE, &opt_batch_mode,            0, N_("Do not ask for confirmation"), NULL },
 976                 { "timeout",           't',  POPT_ARG_INT, &opt_timeout,                0, N_("Timeout for interactive passphrase prompt (in seconds)"), N_("secs") },
 977                 { "tries",             'T',  POPT_ARG_INT, &opt_tries,                  0, N_("How often the input of the passphrase can be retried"), NULL },
 978                 { "align-payload",     '\0', POPT_ARG_INT, &opt_align_payload,          0, N_("Align payload at <n> sector boundaries - for luksFormat"), N_("SECTORS") },
 979                 { "header-backup-file",'\0', POPT_ARG_STRING, &opt_header_backup_file,  0, N_("File with LUKS header and keyslots backup."), NULL },
 980                 { "use-random",        '\0', POPT_ARG_NONE, &opt_random,                0, N_("Use /dev/random for generating volume key."), NULL },
 981                 { "use-urandom",       '\0', POPT_ARG_NONE, &opt_urandom,               0, N_("Use /dev/urandom for generating volume key."), NULL },
 982                 { "uuid",              '\0',  POPT_ARG_STRING, &opt_uuid,               0, N_("UUID for device to use."), NULL },
 983                 POPT_TABLEEND
 984         };
 985         poptContext popt_context;
 986         struct action_type *action;
 987         char *aname;
 988         int r;
 989         const char *null_action_argv[] = {NULL};
 990
 991         crypt_set_log_callback(NULL, _log, NULL);
 992
 993         setlocale(LC_ALL, "");
 994         bindtextdomain(PACKAGE, LOCALEDIR);
 995         textdomain(PACKAGE);
 996
 997         popt_context = poptGetContext(PACKAGE, argc, (const char **)argv,
 998                                       popt_options, 0);
 999         poptSetOtherOptionHelp(popt_context,
1000                                N_("[OPTION...] <action> <action-specific>]"));
1001
1002         while((r = poptGetNextOpt(popt_context)) > 0) {
1003                 unsigned long long ull_value;
1004                 char *endp;
1005
1006                 ull_value = strtoull(popt_tmp, &endp, 0);
1007                 if (*endp || !*popt_tmp)
1008                         r = POPT_ERROR_BADNUMBER;
1009
1010                 switch(r) {
1011                         case 1:
1012                                 opt_size = ull_value;
1013                                 break;
1014                         case 2:
1015                                 opt_offset = ull_value;
1016                                 break;
1017                         case 3:
1018                                 opt_skip = ull_value;
1019                                 break;
1020                 }
1021
1022                 if (r < 0)
1023                         break;
1024         }
1025
1026         if (r < -1)
1027                 usage(popt_context, EXIT_FAILURE, poptStrerror(r),
1028                       poptBadOption(popt_context, POPT_BADOPTION_NOALIAS));
1029         if (opt_version_mode) {
1030                 log_std("%s %s\n", PACKAGE_NAME, PACKAGE_VERSION);
1031                 exit(EXIT_SUCCESS);
1032         }
1033
1034         if (!(aname = (char *)poptGetArg(popt_context)))
1035                 usage(popt_context, EXIT_FAILURE, _("Argument <action> missing."),
1036                       poptGetInvocationName(popt_context));
1037         for(action = action_types; action->type; action++)
1038                 if (strcmp(action->type, aname) == 0)
1039                         break;
1040         if (!action->type)
1041                 usage(popt_context, EXIT_FAILURE, _("Unknown action."),
1042                       poptGetInvocationName(popt_context));
1043
1044         action_argc = 0;
1045         action_argv = poptGetArgs(popt_context);
1046         /* Make return values of poptGetArgs more consistent in case of remaining argc = 0 */
1047         if(!action_argv)
1048                 action_argv = null_action_argv;
1049
1050         /* Count args, somewhat unnice, change? */
1051         while(action_argv[action_argc] != NULL)
1052                 action_argc++;
1053
1054         if(action_argc < action->required_action_argc) {
1055                 char buf[128];
1056                 snprintf(buf, 128,_("%s: requires %s as arguments"), action->type, action->arg_desc);
1057                 usage(popt_context, EXIT_FAILURE, buf,
1058                       poptGetInvocationName(popt_context));
1059         }
1060
1061         /* FIXME: rewrite this from scratch */
1062
1063         if (opt_key_size &&
1064            strcmp(aname, "luksFormat") &&
1065            strcmp(aname, "create") &&
1066            strcmp(aname, "loopaesOpen")) {
1067                 usage(popt_context, EXIT_FAILURE,
1068                       _("Option --key-size is allowed only for luksFormat, create and loopaesOpen.\n"
1069                         "To limit read from keyfile use --keyfile-size=(bytes)."),
1070                       poptGetInvocationName(popt_context));
1071         }
1072
1073         if (opt_key_size % 8)
1074                 usage(popt_context, EXIT_FAILURE,
1075                       _("Key size must be a multiple of 8 bits"),
1076                       poptGetInvocationName(popt_context));
1077
1078         if (!strcmp(aname, "luksKillSlot") && action_argc > 1)
1079                 opt_key_slot = atoi(action_argv[1]);
1080         if (opt_key_slot != CRYPT_ANY_SLOT &&
1081             (opt_key_slot < 0 || opt_key_slot > crypt_keyslot_max(CRYPT_LUKS1)))
1082                 usage(popt_context, EXIT_FAILURE, _("Key slot is invalid."),
1083                       poptGetInvocationName(popt_context));
1084
1085         if ((!strcmp(aname, "luksRemoveKey") ||
1086              !strcmp(aname, "luksFormat")) &&
1087              action_argc > 1) {
1088                 if (opt_key_file)
1089                         log_err(_("Option --key-file takes precedence over specified key file argument.\n"));
1090                 else
1091                         opt_key_file = (char*)action_argv[1];
1092         }
1093
1094         if (opt_random && opt_urandom)
1095                 usage(popt_context, EXIT_FAILURE, _("Only one of --use-[u]random options is allowed."),
1096                       poptGetInvocationName(popt_context));
1097         if ((opt_random || opt_urandom) && strcmp(aname, "luksFormat"))
1098                 usage(popt_context, EXIT_FAILURE, _("Option --use-[u]random is allowed only for luksFormat."),
1099                       poptGetInvocationName(popt_context));
1100
1101         if (opt_uuid && strcmp(aname, "luksFormat") && strcmp(aname, "luksUUID"))
1102                 usage(popt_context, EXIT_FAILURE, _("Option --uuid is allowed only for luksFormat and luksUUID."),
1103                       poptGetInvocationName(popt_context));
1104
1105         if ((opt_offset || opt_skip) && strcmp(aname, "create"))
1106                 usage(popt_context, EXIT_FAILURE, _("Options --offset and --skip are supported only for create command.\n"),
1107                       poptGetInvocationName(popt_context));
1108
1109         if (opt_debug) {
1110                 opt_verbose = 1;
1111                 crypt_set_debug_level(-1);
1112                 _dbg_version_and_cmd(argc, argv);
1113         }
1114
1115         return run_action(action);
1116 }