crypto/secret.c

   1 /*
   2  * QEMU crypto secret support
   3  *
   4  * Copyright (c) 2015 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "crypto/secret.h"
  23 #include "crypto/cipher.h"
  24 #include "qom/object_interfaces.h"
  25 #include "qemu/base64.h"
  26 #include "trace.h"
  27
  28
  29 static void
  30 qcrypto_secret_load_data(QCryptoSecret *secret,
  31                          uint8_t **output,
  32                          size_t *outputlen,
  33                          Error **errp)
  34 {
  35     char *data = NULL;
  36     size_t length = 0;
  37     GError *gerr = NULL;
  38
  39     *output = NULL;
  40     *outputlen = 0;
  41
  42     if (secret->file) {
  43         if (secret->data) {
  44             error_setg(errp,
  45                        "'file' and 'data' are mutually exclusive");
  46             return;
  47         }
  48         if (!g_file_get_contents(secret->file, &data, &length, &gerr)) {
  49             error_setg(errp,
  50                        "Unable to read %s: %s",
  51                        secret->file, gerr->message);
  52             g_error_free(gerr);
  53             return;
  54         }
  55         *output = (uint8_t *)data;
  56         *outputlen = length;
  57     } else if (secret->data) {
  58         *outputlen = strlen(secret->data);
  59         *output = (uint8_t *)g_strdup(secret->data);
  60     } else {
  61         error_setg(errp, "Either 'file' or 'data' must be provided");
  62     }
  63 }
  64
  65
  66 static void qcrypto_secret_decrypt(QCryptoSecret *secret,
  67                                    const uint8_t *input,
  68                                    size_t inputlen,
  69                                    uint8_t **output,
  70                                    size_t *outputlen,
  71                                    Error **errp)
  72 {
  73     uint8_t *key = NULL, *ciphertext = NULL, *iv = NULL;
  74     size_t keylen, ciphertextlen, ivlen;
  75     QCryptoCipher *aes = NULL;
  76     uint8_t *plaintext = NULL;
  77
  78     *output = NULL;
  79     *outputlen = 0;
  80
  81     if (qcrypto_secret_lookup(secret->keyid,
  82                               &key, &keylen,
  83                               errp) < 0) {
  84         goto cleanup;
  85     }
  86
  87     if (keylen != 32) {
  88         error_setg(errp, "Key should be 32 bytes in length");
  89         goto cleanup;
  90     }
  91
  92     if (!secret->iv) {
  93         error_setg(errp, "IV is required to decrypt secret");
  94         goto cleanup;
  95     }
  96
  97     iv = qbase64_decode(secret->iv, -1, &ivlen, errp);
  98     if (!iv) {
  99         goto cleanup;
 100     }
 101     if (ivlen != 16) {
 102         error_setg(errp, "IV should be 16 bytes in length not %zu",
 103                    ivlen);
 104         goto cleanup;
 105     }
 106
 107     aes = qcrypto_cipher_new(QCRYPTO_CIPHER_ALG_AES_256,
 108                              QCRYPTO_CIPHER_MODE_CBC,
 109                              key, keylen,
 110                              errp);
 111     if (!aes) {
 112         goto cleanup;
 113     }
 114
 115     if (qcrypto_cipher_setiv(aes, iv, ivlen, errp) < 0) {
 116         goto cleanup;
 117     }
 118
 119     if (secret->format == QCRYPTO_SECRET_FORMAT_BASE64) {
 120         ciphertext = qbase64_decode((const gchar*)input,
 121                                     inputlen,
 122                                     &ciphertextlen,
 123                                     errp);
 124         if (!ciphertext) {
 125             goto cleanup;
 126         }
 127         plaintext = g_new0(uint8_t, ciphertextlen + 1);
 128     } else {
 129         ciphertextlen = inputlen;
 130         plaintext = g_new0(uint8_t, inputlen + 1);
 131     }
 132     if (qcrypto_cipher_decrypt(aes,
 133                                ciphertext ? ciphertext : input,
 134                                plaintext,
 135                                ciphertextlen,
 136                                errp) < 0) {
 137         plaintext = NULL;
 138         goto cleanup;
 139     }
 140
 141     if (plaintext[ciphertextlen - 1] > 16 ||
 142         plaintext[ciphertextlen - 1] > ciphertextlen) {
 143         error_setg(errp, "Incorrect number of padding bytes (%d) "
 144                    "found on decrypted data",
 145                    (int)plaintext[ciphertextlen - 1]);
 146         g_free(plaintext);
 147         plaintext = NULL;
 148         goto cleanup;
 149     }
 150
 151     /* Even though plaintext may contain arbitrary NUL
 152      * ensure it is explicitly NUL terminated.
 153      */
 154     ciphertextlen -= plaintext[ciphertextlen - 1];
 155     plaintext[ciphertextlen] = '\0';
 156
 157     *output = plaintext;
 158     *outputlen = ciphertextlen;
 159
 160  cleanup:
 161     g_free(ciphertext);
 162     g_free(iv);
 163     g_free(key);
 164     qcrypto_cipher_free(aes);
 165 }
 166
 167
 168 static void qcrypto_secret_decode(const uint8_t *input,
 169                                   size_t inputlen,
 170                                   uint8_t **output,
 171                                   size_t *outputlen,
 172                                   Error **errp)
 173 {
 174     *output = qbase64_decode((const gchar*)input,
 175                              inputlen,
 176                              outputlen,
 177                              errp);
 178 }
 179
 180
 181 static void
 182 qcrypto_secret_prop_set_loaded(Object *obj,
 183                                bool value,
 184                                Error **errp)
 185 {
 186     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 187
 188     if (value) {
 189         Error *local_err = NULL;
 190         uint8_t *input = NULL;
 191         size_t inputlen = 0;
 192         uint8_t *output = NULL;
 193         size_t outputlen = 0;
 194
 195         qcrypto_secret_load_data(secret, &input, &inputlen, &local_err);
 196         if (local_err) {
 197             error_propagate(errp, local_err);
 198             return;
 199         }
 200
 201         if (secret->keyid) {
 202             qcrypto_secret_decrypt(secret, input, inputlen,
 203                                    &output, &outputlen, &local_err);
 204             g_free(input);
 205             if (local_err) {
 206                 error_propagate(errp, local_err);
 207                 return;
 208             }
 209             input = output;
 210             inputlen = outputlen;
 211         } else {
 212             if (secret->format != QCRYPTO_SECRET_FORMAT_RAW) {
 213                 qcrypto_secret_decode(input, inputlen,
 214                                       &output, &outputlen, &local_err);
 215                 g_free(input);
 216                 if (local_err) {
 217                     error_propagate(errp, local_err);
 218                     return;
 219                 }
 220                 input = output;
 221                 inputlen = outputlen;
 222             }
 223         }
 224
 225         secret->rawdata = input;
 226         secret->rawlen = inputlen;
 227     } else {
 228         g_free(secret->rawdata);
 229         secret->rawlen = 0;
 230     }
 231 }
 232
 233
 234 static bool
 235 qcrypto_secret_prop_get_loaded(Object *obj,
 236                                Error **errp G_GNUC_UNUSED)
 237 {
 238     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 239     return secret->data != NULL;
 240 }
 241
 242
 243 static void
 244 qcrypto_secret_prop_set_format(Object *obj,
 245                                int value,
 246                                Error **errp G_GNUC_UNUSED)
 247 {
 248     QCryptoSecret *creds = QCRYPTO_SECRET(obj);
 249
 250     creds->format = value;
 251 }
 252
 253
 254 static int
 255 qcrypto_secret_prop_get_format(Object *obj,
 256                                Error **errp G_GNUC_UNUSED)
 257 {
 258     QCryptoSecret *creds = QCRYPTO_SECRET(obj);
 259
 260     return creds->format;
 261 }
 262
 263
 264 static void
 265 qcrypto_secret_prop_set_data(Object *obj,
 266                              const char *value,
 267                              Error **errp)
 268 {
 269     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 270
 271     g_free(secret->data);
 272     secret->data = g_strdup(value);
 273 }
 274
 275
 276 static char *
 277 qcrypto_secret_prop_get_data(Object *obj,
 278                              Error **errp)
 279 {
 280     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 281     return g_strdup(secret->data);
 282 }
 283
 284
 285 static void
 286 qcrypto_secret_prop_set_file(Object *obj,
 287                              const char *value,
 288                              Error **errp)
 289 {
 290     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 291
 292     g_free(secret->file);
 293     secret->file = g_strdup(value);
 294 }
 295
 296
 297 static char *
 298 qcrypto_secret_prop_get_file(Object *obj,
 299                              Error **errp)
 300 {
 301     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 302     return g_strdup(secret->file);
 303 }
 304
 305
 306 static void
 307 qcrypto_secret_prop_set_iv(Object *obj,
 308                            const char *value,
 309                            Error **errp)
 310 {
 311     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 312
 313     g_free(secret->iv);
 314     secret->iv = g_strdup(value);
 315 }
 316
 317
 318 static char *
 319 qcrypto_secret_prop_get_iv(Object *obj,
 320                            Error **errp)
 321 {
 322     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 323     return g_strdup(secret->iv);
 324 }
 325
 326
 327 static void
 328 qcrypto_secret_prop_set_keyid(Object *obj,
 329                               const char *value,
 330                               Error **errp)
 331 {
 332     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 333
 334     g_free(secret->keyid);
 335     secret->keyid = g_strdup(value);
 336 }
 337
 338
 339 static char *
 340 qcrypto_secret_prop_get_keyid(Object *obj,
 341                               Error **errp)
 342 {
 343     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 344     return g_strdup(secret->keyid);
 345 }
 346
 347
 348 static void
 349 qcrypto_secret_complete(UserCreatable *uc, Error **errp)
 350 {
 351     object_property_set_bool(OBJECT(uc), true, "loaded", errp);
 352 }
 353
 354
 355 static void
 356 qcrypto_secret_finalize(Object *obj)
 357 {
 358     QCryptoSecret *secret = QCRYPTO_SECRET(obj);
 359
 360     g_free(secret->iv);
 361     g_free(secret->file);
 362     g_free(secret->keyid);
 363     g_free(secret->rawdata);
 364     g_free(secret->data);
 365 }
 366
 367 static void
 368 qcrypto_secret_class_init(ObjectClass *oc, void *data)
 369 {
 370     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 371
 372     ucc->complete = qcrypto_secret_complete;
 373
 374     object_class_property_add_bool(oc, "loaded",
 375                                    qcrypto_secret_prop_get_loaded,
 376                                    qcrypto_secret_prop_set_loaded,
 377                                    NULL);
 378     object_class_property_add_enum(oc, "format",
 379                                    "QCryptoSecretFormat",
 380                                    QCryptoSecretFormat_lookup,
 381                                    qcrypto_secret_prop_get_format,
 382                                    qcrypto_secret_prop_set_format,
 383                                    NULL);
 384     object_class_property_add_str(oc, "data",
 385                                   qcrypto_secret_prop_get_data,
 386                                   qcrypto_secret_prop_set_data,
 387                                   NULL);
 388     object_class_property_add_str(oc, "file",
 389                                   qcrypto_secret_prop_get_file,
 390                                   qcrypto_secret_prop_set_file,
 391                                   NULL);
 392     object_class_property_add_str(oc, "keyid",
 393                                   qcrypto_secret_prop_get_keyid,
 394                                   qcrypto_secret_prop_set_keyid,
 395                                   NULL);
 396     object_class_property_add_str(oc, "iv",
 397                                   qcrypto_secret_prop_get_iv,
 398                                   qcrypto_secret_prop_set_iv,
 399                                   NULL);
 400 }
 401
 402
 403 int qcrypto_secret_lookup(const char *secretid,
 404                           uint8_t **data,
 405                           size_t *datalen,
 406                           Error **errp)
 407 {
 408     Object *obj;
 409     QCryptoSecret *secret;
 410
 411     obj = object_resolve_path_component(
 412         object_get_objects_root(), secretid);
 413     if (!obj) {
 414         error_setg(errp, "No secret with id '%s'", secretid);
 415         return -1;
 416     }
 417
 418     secret = (QCryptoSecret *)
 419         object_dynamic_cast(obj,
 420                             TYPE_QCRYPTO_SECRET);
 421     if (!secret) {
 422         error_setg(errp, "Object with id '%s' is not a secret",
 423                    secretid);
 424         return -1;
 425     }
 426
 427     if (!secret->rawdata) {
 428         error_setg(errp, "Secret with id '%s' has no data",
 429                    secretid);
 430         return -1;
 431     }
 432
 433     *data = g_new0(uint8_t, secret->rawlen + 1);
 434     memcpy(*data, secret->rawdata, secret->rawlen);
 435     (*data)[secret->rawlen] = '\0';
 436     *datalen = secret->rawlen;
 437
 438     return 0;
 439 }
 440
 441
 442 char *qcrypto_secret_lookup_as_utf8(const char *secretid,
 443                                     Error **errp)
 444 {
 445     uint8_t *data;
 446     size_t datalen;
 447
 448     if (qcrypto_secret_lookup(secretid,
 449                               &data,
 450                               &datalen,
 451                               errp) < 0) {
 452         return NULL;
 453     }
 454
 455     if (!g_utf8_validate((const gchar*)data, datalen, NULL)) {
 456         error_setg(errp,
 457                    "Data from secret %s is not valid UTF-8",
 458                    secretid);
 459         g_free(data);
 460         return NULL;
 461     }
 462
 463     return (char *)data;
 464 }
 465
 466
 467 char *qcrypto_secret_lookup_as_base64(const char *secretid,
 468                                       Error **errp)
 469 {
 470     uint8_t *data;
 471     size_t datalen;
 472     char *ret;
 473
 474     if (qcrypto_secret_lookup(secretid,
 475                               &data,
 476                               &datalen,
 477                               errp) < 0) {
 478         return NULL;
 479     }
 480
 481     ret = g_base64_encode(data, datalen);
 482     g_free(data);
 483     return ret;
 484 }
 485
 486
 487 static const TypeInfo qcrypto_secret_info = {
 488     .parent = TYPE_OBJECT,
 489     .name = TYPE_QCRYPTO_SECRET,
 490     .instance_size = sizeof(QCryptoSecret),
 491     .instance_finalize = qcrypto_secret_finalize,
 492     .class_size = sizeof(QCryptoSecretClass),
 493     .class_init = qcrypto_secret_class_init,
 494     .interfaces = (InterfaceInfo[]) {
 495         { TYPE_USER_CREATABLE },
 496         { }
 497     }
 498 };
 499
 500
 501 static void
 502 qcrypto_secret_register_types(void)
 503 {
 504     type_register_static(&qcrypto_secret_info);
 505 }
 506
 507
 508 type_init(qcrypto_secret_register_types);