crypto/ct/ct_log.c

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