Merge remote-tracking branch... (c6880845) · Commits · SUMMER2020 / students / proj-2021291

crypto/Makefile.objs

+1 −0

Original line number	Diff line number	Diff line
		@@ -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

0 → 100644

+513 −0

Original line number	Diff line number	Diff line
		/*
		* QEMU crypto secret support
		*
		* 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/secret.h"
		#include "crypto/cipher.h"
		#include "qom/object_interfaces.h"
		#include "qemu/base64.h"
		#include "trace.h"


		static void
		qcrypto_secret_load_data(QCryptoSecret *secret,
		uint8_t **output,
		size_t *outputlen,
		Error **errp)
		{
		char *data = NULL;
		size_t length = 0;
		GError *gerr = NULL;

		*output = NULL;
		*outputlen = 0;

		if (secret->file) {
		if (secret->data) {
		error_setg(errp,
		"'file' and 'data' are mutually exclusive");
		return;
		}
		if (!g_file_get_contents(secret->file, &data, &length, &gerr)) {
		error_setg(errp,
		"Unable to read %s: %s",
		secret->file, gerr->message);
		g_error_free(gerr);
		return;
		}
		output = (uint8_t )data;
		*outputlen = length;
		} else if (secret->data) {
		*outputlen = strlen(secret->data);
		output = (uint8_t )g_strdup(secret->data);
		} else {
		error_setg(errp, "Either 'file' or 'data' must be provided");
		}
		}


		static void qcrypto_secret_decrypt(QCryptoSecret *secret,
		const uint8_t *input,
		size_t inputlen,
		uint8_t **output,
		size_t *outputlen,
		Error **errp)
		{
		uint8_t key = NULL, ciphertext = NULL, *iv = NULL;
		size_t keylen, ciphertextlen, ivlen;
		QCryptoCipher *aes = NULL;
		uint8_t *plaintext = NULL;

		*output = NULL;
		*outputlen = 0;

		if (qcrypto_secret_lookup(secret->keyid,
		&key, &keylen,
		errp) < 0) {
		goto cleanup;
		}

		if (keylen != 32) {
		error_setg(errp, "Key should be 32 bytes in length");
		goto cleanup;
		}

		if (!secret->iv) {
		error_setg(errp, "IV is required to decrypt secret");
		goto cleanup;
		}

		iv = qbase64_decode(secret->iv, -1, &ivlen, errp);
		if (!iv) {
		goto cleanup;
		}
		if (ivlen != 16) {
		error_setg(errp, "IV should be 16 bytes in length not %zu",
		ivlen);
		goto cleanup;
		}

		aes = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_256,
		QCRYPTO_CIPHER_MODE_CBC,
		key, keylen,
		errp);
		if (!aes) {
		goto cleanup;
		}

		if (qcrypto_cipher_setiv(aes, iv, ivlen, errp) < 0) {
		goto cleanup;
		}

		if (secret->format == QCRYPTO_SECRET_FORMAT_BASE64) {
		ciphertext = qbase64_decode((const gchar*)input,
		inputlen,
		&ciphertextlen,
		errp);
		if (!ciphertext) {
		goto cleanup;
		}
		plaintext = g_new0(uint8_t, ciphertextlen + 1);
		} else {
		ciphertextlen = inputlen;
		plaintext = g_new0(uint8_t, inputlen + 1);
		}
		if (qcrypto_cipher_decrypt(aes,
		ciphertext ? ciphertext : input,
		plaintext,
		ciphertextlen,
		errp) < 0) {
		plaintext = NULL;
		goto cleanup;
		}

		if (plaintext[ciphertextlen - 1] > 16 \|\|
		plaintext[ciphertextlen - 1] > ciphertextlen) {
		error_setg(errp, "Incorrect number of padding bytes (%d) "
		"found on decrypted data",
		(int)plaintext[ciphertextlen - 1]);
		g_free(plaintext);
		plaintext = NULL;
		goto cleanup;
		}

		/* Even though plaintext may contain arbitrary NUL
		* ensure it is explicitly NUL terminated.
		*/
		ciphertextlen -= plaintext[ciphertextlen - 1];
		plaintext[ciphertextlen] = '\0';

		*output = plaintext;
		*outputlen = ciphertextlen;

		cleanup:
		g_free(ciphertext);
		g_free(iv);
		g_free(key);
		qcrypto_cipher_free(aes);
		}


		static void qcrypto_secret_decode(const uint8_t *input,
		size_t inputlen,
		uint8_t **output,
		size_t *outputlen,
		Error **errp)
		{
		output = qbase64_decode((const gchar)input,
		inputlen,
		outputlen,
		errp);
		}


		static void
		qcrypto_secret_prop_set_loaded(Object *obj,
		bool value,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);

		if (value) {
		Error *local_err = NULL;
		uint8_t *input = NULL;
		size_t inputlen = 0;
		uint8_t *output = NULL;
		size_t outputlen = 0;

		qcrypto_secret_load_data(secret, &input, &inputlen, &local_err);
		if (local_err) {
		error_propagate(errp, local_err);
		return;
		}

		if (secret->keyid) {
		qcrypto_secret_decrypt(secret, input, inputlen,
		&output, &outputlen, &local_err);
		g_free(input);
		if (local_err) {
		error_propagate(errp, local_err);
		return;
		}
		input = output;
		inputlen = outputlen;
		} else {
		if (secret->format != QCRYPTO_SECRET_FORMAT_RAW) {
		qcrypto_secret_decode(input, inputlen,
		&output, &outputlen, &local_err);
		g_free(input);
		if (local_err) {
		error_propagate(errp, local_err);
		return;
		}
		input = output;
		inputlen = outputlen;
		}
		}

		secret->rawdata = input;
		secret->rawlen = inputlen;
		} else {
		g_free(secret->rawdata);
		secret->rawlen = 0;
		}
		}


		static bool
		qcrypto_secret_prop_get_loaded(Object *obj,
		Error **errp G_GNUC_UNUSED)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);
		return secret->data != NULL;
		}


		static void
		qcrypto_secret_prop_set_format(Object *obj,
		int value,
		Error **errp G_GNUC_UNUSED)
		{
		QCryptoSecret *creds = QCRYPTO_SECRET(obj);

		creds->format = value;
		}


		static int
		qcrypto_secret_prop_get_format(Object *obj,
		Error **errp G_GNUC_UNUSED)
		{
		QCryptoSecret *creds = QCRYPTO_SECRET(obj);

		return creds->format;
		}


		static void
		qcrypto_secret_prop_set_data(Object *obj,
		const char *value,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);

		g_free(secret->data);
		secret->data = g_strdup(value);
		}


		static char *
		qcrypto_secret_prop_get_data(Object *obj,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);
		return g_strdup(secret->data);
		}


		static void
		qcrypto_secret_prop_set_file(Object *obj,
		const char *value,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);

		g_free(secret->file);
		secret->file = g_strdup(value);
		}


		static char *
		qcrypto_secret_prop_get_file(Object *obj,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);
		return g_strdup(secret->file);
		}


		static void
		qcrypto_secret_prop_set_iv(Object *obj,
		const char *value,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);

		g_free(secret->iv);
		secret->iv = g_strdup(value);
		}


		static char *
		qcrypto_secret_prop_get_iv(Object *obj,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);
		return g_strdup(secret->iv);
		}


		static void
		qcrypto_secret_prop_set_keyid(Object *obj,
		const char *value,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);

		g_free(secret->keyid);
		secret->keyid = g_strdup(value);
		}


		static char *
		qcrypto_secret_prop_get_keyid(Object *obj,
		Error **errp)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);
		return g_strdup(secret->keyid);
		}


		static void
		qcrypto_secret_complete(UserCreatable uc, Error *errp)
		{
		object_property_set_bool(OBJECT(uc), true, "loaded", errp);
		}


		static void
		qcrypto_secret_init(Object *obj)
		{
		object_property_add_bool(obj, "loaded",
		qcrypto_secret_prop_get_loaded,
		qcrypto_secret_prop_set_loaded,
		NULL);
		object_property_add_enum(obj, "format",
		"QCryptoSecretFormat",
		QCryptoSecretFormat_lookup,
		qcrypto_secret_prop_get_format,
		qcrypto_secret_prop_set_format,
		NULL);
		object_property_add_str(obj, "data",
		qcrypto_secret_prop_get_data,
		qcrypto_secret_prop_set_data,
		NULL);
		object_property_add_str(obj, "file",
		qcrypto_secret_prop_get_file,
		qcrypto_secret_prop_set_file,
		NULL);
		object_property_add_str(obj, "keyid",
		qcrypto_secret_prop_get_keyid,
		qcrypto_secret_prop_set_keyid,
		NULL);
		object_property_add_str(obj, "iv",
		qcrypto_secret_prop_get_iv,
		qcrypto_secret_prop_set_iv,
		NULL);
		}


		static void
		qcrypto_secret_finalize(Object *obj)
		{
		QCryptoSecret *secret = QCRYPTO_SECRET(obj);

		g_free(secret->iv);
		g_free(secret->file);
		g_free(secret->keyid);
		g_free(secret->rawdata);
		g_free(secret->data);
		}

		static void
		qcrypto_secret_class_init(ObjectClass oc, void data)
		{
		UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);

		ucc->complete = qcrypto_secret_complete;
		}


		int qcrypto_secret_lookup(const char *secretid,
		uint8_t **data,
		size_t *datalen,
		Error **errp)
		{
		Object *obj;
		QCryptoSecret *secret;

		obj = object_resolve_path_component(
		object_get_objects_root(), secretid);
		if (!obj) {
		error_setg(errp, "No secret with id '%s'", secretid);
		return -1;
		}

		secret = (QCryptoSecret *)
		object_dynamic_cast(obj,
		TYPE_QCRYPTO_SECRET);
		if (!secret) {
		error_setg(errp, "Object with id '%s' is not a secret",
		secretid);
		return -1;
		}

		if (!secret->rawdata) {
		error_setg(errp, "Secret with id '%s' has no data",
		secretid);
		return -1;
		}

		*data = g_new0(uint8, secret->rawlen + 1);
		memcpy(*data, secret->rawdata, secret->rawlen);
		(*data)[secret->rawlen] = '\0';
		*datalen = secret->rawlen;

		return 0;
		}


		char qcrypto_secret_lookup_as_utf8(const char secretid,
		Error **errp)
		{
		uint8_t *data;
		size_t datalen;

		if (qcrypto_secret_lookup(secretid,
		&data,
		&datalen,
		errp) < 0) {
		return NULL;
		}

		if (!g_utf8_validate((const gchar*)data, datalen, NULL)) {
		error_setg(errp,
		"Data from secret %s is not valid UTF-8",
		secretid);
		g_free(data);
		return NULL;
		}

		return (char *)data;
		}


		char qcrypto_secret_lookup_as_base64(const char secretid,
		Error **errp)
		{
		uint8_t *data;
		size_t datalen;
		char *ret;

		if (qcrypto_secret_lookup(secretid,
		&data,
		&datalen,
		errp) < 0) {
		return NULL;
		}

		ret = g_base64_encode(data, datalen);
		g_free(data);
		return ret;
		}


		static const TypeInfo qcrypto_secret_info = {
		.parent = TYPE_OBJECT,
		.name = TYPE_QCRYPTO_SECRET,
		.instance_size = sizeof(QCryptoSecret),
		.instance_init = qcrypto_secret_init,
		.instance_finalize = qcrypto_secret_finalize,
		.class_size = sizeof(QCryptoSecretClass),
		.class_init = qcrypto_secret_class_init,
		.interfaces = (InterfaceInfo[]) {
		{ TYPE_USER_CREATABLE },
		{ }
		}
		};


		static void
		qcrypto_secret_register_types(void)
		{
		type_register_static(&qcrypto_secret_info);
		}


		type_init(qcrypto_secret_register_types);

crypto/tlscredsx509.c

+48 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@

		#include "crypto/tlscredsx509.h"
		#include "crypto/tlscredspriv.h"
		#include "crypto/secret.h"
		#include "qom/object_interfaces.h"
		#include "trace.h"

		@@ -607,9 +608,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));
		@@ -737,6 +759,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)
		@@ -769,6 +812,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);
		}


		@@ -777,6 +824,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/secret.h

0 → 100644

+148 −0

Original line number	Diff line number	Diff line
		/*
		* QEMU crypto secret support
		*
		* 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_SECRET_H__
		#define QCRYPTO_SECRET_H__

		#include "qemu-common.h"
		#include "qapi/error.h"
		#include "qom/object.h"

		#define TYPE_QCRYPTO_SECRET "secret"
		#define QCRYPTO_SECRET(obj) \
		OBJECT_CHECK(QCryptoSecret, (obj), TYPE_QCRYPTO_SECRET)

		typedef struct QCryptoSecret QCryptoSecret;
		typedef struct QCryptoSecretClass QCryptoSecretClass;

		/**
		* 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
		* indirectly via the 'file' property. In the latter
		* case there is support for file descriptor passing
		* via the usual /dev/fdset/NN syntax 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 encryption keys, while the former is appropriate
		* 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.
		*
		* Providing data directly, insecurely (suitable for
		* ad hoc developer testing only)
		*
		* $QEMU -object secret,id=sec0,data=letmein
		*
		* Providing data indirectly:
		*
		* # printf "letmein" > password.txt
		* # $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=$(printf "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
		*
		* # printf "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.
		*/

		struct QCryptoSecret {
		Object parent_obj;
		uint8_t *rawdata;
		size_t rawlen;
		QCryptoSecretFormat format;
		char *data;
		char *file;
		char *keyid;
		char *iv;
		};


		struct QCryptoSecretClass {
		ObjectClass parent_class;
		};


		extern int qcrypto_secret_lookup(const char *secretid,
		uint8_t **data,
		size_t *datalen,
		Error **errp);
		extern char qcrypto_secret_lookup_as_utf8(const char secretid,
		Error **errp);
		extern char qcrypto_secret_lookup_as_base64(const char secretid,
		Error **errp);

		#endif /* QCRYPTO_SECRET_H__ */

include/crypto/tlscredsx509.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -101,6 +101,7 @@ struct QCryptoTLSCredsX509 {
		gnutls_certificate_credentials_t data;
		#endif
		bool sanityCheck;
		char *passwordid;
		};