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>
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.
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.
21 52418c8d 2021-02-12 op #include "gmid.h"
23 44ee1bac 2021-01-27 op #include <errno.h>
24 44ee1bac 2021-01-27 op #include <string.h>
26 adaae516 2023-10-18 op #include <openssl/ec.h>
27 86693a33 2023-06-11 op #include <openssl/err.h>
28 adaae516 2023-10-18 op #include <openssl/evp.h>
29 adaae516 2023-10-18 op #include <openssl/obj_mac.h>
30 3abf91b0 2021-02-07 op #include <openssl/pem.h>
31 adaae516 2023-10-18 op #include <openssl/rsa.h>
32 02be96c6 2021-02-09 op #include <openssl/x509_vfy.h>
33 02be96c6 2021-02-09 op #include <openssl/x509v3.h>
35 eae52ad4 2023-06-06 op #include "log.h"
38 adaae516 2023-10-18 op * Default number of bits when creating a new RSA key.
40 adaae516 2023-10-18 op #define KBITS 4096
43 d98ef734 2023-08-08 op strip_path(const char *path, int strip)
47 d98ef734 2023-08-08 op while (strip > 0) {
48 d98ef734 2023-08-08 op if ((t = strchr(path, '/')) == NULL) {
49 d98ef734 2023-08-08 op path = strchr(path, '\0');
60 44ee1bac 2021-01-27 op ends_with(const char *str, const char *sufx)
64 44ee1bac 2021-01-27 op i = strlen(str);
65 44ee1bac 2021-01-27 op j = strlen(sufx);
71 44ee1bac 2021-01-27 op for (j = 0; str[i] != '\0'; i++, j++)
72 44ee1bac 2021-01-27 op if (str[i] != sufx[j])
78 bcf5d929 2021-02-01 op absolutify_path(const char *path)
80 07ad4910 2023-08-11 op char wd[PATH_MAX], *r;
82 bcf5d929 2021-02-01 op if (*path == '/') {
83 bcf5d929 2021-02-01 op if ((r = strdup(path)) == NULL)
84 792f302a 2023-06-09 op fatal("strdup");
88 07ad4910 2023-08-11 op if (getcwd(wd, sizeof(wd)) == NULL)
89 07ad4910 2023-08-11 op fatal("getcwd");
90 bcf5d929 2021-02-01 op if (asprintf(&r, "%s/%s", wd, path) == -1)
91 792f302a 2023-06-09 op fatal("asprintf");
96 ca21e100 2021-02-04 op xstrdup(const char *s)
100 ca21e100 2021-02-04 op if ((d = strdup(s)) == NULL)
101 792f302a 2023-06-09 op fatal("strdup");
106 b8e64ccd 2021-03-31 op xcalloc(size_t nmemb, size_t size)
110 b8e64ccd 2021-03-31 op if ((d = calloc(nmemb, size)) == NULL)
111 792f302a 2023-06-09 op fatal("calloc");
115 adaae516 2023-10-18 op static EVP_PKEY *
116 adaae516 2023-10-18 op rsa_key_create(FILE *f, const char *fname)
118 adaae516 2023-10-18 op EVP_PKEY_CTX *ctx = NULL;
119 adaae516 2023-10-18 op EVP_PKEY *pkey = NULL;
120 adaae516 2023-10-18 op int ret = -1;
122 adaae516 2023-10-18 op /* First, create the context and the key. */
124 adaae516 2023-10-18 op if ((ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)) == NULL) {
125 adaae516 2023-10-18 op log_warnx("EVP_PKEY_CTX_new_id failed");
126 adaae516 2023-10-18 op ssl_error("EVP_PKEY_CTX_new_id");
129 adaae516 2023-10-18 op if (EVP_PKEY_keygen_init(ctx) <= 0) {
130 adaae516 2023-10-18 op log_warnx("EVP_PKEY_keygen_init failed");
131 adaae516 2023-10-18 op ssl_error("EVP_PKEY_keygen_init");
134 adaae516 2023-10-18 op if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, KBITS) <= 0) {
135 adaae516 2023-10-18 op log_warnx("EVP_PKEY_CTX_set_rsa_keygen_bits failed");
136 adaae516 2023-10-18 op ssl_error("EVP_PKEY_CTX_set_rsa_keygen_bits");
139 adaae516 2023-10-18 op if (EVP_PKEY_keygen(ctx, &pkey) <= 0) {
140 adaae516 2023-10-18 op log_warnx("EVP_PKEY_keygen failed");
141 adaae516 2023-10-18 op ssl_error("EVP_PKEY_keygen");
145 adaae516 2023-10-18 op /* Serialize the key to the disc. */
146 adaae516 2023-10-18 op if (!PEM_write_PrivateKey(f, pkey, NULL, NULL, 0, NULL, NULL)) {
147 adaae516 2023-10-18 op log_warnx("PEM_write_PrivateKey failed");
148 adaae516 2023-10-18 op ssl_error("PEM_write_PrivateKey");
154 adaae516 2023-10-18 op if (ret == -1) {
155 adaae516 2023-10-18 op EVP_PKEY_free(pkey);
158 adaae516 2023-10-18 op EVP_PKEY_CTX_free(ctx);
162 adaae516 2023-10-18 op static EVP_PKEY *
163 adaae516 2023-10-18 op ec_key_create(FILE *f, const char *fname)
165 adaae516 2023-10-18 op EC_KEY *eckey = NULL;
166 adaae516 2023-10-18 op EVP_PKEY *pkey = NULL;
167 adaae516 2023-10-18 op int ret = -1;
169 adaae516 2023-10-18 op if ((eckey = EC_KEY_new_by_curve_name(NID_secp384r1)) == NULL) {
170 adaae516 2023-10-18 op log_warnx("EC_KEY_new_by_curve_name failed");
171 adaae516 2023-10-18 op ssl_error("EC_KEY_new_by_curve_name");
175 adaae516 2023-10-18 op if (!EC_KEY_generate_key(eckey)) {
176 adaae516 2023-10-18 op log_warnx("EC_KEY_generate_key failed");
177 adaae516 2023-10-18 op ssl_error("EC_KEY_generate_key");
181 adaae516 2023-10-18 op /* Serialise the key to the disc in EC format */
182 adaae516 2023-10-18 op if (!PEM_write_ECPrivateKey(f, eckey, NULL, NULL, 0, NULL, NULL)) {
183 adaae516 2023-10-18 op log_warnx("PEM_write_ECPrivateKey failed");
184 adaae516 2023-10-18 op ssl_error("PEM_write_ECPrivateKey");
188 adaae516 2023-10-18 op /* Convert the EC key into a PKEY structure */
189 adaae516 2023-10-18 op if ((pkey = EVP_PKEY_new()) == NULL) {
190 adaae516 2023-10-18 op log_warnx("EVP_PKEY_new failed");
191 adaae516 2023-10-18 op ssl_error("EVP_PKEY_new");
194 adaae516 2023-10-18 op if (!EVP_PKEY_set1_EC_KEY(pkey, eckey)) {
195 adaae516 2023-10-18 op log_warnx("EVP_PKEY_set1_EC_KEY failed");
196 adaae516 2023-10-18 op ssl_error("EVP_PKEY_set1_EC_KEY");
202 adaae516 2023-10-18 op if (ret == -1) {
203 adaae516 2023-10-18 op EVP_PKEY_free(pkey);
205 adaae516 2023-10-18 op log_warnx("WOOOPS");
207 adaae516 2023-10-18 op EC_KEY_free(eckey);
212 adaae516 2023-10-18 op gencert(const char *hostname, const char *certpath, const char *keypath,
215 3abf91b0 2021-02-07 op EVP_PKEY *pkey;
217 3abf91b0 2021-02-07 op X509_NAME *name;
219 52418c8d 2021-02-12 op const unsigned char *host = (const unsigned char*)hostname;
221 07d86a0b 2023-10-18 op log_info("Generating new %s key for %s (it could take a while)",
222 07d86a0b 2023-10-18 op eckey ? "EC" : "RSA", host);
224 adaae516 2023-10-18 op if ((f = fopen(keypath, "w")) == NULL) {
225 adaae516 2023-10-18 op log_warn("can't open %s", keypath);
229 adaae516 2023-10-18 op pkey = ec_key_create(f, keypath);
231 adaae516 2023-10-18 op pkey = rsa_key_create(f, keypath);
232 adaae516 2023-10-18 op if (pkey == NULL) {
233 adaae516 2023-10-18 op log_warnx("failed to generate a private key");
236 adaae516 2023-10-18 op if (fflush(f) == EOF || fclose(f) == EOF) {
237 adaae516 2023-10-18 op log_warn("failed to flush or close the private key");
241 adaae516 2023-10-18 op if ((x509 = X509_new()) == NULL) {
242 adaae516 2023-10-18 op log_warnx("couldn't generate the X509 certificate");
243 adaae516 2023-10-18 op ssl_error("X509_new");
247 1eb3631d 2021-05-12 op ASN1_INTEGER_set(X509_get_serialNumber(x509), 0);
248 3abf91b0 2021-02-07 op X509_gmtime_adj(X509_get_notBefore(x509), 0);
249 3abf91b0 2021-02-07 op X509_gmtime_adj(X509_get_notAfter(x509), 315360000L); /* 10 years */
250 adaae516 2023-10-18 op X509_set_version(x509, 2); // v3
252 adaae516 2023-10-18 op if (!X509_set_pubkey(x509, pkey)) {
253 adaae516 2023-10-18 op log_warnx("couldn't set the public key");
254 adaae516 2023-10-18 op ssl_error("X509_set_pubkey");
258 adaae516 2023-10-18 op if ((name = X509_NAME_new()) == NULL) {
259 adaae516 2023-10-18 op log_warnx("X509_NAME_new failed");
260 adaae516 2023-10-18 op ssl_error("X509_NAME_new");
264 adaae516 2023-10-18 op if (!X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, host,
265 adaae516 2023-10-18 op -1, -1, 0)) {
266 adaae516 2023-10-18 op log_warnx("couldn't add CN to cert");
267 adaae516 2023-10-18 op ssl_error("X509_NAME_add_entry_by_txt");
270 adaae516 2023-10-18 op X509_set_subject_name(x509, name);
271 adaae516 2023-10-18 op X509_set_issuer_name(x509, name);
273 adaae516 2023-10-18 op if (!X509_sign(x509, pkey, EVP_sha256())) {
274 adaae516 2023-10-18 op log_warnx("failed to sign the certificate");
275 adaae516 2023-10-18 op ssl_error("X509_sign");
279 adaae516 2023-10-18 op if ((f = fopen(certpath, "w")) == NULL) {
280 adaae516 2023-10-18 op log_warn("can't open %s", certpath);
283 adaae516 2023-10-18 op if (!PEM_write_X509(f, x509)) {
284 adaae516 2023-10-18 op log_warnx("couldn't write cert");
285 adaae516 2023-10-18 op ssl_error("PEM_write_X509");
288 adaae516 2023-10-18 op if (fflush(f) == EOF || fclose(f) == EOF) {
289 adaae516 2023-10-18 op log_warn("failed to flush or close the private key");
293 3abf91b0 2021-02-07 op X509_free(x509);
294 adaae516 2023-10-18 op EVP_PKEY_free(pkey);
295 07d86a0b 2023-10-18 op log_info("Certificate for %s successfully generated", host);
299 adaae516 2023-10-18 op (void) unlink(certpath);
300 adaae516 2023-10-18 op (void) unlink(keypath);
305 2cef5cf4 2023-06-12 op load_ca(uint8_t *d, size_t len)
308 02be96c6 2021-02-09 op X509 *x = NULL;
309 02be96c6 2021-02-09 op X509_STORE *store;
311 deadd9e1 2023-06-09 op if ((store = X509_STORE_new()) == NULL) {
312 2cef5cf4 2023-06-12 op log_warnx("%s: X509_STORE_new failed", __func__);
316 2cef5cf4 2023-06-12 op if ((in = BIO_new_mem_buf(d, len)) == NULL) {
317 2cef5cf4 2023-06-12 op log_warnx("%s: BIO_new_mem_buf failed", __func__);
321 2cef5cf4 2023-06-12 op if ((x = PEM_read_bio_X509(in, NULL, NULL, NULL)) == NULL) {
322 2cef5cf4 2023-06-12 op log_warnx("%s: PEM_read_bio_X509 failed", __func__);
323 2cef5cf4 2023-06-12 op ssl_error("PEM_read_bio_X509");
327 2cef5cf4 2023-06-12 op if (X509_check_ca(x) == 0) {
328 2cef5cf4 2023-06-12 op ssl_error("X509_check_ca");
332 2cef5cf4 2023-06-12 op if (!X509_STORE_add_cert(store, x)) {
333 2cef5cf4 2023-06-12 op ssl_error("X509_STORE_add_cert");
337 02be96c6 2021-02-09 op X509_free(x);
338 2cef5cf4 2023-06-12 op BIO_free(in);
339 02be96c6 2021-02-09 op return store;
342 02be96c6 2021-02-09 op X509_STORE_free(store);
343 02be96c6 2021-02-09 op if (x != NULL)
344 02be96c6 2021-02-09 op X509_free(x);
345 2cef5cf4 2023-06-12 op if (in != NULL)
346 2cef5cf4 2023-06-12 op BIO_free(in);
351 02be96c6 2021-02-09 op validate_against_ca(X509_STORE *ca, const uint8_t *chain, size_t len)
353 02be96c6 2021-02-09 op X509 *client;
355 02be96c6 2021-02-09 op X509_STORE_CTX *ctx = NULL;
358 02be96c6 2021-02-09 op if ((m = BIO_new_mem_buf(chain, len)) == NULL)
361 02be96c6 2021-02-09 op if ((client = PEM_read_bio_X509(m, NULL, NULL, NULL)) == NULL)
364 02be96c6 2021-02-09 op if ((ctx = X509_STORE_CTX_new()) == NULL)
367 02be96c6 2021-02-09 op if (!X509_STORE_CTX_init(ctx, ca, client, NULL))
370 02be96c6 2021-02-09 op ret = X509_verify_cert(ctx);
374 02be96c6 2021-02-09 op if (client != NULL)
375 02be96c6 2021-02-09 op X509_free(client);
376 02be96c6 2021-02-09 op if (ctx != NULL)
377 02be96c6 2021-02-09 op X509_STORE_CTX_free(ctx);
382 86693a33 2023-06-11 op ssl_error(const char *where)
384 86693a33 2023-06-11 op unsigned long code;
385 86693a33 2023-06-11 op char errbuf[128];
387 86693a33 2023-06-11 op while ((code = ERR_get_error()) != 0) {
388 86693a33 2023-06-11 op ERR_error_string_n(code, errbuf, sizeof(errbuf));
389 86693a33 2023-06-11 op log_debug("debug: SSL library error: %s: %s", where, errbuf);
394 b8d68fc8 2023-06-11 op ssl_pubkey_hash(const uint8_t *buf, size_t len)
396 86693a33 2023-06-11 op static const char hex[] = "0123456789abcdef";
398 86693a33 2023-06-11 op X509 *x509 = NULL;
399 86693a33 2023-06-11 op char *hash = NULL;
401 b8d68fc8 2023-06-11 op unsigned char digest[EVP_MAX_MD_SIZE];
402 b8d68fc8 2023-06-11 op unsigned int dlen, i;
404 86693a33 2023-06-11 op if ((in = BIO_new_mem_buf(buf, len)) == NULL) {
405 86693a33 2023-06-11 op log_warnx("%s: BIO_new_mem_buf failed", __func__);
409 86693a33 2023-06-11 op if ((x509 = PEM_read_bio_X509(in, NULL, NULL, NULL)) == NULL) {
410 86693a33 2023-06-11 op log_warnx("%s: PEM_read_bio_X509 failed", __func__);
411 86693a33 2023-06-11 op ssl_error("PEM_read_bio_X509");
415 86693a33 2023-06-11 op if ((hash = malloc(TLS_CERT_HASH_SIZE)) == NULL) {
416 86693a33 2023-06-11 op log_warn("%s: malloc", __func__);
420 86693a33 2023-06-11 op if (X509_pubkey_digest(x509, EVP_sha256(), digest, &dlen) != 1) {
421 86693a33 2023-06-11 op log_warnx("%s: X509_pubkey_digest failed", __func__);
422 86693a33 2023-06-11 op ssl_error("X509_pubkey_digest");
428 86693a33 2023-06-11 op if (TLS_CERT_HASH_SIZE < 2 * dlen + sizeof("SHA256:"))
429 86693a33 2023-06-11 op fatalx("%s: hash buffer too small", __func__);
431 86693a33 2023-06-11 op off = strlcpy(hash, "SHA256:", TLS_CERT_HASH_SIZE);
432 86693a33 2023-06-11 op for (i = 0; i < dlen; ++i) {
433 86693a33 2023-06-11 op hash[off++] = hex[(digest[i] >> 4) & 0xf];
434 86693a33 2023-06-11 op hash[off++] = hex[digest[i] & 0xf];
436 86693a33 2023-06-11 op hash[off] = '\0';
439 86693a33 2023-06-11 op BIO_free(in);
441 86693a33 2023-06-11 op X509_free(x509);
446 b8d68fc8 2023-06-11 op ssl_load_pkey(const uint8_t *buf, size_t len)
449 86693a33 2023-06-11 op EVP_PKEY *pkey;
451 86693a33 2023-06-11 op if ((in = BIO_new_mem_buf(buf, len)) == NULL) {
452 86693a33 2023-06-11 op log_warnx("%s: BIO_new_mem_buf failed", __func__);
456 86693a33 2023-06-11 op if ((pkey = PEM_read_bio_PrivateKey(in, NULL, NULL, NULL)) == NULL) {
457 86693a33 2023-06-11 op log_warnx("%s: PEM_read_bio_PrivateKey failed", __func__);
458 86693a33 2023-06-11 op ssl_error("PEM_read_bio_PrivateKey");
461 86693a33 2023-06-11 op BIO_free(in);
465 fc9cc497 2023-06-08 op struct vhost *
466 fc9cc497 2023-06-08 op new_vhost(void)
468 fc9cc497 2023-06-08 op struct vhost *h;
470 fc9cc497 2023-06-08 op h = xcalloc(1, sizeof(*h));
471 509d0509 2023-06-23 op TAILQ_INIT(&h->addrs);
472 fc9cc497 2023-06-08 op TAILQ_INIT(&h->locations);
473 fc9cc497 2023-06-08 op TAILQ_INIT(&h->aliases);
474 fc9cc497 2023-06-08 op TAILQ_INIT(&h->proxies);
478 fc9cc497 2023-06-08 op struct location *
479 fc9cc497 2023-06-08 op new_location(void)
481 fc9cc497 2023-06-08 op struct location *l;
483 fc9cc497 2023-06-08 op l = xcalloc(1, sizeof(*l));
484 fc9cc497 2023-06-08 op l->dirfd = -1;
485 fc9cc497 2023-06-08 op l->fcgi = -1;
486 a1ba9650 2023-07-23 op TAILQ_INIT(&l->params);
490 fc9cc497 2023-06-08 op struct proxy *
491 fc9cc497 2023-06-08 op new_proxy(void)
493 fc9cc497 2023-06-08 op struct proxy *p;
495 fc9cc497 2023-06-08 op p = xcalloc(1, sizeof(*p));
496 fc9cc497 2023-06-08 op p->protocols = TLS_PROTOCOLS_DEFAULT;