2 * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved.
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
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>
19 #include "internal/cryptlib.h"
21 DEFINE_STACK_OF(CTLOG)
24 * Information about a CT log server.
30 uint8_t log_id[CT_V1_HASHLEN];
35 * A store for multiple CTLOG instances.
36 * It takes ownership of any CTLOG instances added to it.
38 struct ctlog_store_st {
41 STACK_OF(CTLOG) *logs;
44 /* The context when loading a CT log list from a CONF file. */
45 typedef struct ctlog_store_load_ctx_st {
46 CTLOG_STORE *log_store;
48 size_t invalid_log_entries;
49 } CTLOG_STORE_LOAD_CTX;
52 * Creates an empty context for loading a CT log store.
53 * It should be populated before use.
55 static CTLOG_STORE_LOAD_CTX *ctlog_store_load_ctx_new(void);
58 * Deletes a CT log store load context.
59 * Does not delete any of the fields.
61 static void ctlog_store_load_ctx_free(CTLOG_STORE_LOAD_CTX* ctx);
63 static CTLOG_STORE_LOAD_CTX *ctlog_store_load_ctx_new(void)
65 CTLOG_STORE_LOAD_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
68 CTerr(CT_F_CTLOG_STORE_LOAD_CTX_NEW, ERR_R_MALLOC_FAILURE);
73 static void ctlog_store_load_ctx_free(CTLOG_STORE_LOAD_CTX* ctx)
78 /* Converts a log's public key into a SHA256 log ID */
79 static int ct_v1_log_id_from_pkey(CTLOG *log, EVP_PKEY *pkey)
82 unsigned char *pkey_der = NULL;
83 int pkey_der_len = i2d_PUBKEY(pkey, &pkey_der);
85 EVP_MD *sha256 = NULL;
87 if (pkey_der_len <= 0) {
88 CTerr(CT_F_CT_V1_LOG_ID_FROM_PKEY, CT_R_LOG_KEY_INVALID);
91 sha256 = EVP_MD_fetch(log->libctx, "SHA2-256", log->propq);
93 CTerr(CT_F_CT_V1_LOG_ID_FROM_PKEY, ERR_LIB_EVP);
97 ret = EVP_Digest(pkey_der, pkey_der_len, log->log_id, &len, sha256,
101 OPENSSL_free(pkey_der);
105 CTLOG_STORE *CTLOG_STORE_new_with_libctx(OPENSSL_CTX *libctx, const char *propq)
107 CTLOG_STORE *ret = OPENSSL_zalloc(sizeof(*ret));
110 CTerr(0, ERR_R_MALLOC_FAILURE);
114 ret->libctx = libctx;
116 ret->propq = OPENSSL_strdup(propq);
117 if (ret->propq == NULL) {
118 CTerr(0, ERR_R_MALLOC_FAILURE);
123 ret->logs = sk_CTLOG_new_null();
124 if (ret->logs == NULL) {
125 CTerr(0, ERR_R_MALLOC_FAILURE);
131 CTLOG_STORE_free(ret);
135 CTLOG_STORE *CTLOG_STORE_new(void)
137 return CTLOG_STORE_new_with_libctx(NULL, NULL);
140 void CTLOG_STORE_free(CTLOG_STORE *store)
143 OPENSSL_free(store->propq);
144 sk_CTLOG_pop_free(store->logs, CTLOG_free);
149 static int ctlog_new_from_conf(CTLOG_STORE *store, CTLOG **ct_log,
150 const CONF *conf, const char *section)
152 const char *description = NCONF_get_string(conf, section, "description");
155 if (description == NULL) {
156 CTerr(CT_F_CTLOG_NEW_FROM_CONF, CT_R_LOG_CONF_MISSING_DESCRIPTION);
160 pkey_base64 = NCONF_get_string(conf, section, "key");
161 if (pkey_base64 == NULL) {
162 CTerr(CT_F_CTLOG_NEW_FROM_CONF, CT_R_LOG_CONF_MISSING_KEY);
166 return CTLOG_new_from_base64_with_libctx(ct_log, pkey_base64, description,
167 store->libctx, store->propq);
170 int CTLOG_STORE_load_default_file(CTLOG_STORE *store)
172 const char *fpath = ossl_safe_getenv(CTLOG_FILE_EVP);
177 return CTLOG_STORE_load_file(store, fpath);
181 * Called by CONF_parse_list, which stops if this returns <= 0,
182 * Otherwise, one bad log entry would stop loading of any of
183 * the following log entries.
184 * It may stop parsing and returns -1 on any internal (malloc) error.
186 static int ctlog_store_load_log(const char *log_name, int log_name_len,
189 CTLOG_STORE_LOAD_CTX *load_ctx = arg;
190 CTLOG *ct_log = NULL;
191 /* log_name may not be null-terminated, so fix that before using it */
195 /* log_name will be NULL for empty list entries */
196 if (log_name == NULL)
199 tmp = OPENSSL_strndup(log_name, log_name_len);
203 ret = ctlog_new_from_conf(load_ctx->log_store, &ct_log, load_ctx->conf, tmp);
207 /* Propagate any internal error */
211 /* If we can't load this log, record that fact and skip it */
212 ++load_ctx->invalid_log_entries;
216 if (!sk_CTLOG_push(load_ctx->log_store->logs, ct_log)) {
223 CTerr(CT_F_CTLOG_STORE_LOAD_LOG, ERR_R_MALLOC_FAILURE);
227 int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file)
231 CTLOG_STORE_LOAD_CTX* load_ctx = ctlog_store_load_ctx_new();
233 if (load_ctx == NULL)
235 load_ctx->log_store = store;
236 load_ctx->conf = NCONF_new(NULL);
237 if (load_ctx->conf == NULL)
240 if (NCONF_load(load_ctx->conf, file, NULL) <= 0) {
241 CTerr(CT_F_CTLOG_STORE_LOAD_FILE, CT_R_LOG_CONF_INVALID);
245 enabled_logs = NCONF_get_string(load_ctx->conf, NULL, "enabled_logs");
246 if (enabled_logs == NULL) {
247 CTerr(CT_F_CTLOG_STORE_LOAD_FILE, CT_R_LOG_CONF_INVALID);
251 if (!CONF_parse_list(enabled_logs, ',', 1, ctlog_store_load_log, load_ctx) ||
252 load_ctx->invalid_log_entries > 0) {
253 CTerr(CT_F_CTLOG_STORE_LOAD_FILE, CT_R_LOG_CONF_INVALID);
259 NCONF_free(load_ctx->conf);
260 ctlog_store_load_ctx_free(load_ctx);
265 * Initialize a new CTLOG object.
266 * Takes ownership of the public key.
269 CTLOG *CTLOG_new_with_libctx(EVP_PKEY *public_key, const char *name,
270 OPENSSL_CTX *libctx, const char *propq)
272 CTLOG *ret = OPENSSL_zalloc(sizeof(*ret));
275 CTerr(0, ERR_R_MALLOC_FAILURE);
279 ret->libctx = libctx;
281 ret->name = OPENSSL_strdup(propq);
282 if (ret->propq == NULL) {
283 CTerr(0, ERR_R_MALLOC_FAILURE);
288 ret->name = OPENSSL_strdup(name);
289 if (ret->name == NULL) {
290 CTerr(0, ERR_R_MALLOC_FAILURE);
294 if (ct_v1_log_id_from_pkey(ret, public_key) != 1)
297 ret->public_key = public_key;
304 CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name)
306 return CTLOG_new_with_libctx(public_key, name, NULL, NULL);
309 /* Frees CT log and associated structures */
310 void CTLOG_free(CTLOG *log)
313 OPENSSL_free(log->name);
314 EVP_PKEY_free(log->public_key);
315 OPENSSL_free(log->propq);
320 const char *CTLOG_get0_name(const CTLOG *log)
325 void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id,
328 *log_id = log->log_id;
329 *log_id_len = CT_V1_HASHLEN;
332 EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log)
334 return log->public_key;
338 * Given a log ID, finds the matching log.
339 * Returns NULL if no match found.
341 const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store,
342 const uint8_t *log_id,
347 for (i = 0; i < sk_CTLOG_num(store->logs); ++i) {
348 const CTLOG *log = sk_CTLOG_value(store->logs, i);
349 if (memcmp(log->log_id, log_id, log_id_len) == 0)