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 44ee1bac 2021-01-27 op 
 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>
 34 3abf91b0 2021-02-07 op 
 35 eae52ad4 2023-06-06 op #include "log.h"
 36 df5058c9 2023-06-05 op 
 37 adaae516 2023-10-18 op /*
 38 adaae516 2023-10-18 op  * Default number of bits when creating a new RSA key.
 39 adaae516 2023-10-18 op  */
 40 adaae516 2023-10-18 op #define KBITS 4096
 41 adaae516 2023-10-18 op 
 42 d98ef734 2023-08-08 op const char *
 43 d98ef734 2023-08-08 op strip_path(const char *path, int strip)
 44 d98ef734 2023-08-08 op {
 45 d98ef734 2023-08-08 op 	char *t;
 46 d98ef734 2023-08-08 op 
 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');
 50 d98ef734 2023-08-08 op 			break;
 51 d98ef734 2023-08-08 op 		}
 52 d98ef734 2023-08-08 op 		path = t;
 53 d98ef734 2023-08-08 op 		strip--;
 54 d98ef734 2023-08-08 op 	}
 55 d98ef734 2023-08-08 op 
 56 d98ef734 2023-08-08 op 	return path;
 57 44ee1bac 2021-01-27 op }
 58 44ee1bac 2021-01-27 op 
 59 44ee1bac 2021-01-27 op int
 60 44ee1bac 2021-01-27 op ends_with(const char *str, const char *sufx)
 61 44ee1bac 2021-01-27 op {
 62 44ee1bac 2021-01-27 op 	size_t i, j;
 63 44ee1bac 2021-01-27 op 
 64 44ee1bac 2021-01-27 op 	i = strlen(str);
 65 44ee1bac 2021-01-27 op 	j = strlen(sufx);
 66 44ee1bac 2021-01-27 op 
 67 44ee1bac 2021-01-27 op 	if (j > i)
 68 44ee1bac 2021-01-27 op 		return 0;
 69 44ee1bac 2021-01-27 op 
 70 44ee1bac 2021-01-27 op 	i -= j;
 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])
 73 44ee1bac 2021-01-27 op 			return 0;
 74 44ee1bac 2021-01-27 op 	return 1;
 75 44ee1bac 2021-01-27 op }
 76 bcf5d929 2021-02-01 op 
 77 bcf5d929 2021-02-01 op char *
 78 bcf5d929 2021-02-01 op absolutify_path(const char *path)
 79 bcf5d929 2021-02-01 op {
 80 07ad4910 2023-08-11 op 	char wd[PATH_MAX], *r;
 81 bcf5d929 2021-02-01 op 
 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");
 85 bcf5d929 2021-02-01 op 		return r;
 86 bcf5d929 2021-02-01 op 	}
 87 bcf5d929 2021-02-01 op 
 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");
 92 bcf5d929 2021-02-01 op 	return r;
 93 bcf5d929 2021-02-01 op }
 94 ca21e100 2021-02-04 op 
 95 ca21e100 2021-02-04 op char *
 96 ca21e100 2021-02-04 op xstrdup(const char *s)
 97 ca21e100 2021-02-04 op {
 98 ca21e100 2021-02-04 op 	char *d;
 99 ca21e100 2021-02-04 op 
100 ca21e100 2021-02-04 op 	if ((d = strdup(s)) == NULL)
101 792f302a 2023-06-09 op 		fatal("strdup");
102 b8e64ccd 2021-03-31 op 	return d;
103 b8e64ccd 2021-03-31 op }
104 b8e64ccd 2021-03-31 op 
105 b8e64ccd 2021-03-31 op void *
106 b8e64ccd 2021-03-31 op xcalloc(size_t nmemb, size_t size)
107 b8e64ccd 2021-03-31 op {
108 b8e64ccd 2021-03-31 op 	void *d;
109 b8e64ccd 2021-03-31 op 
110 b8e64ccd 2021-03-31 op 	if ((d = calloc(nmemb, size)) == NULL)
111 792f302a 2023-06-09 op 		fatal("calloc");
112 ca21e100 2021-02-04 op 	return d;
113 ca21e100 2021-02-04 op }
114 3abf91b0 2021-02-07 op 
115 adaae516 2023-10-18 op static EVP_PKEY *
116 adaae516 2023-10-18 op rsa_key_create(FILE *f, const char *fname)
117 adaae516 2023-10-18 op {
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;
121 adaae516 2023-10-18 op 
122 adaae516 2023-10-18 op 	/* First, create the context and the key. */
123 adaae516 2023-10-18 op 
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");
127 adaae516 2023-10-18 op 		goto done;
128 adaae516 2023-10-18 op 	}
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");
132 adaae516 2023-10-18 op 		goto done;
133 adaae516 2023-10-18 op 	}
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");
137 adaae516 2023-10-18 op 		goto done;
138 adaae516 2023-10-18 op 	}
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");
142 adaae516 2023-10-18 op 		goto done;
143 adaae516 2023-10-18 op 	}
144 adaae516 2023-10-18 op 
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");
149 adaae516 2023-10-18 op 		goto done;
150 adaae516 2023-10-18 op 	}
151 adaae516 2023-10-18 op 
152 adaae516 2023-10-18 op 	ret = 0;
153 adaae516 2023-10-18 op  done:
154 adaae516 2023-10-18 op 	if (ret == -1) {
155 adaae516 2023-10-18 op 		EVP_PKEY_free(pkey);
156 adaae516 2023-10-18 op 		pkey = NULL;
157 adaae516 2023-10-18 op 	}
158 adaae516 2023-10-18 op 	EVP_PKEY_CTX_free(ctx);
159 adaae516 2023-10-18 op 	return pkey;
160 adaae516 2023-10-18 op }
161 adaae516 2023-10-18 op 
162 adaae516 2023-10-18 op static EVP_PKEY *
163 adaae516 2023-10-18 op ec_key_create(FILE *f, const char *fname)
164 adaae516 2023-10-18 op {
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;
168 adaae516 2023-10-18 op 
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");
172 adaae516 2023-10-18 op 		goto done;
173 adaae516 2023-10-18 op 	}
174 adaae516 2023-10-18 op 
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");
178 adaae516 2023-10-18 op 		goto done;
179 adaae516 2023-10-18 op 	}
180 adaae516 2023-10-18 op 
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");
185 adaae516 2023-10-18 op 		goto done;
186 adaae516 2023-10-18 op 	}
187 adaae516 2023-10-18 op 
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");
192 adaae516 2023-10-18 op 		goto done;
193 adaae516 2023-10-18 op 	}
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");
197 adaae516 2023-10-18 op 		goto done;
198 adaae516 2023-10-18 op 	}
199 adaae516 2023-10-18 op 
200 adaae516 2023-10-18 op 	ret = 0;
201 adaae516 2023-10-18 op  done:
202 adaae516 2023-10-18 op 	if (ret == -1) {
203 adaae516 2023-10-18 op 		EVP_PKEY_free(pkey);
204 adaae516 2023-10-18 op 		pkey = NULL;
205 adaae516 2023-10-18 op 		log_warnx("WOOOPS");
206 adaae516 2023-10-18 op 	}
207 adaae516 2023-10-18 op 	EC_KEY_free(eckey);
208 adaae516 2023-10-18 op 	return pkey;
209 adaae516 2023-10-18 op }
210 adaae516 2023-10-18 op 
211 3abf91b0 2021-02-07 op void
212 adaae516 2023-10-18 op gencert(const char *hostname, const char *certpath, const char *keypath,
213 adaae516 2023-10-18 op     int eckey)
214 3abf91b0 2021-02-07 op {
215 3abf91b0 2021-02-07 op 	EVP_PKEY	*pkey;
216 3abf91b0 2021-02-07 op 	X509		*x509;
217 3abf91b0 2021-02-07 op 	X509_NAME	*name;
218 3abf91b0 2021-02-07 op 	FILE		*f;
219 52418c8d 2021-02-12 op 	const unsigned char *host = (const unsigned char*)hostname;
220 3abf91b0 2021-02-07 op 
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);
223 3abf91b0 2021-02-07 op 
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);
226 adaae516 2023-10-18 op 		goto err;
227 adaae516 2023-10-18 op 	}
228 adaae516 2023-10-18 op 	if (eckey)
229 adaae516 2023-10-18 op 		pkey = ec_key_create(f, keypath);
230 adaae516 2023-10-18 op 	else
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");
234 adaae516 2023-10-18 op 		goto err;
235 adaae516 2023-10-18 op 	}
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");
238 adaae516 2023-10-18 op 		goto err;
239 adaae516 2023-10-18 op 	}
240 3abf91b0 2021-02-07 op 
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");
244 adaae516 2023-10-18 op 		goto err;
245 adaae516 2023-10-18 op 	}
246 3abf91b0 2021-02-07 op 
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
251 3abf91b0 2021-02-07 op 
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");
255 adaae516 2023-10-18 op 		goto err;
256 adaae516 2023-10-18 op 	}
257 3abf91b0 2021-02-07 op 
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");
261 adaae516 2023-10-18 op 		goto err;
262 adaae516 2023-10-18 op 	}
263 3abf91b0 2021-02-07 op 
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");
268 adaae516 2023-10-18 op 		goto err;
269 adaae516 2023-10-18 op 	}
270 adaae516 2023-10-18 op 	X509_set_subject_name(x509, name);
271 adaae516 2023-10-18 op 	X509_set_issuer_name(x509, name);
272 3abf91b0 2021-02-07 op 
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");
276 adaae516 2023-10-18 op 		goto err;
277 adaae516 2023-10-18 op 	}
278 3abf91b0 2021-02-07 op 
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);
281 adaae516 2023-10-18 op 		goto err;
282 adaae516 2023-10-18 op 	}
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");
286 adaae516 2023-10-18 op 		goto err;
287 adaae516 2023-10-18 op 	}
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");
290 adaae516 2023-10-18 op 		goto err;
291 adaae516 2023-10-18 op 	}
292 3abf91b0 2021-02-07 op 
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);
296 adaae516 2023-10-18 op 	return;
297 7b27af83 2022-04-12 op 
298 adaae516 2023-10-18 op  err:
299 adaae516 2023-10-18 op 	(void) unlink(certpath);
300 adaae516 2023-10-18 op 	(void) unlink(keypath);
301 adaae516 2023-10-18 op 	exit(1);
302 3abf91b0 2021-02-07 op }
303 02be96c6 2021-02-09 op 
304 02be96c6 2021-02-09 op X509_STORE *
305 2cef5cf4 2023-06-12 op load_ca(uint8_t *d, size_t len)
306 02be96c6 2021-02-09 op {
307 2cef5cf4 2023-06-12 op 	BIO		*in;
308 02be96c6 2021-02-09 op 	X509		*x = NULL;
309 02be96c6 2021-02-09 op 	X509_STORE	*store;
310 02be96c6 2021-02-09 op 
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__);
313 02be96c6 2021-02-09 op 		return NULL;
314 deadd9e1 2023-06-09 op 	}
315 02be96c6 2021-02-09 op 
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__);
318 02be96c6 2021-02-09 op 		goto err;
319 deadd9e1 2023-06-09 op 	}
320 02be96c6 2021-02-09 op 
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");
324 02be96c6 2021-02-09 op 		goto err;
325 2cef5cf4 2023-06-12 op 	}
326 02be96c6 2021-02-09 op 
327 2cef5cf4 2023-06-12 op 	if (X509_check_ca(x) == 0) {
328 2cef5cf4 2023-06-12 op 		ssl_error("X509_check_ca");
329 02be96c6 2021-02-09 op 		goto err;
330 2cef5cf4 2023-06-12 op 	}
331 02be96c6 2021-02-09 op 
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");
334 02be96c6 2021-02-09 op 		goto err;
335 2cef5cf4 2023-06-12 op 	}
336 02be96c6 2021-02-09 op 
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;
340 02be96c6 2021-02-09 op 
341 02be96c6 2021-02-09 op err:
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);
347 02be96c6 2021-02-09 op 	return NULL;
348 02be96c6 2021-02-09 op }
349 02be96c6 2021-02-09 op 
350 02be96c6 2021-02-09 op int
351 02be96c6 2021-02-09 op validate_against_ca(X509_STORE *ca, const uint8_t *chain, size_t len)
352 02be96c6 2021-02-09 op {
353 02be96c6 2021-02-09 op 	X509		*client;
354 02be96c6 2021-02-09 op 	BIO		*m;
355 02be96c6 2021-02-09 op 	X509_STORE_CTX	*ctx = NULL;
356 02be96c6 2021-02-09 op 	int		 ret = 0;
357 02be96c6 2021-02-09 op 
358 02be96c6 2021-02-09 op 	if ((m = BIO_new_mem_buf(chain, len)) == NULL)
359 02be96c6 2021-02-09 op 		return 0;
360 02be96c6 2021-02-09 op 
361 02be96c6 2021-02-09 op 	if ((client = PEM_read_bio_X509(m, NULL, NULL, NULL)) == NULL)
362 02be96c6 2021-02-09 op 		goto end;
363 02be96c6 2021-02-09 op 
364 02be96c6 2021-02-09 op 	if ((ctx = X509_STORE_CTX_new()) == NULL)
365 02be96c6 2021-02-09 op 		goto end;
366 02be96c6 2021-02-09 op 
367 02be96c6 2021-02-09 op 	if (!X509_STORE_CTX_init(ctx, ca, client, NULL))
368 02be96c6 2021-02-09 op 		goto end;
369 02be96c6 2021-02-09 op 
370 02be96c6 2021-02-09 op 	ret = X509_verify_cert(ctx);
371 02be96c6 2021-02-09 op 
372 02be96c6 2021-02-09 op end:
373 02be96c6 2021-02-09 op 	BIO_free(m);
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);
378 02be96c6 2021-02-09 op 	return ret;
379 fc9cc497 2023-06-08 op }
380 fc9cc497 2023-06-08 op 
381 86693a33 2023-06-11 op void
382 86693a33 2023-06-11 op ssl_error(const char *where)
383 86693a33 2023-06-11 op {
384 86693a33 2023-06-11 op 	unsigned long	 code;
385 86693a33 2023-06-11 op 	char		 errbuf[128];
386 86693a33 2023-06-11 op 
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);
390 86693a33 2023-06-11 op 	}
391 86693a33 2023-06-11 op }
392 86693a33 2023-06-11 op 
393 86693a33 2023-06-11 op char *
394 b8d68fc8 2023-06-11 op ssl_pubkey_hash(const uint8_t *buf, size_t len)
395 86693a33 2023-06-11 op {
396 86693a33 2023-06-11 op 	static const char hex[] = "0123456789abcdef";
397 86693a33 2023-06-11 op 	BIO		*in;
398 86693a33 2023-06-11 op 	X509		*x509 = NULL;
399 86693a33 2023-06-11 op 	char		*hash = NULL;
400 86693a33 2023-06-11 op 	size_t		 off;
401 b8d68fc8 2023-06-11 op 	unsigned char	 digest[EVP_MAX_MD_SIZE];
402 b8d68fc8 2023-06-11 op 	unsigned int	 dlen, i;
403 86693a33 2023-06-11 op 
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__);
406 86693a33 2023-06-11 op 		return NULL;
407 86693a33 2023-06-11 op 	}
408 86693a33 2023-06-11 op 
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");
412 86693a33 2023-06-11 op 		goto fail;
413 86693a33 2023-06-11 op 	}
414 86693a33 2023-06-11 op 
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__);
417 86693a33 2023-06-11 op 		goto fail;
418 86693a33 2023-06-11 op 	}
419 86693a33 2023-06-11 op 
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");
423 86693a33 2023-06-11 op 		free(hash);
424 86693a33 2023-06-11 op 		hash = NULL;
425 86693a33 2023-06-11 op 		goto fail;
426 86693a33 2023-06-11 op 	}
427 86693a33 2023-06-11 op 
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__);
430 86693a33 2023-06-11 op 
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];
435 86693a33 2023-06-11 op 	}
436 86693a33 2023-06-11 op 	hash[off] = '\0';
437 86693a33 2023-06-11 op 
438 86693a33 2023-06-11 op  fail:
439 86693a33 2023-06-11 op 	BIO_free(in);
440 86693a33 2023-06-11 op 	if (x509)
441 86693a33 2023-06-11 op 		X509_free(x509);
442 86693a33 2023-06-11 op 	return hash;
443 86693a33 2023-06-11 op }
444 86693a33 2023-06-11 op 
445 86693a33 2023-06-11 op EVP_PKEY *
446 b8d68fc8 2023-06-11 op ssl_load_pkey(const uint8_t *buf, size_t len)
447 86693a33 2023-06-11 op {
448 86693a33 2023-06-11 op 	BIO		*in;
449 86693a33 2023-06-11 op 	EVP_PKEY	*pkey;
450 86693a33 2023-06-11 op 
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__);
453 86693a33 2023-06-11 op 		return NULL;
454 86693a33 2023-06-11 op 	}
455 86693a33 2023-06-11 op 
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");
459 86693a33 2023-06-11 op 	}
460 86693a33 2023-06-11 op 
461 86693a33 2023-06-11 op 	BIO_free(in);
462 86693a33 2023-06-11 op 	return pkey;
463 86693a33 2023-06-11 op }
464 86693a33 2023-06-11 op 
465 fc9cc497 2023-06-08 op struct vhost *
466 fc9cc497 2023-06-08 op new_vhost(void)
467 fc9cc497 2023-06-08 op {
468 fc9cc497 2023-06-08 op 	struct vhost *h;
469 fc9cc497 2023-06-08 op 
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);
475 fc9cc497 2023-06-08 op 	return h;
476 fc9cc497 2023-06-08 op }
477 fc9cc497 2023-06-08 op 
478 fc9cc497 2023-06-08 op struct location *
479 fc9cc497 2023-06-08 op new_location(void)
480 fc9cc497 2023-06-08 op {
481 fc9cc497 2023-06-08 op 	struct location *l;
482 fc9cc497 2023-06-08 op 
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);
487 fc9cc497 2023-06-08 op 	return l;
488 02be96c6 2021-02-09 op }
489 fc9cc497 2023-06-08 op 
490 fc9cc497 2023-06-08 op struct proxy *
491 fc9cc497 2023-06-08 op new_proxy(void)
492 fc9cc497 2023-06-08 op {
493 fc9cc497 2023-06-08 op 	struct proxy *p;
494 fc9cc497 2023-06-08 op 
495 fc9cc497 2023-06-08 op 	p = xcalloc(1, sizeof(*p));
496 fc9cc497 2023-06-08 op 	p->protocols = TLS_PROTOCOLS_DEFAULT;
497 fc9cc497 2023-06-08 op 	return p;
498 fc9cc497 2023-06-08 op }