luna - wolfssl/linuxkm/lkcapi_dh

   1/* lkcapi_dh_glue.c -- glue logic to register dh and ffdhe wolfCrypt
   2 * implementations with the Linux Kernel Cryptosystem
   3 *
   4 * Copyright (C) 2006-2026 wolfSSL Inc.
   5 *
   6 * This file is part of wolfSSL.
   7 *
   8 * wolfSSL is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 3 of the License, or
  11 * (at your option) any later version.
  12 *
  13 * wolfSSL is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  21 */
  22
  23/* included by linuxkm/lkcapi_glue.c */
  24#ifndef WC_SKIP_INCLUDED_C_FILES
  25
  26#ifndef LINUXKM_LKCAPI_REGISTER
  27    #error lkcapi_dh_glue.c included in non-LINUXKM_LKCAPI_REGISTER project.
  28#endif
  29
  30#if (defined(LINUXKM_LKCAPI_REGISTER_ALL) || \
  31     (defined(LINUXKM_LKCAPI_REGISTER_ALL_KCONFIG) && defined(CONFIG_CRYPTO_DH))) && \
  32    !defined(LINUXKM_LKCAPI_DONT_REGISTER_DH) &&  \
  33    !defined(LINUXKM_LKCAPI_REGISTER_DH)
  34    #define LINUXKM_LKCAPI_REGISTER_DH
  35    #define LINUXKM_DH
  36#endif
  37
  38#if defined(LINUXKM_LKCAPI_REGISTER_DH) && \
  39    !defined(WOLFSSL_DH_EXTRA)
  40     /* not supported without WOLFSSL_DH_EXTRA */
  41    #undef LINUXKM_LKCAPI_REGISTER_DH
  42
  43    #if defined(LINUXKM_LKCAPI_REGISTER_ALL_KCONFIG) && defined(CONFIG_CRYPTO_DH)
  44        #error Config conflict: missing features force off LINUXKM_LKCAPI_REGISTER_DH.
  45    #endif
  46#endif /* LINUXKM_LKCAPI_REGISTER_DH */
  47
  48#if defined (LINUXKM_LKCAPI_REGISTER_DH) && defined(CONFIG_CRYPTO_FIPS) && \
  49    defined(CONFIG_CRYPTO_MANAGER)
  50        /*
  51         * note: normal dh not fips_allowed in kernel crypto/testmgr.c,
  52         * and will not pass the tests.
  53         */
  54        #undef LINUXKM_DH
  55#endif /* LINUXKM_LKCAPI_REGISTER_DH */
  56
  57#ifdef NO_DH
  58    #undef LINUXKM_LKCAPI_REGISTER_DH
  59#endif
  60
  61#if (LINUX_VERSION_CODE < KERNEL_VERSION(5, 18, 0)) &&                  \
  62    !(defined(RHEL_MAJOR) &&                                            \
  63      ((RHEL_MAJOR > 9) || ((RHEL_MAJOR == 9) && (RHEL_MINOR >= 5))))
  64
  65    /* Support for FFDHE was added in kernel 5.18, and generic DH support
  66     * pre-5.18 used a different binary format for the secret (an additional
  67     * slot for q).
  68     *
  69     * LTS backports of FFDHE go as far back as 4.14.236, using the pre-5.18
  70     * binary layout, but other backports, e.g. RHEL 9.5 on kernel
  71     * 5.14.0-503.40.1, have the 5.18+ layout.  Best to disable on all pre-5.18
  72     * and triage as/if necessary.
  73     */
  74    #undef LINUXKM_LKCAPI_REGISTER_DH
  75#endif
  76
  77#if defined(LINUXKM_LKCAPI_REGISTER_ALL_KCONFIG) && \
  78    (defined(CONFIG_CRYPTO_DH) || defined(CONFIG_CRYPTO_DH_RFC7919_GROUPS)) && \
  79    !defined(LINUXKM_LKCAPI_REGISTER_DH) && \
  80    !defined(LINUXKM_LKCAPI_DONT_REGISTER_DH)
  81    #error Config conflict: target kernel has CONFIG_CRYPTO_DH and/or \
  82        _DH_RFC7919_GROUPS, but module is missing LINUXKM_LKCAPI_REGISTER_DH.
  83#endif
  84
  85#if defined(LINUXKM_LKCAPI_REGISTER_DH)
  86
  87#include <wolfssl/wolfcrypt/asn.h>
  88#include <wolfssl/wolfcrypt/dh.h>
  89#include <crypto/dh.h>
  90
  91#define WOLFKM_DH_NAME    ("dh")
  92#define WOLFKM_DH_DRIVER  ("dh" WOLFKM_DRIVER_FIPS \
  93                           "-wolfcrypt")
  94
  95#ifdef HAVE_FFDHE_2048
  96    #define WOLFKM_FFDHE2048_NAME   ("ffdhe2048(dh)")
  97    #define WOLFKM_FFDHE2048_DRIVER ("ffdhe2048" WOLFKM_DRIVER_FIPS \
  98                                     "-wolfcrypt")
  99#endif /* HAVE_FFDHE_2048 */
 100
 101#ifdef HAVE_FFDHE_3072
 102    #define WOLFKM_FFDHE3072_NAME   ("ffdhe3072(dh)")
 103    #define WOLFKM_FFDHE3072_DRIVER ("ffdhe3072" WOLFKM_DRIVER_FIPS \
 104                                     "-wolfcrypt")
 105#endif /* HAVE_FFDHE_3072 */
 106
 107#ifdef HAVE_FFDHE_4096
 108    #define WOLFKM_FFDHE4096_NAME   ("ffdhe4096(dh)")
 109    #define WOLFKM_FFDHE4096_DRIVER ("ffdhe4096" WOLFKM_DRIVER_FIPS \
 110                                     "-wolfcrypt")
 111#endif /* HAVE_FFDHE_4096 */
 112
 113#ifdef HAVE_FFDHE_6144
 114    #define WOLFKM_FFDHE6144_NAME   ("ffdhe6144(dh)")
 115    #define WOLFKM_FFDHE6144_DRIVER ("ffdhe6144" WOLFKM_DRIVER_FIPS \
 116                                     "-wolfcrypt")
 117#endif /* HAVE_FFDHE_6144 */
 118
 119#ifdef HAVE_FFDHE_8192
 120    #define WOLFKM_FFDHE8192_NAME   ("ffdhe8192(dh)")
 121    #define WOLFKM_FFDHE8192_DRIVER ("ffdhe8192" WOLFKM_DRIVER_FIPS \
 122                                     "-wolfcrypt")
 123#endif /* HAVE_FFDHE_8192 */
 124
 125static int linuxkm_test_kpp_driver(const char * driver,
 126                                   const byte * b_pub,
 127                                   const byte * expected_a_pub,
 128                                   word32 pub_len,
 129                                   const byte * secret,
 130                                   word32 secret_len,
 131                                   const byte * shared_secret,
 132                                   word32 shared_s_len);
 133
 134#ifdef LINUXKM_DH
 135static int dh_loaded = 0;
 136#endif /* LINUXKM_DH */
 137#ifdef HAVE_FFDHE_2048
 138static int ffdhe2048_loaded = 0;
 139#endif /* HAVE_FFDHE_2048 */
 140#ifdef HAVE_FFDHE_3072
 141static int ffdhe3072_loaded = 0;
 142#endif /* HAVE_FFDHE_3072 */
 143#ifdef HAVE_FFDHE_4096
 144static int ffdhe4096_loaded = 0;
 145#endif /* HAVE_FFDHE_4096 */
 146#ifdef HAVE_FFDHE_6144
 147static int ffdhe6144_loaded = 0;
 148#endif /* HAVE_FFDHE_6144 */
 149#ifdef HAVE_FFDHE_8192
 150static int ffdhe8192_loaded = 0;
 151#endif /* HAVE_FFDHE_8192 */
 152
 153struct km_dh_ctx {
 154    WC_RNG   rng; /* needed for keypair gen and timing resistance*/
 155    DhKey *  key;
 156    byte *   priv_key;
 157    byte *   pub_key;
 158    int      name; /* the finite-field group name */
 159    word32   nbits;
 160    word32   priv_len;
 161    word32   pub_len;
 162    byte     has_pub_key;
 163};
 164
 165/* shared misc functions */
 166static int          km_dh_decode_secret(const u8 * buf, unsigned int len,
 167                                        struct dh * params);
 168static int          km_dh_alloc_keys(struct km_dh_ctx * ctx);
 169static int          km_dh_reset_ctx(struct km_dh_ctx * ctx);
 170static int          km_ffdhe_init(struct crypto_kpp *tfm, int name,
 171                                  word32 nbits);
 172
 173/* shared callbacks */
 174static unsigned int km_dh_max_size(struct crypto_kpp *tfm);
 175static int          km_dh_gen_pub(struct kpp_request *req);
 176static int          km_dh_compute_shared_secret(struct kpp_request *req);
 177static void         km_dh_exit(struct crypto_kpp *tfm);
 178
 179/* alg specific callbacks */
 180#ifdef LINUXKM_DH
 181static int          km_dh_init(struct crypto_kpp *tfm);
 182static int          km_dh_set_secret(struct crypto_kpp *tfm, const void *buf,
 183                                     unsigned int len);
 184#endif /* LINUXKM_DH */
 185static int          km_ffdhe_set_secret(struct crypto_kpp *tfm,
 186                                        const void *buf, unsigned int len);
 187#ifdef HAVE_FFDHE_2048
 188static int          km_ffdhe2048_init(struct crypto_kpp *tfm);
 189#endif /* HAVE_FFDHE_2048 */
 190#ifdef HAVE_FFDHE_3072
 191static int          km_ffdhe3072_init(struct crypto_kpp *tfm);
 192#endif /* HAVE_FFDHE_3072 */
 193#ifdef HAVE_FFDHE_4096
 194static int          km_ffdhe4096_init(struct crypto_kpp *tfm);
 195#endif /* HAVE_FFDHE_4096 */
 196#ifdef HAVE_FFDHE_6144
 197static int          km_ffdhe6144_init(struct crypto_kpp *tfm);
 198#endif /* HAVE_FFDHE_6144 */
 199#ifdef HAVE_FFDHE_8192
 200static int          km_ffdhe8192_init(struct crypto_kpp *tfm);
 201#endif /* HAVE_FFDHE_8192 */
 202
 203#ifdef LINUXKM_DH
 204static struct kpp_alg dh = {
 205    .base.cra_name         = WOLFKM_DH_NAME,
 206    .base.cra_driver_name  = WOLFKM_DH_DRIVER,
 207    .base.cra_priority     = WOLFSSL_LINUXKM_LKCAPI_PRIORITY,
 208    .base.cra_module       = THIS_MODULE,
 209    .base.cra_ctxsize      = sizeof(struct km_dh_ctx),
 210    .set_secret            = km_dh_set_secret,
 211    .generate_public_key   = km_dh_gen_pub,
 212    .compute_shared_secret = km_dh_compute_shared_secret,
 213    .max_size              = km_dh_max_size,
 214    .init                  = km_dh_init,
 215    .exit                  = km_dh_exit,
 216};
 217#endif /* LINUXKM_DH */
 218
 219#ifdef HAVE_FFDHE_2048
 220static struct kpp_alg ffdhe2048 = {
 221    .base.cra_name         = WOLFKM_FFDHE2048_NAME,
 222    .base.cra_driver_name  = WOLFKM_FFDHE2048_DRIVER,
 223    .base.cra_priority     = WOLFSSL_LINUXKM_LKCAPI_PRIORITY,
 224    .base.cra_module       = THIS_MODULE,
 225    .base.cra_ctxsize      = sizeof(struct km_dh_ctx),
 226    .set_secret            = km_ffdhe_set_secret,
 227    .generate_public_key   = km_dh_gen_pub,
 228    .compute_shared_secret = km_dh_compute_shared_secret,
 229    .max_size              = km_dh_max_size,
 230    .init                  = km_ffdhe2048_init,
 231    .exit                  = km_dh_exit,
 232};
 233#endif /* HAVE_FFDHE_2048 */
 234
 235#ifdef HAVE_FFDHE_3072
 236static struct kpp_alg ffdhe3072 = {
 237    .base.cra_name         = WOLFKM_FFDHE3072_NAME,
 238    .base.cra_driver_name  = WOLFKM_FFDHE3072_DRIVER,
 239    .base.cra_priority     = WOLFSSL_LINUXKM_LKCAPI_PRIORITY,
 240    .base.cra_module       = THIS_MODULE,
 241    .base.cra_ctxsize      = sizeof(struct km_dh_ctx),
 242    .set_secret            = km_ffdhe_set_secret,
 243    .generate_public_key   = km_dh_gen_pub,
 244    .compute_shared_secret = km_dh_compute_shared_secret,
 245    .max_size              = km_dh_max_size,
 246    .init                  = km_ffdhe3072_init,
 247    .exit                  = km_dh_exit,
 248};
 249#endif /* HAVE_FFDHE_3072 */
 250
 251#ifdef HAVE_FFDHE_4096
 252static struct kpp_alg ffdhe4096 = {
 253    .base.cra_name         = WOLFKM_FFDHE4096_NAME,
 254    .base.cra_driver_name  = WOLFKM_FFDHE4096_DRIVER,
 255    .base.cra_priority     = WOLFSSL_LINUXKM_LKCAPI_PRIORITY,
 256    .base.cra_module       = THIS_MODULE,
 257    .base.cra_ctxsize      = sizeof(struct km_dh_ctx),
 258    .set_secret            = km_ffdhe_set_secret,
 259    .generate_public_key   = km_dh_gen_pub,
 260    .compute_shared_secret = km_dh_compute_shared_secret,
 261    .max_size              = km_dh_max_size,
 262    .init                  = km_ffdhe4096_init,
 263    .exit                  = km_dh_exit,
 264};
 265#endif /* HAVE_FFDHE_4096 */
 266
 267#ifdef HAVE_FFDHE_6144
 268static struct kpp_alg ffdhe6144 = {
 269    .base.cra_name         = WOLFKM_FFDHE6144_NAME,
 270    .base.cra_driver_name  = WOLFKM_FFDHE6144_DRIVER,
 271    .base.cra_priority     = WOLFSSL_LINUXKM_LKCAPI_PRIORITY,
 272    .base.cra_module       = THIS_MODULE,
 273    .base.cra_ctxsize      = sizeof(struct km_dh_ctx),
 274    .set_secret            = km_ffdhe_set_secret,
 275    .generate_public_key   = km_dh_gen_pub,
 276    .compute_shared_secret = km_dh_compute_shared_secret,
 277    .max_size              = km_dh_max_size,
 278    .init                  = km_ffdhe6144_init,
 279    .exit                  = km_dh_exit,
 280};
 281#endif /* HAVE_FFDHE_6144 */
 282
 283#ifdef HAVE_FFDHE_8192
 284static struct kpp_alg ffdhe8192 = {
 285    .base.cra_name         = WOLFKM_FFDHE8192_NAME,
 286    .base.cra_driver_name  = WOLFKM_FFDHE8192_DRIVER,
 287    .base.cra_priority     = WOLFSSL_LINUXKM_LKCAPI_PRIORITY,
 288    .base.cra_module       = THIS_MODULE,
 289    .base.cra_ctxsize      = sizeof(struct km_dh_ctx),
 290    .set_secret            = km_ffdhe_set_secret,
 291    .generate_public_key   = km_dh_gen_pub,
 292    .compute_shared_secret = km_dh_compute_shared_secret,
 293    .max_size              = km_dh_max_size,
 294    .init                  = km_ffdhe8192_init,
 295    .exit                  = km_dh_exit,
 296};
 297#endif /* HAVE_FFDHE_8192 */
 298
 299/* The DH secret is passed in this format:
 300 *    ______________________________________________________________________
 301 *   | secret hdr          | key_size | p_size | g_size |  key  |  p  |  g  |
 302 *   | (struct kpp_secret) | (int)    | (int)  | (int)  |       |     |     |
 303 *    ----------------------------------------------------------------------
 304 *
 305 * normal dh:
 306 *   - the key, p, g must all be provided.
 307 *
 308 * ffdhe:
 309 *   - p, g must be empty.
 310 *   - the key is optional.
 311 *
 312 * The key_size, p_size, g_size fields are always provided, even if zero.
 313 * */
 314#define DH_KPP_SECRET_MIN_SIZE (sizeof(struct kpp_secret) + 3 * sizeof(int))
 315
 316static int km_dh_decode_secret(const u8 * buf, unsigned int len,
 317                               struct dh * params)
 318{
 319    struct kpp_secret secret;
 320    const u8 *        ptr = NULL;
 321    size_t            expected_len = 0;
 322
 323    if (unlikely(!buf || len < DH_KPP_SECRET_MIN_SIZE || !params)) {
 324        return -EINVAL;
 325    }
 326
 327    /* the type of secret should be the first byte. */
 328    ptr = buf;
 329    memcpy(&secret, ptr, sizeof(secret));
 330    ptr += sizeof(secret);
 331    if (secret.type != CRYPTO_KPP_SECRET_TYPE_DH) {
 332        return -EINVAL;
 333    }
 334
 335    /* all three of these fields will be present */
 336    memcpy(&params->key_size, ptr, sizeof(params->key_size));
 337    ptr += sizeof(params->key_size);
 338    memcpy(&params->p_size, ptr, sizeof(params->p_size));
 339    ptr += sizeof(params->p_size);
 340    memcpy(&params->g_size, ptr, sizeof(params->g_size));
 341    ptr += sizeof(params->g_size);
 342
 343    /* Calculate expected len based on provided 3 fields. Verify
 344     * we got expected data. */
 345    expected_len = DH_KPP_SECRET_MIN_SIZE + params->key_size + params->p_size
 346                 + params->g_size;
 347
 348    if (secret.len != expected_len) {
 349        #ifdef WOLFKM_DEBUG_DH
 350        pr_err("%s: km_dh_decode_secret: got %d, expected %zu\n",
 351               WOLFKM_DH_DRIVER, secret.len, expected_len);
 352        #endif /* WOLFKM_DEBUG_DH */
 353        return -EINVAL;
 354    }
 355
 356    /* The rest of the fields are optional depending on how much data
 357     * was passed, and whether it's ffdhe or dh. */
 358    if (params->key_size) {
 359        params->key = (void *)ptr;
 360
 361        if (params->p_size && params->g_size) {
 362            ptr += params->key_size;
 363            params->p = (void *)ptr;
 364            params->g = (void *)(ptr + params->p_size);
 365        }
 366    }
 367
 368    return 0;
 369}
 370
 371static inline void km_dh_clear_keys(struct km_dh_ctx * ctx)
 372{
 373    if (ctx->priv_key) {
 374        ForceZero(ctx->priv_key, ctx->priv_len);
 375        free(ctx->priv_key);
 376        ctx->priv_key = NULL;
 377        ctx->priv_len = 0;
 378    }
 379
 380    if (ctx->pub_key) {
 381        free(ctx->pub_key);
 382        ctx->pub_key = NULL;
 383        ctx->pub_len = 0;
 384    }
 385
 386    return;
 387}
 388
 389static int km_dh_alloc_keys(struct km_dh_ctx * ctx)
 390{
 391    int err = 0;
 392
 393    /* allocate priv and pub key arrays. */
 394    ctx->priv_len = ctx->nbits / WOLFSSL_BIT_SIZE;
 395    ctx->pub_len = ctx->nbits / WOLFSSL_BIT_SIZE;
 396
 397    ctx->priv_key = malloc(ctx->priv_len);
 398    if (!ctx->priv_key) {
 399        err = -ENOMEM;
 400        goto alloc_keys_end;
 401    }
 402
 403    memset(ctx->priv_key, 0, ctx->priv_len);
 404
 405    ctx->pub_key = malloc(ctx->pub_len);
 406    if (!ctx->pub_key) {
 407        err = -ENOMEM;
 408        goto alloc_keys_end;
 409    }
 410
 411    memset(ctx->pub_key, 0, ctx->pub_len);
 412
 413alloc_keys_end:
 414    if (err) {
 415        #ifdef WOLFKM_DEBUG_DH
 416        pr_err("%s: km_dh_alloc_keys failed: %d\n",
 417               WOLFKM_DH_DRIVER, err);
 418        #endif
 419        km_dh_clear_keys(ctx);
 420    }
 421
 422    return err;
 423}
 424
 425static int km_dh_reset_ctx(struct km_dh_ctx * ctx)
 426{
 427    int err = 0;
 428
 429    /* reset old dh key. */
 430    if (ctx->priv_key) {
 431        wc_FreeDhKey(ctx->key);
 432        err = wc_InitDhKey(ctx->key);
 433
 434        if (unlikely(err)) {
 435            err = -ENOMEM;
 436            goto reset_ctx_end;
 437        }
 438
 439        if (ctx->name) {
 440            err = wc_DhSetNamedKey(ctx->key, ctx->name);
 441            if (err) {
 442                #ifdef WOLFKM_DEBUG_DH
 443                pr_err("%s: wc_DhSetNamedKey returned: %d\n", WOLFKM_DH_DRIVER,
 444                       err);
 445                #endif /* WOLFKM_DEBUG_DH */
 446                err = -ENOMEM;
 447                goto reset_ctx_end;
 448            }
 449        }
 450    }
 451
 452reset_ctx_end:
 453    /* clear old priv and public key arrays. */
 454    km_dh_clear_keys(ctx);
 455
 456    return err;
 457}
 458
 459#ifdef LINUXKM_DH
 460/**
 461 * Set the secret. Kernel crypto expects secret is passed with
 462 * struct kpp_secret as header, followed by secret data as payload.
 463 * See these for more info:
 464 *  - crypto/dh_helper.c
 465 *  - include/crypto/kpp.h
 466 *
 467 * dh does not accept an empty payload, unlike ffdhe, and ecdh.
 468 * */
 469static int km_dh_set_secret(struct crypto_kpp *tfm, const void *buf,
 470                            unsigned int len)
 471{
 472    int                err = -1;
 473    struct km_dh_ctx * ctx = NULL;
 474    struct dh          params;
 475
 476    ctx = kpp_tfm_ctx(tfm);
 477    memset(&params, 0, sizeof(params));
 478
 479    if (km_dh_decode_secret(buf, len, &params) < 0) {
 480        #ifdef WOLFKM_DEBUG_DH
 481        pr_err("%s: dh_set_secret: decode secret failed: %d\n",
 482               WOLFKM_DH_DRIVER, params.key_size);
 483        #endif /* WOLFKM_DEBUG_DH */
 484        err = -EINVAL;
 485        goto dh_secret_end;
 486    }
 487
 488    /* the key, p, and g, must all be provided for normal dh. */
 489    if (!params.key || !params.key_size || !params.p_size || !params.g_size) {
 490        #ifdef WOLFKM_DEBUG_DH
 491        pr_err("%s: dh_set_secret: empty params\n", WOLFKM_DH_DRIVER);
 492        #endif
 493        err = -EINVAL;
 494        goto dh_secret_end;
 495    }
 496
 497    if (params.key_size > params.p_size || params.g_size > params.p_size) {
 498        #ifdef WOLFKM_DEBUG_DH
 499        pr_err("%s: dh_set_secret: invalid params\n", WOLFKM_DH_DRIVER);
 500        #endif
 501        err = -EINVAL;
 502        goto dh_secret_end;
 503    }
 504
 505    err = km_dh_reset_ctx(ctx);
 506    if (err) {
 507        goto dh_secret_end;
 508    }
 509
 510    err = km_dh_alloc_keys(ctx);
 511    if (err) {
 512        goto dh_secret_end;
 513    }
 514
 515    /* set dh params */
 516    err = wc_DhSetKey(ctx->key, params.p, params.p_size,
 517                      params.g, params.g_size);
 518
 519    if (err) {
 520        #ifdef WOLFKM_DEBUG_DH
 521        pr_err("%s: wc_DhSetKey failed: %d\n", WOLFKM_DH_DRIVER, err);
 522        #endif
 523        err = -EINVAL;
 524        goto dh_secret_end;
 525    }
 526
 527    /* import private key */
 528    err = wc_DhImportKeyPair(ctx->key, params.key, params.key_size,
 529                             NULL, 0);
 530
 531    if (err) {
 532        #ifdef WOLFKM_DEBUG_DH
 533        pr_err("%s: wc_DhImportKeyPair failed: %d\n", WOLFKM_DH_DRIVER, err);
 534        #endif
 535        err = -EINVAL;
 536        goto dh_secret_end;
 537    }
 538
 539    err = wc_DhExportKeyPair(ctx->key, ctx->priv_key, &ctx->priv_len,
 540                             NULL, NULL);
 541
 542    if (err) {
 543        #ifdef WOLFKM_DEBUG_DH
 544        pr_err("%s: wc_DhExportKeyPair failed: %d\n",
 545               WOLFKM_DH_DRIVER, err);
 546        #endif
 547        err = -EINVAL;
 548        goto dh_secret_end;
 549    }
 550
 551    ctx->has_pub_key = 0;
 552dh_secret_end:
 553
 554    #ifdef WOLFKM_DEBUG_DH
 555    pr_info("info: exiting km_dh_set_secret\n");
 556    #endif /* WOLFKM_DEBUG_DH */
 557    return err;
 558}
 559#endif /* LINUXKM_DH */
 560
 561/**
 562 * Set the secret. Kernel crypto expects secret is passed with
 563 * struct kpp_secret as header, followed by secret data as payload.
 564 * See these for more info:
 565 *  - crypto/dh_helper.c
 566 *  - include/crypto/kpp.h
 567 *
 568 * - ffdhe should not pass p or g.
 569 * - passing key is optional. If key is not provided, it should
 570 *   be generated.
 571 * */
 572static int km_ffdhe_set_secret(struct crypto_kpp *tfm, const void *buf,
 573                               unsigned int len)
 574{
 575    int                err = -1;
 576    struct km_dh_ctx * ctx = NULL;
 577    struct dh          params;
 578
 579    ctx = kpp_tfm_ctx(tfm);
 580    memset(&params, 0, sizeof(params));
 581
 582    /* buf is optional for ffdhe */
 583    if (buf) {
 584        err = km_dh_decode_secret((u8*)buf, len, &params);
 585
 586        if (err) {
 587            #ifdef WOLFKM_DEBUG_DH
 588            pr_err("%s: ffdhe_set_secret: decode secret failed: %d\n",
 589                   WOLFKM_DH_DRIVER, params.key_size);
 590            #endif /* WOLFKM_DEBUG_DH */
 591            err = -EINVAL;
 592            goto ffdhe_secret_end;
 593        }
 594
 595        /* p_size and g_size should be 0 for ffdhe. */
 596        if (params.p_size || params.g_size) {
 597            #ifdef WOLFKM_DEBUG_DH
 598            pr_err("%s: ffdhe_set_secret: unexpected p, g params: %d, %d\n",
 599                   WOLFKM_DH_DRIVER, params.p_size, params.g_size);
 600            #endif /* WOLFKM_DEBUG_DH */
 601            err = -EINVAL;
 602            goto ffdhe_secret_end;
 603        }
 604    }
 605
 606    err = km_dh_reset_ctx(ctx);
 607    if (err) {
 608        goto ffdhe_secret_end;
 609    }
 610
 611    err = km_dh_alloc_keys(ctx);
 612    if (err) {
 613        goto ffdhe_secret_end;
 614    }
 615
 616    if (!params.key_size) {
 617        /* generate the ffdhe key pair*/
 618        #ifdef WOLFKM_DEBUG_DH
 619        pr_info("ffdhe gen key pair\n");
 620        #endif
 621        PRIVATE_KEY_UNLOCK();
 622        err = wc_DhGenerateKeyPair(ctx->key, &ctx->rng,
 623                                   ctx->priv_key, &ctx->priv_len,
 624                                   ctx->pub_key, &ctx->pub_len);
 625        PRIVATE_KEY_LOCK();
 626
 627        if (err) {
 628            #ifdef WOLFKM_DEBUG_DH
 629            pr_err("%s: wc_DhGenerateKeyPair failed: %d\n",
 630                   WOLFKM_DH_DRIVER, err);
 631            #endif
 632            err = -EINVAL;
 633            goto ffdhe_secret_end;
 634        }
 635
 636        /* Pad with leading zeros so pub key is modulus length.
 637         *
 638         * The kernel crypto/testmgr.c kpp test assumes same fixed width array
 639         * for all secrets and pub keys, and doesn't check for updates to
 640         * req->dst_len if the pub key is shorter because of leading zeros. */
 641        if (ctx->pub_len < (ctx->nbits / WOLFSSL_BIT_SIZE)) {
 642            word32 pad_len = ctx->nbits / WOLFSSL_BIT_SIZE - ctx->pub_len;
 643            #ifdef WOLFKM_DEBUG_DH
 644            pr_info("info: km_ffdhe_set_secret: pub key padding %d\n", pad_len);
 645            #endif
 646
 647            memmove(ctx->pub_key + pad_len, ctx->pub_key, ctx->pub_len);
 648            memset(ctx->pub_key, 0, pad_len);
 649
 650            ctx->pub_len += pad_len;
 651        }
 652
 653        /* already has the pub key generated. */
 654        ctx->has_pub_key = 1;
 655    }
 656    else {
 657        /* import the private key. */
 658        err = wc_DhImportKeyPair(ctx->key, params.key, params.key_size,
 659                                 NULL, 0);
 660
 661        if (err) {
 662            #ifdef WOLFKM_DEBUG_DH
 663            pr_err("%s: wc_DhImportKeyPair failed: %d\n",
 664                   WOLFKM_DH_DRIVER, err);
 665            #endif
 666            err = -EINVAL;
 667            goto ffdhe_secret_end;
 668        }
 669
 670        err = wc_DhExportKeyPair(ctx->key, ctx->priv_key, &ctx->priv_len,
 671                                 NULL, NULL);
 672
 673        if (err) {
 674            #ifdef WOLFKM_DEBUG_DH
 675            pr_err("%s: wc_DhExportKeyPair failed: %d\n",
 676                   WOLFKM_DH_DRIVER, err);
 677            #endif
 678            err = -EINVAL;
 679            goto ffdhe_secret_end;
 680        }
 681
 682        /* needs pub key generation */
 683        ctx->has_pub_key = 0;
 684    }
 685
 686ffdhe_secret_end:
 687    if (unlikely(err)) {
 688        km_dh_reset_ctx(ctx);
 689    }
 690
 691    #ifdef WOLFKM_DEBUG_DH
 692    pr_info("info: exiting km_dh_set_secret\n");
 693    #endif /* WOLFKM_DEBUG_DH */
 694    return err;
 695}
 696
 697/**
 698 * Returns modulus size for this dh key.
 699 *
 700 * Requires that crypto_kpp_set_secret has been called first.
 701 * */
 702static unsigned int km_dh_max_size(struct crypto_kpp *tfm)
 703{
 704    struct km_dh_ctx * ctx = NULL;
 705    unsigned int       max_size = 0;
 706
 707    ctx = kpp_tfm_ctx(tfm);
 708    max_size = mp_unsigned_bin_size(&ctx->key->p);
 709
 710    #ifdef WOLFKM_DEBUG_DH
 711    pr_info("info: exiting km_dh_max_size: %d\n", max_size);
 712    #endif /* WOLFKM_DEBUG_DH */
 713    return max_size;
 714}
 715
 716static void km_dh_exit(struct crypto_kpp *tfm)
 717{
 718    struct km_dh_ctx * ctx = NULL;
 719
 720    ctx = kpp_tfm_ctx(tfm);
 721
 722    if (ctx->key) {
 723        wc_FreeDhKey(ctx->key);
 724        free(ctx->key);
 725        ctx->key = NULL;
 726    }
 727
 728    km_dh_clear_keys(ctx);
 729    wc_FreeRng(&ctx->rng);
 730
 731    #ifdef WOLFKM_DEBUG_DH
 732    pr_info("info: exiting km_dh_exit\n");
 733    #endif /* WOLFKM_DEBUG_DH */
 734    return;
 735}
 736
 737/* Inits the dh tfm with the given ff named group and bit size.
 738 *
 739 * if name == 0, inits as dh.
 740 * if name != 0, inits as ffdhe.
 741 * */
 742static int km_ffdhe_init(struct crypto_kpp *tfm, int name, word32 nbits)
 743{
 744    struct km_dh_ctx * ctx = NULL;
 745    int                err = 0;
 746
 747    ctx = kpp_tfm_ctx(tfm);
 748    memset(ctx, 0, sizeof(struct km_dh_ctx));
 749    ctx->name = name;
 750    ctx->nbits = nbits;
 751
 752    err = LKCAPI_INITRNG(&ctx->rng);
 753    if (err) {
 754        #ifdef WOLFKM_DEBUG_DH
 755        pr_err("%s: init rng returned: %d\n", WOLFKM_DH_DRIVER, err);
 756        #endif /* WOLFKM_DEBUG_DH */
 757        return -ENOMEM;
 758    }
 759
 760    ctx->key = (DhKey *)malloc(sizeof(DhKey));
 761    if (!ctx->key) {
 762        return -ENOMEM;
 763    }
 764
 765    err = wc_InitDhKey(ctx->key);
 766    if (err < 0) {
 767        free(ctx->key);
 768        ctx->key = NULL;
 769        return -ENOMEM;
 770    }
 771
 772    if (ctx->name) {
 773        err = wc_DhSetNamedKey(ctx->key, ctx->name);
 774        if (err) {
 775            #ifdef WOLFKM_DEBUG_DH
 776            pr_err("%s: wc_DhSetNamedKey returned: %d\n", WOLFKM_DH_DRIVER,
 777                   err);
 778            #endif /* WOLFKM_DEBUG_DH */
 779            free(ctx->key);
 780            ctx->key = NULL;
 781            return -ENOMEM;
 782        }
 783    }
 784
 785    #ifdef WOLFKM_DEBUG_DH
 786    pr_info("info: exiting km_dh_init: name %d, nbits %d\n",
 787            ctx->name, ctx->nbits);
 788    #endif /* WOLFKM_DEBUG_DH */
 789    return 0;
 790}
 791
 792#ifdef LINUXKM_DH
 793static int km_dh_init(struct crypto_kpp *tfm)
 794{
 795    return km_ffdhe_init(tfm, 0, DH_MAX_SIZE);
 796}
 797#endif /* LINUXKM_DH */
 798
 799#ifdef HAVE_FFDHE_2048
 800static int km_ffdhe2048_init(struct crypto_kpp *tfm)
 801{
 802    return km_ffdhe_init(tfm, WC_FFDHE_2048, 2048);
 803}
 804#endif /* HAVE_FFDHE_2048 */
 805
 806#ifdef HAVE_FFDHE_3072
 807static int km_ffdhe3072_init(struct crypto_kpp *tfm)
 808{
 809    return km_ffdhe_init(tfm, WC_FFDHE_3072, 3072);
 810}
 811#endif /* HAVE_FFDHE_3072 */
 812
 813#ifdef HAVE_FFDHE_4096
 814static int km_ffdhe4096_init(struct crypto_kpp *tfm)
 815{
 816    return km_ffdhe_init(tfm, WC_FFDHE_4096, 4096);
 817}
 818#endif /* HAVE_FFDHE_4096 */
 819
 820#ifdef HAVE_FFDHE_6144
 821static int km_ffdhe6144_init(struct crypto_kpp *tfm)
 822{
 823    return km_ffdhe_init(tfm, WC_FFDHE_6144, 6144);
 824}
 825#endif /* HAVE_FFDHE_6144 */
 826
 827#ifdef HAVE_FFDHE_8192
 828static int km_ffdhe8192_init(struct crypto_kpp *tfm)
 829{
 830    return km_ffdhe_init(tfm, WC_FFDHE_8192, 8192);
 831}
 832#endif /* HAVE_FFDHE_8192 */
 833
 834/**
 835 * Generate the dh public key:
 836 *   - req->src should be null
 837 *   - req->dst is where we place the public key.
 838 * The kernel api expects raw pub key.
 839 * */
 840static int km_dh_gen_pub(struct kpp_request *req)
 841{
 842    struct crypto_kpp * tfm = NULL;
 843    struct km_dh_ctx *  ctx = NULL;
 844    int                 err = -1;
 845
 846    if (req->src != NULL || req->dst == NULL) {
 847        return -EINVAL;
 848    }
 849
 850    tfm = crypto_kpp_reqtfm(req);
 851    ctx = kpp_tfm_ctx(tfm);
 852
 853    if (!ctx->priv_key || !ctx->pub_key) {
 854        /* key not set or invalid key state. */
 855        return -EINVAL;
 856    }
 857
 858    if (ctx->has_pub_key == 0) {
 859        memset(ctx->pub_key, 0, ctx->pub_len);
 860
 861        err = wc_DhGeneratePublic(ctx->key, ctx->priv_key, ctx->priv_len,
 862                                  ctx->pub_key, &ctx->pub_len);
 863
 864        if (unlikely(err)) {
 865            #ifdef WOLFKM_DEBUG_DH
 866            pr_err("%s: wc_dh_make_key_ex failed: %d\n",
 867                   WOLFKM_DH_DRIVER, err);
 868            #endif
 869            return -EINVAL;
 870        }
 871
 872        ctx->has_pub_key = 1;
 873    }
 874
 875    if (ctx->pub_len > req->dst_len) {
 876        #ifdef WOLFKM_DEBUG_DH
 877        pr_err("error: dst_len too small: %d\n", req->dst_len);
 878        #endif /* WOLFKM_DEBUG_DH */
 879        req->dst_len = ctx->pub_len;
 880        return -EOVERFLOW;
 881    }
 882
 883    /* copy generated pub to req->dst */
 884    scatterwalk_map_and_copy(ctx->pub_key, req->dst, 0, ctx->pub_len, 1);
 885    err = 0;
 886
 887    #ifdef WOLFKM_DEBUG_DH
 888    pr_info("info: exiting km_dh_gen_pub: %d\n", ctx->pub_len);
 889    #endif /* WOLFKM_DEBUG_DH */
 890    return err;
 891}
 892
 893/**
 894 * Generate dh shared secret.
 895 *   - req->src has raw pub key from other party.
 896 *   - req->dst is shared secret output buffer.
 897 * */
 898static int km_dh_compute_shared_secret(struct kpp_request *req)
 899{
 900    struct crypto_kpp * tfm = NULL;
 901    struct km_dh_ctx *  ctx = NULL;
 902    int                 err = -1;
 903    byte *              pub = NULL;
 904    word32              pub_len = 0;
 905    byte *              shared_secret = NULL;
 906    word32              shared_secret_len = 0;
 907
 908    if (req->src == NULL || req->dst == NULL) {
 909        err = -EINVAL;
 910        goto dh_shared_secret_end;
 911    }
 912
 913    tfm = crypto_kpp_reqtfm(req);
 914    ctx = kpp_tfm_ctx(tfm);
 915
 916    if (!ctx->priv_key || !ctx->pub_key) {
 917        /* key not set or invalid key state. */
 918        err = -EINVAL;
 919        goto dh_shared_secret_end;
 920    }
 921
 922    if (req->src_len <= 0 || req->src_len > (ctx->nbits / WOLFSSL_BIT_SIZE)) {
 923        #ifdef WOLFKM_DEBUG_DH
 924        pr_err("error: got src_len %d, expected %d\n", req->src_len,
 925               (ctx->nbits / WOLFSSL_BIT_SIZE));
 926        #endif /* WOLFKM_DEBUG_DH */
 927        err = -EINVAL;
 928        goto dh_shared_secret_end;
 929    }
 930
 931    pub_len = req->src_len;
 932
 933    pub = malloc(pub_len);
 934    if (!pub) {
 935        err = -ENOMEM;
 936        goto dh_shared_secret_end;
 937    }
 938
 939    memset(pub, 0, pub_len);
 940
 941    /* copy req->src to pub */
 942    scatterwalk_map_and_copy(pub, req->src, 0, req->src_len, 0);
 943
 944    shared_secret_len = pub_len;
 945    shared_secret = malloc(shared_secret_len);
 946    if (!shared_secret) {
 947        err = -ENOMEM;
 948        goto dh_shared_secret_end;
 949    }
 950
 951    PRIVATE_KEY_UNLOCK();
 952    err = wc_DhAgree(ctx->key, shared_secret, &shared_secret_len,
 953                     ctx->priv_key, ctx->priv_len, pub, pub_len);
 954    PRIVATE_KEY_LOCK();
 955
 956    if (unlikely(err)) {
 957        #ifdef WOLFKM_DEBUG_DH
 958        pr_err("error: wc_dh_shared_secret returned: %d, %d\n", err,
 959               shared_secret_len);
 960        #endif
 961        err = -EINVAL;
 962        goto dh_shared_secret_end;
 963    }
 964
 965    if (req->dst_len < shared_secret_len) {
 966        #ifdef WOLFKM_DEBUG_DH
 967        pr_err("error: got dst_len %d, shared_secret_len %d\n",
 968               req->dst_len, shared_secret_len);
 969        #endif
 970        req->dst_len = shared_secret_len;
 971        err = -EOVERFLOW;
 972        goto dh_shared_secret_end;
 973    }
 974
 975    /* copy shared_secret to req->dst */
 976    scatterwalk_map_and_copy(shared_secret, req->dst, 0, shared_secret_len, 1);
 977
 978dh_shared_secret_end:
 979    if (shared_secret) {
 980        ForceZero(shared_secret, shared_secret_len);
 981        free(shared_secret);
 982        shared_secret = NULL;
 983    }
 984    if (pub) { free(pub); pub = NULL; }
 985
 986    #ifdef WOLFKM_DEBUG_DH
 987    pr_info("info: exiting km_dh_compute_shared_secret: %d\n",
 988            shared_secret_len);
 989    #endif /* WOLFKM_DEBUG_DH */
 990    return err;
 991}
 992
 993#ifdef LINUXKM_DH
 994static int linuxkm_test_dh(void)
 995{
 996    int rc = 0;
 997    /* reference values from kernel crypto/testmgr.h */
 998    /* 529 byte secret size */
 999    static const byte secret[] = {
1000#ifdef LITTLE_ENDIAN_ORDER
1001        0x01, 0x00, /* type */
1002        0x11, 0x02, /* len */
1003        0x00, 0x01, 0x00, 0x00, /* key_size */
1004        0x00, 0x01, 0x00, 0x00, /* p_size */
1005        0x01, 0x00, 0x00, 0x00, /* g_size */
1006#else
1007        0x00, 0x01, /* type */
1008        0x02, 0x11, /* len */
1009        0x00, 0x00, 0x01, 0x00, /* key_size */
1010        0x00, 0x00, 0x01, 0x00, /* p_size */
1011        0x00, 0x00, 0x00, 0x01, /* g_size */
1012#endif
1013        /* xa */
1014        0x44, 0xc1, 0x48, 0x36, 0xa7, 0x2b, 0x6f, 0x4e,
1015        0x43, 0x03, 0x68, 0xad, 0x31, 0x00, 0xda, 0xf3,
1016        0x2a, 0x01, 0xa8, 0x32, 0x63, 0x5f, 0x89, 0x32,
1017        0x1f, 0xdf, 0x4c, 0xa1, 0x6a, 0xbc, 0x10, 0x15,
1018        0x90, 0x35, 0xc9, 0x26, 0x41, 0xdf, 0x7b, 0xaa,
1019        0x56, 0x56, 0x3d, 0x85, 0x44, 0xb5, 0xc0, 0x8e,
1020        0x37, 0x83, 0x06, 0x50, 0xb3, 0x5f, 0x0e, 0x28,
1021        0x2c, 0xd5, 0x46, 0x15, 0xe3, 0xda, 0x7d, 0x74,
1022        0x87, 0x13, 0x91, 0x4f, 0xd4, 0x2d, 0xf6, 0xc7,
1023        0x5e, 0x14, 0x2c, 0x11, 0xc2, 0x26, 0xb4, 0x3a,
1024        0xe3, 0xb2, 0x36, 0x20, 0x11, 0x3b, 0x22, 0xf2,
1025        0x06, 0x65, 0x66, 0xe2, 0x57, 0x58, 0xf8, 0x22,
1026        0x1a, 0x94, 0xbd, 0x2b, 0x0e, 0x8c, 0x55, 0xad,
1027        0x61, 0x23, 0x45, 0x2b, 0x19, 0x1e, 0x63, 0x3a,
1028        0x13, 0x61, 0xe3, 0xa0, 0x79, 0x70, 0x3e, 0x6d,
1029        0x98, 0x32, 0xbc, 0x7f, 0x82, 0xc3, 0x11, 0xd8,
1030        0xeb, 0x53, 0xb5, 0xfc, 0xb5, 0xd5, 0x3c, 0x4a,
1031        0xea, 0x92, 0x3e, 0x01, 0xce, 0x15, 0x65, 0xd4,
1032        0xaa, 0x85, 0xc1, 0x11, 0x90, 0x83, 0x31, 0x6e,
1033        0xfe, 0xe7, 0x7f, 0x7d, 0xed, 0xab, 0xf9, 0x29,
1034        0xf8, 0xc7, 0xf1, 0x68, 0xc6, 0xb7, 0xe4, 0x1f,
1035        0x2f, 0x28, 0xa0, 0xc9, 0x1a, 0x50, 0x64, 0x29,
1036        0x4b, 0x01, 0x6d, 0x1a, 0xda, 0x46, 0x63, 0x21,
1037        0x07, 0x40, 0x8c, 0x8e, 0x4c, 0x6f, 0xb5, 0xe5,
1038        0x12, 0xf3, 0xc2, 0x1b, 0x48, 0x27, 0x5e, 0x27,
1039        0x01, 0xb1, 0xaa, 0xed, 0x68, 0x9b, 0x83, 0x18,
1040        0x8f, 0xb1, 0xeb, 0x1f, 0x04, 0xd1, 0x3c, 0x79,
1041        0xed, 0x4b, 0xf7, 0x0a, 0x33, 0xdc, 0xe0, 0xc6,
1042        0xd8, 0x02, 0x51, 0x59, 0x00, 0x74, 0x30, 0x07,
1043        0x4c, 0x2d, 0xac, 0xe4, 0x13, 0xf1, 0x80, 0xf0,
1044        0xce, 0xfa, 0xff, 0xa9, 0xce, 0x29, 0x46, 0xdd,
1045        0x9d, 0xad, 0xd1, 0xc3, 0xc6, 0x58, 0x1a, 0x63,
1046        /* p */
1047        0xb9, 0x36, 0x3a, 0xf1, 0x82, 0x1f, 0x60, 0xd3,
1048        0x22, 0x47, 0xb8, 0xbc, 0x2d, 0x22, 0x6b, 0x81,
1049        0x7f, 0xe8, 0x20, 0x06, 0x09, 0x23, 0x73, 0x49,
1050        0x9a, 0x59, 0x8b, 0x35, 0x25, 0xf8, 0x31, 0xbc,
1051        0x7d, 0xa8, 0x1c, 0x9d, 0x56, 0x0d, 0x1a, 0xf7,
1052        0x4b, 0x4f, 0x96, 0xa4, 0x35, 0x77, 0x6a, 0x89,
1053        0xab, 0x42, 0x00, 0x49, 0x21, 0x71, 0xed, 0x28,
1054        0x16, 0x1d, 0x87, 0x5a, 0x10, 0xa7, 0x9c, 0x64,
1055        0x94, 0xd4, 0x87, 0x3d, 0x28, 0xef, 0x44, 0xfe,
1056        0x4b, 0xe2, 0xb4, 0x15, 0x8c, 0x82, 0xa6, 0xf3,
1057        0x50, 0x5f, 0xa8, 0xe8, 0xa2, 0x60, 0xe7, 0x00,
1058        0x86, 0x78, 0x05, 0xd4, 0x78, 0x19, 0xa1, 0x98,
1059        0x62, 0x4e, 0x4a, 0x00, 0x78, 0x56, 0x96, 0xe6,
1060        0xcf, 0xd7, 0x10, 0x1b, 0x74, 0x5d, 0xd0, 0x26,
1061        0x61, 0xdb, 0x6b, 0x32, 0x09, 0x51, 0xd8, 0xa5,
1062        0xfd, 0x54, 0x16, 0x71, 0x01, 0xb3, 0x39, 0xe6,
1063        0x4e, 0x69, 0xb1, 0xd7, 0x06, 0x8f, 0xd6, 0x1e,
1064        0xdc, 0x72, 0x25, 0x26, 0x74, 0xc8, 0x41, 0x06,
1065        0x5c, 0xd1, 0x26, 0x5c, 0xb0, 0x2f, 0xf9, 0x59,
1066        0x13, 0xc1, 0x2a, 0x0f, 0x78, 0xea, 0x7b, 0xf7,
1067        0xbd, 0x59, 0xa0, 0x90, 0x1d, 0xfc, 0x33, 0x5b,
1068        0x4c, 0xbf, 0x05, 0x9c, 0x3a, 0x3f, 0x69, 0xa2,
1069        0x45, 0x61, 0x4e, 0x10, 0x6a, 0xb3, 0x17, 0xc5,
1070        0x68, 0x30, 0xfb, 0x07, 0x5f, 0x34, 0xc6, 0xfb,
1071        0x73, 0x07, 0x3c, 0x70, 0xf6, 0xae, 0xe7, 0x72,
1072        0x84, 0xc3, 0x18, 0x81, 0x8f, 0xe8, 0x11, 0x1f,
1073        0x3d, 0x83, 0x83, 0x01, 0x2a, 0x14, 0x73, 0xbf,
1074        0x32, 0x32, 0x2e, 0xc9, 0x4d, 0xdb, 0x2a, 0xca,
1075        0xee, 0x71, 0xf9, 0xda, 0xad, 0xe8, 0x82, 0x0b,
1076        0x4d, 0x0c, 0x1f, 0xb6, 0x1d, 0xef, 0x00, 0x67,
1077        0x74, 0x3d, 0x95, 0xe0, 0xb7, 0xc4, 0x30, 0x8a,
1078        0x24, 0x87, 0x12, 0x47, 0x27, 0x70, 0x0d, 0x73,
1079        /* g */
1080        0x02
1081    };
1082
1083    /* 256 byte pub key */
1084    static const byte b_pub[] = {
1085        0x2a, 0x67, 0x5c, 0xfd, 0x63, 0x5d, 0xc0, 0x97,
1086        0x0a, 0x8b, 0xa2, 0x1f, 0xf8, 0x8a, 0xcb, 0x54,
1087        0xca, 0x2f, 0xd3, 0x49, 0x3f, 0x01, 0x8e, 0x87,
1088        0xfe, 0xcc, 0x94, 0xa0, 0x3e, 0xd4, 0x26, 0x79,
1089        0x9a, 0x94, 0x3c, 0x11, 0x81, 0x58, 0x5c, 0x60,
1090        0x3d, 0xf5, 0x98, 0x90, 0x89, 0x64, 0x62, 0x1f,
1091        0xbd, 0x05, 0x6d, 0x2b, 0xcd, 0x84, 0x40, 0x9b,
1092        0x4a, 0x1f, 0xe0, 0x19, 0xf1, 0xca, 0x20, 0xb3,
1093        0x4e, 0xa0, 0x4f, 0x15, 0xcc, 0xa5, 0xfe, 0xa5,
1094        0xb4, 0xf5, 0x0b, 0x18, 0x7a, 0x5a, 0x37, 0xaa,
1095        0x58, 0x00, 0x19, 0x7f, 0xe2, 0xa3, 0xd9, 0x1c,
1096        0x44, 0x57, 0xcc, 0xde, 0x2e, 0xc1, 0x38, 0xea,
1097        0xeb, 0xe3, 0x90, 0x40, 0xc4, 0x6c, 0xf7, 0xcd,
1098        0xe9, 0x22, 0x50, 0x71, 0xf5, 0x7c, 0xdb, 0x37,
1099        0x0e, 0x80, 0xc3, 0xed, 0x7e, 0xb1, 0x2b, 0x2f,
1100        0xbe, 0x71, 0xa6, 0x11, 0xa5, 0x9d, 0xf5, 0x39,
1101        0xf1, 0xa2, 0xe5, 0x85, 0xbc, 0x25, 0x91, 0x4e,
1102        0x84, 0x8d, 0x26, 0x9f, 0x4f, 0xe6, 0x0f, 0xa6,
1103        0x2b, 0x6b, 0xf9, 0x0d, 0xaf, 0x6f, 0xbb, 0xfa,
1104        0x2d, 0x79, 0x15, 0x31, 0x57, 0xae, 0x19, 0x60,
1105        0x22, 0x0a, 0xf5, 0xfd, 0x98, 0x0e, 0xbf, 0x5d,
1106        0x49, 0x75, 0x58, 0x37, 0xbc, 0x7f, 0xf5, 0x21,
1107        0x56, 0x1e, 0xd5, 0xb3, 0x50, 0x0b, 0xca, 0x96,
1108        0xf3, 0xd1, 0x3f, 0xb3, 0x70, 0xa8, 0x6d, 0x63,
1109        0x48, 0xfb, 0x3d, 0xd7, 0x29, 0x91, 0x45, 0xb5,
1110        0x48, 0xcd, 0xb6, 0x78, 0x30, 0xf2, 0x3f, 0x1e,
1111        0xd6, 0x22, 0xd6, 0x35, 0x9b, 0xf9, 0x1f, 0x85,
1112        0xae, 0xab, 0x4b, 0xd7, 0xe0, 0xc7, 0x86, 0x67,
1113        0x3f, 0x05, 0x7f, 0xa6, 0x0d, 0x2f, 0x0d, 0xbf,
1114        0x53, 0x5f, 0x4d, 0x2c, 0x6d, 0x5e, 0x57, 0x40,
1115        0x30, 0x3a, 0x23, 0x98, 0xf9, 0xb4, 0x32, 0xf5,
1116        0x32, 0x83, 0xdd, 0x0b, 0xae, 0x33, 0x97, 0x2f
1117    };
1118
1119    /* 256 byte pub key */
1120    static const byte expected_a_pub[] = {
1121        0x5c, 0x24, 0xdf, 0xeb, 0x5b, 0x4b, 0xf8, 0xc5,
1122        0xef, 0x39, 0x48, 0x82, 0xe0, 0x1e, 0x62, 0xee,
1123        0x8a, 0xae, 0xdf, 0x93, 0x6c, 0x2b, 0x16, 0x95,
1124        0x92, 0x16, 0x3f, 0x16, 0x7b, 0x75, 0x03, 0x85,
1125        0xd9, 0xf1, 0x69, 0xc2, 0x14, 0x87, 0x45, 0xfc,
1126        0xa4, 0x19, 0xf6, 0xf0, 0xa4, 0xf3, 0xec, 0xd4,
1127        0x6c, 0x5c, 0x03, 0x3b, 0x94, 0xc2, 0x2f, 0x92,
1128        0xe4, 0xce, 0xb3, 0xe4, 0x72, 0xe8, 0x17, 0xe6,
1129        0x23, 0x7e, 0x00, 0x01, 0x09, 0x59, 0x13, 0xbf,
1130        0xc1, 0x2f, 0x99, 0xa9, 0x07, 0xaa, 0x02, 0x23,
1131        0x4a, 0xca, 0x39, 0x4f, 0xbc, 0xec, 0x0f, 0x27,
1132        0x4f, 0x19, 0x93, 0x6c, 0xb9, 0x30, 0x52, 0xfd,
1133        0x2b, 0x9d, 0x86, 0xf1, 0x06, 0x1e, 0xb6, 0x56,
1134        0x27, 0x4a, 0xc9, 0x8a, 0xa7, 0x8a, 0x48, 0x5e,
1135        0xb5, 0x60, 0xcb, 0xdf, 0xff, 0x03, 0x26, 0x10,
1136        0xbf, 0x90, 0x8f, 0x46, 0x60, 0xeb, 0x9b, 0x9a,
1137        0xd6, 0x6f, 0x44, 0x91, 0x03, 0x92, 0x18, 0x2c,
1138        0x96, 0x5e, 0x40, 0x19, 0xfb, 0xf4, 0x4f, 0x3a,
1139        0x02, 0x7b, 0xaf, 0xcc, 0x22, 0x20, 0x79, 0xb9,
1140        0xf8, 0x9f, 0x8f, 0x85, 0x6b, 0xec, 0x44, 0xbb,
1141        0xe6, 0xa8, 0x8e, 0xb1, 0xe8, 0x2c, 0xee, 0x64,
1142        0xee, 0xf8, 0xbd, 0x00, 0xf3, 0xe2, 0x2b, 0x93,
1143        0xcd, 0xe7, 0xc4, 0xdf, 0xc9, 0x19, 0x46, 0xfe,
1144        0xb6, 0x07, 0x73, 0xc1, 0x8a, 0x64, 0x79, 0x26,
1145        0xe7, 0x30, 0xad, 0x2a, 0xdf, 0xe6, 0x8f, 0x59,
1146        0xf5, 0x81, 0xbf, 0x4a, 0x29, 0x91, 0xe7, 0xb7,
1147        0xcf, 0x48, 0x13, 0x27, 0x75, 0x79, 0x40, 0xd9,
1148        0xd6, 0x32, 0x52, 0x4e, 0x6a, 0x86, 0xae, 0x6f,
1149        0xc2, 0xbf, 0xec, 0x1f, 0xc2, 0x69, 0xb2, 0xb6,
1150        0x59, 0xe5, 0xa5, 0x17, 0xa4, 0x77, 0xb7, 0x62,
1151        0x46, 0xde, 0xe8, 0xd2, 0x89, 0x78, 0x9a, 0xef,
1152        0xa3, 0xb5, 0x8f, 0x26, 0xec, 0x80, 0xda, 0x39
1153    };
1154
1155    /* 256 byte shared secret */
1156    static const byte shared_secret[] = {
1157        0x8f, 0xf3, 0xac, 0xa2, 0xea, 0x22, 0x11, 0x5c,
1158        0x45, 0x65, 0x1a, 0x77, 0x75, 0x2e, 0xcf, 0x46,
1159        0x23, 0x14, 0x1e, 0x67, 0x53, 0x4d, 0x35, 0xb0,
1160        0x38, 0x1d, 0x4e, 0xb9, 0x41, 0x9a, 0x21, 0x24,
1161        0x6e, 0x9f, 0x40, 0xfe, 0x90, 0x51, 0xb1, 0x06,
1162        0xa4, 0x7b, 0x87, 0x17, 0x2f, 0xe7, 0x5e, 0x22,
1163        0xf0, 0x7b, 0x54, 0x84, 0x0a, 0xac, 0x0a, 0x90,
1164        0xd2, 0xd7, 0xe8, 0x7f, 0xe7, 0xe3, 0x30, 0x75,
1165        0x01, 0x1f, 0x24, 0x75, 0x56, 0xbe, 0xcc, 0x8d,
1166        0x1e, 0x68, 0x0c, 0x41, 0x72, 0xd3, 0xfa, 0xbb,
1167        0xe5, 0x9c, 0x60, 0xc7, 0x28, 0x77, 0x0c, 0xbe,
1168        0x89, 0xab, 0x08, 0xd6, 0x21, 0xe7, 0x2e, 0x1a,
1169        0x58, 0x7a, 0xca, 0x4f, 0x22, 0xf3, 0x2b, 0x30,
1170        0xfd, 0xf4, 0x98, 0xc1, 0xa3, 0xf8, 0xf6, 0xcc,
1171        0xa9, 0xe4, 0xdb, 0x5b, 0xee, 0xd5, 0x5c, 0x6f,
1172        0x62, 0x4c, 0xd1, 0x1a, 0x02, 0x2a, 0x23, 0xe4,
1173        0xb5, 0x57, 0xf3, 0xf9, 0xec, 0x04, 0x83, 0x54,
1174        0xfe, 0x08, 0x5e, 0x35, 0xac, 0xfb, 0xa8, 0x09,
1175        0x82, 0x32, 0x60, 0x11, 0xb2, 0x16, 0x62, 0x6b,
1176        0xdf, 0xda, 0xde, 0x9c, 0xcb, 0x63, 0x44, 0x6c,
1177        0x59, 0x26, 0x6a, 0x8f, 0xb0, 0x24, 0xcb, 0xa6,
1178        0x72, 0x48, 0x1e, 0xeb, 0xe0, 0xe1, 0x09, 0x44,
1179        0xdd, 0xee, 0x66, 0x6d, 0x84, 0xcf, 0xa5, 0xc1,
1180        0xb8, 0x36, 0x74, 0xd3, 0x15, 0x96, 0xc3, 0xe4,
1181        0xc6, 0x5a, 0x4d, 0x23, 0x97, 0x0c, 0x5c, 0xcb,
1182        0xa9, 0xf5, 0x29, 0xc2, 0x0e, 0xff, 0x93, 0x82,
1183        0xd3, 0x34, 0x49, 0xad, 0x64, 0xa6, 0xb1, 0xc0,
1184        0x59, 0x28, 0x75, 0x60, 0xa7, 0x8a, 0xb0, 0x11,
1185        0x56, 0x89, 0x42, 0x74, 0x11, 0xf5, 0xf6, 0x5e,
1186        0x6f, 0x16, 0x54, 0x6a, 0xb1, 0x76, 0x4d, 0x50,
1187        0x8a, 0x68, 0xc1, 0x5b, 0x82, 0xb9, 0x0d, 0x00,
1188        0x32, 0x50, 0xed, 0x88, 0x87, 0x48, 0x92, 0x17
1189    };
1190
1191    rc = linuxkm_test_kpp_driver(WOLFKM_DH_DRIVER,
1192                                 b_pub, expected_a_pub, sizeof(b_pub),
1193                                 secret, sizeof(secret),
1194                                 shared_secret, sizeof(shared_secret));
1195
1196    return rc;
1197}
1198#endif /* LINUXKM_DH */
1199
1200#ifdef HAVE_FFDHE_2048
1201static int linuxkm_test_ffdhe2048(void)
1202{
1203    int rc = 0;
1204
1205    /* reference values from kernel crypto/testmgr.h */
1206    /* 272 byte secret size */
1207    static const byte secret[] = {
1208#ifdef LITTLE_ENDIAN_ORDER
1209        0x01, 0x00, /* type */
1210        0x10, 0x01, /* len */
1211        0x00, 0x01, 0x00, 0x00, /* key_size */
1212        0x00, 0x00, 0x00, 0x00, /* p_size */
1213        0x00, 0x00, 0x00, 0x00, /* g_size */
1214#else
1215        0x00, 0x01, /* type */
1216        0x01, 0x10, /* len */
1217        0x00, 0x00, 0x01, 0x00, /* key_size */
1218        0x00, 0x00, 0x00, 0x00, /* p_size */
1219        0x00, 0x00, 0x00, 0x00, /* g_size */
1220#endif
1221        /* xa */
1222        0x23, 0x7d, 0xd0, 0x06, 0xfd, 0x7a, 0xe5, 0x7a,
1223        0x08, 0xda, 0x98, 0x31, 0xc0, 0xb3, 0xd5, 0x85,
1224        0xe2, 0x0d, 0x2a, 0x91, 0x5f, 0x78, 0x4b, 0xa6,
1225        0x62, 0xd0, 0xa6, 0x35, 0xd4, 0xef, 0x86, 0x39,
1226        0xf1, 0xdb, 0x71, 0x5e, 0xb0, 0x11, 0x2e, 0xee,
1227        0x91, 0x3a, 0xaa, 0xf9, 0xe3, 0xdf, 0x8d, 0x8b,
1228        0x48, 0x41, 0xde, 0xe8, 0x78, 0x53, 0xc5, 0x5f,
1229        0x93, 0xd2, 0x79, 0x0d, 0xbe, 0x8d, 0x83, 0xe8,
1230        0x8f, 0x00, 0xd2, 0xde, 0x13, 0x18, 0x04, 0x05,
1231        0x20, 0x6d, 0xda, 0xfa, 0x1d, 0x0b, 0x24, 0x52,
1232        0x3a, 0x18, 0x2b, 0xe1, 0x1e, 0xae, 0x15, 0x3b,
1233        0x0f, 0xaa, 0x09, 0x09, 0xf6, 0x01, 0x98, 0xe9,
1234        0x81, 0x5d, 0x6b, 0x83, 0x6e, 0x55, 0xf1, 0x5d,
1235        0x6f, 0x6f, 0x0d, 0x9d, 0xa8, 0x72, 0x32, 0x63,
1236        0x60, 0xe6, 0x0b, 0xc5, 0x22, 0xe2, 0xf9, 0x46,
1237        0x58, 0xa2, 0x1c, 0x2a, 0xb0, 0xd5, 0xaf, 0xe3,
1238        0x5b, 0x03, 0xb7, 0x36, 0xb7, 0xba, 0x55, 0x20,
1239        0x08, 0x7c, 0x51, 0xd4, 0x89, 0x42, 0x9c, 0x14,
1240        0x23, 0xe2, 0x71, 0x3e, 0x15, 0x2a, 0x0d, 0x34,
1241        0x8a, 0xde, 0xad, 0x84, 0x11, 0x15, 0x72, 0x18,
1242        0x42, 0x43, 0x0a, 0xe2, 0x58, 0x29, 0xb3, 0x90,
1243        0x0f, 0x56, 0xd8, 0x8a, 0x0f, 0x0e, 0xbc, 0x0e,
1244        0x9c, 0xe7, 0xd5, 0xe6, 0x5b, 0xbf, 0x06, 0x64,
1245        0x38, 0x12, 0xa5, 0x8d, 0x5b, 0x68, 0x34, 0xdd,
1246        0x75, 0x48, 0xc9, 0xa7, 0xa3, 0x58, 0x5a, 0x1c,
1247        0xe1, 0xb2, 0xc5, 0xe3, 0x39, 0x03, 0xcf, 0xab,
1248        0xc2, 0x14, 0x07, 0xaf, 0x55, 0x80, 0xc7, 0x63,
1249        0xe4, 0x03, 0xeb, 0xe9, 0x0a, 0x25, 0x61, 0x85,
1250        0x1d, 0x0e, 0x81, 0x52, 0x7b, 0xbc, 0x4a, 0x0c,
1251        0xc8, 0x59, 0x6a, 0xac, 0x18, 0xfb, 0x8c, 0x0c,
1252        0xb4, 0x79, 0xbd, 0xa1, 0x4c, 0xbb, 0x02, 0xc9,
1253        0xd5, 0x13, 0x88, 0x3d, 0x25, 0xaa, 0x77, 0x49
1254    };
1255
1256    /* 256 byte pub key */
1257    static const byte b_pub[] = {
1258        0x5c, 0x00, 0x6f, 0xda, 0xfe, 0x4c, 0x0c, 0xc2,
1259        0x18, 0xff, 0xa9, 0xec, 0x7a, 0xbe, 0x8a, 0x51,
1260        0x64, 0x6b, 0x57, 0xf8, 0xed, 0xe2, 0x36, 0x77,
1261        0xc1, 0x23, 0xbf, 0x56, 0xa6, 0x48, 0x76, 0x34,
1262        0x0e, 0xf3, 0x68, 0x05, 0x45, 0x6a, 0x98, 0x5b,
1263        0x9e, 0x8b, 0xc0, 0x11, 0x29, 0xcb, 0x5b, 0x66,
1264        0x2d, 0xc2, 0xeb, 0x4c, 0xf1, 0x7d, 0x85, 0x30,
1265        0xaa, 0xd5, 0xf5, 0xb8, 0xd3, 0x62, 0x1e, 0x97,
1266        0x1e, 0x34, 0x18, 0xf8, 0x76, 0x8c, 0x10, 0xca,
1267        0x1f, 0xe4, 0x5d, 0x62, 0xe1, 0xbe, 0x61, 0xef,
1268        0xaf, 0x2c, 0x8d, 0x97, 0x15, 0xa5, 0x86, 0xd5,
1269        0xd3, 0x12, 0x6f, 0xec, 0xe2, 0xa4, 0xb2, 0x5a,
1270        0x35, 0x1d, 0xd4, 0x91, 0xa6, 0xef, 0x13, 0x09,
1271        0x65, 0x9c, 0x45, 0xc0, 0x12, 0xad, 0x7f, 0xee,
1272        0x93, 0x5d, 0xfa, 0x89, 0x26, 0x7d, 0xae, 0xee,
1273        0xea, 0x8c, 0xa3, 0xcf, 0x04, 0x2d, 0xa0, 0xc7,
1274        0xd9, 0x14, 0x62, 0xaf, 0xdf, 0xa0, 0x33, 0xd7,
1275        0x5e, 0x83, 0xa2, 0xe6, 0x0e, 0x0e, 0x5d, 0x77,
1276        0xce, 0xe6, 0x72, 0xe4, 0xec, 0x9d, 0xff, 0x72,
1277        0x9f, 0x38, 0x95, 0x19, 0x96, 0xba, 0x4c, 0xe3,
1278        0x5f, 0xb8, 0x46, 0x4a, 0x1d, 0xe9, 0x62, 0x7b,
1279        0xa8, 0xdc, 0xe7, 0x61, 0x90, 0x6b, 0xb9, 0xd4,
1280        0xad, 0x0b, 0xa3, 0x06, 0xb3, 0x70, 0xfa, 0xea,
1281        0x2b, 0xc4, 0x2c, 0xde, 0x43, 0x37, 0xf6, 0x8d,
1282        0x72, 0xf0, 0x86, 0x9a, 0xbb, 0x3b, 0x8e, 0x7a,
1283        0x71, 0x03, 0x30, 0x30, 0x2a, 0x5d, 0xcd, 0x1e,
1284        0xe4, 0xd3, 0x08, 0x07, 0x75, 0x17, 0x17, 0x72,
1285        0x1e, 0x77, 0x6c, 0x98, 0x0d, 0x29, 0x7f, 0xac,
1286        0xe7, 0xb2, 0xee, 0xa9, 0x1c, 0x33, 0x9d, 0x08,
1287        0x39, 0xe1, 0xd8, 0x5b, 0xe5, 0xbc, 0x48, 0xb2,
1288        0xb6, 0xdf, 0xcd, 0xa0, 0x42, 0x06, 0xcc, 0xfb,
1289        0xed, 0x60, 0x6f, 0xbc, 0x57, 0xac, 0x09, 0x45
1290    };
1291
1292    /* 256 byte pub key */
1293    static const byte expected_a_pub[] = {
1294        0x8b, 0xdb, 0xc1, 0xf7, 0xc6, 0xba, 0xa1, 0x38,
1295        0x95, 0x6a, 0xa1, 0xb6, 0x04, 0x5e, 0xae, 0x52,
1296        0x72, 0xfc, 0xef, 0x2d, 0x9d, 0x71, 0x05, 0x9c,
1297        0xd3, 0x02, 0xa9, 0xfb, 0x55, 0x0f, 0xfa, 0xc9,
1298        0xb4, 0x34, 0x51, 0xa3, 0x28, 0x89, 0x8d, 0x93,
1299        0x92, 0xcb, 0xd9, 0xb5, 0xb9, 0x66, 0xfc, 0x67,
1300        0x15, 0x92, 0x6f, 0x73, 0x85, 0x15, 0xe2, 0xfc,
1301        0x11, 0x6b, 0x97, 0x8c, 0x4b, 0x0f, 0x12, 0xfa,
1302        0x8d, 0x72, 0x76, 0x9b, 0x8f, 0x3b, 0xfe, 0x31,
1303        0xbe, 0x42, 0x88, 0x4c, 0xd2, 0xb2, 0x70, 0xa6,
1304        0xa5, 0xe3, 0x7e, 0x73, 0x07, 0x12, 0x36, 0xaa,
1305        0xc9, 0x5c, 0x83, 0xe1, 0xf1, 0x46, 0x41, 0x4f,
1306        0x7c, 0x52, 0xaf, 0xdc, 0xa4, 0xe6, 0x82, 0xa3,
1307        0x86, 0x83, 0x47, 0x5a, 0x12, 0x3a, 0x0c, 0xe3,
1308        0xdd, 0xdb, 0x94, 0x03, 0x2a, 0x59, 0x91, 0xa0,
1309        0x19, 0xe5, 0xf8, 0x07, 0xdd, 0x54, 0x6a, 0x22,
1310        0x43, 0xb7, 0xf3, 0x74, 0xd7, 0xb9, 0x30, 0xfe,
1311        0x9c, 0xe8, 0xd1, 0xcf, 0x06, 0x43, 0x68, 0xb9,
1312        0x54, 0x8f, 0x54, 0xa2, 0xe5, 0x3c, 0xf2, 0xc3,
1313        0x4c, 0xee, 0xd4, 0x7c, 0x5d, 0x0e, 0xb1, 0x7b,
1314        0x16, 0x68, 0xb5, 0xb3, 0x7d, 0xd4, 0x11, 0x83,
1315        0x5c, 0x77, 0x17, 0xc4, 0xf0, 0x59, 0x76, 0x7a,
1316        0x83, 0x40, 0xe5, 0xd9, 0x4c, 0x76, 0x23, 0x5b,
1317        0x17, 0x6d, 0xee, 0x4a, 0x92, 0x68, 0x4b, 0x89,
1318        0xa0, 0x6d, 0x23, 0x8c, 0x80, 0x31, 0x33, 0x3a,
1319        0x12, 0xf4, 0x50, 0xa6, 0xcb, 0x13, 0x97, 0x01,
1320        0xb8, 0x2c, 0xe6, 0xd2, 0x38, 0xdf, 0xd0, 0x7f,
1321        0xc6, 0x27, 0x19, 0x0e, 0xb2, 0x07, 0xfd, 0x1f,
1322        0x1b, 0x9c, 0x1b, 0x87, 0xf9, 0x73, 0x6a, 0x3f,
1323        0x7f, 0xb0, 0xf9, 0x2f, 0x3c, 0x19, 0x9f, 0xc9,
1324        0x8f, 0x97, 0x21, 0x0e, 0x8e, 0xbb, 0x1a, 0x17,
1325        0x20, 0x15, 0xdd, 0xc6, 0x42, 0x60, 0xae, 0x4d
1326    };
1327
1328    /* 256 byte shared secret */
1329    static const byte shared_secret[] = {
1330        0xf3, 0x0e, 0x64, 0x7b, 0x66, 0xd7, 0x82, 0x7e,
1331        0xab, 0x7e, 0x4a, 0xbe, 0x13, 0x6f, 0x43, 0x3d,
1332        0xea, 0x4f, 0x1f, 0x8b, 0x9d, 0x41, 0x56, 0x71,
1333        0xe1, 0x06, 0x96, 0x02, 0x68, 0xfa, 0x44, 0x6e,
1334        0xe7, 0xf2, 0x26, 0xd4, 0x01, 0x4a, 0xf0, 0x28,
1335        0x25, 0x76, 0xad, 0xd7, 0xe0, 0x17, 0x74, 0xfe,
1336        0xf9, 0xe1, 0x6d, 0xd3, 0xf7, 0xc7, 0xdf, 0xc0,
1337        0x62, 0xa5, 0xf3, 0x4e, 0x1b, 0x5c, 0x77, 0x2a,
1338        0xfb, 0x0b, 0x87, 0xc3, 0xde, 0x1e, 0xc1, 0xe0,
1339        0xd3, 0x7a, 0xb8, 0x02, 0x02, 0xec, 0x9c, 0x97,
1340        0xfb, 0x34, 0xa0, 0x20, 0x10, 0x23, 0x87, 0xb2,
1341        0x9a, 0x72, 0xe3, 0x3d, 0xb2, 0x18, 0x50, 0xf3,
1342        0x6a, 0xd3, 0xd3, 0x19, 0xc4, 0x36, 0xd5, 0x59,
1343        0xd6, 0xd6, 0xa7, 0x5c, 0xc3, 0xf9, 0x09, 0x33,
1344        0xa1, 0xf5, 0xb9, 0x4b, 0xf3, 0x0b, 0xe1, 0x4f,
1345        0x79, 0x6b, 0x45, 0xf2, 0xec, 0x8b, 0xe5, 0x69,
1346        0x9f, 0xc6, 0x05, 0x01, 0xfe, 0x3a, 0x13, 0xfd,
1347        0x6d, 0xea, 0x03, 0x83, 0x29, 0x7c, 0x7f, 0xf5,
1348        0x41, 0x55, 0x95, 0xde, 0x7e, 0x62, 0xae, 0xaf,
1349        0x28, 0xdb, 0x7c, 0xa9, 0x90, 0x1e, 0xb2, 0xb1,
1350        0x1b, 0xef, 0xf1, 0x2e, 0xde, 0x47, 0xaa, 0xa8,
1351        0x92, 0x9a, 0x49, 0x3d, 0xc0, 0xe0, 0x8d, 0xbb,
1352        0x0c, 0x42, 0x86, 0xaf, 0x00, 0xce, 0xb0, 0xab,
1353        0x22, 0x7c, 0xe9, 0xbe, 0xb9, 0x72, 0x2f, 0xcf,
1354        0x5e, 0x5d, 0x62, 0x52, 0x2a, 0xd1, 0xfe, 0xcc,
1355        0xa2, 0xf3, 0x40, 0xfd, 0x01, 0xa7, 0x54, 0x0a,
1356        0xa1, 0xfb, 0x1c, 0xf2, 0x44, 0xa6, 0x47, 0x30,
1357        0x5a, 0xba, 0x2a, 0x05, 0xff, 0xd0, 0x6c, 0xab,
1358        0xeb, 0xe6, 0x8f, 0xf6, 0xd7, 0x73, 0xa3, 0x0e,
1359        0x6c, 0x0e, 0xcf, 0xfd, 0x8e, 0x16, 0x5d, 0xe0,
1360        0x2c, 0x11, 0x05, 0x82, 0x3c, 0x22, 0x16, 0x6c,
1361        0x52, 0x61, 0xcf, 0xbb, 0xff, 0xf8, 0x06, 0xd0
1362    };
1363
1364    rc = linuxkm_test_kpp_driver(WOLFKM_FFDHE2048_DRIVER,
1365                                 b_pub, expected_a_pub, sizeof(b_pub),
1366                                 secret, sizeof(secret),
1367                                 shared_secret, sizeof(shared_secret));
1368
1369    return rc;
1370}
1371#endif /* HAVE_FFDHE_2048 */
1372
1373#ifdef HAVE_FFDHE_3072
1374static int linuxkm_test_ffdhe3072(void)
1375{
1376    int rc = 0;
1377
1378    /* reference values from kernel crypto/testmgr.h */
1379    /* 400 byte secret size */
1380    static const byte secret[] = {
1381#ifdef LITTLE_ENDIAN_ORDER
1382        0x01, 0x00, /* type */
1383        0x90, 0x01, /* len */
1384        0x80, 0x01, 0x00, 0x00, /* key_size */
1385        0x00, 0x00, 0x00, 0x00, /* p_size */
1386        0x00, 0x00, 0x00, 0x00, /* g_size */
1387#else
1388        0x00, 0x01, /* type */
1389        0x01, 0x90, /* len */
1390        0x00, 0x00, 0x01, 0x80, /* key_size */
1391        0x00, 0x00, 0x00, 0x00, /* p_size */
1392        0x00, 0x00, 0x00, 0x00, /* g_size */
1393#endif
1394        /* xa */
1395        0x6b, 0xb4, 0x97, 0x23, 0xfa, 0xc8, 0x5e, 0xa9,
1396        0x7b, 0x63, 0xe7, 0x3e, 0x0e, 0x99, 0xc3, 0xb9,
1397        0xda, 0xb7, 0x48, 0x0d, 0xc3, 0xb1, 0xbf, 0x4f,
1398        0x17, 0xc7, 0xa9, 0x51, 0xf6, 0x64, 0xff, 0xc4,
1399        0x31, 0x58, 0x87, 0x25, 0x83, 0x2c, 0x00, 0xf0,
1400        0x41, 0x29, 0xf7, 0xee, 0xf9, 0xe6, 0x36, 0x76,
1401        0xd6, 0x3a, 0x24, 0xbe, 0xa7, 0x07, 0x0b, 0x93,
1402        0xc7, 0x9f, 0x6c, 0x75, 0x0a, 0x26, 0x75, 0x76,
1403        0xe3, 0x0c, 0x42, 0xe0, 0x00, 0x04, 0x69, 0xd9,
1404        0xec, 0x0b, 0x59, 0x54, 0x28, 0x8f, 0xd7, 0x9a,
1405        0x63, 0xf4, 0x5b, 0xdf, 0x85, 0x65, 0xc4, 0xe1,
1406        0x95, 0x27, 0x4a, 0x42, 0xad, 0x36, 0x47, 0xa9,
1407        0x0a, 0xf8, 0x14, 0x1c, 0xf3, 0x94, 0x3b, 0x7e,
1408        0x47, 0x99, 0x35, 0xa8, 0x18, 0xec, 0x70, 0x10,
1409        0xdf, 0xcb, 0xd2, 0x78, 0x88, 0xc1, 0x2d, 0x59,
1410        0x93, 0xc1, 0xa4, 0x6d, 0xd7, 0x1d, 0xb9, 0xd5,
1411        0xf8, 0x30, 0x06, 0x7f, 0x98, 0x90, 0x0c, 0x74,
1412        0x5e, 0x89, 0x2f, 0x64, 0x5a, 0xad, 0x5f, 0x53,
1413        0xb2, 0xa3, 0xa8, 0x83, 0xbf, 0xfc, 0x37, 0xef,
1414        0xb8, 0x36, 0x0a, 0x5c, 0x62, 0x81, 0x64, 0x74,
1415        0x16, 0x2f, 0x45, 0x39, 0x2a, 0x91, 0x26, 0x87,
1416        0xc0, 0x12, 0xcc, 0x75, 0x11, 0xa3, 0xa1, 0xc5,
1417        0xae, 0x20, 0xcf, 0xcb, 0x20, 0x25, 0x6b, 0x7a,
1418        0x31, 0x93, 0x9d, 0x38, 0xb9, 0x57, 0x72, 0x46,
1419        0xd4, 0x84, 0x65, 0x87, 0xf1, 0xb5, 0xd3, 0xab,
1420        0xfc, 0xc3, 0x4d, 0x40, 0x92, 0x94, 0x1e, 0xcd,
1421        0x1c, 0x87, 0xec, 0x3f, 0xcd, 0xbe, 0xd0, 0x95,
1422        0x6b, 0x40, 0x02, 0xdd, 0x62, 0xeb, 0x0a, 0xda,
1423        0x4f, 0xbe, 0x8e, 0x32, 0x48, 0x8b, 0x6d, 0x83,
1424        0xa0, 0x96, 0x62, 0x23, 0xec, 0x83, 0x91, 0x44,
1425        0xf9, 0x72, 0x01, 0xac, 0xa0, 0xe4, 0x72, 0x1d,
1426        0x5a, 0x75, 0x05, 0x57, 0x90, 0xae, 0x7e, 0xb4,
1427        0x71, 0x39, 0x01, 0x05, 0xdc, 0xe9, 0xee, 0xcb,
1428        0xf0, 0x61, 0x28, 0x91, 0x69, 0x8c, 0x31, 0x03,
1429        0x7a, 0x92, 0x15, 0xa1, 0x58, 0x67, 0x3d, 0x70,
1430        0x82, 0xa6, 0x2c, 0xfe, 0x10, 0x56, 0x58, 0xd3,
1431        0x94, 0x67, 0xe1, 0xbe, 0xee, 0xc1, 0x64, 0x5c,
1432        0x4b, 0xc8, 0x28, 0x3d, 0xc5, 0x66, 0x3a, 0xab,
1433        0x22, 0xc1, 0x7e, 0xa1, 0xbb, 0xf3, 0x19, 0x3b,
1434        0xda, 0x46, 0x82, 0x45, 0xd4, 0x3c, 0x7c, 0xc6,
1435        0xce, 0x1f, 0x7f, 0x95, 0xa2, 0x17, 0xff, 0x88,
1436        0xba, 0xd6, 0x4d, 0xdb, 0xd2, 0xea, 0xde, 0x39,
1437        0xd6, 0xa5, 0x18, 0x73, 0xbb, 0x64, 0x6e, 0x79,
1438        0xe9, 0xdc, 0x3f, 0x92, 0x7f, 0xda, 0x1f, 0x49,
1439        0x33, 0x70, 0x65, 0x73, 0xa2, 0xd9, 0x06, 0xb8,
1440        0x1b, 0x29, 0x29, 0x1a, 0xe0, 0xa3, 0xe6, 0x05,
1441        0x9a, 0xa8, 0xc2, 0x4e, 0x7a, 0x78, 0x1d, 0x22,
1442        0x57, 0x21, 0xc8, 0xa3, 0x8d, 0x66, 0x3e, 0x23
1443    };
1444
1445    /* 384 byte pub key */
1446    static const byte b_pub[] = {
1447        0x73, 0x40, 0x8b, 0xce, 0xe8, 0x6a, 0x1c, 0x03,
1448        0x50, 0x54, 0x42, 0x36, 0x22, 0xc6, 0x1d, 0xe8,
1449        0xe1, 0xef, 0x5c, 0x89, 0xa5, 0x55, 0xc1, 0xc4,
1450        0x1c, 0xd7, 0x4f, 0xee, 0x5d, 0xba, 0x62, 0x60,
1451        0xfe, 0x93, 0x2f, 0xfd, 0x93, 0x2c, 0x8f, 0x70,
1452        0xc6, 0x47, 0x17, 0x25, 0xb2, 0x95, 0xd7, 0x7d,
1453        0x41, 0x81, 0x4d, 0x52, 0x1c, 0xbe, 0x4d, 0x57,
1454        0x3e, 0x26, 0x51, 0x28, 0x03, 0x8f, 0x67, 0xf5,
1455        0x22, 0x16, 0x1c, 0x67, 0xf7, 0x62, 0xcb, 0xfd,
1456        0xa3, 0xee, 0x8d, 0xe0, 0xfa, 0x15, 0x9a, 0x53,
1457        0xbe, 0x7b, 0x9f, 0xc0, 0x12, 0x7a, 0xfc, 0x5e,
1458        0x77, 0x2d, 0x60, 0x06, 0xba, 0x71, 0xc5, 0xca,
1459        0xd7, 0x26, 0xaf, 0x3b, 0xba, 0x6f, 0xd3, 0xc4,
1460        0x82, 0x57, 0x19, 0x26, 0xb0, 0x16, 0x7b, 0xbd,
1461        0x83, 0xf2, 0x21, 0x03, 0x79, 0xff, 0x0a, 0x6f,
1462        0xc5, 0x7b, 0x00, 0x15, 0xad, 0x5b, 0xf4, 0x42,
1463        0x1f, 0xcb, 0x7f, 0x3d, 0x34, 0x77, 0x3c, 0xc3,
1464        0xe0, 0x38, 0xa5, 0x40, 0x51, 0xbe, 0x6f, 0xd9,
1465        0xc9, 0x77, 0x9c, 0xfc, 0x0d, 0xc1, 0x8e, 0xef,
1466        0x0f, 0xaa, 0x5e, 0xa8, 0xbb, 0x16, 0x4a, 0x3e,
1467        0x26, 0x55, 0xae, 0xc1, 0xb6, 0x3e, 0xfd, 0x73,
1468        0xf7, 0x59, 0xd2, 0xe5, 0x4b, 0x91, 0x8e, 0x28,
1469        0x77, 0x1e, 0x5a, 0xe2, 0xcd, 0xce, 0x92, 0x35,
1470        0xbb, 0x1e, 0xbb, 0xcf, 0x79, 0x94, 0xdf, 0x31,
1471        0xde, 0x31, 0xa8, 0x75, 0xf6, 0xe0, 0xaa, 0x2e,
1472        0xe9, 0x4f, 0x44, 0xc8, 0xba, 0xb9, 0xab, 0x80,
1473        0x29, 0xa1, 0xea, 0x58, 0x2e, 0x40, 0x96, 0xa0,
1474        0x1a, 0xf5, 0x2c, 0x38, 0x47, 0x43, 0x5d, 0x26,
1475        0x2c, 0xd8, 0xad, 0xea, 0xd3, 0xad, 0xe8, 0x51,
1476        0x49, 0xad, 0x45, 0x2b, 0x25, 0x7c, 0xde, 0xe4,
1477        0xaf, 0x03, 0x2a, 0x39, 0x26, 0x86, 0x66, 0x10,
1478        0xbc, 0xa8, 0x71, 0xda, 0xe0, 0xe8, 0xf1, 0xdd,
1479        0x50, 0xff, 0x44, 0xb2, 0xd3, 0xc7, 0xff, 0x66,
1480        0x63, 0xf6, 0x42, 0xe3, 0x97, 0x9d, 0x9e, 0xf4,
1481        0xa6, 0x89, 0xb9, 0xab, 0x12, 0x17, 0xf2, 0x85,
1482        0x56, 0x9c, 0x6b, 0x24, 0x71, 0x83, 0x57, 0x7d,
1483        0x3c, 0x7b, 0x2b, 0x88, 0x92, 0x19, 0xd7, 0x1a,
1484        0x00, 0xd5, 0x38, 0x94, 0x43, 0x60, 0x4d, 0xa7,
1485        0x12, 0x9e, 0x0d, 0xf6, 0x5c, 0x9a, 0xd3, 0xe2,
1486        0x9e, 0xb1, 0x21, 0xe8, 0xe2, 0x9e, 0xe9, 0x1e,
1487        0x9d, 0xa5, 0x94, 0x95, 0xa6, 0x3d, 0x12, 0x15,
1488        0xd8, 0x8b, 0xac, 0xe0, 0x8c, 0xde, 0xe6, 0x40,
1489        0x98, 0xaa, 0x5e, 0x55, 0x4f, 0x3d, 0x86, 0x87,
1490        0x0d, 0xe3, 0xc6, 0x68, 0x15, 0xe6, 0xde, 0x17,
1491        0x78, 0x21, 0xc8, 0x6c, 0x06, 0xc7, 0x94, 0x56,
1492        0xb4, 0xaf, 0xa2, 0x35, 0x0b, 0x0c, 0x97, 0xd7,
1493        0xa4, 0x12, 0xee, 0xf4, 0xd2, 0xef, 0x80, 0x28,
1494        0xb3, 0xee, 0xe9, 0x15, 0x8b, 0x01, 0x32, 0x79
1495    };
1496
1497    /* 384 byte pub key */
1498    static const byte expected_a_pub[] = {
1499        0x1b, 0x6a, 0xba, 0xea, 0xa3, 0xcc, 0x50, 0x69,
1500        0xa9, 0x41, 0x89, 0xaf, 0x04, 0xe1, 0x44, 0x22,
1501        0x97, 0x20, 0xd1, 0xf6, 0x1e, 0xcb, 0x64, 0x36,
1502        0x6f, 0xee, 0x0b, 0x16, 0xc1, 0xd9, 0x91, 0xbe,
1503        0x57, 0xc8, 0xd9, 0xf2, 0xa1, 0x96, 0x91, 0xec,
1504        0x41, 0xc7, 0x79, 0x00, 0x1a, 0x48, 0x25, 0x55,
1505        0xbe, 0xf3, 0x20, 0x8c, 0x38, 0xc6, 0x7b, 0xf2,
1506        0x8b, 0x5a, 0xc3, 0xb5, 0x87, 0x0a, 0x86, 0x3d,
1507        0xb7, 0xd6, 0xce, 0xb0, 0x96, 0x2e, 0x5d, 0xc4,
1508        0x00, 0x5e, 0x42, 0xe4, 0xe5, 0x50, 0x4f, 0xb8,
1509        0x6f, 0x18, 0xa4, 0xe1, 0xd3, 0x20, 0xfc, 0x3c,
1510        0xf5, 0x0a, 0xff, 0x23, 0xa6, 0x5b, 0xb4, 0x17,
1511        0x3e, 0x7b, 0xdf, 0xb9, 0xb5, 0x3c, 0x1b, 0x76,
1512        0x29, 0xcd, 0xb4, 0x46, 0x4f, 0x27, 0x8f, 0xd2,
1513        0xe8, 0x27, 0x66, 0xdb, 0xe8, 0xb3, 0xf5, 0xe1,
1514        0xd0, 0x04, 0xcd, 0x89, 0xff, 0xba, 0x76, 0x67,
1515        0xe8, 0x4d, 0xcf, 0x86, 0x1c, 0x8a, 0xd1, 0xcf,
1516        0x99, 0x27, 0xfb, 0xa9, 0x78, 0xcc, 0x94, 0xaf,
1517        0x3d, 0x04, 0xfd, 0x25, 0xc0, 0x47, 0xfa, 0x29,
1518        0x80, 0x05, 0xf4, 0xde, 0xad, 0xdb, 0xab, 0x12,
1519        0xb0, 0x2b, 0x8e, 0xca, 0x02, 0x06, 0x6d, 0xad,
1520        0x3e, 0x09, 0xb1, 0x22, 0xa3, 0xf5, 0x4c, 0x6d,
1521        0x69, 0x99, 0x58, 0x8b, 0xd8, 0x45, 0x2e, 0xe0,
1522        0xc9, 0x3c, 0xf7, 0x92, 0xce, 0x21, 0x90, 0x6b,
1523        0x3b, 0x65, 0x9f, 0x64, 0x79, 0x8d, 0x67, 0x22,
1524        0x1a, 0x37, 0xd3, 0xee, 0x51, 0xe2, 0xe7, 0x5a,
1525        0x93, 0x51, 0xaa, 0x3c, 0x4b, 0x04, 0x16, 0x32,
1526        0xef, 0xe3, 0x66, 0xbe, 0x18, 0x94, 0x88, 0x64,
1527        0x79, 0xce, 0x06, 0x3f, 0xb8, 0xd6, 0xee, 0xdc,
1528        0x13, 0x79, 0x6f, 0x20, 0x14, 0xc2, 0x6b, 0xce,
1529        0xc8, 0xda, 0x42, 0xa5, 0x93, 0x5b, 0xe4, 0x7f,
1530        0x1a, 0xe6, 0xda, 0x0f, 0xb3, 0xc1, 0x5f, 0x30,
1531        0x50, 0x76, 0xe8, 0x37, 0x3d, 0xca, 0x77, 0x2c,
1532        0xa8, 0xe4, 0x3b, 0xf9, 0x6f, 0xe0, 0x17, 0xed,
1533        0x0e, 0xef, 0xb7, 0x31, 0x14, 0xb5, 0xea, 0xd9,
1534        0x39, 0x22, 0x89, 0xb6, 0x40, 0x57, 0xcc, 0x84,
1535        0xef, 0x73, 0xa7, 0xe9, 0x27, 0x21, 0x85, 0x89,
1536        0xfa, 0xaf, 0x03, 0xda, 0x9c, 0x8b, 0xfd, 0x52,
1537        0x7d, 0xb0, 0xa4, 0xe4, 0xf9, 0xd8, 0x90, 0x55,
1538        0xc4, 0x39, 0xd6, 0x9d, 0xaf, 0x3b, 0xce, 0xac,
1539        0xaa, 0x36, 0x14, 0x7a, 0x9b, 0x8b, 0x12, 0x43,
1540        0xe1, 0xca, 0x61, 0xae, 0x46, 0x5b, 0xe7, 0xe5,
1541        0x88, 0x32, 0x80, 0xa0, 0x2d, 0x51, 0xbb, 0x2f,
1542        0xea, 0xeb, 0x3c, 0x71, 0xb2, 0xae, 0xce, 0xca,
1543        0x61, 0xd2, 0x76, 0xe0, 0x45, 0x46, 0x78, 0x4e,
1544        0x09, 0x2d, 0xc2, 0x54, 0xc2, 0xa9, 0xc7, 0xa8,
1545        0x55, 0x8e, 0x72, 0xa4, 0x8b, 0x8a, 0xc9, 0x01,
1546        0xdb, 0xe9, 0x58, 0x11, 0xa1, 0xc4, 0xe7, 0x12
1547    };
1548
1549    /* 384 byte shared secret */
1550    static const byte shared_secret[] = {
1551        0x47, 0x8e, 0xb2, 0x19, 0x09, 0xf0, 0x46, 0x99,
1552        0x6b, 0x41, 0x86, 0xf7, 0x34, 0xad, 0xbf, 0x2a,
1553        0x18, 0x1b, 0x7d, 0xec, 0xa9, 0xb2, 0x47, 0x2f,
1554        0x40, 0xfb, 0x9a, 0x64, 0x30, 0x44, 0xf3, 0x4c,
1555        0x01, 0x67, 0xad, 0x57, 0x5a, 0xbc, 0xd4, 0xc8,
1556        0xef, 0x7e, 0x8a, 0x14, 0x74, 0x1d, 0x6d, 0x8c,
1557        0x7b, 0xce, 0xc5, 0x57, 0x5f, 0x95, 0xe8, 0x72,
1558        0xba, 0xdf, 0xa3, 0xcd, 0x00, 0xbe, 0x09, 0x4c,
1559        0x06, 0x72, 0xe7, 0x17, 0xb0, 0xe5, 0xe5, 0xb7,
1560        0x20, 0xa5, 0xcb, 0xd9, 0x68, 0x99, 0xad, 0x3f,
1561        0xde, 0xf3, 0xde, 0x1d, 0x1c, 0x00, 0x74, 0xd2,
1562        0xd1, 0x57, 0x55, 0x5d, 0xce, 0x76, 0x0c, 0xc4,
1563        0x7a, 0xc4, 0x65, 0x7c, 0x19, 0x17, 0x0a, 0x09,
1564        0x66, 0x7d, 0x3a, 0xab, 0xf7, 0x61, 0x3a, 0xe3,
1565        0x5b, 0xac, 0xcf, 0x69, 0xb0, 0x8b, 0xee, 0x5d,
1566        0x28, 0x36, 0xbb, 0x3f, 0x74, 0xce, 0x6e, 0x38,
1567        0x1e, 0x39, 0xab, 0x26, 0xca, 0x89, 0xdc, 0x58,
1568        0x59, 0xcb, 0x95, 0xe4, 0xbc, 0xd6, 0x19, 0x48,
1569        0xd0, 0x55, 0x68, 0x7b, 0xb4, 0x27, 0x95, 0x3c,
1570        0xd9, 0x58, 0x10, 0x4f, 0x8f, 0x55, 0x1c, 0x3f,
1571        0x04, 0xce, 0x89, 0x1f, 0x82, 0x28, 0xe9, 0x48,
1572        0x17, 0x47, 0x8f, 0xee, 0xb7, 0x8f, 0xeb, 0xb1,
1573        0x29, 0xa8, 0x23, 0x18, 0x73, 0x33, 0x9f, 0x83,
1574        0x08, 0xca, 0xcd, 0x54, 0x6e, 0xca, 0xec, 0x78,
1575        0x7b, 0x16, 0x83, 0x3f, 0xdb, 0x0a, 0xef, 0xfd,
1576        0x87, 0x94, 0x19, 0x08, 0x6e, 0x6e, 0x22, 0x57,
1577        0xd7, 0xd2, 0x79, 0xf9, 0xf6, 0xeb, 0xe0, 0x6c,
1578        0x93, 0x9d, 0x95, 0xfa, 0x41, 0x7a, 0xa9, 0xd6,
1579        0x2a, 0xa3, 0x26, 0x9b, 0x24, 0x1b, 0x8b, 0xa0,
1580        0xed, 0x04, 0xb2, 0xe4, 0x6c, 0x4e, 0xc4, 0x3f,
1581        0x61, 0xe5, 0xe0, 0x4d, 0x09, 0x28, 0xaf, 0x58,
1582        0x35, 0x25, 0x0b, 0xd5, 0x38, 0x18, 0x69, 0x51,
1583        0x18, 0x51, 0x73, 0x7b, 0x28, 0x19, 0x9f, 0xe4,
1584        0x69, 0xfc, 0x2c, 0x25, 0x08, 0x99, 0x8f, 0x62,
1585        0x65, 0x62, 0xa5, 0x28, 0xf1, 0xf4, 0xfb, 0x02,
1586        0x29, 0x27, 0xb0, 0x5e, 0xbb, 0x4f, 0xf9, 0x1a,
1587        0xa7, 0xc4, 0x38, 0x63, 0x5b, 0x01, 0xfe, 0x00,
1588        0x66, 0xe3, 0x47, 0x77, 0x21, 0x85, 0x17, 0xd5,
1589        0x34, 0x19, 0xd3, 0x87, 0xab, 0x44, 0x62, 0x08,
1590        0x59, 0xb2, 0x6b, 0x1f, 0x21, 0x0c, 0x23, 0x84,
1591        0xf7, 0xba, 0x92, 0x67, 0xf9, 0x16, 0x85, 0x6a,
1592        0xe0, 0xeb, 0xe7, 0x4f, 0x06, 0x80, 0x81, 0x81,
1593        0x28, 0x9c, 0xe8, 0x2e, 0x71, 0x97, 0x48, 0xe0,
1594        0xd1, 0xbc, 0xce, 0xe9, 0x42, 0x2c, 0x89, 0xdf,
1595        0x0b, 0xa9, 0xa1, 0x07, 0x84, 0x33, 0x78, 0x7f,
1596        0x49, 0x2f, 0x1c, 0x55, 0xc3, 0x7f, 0xc3, 0x37,
1597        0x40, 0xdf, 0x13, 0xf4, 0xa0, 0x21, 0x79, 0x6e,
1598        0x3a, 0xe3, 0xb8, 0x23, 0x9e, 0x8a, 0x6e, 0x9c
1599    };
1600
1601    rc = linuxkm_test_kpp_driver(WOLFKM_FFDHE3072_DRIVER,
1602                                 b_pub, expected_a_pub, sizeof(b_pub),
1603                                 secret, sizeof(secret),
1604                                 shared_secret, sizeof(shared_secret));
1605
1606    return rc;
1607}
1608#endif /* HAVE_FFDHE_3072 */
1609
1610#ifdef HAVE_FFDHE_4096
1611static int linuxkm_test_ffdhe4096(void)
1612{
1613    int rc = 0;
1614
1615    /* reference values from kernel crypto/testmgr.h */
1616    /* 528 byte secret size */
1617    static const byte secret[] = {
1618#ifdef LITTLE_ENDIAN_ORDER
1619        0x01, 0x00, /* type */
1620        0x10, 0x02, /* len */
1621        0x00, 0x02, 0x00, 0x00, /* key_size */
1622        0x00, 0x00, 0x00, 0x00, /* p_size */
1623        0x00, 0x00, 0x00, 0x00, /* g_size */
1624#else
1625        0x00, 0x01, /* type */
1626        0x02, 0x10, /* len */
1627        0x00, 0x00, 0x02, 0x00, /* key_size */
1628        0x00, 0x00, 0x00, 0x00, /* p_size */
1629        0x00, 0x00, 0x00, 0x00, /* g_size */
1630#endif
1631        /* xa */
1632        0x1a, 0x48, 0xf3, 0x6c, 0x61, 0x03, 0x42, 0x43,
1633        0xd7, 0x42, 0x3b, 0xfa, 0xdb, 0x55, 0x6f, 0xa2,
1634        0xe1, 0x79, 0x52, 0x0b, 0x47, 0xc5, 0x03, 0x60,
1635        0x2f, 0x26, 0xb9, 0x1a, 0x14, 0x15, 0x1a, 0xd9,
1636        0xe0, 0xbb, 0xa7, 0x82, 0x63, 0x41, 0xec, 0x26,
1637        0x55, 0x00, 0xab, 0xe5, 0x21, 0x9d, 0x31, 0x14,
1638        0x0e, 0xe2, 0xc2, 0xb2, 0xb8, 0x37, 0xe6, 0xc3,
1639        0x5a, 0xab, 0xae, 0x25, 0xdb, 0x71, 0x1e, 0xed,
1640        0xe8, 0x75, 0x9a, 0x04, 0xa7, 0x92, 0x2a, 0x99,
1641        0x7e, 0xc0, 0x5b, 0x64, 0x75, 0x7f, 0xe5, 0xb5,
1642        0xdb, 0x6c, 0x95, 0x4f, 0xe9, 0xdc, 0x39, 0x76,
1643        0x79, 0xb0, 0xf7, 0x00, 0x30, 0x8e, 0x86, 0xe7,
1644        0x36, 0xd1, 0xd2, 0x0c, 0x68, 0x7b, 0x94, 0xe9,
1645        0x91, 0x85, 0x08, 0x86, 0xbc, 0x64, 0x87, 0xd2,
1646        0xf5, 0x5b, 0xaf, 0x03, 0xf6, 0x5f, 0x28, 0x25,
1647        0xf1, 0xa3, 0x20, 0x5c, 0x1b, 0xb5, 0x26, 0x45,
1648        0x9a, 0x47, 0xab, 0xd6, 0xad, 0x49, 0xab, 0x92,
1649        0x8e, 0x62, 0x6f, 0x48, 0x31, 0xea, 0xf6, 0x76,
1650        0xff, 0xa2, 0xb6, 0x28, 0x78, 0xef, 0x59, 0xc3,
1651        0x71, 0x5d, 0xa8, 0xd9, 0x70, 0x89, 0xcc, 0xe2,
1652        0x63, 0x58, 0x5e, 0x3a, 0xa2, 0xa2, 0x88, 0xbf,
1653        0x77, 0x20, 0x84, 0x33, 0x65, 0x64, 0x4e, 0x73,
1654        0xe5, 0x08, 0xd5, 0x89, 0x23, 0xd6, 0x07, 0xac,
1655        0x29, 0x65, 0x2e, 0x02, 0xa8, 0x35, 0x96, 0x48,
1656        0xe7, 0x5d, 0x43, 0x6a, 0x42, 0xcc, 0xda, 0x98,
1657        0xc4, 0x75, 0x90, 0x2e, 0xf6, 0xc4, 0xbf, 0xd4,
1658        0xbc, 0x31, 0x14, 0x0d, 0x54, 0x30, 0x11, 0xb2,
1659        0xc9, 0xcf, 0xbb, 0xba, 0xbc, 0xc6, 0xf2, 0xcf,
1660        0xfe, 0x4a, 0x9d, 0xf3, 0xec, 0x78, 0x5d, 0x5d,
1661        0xb4, 0x99, 0xd0, 0x67, 0x0f, 0x5a, 0x21, 0x1c,
1662        0x7b, 0x95, 0x2b, 0xcf, 0x49, 0x44, 0x94, 0x05,
1663        0x1a, 0x21, 0x81, 0x25, 0x7f, 0xe3, 0x8a, 0x2a,
1664        0xdd, 0x88, 0xac, 0x44, 0x94, 0x23, 0x20, 0x3b,
1665        0x75, 0xf6, 0x2a, 0x8a, 0x45, 0xf8, 0xb5, 0x1f,
1666        0xb9, 0x8b, 0xeb, 0xab, 0x9b, 0x38, 0x23, 0x26,
1667        0xf1, 0x0f, 0x34, 0x47, 0x4f, 0x7f, 0xe1, 0x9e,
1668        0x84, 0x84, 0x78, 0xe5, 0xe3, 0x49, 0xeb, 0xcc,
1669        0x2f, 0x02, 0x85, 0xa4, 0x18, 0x91, 0xde, 0x1a,
1670        0x60, 0x54, 0x33, 0x81, 0xd5, 0xae, 0xdb, 0x23,
1671        0x9c, 0x4d, 0xa4, 0xdb, 0x22, 0x5b, 0xdf, 0xf4,
1672        0x8e, 0x05, 0x2b, 0x60, 0xba, 0xe8, 0x75, 0xfc,
1673        0x34, 0x99, 0xcf, 0x35, 0xe1, 0x06, 0xba, 0xdc,
1674        0x79, 0x2a, 0x5e, 0xec, 0x1c, 0xbe, 0x79, 0x33,
1675        0x63, 0x1c, 0xe7, 0x5f, 0x1e, 0x30, 0xd6, 0x1b,
1676        0xdb, 0x11, 0xb8, 0xea, 0x63, 0xff, 0xfe, 0x1a,
1677        0x3c, 0x24, 0xf4, 0x78, 0x9c, 0xcc, 0x5d, 0x9a,
1678        0xc9, 0x2d, 0xc4, 0x9a, 0xd4, 0xa7, 0x65, 0x84,
1679        0x98, 0xdb, 0x66, 0x76, 0xf0, 0x34, 0x31, 0x9f,
1680        0xce, 0xb5, 0xfb, 0x28, 0x07, 0xde, 0x1e, 0x0d,
1681        0x9b, 0x01, 0x64, 0xeb, 0x2a, 0x37, 0x2f, 0x20,
1682        0xa5, 0x95, 0x72, 0x2b, 0x54, 0x51, 0x59, 0x91,
1683        0xea, 0x50, 0x54, 0x0f, 0x2e, 0xb0, 0x1d, 0xf6,
1684        0xb9, 0x46, 0x43, 0xf9, 0xd0, 0x13, 0x21, 0x20,
1685        0x47, 0x61, 0x1a, 0x1c, 0x30, 0xc6, 0x9e, 0x75,
1686        0x22, 0xe4, 0xf2, 0xb1, 0xab, 0x01, 0xdc, 0x5b,
1687        0x3c, 0x1e, 0xa2, 0x6d, 0xc0, 0xb9, 0x9a, 0x2a,
1688        0x84, 0x61, 0xea, 0x85, 0x63, 0xa0, 0x77, 0xd0,
1689        0xeb, 0x20, 0x68, 0xd5, 0x95, 0x6a, 0x1b, 0x8f,
1690        0x1f, 0x9a, 0xba, 0x44, 0x49, 0x8c, 0x77, 0xa6,
1691        0xd9, 0xa0, 0x14, 0xf8, 0x7d, 0x9b, 0x4e, 0xfa,
1692        0xdc, 0x4f, 0x1c, 0x4d, 0x60, 0x50, 0x26, 0x7f,
1693        0xd6, 0xc1, 0x91, 0x2b, 0xa6, 0x37, 0x5d, 0x94,
1694        0x69, 0xb2, 0x47, 0x59, 0xd6, 0xc3, 0x59, 0xbb,
1695        0xd6, 0x9b, 0x71, 0x52, 0x85, 0x7a, 0xcb, 0x2d
1696    };
1697
1698    /* 512 byte pub key */
1699    static const byte b_pub[] = {
1700        0x24, 0x38, 0x02, 0x02, 0x2f, 0xeb, 0x54, 0xdd,
1701        0x73, 0x21, 0x91, 0x4a, 0xd8, 0xa4, 0x0a, 0xbf,
1702        0xf4, 0xf5, 0x9a, 0x45, 0xb5, 0xcd, 0x42, 0xa3,
1703        0x57, 0xcc, 0x65, 0x4a, 0x23, 0x2e, 0xee, 0x59,
1704        0xba, 0x6f, 0x14, 0x89, 0xae, 0x2e, 0x14, 0x0a,
1705        0x72, 0x77, 0x23, 0x7f, 0x6c, 0x2e, 0xba, 0x52,
1706        0x3f, 0x71, 0xbf, 0xe4, 0x60, 0x03, 0x16, 0xaa,
1707        0x61, 0xf5, 0x80, 0x1d, 0x8a, 0x45, 0x9e, 0x53,
1708        0x7b, 0x07, 0xd9, 0x7e, 0xfe, 0xaf, 0xcb, 0xda,
1709        0xff, 0x20, 0x71, 0xba, 0x89, 0x39, 0x75, 0xc3,
1710        0xb3, 0x65, 0x0c, 0xb1, 0xa7, 0xfa, 0x4a, 0xe7,
1711        0xe0, 0x85, 0xc5, 0x4e, 0x91, 0x47, 0x41, 0xf4,
1712        0xdd, 0xcd, 0xc5, 0x3d, 0x17, 0x12, 0xed, 0xee,
1713        0xc0, 0x31, 0xb1, 0xaf, 0xc1, 0xd5, 0x3c, 0x07,
1714        0xa1, 0x5a, 0xc4, 0x05, 0x45, 0xe3, 0x10, 0x0c,
1715        0xc3, 0x14, 0xae, 0x65, 0xca, 0x40, 0xae, 0x31,
1716        0x5c, 0x13, 0x0d, 0x32, 0x85, 0xa7, 0x6e, 0xf4,
1717        0x5e, 0x29, 0x3d, 0x4e, 0xd3, 0xd7, 0x49, 0x58,
1718        0xe1, 0x73, 0xbb, 0x0a, 0x7b, 0xd6, 0x13, 0xea,
1719        0x49, 0xd7, 0x20, 0x3d, 0x31, 0xaa, 0x77, 0xab,
1720        0x21, 0x74, 0xe9, 0x2f, 0xe9, 0x5e, 0xbe, 0x2f,
1721        0xb4, 0xa2, 0x79, 0xf2, 0xbc, 0xcc, 0x51, 0x94,
1722        0xd2, 0x1d, 0xb2, 0xe6, 0xc5, 0x39, 0x66, 0xd7,
1723        0xe5, 0x46, 0x75, 0x53, 0x76, 0xed, 0x49, 0xea,
1724        0x3b, 0xdd, 0x01, 0x27, 0xdb, 0x83, 0xa5, 0x9f,
1725        0xd2, 0xee, 0xc8, 0xde, 0x9e, 0xde, 0xd2, 0xe7,
1726        0x99, 0xad, 0x9c, 0xe0, 0x71, 0x66, 0x29, 0xd8,
1727        0x0d, 0xfe, 0xdc, 0xd1, 0xbc, 0xc7, 0x9a, 0xbe,
1728        0x8b, 0x26, 0x46, 0x57, 0xb6, 0x79, 0xfa, 0xad,
1729        0x8b, 0x45, 0x2e, 0xb5, 0xe5, 0x89, 0x34, 0x01,
1730        0x93, 0x00, 0x9d, 0xe9, 0x58, 0x74, 0x8b, 0xda,
1731        0x07, 0x92, 0xb5, 0x01, 0x4a, 0xe1, 0x44, 0x36,
1732        0xc7, 0x6c, 0xde, 0xc8, 0x7a, 0x17, 0xd0, 0xde,
1733        0xee, 0x68, 0x92, 0xb5, 0xde, 0x21, 0x2b, 0x1c,
1734        0xbc, 0x65, 0x30, 0x1e, 0xae, 0x15, 0x3d, 0x9a,
1735        0xaf, 0x20, 0xa3, 0xc4, 0x21, 0x70, 0xfb, 0x2f,
1736        0x36, 0x72, 0x31, 0xc0, 0xe8, 0x85, 0xdf, 0xc5,
1737        0x50, 0x4c, 0x90, 0x10, 0x32, 0xa4, 0xc7, 0xee,
1738        0x59, 0x5a, 0x21, 0xf4, 0xf1, 0x33, 0xcf, 0xbe,
1739        0xac, 0x67, 0xb1, 0x40, 0x7c, 0x0b, 0x3f, 0x64,
1740        0xe5, 0xd2, 0x2d, 0xb7, 0x7d, 0x0f, 0xce, 0xf7,
1741        0x9b, 0x05, 0xee, 0x37, 0x61, 0xd2, 0x61, 0x9e,
1742        0x1a, 0x80, 0x2e, 0x79, 0xe6, 0x1b, 0x25, 0xb3,
1743        0x61, 0x3d, 0x53, 0xe7, 0xe5, 0x97, 0x9a, 0xc2,
1744        0x39, 0xb1, 0xe3, 0x91, 0xc6, 0xee, 0x96, 0x2e,
1745        0xa9, 0xb4, 0xb8, 0xad, 0xd8, 0x04, 0x3e, 0x11,
1746        0x31, 0x67, 0xb8, 0x6a, 0xcb, 0x6e, 0x1a, 0x4c,
1747        0x7f, 0x74, 0xc7, 0x1f, 0x09, 0xd1, 0xd0, 0x6b,
1748        0x17, 0xde, 0xea, 0xe8, 0x0b, 0xe6, 0x6a, 0xee,
1749        0x2f, 0xe3, 0x5b, 0x9c, 0x59, 0x5d, 0x00, 0x57,
1750        0xbf, 0x24, 0x25, 0xba, 0x22, 0x34, 0xb9, 0xc5,
1751        0x3c, 0xc4, 0x57, 0x26, 0xd0, 0x6d, 0x89, 0xee,
1752        0x67, 0x79, 0x3c, 0x70, 0xf9, 0xc3, 0xb4, 0x30,
1753        0xf0, 0x2e, 0xca, 0xfa, 0x74, 0x00, 0xd1, 0x00,
1754        0x6d, 0x03, 0x97, 0xd5, 0x08, 0x3f, 0x0b, 0x8e,
1755        0xb8, 0x1d, 0xa3, 0x91, 0x7f, 0xa9, 0x3a, 0xf0,
1756        0x37, 0x57, 0x46, 0x87, 0x82, 0xa3, 0xb5, 0x8f,
1757        0x51, 0xaa, 0xc7, 0x7b, 0xfe, 0x86, 0x26, 0xb9,
1758        0xfa, 0xe6, 0x1e, 0xee, 0x92, 0x9d, 0x3a, 0xed,
1759        0x5b, 0x5e, 0x3f, 0xe5, 0xca, 0x5e, 0x13, 0x01,
1760        0xdd, 0x4c, 0x8d, 0x85, 0xf0, 0x60, 0x61, 0xb7,
1761        0x60, 0x24, 0x83, 0x9f, 0xbe, 0x72, 0x21, 0x81,
1762        0x55, 0x7e, 0x7e, 0x6d, 0xf3, 0x28, 0xc8, 0x77,
1763        0x5a, 0xae, 0x5a, 0x32, 0x86, 0xd5, 0x61, 0xad
1764    };
1765
1766    /* 512 byte pub key */
1767    static const byte expected_a_pub[] = {
1768        0x1f, 0xff, 0xd6, 0xc4, 0x59, 0xf3, 0x4a, 0x9e,
1769        0x81, 0x74, 0x4d, 0x27, 0xa7, 0xc6, 0x6b, 0x35,
1770        0xd8, 0xf5, 0xb3, 0x24, 0x97, 0x82, 0xe7, 0x2e,
1771        0xf3, 0x21, 0x91, 0x23, 0x2f, 0x3d, 0x57, 0x7f,
1772        0x15, 0x8c, 0x84, 0x71, 0xe7, 0x25, 0x35, 0xe8,
1773        0x07, 0x14, 0x06, 0x4c, 0x83, 0xdc, 0x55, 0x4a,
1774        0xf8, 0x45, 0xc5, 0xe9, 0xfa, 0x6e, 0xae, 0x6e,
1775        0xcf, 0x4d, 0x11, 0x91, 0x26, 0x16, 0x6f, 0x86,
1776        0x89, 0x78, 0xaa, 0xb4, 0x25, 0x54, 0xb2, 0x74,
1777        0x07, 0xe5, 0x26, 0x26, 0x0c, 0xad, 0xa4, 0x57,
1778        0x59, 0x61, 0x66, 0x71, 0x43, 0x22, 0xff, 0x49,
1779        0x51, 0xa4, 0x76, 0x0e, 0x55, 0x7b, 0x60, 0x45,
1780        0x4f, 0xaf, 0xbd, 0x9c, 0xec, 0x64, 0x3f, 0x80,
1781        0x0b, 0x0c, 0x31, 0x41, 0xf0, 0xfe, 0x2c, 0xb7,
1782        0x0a, 0xbe, 0xa5, 0x71, 0x08, 0x0d, 0x8d, 0x1e,
1783        0x8a, 0x77, 0x9a, 0xd2, 0x90, 0x31, 0x96, 0xd0,
1784        0x3b, 0x31, 0xdc, 0xc6, 0x18, 0x59, 0x43, 0xa1,
1785        0x19, 0x5a, 0x84, 0x68, 0x29, 0xad, 0x5e, 0x58,
1786        0xa2, 0x50, 0x3e, 0x83, 0xf5, 0x7a, 0xbd, 0x88,
1787        0x17, 0x60, 0x89, 0x98, 0x9c, 0x19, 0x89, 0x27,
1788        0x89, 0xfc, 0x33, 0x87, 0x42, 0xd5, 0xde, 0x19,
1789        0x14, 0xf2, 0x95, 0x82, 0x10, 0x87, 0xad, 0x82,
1790        0xdd, 0x6b, 0x51, 0x2d, 0x8d, 0x0e, 0x81, 0x4b,
1791        0xde, 0xb3, 0x35, 0x6c, 0x0f, 0x4b, 0x56, 0x45,
1792        0x48, 0x87, 0xe9, 0x5a, 0xf9, 0x70, 0x10, 0x30,
1793        0x8e, 0xa1, 0xbb, 0xa4, 0x70, 0xbf, 0xa0, 0xab,
1794        0x10, 0x31, 0x3c, 0x2c, 0xdc, 0xc4, 0xed, 0xe3,
1795        0x51, 0xdc, 0xee, 0xd2, 0xa5, 0x5c, 0x4e, 0x6e,
1796        0xf6, 0xed, 0x60, 0x5a, 0xeb, 0xf3, 0x02, 0x19,
1797        0x2a, 0x95, 0xe9, 0x46, 0xff, 0x37, 0x1b, 0xf0,
1798        0x1d, 0x10, 0x4a, 0x8f, 0x4f, 0x3a, 0x6e, 0xf5,
1799        0xfc, 0x02, 0x6d, 0x09, 0x7d, 0xea, 0x69, 0x7b,
1800        0x13, 0xb0, 0xb6, 0x80, 0x5c, 0x15, 0x20, 0xa8,
1801        0x4d, 0x15, 0x56, 0x11, 0x72, 0x49, 0xdb, 0x48,
1802        0x54, 0x40, 0x66, 0xd5, 0xcd, 0x17, 0x3a, 0x26,
1803        0x95, 0xf6, 0xd7, 0xf2, 0x59, 0xa3, 0xda, 0xbb,
1804        0x26, 0xd0, 0xe5, 0x46, 0xbf, 0xee, 0x0e, 0x7d,
1805        0xf1, 0xe0, 0x11, 0x02, 0x4d, 0xd3, 0xdc, 0xe2,
1806        0x3f, 0xc2, 0x51, 0x7e, 0xc7, 0x90, 0x33, 0x3c,
1807        0x1c, 0xa0, 0x4c, 0x69, 0xcc, 0x1e, 0xc7, 0xac,
1808        0x17, 0xe0, 0xe5, 0xf4, 0x8c, 0x05, 0x64, 0x34,
1809        0xfe, 0x84, 0x70, 0xd7, 0x6b, 0xed, 0xab, 0xf5,
1810        0x88, 0x9d, 0x3e, 0x4c, 0x5a, 0x9e, 0xd4, 0x74,
1811        0xfd, 0xdd, 0x91, 0xd5, 0xd4, 0xcb, 0xbf, 0xf8,
1812        0xb7, 0x56, 0xb5, 0xe9, 0x22, 0xa6, 0x6d, 0x7a,
1813        0x44, 0x05, 0x41, 0xbf, 0xdb, 0x61, 0x28, 0xc6,
1814        0x99, 0x49, 0x87, 0x3d, 0x28, 0x77, 0xf8, 0x83,
1815        0x23, 0x7e, 0xa9, 0xa7, 0xee, 0x20, 0xdb, 0x6d,
1816        0x21, 0x50, 0xb7, 0xc9, 0x52, 0x57, 0x53, 0xa3,
1817        0xcf, 0xdf, 0xd0, 0xf9, 0xb9, 0x62, 0x96, 0x89,
1818        0xf5, 0x5c, 0xa9, 0x8a, 0x11, 0x95, 0x01, 0x25,
1819        0xc9, 0x81, 0x15, 0x76, 0xae, 0xf0, 0xc7, 0xc5,
1820        0x50, 0xae, 0x6f, 0xb5, 0xd2, 0x8a, 0x8e, 0x9a,
1821        0xd4, 0x30, 0x55, 0xc6, 0xe9, 0x2c, 0x81, 0x6e,
1822        0x95, 0xf6, 0x45, 0x89, 0x55, 0x28, 0x34, 0x7b,
1823        0xe5, 0x72, 0x9a, 0x2a, 0xe2, 0x98, 0x09, 0x35,
1824        0xe0, 0xe9, 0x75, 0x94, 0xe9, 0x34, 0x95, 0xb9,
1825        0x13, 0x6e, 0xd5, 0xa1, 0x62, 0x5a, 0x1c, 0x94,
1826        0x28, 0xed, 0x84, 0x46, 0x76, 0x6d, 0x10, 0x37,
1827        0x71, 0xa3, 0x31, 0x46, 0x64, 0xe4, 0x59, 0x44,
1828        0x17, 0x70, 0x1c, 0x23, 0xc9, 0x7e, 0xf6, 0xab,
1829        0x8a, 0x24, 0xae, 0x25, 0xe2, 0xb2, 0x5f, 0x33,
1830        0xe4, 0xd7, 0xd3, 0x34, 0x2a, 0x49, 0x22, 0x16,
1831        0x15, 0x9b, 0x90, 0x40, 0xda, 0x99, 0xd5, 0xaf
1832    };
1833
1834    /* 512 byte shared secret */
1835    static const byte shared_secret[] = {
1836        0xe2, 0xce, 0x0e, 0x4b, 0x64, 0xf3, 0x84, 0x62,
1837        0x38, 0xfd, 0xe3, 0x6f, 0x69, 0x40, 0x22, 0xb0,
1838        0x73, 0x27, 0x03, 0x12, 0x82, 0xa4, 0x6e, 0x03,
1839        0x57, 0xec, 0x3d, 0xa0, 0xc1, 0x4f, 0x4b, 0x09,
1840        0xa1, 0xd4, 0xe0, 0x1a, 0x5d, 0x91, 0x2e, 0x08,
1841        0xad, 0x57, 0xfa, 0xcc, 0x55, 0x90, 0x5f, 0xa0,
1842        0x52, 0x27, 0x62, 0x8d, 0xe5, 0x2d, 0xa1, 0x5f,
1843        0xf0, 0x30, 0x43, 0x77, 0x4e, 0x3f, 0x02, 0x58,
1844        0xcb, 0xa0, 0x51, 0xae, 0x1d, 0x24, 0xf9, 0x0a,
1845        0xd1, 0x36, 0x0b, 0x95, 0x0f, 0x07, 0xd9, 0xf7,
1846        0xe2, 0x36, 0x14, 0x2f, 0xf0, 0x11, 0xc2, 0xc9,
1847        0xaf, 0x66, 0x4e, 0x0d, 0xb4, 0x60, 0x01, 0x4e,
1848        0xa8, 0x49, 0xc6, 0xec, 0x5f, 0xb2, 0xbc, 0x05,
1849        0x48, 0x91, 0x4e, 0xe1, 0xc3, 0x99, 0x9f, 0xeb,
1850        0x4a, 0xc1, 0xde, 0x05, 0x9a, 0x65, 0x39, 0x7d,
1851        0x2f, 0x89, 0x85, 0xb2, 0xcf, 0xec, 0x25, 0x27,
1852        0x5f, 0x1c, 0x11, 0x63, 0xcf, 0x7b, 0x86, 0x98,
1853        0x39, 0xae, 0xc2, 0x16, 0x8f, 0x79, 0xd1, 0x20,
1854        0xd0, 0xb4, 0xa0, 0xba, 0x44, 0xd8, 0xf5, 0x3a,
1855        0x0a, 0x08, 0x4c, 0xd1, 0xb9, 0xdd, 0x0a, 0x5b,
1856        0x9e, 0x62, 0xf3, 0x52, 0x0c, 0x84, 0x12, 0x43,
1857        0x9b, 0xd7, 0xdf, 0x86, 0x71, 0x03, 0xdd, 0x04,
1858        0x98, 0x55, 0x0c, 0x7b, 0xe2, 0xe8, 0x03, 0x17,
1859        0x25, 0x84, 0xd9, 0xbd, 0xe1, 0xce, 0x64, 0xbe,
1860        0xca, 0x55, 0xd4, 0x5b, 0xef, 0x61, 0x5b, 0x68,
1861        0x4b, 0x80, 0x37, 0x40, 0xae, 0x28, 0x87, 0x81,
1862        0x55, 0x34, 0x96, 0x50, 0x21, 0x47, 0x49, 0xc0,
1863        0xda, 0x26, 0x46, 0xb8, 0xe8, 0xcc, 0x5a, 0x27,
1864        0x9c, 0x9d, 0x0a, 0x3d, 0xcc, 0x4c, 0x63, 0x27,
1865        0x81, 0x82, 0x2e, 0xf4, 0xa8, 0x91, 0x37, 0x3e,
1866        0xa7, 0x34, 0x6a, 0x0f, 0x60, 0x44, 0xdd, 0x2e,
1867        0xdc, 0xf9, 0x19, 0xf2, 0x2e, 0x81, 0x05, 0x51,
1868        0x16, 0xbc, 0xc0, 0x85, 0xa5, 0xd5, 0x08, 0x09,
1869        0x1f, 0xcd, 0xed, 0xa4, 0xc5, 0xdb, 0x16, 0x43,
1870        0xb5, 0x7a, 0x71, 0x66, 0x19, 0x2e, 0xef, 0x13,
1871        0xbc, 0x40, 0x39, 0x0a, 0x00, 0x45, 0x7e, 0x61,
1872        0xe9, 0x68, 0x60, 0x83, 0x00, 0x70, 0xd1, 0x71,
1873        0xd3, 0xa2, 0x61, 0x3e, 0x00, 0x46, 0x93, 0x0d,
1874        0xbf, 0xe6, 0xa2, 0x07, 0xe6, 0x40, 0x1a, 0xf4,
1875        0x57, 0xc6, 0x67, 0x39, 0xd8, 0xd7, 0x6b, 0xc5,
1876        0xa5, 0xd8, 0x38, 0x78, 0x12, 0xb4, 0x97, 0x12,
1877        0xbe, 0x97, 0x13, 0xef, 0xe4, 0x74, 0x0c, 0xe0,
1878        0x75, 0x89, 0x64, 0xf4, 0xe8, 0x85, 0xda, 0x84,
1879        0x7b, 0x1d, 0xfe, 0xdd, 0x21, 0xba, 0xda, 0x01,
1880        0x52, 0xdc, 0x59, 0xe5, 0x47, 0x50, 0x7e, 0x15,
1881        0x20, 0xd0, 0x43, 0x37, 0x6e, 0x48, 0x39, 0x00,
1882        0xee, 0xd9, 0x54, 0x6d, 0x00, 0x65, 0xc9, 0x4b,
1883        0x85, 0xa2, 0x8a, 0x40, 0x55, 0xd0, 0x63, 0x0c,
1884        0xb5, 0x7a, 0x0d, 0x37, 0x67, 0x27, 0x73, 0x18,
1885        0x7f, 0x5a, 0xf5, 0x0e, 0x22, 0xb9, 0xb0, 0x3f,
1886        0xda, 0xf1, 0xec, 0x7c, 0x24, 0x01, 0x49, 0xa9,
1887        0x09, 0x0e, 0x0f, 0xc4, 0xa9, 0xef, 0xc8, 0x2b,
1888        0x13, 0xd1, 0x0a, 0x6f, 0xf8, 0x92, 0x4b, 0x1d,
1889        0xdd, 0x6c, 0x9c, 0x35, 0xde, 0x75, 0x46, 0x32,
1890        0xe6, 0xfb, 0xda, 0x58, 0xba, 0x81, 0x08, 0xca,
1891        0xa9, 0xb6, 0x69, 0x71, 0x96, 0x2a, 0x1f, 0x2e,
1892        0x25, 0xe0, 0x37, 0xfe, 0xee, 0x4d, 0x27, 0xaa,
1893        0x04, 0xda, 0x95, 0xbb, 0x93, 0xcf, 0x8f, 0xa2,
1894        0x1d, 0x67, 0x35, 0xe3, 0x51, 0x8f, 0x87, 0x3b,
1895        0xa9, 0x62, 0x05, 0xee, 0x44, 0xb7, 0x2e, 0xd0,
1896        0x07, 0x63, 0x32, 0xf5, 0xcd, 0x64, 0x18, 0x20,
1897        0xcf, 0x22, 0x42, 0x28, 0x22, 0x1a, 0xa8, 0xbb,
1898        0x74, 0x8a, 0x6f, 0x2a, 0xea, 0x8a, 0x48, 0x0a,
1899        0xad, 0xd7, 0xed, 0xba, 0xa3, 0x89, 0x37, 0x01
1900    };
1901
1902    rc = linuxkm_test_kpp_driver(WOLFKM_FFDHE4096_DRIVER,
1903                                 b_pub, expected_a_pub, sizeof(b_pub),
1904                                 secret, sizeof(secret),
1905                                 shared_secret, sizeof(shared_secret));
1906
1907    return rc;
1908}
1909#endif /* HAVE_FFDHE_4096 */
1910
1911#ifdef HAVE_FFDHE_6144
1912static int linuxkm_test_ffdhe6144(void)
1913{
1914    int rc = 0;
1915
1916    /* reference values from kernel crypto/testmgr.h */
1917    /* 784 byte secret size */
1918    static const byte secret[] = {
1919#ifdef LITTLE_ENDIAN_ORDER
1920        0x01, 0x00, /* type */
1921        0x10, 0x03, /* len */
1922        0x00, 0x03, 0x00, 0x00, /* key_size */
1923        0x00, 0x00, 0x00, 0x00, /* p_size */
1924        0x00, 0x00, 0x00, 0x00, /* g_size */
1925#else
1926        0x00, 0x01, /* type */
1927        0x03, 0x10, /* len */
1928        0x00, 0x00, 0x03, 0x00, /* key_size */
1929        0x00, 0x00, 0x00, 0x00, /* p_size */
1930        0x00, 0x00, 0x00, 0x00, /* g_size */
1931#endif
1932        /* xa */
1933        0x63, 0x3e, 0x6f, 0xe0, 0xfe, 0x9f, 0x4a, 0x01,
1934        0x62, 0x77, 0xce, 0xf1, 0xc7, 0xcc, 0x49, 0x4d,
1935        0x92, 0x53, 0x56, 0xe3, 0x39, 0x15, 0x81, 0xb2,
1936        0xcd, 0xdc, 0xaf, 0x5e, 0xbf, 0x31, 0x1f, 0x69,
1937        0xce, 0x41, 0x35, 0x24, 0xaa, 0x46, 0x53, 0xb5,
1938        0xb7, 0x3f, 0x2b, 0xad, 0x95, 0x14, 0xfb, 0xe4,
1939        0x9a, 0x61, 0xcd, 0x0f, 0x1f, 0x02, 0xee, 0xa4,
1940        0x79, 0x2c, 0x9d, 0x1a, 0x7c, 0x62, 0x82, 0x39,
1941        0xdd, 0x43, 0xcc, 0x58, 0x9f, 0x62, 0x47, 0x56,
1942        0x1d, 0x0f, 0xc2, 0x67, 0xbc, 0x24, 0xd0, 0xf9,
1943        0x0a, 0x50, 0x1b, 0x10, 0xe7, 0xbb, 0xd1, 0xc2,
1944        0x01, 0xbb, 0xc4, 0x4c, 0xda, 0x12, 0x60, 0x0e,
1945        0x95, 0x2b, 0xde, 0x09, 0xd6, 0x67, 0xe1, 0xbc,
1946        0x4c, 0xb9, 0x67, 0xdf, 0xd0, 0x1f, 0x97, 0xb4,
1947        0xde, 0xcb, 0x6b, 0x78, 0x83, 0x51, 0x74, 0x33,
1948        0x01, 0x7f, 0xf6, 0x0a, 0x95, 0x69, 0x93, 0x00,
1949        0x2a, 0xc3, 0x75, 0x8e, 0xef, 0xbe, 0x53, 0x11,
1950        0x6d, 0xc4, 0xd0, 0x9f, 0x6d, 0x63, 0x48, 0xc1,
1951        0x91, 0x1f, 0x7d, 0x88, 0xa7, 0x90, 0x78, 0xd1,
1952        0x7e, 0x52, 0x42, 0x10, 0x01, 0xb4, 0x27, 0x95,
1953        0x91, 0x43, 0xcc, 0x82, 0x91, 0x86, 0x62, 0xa0,
1954        0x9d, 0xef, 0x65, 0x6e, 0x67, 0xcf, 0x19, 0x11,
1955        0x35, 0x37, 0x5e, 0x94, 0x97, 0x83, 0xa6, 0x83,
1956        0x1c, 0x7e, 0x8a, 0x3e, 0x32, 0xb0, 0xce, 0xff,
1957        0x20, 0xdc, 0x7b, 0x6e, 0x18, 0xd9, 0x6b, 0x27,
1958        0x31, 0xfc, 0xc3, 0xef, 0x47, 0x8d, 0xbe, 0x34,
1959        0x2b, 0xc7, 0x60, 0x74, 0x3c, 0x93, 0xb3, 0x8e,
1960        0x54, 0x77, 0x4e, 0x73, 0xe6, 0x40, 0x72, 0x35,
1961        0xb0, 0xf0, 0x06, 0x53, 0x43, 0xbe, 0xd0, 0xc3,
1962        0x87, 0xcc, 0x38, 0x96, 0xa9, 0x10, 0xa0, 0xd6,
1963        0x17, 0xed, 0xa5, 0x6a, 0xf4, 0xf6, 0xaa, 0x77,
1964        0x40, 0xed, 0x7d, 0x2e, 0x58, 0x0f, 0x5b, 0x04,
1965        0x5a, 0x41, 0x12, 0x95, 0x22, 0xcb, 0xa3, 0xce,
1966        0x8b, 0x6d, 0x6d, 0x89, 0xec, 0x7c, 0x1d, 0x25,
1967        0x27, 0x52, 0x50, 0xa0, 0x5b, 0x93, 0x8c, 0x5d,
1968        0x3f, 0x56, 0xb9, 0xa6, 0x5e, 0xe5, 0xf7, 0x9b,
1969        0xc7, 0x9a, 0x4a, 0x2e, 0x79, 0xb5, 0xca, 0x29,
1970        0x58, 0x52, 0xa0, 0x63, 0xe4, 0x9d, 0xeb, 0x4c,
1971        0x4c, 0xa8, 0x37, 0x0b, 0xe9, 0xa0, 0x18, 0xf1,
1972        0x86, 0xf6, 0x4d, 0x32, 0xfb, 0x9e, 0x4f, 0xb3,
1973        0x7b, 0x5d, 0x58, 0x78, 0x70, 0xbd, 0x56, 0xac,
1974        0x99, 0x75, 0x25, 0x71, 0x66, 0x76, 0x4e, 0x5e,
1975        0x67, 0x4f, 0xb1, 0x17, 0xa7, 0x8b, 0x55, 0x12,
1976        0x87, 0x01, 0x4e, 0xd1, 0x66, 0xef, 0xd0, 0x70,
1977        0xaf, 0x14, 0x34, 0xee, 0x2a, 0x76, 0x49, 0x25,
1978        0xa6, 0x2e, 0x43, 0x37, 0x75, 0x7d, 0x1a, 0xad,
1979        0x08, 0xd5, 0x01, 0x85, 0x9c, 0xe1, 0x20, 0xd8,
1980        0x38, 0x5c, 0x57, 0xa5, 0xed, 0x9d, 0x46, 0x3a,
1981        0xb7, 0x46, 0x60, 0x29, 0x8b, 0xc4, 0x21, 0x50,
1982        0x0a, 0x30, 0x9c, 0x57, 0x42, 0xe4, 0x35, 0xf8,
1983        0x12, 0x5c, 0x4f, 0xa2, 0x20, 0xc2, 0xc9, 0x43,
1984        0xe3, 0x6d, 0x20, 0xbc, 0xdf, 0xb8, 0x37, 0x33,
1985        0x45, 0x43, 0x06, 0x4e, 0x08, 0x6f, 0x8a, 0xcd,
1986        0x61, 0xc3, 0x1b, 0x05, 0x28, 0x82, 0xbe, 0xf0,
1987        0x48, 0x33, 0xe5, 0x93, 0xc9, 0x1a, 0x61, 0x16,
1988        0x67, 0x03, 0x9d, 0x47, 0x9d, 0x74, 0xeb, 0xae,
1989        0x13, 0xf2, 0xb4, 0x1b, 0x09, 0x11, 0xf5, 0x15,
1990        0xcb, 0x28, 0xfd, 0x50, 0xe0, 0xbc, 0x58, 0x36,
1991        0x38, 0x91, 0x2c, 0x07, 0x27, 0x1f, 0x49, 0x68,
1992        0xf4, 0xce, 0xad, 0xf7, 0xba, 0xec, 0x5d, 0x3d,
1993        0xfd, 0x27, 0xe2, 0xcf, 0xf4, 0x56, 0xfe, 0x08,
1994        0xa6, 0x11, 0x61, 0xcb, 0x6c, 0x9f, 0xf9, 0x3c,
1995        0x57, 0x0b, 0x8b, 0xaa, 0x00, 0x16, 0x18, 0xba,
1996        0x1f, 0xe8, 0x4f, 0x01, 0xe2, 0x79, 0x2a, 0x0b,
1997        0xc1, 0xbd, 0x52, 0xef, 0xe6, 0xf7, 0x5a, 0x66,
1998        0xfe, 0x07, 0x3b, 0x50, 0x6b, 0xbb, 0xcb, 0x39,
1999        0x3c, 0x94, 0xf6, 0x21, 0x0d, 0x68, 0x69, 0xa4,
2000        0xed, 0x2e, 0xb5, 0x85, 0x03, 0x11, 0x38, 0x79,
2001        0xec, 0xb5, 0x22, 0x23, 0xdf, 0x9e, 0xad, 0xb4,
2002        0xbe, 0xd7, 0xc7, 0xdf, 0xea, 0x30, 0x23, 0x8a,
2003        0xb7, 0x21, 0x0a, 0x9d, 0xbd, 0x99, 0x13, 0x7d,
2004        0x5f, 0x7e, 0xaf, 0x28, 0x54, 0x3f, 0xca, 0x5e,
2005        0xf4, 0xfc, 0x05, 0x0d, 0x65, 0x67, 0xd8, 0xf6,
2006        0x8e, 0x90, 0x9d, 0x0d, 0xcf, 0x62, 0x82, 0xd6,
2007        0x9f, 0x02, 0xf8, 0xca, 0xfa, 0x42, 0x24, 0x7f,
2008        0x4d, 0xb7, 0xfc, 0x92, 0xa6, 0x4a, 0x51, 0xc4,
2009        0xd8, 0xae, 0x19, 0x87, 0xc6, 0xa3, 0x83, 0xbe,
2010        0x7b, 0x6d, 0xc3, 0xf5, 0xb8, 0xad, 0x4a, 0x05,
2011        0x78, 0x84, 0x3a, 0x15, 0x2e, 0x40, 0xbe, 0x79,
2012        0xa9, 0xc0, 0x12, 0xa1, 0x48, 0x39, 0xc3, 0xdb,
2013        0x47, 0x4f, 0x7d, 0xea, 0x6d, 0xc7, 0xfa, 0x2c,
2014        0x4e, 0xe9, 0xa5, 0x85, 0x81, 0xea, 0x6c, 0xcd,
2015        0x8a, 0xe5, 0x74, 0x17, 0x76, 0x31, 0x31, 0x75,
2016        0x96, 0x83, 0xca, 0x81, 0xbb, 0x5c, 0xa9, 0x79,
2017        0x2c, 0xbd, 0x09, 0xfe, 0xe4, 0x86, 0x0d, 0x8c,
2018        0x76, 0x9c, 0xbc, 0xe8, 0x93, 0xe4, 0xd0, 0xe4,
2019        0x0f, 0xf8, 0xff, 0x24, 0x7e, 0x66, 0x61, 0x69,
2020        0xfb, 0xe4, 0x46, 0x08, 0x94, 0x99, 0xa5, 0x53,
2021        0xd7, 0xe4, 0x29, 0x72, 0x86, 0x86, 0xe8, 0x1d,
2022        0x37, 0xfa, 0xcb, 0xd0, 0x8d, 0x51, 0xd0, 0xbf,
2023        0x81, 0xcf, 0x55, 0xb9, 0xc5, 0x78, 0x8c, 0x74,
2024        0xa0, 0x16, 0x3a, 0xd2, 0x19, 0x94, 0x29, 0x6a,
2025        0x5e, 0xec, 0xd3, 0x20, 0xa0, 0xb2, 0xfd, 0xce,
2026        0xd4, 0x14, 0xa3, 0x39, 0x10, 0xa9, 0xf4, 0x4e,
2027        0xba, 0x21, 0x09, 0x5c, 0xe6, 0x61, 0x43, 0x51,
2028        0xae, 0xc4, 0x71, 0xd7, 0x21, 0xef, 0x98, 0x39
2029    };
2030
2031    /* 768 byte pub key */
2032    static const byte b_pub[] = {
2033        0x30, 0x31, 0xbe, 0x43, 0xd0, 0x14, 0x22, 0x6b,
2034        0x4b, 0x8c, 0x9a, 0xca, 0xc6, 0xdd, 0xe5, 0x99,
2035        0xce, 0xb8, 0x30, 0x23, 0xb6, 0xa8, 0x8c, 0x4d,
2036        0xfa, 0xef, 0xad, 0xa6, 0x6a, 0x21, 0x50, 0xa6,
2037        0x45, 0x2d, 0x19, 0x2a, 0x29, 0x81, 0xc5, 0xac,
2038        0xb4, 0xa8, 0x5f, 0x6d, 0x5b, 0xc8, 0x5f, 0x12,
2039        0x35, 0x21, 0xfb, 0x37, 0xaa, 0x0c, 0x79, 0xeb,
2040        0xd4, 0x83, 0x01, 0xda, 0xa3, 0xf3, 0x51, 0x6e,
2041        0x17, 0xf9, 0xef, 0x3f, 0xbd, 0x2f, 0xd2, 0x43,
2042        0x82, 0x12, 0x48, 0xeb, 0x61, 0x4c, 0x8e, 0xf2,
2043        0x6c, 0x76, 0xf9, 0x6d, 0x42, 0x2a, 0xcb, 0x10,
2044        0x13, 0x3b, 0xf6, 0x9b, 0xcd, 0x46, 0x1e, 0xa2,
2045        0xa7, 0x2c, 0x08, 0x56, 0xd2, 0x42, 0xf5, 0x03,
2046        0xf0, 0x3e, 0xef, 0xa2, 0xa2, 0xf2, 0x4c, 0xf2,
2047        0xdb, 0x4f, 0xeb, 0x40, 0x15, 0x53, 0x27, 0xf7,
2048        0xd4, 0x8e, 0x58, 0x23, 0xf5, 0x2c, 0x88, 0x04,
2049        0x1e, 0xb1, 0xb6, 0xe3, 0xd6, 0x9c, 0x49, 0x08,
2050        0xa1, 0x4b, 0xb8, 0x33, 0xe4, 0x75, 0x85, 0xa1,
2051        0x86, 0x97, 0xce, 0x1d, 0xe9, 0x9f, 0xe2, 0xd8,
2052        0xf2, 0x7e, 0xad, 0xdc, 0x8a, 0x4d, 0xbd, 0x06,
2053        0x52, 0x00, 0x9a, 0x2c, 0x69, 0xdd, 0x02, 0x0c,
2054        0x69, 0x5a, 0xf9, 0x1d, 0xfd, 0xdc, 0xfb, 0x82,
2055        0xb2, 0xe5, 0xf3, 0x24, 0xba, 0xd1, 0x09, 0x76,
2056        0x90, 0xb5, 0x7a, 0x92, 0xa6, 0x6b, 0x97, 0xc0,
2057        0xce, 0x13, 0x9b, 0x4b, 0xbc, 0x30, 0x91, 0xb2,
2058        0x13, 0x8b, 0x57, 0x6c, 0x8b, 0x66, 0x6e, 0x58,
2059        0x3e, 0x91, 0x50, 0xc7, 0x6c, 0xe1, 0x18, 0xec,
2060        0xbf, 0x69, 0xcd, 0xcb, 0xa0, 0xbc, 0x0d, 0x05,
2061        0xc4, 0xf8, 0x45, 0x92, 0xe0, 0x05, 0xd3, 0x08,
2062        0xb3, 0x30, 0x19, 0xc8, 0x80, 0xf8, 0x17, 0x9f,
2063        0x1e, 0x6a, 0x49, 0x8e, 0x43, 0xef, 0x7a, 0x49,
2064        0xa5, 0x93, 0xd9, 0xed, 0xd1, 0x07, 0x03, 0xe4,
2065        0xa3, 0x55, 0xeb, 0x1e, 0x2f, 0x69, 0xd7, 0x40,
2066        0x8f, 0x6e, 0x1c, 0xb6, 0x94, 0xfb, 0xba, 0x4e,
2067        0x46, 0xd0, 0x38, 0x71, 0x00, 0x88, 0x93, 0x6a,
2068        0x55, 0xfc, 0x16, 0x95, 0x1f, 0xb1, 0xf6, 0x2f,
2069        0x26, 0x45, 0x50, 0x54, 0x30, 0x62, 0x62, 0xe8,
2070        0x80, 0xe5, 0x24, 0x0b, 0xe4, 0x15, 0x6b, 0x32,
2071        0x16, 0xc2, 0x30, 0x9b, 0x56, 0xb4, 0xc9, 0x5e,
2072        0x50, 0xb4, 0x27, 0x82, 0x86, 0x01, 0xda, 0x68,
2073        0x44, 0x4b, 0x15, 0x81, 0x31, 0x13, 0x52, 0xd8,
2074        0x08, 0xbc, 0xae, 0xf3, 0xa5, 0x94, 0x1c, 0x81,
2075        0xe8, 0x42, 0xd6, 0x42, 0xd6, 0xff, 0x99, 0x58,
2076        0x0f, 0x61, 0x3e, 0x82, 0x9e, 0x2d, 0x13, 0x03,
2077        0x54, 0x02, 0x74, 0xf4, 0x6b, 0x43, 0x43, 0xce,
2078        0x54, 0x44, 0x36, 0x3f, 0x55, 0xfa, 0xb2, 0x56,
2079        0xdc, 0xac, 0xb5, 0x65, 0x89, 0xbe, 0x36, 0xd2,
2080        0x58, 0x65, 0x79, 0x4c, 0xf3, 0xe2, 0x01, 0xf1,
2081        0x69, 0x96, 0x29, 0x20, 0x5d, 0xee, 0xf5, 0x8a,
2082        0x8b, 0x9f, 0x72, 0xf7, 0x27, 0x02, 0xde, 0x3b,
2083        0xc7, 0x52, 0x19, 0xdc, 0x8e, 0x22, 0x36, 0x09,
2084        0x14, 0x59, 0x07, 0xbb, 0x1e, 0x49, 0x69, 0x4f,
2085        0x00, 0x7b, 0x9a, 0x5d, 0x23, 0xe9, 0xbe, 0x0d,
2086        0x52, 0x90, 0xa3, 0x0d, 0xde, 0xe7, 0x80, 0x57,
2087        0x53, 0x69, 0x39, 0xe6, 0xf8, 0x33, 0xeb, 0x92,
2088        0x0d, 0x9e, 0x04, 0x8b, 0x16, 0x16, 0x16, 0x1c,
2089        0xa9, 0xe6, 0xe3, 0x0e, 0x0a, 0xc6, 0xf6, 0x61,
2090        0xd1, 0x44, 0x2b, 0x3e, 0x5e, 0x02, 0xfe, 0xaa,
2091        0xe3, 0xf3, 0x8f, 0xf9, 0xc8, 0x20, 0x37, 0xad,
2092        0xbc, 0x95, 0xb8, 0xc5, 0xe7, 0x95, 0xda, 0xfb,
2093        0x80, 0x5b, 0xf6, 0x40, 0x28, 0xae, 0xc1, 0x4c,
2094        0x09, 0xde, 0xff, 0x1e, 0xbf, 0x51, 0xd2, 0xfe,
2095        0x08, 0xdc, 0xb0, 0x48, 0x21, 0xf5, 0x4c, 0x43,
2096        0xdc, 0x7b, 0x69, 0x83, 0xc8, 0x69, 0x5c, 0xc4,
2097        0xa9, 0x98, 0x76, 0x4b, 0xc4, 0x4a, 0xac, 0x1d,
2098        0xa5, 0x52, 0xe3, 0x35, 0x43, 0xdd, 0x30, 0xd4,
2099        0xa0, 0x51, 0x9c, 0xc2, 0x62, 0x4c, 0x7e, 0xa5,
2100        0xfb, 0xd3, 0x2c, 0x8a, 0x09, 0x7f, 0x53, 0xa3,
2101        0xcd, 0xca, 0x58, 0x1b, 0x4c, 0xaf, 0xba, 0x21,
2102        0x8b, 0x88, 0x1d, 0xc0, 0xe9, 0x0a, 0x17, 0x30,
2103        0x33, 0xd6, 0xa2, 0xa5, 0x49, 0x50, 0x61, 0x3b,
2104        0xff, 0x37, 0x71, 0x66, 0xef, 0x61, 0xbc, 0xb2,
2105        0x53, 0x82, 0xe5, 0x70, 0xef, 0x32, 0xff, 0x9d,
2106        0x97, 0xe0, 0x82, 0xe0, 0xbb, 0x49, 0xc2, 0x29,
2107        0x58, 0x89, 0xdd, 0xe9, 0x62, 0x52, 0xfb, 0xba,
2108        0x22, 0xa6, 0xd9, 0x16, 0xfa, 0x55, 0xb3, 0x06,
2109        0xed, 0x6d, 0x70, 0x6e, 0xdc, 0x47, 0x7c, 0x67,
2110        0x1a, 0xcc, 0x27, 0x98, 0xd4, 0xd7, 0xe6, 0xf0,
2111        0xf8, 0x9f, 0x51, 0x3e, 0xf0, 0xee, 0xad, 0xb6,
2112        0x78, 0x69, 0x71, 0xb5, 0xcb, 0x09, 0xa3, 0xa6,
2113        0x3f, 0x29, 0x24, 0x46, 0xe0, 0x65, 0xbc, 0x9f,
2114        0x6c, 0xe9, 0xf9, 0x49, 0x49, 0x96, 0x75, 0xe5,
2115        0xe1, 0xff, 0x82, 0x70, 0xf4, 0x7e, 0xff, 0x8f,
2116        0xec, 0x47, 0x98, 0x6d, 0x5b, 0x88, 0x60, 0xee,
2117        0x43, 0xb1, 0xe2, 0x14, 0xc1, 0x49, 0x95, 0x74,
2118        0x46, 0xd3, 0x3f, 0x73, 0xb2, 0xe9, 0x88, 0xe0,
2119        0xd3, 0xb1, 0xc4, 0x2c, 0xef, 0xee, 0xdd, 0x6c,
2120        0xc5, 0xa1, 0x29, 0xef, 0x86, 0xd2, 0x36, 0x8a,
2121        0x2f, 0x7c, 0x9d, 0x28, 0x0a, 0x6d, 0xc9, 0x5a,
2122        0xdb, 0xd4, 0x04, 0x06, 0x36, 0x96, 0x09, 0x03,
2123        0x71, 0x5d, 0x38, 0x67, 0xa2, 0x08, 0x2a, 0x04,
2124        0xe7, 0xd6, 0x51, 0x5a, 0x19, 0x9d, 0xe7, 0xf1,
2125        0x5d, 0x6f, 0xe2, 0xff, 0x48, 0x37, 0xb7, 0x8b,
2126        0xb1, 0x14, 0xb4, 0x96, 0xcd, 0xf0, 0xa7, 0xbd,
2127        0xef, 0x20, 0xff, 0x0a, 0x8d, 0x08, 0xb7, 0x15,
2128        0x98, 0x5a, 0x13, 0xd2, 0xda, 0x2a, 0x27, 0x75
2129    };
2130
2131    /* 768 byte pub key */
2132    static const byte expected_a_pub[] = {
2133        0x45, 0x96, 0x5a, 0xb7, 0x78, 0x5c, 0xa4, 0x4d,
2134        0x39, 0xb2, 0x5f, 0xc8, 0xc2, 0xaa, 0x1a, 0xf4,
2135        0xa6, 0x68, 0xf6, 0x6f, 0x7e, 0xa8, 0x4a, 0x5b,
2136        0x0e, 0xba, 0x0a, 0x99, 0x85, 0xf9, 0x63, 0xd4,
2137        0x58, 0x21, 0x6d, 0xa8, 0x3c, 0xf4, 0x05, 0x10,
2138        0xb0, 0x0d, 0x6f, 0x1c, 0xa0, 0x17, 0x85, 0xae,
2139        0x68, 0xbf, 0xcc, 0x00, 0xc8, 0x86, 0x1b, 0x24,
2140        0x31, 0xc9, 0x49, 0x23, 0x91, 0xe0, 0x71, 0x29,
2141        0x06, 0x39, 0x39, 0x93, 0x49, 0x9c, 0x75, 0x18,
2142        0x1a, 0x8b, 0x61, 0x73, 0x1c, 0x7f, 0x37, 0xd5,
2143        0xf1, 0xab, 0x20, 0x5e, 0x62, 0x25, 0xeb, 0x58,
2144        0xd5, 0xfa, 0xc9, 0x7f, 0xad, 0x57, 0xd5, 0xcc,
2145        0x0d, 0xc1, 0x7a, 0x2b, 0x33, 0x2a, 0x76, 0x84,
2146        0x33, 0x26, 0x97, 0xcf, 0x47, 0x9d, 0x72, 0x2a,
2147        0xc9, 0x39, 0xde, 0xa8, 0x42, 0x27, 0x2d, 0xdc,
2148        0xee, 0x00, 0x60, 0xd2, 0x4f, 0x13, 0xe0, 0xde,
2149        0xd5, 0xc7, 0xf6, 0x7d, 0x8b, 0x2a, 0x43, 0x49,
2150        0x40, 0x99, 0xc2, 0x61, 0x84, 0x8e, 0x57, 0x09,
2151        0x7c, 0xcc, 0x19, 0x46, 0xbd, 0x4c, 0xd2, 0x7c,
2152        0x7d, 0x02, 0x4d, 0x88, 0xdf, 0x58, 0x24, 0x80,
2153        0xeb, 0x19, 0x3b, 0x2a, 0x13, 0x2b, 0x19, 0x85,
2154        0x3c, 0xd8, 0x31, 0x03, 0x00, 0xa4, 0xd4, 0x57,
2155        0x23, 0x2c, 0x24, 0x37, 0xb3, 0x62, 0xea, 0x35,
2156        0x29, 0xd0, 0x2c, 0xac, 0xfd, 0xbd, 0xdf, 0x3d,
2157        0xa6, 0xce, 0xfa, 0x0d, 0x5b, 0xb6, 0x15, 0x8b,
2158        0xe3, 0x58, 0xe9, 0xad, 0x99, 0x87, 0x29, 0x51,
2159        0x8d, 0x97, 0xd7, 0xa9, 0x55, 0xf0, 0x72, 0x6e,
2160        0x4e, 0x58, 0xcb, 0x2b, 0x4d, 0xbd, 0xd0, 0x48,
2161        0x7d, 0x14, 0x86, 0xdb, 0x3f, 0xa2, 0x5f, 0x6e,
2162        0x35, 0x4a, 0xe1, 0x70, 0xb1, 0x53, 0x72, 0xb7,
2163        0xbc, 0xe9, 0x3d, 0x1b, 0x33, 0xc0, 0x54, 0x6f,
2164        0x43, 0x55, 0x76, 0x85, 0x7f, 0x9b, 0xa5, 0xb3,
2165        0xc1, 0x1d, 0xd3, 0xfe, 0xe2, 0xd5, 0x96, 0x3d,
2166        0xdd, 0x92, 0x04, 0xb1, 0xad, 0x75, 0xdb, 0x13,
2167        0x4e, 0x49, 0xfc, 0x35, 0x34, 0xc5, 0xda, 0x13,
2168        0x98, 0xb8, 0x12, 0xbe, 0xda, 0x90, 0x55, 0x7c,
2169        0x11, 0x6c, 0xbe, 0x2b, 0x8c, 0x51, 0x29, 0x23,
2170        0xc1, 0x51, 0xbc, 0x0c, 0x1c, 0xe2, 0x20, 0xfc,
2171        0xfe, 0xf2, 0xaa, 0x71, 0x9b, 0x21, 0xdf, 0x25,
2172        0x1f, 0x68, 0x21, 0x7e, 0xe1, 0xc9, 0x87, 0xa0,
2173        0x20, 0xf6, 0x8d, 0x4f, 0x27, 0x8c, 0x3c, 0x0f,
2174        0x9d, 0xf4, 0x69, 0x25, 0xaa, 0x49, 0xab, 0x94,
2175        0x22, 0x5a, 0x92, 0x3a, 0xba, 0xb4, 0xc2, 0x8c,
2176        0x5a, 0xaa, 0x04, 0xbf, 0x46, 0xc5, 0xaa, 0x93,
2177        0xab, 0x0d, 0xe9, 0x54, 0x6c, 0x3a, 0x64, 0xa6,
2178        0xa2, 0x21, 0x66, 0xee, 0x1c, 0x10, 0x21, 0x84,
2179        0xf2, 0x9e, 0xcc, 0x57, 0xac, 0xc2, 0x25, 0x62,
2180        0xad, 0xbb, 0x59, 0xef, 0x25, 0x61, 0x6c, 0x81,
2181        0x38, 0x8a, 0xdc, 0x8c, 0xeb, 0x7b, 0x18, 0x1d,
2182        0xaf, 0xa9, 0xc5, 0x9a, 0xf4, 0x49, 0x26, 0x8a,
2183        0x25, 0xc4, 0x3e, 0x31, 0x95, 0x28, 0xef, 0xf7,
2184        0x72, 0xe9, 0xc5, 0xaa, 0x59, 0x72, 0x2b, 0x67,
2185        0x47, 0xe8, 0x6b, 0x51, 0x05, 0x24, 0xb8, 0x18,
2186        0xb3, 0x34, 0x0f, 0x8c, 0x2b, 0x80, 0xba, 0x61,
2187        0x1c, 0xbe, 0x9e, 0x9a, 0x7c, 0xe3, 0x60, 0x5e,
2188        0x49, 0x02, 0xff, 0x50, 0x8a, 0x64, 0x28, 0x64,
2189        0x46, 0x7b, 0x83, 0x14, 0x72, 0x6e, 0x59, 0x9b,
2190        0x56, 0x09, 0xb4, 0xf0, 0xde, 0x52, 0xc3, 0xf3,
2191        0x58, 0x17, 0x6a, 0xae, 0xb1, 0x0f, 0xf4, 0x39,
2192        0xcc, 0xd8, 0xce, 0x4d, 0xe1, 0x51, 0x17, 0x88,
2193        0xe4, 0x98, 0xd9, 0xd1, 0xa9, 0x55, 0xbc, 0xbf,
2194        0x7e, 0xc4, 0x51, 0x96, 0xdb, 0x44, 0x1d, 0xcd,
2195        0x8d, 0x74, 0xad, 0xa7, 0x8f, 0x87, 0x83, 0x75,
2196        0xfc, 0x36, 0xb7, 0xd2, 0xd4, 0x89, 0x16, 0x97,
2197        0xe4, 0xc6, 0x2a, 0xe9, 0x65, 0xc8, 0xca, 0x1c,
2198        0xbd, 0x86, 0xaf, 0x57, 0x80, 0xf7, 0xdd, 0x42,
2199        0xc0, 0x3b, 0x3f, 0x87, 0x51, 0x02, 0x2f, 0xf8,
2200        0xd8, 0x68, 0x0f, 0x3d, 0x95, 0x2d, 0xf1, 0x67,
2201        0x09, 0xa6, 0x5d, 0x0b, 0x7e, 0x01, 0xb4, 0xb2,
2202        0x32, 0x01, 0xa8, 0xd0, 0x58, 0x0d, 0xe6, 0xa2,
2203        0xd8, 0x4b, 0x22, 0x10, 0x7d, 0x11, 0xf3, 0xc2,
2204        0x4e, 0xb8, 0x43, 0x8e, 0x31, 0x79, 0x59, 0xe2,
2205        0xc4, 0x96, 0x29, 0x17, 0x40, 0x06, 0x0d, 0xdf,
2206        0xdf, 0xc3, 0x02, 0x30, 0x2a, 0xd1, 0x8e, 0xf2,
2207        0xee, 0x2d, 0xd2, 0x12, 0x63, 0x5a, 0x1d, 0x3c,
2208        0xba, 0x4a, 0xc4, 0x56, 0x90, 0xc6, 0x12, 0x0b,
2209        0xe0, 0x04, 0x3f, 0x35, 0x59, 0x8e, 0x40, 0x75,
2210        0xf4, 0x4c, 0x10, 0x61, 0xb9, 0x30, 0x89, 0x7c,
2211        0x8d, 0x0e, 0x25, 0xb7, 0x5a, 0x6b, 0x97, 0x05,
2212        0xc6, 0x37, 0x80, 0x6e, 0x94, 0x56, 0xa8, 0x5f,
2213        0x03, 0x94, 0x59, 0xc8, 0xc5, 0x3e, 0xdc, 0x23,
2214        0xe5, 0x68, 0x4f, 0xd7, 0xbb, 0x6d, 0x7e, 0xc1,
2215        0x8d, 0xf9, 0xcc, 0x3f, 0x38, 0xad, 0x77, 0xb3,
2216        0x18, 0x61, 0xed, 0x04, 0xc0, 0x71, 0xa7, 0x96,
2217        0xb1, 0xaf, 0x1d, 0x69, 0x78, 0xda, 0x6d, 0x89,
2218        0x8b, 0x50, 0x75, 0x99, 0x44, 0xb3, 0xb2, 0x75,
2219        0xd1, 0xc8, 0x14, 0x40, 0xa1, 0x0a, 0xbf, 0xc4,
2220        0x45, 0xc4, 0xee, 0x12, 0x90, 0x76, 0x26, 0x64,
2221        0xb7, 0x73, 0x2e, 0x0b, 0x0c, 0xfa, 0xc3, 0x55,
2222        0x29, 0x24, 0x1b, 0x7a, 0x00, 0x27, 0x07, 0x26,
2223        0x36, 0xf0, 0x38, 0x1a, 0xe3, 0xb7, 0xc4, 0x8d,
2224        0x1c, 0x9c, 0xa9, 0xc0, 0xc1, 0x45, 0x91, 0x9e,
2225        0x86, 0xdd, 0x82, 0x94, 0x45, 0xfa, 0xcd, 0x5a,
2226        0x19, 0x12, 0x7d, 0xef, 0xda, 0x17, 0xad, 0x21,
2227        0x17, 0x89, 0x8b, 0x45, 0xa7, 0xf5, 0xed, 0x51,
2228        0x9e, 0x58, 0x13, 0xdc, 0x84, 0xa4, 0xe6, 0x37
2229    };
2230
2231    /* 768 byte shared secret */
2232    static const byte shared_secret[] = {
2233        0x9a, 0x9c, 0x1c, 0xb7, 0x73, 0x2f, 0xf2, 0x12,
2234        0xed, 0x59, 0x01, 0xbb, 0x75, 0xf7, 0xf5, 0xe4,
2235        0xa0, 0xa8, 0xbc, 0x3f, 0x3f, 0xb6, 0xf7, 0x74,
2236        0x6e, 0xc4, 0xba, 0x6d, 0x6c, 0x4d, 0x93, 0x31,
2237        0x2b, 0xa7, 0xa4, 0xb3, 0x47, 0x8f, 0x77, 0x04,
2238        0xb5, 0xa5, 0xab, 0xca, 0x6b, 0x5a, 0xe2, 0x86,
2239        0x02, 0x60, 0xca, 0xb4, 0xd7, 0x5e, 0xe0, 0x0f,
2240        0x73, 0xdd, 0xa2, 0x38, 0x7c, 0xae, 0x0f, 0x5a,
2241        0x1a, 0xd7, 0xfd, 0xb6, 0xc8, 0x6f, 0xdd, 0xe0,
2242        0x98, 0xd5, 0x07, 0xea, 0x1f, 0x2a, 0xbb, 0x9e,
2243        0xef, 0x01, 0x24, 0x04, 0xee, 0xf5, 0x89, 0xb1,
2244        0x12, 0x26, 0x54, 0x95, 0xef, 0xcb, 0x84, 0xe9,
2245        0xae, 0x05, 0xef, 0x63, 0x25, 0x15, 0x65, 0x79,
2246        0x79, 0x79, 0x91, 0xc3, 0x76, 0x72, 0xb4, 0x85,
2247        0x86, 0xd9, 0xd3, 0x03, 0xb0, 0xff, 0x04, 0x96,
2248        0x05, 0x3c, 0xde, 0xbf, 0x47, 0x34, 0x76, 0x70,
2249        0x17, 0xd2, 0x24, 0x83, 0xb9, 0xbb, 0xcf, 0x70,
2250        0x7c, 0xb8, 0xc6, 0x7b, 0x4e, 0x01, 0x86, 0x36,
2251        0xc7, 0xc5, 0xe5, 0x8b, 0x7c, 0x69, 0x74, 0x9a,
2252        0xfe, 0x1f, 0x58, 0x85, 0x0f, 0x00, 0xf8, 0x4e,
2253        0xf1, 0x56, 0xdc, 0xd1, 0x11, 0x28, 0x2c, 0xcf,
2254        0x6c, 0xb9, 0xc9, 0x57, 0x17, 0x2e, 0x19, 0x19,
2255        0x55, 0xb3, 0x4c, 0xd8, 0xfb, 0xe7, 0x6f, 0x70,
2256        0x63, 0xf9, 0x53, 0x45, 0xdd, 0xd5, 0x62, 0x95,
2257        0xd3, 0x7d, 0x7e, 0xa0, 0x00, 0x1a, 0x62, 0x9f,
2258        0x96, 0x0a, 0x5d, 0x0a, 0x25, 0x02, 0xbb, 0xff,
2259        0x5a, 0xe8, 0x9e, 0x5a, 0x66, 0x08, 0x93, 0xbc,
2260        0x92, 0xaf, 0xd2, 0x28, 0x04, 0x97, 0xc1, 0x54,
2261        0xfe, 0xcc, 0x0a, 0x25, 0xa2, 0xf4, 0x1d, 0x5a,
2262        0x9a, 0xb1, 0x3e, 0x9c, 0xba, 0x78, 0xe2, 0xcf,
2263        0x71, 0x70, 0xe3, 0x40, 0xea, 0xba, 0x69, 0x9b,
2264        0x03, 0xdd, 0x99, 0x26, 0x09, 0x84, 0x9d, 0x69,
2265        0x4d, 0x3d, 0x0b, 0xe9, 0x3f, 0x51, 0xcd, 0x05,
2266        0xe5, 0x00, 0xaf, 0x2c, 0xd3, 0xf6, 0xc0, 0x68,
2267        0xb5, 0x23, 0x53, 0x33, 0x14, 0xbd, 0x39, 0x1c,
2268        0xbd, 0x1b, 0xe6, 0x72, 0x90, 0xcc, 0xc2, 0x86,
2269        0x1a, 0x42, 0x83, 0x55, 0xb3, 0xed, 0x0b, 0x62,
2270        0x6d, 0x0e, 0xbb, 0x9e, 0x2a, 0x42, 0x32, 0x05,
2271        0x3f, 0xf2, 0x2c, 0xc8, 0x9f, 0x3c, 0xd2, 0xb1,
2272        0x0b, 0xb6, 0x4c, 0xa0, 0x22, 0x36, 0xee, 0xb9,
2273        0x55, 0x23, 0x3e, 0x80, 0xc7, 0x28, 0x7c, 0x39,
2274        0x11, 0xd3, 0x4a, 0x96, 0x2e, 0xef, 0x52, 0x34,
2275        0xf2, 0xda, 0xb1, 0xc6, 0xf5, 0x02, 0x10, 0xbf,
2276        0x56, 0x6b, 0x50, 0x56, 0xcd, 0x2c, 0xfe, 0xe1,
2277        0x94, 0x14, 0x19, 0x24, 0x6e, 0x9a, 0xdf, 0x0c,
2278        0xb8, 0xe2, 0xb8, 0xd5, 0xa3, 0xc1, 0x22, 0x8e,
2279        0x84, 0x92, 0x00, 0x16, 0xf1, 0x3f, 0x83, 0xf6,
2280        0x36, 0x31, 0xa5, 0x38, 0xc6, 0xcf, 0xf8, 0x9b,
2281        0x03, 0xc7, 0x6f, 0xb9, 0xa1, 0x04, 0xdf, 0x20,
2282        0x0f, 0x0b, 0x0f, 0x70, 0xff, 0x57, 0x36, 0x7f,
2283        0xb3, 0x6b, 0xcb, 0x8f, 0x48, 0xf7, 0xb2, 0xdb,
2284        0x85, 0x05, 0xd1, 0xfe, 0x34, 0x05, 0xf6, 0x57,
2285        0xb4, 0x5b, 0xcc, 0x3f, 0x0e, 0xba, 0x36, 0x59,
2286        0xb0, 0xfd, 0x4d, 0xf6, 0xf4, 0x5e, 0xd2, 0x65,
2287        0x1d, 0x98, 0x87, 0xb4, 0x5e, 0xff, 0x29, 0xaa,
2288        0x84, 0x9b, 0x44, 0x0f, 0x06, 0x36, 0x61, 0xbd,
2289        0xdb, 0x51, 0xda, 0x56, 0xc2, 0xd6, 0x19, 0xe2,
2290        0x57, 0x4f, 0xd0, 0x29, 0x71, 0xc8, 0xe4, 0xd6,
2291        0xfb, 0x8c, 0xd0, 0xfc, 0x4f, 0x25, 0x09, 0xa6,
2292        0xfc, 0x67, 0xe2, 0xb8, 0xac, 0xd3, 0x88, 0x8f,
2293        0x1f, 0xf6, 0xa1, 0xe3, 0x45, 0xa6, 0x34, 0xe3,
2294        0xb1, 0x6b, 0xb7, 0x37, 0x0e, 0x06, 0xc7, 0x63,
2295        0xde, 0xac, 0x3b, 0xac, 0x07, 0x91, 0x64, 0xcc,
2296        0x12, 0x10, 0x46, 0x85, 0x14, 0x0b, 0x6b, 0x03,
2297        0xba, 0x4a, 0x85, 0xae, 0xc5, 0x8c, 0xa5, 0x9d,
2298        0x36, 0x38, 0x33, 0xca, 0x42, 0x9c, 0x4b, 0x0c,
2299        0x46, 0xe1, 0x77, 0xe9, 0x1f, 0x80, 0xfe, 0xb7,
2300        0x1d, 0x5a, 0xf4, 0xc6, 0x11, 0x26, 0x78, 0xea,
2301        0x81, 0x25, 0x77, 0x47, 0xed, 0x8b, 0x59, 0xc2,
2302        0x6b, 0x49, 0xff, 0x83, 0x56, 0xec, 0xa5, 0xf0,
2303        0xe0, 0x8b, 0x15, 0xd4, 0x99, 0x40, 0x2a, 0x65,
2304        0x2a, 0x98, 0xf4, 0x71, 0x35, 0x63, 0x84, 0x08,
2305        0x4d, 0xcd, 0x71, 0x85, 0x55, 0xbc, 0xa4, 0x1c,
2306        0x90, 0x93, 0x03, 0x41, 0xde, 0xed, 0x78, 0x62,
2307        0x07, 0x30, 0x50, 0xac, 0x60, 0x21, 0x06, 0xc3,
2308        0xab, 0xa4, 0x04, 0xc0, 0xc2, 0x32, 0x07, 0xc4,
2309        0x1f, 0x2f, 0xec, 0xe2, 0x32, 0xbf, 0xbe, 0x5e,
2310        0x50, 0x5b, 0x2a, 0x19, 0x71, 0x44, 0x37, 0x76,
2311        0x8b, 0xbc, 0xdb, 0x73, 0x98, 0x65, 0x78, 0xc9,
2312        0x33, 0x97, 0x7e, 0xdc, 0x60, 0xa8, 0x87, 0xf2,
2313        0xb5, 0x96, 0x55, 0x7f, 0x44, 0x07, 0xcb, 0x3b,
2314        0xf3, 0xd7, 0x82, 0xfd, 0x77, 0x21, 0x82, 0x21,
2315        0x1a, 0x8b, 0xa2, 0xf5, 0x1f, 0x66, 0xd0, 0x57,
2316        0x00, 0x4f, 0xa9, 0xa5, 0x33, 0xb8, 0x69, 0x91,
2317        0xe8, 0x2e, 0xf7, 0x73, 0x47, 0x89, 0x30, 0x9b,
2318        0xb1, 0xfd, 0xe1, 0x5d, 0x11, 0xfd, 0x84, 0xd9,
2319        0xa2, 0x91, 0x1f, 0x8a, 0xa7, 0x7a, 0x77, 0x8e,
2320        0x3b, 0x10, 0x1d, 0x0a, 0x59, 0x50, 0x34, 0xb0,
2321        0xc3, 0x90, 0x9f, 0x56, 0xb7, 0x43, 0xeb, 0x51,
2322        0x99, 0x2b, 0x8e, 0x6d, 0x7b, 0x58, 0xe7, 0xc0,
2323        0x7f, 0x3d, 0xa0, 0x27, 0x50, 0xf2, 0x6e, 0xc8,
2324        0x1e, 0x7f, 0x84, 0xb3, 0xe1, 0xf7, 0x09, 0x85,
2325        0xd2, 0x9b, 0x56, 0x6b, 0xba, 0xa5, 0x19, 0x2e,
2326        0xec, 0xd8, 0x5c, 0xf5, 0x4e, 0x43, 0x36, 0x2e,
2327        0x89, 0x85, 0x41, 0x7f, 0x9c, 0x91, 0x2e, 0x62,
2328        0xc3, 0x41, 0xcf, 0x0e, 0xa1, 0x7f, 0xeb, 0x50
2329    };
2330
2331    rc = linuxkm_test_kpp_driver(WOLFKM_FFDHE6144_DRIVER,
2332                                 b_pub, expected_a_pub, sizeof(b_pub),
2333                                 secret, sizeof(secret),
2334                                 shared_secret, sizeof(shared_secret));
2335
2336    return rc;
2337}
2338#endif /* HAVE_FFDHE_6144 */
2339
2340#ifdef HAVE_FFDHE_8192
2341static int linuxkm_test_ffdhe8192(void)
2342{
2343    int rc = 0;
2344
2345    /* reference values from kernel crypto/testmgr.h */
2346    /* 1040 byte secret size */
2347    static const byte secret[] = {
2348#ifdef LITTLE_ENDIAN_ORDER
2349        0x01, 0x00, /* type */
2350        0x10, 0x04, /* len */
2351        0x00, 0x04, 0x00, 0x00, /* key_size */
2352        0x00, 0x00, 0x00, 0x00, /* p_size */
2353        0x00, 0x00, 0x00, 0x00, /* g_size */
2354#else
2355        0x00, 0x01, /* type */
2356        0x04, 0x10, /* len */
2357        0x00, 0x00, 0x04, 0x00, /* key_size */
2358        0x00, 0x00, 0x00, 0x00, /* p_size */
2359        0x00, 0x00, 0x00, 0x00, /* g_size */
2360#endif
2361        /* xa */
2362        0x76, 0x6e, 0xeb, 0xf9, 0xeb, 0x76, 0xae, 0x37,
2363        0xcb, 0x19, 0x49, 0x8b, 0xeb, 0xaf, 0xb0, 0x4b,
2364        0x6d, 0xe9, 0x15, 0xad, 0xda, 0xf2, 0xef, 0x58,
2365        0xe9, 0xd6, 0xdd, 0x4c, 0xb3, 0x56, 0xd0, 0x3b,
2366        0x00, 0xb0, 0x65, 0xed, 0xae, 0xe0, 0x2e, 0xdf,
2367        0x8f, 0x45, 0x3f, 0x3c, 0x5d, 0x2f, 0xfa, 0x96,
2368        0x36, 0x33, 0xb2, 0x01, 0x8b, 0x0f, 0xe8, 0x46,
2369        0x15, 0x6d, 0x60, 0x5b, 0xec, 0x32, 0xc3, 0x3b,
2370        0x06, 0xf3, 0xb4, 0x1b, 0x9a, 0xef, 0x3c, 0x03,
2371        0x0e, 0xcc, 0xce, 0x1d, 0x24, 0xa0, 0xc9, 0x08,
2372        0x65, 0xf9, 0x45, 0xe5, 0xd2, 0x43, 0x08, 0x88,
2373        0x58, 0xd6, 0x46, 0xe7, 0xbb, 0x25, 0xac, 0xed,
2374        0x3b, 0xac, 0x6f, 0x5e, 0xfb, 0xd6, 0x19, 0xa6,
2375        0x20, 0x3a, 0x1d, 0x0c, 0xe8, 0x00, 0x72, 0x54,
2376        0xd7, 0xd9, 0xc9, 0x26, 0x49, 0x18, 0xc6, 0xb8,
2377        0xbc, 0xdd, 0xf3, 0xce, 0xf3, 0x7b, 0x69, 0x04,
2378        0x5c, 0x6f, 0x11, 0xdb, 0x44, 0x42, 0x72, 0xb6,
2379        0xb7, 0x84, 0x17, 0x86, 0x47, 0x3f, 0xc5, 0xa1,
2380        0xd8, 0x86, 0xef, 0xe2, 0x27, 0x49, 0x2b, 0x8f,
2381        0x3e, 0x91, 0x12, 0xd9, 0x45, 0x96, 0xf7, 0xe6,
2382        0x77, 0x76, 0x36, 0x58, 0x71, 0x9a, 0xb1, 0xdb,
2383        0xcf, 0x24, 0x9e, 0x7e, 0xad, 0xce, 0x45, 0xba,
2384        0xb5, 0xec, 0x8e, 0xb9, 0xd6, 0x7b, 0x3d, 0x76,
2385        0xa4, 0x85, 0xad, 0xd8, 0x49, 0x9b, 0x80, 0x9d,
2386        0x7f, 0x9f, 0x85, 0x09, 0x9e, 0x86, 0x5b, 0x6b,
2387        0xf3, 0x8d, 0x39, 0x5e, 0x6f, 0xe4, 0x30, 0xc8,
2388        0xa5, 0xf3, 0xdf, 0x68, 0x73, 0x6b, 0x2e, 0x9a,
2389        0xcb, 0xac, 0x0a, 0x0d, 0x44, 0xc1, 0xaf, 0xb2,
2390        0x11, 0x1b, 0x7c, 0x43, 0x08, 0x44, 0x43, 0xe2,
2391        0x4e, 0xfd, 0x93, 0x30, 0x99, 0x09, 0x12, 0xbb,
2392        0xf6, 0x31, 0x34, 0xa5, 0x3d, 0x45, 0x98, 0xee,
2393        0xd7, 0x2a, 0x1a, 0x89, 0xf5, 0x37, 0x92, 0x33,
2394        0xa0, 0xdd, 0xf5, 0xfb, 0x1f, 0x90, 0x42, 0x55,
2395        0x5a, 0x0b, 0x82, 0xff, 0xf0, 0x96, 0x92, 0x15,
2396        0x65, 0x5a, 0x55, 0x96, 0xca, 0x1b, 0xd5, 0xe5,
2397        0xb5, 0x94, 0xde, 0x2e, 0xa6, 0x03, 0x57, 0x9e,
2398        0x15, 0xe4, 0x32, 0x2b, 0x1f, 0xb2, 0x22, 0x21,
2399        0xe9, 0xa0, 0x05, 0xd3, 0x65, 0x6c, 0x11, 0x66,
2400        0x25, 0x38, 0xbb, 0xa3, 0x6c, 0xc2, 0x0b, 0x2b,
2401        0xd0, 0x7a, 0x20, 0x26, 0x29, 0x37, 0x5d, 0x5f,
2402        0xd8, 0xff, 0x2a, 0xcd, 0x46, 0x6c, 0xd6, 0x6e,
2403        0xe5, 0x77, 0x1a, 0xe6, 0x33, 0xf1, 0x8e, 0xc8,
2404        0x10, 0x30, 0x11, 0x00, 0x27, 0xf9, 0x7d, 0x0e,
2405        0x28, 0x43, 0xa7, 0x67, 0x38, 0x7f, 0x16, 0xda,
2406        0xd0, 0x01, 0x8e, 0xa4, 0xe8, 0x6f, 0xcd, 0x23,
2407        0xaf, 0x77, 0x52, 0x34, 0xad, 0x7e, 0xc3, 0xed,
2408        0x2d, 0x10, 0x0a, 0x33, 0xdc, 0xcf, 0x1b, 0x88,
2409        0x0f, 0xcc, 0x48, 0x7f, 0x42, 0xf0, 0x9e, 0x13,
2410        0x1f, 0xf5, 0xd1, 0xe9, 0x90, 0x87, 0xbd, 0xfa,
2411        0x5f, 0x1d, 0x77, 0x55, 0xcb, 0xc3, 0x05, 0xaf,
2412        0x71, 0xd0, 0xe0, 0xab, 0x46, 0x31, 0xd7, 0xea,
2413        0x89, 0x54, 0x2d, 0x39, 0xaf, 0xf6, 0x4f, 0x74,
2414        0xaf, 0x46, 0x58, 0x89, 0x78, 0x95, 0x2e, 0xe6,
2415        0x90, 0xb7, 0xaa, 0x00, 0x73, 0x9f, 0xed, 0xb9,
2416        0x00, 0xd6, 0xf6, 0x6d, 0x26, 0x59, 0xcd, 0x56,
2417        0xdb, 0xf7, 0x3d, 0x5f, 0xeb, 0x6e, 0x46, 0x33,
2418        0xb1, 0x23, 0xed, 0x9f, 0x8d, 0x58, 0xdc, 0xb4,
2419        0x28, 0x3b, 0x90, 0x09, 0xc4, 0x61, 0x02, 0x1f,
2420        0xf8, 0x62, 0xf2, 0x6e, 0xc1, 0x94, 0x71, 0x66,
2421        0x93, 0x11, 0xdf, 0xaa, 0x3e, 0xd7, 0xb5, 0xe5,
2422        0xc1, 0x78, 0xe9, 0x14, 0xcd, 0x55, 0x16, 0x51,
2423        0xdf, 0x8d, 0xd0, 0x94, 0x8c, 0x43, 0xe9, 0xb8,
2424        0x1d, 0x42, 0x7f, 0x76, 0xbc, 0x6f, 0x87, 0x42,
2425        0x88, 0xde, 0xd7, 0x52, 0x78, 0x00, 0x4f, 0x18,
2426        0x02, 0xe7, 0x7b, 0xe2, 0x8a, 0xc3, 0xd1, 0x43,
2427        0xa5, 0xac, 0xda, 0xb0, 0x8d, 0x19, 0x96, 0xd4,
2428        0x81, 0xe0, 0x75, 0xe9, 0xca, 0x41, 0x7e, 0x1f,
2429        0x93, 0x0b, 0x26, 0x24, 0xb3, 0xaa, 0xdd, 0x10,
2430        0x20, 0xd3, 0xf2, 0x9f, 0x3f, 0xdf, 0x65, 0xde,
2431        0x67, 0x79, 0xdc, 0x76, 0x9f, 0x3c, 0x72, 0x75,
2432        0x65, 0x8a, 0x30, 0xcc, 0xd2, 0xcc, 0x06, 0xb1,
2433        0xab, 0x62, 0x86, 0x78, 0x5d, 0xb8, 0xce, 0x72,
2434        0xb3, 0x12, 0xc7, 0x9f, 0x07, 0xd0, 0x6b, 0x98,
2435        0x82, 0x9b, 0x6c, 0xbb, 0x15, 0xe5, 0xcc, 0xf4,
2436        0xc8, 0xf4, 0x60, 0x81, 0xdc, 0xd3, 0x09, 0x1b,
2437        0x5e, 0xd4, 0xf3, 0x55, 0xcf, 0x1c, 0x16, 0x83,
2438        0x61, 0xb4, 0x2e, 0xcc, 0x08, 0x67, 0x58, 0xfd,
2439        0x46, 0x64, 0xbc, 0x29, 0x4b, 0xdd, 0xda, 0xec,
2440        0xdc, 0xc6, 0xa9, 0xa5, 0x73, 0xfb, 0xf8, 0xf3,
2441        0xaf, 0x89, 0xa8, 0x9e, 0x25, 0x14, 0xfa, 0xac,
2442        0xeb, 0x1c, 0x7c, 0x80, 0x96, 0x66, 0x4d, 0x41,
2443        0x67, 0x9b, 0x07, 0x4f, 0x0a, 0x97, 0x17, 0x1c,
2444        0x4d, 0x61, 0xc7, 0x2e, 0x6f, 0x36, 0x98, 0x29,
2445        0x50, 0x39, 0x6d, 0xe7, 0x70, 0xda, 0xf0, 0xc8,
2446        0x05, 0x80, 0x7b, 0x32, 0xff, 0xfd, 0x12, 0xde,
2447        0x61, 0x0d, 0xf9, 0x4c, 0x21, 0xf1, 0x56, 0x72,
2448        0x3d, 0x61, 0x46, 0xc0, 0x2d, 0x07, 0xd1, 0x6c,
2449        0xd3, 0xbe, 0x9a, 0x21, 0x83, 0x85, 0xf7, 0xed,
2450        0x53, 0x95, 0x44, 0x40, 0x8f, 0x75, 0x12, 0x18,
2451        0xc2, 0x9a, 0xfd, 0x5e, 0xce, 0x66, 0xa6, 0x7f,
2452        0x57, 0xc0, 0xd7, 0x73, 0x76, 0xb3, 0x13, 0xda,
2453        0x2e, 0x58, 0xc6, 0x27, 0x40, 0xb2, 0x2d, 0xef,
2454        0x7d, 0x72, 0xb4, 0xa8, 0x75, 0x6f, 0xcc, 0x5f,
2455        0x42, 0x3e, 0x2c, 0x90, 0x36, 0x59, 0xa0, 0x34,
2456        0xaa, 0xce, 0xbc, 0x04, 0x4c, 0xe6, 0x56, 0xc2,
2457        0xcd, 0xa6, 0x1c, 0x59, 0x04, 0x56, 0x53, 0xcf,
2458        0x6d, 0xd7, 0xf0, 0xb1, 0x4f, 0x91, 0xfa, 0x84,
2459        0xcf, 0x4b, 0x8d, 0x50, 0x4c, 0xf8, 0x2a, 0x31,
2460        0x5f, 0xe3, 0xba, 0x79, 0xb4, 0xcc, 0x59, 0x64,
2461        0xe3, 0x7a, 0xfa, 0xf6, 0x06, 0x9d, 0x04, 0xbb,
2462        0xce, 0x61, 0xbf, 0x9e, 0x59, 0x0a, 0x09, 0x51,
2463        0x6a, 0xbb, 0x0b, 0x80, 0xe0, 0x91, 0xc1, 0x51,
2464        0x04, 0x58, 0x67, 0x67, 0x4b, 0x42, 0x4f, 0x95,
2465        0x68, 0x75, 0xe2, 0x1f, 0x9c, 0x14, 0x70, 0xfd,
2466        0x3a, 0x8a, 0xce, 0x8b, 0x04, 0xa1, 0x89, 0xe7,
2467        0xb4, 0xbf, 0x70, 0xfe, 0xf3, 0x0c, 0x48, 0x04,
2468        0x3a, 0xd2, 0x85, 0x68, 0x03, 0xe7, 0xfa, 0xec,
2469        0x5b, 0x55, 0xb7, 0x95, 0xfd, 0x5b, 0x19, 0x35,
2470        0xad, 0xcb, 0x4a, 0x63, 0x03, 0x44, 0x64, 0x2a,
2471        0x48, 0x59, 0x9a, 0x26, 0x43, 0x96, 0x8c, 0xe6,
2472        0xbd, 0xb7, 0x90, 0xd4, 0x5f, 0x8d, 0x08, 0x28,
2473        0xa8, 0xc5, 0x89, 0x70, 0xb9, 0x6e, 0xd3, 0x3b,
2474        0x76, 0x0e, 0x37, 0x98, 0x15, 0x27, 0xca, 0xc9,
2475        0xb0, 0xe0, 0xfd, 0xf3, 0xc6, 0xdf, 0x69, 0xce,
2476        0xe1, 0x5f, 0x6a, 0x3e, 0x5c, 0x86, 0xe2, 0x58,
2477        0x41, 0x11, 0xf0, 0x7e, 0x56, 0xec, 0xe4, 0xc9,
2478        0x0d, 0x87, 0x91, 0xfb, 0xb9, 0xc8, 0x0d, 0x34,
2479        0xab, 0xb0, 0xc6, 0xf2, 0xa6, 0x00, 0x7b, 0x18,
2480        0x92, 0xf4, 0x43, 0x7f, 0x01, 0x85, 0x2e, 0xef,
2481        0x8c, 0x72, 0x50, 0x10, 0xdb, 0xf1, 0x37, 0x62,
2482        0x16, 0x85, 0x71, 0x01, 0xa8, 0x2b, 0xf0, 0x13,
2483        0xd3, 0x7c, 0x0b, 0xaf, 0xf1, 0xf3, 0xd1, 0xee,
2484        0x90, 0x41, 0x5f, 0x7d, 0x5b, 0xa9, 0x83, 0x4b,
2485        0xfa, 0x80, 0x59, 0x50, 0x73, 0xe1, 0xc4, 0xf9,
2486        0x5e, 0x4b, 0xde, 0xd9, 0xf5, 0x22, 0x68, 0x5e,
2487        0x65, 0xd9, 0x37, 0xe4, 0x1a, 0x08, 0x0e, 0xb1,
2488        0x28, 0x2f, 0x40, 0x9e, 0x37, 0xa8, 0x12, 0x56,
2489        0xb7, 0xb8, 0x64, 0x94, 0x68, 0x94, 0xff, 0x9f
2490    };
2491
2492    /* 1024 byte pub key */
2493    static const byte b_pub[] = {
2494        0x26, 0xa8, 0x3a, 0x97, 0xe0, 0x52, 0x76, 0x07,
2495        0x26, 0xa7, 0xbb, 0x21, 0xfd, 0xe5, 0x69, 0xde,
2496        0xe6, 0xe0, 0xb5, 0xa0, 0xf1, 0xaa, 0x51, 0x2b,
2497        0x56, 0x1c, 0x3c, 0x6c, 0xe5, 0x9f, 0x8f, 0x75,
2498        0x71, 0x04, 0x86, 0xf6, 0x43, 0x2f, 0x20, 0x7f,
2499        0x45, 0x4f, 0x5c, 0xb9, 0xf3, 0x90, 0xbe, 0xa9,
2500        0xa0, 0xd7, 0xe8, 0x03, 0x0e, 0xfe, 0x99, 0x9b,
2501        0x8a, 0x1c, 0xbe, 0xa7, 0x63, 0xe8, 0x2b, 0x45,
2502        0xd4, 0x2c, 0x65, 0x25, 0x4c, 0x33, 0xda, 0xc5,
2503        0x85, 0x77, 0x5d, 0x62, 0xea, 0x93, 0xe4, 0x45,
2504        0x59, 0xff, 0xa1, 0xd2, 0xf1, 0x73, 0x11, 0xed,
2505        0x02, 0x64, 0x8a, 0x1a, 0xfb, 0xe1, 0x88, 0xa6,
2506        0x50, 0x6f, 0xff, 0x87, 0x12, 0xbb, 0xfc, 0x10,
2507        0xcf, 0x19, 0x41, 0xb0, 0x35, 0x44, 0x7d, 0x51,
2508        0xe9, 0xc0, 0x77, 0xf2, 0x73, 0x21, 0x2e, 0x62,
2509        0xbf, 0x65, 0xa5, 0xd1, 0x3b, 0xb1, 0x3e, 0x19,
2510        0x75, 0x4b, 0xb7, 0x8e, 0x03, 0xc3, 0xdf, 0xc8,
2511        0xb2, 0xe6, 0xec, 0x2d, 0x7d, 0xa5, 0x6a, 0xba,
2512        0x93, 0x47, 0x50, 0xeb, 0x6e, 0xdb, 0x88, 0x05,
2513        0x45, 0xad, 0x03, 0x8c, 0xf7, 0x9a, 0xe1, 0xc9,
2514        0x1e, 0x16, 0x96, 0x37, 0xa5, 0x3e, 0xe9, 0xb9,
2515        0xa8, 0xdc, 0xb9, 0xa9, 0xf6, 0xa1, 0x3d, 0xed,
2516        0xbe, 0x12, 0x29, 0x8a, 0x3d, 0x3d, 0x90, 0xfc,
2517        0x94, 0xfe, 0x66, 0x28, 0x1c, 0x1b, 0xa4, 0x89,
2518        0x47, 0x66, 0x4f, 0xac, 0x14, 0x00, 0x22, 0x2d,
2519        0x5c, 0x03, 0xea, 0x71, 0x4d, 0x19, 0x7d, 0xd6,
2520        0x58, 0x39, 0x4c, 0x3d, 0x06, 0x2b, 0x30, 0xa6,
2521        0xdc, 0x2c, 0x8d, 0xd1, 0xde, 0x79, 0x77, 0xfa,
2522        0x9c, 0x6b, 0x72, 0x11, 0x8a, 0x7f, 0x7d, 0x37,
2523        0x28, 0x2a, 0x88, 0xbf, 0x0a, 0xdb, 0xac, 0x3b,
2524        0xc5, 0xa5, 0xd5, 0x7e, 0x25, 0xec, 0xa6, 0x7f,
2525        0x5b, 0x53, 0x75, 0x83, 0x49, 0xd4, 0x77, 0xcc,
2526        0x7d, 0x7e, 0xd3, 0x3d, 0x30, 0x2c, 0x98, 0x3f,
2527        0x18, 0x9a, 0x11, 0x8a, 0x37, 0xda, 0x99, 0x0f,
2528        0x3b, 0x06, 0xe1, 0x87, 0xd5, 0xe9, 0x4e, 0xe0,
2529        0x9c, 0x0e, 0x39, 0x34, 0xe2, 0xdd, 0xf6, 0x58,
2530        0x60, 0x63, 0xa6, 0xea, 0xe8, 0xc0, 0xb4, 0xde,
2531        0xdf, 0xa0, 0xbc, 0x21, 0xc3, 0x2d, 0xf4, 0xa4,
2532        0xc8, 0x6f, 0x62, 0x6c, 0x0f, 0x71, 0x88, 0xf9,
2533        0xda, 0x2d, 0x30, 0xd5, 0x95, 0xe1, 0xfc, 0x6d,
2534        0x88, 0xc5, 0xc3, 0x95, 0x51, 0x83, 0xde, 0x41,
2535        0x46, 0x6f, 0x7e, 0x1b, 0x10, 0x48, 0xad, 0x2b,
2536        0x82, 0x88, 0xa2, 0x6f, 0x57, 0x4d, 0x4a, 0xbd,
2537        0x90, 0xc8, 0x06, 0x8f, 0x52, 0x5d, 0x6e, 0xee,
2538        0x09, 0xe6, 0xa3, 0xcb, 0x30, 0x9c, 0x14, 0xf6,
2539        0xac, 0x66, 0x9b, 0x81, 0x0a, 0x75, 0x42, 0x6b,
2540        0xab, 0x27, 0xec, 0x76, 0xfb, 0x8d, 0xc5, 0xbf,
2541        0x0e, 0x93, 0x81, 0x7b, 0x81, 0xd4, 0x85, 0xa6,
2542        0x90, 0x5a, 0xa6, 0xa2, 0x8b, 0xa9, 0xb7, 0x34,
2543        0xe6, 0x15, 0x36, 0x93, 0x8b, 0xe2, 0x99, 0xc7,
2544        0xad, 0x66, 0x7e, 0xd6, 0x89, 0xa9, 0xc8, 0x15,
2545        0xcb, 0xc5, 0xeb, 0x06, 0x85, 0xd4, 0x2f, 0x6e,
2546        0x9b, 0x95, 0x7a, 0x06, 0x6c, 0xfa, 0x31, 0x1d,
2547        0xc4, 0xe5, 0x7d, 0xfb, 0x10, 0x35, 0x88, 0xc2,
2548        0xbe, 0x1c, 0x16, 0x5d, 0xc2, 0xf4, 0x0d, 0xf3,
2549        0xc9, 0x94, 0xb2, 0x7e, 0xa7, 0xbd, 0x9c, 0x03,
2550        0x32, 0xaf, 0x8b, 0x1a, 0xc8, 0xcc, 0x82, 0xd8,
2551        0x87, 0x96, 0x6e, 0x3d, 0xcc, 0x93, 0xd2, 0x43,
2552        0x73, 0xf9, 0xde, 0xec, 0x49, 0x49, 0xf4, 0x56,
2553        0x2a, 0xc8, 0x6e, 0x32, 0x70, 0x48, 0xf8, 0x70,
2554        0xa3, 0x96, 0x31, 0xf4, 0xf2, 0x08, 0xc5, 0x12,
2555        0xd2, 0xeb, 0xb6, 0xea, 0xa3, 0x07, 0x05, 0x61,
2556        0x74, 0xa3, 0x04, 0x2f, 0x17, 0x82, 0x40, 0x5e,
2557        0x4c, 0xd1, 0x51, 0xb8, 0x10, 0x5b, 0xc8, 0x9f,
2558        0x87, 0x73, 0x80, 0x0d, 0x6f, 0xc6, 0xb9, 0xf6,
2559        0x7c, 0x31, 0x0a, 0xcc, 0xd9, 0x03, 0x0f, 0x7a,
2560        0x47, 0x69, 0xb1, 0x55, 0xab, 0xe9, 0xb5, 0x75,
2561        0x62, 0x9e, 0x95, 0xbe, 0x7b, 0xa9, 0x53, 0x6e,
2562        0x28, 0x73, 0xdc, 0xb3, 0xa4, 0x8a, 0x1c, 0x91,
2563        0xf5, 0x8a, 0xf9, 0x32, 0x2b, 0xbd, 0xa5, 0xdc,
2564        0x07, 0xb5, 0xaf, 0x49, 0xdb, 0x9c, 0x35, 0xc9,
2565        0x69, 0xde, 0xac, 0xb1, 0xd0, 0x86, 0xcb, 0x31,
2566        0x0b, 0xc4, 0x4f, 0x63, 0x4e, 0x70, 0xa7, 0x80,
2567        0xe3, 0xbc, 0x0b, 0x73, 0x0e, 0xf2, 0x8c, 0x87,
2568        0x88, 0x7b, 0xa9, 0x6d, 0xde, 0x8a, 0x73, 0x14,
2569        0xb9, 0x80, 0x55, 0x03, 0x2b, 0x29, 0x64, 0x6a,
2570        0xda, 0x48, 0x0e, 0x78, 0x07, 0x40, 0x48, 0x46,
2571        0x58, 0xa9, 0x4e, 0x68, 0x1d, 0xd1, 0xc1, 0xc8,
2572        0x3b, 0x35, 0x53, 0x61, 0xd5, 0xe3, 0x0d, 0x4c,
2573        0x42, 0x74, 0x10, 0x67, 0x85, 0x9f, 0x66, 0x2a,
2574        0xf7, 0x2b, 0x7b, 0x77, 0x8b, 0x6e, 0xda, 0x2c,
2575        0xc1, 0x5a, 0x20, 0x34, 0x3f, 0xf5, 0x8b, 0x6f,
2576        0xe4, 0x61, 0xf5, 0x58, 0xab, 0x72, 0x1a, 0xf1,
2577        0x8d, 0x28, 0xcc, 0xa5, 0x30, 0x68, 0xb5, 0x50,
2578        0x7b, 0x81, 0x43, 0x89, 0x8e, 0xa9, 0xac, 0x63,
2579        0x3a, 0x4a, 0x78, 0x7b, 0xd2, 0x45, 0xe6, 0xe0,
2580        0xdc, 0x5d, 0xf2, 0x1a, 0x2b, 0x54, 0x50, 0xa5,
2581        0x9d, 0xf6, 0xe7, 0x9f, 0x25, 0xaf, 0x56, 0x6a,
2582        0x84, 0x2a, 0x75, 0xa3, 0x9a, 0xc7, 0xfa, 0x94,
2583        0xec, 0x83, 0xab, 0xa5, 0xaa, 0xe1, 0xf9, 0x89,
2584        0x29, 0xa9, 0xf6, 0x53, 0x24, 0x24, 0xae, 0x4a,
2585        0xe8, 0xbc, 0xe8, 0x9e, 0x5c, 0xd7, 0x54, 0x7c,
2586        0x65, 0x20, 0x97, 0x28, 0x94, 0x76, 0xf9, 0x9e,
2587        0x81, 0xcf, 0x98, 0x6a, 0x3a, 0x7b, 0xec, 0xf3,
2588        0x09, 0x60, 0x2e, 0x43, 0x18, 0xb5, 0xf6, 0x8c,
2589        0x44, 0x0f, 0xf2, 0x0a, 0x17, 0x5b, 0xac, 0x98,
2590        0x30, 0xab, 0x6e, 0xd5, 0xb3, 0xef, 0x25, 0x68,
2591        0x50, 0xb6, 0xe1, 0xc0, 0xe4, 0x5a, 0x63, 0x43,
2592        0xea, 0xca, 0xda, 0x23, 0xc1, 0xc2, 0xe9, 0x30,
2593        0xec, 0xb3, 0x9f, 0xbf, 0x1f, 0x09, 0x76, 0xaf,
2594        0x65, 0xbc, 0xb5, 0xab, 0x30, 0xac, 0x0b, 0x05,
2595        0xef, 0x5c, 0xa3, 0x65, 0x77, 0x33, 0x1c, 0xc5,
2596        0xdf, 0xc9, 0x39, 0xab, 0xca, 0xf4, 0x3b, 0x88,
2597        0x25, 0x6d, 0x50, 0x87, 0xb1, 0x79, 0xc2, 0x23,
2598        0x9d, 0xb5, 0x21, 0x01, 0xaa, 0xa3, 0xb7, 0x61,
2599        0xa3, 0x48, 0x91, 0x72, 0x3d, 0x54, 0x85, 0x86,
2600        0x91, 0x81, 0x35, 0x78, 0xbf, 0x8f, 0x27, 0x57,
2601        0xcb, 0x9b, 0x34, 0xab, 0x63, 0x40, 0xf1, 0xbc,
2602        0x23, 0x5a, 0x26, 0x6a, 0xba, 0x57, 0xe2, 0x8f,
2603        0x2a, 0xdc, 0x82, 0xe0, 0x3b, 0x7f, 0xec, 0xd3,
2604        0xd8, 0x9d, 0xd3, 0x13, 0x54, 0x70, 0x64, 0xc3,
2605        0xfd, 0xbf, 0xa3, 0x46, 0xa7, 0x53, 0x42, 0x7f,
2606        0xc1, 0xbd, 0x7b, 0xb3, 0x13, 0x47, 0x2a, 0x45,
2607        0x1e, 0x76, 0x2c, 0x0d, 0x6d, 0x46, 0x26, 0x24,
2608        0xa8, 0xc7, 0x00, 0x2b, 0x10, 0x7f, 0x2a, 0x6c,
2609        0xfc, 0x68, 0x4e, 0x6e, 0x85, 0x53, 0x00, 0xaf,
2610        0xd5, 0xfb, 0x59, 0x64, 0xc7, 0x9b, 0x24, 0xd1,
2611        0x05, 0xdc, 0x34, 0x53, 0x6d, 0x27, 0xa9, 0x79,
2612        0xff, 0xd7, 0x5e, 0x7a, 0x40, 0x81, 0x8e, 0xc3,
2613        0xf2, 0x38, 0xc9, 0x8d, 0x87, 0xb5, 0x38, 0xda,
2614        0x43, 0x64, 0x1b, 0x59, 0x62, 0x88, 0xc1, 0x6e,
2615        0x85, 0x84, 0x33, 0xcd, 0x6d, 0x7b, 0x62, 0x1d,
2616        0x60, 0xf9, 0x98, 0xf7, 0xd1, 0xb1, 0xd4, 0xbe,
2617        0x56, 0x6e, 0xa8, 0x6f, 0xff, 0xe7, 0x8b, 0x60,
2618        0x53, 0x80, 0xc7, 0x7c, 0xe0, 0x78, 0x89, 0xa9,
2619        0xab, 0x42, 0x8f, 0x8e, 0x4d, 0x92, 0xac, 0xa7,
2620        0xfd, 0x47, 0x11, 0xc7, 0xdb, 0x7c, 0x77, 0xfb,
2621        0xa4, 0x1d, 0x70, 0xaf, 0x56, 0x14, 0x52, 0xb0
2622    };
2623
2624    /* 1024 byte pub key */
2625    static const byte expected_a_pub[] = {
2626        0xa1, 0x6c, 0x9e, 0xda, 0x45, 0x4d, 0xf6, 0x59,
2627        0x04, 0x00, 0xc1, 0xc6, 0x8b, 0x12, 0x3b, 0xcd,
2628        0x07, 0xe4, 0x3e, 0xec, 0xac, 0x9b, 0xfc, 0xf7,
2629        0x6d, 0x73, 0x39, 0x9e, 0x52, 0xf8, 0xbe, 0x33,
2630        0xe2, 0xca, 0xea, 0x99, 0x76, 0xc7, 0xc9, 0x94,
2631        0x5c, 0xf3, 0x1b, 0xea, 0x6b, 0x66, 0x4b, 0x51,
2632        0x90, 0xf6, 0x4f, 0x75, 0xd5, 0x85, 0xf4, 0x28,
2633        0xfd, 0x74, 0xa5, 0x57, 0xb1, 0x71, 0x0c, 0xb6,
2634        0xb6, 0x95, 0x70, 0x2d, 0xfa, 0x4b, 0x56, 0xe0,
2635        0x56, 0x10, 0x21, 0xe5, 0x60, 0xa6, 0x18, 0xa4,
2636        0x78, 0x8c, 0x07, 0xc0, 0x2b, 0x59, 0x9c, 0x84,
2637        0x5b, 0xe9, 0xb9, 0x74, 0xbf, 0xbc, 0x65, 0x48,
2638        0x27, 0x82, 0x40, 0x53, 0x46, 0x32, 0xa2, 0x92,
2639        0x91, 0x9d, 0xf6, 0xd1, 0x07, 0x0e, 0x1d, 0x07,
2640        0x1b, 0x41, 0x04, 0xb1, 0xd4, 0xce, 0xae, 0x6e,
2641        0x46, 0xf1, 0x72, 0x50, 0x7f, 0xff, 0xa8, 0xa2,
2642        0xbc, 0x3a, 0xc1, 0xbb, 0x28, 0xd7, 0x7d, 0xcd,
2643        0x7a, 0x22, 0x01, 0xaf, 0x57, 0xb0, 0xa9, 0x02,
2644        0xd4, 0x8a, 0x92, 0xd5, 0xe6, 0x8e, 0x6f, 0x11,
2645        0x39, 0xfe, 0x36, 0x87, 0x89, 0x42, 0x25, 0x42,
2646        0xd9, 0xbe, 0x67, 0x15, 0xe1, 0x82, 0x8a, 0x5e,
2647        0x98, 0xc2, 0xd5, 0xde, 0x9e, 0x13, 0x1a, 0xe7,
2648        0xf9, 0x9f, 0x8e, 0x2d, 0x49, 0xdc, 0x4d, 0x98,
2649        0x8c, 0xdd, 0xfd, 0x24, 0x7c, 0x46, 0xa9, 0x69,
2650        0x3b, 0x31, 0xb3, 0x12, 0xce, 0x54, 0xf6, 0x65,
2651        0x75, 0x40, 0xc2, 0xf1, 0x04, 0x92, 0xe3, 0x83,
2652        0xeb, 0x02, 0x3d, 0x79, 0xc0, 0xf9, 0x7c, 0x28,
2653        0xb3, 0x97, 0x03, 0xf7, 0x61, 0x1c, 0xce, 0x95,
2654        0x1a, 0xa0, 0xb3, 0x77, 0x1b, 0xc1, 0x9f, 0xf8,
2655        0xf6, 0x3f, 0x4d, 0x0a, 0xfb, 0xfa, 0x64, 0x1c,
2656        0xcb, 0x37, 0x5b, 0xc3, 0x28, 0x60, 0x9f, 0xd1,
2657        0xf2, 0xc4, 0xee, 0x77, 0xaa, 0x1f, 0xe9, 0xa2,
2658        0x89, 0x4c, 0xc6, 0xb7, 0xb3, 0xe4, 0xa5, 0xed,
2659        0xa7, 0xe8, 0xac, 0x90, 0xdc, 0xc3, 0xfb, 0x56,
2660        0x9c, 0xda, 0x2c, 0x1d, 0x1a, 0x9a, 0x8c, 0x82,
2661        0x92, 0xee, 0xdc, 0xa0, 0xa4, 0x01, 0x6e, 0x7f,
2662        0xc7, 0x0e, 0xc2, 0x73, 0x7d, 0xa6, 0xac, 0x12,
2663        0x01, 0xc0, 0xc0, 0xc8, 0x7c, 0x84, 0x86, 0xc7,
2664        0xa5, 0x94, 0xe5, 0x33, 0x84, 0x71, 0x6e, 0x36,
2665        0xe3, 0x3b, 0x81, 0x30, 0xe0, 0xc8, 0x51, 0x52,
2666        0x2b, 0x9e, 0x68, 0xa2, 0x6e, 0x09, 0x95, 0x8c,
2667        0x7f, 0x78, 0x82, 0xbd, 0x53, 0x26, 0xe7, 0x95,
2668        0xe0, 0x03, 0xda, 0xc0, 0xc3, 0x6e, 0xcf, 0xdc,
2669        0xb3, 0x14, 0xfc, 0xe9, 0x5b, 0x9b, 0x70, 0x6c,
2670        0x93, 0x04, 0xab, 0x13, 0xf7, 0x17, 0x6d, 0xee,
2671        0xad, 0x32, 0x48, 0xe9, 0xa0, 0x94, 0x1b, 0x14,
2672        0x64, 0x4f, 0xa1, 0xb3, 0x8d, 0x6a, 0xca, 0x28,
2673        0xfe, 0x4a, 0xf4, 0xf0, 0xc5, 0xb7, 0xf9, 0x8a,
2674        0x8e, 0xff, 0xfe, 0x57, 0x6f, 0x20, 0xdb, 0x04,
2675        0xab, 0x02, 0x31, 0x22, 0x42, 0xfd, 0xbd, 0x77,
2676        0xea, 0xce, 0xe8, 0xc7, 0x5d, 0xe0, 0x8e, 0xd6,
2677        0x66, 0xd0, 0xe4, 0x04, 0x2f, 0x5f, 0x71, 0xc7,
2678        0x61, 0x2d, 0xa5, 0x3f, 0x2f, 0x46, 0xf2, 0xd8,
2679        0x5b, 0x25, 0x82, 0xf0, 0x52, 0x88, 0xc0, 0x59,
2680        0xd3, 0xa3, 0x90, 0x17, 0xc2, 0x04, 0x13, 0xc3,
2681        0x13, 0x69, 0x4f, 0x17, 0xb1, 0xb3, 0x46, 0x4f,
2682        0xa7, 0xe6, 0x8b, 0x5e, 0x3e, 0x95, 0x0e, 0xf5,
2683        0x42, 0x17, 0x7f, 0x4d, 0x1f, 0x1b, 0x7d, 0x65,
2684        0x86, 0xc5, 0xc8, 0xae, 0xae, 0xd8, 0x4f, 0xe7,
2685        0x89, 0x41, 0x69, 0xfd, 0x06, 0xce, 0x5d, 0xed,
2686        0x44, 0x55, 0xad, 0x51, 0x98, 0x15, 0x78, 0x8d,
2687        0x68, 0xfc, 0x93, 0x72, 0x9d, 0x22, 0xe5, 0x1d,
2688        0x21, 0xc3, 0xbe, 0x3a, 0x44, 0x34, 0xc0, 0xa3,
2689        0x1f, 0xca, 0xdf, 0x45, 0xd0, 0x5c, 0xcd, 0xb7,
2690        0x72, 0xeb, 0xae, 0x7a, 0xad, 0x3f, 0x05, 0xa0,
2691        0xe3, 0x6e, 0x5a, 0xd8, 0x52, 0xa7, 0xf1, 0x1e,
2692        0xb4, 0xf2, 0xcf, 0xe7, 0xdf, 0xa7, 0xf2, 0x22,
2693        0x00, 0xb2, 0xc4, 0x17, 0x3d, 0x2c, 0x15, 0x04,
2694        0x71, 0x28, 0x69, 0x5c, 0x69, 0x21, 0xc8, 0xf1,
2695        0x9b, 0xd8, 0xc7, 0xbc, 0x27, 0xa3, 0x85, 0xe9,
2696        0x53, 0x77, 0xd3, 0x65, 0xc3, 0x86, 0xdd, 0xb3,
2697        0x76, 0x13, 0xfb, 0xa1, 0xd4, 0xee, 0x9d, 0xe4,
2698        0x51, 0x3f, 0x83, 0x59, 0xe4, 0x47, 0xa8, 0xa6,
2699        0x0d, 0x68, 0xd5, 0xf6, 0xf4, 0xca, 0x31, 0xcd,
2700        0x30, 0x48, 0x34, 0x90, 0x11, 0x8e, 0x87, 0xe9,
2701        0xea, 0xc9, 0xd0, 0xc3, 0xba, 0x28, 0xf9, 0xc0,
2702        0xc9, 0x8e, 0x23, 0xe5, 0xc2, 0xee, 0xf2, 0x47,
2703        0x9c, 0x41, 0x1c, 0x10, 0x33, 0x27, 0x23, 0x49,
2704        0xe5, 0x0d, 0x18, 0xbe, 0x19, 0xc1, 0xba, 0x6c,
2705        0xdc, 0xb7, 0xa1, 0xe7, 0xc5, 0x0d, 0x6f, 0xf0,
2706        0x8c, 0x62, 0x6e, 0x0d, 0x14, 0xef, 0xef, 0xf2,
2707        0x8e, 0x01, 0xd2, 0x76, 0xf5, 0xc1, 0xe1, 0x92,
2708        0x3c, 0xb3, 0x76, 0xcd, 0xd8, 0xdd, 0x9b, 0xe0,
2709        0x8e, 0xdc, 0x24, 0x34, 0x13, 0x65, 0x0f, 0x11,
2710        0xaf, 0x99, 0x7a, 0x2f, 0xe6, 0x1f, 0x7d, 0x17,
2711        0x3e, 0x8a, 0x68, 0x9a, 0x37, 0xc8, 0x8d, 0x3e,
2712        0xa3, 0xfe, 0xfe, 0x57, 0x22, 0xe6, 0x0e, 0x50,
2713        0xb5, 0x98, 0x0b, 0x71, 0xd8, 0x01, 0xa2, 0x8d,
2714        0x51, 0x96, 0x50, 0xc2, 0x41, 0x31, 0xd8, 0x23,
2715        0x98, 0xfc, 0xd1, 0x9d, 0x7e, 0x27, 0xbb, 0x69,
2716        0x78, 0xe0, 0x87, 0xf7, 0xe4, 0xdd, 0x58, 0x13,
2717        0x9d, 0xec, 0x00, 0xe4, 0xb9, 0x70, 0xa2, 0x94,
2718        0x5d, 0x52, 0x4e, 0xf2, 0x5c, 0xd1, 0xbc, 0xfd,
2719        0xee, 0x9b, 0xb9, 0xe5, 0xc4, 0xc0, 0xa8, 0x77,
2720        0x67, 0xa4, 0xd1, 0x95, 0x34, 0xe4, 0x6d, 0x5f,
2721        0x25, 0x02, 0x8d, 0x65, 0xdd, 0x11, 0x63, 0x55,
2722        0x04, 0x01, 0x21, 0x60, 0xc1, 0x5c, 0xef, 0x77,
2723        0x33, 0x01, 0x1c, 0xa2, 0x11, 0x2b, 0xdd, 0x2b,
2724        0x74, 0x99, 0x23, 0x38, 0x05, 0x1b, 0x7e, 0x2e,
2725        0x01, 0x52, 0xfe, 0x9c, 0x23, 0xde, 0x3e, 0x1a,
2726        0x72, 0xf4, 0xff, 0x7b, 0x02, 0xaa, 0x08, 0xcf,
2727        0xe0, 0x5b, 0x83, 0xbe, 0x85, 0x5a, 0xe8, 0x9d,
2728        0x11, 0x3e, 0xff, 0x2f, 0xc6, 0x97, 0x67, 0x36,
2729        0x6c, 0x0f, 0x81, 0x9c, 0x26, 0x29, 0xb1, 0x0f,
2730        0xbb, 0x53, 0xbd, 0xf4, 0xec, 0x2a, 0x84, 0x41,
2731        0x28, 0x3b, 0x86, 0x40, 0x95, 0x69, 0x55, 0x5f,
2732        0x30, 0xee, 0xda, 0x1e, 0x6c, 0x4b, 0x25, 0xd6,
2733        0x2f, 0x2c, 0x0e, 0x3c, 0x1a, 0x26, 0xa0, 0x3e,
2734        0xef, 0x09, 0xc6, 0x2b, 0xe5, 0xa1, 0x0c, 0x03,
2735        0xa8, 0xf5, 0x39, 0x70, 0x31, 0xc4, 0x32, 0x79,
2736        0xd1, 0xd9, 0xc2, 0xcc, 0x32, 0x4a, 0xf1, 0x2f,
2737        0x57, 0x5a, 0xcc, 0xe5, 0xc3, 0xc5, 0xd5, 0x4e,
2738        0x86, 0x56, 0xca, 0x64, 0xdb, 0xab, 0x61, 0x85,
2739        0x8f, 0xf9, 0x20, 0x02, 0x40, 0x66, 0x76, 0x9e,
2740        0x5e, 0xd4, 0xac, 0xf0, 0x47, 0xa6, 0x50, 0x5f,
2741        0xc2, 0xaf, 0x55, 0x9b, 0xa3, 0xc9, 0x8b, 0xf8,
2742        0x42, 0xd5, 0xcf, 0x1a, 0x95, 0x22, 0xd9, 0xd1,
2743        0x0b, 0x92, 0x51, 0xca, 0xde, 0x46, 0x02, 0x0d,
2744        0x8b, 0xee, 0xd9, 0xa0, 0x04, 0x74, 0xf5, 0x0e,
2745        0xb0, 0x3a, 0x62, 0xec, 0x3c, 0x91, 0x29, 0x33,
2746        0xa7, 0x78, 0x22, 0x92, 0xac, 0x27, 0xe6, 0x2d,
2747        0x6f, 0x56, 0x8a, 0x5d, 0x72, 0xc2, 0xf1, 0x5c,
2748        0x54, 0x11, 0x97, 0x24, 0x61, 0xcb, 0x0c, 0x52,
2749        0xd4, 0x57, 0x56, 0x22, 0x86, 0xf0, 0x19, 0x27,
2750        0x76, 0x30, 0x04, 0xf4, 0x39, 0x7b, 0x1a, 0x5a,
2751        0x04, 0x0d, 0xec, 0x59, 0x9a, 0x31, 0x4c, 0x40,
2752        0x19, 0x6d, 0x3c, 0x41, 0x1b, 0x0c, 0xca, 0xeb,
2753        0x25, 0x39, 0x6c, 0x96, 0xf8, 0x55, 0xd0, 0xec
2754    };
2755
2756    /* 1024 byte shared secret */
2757    static const byte shared_secret[] = {
2758        0xf9, 0x55, 0x4f, 0x48, 0x38, 0x74, 0xb7, 0x46, 0xa3, 0xc4, 0x2e, 0x88, 0xf0, 0x34, 0xab, 0x1d,
2759        0xcd, 0xa5, 0x58, 0xa7, 0x95, 0x88, 0x36, 0x62, 0x6f, 0x8a, 0xbd, 0xf2, 0xfb, 0x6f, 0x3e, 0xb9,
2760        0x91, 0x65, 0x58, 0xef, 0x70, 0x2f, 0xd5, 0xc2, 0x97, 0x70, 0xcb, 0xce, 0x8b, 0x78, 0x1c, 0xe0,
2761        0xb9, 0xfa, 0x77, 0x34, 0xd2, 0x4a, 0x19, 0x58, 0x11, 0xfd, 0x93, 0x84, 0x40, 0xc0, 0x8c, 0x19,
2762        0x8b, 0x98, 0x50, 0x83, 0xba, 0xfb, 0xe2, 0xad, 0x8b, 0x81, 0x84, 0x63, 0x90, 0x41, 0x4b, 0xf8,
2763        0xe8, 0x78, 0x86, 0x04, 0x09, 0x8d, 0x84, 0xd1, 0x43, 0xfd, 0xa3, 0x58, 0x21, 0x2a, 0x3b, 0xb1,
2764        0xa2, 0x5b, 0x48, 0x74, 0x3c, 0xa9, 0x16, 0x34, 0x28, 0xf0, 0x8e, 0xde, 0xe2, 0xcf, 0x8e, 0x68,
2765        0x53, 0xab, 0x65, 0x06, 0xb7, 0x86, 0xb1, 0x08, 0x4f, 0x73, 0x97, 0x00, 0x10, 0x95, 0xd1, 0x84,
2766        0x72, 0xcf, 0x14, 0xdb, 0xff, 0xa7, 0x80, 0xd8, 0xe5, 0xf2, 0x2c, 0x89, 0x37, 0xb0, 0x81, 0x2c,
2767        0xf5, 0xd6, 0x7d, 0x1b, 0xb0, 0xe2, 0x8e, 0x87, 0x32, 0x3d, 0x37, 0x6a, 0x79, 0xaa, 0xe7, 0x08,
2768        0xc9, 0x67, 0x55, 0x5f, 0x1c, 0xae, 0xa6, 0xf5, 0xef, 0x79, 0x3a, 0xaf, 0x3f, 0x82, 0x14, 0xe2,
2769        0xf3, 0x69, 0x91, 0xed, 0xb7, 0x9e, 0xc9, 0xde, 0xd0, 0x29, 0x70, 0xd9, 0xeb, 0x0f, 0xf5, 0xc7,
2770        0xf6, 0x7c, 0xa7, 0x7f, 0xec, 0xed, 0xe1, 0xbd, 0x13, 0xe1, 0x43, 0xe4, 0x42, 0x30, 0xe3, 0x5f,
2771        0xe0, 0xf3, 0x15, 0x55, 0x2f, 0x7a, 0x42, 0x17, 0x67, 0xcb, 0xc2, 0x4f, 0xd0, 0x85, 0xfc, 0x6c,
2772        0xec, 0xe8, 0xfc, 0x25, 0x78, 0x4b, 0xe4, 0x0f, 0xd4, 0x3d, 0x78, 0x28, 0xd3, 0x53, 0x79, 0xcb,
2773        0x2c, 0x82, 0x67, 0x9a, 0xdc, 0x32, 0x55, 0xd2, 0xda, 0xae, 0xd8, 0x61, 0xce, 0xd6, 0x59, 0x0b,
2774        0xc5, 0x44, 0xeb, 0x08, 0x81, 0x8c, 0x65, 0xb2, 0xb7, 0xa6, 0xff, 0xf7, 0xbf, 0x99, 0xc6, 0x8a,
2775        0xbe, 0xde, 0xc2, 0x17, 0x56, 0x05, 0x6e, 0xd2, 0xf1, 0x1e, 0xa2, 0x04, 0xeb, 0x02, 0x74, 0xaa,
2776        0x04, 0xfc, 0xf0, 0x6b, 0xd4, 0xfc, 0xf0, 0x7a, 0x5f, 0xfe, 0xe2, 0x74, 0x7f, 0xeb, 0x9b, 0x6a,
2777        0x8a, 0x09, 0x96, 0x5d, 0xe1, 0x91, 0xb6, 0x9e, 0x37, 0xd7, 0x63, 0xd7, 0xb3, 0x5c, 0xb5, 0xa3,
2778        0x5f, 0x62, 0x00, 0xdf, 0xc5, 0xbf, 0x85, 0xba, 0xa7, 0xa9, 0xb6, 0x1f, 0x76, 0x78, 0x65, 0x01,
2779        0xfe, 0x1d, 0x6c, 0xfe, 0x15, 0x9e, 0xf4, 0xb1, 0xbc, 0x8d, 0xad, 0x3c, 0xec, 0x69, 0x27, 0x57,
2780        0xa4, 0x89, 0x77, 0x46, 0xe1, 0x49, 0xc7, 0x22, 0xde, 0x79, 0xe0, 0xf7, 0x3a, 0xa1, 0x59, 0x8b,
2781        0x59, 0x71, 0xcc, 0xd6, 0x18, 0x24, 0xc1, 0x8a, 0x2f, 0xe3, 0xdf, 0xdd, 0x6c, 0xf7, 0x62, 0xaa,
2782        0x15, 0xaa, 0x39, 0x37, 0x3b, 0xaf, 0x7d, 0x6e, 0x88, 0xeb, 0x19, 0xa8, 0xa0, 0x26, 0xd3, 0xaa,
2783        0x2d, 0xcc, 0x5f, 0x56, 0x99, 0x86, 0xa9, 0xed, 0x4d, 0x02, 0x31, 0x40, 0x97, 0x70, 0x83, 0xa7,
2784        0x08, 0x98, 0x7e, 0x49, 0x46, 0xd9, 0x75, 0xb5, 0x7a, 0x6a, 0x40, 0x69, 0xa0, 0x6d, 0xb2, 0x18,
2785        0xc0, 0xad, 0x88, 0x05, 0x02, 0x95, 0x6f, 0xf7, 0x8f, 0xcb, 0xa2, 0xe4, 0x7b, 0xab, 0x4a, 0x0f,
2786        0x9a, 0x1b, 0xef, 0xcc, 0xd1, 0x6a, 0x5d, 0x1e, 0x6a, 0x2a, 0x8b, 0x5b, 0x80, 0xbc, 0x5f, 0x38,
2787        0xdd, 0xaf, 0xad, 0x44, 0x15, 0xb4, 0xaf, 0x26, 0x1c, 0x1a, 0x4d, 0xa7, 0x4b, 0xec, 0x88, 0x33,
2788        0x24, 0x42, 0xb5, 0x0c, 0x9c, 0x56, 0xd4, 0xba, 0xa7, 0xb9, 0x65, 0xd5, 0x76, 0xb2, 0xbc, 0x16,
2789        0x8e, 0xfa, 0x0c, 0x7a, 0xc0, 0xa2, 0x2c, 0x5a, 0x39, 0x56, 0x7d, 0xe6, 0xf8, 0xa9, 0xf4, 0x49,
2790        0xd0, 0x50, 0xf2, 0x5e, 0x4b, 0x0a, 0x43, 0xe4, 0x9a, 0xbb, 0xea, 0x35, 0x28, 0x99, 0x84, 0x83,
2791        0xec, 0xc1, 0xa0, 0x68, 0x15, 0x9a, 0x2b, 0x01, 0x04, 0x48, 0x09, 0x11, 0x1b, 0xb6, 0xa4, 0xd8,
2792        0x03, 0xad, 0xb6, 0x4c, 0x9e, 0x1d, 0x90, 0xae, 0x88, 0x0f, 0x75, 0x95, 0x25, 0xa0, 0x27, 0x13,
2793        0xb7, 0x4f, 0xe2, 0x3e, 0xd5, 0x59, 0x1a, 0x7c, 0xde, 0x95, 0x14, 0x28, 0xd1, 0xde, 0x84, 0xe4,
2794        0x07, 0x7c, 0x5b, 0x06, 0xd6, 0xe6, 0x9c, 0x8a, 0xbe, 0xd2, 0xb4, 0x62, 0xd1, 0x67, 0x8a, 0x9c,
2795        0xac, 0x4f, 0xfa, 0x70, 0xd6, 0xc8, 0xc0, 0xeb, 0x5e, 0xf6, 0x3e, 0xdc, 0x48, 0x8e, 0xce, 0x3f,
2796        0x92, 0x3e, 0x60, 0x77, 0x63, 0x60, 0x6b, 0x76, 0x04, 0xa5, 0xba, 0xc9, 0xab, 0x92, 0x4e, 0x0d,
2797        0xdc, 0xca, 0x82, 0x44, 0x5f, 0x3a, 0x42, 0xeb, 0x01, 0xe7, 0xe0, 0x33, 0xb3, 0x32, 0xaf, 0x4b,
2798        0x81, 0x35, 0x2d, 0xb6, 0x57, 0x15, 0xfe, 0x52, 0xc7, 0x54, 0x2e, 0x41, 0x3b, 0x22, 0x6b, 0x12,
2799        0x72, 0xdb, 0x5c, 0x66, 0xd0, 0xb6, 0xb4, 0xfe, 0x90, 0xc0, 0x20, 0x34, 0x95, 0xf9, 0xe4, 0xc7,
2800        0x7e, 0x71, 0x89, 0x4f, 0x6f, 0xfb, 0x2a, 0xf3, 0xdf, 0x3f, 0xe3, 0xcf, 0x0e, 0x1a, 0xd9, 0xf2,
2801        0xc1, 0x02, 0x67, 0x5d, 0xdc, 0xf1, 0x7d, 0xe8, 0xcf, 0x64, 0x77, 0x4d, 0x12, 0x03, 0x77, 0x2c,
2802        0xfb, 0xe1, 0x59, 0xf7, 0x2c, 0x96, 0x9c, 0xaf, 0x46, 0x9c, 0xc7, 0x67, 0xcf, 0xee, 0x94, 0x50,
2803        0xc7, 0xa1, 0x23, 0xe6, 0x9f, 0x4d, 0x73, 0x92, 0xad, 0xf9, 0x4a, 0xce, 0xdb, 0x44, 0xd5, 0xe3,
2804        0x17, 0x05, 0x37, 0xdb, 0x9c, 0x6c, 0xc5, 0x7e, 0xb7, 0xd4, 0x11, 0x4a, 0x8c, 0x51, 0x03, 0xaa,
2805        0x73, 0x4b, 0x16, 0xd9, 0x79, 0xf5, 0xf1, 0x67, 0x20, 0x9b, 0x25, 0xe5, 0x41, 0x52, 0x59, 0x06,
2806        0x8b, 0xf2, 0x23, 0x2f, 0x6e, 0xea, 0xf3, 0x24, 0x0a, 0x94, 0xbb, 0xb8, 0x7e, 0xd9, 0x23, 0x4a,
2807        0x9f, 0x1f, 0xe1, 0x13, 0xb5, 0xfe, 0x85, 0x2f, 0x4c, 0xbe, 0x6a, 0x66, 0x02, 0x1d, 0x90, 0xd2,
2808        0x01, 0x25, 0x8a, 0xfd, 0x78, 0x3a, 0x28, 0xb8, 0x18, 0xc1, 0x38, 0x16, 0x21, 0x6b, 0xb4, 0xf9,
2809        0x64, 0x0f, 0xf1, 0x73, 0xc4, 0x5c, 0xd1, 0x41, 0xf2, 0xfe, 0xe7, 0x26, 0xad, 0x79, 0x12, 0x75,
2810        0x49, 0x48, 0xdb, 0x21, 0x71, 0x35, 0xf7, 0xb7, 0x46, 0x5a, 0xa1, 0x81, 0x25, 0x47, 0x31, 0xea,
2811        0x1d, 0x76, 0xbb, 0x32, 0x5a, 0x90, 0xb0, 0x42, 0x1a, 0x47, 0xe8, 0x0c, 0x82, 0x92, 0x43, 0x1c,
2812        0x0b, 0xdd, 0xe5, 0x25, 0xce, 0xd3, 0x06, 0xcc, 0x59, 0x5a, 0xc9, 0xa0, 0x01, 0xac, 0x29, 0x12,
2813        0x31, 0x2e, 0x3d, 0x1a, 0xed, 0x3b, 0xf3, 0xa7, 0xef, 0x52, 0xc2, 0x0d, 0x18, 0x1f, 0x03, 0x28,
2814        0xc9, 0x2b, 0x38, 0x61, 0xa4, 0x01, 0xc9, 0x3c, 0x11, 0x08, 0x14, 0xd4, 0xe5, 0x31, 0xe9, 0x3c,
2815        0x1d, 0xad, 0xf8, 0x76, 0xc4, 0x84, 0x9f, 0xea, 0x16, 0x61, 0x3d, 0x6d, 0xa3, 0x32, 0x31, 0xcd,
2816        0x1c, 0xca, 0xb8, 0x74, 0xc2, 0x45, 0xf3, 0x01, 0x9c, 0x7a, 0xaf, 0xfd, 0xe7, 0x1e, 0x5a, 0x18,
2817        0xb1, 0x9d, 0xbb, 0x7a, 0x2d, 0x34, 0x40, 0x17, 0x49, 0xad, 0x1f, 0xeb, 0x2d, 0xa2, 0x26, 0xb8,
2818        0x16, 0x28, 0x4b, 0x72, 0xdd, 0xd0, 0x8d, 0x85, 0x4c, 0xdd, 0xf8, 0x57, 0x48, 0xd5, 0x1d, 0xfb,
2819        0xbd, 0xec, 0x11, 0x5d, 0x1e, 0x9c, 0x26, 0x81, 0xbf, 0xf1, 0x16, 0x12, 0x32, 0xc3, 0xf3, 0x07,
2820        0x0e, 0x6e, 0x7f, 0x17, 0xec, 0xfb, 0xf4, 0x5d, 0xe2, 0xb1, 0xca, 0x97, 0xca, 0x46, 0x20, 0x2d,
2821        0x09, 0x85, 0x19, 0x25, 0x89, 0xa8, 0x9b, 0x51, 0x74, 0xae, 0xc9, 0x1b, 0x4c, 0xb6, 0x80, 0x62
2822    };
2823
2824    rc = linuxkm_test_kpp_driver(WOLFKM_FFDHE8192_DRIVER,
2825                                 b_pub, expected_a_pub, sizeof(b_pub),
2826                                 secret, sizeof(secret),
2827                                 shared_secret, sizeof(shared_secret));
2828
2829    return rc;
2830}
2831#endif /* HAVE_FFDHE_8192 */
2832
2833/**
2834 * driver          the crypto driver to test
2835 * b_pub           pub from party B
2836 * expected_a_pub  the expected generated pub from party A
2837 * pub_len         pub key length
2838 * a_secret        the secret data for party A
2839 * secret_len      the secret data length
2840 * shared_secret   the expected generated shared secret
2841 * shared_s_len    the expected shared secret length
2842 * */
2843static int linuxkm_test_kpp_driver(const char * driver,
2844                                   const byte * b_pub,
2845                                   const byte * expected_a_pub,
2846                                   word32 pub_len,
2847                                   const byte * a_secret,
2848                                   word32 secret_len,
2849                                   const byte * shared_secret,
2850                                   word32 shared_s_len)
2851{
2852    int                  test_rc = WC_NO_ERR_TRACE(WC_FAILURE);
2853    struct crypto_kpp *  tfm = NULL;
2854    struct kpp_request * req = NULL;
2855    struct scatterlist   src, dst;
2856    int                  err = 0;
2857    byte *               src_buf = NULL;
2858    byte *               dst_buf = NULL;
2859    unsigned int         src_len = pub_len;
2860    unsigned int         dst_len = 0;
2861    /**
2862     * Allocate the kpp transform, and set up
2863     * the kpp request.
2864     * */
2865    tfm = crypto_alloc_kpp(driver, 0, 0);
2866    if (IS_ERR(tfm)) {
2867        pr_err("error: allocating kpp algorithm %s failed: %ld\n",
2868               driver, PTR_ERR(tfm));
2869        if (PTR_ERR(tfm) == -ENOMEM)
2870            test_rc = MEMORY_E;
2871        else
2872            test_rc = BAD_FUNC_ARG;
2873        tfm = NULL;
2874        goto test_kpp_end;
2875    }
2876
2877    req = kpp_request_alloc(tfm, GFP_KERNEL);
2878    if (IS_ERR(req)) {
2879        pr_err("error: allocating kpp request %s failed\n",
2880               driver);
2881        if (PTR_ERR(req) == -ENOMEM)
2882            test_rc = MEMORY_E;
2883        else
2884            test_rc = BAD_FUNC_ARG;
2885        req = NULL;
2886        goto test_kpp_end;
2887    }
2888
2889    err = crypto_kpp_set_secret(tfm, a_secret, secret_len);
2890    if (err) {
2891        pr_err("error: crypto_kpp_set_secret returned: %d\n", err);
2892        test_rc = BAD_FUNC_ARG;
2893        goto test_kpp_end;
2894    }
2895
2896    /* large enough to hold largest req output. */
2897    dst_len = crypto_kpp_maxsize(tfm);
2898    if (dst_len <= 0) {
2899        pr_err("error: crypto_kpp_maxsize returned: %d\n", dst_len);
2900        test_rc = BAD_FUNC_ARG;
2901        goto test_kpp_end;
2902    }
2903
2904    dst_buf = malloc(dst_len);
2905    if (dst_buf == NULL) {
2906        pr_err("error: allocating out buf failed\n");
2907        test_rc = MEMORY_E;
2908        goto test_kpp_end;
2909    }
2910
2911    memset(dst_buf, 0, dst_len);
2912
2913    /* generate pub key from input, and verify matches expected. */
2914    kpp_request_set_input(req, NULL, 0);
2915    sg_init_one(&dst, dst_buf, dst_len);
2916    kpp_request_set_output(req, &dst, dst_len);
2917
2918    err = crypto_kpp_generate_public_key(req);
2919    if (err) {
2920        pr_err("error: crypto_kpp_generate_public_key returned: %d\n", err);
2921        test_rc = BAD_FUNC_ARG;
2922        goto test_kpp_end;
2923    }
2924
2925    if (memcmp(expected_a_pub, sg_virt(req->dst), pub_len)) {
2926        pr_err("error: crypto_kpp_generate_public_key: wrong output\n");
2927        test_rc = WC_KEY_MISMATCH_E;
2928        goto test_kpp_end;
2929    }
2930
2931    src_buf = malloc(src_len);
2932    if (src_buf == NULL) {
2933        pr_err("error: allocating in buf failed\n");
2934        test_rc = MEMORY_E;
2935        goto test_kpp_end;
2936    }
2937
2938    memcpy(src_buf, b_pub, pub_len);
2939
2940    /* generate shared secret, verify matches expected value. */
2941    sg_init_one(&src, src_buf, src_len);
2942    sg_init_one(&dst, dst_buf, dst_len);
2943    kpp_request_set_input(req, &src, src_len);
2944    kpp_request_set_output(req, &dst, dst_len);
2945
2946    err = crypto_kpp_compute_shared_secret(req);
2947    if (err) {
2948        pr_err("error: crypto_kpp_compute_shared_secret returned: %d\n", err);
2949        test_rc = BAD_FUNC_ARG;
2950        goto test_kpp_end;
2951    }
2952
2953    if (memcmp(shared_secret, sg_virt(req->dst), shared_s_len)) {
2954        pr_err("error: shared secret does not match\n");
2955        test_rc = BAD_FUNC_ARG;
2956        goto test_kpp_end;
2957    }
2958
2959    test_rc = 0;
2960test_kpp_end:
2961    if (req) { kpp_request_free(req); req = NULL; }
2962    if (tfm) { crypto_free_kpp(tfm); tfm = NULL; }
2963
2964    if (src_buf) { free(src_buf); src_buf = NULL; }
2965    if (dst_buf) { free(dst_buf); dst_buf = NULL; }
2966
2967    #ifdef WOLFKM_DEBUG_DH
2968    pr_info("info: %s: self test returned: %d\n", driver, test_rc);
2969    #endif /* WOLFKM_DEBUG_DH */
2970
2971    return test_rc;
2972}
2973
2974#endif /* LINUXKM_LKCAPI_REGISTER_DH */
2975
2976#endif /* !WC_SKIP_INCLUDED_C_FILES */