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