Blame


1 44ee1bac 2021-01-27 op /*
2 eac9287d 2023-06-24 op * Copyright (c) 2021, 2023 Omar Polo <op@omarpolo.com>
3 adaae516 2023-10-18 op * Copyright (c) 2019 Renaud Allard <renaud@allard.it>
4 adaae516 2023-10-18 op * Copyright (c) 2016 Kristaps Dzonsons <kristaps@bsd.lv>
5 86693a33 2023-06-11 op * Copyright (c) 2008 Pierre-Yves Ritschard <pyr@openbsd.org>
6 86693a33 2023-06-11 op * Copyright (c) 2008 Reyk Floeter <reyk@openbsd.org>
7 44ee1bac 2021-01-27 op *
8 44ee1bac 2021-01-27 op * Permission to use, copy, modify, and distribute this software for any
9 44ee1bac 2021-01-27 op * purpose with or without fee is hereby granted, provided that the above
10 44ee1bac 2021-01-27 op * copyright notice and this permission notice appear in all copies.
11 44ee1bac 2021-01-27 op *
12 44ee1bac 2021-01-27 op * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13 44ee1bac 2021-01-27 op * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14 44ee1bac 2021-01-27 op * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 44ee1bac 2021-01-27 op * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 44ee1bac 2021-01-27 op * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 44ee1bac 2021-01-27 op * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 44ee1bac 2021-01-27 op * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 44ee1bac 2021-01-27 op */
20 44ee1bac 2021-01-27 op
21 52418c8d 2021-02-12 op #include "gmid.h"
22 52418c8d 2021-02-12 op
23 44ee1bac 2021-01-27 op #include <errno.h>
24 44ee1bac 2021-01-27 op #include <string.h>
25 848189f1 2024-06-06 op #include <vis.h> /* for gmid_strnvis() */
26 44ee1bac 2021-01-27 op
27 adaae516 2023-10-18 op #include <openssl/ec.h>
28 86693a33 2023-06-11 op #include <openssl/err.h>
29 adaae516 2023-10-18 op #include <openssl/evp.h>
30 adaae516 2023-10-18 op #include <openssl/obj_mac.h>
31 3abf91b0 2021-02-07 op #include <openssl/pem.h>
32 adaae516 2023-10-18 op #include <openssl/rsa.h>
33 02be96c6 2021-02-09 op #include <openssl/x509_vfy.h>
34 02be96c6 2021-02-09 op #include <openssl/x509v3.h>
35 3abf91b0 2021-02-07 op
36 eae52ad4 2023-06-06 op #include "log.h"
37 df5058c9 2023-06-05 op
38 adaae516 2023-10-18 op /*
39 adaae516 2023-10-18 op * Default number of bits when creating a new RSA key.
40 adaae516 2023-10-18 op */
41 adaae516 2023-10-18 op #define KBITS 4096
42 adaae516 2023-10-18 op
43 d98ef734 2023-08-08 op const char *
44 d98ef734 2023-08-08 op strip_path(const char *path, int strip)
45 d98ef734 2023-08-08 op {
46 d98ef734 2023-08-08 op char *t;
47 d98ef734 2023-08-08 op
48 d98ef734 2023-08-08 op while (strip > 0) {
49 d98ef734 2023-08-08 op if ((t = strchr(path, '/')) == NULL) {
50 d98ef734 2023-08-08 op path = strchr(path, '\0');
51 d98ef734 2023-08-08 op break;
52 d98ef734 2023-08-08 op }
53 d98ef734 2023-08-08 op path = t;
54 d98ef734 2023-08-08 op strip--;
55 d98ef734 2023-08-08 op }
56 d98ef734 2023-08-08 op
57 d98ef734 2023-08-08 op return path;
58 44ee1bac 2021-01-27 op }
59 44ee1bac 2021-01-27 op
60 44ee1bac 2021-01-27 op int
61 44ee1bac 2021-01-27 op ends_with(const char *str, const char *sufx)
62 44ee1bac 2021-01-27 op {
63 44ee1bac 2021-01-27 op size_t i, j;
64 44ee1bac 2021-01-27 op
65 44ee1bac 2021-01-27 op i = strlen(str);
66 44ee1bac 2021-01-27 op j = strlen(sufx);
67 44ee1bac 2021-01-27 op
68 44ee1bac 2021-01-27 op if (j > i)
69 44ee1bac 2021-01-27 op return 0;
70 44ee1bac 2021-01-27 op
71 44ee1bac 2021-01-27 op i -= j;
72 44ee1bac 2021-01-27 op for (j = 0; str[i] != '\0'; i++, j++)
73 44ee1bac 2021-01-27 op if (str[i] != sufx[j])
74 44ee1bac 2021-01-27 op return 0;
75 44ee1bac 2021-01-27 op return 1;
76 44ee1bac 2021-01-27 op }
77 bcf5d929 2021-02-01 op
78 bcf5d929 2021-02-01 op char *
79 bcf5d929 2021-02-01 op absolutify_path(const char *path)
80 bcf5d929 2021-02-01 op {
81 07ad4910 2023-08-11 op char wd[PATH_MAX], *r;
82 bcf5d929 2021-02-01 op
83 bcf5d929 2021-02-01 op if (*path == '/') {
84 bcf5d929 2021-02-01 op if ((r = strdup(path)) == NULL)
85 792f302a 2023-06-09 op fatal("strdup");
86 bcf5d929 2021-02-01 op return r;
87 bcf5d929 2021-02-01 op }
88 bcf5d929 2021-02-01 op
89 07ad4910 2023-08-11 op if (getcwd(wd, sizeof(wd)) == NULL)
90 07ad4910 2023-08-11 op fatal("getcwd");
91 bcf5d929 2021-02-01 op if (asprintf(&r, "%s/%s", wd, path) == -1)
92 792f302a 2023-06-09 op fatal("asprintf");
93 bcf5d929 2021-02-01 op return r;
94 bcf5d929 2021-02-01 op }
95 ca21e100 2021-02-04 op
96 ca21e100 2021-02-04 op char *
97 ca21e100 2021-02-04 op xstrdup(const char *s)
98 ca21e100 2021-02-04 op {
99 ca21e100 2021-02-04 op char *d;
100 ca21e100 2021-02-04 op
101 ca21e100 2021-02-04 op if ((d = strdup(s)) == NULL)
102 792f302a 2023-06-09 op fatal("strdup");
103 b8e64ccd 2021-03-31 op return d;
104 b8e64ccd 2021-03-31 op }
105 b8e64ccd 2021-03-31 op
106 b8e64ccd 2021-03-31 op void *
107 b8e64ccd 2021-03-31 op xcalloc(size_t nmemb, size_t size)
108 b8e64ccd 2021-03-31 op {
109 b8e64ccd 2021-03-31 op void *d;
110 b8e64ccd 2021-03-31 op
111 b8e64ccd 2021-03-31 op if ((d = calloc(nmemb, size)) == NULL)
112 792f302a 2023-06-09 op fatal("calloc");
113 ca21e100 2021-02-04 op return d;
114 ca21e100 2021-02-04 op }
115 3abf91b0 2021-02-07 op
116 adaae516 2023-10-18 op static EVP_PKEY *
117 adaae516 2023-10-18 op rsa_key_create(FILE *f, const char *fname)
118 adaae516 2023-10-18 op {
119 adaae516 2023-10-18 op EVP_PKEY_CTX *ctx = NULL;
120 adaae516 2023-10-18 op EVP_PKEY *pkey = NULL;
121 adaae516 2023-10-18 op int ret = -1;
122 adaae516 2023-10-18 op
123 adaae516 2023-10-18 op /* First, create the context and the key. */
124 adaae516 2023-10-18 op
125 adaae516 2023-10-18 op if ((ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)) == NULL) {
126 adaae516 2023-10-18 op log_warnx("EVP_PKEY_CTX_new_id failed");
127 adaae516 2023-10-18 op ssl_error("EVP_PKEY_CTX_new_id");
128 adaae516 2023-10-18 op goto done;
129 adaae516 2023-10-18 op }
130 adaae516 2023-10-18 op if (EVP_PKEY_keygen_init(ctx) <= 0) {
131 adaae516 2023-10-18 op log_warnx("EVP_PKEY_keygen_init failed");
132 adaae516 2023-10-18 op ssl_error("EVP_PKEY_keygen_init");
133 adaae516 2023-10-18 op goto done;
134 adaae516 2023-10-18 op }
135 adaae516 2023-10-18 op if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, KBITS) <= 0) {
136 adaae516 2023-10-18 op log_warnx("EVP_PKEY_CTX_set_rsa_keygen_bits failed");
137 adaae516 2023-10-18 op ssl_error("EVP_PKEY_CTX_set_rsa_keygen_bits");
138 adaae516 2023-10-18 op goto done;
139 adaae516 2023-10-18 op }
140 adaae516 2023-10-18 op if (EVP_PKEY_keygen(ctx, &pkey) <= 0) {
141 adaae516 2023-10-18 op log_warnx("EVP_PKEY_keygen failed");
142 adaae516 2023-10-18 op ssl_error("EVP_PKEY_keygen");
143 adaae516 2023-10-18 op goto done;
144 adaae516 2023-10-18 op }
145 adaae516 2023-10-18 op
146 adaae516 2023-10-18 op /* Serialize the key to the disc. */
147 adaae516 2023-10-18 op if (!PEM_write_PrivateKey(f, pkey, NULL, NULL, 0, NULL, NULL)) {
148 adaae516 2023-10-18 op log_warnx("PEM_write_PrivateKey failed");
149 adaae516 2023-10-18 op ssl_error("PEM_write_PrivateKey");
150 adaae516 2023-10-18 op goto done;
151 adaae516 2023-10-18 op }
152 adaae516 2023-10-18 op
153 adaae516 2023-10-18 op ret = 0;
154 adaae516 2023-10-18 op done:
155 adaae516 2023-10-18 op if (ret == -1) {
156 adaae516 2023-10-18 op EVP_PKEY_free(pkey);
157 adaae516 2023-10-18 op pkey = NULL;
158 adaae516 2023-10-18 op }
159 adaae516 2023-10-18 op EVP_PKEY_CTX_free(ctx);
160 adaae516 2023-10-18 op return pkey;
161 adaae516 2023-10-18 op }
162 adaae516 2023-10-18 op
163 adaae516 2023-10-18 op static EVP_PKEY *
164 adaae516 2023-10-18 op ec_key_create(FILE *f, const char *fname)
165 adaae516 2023-10-18 op {
166 adaae516 2023-10-18 op EC_KEY *eckey = NULL;
167 adaae516 2023-10-18 op EVP_PKEY *pkey = NULL;
168 adaae516 2023-10-18 op int ret = -1;
169 adaae516 2023-10-18 op
170 adaae516 2023-10-18 op if ((eckey = EC_KEY_new_by_curve_name(NID_secp384r1)) == NULL) {
171 adaae516 2023-10-18 op log_warnx("EC_KEY_new_by_curve_name failed");
172 adaae516 2023-10-18 op ssl_error("EC_KEY_new_by_curve_name");
173 adaae516 2023-10-18 op goto done;
174 adaae516 2023-10-18 op }
175 adaae516 2023-10-18 op
176 adaae516 2023-10-18 op if (!EC_KEY_generate_key(eckey)) {
177 adaae516 2023-10-18 op log_warnx("EC_KEY_generate_key failed");
178 adaae516 2023-10-18 op ssl_error("EC_KEY_generate_key");
179 adaae516 2023-10-18 op goto done;
180 adaae516 2023-10-18 op }
181 adaae516 2023-10-18 op
182 adaae516 2023-10-18 op /* Serialise the key to the disc in EC format */
183 adaae516 2023-10-18 op if (!PEM_write_ECPrivateKey(f, eckey, NULL, NULL, 0, NULL, NULL)) {
184 adaae516 2023-10-18 op log_warnx("PEM_write_ECPrivateKey failed");
185 adaae516 2023-10-18 op ssl_error("PEM_write_ECPrivateKey");
186 adaae516 2023-10-18 op goto done;
187 adaae516 2023-10-18 op }
188 adaae516 2023-10-18 op
189 adaae516 2023-10-18 op /* Convert the EC key into a PKEY structure */
190 adaae516 2023-10-18 op if ((pkey = EVP_PKEY_new()) == NULL) {
191 adaae516 2023-10-18 op log_warnx("EVP_PKEY_new failed");
192 adaae516 2023-10-18 op ssl_error("EVP_PKEY_new");
193 adaae516 2023-10-18 op goto done;
194 adaae516 2023-10-18 op }
195 adaae516 2023-10-18 op if (!EVP_PKEY_set1_EC_KEY(pkey, eckey)) {
196 adaae516 2023-10-18 op log_warnx("EVP_PKEY_set1_EC_KEY failed");
197 adaae516 2023-10-18 op ssl_error("EVP_PKEY_set1_EC_KEY");
198 adaae516 2023-10-18 op goto done;
199 adaae516 2023-10-18 op }
200 adaae516 2023-10-18 op
201 adaae516 2023-10-18 op ret = 0;
202 adaae516 2023-10-18 op done:
203 adaae516 2023-10-18 op if (ret == -1) {
204 adaae516 2023-10-18 op EVP_PKEY_free(pkey);
205 adaae516 2023-10-18 op pkey = NULL;
206 adaae516 2023-10-18 op log_warnx("WOOOPS");
207 adaae516 2023-10-18 op }
208 adaae516 2023-10-18 op EC_KEY_free(eckey);
209 adaae516 2023-10-18 op return pkey;
210 adaae516 2023-10-18 op }
211 adaae516 2023-10-18 op
212 3abf91b0 2021-02-07 op void
213 adaae516 2023-10-18 op gencert(const char *hostname, const char *certpath, const char *keypath,
214 adaae516 2023-10-18 op int eckey)
215 3abf91b0 2021-02-07 op {
216 3abf91b0 2021-02-07 op EVP_PKEY *pkey;
217 3abf91b0 2021-02-07 op X509 *x509;
218 3abf91b0 2021-02-07 op X509_NAME *name;
219 3abf91b0 2021-02-07 op FILE *f;
220 52418c8d 2021-02-12 op const unsigned char *host = (const unsigned char*)hostname;
221 3abf91b0 2021-02-07 op
222 07d86a0b 2023-10-18 op log_info("Generating new %s key for %s (it could take a while)",
223 07d86a0b 2023-10-18 op eckey ? "EC" : "RSA", host);
224 3abf91b0 2021-02-07 op
225 adaae516 2023-10-18 op if ((f = fopen(keypath, "w")) == NULL) {
226 adaae516 2023-10-18 op log_warn("can't open %s", keypath);
227 adaae516 2023-10-18 op goto err;
228 adaae516 2023-10-18 op }
229 adaae516 2023-10-18 op if (eckey)
230 adaae516 2023-10-18 op pkey = ec_key_create(f, keypath);
231 adaae516 2023-10-18 op else
232 adaae516 2023-10-18 op pkey = rsa_key_create(f, keypath);
233 adaae516 2023-10-18 op if (pkey == NULL) {
234 adaae516 2023-10-18 op log_warnx("failed to generate a private key");
235 adaae516 2023-10-18 op goto err;
236 adaae516 2023-10-18 op }
237 adaae516 2023-10-18 op if (fflush(f) == EOF || fclose(f) == EOF) {
238 adaae516 2023-10-18 op log_warn("failed to flush or close the private key");
239 adaae516 2023-10-18 op goto err;
240 adaae516 2023-10-18 op }
241 3abf91b0 2021-02-07 op
242 adaae516 2023-10-18 op if ((x509 = X509_new()) == NULL) {
243 adaae516 2023-10-18 op log_warnx("couldn't generate the X509 certificate");
244 adaae516 2023-10-18 op ssl_error("X509_new");
245 adaae516 2023-10-18 op goto err;
246 adaae516 2023-10-18 op }
247 3abf91b0 2021-02-07 op
248 1eb3631d 2021-05-12 op ASN1_INTEGER_set(X509_get_serialNumber(x509), 0);
249 3abf91b0 2021-02-07 op X509_gmtime_adj(X509_get_notBefore(x509), 0);
250 3abf91b0 2021-02-07 op X509_gmtime_adj(X509_get_notAfter(x509), 315360000L); /* 10 years */
251 3d06af04 2024-06-10 op X509_set_version(x509, 2); /* v3 */
252 3abf91b0 2021-02-07 op
253 adaae516 2023-10-18 op if (!X509_set_pubkey(x509, pkey)) {
254 adaae516 2023-10-18 op log_warnx("couldn't set the public key");
255 adaae516 2023-10-18 op ssl_error("X509_set_pubkey");
256 adaae516 2023-10-18 op goto err;
257 adaae516 2023-10-18 op }
258 3abf91b0 2021-02-07 op
259 adaae516 2023-10-18 op if ((name = X509_NAME_new()) == NULL) {
260 adaae516 2023-10-18 op log_warnx("X509_NAME_new failed");
261 adaae516 2023-10-18 op ssl_error("X509_NAME_new");
262 adaae516 2023-10-18 op goto err;
263 adaae516 2023-10-18 op }
264 3abf91b0 2021-02-07 op
265 adaae516 2023-10-18 op if (!X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, host,
266 adaae516 2023-10-18 op -1, -1, 0)) {
267 adaae516 2023-10-18 op log_warnx("couldn't add CN to cert");
268 adaae516 2023-10-18 op ssl_error("X509_NAME_add_entry_by_txt");
269 adaae516 2023-10-18 op goto err;
270 adaae516 2023-10-18 op }
271 adaae516 2023-10-18 op X509_set_subject_name(x509, name);
272 adaae516 2023-10-18 op X509_set_issuer_name(x509, name);
273 3abf91b0 2021-02-07 op
274 adaae516 2023-10-18 op if (!X509_sign(x509, pkey, EVP_sha256())) {
275 adaae516 2023-10-18 op log_warnx("failed to sign the certificate");
276 adaae516 2023-10-18 op ssl_error("X509_sign");
277 adaae516 2023-10-18 op goto err;
278 adaae516 2023-10-18 op }
279 3abf91b0 2021-02-07 op
280 adaae516 2023-10-18 op if ((f = fopen(certpath, "w")) == NULL) {
281 adaae516 2023-10-18 op log_warn("can't open %s", certpath);
282 adaae516 2023-10-18 op goto err;
283 adaae516 2023-10-18 op }
284 adaae516 2023-10-18 op if (!PEM_write_X509(f, x509)) {
285 adaae516 2023-10-18 op log_warnx("couldn't write cert");
286 adaae516 2023-10-18 op ssl_error("PEM_write_X509");
287 adaae516 2023-10-18 op goto err;
288 adaae516 2023-10-18 op }
289 adaae516 2023-10-18 op if (fflush(f) == EOF || fclose(f) == EOF) {
290 adaae516 2023-10-18 op log_warn("failed to flush or close the private key");
291 adaae516 2023-10-18 op goto err;
292 adaae516 2023-10-18 op }
293 3abf91b0 2021-02-07 op
294 3abf91b0 2021-02-07 op X509_free(x509);
295 adaae516 2023-10-18 op EVP_PKEY_free(pkey);
296 07d86a0b 2023-10-18 op log_info("Certificate for %s successfully generated", host);
297 adaae516 2023-10-18 op return;
298 7b27af83 2022-04-12 op
299 adaae516 2023-10-18 op err:
300 adaae516 2023-10-18 op (void) unlink(certpath);
301 adaae516 2023-10-18 op (void) unlink(keypath);
302 adaae516 2023-10-18 op exit(1);
303 3abf91b0 2021-02-07 op }
304 02be96c6 2021-02-09 op
305 02be96c6 2021-02-09 op X509_STORE *
306 2cef5cf4 2023-06-12 op load_ca(uint8_t *d, size_t len)
307 02be96c6 2021-02-09 op {
308 2cef5cf4 2023-06-12 op BIO *in;
309 02be96c6 2021-02-09 op X509 *x = NULL;
310 02be96c6 2021-02-09 op X509_STORE *store;
311 02be96c6 2021-02-09 op
312 deadd9e1 2023-06-09 op if ((store = X509_STORE_new()) == NULL) {
313 2cef5cf4 2023-06-12 op log_warnx("%s: X509_STORE_new failed", __func__);
314 02be96c6 2021-02-09 op return NULL;
315 deadd9e1 2023-06-09 op }
316 02be96c6 2021-02-09 op
317 2cef5cf4 2023-06-12 op if ((in = BIO_new_mem_buf(d, len)) == NULL) {
318 2cef5cf4 2023-06-12 op log_warnx("%s: BIO_new_mem_buf failed", __func__);
319 02be96c6 2021-02-09 op goto err;
320 deadd9e1 2023-06-09 op }
321 02be96c6 2021-02-09 op
322 2cef5cf4 2023-06-12 op if ((x = PEM_read_bio_X509(in, NULL, NULL, NULL)) == NULL) {
323 2cef5cf4 2023-06-12 op log_warnx("%s: PEM_read_bio_X509 failed", __func__);
324 2cef5cf4 2023-06-12 op ssl_error("PEM_read_bio_X509");
325 02be96c6 2021-02-09 op goto err;
326 2cef5cf4 2023-06-12 op }
327 02be96c6 2021-02-09 op
328 2cef5cf4 2023-06-12 op if (X509_check_ca(x) == 0) {
329 2cef5cf4 2023-06-12 op ssl_error("X509_check_ca");
330 02be96c6 2021-02-09 op goto err;
331 2cef5cf4 2023-06-12 op }
332 02be96c6 2021-02-09 op
333 2cef5cf4 2023-06-12 op if (!X509_STORE_add_cert(store, x)) {
334 2cef5cf4 2023-06-12 op ssl_error("X509_STORE_add_cert");
335 02be96c6 2021-02-09 op goto err;
336 2cef5cf4 2023-06-12 op }
337 02be96c6 2021-02-09 op
338 02be96c6 2021-02-09 op X509_free(x);
339 2cef5cf4 2023-06-12 op BIO_free(in);
340 02be96c6 2021-02-09 op return store;
341 02be96c6 2021-02-09 op
342 02be96c6 2021-02-09 op err:
343 02be96c6 2021-02-09 op X509_STORE_free(store);
344 02be96c6 2021-02-09 op if (x != NULL)
345 02be96c6 2021-02-09 op X509_free(x);
346 2cef5cf4 2023-06-12 op if (in != NULL)
347 2cef5cf4 2023-06-12 op BIO_free(in);
348 02be96c6 2021-02-09 op return NULL;
349 02be96c6 2021-02-09 op }
350 02be96c6 2021-02-09 op
351 02be96c6 2021-02-09 op int
352 02be96c6 2021-02-09 op validate_against_ca(X509_STORE *ca, const uint8_t *chain, size_t len)
353 02be96c6 2021-02-09 op {
354 02be96c6 2021-02-09 op X509 *client;
355 02be96c6 2021-02-09 op BIO *m;
356 02be96c6 2021-02-09 op X509_STORE_CTX *ctx = NULL;
357 02be96c6 2021-02-09 op int ret = 0;
358 02be96c6 2021-02-09 op
359 02be96c6 2021-02-09 op if ((m = BIO_new_mem_buf(chain, len)) == NULL)
360 02be96c6 2021-02-09 op return 0;
361 02be96c6 2021-02-09 op
362 02be96c6 2021-02-09 op if ((client = PEM_read_bio_X509(m, NULL, NULL, NULL)) == NULL)
363 02be96c6 2021-02-09 op goto end;
364 02be96c6 2021-02-09 op
365 02be96c6 2021-02-09 op if ((ctx = X509_STORE_CTX_new()) == NULL)
366 02be96c6 2021-02-09 op goto end;
367 02be96c6 2021-02-09 op
368 02be96c6 2021-02-09 op if (!X509_STORE_CTX_init(ctx, ca, client, NULL))
369 02be96c6 2021-02-09 op goto end;
370 02be96c6 2021-02-09 op
371 02be96c6 2021-02-09 op ret = X509_verify_cert(ctx);
372 02be96c6 2021-02-09 op
373 02be96c6 2021-02-09 op end:
374 02be96c6 2021-02-09 op BIO_free(m);
375 02be96c6 2021-02-09 op if (client != NULL)
376 02be96c6 2021-02-09 op X509_free(client);
377 02be96c6 2021-02-09 op if (ctx != NULL)
378 02be96c6 2021-02-09 op X509_STORE_CTX_free(ctx);
379 02be96c6 2021-02-09 op return ret;
380 fc9cc497 2023-06-08 op }
381 fc9cc497 2023-06-08 op
382 86693a33 2023-06-11 op void
383 86693a33 2023-06-11 op ssl_error(const char *where)
384 86693a33 2023-06-11 op {
385 86693a33 2023-06-11 op unsigned long code;
386 86693a33 2023-06-11 op char errbuf[128];
387 86693a33 2023-06-11 op
388 86693a33 2023-06-11 op while ((code = ERR_get_error()) != 0) {
389 86693a33 2023-06-11 op ERR_error_string_n(code, errbuf, sizeof(errbuf));
390 86693a33 2023-06-11 op log_debug("debug: SSL library error: %s: %s", where, errbuf);
391 86693a33 2023-06-11 op }
392 86693a33 2023-06-11 op }
393 86693a33 2023-06-11 op
394 86693a33 2023-06-11 op char *
395 b8d68fc8 2023-06-11 op ssl_pubkey_hash(const uint8_t *buf, size_t len)
396 86693a33 2023-06-11 op {
397 86693a33 2023-06-11 op static const char hex[] = "0123456789abcdef";
398 86693a33 2023-06-11 op BIO *in;
399 86693a33 2023-06-11 op X509 *x509 = NULL;
400 86693a33 2023-06-11 op char *hash = NULL;
401 86693a33 2023-06-11 op size_t off;
402 b8d68fc8 2023-06-11 op unsigned char digest[EVP_MAX_MD_SIZE];
403 b8d68fc8 2023-06-11 op unsigned int dlen, i;
404 86693a33 2023-06-11 op
405 86693a33 2023-06-11 op if ((in = BIO_new_mem_buf(buf, len)) == NULL) {
406 86693a33 2023-06-11 op log_warnx("%s: BIO_new_mem_buf failed", __func__);
407 86693a33 2023-06-11 op return NULL;
408 86693a33 2023-06-11 op }
409 86693a33 2023-06-11 op
410 86693a33 2023-06-11 op if ((x509 = PEM_read_bio_X509(in, NULL, NULL, NULL)) == NULL) {
411 86693a33 2023-06-11 op log_warnx("%s: PEM_read_bio_X509 failed", __func__);
412 86693a33 2023-06-11 op ssl_error("PEM_read_bio_X509");
413 86693a33 2023-06-11 op goto fail;
414 86693a33 2023-06-11 op }
415 86693a33 2023-06-11 op
416 86693a33 2023-06-11 op if ((hash = malloc(TLS_CERT_HASH_SIZE)) == NULL) {
417 86693a33 2023-06-11 op log_warn("%s: malloc", __func__);
418 86693a33 2023-06-11 op goto fail;
419 86693a33 2023-06-11 op }
420 86693a33 2023-06-11 op
421 86693a33 2023-06-11 op if (X509_pubkey_digest(x509, EVP_sha256(), digest, &dlen) != 1) {
422 86693a33 2023-06-11 op log_warnx("%s: X509_pubkey_digest failed", __func__);
423 86693a33 2023-06-11 op ssl_error("X509_pubkey_digest");
424 86693a33 2023-06-11 op free(hash);
425 86693a33 2023-06-11 op hash = NULL;
426 86693a33 2023-06-11 op goto fail;
427 86693a33 2023-06-11 op }
428 86693a33 2023-06-11 op
429 86693a33 2023-06-11 op if (TLS_CERT_HASH_SIZE < 2 * dlen + sizeof("SHA256:"))
430 86693a33 2023-06-11 op fatalx("%s: hash buffer too small", __func__);
431 86693a33 2023-06-11 op
432 86693a33 2023-06-11 op off = strlcpy(hash, "SHA256:", TLS_CERT_HASH_SIZE);
433 86693a33 2023-06-11 op for (i = 0; i < dlen; ++i) {
434 86693a33 2023-06-11 op hash[off++] = hex[(digest[i] >> 4) & 0xf];
435 86693a33 2023-06-11 op hash[off++] = hex[digest[i] & 0xf];
436 86693a33 2023-06-11 op }
437 86693a33 2023-06-11 op hash[off] = '\0';
438 86693a33 2023-06-11 op
439 86693a33 2023-06-11 op fail:
440 86693a33 2023-06-11 op BIO_free(in);
441 86693a33 2023-06-11 op if (x509)
442 86693a33 2023-06-11 op X509_free(x509);
443 86693a33 2023-06-11 op return hash;
444 86693a33 2023-06-11 op }
445 86693a33 2023-06-11 op
446 86693a33 2023-06-11 op EVP_PKEY *
447 b8d68fc8 2023-06-11 op ssl_load_pkey(const uint8_t *buf, size_t len)
448 86693a33 2023-06-11 op {
449 86693a33 2023-06-11 op BIO *in;
450 86693a33 2023-06-11 op EVP_PKEY *pkey;
451 86693a33 2023-06-11 op
452 86693a33 2023-06-11 op if ((in = BIO_new_mem_buf(buf, len)) == NULL) {
453 86693a33 2023-06-11 op log_warnx("%s: BIO_new_mem_buf failed", __func__);
454 86693a33 2023-06-11 op return NULL;
455 86693a33 2023-06-11 op }
456 86693a33 2023-06-11 op
457 86693a33 2023-06-11 op if ((pkey = PEM_read_bio_PrivateKey(in, NULL, NULL, NULL)) == NULL) {
458 86693a33 2023-06-11 op log_warnx("%s: PEM_read_bio_PrivateKey failed", __func__);
459 86693a33 2023-06-11 op ssl_error("PEM_read_bio_PrivateKey");
460 86693a33 2023-06-11 op }
461 86693a33 2023-06-11 op
462 86693a33 2023-06-11 op BIO_free(in);
463 86693a33 2023-06-11 op return pkey;
464 86693a33 2023-06-11 op }
465 86693a33 2023-06-11 op
466 fc9cc497 2023-06-08 op struct vhost *
467 fc9cc497 2023-06-08 op new_vhost(void)
468 fc9cc497 2023-06-08 op {
469 fc9cc497 2023-06-08 op struct vhost *h;
470 fc9cc497 2023-06-08 op
471 fc9cc497 2023-06-08 op h = xcalloc(1, sizeof(*h));
472 509d0509 2023-06-23 op TAILQ_INIT(&h->addrs);
473 fc9cc497 2023-06-08 op TAILQ_INIT(&h->locations);
474 fc9cc497 2023-06-08 op TAILQ_INIT(&h->aliases);
475 fc9cc497 2023-06-08 op TAILQ_INIT(&h->proxies);
476 fc9cc497 2023-06-08 op return h;
477 fc9cc497 2023-06-08 op }
478 fc9cc497 2023-06-08 op
479 fc9cc497 2023-06-08 op struct location *
480 fc9cc497 2023-06-08 op new_location(void)
481 fc9cc497 2023-06-08 op {
482 fc9cc497 2023-06-08 op struct location *l;
483 fc9cc497 2023-06-08 op
484 fc9cc497 2023-06-08 op l = xcalloc(1, sizeof(*l));
485 fc9cc497 2023-06-08 op l->dirfd = -1;
486 fc9cc497 2023-06-08 op l->fcgi = -1;
487 a1ba9650 2023-07-23 op TAILQ_INIT(&l->params);
488 fc9cc497 2023-06-08 op return l;
489 02be96c6 2021-02-09 op }
490 fc9cc497 2023-06-08 op
491 fc9cc497 2023-06-08 op struct proxy *
492 fc9cc497 2023-06-08 op new_proxy(void)
493 fc9cc497 2023-06-08 op {
494 fc9cc497 2023-06-08 op struct proxy *p;
495 fc9cc497 2023-06-08 op
496 fc9cc497 2023-06-08 op p = xcalloc(1, sizeof(*p));
497 fc9cc497 2023-06-08 op p->protocols = TLS_PROTOCOLS_DEFAULT;
498 fc9cc497 2023-06-08 op return p;
499 848189f1 2024-06-06 op }