#include <mntent.h>
#include <libcryptsetup.h>
-#include <libudev.h>
+#include "fileio.h"
#include "log.h"
#include "util.h"
#include "path-util.h"
#include "strv.h"
#include "ask-password-api.h"
#include "def.h"
+#include "libudev.h"
+#include "udev-util.h"
-static const char *opt_type = NULL; /* LUKS1 or PLAIN */
+static const char *opt_type = NULL; /* CRYPT_LUKS1, CRYPT_TCRYPT or CRYPT_PLAIN */
static char *opt_cipher = NULL;
static unsigned opt_key_size = 0;
static unsigned opt_keyfile_size = 0;
static unsigned opt_keyfile_offset = 0;
static char *opt_hash = NULL;
-static unsigned opt_tries = 0;
+static unsigned opt_tries = 3;
static bool opt_readonly = false;
static bool opt_verify = false;
static bool opt_discards = false;
+static bool opt_tcrypt_hidden = false;
+static bool opt_tcrypt_system = false;
+static char **opt_tcrypt_keyfiles = NULL;
static usec_t opt_timeout = 0;
/* Options Debian's crypttab knows we don't:
t = strdup(option+7);
if (!t)
- return -ENOMEM;
+ return log_oom();
free(opt_cipher);
opt_cipher = t;
return 0;
}
+ } else if (startswith(option, "tcrypt-keyfile=")) {
+
+ opt_type = CRYPT_TCRYPT;
+ if (path_is_absolute(option+15)) {
+ if (strv_extend(&opt_tcrypt_keyfiles, option + 15) < 0)
+ return log_oom();
+ } else
+ log_error("Key file path '%s' is not absolute. Ignoring.", option+15);
+
} else if (startswith(option, "keyfile-size=")) {
if (safe_atou(option+13, &opt_keyfile_size) < 0) {
t = strdup(option+5);
if (!t)
- return -ENOMEM;
+ return log_oom();
free(opt_hash);
opt_hash = t;
opt_readonly = true;
else if (streq(option, "verify"))
opt_verify = true;
- else if (streq(option, "allow-discards"))
+ else if (streq(option, "allow-discards") || streq(option, "discard"))
opt_discards = true;
else if (streq(option, "luks"))
opt_type = CRYPT_LUKS1;
- else if (streq(option, "plain") ||
+ else if (streq(option, "tcrypt"))
+ opt_type = CRYPT_TCRYPT;
+ else if (streq(option, "tcrypt-hidden")) {
+ opt_type = CRYPT_TCRYPT;
+ opt_tcrypt_hidden = true;
+ } else if (streq(option, "tcrypt-system")) {
+ opt_type = CRYPT_TCRYPT;
+ opt_tcrypt_system = true;
+ } else if (streq(option, "plain") ||
streq(option, "swap") ||
streq(option, "tmp"))
opt_type = CRYPT_PLAIN;
log_debug("%s", msg);
}
-static char *disk_description(const char *path) {
+static char* disk_description(const char *path) {
static const char name_fields[] = {
"ID_PART_ENTRY_NAME\0"
"ID_MODEL\0"
};
- struct udev *udev = NULL;
- struct udev_device *device = NULL;
+ _cleanup_udev_unref_ struct udev *udev = NULL;
+ _cleanup_udev_device_unref_ struct udev_device *device = NULL;
struct stat st;
- char *description = NULL;
const char *i;
assert(path);
device = udev_device_new_from_devnum(udev, 'b', st.st_rdev);
if (!device)
- goto finish;
+ return NULL;
NULSTR_FOREACH(i, name_fields) {
const char *name;
name = udev_device_get_property_value(device, i);
- if (!isempty(name)) {
- description = strdup(name);
- break;
- }
+ if (!isempty(name))
+ return strdup(name);
}
-finish:
- if (device)
- udev_device_unref(device);
-
- if (udev)
- udev_unref(udev);
-
- return description;
+ return NULL;
}
static char *disk_mount_point(const char *label) {
- char *mp = NULL;
_cleanup_free_ char *device = NULL;
- FILE *f = NULL;
+ _cleanup_endmntent_ FILE *f = NULL;
struct mntent *m;
/* Yeah, we don't support native systemd unit files here for now */
if (asprintf(&device, "/dev/mapper/%s", label) < 0)
- goto finish;
+ return NULL;
f = setmntent("/etc/fstab", "r");
if (!f)
- goto finish;
+ return NULL;
while ((m = getmntent(f)))
- if (path_equal(m->mnt_fsname, device)) {
- mp = strdup(m->mnt_dir);
- break;
- }
+ if (path_equal(m->mnt_fsname, device))
+ return strdup(m->mnt_dir);
-finish:
- if (f)
- endmntent(f);
-
- return mp;
+ return NULL;
}
static int get_password(const char *name, usec_t until, bool accept_cached, char ***passwords) {
return 0;
}
+static int attach_tcrypt(struct crypt_device *cd,
+ const char *name,
+ const char *key_file,
+ char **passwords,
+ uint32_t flags) {
+ int r = 0;
+ _cleanup_free_ char *passphrase = NULL;
+ struct crypt_params_tcrypt params = {
+ .flags = CRYPT_TCRYPT_LEGACY_MODES,
+ .keyfiles = (const char **)opt_tcrypt_keyfiles,
+ .keyfiles_count = strv_length(opt_tcrypt_keyfiles)
+ };
+
+ assert(cd);
+ assert(name);
+ assert(key_file || passwords);
+
+ if (opt_tcrypt_hidden)
+ params.flags |= CRYPT_TCRYPT_HIDDEN_HEADER;
+
+ if (opt_tcrypt_system)
+ params.flags |= CRYPT_TCRYPT_SYSTEM_HEADER;
+
+ if (key_file) {
+ r = read_one_line_file(key_file, &passphrase);
+ if (r < 0) {
+ log_error("Failed to read password file '%s': %s", key_file, strerror(-r));
+ return -EAGAIN;
+ }
+
+ params.passphrase = passphrase;
+ } else
+ params.passphrase = passwords[0];
+ params.passphrase_size = strlen(params.passphrase);
+
+ r = crypt_load(cd, CRYPT_TCRYPT, ¶ms);
+ if (r < 0) {
+ if (key_file && r == -EPERM) {
+ log_error("Failed to activate using password file '%s'.", key_file);
+ return -EAGAIN;
+ }
+ return r;
+ }
+
+ return crypt_activate_by_volume_key(cd, name, NULL, 0, flags);;
+}
+
static int attach_luks_or_plain(struct crypt_device *cd,
const char *name,
const char *key_file,
!streq(argv[4], "none")) {
if (!path_is_absolute(argv[4]))
- log_error("Password file path %s is not absolute. Ignoring.", argv[4]);
+ log_error("Password file path '%s' is not absolute. Ignoring.", argv[4]);
else
key_file = argv[4];
}
else
until = 0;
- opt_tries = opt_tries > 0 ? opt_tries : 3;
opt_key_size = (opt_key_size > 0 ? opt_key_size : 256);
if (key_file) {
log_warning("Key file %s is world-readable. This is not a good idea!", key_file);
}
- for (tries = 0; tries < opt_tries; tries++) {
+ for (tries = 0; opt_tries == 0 || tries < opt_tries; tries++) {
_cleanup_strv_free_ char **passwords = NULL;
if (!key_file) {
goto finish;
}
- k = attach_luks_or_plain(cd, argv[2], key_file, passwords, flags);
+ if (streq_ptr(opt_type, CRYPT_TCRYPT))
+ k = attach_tcrypt(cd, argv[2], key_file, passwords, flags);
+ else
+ k = attach_luks_or_plain(cd, argv[2], key_file, passwords, flags);
if (k >= 0)
break;
else if (k == -EAGAIN) {
log_warning("Invalid passphrase.");
}
- if (tries >= opt_tries) {
+ if (opt_tries != 0 && tries >= opt_tries) {
log_error("Too many attempts; giving up.");
r = EXIT_FAILURE;
goto finish;
free(opt_cipher);
free(opt_hash);
+ strv_free(opt_tcrypt_keyfiles);
return r;
}