Support for full disk encryption
Subsystems (3)
cover Support for full disk encryption
This Work-In-Progress series introduces a framework for full disk encryption, and implements the LUKS encryption format using it. It provides a new block driver that can use this directly, but also aims to integrate it natively into the qcow2 file format (more on that later).
For convenience, this series includes of the patches I've previously sent wrt introducing a secure framework for passing secrets (passwords, keys, etc) to QEMU:
https://lists.gnu.org/archive/html/qemu-devel/2015-10/msg04365.html
Patches 1-> 15 are the basic secret handling related patches
Patches 16-25 are preparatory work in the crypto codebase. This is some bug fixing, some QAPI-ification, and some new support modules for generating initialization vectors, the PBKDF2 algorithm and LUKS anti-forensic split algorithm.
Patches 26 & 27 provide the full disk encryption framework and LUKS implementation respectively.
Finally, patch 28 provides a general purpose encrypted block driver, that can be used in any place you'd currently use dm-crypt with QEMU), and 29/30 start to extend QCow2 to support LUKS as an embedded encryption method. Patch 28 quickly illustrates the qemu-img commands for dealing with encrypted volumes.
The block/fde.c driver is a fairly clean example of how to make use of the full disk encryption framework to implement a block driver. So a good place to look. The crypto/block-luks.c file is the actual LUKS implementation. Its creation code will generate volumes with pretty much the same parameters as the reference cryptsetup impl will.
The QCow2 support is non-functional, because I hit a small problem. The QCow2 header and all header extensions appear to need to fit into the first cluster. The LUKS header is typically set to be 2 MB in size, which is clearly not going to fit. The actual QCow2 header appears to include offsets for all the various data tables, so it /appears/ that the first cluster limit for headers is just an implementation limit, not a specification limit. Assuming that's correct, I'd aim to extend the permitted size of the header to be much larger.
The main limitation of the LUKS impl is that it currently lacks support for the XTS cipher mode, so only CBC can be used. This is because I'm yet to find any attractive impl of XTS that QEMU can reuse, as either gcrypt/nettle provide it yet. TBD...
Daniel P. Berrange (30):
crypto: add QCryptoSecret object class for password/key handling
crypto: add support for loading encrypted x509 keys
qcow: add a 'keyid' parameter to qcow options
qcow2: add a 'keyid' parameter to qcow2 options
qom: add user_creatable_add & user_creatable_del methods
qemu-img: add support for --object command line arg
qemu-nbd: add support for --object command line arg
qemu-io: add support for --object command line arg
qemu-io: allow specifying image as a set of options args
qemu-nbd: allow specifying image as a set of options args
qemu-img: allow specifying image as a set of options args
block: rip out all traces of password prompting
block: remove all encryption handling APIs
block: remove support for writing to qcow/qcow2 encrypted images
qcow2: make qcow2_encrypt_sectors encrypt in place
crypto: add ability to query the cipher key, block & IV lens
crypto: add method for querying hash digest size
crypto: move QCryptoHashAlgorithm enum definition into QAPI
crypto: move QCryptoCipherAlgorithm/Mode enum definitions into QAPI
crypto: ensure qapi/crypto.json is listed in qapi-modules
crypto: add cryptographic random byte source
crypto: add support for PBKDF2 algorithm
crypto: add support for generating initialization vectors
crypto: add support for anti-forensic split algorithm
crypto: fix transposed arguments in cipher error message
crypto: add block encryption framework
crypto: implement the LUKS block encryption format
block: add generic full disk encryption driver
qcow2: convert QCow2 to use QCryptoBlock for encryption
qcow2: add LUKS full disk encryption support
Makefile | 3 +- block.c | 88 +--- block/Makefile.objs | 2 + block/fde.c | 522 +++++++++++++++++++ block/qapi.c | 2 +- block/qcow.c | 122 +++-- block/qcow2-cluster.c | 55 +- block/qcow2.c | 403 ++++++++++++--- block/qcow2.h | 18 +- blockdev.c | 40 +- crypto/Makefile.objs | 11 + crypto/afsplit.c | 194 +++++++ crypto/block-luks.c | 1056 +++++++++++++++++++++++++++++++++++++++ crypto/block-luks.h | 28 ++ crypto/block-qcowaes.c | 150 ++++++ crypto/block-qcowaes.h | 28 ++ crypto/block.c | 253 ++++++++++ crypto/blockpriv.h | 87 ++++ crypto/cipher.c | 54 +- crypto/hash.c | 17 +- crypto/ivgen-essiv.c | 116 +++++ crypto/ivgen-essiv.h | 28 ++ crypto/ivgen-plain.c | 60 +++ crypto/ivgen-plain.h | 28 ++ crypto/ivgen-plain64.c | 60 +++ crypto/ivgen-plain64.h | 28 ++ crypto/ivgen.c | 117 +++++ crypto/ivgenpriv.h | 47 ++ crypto/pbkdf-gcrypt.c | 64 +++ crypto/pbkdf-nettle.c | 63 +++ crypto/pbkdf-stub.c | 39 ++ crypto/pbkdf.c | 76 +++ crypto/random.c | 50 ++ crypto/secret.c | 567 +++++++++++++++++++++ crypto/tlscredsx509.c | 47 ++ docs/specs/qcow2.txt | 53 ++ hmp.c | 42 +- hw/usb/dev-storage.c | 34 -- include/block/block.h | 5 +- include/crypto/afsplit.h | 133 +++++ include/crypto/block.h | 199 ++++++++ include/crypto/cipher.h | 54 +- include/crypto/hash.h | 20 +- include/crypto/ivgen.h | 167 +++++++ include/crypto/pbkdf.h | 152 ++++++ include/crypto/random.h | 43 ++ include/crypto/secret.h | 148 ++++++ include/crypto/tlscredsx509.h | 1 + include/monitor/monitor.h | 10 - include/qemu/option.h | 1 + include/qemu/osdep.h | 2 - include/qom/object_interfaces.h | 31 ++ monitor.c | 69 --- qapi/block-core.json | 23 +- qapi/crypto.json | 173 +++++++ qemu-img-cmds.hx | 44 +- qemu-img.c | 788 +++++++++++++++++++++++++---- qemu-img.texi | 8 + qemu-io.c | 145 +++++- qemu-nbd.c | 142 +++++- qemu-nbd.texi | 7 + qemu-options.hx | 86 +++- qmp.c | 84 +--- qom/object_interfaces.c | 76 +++ tests/.gitignore | 4 + tests/Makefile | 8 + tests/qemu-iotests/087 | 20 + tests/qemu-iotests/087.out | 26 +- tests/qemu-iotests/134 | 17 +- tests/qemu-iotests/134.out | 44 +- tests/qemu-iotests/common.rc | 4 +- tests/test-crypto-afsplit.c | 176 +++++++ tests/test-crypto-cipher.c | 10 + tests/test-crypto-hash.c | 5 + tests/test-crypto-ivgen.c | 168 +++++++ tests/test-crypto-pbkdf.c | 378 ++++++++++++++ tests/test-crypto-secret.c | 446 +++++++++++++++++ util/oslib-posix.c | 66 --- util/oslib-win32.c | 24 - util/qemu-option.c | 6 + vl.c | 8 +- 81 files changed, 7829 insertions(+), 844 deletions(-) create mode 100644 block/fde.c create mode 100644 crypto/afsplit.c create mode 100644 crypto/block-luks.c create mode 100644 crypto/block-luks.h create mode 100644 crypto/block-qcowaes.c create mode 100644 crypto/block-qcowaes.h create mode 100644 crypto/block.c create mode 100644 crypto/blockpriv.h create mode 100644 crypto/ivgen-essiv.c create mode 100644 crypto/ivgen-essiv.h create mode 100644 crypto/ivgen-plain.c create mode 100644 crypto/ivgen-plain.h create mode 100644 crypto/ivgen-plain64.c create mode 100644 crypto/ivgen-plain64.h create mode 100644 crypto/ivgen.c create mode 100644 crypto/ivgenpriv.h create mode 100644 crypto/pbkdf-gcrypt.c create mode 100644 crypto/pbkdf-nettle.c create mode 100644 crypto/pbkdf-stub.c create mode 100644 crypto/pbkdf.c create mode 100644 crypto/random.c create mode 100644 crypto/secret.c create mode 100644 include/crypto/afsplit.h create mode 100644 include/crypto/block.h create mode 100644 include/crypto/ivgen.h create mode 100644 include/crypto/pbkdf.h create mode 100644 include/crypto/random.h create mode 100644 include/crypto/secret.h create mode 100644 tests/test-crypto-afsplit.c create mode 100644 tests/test-crypto-ivgen.c create mode 100644 tests/test-crypto-pbkdf.c create mode 100644 tests/test-crypto-secret.c
Signature · 1 line
2.5.0
PATCH 1/30 crypto: add QCryptoSecret object class for password/key handling
Introduce a new QCryptoSecret object class which will be used for providing passwords and keys to other objects which need sensitive credentials.
The new object can provide secret values directly as properties, or indirectly via a file. The latter includes support for file descriptor passing syntax on UNIX platforms. Ordinarily passing secret values directly as properties is insecure, since they are visible in process listings, or in log files showing the CLI args / QMP commands. It is possible to use AES-256-CBC to encrypt the secret values though, in which case all that is visible is the ciphertext. For adhoc developer testing though, it is fine to provide the secrets directly without encryption so this is not explicitly forbidden.
The anticipated scenario is that libvirtd will create a random master key per QEMU instance (eg /var/run/libvirt/qemu/$VMNAME.key) and will use that key to encrypt all passwords it provides to QEMU via '-object secret,....'. This avoids the need for libvirt (or other mgmt apps) to worry about file descriptor passing.
It also makes life easier for people who are scripting the management of QEMU, for whom FD passing is significantly more complex.
Providing data inline (insecure, only for adhoc dev tetsing)
$QEMU -object secret,id=sec0,data=letmein
Providing data indirectly in raw format
echo -n "letmein" > mypasswd.txt
$QEMU -object secret,id=sec0,file=mypasswd.txt
Providing data indirectly in base64 format
$QEMU -object secret,id=sec0,file=mykey.b64,format=base64
Providing data with encyption
$QEMU -object secret,id=master0,file=mykey.b64,format=base64 \
-object secret,id=sec0,data=[base64 ciphertext],\
keyid=master0,iv=[base64 IV],format=base64Note that 'format' here refers to the format of the ciphertext data. The decrypted data must always be in raw byte format.
More examples are shown in the updated docs.
--- crypto/Makefile.objs | 1 + crypto/secret.c | 567 +++++++++++++++++++++++++++++++++++++++++++++ include/crypto/secret.h | 148 ++++++++++++ qapi/crypto.json | 14 ++ qemu-options.hx | 78 +++++++ tests/.gitignore | 1 + tests/Makefile | 2 + tests/test-crypto-secret.c | 446 +++++++++++++++++++++++++++++++++++ 8 files changed, 1257 insertions(+) create mode 100644 crypto/secret.c create mode 100644 include/crypto/secret.h create mode 100644 tests/test-crypto-secret.c
crypto/Makefile.objs +1 -0
@@ -7,6 +7,7 @@ crypto-obj-y += tlscreds.o crypto-obj-y += tlscredsanon.o crypto-obj-y += tlscredsx509.o crypto-obj-y += tlssession.o +crypto-obj-y += secret.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o
crypto/secret.c new file +567 -0
567 lines not on this page · raw message
include/crypto/secret.h new file +148 -0
148 lines not on this page · raw message
qapi/crypto.json +14 -0
@@ -19,3 +19,17 @@ { 'enum': 'QCryptoTLSCredsEndpoint', 'prefix': 'QCRYPTO_TLS_CREDS_ENDPOINT', 'data': ['client', 'server']} + + +## +# QCryptoSecretFormat: +# +# The data format that the secret is provided in +# +# @raw: raw bytes. When encoded in JSON only valid UTF-8 sequences can be used +# @base64: arbitrary base64 encoded binary data +# Since: 2.5 +## +{ 'enum': 'QCryptoSecretFormat', + 'prefix': 'QCRYPTO_SECRET_FORMAT', + 'data': ['raw', 'base64']}
qemu-options.hx +78 -0
90 lines not on this page · raw message
tests/.gitignore +1 -0
@@ -13,6 +13,7 @@ test-blockjob-txn test-coroutine test-crypto-cipher test-crypto-hash +test-crypto-secret test-crypto-tlscredsx509 test-crypto-tlscredsx509-work/ test-crypto-tlscredsx509-certs/
tests/Makefile +2 -0
@@ -80,6 +80,7 @@ check-unit-y += tests/test-write-threshold$(EXESUF) gcov-files-test-write-threshold-y = block/write-threshold.c check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF) check-unit-y += tests/test-crypto-cipher$(EXESUF) +check-unit-y += tests/test-crypto-secret$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlscredsx509$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) check-unit-$(CONFIG_LINUX) += tests/test-qga$(EXESUF)
@@ -457,6 +458,7 @@ tests/test-mul64$(EXESUF): tests/test-mul64.o $(test-util-obj-y) tests/test-bitops$(EXESUF): tests/test-bitops.o $(test-util-obj-y) tests/test-crypto-hash$(EXESUF): tests/test-crypto-hash.o $(test-crypto-obj-y) tests/test-crypto-cipher$(EXESUF): tests/test-crypto-cipher.o $(test-crypto-obj-y) +tests/test-crypto-secret$(EXESUF): tests/test-crypto-secret.o $(test-crypto-obj-y) tests/crypto-tls-x509-helpers.o-cflags := $(TASN1_CFLAGS) tests/crypto-tls-x509-helpers.o-libs := $(TASN1_LIBS)
tests/test-crypto-secret.c new file +446 -0
446 lines not on this page · raw message
Signature · 1 line
2.5.0
Re: [Qemu-devel] [PATCH WIP 01/30] crypto: add QCryptoSecret object class for password/key handling
Quoted 21 lines · Daniel P. Berrange
Introduce a new QCryptoSecret object class which will be used for providing passwords and keys to other objects which need sensitive credentials.
The new object can provide secret values directly as properties, or indirectly via a file. The latter includes support for file descriptor passing syntax on UNIX platforms. Ordinarily passing secret values directly as properties is insecure, since they are visible in process listings, or in log files showing the CLI args / QMP commands. It is possible to use AES-256-CBC to encrypt the secret values though, in which case all that is visible is the ciphertext. For adhoc developer testing though, it is fine to provide the secrets directly without encryption so this is not explicitly forbidden.
The anticipated scenario is that libvirtd will create a random master key per QEMU instance (eg
/var/run/libvirt/qemu/$VMNAME.key) and will use that key to encrypt all passwords it provides to QEMU via '-object secret,....'. This avoids the need for libvirt (or other mgmt apps) to worry about file descriptor passing.
Quoted 5 lines
It also makes life easier for people who are scripting the management of QEMU, for whom FD passing is significantly more complex.
Providing data inline (insecure, only for adhoc dev tetsing)
s/tetsing/testing/
Quoted 6 lines
$QEMU -object secret,id=sec0,data=letmein
Providing data indirectly in raw format
echo -n "letmein" > mypasswd.txt
'echo -n' is non-portable (just this month, there was a user complaining that gentoo disables it on dash, even though upstream dash supports it).
Might be better as:
printf "letmein" > mypasswd.txt
Quoted 7 lines
$QEMU -object secret,id=sec0,file=mypasswd.txt
Providing data indirectly in base64 format
$QEMU -object secret,id=sec0,file=mykey.b64,format=base64
Providing data with encyption
s/encyption/encryption/
Quoted 11 lines
$QEMU -object secret,id=master0,file=mykey.b64,format=base64 \ -object secret,id=sec0,data=[base64 ciphertext],\ keyid=master0,iv=[base64 IV],format=base64Note that 'format' here refers to the format of the ciphertext data. The decrypted data must always be in raw byte format.
More examples are shown in the updated docs.
Signed-off-by Daniel P. Berrange <[email protected]>
Quoted 13 lines
--- crypto/Makefile.objs | 1 + crypto/secret.c | 567 +++++++++++++++++++++++++++++++++++++++++++++ include/crypto/secret.h | 148 ++++++++++++ qapi/crypto.json | 14 ++ qemu-options.hx | 78 +++++++ tests/.gitignore | 1 + tests/Makefile | 2 + tests/test-crypto-secret.c | 446 +++++++++++++++++++++++++++++++++++ 8 files changed, 1257 insertions(+) create mode 100644 crypto/secret.c create mode 100644 include/crypto/secret.h create mode 100644 tests/test-crypto-secret.c
Just focusing on the interface on this pass:
crypto/secret.c line 32
Quoted 8 lines
crypto/secret.c new file +8
-0+ +static const char *base64_valid_chars = +"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" ; + +static int +qcrypto_secret_validate_base64 (const uint8_t *input, +size_t inputlen, +Error **errp)
Don't we already have base64 utility methods available?
Quoted 12 lines
+++
b/include/crypto/secret.h+/**
+ * QCryptoSecret:
+ *
+ * The QCryptoSecret object provides storage of secrets,
+ * which may be user passwords, encryption keys or any
+ * other kind of sensitive data that is represented as
+ * a sequence of bytes.
+ *
+ * The sensitive data associated with the secret can
+ * be provided directly via the 'data' property, or
Quoted 8 lines
+ * indirectly via the 'file' property. In the latter
+ * case there is support for file descriptor passing
+ * via the usual/dev/fdset/NNsyntax that QEMU uses.
+ *
+ * The data for a secret can be provided in two formats,
+ * either as a UTF-8 string (the default), or as base64
+ * encoded 8-bit binary data. The latter is appropriate
+ * for raw encrypton keys, while the former is appropriate
s/for raw/for raw/
s/encrypton/encryption/
Quoted 11 lines
+ * for user entered passwords.
+ *
+ * The data may be optionally encrypted with AES-256-CBC,
+ * and the decryption key provided by another
+ * QCryptoSecret instance identified by the 'keyid'
+ * property. When passing sensitive data directly
+ * via the 'data' property it is strongly recommended
+ * to use the AES encryption facility to prevent the
+ * sensitive data being exposed in the process listing
+ * or system log files.
+ *
Quoted 8 lines
+ * Providing data directly, insecurely (suitable for
+ * adhoc developer testing only)
+ *
+ * $QEMU -object secret,id=sec0,data=letmein
+ *
+ * Providing data indirectly:
+ *
+ * # echo -n "letmein" > password.txt
same comment as on commit message
Quoted 56 lines
+ * # $QEMU \
+ * -object secret,id=sec0,file=password.txt
+ *
+ * Using a master encryption key with data.
+ *
+ * The master key needs to be created as 32 secure
+ * random bytes (optionally base64 encoded)
+ *
+ * # openssl rand -base64 32 > key.b64
+ * # KEY=$(base64 -d key.b64 | hexdump -v -e '/1 "%02X"')
+ *
+ * Each secret to be encrypted needs to have a random
+ * initialization vector generated. These do not need
+ * to be kept secret
+ *
+ * # openssl rand -base64 16 > iv.b64
+ * # IV=$(base64 -d iv.b64 | hexdump -v -e '/1 "%02X"')
+ *
+ * A secret to be defined can now be encrypted
+ *
+ * # SECRET=$(echo -n "letmein" |
+ * openssl enc -aes-256-cbc -a -K $KEY -iv $IV)
+ *
+ * When launching QEMU, create a master secret pointing
+ * to key.b64 and specify that to be used to decrypt
+ * the user password
+ *
+ * # $QEMU \
+ * -object secret,id=secmaster0,format=base64,file=key.b64 \
+ * -object secret,id=sec0,keyid=secmaster0,format=base64,\
+ * data=$SECRET,iv=$(<iv.b64)
+ *
+ * When encrypting, the data can still be provided via an
+ * external file, in which case it is possible to use either
+ * raw binary data, or base64 encoded. This example uses
+ * raw format
+ *
+ * # echo -n "letmein" |
+ * openssl enc -aes-256-cbc -K $KEY -iv $IV -o pw.aes
+ * # $QEMU \
+ * -object secret,id=secmaster0,format=base64,file=key.b64 \
+ * -object secret,id=sec0,keyid=secmaster0,\
+ * file=pw.aes,iv=$(<iv.b64)
+ *
+ * Note that the ciphertext can be in either raw or base64
+ * format, as indicated by the 'format' parameter, but the
+ * plaintext resulting from decryption is expected to always
+ * be in raw format.
+ */+++
b/qapi/crypto.jsonqapi/crypto.json +0
-0@@ -19,3 +19,17 @@ { 'enum': 'QCryptoTLSCredsEndpoint', 'prefix': 'QCRYPTO_TLS_CREDS_ENDPOINT', 'data': ['client', 'server']}
qapi/crypto.json line 31
Quoted 10 lines
qapi/crypto.json +10
-0+ + +## +# QCryptoSecretFormat: +# +# The data format that the secret is provided in +# +# @raw: raw bytes. When encoded in JSON only valid UTF-8 sequences can be used +# @base64: arbitrary base64 encoded binary data +# Since: 2.5
You've missed 2.5. Probably need to tweak the whole series to call out 2.6.
Quoted 9 lines
qapi/crypto.json +4
-0+## +{ 'enum': 'QCryptoSecretFormat', + 'prefix': 'QCRYPTO_SECRET_FORMAT', + 'data': ['raw', 'base64']}qemu-options.hx +0
-0
qemu-options.hx queue @var{all|rx|tx} is an option that can be applied to any netfilter. · line 3674
Quoted 5 lines
qemu-options.hx +1
-0@@ -3670,6 +3670,7 @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter. @option{tx}: the filter is attached to the transmit queue of the netdev, where it will receive packets sent by the netdev. + @item -object filter-dump,id=@var{id},netdev=@var{dev},file=@var{filename}][,maxlen=@var{len}]
Why the added blank line here?
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH WIP 01/30] crypto: add QCryptoSecret object class for password/key handling
Quoted 11 lines · Eric Blake
crypto/secret.c line 32
Quoted 8 lines · Daniel P. Berrange
crypto/secret.c new file +8
-0+ +static const char *base64_valid_chars = +"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" ; + +static int +qcrypto_secret_validate_base64 (const uint8_t *input, +size_t inputlen, +Error **errp)Don't we already have base64 utility methods available?
We normally use glib, g_base64_encode/decode. Unfortunately the decode method doesn't provide any usefull error reporting facility. It just silently skips any characters that are outside the valid set. So the only way I could get any kind of sensible error report was to do this validation myself against the set of permitted base64 characters.
Quoted 9 lines
Quoted 9 lines
+++
b/qapi/crypto.jsonqapi/crypto.json +4
-0@@ -19,3 +19,17 @@ { 'enum': 'QCryptoTLSCredsEndpoint', 'prefix': 'QCRYPTO_TLS_CREDS_ENDPOINT', 'data': ['client', 'server']} + + +## +# QCryptoSecretFormat:
Quoted 8 lines
qapi/crypto.json line 31
Quoted 6 lines
qapi/crypto.json +6
-0+# +# The data format that the secret is provided in +# +# @raw: raw bytes. When encoded in JSON only valid UTF-8 sequences can be used +# @base64: arbitrary base64 encoded binary data +# Since: 2.5You've missed 2.5. Probably need to tweak the whole series to call out 2.6.
Yep.
Quoted 12 lines
Quoted 12 lines
qapi/crypto.json +4
-0+## +{ 'enum': 'QCryptoSecretFormat', + 'prefix': 'QCRYPTO_SECRET_FORMAT', + 'data': ['raw', 'base64']}qemu-options.hx +0
-0@@ -3670,6 +3670,7 @@ queue @var{all|rx|tx} is an option that can be applied to any netfilter. @option{tx}: the filter is attached to the transmit queue of the netdev, where it will receive packets sent by the netdev.
Quoted 4 lines
qemu-options.hx queue @var{all|rx|tx} is an option that can be applied to any netfilter. · line 3674
Quoted 2 lines
qemu-options.hx +1
-0+ @item -object filter-dump,id=@var{id},netdev=@var{dev},file=@var{filename}][,maxlen=@var{len}]Why the added blank line here?
Rebase error I presume
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
Re: [Qemu-devel] [PATCH WIP 01/30] crypto: add QCryptoSecret object class for password/key handling
Quoted 13 lines · Daniel P. Berrange
Quoted 11 lines · Eric Blake
crypto/secret.c line 32
Quoted 8 lines · Daniel P. Berrange
crypto/secret.c new file +8
-0+ +static const char *base64_valid_chars = +"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" ; + +static int +qcrypto_secret_validate_base64 (const uint8_t *input, +size_t inputlen, +Error **errp)Don't we already have base64 utility methods available?
Quoted 6 lines
We normally use glib, g_base64_encode/decode. Unfortunately the decode method doesn't provide any usefull error reporting facility. It just silently skips any characters that are outside the valid set. So the only way I could get any kind of sensible error report was to do this validation myself against the set of permitted base64 characters.
Yes. Same problem elsewhere, e.g. ringbuf-write. qapi-schema.json:
# - base64: data must be base64 encoded text. Its binary
# decoding gets written. # Bug: invalid base64 is currently not rejected. # Whitespace *is* invalid.
This suggests that we shouldn't bury this in crypto/, but instead add it to util/.
A replacement for g_base64_decode() could be easier to use than a checker function to use in addition to g_base64_decode(),
[...]
Re: [Qemu-devel] [PATCH WIP 01/30] crypto: add QCryptoSecret object class for password/key handling
Quoted 29 lines · Markus Armbruster
Quoted 13 lines · Daniel P. Berrange
Quoted 11 lines · Eric Blake
crypto/secret.c line 32
Quoted 8 lines · Daniel P. Berrange
crypto/secret.c new file +8
-0+ +static const char *base64_valid_chars = +"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" ; + +static int +qcrypto_secret_validate_base64 (const uint8_t *input, +size_t inputlen, +Error **errp)Don't we already have base64 utility methods available?
Quoted 6 lines
We normally use glib, g_base64_encode/decode. Unfortunately the decode method doesn't provide any usefull error reporting facility. It just silently skips any characters that are outside the valid set. So the only way I could get any kind of sensible error report was to do this validation myself against the set of permitted base64 characters.
Yes. Same problem elsewhere, e.g. ringbuf-write. qapi-schema.json:
# - base64: data must be base64 encoded text. Its binary
# decoding gets written. # Bug: invalid base64 is currently not rejected. # Whitespace *is* invalid.
Quoted 5 lines
This suggests that we shouldn't bury this in
crypto/, but instead add it to util/.A replacement for
g_base64_decode()could be easier to use than a checker function to use in addition tog_base64_decode(),
Yeah, that's a good idea. I'll look at that.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
PATCH 2/30 crypto: add support for loading encrypted x509 keys
In reply to Daniel P. BerrangeMake use of the QCryptoSecret object to support loading of encrypted x509 keys. The optional 'passwordid' parameter to the tls-creds-x509 object type, provides the ID of a secret object instance that holds the decryption password for the PEM file.
# echo "123456" > mypasswd.txt
# $QEMU \
-object secret,id=sec0,filename=mypasswd.txt \
-object tls-creds-x509,passwordid=sec0,id=creds0,\
dir=/home/berrange/.pki/qemu,endpoint=server \
-vnc :1,tls-creds=creds0This requires QEMU to be linked to GNUTLS >= 3.1.11. If GNUTLS is too old an error will be reported if an attempt is made to pass a decryption password.
--- crypto/tlscredsx509.c | 47 +++++++++++++++++++++++++++++++++++++++++++ include/crypto/tlscredsx509.h | 1 + qemu-options.hx | 8 +++++++- 3 files changed, 55 insertions(+), 1 deletion(-)
crypto/tlscredsx509.c +47 -0
@@ -20,6 +20,7 @@#include "crypto/tlscredsx509.h" #include "crypto/tlscredspriv.h" +#include "crypto/secret.h" #include "qom/object_interfaces.h" #include "trace.h"
@@ -606,9 +607,29 @@ qcrypto_tls_creds_x509_load(QCryptoTLSCredsX509 *creds, }if (cert !=NULL && key !=NULL ) { +#if GNUTLS_VERSION_NUMBER >=0x030111 +char *password =NULL ; +if (creds->passwordid) { + password =qcrypto_secret_lookup_as_utf8 (creds->passwordid, + errp); +if (!password) { + goto cleanup; + } + } + ret =gnutls_certificate_set_x509_key_file2 (creds->data, + cert, key, +GNUTLS_X509_FMT_PEM , + password, +0 ); +#else /* GNUTLS_VERSION_NUMBER < 0x030111 */ +if (creds->passwordid) { +error_setg (errp,"PKCS8 decryption requires GNUTLS >= 3.1.11" ); + goto cleanup; + } ret =gnutls_certificate_set_x509_key_file (creds->data, cert, key,GNUTLS_X509_FMT_PEM ); +#endif /* GNUTLS_VERSION_NUMBER < 0x030111 */ if (ret <0 ) {error_setg (errp,"Cannot load certificate '%s' & key '%s': %s" , cert, key,gnutls_strerror (ret));
@@ -736,6 +757,27 @@ qcrypto_tls_creds_x509_prop_set_sanity(Object *obj, } +static void +qcrypto_tls_creds_x509_prop_set_passwordid (Object *obj, +const char *value, + Error **errp G_GNUC_UNUSED) +{ +QCryptoTLSCredsX509 *creds =QCRYPTO_TLS_CREDS_X509 (obj); + + creds->passwordid =g_strdup (value); +} + + +static char * +qcrypto_tls_creds_x509_prop_get_passwordid (Object *obj, + Error **errp G_GNUC_UNUSED) +{ +QCryptoTLSCredsX509 *creds =QCRYPTO_TLS_CREDS_X509 (obj); + +return g_strdup (creds->passwordid); +} + +static bool qcrypto_tls_creds_x509_prop_get_sanity (Object *obj, Error **errp G_GNUC_UNUSED)
@@ -768,6 +810,10 @@ qcrypto_tls_creds_x509_init(Object *obj) qcrypto_tls_creds_x509_prop_get_sanity, qcrypto_tls_creds_x509_prop_set_sanity, NULL); +object_property_add_str (obj,"passwordid" , + qcrypto_tls_creds_x509_prop_get_passwordid, + qcrypto_tls_creds_x509_prop_set_passwordid, +NULL ); }
@@ -776,6 +822,7 @@ qcrypto_tls_creds_x509_finalize(Object *obj) {QCryptoTLSCredsX509 *creds =QCRYPTO_TLS_CREDS_X509 (obj); +g_free (creds->passwordid);qcrypto_tls_creds_x509_unload (creds); }
include/crypto/tlscredsx509.h +1 -0
@@ -101,6 +101,7 @@ struct QCryptoTLSCredsX509 {gnutls_certificate_credentials_t data;#endif bool sanityCheck; +char *passwordid; };
qemu-options.hx +7 -1
@@ -3626,7 +3626,7 @@ expensive operation that consumes random pool entropy, so it is recommended that a persistent set of parameters be generated upfront and saved. -@item -object tls-creds-x509,id=@var{id},endpoint=@var{endpoint},dir=@var{/path/to/cred/dir},verify-peer=@var{on|off} +@item -object tls-creds-x509,id=@var{id},endpoint=@var{endpoint},dir=@var{/path/to/cred/dir},verify-peer=@var{on|off},passwordid=@var{id} Creates a TLS anonymous credentials object, which can be used to provide TLS support on network backends. The @option{id} parameter is a unique
@@ -3653,6 +3653,12 @@ in PEM format, in filenames @var{ca-cert.pem}, @var{ca-crl.pem} (optional), @var{server-cert.pem} (only servers), @var{server-key.pem} (only servers), @var{client-cert.pem} (only clients), and @var{client-key.pem} (only clients). +For the @var{server-key.pem} and @var{client-key.pem} files which +contain sensitive private keys, it is possible to use an encrypted +version by providing the @var{passwordid} parameter. This provides +the ID of a previously created @code{secret} object containing the +password for decryption. + @item -object filter-buffer,id=@var{id},netdev=@var{netdevid},interval=@var{t}[,queue=@var{all|rx|tx}] Interval @var{t} can't be 0, this filter batches the packet delivery: all
Signature · 1 line
2.5.0
PATCH 3/30 qcow: add a 'keyid' parameter to qcow options
In reply to Daniel P. BerrangeAdd a 'keyid' parameter that refers to the ID of a QCryptoSecret instance that provides the encryption key. eg
$QEMU \
-object secret,id=sec0,filename=/home/berrange/encrypted.pw \
-drive file=/home/berrange/encrypted.qcow,keyid=sec0--- block/qcow.c | 94 +++++++++++++++++++++++++++++++++++++++------------- qapi/block-core.json | 17 +++++++++- 2 files changed, 87 insertions(+), 24 deletions(-)
block/qcow.c +71 -23
@@ -27,6 +27,7 @@#include <zlib.h> #include "qapi/qmp/qerror.h" #include "crypto/cipher.h" +#include "crypto/secret.h" #include "migration/migration.h" /**************************************************************/
@@ -40,6 +41,8 @@#define QCOW_OFLAG_COMPRESSED (1LL << 63) +#define QCOW_OPT_KEY_ID "keyid" + typedef struct QCowHeader { uint32_t magic; uint32_t version;
@@ -92,6 +95,43 @@ static int qcow_probe(const uint8_t *buf, int buf_size, const char *filename)return 0 ; } +static QCryptoCipher *qcow_get_cipher_from_key (const char *key, +Error **errp) +{ +uint8_t keybuf[16 ]; +int len, i; + +memset (keybuf,0 ,16 ); + len =strlen (key); +if (len >16 ) { + len =16 ; + } +/* XXX: we could compress the chars to 7 bits to increase +entropy */ +for (i =0 ; i < len; i++) { + keybuf[i] = key[i]; + } + +return qcrypto_cipher_new ( +QCRYPTO_CIPHER_ALG_AES_128 , +QCRYPTO_CIPHER_MODE_CBC , + keybuf,G_N_ELEMENTS (keybuf), + errp); +} + +static QemuOptsList qcow_runtime_opts = { + .name ="qcow" , + .head =QTAILQ_HEAD_INITIALIZER (qcow_runtime_opts.head), + .desc = { + { + .name =QCOW_OPT_KEY_ID , + .type =QEMU_OPT_STRING , + .help ="ID of the secret that provides the encryption key" , + }, + {/* end of list */ } + }, +}; +static int qcow_open (BlockDriverState *bs,QDict *options,int flags,Error **errp) {
@@ -99,6 +139,10 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,unsigned int len, i, shift;int ret;QCowHeader header; +QemuOpts *opts =NULL ; +const char *keyid; +char *key; +Error *local_err =NULL ; ret =bdrv_pread (bs->file->bs,0 , &header,sizeof (header));if (ret <0 ) {
@@ -147,6 +191,32 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } + opts =qemu_opts_create (&qcow_runtime_opts,NULL ,0 , &error_abort); +qemu_opts_absorb_qdict (opts, options, &local_err); +if (local_err) { +error_propagate (errp, local_err); + ret = -EINVAL ; + goto fail; + } + + keyid =qemu_opt_get (opts,QCOW_OPT_KEY_ID ); +if (keyid) { + key =qcrypto_secret_lookup_as_utf8 (keyid, + errp); +if (!key) { + ret = -ENOENT ; + goto fail; + } + + s->cipher =qcow_get_cipher_from_key (key, + errp); +g_free (key); +if (!s->cipher) { + ret = -ENOSYS ; + goto fail; + } + } +if (header.crypt_method >QCOW_CRYPT_AES ) {error_setg (errp,"invalid encryption method in qcow header" ); ret = -EINVAL ;
@@ -261,33 +331,11 @@ static int qcow_reopen_prepare(BDRVReopenState *state,static int qcow_set_key (BlockDriverState *bs,const char *key) {BDRVQcowState *s = bs->opaque; -uint8_t keybuf[16 ]; -int len, i; -Error *err; -memset (keybuf,0 ,16 ); - len =strlen (key); -if (len >16 ) - len =16 ; -/* XXX: we could compress the chars to 7 bits to increase -entropy */ -for (i =0 ;i < len;i++) { - keybuf[i] = key[i]; - }assert (bs->encrypted); -qcrypto_cipher_free (s->cipher); - s->cipher =qcrypto_cipher_new ( -QCRYPTO_CIPHER_ALG_AES_128 , -QCRYPTO_CIPHER_MODE_CBC , - keybuf,G_N_ELEMENTS (keybuf), - &err); - + s->cipher =qcow_get_cipher_from_key (key,NULL );if (!s->cipher) { -/* XXX would be nice if errors in this method could -* be properly propagate to the caller. Would need -* the bdrv_set_key() API signature to be fixed. */ -error_free (err);return -1 ; }return 0 ;
qapi/block-core.json +16 -1
@@ -1693,6 +1693,21 @@ 'mode': 'Qcow2OverlapCheckMode' } } ## +# @BlockdevOptionsQcow +# +# Driver specific block device options for qcow. +# +# @keyid: #optional ID of the "secret" object providing the +# AES decryption key. +# +# Since: 2.5 +## +{ 'struct': 'BlockdevOptionsQcow', + 'base': 'BlockdevOptionsGenericCOWFormat', + 'data': { '*keyid': 'str' } } + + +## # @BlockdevOptionsQcow2 # # Driver specific block device options for qcow2.
@@ -1956,7 +1971,7 @@ 'null-co': 'BlockdevOptionsNull', 'parallels': 'BlockdevOptionsGenericFormat', 'qcow2': 'BlockdevOptionsQcow2', - 'qcow': 'BlockdevOptionsGenericCOWFormat', + 'qcow': 'BlockdevOptionsQcow', 'qed': 'BlockdevOptionsGenericCOWFormat', 'quorum': 'BlockdevOptionsQuorum', 'raw': 'BlockdevOptionsGenericFormat',
Signature · 1 line
2.5.0
PATCH 4/30 qcow2: add a 'keyid' parameter to qcow2 options
In reply to Daniel P. BerrangeAdd a 'keyid' parameter that refers to the ID of a QCryptoSecret instance that provides the encryption key.
$QEMU \
-object secret,id=sec0,filename=/home/berrange/encrypted.pw \
-drive file=/home/berrange/encrypted.qcow2,keyid=sec0--- block/qcow2.c | 80 +++++++++++++++++++++++++++++++++++++--------------- block/qcow2.h | 1 + qapi/block-core.json | 8 ++++-- 3 files changed, 64 insertions(+), 25 deletions(-)
block/qcow2.c +57 -23
@@ -34,6 +34,7 @@#include "qapi-event.h" #include "trace.h" #include "qemu/option_int.h" +#include "crypto/secret.h" /* Differences with QCOW:
@@ -472,6 +473,11 @@ static QemuOptsList qcow2_runtime_opts = { .type = QEMU_OPT_NUMBER, .help = "Clean unused cache entries after this time (in seconds)", }, + { + .name = QCOW2_OPT_KEY_ID, + .type = QEMU_OPT_STRING, + .help = "ID of the secret that provides the encryption key", + }, {/* end of list */ } }, };
@@ -589,6 +595,31 @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts, } } +static QCryptoCipher *qcow2_get_cipher_from_key (const char *key, +Error **errp) +{ +uint8_t keybuf[16 ]; +int len, i; + +memset (keybuf,0 ,16 ); + len =strlen (key); +if (len >16 ) { + len =16 ; + } +/* XXX: we could compress the chars to 7 bits to increase +entropy */ +for (i =0 ; i < len; i++) { + keybuf[i] = key[i]; + } + +return qcrypto_cipher_new ( +QCRYPTO_CIPHER_ALG_AES_128 , +QCRYPTO_CIPHER_MODE_CBC , + keybuf,G_N_ELEMENTS (keybuf), + errp); +} + + typedef struct Qcow2ReopenState { Qcow2Cache *l2_table_cache; Qcow2Cache *refcount_block_cache;
@@ -596,6 +627,7 @@ typedef struct Qcow2ReopenState {int overlap_check;bool discard_passthrough[QCOW2_DISCARD_MAX ];uint64_t cache_clean_interval; +QCryptoCipher *cipher; } Qcow2ReopenState; static int qcow2_update_options_prepare(BlockDriverState *bs,
@@ -611,6 +643,8 @@ static int qcow2_update_options_prepare(BlockDriverState *bs,int i;Error *local_err =NULL ;int ret; +const char *keyid; +char *key; opts =qemu_opts_create (&qcow2_runtime_opts,NULL ,0 , &error_abort);qemu_opts_absorb_qdict (opts, options, &local_err);
@@ -754,6 +788,24 @@ static int qcow2_update_options_prepare(BlockDriverState *bs, r->discard_passthrough[QCOW2_DISCARD_OTHER ] =qemu_opt_get_bool (opts,QCOW2_OPT_DISCARD_OTHER , false); + keyid =qemu_opt_get (opts,QCOW2_OPT_KEY_ID ); +if (keyid) { + key =qcrypto_secret_lookup_as_utf8 (keyid, + errp); +if (!key) { + ret = -ENOENT ; + goto fail; + } + + r->cipher =qcow2_get_cipher_from_key (key, + errp); +g_free (key); +if (!r->cipher) { + ret = -ENOSYS ; + goto fail; + } + } + ret =0 ; fail:qemu_opts_del (opts);
@@ -788,6 +840,9 @@ static void qcow2_update_options_commit(BlockDriverState *bs, s->cache_clean_interval = r->cache_clean_interval;cache_clean_timer_init (bs,bdrv_get_aio_context (bs)); } + +qcrypto_cipher_free (s->cipher); + s->cipher = r->cipher; } static void qcow2_update_options_abort(BlockDriverState *bs,
@@ -799,6 +854,7 @@ static void qcow2_update_options_abort(BlockDriverState *bs,if (r->refcount_block_cache) {qcow2_cache_destroy (bs, r->refcount_block_cache); } +qcrypto_cipher_free (r->cipher); } static int qcow2_update_options(BlockDriverState *bs, QDict *options,
@@ -1202,33 +1258,11 @@ static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)static int qcow2_set_key (BlockDriverState *bs,const char *key) {BDRVQcow2State *s = bs->opaque; -uint8_t keybuf[16 ]; -int len, i; -Error *err =NULL ; -memset (keybuf,0 ,16 ); - len =strlen (key); -if (len >16 ) - len =16 ; -/* XXX: we could compress the chars to 7 bits to increase -entropy */ -for (i =0 ;i < len;i++) { - keybuf[i] = key[i]; - }assert (bs->encrypted); -qcrypto_cipher_free (s->cipher); - s->cipher =qcrypto_cipher_new ( -QCRYPTO_CIPHER_ALG_AES_128 , -QCRYPTO_CIPHER_MODE_CBC , - keybuf,G_N_ELEMENTS (keybuf), - &err); - + s->cipher =qcow2_get_cipher_from_key (key,NULL );if (!s->cipher) { -/* XXX would be nice if errors in this method could -* be properly propagate to the caller. Would need -* the bdrv_set_key() API signature to be fixed. */ -error_free (err);return -1 ; }return 0 ;
block/qcow2.h +1 -0
@@ -97,6 +97,7 @@#define QCOW2_OPT_L2_CACHE_SIZE "l2-cache-size"#define QCOW2_OPT_REFCOUNT_CACHE_SIZE "refcount-cache-size"#define QCOW2_OPT_CACHE_CLEAN_INTERVAL "cache-clean-interval" +#define QCOW2_OPT_KEY_ID "keyid" typedef struct QCowHeader { uint32_t magic;
qapi/block-core.json +6 -2
@@ -1698,7 +1698,7 @@ # Driver specific block device options for qcow. # # @keyid: #optional ID of the "secret" object providing the -# AES decryption key. +# AES decryption key (since 2.5) # # Since: 2.5 ##
@@ -1742,6 +1742,9 @@ # caches. The interval is in seconds. The default value # is 0 and it disables this feature (since 2.5) # +# @keyid: #optional ID of the "secret" object providing the +# AES decryption key. +# # Since: 1.7 ## { 'struct': 'BlockdevOptionsQcow2',
@@ -1754,7 +1757,8 @@ '*cache-size': 'int', '*l2-cache-size': 'int', '*refcount-cache-size': 'int', - '*cache-clean-interval': 'int' } } + '*cache-clean-interval': 'int', + '*keyid': 'str' } } ##
Signature · 1 line
2.5.0
Re: [Qemu-devel] [PATCH WIP 04/30] qcow2: add a 'keyid' parameter to qcow2 options
Quoted 16 lines · Daniel P. Berrange
Add a 'keyid' parameter that refers to the ID of a QCryptoSecret instance that provides the encryption key.
$QEMU \ -object secret,id=sec0,filename=/home/berrange/encrypted.pw \ -drive file=/home/berrange/encrypted.qcow2,keyid=sec0Signed-off-by Daniel P. Berrange <[email protected]>--- block/qcow2.c | 80 +++++++++++++++++++++++++++++++++++++--------------- block/qcow2.h | 1 + qapi/block-core.json | 8 ++++-- 3 files changed, 64 insertions(+), 25 deletions(-)+++
b/qapi/block-core.json
qapi/block-core.json line 1703
Quoted 7 lines
qapi/block-core.json +1
-1@@ -1698,7 +1698,7 @@ # Driver specific block device options for qcow. # # @keyid: #optional ID of the "secret" object providing the -# AES decryption key. +# AES decryption key (since 2.5) # # Since: 2.5
I already pointed this out on the previous post, but this hunk is wrong (since the entire BlockdevOptionsQcow struct is new); it instead belongs...
qapi/block-core.json line 1746
Quoted 7 lines
qapi/block-core.json +2
-0##@@ -1742,6 +1742,9 @@ # caches. The interval is in seconds. The default value # is 0 and it disables this feature (since 2.5) # +# @keyid: #optional ID of the "secret" object providing the +# AES decryption key.
...here as part of BlockdevOptionsQcow2. Also, I wonder if inheriting from BlockdevOptionsQcow is any easier here than just declaring keyid directly.
Quoted 15 lines
qapi/block-core.json +3
-1+# # Since: 1.7 ## { 'struct': 'BlockdevOptionsQcow2',@@ -1754,7 +1757,8 @@ '*cache-size': 'int', '*l2-cache-size': 'int', '*refcount-cache-size': 'int', - '*cache-clean-interval': 'int' } } + '*cache-clean-interval': 'int', + '*keyid': 'str' } } ##
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH WIP 04/30] qcow2: add a 'keyid' parameter to qcow2 options
Quoted 28 lines · Eric Blake
Quoted 16 lines · Daniel P. Berrange
Add a 'keyid' parameter that refers to the ID of a QCryptoSecret instance that provides the encryption key.
$QEMU \ -object secret,id=sec0,filename=/home/berrange/encrypted.pw \ -drive file=/home/berrange/encrypted.qcow2,keyid=sec0Signed-off-by Daniel P. Berrange <[email protected]>--- block/qcow2.c | 80 +++++++++++++++++++++++++++++++++++++--------------- block/qcow2.h | 1 + qapi/block-core.json | 8 ++++-- 3 files changed, 64 insertions(+), 25 deletions(-)+++
b/qapi/block-core.jsonqapi/block-core.json line 1703
Quoted 7 lines
qapi/block-core.json +1
-1@@ -1698,7 +1698,7 @@ # Driver specific block device options for qcow. # # @keyid: #optional ID of the "secret" object providing the -# AES decryption key. +# AES decryption key (since 2.5) # # Since: 2.5I already pointed this out on the previous post, but this hunk is wrong (since the entire BlockdevOptionsQcow struct is new); it instead belongs...
Quoted 11 lines
qapi/block-core.json line 1746
Quoted 7 lines
qapi/block-core.json +2
-0##@@ -1742,6 +1742,9 @@ # caches. The interval is in seconds. The default value # is 0 and it disables this feature (since 2.5) # +# @keyid: #optional ID of the "secret" object providing the +# AES decryption key....here as part of BlockdevOptionsQcow2. Also, I wonder if inheriting from BlockdevOptionsQcow is any easier here than just declaring keyid directly.
When I fully integrate LUKS support in qcow2, there will be several more parameters added to this struct, which I won't be adding to qcow, since I don't fancy doing any work on qcow code to improve its encryption, since its essentially obsolte. So on this basis, I don't think inheriting BlockdevOptionsQcow will have tangible benefit.
Regards,
Daniel
Signature · 4 lines
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
PATCH 5/30 qom: add user_creatable_add & user_creatable_del methods
In reply to Daniel P. BerrangeThe QMP monitor code has two helper methods object_add and qmp_object_del that are called from several places in the code (QMP, HMP and main emulator startup).
We soon need to use this code from qemu-img, qemu-io and qemu-nbd too, but don't want those to depend on the monitor.
To avoid this, move object_add to user_creatable_add an qmp_object_del to user_creatable_del, in the object_interfaces.c file
--- hmp.c | 11 ++++-- include/monitor/monitor.h | 3 -- include/qom/object_interfaces.h | 31 +++++++++++++++++ qmp.c | 75 ++++------------------------------------ qom/object_interfaces.c | 76 +++++++++++++++++++++++++++++++++++++++++ vl.c | 8 +++-- 6 files changed, 127 insertions(+), 77 deletions(-)
hmp.c +8 -3
@@ -29,6 +29,7 @@#include "qapi/string-output-visitor.h" #include "qapi/util.h" #include "qapi-visit.h" +#include "qom/object_interfaces.h" #include "ui/console.h" #include "block/qapi.h" #include "qemu-io.h"
@@ -1662,6 +1663,7 @@ void hmp_object_add(Monitor *mon, const QDict *qdict)void *dummy =NULL ;OptsVisitor *ov;QDict *pdict; +Object *obj =NULL ; opts =qemu_opts_from_qdict (qemu_find_opts ("object" ), qdict, &err);if (err) {
@@ -1688,12 +1690,12 @@ void hmp_object_add(Monitor *mon, const QDict *qdict) goto out_end; } -object_add (type, id, pdict,opts_get_visitor (ov), &err); + obj =user_creatable_add (type, id, pdict,opts_get_visitor (ov), &err); out_end:visit_end_struct (opts_get_visitor (ov), &err_end);if (!err && err_end) { -qmp_object_del (id,NULL ); +user_creatable_del (id,NULL ); }error_propagate (&err, err_end); out_clean:
@@ -1704,6 +1706,9 @@ out_clean:g_free (id);g_free (type);g_free (dummy); +if (obj) { +object_unref (obj); + } out:hmp_handle_error (mon, &err);
@@ -1936,7 +1941,7 @@ void hmp_object_del(Monitor *mon, const QDict *qdict)const char *id =qdict_get_str (qdict,"id" );Error *err =NULL ; -qmp_object_del (id, &err); +user_creatable_del (id, &err);hmp_handle_error (mon, &err); }
include/monitor/monitor.h +0 -3
@@ -43,9 +43,6 @@ void monitor_read_command(Monitor *mon, int show_prompt);int monitor_read_password (Monitor *mon,ReadLineFunc *readline_func,void *opaque); -void object_add (const char *type,const char *id,const QDict *qdict, -Visitor *v,Error **errp); -AddfdInfo *monitor_fdset_add_fd (int fd,bool has_fdset_id,int64_t fdset_id,bool has_opaque,const char *opaque,Error **errp);
include/qom/object_interfaces.h +31 -0
@@ -2,6 +2,8 @@#define OBJECT_INTERFACES_H #include "qom/object.h" +#include "qapi/qmp/qdict.h" +#include "qapi/visitor.h" #define TYPE_USER_CREATABLE "user-creatable"
@@ -72,4 +74,33 @@ void user_creatable_complete(Object *obj, Error **errp);* from implements USER_CREATABLE interface. */ bool user_creatable_can_be_deleted (UserCreatable *uc,Error **errp); + +/** +* user_creatable_add: +* @type: the object type name +* @id: the unique ID for the object +* @qdict: the object parameters +* @v: the visitor +* @errp: if an error occurs, a pointer to an area to store the error +* +* Create an instance of the user creatable object @type, placing +* it in the object composition tree with name @id, initializing +* it with properties from @qdict +* +* Returns: the newly created object or NULL on error +*/ +Object *user_creatable_add (const char *type,const char *id, +const QDict *qdict, +Visitor *v,Error **errp); + +/** +* user_creatable_del: +* @id: the unique ID for the object +* @errp: if an error occurs, a pointer to an area to store the error +* +* Delete an instance of the user creatable object identified +* by @id. +*/ +void user_creatable_del (const char *id,Error **errp); +#endif
qmp.c +6 -69
98 lines not on this page · raw message
qom/object_interfaces.c +76 -0
82 lines not on this page · raw message
vl.c +6 -2
@@ -2831,6 +2831,7 @@ static int object_create(void *opaque, QemuOpts *opts, Error **errp)OptsVisitor *ov;QDict *pdict;bool (*type_predicate)(const char *) = opaque; +Object *obj =NULL ; ov =opts_visitor_new (opts); pdict =qemu_opts_to_qdict (opts,NULL );
@@ -2855,13 +2856,13 @@ static int object_create(void *opaque, QemuOpts *opts, Error **errp) goto out; } -object_add (type, id, pdict,opts_get_visitor (ov), &err); + obj =user_creatable_add (type, id, pdict,opts_get_visitor (ov), &err);if (err) { goto out; }visit_end_struct (opts_get_visitor (ov), &err);if (err) { -qmp_object_del (id,NULL ); +user_creatable_del (id,NULL ); } out:
@@ -2871,6 +2872,9 @@ out:g_free (id);g_free (type);g_free (dummy); +if (obj) { +object_unref (obj); + }if (err) {error_report_err (err);return -1 ;
Signature · 1 line
2.5.0
PATCH 6/30 qemu-img: add support for --object command line arg
In reply to Daniel P. BerrangeAllow creation of user creatable object types with qemu-img via a --object command line arg. This will be used to supply passwords and/or encryption keys to the various block driver backends via the recently added 'secret' object type.
# echo -n letmein > mypasswd.txt
# qemu-img info --object secret,id=sec0,file=mypasswd.txt \
...other info args...--- qemu-img-cmds.hx | 44 ++++---- qemu-img.c | 300 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- qemu-img.texi | 8 ++ 3 files changed, 322 insertions(+), 30 deletions(-)
qemu-img-cmds.hx +22 -22
@@ -10,68 +10,68 @@ STEXI ETEXI DEF("check", img_check, - "check [-q] [-f fmt] [--output=ofmt] [-r [leaks | all]] [-T src_cache] filename") + "check [-q] [--object objectdef] [-f fmt] [--output=ofmt] [-r [leaks | all]] [-T src_cache] filename") STEXI -@item check [-q] [-f @var{fmt}] [--output=@var{ofmt}] [-r [leaks | all]] [-T @var{src_cache}] @var{filename} +@item check [--object objectdef] [-q] [-f @var{fmt}] [--output=@var{ofmt}] [-r [leaks | all]] [-T @var{src_cache}] @var{filename} ETEXI DEF("create", img_create, - "create [-q] [-f fmt] [-o options] filename [size]") + "create [-q] [--object objectdef] [-f fmt] [-o options] filename [size]") STEXI -@item create [-q] [-f @var{fmt}] [-o @var{options}] @var{filename} [@var{size}] +@item create [--object objectdef] [-q] [-f @var{fmt}] [-o @var{options}] @var{filename} [@var{size}] ETEXI DEF("commit", img_commit, - "commit [-q] [-f fmt] [-t cache] [-b base] [-d] [-p] filename") + "commit [-q] [--object objectdef] [-f fmt] [-t cache] [-b base] [-d] [-p] filename") STEXI -@item commit [-q] [-f @var{fmt}] [-t @var{cache}] [-b @var{base}] [-d] [-p] @var{filename} +@item commit [--object objectdef] [-q] [-f @var{fmt}] [-t @var{cache}] [-b @var{base}] [-d] [-p] @var{filename} ETEXI DEF("compare", img_compare, - "compare [-f fmt] [-F fmt] [-T src_cache] [-p] [-q] [-s] filename1 filename2") + "compare [--object objectdef] [-f fmt] [-F fmt] [-T src_cache] [-p] [-q] [-s] filename1 filename2") STEXI -@item compare [-f @var{fmt}] [-F @var{fmt}] [-T @var{src_cache}] [-p] [-q] [-s] @var{filename1} @var{filename2} +@item compare [--object objectdef] [-f @var{fmt}] [-F @var{fmt}] [-T @var{src_cache}] [-p] [-q] [-s] @var{filename1} @var{filename2} ETEXI DEF("convert", img_convert, - "convert [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-o options] [-s snapshot_id_or_name] [-l snapshot_param] [-S sparse_size] filename [filename2 [...]] output_filename") + "convert [--object objectdef] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-o options] [-s snapshot_id_or_name] [-l snapshot_param] [-S sparse_size] filename [filename2 [...]] output_filename") STEXI -@item convert [-c] [-p] [-q] [-n] [-f @var{fmt}] [-t @var{cache}] [-T @var{src_cache}] [-O @var{output_fmt}] [-o @var{options}] [-s @var{snapshot_id_or_name}] [-l @var{snapshot_param}] [-S @var{sparse_size}] @var{filename} [@var{filename2} [...]] @var{output_filename} +@item convert [--object objectdef] [-c] [-p] [-q] [-n] [-f @var{fmt}] [-t @var{cache}] [-T @var{src_cache}] [-O @var{output_fmt}] [-o @var{options}] [-s @var{snapshot_id_or_name}] [-l @var{snapshot_param}] [-S @var{sparse_size}] @var{filename} [@var{filename2} [...]] @var{output_filename} ETEXI DEF("info", img_info, - "info [-f fmt] [--output=ofmt] [--backing-chain] filename") + "info [--object objectdef] [-f fmt] [--output=ofmt] [--backing-chain] filename") STEXI -@item info [-f @var{fmt}] [--output=@var{ofmt}] [--backing-chain] @var{filename} +@item info [--object objectdef] [-f @var{fmt}] [--output=@var{ofmt}] [--backing-chain] @var{filename} ETEXI DEF("map", img_map, - "map [-f fmt] [--output=ofmt] filename") + "map [--object objectdef] [-f fmt] [--output=ofmt] filename") STEXI -@item map [-f @var{fmt}] [--output=@var{ofmt}] @var{filename} +@item map [--object objectdef] [-f @var{fmt}] [--output=@var{ofmt}] @var{filename} ETEXI DEF("snapshot", img_snapshot, - "snapshot [-q] [-l | -a snapshot | -c snapshot | -d snapshot] filename") + "snapshot [--object objectdef] [-q] [-l | -a snapshot | -c snapshot | -d snapshot] filename") STEXI -@item snapshot [-q] [-l | -a @var{snapshot} | -c @var{snapshot} | -d @var{snapshot}] @var{filename} +@item snapshot [--object objectdef] [-q] [-l | -a @var{snapshot} | -c @var{snapshot} | -d @var{snapshot}] @var{filename} ETEXI DEF("rebase", img_rebase, - "rebase [-q] [-f fmt] [-t cache] [-T src_cache] [-p] [-u] -b backing_file [-F backing_fmt] filename") + "rebase [--object objectdef] [-q] [-f fmt] [-t cache] [-T src_cache] [-p] [-u] -b backing_file [-F backing_fmt] filename") STEXI -@item rebase [-q] [-f @var{fmt}] [-t @var{cache}] [-T @var{src_cache}] [-p] [-u] -b @var{backing_file} [-F @var{backing_fmt}] @var{filename} +@item rebase [--object objectdef] [-q] [-f @var{fmt}] [-t @var{cache}] [-T @var{src_cache}] [-p] [-u] -b @var{backing_file} [-F @var{backing_fmt}] @var{filename} ETEXI DEF("resize", img_resize, - "resize [-q] filename [+ | -]size") + "resize [--object objectdef] [-q] filename [+ | -]size") STEXI -@item resize [-q] @var{filename} [+ | -]@var{size} +@item resize [--object objectdef] [-q] @var{filename} [+ | -]@var{size} ETEXI DEF("amend", img_amend, - "amend [-p] [-q] [-f fmt] [-t cache] -o options filename") + "amend [--object objectdef] [-p] [-q] [-f fmt] [-t cache] -o options filename") STEXI -@item amend [-p] [-q] [-f @var{fmt}] [-t @var{cache}] -o @var{options} @var{filename} +@item amend [--object objectdef] [-p] [-q] [-f @var{fmt}] [-t @var{cache}] -o @var{options} @var{filename} @end table ETEXI
qemu-img.c +292 -8
575 lines not on this page · raw message
qemu-img.texi +8 -0
@@ -24,6 +24,14 @@ Command parameters: @table @var @item filename is a disk image filename + +@item objectdef + +is a QEMU user creatable object definition. See the @code{qemu(1)} manual +page for a description of the object properties. The only object type that +it makes sense to define is the @code{secret} object, which is used to +supply passwords and/or encryption keys. + @item fmt is the disk image format. It is guessed automatically in most cases. See below for a description of the supported disk formats.
Signature · 1 line
2.5.0
PATCH 7/30 qemu-nbd: add support for --object command line arg
In reply to Daniel P. BerrangeAllow creation of user creatable object types with qemu-nbd via a --object command line arg. This will be used to supply passwords and/or encryption keys to the various block driver backends via the recently added 'secret' object type.
# echo -n letmein > mypasswd.txt
# qemu-nbd --object secret,id=sec0,file=mypasswd.txt \
...other nbd args...--- qemu-nbd.c | 85 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ qemu-nbd.texi | 7 +++++ 2 files changed, 92 insertions(+)
qemu-nbd.c +85 -0
@@ -23,9 +23,12 @@#include "qemu/main-loop.h" #include "qemu/sockets.h" #include "qemu/error-report.h" +#include "qemu/config-file.h" #include "block/snapshot.h" #include "qapi/util.h" #include "qapi/qmp/qstring.h" +#include "qapi/opts-visitor.h" +#include "qom/object_interfaces.h" #include <stdarg.h> #include <stdio.h>
@@ -45,6 +48,7 @@#define QEMU_NBD_OPT_AIO 2#define QEMU_NBD_OPT_DISCARD 3#define QEMU_NBD_OPT_DETECT_ZEROES 4 +#define QEMU_NBD_OPT_OBJECT 5static NBDExport *exp;static int verbose;
@@ -78,6 +82,9 @@ static void usage(const char *name)" -o, --offset=OFFSET offset into the image\n" " -P, --partition=NUM only expose partition NUM\n" "\n" +"General purpose options:\n" +" --object type,id=ID,... define an object such as 'secret' for providing\n" +" passwords and/or encryption keys\n" #ifdef __linux__"Kernel NBD client support:\n" " -c, --connect=DEV connect FILE to the local NBD device DEV\n"
@@ -380,6 +387,67 @@ static SocketAddress *nbd_build_socket_address(const char *sockpath, } +static QemuOptsList qemu_object_opts = { + .name ="object" , + .implied_opt_name ="qom-type" , + .head =QTAILQ_HEAD_INITIALIZER (qemu_object_opts.head), + .desc = { + { } + }, +}; + +static int object_create (void *opaque,QemuOpts *opts,Error **errp) +{ +Error *err =NULL ; +char *type =NULL ; +char *id =NULL ; +void *dummy =NULL ; +OptsVisitor *ov; +QDict *pdict; + + ov =opts_visitor_new (opts); + pdict =qemu_opts_to_qdict (opts,NULL ); + +visit_start_struct (opts_get_visitor (ov), &dummy,NULL ,NULL ,0 , &err); +if (err) { + goto out; + } + +qdict_del (pdict,"qom-type" ); +visit_type_str (opts_get_visitor (ov), &type,"qom-type" , &err); +if (err) { + goto out; + } + +qdict_del (pdict,"id" ); +visit_type_str (opts_get_visitor (ov), &id,"id" , &err); +if (err) { + goto out; + } + +user_creatable_add (type, id, pdict,opts_get_visitor (ov), &err); +if (err) { + goto out; + } +visit_end_struct (opts_get_visitor (ov), &err); +if (err) { +user_creatable_del (id,NULL ); + } + +out: +opts_visitor_cleanup (ov); + +QDECREF (pdict); +g_free (id); +g_free (type); +g_free (dummy); +if (err) { +error_report_err (err); +return -1 ; + } +return 0 ; +} +int main (int argc,char **argv) {BlockBackend *blk;
@@ -417,6 +485,7 @@ int main(int argc, char **argv) { "format", 1, NULL, 'f' }, { "persistent", 0, NULL, 't' }, { "verbose", 0, NULL, 'v' }, + { "object", 1, NULL, QEMU_NBD_OPT_OBJECT }, { NULL, 0, NULL, 0 } };int ch;
@@ -434,6 +503,7 @@ int main(int argc, char **argv)Error *local_err =NULL ;BlockdevDetectZeroesOptions detect_zeroes =BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF ;QDict *options =NULL ; +QemuOpts *opts;/* The client thread uses SIGTERM to interrupt the server. A signal * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
@@ -442,6 +512,8 @@ int main(int argc, char **argv)memset (&sa_sigterm,0 ,sizeof (sa_sigterm)); sa_sigterm.sa_handler = termsig_handler;sigaction (SIGTERM , &sa_sigterm,NULL ); +module_call_init (MODULE_INIT_QOM ); +qemu_add_opts (&qemu_object_opts);qemu_init_exec_dir (argv[0 ]);while ((ch =getopt_long (argc, argv, sopt, lopt, &opt_ind)) !=-1 ) {
@@ -578,6 +650,13 @@ int main(int argc, char **argv)usage (argv[0 ]);exit (0 );break ; +case QEMU_NBD_OPT_OBJECT : + opts =qemu_opts_parse_noisily (qemu_find_opts ("object" ), + optarg, true); +if (!opts) { +exit (1 ); + } +break ;case '?' :errx (EXIT_FAILURE ,"Try `%s --help' for more information." , argv[0 ]);
@@ -590,6 +669,12 @@ int main(int argc, char **argv) argv[0]); } +if (qemu_opts_foreach (qemu_find_opts ("object" ), + object_create, +NULL ,NULL )) { +exit (1 ); + } +if (disconnect) { fd =open (argv[optind],O_RDWR );if (fd <0 ) {
qemu-nbd.texi +7 -0
@@ -14,6 +14,13 @@ Export QEMU disk image using NBD protocol. @table @option @item @var{filename} is a disk image filename +@item --object type,id=@var{id},...props... + define a new instance of the @var{type} object class + identified by @var{id}. See the @code{qemu(1)} manual + page for full details of the properties supported. + The only object type that it makes sense to define + is the @code{secret} object, which is used to supply + passwords and/or encryption keys. @item -p, --port=@var{port} port to listen on (default @samp{10809}) @item -o, --offset=@var{offset}
Signature · 1 line
2.5.0
PATCH 8/30 qemu-io: add support for --object command line arg
In reply to Daniel P. BerrangeAllow creation of user creatable object types with qemu-io via a --object command line arg. This will be used to supply passwords and/or encryption keys to the various block driver backends via the recently added 'secret' object type.
# echo -n letmein > mypasswd.txt
# qemu-io --object secret,id=sec0,file=mypasswd.txt \
...other args...--- qemu-io.c | 87 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+)
qemu-io.c +87 -0
@@ -21,6 +21,8 @@#include "qemu/config-file.h" #include "qemu/readline.h" #include "qapi/qmp/qstring.h" +#include "qapi/opts-visitor.h" +#include "qom/object_interfaces.h" #include "sysemu/block-backend.h" #include "block/block_int.h" #include "trace/control.h"
@@ -205,6 +207,9 @@ static void usage(const char *name)"Usage: %s [-h] [-V] [-rsnm] [-f FMT] [-c STRING] ... [file]\n" "QEMU Disk exerciser\n" "\n" +" --object OBJECTDEF define a object such as 'secret' for\n" +" providing passwords and/or encryption\n" +" keys\n" " -c, --cmd STRING execute command with its arguments\n" " from the given string\n" " -f, --format FMT specifies the block driver to use\n"
@@ -366,6 +371,71 @@ static void reenable_tty_echo(void)qemu_set_tty_echo (STDIN_FILENO , true); } +enum { +OPTION_OBJECT =258 , +}; + +static QemuOptsList qemu_object_opts = { + .name ="object" , + .implied_opt_name ="qom-type" , + .head =QTAILQ_HEAD_INITIALIZER (qemu_object_opts.head), + .desc = { + { } + }, +}; + +static int object_create (void *opaque,QemuOpts *opts,Error **errp) +{ +Error *err =NULL ; +char *type =NULL ; +char *id =NULL ; +void *dummy =NULL ; +OptsVisitor *ov; +QDict *pdict; + + ov =opts_visitor_new (opts); + pdict =qemu_opts_to_qdict (opts,NULL ); + +visit_start_struct (opts_get_visitor (ov), &dummy,NULL ,NULL ,0 , &err); +if (err) { + goto out; + } + +qdict_del (pdict,"qom-type" ); +visit_type_str (opts_get_visitor (ov), &type,"qom-type" , &err); +if (err) { + goto out; + } + +qdict_del (pdict,"id" ); +visit_type_str (opts_get_visitor (ov), &id,"id" , &err); +if (err) { + goto out; + } + +user_creatable_add (type, id, pdict,opts_get_visitor (ov), &err); +if (err) { + goto out; + } +visit_end_struct (opts_get_visitor (ov), &err); +if (err) { +user_creatable_del (id,NULL ); + } + +out: +opts_visitor_cleanup (ov); + +QDECREF (pdict); +g_free (id); +g_free (type); +g_free (dummy); +if (err) { +error_report_err (err); +return -1 ; + } +return 0 ; +} +int main (int argc,char **argv) {int readonly =0 ;
@@ -384,6 +454,7 @@ int main(int argc, char **argv) { "discard", 1, NULL, 'd' }, { "cache", 1, NULL, 't' }, { "trace", 1, NULL, 'T' }, + { "object", 1, NULL, OPTION_OBJECT }, { NULL, 0, NULL, 0 } };int c;
@@ -391,6 +462,7 @@ int main(int argc, char **argv)int flags =BDRV_O_UNMAP ;Error *local_error =NULL ;QDict *opts =NULL ; +QemuOpts *qopts =NULL ;#ifdef CONFIG_POSIX signal (SIGPIPE ,SIG_IGN );
@@ -399,6 +471,8 @@ int main(int argc, char **argv) progname =basename (argv[0 ]);qemu_init_exec_dir (argv[0 ]); +module_call_init (MODULE_INIT_QOM ); +qemu_add_opts (&qemu_object_opts);bdrv_init ();while ((c =getopt_long (argc, argv, sopt, lopt, &opt_index)) !=-1 ) {
@@ -450,6 +524,13 @@ int main(int argc, char **argv)case 'h' :usage (progname);exit (0 ); +case OPTION_OBJECT : + qopts =qemu_opts_parse_noisily (qemu_find_opts ("object" ), + optarg, true); +if (!qopts) { +exit (1 ); + } +break ;default :usage (progname);exit (1 );
@@ -466,6 +547,12 @@ int main(int argc, char **argv)exit (1 ); } +if (qemu_opts_foreach (qemu_find_opts ("object" ), + object_create, +NULL ,NULL )) { +exit (1 ); + } +/* initialize commands */ qemuio_add_command (&quit_cmd);qemuio_add_command (&open_cmd);
Signature · 1 line
2.5.0
PATCH 9/30 qemu-io: allow specifying image as a set of options args
In reply to Daniel P. BerrangeCurrently qemu-io allows an image filename to be passed on the command line, but does not have a way to set any options except the format eg
qemu-io https://127.0.0.1/images/centos7.iso
qemu-io /home/berrange/demo.qcow2
This adds a --source arg (that is mutually exclusive with a positional filename arg and -f arg) that accepts a full option string, as well as the original syntax eg
qemu-io --source driver=http,url=https://127.0.0.1/images,sslverify=off qemu-io --source https://127.0.0.1/images/centos7.iso
qemu-io --source file=/home/berrange/demo.qcow2
qemu-io --source /home/berrange/demo.qcow2
--- qemu-io.c | 37 ++++++++++++++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-)
qemu-io.c +36 -1
@@ -373,6 +373,7 @@ static void reenable_tty_echo(void)enum {OPTION_OBJECT =258 , +OPTION_SOURCE =259 , };static QemuOptsList qemu_object_opts = {
@@ -436,6 +437,16 @@ out:return 0 ; } +static QemuOptsList file_opts = { + .name ="file" , + .implied_opt_name ="file" , + .head =QTAILQ_HEAD_INITIALIZER (file_opts.head), + .desc = { +/* no elements => accept any params */ + {/* end of list */ } + }, +}; +int main (int argc,char **argv) {int readonly =0 ;
@@ -455,6 +466,7 @@ int main(int argc, char **argv) { "cache", 1, NULL, 't' }, { "trace", 1, NULL, 'T' }, { "object", 1, NULL, OPTION_OBJECT }, + { "source", 1, NULL, OPTION_SOURCE }, { NULL, 0, NULL, 0 } };int c;
@@ -531,6 +543,12 @@ int main(int argc, char **argv)exit (1 ); }break ; +case OPTION_SOURCE : +if (!qemu_opts_parse_noisily (&file_opts, optarg, false)) { +qemu_opts_reset (&file_opts); +return 0 ; + } +break ;default :usage (progname);exit (1 );
@@ -572,7 +590,24 @@ int main(int argc, char **argv) flags |=BDRV_O_RDWR ; } -if ((argc - optind) ==1 ) { + qopts =qemu_opts_find (&file_opts,NULL ); +if (qopts) { +char *file; +if (opts) { +error_report ("--source and -f are mutually exclusive" ); +exit (1 ); + } +if ((argc - optind) ==1 ) { +error_report ("--source and filename are mutually exclusive" ); +exit (1 ); + } + file =g_strdup (qemu_opt_get (qopts,"file" )); +qemu_opt_unset (qopts,"file" ); + opts =qemu_opts_to_qdict (qopts,NULL ); +qemu_opts_reset (&file_opts); +openfile (file, flags, opts); +g_free (file); + }else if ((argc - optind) ==1 ) {openfile (argv[optind], flags, opts); }command_loop ();
Signature · 1 line
2.5.0
PATCH 10/30 qemu-nbd: allow specifying image as a set of options args
In reply to Daniel P. BerrangeCurrently qemu-nbd allows an image filename to be passed on the command line, but does not have a way to set any options except the format eg
qemu-nbd https://127.0.0.1/images/centos7.iso
qemu-nbd /home/berrange/demo.qcow2
This adds a --source arg (that is mutually exclusive with a positional filename arg and -f arg) that accepts a full option string, as well as the original syntax eg
qemu-nbd --source driver=http,url=https://127.0.0.1/images,sslverify=off qemu-nbd --source https://127.0.0.1/images/centos7.iso qemu-nbd --source file=/home/berrange/demo.qcow2 qemu-nbd --source /home/berrange/demo.qcow2
--- qemu-nbd.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 50 insertions(+), 7 deletions(-)
qemu-nbd.c +50 -7
@@ -49,6 +49,7 @@#define QEMU_NBD_OPT_DISCARD 3#define QEMU_NBD_OPT_DETECT_ZEROES 4#define QEMU_NBD_OPT_OBJECT 5 +#define QEMU_NBD_OPT_SOURCE 6static NBDExport *exp;static int verbose;
@@ -387,6 +388,16 @@ static SocketAddress *nbd_build_socket_address(const char *sockpath, } +static QemuOptsList file_opts = { + .name ="file" , + .implied_opt_name ="file" , + .head =QTAILQ_HEAD_INITIALIZER (file_opts.head), + .desc = { +/* no elements => accept any params */ + {/* end of list */ } + }, +}; +static QemuOptsList qemu_object_opts = { .name ="object" , .implied_opt_name ="qom-type" ,
@@ -486,6 +497,7 @@ int main(int argc, char **argv) { "persistent", 0, NULL, 't' }, { "verbose", 0, NULL, 'v' }, { "object", 1, NULL, QEMU_NBD_OPT_OBJECT }, + { "source", 1, NULL, QEMU_NBD_OPT_SOURCE }, { NULL, 0, NULL, 0 } };int ch;
@@ -657,13 +669,23 @@ int main(int argc, char **argv)exit (1 ); }break ; +case QEMU_NBD_OPT_SOURCE : +if (srcpath) { +errx (EXIT_FAILURE ,"--source can only be used once" ); + } +if (!qemu_opts_parse_noisily (&file_opts, optarg, true)) { +qemu_opts_reset (&file_opts); +exit (EXIT_FAILURE ); + } + srcpath = optarg; +break ;case '?' :errx (EXIT_FAILURE ,"Try `%s --help' for more information." , argv[0 ]); } } -if ((argc - optind) !=1 ) { +if ((argc - optind) >1 ) {errx (EXIT_FAILURE ,"Invalid number of argument.\n" "Try `%s --help' for more information." , argv[0 ]);
@@ -757,15 +779,36 @@ int main(int argc, char **argv)bdrv_init ();atexit (bdrv_close_all); -if (fmt) { - options =qdict_new (); -qdict_put (options,"driver" ,qstring_from_str (fmt)); +if (srcpath) { +char *file =NULL ; + opts =qemu_opts_find (&file_opts,NULL ); +if (fmt) { +errx (EXIT_FAILURE ,"--source and -f are mutually exclusive" ); + } +if ((argc - optind) >1 ) { +errx (EXIT_FAILURE ,"--source and filename are mutually exclusive" ); + } + file =g_strdup (qemu_opt_get (opts,"file" )); +qemu_opt_unset (opts,"file" ); + options =qemu_opts_to_qdict (opts,NULL ); +qemu_opts_reset (&file_opts); + blk =blk_new_open ("hda" , file,NULL , options, flags, &local_err); +g_free (file); + }else { +if (fmt) { + options =qdict_new (); +qdict_put (options,"driver" ,qstring_from_str (fmt)); + } +if ((argc - optind) !=1 ) { +errx (EXIT_FAILURE ,"one of --source or filename are expected" ); + } + + srcpath = argv[optind]; + blk =blk_new_open ("hda" , srcpath,NULL , options, flags, &local_err); } - srcpath = argv[optind]; - blk =blk_new_open ("hda" , srcpath,NULL , options, flags, &local_err);if (!blk) { -errx (EXIT_FAILURE ,"Failed to blk_new_open '%s': %s" , argv[optind], +errx (EXIT_FAILURE ,"Failed to blk_new_open '%s': %s" , srcpath,error_get_pretty (local_err)); } bs =blk_bs (blk);
Signature · 1 line
2.5.0
PATCH 11/30 qemu-img: allow specifying image as a set of options args
In reply to Daniel P. BerrangeCurrently qemu-img allows an image filename to be passed on the command line, but does not have a way to set any options except the format eg
qemu-img info https://127.0.0.1/images/centos7.iso
This adds a --source arg (that is mutually exclusive with a positional filename arg and -f arg) that accepts a full option string, as well as the original syntax eg
qemu-img info driver=http,url=https://127.0.0.1/images,sslverify=off
--- include/qemu/option.h | 1 + qemu-img.c | 474 ++++++++++++++++++++++++++++++++++++++++++-------- util/qemu-option.c | 6 + 3 files changed, 407 insertions(+), 74 deletions(-)
include/qemu/option.h +1 -0
@@ -104,6 +104,7 @@ int qemu_opt_foreach(QemuOpts *opts, qemu_opt_loopfunc func, void *opaque, Error **errp);QemuOpts *qemu_opts_find (QemuOptsList *list,const char *id); +QemuOpts *qemu_opts_next (QemuOpts *opts);QemuOpts *qemu_opts_create (QemuOptsList *list,const char *id,int fail_if_exists,Error **errp);void qemu_opts_reset (QemuOptsList *list);
qemu-img.c +400 -74
841 lines not on this page · raw message
util/qemu-option.c +6 -0
@@ -637,6 +637,12 @@ QemuOpts *qemu_opts_find(QemuOptsList *list, const char *id)return NULL ; } + +QemuOpts *qemu_opts_next (QemuOpts *opts) +{ +return QTAILQ_NEXT (opts, next); +} +QemuOpts *qemu_opts_create (QemuOptsList *list,const char *id,int fail_if_exists,Error **errp) {
Signature · 1 line
2.5.0
PATCH 12/30 block: rip out all traces of password prompting
In reply to Daniel P. BerrangeNow that qcow & qcow2 are wired up to get encryption keys via the QCryptoSecret object, all traces of code which had to deal with prompting for passwords can be ripped out.
When the image is initially opened, the encryption key must be available immediately, or an error will be reported.
$ qemu-system-x86_64 -drive file=secret.qcow2 qemu-system-x86_64: -drive file=secret.qcow2: Image is encrypted but no secret is provided
Users must provide the secret with -object
$ echo 123456 > mypasswd.txt qemu-system-x86_64 -drive file=secret.qcow2,keysecret=sec0 -object secret,file=mypasswd.txt,id=sec0
The BDRV_O_NO_IO flag allows this error to be skipped, for use when 'qemu-img info' wants to open the file to query the headers, but not perform any actual I/O operations.
--- block/qcow.c | 7 +++++ block/qcow2.c | 13 +++++++-- hmp.c | 31 -------------------- hw/usb/dev-storage.c | 34 ---------------------- include/block/block.h | 1 + include/monitor/monitor.h | 7 ----- include/qemu/osdep.h | 2 -- monitor.c | 69 -------------------------------------------- qemu-img.c | 46 +++++++++++------------------ qemu-io.c | 21 -------------- qmp.c | 9 ------ tests/qemu-iotests/087 | 20 +++++++++++++ tests/qemu-iotests/087.out | 2 ++ tests/qemu-iotests/134 | 17 +++++++---- tests/qemu-iotests/134.out | 8 ----- tests/qemu-iotests/common.rc | 4 +-- util/oslib-posix.c | 66 ------------------------------------------ util/oslib-win32.c | 24 --------------- 18 files changed, 72 insertions(+), 309 deletions(-)
block/qcow.c +7 -0
@@ -231,6 +231,13 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,if (s->crypt_method_header) { bs->encrypted =1 ; } +if (!(flags &BDRV_O_NO_IO ) && + bs->encrypted && !s->cipher) { +error_setg (errp,"Image is encrypted but no secret is provided" ); + ret = -EINVAL ; + goto fail; + } + s->cluster_bits = header.cluster_bits; s->cluster_size =1 << s->cluster_bits; s->cluster_sectors =1 << (s->cluster_bits -9 );
block/qcow2.c +11 -2
@@ -1136,6 +1136,13 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } +if (!(flags &BDRV_O_NO_IO ) && + bs->encrypted && !s->cipher) { +error_setg (errp,"Image is encrypted but no secret is provided" ); + ret = -EINVAL ; + goto fail; + } + s->cluster_cache =g_malloc (s->cluster_size);/* one more sector for decompressed data alignment */ s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
@@ -2207,7 +2214,8 @@ static int qcow2_create2(const char *filename, int64_t total_size, options =qdict_new ();qdict_put (options,"driver" ,qstring_from_str ("qcow2" )); ret =bdrv_open (&bs, filename,NULL , options, -BDRV_O_RDWR |BDRV_O_CACHE_WB |BDRV_O_NO_FLUSH , +BDRV_O_RDWR |BDRV_O_CACHE_WB |BDRV_O_NO_FLUSH | +BDRV_O_NO_IO , &local_err);if (ret <0 ) {error_propagate (errp, local_err);
@@ -2261,7 +2269,8 @@ static int qcow2_create2(const char *filename, int64_t total_size, options =qdict_new ();qdict_put (options,"driver" ,qstring_from_str ("qcow2" )); ret =bdrv_open (&bs, filename,NULL , options, -BDRV_O_RDWR |BDRV_O_CACHE_WB |BDRV_O_NO_BACKING , +BDRV_O_RDWR |BDRV_O_CACHE_WB |BDRV_O_NO_BACKING | +BDRV_O_NO_IO , &local_err);if (local_err) {error_propagate (errp, local_err);
hmp.c +0 -31
@@ -962,37 +962,12 @@ void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)g_free (data); } -static void hmp_cont_cb (void *opaque,int err) -{ -if (!err) { -qmp_cont (NULL ); - } -} - -static bool key_is_missing (const BlockInfo *bdev) -{ -return (bdev->inserted && bdev->inserted->encryption_key_missing); -} -void hmp_cont (Monitor *mon,const QDict *qdict) { -BlockInfoList *bdev_list, *bdev;Error *err =NULL ; - bdev_list =qmp_query_block (NULL ); -for (bdev = bdev_list; bdev; bdev = bdev->next) { -if (key_is_missing (bdev->value)) { -monitor_read_block_device_key (mon, bdev->value->device, - hmp_cont_cb,NULL ); - goto out; - } - } -qmp_cont (&err);hmp_handle_error (mon, &err); - -out: -qapi_free_BlockInfoList (bdev_list); }void hmp_system_wakeup (Monitor *mon,const QDict *qdict)
@@ -1379,12 +1354,6 @@ void hmp_change(Monitor *mon, const QDict *qdict)qmp_blockdev_change_medium (device, target, !!arg, arg, !!read_only, read_only_mode, &err); -if (err && -error_get_class (err) ==ERROR_CLASS_DEVICE_ENCRYPTED ) { -error_free (err); -monitor_read_block_device_key (mon, device,NULL ,NULL ); -return ; - } }hmp_handle_error (mon, &err);
hw/usb/dev-storage.c +0 -34
@@ -553,21 +553,6 @@ static void usb_msd_handle_data(USBDevice *dev, USBPacket *p) } } -static void usb_msd_password_cb (void *opaque,int err) -{ -MSDState *s = opaque; -Error *local_err =NULL ; - -if (!err) { -usb_device_attach (&s->dev, &local_err); - } - -if (local_err) { -error_report_err (local_err); -qdev_unplug (&s->dev.qdev,NULL ); - } -} -static void *usb_msd_load_request (QEMUFile *f,SCSIRequest *req) {MSDState *s =DO_UPCAST (MSDState, dev.qdev, req->bus->qbus.parent);
@@ -613,25 +598,6 @@ static void usb_msd_realize_storage(USBDevice *dev, Error **errp)return ; } -if (blk_bs (blk)) { -bdrv_add_key (blk_bs (blk),NULL , &err); -if (err) { -if (monitor_cur_is_qmp ()) { -error_propagate (errp, err); -return ; - } -error_free (err); - err =NULL ; -if (cur_mon) { -monitor_read_bdrv_key_start (cur_mon,blk_bs (blk), - usb_msd_password_cb, s); - s->dev.auto_attach =0 ; - }else { - autostart =0 ; - } - } - } -blkconf_serial (&s->conf, &dev->serial);blkconf_blocksizes (&s->conf);
include/block/block.h +1 -0
@@ -91,6 +91,7 @@ typedef struct HDGeometry {#define BDRV_O_PROTOCOL 0x8000/* if no block driver is explicitly given: select an appropriate protocol driver, ignoring the format layer */ +#define BDRV_O_NO_IO 0x10000/* don't initialize for I/O */ #define BDRV_O_CACHE_MASK (BDRV_O_NOCACHE | BDRV_O_CACHE_WB | BDRV_O_NO_FLUSH)
include/monitor/monitor.h +0 -7
@@ -21,13 +21,6 @@ void monitor_init(CharDriverState *chr, int flags);int monitor_suspend (Monitor *mon);void monitor_resume (Monitor *mon); -int monitor_read_bdrv_key_start (Monitor *mon,BlockDriverState *bs, -BlockCompletionFunc *completion_cb, -void *opaque); -int monitor_read_block_device_key (Monitor *mon,const char *device, -BlockCompletionFunc *completion_cb, -void *opaque); -int monitor_get_fd (Monitor *mon,const char *fdname,Error **errp);int monitor_fd_param (Monitor *mon,const char *fdname,Error **errp);
include/qemu/osdep.h +0 -2
@@ -295,8 +295,6 @@ void qemu_set_tty_echo(int fd, bool echo);void os_mem_prealloc (int fd,char *area,size_t sz); -int qemu_read_password (char *buf,int buf_size); -/** * qemu_fork: *
monitor.c +0 -69
75 lines not on this page · raw message
qemu-img.c +17 -29
134 lines not on this page · raw message
qemu-io.c +0 -21
@@ -56,7 +56,6 @@ static const cmdinfo_t close_cmd = {static int openfile (char *name,int flags,QDict *opts) {Error *local_err =NULL ; -BlockDriverState *bs;if (qemuio_blk) {fprintf (stderr,"file open already, try 'help close'\n" );
@@ -73,27 +72,7 @@ static int openfile(char *name, int flags, QDict *opts)return 1 ; } - bs =blk_bs (qemuio_blk); -if (bdrv_is_encrypted (bs)) { -char password[256 ]; -printf ("Disk image '%s' is encrypted.\n" , name); -if (qemu_read_password (password,sizeof (password)) <0 ) { -error_report ("No password given" ); - goto error; - } -if (bdrv_set_key (bs, password) <0 ) { -error_report ("invalid password" ); - goto error; - } - } - -return 0 ; - - error: -blk_unref (qemuio_blk); - qemuio_blk =NULL ; -return 1 ; }static void open_help (void )
qmp.c +0 -9
@@ -170,9 +170,7 @@ SpiceInfo *qmp_query_spice(Error **errp)void qmp_cont (Error **errp) { -Error *local_err =NULL ;BlockBackend *blk; -BlockDriverState *bs;if (runstate_needs_reset ()) {error_setg (errp,"Resetting the Virtual Machine is required" );
@@ -184,13 +182,6 @@ void qmp_cont(Error **errp)for (blk =blk_next (NULL ); blk; blk =blk_next (blk)) {blk_iostatus_reset (blk); } -for (bs =bdrv_next (NULL ); bs; bs =bdrv_next (bs)) { -bdrv_add_key (bs,NULL , &local_err); -if (local_err) { -error_propagate (errp, local_err); -return ; - } - }if (runstate_check (RUN_STATE_INMIGRATE )) { autostart =1 ;
tests/qemu-iotests/087 +20 -0
@@ -187,11 +187,21 @@ echo _make_test_img -o encryption=on $size run_qemu -S <<EOF { "execute": "qmp_capabilities" } +{ "execute": "object-add", + "arguments": { + "qom-type": "secret", + "id": "sec0", + "props": { + "data": "123456" + } + } +} { "execute": "blockdev-add", "arguments": { "options": { "driver": "$IMGFMT", "id": "disk", + "keyid": "sec0", "file": { "driver": "file", "filename": "$TEST_IMG"
@@ -204,11 +214,21 @@ EOF run_qemu <<EOF { "execute": "qmp_capabilities" } +{ "execute": "object-add", + "arguments": { + "qom-type": "secret", + "id": "sec0", + "props": { + "data": "123456" + } + } +} { "execute": "blockdev-add", "arguments": { "options": { "driver": "$IMGFMT", "id": "disk", + "keyid": "sec0", "file": { "driver": "file", "filename": "$TEST_IMG"
tests/qemu-iotests/087.out +2 -0
@@ -48,6 +48,7 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on Testing: -S QMP_VERSION {"return": {}} +{"return": {}} Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one.
@@ -58,6 +59,7 @@ You can use 'qemu-img convert' to convert your image to an unencrypted one. Testing: QMP_VERSION {"return": {}} +{"return": {}} Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one.
tests/qemu-iotests/134 +12 -5
@@ -44,23 +44,30 @@ _supported_os Linux size=128M -IMGOPTS="encryption=on" _make_test_img $size +SECRET1=secret,id=sec0,data=astrochicken +SECRET2=secret,id=sec0,data=platypus + +EXTRA_IMG_ARGS="--object $SECRET1" IMGOPTS="encryption=on" _make_test_img $size + + +QEMU_IO_OPTIONS=`echo $QEMU_IO_OPTIONS | sed -e 's/-f qcow2//'` +TEST_IMG="driver=qcow2,file=$TEST_IMG,keyid=sec0" echo echo "== reading whole image ==" -echo "astrochicken" | $QEMU_IO -c "read 0 $size" "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET1 -c "read 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir echo echo "== rewriting whole image ==" -echo "astrochicken" | $QEMU_IO -c "write -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET1 -c "write -P 0xa 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir echo echo "== verify pattern ==" -echo "astrochicken" | $QEMU_IO -c "read -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET1 -c "read -P 0xa 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir echo echo "== verify pattern failure with wrong password ==" -echo "platypus" | $QEMU_IO -c "read -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET2 -c "read -P 0xa 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir # success, all done
tests/qemu-iotests/134.out +0 -8
@@ -11,8 +11,6 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one. -Disk image 'TEST_DIR/t.qcow2' is encrypted. -password: read 134217728/134217728 bytes at offset 0 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -20,8 +18,6 @@ read 134217728/134217728 bytes at offset 0 Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one. -Disk image 'TEST_DIR/t.qcow2' is encrypted. -password: wrote 134217728/134217728 bytes at offset 0 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -29,8 +25,6 @@ wrote 134217728/134217728 bytes at offset 0 Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one. -Disk image 'TEST_DIR/t.qcow2' is encrypted. -password: read 134217728/134217728 bytes at offset 0 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -38,8 +32,6 @@ read 134217728/134217728 bytes at offset 0 Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one. -Disk image 'TEST_DIR/t.qcow2' is encrypted. -password: Pattern verification failed at offset 0, 134217728 bytes read 134217728/134217728 bytes at offset 0 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
tests/qemu-iotests/common.rc +2 -2
@@ -135,9 +135,9 @@ _make_test_img() # XXX(hch): have global image options? ( if [ $use_backing = 1 ]; then - $QEMU_IMG create -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" $image_size 2>&1 + $QEMU_IMG create $EXTRA_IMG_ARGS -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" $image_size 2>&1 else - $QEMU_IMG create -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1 + $QEMU_IMG create $EXTRA_IMG_ARGS -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1 fi ) | _filter_img_create
util/oslib-posix.c +0 -66
72 lines not on this page · raw message
util/oslib-win32.c +0 -24
@@ -474,30 +474,6 @@ void os_mem_prealloc(int fd, char *area, size_t memory) } -/* XXX: put correct support for win32 */ -int qemu_read_password (char *buf,int buf_size) -{ -int c, i; - -printf ("Password: " ); -fflush (stdout); - i =0 ; -for (;;) { - c =getchar (); -if (c <0 ) { - buf[i] ='\0' ; -return -1 ; - }else if (c =='\n' ) { -break ; - }else if (i < (buf_size -1 )) { - buf[i++] = c; - } - } - buf[i] ='\0' ; -return 0 ; -} - -pid_t qemu_fork (Error **errp) { errno =ENOSYS ;
Signature · 1 line
2.5.0
PATCH 13/30 block: remove all encryption handling APIs
In reply to Daniel P. BerrangeNow that all encryption keys must be provided upfront via the QCryptoSecret API and associated block driver properties there is no need for any explicit encryption handling APIs in the block layer. Encryption can be handled transparently within the block driver. We only retain an API for querying whether an image is encrypted or not, since that is a potentially useful piece of metadata to report to the user.
--- block.c | 81 ++-------------------------------------------- block/qapi.c | 2 +- block/qcow.c | 19 ----------- block/qcow2.c | 19 ----------- blockdev.c | 40 ++--------------------- include/block/block.h | 4 --- tests/qemu-iotests/087.out | 4 +-- 7 files changed, 7 insertions(+), 162 deletions(-)
block.c +2 -79
@@ -1550,17 +1550,8 @@ static int bdrv_open_inherit(BlockDriverState **pbs, const char *filename, goto close_and_fail; } -if (!bdrv_key_required (bs)) { -if (bs->blk) { -blk_dev_change_media_cb (bs->blk, true); - } - }else if (!runstate_check (RUN_STATE_PRELAUNCH ) - && !runstate_check (RUN_STATE_INMIGRATE ) - && !runstate_check (RUN_STATE_PAUSED )) {/* HACK */ -error_setg (errp, -"Guest must be stopped for opening of encrypted image" ); - ret = -EBUSY ; - goto close_and_fail; +if (bs->blk) { +blk_dev_change_media_cb (bs->blk, true); }QDECREF (options);
@@ -2530,74 +2521,6 @@ int bdrv_is_encrypted(BlockDriverState *bs)return bs->encrypted; } -int bdrv_key_required (BlockDriverState *bs) -{ -BdrvChild *backing = bs->backing; - -if (backing && backing->bs->encrypted && !backing->bs->valid_key) { -return 1 ; - } -return (bs->encrypted && !bs->valid_key); -} - -int bdrv_set_key (BlockDriverState *bs,const char *key) -{ -int ret; -if (bs->backing && bs->backing->bs->encrypted) { - ret =bdrv_set_key (bs->backing->bs, key); -if (ret <0 ) -return ret; -if (!bs->encrypted) -return 0 ; - } -if (!bs->encrypted) { -return -EINVAL ; - }else if (!bs->drv || !bs->drv->bdrv_set_key) { -return -ENOMEDIUM ; - } - ret = bs->drv->bdrv_set_key (bs, key); -if (ret <0 ) { - bs->valid_key =0 ; - }else if (!bs->valid_key) { - bs->valid_key =1 ; -if (bs->blk) { -/* call the change callback now, we skipped it on open */ -blk_dev_change_media_cb (bs->blk, true); - } - } -return ret; -} - -/* -* Provide an encryption key for @bs. -* If @key is non-null: -* If @bs is not encrypted, fail. -* Else if the key is invalid, fail. -* Else set @bs's key to @key, replacing the existing key, if any. -* If @key is null: -* If @bs is encrypted and still lacks a key, fail. -* Else do nothing. -* On failure, store an error object through @errp if non-null. -*/ -void bdrv_add_key (BlockDriverState *bs,const char *key,Error **errp) -{ -if (key) { -if (!bdrv_is_encrypted (bs)) { -error_setg (errp,"Node '%s' is not encrypted" , -bdrv_get_device_or_node_name (bs)); - }else if (bdrv_set_key (bs, key) <0 ) { -error_setg (errp,QERR_INVALID_PASSWORD ); - } - }else { -if (bdrv_key_required (bs)) { -error_set (errp,ERROR_CLASS_DEVICE_ENCRYPTED , -"'%s' (%s) is encrypted" , -bdrv_get_device_or_node_name (bs), -bdrv_get_encrypted_filename (bs)); - } - } -} -const char *bdrv_get_format_name (BlockDriverState *bs) {return bs->drv ? bs->drv->format_name :NULL ;
block/qapi.c +1 -1
@@ -42,7 +42,7 @@ BlockDeviceInfo *bdrv_block_device_info(BlockDriverState *bs, Error **errp) info->ro = bs->read_only; info->drv =g_strdup (bs->drv->format_name); info->encrypted = bs->encrypted; - info->encryption_key_missing =bdrv_key_required (bs); + info->encryption_key_missing = false; info->cache =g_new (BlockdevCacheInfo,1 ); *info->cache = (BlockdevCacheInfo ) {
block/qcow.c +0 -19
@@ -222,11 +222,6 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags, ret = -EINVAL ; goto fail; } -if (!qcrypto_cipher_supports (QCRYPTO_CIPHER_ALG_AES_128 )) { -error_setg (errp,"AES cipher not available" ); - ret = -EINVAL ; - goto fail; - } s->crypt_method_header = header.crypt_method;if (s->crypt_method_header) { bs->encrypted =1 ;
@@ -335,19 +330,6 @@ static int qcow_reopen_prepare(BDRVReopenState *state,return 0 ; } -static int qcow_set_key (BlockDriverState *bs,const char *key) -{ -BDRVQcowState *s = bs->opaque; - -assert (bs->encrypted); -qcrypto_cipher_free (s->cipher); - s->cipher =qcow_get_cipher_from_key (key,NULL ); -if (!s->cipher) { -return -1 ; - } -return 0 ; -} -/* The crypt function is compatible with the linux cryptoloop algorithm for < 4 GB images. NOTE: out_buf == in_buf is supported */
@@ -1078,7 +1060,6 @@ static BlockDriver bdrv_qcow = { .bdrv_co_writev = qcow_co_writev, .bdrv_co_get_block_status = qcow_co_get_block_status, - .bdrv_set_key = qcow_set_key, .bdrv_make_empty = qcow_make_empty, .bdrv_write_compressed = qcow_write_compressed, .bdrv_get_info = qcow_get_info,
block/qcow2.c +0 -19
@@ -1026,11 +1026,6 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, ret = -EINVAL ; goto fail; } -if (!qcrypto_cipher_supports (QCRYPTO_CIPHER_ALG_AES_128 )) { -error_setg (errp,"AES cipher not available" ); - ret = -EINVAL ; - goto fail; - } s->crypt_method_header = header.crypt_method;if (s->crypt_method_header) { bs->encrypted =1 ;
@@ -1262,19 +1257,6 @@ static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp) bs->bl.write_zeroes_alignment = s->cluster_sectors; } -static int qcow2_set_key (BlockDriverState *bs,const char *key) -{ -BDRVQcow2State *s = bs->opaque; - -assert (bs->encrypted); -qcrypto_cipher_free (s->cipher); - s->cipher =qcow2_get_cipher_from_key (key,NULL ); -if (!s->cipher) { -return -1 ; - } -return 0 ; -} -static int qcow2_reopen_prepare (BDRVReopenState *state,BlockReopenQueue *queue,Error **errp) {
@@ -3191,7 +3173,6 @@ BlockDriver bdrv_qcow2 = { .bdrv_create = qcow2_create, .bdrv_has_zero_init = bdrv_has_zero_init_1, .bdrv_co_get_block_status = qcow2_co_get_block_status, - .bdrv_set_key = qcow2_set_key, .bdrv_co_readv = qcow2_co_readv, .bdrv_co_writev = qcow2_co_writev,
blockdev.c +2 -38
@@ -624,10 +624,6 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,bdrv_set_io_limits (bs, &cfg); } -if (bdrv_key_required (bs)) { - autostart =0 ; - } -block_acct_init (blk_get_stats (blk), account_invalid, account_failed);if (!parse_stats_intervals (blk_get_stats (blk), interval_list, errp)) {
@@ -2263,24 +2259,8 @@ void qmp_block_passwd(bool has_device, const char *device, bool has_node_name, const char *node_name, const char *password, Error **errp) { - Error *local_err = NULL; -BlockDriverState *bs; -AioContext *aio_context; - - bs =bdrv_lookup_bs (has_device ? device :NULL , - has_node_name ? node_name :NULL , - &local_err); -if (local_err) { -error_propagate (errp, local_err); -return ; - } - - aio_context =bdrv_get_aio_context (bs); -aio_context_acquire (aio_context); - -bdrv_add_key (bs, password, errp); - -aio_context_release (aio_context); + error_setg_errno(errp, -ENOSYS, + "Setting block passwords directly is no longer supported"); } void qmp_blockdev_open_tray(const char *device, bool has_force, bool force,
@@ -2507,12 +2487,6 @@ void qmp_blockdev_change_medium(const char *device, const char *filename,blk_apply_root_state (blk, medium_bs); -bdrv_add_key (medium_bs,NULL , &err); -if (err) { -error_propagate (errp, err); - goto fail; - } -qmp_blockdev_open_tray (device, false, false, &err);if (err) {error_propagate (errp, err);
@@ -3755,16 +3729,6 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp) } } -if (bs &&bdrv_key_required (bs)) { -if (blk) { -blk_unref (blk); - }else { -bdrv_unref (bs); - } -error_setg (errp,"blockdev-add doesn't support encrypted devices" ); - goto fail; - } - fail:qmp_output_visitor_cleanup (ov); }
include/block/block.h +0 -4
@@ -412,10 +412,6 @@ bool bdrv_chain_contains(BlockDriverState *top, BlockDriverState *base);BlockDriverState *bdrv_next_node (BlockDriverState *bs);BlockDriverState *bdrv_next (BlockDriverState *bs);int bdrv_is_encrypted (BlockDriverState *bs); -int bdrv_key_required (BlockDriverState *bs); -int bdrv_set_key (BlockDriverState *bs,const char *key); -void bdrv_add_key (BlockDriverState *bs,const char *key,Error **errp); -int bdrv_query_missing_keys (void );void bdrv_iterate_format (void (*it)(void *opaque,const char *name),void *opaque);const char *bdrv_get_node_name (const BlockDriverState *bs);
tests/qemu-iotests/087.out +2 -2
@@ -52,7 +52,7 @@ QMP_VERSION Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one. -{"error": {"class": "GenericError", "desc": "blockdev-add doesn't support encrypted devices"}} +{"return": {}} {"return": {}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN"}
@@ -63,7 +63,7 @@ QMP_VERSION Encrypted images are deprecated Support for them will be removed in a future release. You can use 'qemu-img convert' to convert your image to an unencrypted one. -{"error": {"class": "GenericError", "desc": "Guest must be stopped for opening of encrypted image"}} +{"return": {}} {"return": {}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN"}
Signature · 1 line
2.5.0
PATCH 14/30 block: remove support for writing to qcow/qcow2 encrypted images
In reply to Daniel P. BerrangeRefuse to open a qcow/qcow2 image with encryption if write access has been requested. To enable historic data to be liberated support for reading images is retained, as it does not pose an unreasonable support burden now that the new key handling infrastructure is inplace.
--- block.c | 7 ------- block/qcow.c | 6 ++++++ block/qcow2.c | 6 ++++++ tests/qemu-iotests/087.out | 24 ++++-------------------- tests/qemu-iotests/134 | 8 ++++---- tests/qemu-iotests/134.out | 36 +++++++++--------------------------- 6 files changed, 29 insertions(+), 58 deletions(-)
block.c +0 -7
@@ -920,13 +920,6 @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file, goto free_and_fail; } -if (bs->encrypted) { -error_report ("Encrypted images are deprecated" ); -error_printf ("Support for them will be removed in a future release.\n" -"You can use 'qemu-img convert' to convert your image" -" to an unencrypted one.\n" ); - } - ret =refresh_total_sectors (bs, bs->total_sectors);if (ret <0 ) {error_setg_errno (errp, -ret,"Could not refresh total sector count" );
block/qcow.c +6 -0
@@ -224,6 +224,12 @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags, } s->crypt_method_header = header.crypt_method;if (s->crypt_method_header) { +if (flags &BDRV_O_RDWR ) { +error_setg (errp, +"Writing of encrypted qcow images is no longer supported" ); + ret = -ENOSYS ; + goto fail; + } bs->encrypted =1 ; } if (!(flags & BDRV_O_NO_IO) &&
block/qcow2.c +6 -0
@@ -1028,6 +1028,12 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, } s->crypt_method_header = header.crypt_method;if (s->crypt_method_header) { +if (flags &BDRV_O_RDWR ) { +error_setg (errp, +"Writing of encrypted qcow2 images is no longer supported" ); + ret = -ENOSYS ; + goto fail; + } bs->encrypted =1 ; }
tests/qemu-iotests/087.out +4 -20
@@ -38,21 +38,13 @@ QMP_VERSION === Encrypted image === -qemu-img: Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -qemu-img: Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. +qemu-img: TEST_DIR/t.IMGFMT: Writing of encrypted IMGFMT images is no longer supported Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on Testing: -S QMP_VERSION {"return": {}} {"return": {}} -Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -{"return": {}} +{"error": {"class": "GenericError", "desc": "Writing of encrypted qcow2 images is no longer supported"}} {"return": {}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN"}
@@ -60,22 +52,14 @@ Testing: QMP_VERSION {"return": {}} {"return": {}} -Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -{"return": {}} +{"error": {"class": "GenericError", "desc": "Writing of encrypted qcow2 images is no longer supported"}} {"return": {}} {"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN"} === Missing driver === -qemu-img: Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -qemu-img: Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. +qemu-img: TEST_DIR/t.IMGFMT: Writing of encrypted IMGFMT images is no longer supported Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on Testing: -S QMP_VERSION
tests/qemu-iotests/134 +4 -4
@@ -55,19 +55,19 @@ TEST_IMG="driver=qcow2,file=$TEST_IMG,keyid=sec0" echo echo "== reading whole image ==" -$QEMU_IO --object $SECRET1 -c "read 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET1 -c "read 0 $size" --source "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir echo echo "== rewriting whole image ==" -$QEMU_IO --object $SECRET1 -c "write -P 0xa 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET1 -c "write -P 0xa 0 $size" --source "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir echo echo "== verify pattern ==" -$QEMU_IO --object $SECRET1 -c "read -P 0xa 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET1 -c "read -P 0xa 0 $size" --source "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir echo echo "== verify pattern failure with wrong password ==" -$QEMU_IO --object $SECRET2 -c "read -P 0xa 0 $size" --source "$TEST_IMG" | _filter_qemu_io | _filter_testdir +$QEMU_IO --object $SECRET2 -c "read -P 0xa 0 $size" --source "$TEST_IMG" 2>&1 | _filter_qemu_io | _filter_testdir # success, all done
tests/qemu-iotests/134.out +9 -27
@@ -1,38 +1,20 @@ QA output created by 134 -qemu-img: Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -qemu-img: Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. +qemu-img: TEST_DIR/t.IMGFMT: Writing of encrypted IMGFMT images is no longer supported Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 encryption=on == reading whole image == -Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -read 134217728/134217728 bytes at offset 0 -128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +qemu-io: can't open device TEST_DIR/t.qcow2: Writing of encrypted qcow2 images is no longer supported +no file open, try 'help open' == rewriting whole image == -Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -wrote 134217728/134217728 bytes at offset 0 -128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +qemu-io: can't open device TEST_DIR/t.qcow2: Writing of encrypted qcow2 images is no longer supported +no file open, try 'help open' == verify pattern == -Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -read 134217728/134217728 bytes at offset 0 -128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +qemu-io: can't open device TEST_DIR/t.qcow2: Writing of encrypted qcow2 images is no longer supported +no file open, try 'help open' == verify pattern failure with wrong password == -Encrypted images are deprecated -Support for them will be removed in a future release. -You can use 'qemu-img convert' to convert your image to an unencrypted one. -Pattern verification failed at offset 0, 134217728 bytes -read 134217728/134217728 bytes at offset 0 -128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) +qemu-io: can't open device TEST_DIR/t.qcow2: Writing of encrypted qcow2 images is no longer supported +no file open, try 'help open' *** done
Signature · 1 line
2.5.0
PATCH 15/30 qcow2: make qcow2_encrypt_sectors encrypt in place
In reply to Daniel P. BerrangeInstead of requiring separate input/output buffers for encrypting data, change qcow2_encrypt_sectors() to assume use of a single buffer, encrypting in place. The current callers all used the same buffer for input/output already.
--- block/qcow2-cluster.c | 17 +++++------------ block/qcow2.c | 5 ++--- block/qcow2.h | 3 +-- 3 files changed, 8 insertions(+), 17 deletions(-)
block/qcow2-cluster.c +5 -12
@@ -341,12 +341,8 @@ static int count_contiguous_clusters_by_type(int nb_clusters,return i; } -/* The crypt function is compatible with the linux cryptoloop -algorithm for < 4 GB images. NOTE: out_buf == in_buf is -supported */ int qcow2_encrypt_sectors (BDRVQcow2State *s,int64_t sector_num, -uint8_t *out_buf,const uint8_t *in_buf, -int nb_sectors,bool enc, +uint8_t *buf,int nb_sectors,bool enc,Error **errp) {union {
@@ -366,14 +362,12 @@ int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num, }if (enc) { ret =qcrypto_cipher_encrypt (s->cipher, - in_buf, - out_buf, + buf, buf,512 , errp); }else { ret =qcrypto_cipher_decrypt (s->cipher, - in_buf, - out_buf, + buf, buf,512 , errp); }
@@ -381,8 +375,7 @@ int qcow2_encrypt_sectors(BDRVQcow2State *s, int64_t sector_num,return -1 ; } sector_num++; - in_buf +=512 ; - out_buf +=512 ; + buf +=512 ; }return 0 ; }
@@ -430,7 +423,7 @@ static int coroutine_fn copy_sectors(BlockDriverState *bs,Error *err =NULL ;assert (s->cipher);if (qcow2_encrypt_sectors (s, start_sect + n_start, - iov.iov_base, iov.iov_base, n, + iov.iov_base, n, true, &err) <0 ) { ret = -EIO ;error_free (err);
block/qcow2.c +2 -3
@@ -1487,7 +1487,7 @@ static coroutine_fn int qcow2_co_readv(BlockDriverState *bs, int64_t sector_num,assert (s->cipher);Error *err =NULL ;if (qcow2_encrypt_sectors (s, sector_num, cluster_data, - cluster_data, cur_nr_sectors, false, + cur_nr_sectors, false, &err) <0 ) {error_free (err); ret = -EIO ;
@@ -1587,8 +1587,7 @@ static coroutine_fn int qcow2_co_writev(BlockDriverState *bs,qemu_iovec_to_buf (&hd_qiov,0 , cluster_data, hd_qiov.size);if (qcow2_encrypt_sectors (s, sector_num, cluster_data, - cluster_data, cur_nr_sectors, - true, &err) <0 ) { + cur_nr_sectors, true, &err) <0 ) {error_free (err); ret = -EIO ; goto fail;
block/qcow2.h +1 -2
@@ -537,8 +537,7 @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index);void qcow2_l2_cache_reset (BlockDriverState *bs);int qcow2_decompress_cluster (BlockDriverState *bs,uint64_t cluster_offset);int qcow2_encrypt_sectors (BDRVQcow2State *s,int64_t sector_num, -uint8_t *out_buf,const uint8_t *in_buf, -int nb_sectors,bool enc,Error **errp); +uint8_t *buf,int nb_sectors,bool enc,Error **errp);int qcow2_get_cluster_offset (BlockDriverState *bs,uint64_t offset,int *num,uint64_t *cluster_offset);
Signature · 1 line
2.5.0
PATCH 16/30 crypto: add ability to query the cipher key, block & IV lens
In reply to Daniel P. BerrangeAdds new methods to allow querying the length of the cipher key, block size and initialization vectors.
--- crypto/cipher.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++ include/crypto/cipher.h | 37 +++++++++++++++++++++++++++++++++++ tests/test-crypto-cipher.c | 10 ++++++++++ 3 files changed, 95 insertions(+)
crypto/cipher.c +48 -0
@@ -28,6 +28,54 @@ static size_t alg_key_len[QCRYPTO_CIPHER_ALG_LAST] = { [QCRYPTO_CIPHER_ALG_DES_RFB] = 8, }; +static size_t alg_block_len[QCRYPTO_CIPHER_ALG_LAST ] = { + [QCRYPTO_CIPHER_ALG_AES_128 ] =16 , + [QCRYPTO_CIPHER_ALG_AES_192 ] =16 , + [QCRYPTO_CIPHER_ALG_AES_256 ] =16 , + [QCRYPTO_CIPHER_ALG_DES_RFB ] =8 , +}; + +static bool mode_need_iv[QCRYPTO_CIPHER_MODE_LAST ] = { + [QCRYPTO_CIPHER_MODE_ECB ] = false, + [QCRYPTO_CIPHER_MODE_CBC ] = true, +}; + + +size_t qcrypto_cipher_get_block_len (QCryptoCipherAlgorithm alg) +{ +if (alg >=G_N_ELEMENTS (alg_key_len)) { +return 0 ; + } +return alg_block_len[alg]; +} + + +size_t qcrypto_cipher_get_key_len (QCryptoCipherAlgorithm alg) +{ +if (alg >=G_N_ELEMENTS (alg_key_len)) { +return 0 ; + } +return alg_key_len[alg]; +} + + +size_t qcrypto_cipher_get_iv_len (QCryptoCipherAlgorithm alg, +QCryptoCipherMode mode) +{ +if (alg >=G_N_ELEMENTS (alg_block_len)) { +return 0 ; + } +if (mode >=G_N_ELEMENTS (mode_need_iv)) { +return 0 ; + } + +if (mode_need_iv[mode]) { +return alg_block_len[alg]; + } +return 0 ; +} + + static bool qcrypto_cipher_validate_key_length(QCryptoCipherAlgorithm alg, size_t nkey,
include/crypto/cipher.h +37 -0
@@ -107,6 +107,43 @@ struct QCryptoCipher {*/ bool qcrypto_cipher_supports (QCryptoCipherAlgorithm alg); +/** +* qcrypto_cipher_get_block_len: +* @alg: the cipher algorithm +* +* Get the required data block size in bytes. When +* encrypting data, it must be a multiple of the +* block size. +* +* Returns: the block size in bytes +*/ +size_t qcrypto_cipher_get_block_len (QCryptoCipherAlgorithm alg); + + +/** +* qcrypto_cipher_get_key_len: +* @alg: the cipher algorithm +* +* Get the required key size in bytes. +* +* Returns: the key size in bytes +*/ +size_t qcrypto_cipher_get_key_len (QCryptoCipherAlgorithm alg); + + +/** +* qcrypto_cipher_get_iv_len: +* @alg: the cipher algorithm +* @mode: the cipher mode +* +* Get the required initialization vector size +* in bytes, if one is required. +* +* Returns: the IV size in bytes, or 0 if no IV is permitted +*/ +size_t qcrypto_cipher_get_iv_len (QCryptoCipherAlgorithm alg, +QCryptoCipherMode mode); +/** * qcrypto_cipher_new:
tests/test-crypto-cipher.c +10 -0
@@ -229,6 +229,7 @@ static void test_cipher(const void *opaque)uint8_t *key, *iv, *ciphertext, *plaintext, *outtext;size_t nkey, niv, nciphertext, nplaintext;char *outtexthex; +size_t ivsize, keysize, blocksize; nkey =unhex_string (data->key, &key); niv =unhex_string (data->iv, &iv);
@@ -245,6 +246,15 @@ static void test_cipher(const void *opaque) &error_abort);g_assert (cipher !=NULL ); + keysize =qcrypto_cipher_get_key_len (data->alg); + blocksize =qcrypto_cipher_get_block_len (data->alg); + ivsize =qcrypto_cipher_get_iv_len (data->alg, data->mode); + + g_assert_cmpint(keysize, ==, nkey); + g_assert_cmpint(ivsize, ==, niv); +if (niv) { + g_assert_cmpint(blocksize, ==, niv); + }if (iv) { g_assert(qcrypto_cipher_setiv(cipher,
Signature · 1 line
2.5.0
PATCH 17/30 crypto: add method for querying hash digest size
In reply to Daniel P. BerrangeAdd a qcrypto_hash_digest_len() method which allows querying of the raw digest size for a given hash algorithm.
--- crypto/hash.c | 15 +++++++++++++++ include/crypto/hash.h | 11 +++++++++++ tests/test-crypto-hash.c | 5 +++++ 3 files changed, 31 insertions(+)
crypto/hash.c +15 -0
@@ -30,6 +30,12 @@ static int qcrypto_hash_alg_map[QCRYPTO_HASH_ALG_LAST] = { [QCRYPTO_HASH_ALG_SHA256] = GNUTLS_DIG_SHA256, }; +static size_t qcrypto_hash_alg_size[QCRYPTO_HASH_ALG_LAST ] = { + [QCRYPTO_HASH_ALG_MD5 ] =16 , + [QCRYPTO_HASH_ALG_SHA1 ] =20 , + [QCRYPTO_HASH_ALG_SHA256 ] =32 , +}; +gboolean qcrypto_hash_supports (QCryptoHashAlgorithm alg) {if (alg <G_N_ELEMENTS (qcrypto_hash_alg_map)) {
@@ -38,6 +44,15 @@ gboolean qcrypto_hash_supports(QCryptoHashAlgorithm alg)return false; } +size_t qcrypto_hash_digest_len (QCryptoHashAlgorithm alg) +{ +if (alg >=G_N_ELEMENTS (qcrypto_hash_alg_size)) { +return 0 ; + } +return qcrypto_hash_alg_size[alg]; +} + + int qcrypto_hash_bytesv(QCryptoHashAlgorithm alg, const struct iovec *iov, size_t niov,
include/crypto/hash.h +11 -0
@@ -44,6 +44,17 @@ typedef enum {*/ gboolean qcrypto_hash_supports (QCryptoHashAlgorithm alg); + +/** +* qcrypto_hash_digest_len: +* @alg: the hash algorithm +* +* Determine the size of the hash digest in bytes +* +* Returns: the digest length in bytes +*/ +size_t qcrypto_hash_digest_len (QCryptoHashAlgorithm alg); +/** * qcrypto_hash_bytesv: * @alg: the hash algorithm
tests/test-crypto-hash.c +5 -0
@@ -163,6 +163,11 @@ static void test_hash_digest(void)for (i =0 ; i <G_N_ELEMENTS (expected_outputs) ; i++) {int ret;char *digest; +size_t digestsize; + + digestsize =qcrypto_hash_digest_len (i); + +g_assert ((digestsize *2 ) ==strlen (expected_outputs[i])); ret = qcrypto_hash_digest(i, INPUT_TEXT,
Signature · 1 line
2.5.0
PATCH 18/30 crypto: move QCryptoHashAlgorithm enum definition into QAPI
In reply to Daniel P. BerrangeThe QCryptoHashAlgorithm enum is defined in the crypto/hash.h header. In the future some QAPI types will want to reference the hash enums, so move the enum definition into QAPI too.
--- crypto/hash.c | 4 ++-- include/crypto/hash.h | 9 +-------- qapi/crypto.json | 15 +++++++++++++++ 3 files changed, 18 insertions(+), 10 deletions(-)
crypto/hash.c +2 -2
@@ -24,13 +24,13 @@#include <gnutls/gnutls.h> #include <gnutls/crypto.h> -static int qcrypto_hash_alg_map[QCRYPTO_HASH_ALG_LAST ] = { +static int qcrypto_hash_alg_map[QCRYPTO_HASH_ALG_MAX ] = { [QCRYPTO_HASH_ALG_MD5 ] =GNUTLS_DIG_MD5 , [QCRYPTO_HASH_ALG_SHA1 ] =GNUTLS_DIG_SHA1 , [QCRYPTO_HASH_ALG_SHA256 ] =GNUTLS_DIG_SHA256 , }; -static size_t qcrypto_hash_alg_size[QCRYPTO_HASH_ALG_LAST ] = { +static size_t qcrypto_hash_alg_size[QCRYPTO_HASH_ALG_MAX ] = { [QCRYPTO_HASH_ALG_MD5 ] =16 , [QCRYPTO_HASH_ALG_SHA1 ] =20 , [QCRYPTO_HASH_ALG_SHA256 ] =32 ,
include/crypto/hash.h +1 -8
@@ -24,14 +24,7 @@#include "qemu-common.h" #include "qapi/error.h" -typedef enum { -QCRYPTO_HASH_ALG_MD5 , -QCRYPTO_HASH_ALG_SHA1 , -QCRYPTO_HASH_ALG_SHA256 , - -QCRYPTO_HASH_ALG_LAST -}QCryptoHashAlgorithm ; - +/* See also "QCryptoHashAlgorithm" defined in qapi/crypto.json */ /** * qcrypto_hash_supports:
qapi/crypto.json +15 -0
@@ -33,3 +33,18 @@ { 'enum': 'QCryptoSecretFormat', 'prefix': 'QCRYPTO_SECRET_FORMAT', 'data': ['raw', 'base64']} + + +## +# QCryptoHashAlgorithm: +# +# The supported algorithms for computing content digests +# +# @md5: MD5. Should not be used in any new code, legacy compat only +# @sha1: SHA-1. Should not be used in any new code, legacy compat only +# @sha256: SHA-256. Current recommended strong hash. +# Since: 2.6 +## +{ 'enum': 'QCryptoHashAlgorithm', + 'prefix': 'QCRYPTO_HASH_ALG', + 'data': ['md5', 'sha1', 'sha256']}
Signature · 1 line
2.5.0
PATCH 19/30 crypto: move QCryptoCipherAlgorithm/Mode enum definitions into QAPI
In reply to Daniel P. BerrangeThe QCryptoCipherAlgorithm and QCryptoCipherMode enums are defined in the crypto/cipher.h header. In the future some QAPI types will want to reference the hash enums, so move the enum definition into QAPI too.
--- crypto/cipher.c | 8 ++++---- include/crypto/cipher.h | 17 ++--------------- qapi/crypto.json | 30 ++++++++++++++++++++++++++++++ 3 files changed, 36 insertions(+), 19 deletions(-)
crypto/cipher.c +4 -4
@@ -21,21 +21,21 @@#include "crypto/cipher.h" -static size_t alg_key_len[QCRYPTO_CIPHER_ALG_LAST ] = { +static size_t alg_key_len[QCRYPTO_CIPHER_ALG_MAX ] = { [QCRYPTO_CIPHER_ALG_AES_128 ] =16 , [QCRYPTO_CIPHER_ALG_AES_192 ] =24 , [QCRYPTO_CIPHER_ALG_AES_256 ] =32 , [QCRYPTO_CIPHER_ALG_DES_RFB ] =8 , }; -static size_t alg_block_len[QCRYPTO_CIPHER_ALG_LAST ] = { +static size_t alg_block_len[QCRYPTO_CIPHER_ALG_MAX ] = { [QCRYPTO_CIPHER_ALG_AES_128 ] =16 , [QCRYPTO_CIPHER_ALG_AES_192 ] =16 , [QCRYPTO_CIPHER_ALG_AES_256 ] =16 , [QCRYPTO_CIPHER_ALG_DES_RFB ] =8 , }; -static bool mode_need_iv[QCRYPTO_CIPHER_MODE_LAST ] = { +static bool mode_need_iv[QCRYPTO_CIPHER_MODE_MAX ] = { [QCRYPTO_CIPHER_MODE_ECB ] = false, [QCRYPTO_CIPHER_MODE_CBC ] = true, };
@@ -81,7 +81,7 @@ qcrypto_cipher_validate_key_length(QCryptoCipherAlgorithm alg, size_t nkey, Error **errp) { -if ((unsigned )alg >=QCRYPTO_CIPHER_ALG_LAST ) { +if ((unsigned )alg >=QCRYPTO_CIPHER_ALG_MAX ) {error_setg (errp,"Cipher algorithm %d out of range" , alg);return false;
include/crypto/cipher.h +2 -15
@@ -26,21 +26,8 @@typedef struct QCryptoCipher QCryptoCipher ; -typedef enum { -QCRYPTO_CIPHER_ALG_AES_128 , -QCRYPTO_CIPHER_ALG_AES_192 , -QCRYPTO_CIPHER_ALG_AES_256 , -QCRYPTO_CIPHER_ALG_DES_RFB ,/* A stupid variant on DES for VNC */ - -QCRYPTO_CIPHER_ALG_LAST -}QCryptoCipherAlgorithm ; - -typedef enum { -QCRYPTO_CIPHER_MODE_ECB , -QCRYPTO_CIPHER_MODE_CBC , - -QCRYPTO_CIPHER_MODE_LAST -}QCryptoCipherMode ; +/* See also "QCryptoCipherAlgorithm" and "QCryptoCipherMode" +* enums defined in qapi/crypto.json */ /** * QCryptoCipher:
qapi/crypto.json +30 -0
@@ -48,3 +48,33 @@ { 'enum': 'QCryptoHashAlgorithm', 'prefix': 'QCRYPTO_HASH_ALG', 'data': ['md5', 'sha1', 'sha256']} + + +## +# QCryptoCipherAlgorithm: +# +# The supported algorithms for content encryption ciphers +# +# @aes-128: AES with 128 bit / 16 byte keys +# @aes-192: AES with 192 bit / 24 byte keys +# @aes-256: AES with 256 bit / 32 byte keys +# @des-rfb: RFB specific variant of single DES. Do not use except in VNC. +# Since: 2.6 +## +{ 'enum': 'QCryptoCipherAlgorithm', + 'prefix': 'QCRYPTO_CIPHER_ALG', + 'data': ['aes-128', 'aes-192', 'aes-256', 'des-rfb']} + + +## +# QCryptoCipherMode: +# +# The supported modes for content encryption ciphers +# +# @ecb: Electronic Code Book +# @cbc: Cipher Block Chaining +# Since: 2.6 +## +{ 'enum': 'QCryptoCipherMode', + 'prefix': 'QCRYPTO_CIPHER_MODE', + 'data': ['ecb', 'cbc']}
Signature · 1 line
2.5.0
PATCH 20/30 crypto: ensure qapi/crypto.json is listed in qapi-modules
In reply to Daniel P. BerrangeThe rebuild of qapi-types.c/h is not correctly triggered when qapi/crypto.json is changed because it was missing from the list of files in the qapi-modules variable.
--- Makefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
Makefile +2 -1
@@ -269,7 +269,8 @@ $(SRC_PATH)/qga/qapi-schema.json $(SRC_PATH)/scripts/qapi-commands.py $(qapi-py) qapi-modules = $(SRC_PATH)/qapi-schema.json $(SRC_PATH)/qapi/common.json \ $(SRC_PATH)/qapi/block.json $(SRC_PATH)/qapi/block-core.json \ - $(SRC_PATH)/qapi/event.json $(SRC_PATH)/qapi/introspect.json + $(SRC_PATH)/qapi/event.json $(SRC_PATH)/qapi/introspect.json \ + $(SRC_PATH)/qapi/crypto.json qapi-types.c qapi-types.h :\ $(qapi-modules) $(SRC_PATH)/scripts/qapi-types.py $(qapi-py)
Signature · 1 line
2.5.0
PATCH 21/30 crypto: add cryptographic random byte source
In reply to Daniel P. Berrange--- crypto/Makefile.objs | 1 + crypto/random.c | 50 +++++++++++++++++++++++++++++++++++++++++++++++++ include/crypto/random.h | 43 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 94 insertions(+) create mode 100644 crypto/random.c create mode 100644 include/crypto/random.h
crypto/Makefile.objs +1 -0
@@ -8,6 +8,7 @@ crypto-obj-y += tlscredsanon.o crypto-obj-y += tlscredsx509.o crypto-obj-y += tlssession.o crypto-obj-y += secret.o +crypto-obj-y += random.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o
crypto/random.c new file +50 -0
50 lines not on this page · raw message
include/crypto/random.h new file +43 -0
43 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 22/30 crypto: add support for PBKDF2 algorithm
In reply to Daniel P. BerrangeThe LUKS data format includes use of PBKDF2 (Password-Based Key Derivation Function). The Nettle library can provide an implementation of this, but we don't want code directly depending on a specific crypto library backend. Introduce a include/crypto/pbkdf.h header which defines a QEMU API for invoking PBKDK2. The initial implementations are backed by nettle & gcrypt, which are commonly available with distros shipping GNUTLS.
The test suite data is taken from the cryptsetup codebase under the LGPLv2.1+ license. This merely aims to verify that whatever backend we provide for this function in QEMU will comply with the spec.
--- crypto/Makefile.objs | 1 + crypto/pbkdf-gcrypt.c | 64 ++++++++ crypto/pbkdf-nettle.c | 63 ++++++++ crypto/pbkdf-stub.c | 39 +++++ crypto/pbkdf.c | 76 ++++++++++ include/crypto/pbkdf.h | 152 +++++++++++++++++++ tests/.gitignore | 1 + tests/Makefile | 2 + tests/test-crypto-pbkdf.c | 378 ++++++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 776 insertions(+) create mode 100644 crypto/pbkdf-gcrypt.c create mode 100644 crypto/pbkdf-nettle.c create mode 100644 crypto/pbkdf-stub.c create mode 100644 crypto/pbkdf.c create mode 100644 include/crypto/pbkdf.h create mode 100644 tests/test-crypto-pbkdf.c
crypto/Makefile.objs +1 -0
@@ -9,6 +9,7 @@ crypto-obj-y += tlscredsx509.o crypto-obj-y += tlssession.o crypto-obj-y += secret.o crypto-obj-y += random.o +crypto-obj-y += pbkdf.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o
crypto/pbkdf-gcrypt.c new file +64 -0
64 lines not on this page · raw message
crypto/pbkdf-nettle.c new file +63 -0
63 lines not on this page · raw message
crypto/pbkdf-stub.c new file +39 -0
@@ -0,0 +1,39 @@ +/* +* QEMU Crypto PBKDF support (Password-Based Key Derivation Function) +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +bool qcrypto_pbkdf2_supports (QCryptoHashAlgorithm hash) +{ +return false; +} + +int qcrypto_pbkdf2(QCryptoHashAlgorithm hash G_GNUC_UNUSED, + const uint8_t *key G_GNUC_UNUSED, + size_t nkey G_GNUC_UNUSED, + const uint8_t *salt G_GNUC_UNUSED, + size_t nsalt G_GNUC_UNUSED, + unsigned int iterations G_GNUC_UNUSED, + uint8_t *out G_GNUC_UNUSED, + size_t nout G_GNUC_UNUSED, +Error **errp) +{ +error_setg_errno (errp,ENOSYS , +"No crypto library supporting PBKDF in this build" ); +return -1 ; +}
crypto/pbkdf.c new file +76 -0
76 lines not on this page · raw message
include/crypto/pbkdf.h new file +152 -0
152 lines not on this page · raw message
tests/.gitignore +1 -0
@@ -13,6 +13,7 @@ test-blockjob-txn test-coroutine test-crypto-cipher test-crypto-hash +test-crypto-pbkdf test-crypto-secret test-crypto-tlscredsx509 test-crypto-tlscredsx509-work/
tests/Makefile +2 -0
@@ -85,6 +85,7 @@ check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlscredsx509$(EXESUF) check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) check-unit-$(CONFIG_LINUX) += tests/test-qga$(EXESUF) check-unit-y += tests/test-timed-average$(EXESUF) +check-unit-y += tests/test-crypto-pbkdf$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -471,6 +472,7 @@ tests/test-crypto-tlscredsx509$(EXESUF): tests/test-crypto-tlscredsx509.o \ tests/test-crypto-tlssession.o-cflags := $(TASN1_CFLAGS) tests/test-crypto-tlssession$(EXESUF): tests/test-crypto-tlssession.o \ tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o $(test-crypto-obj-y) +tests/test-crypto-pbkdf$(EXESUF): tests/test-crypto-pbkdf.o $(test-crypto-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/test-crypto-pbkdf.c new file +378 -0
378 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 23/30 crypto: add support for generating initialization vectors
In reply to Daniel P. BerrangeThere are a number of different algorithms that can be used to generate initialization vectors for disk encryption. This introduces a simple internal QCryptoBlockIV object to provide a consistent internal API to the different algorithms. The initially implemented algorithms are 'plain', 'plain64' and 'essiv', each matching the same named algorithm provided by the Linux kernel dm-crypt driver.
--- crypto/Makefile.objs | 4 ++ crypto/ivgen-essiv.c | 116 ++++++++++++++++++++++++++++++++ crypto/ivgen-essiv.h | 28 ++++++++ crypto/ivgen-plain.c | 60 +++++++++++++++++ crypto/ivgen-plain.h | 28 ++++++++ crypto/ivgen-plain64.c | 60 +++++++++++++++++ crypto/ivgen-plain64.h | 28 ++++++++ crypto/ivgen.c | 117 ++++++++++++++++++++++++++++++++ crypto/ivgenpriv.h | 47 +++++++++++++ include/crypto/ivgen.h | 167 +++++++++++++++++++++++++++++++++++++++++++++ qapi/crypto.json | 16 +++++ tests/.gitignore | 1 + tests/Makefile | 2 + tests/test-crypto-ivgen.c | 168 ++++++++++++++++++++++++++++++++++++++++++++++ 14 files changed, 842 insertions(+) create mode 100644 crypto/ivgen-essiv.c create mode 100644 crypto/ivgen-essiv.h create mode 100644 crypto/ivgen-plain.c create mode 100644 crypto/ivgen-plain.h create mode 100644 crypto/ivgen-plain64.c create mode 100644 crypto/ivgen-plain64.h create mode 100644 crypto/ivgen.c create mode 100644 crypto/ivgenpriv.h create mode 100644 include/crypto/ivgen.h create mode 100644 tests/test-crypto-ivgen.c
crypto/Makefile.objs +4 -0
@@ -10,6 +10,10 @@ crypto-obj-y += tlssession.o crypto-obj-y += secret.o crypto-obj-y += random.o crypto-obj-y += pbkdf.o +crypto-obj-y += ivgen.o +crypto-obj-y += ivgen-essiv.o +crypto-obj-y += ivgen-plain.o +crypto-obj-y += ivgen-plain64.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o
crypto/ivgen-essiv.c new file +116 -0
116 lines not on this page · raw message
crypto/ivgen-essiv.h new file +28 -0
@@ -0,0 +1,28 @@ +/* +* QEMU Crypto block IV generator - essiv +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "crypto/ivgenpriv.h" + +#ifndef QCRYPTO_IVGEN_ESSIV_H__ +#define QCRYPTO_IVGEN_ESSIV_H__ + +extern struct QCryptoIVGenDriver qcrypto_ivgen_essiv; + +#endif /* QCRYPTO_IVGEN_ESSIV_H__ */
crypto/ivgen-plain.c new file +60 -0
60 lines not on this page · raw message
crypto/ivgen-plain.h new file +28 -0
@@ -0,0 +1,28 @@ +/* +* QEMU Crypto block IV generator - plain +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "crypto/ivgenpriv.h" + +#ifndef QCRYPTO_IVGEN_PLAIN_H__ +#define QCRYPTO_IVGEN_PLAIN_H__ + +extern struct QCryptoIVGenDriver qcrypto_ivgen_plain; + +#endif /* QCRYPTO_IVGEN_PLAIN_H__ */
crypto/ivgen-plain64.c new file +60 -0
60 lines not on this page · raw message
crypto/ivgen-plain64.h new file +28 -0
@@ -0,0 +1,28 @@ +/* +* QEMU Crypto block IV generator - plain64 +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#include "crypto/ivgenpriv.h" + +#ifndef QCRYPTO_IVGEN_PLAIN64_H__ +#define QCRYPTO_IVGEN_PLAIN64_H__ + +extern struct QCryptoIVGenDriver qcrypto_ivgen_plain64; + +#endif /* QCRYPTO_IVGEN_PLAIN64_H__ */
crypto/ivgen.c new file +117 -0
117 lines not on this page · raw message
crypto/ivgenpriv.h new file +47 -0
47 lines not on this page · raw message
include/crypto/ivgen.h new file +167 -0
167 lines not on this page · raw message
qapi/crypto.json +16 -0
@@ -78,3 +78,19 @@ { 'enum': 'QCryptoCipherMode', 'prefix': 'QCRYPTO_CIPHER_MODE', 'data': ['ecb', 'cbc']} + + +## +# QCryptoIVGenAlgorithm: +# +# The supported algorithms for generating initialization +# vectors for full disk encryption +# +# @plain: 64-bit sector number truncated to 32-bits +# @plain64: 64-bit sector number +# @essiv: 64-bit sector number encrypted with a hash of the encryption key +# Since: 2.6 +## +{ 'enum': 'QCryptoIVGenAlgorithm', + 'prefix': 'QCRYPTO_IVGEN_ALG', + 'data': ['plain', 'plain64', 'essiv']}
tests/.gitignore +1 -0
@@ -13,6 +13,7 @@ test-blockjob-txn test-coroutine test-crypto-cipher test-crypto-hash +test-crypto-ivgen test-crypto-pbkdf test-crypto-secret test-crypto-tlscredsx509
tests/Makefile +2 -0
@@ -86,6 +86,7 @@ check-unit-$(CONFIG_GNUTLS) += tests/test-crypto-tlssession$(EXESUF) check-unit-$(CONFIG_LINUX) += tests/test-qga$(EXESUF) check-unit-y += tests/test-timed-average$(EXESUF) check-unit-y += tests/test-crypto-pbkdf$(EXESUF) +check-unit-y += tests/test-crypto-ivgen$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -473,6 +474,7 @@ tests/test-crypto-tlssession.o-cflags := $(TASN1_CFLAGS) tests/test-crypto-tlssession$(EXESUF): tests/test-crypto-tlssession.o \ tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o $(test-crypto-obj-y) tests/test-crypto-pbkdf$(EXESUF): tests/test-crypto-pbkdf.o $(test-crypto-obj-y) +tests/test-crypto-ivgen$(EXESUF): tests/test-crypto-ivgen.o $(test-crypto-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/test-crypto-ivgen.c new file +168 -0
168 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 24/30 crypto: add support for anti-forensic split algorithm
In reply to Daniel P. BerrangeThe LUKS format specifies an anti-forensic split algorithm which is used to artificially expand the size of the key material on disk. This is an implementation of that algorithm.
--- crypto/Makefile.objs | 1 + crypto/afsplit.c | 194 ++++++++++++++++++++++++++++++++++++++++++++ include/crypto/afsplit.h | 133 ++++++++++++++++++++++++++++++ tests/.gitignore | 1 + tests/Makefile | 2 + tests/test-crypto-afsplit.c | 176 ++++++++++++++++++++++++++++++++++++++++ 6 files changed, 507 insertions(+) create mode 100644 crypto/afsplit.c create mode 100644 include/crypto/afsplit.h create mode 100644 tests/test-crypto-afsplit.c
crypto/Makefile.objs +1 -0
@@ -14,6 +14,7 @@ crypto-obj-y += ivgen.o crypto-obj-y += ivgen-essiv.o crypto-obj-y += ivgen-plain.o crypto-obj-y += ivgen-plain64.o +crypto-obj-y += afsplit.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o
crypto/afsplit.c new file +194 -0
194 lines not on this page · raw message
include/crypto/afsplit.h new file +133 -0
133 lines not on this page · raw message
tests/.gitignore +1 -0
@@ -11,6 +11,7 @@ test-aio test-bitops test-blockjob-txn test-coroutine +test-crypto-afsplit test-crypto-cipher test-crypto-hash test-crypto-ivgen
tests/Makefile +2 -0
@@ -87,6 +87,7 @@ check-unit-$(CONFIG_LINUX) += tests/test-qga$(EXESUF) check-unit-y += tests/test-timed-average$(EXESUF) check-unit-y += tests/test-crypto-pbkdf$(EXESUF) check-unit-y += tests/test-crypto-ivgen$(EXESUF) +check-unit-y += tests/test-crypto-afsplit$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -475,6 +476,7 @@ tests/test-crypto-tlssession$(EXESUF): tests/test-crypto-tlssession.o \ tests/crypto-tls-x509-helpers.o tests/pkix_asn1_tab.o $(test-crypto-obj-y) tests/test-crypto-pbkdf$(EXESUF): tests/test-crypto-pbkdf.o $(test-crypto-obj-y) tests/test-crypto-ivgen$(EXESUF): tests/test-crypto-ivgen.o $(test-crypto-obj-y) +tests/test-crypto-afsplit$(EXESUF): tests/test-crypto-afsplit.o $(test-crypto-obj-y) libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
tests/test-crypto-afsplit.c new file +176 -0
176 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 25/30 crypto: fix transposed arguments in cipher error message
In reply to Daniel P. BerrangeWhen reporting an incorrect key length for a cipher, we mixed up the actual vs expected arguments.
--- crypto/cipher.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
crypto/cipher.c +1 -1
@@ -89,7 +89,7 @@ qcrypto_cipher_validate_key_length(QCryptoCipherAlgorithm alg,if (alg_key_len[alg] != nkey) {error_setg (errp,"Cipher key length %zu should be %zu" , - alg_key_len[alg], nkey); + nkey, alg_key_len[alg]);return false; }return true;
Signature · 1 line
2.5.0
PATCH 26/30 crypto: add block encryption framework
In reply to Daniel P. BerrangeAdd a generic framework for support different block encryption formats. Upon instantiating a QCryptoBlock object, it will read the encryption header and extract the encryption keys. It is then possible to call methods to encrypt/decrypt data buffers.
There is also a mode whereby it will create/initialize a new encryption header on a previously unformatted volume.
The initial framework comes with support for the legacy QCow AES based encryption. This enables code in the QCow driver to be consolidated later.
--- crypto/Makefile.objs | 2 + crypto/block-qcowaes.c | 150 +++++++++++++++++++++++++++++ crypto/block-qcowaes.h | 28 ++++++ crypto/block.c | 251 +++++++++++++++++++++++++++++++++++++++++++++++++ crypto/blockpriv.h | 87 +++++++++++++++++ include/crypto/block.h | 199 +++++++++++++++++++++++++++++++++++++++ qapi/crypto.json | 62 ++++++++++++ 7 files changed, 779 insertions(+) create mode 100644 crypto/block-qcowaes.c create mode 100644 crypto/block-qcowaes.h create mode 100644 crypto/block.c create mode 100644 crypto/blockpriv.h create mode 100644 include/crypto/block.h
crypto/Makefile.objs +2 -0
@@ -15,6 +15,8 @@ crypto-obj-y += ivgen-essiv.o crypto-obj-y += ivgen-plain.o crypto-obj-y += ivgen-plain64.o crypto-obj-y += afsplit.o +crypto-obj-y += block.o +crypto-obj-y += block-qcowaes.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o
crypto/block-qcowaes.c new file +150 -0
150 lines not on this page · raw message
crypto/block-qcowaes.h new file +28 -0
@@ -0,0 +1,28 @@ +/* +* QEMU Crypto block device encryption QCow AES format +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QCRYPTO_BLOCK_QCOWAES_H__ +#define QCRYPTO_BLOCK_QCOWAES_H__ + +#include "crypto/blockpriv.h" + +extern const QCryptoBlockDriver qcrypto_block_driver_qcowaes; + +#endif /* QCRYPTO_BLOCK_QCOWAES_H__ */
crypto/block.c new file +251 -0
251 lines not on this page · raw message
crypto/blockpriv.h new file +87 -0
87 lines not on this page · raw message
include/crypto/block.h new file +199 -0
199 lines not on this page · raw message
qapi/crypto.json +62 -0
65 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 27/30 crypto: implement the LUKS block encryption format
In reply to Daniel P. BerrangeProvide a block encryption implementation that follows the LUKS/dm-crypt specification.
This supports all combinations of hash, cipher algorithm, cipher mode and iv generator that are implemented by the current crypto layer.
The notable missing feature is support for the 'xts' cipher mode, which is commonly used for disk encryption instead of 'cbc'. This is because it is not provided by either nettle or libgcrypt. A suitable implementation will be identified & integrated later.
There is support for opening existing volumes formatted by dm-crypt, and for formatting new volumes. In the latter case it will only use key slot 0.
--- crypto/Makefile.objs | 1 + crypto/block-luks.c | 1056 ++++++++++++++++++++++++++++++++++++++++++++++++++ crypto/block-luks.h | 28 ++ crypto/block.c | 2 + qapi/crypto.json | 42 +- 5 files changed, 1126 insertions(+), 3 deletions(-) create mode 100644 crypto/block-luks.c create mode 100644 crypto/block-luks.h
crypto/Makefile.objs +1 -0
@@ -17,6 +17,7 @@ crypto-obj-y += ivgen-plain64.o crypto-obj-y += afsplit.o crypto-obj-y += block.o crypto-obj-y += block-qcowaes.o +crypto-obj-y += block-luks.o # Let the userspace emulators avoid linking gnutls/etc crypto-aes-obj-y = aes.o
crypto/block-luks.c new file +1056 -0
1,056 lines not on this page · raw message
crypto/block-luks.h new file +28 -0
@@ -0,0 +1,28 @@ +/* +* QEMU Crypto block device encryption LUKS format +* +* Copyright (c) 2015 Red Hat, Inc. +* +* This library is free software; you can redistribute it and/or +* modify it under the terms of the GNU Lesser General Public +* License as published by the Free Software Foundation; either +* version 2 of the License, or (at your option) any later version. +* +* This library is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this library; if not, see <http://www.gnu.org/licenses/>. +* +*/ + +#ifndef QCRYPTO_BLOCK_LUKS_H__ +#define QCRYPTO_BLOCK_LUKS_H__ + +#include "crypto/blockpriv.h" + +extern const QCryptoBlockDriver qcrypto_block_driver_luks; + +#endif /* QCRYPTO_BLOCK_LUKS_H__ */
crypto/block.c +2 -0
@@ -20,9 +20,11 @@#include "crypto/blockpriv.h" #include "crypto/block-qcowaes.h" +#include "crypto/block-luks.h" static const QCryptoBlockDriver *qcrypto_block_drivers[] = { [Q_CRYPTO_BLOCK_FORMAT_QCOWAES ] = &qcrypto_block_driver_qcowaes, + [Q_CRYPTO_BLOCK_FORMAT_LUKS ] = &qcrypto_block_driver_luks, };
qapi/crypto.json +39 -3
67 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 28/30 block: add generic full disk encryption driver
In reply to Daniel P. BerrangeAdd a block driver that is capable of supporting any full disk encryption format. This utilizes the previously added block encryption code, and at this time supports the LUKS format.
The driver code is capable of supporting any format supported by the QCryptoBlock module, so it registers one block driver for each format.
At this time, the "luks" driver is registered. A new LUKS compatible volume can be formatted using qemu-img
$ qemu-img create --object secret,data=123456,id=sec0 \
-f luks -o keyid=sec0,cipher_alg=aes-256,\
cipher_mode=cbc,ivgen_alg=plain64,hash_alg=sha256 \
demo.luks 10GAnd query its size
$ qemu-img info --object secret,data=123456,id=sec0 --source demo.luks,driver=luks,keyid=sec0
image: json:{"keyid": "sec0", "driver": "luks", "file": {"driver": "file", "filename": "demo.luks"}}
file format: luks
virtual size: 10.0G (10737416192 bytes)
disk size: 132K--- block/Makefile.objs | 2 + block/fde.c | 522 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 524 insertions(+) create mode 100644 block/fde.c
block/Makefile.objs +2 -0
@@ -23,6 +23,8 @@ block-obj-$(CONFIG_LIBSSH2) += ssh.o block-obj-y += accounting.o block-obj-y += write-threshold.o +block-obj-y += fde.o + common-obj-y += stream.o common-obj-y += commit.o common-obj-y += backup.o
block/fde.c new file +522 -0
522 lines not on this page · raw message
Signature · 1 line
2.5.0
PATCH 29/30 qcow2: convert QCow2 to use QCryptoBlock for encryption
In reply to Daniel P. BerrangeThe QCryptoBlock framework trivially supports the legecy QCow encryption format. Convert QCow2 to use QCryptoBlock, since this will unlock the ability to support LUKS in QCow2 without increasing the code burden for encryption in QCow2.
--- block/qcow2-cluster.c | 46 ++------------------- block/qcow2.c | 108 +++++++++++++++++++------------------------------- block/qcow2.h | 5 ++- 3 files changed, 48 insertions(+), 111 deletions(-)
block/qcow2-cluster.c +4 -42
@@ -341,45 +341,6 @@ static int count_contiguous_clusters_by_type(int nb_clusters,return i; } -int qcow2_encrypt_sectors (BDRVQcow2State *s,int64_t sector_num, -uint8_t *buf,int nb_sectors,bool enc, -Error **errp) -{ -union { -uint64_t ll[2 ]; -uint8_t b[16 ]; - } ivec; -int i; -int ret; - -for (i =0 ; i < nb_sectors; i++) { - ivec.ll[0 ] =cpu_to_le64 (sector_num); - ivec.ll[1 ] =0 ; -if (qcrypto_cipher_setiv (s->cipher, - ivec.b,G_N_ELEMENTS (ivec.b), - errp) <0 ) { -return -1 ; - } -if (enc) { - ret =qcrypto_cipher_encrypt (s->cipher, - buf, buf, -512 , - errp); - }else { - ret =qcrypto_cipher_decrypt (s->cipher, - buf, buf, -512 , - errp); - } -if (ret <0 ) { -return -1 ; - } - sector_num++; - buf +=512 ; - } -return 0 ; -} - static int coroutine_fn copy_sectors(BlockDriverState *bs, uint64_t start_sect, uint64_t cluster_offset,
@@ -421,10 +382,11 @@ static int coroutine_fn copy_sectors(BlockDriverState *bs,if (bs->encrypted) {Error *err =NULL ; -assert (s->cipher); -if (qcow2_encrypt_sectors (s, start_sect + n_start, +assert (s->fde); +if (qcrypto_block_encrypt (s->fde, + start_sect + n_start, iov.iov_base, n, - true, &err) <0 ) { + &err) <0 ) { ret = -EIO ;error_free (err); goto out;
block/qcow2.c +41 -67
219 lines not on this page · raw message
block/qcow2.h +3 -2
@@ -25,7 +25,7 @@#ifndef BLOCK_QCOW2_H #define BLOCK_QCOW2_H -#include "crypto/cipher.h" +#include "crypto/block.h" #include "qemu/coroutine.h" //#define DEBUG_ALLOC
@@ -257,7 +257,8 @@ typedef struct BDRVQcow2State {CoMutex lock; -QCryptoCipher *cipher;/* current cipher, NULL if no key yet */ +QCryptoBlockOpenOptions *fde_opts;/* Disk encryption runtime options */ +QCryptoBlock *fde;/* Disk encryption format driver */ uint32_t crypt_method_header;uint64_t snapshots_offset;int snapshots_size;
Signature · 1 line
2.5.0
PATCH 30/30 qcow2: add LUKS full disk encryption support
In reply to Daniel P. BerrangeThe QCow2 format currently has support for built-in AES encryption, however, this is fundamentally flawed from a cryptographic security POV, so its use is deprecated. The previously added generic full disk encryption driver could be used to encrypt QCow2 files by either laying it above or below the QCow2 driver in the QEMU BlockBackend tree.
If it is layered above (FDE -> QCow2 -> File), then only the image payload will be encrypted. There is no safe way to auto-detect use of FDE for the image payload, as you cannot safely distinguish between a QCow2 image that has the FDE driver layered above in the host, from a QCow2 image where the guest is using LUKS over a partitionless drive. Layering above the image is a valid use case, but this auto-detection limitation makes it undesirable as a default approach for QCow2 encryption.
If it is layered below (QCow2 -> FDE -> File), then both the image payload and QCow2 headers are encrypted. This makes it impossible to query the disk image to determine its logical disk size, or backing file requirements without first unlocking the decryption key. This is again a valid use case for scenarios where it is desirable to avoid any leakage of information about the underling disk format, but it is undesirable as a default approach for QCow2 encryption.
Thus this patch takes a third approach of integrating LUKS support directly into the QCow2 file format. Only the image payload is encrypted, the QCow2 file header remainins in clear text. Thus makes it possible to probe info about the disk size, backing files, etc without needing decryption keys. Since use of LUKS is encoded in the QCow2 header, it is still possible to reliabily distinguish host side encryption from guest side encryption.
First a new QCow2 encryption scheme is defined to represent the LUKS format, with a value '2' (0 == plain text, 1 == the legacy AES format). A corresponding new QCow2 header extension is defined to hold the LUKS partition header data. This stores the various encryption parameters and key slot metadata and the encrypted master keys. The payload of the QCow2 file does not change in structure. Sectors are simply processed via the QCryptoBlock object to apply/remove encryption when required.
--- block/qcow2.c | 294 +++++++++++++++++++++++++++++++++++++++++++++++++-- block/qcow2.h | 11 +- docs/specs/qcow2.txt | 53 ++++++++++ 3 files changed, 347 insertions(+), 11 deletions(-)
block/qcow2.c +284 -10
@@ -35,6 +35,8 @@#include "trace.h" #include "qemu/option_int.h" #include "crypto/secret.h" +#include "qapi/opts-visitor.h" +#include "qapi-visit.h" /* Differences with QCOW:
@@ -61,6 +63,7 @@ typedef struct {#define QCOW2_EXT_MAGIC_END 0#define QCOW2_EXT_MAGIC_BACKING_FORMAT 0xE2792ACA#define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857 +#define QCOW2_EXT_MAGIC_LUKS_HEADER 0x4c554b53static int qcow2_probe (const uint8_t *buf,int buf_size,const char *filename) {
@@ -75,6 +78,63 @@ static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename) } +struct QCow2FDEData { +BlockDriverState *bs; +size_t hdr_ext_offset;/* Offset of encryption header extension data */ +size_t hdr_ext_length;/* Length of encryption header extension data */ +}; + +static ssize_t qcow2_header_read_func (QCryptoBlock *block, +size_t offset, +uint8_t *buf, +size_t buflen, +Error **errp, +void *opaque) +{ +struct QCow2FDEData *data = opaque; +ssize_t ret; + +if ((offset + buflen) > data->hdr_ext_length) { +error_setg_errno (errp,EINVAL , +"Request for data outside of extension header" ); +return -1 ; + } + + ret =bdrv_pread (data->bs->file->bs, + data->hdr_ext_offset + offset, buf, buflen); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Could not read encryption header" ); +return ret; + } +return ret; +} + + +static ssize_t qcow2_header_write_func (QCryptoBlock *block, +size_t offset, +const uint8_t *buf, +size_t buflen, +Error **errp, +void *opaque) +{ +struct QCow2FDEData *data = opaque; +ssize_t ret; + +if ((offset + buflen) > data->hdr_ext_length) { +error_setg_errno (errp,EINVAL , +"Request for data outside of extension header" ); +return -1 ; + } + + ret =bdrv_pwrite (data->bs, data->hdr_ext_offset + offset, buf, buflen); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Could not read encryption header" ); +return ret; + } +return ret; +} + +/* * read qcow2 extension and fill bs * start reading from start_offset
@@ -90,6 +150,7 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,QCowExtension ext;uint64_t offset;int ret; +struct QCow2FDEData fdedata;#ifdef DEBUG_EXT printf ("qcow2_read_extensions: start=%ld end=%ld\n" , start_offset, end_offset);
@@ -160,6 +221,24 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset, }break ; +case QCOW2_EXT_MAGIC_LUKS_HEADER : +if (s->crypt_method_header !=QCOW_CRYPT_LUKS ) { +error_setg (errp,"LUKS header extension only " +"expected with LUKS encryption method" ); +return -EINVAL ; + } + fdedata.bs = bs; + fdedata.hdr_ext_offset = offset; + fdedata.hdr_ext_length = ext.len; + + s->fde =qcrypto_block_open (s->fde_opts, + qcow2_header_read_func, + &fdedata, + errp); +if (!s->fde) { +return -EINVAL ; + } +break ;default :/* unknown magic - save it in case we need to rewrite the header */ {
@@ -474,7 +553,7 @@ static QemuOptsList qcow2_runtime_opts = { .help = "Clean unused cache entries after this time (in seconds)", }, { - .name = QCOW2_OPT_KEY_ID, + .name = QCOW2_OPT_FDE_KEY_ID, .type = QEMU_OPT_STRING, .help = "ID of the secret that provides the encryption key", },
@@ -595,6 +674,98 @@ static void read_cache_sizes(BlockDriverState *bs, QemuOpts *opts, } } + +static QCryptoBlockOpenOptions * +qcow2_fde_open_opts_init (QCryptoBlockFormat format, +QemuOpts *opts, +Error **errp) +{ +OptsVisitor *ov; +QCryptoBlockOpenOptions *ret; +Error *local_err =NULL ; + + ret =g_new0 (QCryptoBlockOpenOptions,1 ); + ret->format = format; + + ov =opts_visitor_new (opts); + +switch (format) { +case Q_CRYPTO_BLOCK_FORMAT_QCOWAES : + ret->u.qcowaes =g_new0 (QCryptoBlockOptionsQCowAES,1 ); +visit_type_QCryptoBlockOptionsQCowAES (opts_get_visitor (ov), + &ret->u.qcowaes, +"qcowaes" , &local_err); +break ; + +case Q_CRYPTO_BLOCK_FORMAT_LUKS : + ret->u.luks =g_new0 (QCryptoBlockOptionsLUKS,1 ); +visit_type_QCryptoBlockOptionsLUKS (opts_get_visitor (ov), + &ret->u.luks,"luks" , &local_err); +break ; + +default : +error_setg (&local_err,"Unsupported block format %d" , format); +break ; + } + +if (local_err) { +error_propagate (errp, local_err); +opts_visitor_cleanup (ov); +qapi_free_QCryptoBlockOpenOptions (ret); +return NULL ; + } + +opts_visitor_cleanup (ov); +return ret; +} + + +static QCryptoBlockCreateOptions * +qcow2_fde_create_opts_init (QCryptoBlockFormat format, +QemuOpts *opts, +Error **errp) +{ +OptsVisitor *ov; +QCryptoBlockCreateOptions *ret; +Error *local_err =NULL ; + + ret =g_new0 (QCryptoBlockCreateOptions,1 ); + ret->format = format; + + ov =opts_visitor_new (opts); + +switch (format) { +case Q_CRYPTO_BLOCK_FORMAT_QCOWAES : + ret->u.qcowaes =g_new0 (QCryptoBlockOptionsQCowAES,1 ); +visit_type_QCryptoBlockOptionsQCowAES (opts_get_visitor (ov), + &ret->u.qcowaes, +"qcowaes" , &local_err); +break ; + +case Q_CRYPTO_BLOCK_FORMAT_LUKS : + ret->u.luks =g_new0 (QCryptoBlockCreateOptionsLUKS,1 ); +visit_type_QCryptoBlockCreateOptionsLUKS (opts_get_visitor (ov), + &ret->u.luks, +"luks" , &local_err); +break ; + +default : +error_setg (&local_err,"Unsupported block format %d" , format); +break ; + } + +if (local_err) { +error_propagate (errp, local_err); +opts_visitor_cleanup (ov); +qapi_free_QCryptoBlockCreateOptions (ret); +return NULL ; + } + +opts_visitor_cleanup (ov); +return ret; +} + + typedef struct Qcow2ReopenState { Qcow2Cache *l2_table_cache; Qcow2Cache *refcount_block_cache;
@@ -761,13 +932,30 @@ static int qcow2_update_options_prepare(BlockDriverState *bs, r->discard_passthrough[QCOW2_DISCARD_OTHER ] =qemu_opt_get_bool (opts,QCOW2_OPT_DISCARD_OTHER , false); -if (s->crypt_method_header) { - r->fde_opts =g_new0 (QCryptoBlockOpenOptions,1 ); - r->fde_opts->format =Q_CRYPTO_BLOCK_FORMAT_QCOWAES ; - r->fde_opts->u.qcowaes =g_new0 (QCryptoBlockOptionsQCowAES,1 ); +switch (s->crypt_method_header) { +case QCOW_CRYPT_NONE : +break ; + +case QCOW_CRYPT_AES : + r->fde_opts =qcow2_fde_open_opts_init ( +Q_CRYPTO_BLOCK_FORMAT_QCOWAES , + opts, + errp); +break ; - r->fde_opts->u.qcowaes->keyid = -g_strdup (qemu_opt_get (opts,QCOW2_OPT_KEY_ID )); +case QCOW_CRYPT_LUKS : + r->fde_opts =qcow2_fde_open_opts_init ( +Q_CRYPTO_BLOCK_FORMAT_QCOWAES , + opts, + errp); +break ; + +default : +g_assert_not_reached (); + } +if (s->crypt_method_header && + !r->fde_opts) { + goto fail; } ret =0 ;
@@ -1102,7 +1290,7 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, }if (!(flags &BDRV_O_NO_IO ) && - bs->encrypted) { + s->crypt_method_header ==QCOW_CRYPT_AES ) { s->fde =qcrypto_block_open (s->fde_opts,NULL ,NULL , errp);
@@ -1143,6 +1331,13 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } +if (!(flags &BDRV_O_NO_IO ) && + bs->encrypted && !s->fde) { +error_setg (errp,"No encryption layer was initiailized" ); + ret = -EINVAL ; + goto fail; + } +/* read the backing file name */ if (header.backing_file_offset !=0 ) { len = header.backing_file_size;
@@ -2013,6 +2208,10 @@ static int qcow2_create2(const char *filename, int64_t total_size, {int cluster_bits;QDict *options; +const char *fdestr; +QCryptoBlockCreateOptions *fdeopts =NULL ; +QCryptoBlock *fde =NULL ; +size_t i;/* Calculate cluster_bits */ cluster_bits =ctz32 (cluster_size);
@@ -2135,8 +2334,35 @@ static int qcow2_create2(const char *filename, int64_t total_size, .header_length = cpu_to_be32(sizeof(*header)), }; -if (flags &BLOCK_FLAG_ENCRYPT ) { - header->crypt_method =cpu_to_be32 (QCOW_CRYPT_AES ); + fdestr =qemu_opt_get (opts,QCOW2_OPT_FDE ); +if (fdestr) { +for (i =0 ; i <Q_CRYPTO_BLOCK_FORMAT_MAX ; i++) { +if (g_str_equal (QCryptoBlockFormat_lookup[i], + fdestr)) { + fdeopts =qcow2_fde_create_opts_init (i, + opts, + errp); +if (!fdeopts) { + goto out; + } +break ; + } + } +if (!fdeopts) { +error_setg (errp,"Unknown fde format %s" , fdestr); + goto out; + } +switch (fdeopts->format) { +case Q_CRYPTO_BLOCK_FORMAT_QCOWAES : + header->crypt_method =cpu_to_be32 (QCOW_CRYPT_AES ); +break ; +case Q_CRYPTO_BLOCK_FORMAT_LUKS : + header->crypt_method =cpu_to_be32 (QCOW_CRYPT_LUKS ); +break ; +default : +error_setg (errp,"Unsupported fde format %s" , fdestr); + goto out; + } }else { header->crypt_method =cpu_to_be32 (QCOW_CRYPT_NONE ); }
@@ -2153,6 +2379,24 @@ static int qcow2_create2(const char *filename, int64_t total_size, goto out; } +/* XXXX this is roughly where we need to write the LUKS header, +* but its not going to fit inside the first cluster. Need to +* allow qcow2 header extensions to consume >1 cluster.... +*/ +if (fdeopts &&0 ) { +struct QCow2FDEData fdedata; + fdedata.bs = bs; + fdedata.hdr_ext_offset = cluster_size; + + fde =qcrypto_block_create (fdeopts, + qcow2_header_write_func, + &fdedata, + errp); +if (!fde) { + goto out; + } + } +/* Write a refcount table with one refcount block */ refcount_table =g_malloc0 (2 * cluster_size); refcount_table[0 ] =cpu_to_be64 (2 * cluster_size);
@@ -3136,6 +3380,36 @@ static QemuOptsList qcow2_create_opts = { .help = "Width of a reference count entry in bits", .def_value_str = "16" }, + { + .name = QCOW2_OPT_FDE_KEY_ID, + .type = QEMU_OPT_STRING, + .help = "ID of the secret that provides the encryption key", + }, + { + .name = QCOW2_OPT_FDE_CIPHER_ALG, + .type = QEMU_OPT_STRING, + .help = "Name of encryption cipher algorithm", + }, + { + .name = QCOW2_OPT_FDE_CIPHER_MODE, + .type = QEMU_OPT_STRING, + .help = "Name of encryption cipher mode", + }, + { + .name = QCOW2_OPT_FDE_IVGEN_ALG, + .type = QEMU_OPT_STRING, + .help = "Name of IV generator algorithm", + }, + { + .name = QCOW2_OPT_FDE_IVGEN_HASH_ALG, + .type = QEMU_OPT_STRING, + .help = "Name of IV generator hash algorithm", + }, + { + .name = QCOW2_OPT_FDE_HASH_ALG, + .type = QEMU_OPT_STRING, + .help = "Name of encryption hash algorithm", + }, { /* end of list */ } } };
block/qcow2.h +10 -1
@@ -36,6 +36,7 @@#define QCOW_CRYPT_NONE 0#define QCOW_CRYPT_AES 1 +#define QCOW_CRYPT_LUKS 2#define QCOW_MAX_CRYPT_CLUSTERS 32#define QCOW_MAX_SNAPSHOTS 65536
@@ -97,7 +98,15 @@#define QCOW2_OPT_L2_CACHE_SIZE "l2-cache-size"#define QCOW2_OPT_REFCOUNT_CACHE_SIZE "refcount-cache-size"#define QCOW2_OPT_CACHE_CLEAN_INTERVAL "cache-clean-interval" -#define QCOW2_OPT_KEY_ID "keyid" + +#define QCOW2_OPT_FDE "fde" +#define QCOW2_OPT_FDE_KEY_ID "keyid" +#define QCOW2_OPT_FDE_CIPHER_ALG "cipher_alg" +#define QCOW2_OPT_FDE_CIPHER_MODE "cipher_mode" +#define QCOW2_OPT_FDE_IVGEN_ALG "ivgen_alg" +#define QCOW2_OPT_FDE_IVGEN_HASH_ALG "ivgen_hash_alg" +#define QCOW2_OPT_FDE_HASH_ALG "hash_alg" + typedef struct QCowHeader { uint32_t magic;
docs/specs/qcow2.txt +53 -0
71 lines not on this page · raw message
Signature · 1 line
2.5.0