366 lines
8.8 KiB
C
366 lines
8.8 KiB
C
|
/* $OpenBSD: ct_log.c,v 1.5 2021/12/18 16:34:52 tb Exp $ */
|
||
|
|
/* Author: Adam Eijdenberg <adam.eijdenberg@gmail.com>. */
|
||
|
|
/* ====================================================================
|
||
|
|
* Copyright (c) 1998-2016 The OpenSSL Project. All rights reserved.
|
||
|
|
*
|
||
|
|
* Redistribution and use in source and binary forms, with or without
|
||
|
|
* modification, are permitted provided that the following conditions
|
||
|
|
* are met:
|
||
|
|
*
|
||
|
|
* 1. Redistributions of source code must retain the above copyright
|
||
|
|
* notice, this list of conditions and the following disclaimer.
|
||
|
|
*
|
||
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
||
|
|
* notice, this list of conditions and the following disclaimer in
|
||
|
|
* the documentation and/or other materials provided with the
|
||
|
|
* distribution.
|
||
|
|
*
|
||
|
|
* 3. All advertising materials mentioning features or use of this
|
||
|
|
* software must display the following acknowledgment:
|
||
|
|
* "This product includes software developed by the OpenSSL Project
|
||
|
|
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
||
|
|
*
|
||
|
|
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
||
|
|
* endorse or promote products derived from this software without
|
||
|
|
* prior written permission. For written permission, please contact
|
||
|
|
* openssl-core@openssl.org.
|
||
|
|
*
|
||
|
|
* 5. Products derived from this software may not be called "OpenSSL"
|
||
|
|
* nor may "OpenSSL" appear in their names without prior written
|
||
|
|
* permission of the OpenSSL Project.
|
||
|
|
*
|
||
|
|
* 6. Redistributions of any form whatsoever must retain the following
|
||
|
|
* acknowledgment:
|
||
|
|
* "This product includes software developed by the OpenSSL Project
|
||
|
|
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
||
|
|
*
|
||
|
|
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
||
|
|
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
|
||
|
|
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
|
|
* ====================================================================
|
||
|
|
*
|
||
|
|
* This product includes cryptographic software written by Eric Young
|
||
|
|
* (eay@cryptsoft.com). This product includes software written by Tim
|
||
|
|
* Hudson (tjh@cryptsoft.com).
|
||
|
|
*
|
||
|
|
* Licensed under the OpenSSL license (the "License"). You may not use
|
||
|
|
* this file except in compliance with the License. You can obtain a copy
|
||
|
|
* in the file LICENSE in the source distribution or at
|
||
|
|
* https://www.openssl.org/source/license.html
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
#include <openssl/conf.h>
|
||
|
|
#include <openssl/ct.h>
|
||
|
|
#include <openssl/err.h>
|
||
|
|
#include <openssl/evp.h>
|
||
|
|
#include <openssl/safestack.h>
|
||
|
|
|
||
|
|
#include "cryptlib.h"
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Information about a CT log server.
|
||
|
|
*/
|
||
|
|
struct ctlog_st {
|
||
|
|
char *name;
|
||
|
|
uint8_t log_id[CT_V1_HASHLEN];
|
||
|
|
EVP_PKEY *public_key;
|
||
|
|
};
|
||
|
|
|
||
|
|
/*
|
||
|
|
* A store for multiple CTLOG instances.
|
||
|
|
* It takes ownership of any CTLOG instances added to it.
|
||
|
|
*/
|
||
|
|
struct ctlog_store_st {
|
||
|
|
STACK_OF(CTLOG) *logs;
|
||
|
|
};
|
||
|
|
|
||
|
|
/* The context when loading a CT log list from a CONF file. */
|
||
|
|
typedef struct ctlog_store_load_ctx_st {
|
||
|
|
CTLOG_STORE *log_store;
|
||
|
|
CONF *conf;
|
||
|
|
size_t invalid_log_entries;
|
||
|
|
} CTLOG_STORE_LOAD_CTX;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Creates an empty context for loading a CT log store.
|
||
|
|
* It should be populated before use.
|
||
|
|
*/
|
||
|
|
static CTLOG_STORE_LOAD_CTX *ctlog_store_load_ctx_new(void);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Deletes a CT log store load context.
|
||
|
|
* Does not delete any of the fields.
|
||
|
|
*/
|
||
|
|
static void ctlog_store_load_ctx_free(CTLOG_STORE_LOAD_CTX *ctx);
|
||
|
|
|
||
|
|
static CTLOG_STORE_LOAD_CTX *
|
||
|
|
ctlog_store_load_ctx_new(void)
|
||
|
|
{
|
||
|
|
CTLOG_STORE_LOAD_CTX *ctx = calloc(1, sizeof(*ctx));
|
||
|
|
|
||
|
|
if (ctx == NULL)
|
||
|
|
CTerror(ERR_R_MALLOC_FAILURE);
|
||
|
|
|
||
|
|
return ctx;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
ctlog_store_load_ctx_free(CTLOG_STORE_LOAD_CTX *ctx)
|
||
|
|
{
|
||
|
|
free(ctx);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Converts a log's public key into a SHA256 log ID */
|
||
|
|
static int
|
||
|
|
ct_v1_log_id_from_pkey(EVP_PKEY *pkey, unsigned char log_id[CT_V1_HASHLEN])
|
||
|
|
{
|
||
|
|
int ret = 0;
|
||
|
|
unsigned char *pkey_der = NULL;
|
||
|
|
int pkey_der_len = i2d_PUBKEY(pkey, &pkey_der);
|
||
|
|
|
||
|
|
if (pkey_der_len <= 0) {
|
||
|
|
CTerror(CT_R_LOG_KEY_INVALID);
|
||
|
|
goto err;
|
||
|
|
}
|
||
|
|
|
||
|
|
SHA256(pkey_der, pkey_der_len, log_id);
|
||
|
|
ret = 1;
|
||
|
|
err:
|
||
|
|
free(pkey_der);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
CTLOG_STORE *
|
||
|
|
CTLOG_STORE_new(void)
|
||
|
|
{
|
||
|
|
CTLOG_STORE *ret = calloc(1, sizeof(*ret));
|
||
|
|
|
||
|
|
if (ret == NULL) {
|
||
|
|
CTerror(ERR_R_MALLOC_FAILURE);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret->logs = sk_CTLOG_new_null();
|
||
|
|
if (ret->logs == NULL)
|
||
|
|
goto err;
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
err:
|
||
|
|
free(ret);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
CTLOG_STORE_free(CTLOG_STORE *store)
|
||
|
|
{
|
||
|
|
if (store != NULL) {
|
||
|
|
sk_CTLOG_pop_free(store->logs, CTLOG_free);
|
||
|
|
free(store);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static int
|
||
|
|
ctlog_new_from_conf(CTLOG **ct_log, const CONF *conf, const char *section)
|
||
|
|
{
|
||
|
|
const char *description = NCONF_get_string(conf, section,
|
||
|
|
"description");
|
||
|
|
char *pkey_base64;
|
||
|
|
|
||
|
|
if (description == NULL) {
|
||
|
|
CTerror(CT_R_LOG_CONF_MISSING_DESCRIPTION);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
pkey_base64 = NCONF_get_string(conf, section, "key");
|
||
|
|
if (pkey_base64 == NULL) {
|
||
|
|
CTerror(CT_R_LOG_CONF_MISSING_KEY);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return CTLOG_new_from_base64(ct_log, pkey_base64, description);
|
||
|
|
}
|
||
|
|
|
||
|
|
int
|
||
|
|
CTLOG_STORE_load_default_file(CTLOG_STORE *store)
|
||
|
|
{
|
||
|
|
return CTLOG_STORE_load_file(store, CTLOG_FILE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Called by CONF_parse_list, which stops if this returns <= 0,
|
||
|
|
* Otherwise, one bad log entry would stop loading of any of
|
||
|
|
* the following log entries.
|
||
|
|
* It may stop parsing and returns -1 on any internal (malloc) error.
|
||
|
|
*/
|
||
|
|
static int
|
||
|
|
ctlog_store_load_log(const char *log_name, int log_name_len, void *arg)
|
||
|
|
{
|
||
|
|
CTLOG_STORE_LOAD_CTX *load_ctx = arg;
|
||
|
|
CTLOG *ct_log = NULL;
|
||
|
|
/* log_name may not be null-terminated, so fix that before using it */
|
||
|
|
char *tmp;
|
||
|
|
int ret = 0;
|
||
|
|
|
||
|
|
/* log_name will be NULL for empty list entries */
|
||
|
|
if (log_name == NULL)
|
||
|
|
return 1;
|
||
|
|
|
||
|
|
tmp = strndup(log_name, log_name_len);
|
||
|
|
if (tmp == NULL)
|
||
|
|
goto mem_err;
|
||
|
|
|
||
|
|
ret = ctlog_new_from_conf(&ct_log, load_ctx->conf, tmp);
|
||
|
|
free(tmp);
|
||
|
|
|
||
|
|
if (ret < 0) {
|
||
|
|
/* Propagate any internal error */
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
if (ret == 0) {
|
||
|
|
/* If we can't load this log, record that fact and skip it */
|
||
|
|
++load_ctx->invalid_log_entries;
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!sk_CTLOG_push(load_ctx->log_store->logs, ct_log)) {
|
||
|
|
goto mem_err;
|
||
|
|
}
|
||
|
|
return 1;
|
||
|
|
|
||
|
|
mem_err:
|
||
|
|
CTLOG_free(ct_log);
|
||
|
|
CTerror(ERR_R_MALLOC_FAILURE);
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
int
|
||
|
|
CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file)
|
||
|
|
{
|
||
|
|
int ret = 0;
|
||
|
|
char *enabled_logs;
|
||
|
|
CTLOG_STORE_LOAD_CTX* load_ctx = ctlog_store_load_ctx_new();
|
||
|
|
|
||
|
|
if (load_ctx == NULL)
|
||
|
|
return 0;
|
||
|
|
load_ctx->log_store = store;
|
||
|
|
load_ctx->conf = NCONF_new(NULL);
|
||
|
|
if (load_ctx->conf == NULL)
|
||
|
|
goto end;
|
||
|
|
|
||
|
|
if (NCONF_load(load_ctx->conf, file, NULL) <= 0) {
|
||
|
|
CTerror(CT_R_LOG_CONF_INVALID);
|
||
|
|
goto end;
|
||
|
|
}
|
||
|
|
|
||
|
|
enabled_logs = NCONF_get_string(load_ctx->conf, NULL, "enabled_logs");
|
||
|
|
if (enabled_logs == NULL) {
|
||
|
|
CTerror(CT_R_LOG_CONF_INVALID);
|
||
|
|
goto end;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!CONF_parse_list(enabled_logs, ',', 1, ctlog_store_load_log, load_ctx) ||
|
||
|
|
load_ctx->invalid_log_entries > 0) {
|
||
|
|
CTerror(CT_R_LOG_CONF_INVALID);
|
||
|
|
goto end;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret = 1;
|
||
|
|
end:
|
||
|
|
NCONF_free(load_ctx->conf);
|
||
|
|
ctlog_store_load_ctx_free(load_ctx);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Initialize a new CTLOG object.
|
||
|
|
* Takes ownership of the public key.
|
||
|
|
* Copies the name.
|
||
|
|
*/
|
||
|
|
CTLOG *
|
||
|
|
CTLOG_new(EVP_PKEY *public_key, const char *name)
|
||
|
|
{
|
||
|
|
CTLOG *ret = calloc(1, sizeof(*ret));
|
||
|
|
|
||
|
|
if (ret == NULL) {
|
||
|
|
CTerror(ERR_R_MALLOC_FAILURE);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
ret->name = strdup(name);
|
||
|
|
if (ret->name == NULL) {
|
||
|
|
CTerror(ERR_R_MALLOC_FAILURE);
|
||
|
|
goto err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ct_v1_log_id_from_pkey(public_key, ret->log_id) != 1)
|
||
|
|
goto err;
|
||
|
|
|
||
|
|
ret->public_key = public_key;
|
||
|
|
return ret;
|
||
|
|
err:
|
||
|
|
CTLOG_free(ret);
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Frees CT log and associated structures */
|
||
|
|
void
|
||
|
|
CTLOG_free(CTLOG *log)
|
||
|
|
{
|
||
|
|
if (log != NULL) {
|
||
|
|
free(log->name);
|
||
|
|
EVP_PKEY_free(log->public_key);
|
||
|
|
free(log);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *
|
||
|
|
CTLOG_get0_name(const CTLOG *log)
|
||
|
|
{
|
||
|
|
return log->name;
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id, size_t *log_id_len)
|
||
|
|
{
|
||
|
|
*log_id = log->log_id;
|
||
|
|
*log_id_len = CT_V1_HASHLEN;
|
||
|
|
}
|
||
|
|
|
||
|
|
EVP_PKEY *
|
||
|
|
CTLOG_get0_public_key(const CTLOG *log)
|
||
|
|
{
|
||
|
|
return log->public_key;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Given a log ID, finds the matching log.
|
||
|
|
* Returns NULL if no match found.
|
||
|
|
*/
|
||
|
|
const CTLOG *
|
||
|
|
CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store, const uint8_t *log_id,
|
||
|
|
size_t log_id_len)
|
||
|
|
{
|
||
|
|
int i;
|
||
|
|
|
||
|
|
for (i = 0; i < sk_CTLOG_num(store->logs); ++i) {
|
||
|
|
const CTLOG *log = sk_CTLOG_value(store->logs, i);
|
||
|
|
if (memcmp(log->log_id, log_id, log_id_len) == 0)
|
||
|
|
return log;
|
||
|
|
}
|
||
|
|
|
||
|
|
return NULL;
|
||
|
|
}
|