luna - wolfssl/tests/api/test_evp

   1/* test_evp_pkey.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#include <tests/unit.h>
  23
  24#ifdef NO_INLINE
  25    #include <wolfssl/wolfcrypt/misc.h>
  26#else
  27    #define WOLFSSL_MISC_INCLUDED
  28    #include <wolfcrypt/src/misc.c>
  29#endif
  30
  31#include <wolfssl/openssl/evp.h>
  32#include <wolfssl/openssl/kdf.h>
  33#include <tests/api/api.h>
  34#include <tests/api/test_evp_pkey.h>
  35
  36
  37int test_wolfSSL_EVP_PKEY_CTX_new_id(void)
  38{
  39    EXPECT_DECLS;
  40#ifdef OPENSSL_ALL
  41    WOLFSSL_ENGINE* e = NULL;
  42    int id = 0;
  43    EVP_PKEY_CTX *ctx = NULL;
  44
  45    ExpectNotNull(ctx = wolfSSL_EVP_PKEY_CTX_new_id(id, e));
  46
  47    EVP_PKEY_CTX_free(ctx);
  48#endif
  49    return EXPECT_RESULT();
  50}
  51
  52int test_wolfSSL_EVP_PKEY_CTX_set_rsa_keygen_bits(void)
  53{
  54    EXPECT_DECLS;
  55#ifdef OPENSSL_ALL
  56    WOLFSSL_EVP_PKEY*   pkey = NULL;
  57    EVP_PKEY_CTX*       ctx = NULL;
  58    int                 bits = 2048;
  59
  60    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
  61    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
  62
  63    ExpectIntEQ(wolfSSL_EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, bits),
  64        WOLFSSL_SUCCESS);
  65
  66    EVP_PKEY_CTX_free(ctx);
  67    EVP_PKEY_free(pkey);
  68#endif
  69    return EXPECT_RESULT();
  70}
  71
  72int test_wolfSSL_QT_EVP_PKEY_CTX_free(void)
  73{
  74    EXPECT_DECLS;
  75#if defined(OPENSSL_EXTRA) && defined(OPENSSL_ALL)
  76    EVP_PKEY*     pkey = NULL;
  77    EVP_PKEY_CTX* ctx = NULL;
  78
  79    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
  80    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
  81
  82#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L
  83    /* void */
  84    EVP_PKEY_CTX_free(ctx);
  85#else
  86    /* int */
  87    ExpectIntEQ(EVP_PKEY_CTX_free(ctx), WOLFSSL_SUCCESS);
  88#endif
  89
  90    EVP_PKEY_free(pkey);
  91#endif
  92    return EXPECT_RESULT();
  93}
  94
  95int test_wolfSSL_EVP_PKEY_up_ref(void)
  96{
  97    EXPECT_DECLS;
  98#if defined(OPENSSL_ALL)
  99    EVP_PKEY* pkey;
 100
 101    pkey = EVP_PKEY_new();
 102    ExpectNotNull(pkey);
 103    ExpectIntEQ(EVP_PKEY_up_ref(NULL), 0);
 104    ExpectIntEQ(EVP_PKEY_up_ref(pkey), 1);
 105    EVP_PKEY_free(pkey);
 106    ExpectIntEQ(EVP_PKEY_up_ref(pkey), 1);
 107    EVP_PKEY_free(pkey);
 108    EVP_PKEY_free(pkey);
 109#endif
 110    return EXPECT_RESULT();
 111}
 112
 113int test_wolfSSL_EVP_PKEY_base_id(void)
 114{
 115    EXPECT_DECLS;
 116#ifdef OPENSSL_ALL
 117    WOLFSSL_EVP_PKEY* pkey = NULL;
 118
 119    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
 120
 121    ExpectIntEQ(wolfSSL_EVP_PKEY_base_id(NULL), NID_undef);
 122
 123    ExpectIntEQ(wolfSSL_EVP_PKEY_base_id(pkey), EVP_PKEY_RSA);
 124
 125    EVP_PKEY_free(pkey);
 126#endif
 127    return EXPECT_RESULT();
 128}
 129int test_wolfSSL_EVP_PKEY_id(void)
 130{
 131    EXPECT_DECLS;
 132#ifdef OPENSSL_ALL
 133    WOLFSSL_EVP_PKEY* pkey = NULL;
 134
 135    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
 136
 137    ExpectIntEQ(wolfSSL_EVP_PKEY_id(NULL), 0);
 138
 139    ExpectIntEQ(wolfSSL_EVP_PKEY_id(pkey), EVP_PKEY_RSA);
 140
 141    EVP_PKEY_free(pkey);
 142#endif
 143    return EXPECT_RESULT();
 144}
 145
 146int test_wolfSSL_EVP_MD_pkey_type(void)
 147{
 148    EXPECT_DECLS;
 149#ifdef OPENSSL_EXTRA
 150    const WOLFSSL_EVP_MD* md;
 151
 152#ifndef NO_MD5
 153    ExpectNotNull(md = EVP_md5());
 154    ExpectIntEQ(EVP_MD_pkey_type(md), NID_md5WithRSAEncryption);
 155#endif
 156#ifndef NO_SHA
 157    ExpectNotNull(md = EVP_sha1());
 158    ExpectIntEQ(EVP_MD_pkey_type(md), NID_sha1WithRSAEncryption);
 159#endif
 160#ifdef WOLFSSL_SHA224
 161    ExpectNotNull(md = EVP_sha224());
 162    ExpectIntEQ(EVP_MD_pkey_type(md), NID_sha224WithRSAEncryption);
 163#endif
 164    ExpectNotNull(md = EVP_sha256());
 165    ExpectIntEQ(EVP_MD_pkey_type(md), NID_sha256WithRSAEncryption);
 166#ifdef WOLFSSL_SHA384
 167    ExpectNotNull(md = EVP_sha384());
 168    ExpectIntEQ(EVP_MD_pkey_type(md), NID_sha384WithRSAEncryption);
 169#endif
 170#ifdef WOLFSSL_SHA512
 171    ExpectNotNull(md = EVP_sha512());
 172    ExpectIntEQ(EVP_MD_pkey_type(md), NID_sha512WithRSAEncryption);
 173#endif
 174#endif
 175    return EXPECT_RESULT();
 176}
 177
 178#ifdef OPENSSL_EXTRA
 179static int test_hmac_signing(const WOLFSSL_EVP_MD *type, const byte* testKey,
 180        size_t testKeySz, const char* testData, size_t testDataSz,
 181        const byte* testResult, size_t testResultSz)
 182{
 183    EXPECT_DECLS;
 184    unsigned char check[WC_MAX_DIGEST_SIZE];
 185    size_t checkSz = 0;
 186    WOLFSSL_EVP_PKEY* key = NULL;
 187    WOLFSSL_EVP_MD_CTX mdCtx;
 188
 189    ExpectNotNull(key = wolfSSL_EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL,
 190                                                      testKey, (int)testKeySz));
 191    wolfSSL_EVP_MD_CTX_init(&mdCtx);
 192    ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, NULL, type, NULL, key), 1);
 193    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData,
 194                                                  (unsigned int)testDataSz), 1);
 195    checkSz = sizeof(check);
 196    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, NULL, &checkSz), 1);
 197    ExpectIntEQ((int)checkSz, (int)testResultSz);
 198    checkSz = sizeof(check);
 199    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
 200    ExpectIntEQ((int)checkSz,(int)testResultSz);
 201    ExpectIntEQ(XMEMCMP(testResult, check, testResultSz), 0);
 202    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 203
 204    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, type, NULL, key), 1);
 205    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData,
 206                                                  (unsigned int)testDataSz), 1);
 207    ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, testResult, checkSz), 1);
 208
 209    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 210    wolfSSL_EVP_MD_CTX_init(&mdCtx);
 211    ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, NULL, type, NULL, key), 1);
 212    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData, 4), 1);
 213    checkSz = sizeof(check);
 214    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, NULL, &checkSz), 1);
 215    ExpectIntEQ((int)checkSz, (int)testResultSz);
 216    checkSz = sizeof(check);
 217    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
 218    ExpectIntEQ((int)checkSz,(int)testResultSz);
 219    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData + 4,
 220                                              (unsigned int)testDataSz - 4), 1);
 221    checkSz = sizeof(check);
 222    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
 223    ExpectIntEQ((int)checkSz,(int)testResultSz);
 224    ExpectIntEQ(XMEMCMP(testResult, check, testResultSz), 0);
 225
 226    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 227    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, type, NULL, key), 1);
 228    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData, 4), 1);
 229    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData + 4,
 230                                              (unsigned int)testDataSz - 4), 1);
 231    ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, testResult, checkSz), 1);
 232
 233    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 234
 235    wolfSSL_EVP_PKEY_free(key);
 236
 237    return EXPECT_RESULT();
 238}
 239#endif
 240
 241int test_wolfSSL_EVP_MD_hmac_signing(void)
 242{
 243    EXPECT_DECLS;
 244#ifdef OPENSSL_EXTRA
 245    static const unsigned char testKey[] =
 246    {
 247        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 248        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 249        0x0b, 0x0b, 0x0b, 0x0b
 250    };
 251    static const char testData[] = "Hi There";
 252#ifdef WOLFSSL_SHA224
 253    static const unsigned char testResultSha224[] =
 254    {
 255        0x89, 0x6f, 0xb1, 0x12, 0x8a, 0xbb, 0xdf, 0x19,
 256        0x68, 0x32, 0x10, 0x7c, 0xd4, 0x9d, 0xf3, 0x3f,
 257        0x47, 0xb4, 0xb1, 0x16, 0x99, 0x12, 0xba, 0x4f,
 258        0x53, 0x68, 0x4b, 0x22
 259    };
 260#endif
 261#ifndef NO_SHA256
 262    static const unsigned char testResultSha256[] =
 263    {
 264        0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
 265        0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
 266        0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
 267        0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7
 268    };
 269#endif
 270#ifdef WOLFSSL_SHA384
 271    static const unsigned char testResultSha384[] =
 272    {
 273        0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62,
 274        0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
 275        0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6,
 276        0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
 277        0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f,
 278        0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6
 279    };
 280#endif
 281#ifdef WOLFSSL_SHA512
 282    static const unsigned char testResultSha512[] =
 283    {
 284        0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
 285        0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
 286        0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
 287        0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde,
 288        0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02,
 289        0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4,
 290        0xbe, 0x9d, 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70,
 291        0x2e, 0x69, 0x6c, 0x20, 0x3a, 0x12, 0x68, 0x54
 292    };
 293#endif
 294#ifdef WOLFSSL_SHA3
 295    #ifndef WOLFSSL_NOSHA3_224
 296    static const unsigned char testResultSha3_224[] =
 297    {
 298        0x3b, 0x16, 0x54, 0x6b, 0xbc, 0x7b, 0xe2, 0x70,
 299        0x6a, 0x03, 0x1d, 0xca, 0xfd, 0x56, 0x37, 0x3d,
 300        0x98, 0x84, 0x36, 0x76, 0x41, 0xd8, 0xc5, 0x9a,
 301        0xf3, 0xc8, 0x60, 0xf7
 302    };
 303    #endif
 304    #ifndef WOLFSSL_NOSHA3_256
 305    static const unsigned char testResultSha3_256[] =
 306    {
 307        0xba, 0x85, 0x19, 0x23, 0x10, 0xdf, 0xfa, 0x96,
 308        0xe2, 0xa3, 0xa4, 0x0e, 0x69, 0x77, 0x43, 0x51,
 309        0x14, 0x0b, 0xb7, 0x18, 0x5e, 0x12, 0x02, 0xcd,
 310        0xcc, 0x91, 0x75, 0x89, 0xf9, 0x5e, 0x16, 0xbb
 311    };
 312    #endif
 313    #ifndef WOLFSSL_NOSHA3_384
 314    static const unsigned char testResultSha3_384[] =
 315    {
 316        0x68, 0xd2, 0xdc, 0xf7, 0xfd, 0x4d, 0xdd, 0x0a,
 317        0x22, 0x40, 0xc8, 0xa4, 0x37, 0x30, 0x5f, 0x61,
 318        0xfb, 0x73, 0x34, 0xcf, 0xb5, 0xd0, 0x22, 0x6e,
 319        0x1b, 0xc2, 0x7d, 0xc1, 0x0a, 0x2e, 0x72, 0x3a,
 320        0x20, 0xd3, 0x70, 0xb4, 0x77, 0x43, 0x13, 0x0e,
 321        0x26, 0xac, 0x7e, 0x3d, 0x53, 0x28, 0x86, 0xbd
 322    };
 323    #endif
 324    #ifndef WOLFSSL_NOSHA3_512
 325    static const unsigned char testResultSha3_512[] =
 326    {
 327        0xeb, 0x3f, 0xbd, 0x4b, 0x2e, 0xaa, 0xb8, 0xf5,
 328        0xc5, 0x04, 0xbd, 0x3a, 0x41, 0x46, 0x5a, 0xac,
 329        0xec, 0x15, 0x77, 0x0a, 0x7c, 0xab, 0xac, 0x53,
 330        0x1e, 0x48, 0x2f, 0x86, 0x0b, 0x5e, 0xc7, 0xba,
 331        0x47, 0xcc, 0xb2, 0xc6, 0xf2, 0xaf, 0xce, 0x8f,
 332        0x88, 0xd2, 0x2b, 0x6d, 0xc6, 0x13, 0x80, 0xf2,
 333        0x3a, 0x66, 0x8f, 0xd3, 0x88, 0x8b, 0xb8, 0x05,
 334        0x37, 0xc0, 0xa0, 0xb8, 0x64, 0x07, 0x68, 0x9e
 335    };
 336    #endif
 337#endif
 338
 339#ifndef NO_SHA256
 340    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha256(), testKey,
 341        sizeof(testKey), testData, XSTRLEN(testData), testResultSha256,
 342        sizeof(testResultSha256)), TEST_SUCCESS);
 343#endif
 344#ifdef WOLFSSL_SHA224
 345    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha224(), testKey,
 346        sizeof(testKey), testData, XSTRLEN(testData), testResultSha224,
 347        sizeof(testResultSha224)), TEST_SUCCESS);
 348#endif
 349#ifdef WOLFSSL_SHA384
 350    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha384(), testKey,
 351        sizeof(testKey), testData, XSTRLEN(testData), testResultSha384,
 352        sizeof(testResultSha384)), TEST_SUCCESS);
 353#endif
 354#ifdef WOLFSSL_SHA512
 355    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha512(), testKey,
 356        sizeof(testKey), testData, XSTRLEN(testData), testResultSha512,
 357        sizeof(testResultSha512)), TEST_SUCCESS);
 358#endif
 359#ifdef WOLFSSL_SHA3
 360    #ifndef WOLFSSL_NOSHA3_224
 361    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha3_224(), testKey,
 362        sizeof(testKey), testData, XSTRLEN(testData), testResultSha3_224,
 363        sizeof(testResultSha3_224)), TEST_SUCCESS);
 364    #endif
 365    #ifndef WOLFSSL_NOSHA3_256
 366    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha3_256(), testKey,
 367        sizeof(testKey), testData, XSTRLEN(testData), testResultSha3_256,
 368        sizeof(testResultSha3_256)), TEST_SUCCESS);
 369    #endif
 370    #ifndef WOLFSSL_NOSHA3_384
 371    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha3_384(), testKey,
 372        sizeof(testKey), testData, XSTRLEN(testData), testResultSha3_384,
 373        sizeof(testResultSha3_384)), TEST_SUCCESS);
 374    #endif
 375    #ifndef WOLFSSL_NOSHA3_512
 376    ExpectIntEQ(test_hmac_signing(wolfSSL_EVP_sha3_512(), testKey,
 377        sizeof(testKey), testData, XSTRLEN(testData), testResultSha3_512,
 378        sizeof(testResultSha3_512)), TEST_SUCCESS);
 379    #endif
 380#endif
 381#endif /* OPENSSL_EXTRA */
 382    return EXPECT_RESULT();
 383}
 384
 385/* Verify that EVP_DigestVerifyFinal rejects zero-length HMAC tags. */
 386int test_wolfSSL_EVP_DigestVerify_HMAC_zero_len_forgery(void)
 387{
 388    EXPECT_DECLS;
 389#if defined(OPENSSL_EXTRA) && !defined(NO_HMAC) && !defined(NO_SHA256)
 390    static const unsigned char key[] = {
 391        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 392        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 393        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 394        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b
 395    };
 396    static const char message[] = "wolfSSL DigestVerifyFinal forgery probe";
 397    static const unsigned char zeros[WC_MAX_DIGEST_SIZE] = { 0 };
 398
 399    WOLFSSL_EVP_PKEY*  pkey = NULL;
 400    WOLFSSL_EVP_MD_CTX mdCtx;
 401    unsigned char      tag[WC_MAX_DIGEST_SIZE];
 402    size_t             tagLen = sizeof(tag);
 403
 404    wolfSSL_EVP_MD_CTX_init(&mdCtx);
 405
 406    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL,
 407                                                      key, (int)sizeof(key)));
 408
 409    /* Compute the genuine HMAC-SHA256 tag for the message. */
 410    ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
 411                                           NULL, pkey), 1);
 412    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, message,
 413                                             (unsigned int)XSTRLEN(message)),
 414                1);
 415    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, tag, &tagLen), 1);
 416    ExpectIntEQ((int)tagLen, WC_SHA256_DIGEST_SIZE);
 417    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 418
 419    /* Full-length genuine tag verifies. */
 420    wolfSSL_EVP_MD_CTX_init(&mdCtx);
 421    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
 422                                             NULL, pkey), 1);
 423    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, message,
 424                                               (unsigned int)XSTRLEN(message)),
 425                1);
 426    ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, tag, tagLen), 1);
 427    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 428
 429    /* Wrong full-length tag is rejected. */
 430    wolfSSL_EVP_MD_CTX_init(&mdCtx);
 431    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
 432                                             NULL, pkey), 1);
 433    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, message,
 434                                               (unsigned int)XSTRLEN(message)),
 435                1);
 436    ExpectIntNE(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, zeros,
 437                                              WC_SHA256_DIGEST_SIZE), 1);
 438    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 439
 440    /* Zero-length tag must be rejected. */
 441    wolfSSL_EVP_MD_CTX_init(&mdCtx);
 442    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
 443                                             NULL, pkey), 1);
 444    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, message,
 445                                               (unsigned int)XSTRLEN(message)),
 446                1);
 447    ExpectIntNE(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, zeros, 0), 1);
 448    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
 449
 450    wolfSSL_EVP_PKEY_free(pkey);
 451#endif
 452    return EXPECT_RESULT();
 453}
 454
 455int test_wolfSSL_EVP_PKEY_new_mac_key(void)
 456{
 457    EXPECT_DECLS;
 458#ifdef OPENSSL_EXTRA
 459    static const unsigned char pw[] = "password";
 460    static const int pwSz = sizeof(pw) - 1;
 461    size_t checkPwSz = 0;
 462    const unsigned char* checkPw = NULL;
 463    WOLFSSL_EVP_PKEY* key = NULL;
 464
 465    ExpectNull(key = wolfSSL_EVP_PKEY_new_mac_key(0, NULL, pw, pwSz));
 466    ExpectNull(key = wolfSSL_EVP_PKEY_new_mac_key(0, NULL, NULL, pwSz));
 467
 468    ExpectNotNull(key = wolfSSL_EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, pw,
 469        pwSz));
 470    if (key != NULL) {
 471        ExpectIntEQ(key->type, EVP_PKEY_HMAC);
 472        ExpectIntEQ(key->save_type, EVP_PKEY_HMAC);
 473        ExpectIntEQ(key->pkey_sz, pwSz);
 474        ExpectIntEQ(XMEMCMP(key->pkey.ptr, pw, pwSz), 0);
 475    }
 476    ExpectNotNull(checkPw = wolfSSL_EVP_PKEY_get0_hmac(key, &checkPwSz));
 477    ExpectIntEQ((int)checkPwSz, pwSz);
 478    ExpectIntEQ(XMEMCMP(checkPw, pw, pwSz), 0);
 479    wolfSSL_EVP_PKEY_free(key);
 480    key = NULL;
 481
 482    ExpectNotNull(key = wolfSSL_EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, pw,
 483        0));
 484    ExpectIntEQ(key->pkey_sz, 0);
 485    if (EXPECT_SUCCESS()) {
 486        /* Allocation for key->pkey.ptr may fail - OK key len is 0 */
 487        checkPw = wolfSSL_EVP_PKEY_get0_hmac(key, &checkPwSz);
 488    }
 489    ExpectTrue((checkPwSz == 0) || (checkPw != NULL));
 490    ExpectIntEQ((int)checkPwSz, 0);
 491    wolfSSL_EVP_PKEY_free(key);
 492    key = NULL;
 493
 494    ExpectNotNull(key = wolfSSL_EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, NULL,
 495        0));
 496    ExpectIntEQ(key->pkey_sz, 0);
 497    if (EXPECT_SUCCESS()) {
 498        /* Allocation for key->pkey.ptr may fail - OK key len is 0 */
 499        checkPw = wolfSSL_EVP_PKEY_get0_hmac(key, &checkPwSz);
 500    }
 501    ExpectTrue((checkPwSz == 0) || (checkPw != NULL));
 502    ExpectIntEQ((int)checkPwSz, 0);
 503    wolfSSL_EVP_PKEY_free(key);
 504    key = NULL;
 505#endif /* OPENSSL_EXTRA */
 506    return EXPECT_RESULT();
 507}
 508
 509int test_wolfSSL_EVP_PKEY_hkdf(void)
 510{
 511    EXPECT_DECLS;
 512#if defined(OPENSSL_EXTRA) && defined(HAVE_HKDF)
 513    EVP_PKEY_CTX* ctx = NULL;
 514    byte salt[]  = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 515                    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
 516    byte key[]   = {0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 517                    0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F};
 518    byte info[]  = {0X01, 0x02, 0x03, 0x04, 0x05};
 519    byte info2[] = {0X06, 0x07, 0x08, 0x09, 0x0A};
 520    byte outKey[34];
 521    size_t outKeySz = sizeof(outKey);
 522    /* These expected outputs were gathered by running the same test below using
 523     * OpenSSL. */
 524    const byte extractAndExpand[] = {
 525        0x8B, 0xEB, 0x90, 0xA9, 0x04, 0xFF, 0x05, 0x10, 0xE4, 0xB5, 0xB1, 0x10,
 526        0x31, 0x34, 0xFF, 0x07, 0x5B, 0xE3, 0xC6, 0x93, 0xD4, 0xF8, 0xC7, 0xEE,
 527        0x96, 0xDA, 0x78, 0x7A, 0xE2, 0x9A, 0x2D, 0x05, 0x4B, 0xF6
 528    };
 529    const byte extractOnly[] = {
 530        0xE7, 0x6B, 0x9E, 0x0F, 0xE4, 0x02, 0x1D, 0x62, 0xEA, 0x97, 0x74, 0x5E,
 531        0xF4, 0x3C, 0x65, 0x4D, 0xC1, 0x46, 0x98, 0xAA, 0x79, 0x9A, 0xCB, 0x9C,
 532        0xCC, 0x3E, 0x7F, 0x2A, 0x2B, 0x41, 0xA1, 0x9E
 533    };
 534    const byte expandOnly[] = {
 535        0xFF, 0x29, 0x29, 0x56, 0x9E, 0xA7, 0x66, 0x02, 0xDB, 0x4F, 0xDB, 0x53,
 536        0x7D, 0x21, 0x67, 0x52, 0xC3, 0x0E, 0xF3, 0xFC, 0x71, 0xCE, 0x67, 0x2B,
 537        0xEA, 0x3B, 0xE9, 0xFC, 0xDD, 0xC8, 0xCC, 0xB7, 0x42, 0x74
 538    };
 539    const byte extractAndExpandAddInfo[] = {
 540        0x5A, 0x74, 0x79, 0x83, 0xA3, 0xA4, 0x2E, 0xB7, 0xD4, 0x08, 0xC2, 0x6A,
 541        0x2F, 0xA5, 0xE3, 0x4E, 0xF1, 0xF4, 0x87, 0x3E, 0xA6, 0xC7, 0x88, 0x45,
 542        0xD7, 0xE2, 0x15, 0xBC, 0xB8, 0x10, 0xEF, 0x6C, 0x4D, 0x7A
 543    };
 544
 545    ExpectNotNull((ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)));
 546    ExpectIntEQ(EVP_PKEY_derive_init(ctx), WOLFSSL_SUCCESS);
 547    /* NULL ctx. */
 548    ExpectIntEQ(EVP_PKEY_CTX_set_hkdf_md(NULL, EVP_sha256()),
 549        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 550    /* NULL md. */
 551    ExpectIntEQ(EVP_PKEY_CTX_set_hkdf_md(ctx, NULL),
 552        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 553    ExpectIntEQ(EVP_PKEY_CTX_set_hkdf_md(ctx, EVP_sha256()), WOLFSSL_SUCCESS);
 554    /* NULL ctx. */
 555    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_salt(NULL, salt, sizeof(salt)),
 556                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 557    /* NULL salt is ok. */
 558    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_salt(ctx, NULL, sizeof(salt)),
 559                WOLFSSL_SUCCESS);
 560    /* Salt length <= 0. */
 561    /* Length 0 salt is ok. */
 562    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_salt(ctx, salt, 0), WOLFSSL_SUCCESS);
 563    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_salt(ctx, salt, -1),
 564                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 565    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_salt(ctx, salt, sizeof(salt)),
 566                WOLFSSL_SUCCESS);
 567    /* NULL ctx. */
 568    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_key(NULL, key, sizeof(key)),
 569                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 570    /* NULL key. */
 571    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_key(ctx, NULL, sizeof(key)),
 572                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 573    /* Key length <= 0 */
 574    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_key(ctx, key, 0),
 575                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 576    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_key(ctx, key, -1),
 577                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 578    ExpectIntEQ(EVP_PKEY_CTX_set1_hkdf_key(ctx, key, sizeof(key)),
 579                WOLFSSL_SUCCESS);
 580    /* NULL ctx. */
 581    ExpectIntEQ(EVP_PKEY_CTX_add1_hkdf_info(NULL, info, sizeof(info)),
 582                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 583    /* NULL info is ok. */
 584    ExpectIntEQ(EVP_PKEY_CTX_add1_hkdf_info(ctx, NULL, sizeof(info)),
 585                WOLFSSL_SUCCESS);
 586    /* Info length <= 0 */
 587    /* Length 0 info is ok. */
 588    ExpectIntEQ(EVP_PKEY_CTX_add1_hkdf_info(ctx, info, 0), WOLFSSL_SUCCESS);
 589    ExpectIntEQ(EVP_PKEY_CTX_add1_hkdf_info(ctx, info, -1),
 590                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 591    ExpectIntEQ(EVP_PKEY_CTX_add1_hkdf_info(ctx, info, sizeof(info)),
 592                WOLFSSL_SUCCESS);
 593    /* NULL ctx. */
 594    ExpectIntEQ(EVP_PKEY_CTX_hkdf_mode(NULL, EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY),
 595                WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 596    /* Extract and expand (default). */
 597    ExpectIntEQ(EVP_PKEY_derive(ctx, outKey, &outKeySz), WOLFSSL_SUCCESS);
 598    ExpectIntEQ(outKeySz, sizeof(extractAndExpand));
 599    ExpectIntEQ(XMEMCMP(outKey, extractAndExpand, outKeySz), 0);
 600    /* Extract only. */
 601    ExpectIntEQ(EVP_PKEY_CTX_hkdf_mode(ctx, EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY),
 602                WOLFSSL_SUCCESS);
 603    ExpectIntEQ(EVP_PKEY_derive(ctx, outKey, &outKeySz), WOLFSSL_SUCCESS);
 604    ExpectIntEQ(outKeySz, sizeof(extractOnly));
 605    ExpectIntEQ(XMEMCMP(outKey, extractOnly, outKeySz), 0);
 606    outKeySz = sizeof(outKey);
 607    /* Expand only. */
 608    ExpectIntEQ(EVP_PKEY_CTX_hkdf_mode(ctx, EVP_PKEY_HKDEF_MODE_EXPAND_ONLY),
 609                WOLFSSL_SUCCESS);
 610    ExpectIntEQ(EVP_PKEY_derive(ctx, outKey, &outKeySz), WOLFSSL_SUCCESS);
 611    ExpectIntEQ(outKeySz, sizeof(expandOnly));
 612    ExpectIntEQ(XMEMCMP(outKey, expandOnly, outKeySz), 0);
 613    outKeySz = sizeof(outKey);
 614    /* Extract and expand with appended additional info. */
 615    ExpectIntEQ(EVP_PKEY_CTX_add1_hkdf_info(ctx, info2, sizeof(info2)),
 616                WOLFSSL_SUCCESS);
 617    ExpectIntEQ(EVP_PKEY_CTX_hkdf_mode(ctx,
 618                EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND), WOLFSSL_SUCCESS);
 619    ExpectIntEQ(EVP_PKEY_derive(ctx, outKey, &outKeySz), WOLFSSL_SUCCESS);
 620    ExpectIntEQ(outKeySz, sizeof(extractAndExpandAddInfo));
 621    ExpectIntEQ(XMEMCMP(outKey, extractAndExpandAddInfo, outKeySz), 0);
 622
 623    EVP_PKEY_CTX_free(ctx);
 624#endif /* OPENSSL_EXTRA && HAVE_HKDF */
 625    return EXPECT_RESULT();
 626}
 627
 628
 629int test_wolfSSL_EVP_PBE_scrypt(void)
 630{
 631    EXPECT_DECLS;
 632#if defined(OPENSSL_EXTRA) && defined(HAVE_SCRYPT) && defined(HAVE_PBKDF2) && \
 633    (!defined(HAVE_FIPS_VERSION) || (HAVE_FIPS_VERSION < 5))
 634#if !defined(NO_PWDBASED) &&  !defined(NO_SHA256)
 635    int ret;
 636
 637    const char  pwd[]    = {'p','a','s','s','w','o','r','d'};
 638    int         pwdlen   = sizeof(pwd);
 639    const byte  salt[]   = {'N','a','C','l'};
 640    int         saltlen  = sizeof(salt);
 641    byte        key[80];
 642    word64      numOvr32 = (word64)INT32_MAX + 1;
 643
 644    /* expected derived key for N:16, r:1, p:1 */
 645    const byte expectedKey[] = {
 646        0xAE, 0xC6, 0xB7, 0x48, 0x3E, 0xD2, 0x6E, 0x08, 0x80, 0x2B,
 647        0x41, 0xF4, 0x03, 0x20, 0x86, 0xA0, 0xE8, 0x86, 0xBE, 0x7A,
 648        0xC4, 0x8F, 0xCF, 0xD9, 0x2F, 0xF0, 0xCE, 0xF8, 0x10, 0x97,
 649        0x52, 0xF4, 0xAC, 0x74, 0xB0, 0x77, 0x26, 0x32, 0x56, 0xA6,
 650        0x5A, 0x99, 0x70, 0x1B, 0x7A, 0x30, 0x4D, 0x46, 0x61, 0x1C,
 651        0x8A, 0xA3, 0x91, 0xE7, 0x99, 0xCE, 0x10, 0xA2, 0x77, 0x53,
 652        0xE7, 0xE9, 0xC0, 0x9A};
 653
 654    /*                                               N  r  p  mx key keylen */
 655    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 0, 1, 1, 0, key, 64);
 656    ExpectIntEQ(ret, 0); /* N must be greater than 1 */
 657
 658    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 3, 1, 1, 0, key, 64);
 659    ExpectIntEQ(ret, 0); /* N must be power of 2 */
 660
 661    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, 0, 1, 0, key, 64);
 662    ExpectIntEQ(ret, 0); /* r must be greater than 0 */
 663
 664    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, 1, 0, 0, key, 64);
 665    ExpectIntEQ(ret, 0); /* p must be greater than 0 */
 666
 667    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, 1, 1, 0, key, 0);
 668    ExpectIntEQ(ret, 0); /* keylen must be greater than 0 */
 669
 670    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, 9, 1, 0, key, 64);
 671    ExpectIntEQ(ret, 0); /* r must be smaller than 9 */
 672
 673    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, 1, 1, 0, NULL, 64);
 674    ExpectIntEQ(ret, 1); /* should succeed if key is NULL  */
 675
 676    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, 1, 1, 0, key, 64);
 677    ExpectIntEQ(ret, 1); /* should succeed */
 678
 679    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, numOvr32, 1, 0,
 680                                                                    key, 64);
 681    ExpectIntEQ(ret, 0); /* should fail since r is greater than INT32_MAC */
 682
 683    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 2, 1, numOvr32, 0,
 684                                                                    key, 64);
 685    ExpectIntEQ(ret, 0); /* should fail since p is greater than INT32_MAC */
 686
 687    ret = EVP_PBE_scrypt(pwd, pwdlen, NULL, 0, 2, 1, 1, 0, key, 64);
 688    ExpectIntEQ(ret, 1); /* should succeed even if salt is NULL */
 689
 690    ret = EVP_PBE_scrypt(pwd, pwdlen, NULL, 4, 2, 1, 1, 0, key, 64);
 691    ExpectIntEQ(ret, 0); /* if salt is NULL, saltlen must be 0, otherwise fail*/
 692
 693    ret = EVP_PBE_scrypt(NULL, 0, salt, saltlen, 2, 1, 1, 0, key, 64);
 694    ExpectIntEQ(ret, 1); /* should succeed if pwd is NULL and pwdlen is 0*/
 695
 696    ret = EVP_PBE_scrypt(NULL, 4, salt, saltlen, 2, 1, 1, 0, key, 64);
 697    ExpectIntEQ(ret, 0); /* if pwd is NULL, pwdlen must be 0 */
 698
 699    ret = EVP_PBE_scrypt(NULL, 0, NULL, 0, 2, 1, 1, 0, key, 64);
 700    ExpectIntEQ(ret, 1); /* should succeed even both pwd and salt are NULL */
 701
 702    ret = EVP_PBE_scrypt(pwd, pwdlen, salt, saltlen, 16, 1, 1, 0, key, 64);
 703    ExpectIntEQ(ret, 1);
 704
 705    ret = XMEMCMP(expectedKey, key, sizeof(expectedKey));
 706    ExpectIntEQ(ret, 0); /* derived key must be the same as expected-key */
 707#endif /* !NO_PWDBASED && !NO_SHA256 */
 708#endif /* OPENSSL_EXTRA && HAVE_SCRYPT && HAVE_PBKDF2 */
 709    return EXPECT_RESULT();
 710}
 711
 712int test_EVP_PKEY_cmp(void)
 713{
 714    EXPECT_DECLS;
 715#if defined(OPENSSL_EXTRA)
 716    EVP_PKEY *a = NULL;
 717    EVP_PKEY *b = NULL;
 718    const unsigned char *in;
 719
 720#if !defined(NO_RSA) && defined(USE_CERT_BUFFERS_2048)
 721    in = client_key_der_2048;
 722    ExpectNotNull(a = wolfSSL_d2i_PrivateKey(EVP_PKEY_RSA, NULL,
 723        &in, (long)sizeof_client_key_der_2048));
 724    in = client_key_der_2048;
 725    ExpectNotNull(b = wolfSSL_d2i_PrivateKey(EVP_PKEY_RSA, NULL,
 726        &in, (long)sizeof_client_key_der_2048));
 727
 728    /* Test success case RSA */
 729#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
 730    ExpectIntEQ(EVP_PKEY_cmp(a, b), 1);
 731#else
 732    ExpectIntEQ(EVP_PKEY_cmp(a, b), 0);
 733#endif /* WOLFSSL_ERROR_CODE_OPENSSL */
 734
 735    EVP_PKEY_free(b);
 736    b = NULL;
 737    EVP_PKEY_free(a);
 738    a = NULL;
 739#endif
 740
 741#if defined(HAVE_ECC) && defined(USE_CERT_BUFFERS_256)
 742    in = ecc_clikey_der_256;
 743    ExpectNotNull(a = wolfSSL_d2i_PrivateKey(EVP_PKEY_EC, NULL,
 744        &in, (long)sizeof_ecc_clikey_der_256));
 745    in = ecc_clikey_der_256;
 746    ExpectNotNull(b = wolfSSL_d2i_PrivateKey(EVP_PKEY_EC, NULL,
 747        &in, (long)sizeof_ecc_clikey_der_256));
 748
 749    /* Test success case ECC */
 750#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
 751    ExpectIntEQ(EVP_PKEY_cmp(a, b), 1);
 752#else
 753    ExpectIntEQ(EVP_PKEY_cmp(a, b), 0);
 754#endif /* WOLFSSL_ERROR_CODE_OPENSSL */
 755
 756    EVP_PKEY_free(b);
 757    b = NULL;
 758    EVP_PKEY_free(a);
 759    a = NULL;
 760#endif
 761
 762    /* Test failure cases */
 763#if !defined(NO_RSA) && defined(USE_CERT_BUFFERS_2048) && \
 764     defined(HAVE_ECC) && defined(USE_CERT_BUFFERS_256)
 765
 766    in = client_key_der_2048;
 767    ExpectNotNull(a = wolfSSL_d2i_PrivateKey(EVP_PKEY_RSA, NULL,
 768        &in, (long)sizeof_client_key_der_2048));
 769    in = ecc_clikey_der_256;
 770    ExpectNotNull(b = wolfSSL_d2i_PrivateKey(EVP_PKEY_EC, NULL,
 771        &in, (long)sizeof_ecc_clikey_der_256));
 772
 773#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
 774    ExpectIntEQ(EVP_PKEY_cmp(a, b), -1);
 775#else
 776    ExpectIntNE(EVP_PKEY_cmp(a, b), 0);
 777#endif /* WOLFSSL_ERROR_CODE_OPENSSL */
 778    EVP_PKEY_free(b);
 779    b = NULL;
 780    EVP_PKEY_free(a);
 781    a = NULL;
 782#endif
 783
 784    /* invalid or empty failure cases */
 785    a = EVP_PKEY_new();
 786    b = EVP_PKEY_new();
 787#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
 788    ExpectIntEQ(EVP_PKEY_cmp(NULL, NULL), 0);
 789    ExpectIntEQ(EVP_PKEY_cmp(a, NULL), 0);
 790    ExpectIntEQ(EVP_PKEY_cmp(NULL, b), 0);
 791#ifdef NO_RSA
 792    /* Type check will fail since RSA is the default EVP key type */
 793    ExpectIntEQ(EVP_PKEY_cmp(a, b), -2);
 794#else
 795    ExpectIntEQ(EVP_PKEY_cmp(a, b), 0);
 796#endif
 797#else
 798    ExpectIntNE(EVP_PKEY_cmp(NULL, NULL), 0);
 799    ExpectIntNE(EVP_PKEY_cmp(a, NULL), 0);
 800    ExpectIntNE(EVP_PKEY_cmp(NULL, b), 0);
 801    ExpectIntNE(EVP_PKEY_cmp(a, b), 0);
 802#endif
 803    EVP_PKEY_free(b);
 804    EVP_PKEY_free(a);
 805
 806    (void)in;
 807#endif
 808    return EXPECT_RESULT();
 809}
 810
 811int test_wolfSSL_EVP_PKEY_set1_get1_DSA(void)
 812{
 813    EXPECT_DECLS;
 814#if defined(OPENSSL_ALL) && !defined (NO_DSA) && !defined(HAVE_SELFTEST) && \
 815    !defined(WC_FIPS_186_5_PLUS) && defined(WOLFSSL_KEY_GEN)
 816    DSA       *dsa  = NULL;
 817    DSA       *setDsa  = NULL;
 818    EVP_PKEY  *pkey = NULL;
 819    EVP_PKEY  *set1Pkey = NULL;
 820
 821    SHA_CTX sha;
 822    byte    signature[DSA_SIG_SIZE];
 823    byte    hash[WC_SHA_DIGEST_SIZE];
 824    word32  bytes;
 825    int     answer;
 826#ifdef USE_CERT_BUFFERS_1024
 827    const unsigned char* dsaKeyDer = dsa_key_der_1024;
 828    int dsaKeySz  = sizeof_dsa_key_der_1024;
 829    byte    tmp[ONEK_BUF];
 830
 831    XMEMSET(tmp, 0, sizeof(tmp));
 832    XMEMCPY(tmp, dsaKeyDer , dsaKeySz);
 833    bytes = dsaKeySz;
 834#elif defined(USE_CERT_BUFFERS_2048)
 835    const unsigned char* dsaKeyDer = dsa_key_der_2048;
 836    int dsaKeySz  = sizeof_dsa_key_der_2048;
 837    byte    tmp[TWOK_BUF];
 838
 839    XMEMSET(tmp, 0, sizeof(tmp));
 840    XMEMCPY(tmp, dsaKeyDer , dsaKeySz);
 841    bytes = (word32)dsaKeySz;
 842#else
 843    byte    tmp[TWOK_BUF];
 844    const unsigned char* dsaKeyDer = (const unsigned char*)tmp;
 845    int dsaKeySz;
 846    XFILE fp = XBADFILE;
 847
 848    XMEMSET(tmp, 0, sizeof(tmp));
 849    ExpectTrue((fp = XFOPEN("./certs/dsa2048.der", "rb")) != XBADFILE);
 850    ExpectIntGT(dsaKeySz = bytes = (word32) XFREAD(tmp, 1, sizeof(tmp), fp), 0);
 851    if (fp != XBADFILE)
 852        XFCLOSE(fp);
 853#endif /* END USE_CERT_BUFFERS_1024 */
 854
 855    /* Create hash to later Sign and Verify */
 856    ExpectIntEQ(SHA1_Init(&sha), WOLFSSL_SUCCESS);
 857    ExpectIntEQ(SHA1_Update(&sha, tmp, bytes), WOLFSSL_SUCCESS);
 858    ExpectIntEQ(SHA1_Final(hash,&sha), WOLFSSL_SUCCESS);
 859
 860    /* Initialize pkey with der format dsa key */
 861    ExpectNotNull(d2i_PrivateKey(EVP_PKEY_DSA, &pkey, &dsaKeyDer,
 862        (long)dsaKeySz));
 863
 864    /* Test wolfSSL_EVP_PKEY_get1_DSA */
 865    /* Should Fail: NULL argument */
 866    ExpectNull(dsa = EVP_PKEY_get0_DSA(NULL));
 867    ExpectNull(dsa = EVP_PKEY_get1_DSA(NULL));
 868    /* Should Pass: Initialized pkey argument */
 869    ExpectNotNull(dsa = EVP_PKEY_get0_DSA(pkey));
 870    ExpectNotNull(dsa = EVP_PKEY_get1_DSA(pkey));
 871
 872#ifdef USE_CERT_BUFFERS_1024
 873    ExpectIntEQ(DSA_bits(dsa), 1024);
 874#else
 875    ExpectIntEQ(DSA_bits(dsa), 2048);
 876#endif
 877
 878    /* Sign */
 879    ExpectIntEQ(wolfSSL_DSA_do_sign(hash, signature, dsa), WOLFSSL_SUCCESS);
 880    /* Verify. */
 881    ExpectIntEQ(wolfSSL_DSA_do_verify(hash, signature, dsa, &answer),
 882                WOLFSSL_SUCCESS);
 883
 884    /* Test wolfSSL_EVP_PKEY_set1_DSA */
 885    /* Should Fail: set1Pkey not initialized */
 886    ExpectIntNE(EVP_PKEY_set1_DSA(set1Pkey, dsa), WOLFSSL_SUCCESS);
 887
 888    /* Initialize set1Pkey */
 889    set1Pkey = EVP_PKEY_new();
 890
 891    /* Should Fail Verify: setDsa not initialized from set1Pkey */
 892    ExpectIntNE(wolfSSL_DSA_do_verify(hash,signature,setDsa,&answer),
 893                WOLFSSL_SUCCESS);
 894
 895    /* Should Pass: set dsa into set1Pkey */
 896    ExpectIntEQ(EVP_PKEY_set1_DSA(set1Pkey, dsa), WOLFSSL_SUCCESS);
 897
 898    DSA_free(dsa);
 899    DSA_free(setDsa);
 900    EVP_PKEY_free(pkey);
 901    EVP_PKEY_free(set1Pkey);
 902#endif /* OPENSSL_ALL && !NO_DSA && !HAVE_SELFTEST && !WC_FIPS_186_5_PLUS */
 903       /* && WOLFSSL_KEY_GEN */
 904    return EXPECT_RESULT();
 905} /* END test_EVP_PKEY_set1_get1_DSA */
 906
 907int test_wolfSSL_EVP_PKEY_set1_get1_EC_KEY(void)
 908{
 909    EXPECT_DECLS;
 910#if defined(HAVE_ECC) && defined(OPENSSL_ALL)
 911    WOLFSSL_EC_KEY* ecKey  = NULL;
 912    WOLFSSL_EC_KEY* ecGet1  = NULL;
 913    EVP_PKEY* pkey = NULL;
 914
 915    ExpectNotNull(ecKey = wolfSSL_EC_KEY_new());
 916    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
 917
 918    /* Test wolfSSL_EVP_PKEY_set1_EC_KEY */
 919    ExpectIntEQ(wolfSSL_EVP_PKEY_set1_EC_KEY(NULL, ecKey),
 920        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 921    ExpectIntEQ(wolfSSL_EVP_PKEY_set1_EC_KEY(pkey, NULL),
 922        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 923    /* Should fail since ecKey is empty */
 924    ExpectIntEQ(wolfSSL_EVP_PKEY_set1_EC_KEY(pkey, ecKey),
 925        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
 926    ExpectIntEQ(wolfSSL_EC_KEY_generate_key(ecKey), 1);
 927    ExpectIntEQ(wolfSSL_EVP_PKEY_set1_EC_KEY(pkey, ecKey), WOLFSSL_SUCCESS);
 928
 929    /* Test wolfSSL_EVP_PKEY_get1_EC_KEY */
 930    ExpectNull(wolfSSL_EVP_PKEY_get1_EC_KEY(NULL));
 931    ExpectNotNull(ecGet1 = wolfSSL_EVP_PKEY_get1_EC_KEY(pkey));
 932
 933    wolfSSL_EC_KEY_free(ecKey);
 934    wolfSSL_EC_KEY_free(ecGet1);
 935    EVP_PKEY_free(pkey);
 936#endif /* HAVE_ECC && OPENSSL_ALL */
 937    return EXPECT_RESULT();
 938} /* END test_EVP_PKEY_set1_get1_EC_KEY */
 939
 940int test_wolfSSL_EVP_PKEY_get0_EC_KEY(void)
 941{
 942    EXPECT_DECLS;
 943#if defined(HAVE_ECC) && defined(OPENSSL_ALL)
 944    WOLFSSL_EVP_PKEY* pkey = NULL;
 945
 946    ExpectNull(EVP_PKEY_get0_EC_KEY(NULL));
 947
 948    ExpectNotNull(pkey = EVP_PKEY_new());
 949    ExpectNull(EVP_PKEY_get0_EC_KEY(pkey));
 950    EVP_PKEY_free(pkey);
 951#endif
 952    return EXPECT_RESULT();
 953}
 954
 955int test_wolfSSL_EVP_PKEY_set1_get1_DH(void)
 956{
 957    EXPECT_DECLS;
 958#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
 959#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
 960#if !defined(NO_DH) && defined(WOLFSSL_DH_EXTRA) && !defined(NO_FILESYSTEM)
 961    DH       *dh    = NULL;
 962    DH       *setDh = NULL;
 963    EVP_PKEY *pkey  = NULL;
 964
 965    XFILE f = XBADFILE;
 966    unsigned char buf[4096];
 967    const unsigned char* pt = buf;
 968    const char* dh2048 = "./certs/dh2048.der";
 969    long len = 0;
 970    int code = -1;
 971
 972    XMEMSET(buf, 0, sizeof(buf));
 973
 974    ExpectTrue((f = XFOPEN(dh2048, "rb")) != XBADFILE);
 975    ExpectTrue((len = (long)XFREAD(buf, 1, sizeof(buf), f)) > 0);
 976    if (f != XBADFILE)
 977        XFCLOSE(f);
 978
 979    /* Load dh2048.der into DH with internal format */
 980    ExpectNotNull(setDh = wolfSSL_d2i_DHparams(NULL, &pt, len));
 981
 982    ExpectIntEQ(wolfSSL_DH_check(setDh, &code), WOLFSSL_SUCCESS);
 983    ExpectIntEQ(code, 0);
 984    code = -1;
 985
 986    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
 987
 988    /* Set DH into PKEY */
 989    ExpectIntEQ(wolfSSL_EVP_PKEY_set1_DH(pkey, setDh), WOLFSSL_SUCCESS);
 990
 991    /* Get DH from PKEY */
 992    ExpectNotNull(dh = wolfSSL_EVP_PKEY_get1_DH(pkey));
 993
 994    ExpectIntEQ(wolfSSL_DH_check(dh, &code), WOLFSSL_SUCCESS);
 995    ExpectIntEQ(code, 0);
 996
 997    EVP_PKEY_free(pkey);
 998    DH_free(setDh);
 999    setDh = NULL;
1000    DH_free(dh);
1001    dh = NULL;
1002#endif /* !NO_DH && WOLFSSL_DH_EXTRA && !NO_FILESYSTEM */
1003#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
1004#endif /* OPENSSL_ALL || WOLFSSL_QT || WOLFSSL_OPENSSH */
1005    return EXPECT_RESULT();
1006} /* END test_EVP_PKEY_set1_get1_DH */
1007
1008int test_wolfSSL_EVP_PKEY_assign(void)
1009{
1010    EXPECT_DECLS;
1011#if (!defined(NO_RSA) || !defined(NO_DSA) || defined(HAVE_ECC)) && \
1012    defined(OPENSSL_ALL)
1013    int type;
1014    WOLFSSL_EVP_PKEY* pkey = NULL;
1015#ifndef NO_RSA
1016    WOLFSSL_RSA* rsa = NULL;
1017#endif
1018#ifndef NO_DSA
1019    WOLFSSL_DSA* dsa = NULL;
1020#endif
1021#ifdef HAVE_ECC
1022    WOLFSSL_EC_KEY* ecKey = NULL;
1023#endif
1024
1025#ifndef NO_RSA
1026    type = EVP_PKEY_RSA;
1027    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1028    ExpectNotNull(rsa = wolfSSL_RSA_new());
1029    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(NULL, type, rsa),
1030        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1031    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, type, NULL),
1032        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1033    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, -1, rsa),
1034        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1035    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, type, rsa),  WOLFSSL_SUCCESS);
1036    if (EXPECT_FAIL()) {
1037        wolfSSL_RSA_free(rsa);
1038    }
1039    wolfSSL_EVP_PKEY_free(pkey);
1040    pkey = NULL;
1041#endif /* NO_RSA */
1042
1043#ifndef NO_DSA
1044    type = EVP_PKEY_DSA;
1045    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1046    ExpectNotNull(dsa = wolfSSL_DSA_new());
1047    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(NULL, type, dsa),
1048        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1049    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, type, NULL),
1050        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1051    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, -1, dsa),
1052        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1053    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, type, dsa),  WOLFSSL_SUCCESS);
1054    if (EXPECT_FAIL()) {
1055        wolfSSL_DSA_free(dsa);
1056    }
1057    wolfSSL_EVP_PKEY_free(pkey);
1058    pkey = NULL;
1059#endif /* NO_DSA */
1060
1061#ifdef HAVE_ECC
1062    type = EVP_PKEY_EC;
1063    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1064    ExpectNotNull(ecKey = wolfSSL_EC_KEY_new());
1065    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(NULL, type, ecKey),
1066        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1067    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, type, NULL),
1068        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1069    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, -1, ecKey),
1070        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1071    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, type, ecKey),
1072        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1073    ExpectIntEQ(wolfSSL_EC_KEY_generate_key(ecKey), 1);
1074    ExpectIntEQ(wolfSSL_EVP_PKEY_assign(pkey, type, ecKey), WOLFSSL_SUCCESS);
1075    if (EXPECT_FAIL()) {
1076        wolfSSL_EC_KEY_free(ecKey);
1077    }
1078    wolfSSL_EVP_PKEY_free(pkey);
1079    pkey = NULL;
1080#endif /* HAVE_ECC */
1081#endif /* (!NO_RSA || !NO_DSA || HAVE_ECC) && OPENSSL_ALL */
1082    return EXPECT_RESULT();
1083}
1084
1085int test_wolfSSL_EVP_PKEY_assign_DH(void)
1086{
1087    EXPECT_DECLS;
1088#if !defined(NO_DH) && defined(OPENSSL_ALL) && (!defined(HAVE_FIPS) || \
1089    (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION > 2)))
1090    XFILE                   f = XBADFILE;
1091    unsigned char           buf[4096];
1092    const unsigned char*    pt = buf;
1093    const char*             params1 = "./certs/dh2048.der";
1094    long                    len = 0;
1095    WOLFSSL_DH*             dh = NULL;
1096    WOLFSSL_EVP_PKEY*       pkey = NULL;
1097    XMEMSET(buf, 0, sizeof(buf));
1098
1099    /* Load DH parameters DER. */
1100    ExpectTrue((f = XFOPEN(params1, "rb")) != XBADFILE);
1101    ExpectTrue((len = (long)XFREAD(buf, 1, sizeof(buf), f)) > 0);
1102    if (f != XBADFILE)
1103        XFCLOSE(f);
1104
1105    ExpectNotNull(dh = wolfSSL_d2i_DHparams(NULL, &pt, len));
1106    ExpectIntEQ(DH_generate_key(dh), WOLFSSL_SUCCESS);
1107
1108    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1109
1110    /* Bad cases */
1111    ExpectIntEQ(wolfSSL_EVP_PKEY_assign_DH(NULL, dh),
1112        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1113    ExpectIntEQ(wolfSSL_EVP_PKEY_assign_DH(pkey, NULL),
1114        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1115    ExpectIntEQ(wolfSSL_EVP_PKEY_assign_DH(NULL, NULL),
1116        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1117
1118    /* Good case */
1119    ExpectIntEQ(wolfSSL_EVP_PKEY_assign_DH(pkey, dh), WOLFSSL_SUCCESS);
1120    if (EXPECT_FAIL()) {
1121        wolfSSL_DH_free(dh);
1122    }
1123
1124    EVP_PKEY_free(pkey);
1125#endif
1126    return EXPECT_RESULT();
1127}
1128
1129int test_EVP_PKEY_rsa(void)
1130{
1131    EXPECT_DECLS;
1132#if defined(OPENSSL_EXTRA) && !defined(NO_RSA)
1133    WOLFSSL_RSA* rsa = NULL;
1134    WOLFSSL_EVP_PKEY* pkey = NULL;
1135
1136    ExpectNotNull(rsa = wolfSSL_RSA_new());
1137    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1138    ExpectIntEQ(EVP_PKEY_assign_RSA(NULL, rsa),
1139        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1140    ExpectIntEQ(EVP_PKEY_assign_RSA(pkey, NULL),
1141        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1142    ExpectIntEQ(EVP_PKEY_assign_RSA(pkey, rsa), WOLFSSL_SUCCESS);
1143    if (EXPECT_FAIL()) {
1144        wolfSSL_RSA_free(rsa);
1145    }
1146    ExpectPtrEq(EVP_PKEY_get0_RSA(pkey), rsa);
1147    wolfSSL_EVP_PKEY_free(pkey);
1148#endif
1149    return EXPECT_RESULT();
1150}
1151
1152int test_EVP_PKEY_ec(void)
1153{
1154    EXPECT_DECLS;
1155#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC)
1156#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1157    WOLFSSL_EC_KEY* ecKey = NULL;
1158    WOLFSSL_EVP_PKEY* pkey = NULL;
1159
1160    ExpectNotNull(ecKey = wolfSSL_EC_KEY_new());
1161    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1162    ExpectIntEQ(EVP_PKEY_assign_EC_KEY(NULL, ecKey),
1163        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1164    ExpectIntEQ(EVP_PKEY_assign_EC_KEY(pkey, NULL),
1165        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1166    /* Should fail since ecKey is empty */
1167    ExpectIntEQ(EVP_PKEY_assign_EC_KEY(pkey, ecKey),
1168        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1169    ExpectIntEQ(wolfSSL_EC_KEY_generate_key(ecKey), 1);
1170    ExpectIntEQ(EVP_PKEY_assign_EC_KEY(pkey, ecKey), WOLFSSL_SUCCESS);
1171    if (EXPECT_FAIL()) {
1172        wolfSSL_EC_KEY_free(ecKey);
1173    }
1174    wolfSSL_EVP_PKEY_free(pkey);
1175#endif
1176#endif
1177    return EXPECT_RESULT();
1178}
1179
1180int test_wolfSSL_EVP_PKEY_missing_parameters(void)
1181{
1182    EXPECT_DECLS;
1183#if defined(OPENSSL_ALL) && !defined(NO_WOLFSSL_STUB)
1184    WOLFSSL_EVP_PKEY* pkey = NULL;
1185
1186    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1187
1188    ExpectIntEQ(wolfSSL_EVP_PKEY_missing_parameters(pkey), 0);
1189    ExpectIntEQ(wolfSSL_EVP_PKEY_missing_parameters(NULL), 0);
1190
1191    EVP_PKEY_free(pkey);
1192#endif
1193    return EXPECT_RESULT();
1194}
1195
1196int test_wolfSSL_EVP_PKEY_copy_parameters(void)
1197{
1198    EXPECT_DECLS;
1199#if defined(OPENSSL_EXTRA) && !defined(NO_DH) && defined(WOLFSSL_KEY_GEN) && \
1200    !defined(HAVE_SELFTEST) && defined(WOLFSSL_DH_EXTRA) && \
1201     (defined(OPENSSL_ALL) || defined(WOLFSSL_QT)) && !defined(NO_FILESYSTEM)
1202    WOLFSSL_EVP_PKEY* params = NULL;
1203    WOLFSSL_EVP_PKEY* copy = NULL;
1204    DH* dh = NULL;
1205    BIGNUM* p1;
1206    BIGNUM* g1;
1207    BIGNUM* q1;
1208    BIGNUM* p2;
1209    BIGNUM* g2;
1210    BIGNUM* q2;
1211
1212    /* create DH with DH_get_2048_256 params */
1213    ExpectNotNull(params = wolfSSL_EVP_PKEY_new());
1214    ExpectNotNull(dh = DH_get_2048_256());
1215    ExpectIntEQ(EVP_PKEY_set1_DH(params, dh), WOLFSSL_SUCCESS);
1216    DH_get0_pqg(dh, (const BIGNUM**)&p1,
1217                    (const BIGNUM**)&q1,
1218                    (const BIGNUM**)&g1);
1219    DH_free(dh);
1220    dh = NULL;
1221
1222    /* create DH with random generated DH params */
1223    ExpectNotNull(copy = wolfSSL_EVP_PKEY_new());
1224    ExpectNotNull(dh = DH_generate_parameters(2048, 2, NULL, NULL));
1225    ExpectIntEQ(EVP_PKEY_set1_DH(copy, dh), WOLFSSL_SUCCESS);
1226    DH_free(dh);
1227    dh = NULL;
1228
1229    ExpectIntEQ(EVP_PKEY_copy_parameters(copy, params), WOLFSSL_SUCCESS);
1230    ExpectNotNull(dh = EVP_PKEY_get1_DH(copy));
1231    ExpectNotNull(dh->p);
1232    ExpectNotNull(dh->g);
1233    ExpectNotNull(dh->q);
1234    DH_get0_pqg(dh, (const BIGNUM**)&p2,
1235                    (const BIGNUM**)&q2,
1236                    (const BIGNUM**)&g2);
1237
1238    ExpectIntEQ(BN_cmp(p1, p2), 0);
1239    ExpectIntEQ(BN_cmp(q1, q2), 0);
1240    ExpectIntEQ(BN_cmp(g1, g2), 0);
1241
1242    DH_free(dh);
1243    dh = NULL;
1244    EVP_PKEY_free(copy);
1245    EVP_PKEY_free(params);
1246#endif
1247    return EXPECT_RESULT();
1248}
1249
1250int test_wolfSSL_EVP_PKEY_paramgen(void)
1251{
1252    EXPECT_DECLS;
1253    /* ECC check taken from ecc.c. It is the condition that defines ECC256 */
1254#if defined(OPENSSL_ALL) && !defined(NO_ECC_SECP) && \
1255    ((!defined(NO_ECC256)  || defined(HAVE_ALL_CURVES)) && \
1256            ECC_MIN_KEY_SZ <= 256)
1257    EVP_PKEY_CTX* ctx = NULL;
1258    EVP_PKEY*     pkey = NULL;
1259
1260    /* Test error conditions. */
1261    ExpectIntEQ(EVP_PKEY_paramgen(NULL, &pkey),
1262        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1263    ExpectNotNull(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL));
1264    ExpectIntEQ(EVP_PKEY_paramgen(ctx, NULL), WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1265
1266#ifndef NO_RSA
1267    EVP_PKEY_CTX_free(ctx);
1268    /* Parameter generation for RSA not supported yet. */
1269    ExpectNotNull(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL));
1270    ExpectIntEQ(EVP_PKEY_paramgen(ctx, &pkey),
1271        WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1272#endif
1273
1274#ifdef HAVE_ECC
1275    EVP_PKEY_CTX_free(ctx);
1276    ExpectNotNull(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL));
1277    ExpectIntEQ(EVP_PKEY_paramgen_init(ctx), WOLFSSL_SUCCESS);
1278    ExpectIntEQ(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx,
1279        NID_X9_62_prime256v1), WOLFSSL_SUCCESS);
1280    ExpectIntEQ(EVP_PKEY_paramgen(ctx, &pkey), WOLFSSL_SUCCESS);
1281    ExpectIntEQ(EVP_PKEY_CTX_set_ec_param_enc(ctx, OPENSSL_EC_NAMED_CURVE),
1282        WOLFSSL_SUCCESS);
1283    ExpectIntEQ(EVP_PKEY_keygen_init(ctx), WOLFSSL_SUCCESS);
1284    ExpectIntEQ(EVP_PKEY_keygen(ctx, &pkey), WOLFSSL_SUCCESS);
1285#endif
1286
1287    EVP_PKEY_CTX_free(ctx);
1288    EVP_PKEY_free(pkey);
1289#endif
1290    return EXPECT_RESULT();
1291}
1292
1293int test_wolfSSL_EVP_PKEY_param_check(void)
1294{
1295    EXPECT_DECLS;
1296#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
1297#if !defined(NO_DH) && defined(WOLFSSL_DH_EXTRA) && !defined(NO_FILESYSTEM)
1298
1299    DH       *dh    = NULL;
1300    DH       *setDh = NULL;
1301    EVP_PKEY *pkey  = NULL;
1302    EVP_PKEY_CTX*   ctx = NULL;
1303
1304    FILE* f = NULL;
1305    unsigned char buf[512];
1306    const unsigned char* pt = buf;
1307    const char* dh2048 = "./certs/dh2048.der";
1308    long len = 0;
1309    int code = -1;
1310
1311    XMEMSET(buf, 0, sizeof(buf));
1312
1313    ExpectTrue((f = XFOPEN(dh2048, "rb")) != XBADFILE);
1314    ExpectTrue((len = (long)XFREAD(buf, 1, sizeof(buf), f)) > 0);
1315    if (f != XBADFILE)
1316        XFCLOSE(f);
1317
1318    /* Load dh2048.der into DH with internal format */
1319    ExpectNotNull(setDh = d2i_DHparams(NULL, &pt, len));
1320    ExpectIntEQ(DH_check(setDh, &code), WOLFSSL_SUCCESS);
1321    ExpectIntEQ(code, 0);
1322    code = -1;
1323
1324    pkey = wolfSSL_EVP_PKEY_new();
1325    /* Set DH into PKEY */
1326    ExpectIntEQ(EVP_PKEY_set1_DH(pkey, setDh), WOLFSSL_SUCCESS);
1327    /* create ctx from pkey */
1328    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
1329    ExpectIntEQ(EVP_PKEY_param_check(ctx), 1/* valid */);
1330
1331    /* TODO: more invalid cases */
1332    ExpectIntEQ(EVP_PKEY_param_check(NULL), 0);
1333
1334    EVP_PKEY_CTX_free(ctx);
1335    EVP_PKEY_free(pkey);
1336    DH_free(setDh);
1337    setDh = NULL;
1338    DH_free(dh);
1339    dh = NULL;
1340#endif
1341#endif
1342    return EXPECT_RESULT();
1343}
1344
1345int test_wolfSSL_EVP_PKEY_keygen_init(void)
1346{
1347    EXPECT_DECLS;
1348#ifdef OPENSSL_ALL
1349    WOLFSSL_EVP_PKEY*   pkey = NULL;
1350    EVP_PKEY_CTX        *ctx = NULL;
1351
1352    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1353    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
1354
1355    ExpectIntEQ(wolfSSL_EVP_PKEY_keygen_init(ctx), WOLFSSL_SUCCESS);
1356    ExpectIntEQ(wolfSSL_EVP_PKEY_keygen_init(NULL), WOLFSSL_SUCCESS);
1357
1358    EVP_PKEY_CTX_free(ctx);
1359    EVP_PKEY_free(pkey);
1360#endif
1361    return EXPECT_RESULT();
1362}
1363
1364int test_wolfSSL_EVP_PKEY_keygen(void)
1365{
1366    EXPECT_DECLS;
1367#ifdef OPENSSL_ALL
1368    WOLFSSL_EVP_PKEY* pkey = NULL;
1369    EVP_PKEY_CTX*     ctx = NULL;
1370#if !defined(NO_DH) && (!defined(HAVE_FIPS) || FIPS_VERSION_GT(2,0))
1371    WOLFSSL_EVP_PKEY* params = NULL;
1372    DH* dh = NULL;
1373    const BIGNUM* pubkey = NULL;
1374    const BIGNUM* privkey = NULL;
1375    ASN1_INTEGER* asn1int = NULL;
1376    unsigned int length = 0;
1377    byte* derBuffer = NULL;
1378#endif
1379
1380    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
1381    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
1382
1383    /* Bad cases */
1384    ExpectIntEQ(wolfSSL_EVP_PKEY_keygen(NULL, &pkey), 0);
1385    ExpectIntEQ(wolfSSL_EVP_PKEY_keygen(ctx, NULL), 0);
1386    ExpectIntEQ(wolfSSL_EVP_PKEY_keygen(NULL, NULL), 0);
1387
1388    /* Good case */
1389    ExpectIntEQ(wolfSSL_EVP_PKEY_keygen(ctx, &pkey), 0);
1390
1391    EVP_PKEY_CTX_free(ctx);
1392    ctx = NULL;
1393    EVP_PKEY_free(pkey);
1394    pkey = NULL;
1395
1396#if !defined(NO_DH) && (!defined(HAVE_FIPS) || FIPS_VERSION_GT(2,0))
1397    /* Test DH keygen */
1398    {
1399        ExpectNotNull(params = wolfSSL_EVP_PKEY_new());
1400        ExpectNotNull(dh = DH_get_2048_256());
1401        ExpectIntEQ(EVP_PKEY_set1_DH(params, dh), WOLFSSL_SUCCESS);
1402        ExpectNotNull(ctx = EVP_PKEY_CTX_new(params, NULL));
1403        ExpectIntEQ(EVP_PKEY_keygen_init(ctx), WOLFSSL_SUCCESS);
1404        ExpectIntEQ(EVP_PKEY_keygen(ctx, &pkey), WOLFSSL_SUCCESS);
1405
1406        DH_free(dh);
1407        dh = NULL;
1408        EVP_PKEY_CTX_free(ctx);
1409        EVP_PKEY_free(params);
1410
1411        /* try exporting generated key to DER, to verify */
1412        ExpectNotNull(dh = EVP_PKEY_get1_DH(pkey));
1413        DH_get0_key(dh, &pubkey, &privkey);
1414        ExpectNotNull(pubkey);
1415        ExpectNotNull(privkey);
1416        ExpectNotNull(asn1int = BN_to_ASN1_INTEGER(pubkey, NULL));
1417        ExpectIntGT((length = i2d_ASN1_INTEGER(asn1int, &derBuffer)), 0);
1418
1419        ASN1_INTEGER_free(asn1int);
1420        DH_free(dh);
1421        dh = NULL;
1422        XFREE(derBuffer, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1423
1424        EVP_PKEY_free(pkey);
1425    }
1426#endif
1427#endif
1428    return EXPECT_RESULT();
1429}
1430
1431int test_wolfSSL_EVP_SignInit_ex(void)
1432{
1433    EXPECT_DECLS;
1434#ifdef OPENSSL_ALL
1435    WOLFSSL_EVP_MD_CTX mdCtx;
1436    WOLFSSL_ENGINE*    e = 0;
1437    const EVP_MD*      md = EVP_sha256();
1438
1439    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1440    ExpectIntEQ(wolfSSL_EVP_SignInit_ex(&mdCtx, md, e), WOLFSSL_SUCCESS);
1441
1442    ExpectIntEQ(wolfSSL_EVP_MD_CTX_cleanup(&mdCtx), 1);
1443#endif
1444    return EXPECT_RESULT();
1445}
1446
1447#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
1448    !defined(HAVE_SELFTEST)
1449#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1450    #ifndef TEST_WOLFSSL_EVP_PKEY_SIGN_VERIFY
1451        #define TEST_WOLFSSL_EVP_PKEY_SIGN_VERIFY
1452    #endif
1453#endif
1454#endif
1455#if defined(OPENSSL_EXTRA)
1456#if !defined (NO_DSA) && !defined(HAVE_SELFTEST) && defined(WOLFSSL_KEY_GEN)
1457    #ifndef TEST_WOLFSSL_EVP_PKEY_SIGN_VERIFY
1458        #define TEST_WOLFSSL_EVP_PKEY_SIGN_VERIFY
1459    #endif
1460#endif
1461#endif
1462#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC)
1463#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1464    #ifndef TEST_WOLFSSL_EVP_PKEY_SIGN_VERIFY
1465        #define TEST_WOLFSSL_EVP_PKEY_SIGN_VERIFY
1466    #endif
1467#endif
1468#endif
1469
1470#ifdef TEST_WOLFSSL_EVP_PKEY_SIGN_VERIFY
1471static int test_wolfSSL_EVP_PKEY_sign_verify(int keyType)
1472{
1473    EXPECT_DECLS;
1474#if defined(OPENSSL_EXTRA)
1475#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
1476    !defined(HAVE_SELFTEST)
1477#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1478    WOLFSSL_RSA* rsa = NULL;
1479#endif
1480#endif
1481#if !defined (NO_DSA) && !defined(HAVE_SELFTEST) && defined(WOLFSSL_KEY_GEN)
1482    WOLFSSL_DSA* dsa = NULL;
1483#endif /* !NO_DSA && !HAVE_SELFTEST && WOLFSSL_KEY_GEN */
1484#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC)
1485#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1486    WOLFSSL_EC_KEY* ecKey = NULL;
1487#endif
1488#endif
1489    WOLFSSL_EVP_PKEY* pkey = NULL;
1490    WOLFSSL_EVP_PKEY_CTX* ctx = NULL;
1491    WOLFSSL_EVP_PKEY_CTX* ctx_verify = NULL;
1492    const char* in = "What is easy to do is easy not to do.";
1493    size_t inlen = XSTRLEN(in);
1494    byte hash[SHA256_DIGEST_LENGTH] = {0};
1495    byte zero[SHA256_DIGEST_LENGTH] = {0};
1496    SHA256_CTX c;
1497    byte*  sig = NULL;
1498    byte*  sigVerify = NULL;
1499    size_t siglen;
1500    size_t siglenOnlyLen;
1501    size_t keySz = 2048/8;  /* Bytes */
1502
1503    ExpectNotNull(sig =
1504        (byte*)XMALLOC(keySz, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER));
1505    ExpectNotNull(sigVerify =
1506        (byte*)XMALLOC(keySz, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER));
1507
1508    siglen = keySz;
1509    ExpectNotNull(XMEMSET(sig, 0, keySz));
1510    ExpectNotNull(XMEMSET(sigVerify, 0, keySz));
1511
1512    /* Generate hash */
1513    SHA256_Init(&c);
1514    SHA256_Update(&c, in, inlen);
1515    SHA256_Final(hash, &c);
1516#ifdef WOLFSSL_SMALL_STACK_CACHE
1517    /* workaround for small stack cache case */
1518    wc_Sha256Free((wc_Sha256*)&c);
1519#endif
1520
1521    /* Generate key */
1522    ExpectNotNull(pkey = EVP_PKEY_new());
1523    switch (keyType) {
1524        case EVP_PKEY_RSA:
1525#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
1526    !defined(HAVE_SELFTEST)
1527#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1528        {
1529            ExpectNotNull(rsa = RSA_generate_key(2048, 3, NULL, NULL));
1530            ExpectIntEQ(EVP_PKEY_assign_RSA(pkey, rsa), WOLFSSL_SUCCESS);
1531        }
1532#endif
1533#endif
1534            break;
1535        case EVP_PKEY_DSA:
1536#if !defined (NO_DSA) && !defined(HAVE_SELFTEST) && defined(WOLFSSL_KEY_GEN)
1537            ExpectNotNull(dsa = DSA_new());
1538            ExpectIntEQ(DSA_generate_parameters_ex(dsa, 2048,
1539                NULL, 0, NULL, NULL, NULL), 1);
1540            ExpectIntEQ(DSA_generate_key(dsa), 1);
1541            ExpectIntEQ(EVP_PKEY_set1_DSA(pkey, dsa), WOLFSSL_SUCCESS);
1542#endif /* !NO_DSA && !HAVE_SELFTEST && WOLFSSL_KEY_GEN */
1543            break;
1544        case EVP_PKEY_EC:
1545#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC)
1546#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1547        {
1548            ExpectNotNull(ecKey = EC_KEY_new());
1549            ExpectIntEQ(EC_KEY_generate_key(ecKey), 1);
1550            ExpectIntEQ(
1551                EVP_PKEY_assign_EC_KEY(pkey, ecKey), WOLFSSL_SUCCESS);
1552            if (EXPECT_FAIL()) {
1553                EC_KEY_free(ecKey);
1554            }
1555        }
1556#endif
1557#endif
1558            break;
1559    }
1560    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
1561    ExpectIntEQ(EVP_PKEY_sign_init(ctx), WOLFSSL_SUCCESS);
1562#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
1563    !defined(HAVE_SELFTEST)
1564#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1565    if (keyType == EVP_PKEY_RSA)
1566        ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING),
1567                    WOLFSSL_SUCCESS);
1568#endif
1569#endif
1570
1571    /* Check returning only length */
1572    ExpectIntEQ(EVP_PKEY_sign(ctx, NULL, &siglenOnlyLen, hash,
1573        SHA256_DIGEST_LENGTH), WOLFSSL_SUCCESS);
1574    ExpectIntGT(siglenOnlyLen, 0);
1575    /* Sign data */
1576    ExpectIntEQ(EVP_PKEY_sign(ctx, sig, &siglen, hash,
1577        SHA256_DIGEST_LENGTH), WOLFSSL_SUCCESS);
1578    ExpectIntGE(siglenOnlyLen, siglen);
1579
1580    /* Verify signature */
1581    ExpectNotNull(ctx_verify = EVP_PKEY_CTX_new(pkey, NULL));
1582    ExpectIntEQ(EVP_PKEY_verify_init(ctx_verify), WOLFSSL_SUCCESS);
1583#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
1584    !defined(HAVE_SELFTEST)
1585#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1586    if (keyType == EVP_PKEY_RSA)
1587        ExpectIntEQ(
1588            EVP_PKEY_CTX_set_rsa_padding(ctx_verify, RSA_PKCS1_PADDING),
1589            WOLFSSL_SUCCESS);
1590#endif
1591#endif
1592    ExpectIntEQ(EVP_PKEY_verify(
1593        ctx_verify, sig, siglen, hash, SHA256_DIGEST_LENGTH),
1594        WOLFSSL_SUCCESS);
1595
1596    if (keyType == EVP_PKEY_EC) {
1597#ifdef WC_TEST_NO_ECC_SIGN_VERIFY_ZERO_DIGEST
1598        /* wolfSSL differs from OpenSSL in that it treats a hash of all 0's as a
1599         * fatal error and does not attempt to verify */
1600        ExpectIntEQ(EVP_PKEY_verify(
1601            ctx_verify, sig, siglen, zero, SHA256_DIGEST_LENGTH),
1602            WC_NO_ERR_TRACE(WOLFSSL_FATAL_ERROR));
1603#else
1604        ExpectIntEQ(EVP_PKEY_verify(
1605            ctx_verify, sig, siglen, zero, SHA256_DIGEST_LENGTH),
1606            WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1607#endif
1608    }
1609    else {
1610        ExpectIntEQ(EVP_PKEY_verify(
1611            ctx_verify, sig, siglen, zero, SHA256_DIGEST_LENGTH),
1612            WC_NO_ERR_TRACE(WOLFSSL_FAILURE));
1613    }
1614
1615#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
1616    !defined(HAVE_SELFTEST)
1617#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1618    if (keyType == EVP_PKEY_RSA) {
1619    #if defined(WC_RSA_NO_PADDING) || defined(WC_RSA_DIRECT)
1620        /* Try RSA sign/verify with no padding. */
1621        ExpectIntEQ(EVP_PKEY_sign_init(ctx), WOLFSSL_SUCCESS);
1622        ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING),
1623            WOLFSSL_SUCCESS);
1624        ExpectIntEQ(EVP_PKEY_sign(ctx, sigVerify, &siglen, sig,
1625            siglen), WOLFSSL_SUCCESS);
1626        ExpectIntGE(siglenOnlyLen, siglen);
1627        ExpectIntEQ(EVP_PKEY_verify_init(ctx_verify), WOLFSSL_SUCCESS);
1628        ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx_verify,
1629            RSA_NO_PADDING), WOLFSSL_SUCCESS);
1630        ExpectIntEQ(EVP_PKEY_verify(ctx_verify, sigVerify, siglen, sig,
1631            siglen), WOLFSSL_SUCCESS);
1632   #endif
1633
1634        /* Wrong padding schemes. */
1635        ExpectIntEQ(EVP_PKEY_sign_init(ctx), WOLFSSL_SUCCESS);
1636        ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx,
1637            RSA_PKCS1_OAEP_PADDING), WOLFSSL_SUCCESS);
1638        ExpectIntNE(EVP_PKEY_sign(ctx, sigVerify, &siglen, sig,
1639            siglen), WOLFSSL_SUCCESS);
1640        ExpectIntEQ(EVP_PKEY_verify_init(ctx_verify), WOLFSSL_SUCCESS);
1641        ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx_verify,
1642            RSA_PKCS1_OAEP_PADDING), WOLFSSL_SUCCESS);
1643        ExpectIntNE(EVP_PKEY_verify(ctx_verify, sigVerify, siglen, sig,
1644            siglen), WOLFSSL_SUCCESS);
1645
1646        ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING),
1647            WOLFSSL_SUCCESS);
1648        ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx_verify,
1649            RSA_PKCS1_PADDING), WOLFSSL_SUCCESS);
1650    }
1651#endif
1652#endif
1653
1654    /* error cases */
1655    siglen = keySz; /* Reset because sig size may vary slightly */
1656    ExpectIntNE(EVP_PKEY_sign_init(NULL), WOLFSSL_SUCCESS);
1657    ExpectIntEQ(EVP_PKEY_sign_init(ctx), WOLFSSL_SUCCESS);
1658    ExpectIntNE(EVP_PKEY_sign(NULL, sig, &siglen, (byte*)in, inlen),
1659                              WOLFSSL_SUCCESS);
1660    ExpectIntEQ(EVP_PKEY_sign(ctx, sig, &siglen, (byte*)in, inlen),
1661                              WOLFSSL_SUCCESS);
1662
1663    EVP_PKEY_free(pkey);
1664    pkey = NULL;
1665#if !defined (NO_DSA) && !defined(HAVE_SELFTEST) && defined(WOLFSSL_KEY_GEN)
1666    DSA_free(dsa);
1667    dsa = NULL;
1668#endif /* !NO_DSA && !HAVE_SELFTEST && WOLFSSL_KEY_GEN */
1669    EVP_PKEY_CTX_free(ctx_verify);
1670    ctx_verify = NULL;
1671    EVP_PKEY_CTX_free(ctx);
1672    ctx = NULL;
1673
1674    XFREE(sig, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
1675    XFREE(sigVerify, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
1676#endif /* OPENSSL_EXTRA */
1677    return EXPECT_RESULT();
1678}
1679#endif
1680
1681int test_wolfSSL_EVP_PKEY_sign_verify_rsa(void)
1682{
1683    EXPECT_DECLS;
1684#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN) && \
1685    !defined(HAVE_SELFTEST)
1686#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1687    ExpectIntEQ(test_wolfSSL_EVP_PKEY_sign_verify(EVP_PKEY_RSA), TEST_SUCCESS);
1688#endif
1689#endif
1690    return EXPECT_RESULT();
1691}
1692int test_wolfSSL_EVP_PKEY_sign_verify_dsa(void)
1693{
1694    EXPECT_DECLS;
1695#if defined(OPENSSL_EXTRA)
1696#if !defined (NO_DSA) && !defined(WC_FIPS_186_5_PLUS) && \
1697    !defined(HAVE_SELFTEST) && defined(WOLFSSL_KEY_GEN)
1698    ExpectIntEQ(test_wolfSSL_EVP_PKEY_sign_verify(EVP_PKEY_DSA), TEST_SUCCESS);
1699#endif
1700#endif
1701    return EXPECT_RESULT();
1702}
1703int test_wolfSSL_EVP_PKEY_sign_verify_ec(void)
1704{
1705    EXPECT_DECLS;
1706#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC)
1707#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
1708    ExpectIntEQ(test_wolfSSL_EVP_PKEY_sign_verify(EVP_PKEY_EC), TEST_SUCCESS);
1709#endif
1710#endif
1711    return EXPECT_RESULT();
1712}
1713
1714
1715int test_wolfSSL_EVP_MD_rsa_signing(void)
1716{
1717    EXPECT_DECLS;
1718#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(USE_CERT_BUFFERS_2048)
1719    WOLFSSL_EVP_PKEY* privKey = NULL;
1720    WOLFSSL_EVP_PKEY* pubKey = NULL;
1721    WOLFSSL_EVP_PKEY_CTX* keyCtx = NULL;
1722    const char testData[] = "Hi There";
1723    WOLFSSL_EVP_MD_CTX mdCtx;
1724    WOLFSSL_EVP_MD_CTX mdCtxCopy;
1725    int ret;
1726    size_t checkSz = -1;
1727    int sz = 2048 / 8;
1728    const unsigned char* cp;
1729    const unsigned char* p;
1730    unsigned char check[2048/8];
1731    size_t i;
1732    int paddings[] = {
1733            RSA_PKCS1_PADDING,
1734#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST) && defined(WC_RSA_PSS)
1735            RSA_PKCS1_PSS_PADDING,
1736#endif
1737    };
1738
1739
1740    cp = client_key_der_2048;
1741    ExpectNotNull((privKey = wolfSSL_d2i_PrivateKey(EVP_PKEY_RSA, NULL, &cp,
1742                                                  sizeof_client_key_der_2048)));
1743    p = client_keypub_der_2048;
1744    ExpectNotNull((pubKey = wolfSSL_d2i_PUBKEY(NULL, &p,
1745                                               sizeof_client_keypub_der_2048)));
1746
1747    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1748    wolfSSL_EVP_MD_CTX_init(&mdCtxCopy);
1749    ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
1750                                                             NULL, privKey), 1);
1751    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData,
1752                                          (unsigned int)XSTRLEN(testData)), 1);
1753    checkSz = sizeof(check);
1754    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, NULL, &checkSz), 1);
1755    ExpectIntEQ((int)checkSz, sz);
1756    checkSz = sizeof(check);
1757    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
1758    ExpectIntEQ((int)checkSz,sz);
1759    ExpectIntEQ(wolfSSL_EVP_MD_CTX_copy_ex(&mdCtxCopy, &mdCtx), 1);
1760    ExpectIntEQ(wolfSSL_EVP_MD_CTX_copy_ex(&mdCtxCopy, &mdCtx), 1);
1761    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtxCopy);
1762    ExpectIntEQ(ret, 1);
1763    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1764    ExpectIntEQ(ret, 1);
1765
1766    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1767    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
1768                                                              NULL, pubKey), 1);
1769    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData,
1770                                               (unsigned int)XSTRLEN(testData)),
1771                1);
1772    ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, check, checkSz), 1);
1773    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1774    ExpectIntEQ(ret, 1);
1775
1776    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1777    ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
1778                                                             NULL, privKey), 1);
1779    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData, 4), 1);
1780    checkSz = sizeof(check);
1781    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, NULL, &checkSz), 1);
1782    ExpectIntEQ((int)checkSz, sz);
1783    checkSz = sizeof(check);
1784    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
1785    ExpectIntEQ((int)checkSz, sz);
1786    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData + 4,
1787                                      (unsigned int)XSTRLEN(testData) - 4), 1);
1788    checkSz = sizeof(check);
1789    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
1790    ExpectIntEQ((int)checkSz, sz);
1791    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1792    ExpectIntEQ(ret, 1);
1793
1794    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1795    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
1796                                                              NULL, pubKey), 1);
1797    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData, 4), 1);
1798    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData + 4,
1799                                           (unsigned int)XSTRLEN(testData) - 4),
1800                1);
1801    ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, check, checkSz), 1);
1802    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1803    ExpectIntEQ(ret, 1);
1804
1805    /* Check all signing padding types */
1806    for (i = 0; i < sizeof(paddings)/sizeof(int); i++) {
1807        wolfSSL_EVP_MD_CTX_init(&mdCtx);
1808        ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, &keyCtx,
1809                wolfSSL_EVP_sha256(), NULL, privKey), 1);
1810        ExpectIntEQ(wolfSSL_EVP_PKEY_CTX_set_rsa_padding(keyCtx,
1811                paddings[i]), 1);
1812        ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData,
1813                (unsigned int)XSTRLEN(testData)), 1);
1814        checkSz = sizeof(check);
1815        ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, NULL, &checkSz), 1);
1816        ExpectIntEQ((int)checkSz, sz);
1817        checkSz = sizeof(check);
1818        ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
1819        ExpectIntEQ((int)checkSz,sz);
1820        ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1821        ExpectIntEQ(ret, 1);
1822
1823        wolfSSL_EVP_MD_CTX_init(&mdCtx);
1824        ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, &keyCtx,
1825                wolfSSL_EVP_sha256(), NULL, pubKey), 1);
1826        ExpectIntEQ(wolfSSL_EVP_PKEY_CTX_set_rsa_padding(keyCtx,
1827                paddings[i]), 1);
1828        ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData,
1829                (unsigned int)XSTRLEN(testData)), 1);
1830        ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, check, checkSz), 1);
1831        ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1832        ExpectIntEQ(ret, 1);
1833    }
1834
1835    wolfSSL_EVP_PKEY_free(pubKey);
1836    wolfSSL_EVP_PKEY_free(privKey);
1837#endif
1838    return EXPECT_RESULT();
1839}
1840
1841/* Test RSA-PSS digital signature creation and verification */
1842int test_wc_RsaPSS_DigitalSignVerify(void)
1843{
1844    EXPECT_DECLS;
1845
1846    /* Early FIPS did not support PSS. */
1847#if (!defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \
1848    (HAVE_FIPS_VERSION > 2))) && \
1849    (!defined(HAVE_SELFTEST) || (defined(HAVE_SELFTEST_VERSION) && \
1850    (HAVE_SELFTEST_VERSION > 2))) && \
1851    !defined(NO_RSA) && defined(WC_RSA_PSS) && defined(OPENSSL_EXTRA) && \
1852    defined(WOLFSSL_KEY_GEN) && defined(WC_RSA_NO_PADDING) && \
1853    !defined(NO_SHA256)
1854
1855    /* Test digest */
1856    const unsigned char test_digest[32] = {
1857        0x08, 0x09, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
1858        0x06, 0x07, 0x08, 0x09, 0x00, 0x01, 0x02, 0x03,
1859        0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x01,
1860        0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09
1861    };
1862    const unsigned int digest_len = sizeof(test_digest);
1863
1864    /* Variables for RSA key generation and signature operations */
1865    EVP_PKEY_CTX *pkctx = NULL;
1866    EVP_PKEY *pkey = NULL;
1867    EVP_PKEY_CTX *sign_ctx = NULL;
1868    EVP_PKEY_CTX *verify_ctx = NULL;
1869    unsigned char signature[256+MAX_DER_DIGEST_ASN_SZ] = {0};
1870    size_t signature_len = sizeof(signature);
1871    int modulus_bits = 2048;
1872
1873    /* Generate RSA key pair to avoid file dependencies */
1874    ExpectNotNull(pkctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL));
1875    ExpectIntEQ(EVP_PKEY_keygen_init(pkctx), 1);
1876    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_keygen_bits(pkctx, modulus_bits), 1);
1877    ExpectIntEQ(EVP_PKEY_keygen(pkctx, &pkey), 1);
1878
1879    /* Create signing context */
1880    ExpectNotNull(sign_ctx = EVP_PKEY_CTX_new(pkey, NULL));
1881    ExpectIntEQ(EVP_PKEY_sign_init(sign_ctx), 1);
1882
1883    /* Configure RSA-PSS parameters for signing. */
1884    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(sign_ctx, RSA_PKCS1_PSS_PADDING),
1885        1);
1886    /* Default salt length matched hash so use 32 for SHA256 */
1887    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_pss_saltlen(sign_ctx, 32), 1);
1888    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_mgf1_md(sign_ctx, EVP_sha256()), 1);
1889    ExpectIntEQ(EVP_PKEY_CTX_set_signature_md(sign_ctx, EVP_sha256()), 1);
1890
1891    /* Create the digital signature */
1892    ExpectIntEQ(EVP_PKEY_sign(sign_ctx, signature, &signature_len, test_digest,
1893                              digest_len), 1);
1894    ExpectIntGT((int)signature_len, 0);
1895
1896    /* Create verification context */
1897    ExpectNotNull(verify_ctx = EVP_PKEY_CTX_new(pkey, NULL));
1898    ExpectIntEQ(EVP_PKEY_verify_init(verify_ctx), 1);
1899
1900    /* Configure RSA-PSS parameters for verification */
1901    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(verify_ctx, RSA_PKCS1_PSS_PADDING),
1902        1);
1903    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_pss_saltlen(verify_ctx, 32), 1);
1904    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_mgf1_md(verify_ctx, EVP_sha256()), 1);
1905    ExpectIntEQ(EVP_PKEY_CTX_set_signature_md(verify_ctx, EVP_sha256()), 1);
1906
1907    /* Verify the digital signature */
1908    ExpectIntEQ(EVP_PKEY_verify(verify_ctx, signature, signature_len,
1909                                test_digest, digest_len), 1);
1910
1911    /* Test with wrong digest to ensure verification fails (negative test) */
1912    {
1913        const unsigned char wrong_digest[32] = {
1914            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1915            0x09, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
1916            0x07, 0x08, 0x09, 0x00, 0x01, 0x02, 0x03, 0x04,
1917            0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x01, 0x02
1918        };
1919        ExpectIntNE(EVP_PKEY_verify(verify_ctx, signature, signature_len,
1920                    wrong_digest, digest_len), 1);
1921    }
1922
1923    /* Clean up */
1924    if (verify_ctx)
1925        EVP_PKEY_CTX_free(verify_ctx);
1926    if (sign_ctx)
1927        EVP_PKEY_CTX_free(sign_ctx);
1928    if (pkey)
1929        EVP_PKEY_free(pkey);
1930    if (pkctx)
1931        EVP_PKEY_CTX_free(pkctx);
1932
1933#endif
1934
1935    return EXPECT_RESULT();
1936}
1937
1938int test_wolfSSL_EVP_MD_ecc_signing(void)
1939{
1940    EXPECT_DECLS;
1941#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC) && defined(USE_CERT_BUFFERS_256)
1942    WOLFSSL_EVP_PKEY* privKey = NULL;
1943    WOLFSSL_EVP_PKEY* pubKey = NULL;
1944    const char testData[] = "Hi There";
1945    WOLFSSL_EVP_MD_CTX mdCtx;
1946    int ret;
1947    const unsigned char* cp;
1948    const unsigned char* p;
1949    unsigned char check[2048/8];
1950    size_t checkSz = sizeof(check);
1951
1952    XMEMSET(check, 0, sizeof(check));
1953
1954    cp = ecc_clikey_der_256;
1955    ExpectNotNull(privKey = wolfSSL_d2i_PrivateKey(EVP_PKEY_EC, NULL, &cp,
1956                                                   sizeof_ecc_clikey_der_256));
1957    p = ecc_clikeypub_der_256;
1958    ExpectNotNull((pubKey = wolfSSL_d2i_PUBKEY(NULL, &p,
1959                                                sizeof_ecc_clikeypub_der_256)));
1960
1961    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1962    ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
1963                                                             NULL, privKey), 1);
1964    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData,
1965                                          (unsigned int)XSTRLEN(testData)), 1);
1966    checkSz = sizeof(check);
1967    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, NULL, &checkSz), 1);
1968    checkSz = sizeof(check);
1969    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
1970    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1971    ExpectIntEQ(ret, 1);
1972
1973    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1974    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
1975                                                              NULL, pubKey), 1);
1976    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData,
1977                                               (unsigned int)XSTRLEN(testData)),
1978                1);
1979    ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, check, checkSz), 1);
1980    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1981    ExpectIntEQ(ret, 1);
1982
1983    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1984    ExpectIntEQ(wolfSSL_EVP_DigestSignInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
1985                                                             NULL, privKey), 1);
1986    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData, 4), 1);
1987    checkSz = sizeof(check);
1988    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, NULL, &checkSz), 1);
1989    checkSz = sizeof(check);
1990    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
1991    ExpectIntEQ(wolfSSL_EVP_DigestSignUpdate(&mdCtx, testData + 4,
1992                                      (unsigned int)XSTRLEN(testData) - 4), 1);
1993    checkSz = sizeof(check);
1994    ExpectIntEQ(wolfSSL_EVP_DigestSignFinal(&mdCtx, check, &checkSz), 1);
1995    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
1996    ExpectIntEQ(ret, 1);
1997
1998    wolfSSL_EVP_MD_CTX_init(&mdCtx);
1999    ExpectIntEQ(wolfSSL_EVP_DigestVerifyInit(&mdCtx, NULL, wolfSSL_EVP_sha256(),
2000                                                              NULL, pubKey), 1);
2001    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData, 4), 1);
2002    ExpectIntEQ(wolfSSL_EVP_DigestVerifyUpdate(&mdCtx, testData + 4,
2003                                           (unsigned int)XSTRLEN(testData) - 4),
2004                1);
2005    ExpectIntEQ(wolfSSL_EVP_DigestVerifyFinal(&mdCtx, check, checkSz), 1);
2006    ret = wolfSSL_EVP_MD_CTX_cleanup(&mdCtx);
2007    ExpectIntEQ(ret, 1);
2008
2009    wolfSSL_EVP_PKEY_free(pubKey);
2010    wolfSSL_EVP_PKEY_free(privKey);
2011#endif
2012    return EXPECT_RESULT();
2013}
2014
2015
2016int test_wolfSSL_EVP_PKEY_encrypt(void)
2017{
2018    EXPECT_DECLS;
2019#if defined(OPENSSL_EXTRA) && !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN)
2020    WOLFSSL_RSA* rsa = NULL;
2021    WOLFSSL_EVP_PKEY* pkey = NULL;
2022    WOLFSSL_EVP_PKEY_CTX* ctx = NULL;
2023    const char* in = "What is easy to do is easy not to do.";
2024    size_t inlen = XSTRLEN(in);
2025    size_t outEncLen = 0;
2026    byte*  outEnc = NULL;
2027    byte*  outDec = NULL;
2028    size_t outDecLen = 0;
2029    size_t rsaKeySz = 2048/8;  /* Bytes */
2030#if !defined(HAVE_FIPS) && defined(WC_RSA_NO_PADDING)
2031    byte*  inTmp = NULL;
2032    byte*  outEncTmp = NULL;
2033    byte*  outDecTmp = NULL;
2034#endif
2035
2036    ExpectNotNull(outEnc = (byte*)XMALLOC(rsaKeySz, HEAP_HINT,
2037        DYNAMIC_TYPE_TMP_BUFFER));
2038    if (outEnc != NULL) {
2039        XMEMSET(outEnc, 0, rsaKeySz);
2040    }
2041    ExpectNotNull(outDec = (byte*)XMALLOC(rsaKeySz, HEAP_HINT,
2042        DYNAMIC_TYPE_TMP_BUFFER));
2043    if (outDec != NULL) {
2044        XMEMSET(outDec, 0, rsaKeySz);
2045    }
2046
2047    ExpectNotNull(rsa = RSA_generate_key(2048, 3, NULL, NULL));
2048    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new());
2049    ExpectIntEQ(EVP_PKEY_assign_RSA(pkey, rsa), WOLFSSL_SUCCESS);
2050    if (EXPECT_FAIL()) {
2051        RSA_free(rsa);
2052    }
2053    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
2054    ExpectIntEQ(EVP_PKEY_encrypt_init(ctx), WOLFSSL_SUCCESS);
2055    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING),
2056        WOLFSSL_SUCCESS);
2057
2058    /* Test pkey references count is decremented. pkey shouldn't be destroyed
2059     since ctx uses it.*/
2060    ExpectIntEQ(pkey->ref.count, 2);
2061    EVP_PKEY_free(pkey);
2062    ExpectIntEQ(pkey->ref.count, 1);
2063
2064    /* Encrypt data */
2065    /* Check that we can get the required output buffer length by passing in a
2066     * NULL output buffer. */
2067    ExpectIntEQ(EVP_PKEY_encrypt(ctx, NULL, &outEncLen,
2068                            (const unsigned char*)in, inlen), WOLFSSL_SUCCESS);
2069    ExpectIntEQ(rsaKeySz, outEncLen);
2070    /* Now do the actual encryption. */
2071    ExpectIntEQ(EVP_PKEY_encrypt(ctx, outEnc, &outEncLen,
2072                            (const unsigned char*)in, inlen), WOLFSSL_SUCCESS);
2073
2074    /* Decrypt data */
2075    ExpectIntEQ(EVP_PKEY_decrypt_init(ctx), WOLFSSL_SUCCESS);
2076    /* Check that we can get the required output buffer length by passing in a
2077     * NULL output buffer. */
2078    ExpectIntEQ(EVP_PKEY_decrypt(ctx, NULL, &outDecLen, outEnc, outEncLen),
2079                                 WOLFSSL_SUCCESS);
2080    ExpectIntEQ(rsaKeySz, outDecLen);
2081    /* Now do the actual decryption. */
2082    ExpectIntEQ(EVP_PKEY_decrypt(ctx, outDec, &outDecLen, outEnc, outEncLen),
2083                                 WOLFSSL_SUCCESS);
2084
2085    ExpectIntEQ(XMEMCMP(in, outDec, outDecLen), 0);
2086
2087#if !defined(HAVE_FIPS) && defined(WC_RSA_NO_PADDING)
2088    /* The input length must be the same size as the RSA key.*/
2089    ExpectNotNull(inTmp = (byte*)XMALLOC(rsaKeySz, HEAP_HINT,
2090        DYNAMIC_TYPE_TMP_BUFFER));
2091    if (inTmp != NULL) {
2092        XMEMSET(inTmp, 9, rsaKeySz);
2093    }
2094    ExpectNotNull(outEncTmp = (byte*)XMALLOC(rsaKeySz, HEAP_HINT,
2095        DYNAMIC_TYPE_TMP_BUFFER));
2096    if (outEncTmp != NULL) {
2097        XMEMSET(outEncTmp, 0, rsaKeySz);
2098   }
2099    ExpectNotNull(outDecTmp = (byte*)XMALLOC(rsaKeySz, HEAP_HINT,
2100        DYNAMIC_TYPE_TMP_BUFFER));
2101    if (outDecTmp != NULL) {
2102        XMEMSET(outDecTmp, 0, rsaKeySz);
2103    }
2104    ExpectIntEQ(EVP_PKEY_encrypt_init(ctx), WOLFSSL_SUCCESS);
2105    ExpectIntEQ(EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING),
2106        WOLFSSL_SUCCESS);
2107    ExpectIntEQ(EVP_PKEY_encrypt(ctx, outEncTmp, &outEncLen, inTmp, rsaKeySz),
2108        WOLFSSL_SUCCESS);
2109    ExpectIntEQ(EVP_PKEY_decrypt_init(ctx), WOLFSSL_SUCCESS);
2110    ExpectIntEQ(EVP_PKEY_decrypt(ctx, outDecTmp, &outDecLen, outEncTmp,
2111        outEncLen), WOLFSSL_SUCCESS);
2112    ExpectIntEQ(XMEMCMP(inTmp, outDecTmp, outDecLen), 0);
2113#endif
2114    EVP_PKEY_CTX_free(ctx);
2115    XFREE(outEnc, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
2116    XFREE(outDec, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
2117#if !defined(HAVE_FIPS) && defined(WC_RSA_NO_PADDING)
2118    XFREE(inTmp, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
2119    XFREE(outEncTmp, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
2120    XFREE(outDecTmp, HEAP_HINT, DYNAMIC_TYPE_TMP_BUFFER);
2121#endif
2122#endif
2123    return EXPECT_RESULT();
2124}
2125
2126int test_wolfSSL_EVP_PKEY_derive(void)
2127{
2128    EXPECT_DECLS;
2129#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT) || defined(WOLFSSL_OPENSSH)
2130#if (!defined(NO_DH) && defined(WOLFSSL_DH_EXTRA)) || defined(HAVE_ECC)
2131    EVP_PKEY_CTX *ctx = NULL;
2132    unsigned char *skey = NULL;
2133    size_t skeylen;
2134    EVP_PKEY *pkey = NULL;
2135    EVP_PKEY *peerkey = NULL;
2136    const unsigned char* key;
2137
2138#if !defined(NO_DH) && defined(WOLFSSL_DH_EXTRA)
2139    /* DH */
2140    key = dh_key_der_2048;
2141    ExpectNotNull((pkey = d2i_PrivateKey(EVP_PKEY_DH, NULL, &key,
2142        sizeof_dh_key_der_2048)));
2143    ExpectIntEQ(DH_generate_key(EVP_PKEY_get0_DH(pkey)), 1);
2144    key = dh_key_der_2048;
2145    ExpectNotNull((peerkey = d2i_PrivateKey(EVP_PKEY_DH, NULL, &key,
2146        sizeof_dh_key_der_2048)));
2147    ExpectIntEQ(DH_generate_key(EVP_PKEY_get0_DH(peerkey)), 1);
2148    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
2149    ExpectIntEQ(EVP_PKEY_derive_init(ctx), 1);
2150    ExpectIntEQ(EVP_PKEY_derive_set_peer(ctx, peerkey), 1);
2151    ExpectIntEQ(EVP_PKEY_derive(ctx, NULL, &skeylen), 1);
2152    ExpectNotNull(skey = (unsigned char*)XMALLOC(skeylen, NULL,
2153        DYNAMIC_TYPE_OPENSSL));
2154    ExpectIntEQ(EVP_PKEY_derive(ctx, skey, &skeylen), 1);
2155
2156    EVP_PKEY_CTX_free(ctx);
2157    ctx = NULL;
2158    EVP_PKEY_free(peerkey);
2159    peerkey = NULL;
2160    EVP_PKEY_free(pkey);
2161    pkey = NULL;
2162    XFREE(skey, NULL, DYNAMIC_TYPE_OPENSSL);
2163    skey = NULL;
2164#endif
2165
2166#ifdef HAVE_ECC
2167    /* ECDH */
2168    key = ecc_clikey_der_256;
2169    ExpectNotNull((pkey = d2i_PrivateKey(EVP_PKEY_EC, NULL, &key,
2170        sizeof_ecc_clikey_der_256)));
2171    key = ecc_clikeypub_der_256;
2172    ExpectNotNull((peerkey = d2i_PUBKEY(NULL, &key,
2173        sizeof_ecc_clikeypub_der_256)));
2174    ExpectNotNull(ctx = EVP_PKEY_CTX_new(pkey, NULL));
2175    ExpectIntEQ(EVP_PKEY_derive_init(ctx), 1);
2176    ExpectIntEQ(EVP_PKEY_derive_set_peer(ctx, peerkey), 1);
2177    ExpectIntEQ(EVP_PKEY_derive(ctx, NULL, &skeylen), 1);
2178    ExpectNotNull(skey = (unsigned char*)XMALLOC(skeylen, NULL,
2179        DYNAMIC_TYPE_OPENSSL));
2180    ExpectIntEQ(EVP_PKEY_derive(ctx, skey, &skeylen), 1);
2181
2182    EVP_PKEY_CTX_free(ctx);
2183    EVP_PKEY_free(peerkey);
2184    EVP_PKEY_free(pkey);
2185    XFREE(skey, NULL, DYNAMIC_TYPE_OPENSSL);
2186#endif /* HAVE_ECC */
2187#endif /* (!NO_DH && WOLFSSL_DH_EXTRA) || HAVE_ECC */
2188#endif /* OPENSSL_ALL || WOLFSSL_QT || WOLFSSL_OPENSSH */
2189    return EXPECT_RESULT();
2190}
2191
2192int test_wolfSSL_EVP_PKEY_print_public(void)
2193{
2194    EXPECT_DECLS;
2195#if defined(OPENSSL_EXTRA) && !defined(NO_BIO)
2196    WOLFSSL_BIO* rbio = NULL;
2197    WOLFSSL_BIO* wbio = NULL;
2198    WOLFSSL_EVP_PKEY* pkey = NULL;
2199    char line[256] = { 0 };
2200    char line1[256] = { 0 };
2201    int i = 0;
2202
2203    /* test error cases */
2204    ExpectIntEQ( EVP_PKEY_print_public(NULL,NULL,0,NULL),0L);
2205
2206    /*
2207     *  test RSA public key print
2208     *  in this test, pass '3' for indent
2209     */
2210#if !defined(NO_RSA) && defined(USE_CERT_BUFFERS_1024)
2211
2212    ExpectNotNull(rbio = BIO_new_mem_buf( client_keypub_der_1024,
2213        sizeof_client_keypub_der_1024));
2214
2215    ExpectNotNull(wolfSSL_d2i_PUBKEY_bio(rbio, &pkey));
2216
2217    ExpectNotNull(wbio = BIO_new(BIO_s_mem()));
2218
2219    ExpectIntEQ(EVP_PKEY_print_public(wbio, pkey,3,NULL),1);
2220
2221    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2222    strcpy(line1, "   RSA Public-Key: (1024 bit)\n");
2223    ExpectIntEQ(XSTRNCMP(line, line1, XSTRLEN(line1)), 0);
2224
2225    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2226    strcpy(line1, "   Modulus:\n");
2227    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2228
2229    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2230    strcpy(line1, "       00:bc:73:0e:a8:49:f3:74:a2:a9:ef:18:a5:da:55:\n");
2231    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2232
2233    /* skip to the end of modulus element*/
2234    for (i = 0; i < 8 ;i++) {
2235        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2236    }
2237
2238    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2239    strcpy(line1, "   Exponent: 65537 (0x010001)\n");
2240    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2241
2242
2243    /* should reach EOF */
2244    ExpectIntLE(BIO_gets(wbio, line, sizeof(line)), 0);
2245
2246    EVP_PKEY_free(pkey);
2247    pkey = NULL;
2248    BIO_free(rbio);
2249    BIO_free(wbio);
2250    rbio = NULL;
2251    wbio = NULL;
2252
2253#endif  /* !NO_RSA && USE_CERT_BUFFERS_1024*/
2254
2255    /*
2256     *  test DSA public key print
2257     */
2258#if !defined(NO_DSA) && defined(USE_CERT_BUFFERS_2048)
2259    ExpectNotNull(rbio = BIO_new_mem_buf( dsa_pub_key_der_2048,
2260        sizeof_dsa_pub_key_der_2048));
2261
2262    ExpectNotNull(wolfSSL_d2i_PUBKEY_bio(rbio, &pkey));
2263
2264    ExpectNotNull(wbio = BIO_new(BIO_s_mem()));
2265
2266    ExpectIntEQ(EVP_PKEY_print_public(wbio, pkey,0,NULL),1);
2267
2268    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2269    strcpy(line1, "DSA Public-Key: (2048 bit)\n");
2270    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2271
2272    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2273    strcpy(line1, "pub:\n");
2274    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2275
2276    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2277    strcpy(line1,
2278        "    00:C2:35:2D:EC:83:83:6C:73:13:9E:52:7C:74:C8:\n");
2279    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2280
2281    /* skip to the end of pub element*/
2282    for (i = 0; i < 17 ;i++) {
2283        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2284    }
2285
2286    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2287    strcpy(line1, "P:\n");
2288    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2289
2290    /* skip to the end of P element*/
2291    for (i = 0; i < 18 ;i++) {
2292        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2293    }
2294
2295    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2296    strcpy(line1, "Q:\n");
2297    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2298
2299    /* skip to the end of Q element*/
2300    for (i = 0; i < 3 ;i++) {
2301        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2302    }
2303    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2304    strcpy(line1, "G:\n");
2305    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2306
2307    /* skip to the end of G element*/
2308    for (i = 0; i < 18 ;i++) {
2309        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2310    }
2311    /* should reach EOF */
2312    ExpectIntLE(BIO_gets(wbio, line, sizeof(line)), 0);
2313
2314    EVP_PKEY_free(pkey);
2315    pkey = NULL;
2316    BIO_free(rbio);
2317    BIO_free(wbio);
2318    rbio = NULL;
2319    wbio = NULL;
2320
2321#endif /* !NO_DSA && USE_CERT_BUFFERS_2048 */
2322
2323    /*
2324     *  test ECC public key print
2325     */
2326#if defined(HAVE_ECC) && defined(USE_CERT_BUFFERS_256)
2327
2328    ExpectNotNull(rbio = BIO_new_mem_buf( ecc_clikeypub_der_256,
2329        sizeof_ecc_clikeypub_der_256));
2330
2331    ExpectNotNull(wolfSSL_d2i_PUBKEY_bio(rbio, &pkey));
2332
2333    ExpectNotNull(wbio = BIO_new(BIO_s_mem()));
2334
2335    ExpectIntEQ(EVP_PKEY_print_public(wbio, pkey,0,NULL),1);
2336
2337    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2338    ExpectStrEQ(line, "Public-Key: (256 bit)\n");
2339
2340    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2341    strcpy(line1, "pub:\n");
2342    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2343
2344    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2345    strcpy(line1,
2346            "    04:55:BF:F4:0F:44:50:9A:3D:CE:9B:B7:F0:C5:4D:\n");
2347    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2348
2349    /* skip to the end of pub element*/
2350    for (i = 0; i < 4 ;i++) {
2351        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2352    }
2353
2354    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2355    strcpy(line1, "ASN1 OID: prime256v1\n");
2356    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2357
2358    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2359    strcpy(line1, "NIST CURVE: P-256\n");
2360    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2361
2362
2363    /* should reach EOF */
2364    ExpectIntLE(BIO_gets(wbio, line, sizeof(line)), 0);
2365
2366    EVP_PKEY_free(pkey);
2367    pkey = NULL;
2368    BIO_free(rbio);
2369    BIO_free(wbio);
2370    rbio = NULL;
2371    wbio = NULL;
2372
2373#endif /* HAVE_ECC && USE_CERT_BUFFERS_256 */
2374
2375    /*
2376     *  test DH public key print
2377     */
2378#if defined(WOLFSSL_DH_EXTRA) && defined(USE_CERT_BUFFERS_2048)
2379
2380    ExpectNotNull(rbio = BIO_new_mem_buf( dh_pub_key_der_2048,
2381        sizeof_dh_pub_key_der_2048));
2382
2383    ExpectNotNull(wolfSSL_d2i_PUBKEY_bio(rbio, &pkey));
2384
2385    ExpectNotNull(wbio = BIO_new(BIO_s_mem()));
2386
2387    ExpectIntEQ(EVP_PKEY_print_public(wbio, pkey,0,NULL), 1);
2388
2389    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2390    strcpy(line1, "DH Public-Key: (2048 bit)\n");
2391    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2392
2393    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2394    strcpy(line1, "public-key:\n");
2395    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2396
2397    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2398    strcpy(line1,
2399        "    34:41:BF:E9:F2:11:BF:05:DB:B2:72:A8:29:CC:BD:\n");
2400    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2401
2402    /* skip to the end of public-key element*/
2403    for (i = 0; i < 17 ;i++) {
2404        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2405    }
2406
2407    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2408    strcpy(line1, "prime:\n");
2409    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2410
2411    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2412    strcpy(line1,
2413        "    00:D3:B2:99:84:5C:0A:4C:E7:37:CC:FC:18:37:01:\n");
2414    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2415
2416    /* skip to the end of prime element*/
2417    for (i = 0; i < 17 ;i++) {
2418        ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2419    }
2420
2421    ExpectIntGT(BIO_gets(wbio, line, sizeof(line)), 0);
2422    strcpy(line1, "generator: 2 (0x02)\n");
2423    ExpectIntEQ(XSTRNCMP( line, line1, XSTRLEN(line1)), 0);
2424
2425    /* should reach EOF */
2426    ExpectIntLE(BIO_gets(wbio, line, sizeof(line)), 0);
2427
2428    EVP_PKEY_free(pkey);
2429    pkey = NULL;
2430    BIO_free(rbio);
2431    BIO_free(wbio);
2432    rbio = NULL;
2433    wbio = NULL;
2434
2435#endif /* WOLFSSL_DH_EXTRA && USE_CERT_BUFFERS_2048 */
2436
2437    /* to prevent "unused variable" warning */
2438    (void)pkey;
2439    (void)wbio;
2440    (void)rbio;
2441    (void)line;
2442    (void)line1;
2443    (void)i;
2444#endif /* OPENSSL_EXTRA */
2445    return EXPECT_RESULT();
2446}
2447
2448int test_wolfSSL_EVP_PKEY_ed25519(void)
2449{
2450    EXPECT_DECLS;
2451#if defined(OPENSSL_EXTRA) && defined(HAVE_ED25519)
2452    WOLFSSL_EVP_PKEY* pkey = NULL;
2453    const unsigned char* p;
2454
2455    /* Known-valid Ed25519 public key matching server_ed25519_key. The bytes
2456     * are the raw 32-byte BIT STRING contents from
2457     * ./certs/ed25519/server-ed25519-key.der so the import succeeds even
2458     * under strict point-validation. */
2459    static const unsigned char rawPub[32] = {
2460        0x23, 0xaa, 0x4d, 0x60, 0x50, 0xe0, 0x13, 0xd3,
2461        0x3a, 0xed, 0xab, 0xf6, 0xa9, 0xcc, 0x4a, 0xfe,
2462        0xd7, 0x4d, 0x2f, 0xd2, 0x5b, 0x1a, 0x10, 0x05,
2463        0xef, 0x5a, 0x41, 0x25, 0xce, 0x1b, 0x53, 0x78
2464    };
2465
2466    /* SPKI wrapper around the same known-valid public key (the full
2467     * contents of ./certs/ed25519/server-ed25519-key.der). */
2468    static const unsigned char spkiPub[] = {
2469        0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
2470        0x23, 0xaa, 0x4d, 0x60, 0x50, 0xe0, 0x13, 0xd3,
2471        0x3a, 0xed, 0xab, 0xf6, 0xa9, 0xcc, 0x4a, 0xfe,
2472        0xd7, 0x4d, 0x2f, 0xd2, 0x5b, 0x1a, 0x10, 0x05,
2473        0xef, 0x5a, 0x41, 0x25, 0xce, 0x1b, 0x53, 0x78
2474    };
2475
2476    /* Exercise the WC_EVP_PKEY_ED25519 case in d2i_evp_pkey()
2477     * including the algId match for the PKCS#8 wrapper. */
2478    p = server_ed25519_key;
2479    ExpectNotNull(pkey = wolfSSL_d2i_PrivateKey(EVP_PKEY_ED25519, NULL,
2480        &p, (long)sizeof_server_ed25519_key));
2481    ExpectIntEQ(wolfSSL_EVP_PKEY_id(pkey), EVP_PKEY_ED25519);
2482    wolfSSL_EVP_PKEY_free(pkey);
2483    pkey = NULL;
2484
2485    p = spkiPub;
2486    ExpectNotNull(pkey = wolfSSL_d2i_PUBKEY(NULL, &p, (long)sizeof(spkiPub)));
2487    ExpectIntEQ(wolfSSL_EVP_PKEY_id(pkey), EVP_PKEY_ED25519);
2488    wolfSSL_EVP_PKEY_free(pkey);
2489    pkey = NULL;
2490
2491    /* Exercise EVP_PKEY_new_raw_public_key to parse 32 raw BIT STRING bytes */
2492    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new_raw_public_key(
2493        WC_EVP_PKEY_ED25519, NULL, rawPub, sizeof(rawPub)));
2494    ExpectIntEQ(wolfSSL_EVP_PKEY_id(pkey), EVP_PKEY_ED25519);
2495    wolfSSL_EVP_PKEY_free(pkey);
2496    pkey = NULL;
2497
2498    {
2499        static const unsigned char junk[16] = { 0 };
2500        const unsigned char* jp = junk;
2501        ExpectNull(wolfSSL_d2i_PUBKEY(NULL, &jp, (long)sizeof(junk)));
2502    }
2503#endif
2504    return EXPECT_RESULT();
2505}
2506
2507int test_wolfSSL_CTX_use_PrivateKey_ed25519(void)
2508{
2509    EXPECT_DECLS;
2510#if defined(OPENSSL_EXTRA) && defined(HAVE_ED25519) && \
2511    !defined(NO_WOLFSSL_SERVER) && !defined(NO_TLS)
2512    WOLFSSL_CTX* ctx = NULL;
2513    WOLFSSL_EVP_PKEY* pkey = NULL;
2514    const unsigned char* p;
2515
2516    ExpectNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_server_method()));
2517
2518     /* Load the matching Ed25519 server cert */
2519    ExpectIntEQ(wolfSSL_CTX_use_certificate_buffer(ctx, server_ed25519_cert,
2520        (long)sizeof_server_ed25519_cert, WOLFSSL_FILETYPE_ASN1),
2521        WOLFSSL_SUCCESS);
2522
2523    /* Decode the Ed25519 private key as a WOLFSSL_EVP_PKEY */
2524    p = server_ed25519_key;
2525    ExpectNotNull(pkey = wolfSSL_d2i_PrivateKey(EVP_PKEY_ED25519, NULL,
2526        &p, (long)sizeof_server_ed25519_key));
2527    ExpectIntEQ(wolfSSL_EVP_PKEY_id(pkey), EVP_PKEY_ED25519);
2528
2529    /* Load the pkey and check for success */
2530    ExpectIntEQ(wolfSSL_CTX_use_PrivateKey(ctx, pkey), WOLFSSL_SUCCESS);
2531
2532    wolfSSL_EVP_PKEY_free(pkey);
2533    wolfSSL_CTX_free(ctx);
2534#endif
2535    return EXPECT_RESULT();
2536}
2537
2538int test_wolfSSL_EVP_PKEY_ed448(void)
2539{
2540    EXPECT_DECLS;
2541#if defined(OPENSSL_EXTRA) && defined(HAVE_ED448)
2542    WOLFSSL_EVP_PKEY* pkey = NULL;
2543    const unsigned char* p;
2544
2545    /* Known-valid Ed448 public key: the raw 57-byte BIT STRING contents
2546     * from ./certs/ed448/server-ed448-key.der so the import succeeds even
2547     * under strict point-validation. */
2548    static const unsigned char rawPub[57] = {
2549        0x54, 0x81, 0x39, 0x01, 0xeb, 0x37, 0xd9, 0xa9,
2550        0x07, 0xcd, 0x01, 0xbc, 0x9d, 0x70, 0x16, 0xc2,
2551        0x2c, 0x2b, 0x75, 0x5b, 0x63, 0xdb, 0xee, 0x3a,
2552        0x2d, 0x44, 0x92, 0x46, 0xb4, 0x7b, 0x07, 0x03,
2553        0x4f, 0xa2, 0xae, 0x86, 0x86, 0xdc, 0x8b, 0x4b,
2554        0x2c, 0x7f, 0xe8, 0x6b, 0x14, 0x8d, 0x58, 0xdd,
2555        0x6d, 0xe7, 0x6f, 0x3a, 0x05, 0x95, 0xa8, 0xef,
2556        0x00
2557    };
2558
2559    /* SPKI wrapper around the same known-valid public key (the full
2560     * contents of ./certs/ed448/server-ed448-key.der). */
2561    static const unsigned char spkiPub[] = {
2562        0x30, 0x43, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x71, 0x03, 0x3a, 0x00,
2563        0x54, 0x81, 0x39, 0x01, 0xeb, 0x37, 0xd9, 0xa9,
2564        0x07, 0xcd, 0x01, 0xbc, 0x9d, 0x70, 0x16, 0xc2,
2565        0x2c, 0x2b, 0x75, 0x5b, 0x63, 0xdb, 0xee, 0x3a,
2566        0x2d, 0x44, 0x92, 0x46, 0xb4, 0x7b, 0x07, 0x03,
2567        0x4f, 0xa2, 0xae, 0x86, 0x86, 0xdc, 0x8b, 0x4b,
2568        0x2c, 0x7f, 0xe8, 0x6b, 0x14, 0x8d, 0x58, 0xdd,
2569        0x6d, 0xe7, 0x6f, 0x3a, 0x05, 0x95, 0xa8, 0xef,
2570        0x00
2571    };
2572
2573    /* SPKI path. */
2574    p = spkiPub;
2575    ExpectNotNull(pkey = wolfSSL_d2i_PUBKEY(NULL, &p, (long)sizeof(spkiPub)));
2576    ExpectIntEQ(wolfSSL_EVP_PKEY_id(pkey), EVP_PKEY_ED448);
2577    wolfSSL_EVP_PKEY_free(pkey);
2578    pkey = NULL;
2579
2580    /* Parse raw bytes */
2581    ExpectNotNull(pkey = wolfSSL_EVP_PKEY_new_raw_public_key(
2582        WC_EVP_PKEY_ED448, NULL, rawPub, sizeof(rawPub)));
2583    ExpectIntEQ(wolfSSL_EVP_PKEY_id(pkey), EVP_PKEY_ED448);
2584    wolfSSL_EVP_PKEY_free(pkey);
2585    pkey = NULL;
2586#endif
2587    return EXPECT_RESULT();
2588}
2589