test/tls-provider.c

   1 /*
   2  * Copyright 2019-2021 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 /* For TLS1_3_VERSION */
  16 #include <openssl/ssl.h>
  17
  18 static OSSL_FUNC_keymgmt_import_fn xor_import;
  19 static OSSL_FUNC_keymgmt_import_types_fn xor_import_types;
  20 static OSSL_FUNC_keymgmt_export_fn xor_export;
  21 static OSSL_FUNC_keymgmt_export_types_fn xor_export_types;
  22
  23 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
  24                       const OSSL_DISPATCH *in,
  25                       const OSSL_DISPATCH **out,
  26                       void **provctx);
  27
  28 #define XOR_KEY_SIZE 32
  29
  30 /*
  31  * Top secret. This algorithm only works if no one knows what this number is.
  32  * Please don't tell anyone what it is.
  33  *
  34  * This algorithm is for testing only - don't really use it!
  35  */
  36 static const unsigned char private_constant[XOR_KEY_SIZE] = {
  37     0xd3, 0x6b, 0x54, 0xec, 0x5b, 0xac, 0x89, 0x96, 0x8c, 0x2c, 0x66, 0xa5,
  38     0x67, 0x0d, 0xe3, 0xdd, 0x43, 0x69, 0xbc, 0x83, 0x3d, 0x60, 0xc7, 0xb8,
  39     0x2b, 0x1c, 0x5a, 0xfd, 0xb5, 0xcd, 0xd0, 0xf8
  40 };
  41
  42 typedef struct xorkey_st {
  43     unsigned char privkey[XOR_KEY_SIZE];
  44     unsigned char pubkey[XOR_KEY_SIZE];
  45     int hasprivkey;
  46     int haspubkey;
  47 } XORKEY;
  48
  49
  50 /* Key Management for the dummy XOR KEX and KEM algorithms */
  51
  52 static OSSL_FUNC_keymgmt_new_fn xor_newdata;
  53 static OSSL_FUNC_keymgmt_free_fn xor_freedata;
  54 static OSSL_FUNC_keymgmt_has_fn xor_has;
  55 static OSSL_FUNC_keymgmt_copy_fn xor_copy;
  56 static OSSL_FUNC_keymgmt_gen_init_fn xor_gen_init;
  57 static OSSL_FUNC_keymgmt_gen_set_params_fn xor_gen_set_params;
  58 static OSSL_FUNC_keymgmt_gen_settable_params_fn xor_gen_settable_params;
  59 static OSSL_FUNC_keymgmt_gen_fn xor_gen;
  60 static OSSL_FUNC_keymgmt_gen_cleanup_fn xor_gen_cleanup;
  61 static OSSL_FUNC_keymgmt_get_params_fn xor_get_params;
  62 static OSSL_FUNC_keymgmt_gettable_params_fn xor_gettable_params;
  63 static OSSL_FUNC_keymgmt_set_params_fn xor_set_params;
  64 static OSSL_FUNC_keymgmt_settable_params_fn xor_settable_params;
  65
  66 /*
  67  * Dummy "XOR" Key Exchange algorithm. We just xor the private and public keys
  68  * together. Don't use this!
  69  */
  70
  71 static OSSL_FUNC_keyexch_newctx_fn xor_newctx;
  72 static OSSL_FUNC_keyexch_init_fn xor_init;
  73 static OSSL_FUNC_keyexch_set_peer_fn xor_set_peer;
  74 static OSSL_FUNC_keyexch_derive_fn xor_derive;
  75 static OSSL_FUNC_keyexch_freectx_fn xor_freectx;
  76 static OSSL_FUNC_keyexch_dupctx_fn xor_dupctx;
  77
  78 /*
  79  * Dummy "XOR" Key Encapsulation Method. We just build a KEM over the xor KEX.
  80  * Don't use this!
  81  */
  82
  83 static OSSL_FUNC_kem_newctx_fn xor_newctx;
  84 static OSSL_FUNC_kem_freectx_fn xor_freectx;
  85 static OSSL_FUNC_kem_dupctx_fn xor_dupctx;
  86 static OSSL_FUNC_kem_encapsulate_init_fn xor_init;
  87 static OSSL_FUNC_kem_encapsulate_fn xor_encapsulate;
  88 static OSSL_FUNC_kem_decapsulate_init_fn xor_init;
  89 static OSSL_FUNC_kem_decapsulate_fn xor_decapsulate;
  90
  91
  92 /*
  93  * We define 2 dummy TLS groups called "xorgroup" and "xorkemgroup" for test
  94  * purposes
  95  */
  96 struct tls_group_st {
  97     unsigned int group_id; /* for "tls-group-id", see provider-base(7) */
  98     unsigned int secbits;
  99     unsigned int mintls;
 100     unsigned int maxtls;
 101     unsigned int mindtls;
 102     unsigned int maxdtls;
 103     unsigned int is_kem; /* boolean */
 104 };
 105
 106 #define XORGROUP_NAME "xorgroup"
 107 #define XORGROUP_NAME_INTERNAL "xorgroup-int"
 108 static struct tls_group_st xor_group = {
 109     0,                  /* group_id, set by randomize_tls_group_id() */
 110     128,                /* secbits */
 111     TLS1_3_VERSION,     /* mintls */
 112     0,                  /* maxtls */
 113     -1,                 /* mindtls */
 114     -1,                 /* maxdtls */
 115     0                   /* is_kem */
 116 };
 117
 118 #define XORKEMGROUP_NAME "xorkemgroup"
 119 #define XORKEMGROUP_NAME_INTERNAL "xorkemgroup-int"
 120 static struct tls_group_st xor_kemgroup = {
 121     0,                  /* group_id, set by randomize_tls_group_id() */
 122     128,                /* secbits */
 123     TLS1_3_VERSION,     /* mintls */
 124     0,                  /* maxtls */
 125     -1,                 /* mindtls */
 126     -1,                 /* maxdtls */
 127     1                   /* is_kem */
 128 };
 129
 130 #define ALGORITHM "XOR"
 131
 132 static const OSSL_PARAM xor_group_params[] = {
 133     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME,
 134                            XORGROUP_NAME, sizeof(XORGROUP_NAME)),
 135     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL,
 136                            XORGROUP_NAME_INTERNAL,
 137                            sizeof(XORGROUP_NAME_INTERNAL)),
 138     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_ALG, ALGORITHM,
 139                            sizeof(ALGORITHM)),
 140     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_ID, &xor_group.group_id),
 141     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS,
 142                     &xor_group.secbits),
 143     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_TLS, &xor_group.mintls),
 144     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_TLS, &xor_group.maxtls),
 145     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS, &xor_group.mindtls),
 146     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS, &xor_group.maxdtls),
 147     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_IS_KEM, &xor_group.is_kem),
 148     OSSL_PARAM_END
 149 };
 150
 151 static const OSSL_PARAM xor_kemgroup_params[] = {
 152     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME,
 153                            XORKEMGROUP_NAME, sizeof(XORKEMGROUP_NAME)),
 154     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL,
 155                            XORKEMGROUP_NAME_INTERNAL,
 156                            sizeof(XORKEMGROUP_NAME_INTERNAL)),
 157     OSSL_PARAM_utf8_string(OSSL_CAPABILITY_TLS_GROUP_ALG, ALGORITHM,
 158                            sizeof(ALGORITHM)),
 159     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_ID, &xor_kemgroup.group_id),
 160     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS,
 161                     &xor_kemgroup.secbits),
 162     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_TLS, &xor_kemgroup.mintls),
 163     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_TLS, &xor_kemgroup.maxtls),
 164     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS, &xor_kemgroup.mindtls),
 165     OSSL_PARAM_int(OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS, &xor_kemgroup.maxdtls),
 166     OSSL_PARAM_uint(OSSL_CAPABILITY_TLS_GROUP_IS_KEM, &xor_kemgroup.is_kem),
 167     OSSL_PARAM_END
 168 };
 169
 170
 171 static int tls_prov_get_capabilities(void *provctx, const char *capability,
 172                                      OSSL_CALLBACK *cb, void *arg)
 173 {
 174     if (strcmp(capability, "TLS-GROUP") == 0)
 175         return cb(xor_group_params, arg)
 176             && cb(xor_kemgroup_params, arg);
 177
 178     /* We don't support this capability */
 179     return 0;
 180 }
 181
 182 /*
 183  * Dummy "XOR" Key Exchange algorithm. We just xor the private and public keys
 184  * together. Don't use this!
 185  */
 186
 187 typedef struct {
 188     XORKEY *key;
 189     XORKEY *peerkey;
 190     void *provctx;
 191 } PROV_XOR_CTX;
 192
 193 static void *xor_newctx(void *provctx)
 194 {
 195     PROV_XOR_CTX *pxorctx = OPENSSL_zalloc(sizeof(PROV_XOR_CTX));
 196
 197     if (pxorctx == NULL)
 198         return NULL;
 199
 200     pxorctx->provctx = provctx;
 201
 202     return pxorctx;
 203 }
 204
 205 static int xor_init(void *vpxorctx, void *vkey,
 206                     ossl_unused const OSSL_PARAM params[])
 207 {
 208     PROV_XOR_CTX *pxorctx = (PROV_XOR_CTX *)vpxorctx;
 209
 210     if (pxorctx == NULL || vkey == NULL)
 211         return 0;
 212     pxorctx->key = vkey;
 213     return 1;
 214 }
 215
 216 static int xor_set_peer(void *vpxorctx, void *vpeerkey)
 217 {
 218     PROV_XOR_CTX *pxorctx = (PROV_XOR_CTX *)vpxorctx;
 219
 220     if (pxorctx == NULL || vpeerkey == NULL)
 221         return 0;
 222     pxorctx->peerkey = vpeerkey;
 223     return 1;
 224 }
 225
 226 static int xor_derive(void *vpxorctx, unsigned char *secret, size_t *secretlen,
 227                       size_t outlen)
 228 {
 229     PROV_XOR_CTX *pxorctx = (PROV_XOR_CTX *)vpxorctx;
 230     int i;
 231
 232     if (pxorctx->key == NULL || pxorctx->peerkey == NULL)
 233         return 0;
 234
 235     *secretlen = XOR_KEY_SIZE;
 236     if (secret == NULL)
 237         return 1;
 238
 239     if (outlen < XOR_KEY_SIZE)
 240         return 0;
 241
 242     for (i = 0; i < XOR_KEY_SIZE; i++)
 243         secret[i] = pxorctx->key->privkey[i] ^ pxorctx->peerkey->pubkey[i];
 244
 245     return 1;
 246 }
 247
 248 static void xor_freectx(void *pxorctx)
 249 {
 250     OPENSSL_free(pxorctx);
 251 }
 252
 253 static void *xor_dupctx(void *vpxorctx)
 254 {
 255     PROV_XOR_CTX *srcctx = (PROV_XOR_CTX *)vpxorctx;
 256     PROV_XOR_CTX *dstctx;
 257
 258     dstctx = OPENSSL_zalloc(sizeof(*srcctx));
 259     if (dstctx == NULL)
 260         return NULL;
 261
 262     *dstctx = *srcctx;
 263
 264     return dstctx;
 265 }
 266
 267 static const OSSL_DISPATCH xor_keyexch_functions[] = {
 268     { OSSL_FUNC_KEYEXCH_NEWCTX, (void (*)(void))xor_newctx },
 269     { OSSL_FUNC_KEYEXCH_INIT, (void (*)(void))xor_init },
 270     { OSSL_FUNC_KEYEXCH_DERIVE, (void (*)(void))xor_derive },
 271     { OSSL_FUNC_KEYEXCH_SET_PEER, (void (*)(void))xor_set_peer },
 272     { OSSL_FUNC_KEYEXCH_FREECTX, (void (*)(void))xor_freectx },
 273     { OSSL_FUNC_KEYEXCH_DUPCTX, (void (*)(void))xor_dupctx },
 274     { 0, NULL }
 275 };
 276
 277 static const OSSL_ALGORITHM tls_prov_keyexch[] = {
 278     /*
 279      * Obviously this is not FIPS approved, but in order to test in conjuction
 280      * with the FIPS provider we pretend that it is.
 281      */
 282     { "XOR", "provider=tls-provider,fips=yes", xor_keyexch_functions },
 283     { NULL, NULL, NULL }
 284 };
 285
 286 /*
 287  * Dummy "XOR" Key Encapsulation Method. We just build a KEM over the xor KEX.
 288  * Don't use this!
 289  */
 290
 291 static int xor_encapsulate(void *vpxorctx,
 292                            unsigned char *ct, size_t *ctlen,
 293                            unsigned char *ss, size_t *sslen)
 294 {
 295     /*
 296      * We are building this around a KEX:
 297      *
 298      * 1. we generate ephemeral keypair
 299      * 2. we encode our ephemeral pubkey as the outgoing ct
 300      * 3. we derive using our ephemeral privkey in combination with the peer
 301      *    pubkey from the ctx; the result is our ss.
 302      */
 303     int rv = 0;
 304     void *genctx = NULL, *derivectx = NULL;
 305     XORKEY *ourkey = NULL;
 306     PROV_XOR_CTX *pxorctx = vpxorctx;
 307
 308     if (ct == NULL || ss == NULL) {
 309         /* Just return sizes */
 310
 311         if (ctlen == NULL && sslen == NULL)
 312             return 0;
 313         if (ctlen != NULL)
 314             *ctlen = XOR_KEY_SIZE;
 315         if (sslen != NULL)
 316             *sslen = XOR_KEY_SIZE;
 317         return 1;
 318     }
 319
 320     /* 1. Generate keypair */
 321     genctx = xor_gen_init(pxorctx->provctx, OSSL_KEYMGMT_SELECT_KEYPAIR, NULL);
 322     if (genctx == NULL)
 323         goto end;
 324     ourkey = xor_gen(genctx, NULL, NULL);
 325     if (ourkey == NULL)
 326         goto end;
 327
 328     /* 2. Encode ephemeral pubkey as ct */
 329     memcpy(ct, ourkey->pubkey, XOR_KEY_SIZE);
 330     *ctlen = XOR_KEY_SIZE;
 331
 332     /* 3. Derive ss via KEX */
 333     derivectx = xor_newctx(pxorctx->provctx);
 334     if (derivectx == NULL
 335             || !xor_init(derivectx, ourkey, NULL)
 336             || !xor_set_peer(derivectx, pxorctx->key)
 337             || !xor_derive(derivectx, ss, sslen, XOR_KEY_SIZE))
 338         goto end;
 339
 340     rv = 1;
 341
 342  end:
 343     xor_gen_cleanup(genctx);
 344     xor_freedata(ourkey);
 345     xor_freectx(derivectx);
 346     return rv;
 347 }
 348
 349 static int xor_decapsulate(void *vpxorctx,
 350                            unsigned char *ss, size_t *sslen,
 351                            const unsigned char *ct, size_t ctlen)
 352 {
 353     /*
 354      * We are building this around a KEX:
 355      *
 356      * - ct is our peer's pubkey
 357      * - decapsulate is just derive.
 358      */
 359     int rv = 0;
 360     void *derivectx = NULL;
 361     XORKEY *peerkey = NULL;
 362     PROV_XOR_CTX *pxorctx = vpxorctx;
 363
 364     if (ss == NULL) {
 365         /* Just return size */
 366         if (sslen == NULL)
 367             return 0;
 368         *sslen = XOR_KEY_SIZE;
 369         return 1;
 370     }
 371
 372     if (ctlen != XOR_KEY_SIZE)
 373         return 0;
 374     peerkey = xor_newdata(pxorctx->provctx);
 375     if (peerkey == NULL)
 376         goto end;
 377     memcpy(peerkey->pubkey, ct, XOR_KEY_SIZE);
 378
 379     /* Derive ss via KEX */
 380     derivectx = xor_newctx(pxorctx->provctx);
 381     if (derivectx == NULL
 382             || !xor_init(derivectx, pxorctx->key, NULL)
 383             || !xor_set_peer(derivectx, peerkey)
 384             || !xor_derive(derivectx, ss, sslen, XOR_KEY_SIZE))
 385         goto end;
 386
 387     rv = 1;
 388
 389  end:
 390     xor_freedata(peerkey);
 391     xor_freectx(derivectx);
 392     return rv;
 393 }
 394
 395 static const OSSL_DISPATCH xor_kem_functions[] = {
 396     { OSSL_FUNC_KEM_NEWCTX, (void (*)(void))xor_newctx },
 397     { OSSL_FUNC_KEM_FREECTX, (void (*)(void))xor_freectx },
 398     { OSSL_FUNC_KEM_DUPCTX, (void (*)(void))xor_dupctx },
 399     { OSSL_FUNC_KEM_ENCAPSULATE_INIT, (void (*)(void))xor_init },
 400     { OSSL_FUNC_KEM_ENCAPSULATE, (void (*)(void))xor_encapsulate },
 401     { OSSL_FUNC_KEM_DECAPSULATE_INIT, (void (*)(void))xor_init },
 402     { OSSL_FUNC_KEM_DECAPSULATE, (void (*)(void))xor_decapsulate },
 403     { 0, NULL }
 404 };
 405
 406 static const OSSL_ALGORITHM tls_prov_kem[] = {
 407     /*
 408      * Obviously this is not FIPS approved, but in order to test in conjuction
 409      * with the FIPS provider we pretend that it is.
 410      */
 411     { "XOR", "provider=tls-provider,fips=yes", xor_kem_functions },
 412     { NULL, NULL, NULL }
 413 };
 414
 415 /* Key Management for the dummy XOR key exchange algorithm */
 416
 417 static void *xor_newdata(void *provctx)
 418 {
 419     return OPENSSL_zalloc(sizeof(XORKEY));
 420 }
 421
 422 static void xor_freedata(void *keydata)
 423 {
 424     OPENSSL_free(keydata);
 425 }
 426
 427 static int xor_has(const void *vkey, int selection)
 428 {
 429     const XORKEY *key = vkey;
 430     int ok = 0;
 431
 432     if (key != NULL) {
 433         ok = 1;
 434
 435         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
 436             ok = ok && key->haspubkey;
 437         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0)
 438             ok = ok && key->hasprivkey;
 439     }
 440     return ok;
 441 }
 442
 443 static int xor_copy(void *vtokey, const void *vfromkey, int selection)
 444 {
 445     XORKEY *tokey = vtokey;
 446     const XORKEY *fromkey = vfromkey;
 447     int ok = 0;
 448
 449     if (tokey != NULL && fromkey != NULL) {
 450         ok = 1;
 451
 452         if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
 453             if (fromkey->haspubkey) {
 454                 memcpy(tokey->pubkey, fromkey->pubkey, XOR_KEY_SIZE);
 455                 tokey->haspubkey = 1;
 456             } else {
 457                 tokey->haspubkey = 0;
 458             }
 459         }
 460         if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
 461             if (fromkey->hasprivkey) {
 462                 memcpy(tokey->privkey, fromkey->privkey, XOR_KEY_SIZE);
 463                 tokey->hasprivkey = 1;
 464             } else {
 465                 tokey->hasprivkey = 0;
 466             }
 467         }
 468     }
 469     return ok;
 470 }
 471
 472 static ossl_inline int xor_get_params(void *vkey, OSSL_PARAM params[])
 473 {
 474     XORKEY *key = vkey;
 475     OSSL_PARAM *p;
 476
 477     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
 478         && !OSSL_PARAM_set_int(p, XOR_KEY_SIZE))
 479         return 0;
 480
 481     if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
 482         && !OSSL_PARAM_set_int(p, xor_group.secbits))
 483         return 0;
 484
 485     if ((p = OSSL_PARAM_locate(params,
 486                                OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY)) != NULL) {
 487         if (p->data_type != OSSL_PARAM_OCTET_STRING)
 488             return 0;
 489         p->return_size = XOR_KEY_SIZE;
 490         if (p->data != NULL && p->data_size >= XOR_KEY_SIZE)
 491             memcpy(p->data, key->pubkey, XOR_KEY_SIZE);
 492     }
 493
 494     return 1;
 495 }
 496
 497 static const OSSL_PARAM xor_params[] = {
 498     OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
 499     OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
 500     OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
 501     OSSL_PARAM_END
 502 };
 503
 504 static const OSSL_PARAM *xor_gettable_params(void *provctx)
 505 {
 506     return xor_params;
 507 }
 508
 509 static int xor_set_params(void *vkey, const OSSL_PARAM params[])
 510 {
 511     XORKEY *key = vkey;
 512     const OSSL_PARAM *p;
 513
 514     p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY);
 515     if (p != NULL) {
 516         if (p->data_type != OSSL_PARAM_OCTET_STRING
 517                 || p->data_size != XOR_KEY_SIZE)
 518             return 0;
 519         memcpy(key->pubkey, p->data, XOR_KEY_SIZE);
 520         key->haspubkey = 1;
 521     }
 522
 523     return 1;
 524 }
 525
 526 static const OSSL_PARAM xor_known_settable_params[] = {
 527     OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
 528     OSSL_PARAM_END
 529 };
 530
 531 static const OSSL_PARAM *xor_settable_params(void *provctx)
 532 {
 533     return xor_known_settable_params;
 534 }
 535
 536 struct xor_gen_ctx {
 537     int selection;
 538     OSSL_LIB_CTX *libctx;
 539 };
 540
 541 static void *xor_gen_init(void *provctx, int selection,
 542                           const OSSL_PARAM params[])
 543 {
 544     struct xor_gen_ctx *gctx = NULL;
 545
 546     if ((selection & (OSSL_KEYMGMT_SELECT_KEYPAIR
 547                       | OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS)) == 0)
 548         return NULL;
 549
 550     if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL)
 551         gctx->selection = selection;
 552
 553     /* Our provctx is really just an OSSL_LIB_CTX */
 554     gctx->libctx = (OSSL_LIB_CTX *)provctx;
 555
 556     if (!xor_gen_set_params(gctx, params)) {
 557         OPENSSL_free(gctx);
 558         return NULL;
 559     }
 560     return gctx;
 561 }
 562
 563 static int xor_gen_set_params(void *genctx, const OSSL_PARAM params[])
 564 {
 565     struct xor_gen_ctx *gctx = genctx;
 566     const OSSL_PARAM *p;
 567
 568     if (gctx == NULL)
 569         return 0;
 570
 571     p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_GROUP_NAME);
 572     if (p != NULL) {
 573         if (p->data_type != OSSL_PARAM_UTF8_STRING
 574                 || (strcmp(p->data, XORGROUP_NAME_INTERNAL) != 0
 575                     &&  strcmp(p->data, XORKEMGROUP_NAME_INTERNAL) != 0))
 576             return 0;
 577     }
 578
 579     return 1;
 580 }
 581
 582 static const OSSL_PARAM *xor_gen_settable_params(ossl_unused void *genctx,
 583                                                  ossl_unused void *provctx)
 584 {
 585     static OSSL_PARAM settable[] = {
 586         OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
 587         OSSL_PARAM_END
 588     };
 589     return settable;
 590 }
 591
 592 static void *xor_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)
 593 {
 594     struct xor_gen_ctx *gctx = genctx;
 595     XORKEY *key = OPENSSL_zalloc(sizeof(*key));
 596     size_t i;
 597
 598     if (key == NULL)
 599         return NULL;
 600
 601     if ((gctx->selection & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0) {
 602         if (RAND_bytes_ex(gctx->libctx, key->privkey, XOR_KEY_SIZE) <= 0) {
 603             OPENSSL_free(key);
 604             return NULL;
 605         }
 606         for (i = 0; i < XOR_KEY_SIZE; i++)
 607             key->pubkey[i] = key->privkey[i] ^ private_constant[i];
 608         key->hasprivkey = 1;
 609         key->haspubkey = 1;
 610     }
 611
 612     return key;
 613 }
 614
 615 /* IMPORT + EXPORT */
 616
 617 static int xor_import(void *vkey, int select, const OSSL_PARAM params[])
 618 {
 619     XORKEY *key = vkey;
 620     const OSSL_PARAM *param_priv_key, *param_pub_key;
 621     unsigned char privkey[XOR_KEY_SIZE];
 622     unsigned char pubkey[XOR_KEY_SIZE];
 623     void *pprivkey = privkey, *ppubkey = pubkey;
 624     size_t priv_len = 0, pub_len = 0;
 625     int res = 0;
 626
 627     if (key == NULL || (select & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
 628         return 0;
 629
 630     memset(privkey, 0, sizeof(privkey));
 631     memset(pubkey, 0, sizeof(pubkey));
 632     param_priv_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
 633     param_pub_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
 634
 635     if ((param_priv_key != NULL
 636          && !OSSL_PARAM_get_octet_string(param_priv_key, &pprivkey,
 637                                          sizeof(privkey), &priv_len))
 638         || (param_pub_key != NULL
 639             && !OSSL_PARAM_get_octet_string(param_pub_key, &ppubkey,
 640                                             sizeof(pubkey), &pub_len)))
 641         goto err;
 642
 643     if (priv_len > 0) {
 644         memcpy(key->privkey, privkey, priv_len);
 645         key->hasprivkey = 1;
 646     }
 647     if (pub_len > 0) {
 648         memcpy(key->pubkey, pubkey, pub_len);
 649         key->haspubkey = 1;
 650     }
 651     res = 1;
 652  err:
 653     return res;
 654 }
 655
 656 static int xor_export(void *vkey, int select, OSSL_CALLBACK *param_cb,
 657                       void *cbarg)
 658 {
 659     XORKEY *key = vkey;
 660     OSSL_PARAM params[3], *p = params;
 661
 662     if (key == NULL || (select & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
 663         return 0;
 664
 665     *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PRIV_KEY,
 666                                              key->privkey,
 667                                              sizeof(key->privkey));
 668     *p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_PUB_KEY,
 669                                              key->pubkey, sizeof(key->pubkey));
 670     *p++ = OSSL_PARAM_construct_end();
 671
 672     return param_cb(params, cbarg);
 673 }
 674
 675 static const OSSL_PARAM xor_key_types[] = {
 676     OSSL_PARAM_BN(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
 677     OSSL_PARAM_BN(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
 678     OSSL_PARAM_END
 679 };
 680
 681 static const OSSL_PARAM *xor_import_types(int select)
 682 {
 683     return (select & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0 ? xor_key_types : NULL;
 684 }
 685
 686 static const OSSL_PARAM *xor_export_types(int select)
 687 {
 688     return (select & OSSL_KEYMGMT_SELECT_KEYPAIR) != 0 ? xor_key_types : NULL;
 689 }
 690
 691 static void xor_gen_cleanup(void *genctx)
 692 {
 693     OPENSSL_free(genctx);
 694 }
 695
 696 static const OSSL_DISPATCH xor_keymgmt_functions[] = {
 697     { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))xor_newdata },
 698     { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))xor_gen_init },
 699     { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, (void (*)(void))xor_gen_set_params },
 700     { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,
 701       (void (*)(void))xor_gen_settable_params },
 702     { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))xor_gen },
 703     { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))xor_gen_cleanup },
 704     { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))xor_get_params },
 705     { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))xor_gettable_params },
 706     { OSSL_FUNC_KEYMGMT_SET_PARAMS, (void (*) (void))xor_set_params },
 707     { OSSL_FUNC_KEYMGMT_SETTABLE_PARAMS, (void (*) (void))xor_settable_params },
 708     { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))xor_has },
 709     { OSSL_FUNC_KEYMGMT_COPY, (void (*)(void))xor_copy },
 710     { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))xor_freedata },
 711     { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))xor_import },
 712     { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))xor_import_types },
 713     { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))xor_export },
 714     { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))xor_export_types },
 715     { 0, NULL }
 716 };
 717
 718 static const OSSL_ALGORITHM tls_prov_keymgmt[] = {
 719     /*
 720      * Obviously this is not FIPS approved, but in order to test in conjuction
 721      * with the FIPS provider we pretend that it is.
 722      */
 723     { "XOR", "provider=tls-provider,fips=yes", xor_keymgmt_functions },
 724     { NULL, NULL, NULL }
 725 };
 726
 727 static const OSSL_ALGORITHM *tls_prov_query(void *provctx, int operation_id,
 728                                             int *no_cache)
 729 {
 730     *no_cache = 0;
 731     switch (operation_id) {
 732     case OSSL_OP_KEYMGMT:
 733         return tls_prov_keymgmt;
 734     case OSSL_OP_KEYEXCH:
 735         return tls_prov_keyexch;
 736     case OSSL_OP_KEM:
 737         return tls_prov_kem;
 738     }
 739     return NULL;
 740 }
 741
 742 /* Functions we provide to the core */
 743 static const OSSL_DISPATCH tls_prov_dispatch_table[] = {
 744     { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OSSL_LIB_CTX_free },
 745     { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))tls_prov_query },
 746     { OSSL_FUNC_PROVIDER_GET_CAPABILITIES, (void (*)(void))tls_prov_get_capabilities },
 747     { 0, NULL }
 748 };
 749
 750 static
 751 unsigned int randomize_tls_group_id(OSSL_LIB_CTX *libctx)
 752 {
 753     /*
 754      * Randomise the group_id we're going to use to ensure we don't interoperate
 755      * with anything but ourselves.
 756      */
 757     unsigned int group_id;
 758     static unsigned int mem[10] = { 0 };
 759     static int in_mem = 0;
 760     int i;
 761
 762  retry:
 763     if (!RAND_bytes_ex(libctx, (unsigned char *)&group_id, sizeof(group_id)))
 764         return 0;
 765     /*
 766      * Ensure group_id is within the IANA Reserved for private use range
 767      * (65024-65279)
 768      */
 769     group_id %= 65279 - 65024;
 770     group_id += 65024;
 771
 772     /* Ensure we did not already issue this group_id */
 773     for (i = 0; i < in_mem; i++)
 774         if (mem[i] == group_id)
 775             goto retry;
 776
 777     /* Add this group_id to the list of ids issued by this function */
 778     mem[in_mem++] = group_id;
 779
 780     return group_id;
 781 }
 782
 783 int tls_provider_init(const OSSL_CORE_HANDLE *handle,
 784                       const OSSL_DISPATCH *in,
 785                       const OSSL_DISPATCH **out,
 786                       void **provctx)
 787 {
 788     OSSL_LIB_CTX *libctx = OSSL_LIB_CTX_new();
 789
 790     *provctx = libctx;
 791
 792     /*
 793      * Randomise the group_id we're going to use to ensure we don't interoperate
 794      * with anything but ourselves.
 795      */
 796     xor_group.group_id = randomize_tls_group_id(libctx);
 797     xor_kemgroup.group_id = randomize_tls_group_id(libctx);
 798
 799     *out = tls_prov_dispatch_table;
 800     return 1;
 801 }