test/tls-provider.c

   1 /*
   2  * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <string.h>
  11 #include <openssl/core_names.h>
  12 #include <openssl/core_dispatch.h>
  13 #include <openssl/rand.h>
  14 #include <openssl/params.h>
  15 #include <openssl/err.h>
  16 #include <openssl/proverr.h>
  17 #include <openssl/pkcs12.h>
  18 #include <openssl/provider.h>
  19 #include <assert.h>
  20 #include <openssl/asn1.h>
  21 #include <openssl/asn1t.h>
  22 #include <openssl/core_object.h>
  23 #include "internal/asn1.h"
  24 /* For TLS1_3_VERSION */
  25 #include <openssl/ssl.h>
  26 #include "internal/nelem.h"
  27 #include "internal/refcount.h"
  28
  29 /* error codes */
  30
  31 /* xorprovider error codes */
  32 #define XORPROV_R_INVALID_DIGEST                            1
  33 #define XORPROV_R_INVALID_SIZE                              2
  34 #define XORPROV_R_INVALID_KEY                               3
  35 #define XORPROV_R_UNSUPPORTED                               4
  36 #define XORPROV_R_MISSING_OID                               5
  37 #define XORPROV_R_OBJ_CREATE_ERR                            6
  38 #define XORPROV_R_INVALID_ENCODING                          7
  39 #define XORPROV_R_SIGN_ERROR                                8
  40 #define XORPROV_R_LIB_CREATE_ERR                            9
  41 #define XORPROV_R_NO_PRIVATE_KEY                            10
  42 #define XORPROV_R_BUFFER_LENGTH_WRONG                       11
  43 #define XORPROV_R_SIGNING_FAILED                            12
  44 #define XORPROV_R_WRONG_PARAMETERS                          13
  45 #define XORPROV_R_VERIFY_ERROR                              14
  46 #define XORPROV_R_EVPINFO_MISSING                           15
  47
  48 static OSSL_FUNC_keymgmt_import_fn xor_import;
  49 static OSSL_FUNC_keymgmt_import_types_fn xor_import_types;
  50 static OSSL_FUNC_keymgmt_import_types_ex_fn xor_import_types_ex;
  51 static OSSL_FUNC_keymgmt_export_fn xor_export;
  52 static OSSL_FUNC_keymgmt_export_types_fn xor_export_types;
  53 static OSSL_FUNC_keymgmt_export_types_ex_fn xor_export_types_ex;
  54
  55 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
  56                       const OSSL_DISPATCH *in,
  57                       const OSSL_DISPATCH **out,
  58                       void **provctx);
  59
  60 #define XOR_KEY_SIZE 32
  61
  62 /*
  63  * Top secret. This algorithm only works if no one knows what this number is.
  64  * Please don't tell anyone what it is.
  65  *
  66  * This algorithm is for testing only - don't really use it!
  67  */
  68 static const unsigned char private_constant[XOR_KEY_SIZE] = {
  69     0xd3, 0x6b, 0x54, 0xec, 0x5b, 0xac, 0x89, 0x96, 0x8c, 0x2c, 0x66, 0xa5,
  70     0x67, 0x0d, 0xe3, 0xdd, 0x43, 0x69, 0xbc, 0x83, 0x3d, 0x60, 0xc7, 0xb8,
  71     0x2b, 0x1c, 0x5a, 0xfd, 0xb5, 0xcd, 0xd0, 0xf8
  72 };
  73
  74 typedef struct xorkey_st {
  75     unsigned char privkey[XOR_KEY_SIZE];
  76     unsigned char pubkey[XOR_KEY_SIZE];
  77     int hasprivkey;
  78     int haspubkey;
  79     char *tls_name;
  80     CRYPTO_REF_COUNT references;
  81 } XORKEY;
  82
  83 /* Key Management for the dummy XOR KEX, KEM and signature algorithms */
  84
  85 static OSSL_FUNC_keymgmt_new_fn xor_newkey;
  86 static OSSL_FUNC_keymgmt_free_fn xor_freekey;
  87 static OSSL_FUNC_keymgmt_has_fn xor_has;
  88 static OSSL_FUNC_keymgmt_dup_fn xor_dup;
  89 static OSSL_FUNC_keymgmt_gen_init_fn xor_gen_init;
  90 static OSSL_FUNC_keymgmt_gen_set_params_fn xor_gen_set_params;
  91 static OSSL_FUNC_keymgmt_gen_settable_params_fn xor_gen_settable_params;
  92 static OSSL_FUNC_keymgmt_gen_fn xor_gen;
  93 static OSSL_FUNC_keymgmt_gen_cleanup_fn xor_gen_cleanup;
  94 static OSSL_FUNC_keymgmt_load_fn xor_load;
  95 static OSSL_FUNC_keymgmt_get_params_fn xor_get_params;
  96 static OSSL_FUNC_keymgmt_gettable_params_fn xor_gettable_params;
  97 static OSSL_FUNC_keymgmt_set_params_fn xor_set_params;
  98 static OSSL_FUNC_keymgmt_settable_params_fn xor_settable_params;
  99
 100 /*
 101  * Dummy "XOR" Key Exchange algorithm. We just xor the private and public keys
 102  * together. Don't use this!
 103  */
 104
 105 static OSSL_FUNC_keyexch_newctx_fn xor_newkemkexctx;
 106 static OSSL_FUNC_keyexch_init_fn xor_init;
 107 static OSSL_FUNC_keyexch_set_peer_fn xor_set_peer;
 108 static OSSL_FUNC_keyexch_derive_fn xor_derive;
 109 static OSSL_FUNC_keyexch_freectx_fn xor_freectx;
 110 static OSSL_FUNC_keyexch_dupctx_fn xor_dupctx;
 111
 112 /*
 113  * Dummy "XOR" Key Encapsulation Method. We just build a KEM over the xor KEX.
 114  * Don't use this!
 115  */
 116
 117 static OSSL_FUNC_kem_newctx_fn xor_newkemkexctx;
 118 static OSSL_FUNC_kem_freectx_fn xor_freectx;
 119 static OSSL_FUNC_kem_dupctx_fn xor_dupctx;
 120 static OSSL_FUNC_kem_encapsulate_init_fn xor_init;
 121 static OSSL_FUNC_kem_encapsulate_fn xor_encapsulate;
 122 static OSSL_FUNC_kem_decapsulate_init_fn xor_init;
 123 static OSSL_FUNC_kem_decapsulate_fn xor_decapsulate;
 124
 125 /*
 126  * Common key management table access functions
 127  */
 128 static OSSL_FUNC_keymgmt_new_fn *
 129 xor_prov_get_keymgmt_new(const OSSL_DISPATCH *fns)
 130 {
 131     /* Pilfer the keymgmt dispatch table */
 132     for (; fns->function_id != 0; fns++)
 133         if (fns->function_id == OSSL_FUNC_KEYMGMT_NEW)
 134             return OSSL_FUNC_keymgmt_new(fns);
 135
 136     return NULL;
 137 }
 138
 139 static OSSL_FUNC_keymgmt_free_fn *
 140 xor_prov_get_keymgmt_free(const OSSL_DISPATCH *fns)
 141 {
 142     /* Pilfer the keymgmt dispatch table */
 143     for (; fns->function_id != 0; fns++)
 144         if (fns->function_id == OSSL_FUNC_KEYMGMT_FREE)
 145             return OSSL_FUNC_keymgmt_free(fns);
 146
 147     return NULL;
 148 }
 149
 150 static OSSL_FUNC_keymgmt_import_fn *
 151 xor_prov_get_keymgmt_import(const OSSL_DISPATCH *fns)
 152 {
 153     /* Pilfer the keymgmt dispatch table */
 154     for (; fns->function_id != 0; fns++)
 155         if (fns->function_id == OSSL_FUNC_KEYMGMT_IMPORT)
 156             return OSSL_FUNC_keymgmt_import(fns);
 157
 158     return NULL;
 159 }
 160
 161 static OSSL_FUNC_keymgmt_export_fn *
 162 xor_prov_get_keymgmt_export(const OSSL_DISPATCH *fns)
 163 {
 164     /* Pilfer the keymgmt dispatch table */
 165     for (; fns->function_id != 0; fns++)
 166         if (fns->function_id == OSSL_FUNC_KEYMGMT_EXPORT)
 167             return OSSL_FUNC_keymgmt_export(fns);
 168
 169     return NULL;
 170 }
 171
 172 static void *xor_prov_import_key(const OSSL_DISPATCH *fns, void *provctx,
 173                            int selection, const OSSL_PARAM params[])
 174 {
 175     OSSL_FUNC_keymgmt_new_fn *kmgmt_new = xor_prov_get_keymgmt_new(fns);
 176     OSSL_FUNC_keymgmt_free_fn *kmgmt_free = xor_prov_get_keymgmt_free(fns);
 177     OSSL_FUNC_keymgmt_import_fn *kmgmt_import =
 178         xor_prov_get_keymgmt_import(fns);
 179     void *key = NULL;
 180
 181     if (kmgmt_new != NULL && kmgmt_import != NULL && kmgmt_free != NULL) {
 182         if ((key = kmgmt_new(provctx)) == NULL
 183             || !kmgmt_import(key, selection, params)) {
 184             kmgmt_free(key);
 185             key = NULL;
 186         }
 187     }
 188     return key;
 189 }
 190
 191 static void xor_prov_free_key(const OSSL_DISPATCH *fns, void *key)
 192 {
 193     OSSL_FUNC_keymgmt_free_fn *kmgmt_free = xor_prov_get_keymgmt_free(fns);
 194
 195     if (kmgmt_free != NULL)
 196         kmgmt_free(key);
 197 }
 198
 199 /*
 200  * We define 2 dummy TLS groups called "xorgroup" and "xorkemgroup" for test
 201  * purposes
 202  */
 203 struct tls_group_st {
 204     unsigned int group_id; /* for "tls-group-id", see provider-base(7) */
 205     unsigned int secbits;
 206     unsigned int mintls;
 207     unsigned int maxtls;
 208     unsigned int mindtls;
 209     unsigned int maxdtls;
 210     unsigned int is_kem; /* boolean */
 211 };
 212
 213 #define XORGROUP_NAME "xorgroup"
 214 #define XORGROUP_NAME_INTERNAL "xorgroup-int"
 215 static struct tls_group_st xor_group = {
 216     0,                  /* group_id, set by randomize_tls_alg_id() */
 217     128,                /* secbits */
 218     TLS1_3_VERSION,     /* mintls */
 219     0,                  /* maxtls */
 220     -1,                 /* mindtls */
 221     -1,                 /* maxdtls */
 222     0                   /* is_kem */
 223 };
 224
 225 #define XORKEMGROUP_NAME "xorkemgroup"
 226 #define XORKEMGROUP_NAME_INTERNAL "xorkemgroup-int"
 227 static struct tls_group_st xor_kemgroup = {
 228     0,                  /* group_id, set by randomize_tls_alg_id() */
 229     128,                /* secbits */
 230     TLS1_3_VERSION,     /* mintls */
 231     0,                  /* maxtls */
 232     -1,                 /* mindtls */
 233     -1,                 /* maxdtls */
 234     1                   /* is_kem */
 235 };
 236
 237 #define ALGORITHM "XOR"
 238
 239 static const OSSL_PARAM xor_group_params[] = {
 240     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME,
 241                            XORGROUP_NAME, sizeof(XORGROUP_NAME)),
 242     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL,
 243                            XORGROUP_NAME_INTERNAL,
 244                            sizeof(XORGROUP_NAME_INTERNAL)),
 245     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_ALG, ALGORITHM,
 246                            sizeof(ALGORITHM)),
 247     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_ID, &xor_group.group_id),
 248     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS,
 249                     &xor_group.secbits),
 250     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_TLS, &xor_group.mintls),
 251     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_TLS, &xor_group.maxtls),
 252     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS, &xor_group.mindtls),
 253     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS, &xor_group.maxdtls),
 254     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_IS_KEM, &xor_group.is_kem),
 255     OSSL_PARAM_END
 256 };
 257
 258 static const OSSL_PARAM xor_kemgroup_params[] = {
 259     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME,
 260                            XORKEMGROUP_NAME, sizeof(XORKEMGROUP_NAME)),
 261     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL,
 262                            XORKEMGROUP_NAME_INTERNAL,
 263                            sizeof(XORKEMGROUP_NAME_INTERNAL)),
 264     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_ALG, ALGORITHM,
 265                            sizeof(ALGORITHM)),
 266     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_ID, &xor_kemgroup.group_id),
 267     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS,
 268                     &xor_kemgroup.secbits),
 269     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_TLS, &xor_kemgroup.mintls),
 270     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_TLS, &xor_kemgroup.maxtls),
 271     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS, &xor_kemgroup.mindtls),
 272     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS, &xor_kemgroup.maxdtls),
 273     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_IS_KEM, &xor_kemgroup.is_kem),
 274     OSSL_PARAM_END
 275 };
 276
 277 #define NUM_DUMMY_GROUPS 50
 278 static char *dummy_group_names[NUM_DUMMY_GROUPS];
 279
 280 /*
 281  * We define a dummy TLS sigalg called for test purposes
 282  */
 283 struct tls_sigalg_st {
 284     unsigned int code_point; /* for "tls-sigalg-alg", see provider-base(7) */
 285     unsigned int secbits;
 286     unsigned int mintls;
 287     unsigned int maxtls;
 288 };
 289
 290 #define XORSIGALG_NAME "xorhmacsig"
 291 #define XORSIGALG_OID "1.3.6.1.4.1.16604.998888.1"
 292 #define XORSIGALG_HASH_NAME "xorhmacsha2sig"
 293 #define XORSIGALG_HASH "SHA256"
 294 #define XORSIGALG_HASH_OID "1.3.6.1.4.1.16604.998888.2"
 295 #define XORSIGALG12_NAME "xorhmacsig12"
 296 #define XORSIGALG12_OID "1.3.6.1.4.1.16604.998888.3"
 297
 298 static struct tls_sigalg_st xor_sigalg = {
 299     0,                  /* alg id, set by randomize_tls_alg_id() */
 300     128,                /* secbits */
 301     TLS1_3_VERSION,     /* mintls */
 302     0,                  /* maxtls */
 303 };
 304
 305 static struct tls_sigalg_st xor_sigalg_hash = {
 306     0,                  /* alg id, set by randomize_tls_alg_id() */
 307     128,                /* secbits */
 308     TLS1_3_VERSION,     /* mintls */
 309     0,                  /* maxtls */
 310 };
 311
 312 static struct tls_sigalg_st xor_sigalg12 = {
 313     0,                  /* alg id, set by randomize_tls_alg_id() */
 314     128,                /* secbits */
 315     TLS1_2_VERSION,     /* mintls */
 316     TLS1_2_VERSION,     /* maxtls */
 317 };
 318
 319 static const OSSL_PARAM xor_sig_nohash_params[] = {
 320     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME,
 321                            XORSIGALG_NAME, sizeof(XORSIGALG_NAME)),
 322     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_NAME,
 323                            XORSIGALG_NAME,
 324                            sizeof(XORSIGALG_NAME)),
 325     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_OID,
 326                            XORSIGALG_OID, sizeof(XORSIGALG_OID)),
 327     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT,
 328                     &xor_sigalg.code_point),
 329     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS,
 330                     &xor_sigalg.secbits),
 331     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS,
 332                    &xor_sigalg.mintls),
 333     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS,
 334                    &xor_sigalg.maxtls),
 335     OSSL_PARAM_END
 336 };
 337
 338 static const OSSL_PARAM xor_sig_hash_params[] = {
 339     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME,
 340                            XORSIGALG_HASH_NAME, sizeof(XORSIGALG_HASH_NAME)),
 341     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_NAME,
 342                            XORSIGALG_HASH_NAME,
 343                            sizeof(XORSIGALG_HASH_NAME)),
 344     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME,
 345                            XORSIGALG_HASH, sizeof(XORSIGALG_HASH)),
 346     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_OID,
 347                            XORSIGALG_HASH_OID, sizeof(XORSIGALG_HASH_OID)),
 348     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT,
 349                     &xor_sigalg_hash.code_point),
 350     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS,
 351                     &xor_sigalg_hash.secbits),
 352     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS,
 353                    &xor_sigalg_hash.mintls),
 354     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS,
 355                    &xor_sigalg_hash.maxtls),
 356     OSSL_PARAM_END
 357 };
 358
 359 static const OSSL_PARAM xor_sig_12_params[] = {
 360     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME,
 361                            XORSIGALG12_NAME, sizeof(XORSIGALG12_NAME)),
 362     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_NAME,
 363                            XORSIGALG12_NAME,
 364                            sizeof(XORSIGALG12_NAME)),
 365     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_SIGALG_OID,
 366                            XORSIGALG12_OID, sizeof(XORSIGALG12_OID)),
 367     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT,
 368                     &xor_sigalg12.code_point),
 369     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS,
 370                     &xor_sigalg12.secbits),
 371     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS,
 372                    &xor_sigalg12.mintls),
 373     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS,
 374                    &xor_sigalg12.maxtls),
 375     OSSL_PARAM_END
 376 };
 377
 378 static int tls_prov_get_capabilities(void *provctx, const char *capability,
 379                                      OSSL_CALLBACK *cb, void *arg)
 380 {
 381     int ret = 0;
 382     int i;
 383     const char *dummy_base = "dummy";
 384     const size_t dummy_name_max_size = strlen(dummy_base) + 3;
 385
 386     if (strcmp(capability, "TLS-GROUP") == 0) {
 387         /* Register our 2 groups */
 388         ret = cb(xor_group_params, arg);
 389         ret &= cb(xor_kemgroup_params, arg);
 390
 391         /*
 392          * Now register some dummy groups > GROUPLIST_INCREMENT (== 40) as defined
 393          * in ssl/t1_lib.c, to make sure we exercise the code paths for registering
 394          * large numbers of groups.
 395          */
 396
 397         for (i = 0; i < NUM_DUMMY_GROUPS; i++) {
 398             OSSL_PARAM dummygroup[OSSL_NELEM(xor_group_params)];
 399
 400             memcpy(dummygroup, xor_group_params, sizeof(xor_group_params));
 401
 402             /* Give the dummy group a unique name */
 403             if (dummy_group_names[i] == NULL) {
 404                 dummy_group_names[i] = OPENSSL_zalloc(dummy_name_max_size);
 405                 if (dummy_group_names[i] == NULL)
 406                     return 0;
 407                 BIO_snprintf(dummy_group_names[i],
 408                          dummy_name_max_size,
 409                          "%s%d", dummy_base, i);
 410             }
 411             dummygroup[0].data = dummy_group_names[i];
 412             dummygroup[0].data_size = strlen(dummy_group_names[i]) + 1;
 413             ret &= cb(dummygroup, arg);
 414         }
 415     }
 416
 417     if (strcmp(capability, "TLS-SIGALG") == 0) {
 418         ret = cb(xor_sig_nohash_params, arg);
 419         ret &= cb(xor_sig_hash_params, arg);
 420         ret &= cb(xor_sig_12_params, arg);
 421     }
 422     return ret;
 423 }
 424
 425 typedef struct {
 426     OSSL_LIB_CTX *libctx;
 427 } PROV_XOR_CTX;
 428
 429 static PROV_XOR_CTX *xor_newprovctx(OSSL_LIB_CTX *libctx)
 430 {
 431     PROV_XOR_CTX* prov_ctx = OPENSSL_malloc(sizeof(PROV_XOR_CTX));
 432
 433     if (prov_ctx == NULL)
 434         return NULL;
 435
 436     if (libctx == NULL) {
 437         OPENSSL_free(prov_ctx);
 438         return NULL;
 439     }
 440     prov_ctx->libctx = libctx;
 441     return prov_ctx;
 442 }
 443
 444
 445
 446 #define PROV_XOR_LIBCTX_OF(provctx) (((PROV_XOR_CTX *)provctx)->libctx)
 447
 448 /*
 449  * Dummy "XOR" Key Exchange and signature algorithm. We just xor the
 450  * private and public keys together. Don't use this!
 451  */
 452
 453 typedef struct {
 454     XORKEY *key;
 455     XORKEY *peerkey;
 456     void *provctx;
 457 } PROV_XORKEMKEX_CTX;
 458
 459 static void *xor_newkemkexctx(void *provctx)
 460 {
 461     PROV_XORKEMKEX_CTX *pxorctx = OPENSSL_zalloc(sizeof(PROV_XORKEMKEX_CTX));
 462
 463     if (pxorctx == NULL)
 464         return NULL;
 465
 466     pxorctx->provctx = provctx;
 467
 468     return pxorctx;
 469 }
 470
 471 static int xor_init(void *vpxorctx, void *vkey,
 472                     ossl_unused const OSSL_PARAM params[])
 473 {
 474     PROV_XORKEMKEX_CTX *pxorctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
 475
 476     if (pxorctx == NULL || vkey == NULL)
 477         return 0;
 478     pxorctx->key = vkey;
 479     return 1;
 480 }
 481
 482 static int xor_set_peer(void *vpxorctx, void *vpeerkey)
 483 {
 484     PROV_XORKEMKEX_CTX *pxorctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
 485
 486     if (pxorctx == NULL || vpeerkey == NULL)
 487         return 0;
 488     pxorctx->peerkey = vpeerkey;
 489     return 1;
 490 }
 491
 492 static int xor_derive(void *vpxorctx, unsigned char *secret, size_t *secretlen,
 493                       size_t outlen)
 494 {
 495     PROV_XORKEMKEX_CTX *pxorctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
 496     int i;
 497
 498     if (pxorctx->key == NULL || pxorctx->peerkey == NULL)
 499         return 0;
 500
 501     *secretlen = XOR_KEY_SIZE;
 502     if (secret == NULL)
 503         return 1;
 504
 505     if (outlen < XOR_KEY_SIZE)
 506         return 0;
 507
 508     for (i = 0; i < XOR_KEY_SIZE; i++)
 509         secret[i] = pxorctx->key->privkey[i] ^ pxorctx->peerkey->pubkey[i];
 510
 511     return 1;
 512 }
 513
 514 static void xor_freectx(void *pxorctx)
 515 {
 516     OPENSSL_free(pxorctx);
 517 }
 518
 519 static void *xor_dupctx(void *vpxorctx)
 520 {
 521     PROV_XORKEMKEX_CTX *srcctx = (PROV_XORKEMKEX_CTX *)vpxorctx;
 522     PROV_XORKEMKEX_CTX *dstctx;
 523
 524     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
 525     if (dstctx == NULL)
 526         return NULL;
 527
 528     *dstctx = *srcctx;
 529
 530     return dstctx;
 531 }
 532
 533 static const OSSL_DISPATCH xor_keyexch_functions[] = {
 534     { OSSL_FUNC_KEYEXCH_NEWCTX, (void (*)(void))xor_newkemkexctx },
 535     { OSSL_FUNC_KEYEXCH_INIT, (void (*)(void))xor_init },
 536     { OSSL_FUNC_KEYEXCH_DERIVE, (void (*)(void))xor_derive },
 537     { OSSL_FUNC_KEYEXCH_SET_PEER, (void (*)(void))xor_set_peer },
 538     { OSSL_FUNC_KEYEXCH_FREECTX, (void (*)(void))xor_freectx },
 539     { OSSL_FUNC_KEYEXCH_DUPCTX, (void (*)(void))xor_dupctx },
 540     OSSL_DISPATCH_END
 541 };
 542
 543 static const OSSL_ALGORITHM tls_prov_keyexch[] = {
 544     /*
 545      * Obviously this is not FIPS approved, but in order to test in conjunction
 546      * with the FIPS provider we pretend that it is.
 547      */
 548     { "XOR", "provider=tls-provider,fips=yes", xor_keyexch_functions },
 549     { NULL, NULL, NULL }
 550 };
 551
 552 /*
 553  * Dummy "XOR" Key Encapsulation Method. We just build a KEM over the xor KEX.
 554  * Don't use this!
 555  */
 556
 557 static int xor_encapsulate(void *vpxorctx,
 558                            unsigned char *ct, size_t *ctlen,
 559                            unsigned char *ss, size_t *sslen)
 560 {
 561     /*
 562      * We are building this around a KEX:
 563      *
 564      * 1. we generate ephemeral keypair
 565      * 2. we encode our ephemeral pubkey as the outgoing ct
 566      * 3. we derive using our ephemeral privkey in combination with the peer
 567      *    pubkey from the ctx; the result is our ss.
 568      */
 569     int rv = 0;
 570     void *genctx = NULL, *derivectx = NULL;
 571     XORKEY *ourkey = NULL;
 572     PROV_XORKEMKEX_CTX *pxorctx = vpxorctx;
 573
 574     if (ct == NULL || ss == NULL) {
 575         /* Just return sizes */
 576
 577         if (ctlen == NULL && sslen == NULL)
 578             return 0;
 579         if (ctlen != NULL)
 580             *ctlen = XOR_KEY_SIZE;
 581         if (sslen != NULL)
 582             *sslen = XOR_KEY_SIZE;
 583         return 1;
 584     }
 585
 586     /* 1. Generate keypair */
 587     genctx = xor_gen_init(pxorctx->provctx, OSSL_KEYMGMT_SELECT_KEYPAIR, NULL);
 588     if (genctx == NULL)
 589         goto end;
 590     ourkey = xor_gen(genctx, NULL, NULL);
 591     if (ourkey == NULL)
 592         goto end;
 593
 594     /* 2. Encode ephemeral pubkey as ct */
 595     memcpy(ct, ourkey->pubkey, XOR_KEY_SIZE);
 596     *ctlen = XOR_KEY_SIZE;
 597
 598     /* 3. Derive ss via KEX */
 599     derivectx = xor_newkemkexctx(pxorctx->provctx);
 600     if (derivectx == NULL
 601             || !xor_init(derivectx, ourkey, NULL)
 602             || !xor_set_peer(derivectx, pxorctx->key)
 603             || !xor_derive(derivectx, ss, sslen, XOR_KEY_SIZE))
 604         goto end;
 605
 606     rv = 1;
 607
 608  end:
 609     xor_gen_cleanup(genctx);
 610     xor_freekey(ourkey);
 611     xor_freectx(derivectx);
 612     return rv;
 613 }
 614
 615 static int xor_decapsulate(void *vpxorctx,
 616                            unsigned char *ss, size_t *sslen,
 617                            const unsigned char *ct, size_t ctlen)
 618 {
 619     /*
 620      * We are building this around a KEX:
 621      *
 622      * - ct is our peer's pubkey
 623      * - decapsulate is just derive.
 624      */
 625     int rv = 0;
 626     void *derivectx = NULL;
 627     XORKEY *peerkey = NULL;
 628     PROV_XORKEMKEX_CTX *pxorctx = vpxorctx;
 629
 630     if (ss == NULL) {
 631         /* Just return size */
 632         if (sslen == NULL)
 633             return 0;
 634         *sslen = XOR_KEY_SIZE;
 635         return 1;
 636     }
 637
 638     if (ctlen != XOR_KEY_SIZE)
 639         return 0;
 640     peerkey = xor_newkey(pxorctx->provctx);
 641     if (peerkey == NULL)
 642         goto end;
 643     memcpy(peerkey->pubkey, ct, XOR_KEY_SIZE);
 644
 645     /* Derive ss via KEX */
 646     derivectx = xor_newkemkexctx(pxorctx->provctx);
 647     if (derivectx == NULL
 648             || !xor_init(derivectx, pxorctx->key, NULL)
 649             || !xor_set_peer(derivectx, peerkey)
 650             || !xor_derive(derivectx, ss, sslen, XOR_KEY_SIZE))
 651         goto end;
 652
 653     rv = 1;
 654
 655  end:
 656     xor_freekey(peerkey);
 657     xor_freectx(derivectx);
 658     return rv;
 659 }
 660
 661 static const OSSL_DISPATCH xor_kem_functions[] = {
 662     { OSSL_FUNC_KEM_NEWCTX, (void (*)(void))xor_newkemkexctx },
 663     { OSSL_FUNC_KEM_FREECTX, (void (*)(void))xor_freectx },
 664     { OSSL_FUNC_KEM_DUPCTX, (void (*)(void))xor_dupctx },
 665     { OSSL_FUNC_KEM_ENCAPSULATE_INIT, (void (*)(void))xor_init },
 666     { OSSL_FUNC_KEM_ENCAPSULATE, (void (*)(void))xor_encapsulate },
 667     { OSSL_FUNC_KEM_DECAPSULATE_INIT, (void (*)(void))xor_init },
 668     { OSSL_FUNC_KEM_DECAPSULATE, (void (*)(void))xor_decapsulate },
 669     OSSL_DISPATCH_END
 670 };
 671
 672 static const OSSL_ALGORITHM tls_prov_kem[] = {
 673     /*
 674      * Obviously this is not FIPS approved, but in order to test in conjunction
 675      * with the FIPS provider we pretend that it is.
 676      */
 677     { "XOR", "provider=tls-provider,fips=yes", xor_kem_functions },
 678     { NULL, NULL, NULL }
 679 };
 680
 681 /* Key Management for the dummy XOR key exchange algorithm */
 682
 683 static void *xor_newkey(void *provctx)
 684 {
 685     XORKEY *ret = OPENSSL_zalloc(sizeof(XORKEY));
 686
 687     if (ret == NULL)
 688         return NULL;
 689
 690     if (!CRYPTO_NEW_REF(&ret->references, 1)) {
 691         OPENSSL_free(ret);
 692         return NULL;
 693     }
 694
 695     return ret;
 696 }
 697
 698 static void xor_freekey(void *keydata)
 699 {
 700     XORKEY* key = (XORKEY *)keydata;
 701     int refcnt;
 702
 703     if (key == NULL)
 704         return;
 705
 706     if (CRYPTO_DOWN_REF(&key->references, &refcnt) <= 0)
 707         return;
 708
 709     if (refcnt > 0)
 710         return;
 711     assert(refcnt == 0);
 712
 713     if (key != NULL) {
 714         OPENSSL_free(key->tls_name);
 715         key->tls_name = NULL;
 716     }
 717     CRYPTO_FREE_REF(&key->references);
 718     OPENSSL_free(key);
 719 }
 720
 721 static int xor_key_up_ref(XORKEY *key)
 722 {
 723     int refcnt;
 724
 725     if (CRYPTO_UP_REF(&key->references, &refcnt) <= 0)
 726         return 0;
 727
 728     assert(refcnt > 1);
 729     return (refcnt > 1);
 730 }
 731
 732 static int xor_has(const void *vkey, int selection)
 733 {
 734     const XORKEY *key = vkey;
 735     int ok = 0;
 736
 737     if (key != NULL) {
 738         ok = 1;
 739
 740         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
 741             ok = ok && key->haspubkey;
 742         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
 743             ok = ok && key->hasprivkey;
 744     }
 745     return ok;
 746 }
 747
 748 static void *xor_dup(const void *vfromkey, int selection)
 749 {
 750     XORKEY *tokey = xor_newkey(NULL);
 751     const XORKEY *fromkey = vfromkey;
 752     int ok = 0;
 753
 754     if (tokey != NULL && fromkey != NULL) {
 755         ok = 1;
 756
 757         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
 758             if (fromkey->haspubkey) {
 759                 memcpy(tokey->pubkey, fromkey->pubkey, XOR_KEY_SIZE);
 760                 tokey->haspubkey = 1;
 761             } else {
 762                 tokey->haspubkey = 0;
 763             }
 764         }
 765         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
 766             if (fromkey->hasprivkey) {
 767                 memcpy(tokey->privkey, fromkey->privkey, XOR_KEY_SIZE);
 768                 tokey->hasprivkey = 1;
 769             } else {
 770                 tokey->hasprivkey = 0;
 771             }
 772         }
 773         if (fromkey->tls_name != NULL)
 774             tokey->tls_name = OPENSSL_strdup(fromkey->tls_name);
 775     }
 776     if (!ok) {
 777         xor_freekey(tokey);
 778         tokey = NULL;
 779     }
 780     return tokey;
 781 }
 782
 783 static ossl_inline int xor_get_params(void *vkey, OSSL_PARAM params[])
 784 {
 785     XORKEY *key = vkey;
 786     OSSL_PARAM *p;
 787
 788     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
 789         && !OSSL_PARAM_set_int(p, XOR_KEY_SIZE))
 790         return 0;
 791
 792     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
 793         && !OSSL_PARAM_set_int(p, xor_group.secbits))
 794         return 0;
 795
 796     if ((p = OSSL_PARAM_locate(params,
 797                                OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY)) != NULL) {
 798         if (p->data_type != OSSL_PARAM_OCTET_STRING)
 799             return 0;
 800         p->return_size = XOR_KEY_SIZE;
 801         if (p->data != NULL && p->data_size >= XOR_KEY_SIZE)
 802             memcpy(p->data, key->pubkey, XOR_KEY_SIZE);
 803     }
 804
 805     return 1;
 806 }
 807
 808 static const OSSL_PARAM xor_params[] = {
 809     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
 810     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
 811     OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
 812     OSSL_PARAM_END
 813 };
 814
 815 static const OSSL_PARAM *xor_gettable_params(void *provctx)
 816 {
 817     return xor_params;
 818 }
 819
 820 static int xor_set_params(void *vkey, const OSSL_PARAM params[])
 821 {
 822     XORKEY *key = vkey;
 823     const OSSL_PARAM *p;
 824
 825     p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY);
 826     if (p != NULL) {
 827         if (p->data_type != OSSL_PARAM_OCTET_STRING
 828                 || p->data_size != XOR_KEY_SIZE)
 829             return 0;
 830         memcpy(key->pubkey, p->data, XOR_KEY_SIZE);
 831         key->haspubkey = 1;
 832     }
 833
 834     return 1;
 835 }
 836
 837 static const OSSL_PARAM xor_known_settable_params[] = {
 838     OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
 839     OSSL_PARAM_END
 840 };
 841
 842 static void *xor_load(const void *reference, size_t reference_sz)
 843 {
 844     XORKEY *key = NULL;
 845
 846     if (reference_sz == sizeof(key)) {
 847         /* The contents of the reference is the address to our object */
 848         key = *(XORKEY **)reference;
 849         /* We grabbed, so we detach it */
 850         *(XORKEY **)reference = NULL;
 851         return key;
 852     }
 853     return NULL;
 854 }
 855
 856 /* check one key is the "XOR complement" of the other */
 857 static int xor_recreate(const unsigned char *kd1, const unsigned char *kd2) {
 858     int i;
 859
 860     for (i = 0; i < XOR_KEY_SIZE; i++) {
 861         if ((kd1[i] & 0xff) != ((kd2[i] ^ private_constant[i]) & 0xff))
 862             return 0;
 863     }
 864     return 1;
 865 }
 866
 867 static int xor_match(const void *keydata1, const void *keydata2, int selection)
 868 {
 869     const XORKEY *key1 = keydata1;
 870     const XORKEY *key2 = keydata2;
 871     int ok = 1;
 872
 873     if (key1->tls_name != NULL && key2->tls_name != NULL)
 874         ok = ok & (strcmp(key1->tls_name, key2->tls_name) == 0);
 875
 876     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)  {
 877         if (key1->hasprivkey) {
 878             if (key2->hasprivkey)
 879                 ok = ok & (CRYPTO_memcmp(key1->privkey, key2->privkey,
 880                                          XOR_KEY_SIZE) == 0);
 881             else
 882                 ok = ok & xor_recreate(key1->privkey, key2->pubkey);
 883         } else {
 884             if (key2->hasprivkey)
 885                 ok = ok & xor_recreate(key2->privkey, key1->pubkey);
 886             else
 887                 ok = 0;
 888         }
 889     }
 890
 891     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)  {
 892         if (key1->haspubkey) {
 893             if (key2->haspubkey)
 894                 ok = ok & (CRYPTO_memcmp(key1->pubkey, key2->pubkey, XOR_KEY_SIZE) == 0);
 895             else
 896                 ok = ok & xor_recreate(key1->pubkey, key2->privkey);
 897         } else {
 898             if (key2->haspubkey)
 899                 ok = ok & xor_recreate(key2->pubkey, key1->privkey);
 900             else
 901                 ok = 0;
 902         }
 903     }
 904
 905     return ok;
 906 }
 907
 908 static const OSSL_PARAM *xor_settable_params(void *provctx)
 909 {
 910     return xor_known_settable_params;
 911 }
 912
 913 struct xor_gen_ctx {
 914     int selection;
 915     OSSL_LIB_CTX *libctx;
 916 };
 917
 918 static void *xor_gen_init(void *provctx, int selection,
 919                           const OSSL_PARAM params[])
 920 {
 921     struct xor_gen_ctx *gctx = NULL;
 922
 923     if ((selection & (OSSL_KEYMGMT_SELECT_KEYPAIR
 924                       | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS)) == 0)
 925         return NULL;
 926
 927     if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL)
 928         gctx->selection = selection;
 929
 930     gctx->libctx = PROV_XOR_LIBCTX_OF(provctx);
 931
 932     if (!xor_gen_set_params(gctx, params)) {
 933         OPENSSL_free(gctx);
 934         return NULL;
 935     }
 936     return gctx;
 937 }
 938
 939 static int xor_gen_set_params(void *genctx, const OSSL_PARAM params[])
 940 {
 941     struct xor_gen_ctx *gctx = genctx;
 942     const OSSL_PARAM *p;
 943
 944     if (gctx == NULL)
 945         return 0;
 946
 947     p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_GROUP_NAME);
 948     if (p != NULL) {
 949         if (p->data_type != OSSL_PARAM_UTF8_STRING
 950                 || (strcmp(p->data, XORGROUP_NAME_INTERNAL) != 0
 951                     &&  strcmp(p->data, XORKEMGROUP_NAME_INTERNAL) != 0))
 952             return 0;
 953     }
 954
 955     return 1;
 956 }
 957
 958 static const OSSL_PARAM *xor_gen_settable_params(ossl_unused void *genctx,
 959                                                  ossl_unused void *provctx)
 960 {
 961     static OSSL_PARAM settable[] = {
 962         OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
 963         OSSL_PARAM_END
 964     };
 965     return settable;
 966 }
 967
 968 static void *xor_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
 969 {
 970     struct xor_gen_ctx *gctx = genctx;
 971     XORKEY *key = xor_newkey(NULL);
 972     size_t i;
 973
 974     if (key == NULL)
 975         return NULL;
 976
 977     if ((gctx->selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0) {
 978         if (RAND_bytes_ex(gctx->libctx, key->privkey, XOR_KEY_SIZE, 0) <= 0) {
 979             OPENSSL_free(key);
 980             return NULL;
 981         }
 982         for (i = 0; i < XOR_KEY_SIZE; i++)
 983             key->pubkey[i] = key->privkey[i] ^ private_constant[i];
 984         key->hasprivkey = 1;
 985         key->haspubkey = 1;
 986     }
 987
 988     return key;
 989 }
 990
 991 /* IMPORT + EXPORT */
 992
 993 static int xor_import(void *vkey, int select, const OSSL_PARAM params[])
 994 {
 995     XORKEY *key = vkey;
 996     const OSSL_PARAM *param_priv_key, *param_pub_key;
 997     unsigned char privkey[XOR_KEY_SIZE];
 998     unsigned char pubkey[XOR_KEY_SIZE];
 999     void *pprivkey = privkey, *ppubkey = pubkey;
1000     size_t priv_len = 0, pub_len = 0;
1001     int res = 0;
1002
1003     if (key == NULL || (select & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
1004         return 0;
1005
1006     memset(privkey, 0, sizeof(privkey));
1007     memset(pubkey, 0, sizeof(pubkey));
1008     param_priv_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
1009     param_pub_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
1010
1011     if ((param_priv_key != NULL
1012          && !OSSL_PARAM_get_octet_string(param_priv_key, &pprivkey,
1013                                          sizeof(privkey), &priv_len))
1014         || (param_pub_key != NULL
1015             && !OSSL_PARAM_get_octet_string(param_pub_key, &ppubkey,
1016                                             sizeof(pubkey), &pub_len)))
1017         goto err;
1018
1019     if (priv_len > 0) {
1020         memcpy(key->privkey, privkey, priv_len);
1021         key->hasprivkey = 1;
1022     }
1023     if (pub_len > 0) {
1024         memcpy(key->pubkey, pubkey, pub_len);
1025         key->haspubkey = 1;
1026     }
1027     res = 1;
1028  err:
1029     return res;
1030 }
1031
1032 static int xor_export(void *vkey, int select, OSSL_CALLBACK *param_cb,
1033                       void *cbarg)
1034 {
1035     XORKEY *key = vkey;
1036     OSSL_PARAM params[3], *p = params;
1037
1038     if (key == NULL || (select & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
1039         return 0;
1040
1041     *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
1042                                              key->privkey,
1043                                              sizeof(key->privkey));
1044     *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
1045                                              key->pubkey, sizeof(key->pubkey));
1046     *p++ = OSSL_PARAM_construct_end();
1047
1048     return param_cb(params, cbarg);
1049 }
1050
1051 static const OSSL_PARAM xor_key_types[] = {
1052     OSSL_PARAM_BN(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
1053     OSSL_PARAM_BN(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
1054     OSSL_PARAM_END
1055 };
1056
1057 static const OSSL_PARAM *xor_import_types(int select)
1058 {
1059     return (select & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0 ? xor_key_types : NULL;
1060 }
1061
1062 static const OSSL_PARAM *xor_import_types_ex(void *provctx, int select)
1063 {
1064     if (provctx == NULL)
1065         return NULL;
1066
1067     return xor_import_types(select);
1068 }
1069
1070 static const OSSL_PARAM *xor_export_types(int select)
1071 {
1072     return (select & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0 ? xor_key_types : NULL;
1073 }
1074
1075 static const OSSL_PARAM *xor_export_types_ex(void *provctx, int select)
1076 {
1077     if (provctx == NULL)
1078         return NULL;
1079
1080     return xor_export_types(select);
1081 }
1082
1083 static void xor_gen_cleanup(void *genctx)
1084 {
1085     OPENSSL_free(genctx);
1086 }
1087
1088 static const OSSL_DISPATCH xor_keymgmt_functions[] = {
1089     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))xor_newkey },
1090     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))xor_gen_init },
1091     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))xor_gen_set_params },
1092     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
1093       (void (*)(void))xor_gen_settable_params },
1094     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))xor_gen },
1095     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))xor_gen_cleanup },
1096     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))xor_get_params },
1097     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))xor_gettable_params },
1098     { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))xor_set_params },
1099     { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))xor_settable_params },
1100     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))xor_has },
1101     { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))xor_dup },
1102     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))xor_freekey },
1103     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))xor_import },
1104     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))xor_import_types },
1105     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES_EX, (void (*)(void))xor_import_types_ex },
1106     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))xor_export },
1107     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))xor_export_types },
1108     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES_EX, (void (*)(void))xor_export_types_ex },
1109     OSSL_DISPATCH_END
1110 };
1111
1112 /* We're re-using most XOR keymgmt functions also for signature operations: */
1113 static void *xor_xorhmacsig_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
1114 {
1115     XORKEY *k = xor_gen(genctx, osslcb, cbarg);
1116
1117     if (k == NULL)
1118         return NULL;
1119     k->tls_name = OPENSSL_strdup(XORSIGALG_NAME);
1120     if (k->tls_name == NULL) {
1121         xor_freekey(k);
1122         return NULL;
1123     }
1124     return k;
1125 }
1126
1127 static void *xor_xorhmacsha2sig_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
1128 {
1129     XORKEY* k = xor_gen(genctx, osslcb, cbarg);
1130
1131     if (k == NULL)
1132         return NULL;
1133     k->tls_name = OPENSSL_strdup(XORSIGALG_HASH_NAME);
1134     if (k->tls_name == NULL) {
1135         xor_freekey(k);
1136         return NULL;
1137     }
1138     return k;
1139 }
1140
1141
1142 static const OSSL_DISPATCH xor_xorhmacsig_keymgmt_functions[] = {
1143     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))xor_newkey },
1144     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))xor_gen_init },
1145     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))xor_gen_set_params },
1146     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
1147       (void (*)(void))xor_gen_settable_params },
1148     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))xor_xorhmacsig_gen },
1149     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))xor_gen_cleanup },
1150     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))xor_get_params },
1151     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))xor_gettable_params },
1152     { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))xor_set_params },
1153     { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))xor_settable_params },
1154     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))xor_has },
1155     { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))xor_dup },
1156     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))xor_freekey },
1157     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))xor_import },
1158     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))xor_import_types },
1159     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))xor_export },
1160     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))xor_export_types },
1161     { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))xor_load },
1162     { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))xor_match },
1163     OSSL_DISPATCH_END
1164 };
1165
1166 static const OSSL_DISPATCH xor_xorhmacsha2sig_keymgmt_functions[] = {
1167     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))xor_newkey },
1168     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))xor_gen_init },
1169     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))xor_gen_set_params },
1170     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
1171       (void (*)(void))xor_gen_settable_params },
1172     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))xor_xorhmacsha2sig_gen },
1173     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))xor_gen_cleanup },
1174     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))xor_get_params },
1175     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))xor_gettable_params },
1176     { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))xor_set_params },
1177     { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))xor_settable_params },
1178     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))xor_has },
1179     { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))xor_dup },
1180     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))xor_freekey },
1181     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))xor_import },
1182     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))xor_import_types },
1183     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))xor_export },
1184     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))xor_export_types },
1185     { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))xor_load },
1186     { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))xor_match },
1187     OSSL_DISPATCH_END
1188 };
1189
1190 typedef enum {
1191     KEY_OP_PUBLIC,
1192     KEY_OP_PRIVATE,
1193     KEY_OP_KEYGEN
1194 } xor_key_op_t;
1195
1196 /* Re-create XORKEY from encoding(s): Same end-state as after key-gen */
1197 static XORKEY *xor_key_op(const X509_ALGOR *palg,
1198                           const unsigned char *p, int plen,
1199                           xor_key_op_t op,
1200                           OSSL_LIB_CTX *libctx, const char *propq)
1201 {
1202     XORKEY *key = NULL;
1203     int nid = NID_undef;
1204
1205     if (palg != NULL) {
1206         int ptype;
1207
1208         /* Algorithm parameters must be absent */
1209         X509_ALGOR_get0(NULL, &ptype, NULL, palg);
1210         if (ptype != V_ASN1_UNDEF || palg->algorithm == NULL) {
1211             ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_ENCODING);
1212             return 0;
1213         }
1214         nid = OBJ_obj2nid(palg->algorithm);
1215     }
1216
1217     if (p == NULL || nid == EVP_PKEY_NONE || nid == NID_undef) {
1218         ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_ENCODING);
1219         return 0;
1220     }
1221
1222     key = xor_newkey(NULL);
1223     if (key == NULL) {
1224         ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1225         return 0;
1226     }
1227
1228     if (XOR_KEY_SIZE != plen) {
1229         ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_ENCODING);
1230         goto err;
1231     }
1232
1233     if (op == KEY_OP_PUBLIC) {
1234         memcpy(key->pubkey, p, plen);
1235         key->haspubkey = 1;
1236     } else {
1237         memcpy(key->privkey, p, plen);
1238         key->hasprivkey = 1;
1239     }
1240
1241     key->tls_name = OPENSSL_strdup(OBJ_nid2sn(nid));
1242     if (key->tls_name == NULL)
1243         goto err;
1244     return key;
1245
1246  err:
1247     xor_freekey(key);
1248     return NULL;
1249 }
1250
1251 static XORKEY *xor_key_from_x509pubkey(const X509_PUBKEY *xpk,
1252                                  OSSL_LIB_CTX *libctx, const char *propq)
1253 {
1254     const unsigned char *p;
1255     int plen;
1256     X509_ALGOR *palg;
1257
1258     if (!xpk || (!X509_PUBKEY_get0_param(NULL, &p, &plen, &palg, xpk))) {
1259         return NULL;
1260     }
1261     return xor_key_op(palg, p, plen, KEY_OP_PUBLIC, libctx, propq);
1262 }
1263
1264 static XORKEY *xor_key_from_pkcs8(const PKCS8_PRIV_KEY_INFO *p8inf,
1265                            OSSL_LIB_CTX *libctx, const char *propq)
1266 {
1267     XORKEY *xork = NULL;
1268     const unsigned char *p;
1269     int plen;
1270     ASN1_OCTET_STRING *oct = NULL;
1271     const X509_ALGOR *palg;
1272
1273     if (!PKCS8_pkey_get0(NULL, &p, &plen, &palg, p8inf))
1274         return 0;
1275
1276     oct = d2i_ASN1_OCTET_STRING(NULL, &p, plen);
1277     if (oct == NULL) {
1278         p = NULL;
1279         plen = 0;
1280     } else {
1281         p = ASN1_STRING_get0_data(oct);
1282         plen = ASN1_STRING_length(oct);
1283     }
1284
1285     xork = xor_key_op(palg, p, plen, KEY_OP_PRIVATE,
1286                       libctx, propq);
1287     ASN1_OCTET_STRING_free(oct);
1288     return xork;
1289 }
1290
1291 static const OSSL_ALGORITHM tls_prov_keymgmt[] = {
1292     /*
1293      * Obviously this is not FIPS approved, but in order to test in conjunction
1294      * with the FIPS provider we pretend that it is.
1295      */
1296     { "XOR", "provider=tls-provider,fips=yes",
1297              xor_keymgmt_functions },
1298     { XORSIGALG_NAME, "provider=tls-provider,fips=yes",
1299              xor_xorhmacsig_keymgmt_functions },
1300     { XORSIGALG_HASH_NAME,
1301     "provider=tls-provider,fips=yes",
1302              xor_xorhmacsha2sig_keymgmt_functions },
1303     { NULL, NULL, NULL }
1304 };
1305
1306 struct key2any_ctx_st {
1307     PROV_XOR_CTX *provctx;
1308
1309     /* Set to 0 if parameters should not be saved (dsa only) */
1310     int save_parameters;
1311
1312     /* Set to 1 if intending to encrypt/decrypt, otherwise 0 */
1313     int cipher_intent;
1314
1315     EVP_CIPHER *cipher;
1316
1317     OSSL_PASSPHRASE_CALLBACK *pwcb;
1318     void *pwcbarg;
1319 };
1320
1321 typedef int check_key_type_fn(const void *key, int nid);
1322 typedef int key_to_paramstring_fn(const void *key, int nid, int save,
1323                                   void **str, int *strtype);
1324 typedef int key_to_der_fn(BIO *out, const void *key,
1325                           int key_nid, const char *pemname,
1326                           key_to_paramstring_fn *p2s, i2d_of_void *k2d,
1327                           struct key2any_ctx_st *ctx);
1328 typedef int write_bio_of_void_fn(BIO *bp, const void *x);
1329
1330
1331 /* Free the blob allocated during key_to_paramstring_fn */
1332 static void free_asn1_data(int type, void *data)
1333 {
1334     switch(type) {
1335     case V_ASN1_OBJECT:
1336         ASN1_OBJECT_free(data);
1337         break;
1338     case V_ASN1_SEQUENCE:
1339         ASN1_STRING_free(data);
1340         break;
1341     }
1342 }
1343
1344 static PKCS8_PRIV_KEY_INFO *key_to_p8info(const void *key, int key_nid,
1345                                           void *params, int params_type,
1346                                           i2d_of_void *k2d)
1347 {
1348     /* der, derlen store the key DER output and its length */
1349     unsigned char *der = NULL;
1350     int derlen;
1351     /* The final PKCS#8 info */
1352     PKCS8_PRIV_KEY_INFO *p8info = NULL;
1353
1354     if ((p8info = PKCS8_PRIV_KEY_INFO_new()) == NULL
1355         || (derlen = k2d(key, &der)) <= 0
1356         || !PKCS8_pkey_set0(p8info, OBJ_nid2obj(key_nid), 0,
1357                             V_ASN1_UNDEF, NULL,
1358                             der, derlen)) {
1359         ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1360         PKCS8_PRIV_KEY_INFO_free(p8info);
1361         OPENSSL_free(der);
1362         p8info = NULL;
1363     }
1364
1365     return p8info;
1366 }
1367
1368 static X509_SIG *p8info_to_encp8(PKCS8_PRIV_KEY_INFO *p8info,
1369                                  struct key2any_ctx_st *ctx)
1370 {
1371     X509_SIG *p8 = NULL;
1372     char kstr[PEM_BUFSIZE];
1373     size_t klen = 0;
1374     OSSL_LIB_CTX *libctx = PROV_XOR_LIBCTX_OF(ctx->provctx);
1375
1376     if (ctx->cipher == NULL || ctx->pwcb == NULL)
1377         return NULL;
1378
1379     if (!ctx->pwcb(kstr, PEM_BUFSIZE, &klen, NULL, ctx->pwcbarg)) {
1380         ERR_raise(ERR_LIB_USER, PROV_R_UNABLE_TO_GET_PASSPHRASE);
1381         return NULL;
1382     }
1383     /* First argument == -1 means "standard" */
1384     p8 = PKCS8_encrypt_ex(-1, ctx->cipher, kstr, klen, NULL, 0, 0, p8info, libctx, NULL);
1385     OPENSSL_cleanse(kstr, klen);
1386     return p8;
1387 }
1388
1389 static X509_SIG *key_to_encp8(const void *key, int key_nid,
1390                               void *params, int params_type,
1391                               i2d_of_void *k2d, struct key2any_ctx_st *ctx)
1392 {
1393     PKCS8_PRIV_KEY_INFO *p8info =
1394         key_to_p8info(key, key_nid, params, params_type, k2d);
1395     X509_SIG *p8 = NULL;
1396
1397     if (p8info == NULL) {
1398         free_asn1_data(params_type, params);
1399     } else {
1400         p8 = p8info_to_encp8(p8info, ctx);
1401         PKCS8_PRIV_KEY_INFO_free(p8info);
1402     }
1403     return p8;
1404 }
1405
1406 static X509_PUBKEY *xorx_key_to_pubkey(const void *key, int key_nid,
1407                                   void *params, int params_type,
1408                                   i2d_of_void k2d)
1409 {
1410     /* der, derlen store the key DER output and its length */
1411     unsigned char *der = NULL;
1412     int derlen;
1413     /* The final X509_PUBKEY */
1414     X509_PUBKEY *xpk = NULL;
1415
1416     if ((xpk = X509_PUBKEY_new()) == NULL
1417         || (derlen = k2d(key, &der)) <= 0
1418         || !X509_PUBKEY_set0_param(xpk, OBJ_nid2obj(key_nid),
1419                         V_ASN1_UNDEF, NULL,
1420                         der, derlen)) {
1421         ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1422         X509_PUBKEY_free(xpk);
1423         OPENSSL_free(der);
1424         xpk = NULL;
1425     }
1426
1427     return xpk;
1428 }
1429
1430 /*
1431  * key_to_epki_* produce encoded output with the private key data in a
1432  * EncryptedPrivateKeyInfo structure (defined by PKCS#8).  They require
1433  * that there's an intent to encrypt, anything else is an error.
1434  *
1435  * key_to_pki_* primarily produce encoded output with the private key data
1436  * in a PrivateKeyInfo structure (also defined by PKCS#8).  However, if
1437  * there is an intent to encrypt the data, the corresponding key_to_epki_*
1438  * function is used instead.
1439  *
1440  * key_to_spki_* produce encoded output with the public key data in an
1441  * X.509 SubjectPublicKeyInfo.
1442  *
1443  * Key parameters don't have any defined envelopment of this kind, but are
1444  * included in some manner in the output from the functions described above,
1445  * either in the AlgorithmIdentifier's parameter field, or as part of the
1446  * key data itself.
1447  */
1448
1449 static int key_to_epki_der_priv_bio(BIO *out, const void *key,
1450                                     int key_nid,
1451                                     ossl_unused const char *pemname,
1452                                     key_to_paramstring_fn *p2s,
1453                                     i2d_of_void *k2d,
1454                                     struct key2any_ctx_st *ctx)
1455 {
1456     int ret = 0;
1457     void *str = NULL;
1458     int strtype = V_ASN1_UNDEF;
1459     X509_SIG *p8;
1460
1461     if (!ctx->cipher_intent)
1462         return 0;
1463
1464     if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1465                             &str, &strtype))
1466         return 0;
1467
1468     p8 = key_to_encp8(key, key_nid, str, strtype, k2d, ctx);
1469     if (p8 != NULL)
1470         ret = i2d_PKCS8_bio(out, p8);
1471
1472     X509_SIG_free(p8);
1473
1474     return ret;
1475 }
1476
1477 static int key_to_epki_pem_priv_bio(BIO *out, const void *key,
1478                                     int key_nid,
1479                                     ossl_unused const char *pemname,
1480                                     key_to_paramstring_fn *p2s,
1481                                     i2d_of_void *k2d,
1482                                     struct key2any_ctx_st *ctx)
1483 {
1484     int ret = 0;
1485     void *str = NULL;
1486     int strtype = V_ASN1_UNDEF;
1487     X509_SIG *p8;
1488
1489     if (!ctx->cipher_intent)
1490         return 0;
1491
1492     if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1493                             &str, &strtype))
1494         return 0;
1495
1496     p8 = key_to_encp8(key, key_nid, str, strtype, k2d, ctx);
1497     if (p8 != NULL)
1498         ret = PEM_write_bio_PKCS8(out, p8);
1499
1500     X509_SIG_free(p8);
1501
1502     return ret;
1503 }
1504
1505 static int key_to_pki_der_priv_bio(BIO *out, const void *key,
1506                                    int key_nid,
1507                                    ossl_unused const char *pemname,
1508                                    key_to_paramstring_fn *p2s,
1509                                    i2d_of_void *k2d,
1510                                    struct key2any_ctx_st *ctx)
1511 {
1512     int ret = 0;
1513     void *str = NULL;
1514     int strtype = V_ASN1_UNDEF;
1515     PKCS8_PRIV_KEY_INFO *p8info;
1516
1517     if (ctx->cipher_intent)
1518         return key_to_epki_der_priv_bio(out, key, key_nid, pemname,
1519                                         p2s, k2d, ctx);
1520
1521     if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1522                             &str, &strtype))
1523         return 0;
1524
1525     p8info = key_to_p8info(key, key_nid, str, strtype, k2d);
1526
1527     if (p8info != NULL)
1528         ret = i2d_PKCS8_PRIV_KEY_INFO_bio(out, p8info);
1529     else
1530         free_asn1_data(strtype, str);
1531
1532     PKCS8_PRIV_KEY_INFO_free(p8info);
1533
1534     return ret;
1535 }
1536
1537 static int key_to_pki_pem_priv_bio(BIO *out, const void *key,
1538                                    int key_nid,
1539                                    ossl_unused const char *pemname,
1540                                    key_to_paramstring_fn *p2s,
1541                                    i2d_of_void *k2d,
1542                                    struct key2any_ctx_st *ctx)
1543 {
1544     int ret = 0;
1545     void *str = NULL;
1546     int strtype = V_ASN1_UNDEF;
1547     PKCS8_PRIV_KEY_INFO *p8info;
1548
1549     if (ctx->cipher_intent)
1550         return key_to_epki_pem_priv_bio(out, key, key_nid, pemname,
1551                                         p2s, k2d, ctx);
1552
1553     if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1554                             &str, &strtype))
1555         return 0;
1556
1557     p8info = key_to_p8info(key, key_nid, str, strtype, k2d);
1558
1559     if (p8info != NULL)
1560         ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(out, p8info);
1561     else
1562         free_asn1_data(strtype, str);
1563
1564     PKCS8_PRIV_KEY_INFO_free(p8info);
1565
1566     return ret;
1567 }
1568
1569 static int key_to_spki_der_pub_bio(BIO *out, const void *key,
1570                                    int key_nid,
1571                                    ossl_unused const char *pemname,
1572                                    key_to_paramstring_fn *p2s,
1573                                    i2d_of_void *k2d,
1574                                    struct key2any_ctx_st *ctx)
1575 {
1576     int ret = 0;
1577     X509_PUBKEY *xpk = NULL;
1578     void *str = NULL;
1579     int strtype = V_ASN1_UNDEF;
1580
1581     if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1582                             &str, &strtype))
1583         return 0;
1584
1585     xpk = xorx_key_to_pubkey(key, key_nid, str, strtype, k2d);
1586
1587     if (xpk != NULL)
1588         ret = i2d_X509_PUBKEY_bio(out, xpk);
1589
1590     X509_PUBKEY_free(xpk);
1591     return ret;
1592 }
1593
1594 static int key_to_spki_pem_pub_bio(BIO *out, const void *key,
1595                                    int key_nid,
1596                                    ossl_unused const char *pemname,
1597                                    key_to_paramstring_fn *p2s,
1598                                    i2d_of_void *k2d,
1599                                    struct key2any_ctx_st *ctx)
1600 {
1601     int ret = 0;
1602     X509_PUBKEY *xpk = NULL;
1603     void *str = NULL;
1604     int strtype = V_ASN1_UNDEF;
1605
1606     if (p2s != NULL && !p2s(key, key_nid, ctx->save_parameters,
1607                             &str, &strtype))
1608         return 0;
1609
1610     xpk = xorx_key_to_pubkey(key, key_nid, str, strtype, k2d);
1611
1612     if (xpk != NULL)
1613         ret = PEM_write_bio_X509_PUBKEY(out, xpk);
1614     else
1615         free_asn1_data(strtype, str);
1616
1617     /* Also frees |str| */
1618     X509_PUBKEY_free(xpk);
1619     return ret;
1620 }
1621
1622 /* ---------------------------------------------------------------------- */
1623
1624 static int prepare_xorx_params(const void *xorxkey, int nid, int save,
1625                              void **pstr, int *pstrtype)
1626 {
1627     ASN1_OBJECT *params = NULL;
1628     XORKEY *k = (XORKEY*)xorxkey;
1629
1630     if (k->tls_name && OBJ_sn2nid(k->tls_name) != nid) {
1631         ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_KEY);
1632         return 0;
1633     }
1634
1635     if (nid == NID_undef) {
1636         ERR_raise(ERR_LIB_USER, XORPROV_R_MISSING_OID);
1637         return 0;
1638     }
1639
1640     params = OBJ_nid2obj(nid);
1641
1642     if (params == NULL || OBJ_length(params) == 0) {
1643         /* unexpected error */
1644         ERR_raise(ERR_LIB_USER, XORPROV_R_MISSING_OID);
1645         ASN1_OBJECT_free(params);
1646         return 0;
1647     }
1648     *pstr = params;
1649     *pstrtype = V_ASN1_OBJECT;
1650     return 1;
1651 }
1652
1653 static int xorx_spki_pub_to_der(const void *vecxkey, unsigned char **pder)
1654 {
1655     const XORKEY *xorxkey = vecxkey;
1656     unsigned char *keyblob;
1657     int retlen;
1658
1659     if (xorxkey == NULL) {
1660         ERR_raise(ERR_LIB_USER, ERR_R_PASSED_NULL_PARAMETER);
1661         return 0;
1662     }
1663
1664     keyblob = OPENSSL_memdup(xorxkey->pubkey, retlen = XOR_KEY_SIZE);
1665     if (keyblob == NULL) {
1666         ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1667         return 0;
1668     }
1669
1670     *pder = keyblob;
1671     return retlen;
1672 }
1673
1674 static int xorx_pki_priv_to_der(const void *vecxkey, unsigned char **pder)
1675 {
1676     XORKEY *xorxkey = (XORKEY *)vecxkey;
1677     unsigned char* buf = NULL;
1678     ASN1_OCTET_STRING oct;
1679     int keybloblen;
1680
1681     if (xorxkey == NULL) {
1682         ERR_raise(ERR_LIB_USER, ERR_R_PASSED_NULL_PARAMETER);
1683         return 0;
1684     }
1685
1686     buf = OPENSSL_secure_malloc(XOR_KEY_SIZE);
1687     memcpy(buf, xorxkey->privkey, XOR_KEY_SIZE);
1688
1689     oct.data = buf;
1690     oct.length = XOR_KEY_SIZE;
1691     oct.flags = 0;
1692
1693     keybloblen = i2d_ASN1_OCTET_STRING(&oct, pder);
1694     if (keybloblen < 0) {
1695         ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
1696         keybloblen = 0;
1697     }
1698
1699     OPENSSL_secure_clear_free(buf, XOR_KEY_SIZE);
1700     return keybloblen;
1701 }
1702
1703 # define xorx_epki_priv_to_der xorx_pki_priv_to_der
1704
1705 /*
1706  * XORX only has PKCS#8 / SubjectPublicKeyInfo
1707  * representation, so we don't define xorx_type_specific_[priv,pub,params]_to_der.
1708  */
1709
1710 # define xorx_check_key_type            NULL
1711
1712 # define xorhmacsig_evp_type            0
1713 # define xorhmacsig_input_type          XORSIGALG_NAME
1714 # define xorhmacsig_pem_type            XORSIGALG_NAME
1715 # define xorhmacsha2sig_evp_type        0
1716 # define xorhmacsha2sig_input_type      XORSIGALG_HASH_NAME
1717 # define xorhmacsha2sig_pem_type        XORSIGALG_HASH_NAME
1718
1719 /* ---------------------------------------------------------------------- */
1720
1721 static OSSL_FUNC_decoder_newctx_fn key2any_newctx;
1722 static OSSL_FUNC_decoder_freectx_fn key2any_freectx;
1723
1724 static void *key2any_newctx(void *provctx)
1725 {
1726     struct key2any_ctx_st *ctx = OPENSSL_zalloc(sizeof(*ctx));
1727
1728     if (ctx != NULL) {
1729         ctx->provctx = provctx;
1730         ctx->save_parameters = 1;
1731     }
1732
1733     return ctx;
1734 }
1735
1736 static void key2any_freectx(void *vctx)
1737 {
1738     struct key2any_ctx_st *ctx = vctx;
1739
1740     EVP_CIPHER_free(ctx->cipher);
1741     OPENSSL_free(ctx);
1742 }
1743
1744 static const OSSL_PARAM *key2any_settable_ctx_params(ossl_unused void *provctx)
1745 {
1746     static const OSSL_PARAM settables[] = {
1747         OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_CIPHER, NULL, 0),
1748         OSSL_PARAM_utf8_string(OSSL_ENCODER_PARAM_PROPERTIES, NULL, 0),
1749         OSSL_PARAM_END,
1750     };
1751
1752     return settables;
1753 }
1754
1755 static int key2any_set_ctx_params(void *vctx, const OSSL_PARAM params[])
1756 {
1757     struct key2any_ctx_st *ctx = vctx;
1758     OSSL_LIB_CTX *libctx = PROV_XOR_LIBCTX_OF(ctx->provctx);
1759     const OSSL_PARAM *cipherp =
1760         OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_CIPHER);
1761     const OSSL_PARAM *propsp =
1762         OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_PROPERTIES);
1763     const OSSL_PARAM *save_paramsp =
1764         OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_SAVE_PARAMETERS);
1765
1766     if (cipherp != NULL) {
1767         const char *ciphername = NULL;
1768         const char *props = NULL;
1769
1770         if (!OSSL_PARAM_get_utf8_string_ptr(cipherp, &ciphername))
1771             return 0;
1772         if (propsp != NULL && !OSSL_PARAM_get_utf8_string_ptr(propsp, &props))
1773             return 0;
1774
1775         EVP_CIPHER_free(ctx->cipher);
1776         ctx->cipher = NULL;
1777         ctx->cipher_intent = ciphername != NULL;
1778         if (ciphername != NULL
1779             && ((ctx->cipher =
1780                  EVP_CIPHER_fetch(libctx, ciphername, props)) == NULL)) {
1781             return 0;
1782         }
1783     }
1784
1785     if (save_paramsp != NULL) {
1786         if (!OSSL_PARAM_get_int(save_paramsp, &ctx->save_parameters)) {
1787             return 0;
1788         }
1789     }
1790     return 1;
1791 }
1792
1793 static int key2any_check_selection(int selection, int selection_mask)
1794 {
1795     /*
1796      * The selections are kinda sorta "levels", i.e. each selection given
1797      * here is assumed to include those following.
1798      */
1799     int checks[] = {
1800         OSSL_KEYMGMT_SELECT_PRIVATE_KEY,
1801         OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
1802         OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
1803     };
1804     size_t i;
1805
1806     /* The decoder implementations made here support guessing */
1807     if (selection == 0)
1808         return 1;
1809
1810     for (i = 0; i < OSSL_NELEM(checks); i++) {
1811         int check1 = (selection & checks[i]) != 0;
1812         int check2 = (selection_mask & checks[i]) != 0;
1813
1814         /*
1815          * If the caller asked for the currently checked bit(s), return
1816          * whether the decoder description says it's supported.
1817          */
1818         if (check1)
1819             return check2;
1820     }
1821
1822     /* This should be dead code, but just to be safe... */
1823     return 0;
1824 }
1825
1826 static int key2any_encode(struct key2any_ctx_st *ctx, OSSL_CORE_BIO *cout,
1827                           const void *key, const char* typestr, const char *pemname,
1828                           key_to_der_fn *writer,
1829                           OSSL_PASSPHRASE_CALLBACK *pwcb, void *pwcbarg,
1830                           key_to_paramstring_fn *key2paramstring,
1831                           i2d_of_void *key2der)
1832 {
1833     int ret = 0;
1834     int type = OBJ_sn2nid(typestr);
1835
1836     if (key == NULL || type <= 0) {
1837         ERR_raise(ERR_LIB_USER, ERR_R_PASSED_NULL_PARAMETER);
1838     } else if (writer != NULL) {
1839         BIO *out = BIO_new_from_core_bio(ctx->provctx->libctx, cout);
1840
1841         if (out != NULL) {
1842             ctx->pwcb = pwcb;
1843             ctx->pwcbarg = pwcbarg;
1844
1845             ret = writer(out, key, type, pemname, key2paramstring, key2der, ctx);
1846         }
1847
1848         BIO_free(out);
1849     } else {
1850         ERR_raise(ERR_LIB_USER, ERR_R_PASSED_INVALID_ARGUMENT);
1851     }
1852     return ret;
1853 }
1854
1855 #define DO_ENC_PRIVATE_KEY_selection_mask OSSL_KEYMGMT_SELECT_PRIVATE_KEY
1856 #define DO_ENC_PRIVATE_KEY(impl, type, kind, output)                            \
1857     if ((selection & DO_ENC_PRIVATE_KEY_selection_mask) != 0)                   \
1858         return key2any_encode(ctx, cout, key, impl##_pem_type,              \
1859                               impl##_pem_type " PRIVATE KEY",               \
1860                               key_to_##kind##_##output##_priv_bio,          \
1861                               cb, cbarg, prepare_##type##_params,           \
1862                               type##_##kind##_priv_to_der);
1863
1864 #define DO_ENC_PUBLIC_KEY_selection_mask OSSL_KEYMGMT_SELECT_PUBLIC_KEY
1865 #define DO_ENC_PUBLIC_KEY(impl, type, kind, output)                             \
1866     if ((selection & DO_ENC_PUBLIC_KEY_selection_mask) != 0)                    \
1867         return key2any_encode(ctx, cout, key, impl##_pem_type,              \
1868                               impl##_pem_type " PUBLIC KEY",                \
1869                               key_to_##kind##_##output##_pub_bio,           \
1870                               cb, cbarg, prepare_##type##_params,           \
1871                               type##_##kind##_pub_to_der);
1872
1873 #define DO_ENC_PARAMETERS_selection_mask OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
1874 #define DO_ENC_PARAMETERS(impl, type, kind, output)                             \
1875     if ((selection & DO_ENC_PARAMETERS_selection_mask) != 0)                    \
1876         return key2any_encode(ctx, cout, key, impl##_pem_type,              \
1877                               impl##_pem_type " PARAMETERS",                \
1878                               key_to_##kind##_##output##_param_bio,         \
1879                               NULL, NULL, NULL,                             \
1880                               type##_##kind##_params_to_der);
1881
1882 /*-
1883  * Implement the kinds of output structure that can be produced.  They are
1884  * referred to by name, and for each name, the following macros are defined
1885  * (braces not included):
1886  *
1887  * DO_{kind}_selection_mask
1888  *
1889  *      A mask of selection bits that must not be zero.  This is used as a
1890  *      selection criterion for each implementation.
1891  *      This mask must never be zero.
1892  *
1893  * DO_{kind}
1894  *
1895  *      The performing macro.  It must use the DO_ macros defined above,
1896  *      always in this order:
1897  *
1898  *      - DO_PRIVATE_KEY
1899  *      - DO_PUBLIC_KEY
1900  *      - DO_PARAMETERS
1901  *
1902  *      Any of those may be omitted, but the relative order must still be
1903  *      the same.
1904  */
1905
1906 /*
1907  * PKCS#8 defines two structures for private keys only:
1908  * - PrivateKeyInfo             (raw unencrypted form)
1909  * - EncryptedPrivateKeyInfo    (encrypted wrapping)
1910  *
1911  * To allow a certain amount of flexibility, we allow the routines
1912  * for PrivateKeyInfo to also produce EncryptedPrivateKeyInfo if a
1913  * passphrase callback has been passed to them.
1914  */
1915 #define DO_ENC_PrivateKeyInfo_selection_mask DO_ENC_PRIVATE_KEY_selection_mask
1916 #define DO_ENC_PrivateKeyInfo(impl, type, output)                               \
1917     DO_ENC_PRIVATE_KEY(impl, type, pki, output)
1918
1919 #define DO_ENC_EncryptedPrivateKeyInfo_selection_mask DO_ENC_PRIVATE_KEY_selection_mask
1920 #define DO_ENC_EncryptedPrivateKeyInfo(impl, type, output)                      \
1921     DO_ENC_PRIVATE_KEY(impl, type, epki, output)
1922
1923 /* SubjectPublicKeyInfo is a structure for public keys only */
1924 #define DO_ENC_SubjectPublicKeyInfo_selection_mask DO_ENC_PUBLIC_KEY_selection_mask
1925 #define DO_ENC_SubjectPublicKeyInfo(impl, type, output)                         \
1926     DO_ENC_PUBLIC_KEY(impl, type, spki, output)
1927
1928 /*
1929  * MAKE_ENCODER is the single driver for creating OSSL_DISPATCH tables.
1930  * It takes the following arguments:
1931  *
1932  * impl         This is the key type name that's being implemented.
1933  * type         This is the type name for the set of functions that implement
1934  *              the key type.  For example, ed25519, ed448, x25519 and x448
1935  *              are all implemented with the exact same set of functions.
1936  * kind         What kind of support to implement.  These translate into
1937  *              the DO_##kind macros above.
1938  * output       The output type to implement.  may be der or pem.
1939  *
1940  * The resulting OSSL_DISPATCH array gets the following name (expressed in
1941  * C preprocessor terms) from those arguments:
1942  *
1943  * xor_##impl##_to_##kind##_##output##_encoder_functions
1944  */
1945 #define MAKE_ENCODER(impl, type, kind, output)                              \
1946     static OSSL_FUNC_encoder_import_object_fn                               \
1947     impl##_to_##kind##_##output##_import_object;                            \
1948     static OSSL_FUNC_encoder_free_object_fn                                 \
1949     impl##_to_##kind##_##output##_free_object;                              \
1950     static OSSL_FUNC_encoder_encode_fn                                      \
1951     impl##_to_##kind##_##output##_encode;                                   \
1952                                                                             \
1953     static void *                                                           \
1954     impl##_to_##kind##_##output##_import_object(void *vctx, int selection,  \
1955                                                 const OSSL_PARAM params[])  \
1956     {                                                                       \
1957         struct key2any_ctx_st *ctx = vctx;                                  \
1958                                                                             \
1959         return xor_prov_import_key(xor_##impl##_keymgmt_functions,          \
1960                                     ctx->provctx, selection, params);       \
1961     }                                                                       \
1962     static void impl##_to_##kind##_##output##_free_object(void *key)        \
1963     {                                                                       \
1964         xor_prov_free_key(xor_##impl##_keymgmt_functions, key);             \
1965     }                                                                       \
1966     static int impl##_to_##kind##_##output##_does_selection(void *ctx,      \
1967                                                             int selection)  \
1968     {                                                                       \
1969         return key2any_check_selection(selection,                           \
1970                                        DO_ENC_##kind##_selection_mask);     \
1971     }                                                                       \
1972     static int                                                              \
1973     impl##_to_##kind##_##output##_encode(void *ctx, OSSL_CORE_BIO *cout,    \
1974                                          const void *key,                   \
1975                                          const OSSL_PARAM key_abstract[],   \
1976                                          int selection,                     \
1977                                          OSSL_PASSPHRASE_CALLBACK *cb,      \
1978                                          void *cbarg)                       \
1979     {                                                                       \
1980         /* We don't deal with abstract objects */                           \
1981         if (key_abstract != NULL) {                                         \
1982             ERR_raise(ERR_LIB_USER, ERR_R_PASSED_INVALID_ARGUMENT);         \
1983             return 0;                                                       \
1984         }                                                                   \
1985         DO_ENC_##kind(impl, type, output)                                   \
1986                                                                             \
1987         ERR_raise(ERR_LIB_USER, ERR_R_PASSED_INVALID_ARGUMENT);             \
1988         return 0;                                                           \
1989     }                                                                       \
1990     static const OSSL_DISPATCH                                              \
1991     xor_##impl##_to_##kind##_##output##_encoder_functions[] = {             \
1992         { OSSL_FUNC_ENCODER_NEWCTX,                                         \
1993           (void (*)(void))key2any_newctx },                                 \
1994         { OSSL_FUNC_ENCODER_FREECTX,                                        \
1995           (void (*)(void))key2any_freectx },                                \
1996         { OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS,                            \
1997           (void (*)(void))key2any_settable_ctx_params },                    \
1998         { OSSL_FUNC_ENCODER_SET_CTX_PARAMS,                                 \
1999           (void (*)(void))key2any_set_ctx_params },                         \
2000         { OSSL_FUNC_ENCODER_DOES_SELECTION,                                 \
2001           (void (*)(void))impl##_to_##kind##_##output##_does_selection },   \
2002         { OSSL_FUNC_ENCODER_IMPORT_OBJECT,                                  \
2003           (void (*)(void))impl##_to_##kind##_##output##_import_object },    \
2004         { OSSL_FUNC_ENCODER_FREE_OBJECT,                                    \
2005           (void (*)(void))impl##_to_##kind##_##output##_free_object },      \
2006         { OSSL_FUNC_ENCODER_ENCODE,                                         \
2007           (void (*)(void))impl##_to_##kind##_##output##_encode },           \
2008         OSSL_DISPATCH_END                                                   \
2009     }
2010
2011 /*
2012  * Replacements for i2d_{TYPE}PrivateKey, i2d_{TYPE}PublicKey,
2013  * i2d_{TYPE}params, as they exist.
2014  */
2015
2016 /*
2017  * PKCS#8 and SubjectPublicKeyInfo support.  This may duplicate some of the
2018  * implementations specified above, but are more specific.
2019  * The SubjectPublicKeyInfo implementations also replace the
2020  * PEM_write_bio_{TYPE}_PUBKEY functions.
2021  * For PEM, these are expected to be used by PEM_write_bio_PrivateKey(),
2022  * PEM_write_bio_PUBKEY() and PEM_write_bio_Parameters().
2023  */
2024
2025 MAKE_ENCODER(xorhmacsig, xorx, EncryptedPrivateKeyInfo, der);
2026 MAKE_ENCODER(xorhmacsig, xorx, EncryptedPrivateKeyInfo, pem);
2027 MAKE_ENCODER(xorhmacsig, xorx, PrivateKeyInfo, der);
2028 MAKE_ENCODER(xorhmacsig, xorx, PrivateKeyInfo, pem);
2029 MAKE_ENCODER(xorhmacsig, xorx, SubjectPublicKeyInfo, der);
2030 MAKE_ENCODER(xorhmacsig, xorx, SubjectPublicKeyInfo, pem);
2031 MAKE_ENCODER(xorhmacsha2sig, xorx, EncryptedPrivateKeyInfo, der);
2032 MAKE_ENCODER(xorhmacsha2sig, xorx, EncryptedPrivateKeyInfo, pem);
2033 MAKE_ENCODER(xorhmacsha2sig, xorx, PrivateKeyInfo, der);
2034 MAKE_ENCODER(xorhmacsha2sig, xorx, PrivateKeyInfo, pem);
2035 MAKE_ENCODER(xorhmacsha2sig, xorx, SubjectPublicKeyInfo, der);
2036 MAKE_ENCODER(xorhmacsha2sig, xorx, SubjectPublicKeyInfo, pem);
2037
2038 static const OSSL_ALGORITHM tls_prov_encoder[] = {
2039 #define ENCODER_PROVIDER "tls-provider"
2040 #ifndef ENCODER_PROVIDER
2041 # error Macro ENCODER_PROVIDER undefined
2042 #endif
2043
2044 #define ENCODER_STRUCTURE_PKCS8                         "pkcs8"
2045 #define ENCODER_STRUCTURE_SubjectPublicKeyInfo          "SubjectPublicKeyInfo"
2046 #define ENCODER_STRUCTURE_PrivateKeyInfo                "PrivateKeyInfo"
2047 #define ENCODER_STRUCTURE_EncryptedPrivateKeyInfo       "EncryptedPrivateKeyInfo"
2048 #define ENCODER_STRUCTURE_PKCS1                         "pkcs1"
2049 #define ENCODER_STRUCTURE_PKCS3                         "pkcs3"
2050
2051 /* Arguments are prefixed with '_' to avoid build breaks on certain platforms */
2052 /*
2053  * Obviously this is not FIPS approved, but in order to test in conjunction
2054  * with the FIPS provider we pretend that it is.
2055  */
2056 #define ENCODER_TEXT(_name, _sym)                                \
2057     { _name,                                                            \
2058       "provider=" ENCODER_PROVIDER ",fips=yes,output=text",      \
2059       (xor_##_sym##_to_text_encoder_functions) }
2060 #define ENCODER(_name, _sym, _fips, _output)                            \
2061     { _name,                                                            \
2062       "provider=" ENCODER_PROVIDER ",fips=yes,output=" #_output, \
2063       (xor_##_sym##_to_##_output##_encoder_functions) }
2064
2065 #define ENCODER_w_structure(_name, _sym, _output, _structure)    \
2066     { _name,                                                            \
2067       "provider=" ENCODER_PROVIDER ",fips=yes,output=" #_output  \
2068       ",structure=" ENCODER_STRUCTURE_##_structure,                     \
2069       (xor_##_sym##_to_##_structure##_##_output##_encoder_functions) }
2070
2071 /*
2072  * Entries for human text "encoders"
2073  */
2074
2075 /*
2076  * Entries for PKCS#8 and SubjectPublicKeyInfo.
2077  * The "der" ones are added convenience for any user that wants to use
2078  * OSSL_ENCODER directly.
2079  * The "pem" ones also support PEM_write_bio_PrivateKey() and
2080  * PEM_write_bio_PUBKEY().
2081  */
2082
2083 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, der, PrivateKeyInfo),
2084 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, pem, PrivateKeyInfo),
2085 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, der, EncryptedPrivateKeyInfo),
2086 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, pem, EncryptedPrivateKeyInfo),
2087 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, der, SubjectPublicKeyInfo),
2088 ENCODER_w_structure(XORSIGALG_NAME, xorhmacsig, pem, SubjectPublicKeyInfo),
2089 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2090                     der, PrivateKeyInfo),
2091 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2092                     pem, PrivateKeyInfo),
2093 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2094                     der, EncryptedPrivateKeyInfo),
2095 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2096                     pem, EncryptedPrivateKeyInfo),
2097 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2098                     der, SubjectPublicKeyInfo),
2099 ENCODER_w_structure(XORSIGALG_HASH_NAME, xorhmacsha2sig,
2100                     pem, SubjectPublicKeyInfo),
2101 #undef ENCODER_PROVIDER
2102     { NULL, NULL, NULL }
2103 };
2104
2105 struct der2key_ctx_st;           /* Forward declaration */
2106 typedef int check_key_fn(void *, struct der2key_ctx_st *ctx);
2107 typedef void adjust_key_fn(void *, struct der2key_ctx_st *ctx);
2108 typedef void free_key_fn(void *);
2109 typedef void *d2i_PKCS8_fn(void **, const unsigned char **, long,
2110                            struct der2key_ctx_st *);
2111 struct keytype_desc_st {
2112     const char *keytype_name;
2113     const OSSL_DISPATCH *fns; /* Keymgmt (to pilfer functions from) */
2114
2115     /* The input structure name */
2116     const char *structure_name;
2117
2118     /*
2119      * The EVP_PKEY_xxx type macro.  Should be zero for type specific
2120      * structures, non-zero when the outermost structure is PKCS#8 or
2121      * SubjectPublicKeyInfo.  This determines which of the function
2122      * pointers below will be used.
2123      */
2124     int evp_type;
2125
2126     /* The selection mask for OSSL_FUNC_decoder_does_selection() */
2127     int selection_mask;
2128
2129     /* For type specific decoders, we use the corresponding d2i */
2130     d2i_of_void *d2i_private_key; /* From type-specific DER */
2131     d2i_of_void *d2i_public_key;  /* From type-specific DER */
2132     d2i_of_void *d2i_key_params;  /* From type-specific DER */
2133     d2i_PKCS8_fn *d2i_PKCS8;      /* Wrapped in a PrivateKeyInfo */
2134     d2i_of_void *d2i_PUBKEY;      /* Wrapped in a SubjectPublicKeyInfo */
2135
2136     /*
2137      * For any key, we may need to check that the key meets expectations.
2138      * This is useful when the same functions can decode several variants
2139      * of a key.
2140      */
2141     check_key_fn *check_key;
2142
2143     /*
2144      * For any key, we may need to make provider specific adjustments, such
2145      * as ensure the key carries the correct library context.
2146      */
2147     adjust_key_fn *adjust_key;
2148     /* {type}_free() */
2149     free_key_fn *free_key;
2150 };
2151
2152 /*
2153  * Start blatant code steal. Alternative: Open up d2i_X509_PUBKEY_INTERNAL
2154  * as per https://github.com/openssl/openssl/issues/16697 (TBD)
2155  * Code from openssl/crypto/x509/x_pubkey.c as
2156  * ossl_d2i_X509_PUBKEY_INTERNAL is presently not public
2157  */
2158 struct X509_pubkey_st {
2159     X509_ALGOR *algor;
2160     ASN1_BIT_STRING *public_key;
2161
2162     EVP_PKEY *pkey;
2163
2164     /* extra data for the callback, used by d2i_PUBKEY_ex */
2165     OSSL_LIB_CTX *libctx;
2166     char *propq;
2167 };
2168
2169 ASN1_SEQUENCE(X509_PUBKEY_INTERNAL) = {
2170         ASN1_SIMPLE(X509_PUBKEY, algor, X509_ALGOR),
2171         ASN1_SIMPLE(X509_PUBKEY, public_key, ASN1_BIT_STRING)
2172 } static_ASN1_SEQUENCE_END_name(X509_PUBKEY, X509_PUBKEY_INTERNAL)
2173
2174 static X509_PUBKEY *xorx_d2i_X509_PUBKEY_INTERNAL(const unsigned char **pp,
2175                                            long len, OSSL_LIB_CTX *libctx)
2176 {
2177     X509_PUBKEY *xpub = OPENSSL_zalloc(sizeof(*xpub));
2178
2179     if (xpub == NULL)
2180         return NULL;
2181     return (X509_PUBKEY *)ASN1_item_d2i_ex((ASN1_VALUE **)&xpub, pp, len,
2182                                            ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL),
2183                                            libctx, NULL);
2184 }
2185 /* end steal https://github.com/openssl/openssl/issues/16697 */
2186
2187 /*
2188  * Context used for DER to key decoding.
2189  */
2190 struct der2key_ctx_st {
2191     PROV_XOR_CTX *provctx;
2192     struct keytype_desc_st *desc;
2193     /* The selection that is passed to xor_der2key_decode() */
2194     int selection;
2195     /* Flag used to signal that a failure is fatal */
2196     unsigned int flag_fatal : 1;
2197 };
2198
2199 static int xor_read_der(PROV_XOR_CTX *provctx, OSSL_CORE_BIO *cin,
2200                         unsigned char **data, long *len)
2201 {
2202     BUF_MEM *mem = NULL;
2203     BIO *in = BIO_new_from_core_bio(provctx->libctx, cin);
2204     int ok = (asn1_d2i_read_bio(in, &mem) >= 0);
2205
2206     if (ok) {
2207         *data = (unsigned char *)mem->data;
2208         *len = (long)mem->length;
2209         OPENSSL_free(mem);
2210     }
2211     BIO_free(in);
2212     return ok;
2213 }
2214
2215 typedef void *key_from_pkcs8_t(const PKCS8_PRIV_KEY_INFO *p8inf,
2216                                OSSL_LIB_CTX *libctx, const char *propq);
2217 static void *xor_der2key_decode_p8(const unsigned char **input_der,
2218                                long input_der_len, struct der2key_ctx_st *ctx,
2219                                key_from_pkcs8_t *key_from_pkcs8)
2220 {
2221     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
2222     const X509_ALGOR *alg = NULL;
2223     void *key = NULL;
2224
2225     if ((p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, input_der, input_der_len)) != NULL
2226         && PKCS8_pkey_get0(NULL, NULL, NULL, &alg, p8inf)
2227         && OBJ_obj2nid(alg->algorithm) == ctx->desc->evp_type)
2228         key = key_from_pkcs8(p8inf, PROV_XOR_LIBCTX_OF(ctx->provctx), NULL);
2229     PKCS8_PRIV_KEY_INFO_free(p8inf);
2230
2231     return key;
2232 }
2233
2234 static XORKEY *xor_d2i_PUBKEY(XORKEY **a,
2235                                const unsigned char **pp, long length)
2236 {
2237     XORKEY *key = NULL;
2238     X509_PUBKEY *xpk;
2239
2240     xpk = xorx_d2i_X509_PUBKEY_INTERNAL(pp, length, NULL);
2241
2242     key = xor_key_from_x509pubkey(xpk, NULL, NULL);
2243
2244     if (key == NULL)
2245         goto err_exit;
2246
2247     if (a != NULL) {
2248         xor_freekey(*a);
2249         *a = key;
2250     }
2251
2252     err_exit:
2253     X509_PUBKEY_free(xpk);
2254     return key;
2255 }
2256
2257
2258 /* ---------------------------------------------------------------------- */
2259
2260 static OSSL_FUNC_decoder_freectx_fn der2key_freectx;
2261 static OSSL_FUNC_decoder_decode_fn xor_der2key_decode;
2262 static OSSL_FUNC_decoder_export_object_fn der2key_export_object;
2263
2264 static struct der2key_ctx_st *
2265 der2key_newctx(void *provctx, struct keytype_desc_st *desc, const char* tls_name)
2266 {
2267     struct der2key_ctx_st *ctx = OPENSSL_zalloc(sizeof(*ctx));
2268
2269     if (ctx != NULL) {
2270         ctx->provctx = provctx;
2271         ctx->desc = desc;
2272         if (desc->evp_type == 0) {
2273            ctx->desc->evp_type = OBJ_sn2nid(tls_name);
2274         }
2275     }
2276     return ctx;
2277 }
2278
2279 static void der2key_freectx(void *vctx)
2280 {
2281     struct der2key_ctx_st *ctx = vctx;
2282
2283     OPENSSL_free(ctx);
2284 }
2285
2286 static int der2key_check_selection(int selection,
2287                                    const struct keytype_desc_st *desc)
2288 {
2289     /*
2290      * The selections are kinda sorta "levels", i.e. each selection given
2291      * here is assumed to include those following.
2292      */
2293     int checks[] = {
2294         OSSL_KEYMGMT_SELECT_PRIVATE_KEY,
2295         OSSL_KEYMGMT_SELECT_PUBLIC_KEY,
2296         OSSL_KEYMGMT_SELECT_ALL_PARAMETERS
2297     };
2298     size_t i;
2299
2300     /* The decoder implementations made here support guessing */
2301     if (selection == 0)
2302         return 1;
2303
2304     for (i = 0; i < OSSL_NELEM(checks); i++) {
2305         int check1 = (selection & checks[i]) != 0;
2306         int check2 = (desc->selection_mask & checks[i]) != 0;
2307
2308         /*
2309          * If the caller asked for the currently checked bit(s), return
2310          * whether the decoder description says it's supported.
2311          */
2312         if (check1)
2313             return check2;
2314     }
2315
2316     /* This should be dead code, but just to be safe... */
2317     return 0;
2318 }
2319
2320 static int xor_der2key_decode(void *vctx, OSSL_CORE_BIO *cin, int selection,
2321                           OSSL_CALLBACK *data_cb, void *data_cbarg,
2322                           OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
2323 {
2324     struct der2key_ctx_st *ctx = vctx;
2325     unsigned char *der = NULL;
2326     const unsigned char *derp;
2327     long der_len = 0;
2328     void *key = NULL;
2329     int ok = 0;
2330
2331     ctx->selection = selection;
2332     /*
2333      * The caller is allowed to specify 0 as a selection mark, to have the
2334      * structure and key type guessed.  For type-specific structures, this
2335      * is not recommended, as some structures are very similar.
2336      * Note that 0 isn't the same as OSSL_KEYMGMT_SELECT_ALL, as the latter
2337      * signifies a private key structure, where everything else is assumed
2338      * to be present as well.
2339      */
2340     if (selection == 0)
2341         selection = ctx->desc->selection_mask;
2342     if ((selection & ctx->desc->selection_mask) == 0) {
2343         ERR_raise(ERR_LIB_PROV, ERR_R_PASSED_INVALID_ARGUMENT);
2344         return 0;
2345     }
2346
2347     ok = xor_read_der(ctx->provctx, cin, &der, &der_len);
2348     if (!ok)
2349         goto next;
2350
2351     ok = 0;                      /* Assume that we fail */
2352
2353     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
2354         derp = der;
2355         if (ctx->desc->d2i_PKCS8 != NULL) {
2356             key = ctx->desc->d2i_PKCS8(NULL, &derp, der_len, ctx);
2357             if (ctx->flag_fatal)
2358                 goto end;
2359         } else if (ctx->desc->d2i_private_key != NULL) {
2360             key = ctx->desc->d2i_private_key(NULL, &derp, der_len);
2361         }
2362         if (key == NULL && ctx->selection != 0)
2363             goto next;
2364     }
2365     if (key == NULL && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
2366         derp = der;
2367         if (ctx->desc->d2i_PUBKEY != NULL)
2368             key = ctx->desc->d2i_PUBKEY(NULL, &derp, der_len);
2369         else
2370             key = ctx->desc->d2i_public_key(NULL, &derp, der_len);
2371         if (key == NULL && ctx->selection != 0)
2372             goto next;
2373     }
2374     if (key == NULL && (selection & OSSL_KEYMGMT_SELECT_ALL_PARAMETERS) != 0) {
2375         derp = der;
2376         if (ctx->desc->d2i_key_params != NULL)
2377             key = ctx->desc->d2i_key_params(NULL, &derp, der_len);
2378         if (key == NULL && ctx->selection != 0)
2379             goto next;
2380     }
2381
2382     /*
2383      * Last minute check to see if this was the correct type of key.  This
2384      * should never lead to a fatal error, i.e. the decoding itself was
2385      * correct, it was just an unexpected key type.  This is generally for
2386      * classes of key types that have subtle variants, like RSA-PSS keys as
2387      * opposed to plain RSA keys.
2388      */
2389     if (key != NULL
2390         && ctx->desc->check_key != NULL
2391         && !ctx->desc->check_key(key, ctx)) {
2392         ctx->desc->free_key(key);
2393         key = NULL;
2394     }
2395
2396     if (key != NULL && ctx->desc->adjust_key != NULL)
2397         ctx->desc->adjust_key(key, ctx);
2398
2399  next:
2400     /*
2401      * Indicated that we successfully decoded something, or not at all.
2402      * Ending up "empty handed" is not an error.
2403      */
2404     ok = 1;
2405
2406     /*
2407      * We free memory here so it's not held up during the callback, because
2408      * we know the process is recursive and the allocated chunks of memory
2409      * add up.
2410      */
2411     OPENSSL_free(der);
2412     der = NULL;
2413
2414     if (key != NULL) {
2415         OSSL_PARAM params[4];
2416         int object_type = OSSL_OBJECT_PKEY;
2417
2418         params[0] =
2419             OSSL_PARAM_construct_int(OSSL_OBJECT_PARAM_TYPE, &object_type);
2420         params[1] =
2421             OSSL_PARAM_construct_utf8_string(OSSL_OBJECT_PARAM_DATA_TYPE,
2422                                              (char *)ctx->desc->keytype_name,
2423                                              0);
2424         /* The address of the key becomes the octet string */
2425         params[2] =
2426             OSSL_PARAM_construct_octet_string(OSSL_OBJECT_PARAM_REFERENCE,
2427                                               &key, sizeof(key));
2428         params[3] = OSSL_PARAM_construct_end();
2429
2430         ok = data_cb(params, data_cbarg);
2431     }
2432
2433  end:
2434     ctx->desc->free_key(key);
2435     OPENSSL_free(der);
2436
2437     return ok;
2438 }
2439
2440 static int der2key_export_object(void *vctx,
2441                                  const void *reference, size_t reference_sz,
2442                                  OSSL_CALLBACK *export_cb, void *export_cbarg)
2443 {
2444     struct der2key_ctx_st *ctx = vctx;
2445     OSSL_FUNC_keymgmt_export_fn *export =
2446         xor_prov_get_keymgmt_export(ctx->desc->fns);
2447     void *keydata;
2448
2449     if (reference_sz == sizeof(keydata) && export != NULL) {
2450         /* The contents of the reference is the address to our object */
2451         keydata = *(void **)reference;
2452
2453         return export(keydata, ctx->selection, export_cb, export_cbarg);
2454     }
2455     return 0;
2456 }
2457
2458 /* ---------------------------------------------------------------------- */
2459
2460 static void *xorx_d2i_PKCS8(void **key, const unsigned char **der, long der_len,
2461                            struct der2key_ctx_st *ctx)
2462 {
2463     return xor_der2key_decode_p8(der, der_len, ctx,
2464                              (key_from_pkcs8_t *)xor_key_from_pkcs8);
2465 }
2466
2467 static void xorx_key_adjust(void *key, struct der2key_ctx_st *ctx)
2468 {
2469 }
2470
2471 /* ---------------------------------------------------------------------- */
2472
2473 #define DO_PrivateKeyInfo(keytype)                      \
2474     "PrivateKeyInfo", 0,                                \
2475         ( OSSL_KEYMGMT_SELECT_PRIVATE_KEY ),            \
2476         NULL,                                           \
2477         NULL,                                           \
2478         NULL,                                           \
2479         xorx_d2i_PKCS8,                                 \
2480         NULL,                                           \
2481         NULL,                                           \
2482         xorx_key_adjust,                                \
2483         (free_key_fn *)xor_freekey
2484
2485 #define DO_SubjectPublicKeyInfo(keytype)                \
2486     "SubjectPublicKeyInfo", 0,                          \
2487         ( OSSL_KEYMGMT_SELECT_PUBLIC_KEY ),             \
2488         NULL,                                           \
2489         NULL,                                           \
2490         NULL,                                           \
2491         NULL,                                           \
2492         (d2i_of_void *)xor_d2i_PUBKEY,                  \
2493         NULL,                                           \
2494         xorx_key_adjust,                                \
2495         (free_key_fn *)xor_freekey
2496
2497 /*
2498  * MAKE_DECODER is the single driver for creating OSSL_DISPATCH tables.
2499  * It takes the following arguments:
2500  *
2501  * keytype_name The implementation key type as a string.
2502  * keytype      The implementation key type.  This must correspond exactly
2503  *              to our existing keymgmt keytype names...  in other words,
2504  *              there must exist an ossl_##keytype##_keymgmt_functions.
2505  * type         The type name for the set of functions that implement the
2506  *              decoder for the key type.  This isn't necessarily the same
2507  *              as keytype.  For example, the key types ed25519, ed448,
2508  *              x25519 and x448 are all handled by the same functions with
2509  *              the common type name ecx.
2510  * kind         The kind of support to implement.  This translates into
2511  *              the DO_##kind macros above, to populate the keytype_desc_st
2512  *              structure.
2513  */
2514 #define MAKE_DECODER(keytype_name, keytype, type, kind)                 \
2515     static struct keytype_desc_st kind##_##keytype##_desc =             \
2516         { keytype_name, xor_##keytype##_keymgmt_functions,              \
2517           DO_##kind(keytype) };                                         \
2518                                                                         \
2519     static OSSL_FUNC_decoder_newctx_fn kind##_der2##keytype##_newctx;   \
2520                                                                         \
2521     static void *kind##_der2##keytype##_newctx(void *provctx)           \
2522     {                                                                   \
2523         return der2key_newctx(provctx, &kind##_##keytype##_desc, keytype_name );\
2524     }                                                                   \
2525     static int kind##_der2##keytype##_does_selection(void *provctx,     \
2526                                                      int selection)     \
2527     {                                                                   \
2528         return der2key_check_selection(selection,                       \
2529                                        &kind##_##keytype##_desc);       \
2530     }                                                                   \
2531     static const OSSL_DISPATCH                                          \
2532     xor_##kind##_der_to_##keytype##_decoder_functions[] = {             \
2533         { OSSL_FUNC_DECODER_NEWCTX,                                     \
2534           (void (*)(void))kind##_der2##keytype##_newctx },              \
2535         { OSSL_FUNC_DECODER_FREECTX,                                    \
2536           (void (*)(void))der2key_freectx },                            \
2537         { OSSL_FUNC_DECODER_DOES_SELECTION,                             \
2538           (void (*)(void))kind##_der2##keytype##_does_selection },      \
2539         { OSSL_FUNC_DECODER_DECODE,                                     \
2540           (void (*)(void))xor_der2key_decode },                         \
2541         { OSSL_FUNC_DECODER_EXPORT_OBJECT,                              \
2542           (void (*)(void))der2key_export_object },                      \
2543         OSSL_DISPATCH_END                                               \
2544     }
2545
2546 MAKE_DECODER(XORSIGALG_NAME, xorhmacsig, xor, PrivateKeyInfo);
2547 MAKE_DECODER(XORSIGALG_NAME, xorhmacsig, xor, SubjectPublicKeyInfo);
2548 MAKE_DECODER(XORSIGALG_HASH_NAME, xorhmacsha2sig, xor, PrivateKeyInfo);
2549 MAKE_DECODER(XORSIGALG_HASH_NAME, xorhmacsha2sig, xor, SubjectPublicKeyInfo);
2550
2551 static const OSSL_ALGORITHM tls_prov_decoder[] = {
2552 #define DECODER_PROVIDER "tls-provider"
2553 #define DECODER_STRUCTURE_SubjectPublicKeyInfo          "SubjectPublicKeyInfo"
2554 #define DECODER_STRUCTURE_PrivateKeyInfo                "PrivateKeyInfo"
2555
2556 /* Arguments are prefixed with '_' to avoid build breaks on certain platforms */
2557 /*
2558  * Obviously this is not FIPS approved, but in order to test in conjunction
2559  * with the FIPS provider we pretend that it is.
2560  */
2561
2562 #define DECODER(_name, _input, _output)                          \
2563     { _name,                                                            \
2564       "provider=" DECODER_PROVIDER ",fips=yes,input=" #_input,   \
2565       (xor_##_input##_to_##_output##_decoder_functions) }
2566 #define DECODER_w_structure(_name, _input, _structure, _output)  \
2567     { _name,                                                            \
2568       "provider=" DECODER_PROVIDER ",fips=yes,input=" #_input    \
2569       ",structure=" DECODER_STRUCTURE_##_structure,                     \
2570       (xor_##_structure##_##_input##_to_##_output##_decoder_functions) }
2571
2572 DECODER_w_structure(XORSIGALG_NAME, der, PrivateKeyInfo, xorhmacsig),
2573 DECODER_w_structure(XORSIGALG_NAME, der, SubjectPublicKeyInfo, xorhmacsig),
2574 DECODER_w_structure(XORSIGALG_HASH_NAME, der, PrivateKeyInfo, xorhmacsha2sig),
2575 DECODER_w_structure(XORSIGALG_HASH_NAME, der, SubjectPublicKeyInfo, xorhmacsha2sig),
2576 #undef DECODER_PROVIDER
2577     { NULL, NULL, NULL }
2578 };
2579
2580 #define OSSL_MAX_NAME_SIZE 50
2581 #define OSSL_MAX_PROPQUERY_SIZE     256 /* Property query strings */
2582
2583 static OSSL_FUNC_signature_newctx_fn xor_sig_newctx;
2584 static OSSL_FUNC_signature_sign_init_fn xor_sig_sign_init;
2585 static OSSL_FUNC_signature_verify_init_fn xor_sig_verify_init;
2586 static OSSL_FUNC_signature_sign_fn xor_sig_sign;
2587 static OSSL_FUNC_signature_verify_fn xor_sig_verify;
2588 static OSSL_FUNC_signature_digest_sign_init_fn xor_sig_digest_sign_init;
2589 static OSSL_FUNC_signature_digest_sign_update_fn xor_sig_digest_signverify_update;
2590 static OSSL_FUNC_signature_digest_sign_final_fn xor_sig_digest_sign_final;
2591 static OSSL_FUNC_signature_digest_verify_init_fn xor_sig_digest_verify_init;
2592 static OSSL_FUNC_signature_digest_verify_update_fn xor_sig_digest_signverify_update;
2593 static OSSL_FUNC_signature_digest_verify_final_fn xor_sig_digest_verify_final;
2594 static OSSL_FUNC_signature_freectx_fn xor_sig_freectx;
2595 static OSSL_FUNC_signature_dupctx_fn xor_sig_dupctx;
2596 static OSSL_FUNC_signature_get_ctx_params_fn xor_sig_get_ctx_params;
2597 static OSSL_FUNC_signature_gettable_ctx_params_fn xor_sig_gettable_ctx_params;
2598 static OSSL_FUNC_signature_set_ctx_params_fn xor_sig_set_ctx_params;
2599 static OSSL_FUNC_signature_settable_ctx_params_fn xor_sig_settable_ctx_params;
2600 static OSSL_FUNC_signature_get_ctx_md_params_fn xor_sig_get_ctx_md_params;
2601 static OSSL_FUNC_signature_gettable_ctx_md_params_fn xor_sig_gettable_ctx_md_params;
2602 static OSSL_FUNC_signature_set_ctx_md_params_fn xor_sig_set_ctx_md_params;
2603 static OSSL_FUNC_signature_settable_ctx_md_params_fn xor_sig_settable_ctx_md_params;
2604
2605 static int xor_get_aid(unsigned char** oidbuf, const char *tls_name) {
2606    X509_ALGOR *algor = X509_ALGOR_new();
2607    int aidlen = 0;
2608
2609    X509_ALGOR_set0(algor, OBJ_txt2obj(tls_name, 0), V_ASN1_UNDEF, NULL);
2610
2611    aidlen = i2d_X509_ALGOR(algor, oidbuf);
2612    X509_ALGOR_free(algor);
2613    return(aidlen);
2614 }
2615
2616 /*
2617  * What's passed as an actual key is defined by the KEYMGMT interface.
2618  */
2619 typedef struct {
2620     OSSL_LIB_CTX *libctx;
2621     char *propq;
2622     XORKEY *sig;
2623
2624     /*
2625      * Flag to determine if the hash function can be changed (1) or not (0)
2626      * Because it's dangerous to change during a DigestSign or DigestVerify
2627      * operation, this flag is cleared by their Init function, and set again
2628      * by their Final function.
2629      */
2630     unsigned int flag_allow_md : 1;
2631
2632     char mdname[OSSL_MAX_NAME_SIZE];
2633
2634     /* The Algorithm Identifier of the combined signature algorithm */
2635     unsigned char *aid;
2636     size_t  aid_len;
2637
2638     /* main digest */
2639     EVP_MD *md;
2640     EVP_MD_CTX *mdctx;
2641     int operation;
2642 } PROV_XORSIG_CTX;
2643
2644 static void *xor_sig_newctx(void *provctx, const char *propq)
2645 {
2646     PROV_XORSIG_CTX *pxor_sigctx;
2647
2648     pxor_sigctx = OPENSSL_zalloc(sizeof(PROV_XORSIG_CTX));
2649     if (pxor_sigctx == NULL)
2650         return NULL;
2651
2652     pxor_sigctx->libctx = ((PROV_XOR_CTX*)provctx)->libctx;
2653     pxor_sigctx->flag_allow_md = 0;
2654     if (propq != NULL && (pxor_sigctx->propq = OPENSSL_strdup(propq)) == NULL) {
2655         OPENSSL_free(pxor_sigctx);
2656         pxor_sigctx = NULL;
2657         ERR_raise(ERR_LIB_USER, ERR_R_MALLOC_FAILURE);
2658     }
2659     return pxor_sigctx;
2660 }
2661
2662 static int xor_sig_setup_md(PROV_XORSIG_CTX *ctx,
2663                         const char *mdname, const char *mdprops)
2664 {
2665     EVP_MD *md;
2666
2667     if (mdprops == NULL)
2668         mdprops = ctx->propq;
2669
2670     md = EVP_MD_fetch(ctx->libctx, mdname, mdprops);
2671
2672     if ((md == NULL) || (EVP_MD_nid(md)==NID_undef)) {
2673         if (md == NULL)
2674             ERR_raise_data(ERR_LIB_USER, XORPROV_R_INVALID_DIGEST,
2675                            "%s could not be fetched", mdname);
2676         EVP_MD_free(md);
2677         return 0;
2678     }
2679
2680     EVP_MD_CTX_free(ctx->mdctx);
2681     ctx->mdctx = NULL;
2682     EVP_MD_free(ctx->md);
2683     ctx->md = NULL;
2684
2685     OPENSSL_free(ctx->aid);
2686     ctx->aid = NULL;
2687     ctx->aid_len = xor_get_aid(&(ctx->aid), ctx->sig->tls_name);
2688
2689     ctx->mdctx = NULL;
2690     ctx->md = md;
2691     OPENSSL_strlcpy(ctx->mdname, mdname, sizeof(ctx->mdname));
2692     return 1;
2693 }
2694
2695 static int xor_sig_signverify_init(void *vpxor_sigctx, void *vxorsig,
2696                                    int operation)
2697 {
2698     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2699
2700     if (pxor_sigctx == NULL || vxorsig == NULL)
2701         return 0;
2702     xor_freekey(pxor_sigctx->sig);
2703     if (!xor_key_up_ref(vxorsig))
2704         return 0;
2705     pxor_sigctx->sig = vxorsig;
2706     pxor_sigctx->operation = operation;
2707     if ((operation==EVP_PKEY_OP_SIGN && pxor_sigctx->sig == NULL)
2708         || (operation==EVP_PKEY_OP_VERIFY && pxor_sigctx->sig == NULL)) {
2709         ERR_raise(ERR_LIB_USER, XORPROV_R_INVALID_KEY);
2710         return 0;
2711     }
2712     return 1;
2713 }
2714
2715 static int xor_sig_sign_init(void *vpxor_sigctx, void *vxorsig,
2716                              const OSSL_PARAM params[])
2717 {
2718     return xor_sig_signverify_init(vpxor_sigctx, vxorsig, EVP_PKEY_OP_SIGN);
2719 }
2720
2721 static int xor_sig_verify_init(void *vpxor_sigctx, void *vxorsig,
2722                                const OSSL_PARAM params[])
2723 {
2724     return xor_sig_signverify_init(vpxor_sigctx, vxorsig, EVP_PKEY_OP_VERIFY);
2725 }
2726
2727 static int xor_sig_sign(void *vpxor_sigctx, unsigned char *sig, size_t *siglen,
2728                     size_t sigsize, const unsigned char *tbs, size_t tbslen)
2729 {
2730     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2731     XORKEY *xorkey = pxor_sigctx->sig;
2732
2733     size_t max_sig_len = EVP_MAX_MD_SIZE;
2734     size_t xor_sig_len = 0;
2735     int rv = 0;
2736
2737     if (xorkey == NULL || !xorkey->hasprivkey) {
2738         ERR_raise(ERR_LIB_USER, XORPROV_R_NO_PRIVATE_KEY);
2739         return rv;
2740     }
2741
2742     if (sig == NULL) {
2743         *siglen = max_sig_len;
2744         return 1;
2745     }
2746     if (*siglen < max_sig_len) {
2747         ERR_raise(ERR_LIB_USER, XORPROV_R_BUFFER_LENGTH_WRONG);
2748         return rv;
2749     }
2750
2751     /*
2752      * create HMAC using XORKEY as key and hash as data:
2753      * No real crypto, just for test, don't do this at home!
2754      */
2755     if (!EVP_Q_mac(pxor_sigctx->libctx, "HMAC", NULL, "sha1", NULL,
2756                    xorkey->privkey, XOR_KEY_SIZE, tbs, tbslen,
2757                    &sig[0], EVP_MAX_MD_SIZE, &xor_sig_len)) {
2758         ERR_raise(ERR_LIB_USER, XORPROV_R_SIGNING_FAILED);
2759         goto endsign;
2760     }
2761
2762     *siglen = xor_sig_len;
2763     rv = 1; /* success */
2764
2765  endsign:
2766     return rv;
2767 }
2768
2769 static int xor_sig_verify(void *vpxor_sigctx,
2770     const unsigned char *sig, size_t siglen,
2771                           const unsigned char *tbs, size_t tbslen)
2772 {
2773     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2774     XORKEY *xorkey = pxor_sigctx->sig;
2775     unsigned char resignature[EVP_MAX_MD_SIZE];
2776     size_t resiglen;
2777     int i;
2778
2779     if (xorkey == NULL || sig == NULL || tbs == NULL) {
2780         ERR_raise(ERR_LIB_USER, XORPROV_R_WRONG_PARAMETERS);
2781         return 0;
2782     }
2783
2784     /*
2785      * This is no real verify: just re-sign and compare:
2786      * Don't do this at home! Not fit for real use!
2787      */
2788     /* First re-create private key from public key: */
2789     for (i = 0; i < XOR_KEY_SIZE; i++)
2790         xorkey->privkey[i] = xorkey->pubkey[i] ^ private_constant[i];
2791
2792     /* Now re-create signature */
2793     if (!EVP_Q_mac(pxor_sigctx->libctx, "HMAC", NULL, "sha1", NULL,
2794                    xorkey->privkey, XOR_KEY_SIZE, tbs, tbslen,
2795                    &resignature[0], EVP_MAX_MD_SIZE, &resiglen)) {
2796         ERR_raise(ERR_LIB_USER, XORPROV_R_VERIFY_ERROR);
2797         return 0;
2798     }
2799
2800     /* Now compare with signature passed */
2801     if (siglen != resiglen || memcmp(resignature, sig, siglen) != 0) {
2802         ERR_raise(ERR_LIB_USER, XORPROV_R_VERIFY_ERROR);
2803         return 0;
2804     }
2805     return 1;
2806 }
2807
2808 static int xor_sig_digest_signverify_init(void *vpxor_sigctx, const char *mdname,
2809                                       void *vxorsig, int operation)
2810 {
2811     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2812     char *rmdname = (char *)mdname;
2813
2814     if (rmdname == NULL)
2815         rmdname = "sha256";
2816
2817     pxor_sigctx->flag_allow_md = 0;
2818     if (!xor_sig_signverify_init(vpxor_sigctx, vxorsig, operation))
2819         return 0;
2820
2821     if (!xor_sig_setup_md(pxor_sigctx, rmdname, NULL))
2822         return 0;
2823
2824     pxor_sigctx->mdctx = EVP_MD_CTX_new();
2825     if (pxor_sigctx->mdctx == NULL)
2826         goto error;
2827
2828     if (!EVP_DigestInit_ex(pxor_sigctx->mdctx, pxor_sigctx->md, NULL))
2829         goto error;
2830
2831     return 1;
2832
2833  error:
2834     EVP_MD_CTX_free(pxor_sigctx->mdctx);
2835     EVP_MD_free(pxor_sigctx->md);
2836     pxor_sigctx->mdctx = NULL;
2837     pxor_sigctx->md = NULL;
2838     return 0;
2839 }
2840
2841 static int xor_sig_digest_sign_init(void *vpxor_sigctx, const char *mdname,
2842                                       void *vxorsig, const OSSL_PARAM params[])
2843 {
2844     return xor_sig_digest_signverify_init(vpxor_sigctx, mdname, vxorsig,
2845                                           EVP_PKEY_OP_SIGN);
2846 }
2847
2848 static int xor_sig_digest_verify_init(void *vpxor_sigctx, const char *mdname, void *vxorsig, const OSSL_PARAM params[])
2849 {
2850     return xor_sig_digest_signverify_init(vpxor_sigctx, mdname,
2851                                           vxorsig, EVP_PKEY_OP_VERIFY);
2852 }
2853
2854 int xor_sig_digest_signverify_update(void *vpxor_sigctx,
2855                                      const unsigned char *data,
2856                                      size_t datalen)
2857 {
2858     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2859
2860     if (pxor_sigctx == NULL || pxor_sigctx->mdctx == NULL)
2861         return 0;
2862
2863     return EVP_DigestUpdate(pxor_sigctx->mdctx, data, datalen);
2864 }
2865
2866 int xor_sig_digest_sign_final(void *vpxor_sigctx,
2867                               unsigned char *sig, size_t *siglen,
2868                               size_t sigsize)
2869 {
2870     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2871     unsigned char digest[EVP_MAX_MD_SIZE];
2872     unsigned int dlen = 0;
2873
2874     if (sig != NULL) {
2875         if (pxor_sigctx == NULL || pxor_sigctx->mdctx == NULL)
2876             return 0;
2877
2878         if (!EVP_DigestFinal_ex(pxor_sigctx->mdctx, digest, &dlen))
2879             return 0;
2880
2881         pxor_sigctx->flag_allow_md = 1;
2882     }
2883
2884     return xor_sig_sign(vpxor_sigctx, sig, siglen, sigsize, digest, (size_t)dlen);
2885
2886 }
2887
2888 int xor_sig_digest_verify_final(void *vpxor_sigctx, const unsigned char *sig,
2889                             size_t siglen)
2890 {
2891     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2892     unsigned char digest[EVP_MAX_MD_SIZE];
2893     unsigned int dlen = 0;
2894
2895     if (pxor_sigctx == NULL || pxor_sigctx->mdctx == NULL)
2896         return 0;
2897
2898     if (!EVP_DigestFinal_ex(pxor_sigctx->mdctx, digest, &dlen))
2899         return 0;
2900
2901     pxor_sigctx->flag_allow_md = 1;
2902
2903     return xor_sig_verify(vpxor_sigctx, sig, siglen, digest, (size_t)dlen);
2904 }
2905
2906 static void xor_sig_freectx(void *vpxor_sigctx)
2907 {
2908     PROV_XORSIG_CTX *ctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2909
2910     OPENSSL_free(ctx->propq);
2911     EVP_MD_CTX_free(ctx->mdctx);
2912     EVP_MD_free(ctx->md);
2913     ctx->propq = NULL;
2914     ctx->mdctx = NULL;
2915     ctx->md = NULL;
2916     xor_freekey(ctx->sig);
2917     ctx->sig = NULL;
2918     OPENSSL_free(ctx->aid);
2919     OPENSSL_free(ctx);
2920 }
2921
2922 static void *xor_sig_dupctx(void *vpxor_sigctx)
2923 {
2924     PROV_XORSIG_CTX *srcctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2925     PROV_XORSIG_CTX *dstctx;
2926
2927     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
2928     if (dstctx == NULL)
2929         return NULL;
2930
2931     *dstctx = *srcctx;
2932     dstctx->sig = NULL;
2933     dstctx->md = NULL;
2934     dstctx->mdctx = NULL;
2935     dstctx->aid = NULL;
2936
2937     if ((srcctx->sig != NULL) && !xor_key_up_ref(srcctx->sig))
2938         goto err;
2939     dstctx->sig = srcctx->sig;
2940
2941     if (srcctx->md != NULL && !EVP_MD_up_ref(srcctx->md))
2942         goto err;
2943     dstctx->md = srcctx->md;
2944
2945     if (srcctx->mdctx != NULL) {
2946         dstctx->mdctx = EVP_MD_CTX_new();
2947         if (dstctx->mdctx == NULL
2948                 || !EVP_MD_CTX_copy_ex(dstctx->mdctx, srcctx->mdctx))
2949             goto err;
2950     }
2951
2952     return dstctx;
2953  err:
2954     xor_sig_freectx(dstctx);
2955     return NULL;
2956 }
2957
2958 static int xor_sig_get_ctx_params(void *vpxor_sigctx, OSSL_PARAM *params)
2959 {
2960     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2961     OSSL_PARAM *p;
2962
2963     if (pxor_sigctx == NULL || params == NULL)
2964         return 0;
2965
2966     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_ALGORITHM_ID);
2967
2968     if (pxor_sigctx->aid == NULL)
2969         pxor_sigctx->aid_len = xor_get_aid(&(pxor_sigctx->aid), pxor_sigctx->sig->tls_name);
2970
2971     if (p != NULL
2972         && !OSSL_PARAM_set_octet_string(p, pxor_sigctx->aid, pxor_sigctx->aid_len))
2973         return 0;
2974
2975     p = OSSL_PARAM_locate(params, OSSL_SIGNATURE_PARAM_DIGEST);
2976     if (p != NULL && !OSSL_PARAM_set_utf8_string(p, pxor_sigctx->mdname))
2977         return 0;
2978
2979     return 1;
2980 }
2981
2982 static const OSSL_PARAM known_gettable_ctx_params[] = {
2983     OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
2984     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
2985     OSSL_PARAM_END
2986 };
2987
2988 static const OSSL_PARAM *xor_sig_gettable_ctx_params(ossl_unused void *vpxor_sigctx, ossl_unused void *vctx)
2989 {
2990     return known_gettable_ctx_params;
2991 }
2992
2993 static int xor_sig_set_ctx_params(void *vpxor_sigctx, const OSSL_PARAM params[])
2994 {
2995     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
2996     const OSSL_PARAM *p;
2997
2998     if (pxor_sigctx == NULL || params == NULL)
2999         return 0;
3000
3001     p = OSSL_PARAM_locate_const(params, OSSL_SIGNATURE_PARAM_DIGEST);
3002     /* Not allowed during certain operations */
3003     if (p != NULL && !pxor_sigctx->flag_allow_md)
3004         return 0;
3005     if (p != NULL) {
3006         char mdname[OSSL_MAX_NAME_SIZE] = "", *pmdname = mdname;
3007         char mdprops[OSSL_MAX_PROPQUERY_SIZE] = "", *pmdprops = mdprops;
3008         const OSSL_PARAM *propsp =
3009             OSSL_PARAM_locate_const(params,
3010                                     OSSL_SIGNATURE_PARAM_PROPERTIES);
3011
3012         if (!OSSL_PARAM_get_utf8_string(p, &pmdname, sizeof(mdname)))
3013             return 0;
3014         if (propsp != NULL
3015             && !OSSL_PARAM_get_utf8_string(propsp, &pmdprops, sizeof(mdprops)))
3016             return 0;
3017         if (!xor_sig_setup_md(pxor_sigctx, mdname, mdprops))
3018             return 0;
3019     }
3020
3021     return 1;
3022 }
3023
3024 static const OSSL_PARAM known_settable_ctx_params[] = {
3025     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST, NULL, 0),
3026     OSSL_PARAM_utf8_string(OSSL_SIGNATURE_PARAM_PROPERTIES, NULL, 0),
3027     OSSL_PARAM_END
3028 };
3029
3030 static const OSSL_PARAM *xor_sig_settable_ctx_params(ossl_unused void *vpsm2ctx,
3031                                                      ossl_unused void *provctx)
3032 {
3033     return known_settable_ctx_params;
3034 }
3035
3036 static int xor_sig_get_ctx_md_params(void *vpxor_sigctx, OSSL_PARAM *params)
3037 {
3038     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3039
3040     if (pxor_sigctx->mdctx == NULL)
3041         return 0;
3042
3043     return EVP_MD_CTX_get_params(pxor_sigctx->mdctx, params);
3044 }
3045
3046 static const OSSL_PARAM *xor_sig_gettable_ctx_md_params(void *vpxor_sigctx)
3047 {
3048     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3049
3050     if (pxor_sigctx->md == NULL)
3051         return 0;
3052
3053     return EVP_MD_gettable_ctx_params(pxor_sigctx->md);
3054 }
3055
3056 static int xor_sig_set_ctx_md_params(void *vpxor_sigctx, const OSSL_PARAM params[])
3057 {
3058     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3059
3060     if (pxor_sigctx->mdctx == NULL)
3061         return 0;
3062
3063     return EVP_MD_CTX_set_params(pxor_sigctx->mdctx, params);
3064 }
3065
3066 static const OSSL_PARAM *xor_sig_settable_ctx_md_params(void *vpxor_sigctx)
3067 {
3068     PROV_XORSIG_CTX *pxor_sigctx = (PROV_XORSIG_CTX *)vpxor_sigctx;
3069
3070     if (pxor_sigctx->md == NULL)
3071         return 0;
3072
3073     return EVP_MD_settable_ctx_params(pxor_sigctx->md);
3074 }
3075
3076 static const OSSL_DISPATCH xor_signature_functions[] = {
3077     { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))xor_sig_newctx },
3078     { OSSL_FUNC_SIGNATURE_SIGN_INIT, (void (*)(void))xor_sig_sign_init },
3079     { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))xor_sig_sign },
3080     { OSSL_FUNC_SIGNATURE_VERIFY_INIT, (void (*)(void))xor_sig_verify_init },
3081     { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))xor_sig_verify },
3082     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,
3083       (void (*)(void))xor_sig_digest_sign_init },
3084     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_UPDATE,
3085       (void (*)(void))xor_sig_digest_signverify_update },
3086     { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_FINAL,
3087       (void (*)(void))xor_sig_digest_sign_final },
3088     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,
3089       (void (*)(void))xor_sig_digest_verify_init },
3090     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_UPDATE,
3091       (void (*)(void))xor_sig_digest_signverify_update },
3092     { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_FINAL,
3093       (void (*)(void))xor_sig_digest_verify_final },
3094     { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))xor_sig_freectx },
3095     { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))xor_sig_dupctx },
3096     { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, (void (*)(void))xor_sig_get_ctx_params },
3097     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,
3098       (void (*)(void))xor_sig_gettable_ctx_params },
3099     { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))xor_sig_set_ctx_params },
3100     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,
3101       (void (*)(void))xor_sig_settable_ctx_params },
3102     { OSSL_FUNC_SIGNATURE_GET_CTX_MD_PARAMS,
3103       (void (*)(void))xor_sig_get_ctx_md_params },
3104     { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_MD_PARAMS,
3105       (void (*)(void))xor_sig_gettable_ctx_md_params },
3106     { OSSL_FUNC_SIGNATURE_SET_CTX_MD_PARAMS,
3107       (void (*)(void))xor_sig_set_ctx_md_params },
3108     { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_MD_PARAMS,
3109       (void (*)(void))xor_sig_settable_ctx_md_params },
3110     OSSL_DISPATCH_END
3111 };
3112
3113 static const OSSL_ALGORITHM tls_prov_signature[] = {
3114     /*
3115      * Obviously this is not FIPS approved, but in order to test in conjunction
3116      * with the FIPS provider we pretend that it is.
3117      */
3118     { XORSIGALG_NAME, "provider=tls-provider,fips=yes",
3119                            xor_signature_functions },
3120     { XORSIGALG_HASH_NAME, "provider=tls-provider,fips=yes",
3121                            xor_signature_functions },
3122     { XORSIGALG12_NAME, "provider=tls-provider,fips=yes",
3123                            xor_signature_functions },
3124     { NULL, NULL, NULL }
3125 };
3126
3127
3128 static const OSSL_ALGORITHM *tls_prov_query(void *provctx, int operation_id,
3129                                             int *no_cache)
3130 {
3131     *no_cache = 0;
3132     switch (operation_id) {
3133     case OSSL_OP_KEYMGMT:
3134         return tls_prov_keymgmt;
3135     case OSSL_OP_KEYEXCH:
3136         return tls_prov_keyexch;
3137     case OSSL_OP_KEM:
3138         return tls_prov_kem;
3139     case OSSL_OP_ENCODER:
3140         return tls_prov_encoder;
3141     case OSSL_OP_DECODER:
3142         return tls_prov_decoder;
3143     case OSSL_OP_SIGNATURE:
3144         return tls_prov_signature;
3145     }
3146     return NULL;
3147 }
3148
3149 static void tls_prov_teardown(void *provctx)
3150 {
3151     int i;
3152     PROV_XOR_CTX *pctx = (PROV_XOR_CTX*)provctx;
3153
3154     OSSL_LIB_CTX_free(pctx->libctx);
3155
3156     for (i = 0; i < NUM_DUMMY_GROUPS; i++) {
3157         OPENSSL_free(dummy_group_names[i]);
3158         dummy_group_names[i] = NULL;
3159     }
3160     OPENSSL_free(pctx);
3161 }
3162
3163 /* Functions we provide to the core */
3164 static const OSSL_DISPATCH tls_prov_dispatch_table[] = {
3165     { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))tls_prov_teardown },
3166     { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))tls_prov_query },
3167     { OSSL_FUNC_PROVIDER_GET_CAPABILITIES, (void (*)(void))tls_prov_get_capabilities },
3168     OSSL_DISPATCH_END
3169 };
3170
3171 static
3172 unsigned int randomize_tls_alg_id(OSSL_LIB_CTX *libctx)
3173 {
3174     /*
3175      * Randomise the id we're going to use to ensure we don't interoperate
3176      * with anything but ourselves.
3177      */
3178     unsigned int id;
3179     static unsigned int mem[10] = { 0 };
3180     static int in_mem = 0;
3181     int i;
3182
3183  retry:
3184     if (RAND_bytes_ex(libctx, (unsigned char *)&id, sizeof(id), 0) <= 0)
3185         return 0;
3186     /*
3187      * Ensure id is within the IANA Reserved for private use range
3188      * (65024-65279)
3189      */
3190     id %= 65279 - 65024;
3191     id += 65024;
3192
3193     /* Ensure we did not already issue this id */
3194     for (i = 0; i < in_mem; i++)
3195         if (mem[i] == id)
3196             goto retry;
3197
3198     /* Add this id to the list of ids issued by this function */
3199     mem[in_mem++] = id;
3200
3201     return id;
3202 }
3203
3204 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
3205                       const OSSL_DISPATCH *in,
3206                       const OSSL_DISPATCH **out,
3207                       void **provctx)
3208 {
3209     OSSL_LIB_CTX *libctx = OSSL_LIB_CTX_new_from_dispatch(handle, in);
3210     OSSL_FUNC_core_obj_create_fn *c_obj_create= NULL;
3211     OSSL_FUNC_core_obj_add_sigid_fn *c_obj_add_sigid= NULL;
3212     PROV_XOR_CTX *prov_ctx = xor_newprovctx(libctx);
3213
3214     if (libctx == NULL || prov_ctx == NULL)
3215         return 0;
3216
3217     *provctx = prov_ctx;
3218
3219     /*
3220      * Randomise the group_id and code_points we're going to use to ensure we
3221      * don't interoperate with anything but ourselves.
3222      */
3223     xor_group.group_id = randomize_tls_alg_id(libctx);
3224     xor_kemgroup.group_id = randomize_tls_alg_id(libctx);
3225     xor_sigalg.code_point = randomize_tls_alg_id(libctx);
3226     xor_sigalg_hash.code_point = randomize_tls_alg_id(libctx);
3227
3228     /* Retrieve registration functions */
3229     for (; in->function_id != 0; in++) {
3230         switch (in->function_id) {
3231         case OSSL_FUNC_CORE_OBJ_CREATE:
3232             c_obj_create = OSSL_FUNC_core_obj_create(in);
3233             break;
3234         case OSSL_FUNC_CORE_OBJ_ADD_SIGID:
3235             c_obj_add_sigid = OSSL_FUNC_core_obj_add_sigid(in);
3236             break;
3237         /* Just ignore anything we don't understand */
3238         default:
3239             break;
3240         }
3241     }
3242
3243     /*
3244      * Register algorithms manually as add_provider_sigalgs is
3245      * only called during session establishment -- too late for
3246      * key & cert generation...
3247      */
3248     if (!c_obj_create(handle, XORSIGALG_OID, XORSIGALG_NAME, XORSIGALG_NAME)) {
3249         ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3250         return 0;
3251     }
3252
3253     if (!c_obj_add_sigid(handle, XORSIGALG_OID, "", XORSIGALG_OID)) {
3254         ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3255         return 0;
3256     }
3257     if (!c_obj_create(handle, XORSIGALG_HASH_OID, XORSIGALG_HASH_NAME, NULL)) {
3258         ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3259         return 0;
3260     }
3261
3262     if (!c_obj_add_sigid(handle, XORSIGALG_HASH_OID, XORSIGALG_HASH, XORSIGALG_HASH_OID)) {
3263         ERR_raise(ERR_LIB_USER, XORPROV_R_OBJ_CREATE_ERR);
3264         return 0;
3265     }
3266
3267     *out = tls_prov_dispatch_table;
3268     return 1;
3269 }