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