Replace the uint8 softfloat-specific typedef with uint8_t. This change was made with find include hw fpu target-* -name '*.[ch]' | xargs sed -i -e 's/\buint8\b/uint8_t/g' together with manual removal of the typedef definition and manual fixing of more erroneous uses found via test compilation. It turns out that the only code using this type is an accidental use where uint8_t was intended anyway... Signed-off-by: Peter Maydell <peter.maydell@linaro.org> Reviewed-by: Richard Henderson <rth@twiddle.net> Reviewed-by: Aurelien Jarno <aurelien@aurel32.net> Acked-by: Leon Alrae <leon.alrae@imgtec.com> Acked-by: James Hogan <james.hogan@imgtec.com> Message-id: 1452603315-27030-7-git-send-email-peter.maydell@linaro.org
514 lines
13 KiB
C
514 lines
13 KiB
C
/*
|
|
* 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_t, 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);
|