From: Maxim Levitsky <mlevitsk@redhat.com>

This allows more tests to be able to have same output on both qcow2 luks encrypted images

and raw luks images

Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

Message-Id: <20200618150628.2169239-3-mreitz@redhat.com>

---

tests/qemu-iotests/087.out | 6 +++---

tests/qemu-iotests/134.out | 2 +-

tests/qemu-iotests/158.out | 4 ++--

tests/qemu-iotests/188.out | 2 +-

tests/qemu-iotests/189.out | 4 ++--

tests/qemu-iotests/198.out | 4 ++--

tests/qemu-iotests/263.out | 4 ++--

tests/qemu-iotests/284.out | 6 +++---

tests/qemu-iotests/common.filter | 5 +----

9 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/tests/qemu-iotests/087.out b/tests/qemu-iotests/087.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/087.out

+++ b/tests/qemu-iotests/087.out

@@ -XXX,XX +XXX,XX @@ QMP_VERSION

=== Encrypted image QCow ===

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on encrypt.key-secret=sec0

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on

Testing:

QMP_VERSION

{"return": {}}

@@ -XXX,XX +XXX,XX @@ QMP_VERSION

=== Encrypted image LUKS ===

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encrypt.format=luks encrypt.key-secret=sec0

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728

Testing:

QMP_VERSION

{"return": {}}

@@ -XXX,XX +XXX,XX @@ QMP_VERSION

=== Missing driver ===

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on encrypt.key-secret=sec0

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on

Testing: -S

QMP_VERSION

{"return": {}}

diff --git a/tests/qemu-iotests/134.out b/tests/qemu-iotests/134.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/134.out

+++ b/tests/qemu-iotests/134.out

@@ -XXX,XX +XXX,XX @@

QA output created by 134

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on encrypt.key-secret=sec0

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on

== reading whole image ==

read 134217728/134217728 bytes at offset 0

diff --git a/tests/qemu-iotests/158.out b/tests/qemu-iotests/158.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/158.out

+++ b/tests/qemu-iotests/158.out

@@ -XXX,XX +XXX,XX @@

QA output created by 158

== create base ==

-Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728 encryption=on encrypt.key-secret=sec0

+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728 encryption=on

== writing whole image ==

wrote 134217728/134217728 bytes at offset 0

@@ -XXX,XX +XXX,XX @@ wrote 134217728/134217728 bytes at offset 0

read 134217728/134217728 bytes at offset 0

128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

== create overlay ==

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base encryption=on encrypt.key-secret=sec0

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base encryption=on

== writing part of a cluster ==

wrote 1024/1024 bytes at offset 0

diff --git a/tests/qemu-iotests/188.out b/tests/qemu-iotests/188.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/188.out

+++ b/tests/qemu-iotests/188.out

@@ -XXX,XX +XXX,XX @@

QA output created by 188

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=16777216 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=16777216

== reading whole image ==

read 16777216/16777216 bytes at offset 0

diff --git a/tests/qemu-iotests/189.out b/tests/qemu-iotests/189.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/189.out

+++ b/tests/qemu-iotests/189.out

@@ -XXX,XX +XXX,XX @@

QA output created by 189

== create base ==

-Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=16777216 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=16777216

== writing whole image ==

wrote 16777216/16777216 bytes at offset 0

@@ -XXX,XX +XXX,XX @@ wrote 16777216/16777216 bytes at offset 0

read 16777216/16777216 bytes at offset 0

16 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

== create overlay ==

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=16777216 backing_file=TEST_DIR/t.IMGFMT.base encrypt.format=luks encrypt.key-secret=sec1 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=16777216 backing_file=TEST_DIR/t.IMGFMT.base

== writing part of a cluster ==

wrote 1024/1024 bytes at offset 0

diff --git a/tests/qemu-iotests/198.out b/tests/qemu-iotests/198.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/198.out

+++ b/tests/qemu-iotests/198.out

@@ -XXX,XX +XXX,XX @@

QA output created by 198

== create base ==

-Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=16777216 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=16777216

== writing whole image base ==

wrote 16777216/16777216 bytes at offset 0

16 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

== create overlay ==

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=16777216 backing_file=TEST_DIR/t.IMGFMT.base encrypt.format=luks encrypt.key-secret=sec1 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=16777216 backing_file=TEST_DIR/t.IMGFMT.base

== writing whole image layer ==

wrote 16777216/16777216 bytes at offset 0

diff --git a/tests/qemu-iotests/263.out b/tests/qemu-iotests/263.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/263.out

+++ b/tests/qemu-iotests/263.out

@@ -XXX,XX +XXX,XX @@ QA output created by 263

testing LUKS qcow2 encryption

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

== reading the whole image ==

read 1048576/1048576 bytes at offset 0

1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

@@ -XXX,XX +XXX,XX @@ read 982528/982528 bytes at offset 66048

testing legacy AES qcow2 encryption

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=aes encrypt.key-secret=sec0

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

== reading the whole image ==

read 1048576/1048576 bytes at offset 0

1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

diff --git a/tests/qemu-iotests/284.out b/tests/qemu-iotests/284.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/284.out

+++ b/tests/qemu-iotests/284.out

@@ -XXX,XX +XXX,XX @@ QA output created by 284

testing LUKS qcow2 encryption

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

== cluster size 512

== checking image refcounts ==

@@ -XXX,XX +XXX,XX @@ wrote 1/1 bytes at offset 512

== rechecking image refcounts ==

No errors were found on the image.

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

== cluster size 2048

== checking image refcounts ==

@@ -XXX,XX +XXX,XX @@ wrote 1/1 bytes at offset 2048

== rechecking image refcounts ==

No errors were found on the image.

-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576

== cluster size 32768

== checking image refcounts ==

diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/common.filter

+++ b/tests/qemu-iotests/common.filter

@@ -XXX,XX +XXX,XX @@ _filter_img_create()

echo "$options" \

| tr '\n' '\0' \

| $SED -e 's/\x0$//' -e 's/ \([a-z0-9_.-]*\)=/\n\1=/g' \

- | grep -ae "^\(fmt\\|size\\|backing\\|preallocation\\|encrypt$grep_data_file\\)" \

+ | grep -ae "^\(fmt\\|size\\|backing\\|preallocation\\|encryption$grep_data_file\\)" \

| $SED "${filename_filters[@]}" \

-e 's/^\(fmt\)/0-\1/' \

-e 's/^\(size\)/1-\1/' \

-e 's/^\(backing\)/2-\1/' \

-e 's/^\(data_file\)/3-\1/' \

-e 's/^\(encryption\)/4-\1/' \

- -e 's/^\(encrypt\.format\)/5-\1/' \

- -e 's/^\(encrypt\.key-secret\)/6-\1/' \

- -e 's/^\(encrypt\.iter-time\)/7-\1/' \

-e 's/^\(preallocation\)/8-\1/' \

| sort \

| $SED -e 's/^[0-9]-//' \

--

2.26.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

ret may be > 0 on success path at this point. Fix assertion, which may

crash currently.

Fixes: 4ce5dd3e9b5ee0fac18625860eb3727399ee965e

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Message-Id: <20200526181347.489557-1-vsementsov@virtuozzo.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

block/block-copy.c | 4 +++-

1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/block/block-copy.c b/block/block-copy.c

index XXXXXXX..XXXXXXX 100644

--- a/block/block-copy.c

+++ b/block/block-copy.c

@@ -XXX,XX +XXX,XX @@ out:

* block_copy_task_run. If it fails, it means some task already failed

* for real reason, let's return first failure.

* Still, assert that we don't rewrite failure by success.

+ *

+ * Note: ret may be positive here because of block-status result.

*/

- assert(ret == 0 || aio_task_pool_status(aio) < 0);

+ assert(ret >= 0 || aio_task_pool_status(aio) < 0);

ret = aio_task_pool_status(aio);

aio_task_pool_free(aio);

--

2.26.2

From: Maxim Levitsky <mlevitsk@redhat.com>

This will be used first to implement luks keyslot management.

block_crypto_amend_opts_init will be used to convert

qemu-img cmdline to QCryptoBlockAmendOptions

Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>

Message-Id: <20200608094030.670121-2-mlevitsk@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

qapi/crypto.json | 16 ++++++++++++++++

block/crypto.h | 3 +++

crypto/blockpriv.h | 8 ++++++++

include/crypto/block.h | 22 ++++++++++++++++++++++

block/crypto.c | 17 +++++++++++++++++

crypto/block.c | 29 +++++++++++++++++++++++++++++

6 files changed, 95 insertions(+)

diff --git a/qapi/crypto.json b/qapi/crypto.json

index XXXXXXX..XXXXXXX 100644

--- a/qapi/crypto.json

+++ b/qapi/crypto.json

@@ -XXX,XX +XXX,XX @@

'base': 'QCryptoBlockInfoBase',

'discriminator': 'format',

'data': { 'luks': 'QCryptoBlockInfoLUKS' } }

+

+

+

+##

+# @QCryptoBlockAmendOptions:

+#

+# The options that are available for all encryption formats

+# when amending encryption settings

+#

+# Since: 5.1

+##

+{ 'union': 'QCryptoBlockAmendOptions',

+ 'base': 'QCryptoBlockOptionsBase',

+ 'discriminator': 'format',

+ 'data': {

+ } }

diff --git a/block/crypto.h b/block/crypto.h

index XXXXXXX..XXXXXXX 100644

--- a/block/crypto.h

+++ b/block/crypto.h

@@ -XXX,XX +XXX,XX @@

QCryptoBlockCreateOptions *

block_crypto_create_opts_init(QDict *opts, Error **errp);

+QCryptoBlockAmendOptions *

+block_crypto_amend_opts_init(QDict *opts, Error **errp);

+

QCryptoBlockOpenOptions *

block_crypto_open_opts_init(QDict *opts, Error **errp);

diff --git a/crypto/blockpriv.h b/crypto/blockpriv.h

index XXXXXXX..XXXXXXX 100644

--- a/crypto/blockpriv.h

+++ b/crypto/blockpriv.h

@@ -XXX,XX +XXX,XX @@ struct QCryptoBlockDriver {

void *opaque,

Error **errp);

+ int (*amend)(QCryptoBlock *block,

+ QCryptoBlockReadFunc readfunc,

+ QCryptoBlockWriteFunc writefunc,

+ void *opaque,

+ QCryptoBlockAmendOptions *options,

+ bool force,

+ Error **errp);

+

int (*get_info)(QCryptoBlock *block,

QCryptoBlockInfo *info,

Error **errp);

diff --git a/include/crypto/block.h b/include/crypto/block.h

index XXXXXXX..XXXXXXX 100644

--- a/include/crypto/block.h

+++ b/include/crypto/block.h

@@ -XXX,XX +XXX,XX @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,

void *opaque,

Error **errp);

+/**

+ * qcrypto_block_amend_options:

+ * @block: the block encryption object

+ *

+ * @readfunc: callback for reading data from the volume header

+ * @writefunc: callback for writing data to the volume header

+ * @opaque: data to pass to @readfunc and @writefunc

+ * @options: the new/amended encryption options

+ * @force: hint for the driver to allow unsafe operation

+ * @errp: error pointer

+ *

+ * Changes the crypto options of the encryption format

+ *

+ */

+int qcrypto_block_amend_options(QCryptoBlock *block,

+ QCryptoBlockReadFunc readfunc,

+ QCryptoBlockWriteFunc writefunc,

+ void *opaque,

+ QCryptoBlockAmendOptions *options,

+ bool force,

+ Error **errp);

+

/**

* qcrypto_block_calculate_payload_offset:

diff --git a/block/crypto.c b/block/crypto.c

index XXXXXXX..XXXXXXX 100644

--- a/block/crypto.c

+++ b/block/crypto.c

@@ -XXX,XX +XXX,XX @@ block_crypto_create_opts_init(QDict *opts, Error **errp)

return ret;

}

+QCryptoBlockAmendOptions *

+block_crypto_amend_opts_init(QDict *opts, Error **errp)

+{

+ Visitor *v;

+ QCryptoBlockAmendOptions *ret;

+

+ v = qobject_input_visitor_new_flat_confused(opts, errp);

+ if (!v) {

+ return NULL;

+ }

+

+ visit_type_QCryptoBlockAmendOptions(v, NULL, &ret, errp);

+

+ visit_free(v);

+ return ret;

+}

+

static int block_crypto_open_generic(QCryptoBlockFormat format,

QemuOptsList *opts_spec,

diff --git a/crypto/block.c b/crypto/block.c

index XXXXXXX..XXXXXXX 100644

--- a/crypto/block.c

+++ b/crypto/block.c

@@ -XXX,XX +XXX,XX @@ qcrypto_block_calculate_payload_offset(QCryptoBlockCreateOptions *create_opts,

return crypto != NULL;

}

+int qcrypto_block_amend_options(QCryptoBlock *block,

+ QCryptoBlockReadFunc readfunc,

+ QCryptoBlockWriteFunc writefunc,

+ void *opaque,

+ QCryptoBlockAmendOptions *options,

+ bool force,

+ Error **errp)

+{

+ if (options->format != block->format) {

+ error_setg(errp,

+ "Cannot amend encryption format");

+ return -1;

+ }

+

+ if (!block->driver->amend) {

+ error_setg(errp,

+ "Crypto format %s doesn't support format options amendment",

+ QCryptoBlockFormat_str(block->format));

+ return -1;

+ }

+

+ return block->driver->amend(block,

+ readfunc,

+ writefunc,

+ opaque,

+ options,

+ force,

+ errp);

+}

QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,

Error **errp)

--

2.26.2

From: Maxim Levitsky <mlevitsk@redhat.com>

Next few patches will expose that functionality to the user.

Signed-off-by: Maxim Levitsky <mlevitsk@redhat.com>

Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>

Message-Id: <20200608094030.670121-3-mlevitsk@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>

---

qapi/crypto.json | 59 ++++++-

crypto/block-luks.c | 416 +++++++++++++++++++++++++++++++++++++++++++-

2 files changed, 469 insertions(+), 6 deletions(-)

diff --git a/qapi/crypto.json b/qapi/crypto.json

index XXXXXXX..XXXXXXX 100644

--- a/qapi/crypto.json

+++ b/qapi/crypto.json

@@ -XXX,XX +XXX,XX @@

'uuid': 'str',

'slots': [ 'QCryptoBlockInfoLUKSSlot' ] }}

-

##

# @QCryptoBlockInfo:

#

@@ -XXX,XX +XXX,XX @@

'discriminator': 'format',

'data': { 'luks': 'QCryptoBlockInfoLUKS' } }

+##

+# @QCryptoBlockLUKSKeyslotState:

+#

+# Defines state of keyslots that are affected by the update

+#

+# @active: The slots contain the given password and marked as active

+# @inactive: The slots are erased (contain garbage) and marked as inactive

+#

+# Since: 5.1

+##

+{ 'enum': 'QCryptoBlockLUKSKeyslotState',

+ 'data': [ 'active', 'inactive' ] }

+

+##

+# @QCryptoBlockAmendOptionsLUKS:

+#

+# This struct defines the update parameters that activate/de-activate set

+# of keyslots

+#

+# @state: the desired state of the keyslots

+#

+# @new-secret: The ID of a QCryptoSecret object providing the password to be

+# written into added active keyslots

+#

+# @old-secret: Optional (for deactivation only)

+# If given will deactive all keyslots that

+# match password located in QCryptoSecret with this ID

+#

+# @iter-time: Optional (for activation only)

+# Number of milliseconds to spend in

+# PBKDF passphrase processing for the newly activated keyslot.

+# Currently defaults to 2000.

+#

+# @keyslot: Optional. ID of the keyslot to activate/deactivate.

+# For keyslot activation, keyslot should not be active already

+# (this is unsafe to update an active keyslot),

+# but possible if 'force' parameter is given.

+# If keyslot is not given, first free keyslot will be written.

+#

+# For keyslot deactivation, this parameter specifies the exact

+# keyslot to deactivate

+#

+# @secret: Optional. The ID of a QCryptoSecret object providing the

+# password to use to retrive current master key.

+# Defaults to the same secret that was used to open the image

+#

+#

+# Since 5.1

+##

+{ 'struct': 'QCryptoBlockAmendOptionsLUKS',

+ 'data': { 'state': 'QCryptoBlockLUKSKeyslotState',

+ '*new-secret': 'str',

+ '*old-secret': 'str',

+ '*keyslot': 'int',

+ '*iter-time': 'int',

+ '*secret': 'str' } }

##

# @QCryptoBlockAmendOptions:

@@ -XXX,XX +XXX,XX @@

'base': 'QCryptoBlockOptionsBase',

'discriminator': 'format',

'data': {

- } }

+ 'luks': 'QCryptoBlockAmendOptionsLUKS' } }

diff --git a/crypto/block-luks.c b/crypto/block-luks.c

index XXXXXXX..XXXXXXX 100644

--- a/crypto/block-luks.c

+++ b/crypto/block-luks.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/uuid.h"

#include "qemu/coroutine.h"

+#include "qemu/bitmap.h"

/*

* Reference for the LUKS format implemented here is

@@ -XXX,XX +XXX,XX @@ typedef struct QCryptoBlockLUKSKeySlot QCryptoBlockLUKSKeySlot;

#define QCRYPTO_BLOCK_LUKS_SECTOR_SIZE 512LL

+#define QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS 2000

+#define QCRYPTO_BLOCK_LUKS_ERASE_ITERATIONS 40

+

static const char qcrypto_block_luks_magic[QCRYPTO_BLOCK_LUKS_MAGIC_LEN] = {

'L', 'U', 'K', 'S', 0xBA, 0xBE

};

@@ -XXX,XX +XXX,XX @@ struct QCryptoBlockLUKS {

/* Hash algorithm used in pbkdf2 function */

QCryptoHashAlgorithm hash_alg;

+

+ /* Name of the secret that was used to open the image */

+ char *secret;

};

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_store_key(QCryptoBlock *block,

Error **errp)

{

QCryptoBlockLUKS *luks = block->opaque;

- QCryptoBlockLUKSKeySlot *slot = &luks->header.key_slots[slot_idx];

+ QCryptoBlockLUKSKeySlot *slot;

g_autofree uint8_t *splitkey = NULL;

size_t splitkeylen;

g_autofree uint8_t *slotkey = NULL;

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_store_key(QCryptoBlock *block,

uint64_t iters;

int ret = -1;

+ assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);

+ slot = &luks->header.key_slots[slot_idx];

if (qcrypto_random_bytes(slot->salt,

QCRYPTO_BLOCK_LUKS_SALT_LEN,

errp) < 0) {

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_load_key(QCryptoBlock *block,

Error **errp)

{

QCryptoBlockLUKS *luks = block->opaque;

- const QCryptoBlockLUKSKeySlot *slot = &luks->header.key_slots[slot_idx];

+ const QCryptoBlockLUKSKeySlot *slot;

g_autofree uint8_t *splitkey = NULL;

size_t splitkeylen;

g_autofree uint8_t *possiblekey = NULL;

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_load_key(QCryptoBlock *block,

g_autoptr(QCryptoIVGen) ivgen = NULL;

size_t niv;

+ assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);

+ slot = &luks->header.key_slots[slot_idx];

if (slot->active != QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED) {

return 0;

}

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_find_key(QCryptoBlock *block,

return -1;

}

+/*

+ * Returns true if a slot i is marked as active

+ * (contains encrypted copy of the master key)

+ */

+static bool

+qcrypto_block_luks_slot_active(const QCryptoBlockLUKS *luks,

+ unsigned int slot_idx)

+{

+ uint32_t val;

+

+ assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);

+ val = luks->header.key_slots[slot_idx].active;

+ return val == QCRYPTO_BLOCK_LUKS_KEY_SLOT_ENABLED;

+}

+

+/*

+ * Returns the number of slots that are marked as active

+ * (slots that contain encrypted copy of the master key)

+ */

+static unsigned int

+qcrypto_block_luks_count_active_slots(const QCryptoBlockLUKS *luks)

+{

+ size_t i = 0;

+ unsigned int ret = 0;

+

+ for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {

+ if (qcrypto_block_luks_slot_active(luks, i)) {

+ ret++;

+ }

+ }

+ return ret;

+}

+

+/*

+ * Finds first key slot which is not active

+ * Returns the key slot index, or -1 if it doesn't exist

+ */

+static int

+qcrypto_block_luks_find_free_keyslot(const QCryptoBlockLUKS *luks)

+{

+ size_t i;

+

+ for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {

+ if (!qcrypto_block_luks_slot_active(luks, i)) {

+ return i;

+ }

+ }

+ return -1;

+}

+

+/*

+ * Erases an keyslot given its index

+ * Returns:

+ * 0 if the keyslot was erased successfully

+ * -1 if a error occurred while erasing the keyslot

+ *

+ */

+static int

+qcrypto_block_luks_erase_key(QCryptoBlock *block,

+ unsigned int slot_idx,

+ QCryptoBlockWriteFunc writefunc,

+ void *opaque,

+ Error **errp)

+{

+ QCryptoBlockLUKS *luks = block->opaque;

+ QCryptoBlockLUKSKeySlot *slot;

+ g_autofree uint8_t *garbagesplitkey = NULL;

+ size_t splitkeylen;

+ size_t i;

+ Error *local_err = NULL;

+ int ret;

+

+ assert(slot_idx < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS);

+ slot = &luks->header.key_slots[slot_idx];

+

+ splitkeylen = luks->header.master_key_len * slot->stripes;

+ assert(splitkeylen > 0);

+

+ garbagesplitkey = g_new0(uint8_t, splitkeylen);

+

+ /* Reset the key slot header */

+ memset(slot->salt, 0, QCRYPTO_BLOCK_LUKS_SALT_LEN);

+ slot->iterations = 0;

+ slot->active = QCRYPTO_BLOCK_LUKS_KEY_SLOT_DISABLED;

+

+ ret = qcrypto_block_luks_store_header(block, writefunc,

+ opaque, &local_err);

+

+ if (ret < 0) {

+ error_propagate(errp, local_err);

+ }

+ /*

+ * Now try to erase the key material, even if the header

+ * update failed

+ */

+ for (i = 0; i < QCRYPTO_BLOCK_LUKS_ERASE_ITERATIONS; i++) {

+ if (qcrypto_random_bytes(garbagesplitkey,

+ splitkeylen, &local_err) < 0) {

+ /*

+ * If we failed to get the random data, still write

+ * at least zeros to the key slot at least once

+ */

+ error_propagate(errp, local_err);

+

+ if (i > 0) {

+ return -1;

+ }

+ }

+ if (writefunc(block,

+ slot->key_offset_sector * QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,

+ garbagesplitkey,

+ splitkeylen,

+ opaque,

+ &local_err) != splitkeylen) {

+ error_propagate(errp, local_err);

+ return -1;

+ }

+ }

+ return ret;

+}

static int

qcrypto_block_luks_open(QCryptoBlock *block,

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_open(QCryptoBlock *block,

luks = g_new0(QCryptoBlockLUKS, 1);

block->opaque = luks;

+ luks->secret = g_strdup(options->u.luks.key_secret);

if (qcrypto_block_luks_load_header(block, readfunc, opaque, errp) < 0) {

goto fail;

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_open(QCryptoBlock *block,

fail:

qcrypto_block_free_cipher(block);

qcrypto_ivgen_free(block->ivgen);

+ g_free(luks->secret);

g_free(luks);

return -1;

}

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_create(QCryptoBlock *block,

memcpy(&luks_opts, &options->u.luks, sizeof(luks_opts));

if (!luks_opts.has_iter_time) {

- luks_opts.iter_time = 2000;

+ luks_opts.iter_time = QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS;

}

if (!luks_opts.has_cipher_alg) {

luks_opts.cipher_alg = QCRYPTO_CIPHER_ALG_AES_256;

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_create(QCryptoBlock *block,

optprefix ? optprefix : "");

goto error;

}

+ luks->secret = g_strdup(options->u.luks.key_secret);

+

password = qcrypto_secret_lookup_as_utf8(luks_opts.key_secret, errp);

if (!password) {

goto error;

@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_create(QCryptoBlock *block,

qcrypto_block_free_cipher(block);

qcrypto_ivgen_free(block->ivgen);

+ g_free(luks->secret);

g_free(luks);

return -1;

}

+static int

+qcrypto_block_luks_amend_add_keyslot(QCryptoBlock *block,

+ QCryptoBlockReadFunc readfunc,

+ QCryptoBlockWriteFunc writefunc,

+ void *opaque,

+ QCryptoBlockAmendOptionsLUKS *opts_luks,

+ bool force,

+ Error **errp)

+{

+ QCryptoBlockLUKS *luks = block->opaque;

+ uint64_t iter_time = opts_luks->has_iter_time ?

+ opts_luks->iter_time :

+ QCRYPTO_BLOCK_LUKS_DEFAULT_ITER_TIME_MS;

+ int keyslot;

+ g_autofree char *old_password = NULL;

+ g_autofree char *new_password = NULL;

+ g_autofree uint8_t *master_key = NULL;

+

+ char *secret = opts_luks->has_secret ? opts_luks->secret : luks->secret;

+

+ if (!opts_luks->has_new_secret) {

+ error_setg(errp, "'new-secret' is required to activate a keyslot");

+ return -1;

+ }

+ if (opts_luks->has_old_secret) {

+ error_setg(errp,

+ "'old-secret' must not be given when activating keyslots");

+ return -1;

+ }

+

+ if (opts_luks->has_keyslot) {

+ keyslot = opts_luks->keyslot;

+ if (keyslot < 0 || keyslot >= QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS) {

+ error_setg(errp,

+ "Invalid keyslot %u specified, must be between 0 and %u",

+ keyslot, QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS - 1);

+ return -1;

+ }

+ } else {

+ keyslot = qcrypto_block_luks_find_free_keyslot(luks);

+ if (keyslot == -1) {

+ error_setg(errp,

+ "Can't add a keyslot - all keyslots are in use");

+ return -1;

+ }

+ }

+

+ if (!force && qcrypto_block_luks_slot_active(luks, keyslot)) {

+ error_setg(errp,

+ "Refusing to overwrite active keyslot %i - "

+ "please erase it first",

+ keyslot);

+ return -1;

+ }

+

+ /* Locate the password that will be used to retrieve the master key */

+ old_password = qcrypto_secret_lookup_as_utf8(secret, errp);

+ if (!old_password) {

+ return -1;

+ }

+

+ /* Retrieve the master key */

+ master_key = g_new0(uint8_t, luks->header.master_key_len);

+

+ if (qcrypto_block_luks_find_key(block, old_password, master_key,

+ readfunc, opaque, errp) < 0) {

+ error_append_hint(errp, "Failed to retrieve the master key");

+ return -1;

+ }

+

+ /* Locate the new password*/

+ new_password = qcrypto_secret_lookup_as_utf8(opts_luks->new_secret, errp);

+ if (!new_password) {

+ return -1;

+ }

+

+ /* Now set the new keyslots */

+ if (qcrypto_block_luks_store_key(block, keyslot, new_password, master_key,

+ iter_time, writefunc, opaque, errp)) {

+ error_append_hint(errp, "Failed to write to keyslot %i", keyslot);

+ return -1;

+ }

+ return 0;

+}

+

+static int

+qcrypto_block_luks_amend_erase_keyslots(QCryptoBlock *block,

+ QCryptoBlockReadFunc readfunc,

+ QCryptoBlockWriteFunc writefunc,

+ void *opaque,

+ QCryptoBlockAmendOptionsLUKS *opts_luks,

+ bool force,

+ Error **errp)

+{

+ QCryptoBlockLUKS *luks = block->opaque;

+ g_autofree uint8_t *tmpkey = NULL;

+ g_autofree char *old_password = NULL;

+

+ if (opts_luks->has_new_secret) {

+ error_setg(errp,

+ "'new-secret' must not be given when erasing keyslots");

+ return -1;

+ }

+ if (opts_luks->has_iter_time) {

+ error_setg(errp,

+ "'iter-time' must not be given when erasing keyslots");

+ return -1;

+ }

+ if (opts_luks->has_secret) {

+ error_setg(errp,

+ "'secret' must not be given when erasing keyslots");

+ return -1;

+ }

+

+ /* Load the old password if given */

+ if (opts_luks->has_old_secret) {

+ old_password = qcrypto_secret_lookup_as_utf8(opts_luks->old_secret,

+ errp);

+ if (!old_password) {

+ return -1;

+ }

+

+ /*

+ * Allocate a temporary key buffer that we will need when

+ * checking if slot matches the given old password

+ */

+ tmpkey = g_new0(uint8_t, luks->header.master_key_len);

+ }

+

+ /* Erase an explicitly given keyslot */

+ if (opts_luks->has_keyslot) {

+ int keyslot = opts_luks->keyslot;

+

+ if (keyslot < 0 || keyslot >= QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS) {

+ error_setg(errp,

+ "Invalid keyslot %i specified, must be between 0 and %i",

+ keyslot, QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS - 1);

+ return -1;

+ }

+

+ if (opts_luks->has_old_secret) {

+ int rv = qcrypto_block_luks_load_key(block,

+ keyslot,

+ old_password,

+ tmpkey,

+ readfunc,

+ opaque,

+ errp);

+ if (rv == -1) {

+ return -1;

+ } else if (rv == 0) {

+ error_setg(errp,

+ "Given keyslot %i doesn't contain the given "

+ "old password for erase operation",

+ keyslot);

+ return -1;

+ }

+ }

+

+ if (!force && !qcrypto_block_luks_slot_active(luks, keyslot)) {

+ error_setg(errp,

+ "Given keyslot %i is already erased (inactive) ",

+ keyslot);

+ return -1;

+ }

+

+ if (!force && qcrypto_block_luks_count_active_slots(luks) == 1) {

+ error_setg(errp,

+ "Attempt to erase the only active keyslot %i "

+ "which will erase all the data in the image "

+ "irreversibly - refusing operation",

+ keyslot);

+ return -1;

+ }

+

+ if (qcrypto_block_luks_erase_key(block, keyslot,

+ writefunc, opaque, errp)) {

+ error_append_hint(errp, "Failed to erase keyslot %i", keyslot);

+ return -1;

+ }

+

+ /* Erase all keyslots that match the given old password */

+ } else if (opts_luks->has_old_secret) {

+

+ unsigned long slots_to_erase_bitmap = 0;

+ size_t i;

+ int slot_count;

+

+ assert(QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS <=

+ sizeof(slots_to_erase_bitmap) * 8);

+

+ for (i = 0; i < QCRYPTO_BLOCK_LUKS_NUM_KEY_SLOTS; i++) {

+ int rv = qcrypto_block_luks_load_key(block,

+ i,

+ old_password,

+ tmpkey,

+ readfunc,

+ opaque,

+ errp);

+ if (rv == -1) {

+ return -1;

+ } else if (rv == 1) {

+ bitmap_set(&slots_to_erase_bitmap, i, 1);

+ }

+ }

+

+ slot_count = bitmap_count_one(&slots_to_erase_bitmap,