crypto/ct/ct_log.c

   1 /*
   2  * Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include <openssl/conf.h>
  14 #include <openssl/ct.h>
  15 #include <openssl/err.h>
  16 #include <openssl/evp.h>
  17 #include <openssl/safestack.h>
  18
  19 #include "internal/cryptlib.h"
  20
  21 /*
  22  * Information about a CT log server.
  23  */
  24 struct ctlog_st {
  25     OSSL_LIB_CTX *libctx;
  26     char *propq;
  27     char *name;
  28     uint8_t log_id[CT_V1_HASHLEN];
  29     EVP_PKEY *public_key;
  30 };
  31
  32 /*
  33  * A store for multiple CTLOG instances.
  34  * It takes ownership of any CTLOG instances added to it.
  35  */
  36 struct ctlog_store_st {
  37     OSSL_LIB_CTX *libctx;
  38     char *propq;
  39     STACK_OF(CTLOG) *logs;
  40 };
  41
  42 /* The context when loading a CT log list from a CONF file. */
  43 typedef struct ctlog_store_load_ctx_st {
  44     CTLOG_STORE *log_store;
  45     CONF *conf;
  46     size_t invalid_log_entries;
  47 } CTLOG_STORE_LOAD_CTX;
  48
  49 /*
  50  * Creates an empty context for loading a CT log store.
  51  * It should be populated before use.
  52  */
  53 static CTLOG_STORE_LOAD_CTX *ctlog_store_load_ctx_new(void);
  54
  55 /*
  56  * Deletes a CT log store load context.
  57  * Does not delete any of the fields.
  58  */
  59 static void ctlog_store_load_ctx_free(CTLOG_STORE_LOAD_CTX* ctx);
  60
  61 static CTLOG_STORE_LOAD_CTX *ctlog_store_load_ctx_new(void)
  62 {
  63     CTLOG_STORE_LOAD_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
  64
  65     return ctx;
  66 }
  67
  68 static void ctlog_store_load_ctx_free(CTLOG_STORE_LOAD_CTX* ctx)
  69 {
  70     OPENSSL_free(ctx);
  71 }
  72
  73 /* Converts a log's public key into a SHA256 log ID */
  74 static int ct_v1_log_id_from_pkey(CTLOG *log, EVP_PKEY *pkey)
  75 {
  76     int ret = 0;
  77     unsigned char *pkey_der = NULL;
  78     int pkey_der_len = i2d_PUBKEY(pkey, &pkey_der);
  79     unsigned int len;
  80     EVP_MD *sha256 = NULL;
  81
  82     if (pkey_der_len <= 0) {
  83         ERR_raise(ERR_LIB_CT, CT_R_LOG_KEY_INVALID);
  84         goto err;
  85     }
  86     sha256 = EVP_MD_fetch(log->libctx, "SHA2-256", log->propq);
  87     if (sha256 == NULL) {
  88         ERR_raise(ERR_LIB_CT, ERR_R_EVP_LIB);
  89         goto err;
  90     }
  91
  92     ret = EVP_Digest(pkey_der, pkey_der_len, log->log_id, &len, sha256,
  93                      NULL);
  94 err:
  95     EVP_MD_free(sha256);
  96     OPENSSL_free(pkey_der);
  97     return ret;
  98 }
  99
 100 CTLOG_STORE *CTLOG_STORE_new_ex(OSSL_LIB_CTX *libctx, const char *propq)
 101 {
 102     CTLOG_STORE *ret = OPENSSL_zalloc(sizeof(*ret));
 103
 104     if (ret == NULL)
 105         return NULL;
 106
 107     ret->libctx = libctx;
 108     if (propq != NULL) {
 109         ret->propq = OPENSSL_strdup(propq);
 110         if (ret->propq == NULL)
 111             goto err;
 112     }
 113
 114     ret->logs = sk_CTLOG_new_null();
 115     if (ret->logs == NULL) {
 116         ERR_raise(ERR_LIB_CT, ERR_R_CRYPTO_LIB);
 117         goto err;
 118     }
 119
 120     return ret;
 121 err:
 122     CTLOG_STORE_free(ret);
 123     return NULL;
 124 }
 125
 126 CTLOG_STORE *CTLOG_STORE_new(void)
 127 {
 128     return CTLOG_STORE_new_ex(NULL, NULL);
 129 }
 130
 131 void CTLOG_STORE_free(CTLOG_STORE *store)
 132 {
 133     if (store != NULL) {
 134         OPENSSL_free(store->propq);
 135         sk_CTLOG_pop_free(store->logs, CTLOG_free);
 136         OPENSSL_free(store);
 137     }
 138 }
 139
 140 static int ctlog_new_from_conf(CTLOG_STORE *store, CTLOG **ct_log,
 141                                const CONF *conf, const char *section)
 142 {
 143     const char *description = NCONF_get_string(conf, section, "description");
 144     char *pkey_base64;
 145
 146     if (description == NULL) {
 147         ERR_raise(ERR_LIB_CT, CT_R_LOG_CONF_MISSING_DESCRIPTION);
 148         return 0;
 149     }
 150
 151     pkey_base64 = NCONF_get_string(conf, section, "key");
 152     if (pkey_base64 == NULL) {
 153         ERR_raise(ERR_LIB_CT, CT_R_LOG_CONF_MISSING_KEY);
 154         return 0;
 155     }
 156
 157     return CTLOG_new_from_base64_ex(ct_log, pkey_base64, description,
 158                                     store->libctx, store->propq);
 159 }
 160
 161 int CTLOG_STORE_load_default_file(CTLOG_STORE *store)
 162 {
 163     const char *fpath = ossl_safe_getenv(CTLOG_FILE_EVP);
 164
 165     if (fpath == NULL)
 166       fpath = CTLOG_FILE;
 167
 168     return CTLOG_STORE_load_file(store, fpath);
 169 }
 170
 171 /*
 172  * Called by CONF_parse_list, which stops if this returns <= 0,
 173  * Otherwise, one bad log entry would stop loading of any of
 174  * the following log entries.
 175  * It may stop parsing and returns -1 on any internal (malloc) error.
 176  */
 177 static int ctlog_store_load_log(const char *log_name, int log_name_len,
 178                                 void *arg)
 179 {
 180     CTLOG_STORE_LOAD_CTX *load_ctx = arg;
 181     CTLOG *ct_log = NULL;
 182     /* log_name may not be null-terminated, so fix that before using it */
 183     char *tmp;
 184     int ret = 0;
 185
 186     /* log_name will be NULL for empty list entries */
 187     if (log_name == NULL)
 188         return 1;
 189
 190     tmp = OPENSSL_strndup(log_name, log_name_len);
 191     if (tmp == NULL)
 192         return -1;
 193
 194     ret = ctlog_new_from_conf(load_ctx->log_store, &ct_log, load_ctx->conf, tmp);
 195     OPENSSL_free(tmp);
 196
 197     if (ret < 0) {
 198         /* Propagate any internal error */
 199         return ret;
 200     }
 201     if (ret == 0) {
 202         /* If we can't load this log, record that fact and skip it */
 203         ++load_ctx->invalid_log_entries;
 204         return 1;
 205     }
 206
 207     if (!sk_CTLOG_push(load_ctx->log_store->logs, ct_log)) {
 208         CTLOG_free(ct_log);
 209         ERR_raise(ERR_LIB_CT, ERR_R_CRYPTO_LIB);
 210         return -1;
 211     }
 212     return 1;
 213 }
 214
 215 int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file)
 216 {
 217     int ret = 0;
 218     char *enabled_logs;
 219     CTLOG_STORE_LOAD_CTX* load_ctx = ctlog_store_load_ctx_new();
 220
 221     if (load_ctx == NULL)
 222         return 0;
 223     load_ctx->log_store = store;
 224     load_ctx->conf = NCONF_new(NULL);
 225     if (load_ctx->conf == NULL)
 226         goto end;
 227
 228     if (NCONF_load(load_ctx->conf, file, NULL) <= 0) {
 229         ERR_raise(ERR_LIB_CT, CT_R_LOG_CONF_INVALID);
 230         goto end;
 231     }
 232
 233     enabled_logs = NCONF_get_string(load_ctx->conf, NULL, "enabled_logs");
 234     if (enabled_logs == NULL) {
 235         ERR_raise(ERR_LIB_CT, CT_R_LOG_CONF_INVALID);
 236         goto end;
 237     }
 238
 239     if (!CONF_parse_list(enabled_logs, ',', 1, ctlog_store_load_log, load_ctx) ||
 240         load_ctx->invalid_log_entries > 0) {
 241         ERR_raise(ERR_LIB_CT, CT_R_LOG_CONF_INVALID);
 242         goto end;
 243     }
 244
 245     ret = 1;
 246 end:
 247     NCONF_free(load_ctx->conf);
 248     ctlog_store_load_ctx_free(load_ctx);
 249     return ret;
 250 }
 251
 252 /*
 253  * Initialize a new CTLOG object.
 254  * Takes ownership of the public key.
 255  * Copies the name.
 256  */
 257 CTLOG *CTLOG_new_ex(EVP_PKEY *public_key, const char *name, OSSL_LIB_CTX *libctx,
 258                     const char *propq)
 259 {
 260     CTLOG *ret = OPENSSL_zalloc(sizeof(*ret));
 261
 262     if (ret == NULL)
 263         return NULL;
 264
 265     ret->libctx = libctx;
 266     if (propq != NULL) {
 267         ret->propq = OPENSSL_strdup(propq);
 268         if (ret->propq == NULL)
 269             goto err;
 270     }
 271
 272     ret->name = OPENSSL_strdup(name);
 273     if (ret->name == NULL)
 274         goto err;
 275
 276     if (ct_v1_log_id_from_pkey(ret, public_key) != 1)
 277         goto err;
 278
 279     ret->public_key = public_key;
 280     return ret;
 281 err:
 282     CTLOG_free(ret);
 283     return NULL;
 284 }
 285
 286 CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name)
 287 {
 288     return CTLOG_new_ex(public_key, name, NULL, NULL);
 289 }
 290
 291 /* Frees CT log and associated structures */
 292 void CTLOG_free(CTLOG *log)
 293 {
 294     if (log != NULL) {
 295         OPENSSL_free(log->name);
 296         EVP_PKEY_free(log->public_key);
 297         OPENSSL_free(log->propq);
 298         OPENSSL_free(log);
 299     }
 300 }
 301
 302 const char *CTLOG_get0_name(const CTLOG *log)
 303 {
 304     return log->name;
 305 }
 306
 307 void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id,
 308                        size_t *log_id_len)
 309 {
 310     *log_id = log->log_id;
 311     *log_id_len = CT_V1_HASHLEN;
 312 }
 313
 314 EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log)
 315 {
 316     return log->public_key;
 317 }
 318
 319 /*
 320  * Given a log ID, finds the matching log.
 321  * Returns NULL if no match found.
 322  */
 323 const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store,
 324                                         const uint8_t *log_id,
 325                                         size_t log_id_len)
 326 {
 327     int i;
 328
 329     for (i = 0; i < sk_CTLOG_num(store->logs); ++i) {
 330         const CTLOG *log = sk_CTLOG_value(store->logs, i);
 331         if (memcmp(log->log_id, log_id, log_id_len) == 0)
 332             return log;
 333     }
 334
 335     return NULL;
 336 }