X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcryptsetup_reencrypt.c;h=a536093b6303f6439cc15202e3a9bce931e01d4a;hb=aa66c91d39314000f31c4c024c3e21302a2822fc;hp=c6b7e5865929d17f9c0d9da288376567ee4be303;hpb=fb3b62ca02013b8526fc0e73bc5c19f737be27fa;p=platform%2Fupstream%2Fcryptsetup.git

diff --git a/src/cryptsetup_reencrypt.c b/src/cryptsetup_reencrypt.c
index c6b7e58..a536093 100644
--- a/src/cryptsetup_reencrypt.c
+++ b/src/cryptsetup_reencrypt.c
@@ -1,12 +1,13 @@
 /*
  * cryptsetup-reencrypt - crypt utility for offline re-encryption
  *
- * Copyright (C) 2012, Milan Broz All rights reserved.
- * Copyright (C) 2012, Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2012-2020 Red Hat, Inc. All rights reserved.
+ * Copyright (C) 2012-2020 Milan Broz All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -18,47 +19,32 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#define PACKAGE_REENC "crypt_reencrypt"
-
-#define _LARGEFILE64_SOURCE
-#define _FILE_OFFSET_BITS 64
-#define SECTOR_SIZE 512
-#define NO_UUID "cafecafe-cafe-cafe-cafe-cafecafeeeee"
-#define MAX_BCK_SECTORS 8192
-
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdarg.h>
-#include <inttypes.h>
-#include <errno.h>
-#include <unistd.h>
-#include <sys/stat.h>
+#include "cryptsetup.h"
 #include <sys/ioctl.h>
-#include <sys/time.h>
 #include <linux/fs.h>
 #include <arpa/inet.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <popt.h>
+#include <uuid/uuid.h>
 
-#include "cryptsetup.h"
+#define PACKAGE_REENC "cryptsetup-reencrypt"
+
+#define NO_UUID "cafecafe-cafe-cafe-cafe-cafecafeeeee"
 
-static int opt_verbose = 0;
-static int opt_debug = 0;
 static const char *opt_cipher = NULL;
 static const char *opt_hash = NULL;
 static const char *opt_key_file = NULL;
+static const char *opt_master_key_file = NULL;
+static const char *opt_uuid = NULL;
+static const char *opt_type = "luks";
 static long opt_keyfile_size = 0;
 static long opt_keyfile_offset = 0;
-static int opt_iteration_time = 1000;
-static int opt_batch_mode = 0;
-static int opt_version_mode = 0;
+static int opt_iteration_time = 0;
+static const char *opt_pbkdf = NULL;
+static long opt_pbkdf_memory = DEFAULT_LUKS2_MEMORY_KB;
+static long opt_pbkdf_parallel = DEFAULT_LUKS2_PARALLEL_THREADS;
+static long opt_pbkdf_iterations = 0;
 static int opt_random = 0;
 static int opt_urandom = 0;
 static int opt_bsize = 4;
-static int opt_reduce_device_size = 0;
 static int opt_directio = 0;
 static int opt_fsync = 0;
 static int opt_write_log = 0;
@@ -66,34 +52,46 @@ static int opt_tries = 3;
 static int opt_key_slot = CRYPT_ANY_SLOT;
 static int opt_key_size = 0;
 static int opt_new = 0;
+static int opt_keep_key = 0;
+static int opt_decrypt = 0;
+static const char *opt_header_device = NULL;
+
+static const char *opt_reduce_size_str = NULL;
+static uint64_t opt_reduce_size = 0;
 
 static const char *opt_device_size_str = NULL;
 static uint64_t opt_device_size = 0;
 
 static const char **action_argv;
 
-static volatile int quit = 0;
-
-#define MAX_SLOT 8
+#define MAX_SLOT 32
+#define MAX_TOKEN 32
 struct reenc_ctx {
 	char *device;
+	char *device_header;
 	char *device_uuid;
-	uint64_t device_size; /* overrided by parameter */
-	uint64_t device_size_real;
+	const char *type;
+	uint64_t device_size; /* overridden by parameter */
+	uint64_t device_size_new_real;
+	uint64_t device_size_org_real;
 	uint64_t device_offset;
 	uint64_t device_shift;
+	uint64_t data_offset;
 
-	int in_progress:1;
+	unsigned int stained:1;
+	unsigned int in_progress:1;
 	enum { FORWARD = 0, BACKWARD = 1 } reencrypt_direction;
+	enum { REENCRYPT = 0, ENCRYPT = 1, DECRYPT = 2 } reencrypt_mode;
 
 	char header_file_org[PATH_MAX];
+	char header_file_tmp[PATH_MAX];
 	char header_file_new[PATH_MAX];
 	char log_file[PATH_MAX];
 
 	char crypt_path_org[PATH_MAX];
 	char crypt_path_new[PATH_MAX];
 	int log_fd;
-	char *log_buf;
+	char log_buf[SECTOR_SIZE];
 
 	struct {
 		char *password;
@@ -101,8 +99,7 @@ struct reenc_ctx {
 	} p[MAX_SLOT];
 	int keyslot;
 
-	struct timeval start_time, end_time;
-	uint64_t restart_bytes;
+	uint64_t resume_bytes;
 };
 
 char MAGIC[]   = {'L','U','K','S', 0xba, 0xbe};
@@ -116,116 +113,103 @@ typedef enum {
 	CHECK_OPEN,
 } header_magic;
 
-__attribute__((format(printf, 5, 6)))
-static void clogger(struct crypt_device *cd, int level, const char *file,
-		   int line, const char *format, ...)
-{
-	va_list argp;
-	char *target = NULL;
-
-	va_start(argp, format);
-
-	if (vasprintf(&target, format, argp) > 0) {
-		if (level >= 0) {
-			crypt_log(cd, level, target);
-		} else if (opt_debug)
-			printf("# %s\n", target);
-	}
-
-	va_end(argp);
-	free(target);
-}
-
-static void _log(int level, const char *msg, void *usrptr __attribute__((unused)))
-{
-	switch(level) {
-
-	case CRYPT_LOG_NORMAL:
-		fputs(msg, stdout);
-		break;
-	case CRYPT_LOG_VERBOSE:
-		if (opt_verbose)
-			fputs(msg, stdout);
-		break;
-	case CRYPT_LOG_ERROR:
-		fputs(msg, stderr);
-		break;
-	case CRYPT_LOG_DEBUG:
-		if (opt_debug)
-			printf("# %s\n", msg);
-		break;
-	default:
-		fprintf(stderr, "Internal error on logging class for msg: %s", msg);
-		break;
-	}
-}
-
 static void _quiet_log(int level, const char *msg, void *usrptr)
 {
 	if (!opt_debug)
 		return;
-	_log(level, msg, usrptr);
+	tool_log(level, msg, usrptr);
 }
 
-static void int_handler(int sig __attribute__((__unused__)))
+static int alignment(int fd)
 {
-	quit++;
+	int alignment;
+
+	alignment = fpathconf(fd, _PC_REC_XFER_ALIGN);
+	if (alignment < 0)
+		alignment = 4096;
+	return alignment;
 }
 
-static void set_int_block(int block)
+static size_t pagesize(void)
 {
-	sigset_t signals_open;
-
-	sigemptyset(&signals_open);
-	sigaddset(&signals_open, SIGINT);
-	sigaddset(&signals_open, SIGTERM);
-	sigprocmask(block ? SIG_SETMASK : SIG_UNBLOCK, &signals_open, NULL);
+	long r = sysconf(_SC_PAGESIZE);
+	return r < 0 ? 4096 : (size_t)r;
 }
 
-static void set_int_handler(void)
+static const char *luksType(const char *type)
 {
-	struct sigaction sigaction_open;
+	if (type && !strcmp(type, "luks2"))
+		return CRYPT_LUKS2;
 
-	memset(&sigaction_open, 0, sizeof(struct sigaction));
-	sigaction_open.sa_handler = int_handler;
-	sigaction(SIGINT, &sigaction_open, 0);
-	sigaction(SIGTERM, &sigaction_open, 0);
-	set_int_block(0);
+	if (type && !strcmp(type, "luks1"))
+		return CRYPT_LUKS1;
+
+	if (!type || !strcmp(type, "luks"))
+		return crypt_get_default_type();
+
+	return NULL;
 }
 
-/* The difference in seconds between two times in "timeval" format. */
-static double time_diff(struct timeval start, struct timeval end)
+static const char *hdr_device(const struct reenc_ctx *rc)
 {
-	return (end.tv_sec - start.tv_sec)
-		+ (end.tv_usec - start.tv_usec) / 1E6;
+	return rc->device_header ?: rc->device;
 }
 
-static int alignment(int fd)
+static int set_reencrypt_requirement(const struct reenc_ctx *rc)
 {
-	int alignment;
+	uint32_t reqs;
+	int r = -EINVAL;
+	struct crypt_device *cd = NULL;
+	struct crypt_params_integrity ip = { 0 };
 
-	alignment = fpathconf(fd, _PC_REC_XFER_ALIGN);
-	if (alignment < 0)
-		alignment = 4096;
-	return alignment;
+	if (crypt_init(&cd, hdr_device(rc)) ||
+	    crypt_load(cd, CRYPT_LUKS2, NULL) ||
+	    crypt_persistent_flags_get(cd, CRYPT_FLAGS_REQUIREMENTS, &reqs))
+		goto out;
+
+	/* reencrypt already in-progress */
+	if (reqs & CRYPT_REQUIREMENT_OFFLINE_REENCRYPT) {
+		log_err(_("Reencryption already in-progress."));
+		goto out;
+	}
+
+	/* raw integrity info is available since 2.0 */
+	if (crypt_get_integrity_info(cd, &ip) || ip.tag_size) {
+		log_err(_("Reencryption of device with integrity profile is not supported."));
+		r = -ENOTSUP;
+		goto out;
+	}
+
+	r = crypt_persistent_flags_set(cd, CRYPT_FLAGS_REQUIREMENTS, reqs | CRYPT_REQUIREMENT_OFFLINE_REENCRYPT);
+out:
+	crypt_free(cd);
+	return r;
 }
 
 /* Depends on the first two fields of LUKS1 header format, magic and version */
-static int device_check(struct reenc_ctx *rc, header_magic set_magic)
+static int device_check(struct reenc_ctx *rc, const char *device, header_magic set_magic)
 {
 	char *buf = NULL;
 	int r, devfd;
 	ssize_t s;
 	uint16_t version;
+	size_t buf_size = pagesize();
+	struct stat st;
+
+	if (stat(device, &st)) {
+		log_err(_("Cannot open device %s."), device);
+		return -EINVAL;
+	}
 
-	devfd = open(rc->device, O_RDWR | O_EXCL | O_DIRECT);
+	/* coverity[toctou] */
+	devfd = open(device, O_RDWR | (S_ISBLK(st.st_mode) ? O_EXCL : 0));
 	if (devfd == -1) {
 		if (errno == EBUSY) {
-			log_err(_("Cannot exclusively open %s, device in use.\n"),
-				rc->device);
+			log_err(_("Cannot exclusively open %s, device in use."),
+				device);
 			return -EBUSY;
 		}
-		log_err(_("Cannot open device %s\n"), rc->device);
+		log_err(_("Cannot open device %s."), device);
 		return -EINVAL;
 	}
 
@@ -234,17 +218,17 @@ static int device_check(struct reenc_ctx *rc, header_magic set_magic)
 		goto out;
 	}
 
-	if (posix_memalign((void *)&buf, alignment(devfd), SECTOR_SIZE)) {
-		log_err(_("Allocation of aligned memory failed.\n"));
+	if (posix_memalign((void *)&buf, alignment(devfd), buf_size)) {
+		log_err(_("Allocation of aligned memory failed."));
 		r = -ENOMEM;
 		goto out;
 	}
 
-	s = read(devfd, buf, SECTOR_SIZE);
-	if (s < 0 || s != SECTOR_SIZE) {
-		log_err(_("Cannot read device %s.\n"), rc->device);
-		close(devfd);
-		return -EIO;
+	s = read(devfd, buf, buf_size);
+	if (s < 0 || s != (ssize_t)buf_size) {
+		log_err(_("Cannot read device %s."), device);
+		r = -EIO;
+		goto out;
 	}
 
 	/* Be sure that we do not process new version of header */
@@ -253,14 +237,14 @@ static int device_check(struct reenc_ctx *rc, header_magic set_magic)
 
 	if (set_magic == MAKE_UNUSABLE && !memcmp(buf, MAGIC, MAGIC_L) &&
 	    version == 1) {
-		log_verbose(_("Marking LUKS device %s unusable.\n"), rc->device);
+		log_verbose(_("Marking LUKS1 device %s unusable."), device);
 		memcpy(buf, NOMAGIC, MAGIC_L);
 		r = 0;
-	} else if (set_magic == MAKE_USABLE && !memcmp(buf, NOMAGIC, MAGIC_L) &&
-		   version == 1) {
-		log_verbose(_("Marking LUKS device %s usable.\n"), rc->device);
-		memcpy(buf, MAGIC, MAGIC_L);
-		r = 0;
+	} else if (set_magic == MAKE_UNUSABLE && version == 2) {
+		log_verbose(_("Setting LUKS2 offline reencrypt flag on device %s."), device);
+		r = set_reencrypt_requirement(rc);
+		if (!r)
+			rc->stained = 1;
 	} else if (set_magic == CHECK_UNUSABLE && version == 1) {
 		r = memcmp(buf, NOMAGIC, MAGIC_L) ? -EINVAL : 0;
 		if (!r)
@@ -269,73 +253,40 @@ static int device_check(struct reenc_ctx *rc, header_magic set_magic)
 	} else
 		r = -EINVAL;
 
-	if (!r) {
+	if (!r && version == 1) {
 		if (lseek(devfd, 0, SEEK_SET) == -1)
 			goto out;
-		s = write(devfd, buf, SECTOR_SIZE);
-		if (s < 0 || s != SECTOR_SIZE) {
-			log_err(_("Cannot write device %s.\n"), rc->device);
+		s = write(devfd, buf, buf_size);
+		if (s < 0 || s != (ssize_t)buf_size || fsync(devfd) < 0) {
+			log_err(_("Cannot write device %s."), device);
 			r = -EIO;
 		}
-	} else
-		log_dbg("LUKS signature check failed for %s.", rc->device);
+		if (s > 0 && set_magic == MAKE_UNUSABLE)
+			rc->stained = 1;
+	}
+	if (r)
+		log_dbg("LUKS signature check failed for %s.", device);
 out:
 	if (buf)
-		memset(buf, 0, SECTOR_SIZE);
+		memset(buf, 0, buf_size);
 	free(buf);
 	close(devfd);
 	return r;
 }
 
-static int create_empty_header(const char *new_file, const char *old_file,
-			       uint64_t data_sector)
+static int create_empty_header(const char *new_file)
 {
-	struct stat st;
-	ssize_t size = 0;
 	int fd, r = 0;
-	char *buf;
-
-	/* Never create header > 4MiB */
-	if (data_sector > MAX_BCK_SECTORS)
-		data_sector = MAX_BCK_SECTORS;
-
-	/* new header file of the same size as old backup */
-	if (old_file) {
-		if (stat(old_file, &st) == -1 ||
-		    (st.st_mode & S_IFMT) != S_IFREG ||
-		    (st.st_size > 16 * 1024 * 1024))
-			return -EINVAL;
-		size = st.st_size;
-	}
-
-	/*
-	 * if requesting key size change, try to use offset
-	 * here can be enough space to fit new key.
-	 */
-	if (opt_key_size)
-		size = data_sector * SECTOR_SIZE;
-
-	/* if reducing size, be sure we have enough space */
-	if (opt_reduce_device_size)
-		size += (opt_reduce_device_size * SECTOR_SIZE);
-
-	log_dbg("Creating empty file %s of size %lu.", new_file, (unsigned long)size);
 
-	if (!size || !(buf = malloc(size)))
-		return -ENOMEM;
-	memset(buf, 0, size);
-
-	fd = creat(new_file, S_IRUSR|S_IWUSR);
-	if(fd == -1) {
-		free(buf);
-		return -EINVAL;
-	}
+	log_dbg("Creating empty file %s of size 4096.", new_file);
 
-	if (write(fd, buf, size) < size)
-		r = -EIO;
+	/* coverity[toctou] */
+	fd = open(new_file, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
+	if (fd == -1 || posix_fallocate(fd, 0, 4096))
+		r = -EINVAL;
+	if (fd >= 0)
+		close(fd);
 
-	close(fd);
-	free(buf);
 	return r;
 }
 
@@ -345,15 +296,17 @@ static int write_log(struct reenc_ctx *rc)
 
 	memset(rc->log_buf, 0, SECTOR_SIZE);
 	snprintf(rc->log_buf, SECTOR_SIZE, "# LUKS reencryption log, DO NOT EDIT OR DELETE.\n"
-		"version = %d\nUUID = %s\ndirection = %d\n"
+		"version = %d\nUUID = %s\ndirection = %d\nmode = %d\n"
 		"offset = %" PRIu64 "\nshift = %" PRIu64 "\n# EOF\n",
-		1, rc->device_uuid, rc->reencrypt_direction,
+		2, rc->device_uuid, rc->reencrypt_direction, rc->reencrypt_mode,
 		rc->device_offset, rc->device_shift);
 
-	lseek(rc->log_fd, 0, SEEK_SET);
+	if (lseek(rc->log_fd, 0, SEEK_SET) == -1)
+		return -EIO;
+
 	r = write(rc->log_fd, rc->log_buf, SECTOR_SIZE);
 	if (r < 0 || r != SECTOR_SIZE) {
-		log_err(_("Cannot write reencryption log file.\n"));
+		log_err(_("Cannot write reencryption log file."));
 		return -EIO;
 	}
 
@@ -371,7 +324,7 @@ static int parse_line_log(struct reenc_ctx *rc, const char *line)
 		return 0;
 
 	if (sscanf(line, "version = %d", &i) == 1) {
-		if (i != 1) {
+		if (i < 1 || i > 2) {
 			log_dbg("Log: Unexpected version = %i", i);
 			return -EINVAL;
 		}
@@ -389,6 +342,13 @@ static int parse_line_log(struct reenc_ctx *rc, const char *line)
 	} else if (sscanf(line, "shift = %" PRIu64, &u64) == 1) {
 		log_dbg("Log: shift = %" PRIu64, u64);
 		rc->device_shift = u64;
+	} else if (sscanf(line, "mode = %d", &i) == 1) { /* added in v2 */
+		log_dbg("Log: mode = %i", i);
+		rc->reencrypt_mode = i;
+		if (rc->reencrypt_mode != REENCRYPT &&
+		    rc->reencrypt_mode != ENCRYPT &&
+		    rc->reencrypt_mode != DECRYPT)
+			return -EINVAL;
 	} else
 		return -EINVAL;
 
@@ -402,7 +362,7 @@ static int parse_log(struct reenc_ctx *rc)
 
 	s = read(rc->log_fd, rc->log_buf, SECTOR_SIZE);
 	if (s == -1) {
-		log_err(_("Cannot read reencryption log file.\n"));
+		log_err(_("Cannot read reencryption log file."));
 		return -EIO;
 	}
 
@@ -413,7 +373,7 @@ static int parse_log(struct reenc_ctx *rc)
 		if (end) {
 			*end++ = '\0';
 			if (parse_line_log(rc, start)) {
-				log_err("Wrong log format.\n");
+				log_err("Wrong log format.");
 				return -EINVAL;
 			}
 		}
@@ -429,44 +389,26 @@ static void close_log(struct reenc_ctx *rc)
 	log_dbg("Closing LUKS reencryption log file %s.", rc->log_file);
 	if (rc->log_fd != -1)
 		close(rc->log_fd);
-	free(rc->log_buf);
-	rc->log_buf = NULL;
 }
 
 static int open_log(struct reenc_ctx *rc)
 {
-	int flags, create_new;
-	struct stat st;
-
-	if (!stat(rc->log_file, &st))
-		create_new = 0;
-	else if (errno == ENOENT)
-		create_new = 1;
-	else
-		return -EINVAL;
-
-	if (create_new) {
-		log_dbg("Creating LUKS reencryption log file %s.", rc->log_file);
-		flags = opt_directio ? O_RDWR|O_CREAT|O_DIRECT : O_RDWR|O_CREAT;
-		rc->log_fd = open(rc->log_file, flags, S_IRUSR|S_IWUSR);
-		if (rc->log_fd == -1)
-			return -EINVAL;
-	} else {
-		log_std(_("Log file %s exists, restarting reencryption.\n"), rc->log_file);
-		flags = opt_directio ? O_RDWR|O_DIRECT : O_RDWR;
-		rc->log_fd = open(rc->log_file, flags);
-		if (rc->log_fd == -1)
-			return -EINVAL;
+	int flags = opt_fsync ? O_SYNC : 0;
+
+	rc->log_fd = open(rc->log_file, O_RDWR|O_EXCL|O_CREAT|flags, S_IRUSR|S_IWUSR);
+	if (rc->log_fd != -1) {
+		log_dbg("Created LUKS reencryption log file %s.", rc->log_file);
+		rc->stained = 0;
+	} else if (errno == EEXIST) {
+		log_std(_("Log file %s exists, resuming reencryption.\n"), rc->log_file);
+		rc->log_fd = open(rc->log_file, O_RDWR|flags);
 		rc->in_progress = 1;
 	}
 
-	if (posix_memalign((void *)&rc->log_buf, alignment(rc->log_fd), SECTOR_SIZE)) {
-		log_err(_("Allocation of aligned memory failed.\n"));
-		close_log(rc);
-		return -ENOMEM;
-	}
+	if (rc->log_fd == -1)
+		return -EINVAL;
 
-	if (create_new && write_log(rc) < 0) {
+	if (!rc->in_progress && write_log(rc) < 0) {
 		close_log(rc);
 		return -EIO;
 	}
@@ -478,27 +420,48 @@ static int open_log(struct reenc_ctx *rc)
 static int activate_luks_headers(struct reenc_ctx *rc)
 {
 	struct crypt_device *cd = NULL, *cd_new = NULL;
+	const char *pwd_old, *pwd_new, pwd_empty[] = "";
+	size_t pwd_old_len, pwd_new_len;
 	int r;
 
 	log_dbg("Activating LUKS devices from headers.");
 
-	if ((r = crypt_init(&cd, rc->header_file_org)) ||
-	    (r = crypt_load(cd, CRYPT_LUKS1, NULL)) ||
-	    (r = crypt_set_data_device(cd, rc->device)))
+	/* Never use real password for empty header processing */
+	if (rc->reencrypt_mode == REENCRYPT) {
+		pwd_old = rc->p[rc->keyslot].password;
+		pwd_old_len = rc->p[rc->keyslot].passwordLen;
+		pwd_new = pwd_old;
+		pwd_new_len = pwd_old_len;
+	} else if (rc->reencrypt_mode == DECRYPT) {
+		pwd_old = rc->p[rc->keyslot].password;
+		pwd_old_len = rc->p[rc->keyslot].passwordLen;
+		pwd_new = pwd_empty;
+		pwd_new_len = 0;
+	} else if (rc->reencrypt_mode == ENCRYPT) {
+		pwd_old = pwd_empty;
+		pwd_old_len = 0;
+		pwd_new = rc->p[rc->keyslot].password;
+		pwd_new_len = rc->p[rc->keyslot].passwordLen;
+	} else
+		return -EINVAL;
+
+	if ((r = crypt_init_data_device(&cd, rc->header_file_org, rc->device)) ||
+	    (r = crypt_load(cd, CRYPT_LUKS, NULL)))
 		goto out;
 
+	log_verbose(_("Activating temporary device using old LUKS header."));
 	if ((r = crypt_activate_by_passphrase(cd, rc->header_file_org,
-		opt_key_slot, rc->p[rc->keyslot].password, rc->p[rc->keyslot].passwordLen,
+		opt_key_slot, pwd_old, pwd_old_len,
 		CRYPT_ACTIVATE_READONLY|CRYPT_ACTIVATE_PRIVATE)) < 0)
 		goto out;
 
-	if ((r = crypt_init(&cd_new, rc->header_file_new)) ||
-	    (r = crypt_load(cd_new, CRYPT_LUKS1, NULL)) ||
-	    (r = crypt_set_data_device(cd_new, rc->device)))
+	if ((r = crypt_init_data_device(&cd_new, rc->header_file_new, rc->device)) ||
+	    (r = crypt_load(cd_new, CRYPT_LUKS, NULL)))
 		goto out;
 
+	log_verbose(_("Activating temporary device using new LUKS header."));
 	if ((r = crypt_activate_by_passphrase(cd_new, rc->header_file_new,
-		opt_key_slot, rc->p[rc->keyslot].password, rc->p[rc->keyslot].passwordLen,
+		opt_key_slot, pwd_new, pwd_new_len,
 		CRYPT_ACTIVATE_SHARED|CRYPT_ACTIVATE_PRIVATE)) < 0)
 		goto out;
 	r = 0;
@@ -506,13 +469,73 @@ out:
 	crypt_free(cd);
 	crypt_free(cd_new);
 	if (r < 0)
-		log_err(_("Activation of temporary devices failed.\n"));
+		log_err(_("Activation of temporary devices failed."));
+	return r;
+}
+
+static int set_pbkdf_params(struct crypt_device *cd, const char *dev_type)
+{
+	const struct crypt_pbkdf_type *pbkdf_default;
+	struct crypt_pbkdf_type pbkdf = {};
+
+	pbkdf_default = crypt_get_pbkdf_default(dev_type);
+	if (!pbkdf_default)
+		return -EINVAL;
+
+	pbkdf.type = opt_pbkdf ?: pbkdf_default->type;
+	pbkdf.hash = opt_hash ?: pbkdf_default->hash;
+	pbkdf.time_ms = (uint32_t)opt_iteration_time ?: pbkdf_default->time_ms;
+	if (strcmp(pbkdf.type, CRYPT_KDF_PBKDF2)) {
+		pbkdf.max_memory_kb = (uint32_t)opt_pbkdf_memory ?: pbkdf_default->max_memory_kb;
+		pbkdf.parallel_threads = (uint32_t)opt_pbkdf_parallel ?: pbkdf_default->parallel_threads;
+	}
+
+	if (opt_pbkdf_iterations) {
+		pbkdf.iterations = opt_pbkdf_iterations;
+		pbkdf.time_ms = 0;
+		pbkdf.flags |= CRYPT_PBKDF_NO_BENCHMARK;
+	}
+
+	return crypt_set_pbkdf_type(cd, &pbkdf);
+}
+
+static int create_new_keyslot(struct reenc_ctx *rc, int keyslot,
+			      struct crypt_device *cd_old,
+			      struct crypt_device *cd_new)
+{
+	int r;
+	char *key = NULL;
+	size_t key_size;
+
+	if (cd_old && crypt_keyslot_status(cd_old, keyslot) == CRYPT_SLOT_UNBOUND) {
+		key_size = 4096;
+		key = crypt_safe_alloc(key_size);
+		if (!key)
+			return -ENOMEM;
+		r = crypt_volume_key_get(cd_old, keyslot, key, &key_size,
+			rc->p[keyslot].password, rc->p[keyslot].passwordLen);
+		if (r == keyslot) {
+			r = crypt_keyslot_add_by_key(cd_new, keyslot, key, key_size,
+				rc->p[keyslot].password, rc->p[keyslot].passwordLen,
+				CRYPT_VOLUME_KEY_NO_SEGMENT);
+		} else
+			r = -EINVAL;
+		crypt_safe_free(key);
+	} else
+		r = crypt_keyslot_add_by_volume_key(cd_new, keyslot, NULL, 0,
+			rc->p[keyslot].password, rc->p[keyslot].passwordLen);
+
 	return r;
 }
 
-static int create_new_header(struct reenc_ctx *rc, const char *cipher,
-			     const char *cipher_mode, const char *uuid,
-			     int key_size, struct crypt_params_luks1 *params)
+static int create_new_header(struct reenc_ctx *rc, struct crypt_device *cd_old,
+			     const char *cipher, const char *cipher_mode,
+			     const char *uuid,
+			     const char *key, int key_size,
+			     const char *type,
+			     uint64_t metadata_size,
+			     uint64_t keyslots_size,
+			     void *params)
 {
 	struct crypt_device *cd_new = NULL;
 	int i, r;
@@ -525,21 +548,39 @@ static int create_new_header(struct reenc_ctx *rc, const char *cipher,
 	else if (opt_urandom)
 		crypt_set_rng_type(cd_new, CRYPT_RNG_URANDOM);
 
-	if (opt_iteration_time)
-		crypt_set_iteration_time(cd_new, opt_iteration_time);
+	r = set_pbkdf_params(cd_new, type);
+	if (r) {
+		log_err(_("Failed to set pbkdf parameters."));
+		goto out;
+	}
 
-	if ((r = crypt_format(cd_new, CRYPT_LUKS1, cipher, cipher_mode,
-			      uuid, NULL, key_size, params)))
+	r = crypt_set_data_offset(cd_new, rc->data_offset);
+	if (r) {
+		log_err(_("Failed to set data offset."));
 		goto out;
-	log_verbose(_("New LUKS header for device %s created.\n"), rc->device);
+	}
 
-	for (i = 0; i < MAX_SLOT; i++) {
+	r = crypt_set_metadata_size(cd_new, metadata_size, keyslots_size);
+	if (r) {
+		log_err(_("Failed to set metadata size."));
+		goto out;
+	}
+
+	r = crypt_format(cd_new, type, cipher, cipher_mode, uuid, key, key_size, params);
+	check_signal(&r);
+	if (r < 0)
+		goto out;
+	log_verbose(_("New LUKS header for device %s created."), rc->device);
+
+	for (i = 0; i < crypt_keyslot_max(type); i++) {
 		if (!rc->p[i].password)
 			continue;
-		if ((r = crypt_keyslot_add_by_volume_key(cd_new, i,
-			NULL, 0, rc->p[i].password, rc->p[i].passwordLen)) < 0)
+
+		r = create_new_keyslot(rc, i, cd_old, cd_new);
+		check_signal(&r);
+		if (r < 0)
 			goto out;
-		log_verbose(_("Activated keyslot %i.\n"), r);
+		tools_keyslot_msg(r, CREATED);
 		r = 0;
 	}
 out:
@@ -547,51 +588,184 @@ out:
 	return r;
 }
 
+static int isLUKS2(const char *type)
+{
+	return (type && !strcmp(type, CRYPT_LUKS2));
+}
+
+static int luks2_metadata_copy(struct reenc_ctx *rc)
+{
+	const char *json, *type;
+	crypt_token_info ti;
+	uint32_t flags;
+	int i, r = -EINVAL;
+	struct crypt_device *cd_old = NULL, *cd_new = NULL;
+
+	if (crypt_init(&cd_old, rc->header_file_tmp) ||
+	    crypt_load(cd_old, CRYPT_LUKS2, NULL))
+		goto out;
+
+	if (crypt_init(&cd_new, rc->header_file_new) ||
+	    crypt_load(cd_new, CRYPT_LUKS2, NULL))
+		goto out;
+
+	/*
+	 * we have to erase keyslots missing in new header so that we can
+	 * transfer tokens from old header to new one
+	 */
+	for (i = 0; i < crypt_keyslot_max(CRYPT_LUKS2); i++)
+		if (!rc->p[i].password && crypt_keyslot_status(cd_old, i) == CRYPT_SLOT_ACTIVE) {
+			r = crypt_keyslot_destroy(cd_old, i);
+			if (r < 0)
+				goto out;
+		}
+
+	for (i = 0; i < MAX_TOKEN; i++) {
+		ti = crypt_token_status(cd_old, i, &type);
+		switch (ti) {
+		case CRYPT_TOKEN_INVALID:
+			log_dbg("Internal error.");
+			r = -EINVAL;
+			goto out;
+		case CRYPT_TOKEN_INACTIVE:
+			break;
+		case CRYPT_TOKEN_INTERNAL_UNKNOWN:
+			log_err(_("This version of cryptsetup-reencrypt can't handle new internal token type %s."), type);
+			r = -EINVAL;
+			goto out;
+		case CRYPT_TOKEN_INTERNAL:
+			/* fallthrough */
+		case CRYPT_TOKEN_EXTERNAL:
+			/* fallthrough */
+		case CRYPT_TOKEN_EXTERNAL_UNKNOWN:
+			if (crypt_token_json_get(cd_old, i, &json) != i) {
+				log_dbg("Failed to get %s token (%d).", type, i);
+				r = -EINVAL;
+				goto out;
+			}
+			if (crypt_token_json_set(cd_new, i, json) != i) {
+				log_dbg("Failed to create %s token (%d).", type, i);
+				r = -EINVAL;
+				goto out;
+			}
+		}
+	}
+
+	if ((r = crypt_persistent_flags_get(cd_old, CRYPT_FLAGS_ACTIVATION, &flags))) {
+		log_err(_("Failed to read activation flags from backup header."));
+		goto out;
+	}
+	if ((r = crypt_persistent_flags_set(cd_new, CRYPT_FLAGS_ACTIVATION, flags))) {
+		log_err(_("Failed to write activation flags to new header."));
+		goto out;
+	}
+	if ((r = crypt_persistent_flags_get(cd_old, CRYPT_FLAGS_REQUIREMENTS, &flags))) {
+		log_err(_("Failed to read requirements from backup header."));
+		goto out;
+	}
+	if ((r = crypt_persistent_flags_set(cd_new, CRYPT_FLAGS_REQUIREMENTS, flags)))
+		log_err(_("Failed to read requirements from backup header."));
+out:
+	crypt_free(cd_old);
+	crypt_free(cd_new);
+	unlink(rc->header_file_tmp);
+
+	return r;
+}
+
 static int backup_luks_headers(struct reenc_ctx *rc)
 {
 	struct crypt_device *cd = NULL;
 	struct crypt_params_luks1 params = {0};
+	struct crypt_params_luks2 params2 = {0};
+	struct stat st;
 	char cipher [MAX_CIPHER_LEN], cipher_mode[MAX_CIPHER_LEN];
+	char *key = NULL;
+	size_t key_size;
+	uint64_t mdata_size = 0, keyslots_size = 0;
 	int r;
 
-	log_dbg("Creating LUKS header backup for device %s.", rc->device);
+	log_dbg("Creating LUKS header backup for device %s.", hdr_device(rc));
 
-	if ((r = crypt_init(&cd, rc->device)) ||
-	    (r = crypt_load(cd, CRYPT_LUKS1, NULL)))
+	if ((r = crypt_init(&cd, hdr_device(rc))) ||
+	    (r = crypt_load(cd, CRYPT_LUKS, NULL)))
 		goto out;
 
-	crypt_set_confirm_callback(cd, NULL, NULL);
-	if ((r = crypt_header_backup(cd, CRYPT_LUKS1, rc->header_file_org)))
+	if ((r = crypt_header_backup(cd, CRYPT_LUKS, rc->header_file_org)))
 		goto out;
-	log_verbose(_("LUKS header backup of device %s created.\n"), rc->device);
+	if (isLUKS2(rc->type)) {
+		if ((r = crypt_header_backup(cd, CRYPT_LUKS2, rc->header_file_tmp)))
+			goto out;
+		if ((r = stat(rc->header_file_tmp, &st)))
+			goto out;
+		/* coverity[toctou] */
+		if ((r = chmod(rc->header_file_tmp, st.st_mode | S_IWUSR)))
+			goto out;
+	}
+	log_verbose(_("%s header backup of device %s created."), isLUKS2(rc->type) ? "LUKS2" : "LUKS1", rc->device);
+
+	/* For decrypt, new header will be fake one, so we are done here. */
+	if (rc->reencrypt_mode == DECRYPT)
+		goto out;
+
+	rc->data_offset = crypt_get_data_offset(cd) + ROUND_SECTOR(opt_reduce_size);
 
-	if ((r = create_empty_header(rc->header_file_new, rc->header_file_org,
-		crypt_get_data_offset(cd))))
+	if ((r = create_empty_header(rc->header_file_new)))
 		goto out;
 
 	params.hash = opt_hash ?: DEFAULT_LUKS1_HASH;
-	params.data_alignment = crypt_get_data_offset(cd);
-	params.data_alignment += opt_reduce_device_size;
-	params.data_device = rc->device;
+	params2.data_device = params.data_device = rc->device;
+	params2.sector_size = crypt_get_sector_size(cd);
 
 	if (opt_cipher) {
 		r = crypt_parse_name_and_mode(opt_cipher, cipher, NULL, cipher_mode);
 		if (r < 0) {
-			log_err(_("No known cipher specification pattern detected.\n"));
+			log_err(_("No known cipher specification pattern detected."));
 			goto out;
 		}
 	}
 
-	r = create_new_header(rc,
+	key_size = opt_key_size ? opt_key_size / 8 : crypt_get_volume_key_size(cd);
+
+	if (opt_keep_key) {
+		log_dbg("Keeping key from old header.");
+		key_size = crypt_get_volume_key_size(cd);
+		key = crypt_safe_alloc(key_size);
+		if (!key) {
+			r = -ENOMEM;
+			goto out;
+		}
+		r = crypt_volume_key_get(cd, CRYPT_ANY_SLOT, key, &key_size,
+			rc->p[rc->keyslot].password, rc->p[rc->keyslot].passwordLen);
+	} else if (opt_master_key_file) {
+		log_dbg("Loading new key from file.");
+		r = tools_read_mk(opt_master_key_file, &key, key_size);
+	}
+
+	if (r < 0)
+		goto out;
+
+	if (isLUKS2(crypt_get_type(cd)) && crypt_get_metadata_size(cd, &mdata_size, &keyslots_size))
+		goto out;
+
+	r = create_new_header(rc, cd,
 		opt_cipher ? cipher : crypt_get_cipher(cd),
 		opt_cipher ? cipher_mode : crypt_get_cipher_mode(cd),
 		crypt_get_uuid(cd),
-		opt_key_size ? opt_key_size / 8 : crypt_get_volume_key_size(cd),
-		&params);
+		key,
+		key_size,
+		rc->type,
+		mdata_size,
+		keyslots_size,
+		isLUKS2(rc->type) ? (void*)&params2 : (void*)&params);
+
+	if (!r && isLUKS2(rc->type))
+		r = luks2_metadata_copy(rc);
 out:
 	crypt_free(cd);
+	crypt_safe_free(key);
 	if (r)
-		log_err(_("Creation of LUKS backup headers failed.\n"));
+		log_err(_("Creation of LUKS backup headers failed."));
 	return r;
 }
 
@@ -600,11 +774,15 @@ static int backup_fake_header(struct reenc_ctx *rc)
 {
 	struct crypt_device *cd_new = NULL;
 	struct crypt_params_luks1 params = {0};
+	struct crypt_params_luks2 params2 = {0};
 	char cipher [MAX_CIPHER_LEN], cipher_mode[MAX_CIPHER_LEN];
-
+	const char *header_file_fake;
 	int r;
 
-	log_dbg("Creating fake (cipher_null) header for original device.");
+	log_dbg("Creating fake (cipher_null) header for %s device.",
+		(rc->reencrypt_mode == DECRYPT) ? "new" : "original");
+
+	header_file_fake = (rc->reencrypt_mode == DECRYPT) ? rc->header_file_new : rc->header_file_org;
 
 	if (!opt_key_size)
 		opt_key_size = DEFAULT_LUKS1_KEYBITS;
@@ -612,44 +790,57 @@ static int backup_fake_header(struct reenc_ctx *rc)
 	if (opt_cipher) {
 		r = crypt_parse_name_and_mode(opt_cipher, cipher, NULL, cipher_mode);
 		if (r < 0) {
-			log_err(_("No known cipher specification pattern detected.\n"));
+			log_err(_("No known cipher specification pattern detected."));
 			goto out;
 		}
 	}
 
-	r = create_empty_header(rc->header_file_org, NULL, 0);
+	r = create_empty_header(header_file_fake);
 	if (r < 0)
 		return r;
 
 	params.hash = opt_hash ?: DEFAULT_LUKS1_HASH;
-	params.data_alignment = 0;
-	params.data_device = rc->device;
+	params2.data_alignment = params.data_alignment = 0;
+	params2.data_device = params.data_device = rc->device;
+	params2.sector_size = crypt_get_sector_size(NULL);
+	params2.pbkdf = crypt_get_pbkdf_default(CRYPT_LUKS2);
 
-	r = crypt_init(&cd_new, rc->header_file_org);
+	r = crypt_init(&cd_new, header_file_fake);
 	if (r < 0)
 		return r;
 
 	r = crypt_format(cd_new, CRYPT_LUKS1, "cipher_null", "ecb",
 			 NO_UUID, NULL, opt_key_size / 8, &params);
+	check_signal(&r);
 	if (r < 0)
 		goto out;
 
-	r = crypt_keyslot_add_by_volume_key(cd_new, 0, NULL, 0,
-			rc->p[0].password, rc->p[0].passwordLen);
+	r = crypt_keyslot_add_by_volume_key(cd_new, rc->keyslot, NULL, 0,
+			rc->p[rc->keyslot].password, rc->p[rc->keyslot].passwordLen);
+	check_signal(&r);
 	if (r < 0)
 		goto out;
 
-	r = create_empty_header(rc->header_file_new, rc->header_file_org, 0);
+	/* The real header is backup header created in backup_luks_headers() */
+	if (rc->reencrypt_mode == DECRYPT) {
+		r = 0;
+		goto out;
+	}
+
+	r = create_empty_header(rc->header_file_new);
 	if (r < 0)
 		goto out;
 
-	params.data_alignment = opt_reduce_device_size;
-	r = create_new_header(rc,
+	params2.data_alignment = params.data_alignment = ROUND_SECTOR(opt_reduce_size);
+	r = create_new_header(rc, NULL,
 		opt_cipher ? cipher : DEFAULT_LUKS1_CIPHER,
 		opt_cipher ? cipher_mode : DEFAULT_LUKS1_MODE,
-		NULL,
+		NULL, NULL,
 		(opt_key_size ? opt_key_size : DEFAULT_LUKS1_KEYBITS) / 8,
-		&params);
+		rc->type,
+		0,
+		0,
+		isLUKS2(rc->type) ? (void*)&params2 : (void*)&params);
 out:
 	crypt_free(cd_new);
 	return r;
@@ -673,58 +864,69 @@ static void remove_headers(struct reenc_ctx *rc)
 
 static int restore_luks_header(struct reenc_ctx *rc)
 {
+	struct stat st;
 	struct crypt_device *cd = NULL;
-	int r;
+	int fd, r;
 
-	log_dbg("Restoring header for %s from %s.", rc->device, rc->header_file_new);
+	log_dbg("Restoring header for %s from %s.", hdr_device(rc), rc->header_file_new);
 
-	r = crypt_init(&cd, rc->device);
+	/*
+	 * For new encryption and new detached header in file just move it.
+	 * For existing file try to ensure we have preallocated space for restore.
+	 */
+	if (opt_new && rc->device_header) {
+		r = stat(rc->device_header, &st);
+		if (r == -1) {
+			r = rename(rc->header_file_new, rc->device_header);
+			goto out;
+		} else if ((st.st_mode & S_IFMT) == S_IFREG &&
+			stat(rc->header_file_new, &st) != -1) {
+			/* coverity[toctou] */
+			fd = open(rc->device_header, O_WRONLY);
+			if (fd != -1) {
+				if (posix_fallocate(fd, 0, st.st_size)) {};
+				close(fd);
+			}
+		}
+	}
+
+	r = crypt_init(&cd, hdr_device(rc));
 	if (r == 0) {
-		crypt_set_confirm_callback(cd, NULL, NULL);
-		r = crypt_header_restore(cd, CRYPT_LUKS1, rc->header_file_new);
+		r = crypt_header_restore(cd, rc->type, rc->header_file_new);
 	}
 
 	crypt_free(cd);
+out:
 	if (r)
-		log_err(_("Cannot restore LUKS header on device %s.\n"), rc->device);
-	else
-		log_verbose(_("LUKS header on device %s restored.\n"), rc->device);
+		log_err(_("Cannot restore %s header on device %s."), isLUKS2(rc->type) ? "LUKS2" : "LUKS1", hdr_device(rc));
+	else {
+		log_verbose(_("%s header on device %s restored."), isLUKS2(rc->type) ? "LUKS2" : "LUKS1", hdr_device(rc));
+		rc->stained = 0;
+	}
 	return r;
 }
 
-static void print_progress(struct reenc_ctx *rc, uint64_t bytes, int final)
+static ssize_t read_buf(int fd, void *buf, size_t count)
 {
-	unsigned long long mbytes, eta;
-	struct timeval now_time;
-	double tdiff, mib;
-
-	gettimeofday(&now_time, NULL);
-	if (!final && time_diff(rc->end_time, now_time) < 0.5)
-		return;
-
-	rc->end_time = now_time;
-
-	if (opt_batch_mode)
-		return;
-
-	tdiff = time_diff(rc->start_time, rc->end_time);
-	if (!tdiff)
-		return;
-
-	mbytes = (bytes - rc->restart_bytes) / 1024 / 1024;
-	mib = (double)(mbytes) / tdiff;
-	if (!mib)
-		return;
+	size_t read_size = 0;
+	ssize_t s;
 
-	eta = (unsigned long long)(rc->device_size / 1024 / 1024 / mib - tdiff);
+	do {
+		/* This expects that partial read is aligned in buffer */
+		s = read(fd, buf, count - read_size);
+		if (s == -1 && errno != EINTR)
+			return s;
+		if (s == 0)
+			return (ssize_t)read_size;
+		if (s > 0) {
+			if (s != (ssize_t)count)
+				log_dbg("Partial read %zd / %zu.", s, count);
+			read_size += (size_t)s;
+			buf = (uint8_t*)buf + s;
+		}
+	} while (read_size != count);
 
-	/* vt100 code clear line */
-	log_err("\33[2K\r");
-	log_err(_("Progress: %5.1f%%, ETA %02llu:%02llu, "
-		"%4llu MiB written, speed %5.1f MiB/s%s"),
-		(double)bytes / rc->device_size * 100,
-		eta / 60, eta % 60, mbytes, mib,
-		final ? "\n" :"");
+	return (ssize_t)count;
 }
 
 static int copy_data_forward(struct reenc_ctx *rc, int fd_old, int fd_new,
@@ -736,21 +938,23 @@ static int copy_data_forward(struct reenc_ctx *rc, int fd_old, int fd_new,
 
 	if (lseek64(fd_old, rc->device_offset, SEEK_SET) < 0 ||
 	    lseek64(fd_new, rc->device_offset, SEEK_SET) < 0) {
-		log_err(_("Cannot seek to device offset.\n"));
+		log_err(_("Cannot seek to device offset."));
 		return -EIO;
 	}
 
-	rc->restart_bytes = *bytes = rc->device_offset;
+	rc->resume_bytes = *bytes = rc->device_offset;
+
+	tools_reencrypt_progress(rc->device_size, *bytes, NULL);
 
 	if (write_log(rc) < 0)
 		return -EIO;
 
 	while (!quit && rc->device_offset < rc->device_size) {
-		s1 = read(fd_old, buf, block_size);
+		s1 = read_buf(fd_old, buf, block_size);
 		if (s1 < 0 || ((size_t)s1 != block_size &&
 		    (rc->device_offset + s1) != rc->device_size)) {
-			log_dbg("Read error, expecting %d, got %d.",
-				(int)block_size, (int)s1);
+			log_dbg("Read error, expecting %zu, got %zd.",
+				block_size, s1);
 			return -EIO;
 		}
 
@@ -760,8 +964,8 @@ static int copy_data_forward(struct reenc_ctx *rc, int fd_old, int fd_new,
 
 		s2 = write(fd_new, buf, s1);
 		if (s2 < 0) {
-			log_dbg("Write error, expecting %d, got %d.",
-				(int)block_size, (int)s2);
+			log_dbg("Write error, expecting %zu, got %zd.",
+				block_size, s2);
 			return -EIO;
 		}
 
@@ -775,7 +979,8 @@ static int copy_data_forward(struct reenc_ctx *rc, int fd_old, int fd_new,
 		}
 
 		*bytes += (uint64_t)s2;
-		print_progress(rc, *bytes, 0);
+
+		tools_reencrypt_progress(rc->device_size, *bytes, NULL);
 	}
 
 	return quit ? -EAGAIN : 0;
@@ -791,16 +996,21 @@ static int copy_data_backward(struct reenc_ctx *rc, int fd_old, int fd_new,
 
 	if (!rc->in_progress) {
 		rc->device_offset = rc->device_size;
-		rc->restart_bytes = 0;
+		rc->resume_bytes = 0;
 		*bytes = 0;
 	} else {
-		rc->restart_bytes = rc->device_size - rc->device_offset;
-		*bytes = rc->restart_bytes;
+		rc->resume_bytes = rc->device_size - rc->device_offset;
+		*bytes = rc->resume_bytes;
 	}
 
+	tools_reencrypt_progress(rc->device_size, *bytes, NULL);
+
 	if (write_log(rc) < 0)
 		return -EIO;
 
+	/* dirty the device during ENCRYPT mode */
+	rc->stained = 1;
+
 	while (!quit && rc->device_offset) {
 		if (rc->device_offset < block_size) {
 			working_offset = 0;
@@ -812,21 +1022,21 @@ static int copy_data_backward(struct reenc_ctx *rc, int fd_old, int fd_new,
 
 		if (lseek64(fd_old, working_offset, SEEK_SET) < 0 ||
 		    lseek64(fd_new, working_offset, SEEK_SET) < 0) {
-			log_err(_("Cannot seek to device offset.\n"));
+			log_err(_("Cannot seek to device offset."));
 			return -EIO;
 		}
 
-		s1 = read(fd_old, buf, working_block);
+		s1 = read_buf(fd_old, buf, working_block);
 		if (s1 < 0 || (s1 != working_block)) {
-			log_dbg("Read error, expecting %d, got %d.",
-				(int)block_size, (int)s1);
+			log_dbg("Read error, expecting %zu, got %zd.",
+				block_size, s1);
 			return -EIO;
 		}
 
 		s2 = write(fd_new, buf, working_block);
 		if (s2 < 0) {
-			log_dbg("Write error, expecting %d, got %d.",
-				(int)block_size, (int)s2);
+			log_dbg("Write error, expecting %zu, got %zd.",
+				block_size, s2);
 			return -EIO;
 		}
 
@@ -840,12 +1050,48 @@ static int copy_data_backward(struct reenc_ctx *rc, int fd_old, int fd_new,
 		}
 
 		*bytes += (uint64_t)s2;
-		print_progress(rc, *bytes, 0);
+
+		tools_reencrypt_progress(rc->device_size, *bytes, NULL);
 	}
 
 	return quit ? -EAGAIN : 0;
 }
 
+static void zero_rest_of_device(int fd, size_t block_size, void *buf,
+				uint64_t *bytes, uint64_t offset)
+{
+	ssize_t s1, s2;
+
+	log_dbg("Zeroing rest of device.");
+
+	if (lseek64(fd, offset, SEEK_SET) < 0) {
+		log_dbg("Cannot seek to device offset.");
+		return;
+	}
+
+	memset(buf, 0, block_size);
+	s1 = block_size;
+
+	while (!quit && *bytes) {
+		if (*bytes < (uint64_t)s1)
+			s1 = *bytes;
+
+		s2 = write(fd, buf, s1);
+		if (s2 != s1) {
+			log_dbg("Write error, expecting %zd, got %zd.",
+				s1, s2);
+			return;
+		}
+
+		if (opt_fsync && fsync(fd) < 0) {
+			log_dbg("Write error, fsync.");
+			return;
+		}
+
+		*bytes -= s2;
+	}
+}
+
 static int copy_data(struct reenc_ctx *rc)
 {
 	size_t block_size = opt_bsize * 1024 * 1024;
@@ -858,45 +1104,58 @@ static int copy_data(struct reenc_ctx *rc)
 
 	fd_old = open(rc->crypt_path_org, O_RDONLY | (opt_directio ? O_DIRECT : 0));
 	if (fd_old == -1) {
-		log_err(_("Cannot open temporary LUKS header file.\n"));
+		log_err(_("Cannot open temporary LUKS device."));
 		goto out;
 	}
 
 	fd_new = open(rc->crypt_path_new, O_WRONLY | (opt_directio ? O_DIRECT : 0));
 	if (fd_new == -1) {
-		log_err(_("Cannot open temporary LUKS header file.\n"));
+		log_err(_("Cannot open temporary LUKS device."));
 		goto out;
 	}
 
-	/* Check size */
-	if (ioctl(fd_new, BLKGETSIZE64, &rc->device_size_real) < 0) {
-		log_err(_("Cannot get device size.\n"));
+	if (ioctl(fd_old, BLKGETSIZE64, &rc->device_size_org_real) < 0) {
+		log_err(_("Cannot get device size."));
 		goto out;
 	}
 
-	rc->device_size = opt_device_size ?: rc->device_size_real;
+	if (ioctl(fd_new, BLKGETSIZE64, &rc->device_size_new_real) < 0) {
+		log_err(_("Cannot get device size."));
+		goto out;
+	}
+
+	if (opt_device_size)
+		rc->device_size = opt_device_size;
+	else if (rc->reencrypt_mode == DECRYPT)
+		rc->device_size = rc->device_size_org_real;
+	else
+		rc->device_size = rc->device_size_new_real;
 
 	if (posix_memalign((void *)&buf, alignment(fd_new), block_size)) {
-		log_err(_("Allocation of aligned memory failed.\n"));
+		log_err(_("Allocation of aligned memory failed."));
 		r = -ENOMEM;
 		goto out;
 	}
 
-	set_int_handler();
-	gettimeofday(&rc->start_time, NULL);
+	set_int_handler(0);
 
 	if (rc->reencrypt_direction == FORWARD)
 		r = copy_data_forward(rc, fd_old, fd_new, block_size, buf, &bytes);
 	else
 		r = copy_data_backward(rc, fd_old, fd_new, block_size, buf, &bytes);
 
+	/* Zero (wipe) rest of now plain-only device when decrypting.
+	 * (To not leave any sign of encryption here.) */
+	if (!r && rc->reencrypt_mode == DECRYPT &&
+	    rc->device_size_new_real > rc->device_size_org_real) {
+		bytes = rc->device_size_new_real - rc->device_size_org_real;
+		zero_rest_of_device(fd_new, block_size, buf, &bytes, rc->device_size_org_real);
+	}
+
 	set_int_block(1);
-	print_progress(rc, bytes, 1);
 
-	if (r == -EAGAIN)
-		 log_err(_("Interrupted by a signal.\n"));
-	else if (r < 0)
-		log_err(_("IO error during reencryption.\n"));
+	if (r < 0 && r != -EAGAIN)
+		log_err(_("IO error during reencryption."));
 
 	(void)write_log(rc);
 out:
@@ -912,105 +1171,145 @@ static int initialize_uuid(struct reenc_ctx *rc)
 {
 	struct crypt_device *cd = NULL;
 	int r;
+	uuid_t device_uuid;
 
 	log_dbg("Initialising UUID.");
 
 	if (opt_new) {
 		rc->device_uuid = strdup(NO_UUID);
+		rc->type = luksType(opt_type);
 		return 0;
 	}
 
+	if (opt_decrypt && opt_uuid) {
+		r = uuid_parse(opt_uuid, device_uuid);
+		if (!r)
+			rc->device_uuid = strdup(opt_uuid);
+		else
+			log_err(_("Provided UUID is invalid."));
+
+		return r;
+	}
+
 	/* Try to load LUKS from device */
-	if ((r = crypt_init(&cd, rc->device)))
+	if ((r = crypt_init(&cd, hdr_device(rc))))
 		return r;
 	crypt_set_log_callback(cd, _quiet_log, NULL);
-	r = crypt_load(cd, CRYPT_LUKS1, NULL);
+	r = crypt_load(cd, CRYPT_LUKS, NULL);
 	if (!r)
 		rc->device_uuid = strdup(crypt_get_uuid(cd));
 	else
 		/* Reencryption already in progress - magic header? */
-		r = device_check(rc, CHECK_UNUSABLE);
+		r = device_check(rc, hdr_device(rc), CHECK_UNUSABLE);
+
+	if (!r)
+		rc->type = isLUKS2(crypt_get_type(cd)) ? CRYPT_LUKS2 : CRYPT_LUKS1;
 
 	crypt_free(cd);
 	return r;
 }
 
 static int init_passphrase1(struct reenc_ctx *rc, struct crypt_device *cd,
-			    const char *msg, int slot_to_check, int check)
+			    const char *msg, int slot_to_check, int check, int verify)
 {
-	int r = -EINVAL, slot, retry_count;
-
-	slot = (slot_to_check == CRYPT_ANY_SLOT) ? 0 : slot_to_check;
+	crypt_keyslot_info ki;
+	char *password;
+	int r = -EINVAL, retry_count;
+	size_t passwordLen;
+
+	/* mode ENCRYPT call this without header */
+	if (cd && slot_to_check != CRYPT_ANY_SLOT) {
+		ki = crypt_keyslot_status(cd, slot_to_check);
+		if (ki < CRYPT_SLOT_ACTIVE)
+			return -ENOENT;
+	} else
+		ki = CRYPT_SLOT_ACTIVE;
 
 	retry_count = opt_tries ?: 1;
 	while (retry_count--) {
-		set_int_handler();
-		r = crypt_get_key(msg, &rc->p[slot].password,
-			&rc->p[slot].passwordLen,
-			0, 0, NULL /*opt_key_file*/,
-			0, 0, cd);
+		r = tools_get_key(msg,  &password, &passwordLen, 0, 0,
+				  NULL /*opt_key_file*/, 0, verify, 0 /*pwquality*/, cd);
 		if (r < 0)
 			return r;
-		if (quit)
+		if (quit) {
+			crypt_safe_free(password);
+			password = NULL;
+			passwordLen = 0;
 			return -EAGAIN;
+		}
 
-		/* library uses sigint internally, until it is fixed...*/
-		set_int_block(1);
 		if (check)
 			r = crypt_activate_by_passphrase(cd, NULL, slot_to_check,
-				rc->p[slot].password, rc->p[slot].passwordLen, 0);
+				password, passwordLen, CRYPT_ACTIVATE_ALLOW_UNBOUND_KEY);
 		else
-			r = slot;
+			r = (slot_to_check == CRYPT_ANY_SLOT) ? 0 : slot_to_check;
 
 		if (r < 0) {
-			crypt_safe_free(rc->p[slot].password);
-			rc->p[slot].password = NULL;
-			rc->p[slot].passwordLen = 0;
+			crypt_safe_free(password);
+			password = NULL;
+			passwordLen = 0;
 		}
 		if (r < 0 && r != -EPERM)
 			return r;
+
 		if (r >= 0) {
-			rc->keyslot = slot;
+			tools_keyslot_msg(r, UNLOCKED);
+			rc->p[r].password = password;
+			rc->p[r].passwordLen = passwordLen;
+			if (ki != CRYPT_SLOT_UNBOUND)
+				rc->keyslot = r;
 			break;
 		}
-		log_err(_("No key available with this passphrase.\n"));
+		tools_passphrase_msg(r);
 	}
+
+	password = NULL;
+	passwordLen = 0;
+
 	return r;
 }
 
 static int init_keyfile(struct reenc_ctx *rc, struct crypt_device *cd, int slot_check)
 {
-	int r, slot;
+	char *password;
+	int r;
+	size_t passwordLen;
 
-	slot = (slot_check == CRYPT_ANY_SLOT) ? 0 : slot_check;
-	r = crypt_get_key(NULL, &rc->p[slot].password, &rc->p[slot].passwordLen,
-		opt_keyfile_offset, opt_keyfile_size, opt_key_file, 0, 0, cd);
+	r = tools_get_key(NULL, &password, &passwordLen, opt_keyfile_offset,
+			  opt_keyfile_size, opt_key_file, 0, 0, 0, cd);
 	if (r < 0)
 		return r;
 
-	r = crypt_activate_by_passphrase(cd, NULL, slot_check,
-		rc->p[slot].password, rc->p[slot].passwordLen, 0);
-
-	/*
-	 * Allow keyslot only if it is last slot or if user explicitly
-	 * specify whch slot to use (IOW others will be disabled).
-	 */
-	if (r >= 0 && opt_key_slot == CRYPT_ANY_SLOT &&
-	    crypt_keyslot_status(cd, r) != CRYPT_SLOT_ACTIVE_LAST) {
-		log_err(_("Key file can be used only with --key-slot or with "
-			  "exactly one key slot active.\n"));
-		r = -EINVAL;
+	/* mode ENCRYPT call this without header */
+	if (cd) {
+		r = crypt_activate_by_passphrase(cd, NULL, slot_check, password,
+						 passwordLen, 0);
+
+		/*
+		 * Allow keyslot only if it is last slot or if user explicitly
+		 * specify which slot to use (IOW others will be disabled).
+		 */
+		if (r >= 0 && opt_key_slot == CRYPT_ANY_SLOT &&
+		    crypt_keyslot_status(cd, r) != CRYPT_SLOT_ACTIVE_LAST) {
+			log_err(_("Key file can be used only with --key-slot or with "
+				  "exactly one key slot active."));
+			r = -EINVAL;
+		}
+	} else {
+		r = slot_check == CRYPT_ANY_SLOT ? 0 : slot_check;
 	}
 
 	if (r < 0) {
-		crypt_safe_free(rc->p[slot].password);
-		rc->p[slot].password = NULL;
-		rc->p[slot].passwordLen = 0;
-		if (r == -EPERM)
-			log_err(_("No key available with this passphrase.\n"));
-		return r;
-	} else
-		rc->keyslot = slot;
+		crypt_safe_free(password);
+		tools_passphrase_msg(r);
+	} else {
+		rc->keyslot = r;
+		rc->p[r].password = password;
+		rc->p[r].passwordLen = passwordLen;
+	}
+
+	password = NULL;
+	passwordLen = 0;
 
 	return r;
 }
@@ -1018,36 +1317,44 @@ static int init_keyfile(struct reenc_ctx *rc, struct crypt_device *cd, int slot_
 static int initialize_passphrase(struct reenc_ctx *rc, const char *device)
 {
 	struct crypt_device *cd = NULL;
-	crypt_keyslot_info ki;
 	char msg[256];
 	int i, r;
 
-	log_dbg("Passhrases initialization.");
+	log_dbg("Passphrases initialization.");
 
-	if (opt_new && !rc->in_progress) {
-		r = init_passphrase1(rc, cd, _("Enter new LUKS passphrase: "), 0, 0);
+	if (rc->reencrypt_mode == ENCRYPT && !rc->in_progress) {
+		if (opt_key_file)
+			r = init_keyfile(rc, NULL, opt_key_slot);
+		else
+			r = init_passphrase1(rc, NULL, _("Enter new passphrase: "), opt_key_slot, 0, 1);
 		return r > 0 ? 0 : r;
 	}
 
-	if ((r = crypt_init(&cd, device)) ||
-	    (r = crypt_load(cd, CRYPT_LUKS1, NULL)) ||
-	    (r = crypt_set_data_device(cd, rc->device))) {
+	if ((r = crypt_init_data_device(&cd, device, rc->device)) ||
+	    (r = crypt_load(cd, CRYPT_LUKS, NULL))) {
 		crypt_free(cd);
 		return r;
 	}
 
+	if (opt_key_slot != CRYPT_ANY_SLOT)
+		snprintf(msg, sizeof(msg),
+			 _("Enter passphrase for key slot %d: "), opt_key_slot);
+	else
+		snprintf(msg, sizeof(msg), _("Enter any existing passphrase: "));
+
 	if (opt_key_file) {
 		r = init_keyfile(rc, cd, opt_key_slot);
-	} else if (rc->in_progress) {
-		r = init_passphrase1(rc, cd, _("Enter any LUKS passphrase: "),
-				     CRYPT_ANY_SLOT, 1);
-	} else for (i = 0; i < MAX_SLOT; i++) {
-		ki = crypt_keyslot_status(cd, i);
-		if (ki != CRYPT_SLOT_ACTIVE && ki != CRYPT_SLOT_ACTIVE_LAST)
+	} else if (rc->in_progress ||
+		   opt_key_slot != CRYPT_ANY_SLOT ||
+		   rc->reencrypt_mode == DECRYPT) {
+		r = init_passphrase1(rc, cd, msg, opt_key_slot, 1, 0);
+	} else for (i = 0; i < crypt_keyslot_max(crypt_get_type(cd)); i++) {
+		snprintf(msg, sizeof(msg), _("Enter passphrase for key slot %d: "), i);
+		r = init_passphrase1(rc, cd, msg, i, 1, 0);
+		if (r == -ENOENT) {
+			r = 0;
 			continue;
-
-		snprintf(msg, sizeof(msg), _("Enter LUKS passphrase for key slot %u: "), i);
-		r = init_passphrase1(rc, cd, msg, i, 1);
+		}
 		if (r < 0)
 			break;
 	}
@@ -1060,16 +1367,31 @@ static int initialize_context(struct reenc_ctx *rc, const char *device)
 {
 	log_dbg("Initialising reencryption context.");
 
-	rc->log_fd =-1;
+	rc->log_fd = -1;
+
+	/* FIXME: replace MAX_KEYSLOT with crypt_keyslot_max(CRYPT_LUKS2) */
+	if (crypt_keyslot_max(CRYPT_LUKS2) > MAX_SLOT) {
+		log_dbg("Internal error");
+		return -EINVAL;
+	}
 
 	if (!(rc->device = strndup(device, PATH_MAX)))
 		return -ENOMEM;
 
-	if (device_check(rc, CHECK_OPEN) < 0)
+	if (opt_header_device && !(rc->device_header = strndup(opt_header_device, PATH_MAX)))
+		return -ENOMEM;
+
+	if (device_check(rc, rc->device, CHECK_OPEN) < 0)
 		return -EINVAL;
 
 	if (initialize_uuid(rc)) {
-		log_err(_("Device %s is not a valid LUKS device.\n"), device);
+		log_err(_("Device %s is not a valid LUKS device."), device);
+		return -EINVAL;
+	}
+
+	if (opt_key_slot != CRYPT_ANY_SLOT &&
+	    opt_key_slot >= crypt_keyslot_max(rc->type)) {
+		log_err(_("Key slot is invalid."));
 		return -EINVAL;
 	}
 
@@ -1083,6 +1405,9 @@ static int initialize_context(struct reenc_ctx *rc, const char *device)
 	if (snprintf(rc->header_file_new, PATH_MAX,
 		     "LUKS-%s.new", rc->device_uuid) < 0)
 		return -ENOMEM;
+	if (snprintf(rc->header_file_tmp, PATH_MAX,
+		     "LUKS-%s.tmp", rc->device_uuid) < 0)
+		return -ENOMEM;
 
 	/* Paths to encrypted devices */
 	if (snprintf(rc->crypt_path_org, PATH_MAX,
@@ -1095,17 +1420,30 @@ static int initialize_context(struct reenc_ctx *rc, const char *device)
 	remove_headers(rc);
 
 	if (open_log(rc) < 0) {
-		log_err(_("Cannot open reencryption log file.\n"));
+		log_err(_("Cannot open reencryption log file."));
 		return -EINVAL;
 	}
 
 	if (!rc->in_progress) {
-		if (!opt_reduce_device_size)
+		if (opt_uuid) {
+			log_err(_("No decryption in progress, provided UUID can "
+			"be used only to resume suspended decryption process."));
+			return -EINVAL;
+		}
+
+		if (!opt_reduce_size)
 			rc->reencrypt_direction = FORWARD;
 		else {
 			rc->reencrypt_direction = BACKWARD;
 			rc->device_offset = (uint64_t)~0;
 		}
+
+		if (opt_new)
+			rc->reencrypt_mode = ENCRYPT;
+		else if (opt_decrypt)
+			rc->reencrypt_mode = DECRYPT;
+		else
+			rc->reencrypt_mode = REENCRYPT;
 	}
 
 	return 0;
@@ -1120,69 +1458,129 @@ static void destroy_context(struct reenc_ctx *rc)
 	close_log(rc);
 	remove_headers(rc);
 
-	if ((rc->reencrypt_direction == FORWARD &&
-	     rc->device_offset == rc->device_size) ||
-	    (rc->reencrypt_direction == BACKWARD &&
-	     (rc->device_offset == 0 || rc->device_offset == (uint64_t)~0))) {
+	if (!rc->stained) {
 		unlink(rc->log_file);
 		unlink(rc->header_file_org);
 		unlink(rc->header_file_new);
+		unlink(rc->header_file_tmp);
 	}
 
 	for (i = 0; i < MAX_SLOT; i++)
 		crypt_safe_free(rc->p[i].password);
 
 	free(rc->device);
+	free(rc->device_header);
 	free(rc->device_uuid);
 }
 
+static int luks2_change_pbkdf_params(struct reenc_ctx *rc)
+{
+	int i, r;
+	struct crypt_device *cd = NULL;
+
+	if ((r = initialize_passphrase(rc, hdr_device(rc))))
+		return r;
+
+	if (crypt_init(&cd, hdr_device(rc)) ||
+	    crypt_load(cd, CRYPT_LUKS2, NULL)) {
+		r = -EINVAL;
+		goto out;
+	}
+
+	if ((r = set_pbkdf_params(cd, CRYPT_LUKS2)))
+		goto out;
+
+	log_dbg("LUKS2 keyslot pbkdf params change.");
+
+	r = -EINVAL;
+
+	for (i = 0; i < crypt_keyslot_max(CRYPT_LUKS2); i++) {
+		if (!rc->p[i].password)
+			continue;
+		if ((r = crypt_keyslot_change_by_passphrase(cd, i, i,
+			rc->p[i].password, rc->p[i].passwordLen,
+			rc->p[i].password, rc->p[i].passwordLen)) < 0)
+			goto out;
+		log_verbose(_("Changed pbkdf parameters in keyslot %i."), r);
+		r = 0;
+	}
+
+	if (r)
+		goto out;
+
+	/* see create_new_header */
+	for (i = 0; i < crypt_keyslot_max(CRYPT_LUKS2); i++)
+		if (!rc->p[i].password)
+			(void)crypt_keyslot_destroy(cd, i);
+out:
+	crypt_free(cd);
+	return r;
+}
+
 static int run_reencrypt(const char *device)
 {
 	int r = -EINVAL;
-	struct reenc_ctx rc = {};
+	static struct reenc_ctx rc = {
+		.stained = 1
+	};
+
+	set_int_handler(0);
 
 	if (initialize_context(&rc, device))
 		goto out;
 
+	/* short-circuit LUKS2 keyslot parameters change */
+	if (opt_keep_key && isLUKS2(rc.type)) {
+		r = luks2_change_pbkdf_params(&rc);
+		goto out;
+	}
+
 	log_dbg("Running reencryption.");
 
 	if (!rc.in_progress) {
-		if (opt_new) {
-			if ((r = initialize_passphrase(&rc, rc.device)) ||
-			    (r = backup_fake_header(&rc)))
-			goto out;
-		} else if ((r = initialize_passphrase(&rc, rc.device)) ||
-			   (r = backup_luks_headers(&rc)) ||
-			   (r = device_check(&rc, MAKE_UNUSABLE)))
+		if ((r = initialize_passphrase(&rc, hdr_device(&rc))))
 			goto out;
+
+		log_dbg("Storing backup of LUKS headers.");
+		if (rc.reencrypt_mode == ENCRYPT) {
+			/* Create fake header for existing device */
+			if ((r = backup_fake_header(&rc)))
+				goto out;
+		} else {
+			if ((r = backup_luks_headers(&rc)))
+				goto out;
+			/* Create fake header for decrypted device */
+			if (rc.reencrypt_mode == DECRYPT &&
+			    (r = backup_fake_header(&rc)))
+				goto out;
+			if ((r = device_check(&rc, hdr_device(&rc), MAKE_UNUSABLE)))
+				goto out;
+		}
 	} else {
-		if ((r = initialize_passphrase(&rc, rc.header_file_new)))
+		if ((r = initialize_passphrase(&rc, opt_decrypt ? rc.header_file_org : rc.header_file_new)))
 			goto out;
 	}
 
-	if ((r = activate_luks_headers(&rc)))
-		goto out;
+	if (!opt_keep_key) {
+		log_dbg("Running data area reencryption.");
+		if ((r = activate_luks_headers(&rc)))
+			goto out;
 
-	if ((r = copy_data(&rc)))
-		goto out;
+		if ((r = copy_data(&rc)))
+			goto out;
+	} else
+		log_dbg("Keeping existing key, skipping data area reencryption.");
 
-	r = restore_luks_header(&rc);
+	// FIXME: fix error path above to not skip this
+	if (rc.reencrypt_mode != DECRYPT)
+		r = restore_luks_header(&rc);
+	else
+		rc.stained = 0;
 out:
 	destroy_context(&rc);
 	return r;
 }
 
-static __attribute__ ((noreturn)) void usage(poptContext popt_context,
-					     int exitcode, const char *error,
-					     const char *more)
-{
-	poptPrintUsage(popt_context, stderr, 0);
-	if (error)
-		log_err("%s: %s\n", more, error);
-	poptFreeContext(popt_context);
-	exit(exitcode);
-}
-
 static void help(poptContext popt_context,
 		 enum poptCallbackReason reason __attribute__((unused)),
 		 struct poptOption *key,
@@ -1192,64 +1590,65 @@ static void help(poptContext popt_context,
 	if (key->shortName == '?') {
 		log_std("%s %s\n", PACKAGE_REENC, PACKAGE_VERSION);
 		poptPrintHelp(popt_context, stdout, 0);
+		poptFreeContext(popt_context);
+		exit(EXIT_SUCCESS);
+	} else if (key->shortName == 'V') {
+		log_std("%s %s\n", PACKAGE_REENC, PACKAGE_VERSION);
+		poptFreeContext(popt_context);
 		exit(EXIT_SUCCESS);
 	} else
 		usage(popt_context, EXIT_SUCCESS, NULL, NULL);
 }
 
-static void _dbg_version_and_cmd(int argc, const char **argv)
-{
-	int i;
-
-	log_std("# %s %s processing \"", PACKAGE_REENC, PACKAGE_VERSION);
-	for (i = 0; i < argc; i++) {
-		if (i)
-			log_std(" ");
-		log_std("%s", argv[i]);
-	}
-	log_std("\"\n");
-}
-
 int main(int argc, const char **argv)
 {
 	static struct poptOption popt_help_options[] = {
 		{ NULL,    '\0', POPT_ARG_CALLBACK, help, 0, NULL,                         NULL },
 		{ "help",  '?',  POPT_ARG_NONE,     NULL, 0, N_("Show this help message"), NULL },
 		{ "usage", '\0', POPT_ARG_NONE,     NULL, 0, N_("Display brief usage"),    NULL },
+		{ "version",'V', POPT_ARG_NONE,     NULL, 0, N_("Print package version"),  NULL },
 		POPT_TABLEEND
 	};
 	static struct poptOption popt_options[] = {
 		{ NULL,                '\0', POPT_ARG_INCLUDE_TABLE, popt_help_options, 0, N_("Help options:"), NULL },
-		{ "version",           '\0', POPT_ARG_NONE, &opt_version_mode,          0, N_("Print package version"), NULL },
 		{ "verbose",           'v',  POPT_ARG_NONE, &opt_verbose,               0, N_("Shows more detailed error messages"), NULL },
 		{ "debug",             '\0', POPT_ARG_NONE, &opt_debug,                 0, N_("Show debug messages"), NULL },
 		{ "block-size",        'B',  POPT_ARG_INT, &opt_bsize,                  0, N_("Reencryption block size"), N_("MiB") },
 		{ "cipher",            'c',  POPT_ARG_STRING, &opt_cipher,              0, N_("The cipher used to encrypt the disk (see /proc/crypto)"), NULL },
 		{ "key-size",          's',  POPT_ARG_INT, &opt_key_size,               0, N_("The size of the encryption key"), N_("BITS") },
 		{ "hash",              'h',  POPT_ARG_STRING, &opt_hash,                0, N_("The hash used to create the encryption key from the passphrase"), NULL },
-		{ "key-file",          'd',  POPT_ARG_STRING, &opt_key_file,            0, N_("Read the key from a file."), NULL },
+		{ "keep-key",          '\0', POPT_ARG_NONE, &opt_keep_key,              0, N_("Do not change key, no data area reencryption"), NULL },
+		{ "key-file",          'd',  POPT_ARG_STRING, &opt_key_file,            0, N_("Read the key from a file"), NULL },
+		{ "master-key-file",   '\0', POPT_ARG_STRING, &opt_master_key_file,     0, N_("Read new volume (master) key from file"), NULL },
 		{ "iter-time",         'i',  POPT_ARG_INT, &opt_iteration_time,         0, N_("PBKDF2 iteration time for LUKS (in ms)"), N_("msecs") },
 		{ "batch-mode",        'q',  POPT_ARG_NONE, &opt_batch_mode,            0, N_("Do not ask for confirmation"), NULL },
+		{ "progress-frequency",'\0', POPT_ARG_INT, &opt_progress_frequency,     0, N_("Progress line update (in seconds)"), N_("secs") },
 		{ "tries",             'T',  POPT_ARG_INT, &opt_tries,                  0, N_("How often the input of the passphrase can be retried"), NULL },
-		{ "use-random",        '\0', POPT_ARG_NONE, &opt_random,                0, N_("Use /dev/random for generating volume key."), NULL },
-		{ "use-urandom",       '\0', POPT_ARG_NONE, &opt_urandom,               0, N_("Use /dev/urandom for generating volume key."), NULL },
-		{ "use-directio",      '\0', POPT_ARG_NONE, &opt_directio,              0, N_("Use direct-io when accesing devices."), NULL },
-		{ "use-fsync",         '\0', POPT_ARG_NONE, &opt_fsync,                 0, N_("Use fsync after each block."), NULL },
-		{ "write-log",         '\0', POPT_ARG_NONE, &opt_write_log,             0, N_("Update log file after every block."), NULL },
-		{ "key-slot",          'S',  POPT_ARG_INT, &opt_key_slot,               0, N_("Use only this slot (others will be disabled)."), NULL },
+		{ "use-random",        '\0', POPT_ARG_NONE, &opt_random,                0, N_("Use /dev/random for generating volume key"), NULL },
+		{ "use-urandom",       '\0', POPT_ARG_NONE, &opt_urandom,               0, N_("Use /dev/urandom for generating volume key"), NULL },
+		{ "use-directio",      '\0', POPT_ARG_NONE, &opt_directio,              0, N_("Use direct-io when accessing devices"), NULL },
+		{ "use-fsync",         '\0', POPT_ARG_NONE, &opt_fsync,                 0, N_("Use fsync after each block"), NULL },
+		{ "write-log",         '\0', POPT_ARG_NONE, &opt_write_log,             0, N_("Update log file after every block"), NULL },
+		{ "key-slot",          'S',  POPT_ARG_INT, &opt_key_slot,               0, N_("Use only this slot (others will be disabled)"), NULL },
 		{ "keyfile-offset",   '\0',  POPT_ARG_LONG, &opt_keyfile_offset,        0, N_("Number of bytes to skip in keyfile"), N_("bytes") },
 		{ "keyfile-size",      'l',  POPT_ARG_LONG, &opt_keyfile_size,          0, N_("Limits the read from keyfile"), N_("bytes") },
-		{ "reduce-device-size",'\0', POPT_ARG_INT, &opt_reduce_device_size,     0, N_("Reduce data device size (move data offset). DANGEROUS!"), N_("SECTORS") },
+		{ "reduce-device-size",'\0', POPT_ARG_STRING, &opt_reduce_size_str,     0, N_("Reduce data device size (move data offset). DANGEROUS!"), N_("bytes") },
 		{ "device-size",       '\0', POPT_ARG_STRING, &opt_device_size_str,     0, N_("Use only specified device size (ignore rest of device). DANGEROUS!"), N_("bytes") },
-		{ "new",               'N',  POPT_ARG_NONE,&opt_new,                    0, N_("Create new header on not encrypted device."), NULL },
+		{ "new",               'N',  POPT_ARG_NONE, &opt_new,                   0, N_("Create new header on not encrypted device"), NULL },
+		{ "decrypt",           '\0', POPT_ARG_NONE, &opt_decrypt,               0, N_("Permanently decrypt device (remove encryption)"), NULL },
+		{ "uuid",              '\0', POPT_ARG_STRING, &opt_uuid,                0, N_("The UUID used to resume decryption"), NULL },
+		{ "type",              '\0', POPT_ARG_STRING, &opt_type,                0, N_("Type of LUKS metadata: luks1, luks2"), NULL },
+		{ "pbkdf",             '\0', POPT_ARG_STRING, &opt_pbkdf,               0, N_("PBKDF algorithm (for LUKS2): argon2i, argon2id, pbkdf2"), NULL },
+		{ "pbkdf-memory",      '\0', POPT_ARG_LONG, &opt_pbkdf_memory,          0, N_("PBKDF memory cost limit"), N_("kilobytes") },
+		{ "pbkdf-parallel",    '\0', POPT_ARG_LONG, &opt_pbkdf_parallel,        0, N_("PBKDF parallel cost"), N_("threads") },
+		{ "pbkdf-force-iterations",'\0',POPT_ARG_LONG, &opt_pbkdf_iterations,   0, N_("PBKDF iterations cost (forced, disables benchmark)"), NULL },
+		{ "header",            '\0', POPT_ARG_STRING, &opt_header_device,       0, N_("Device or file with separated LUKS header"), NULL },
 		POPT_TABLEEND
 	};
 	poptContext popt_context;
 	int r;
 
-	crypt_set_log_callback(NULL, _log, NULL);
-
-	set_int_block(1);
+	crypt_set_log_callback(NULL, tool_log, NULL);
 
 	setlocale(LC_ALL, "");
 	bindtextdomain(PACKAGE, LOCALEDIR);
@@ -1257,25 +1656,19 @@ int main(int argc, const char **argv)
 
 	popt_context = poptGetContext(PACKAGE, argc, argv, popt_options, 0);
 	poptSetOtherOptionHelp(popt_context,
-	                       N_("[OPTION...] <device>"));
+	                       _("[OPTION...] <device>"));
 
 	while((r = poptGetNextOpt(popt_context)) > 0) ;
 	if (r < -1)
 		usage(popt_context, EXIT_FAILURE, poptStrerror(r),
 		      poptBadOption(popt_context, POPT_BADOPTION_NOALIAS));
 
-	if (opt_version_mode) {
-		log_std("%s %s\n", PACKAGE_REENC, PACKAGE_VERSION);
-		poptFreeContext(popt_context);
-		exit(EXIT_SUCCESS);
-	}
-
-	if (!opt_batch_mode) {
-		log_std(_("WARNING: this is experimental code, it can completely break your data.\n"));
-		log_verbose(_("Reencryption will change: volume key%s%s%s%s.\n"),
-			opt_hash   ? _(", set hash to ")  : "", opt_hash   ?: "",
+	if (!opt_batch_mode)
+		log_verbose(_("Reencryption will change: %s%s%s%s%s%s."),
+			opt_keep_key ? "" :  _("volume key"),
+			(!opt_keep_key && opt_hash) ? ", " : "",
+			opt_hash   ? _("set hash to ")    : "", opt_hash   ?: "",
 			opt_cipher ? _(", set cipher to "): "", opt_cipher ?: "");
-	}
 
 	action_argv = poptGetArgs(popt_context);
 	if(!action_argv)
@@ -1288,20 +1681,26 @@ int main(int argc, const char **argv)
 
 	if (opt_bsize < 0 || opt_key_size < 0 || opt_iteration_time < 0 ||
 	    opt_tries < 0 || opt_keyfile_offset < 0 || opt_key_size < 0 ||
-	    opt_reduce_device_size < 0) {
+	    opt_pbkdf_iterations < 0 || opt_pbkdf_memory < 0 ||
+	    opt_pbkdf_parallel < 0) {
 		usage(popt_context, EXIT_FAILURE,
 		      _("Negative number for option not permitted."),
 		      poptGetInvocationName(popt_context));
 	}
 
-	if (opt_bsize < 1 || opt_bsize > 64)
+	if (opt_pbkdf && crypt_parse_pbkdf(opt_pbkdf, &opt_pbkdf))
 		usage(popt_context, EXIT_FAILURE,
-		      _("Only values between 1MiB and 64 MiB allowed for reencryption block size."),
-		      poptGetInvocationName(popt_context));
+		_("Password-based key derivation function (PBKDF) can be only pbkdf2 or argon2i/argon2id."),
+		poptGetInvocationName(popt_context));
+
+	if (opt_pbkdf_iterations && opt_iteration_time)
+		usage(popt_context, EXIT_FAILURE,
+		_("PBKDF forced iterations cannot be combined with iteration time option."),
+		poptGetInvocationName(popt_context));
 
-	if (opt_reduce_device_size > (64 * 1024 * 1024 / SECTOR_SIZE))
+	if (opt_bsize < 1 || opt_bsize > 64)
 		usage(popt_context, EXIT_FAILURE,
-		      _("Maximum device reduce size is 64 MiB."),
+		      _("Only values between 1 MiB and 64 MiB allowed for reencryption block size."),
 		      poptGetInvocationName(popt_context));
 
 	if (opt_key_size % 8)
@@ -1310,7 +1709,7 @@ int main(int argc, const char **argv)
 		      poptGetInvocationName(popt_context));
 
 	if (opt_key_slot != CRYPT_ANY_SLOT &&
-	    (opt_key_slot < 0 || opt_key_slot >= crypt_keyslot_max(CRYPT_LUKS1)))
+	    (opt_key_slot < 0 || opt_key_slot >= crypt_keyslot_max(CRYPT_LUKS2)))
 		usage(popt_context, EXIT_FAILURE, _("Key slot is invalid."),
 		      poptGetInvocationName(popt_context));
 
@@ -1318,35 +1717,55 @@ int main(int argc, const char **argv)
 		usage(popt_context, EXIT_FAILURE, _("Only one of --use-[u]random options is allowed."),
 		      poptGetInvocationName(popt_context));
 
-	if (opt_new && !opt_reduce_device_size)
-		usage(popt_context, EXIT_FAILURE, _("Option --new must be used together with --reduce_device_size."),
+	if (opt_device_size_str &&
+	    tools_string_to_size(NULL, opt_device_size_str, &opt_device_size))
+		usage(popt_context, EXIT_FAILURE, _("Invalid device size specification."),
 		      poptGetInvocationName(popt_context));
 
-	if (opt_device_size_str &&
-	    crypt_string_to_size(NULL, opt_device_size_str, &opt_device_size))
+	if (opt_reduce_size_str &&
+	    tools_string_to_size(NULL, opt_reduce_size_str, &opt_reduce_size))
 		usage(popt_context, EXIT_FAILURE, _("Invalid device size specification."),
 		      poptGetInvocationName(popt_context));
+	if (opt_reduce_size > 64 * 1024 * 1024)
+		usage(popt_context, EXIT_FAILURE, _("Maximum device reduce size is 64 MiB."),
+		      poptGetInvocationName(popt_context));
+	if (opt_reduce_size % SECTOR_SIZE)
+		usage(popt_context, EXIT_FAILURE, _("Reduce size must be multiple of 512 bytes sector."),
+		      poptGetInvocationName(popt_context));
+
+	if (opt_new && (!opt_reduce_size && !opt_header_device))
+		usage(popt_context, EXIT_FAILURE, _("Option --new must be used together with --reduce-device-size or --header."),
+		      poptGetInvocationName(popt_context));
+
+	if (opt_keep_key && (opt_cipher || opt_new || opt_master_key_file))
+		usage(popt_context, EXIT_FAILURE, _("Option --keep-key can be used only with --hash, --iter-time or --pbkdf-force-iterations."),
+		      poptGetInvocationName(popt_context));
+
+	if (opt_new && opt_decrypt)
+		usage(popt_context, EXIT_FAILURE, _("Option --new cannot be used together with --decrypt."),
+		      poptGetInvocationName(popt_context));
+
+	if (opt_decrypt && (opt_cipher || opt_hash || opt_reduce_size || opt_keep_key || opt_device_size))
+		usage(popt_context, EXIT_FAILURE, _("Option --decrypt is incompatible with specified parameters."),
+		      poptGetInvocationName(popt_context));
+
+	if (opt_uuid && !opt_decrypt)
+		usage(popt_context, EXIT_FAILURE, _("Option --uuid is allowed only together with --decrypt."),
+		      poptGetInvocationName(popt_context));
+
+	if (!luksType(opt_type))
+		usage(popt_context, EXIT_FAILURE, _("Invalid luks type. Use one of these: 'luks', 'luks1' or 'luks2'."),
+		      poptGetInvocationName(popt_context));
 
 	if (opt_debug) {
 		opt_verbose = 1;
 		crypt_set_debug_level(-1);
-		_dbg_version_and_cmd(argc, argv);
+		dbg_version_and_cmd(argc, argv);
 	}
 
 	r = run_reencrypt(action_argv[0]);
 
 	poptFreeContext(popt_context);
 
-	/* Translate exit code to simple codes */
-	switch (r) {
-	case 0: 	r = EXIT_SUCCESS; break;
-	case -EEXIST:
-	case -EBUSY:	r = 5; break;
-	case -ENOTBLK:
-	case -ENODEV:	r = 4; break;
-	case -ENOMEM:	r = 3; break;
-	case -EPERM:	r = 2; break;
-	default:	r = EXIT_FAILURE;
-	}
-	return r;
+	return translate_errno(r);
 }