35#ifdef HAVE_XKEY_PROVIDER
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>
46static const char *
const props = XKEY_PROV_PROPS;
48XKEY_EXTERNAL_SIGN_fn xkey_management_sign;
51print_openssl_errors(
void)
54 while ((e = ERR_get_error()))
56 msg(
M_WARN,
"OpenSSL error %lu: %s", e, ERR_error_string(e, NULL));
62xkey_digest(
const unsigned char *src,
size_t srclen,
unsigned char *buf,
size_t *buflen,
69 msg(
M_WARN,
"WARN: xkey_digest: MD_fetch failed for <%s>", mdname);
73 unsigned int len = (
unsigned int)*buflen;
74 int ret = EVP_Digest(src, srclen, buf, &len, md, NULL);
78 msg(
M_WARN,
"WARN: xkey_digest: EVP_Digest failed");
86#ifdef ENABLE_MANAGEMENT
95xkey_load_management_key(
OSSL_LIB_CTX *libctx, EVP_PKEY *pubkey)
103 void *dummy = &
"dummy";
105 XKEY_EXTERNAL_SIGN_fn *sign_op = xkey_management_sign;
107 return xkey_load_generic_key(libctx, dummy, pubkey, sign_op, NULL);
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)
120 EVP_PKEY *pkey = NULL;
121 const char *origin =
"external";
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 }
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)
138 print_openssl_errors();
139 msg(
M_FATAL,
"OpenSSL error: failed to load key into ovpn.xkey provider");
143 EVP_PKEY_CTX_free(ctx);
149#ifdef ENABLE_MANAGEMENT
151#if defined(__GNUC__) || defined(__clang__)
152#pragma GCC diagnostic push
153#pragma GCC diagnostic ignored "-Wsign-conversion"
169xkey_management_sign(
void *unused,
unsigned char *sig,
size_t *siglen,
const unsigned char *tbs,
170 size_t tbslen, XKEY_SIGALG alg)
172 dmsg(
D_XKEY,
"In xkey_management_sign with keytype = %s, op = %s", alg.keytype, alg.op);
176 unsigned char buf[EVP_MAX_MD_SIZE];
177 size_t buflen =
sizeof(buf);
179 unsigned char enc[EVP_MAX_MD_SIZE + 32];
180 size_t enc_len =
sizeof(enc);
183 bool is_message = !strcmp(alg.op,
"DigestSign");
187 && strcmp(alg.mdname,
"none"))
189 dmsg(
D_XKEY,
"xkey_management_sign: computing digest");
190 if (xkey_digest(tbs, tbslen, buf, &buflen, alg.mdname))
203 if (!strcmp(alg.keytype,
"EC"))
205 if (!strcmp(alg.op,
"Sign"))
207 strlcpy(alg_str,
"ECDSA",
sizeof(alg_str));
211 snprintf(alg_str,
sizeof(alg_str),
"ECDSA,hashalg=%s", alg.mdname);
214 else if (!strcmp(alg.keytype,
"ED448") || !strcmp(alg.keytype,
"ED25519"))
216 strlcpy(alg_str, alg.keytype,
sizeof(alg_str));
222 if (!strcmp(alg.op,
"Sign"))
224 if (!encode_pkcs1(enc, &enc_len, alg.mdname, tbs, tbslen))
230 strlcpy(alg_str,
"RSA_PKCS1_PADDING",
sizeof(alg_str));
235 snprintf(alg_str,
sizeof(alg_str),
"%s,hashalg=%s",
"RSA_PKCS1_PADDING", alg.mdname);
239 && !strcmp(alg.op,
"Sign"))
241 strlcpy(alg_str,
"RSA_NO_PADDING",
sizeof(alg_str));
245 snprintf(alg_str,
sizeof(alg_str),
"%s,hashalg=%s,saltlen=%s",
"RSA_PKCS1_PSS_PADDING",
246 alg.mdname, alg.saltlen);
250 msg(
M_NONFATAL,
"RSA padding mode not supported by management-client <%s>", alg.padmode);
256 if (
strlcat(alg_str,
",data=message",
sizeof(alg_str)) >=
sizeof(alg_str))
262 dmsg(
D_LOW,
"xkey management_sign: requesting sig with algorithm <%s>", alg_str);
265 char *out_b64 = NULL;
281 *siglen = (len > 0) ? len : 0;
283 return (*siglen > 0);
285#if defined(__GNUC__) || defined(__clang__)
286#pragma GCC diagnostic pop
307encode_pkcs1(
unsigned char *enc,
size_t *enc_len,
const char *mdname,
const unsigned char *tbs,
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 };
339 const unsigned char *header;
343#define MAKE_DI(x) { NID_##x, x, sizeof(x) }
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 }
355 int nid = OBJ_sn2nid(mdname);
356 if (nid == NID_undef)
359 nid = EVP_MD_type(EVP_get_digestbyname(mdname));
360 if (nid == NID_undef)
362 msg(
M_WARN,
"Error: encode_pkcs11: invalid digest name <%s>", mdname);
367 if (tbslen != (
size_t)EVP_MD_size(EVP_get_digestbyname(mdname)))
369 msg(
M_WARN,
"Error: encode_pkcs11: invalid input length <%zu>", tbslen);
373 if (nid == NID_md5_sha1)
375 if (enc && (*enc_len >= tbslen))
377 memcpy(enc, tbs, tbslen);
385 DIG_INFO *di = dinfo;
386 while ((di->nid != nid) && (di->nid != 0))
392 msg(
M_WARN,
"Error: encode_pkcs11: unsupported hash algorithm <%s>", mdname);
396 out_len = tbslen + di->sz;
398 if (enc && (out_len <= *enc_len))
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);
420ecdsa_bin2der(
unsigned char *buf,
int len,
size_t capacity)
422 ECDSA_SIG *ecsig = NULL;
424 BIGNUM *r = BN_bin2bn(buf, rlen, NULL);
425 BIGNUM *s = BN_bin2bn(buf + rlen, rlen, NULL);
430 ecsig = ECDSA_SIG_new();
435 if (!ECDSA_SIG_set0(ecsig, r, s))
437 ECDSA_SIG_free(ecsig);
441 int derlen = i2d_ECDSA_SIG(ecsig, NULL);
442 if (derlen > (
int)capacity)
444 ECDSA_SIG_free(ecsig);
445 msg(
M_NONFATAL,
"Error: DER encoded ECDSA signature is too long (%d)", derlen);
448 derlen = i2d_ECDSA_SIG(ecsig, &buf);
449 ECDSA_SIG_free(ecsig);
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)
char * management_query_pk_sig(struct management *man, const char *b64_data, const char *algorithm)
#define MF_EXTERNAL_KEY_PKCS1PAD
#define MF_EXTERNAL_KEY_PSSPAD
#define MF_EXTERNAL_KEY_NOPADDING
#define MF_EXTERNAL_KEY_DIGEST
static const EVP_MD * EVP_MD_fetch(const void *ctx, const char *algorithm, const char *properties)
static void EVP_MD_free(const EVP_MD *md)
int openvpn_base64_decode(const char *str, void *data, int size)
int openvpn_base64_encode(const void *data, int size, char **str)
struct man_settings settings