OpenVPN
xkey_helper.c
Go to the documentation of this file.
1/*
2 * OpenVPN -- An application to securely tunnel IP networks
3 * over a single TCP/UDP port, with support for SSL/TLS-based
4 * session authentication and key exchange,
5 * packet encryption, packet authentication, and
6 * packet compression.
7 *
8 * Copyright (C) 2021-2026 Selva Nair <selva.nair@gmail.com>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by the
12 * Free Software Foundation, either version 2 of the License,
13 * or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; if not, see <https://www.gnu.org/licenses/>.
22 */
23
24#ifdef HAVE_CONFIG_H
25#include <config.h>
26#endif
27
28#include "syshead.h"
29#include "error.h"
30#include "buffer.h"
31#include "xkey_common.h"
32#include "manage.h"
33#include "base64.h"
34
35#ifdef HAVE_XKEY_PROVIDER
36
37#include <openssl/provider.h>
38#include <openssl/params.h>
39#include <openssl/core_dispatch.h>
40#include <openssl/core_object.h>
41#include <openssl/core_names.h>
42#include <openssl/store.h>
43#include <openssl/evp.h>
44#include <openssl/err.h>
45
46static const char *const props = XKEY_PROV_PROPS;
47
48XKEY_EXTERNAL_SIGN_fn xkey_management_sign;
49
50static void
51print_openssl_errors(void)
52{
53 unsigned long e;
54 while ((e = ERR_get_error()))
55 {
56 msg(M_WARN, "OpenSSL error %lu: %s", e, ERR_error_string(e, NULL));
57 }
58}
59
61int
62xkey_digest(const unsigned char *src, size_t srclen, unsigned char *buf, size_t *buflen,
63 const char *mdname)
64{
65 dmsg(D_XKEY, "In xkey_digest");
66 EVP_MD *md = EVP_MD_fetch(NULL, mdname, NULL); /* from default context */
67 if (!md)
68 {
69 msg(M_WARN, "WARN: xkey_digest: MD_fetch failed for <%s>", mdname);
70 return 0;
71 }
72
73 unsigned int len = (unsigned int)*buflen;
74 int ret = EVP_Digest(src, srclen, buf, &len, md, NULL);
75 EVP_MD_free(md);
76 if (ret != 1)
77 {
78 msg(M_WARN, "WARN: xkey_digest: EVP_Digest failed");
79 return 0;
80 }
81
82 *buflen = len;
83 return 1;
84}
85
86#ifdef ENABLE_MANAGEMENT
94EVP_PKEY *
95xkey_load_management_key(OSSL_LIB_CTX *libctx, EVP_PKEY *pubkey)
96{
97 ASSERT(pubkey);
98
99 /* Management interface doesn't require any handle to be
100 * stored in the key. We use a dummy pointer as we do need a
101 * non-NULL value to indicate private key is available.
102 */
103 void *dummy = &"dummy";
104
105 XKEY_EXTERNAL_SIGN_fn *sign_op = xkey_management_sign;
106
107 return xkey_load_generic_key(libctx, dummy, pubkey, sign_op, NULL);
108}
109#endif
110
116EVP_PKEY *
117xkey_load_generic_key(OSSL_LIB_CTX *libctx, void *handle, EVP_PKEY *pubkey,
118 XKEY_EXTERNAL_SIGN_fn *sign_op, XKEY_PRIVKEY_FREE_fn *free_op)
119{
120 EVP_PKEY *pkey = NULL;
121 const char *origin = "external";
122
123 /* UTF8 string pointers in here are only read from, so cast is safe */
124 OSSL_PARAM params[] = {
125 { "xkey-origin", OSSL_PARAM_UTF8_STRING, (char *)origin, 0, 0 },
126 { "pubkey", OSSL_PARAM_OCTET_STRING, &pubkey, sizeof(pubkey), 0 },
127 { "handle", OSSL_PARAM_OCTET_PTR, &handle, sizeof(handle), 0 },
128 { "sign_op", OSSL_PARAM_OCTET_PTR, (void **)&sign_op, sizeof(sign_op), 0 },
129 { "free_op", OSSL_PARAM_OCTET_PTR, (void **)&free_op, sizeof(free_op), 0 },
130 { NULL, 0, NULL, 0, 0 }
131 };
132
133 /* Do not use EVP_PKEY_new_from_pkey as that will take keymgmt from pubkey */
134 EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name(libctx, EVP_PKEY_get0_type_name(pubkey), props);
135 if (!ctx || EVP_PKEY_fromdata_init(ctx) != 1
136 || EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEYPAIR, params) != 1)
137 {
138 print_openssl_errors();
139 msg(M_FATAL, "OpenSSL error: failed to load key into ovpn.xkey provider");
140 }
141 if (ctx)
142 {
143 EVP_PKEY_CTX_free(ctx);
144 }
145
146 return pkey;
147}
148
149#ifdef ENABLE_MANAGEMENT
150
151#if defined(__GNUC__) || defined(__clang__)
152#pragma GCC diagnostic push
153#pragma GCC diagnostic ignored "-Wsign-conversion"
154#endif
168int
169xkey_management_sign(void *unused, unsigned char *sig, size_t *siglen, const unsigned char *tbs,
170 size_t tbslen, XKEY_SIGALG alg)
171{
172 dmsg(D_XKEY, "In xkey_management_sign with keytype = %s, op = %s", alg.keytype, alg.op);
173
174 (void)unused;
175 char alg_str[128];
176 unsigned char buf[EVP_MAX_MD_SIZE]; /* for computing digest if required */
177 size_t buflen = sizeof(buf);
178
179 unsigned char enc[EVP_MAX_MD_SIZE + 32]; /* 32 bytes enough for digest info structure */
180 size_t enc_len = sizeof(enc);
181
182 unsigned int flags = management->settings.flags;
183 bool is_message = !strcmp(alg.op, "DigestSign"); /* tbs is message, not digest */
184
185 /* if management client cannot do digest -- we do it here */
186 if (!strcmp(alg.op, "DigestSign") && !(flags & MF_EXTERNAL_KEY_DIGEST)
187 && strcmp(alg.mdname, "none"))
188 {
189 dmsg(D_XKEY, "xkey_management_sign: computing digest");
190 if (xkey_digest(tbs, tbslen, buf, &buflen, alg.mdname))
191 {
192 tbs = buf;
193 tbslen = buflen;
194 alg.op = "Sign";
195 is_message = false;
196 }
197 else
198 {
199 return 0;
200 }
201 }
202
203 if (!strcmp(alg.keytype, "EC"))
204 {
205 if (!strcmp(alg.op, "Sign"))
206 {
207 strlcpy(alg_str, "ECDSA", sizeof(alg_str));
208 }
209 else
210 {
211 snprintf(alg_str, sizeof(alg_str), "ECDSA,hashalg=%s", alg.mdname);
212 }
213 }
214 else if (!strcmp(alg.keytype, "ED448") || !strcmp(alg.keytype, "ED25519"))
215 {
216 strlcpy(alg_str, alg.keytype, sizeof(alg_str));
217 }
218 /* else assume RSA key */
219 else if (!strcmp(alg.padmode, "pkcs1") && (flags & MF_EXTERNAL_KEY_PKCS1PAD))
220 {
221 /* For Sign, management interface expects a pkcs1 encoded digest -- add it */
222 if (!strcmp(alg.op, "Sign"))
223 {
224 if (!encode_pkcs1(enc, &enc_len, alg.mdname, tbs, tbslen))
225 {
226 return 0;
227 }
228 tbs = enc;
229 tbslen = enc_len;
230 strlcpy(alg_str, "RSA_PKCS1_PADDING", sizeof(alg_str));
231 }
232 /* For undigested message, add hashalg=digest parameter */
233 else
234 {
235 snprintf(alg_str, sizeof(alg_str), "%s,hashalg=%s", "RSA_PKCS1_PADDING", alg.mdname);
236 }
237 }
238 else if (!strcmp(alg.padmode, "none") && (flags & MF_EXTERNAL_KEY_NOPADDING)
239 && !strcmp(alg.op, "Sign")) /* NO_PADDING requires digested data */
240 {
241 strlcpy(alg_str, "RSA_NO_PADDING", sizeof(alg_str));
242 }
243 else if (!strcmp(alg.padmode, "pss") && (flags & MF_EXTERNAL_KEY_PSSPAD))
244 {
245 snprintf(alg_str, sizeof(alg_str), "%s,hashalg=%s,saltlen=%s", "RSA_PKCS1_PSS_PADDING",
246 alg.mdname, alg.saltlen);
247 }
248 else
249 {
250 msg(M_NONFATAL, "RSA padding mode not supported by management-client <%s>", alg.padmode);
251 return 0;
252 }
253
254 if (is_message)
255 {
256 if (strlcat(alg_str, ",data=message", sizeof(alg_str)) >= sizeof(alg_str))
257 {
258 return 0;
259 }
260 }
261
262 dmsg(D_LOW, "xkey management_sign: requesting sig with algorithm <%s>", alg_str);
263
264 char *in_b64 = NULL;
265 char *out_b64 = NULL;
266 int len = -1;
267
268 int bencret = openvpn_base64_encode(tbs, (int)tbslen, &in_b64);
269
270 if (management && bencret > 0)
271 {
272 out_b64 = management_query_pk_sig(management, in_b64, alg_str);
273 }
274 if (out_b64)
275 {
276 len = openvpn_base64_decode(out_b64, sig, (int)*siglen);
277 }
278 free(in_b64);
279 free(out_b64);
280
281 *siglen = (len > 0) ? len : 0;
282
283 return (*siglen > 0);
284}
285#if defined(__GNUC__) || defined(__clang__)
286#pragma GCC diagnostic pop
287#endif
288
289#endif /* ENABLE MANAGEMENT */
290
306bool
307encode_pkcs1(unsigned char *enc, size_t *enc_len, const char *mdname, const unsigned char *tbs,
308 size_t tbslen)
309{
310 ASSERT(enc_len != NULL);
311 ASSERT(tbs != NULL);
312
313 /* Tabulate the digest info header for expected hash algorithms
314 * These were pre-computed using the DigestInfo definition:
315 * DigestInfo ::= SEQUENCE {
316 * digestAlgorithm DigestAlgorithmIdentifier,
317 * digest Digest }
318 * Also see the table in RFC 8017 section 9.2, Note 1.
319 */
320
321 const unsigned char sha1[] = { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e,
322 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
323 const unsigned char sha256[] = { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
324 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20 };
325 const unsigned char sha384[] = { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
326 0x65, 0x03, 0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30 };
327 const unsigned char sha512[] = { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
328 0x65, 0x03, 0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40 };
329 const unsigned char sha224[] = { 0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
330 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c };
331 const unsigned char sha512_224[] = { 0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
332 0x65, 0x03, 0x04, 0x02, 0x05, 0x05, 0x00, 0x04, 0x1c };
333 const unsigned char sha512_256[] = { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01,
334 0x65, 0x03, 0x04, 0x02, 0x06, 0x05, 0x00, 0x04, 0x20 };
335
336 typedef struct
337 {
338 const int nid;
339 const unsigned char *header;
340 size_t sz;
341 } DIG_INFO;
342
343#define MAKE_DI(x) { NID_##x, x, sizeof(x) }
344
345 /* clang-format off */
346 DIG_INFO dinfo[] = {
347 MAKE_DI(sha1), MAKE_DI(sha256), MAKE_DI(sha384), MAKE_DI(sha512),
348 MAKE_DI(sha224), MAKE_DI(sha512_224), MAKE_DI(sha512_256), { 0, NULL, 0 }
349 };
350 /* clang-format on */
351
352 size_t out_len = 0;
353 bool ret = false;
354
355 int nid = OBJ_sn2nid(mdname);
356 if (nid == NID_undef)
357 {
358 /* try harder -- name variants like SHA2-256 doesn't work */
359 nid = EVP_MD_type(EVP_get_digestbyname(mdname));
360 if (nid == NID_undef)
361 {
362 msg(M_WARN, "Error: encode_pkcs11: invalid digest name <%s>", mdname);
363 goto done;
364 }
365 }
366
367 if (tbslen != (size_t)EVP_MD_size(EVP_get_digestbyname(mdname)))
368 {
369 msg(M_WARN, "Error: encode_pkcs11: invalid input length <%zu>", tbslen);
370 goto done;
371 }
372
373 if (nid == NID_md5_sha1) /* no encoding needed -- just copy */
374 {
375 if (enc && (*enc_len >= tbslen))
376 {
377 memcpy(enc, tbs, tbslen);
378 ret = true;
379 }
380 out_len = tbslen;
381 goto done;
382 }
383
384 /* locate entry for nid in dinfo table */
385 DIG_INFO *di = dinfo;
386 while ((di->nid != nid) && (di->nid != 0))
387 {
388 di++;
389 }
390 if (di->nid != nid) /* not found in our table */
391 {
392 msg(M_WARN, "Error: encode_pkcs11: unsupported hash algorithm <%s>", mdname);
393 goto done;
394 }
395
396 out_len = tbslen + di->sz;
397
398 if (enc && (out_len <= *enc_len))
399 {
400 /* combine header and digest */
401 memcpy(enc, di->header, di->sz);
402 memcpy(enc + di->sz, tbs, tbslen);
403 dmsg(D_XKEY, "encode_pkcs1: digest length = %zu encoded length = %zu", tbslen, out_len);
404 ret = true;
405 }
406
407done:
408 *enc_len = out_len; /* assignment safe as out_len is > 0 at this point */
409
410 return ret;
411}
412
419int
420ecdsa_bin2der(unsigned char *buf, int len, size_t capacity)
421{
422 ECDSA_SIG *ecsig = NULL;
423 int rlen = len / 2;
424 BIGNUM *r = BN_bin2bn(buf, rlen, NULL);
425 BIGNUM *s = BN_bin2bn(buf + rlen, rlen, NULL);
426 if (!r || !s)
427 {
428 goto err;
429 }
430 ecsig = ECDSA_SIG_new(); /* this does not allocate r, s */
431 if (!ecsig)
432 {
433 goto err;
434 }
435 if (!ECDSA_SIG_set0(ecsig, r, s)) /* ecsig takes ownership of r and s */
436 {
437 ECDSA_SIG_free(ecsig);
438 goto err;
439 }
440
441 int derlen = i2d_ECDSA_SIG(ecsig, NULL);
442 if (derlen > (int)capacity)
443 {
444 ECDSA_SIG_free(ecsig);
445 msg(M_NONFATAL, "Error: DER encoded ECDSA signature is too long (%d)", derlen);
446 return 0;
447 }
448 derlen = i2d_ECDSA_SIG(ecsig, &buf);
449 ECDSA_SIG_free(ecsig);
450 return derlen;
451
452err:
453 BN_free(r); /* it is ok to free NULL BN */
454 BN_free(s);
455 return 0;
456}
457
458#endif /* HAVE_XKEY_PROVIDER */
Buffer management functions and garbage collection.
size_t strlcpy(char *dest, const char *src, size_t maxlen)
size_t strlcat(char *dest, const char *src, size_t maxlen)
#define D_XKEY
Definition errlevel.h:114
#define D_LOW
Definition errlevel.h:95
char * management_query_pk_sig(struct management *man, const char *b64_data, const char *algorithm)
Definition manage.c:3974
#define MF_EXTERNAL_KEY_PKCS1PAD
Definition manage.h:38
#define MF_EXTERNAL_KEY_PSSPAD
Definition manage.h:43
#define MF_EXTERNAL_KEY_NOPADDING
Definition manage.h:37
#define MF_EXTERNAL_KEY_DIGEST
Definition manage.h:44
static const EVP_MD * EVP_MD_fetch(const void *ctx, const char *algorithm, const char *properties)
void OSSL_LIB_CTX
static void EVP_MD_free(const EVP_MD *md)
#define M_FATAL
Definition error.h:90
#define M_NONFATAL
Definition error.h:91
#define dmsg(flags,...)
Definition error.h:164
#define msg(flags,...)
Definition error.h:152
#define ASSERT(x)
Definition error.h:221
#define M_WARN
Definition error.h:92
int openvpn_base64_decode(const char *str, void *data, int size)
Definition base64.c:160
int openvpn_base64_encode(const void *data, int size, char **str)
Definition base64.c:51
unsigned int flags
Definition manage.h:248
struct man_settings settings
Definition manage.h:345