test/tls-provider.c

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