Skip to contentSkip to conversation

Add framework for passing secrets to QEMU

PATCH Superseded Daniel P. Berrange 2 participants 11 messages Nov 27, 2015 – Dec 9, 2015 Crypto API

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v3 cover Add framework for passing secrets to QEMU

This small series contains just the first two patches for adding the secrets object to QEMU previously shown here:

https://lists.gnu.org/archive/html/qemu-devel/2015-11/msg04748.html

The QCryptoSecret object provides a QOM object that allows passing secrets (passwords, encryption keys, etc) to QEMU in a secure manner, via an external file, or on the CLI or monitor with encryption. It also uses this to allow use of encrypted x509 keys with the TLS handling code.

Changed in v3:

- s/adhoc/ad hoc/ (Eric)
- Fix mistake in unit test sample data (Eric)
- Permit inclusion of newline in base64 and test it (Eric)
- Switch to g_file_get_contents() instead of hand written equivalent (Eric)
- Add missing conversion to qbase64_decode (Eric)

Changed in v2:

- Fix version tag in QAPI schema to be 2.6 (Eric)
- Changed "echo -n" to "printf" (Eric)
- Misc typo fixes (Eric)
- Added a genmeric qbase64_decode() wrapper around g_base64_decode() that does error checking (Markus)
- Convert callers of g_base64_decode() to qbase64_decode() to get error checking (Markus)

Daniel P. Berrange (5):
util: add base64 decoding function
qemu-char: convert to use error checked base64 decode
qga: convert to use error checked base64 decode
crypto: add QCryptoSecret object class for password/key handling
crypto: add support for loading encrypted x509 keys

 crypto/Makefile.objs          |   1 +
 crypto/secret.c               | 524 ++++++++++++++++++++++++++++++++++++++++++
 crypto/tlscredsx509.c         |  48 ++++
 include/crypto/secret.h       | 148 ++++++++++++
 include/crypto/tlscredsx509.h |   1 +
 include/qemu/base64.h         |  56 +++++
 qapi-schema.json              |   2 -
 qapi/crypto.json              |  14 ++
 qemu-char.c                   |   8 +-
 qemu-options.hx               |  85 ++++++-
 qga/commands-posix.c          |  11 +-
 qga/commands-win32.c          |  11 +-
 qga/commands.c                |  13 +-
 qmp-commands.hx               |   2 -
 tests/.gitignore              |   2 +
 tests/Makefile                |   5 +
 tests/test-base64.c           |  98 ++++++++
 tests/test-crypto-secret.c    | 446 +++++++++++++++++++++++++++++++++++
 util/Makefile.objs            |   1 +
 util/base64.c                 |  60 +++++
 20 files changed, 1525 insertions(+), 11 deletions(-)
 create mode 100644 crypto/secret.c
 create mode 100644 include/crypto/secret.h
 create mode 100644 include/qemu/base64.h
 create mode 100644 tests/test-base64.c
 create mode 100644 tests/test-crypto-secret.c
 create mode 100644 util/base64.c
Signature · 1 line
2.5.0
#1 lore raw

PATCH v3 1/5 util: add base64 decoding function

The standard glib provided g_base64_decode doesn't provide any kind of sensible error checking on its input. Add a QEMU custom wrapper qbase64_decode which can be used with untrustworthy input that can contain invalid base64 characters, embedded NUL characters, or not be NUL terminated at all.

---
 include/qemu/base64.h | 56 +++++++++++++++++++++++++++++
 tests/.gitignore      |  1 +
 tests/Makefile        |  3 ++
 tests/test-base64.c   | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++
 util/Makefile.objs    |  1 +
 util/base64.c         | 60 +++++++++++++++++++++++++++++++
 6 files changed, 219 insertions(+)
 create mode 100644 include/qemu/base64.h
 create mode 100644 tests/test-base64.c
 create mode 100644 util/base64.c
include/qemu/base64.h new file +56 -0
new file mode 100644
index 0000000..ea9e70f
@@ -0,0 +1,56 @@
+/*
+ * QEMU base64 helpers
+ *
+ * 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 QEMU_BASE64_H__
+#define QEMU_BASE64_H__
+
+#include "qemu-common.h"
+
+
+/**
+ * qbase64_decode:
+ * @input: the (possibly) base64 encoded text
+ * @in_len: length of @input or -1 if NUL terminated
+ * @out_len: filled with length of decoded data
+ * @errp: pointer to uninitialized error object
+ *
+ * Attempt to decode the (possibly) base64 encoded
+ * text provided in @input. If the @input text may
+ * contain embedded NUL characters, or may not be
+ * NUL terminated, then @in_len must be set to the
+ * known size of the @input buffer.
+ *
+ * Note that embedded NULs, or lack of a NUL terminator
+ * are considered invalid base64 data and errors
+ * will be reported to this effect.
+ *
+ * If decoding is successful, the decoded data will
+ * be returned and @out_len set to indicate the
+ * number of bytes in the decoded data.
+ *
+ * Returns: the decoded data or NULL
+ */
+uint8_t *qbase64_decode(const char *input,
+                        size_t in_len,
+                        size_t *out_len,
+                        Error **errp);
+
+
+#endif /* QEMU_BUFFER_H__ */
tests/.gitignore +1 -0
index 1e55722..00a7fed 100644
@@ -8,6 +8,7 @@ check-qom-interface
 check-qom-proplist
 rcutorture
 test-aio
+test-base64
 test-bitops
 test-blockjob-txn
 test-coroutine
tests/Makefile +3 -0
index 0ef00a1..7d9dcc7 100644
@@ -84,6 +84,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-base64$(EXESUF)
 
 check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
 
@@ -416,6 +417,8 @@ tests/test-vmstate$(EXESUF): tests/test-vmstate.o \
 	$(test-qom-obj-y)
 tests/test-timed-average$(EXESUF): tests/test-timed-average.o qemu-timer.o \
 	$(test-util-obj-y)
+tests/test-base64$(EXESUF): tests/test-base64.o \
+	libqemuutil.a libqemustub.a
 
 tests/test-qapi-types.c tests/test-qapi-types.h :\
 $(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-types.py $(qapi-py)
tests/test-base64.c new file +98 -0

98 lines not on this page · raw message

util/Makefile.objs +1 -0
index 89dd80e..8620a80 100644
@@ -30,3 +30,4 @@ util-obj-y += qemu-coroutine-sleep.o
 util-obj-y += coroutine-$(CONFIG_COROUTINE_BACKEND).o
 util-obj-y += buffer.o
 util-obj-y += timed-average.o
+util-obj-y += base64.o
util/base64.c new file +60 -0

60 lines not on this page · raw message

Signature · 1 line
2.5.0
Reviewed-by on v3 1/5
#2 lore raw

Re: [Qemu-devel] [PATCH v3 1/5] util: add base64 decoding function

Quoted 9 lines · Daniel P. Berrange

The standard glib provided g_base64_decode doesn't provide any kind of sensible error checking on its input. Add a QEMU custom wrapper qbase64_decode which can be used with untrustworthy input that can contain invalid base64 characters, embedded NUL characters, or not be NUL terminated at all.

---

include/qemu/base64.h line 32

Quoted 7 lines
include/qemu/base64.h new file +7 -0
+
+/**
+ * qbase64_decode:
+ * @input: the (possibly) base64 encoded text
+ * @in_len: length of @input or -1 if NUL terminated
+ * @out_len: filled with length of decoded data
+ * @errp: pointer to uninitialized error object

That almost implies that I could do:

Error *err;
qbase64_decode(,&err);

In reality, it should be the NULL-initialized error object, as in:

Error *err = NULL;

but I don't know if there is a better way to represent it in text. At any rate, that phrase exists elsewhere, so it would be easier to do a tree-wide cleanup if we have a better terminology to use, and I won't hold up review on this patch for it.

Quoted 7 lines

+ *
+ * Attempt to decode the (possibly) base64 encoded
+ * text provided in @input. If the @input text may
+ * contain embedded NUL characters, or may not be
+ * NUL terminated, then @in_len must be set to the
+ * known size of the @input buffer.
+ *

Quoted 8 lines

+ * Note that embedded NULs, or lack of a NUL terminator
+ * are considered invalid base64 data and errors
+ * will be reported to this effect.
+ *
+ * If decoding is successful, the decoded data will
+ * be returned and @out_len set to indicate the
+ * number of bytes in the decoded data.
+ *

Maybe mention that caller must g_free() the successful result?

Quoted 13 lines

+ * Returns: the decoded data or NULL
+ */

include/qemu/base64.h new file +8 -0
+uint8_t *qbase64_decode(const char *input,
+                        size_t in_len,
+                        size_t *out_len,
+                        Error **errp);
+
+
 
+++ b/tests/test-base64.c
@@ -0,0 +1,98 @@
 
+static void test_base64_bad(const char *input,

include/qemu/base64.h

Quoted 10 lines
include/qemu/base64.h new file +10 -0
+                            size_t input_len)
+{
+    size_t len;
+    Error *err = NULL;
+    uint8_t *actual = qbase64_decode(input,
+                                     input_len,
+                                     &len,
+                                     &err);
+
+    g_assert(err != NULL);

Could use &error_abort in the original call instead of a second check for err != NULL; but that's cosmetic.

tests/test-base64.c line 59

Quoted 2 lines
tests/test-base64.c new file +2 -0
+    g_assert(actual == NULL);
+    g_assert_cmpint(len, ==, 0);

So you are testing that we initialize output length even on error, rather than leaving it uninitialized. That's fair.

tests/test-base64.c line 70

Quoted 8 lines
tests/test-base64.c new file +8 -0
+
+static void test_base64_embedded_nul(void)
+{
+    const char input[] = "There's no such\0thing as a free lunch.";
+
+    test_base64_bad(input, G_N_ELEMENTS(input) - 1);
+}
+

This asserts that you have a failure, but doesn't say what that failure would be...

Quoted 6 lines
tests/test-base64.c new file +6 -0
+
+static void test_base64_not_nul_terminated(void)
+{
+    char input[] = "There's no such thing as a free lunch.";
+    input[G_N_ELEMENTS(input) - 1] = '!';
+

tests/test-base64.c line 86

Quoted 10 lines
tests/test-base64.c new file +10 -0
+    test_base64_bad(input, G_N_ELEMENTS(input) - 1);
+}
+
+
+static void test_base64_invalid_chars(void)
+{
+    const char *input = "There's no such thing as a free lunch.";
+
+    test_base64_bad(input, strlen(input));
+}

...and this same input already fails because it doesn't match base64, regardless of whether NUL bytes are mishandled. I wonder if test_base64_embedded_nul() and test_base64_not_nul_terminated() should be using variations of your known-good base64 string ("QmVjYXVzZSB3ZSBmb2N1c2VkIG9uIHRoZSBzbmFrZSwgd2UgbW\n" "lzc2VkIHRoZSBzY29ycGlvbi4="), to prove that they are failing purely because of the NUL handling and not because of invalid base64 content. But that's only a weak complaint - because by peering into the black box, I see that you are fully testing all code paths (that is, the black box checks for NUL abuse prior to checking for valid base64 data), so I'm not going to insist on a respin.

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
#3 lore raw

Re: [Qemu-devel] [PATCH v3 1/5] util: add base64 decoding function

Quoted 23 lines · Eric Blake
Quoted 9 lines · Daniel P. Berrange

The standard glib provided g_base64_decode doesn't provide any kind of sensible error checking on its input. Add a QEMU custom wrapper qbase64_decode which can be used with untrustworthy input that can contain invalid base64 characters, embedded NUL characters, or not be NUL terminated at all.

---

include/qemu/base64.h line 32

Quoted 7 lines
include/qemu/base64.h new file +7 -0
+
+/**
+ * qbase64_decode:
+ * @input: the (possibly) base64 encoded text
+ * @in_len: length of @input or -1 if NUL terminated
+ * @out_len: filled with length of decoded data
+ * @errp: pointer to uninitialized error object

That almost implies that I could do:

Error *err;
qbase64_decode(,&err);

Quoted 8 lines

In reality, it should be the NULL-initialized error object, as in:

Error *err = NULL;

but I don't know if there is a better way to represent it in text. At any rate, that phrase exists elsewhere, so it would be easier to do a tree-wide cleanup if we have a better terminology to use, and I won't hold up review on this patch for it.

Yep, most of those comments will be my fault, since that's the standard doc text I've been adding for @errp parameters. I'll fix this one and also do a general cleanup patch for others separately.

Quoted 6 lines
Quoted 6 lines
tests/test-base64.c new file +6 -0
+static void test_base64_bad(const char *input,
+                            size_t input_len)
+{
+    size_t len;
+    Error *err = NULL;
+    uint8_t *actual = qbase64_decode(input,
Quoted 8 lines

tests/test-base64.c line 57

Quoted 5 lines
tests/test-base64.c new file +5 -0
+                                     input_len,
+                                     &len,
+                                     &err);
+
+    g_assert(err != NULL);

Could use &error_abort in the original call instead of a second check for err != NULL; but that's cosmetic.

Actually we can't use &error_abort, as we don't want the test function to abort on error as that would indicate test failure. We want to make sure the call completes & returns an error set without aborting.

Quoted 34 lines

tests/test-base64.c line 59

Quoted 2 lines
tests/test-base64.c new file +2 -0
+    g_assert(actual == NULL);
+    g_assert_cmpint(len, ==, 0);

So you are testing that we initialize output length even on error, rather than leaving it uninitialized. That's fair.

tests/test-base64.c line 70

Quoted 7 lines
tests/test-base64.c new file +7 -0
+static void test_base64_embedded_nul(void)
+{
+    const char input[] = "There's no such\0thing as a free lunch.";
+
+    test_base64_bad(input, G_N_ELEMENTS(input) - 1);
+}
+

This asserts that you have a failure, but doesn't say what that failure would be...

Quoted 6 lines
tests/test-base64.c new file +6 -0
+
+static void test_base64_not_nul_terminated(void)
+{
+    char input[] = "There's no such thing as a free lunch.";
+    input[G_N_ELEMENTS(input) - 1] = '!';
+

tests/test-base64.c line 86

Quoted 10 lines
tests/test-base64.c new file +10 -0
+    test_base64_bad(input, G_N_ELEMENTS(input) - 1);
+}
+
+
+static void test_base64_invalid_chars(void)
+{
+    const char *input = "There's no such thing as a free lunch.";
+
+    test_base64_bad(input, strlen(input));
+}
Quoted 7 lines

...and this same input already fails because it doesn't match base64, regardless of whether NUL bytes are mishandled. I wonder if test_base64_embedded_nul() and test_base64_not_nul_terminated() should be using variations of your known-good base64 string ("QmVjYXVzZSB3ZSBmb2N1c2VkIG9uIHRoZSBzbmFrZSwgd2UgbW\n" "lzc2VkIHRoZSBzY29ycGlvbi4="), to prove that they are failing purely because of the NUL handling and not because of invalid base64 content.

That's a good idea - I'll respin with that an add more comments about what we're testing for in each case.

Quoted 4 lines

But that's only a weak complaint - because by peering into the black box, I see that you are fully testing all code paths (that is, the black box checks for NUL abuse prior to checking for valid base64 data), so I'm not going to insist on a respin.

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 :|
#4 lore raw

Re: [Qemu-devel] [PATCH v3 1/5] util: add base64 decoding function

Quoted 19 lines · Daniel P. Berrange
Quoted 18 lines · Eric Blake
Quoted 16 lines · Daniel P. Berrange

The standard glib provided g_base64_decode doesn't provide any kind of sensible error checking on its input. Add a QEMU custom wrapper qbase64_decode which can be used with untrustworthy input that can contain invalid base64 characters, embedded NUL characters, or not be NUL terminated at all.

---

tests/test-base64.c new file +6 -0
+    uint8_t *actual = qbase64_decode(input,
+                                     input_len,
+                                     &len,
+                                     &err);
+
+    g_assert(err != NULL);
Quoted 7 lines
Quoted 2 lines

Could use &error_abort in the original call instead of a second check for err != NULL; but that's cosmetic.

Actually we can't use &error_abort, as we don't want the test function to abort on error as that would indicate test failure. We want to make sure the call completes & returns an error set without aborting.

Whoops; confusing it with g_assert(err == NULL). (Which is why I tend to just do g_assert(err) or g_assert(!err) instead of having to think about the comparison with NULL, oh well).

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
#5 lore raw

PATCH v3 2/5 qemu-char: convert to use error checked base64 decode

In reply to Daniel P. Berrange

Switch from using g_base64_decode over to qbase64_decode in order to get error checking of the base64 input data.

---
 qapi-schema.json | 2 --
 qemu-char.c      | 8 +++++++-
 qmp-commands.hx  | 2 --
 3 files changed, 7 insertions(+), 5 deletions(-)
qapi-schema.json +0 -2
index 8b1a423..7d92c04 100644
@@ -295,8 +295,6 @@
 # @format: #optional data encoding (default 'utf8').
 #          - base64: data must be base64 encoded text.  Its binary
 #            decoding gets written.
-#            Bug: invalid base64 is currently not rejected.
-#            Whitespace *is* invalid.
 #          - utf8: data's UTF-8 encoding is written
 #          - data itself is always Unicode regardless of format, like
 #            any other string.
qemu-char.c +7 -1
index 5448b0f..ac01d73 100644
@@ -32,6 +32,7 @@
 #include "qapi/qmp-input-visitor.h"
 #include "qapi/qmp-output-visitor.h"
 #include "qapi-visit.h"
+#include "qemu/base64.h"
 
 #include <unistd.h>
 #include <fcntl.h>
@@ -3259,7 +3260,12 @@ void qmp_ringbuf_write(const char *device, const char *data,
     }
 
     if (has_format && (format == DATA_FORMAT_BASE64)) {
-        write_data = g_base64_decode(data, &write_count);
+        write_data = qbase64_decode(data, -1,
+                                    &write_count,
+                                    errp);
+        if (!write_data) {
+            return;
+        }
     } else {
         write_data = (uint8_t *)data;
         write_count = strlen(data);
qmp-commands.hx +0 -2
index 9d8b42f..1b47cdd 100644
@@ -512,8 +512,6 @@ Arguments:
 - "data": data to write (json-string)
 - "format": data format (json-string, optional)
           - Possible values: "utf8" (default), "base64"
-            Bug: invalid base64 is currently not rejected.
-            Whitespace *is* invalid.
 
 Example:
 
Signature · 1 line
2.5.0
#6 lore raw

PATCH v3 3/5 qga: convert to use error checked base64 decode

In reply to Daniel P. Berrange

Switch from using g_base64_decode over to qbase64_decode in order to get error checking of the base64 input data.

---
 qga/commands-posix.c | 11 +++++++++--
 qga/commands-win32.c | 11 +++++++++--
 qga/commands.c       | 13 ++++++++++++-
 3 files changed, 30 insertions(+), 5 deletions(-)
qga/commands-posix.c +9 -2
index c2ff970..8fe708f 100644
@@ -29,6 +29,7 @@
 #include "qemu/queue.h"
 #include "qemu/host-utils.h"
 #include "qemu/sockets.h"
+#include "qemu/base64.h"
 
 #ifndef CONFIG_HAS_ENVIRON
 #ifdef __APPLE__
@@ -525,7 +526,10 @@ GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
         gfh->state = RW_STATE_NEW;
     }
 
-    buf = g_base64_decode(buf_b64, &buf_len);
+    buf = qbase64_decode(buf_b64, -1, &buf_len, errp);
+    if (!buf) {
+        return NULL;
+    }
 
     if (!has_count) {
         count = buf_len;
@@ -1963,7 +1967,10 @@ void qmp_guest_set_user_password(const char *username,
     char *chpasswddata = NULL;
     size_t chpasswdlen;
 
-    rawpasswddata = (char *)g_base64_decode(password, &rawpasswdlen);
+    rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp);
+    if (!rawpasswddata) {
+        return;
+    }
     rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1);
     rawpasswddata[rawpasswdlen] = '\0';
 
qga/commands-win32.c +9 -2
index 0654fe4..61ffbdf 100644
@@ -34,6 +34,7 @@
 #include "qapi/qmp/qerror.h"
 #include "qemu/queue.h"
 #include "qemu/host-utils.h"
+#include "qemu/base64.h"
 
 #ifndef SHTDN_REASON_FLAG_PLANNED
 #define SHTDN_REASON_FLAG_PLANNED 0x80000000
@@ -357,7 +358,10 @@ GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
         return NULL;
     }
     fh = gfh->fh;
-    buf = g_base64_decode(buf_b64, &buf_len);
+    buf = qbase64_decode(buf_b64, -1, &buf_len, errp);
+    if (!buf) {
+        return NULL;
+    }
 
     if (!has_count) {
         count = buf_len;
@@ -1294,7 +1298,10 @@ void qmp_guest_set_user_password(const char *username,
         return;
     }
 
-    rawpasswddata = (char *)g_base64_decode(password, &rawpasswdlen);
+    rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp);
+    if (!rawpasswddata) {
+        return;
+    }
     rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1);
     rawpasswddata[rawpasswdlen] = '\0';
 
qga/commands.c +12 -1
index bb73e7d..58568d8 100644
@@ -14,6 +14,7 @@
 #include "qga/guest-agent-core.h"
 #include "qga-qmp-commands.h"
 #include "qapi/qmp/qerror.h"
+#include "qemu/base64.h"
 
 /* Maximum captured guest-exec out_data/err_data - 16MB */
 #define GUEST_EXEC_MAX_OUTPUT (16*1024*1024)
@@ -393,10 +394,19 @@ GuestExec *qmp_guest_exec(const char *path,
     GIOChannel *in_ch, *out_ch, *err_ch;
     GSpawnFlags flags;
     bool has_output = (has_capture_output && capture_output);
+    uint8_t *input = NULL;
+    size_t ninput = 0;
 
     arglist.value = (char *)path;
     arglist.next = has_arg ? arg : NULL;
 
+    if (has_input_data) {
+        input = qbase64_decode(input_data, -1, &ninput, err);
+        if (!input) {
+            return NULL;
+        }
+    }
+
     argv = guest_exec_get_args(&arglist, true);
     envp = has_env ? guest_exec_get_args(env, false) : NULL;
 
@@ -425,7 +435,8 @@ GuestExec *qmp_guest_exec(const char *path,
     g_child_watch_add(pid, guest_exec_child_watch, gei);
 
     if (has_input_data) {
-        gei->in.data = g_base64_decode(input_data, &gei->in.size);
+        gei->in.data = input;
+        gei->in.size = ninput;
 #ifdef G_OS_WIN32
         in_ch = g_io_channel_win32_new_fd(in_fd);
 #else
Signature · 1 line
2.5.0
#7 lore raw

PATCH v3 4/5 crypto: add QCryptoSecret object class for password/key handling

In reply to 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 ad hoc 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 ad hoc dev testing)

$QEMU -object secret,id=sec0,data=letmein

Providing data indirectly in raw format

printf "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 encryption

  $QEMU -object secret,id=master0,file=mykey.b64,format=base64 \
        -object secret,id=sec0,data=[base64 ciphertext],\
	           keyid=master0,iv=[base64 IV],format=base64

Note 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            | 524 +++++++++++++++++++++++++++++++++++++++++++++
 include/crypto/secret.h    | 148 +++++++++++++
 qapi/crypto.json           |  14 ++
 qemu-options.hx            |  77 +++++++
 tests/.gitignore           |   1 +
 tests/Makefile             |   2 +
 tests/test-crypto-secret.c | 446 ++++++++++++++++++++++++++++++++++++++
 8 files changed, 1213 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
index b2a0e0b..a3135f1 100644
@@ -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 +524 -0

524 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
index b058b14..4012659 100644
@@ -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.6
+##
+{ 'enum': 'QCryptoSecretFormat',
+  'prefix': 'QCRYPTO_SECRET_FORMAT',
+  'data': ['raw', 'base64']}
qemu-options.hx +77 -0

83 lines not on this page · raw message

tests/.gitignore +1 -0
index 00a7fed..dbe7c06 100644
@@ -14,6 +14,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
index 7d9dcc7..42d84f4 100644
@@ -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)
@@ -460,6 +461,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
Reviewed-by on v3 4/5
#8 lore raw

Re: [Qemu-devel] [PATCH v3 4/5] crypto: add QCryptoSecret object class for password/key handling

Quoted 22 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.

More examples are shown in the updated docs.

---

+++ b/crypto/secret.c

crypto/secret.c new file +9 -0
+static void
+qcrypto_secret_load_data(QCryptoSecret *secret,
+                         uint8_t **output,
+                         size_t *outputlen,
+                         Error **errp)
+{
 
+        if (!g_file_get_contents(secret->file, &data, &length, &gerr)) {
+            error_setg(errp,
+                       "Unable to read %s: %s",

crypto/secret.c line 59

Quoted 10 lines
crypto/secret.c new file +10 -0
+                       secret->file, gerr->message);
+            g_error_free(gerr);
+            return;
+        }
+        if (length) {
+            /* Even though data is raw 8-bit, so may contain
+             * arbitrary NULs, ensure it is explicitly NUL
+             * terminated */
+            *output = g_renew(uint8_t, data, length + 1);
+            (*output)[length] = '\0';

These two lines are dead code. g_file_get_contents() guarantees that on success, contents is malloc'd large enough and that contents[length] == 0.

https://developer.gnome.org/glib/stable/glib-File-Utilities.html#g-file-get-contents

crypto/secret.c line 63

Quoted 4 lines
crypto/secret.c new file +4 -0
+            *outputlen = length;
+        } else {
+            error_setg(errp, "Secret file %s is empty",
+                       secret->file);

Is there any technical reason why we must forbid a 0-length password? (Sometimes, having the empty string as a password can be a useful for development tests). I'm not opposed to rejecting it, especially if doing so now avoids a more cryptic error message later because there is indeed a technical reason; but just want to make sure it is not an arbitrary limitation.

crypto/secret.c line 69

Quoted 6 lines
crypto/secret.c new file +6 -0
+            g_free(data);
+        }
+    } else if (secret->data) {
+        *outputlen = strlen(secret->data);
+        *output = g_new(uint8_t, *outputlen + 1);
+        memcpy(*output, secret->data, *outputlen + 1);

These two lines could be shortened to:
*output = g_strdup(secret->data);

Quoted 11 lines
crypto/secret.c new file +10 -0
+
+static void qcrypto_secret_decrypt(QCryptoSecret *secret,
+                                   const uint8_t *input,
+                                   size_t inputlen,
+                                   uint8_t **output,
+                                   size_t *outputlen,
+                                   Error **errp)
+{
 
+    if (secret->format == QCRYPTO_SECRET_FORMAT_BASE64) {
+        ciphertext = qbase64_decode((const gchar*)input,

crypto/secret.c line 140

Quoted 10 lines
crypto/secret.c new file +10 -0
+                                    inputlen,
+                                    &ciphertextlen,
+                                    errp);
+        if (!ciphertext) {
+            goto cleanup;
+        }
+        plaintext = g_new0(uint8_t, ciphertextlen + 1);
+    } else {
+        ciphertextlen = inputlen;
+        plaintext = g_new0(uint8_t, inputlen + 1);

g_new0(uint8_t, value) is the same as g_malloc0(value); I don't know if it is worth the distinction. But not worth a respin on its own.

I found some style or efficiency things you might want to touch up, but no actual bugs that would prevent this patch from being usable as-is.

Signature · 2 lines
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org
#9 lore raw

Re: [Qemu-devel] [PATCH v3 4/5] crypto: add QCryptoSecret object class for password/key handling

Quoted 34 lines · Eric Blake
Quoted 22 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.

More examples are shown in the updated docs.

---

+++ b/crypto/secret.c

crypto/secret.c new file +9 -0
+static void
+qcrypto_secret_load_data(QCryptoSecret *secret,
+                         uint8_t **output,
+                         size_t *outputlen,
+                         Error **errp)
+{
 
+        if (!g_file_get_contents(secret->file, &data, &length, &gerr)) {
+            error_setg(errp,
+                       "Unable to read %s: %s",

crypto/secret.c line 59

Quoted 10 lines
crypto/secret.c new file +10 -0
+                       secret->file, gerr->message);
+            g_error_free(gerr);
+            return;
+        }
+        if (length) {
+            /* Even though data is raw 8-bit, so may contain
+             * arbitrary NULs, ensure it is explicitly NUL
+             * terminated */
+            *output = g_renew(uint8_t, data, length + 1);
+            (*output)[length] = '\0';
Quoted 4 lines

These two lines are dead code. g_file_get_contents() guarantees that on success, contents is malloc'd large enough and that contents[length] == 0.

https://developer.gnome.org/glib/stable/glib-File-Utilities.html#g-file-get-contents

Yep, I just checked the source too and it matches the docs

Quoted 6 lines

crypto/secret.c line 63

Quoted 5 lines
crypto/secret.c new file +4 -0
+            *outputlen = length;
+        } else {
+            error_setg(errp, "Secret file %s is empty",
+                       secret->file);
Quoted 6 lines

Is there any technical reason why we must forbid a 0-length password? (Sometimes, having the empty string as a password can be a useful for development tests). I'm not opposed to rejecting it, especially if doing so now avoids a more cryptic error message later because there is indeed a technical reason; but just want to make sure it is not an arbitrary limitation.

It was fairly arbitrary, motivated by a desire to give an error message if user accidentally pointed to a bad file, but based on your point about empty passwords I'll remove this and leave it upto the callers to decide if they'll accept empty passwords.

Quoted 10 lines

crypto/secret.c line 69

Quoted 7 lines
crypto/secret.c new file +6 -0
+            g_free(data);
+        }
+    } else if (secret->data) {
+        *outputlen = strlen(secret->data);
+        *output = g_new(uint8_t, *outputlen + 1);
+        memcpy(*output, secret->data, *outputlen + 1);

These two lines could be shortened to:
*output = g_strdup(secret->data);

Yes, indeed, I'll fix that.

Quoted 23 lines
Quoted 12 lines
crypto/secret.c new file +10 -0
+
+static void qcrypto_secret_decrypt(QCryptoSecret *secret,
+                                   const uint8_t *input,
+                                   size_t inputlen,
+                                   uint8_t **output,
+                                   size_t *outputlen,
+                                   Error **errp)
+{
 
+    if (secret->format == QCRYPTO_SECRET_FORMAT_BASE64) {
+        ciphertext = qbase64_decode((const gchar*)input,

crypto/secret.c line 140

Quoted 10 lines
crypto/secret.c new file +10 -0
+                                    inputlen,
+                                    &ciphertextlen,
+                                    errp);
+        if (!ciphertext) {
+            goto cleanup;
+        }
+        plaintext = g_new0(uint8_t, ciphertextlen + 1);
+    } else {
+        ciphertextlen = inputlen;
+        plaintext = g_new0(uint8_t, inputlen + 1);
Quoted 2 lines

g_new0(uint8_t, value) is the same as g_malloc0(value); I don't know if it is worth the distinction. But not worth a respin on its own.

I just prefer to always use g_new0 so it is explicit what type we're using, though I wish glib's allocators worked like libvirt's so it got the compiler to provide the correct type.

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 :|
#10 lore raw

PATCH v3 5/5 crypto: add support for loading encrypted x509 keys

In reply to Daniel P. Berrange

Make 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.

 # printf "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=creds0

This 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         | 48 +++++++++++++++++++++++++++++++++++++++++++
 include/crypto/tlscredsx509.h |  1 +
 qemu-options.hx               |  8 +++++++-
 3 files changed, 56 insertions(+), 1 deletion(-)
crypto/tlscredsx509.c +48 -0
index d080deb..c06edbb 100644
@@ -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,30 @@ 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);
+        g_free(password);
+#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 +758,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 +811,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 +823,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
index b9785fd..25796d7 100644
@@ -101,6 +101,7 @@ struct QCryptoTLSCredsX509 {
     gnutls_certificate_credentials_t data;
 #endif
     bool sanityCheck;
+    char *passwordid;
 };
 
 
qemu-options.hx +7 -1
index 5aa22fc..0a8c640 100644
@@ -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