test/evp_extra_test2.c

   1 /*
   2  * Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /* We need to use some deprecated APIs */
  11 #define OPENSSL_SUPPRESS_DEPRECATED
  12
  13 /*
  14  * Really these tests should be in evp_extra_test - but that doesn't
  15  * yet support testing with a non-default libctx. Once it does we should move
  16  * everything into one file. Consequently some things are duplicated between
  17  * the two files.
  18  */
  19
  20 #include <openssl/evp.h>
  21 #include <openssl/pem.h>
  22 #include <openssl/provider.h>
  23 #include <openssl/rsa.h>
  24 #include <openssl/dh.h>
  25 #include <openssl/core_names.h>
  26
  27 #include "testutil.h"
  28 #include "internal/nelem.h"
  29
  30 static OSSL_LIB_CTX *mainctx = NULL;
  31 static OSSL_PROVIDER *nullprov = NULL;
  32
  33 /*
  34  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
  35  * should never use this key anywhere but in an example.
  36  */
  37 static const unsigned char kExampleRSAKeyDER[] = {
  38     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
  39     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
  40     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
  41     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
  42     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
  43     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
  44     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
  45     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
  46     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
  47     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
  48     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
  49     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
  50     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
  51     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
  52     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
  53     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
  54     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
  55     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
  56     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
  57     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
  58     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
  59     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
  60     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
  61     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
  62     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
  63     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
  64     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
  65     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
  66     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
  67     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
  68     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
  69     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
  70     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
  71     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
  72     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
  73     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
  74     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
  75     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
  76     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
  77     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
  78     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
  79     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
  80     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
  81     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
  82     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
  83     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
  84     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
  85     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
  86     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
  87     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
  88     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
  89 };
  90
  91 /*
  92  * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
  93  * PrivateKeyInfo.
  94  */
  95 static const unsigned char kExampleRSAKeyPKCS8[] = {
  96     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
  97     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
  98     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
  99     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
 100     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
 101     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
 102     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
 103     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
 104     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
 105     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
 106     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
 107     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
 108     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
 109     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
 110     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
 111     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
 112     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
 113     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
 114     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
 115     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
 116     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
 117     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
 118     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
 119     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
 120     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
 121     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
 122     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
 123     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
 124     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
 125     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
 126     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
 127     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
 128     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
 129     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
 130     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
 131     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
 132     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
 133     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
 134     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
 135     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
 136     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
 137     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
 138     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
 139     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
 140     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
 141     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
 142     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
 143     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
 144     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
 145     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
 146     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
 147     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
 148     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 149 };
 150
 151 #ifndef OPENSSL_NO_DH
 152 static const unsigned char kExampleDHPrivateKeyDER[] = {
 153     0x30, 0x82, 0x02, 0x26, 0x02, 0x01, 0x00, 0x30, 0x82, 0x01, 0x17, 0x06,
 154     0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x03, 0x01, 0x30, 0x82,
 155     0x01, 0x08, 0x02, 0x82, 0x01, 0x01, 0x00, 0xD8, 0x4B, 0x0F, 0x0E, 0x6B,
 156     0x79, 0xE9, 0x23, 0x4E, 0xE4, 0xBE, 0x9A, 0x8F, 0x7A, 0x5C, 0xA3, 0x20,
 157     0xD0, 0x86, 0x6B, 0x95, 0x78, 0x39, 0x59, 0x7A, 0x11, 0x2A, 0x5B, 0x87,
 158     0xA4, 0xFB, 0x2F, 0x99, 0xD0, 0x57, 0xF5, 0xE1, 0xA3, 0xAF, 0x41, 0xD1,
 159     0xCD, 0xA3, 0x94, 0xBB, 0xE5, 0x5A, 0x68, 0xE2, 0xEE, 0x69, 0x56, 0x51,
 160     0xB2, 0xEE, 0xF2, 0xFE, 0x10, 0xC9, 0x55, 0xE3, 0x82, 0x3C, 0x50, 0x0D,
 161     0xF5, 0x82, 0x73, 0xE4, 0xD6, 0x3E, 0x45, 0xB4, 0x89, 0x80, 0xE4, 0xF0,
 162     0x99, 0x85, 0x2B, 0x4B, 0xF9, 0xB8, 0xFD, 0x2C, 0x3C, 0x49, 0x2E, 0xB3,
 163     0x56, 0x7E, 0x99, 0x07, 0xD3, 0xF7, 0xD9, 0xE4, 0x0C, 0x64, 0xC5, 0x7D,
 164     0x03, 0x8E, 0x05, 0x3C, 0x0A, 0x40, 0x17, 0xAD, 0xA8, 0x0F, 0x9B, 0xF4,
 165     0x8B, 0xA7, 0xDB, 0x16, 0x4F, 0x4A, 0x57, 0x0B, 0x89, 0x80, 0x0B, 0x9F,
 166     0x26, 0x56, 0x3F, 0x1D, 0xFA, 0x52, 0x2D, 0x1A, 0x9E, 0xDC, 0x42, 0xA3,
 167     0x2E, 0xA9, 0x87, 0xE3, 0x8B, 0x45, 0x5E, 0xEE, 0x99, 0xB8, 0x30, 0x15,
 168     0x58, 0xA3, 0x5F, 0xB5, 0x69, 0xD8, 0x0C, 0xE8, 0x6B, 0x36, 0xD8, 0xAB,
 169     0xD8, 0xE4, 0x77, 0x46, 0x13, 0xA2, 0x15, 0xB3, 0x9C, 0xAD, 0x99, 0x91,
 170     0xE5, 0xA3, 0x30, 0x7D, 0x40, 0x70, 0xB3, 0x32, 0x5E, 0xAF, 0x96, 0x8D,
 171     0xE6, 0x3F, 0x47, 0xA3, 0x18, 0xDA, 0xE1, 0x9A, 0x20, 0x11, 0xE1, 0x49,
 172     0x51, 0x45, 0xE3, 0x8C, 0xA5, 0x56, 0x39, 0x67, 0xCB, 0x9D, 0xCF, 0xBA,
 173     0xF4, 0x46, 0x4E, 0x0A, 0xB6, 0x0B, 0xA9, 0xB4, 0xF6, 0xF1, 0x6A, 0xC8,
 174     0x63, 0xE2, 0xB4, 0xB2, 0x9F, 0x44, 0xAA, 0x0A, 0xDA, 0x53, 0xF7, 0x52,
 175     0x14, 0x57, 0xEE, 0x2C, 0x5D, 0x31, 0x9C, 0x27, 0x03, 0x64, 0x9E, 0xC0,
 176     0x1E, 0x4B, 0x1B, 0x4F, 0xEE, 0xA6, 0x3F, 0xC1, 0x3E, 0x61, 0x93, 0x02,
 177     0x01, 0x02, 0x04, 0x82, 0x01, 0x04, 0x02, 0x82, 0x01, 0x00, 0x7E, 0xC2,
 178     0x04, 0xF9, 0x95, 0xC7, 0xEF, 0x96, 0xBE, 0xA0, 0x9D, 0x2D, 0xC3, 0x0C,
 179     0x3A, 0x67, 0x02, 0x7C, 0x7D, 0x3B, 0xC9, 0xB1, 0xDE, 0x13, 0x97, 0x64,
 180     0xEF, 0x87, 0x80, 0x4F, 0xBF, 0xA2, 0xAC, 0x18, 0x6B, 0xD5, 0xB2, 0x42,
 181     0x0F, 0xDA, 0x28, 0x40, 0x93, 0x40, 0xB2, 0x1E, 0x80, 0xB0, 0x6C, 0xDE,
 182     0x9C, 0x54, 0xA4, 0xB4, 0x68, 0x29, 0xE0, 0x13, 0x57, 0x1D, 0xC9, 0x87,
 183     0xC0, 0xDE, 0x2F, 0x1D, 0x72, 0xF0, 0xC0, 0xE4, 0x4E, 0x04, 0x48, 0xF5,
 184     0x2D, 0x8D, 0x9A, 0x1B, 0xE5, 0xEB, 0x06, 0xAB, 0x7C, 0x74, 0x10, 0x3C,
 185     0xA8, 0x2D, 0x39, 0xBC, 0xE3, 0x15, 0x3E, 0x63, 0x37, 0x8C, 0x1B, 0xF1,
 186     0xB3, 0x99, 0xB6, 0xAE, 0x5A, 0xEB, 0xB3, 0x3D, 0x30, 0x39, 0x69, 0xDB,
 187     0xF2, 0x4F, 0x94, 0xB7, 0x71, 0xAF, 0xBA, 0x5C, 0x1F, 0xF8, 0x6B, 0xE5,
 188     0xD1, 0xB1, 0x00, 0x81, 0xE2, 0x6D, 0xEC, 0x65, 0xF7, 0x7E, 0xCE, 0x03,
 189     0x84, 0x68, 0x42, 0x6A, 0x8B, 0x47, 0x8E, 0x4A, 0x88, 0xDE, 0x82, 0xDD,
 190     0xAF, 0xA9, 0x6F, 0x18, 0xF7, 0xC6, 0xE2, 0xB9, 0x97, 0xCE, 0x47, 0x8F,
 191     0x85, 0x19, 0x61, 0x42, 0x67, 0x21, 0x7D, 0x13, 0x6E, 0xB5, 0x5A, 0x62,
 192     0xF3, 0x08, 0xE2, 0x70, 0x3B, 0x0E, 0x85, 0x3C, 0xA1, 0xD3, 0xED, 0x7A,
 193     0x43, 0xD6, 0xDE, 0x30, 0x5C, 0x48, 0xB2, 0x99, 0xAB, 0x3E, 0x65, 0xA6,
 194     0x66, 0x80, 0x22, 0xFF, 0x92, 0xC1, 0x42, 0x1C, 0x30, 0x87, 0x74, 0x1E,
 195     0x53, 0x57, 0x7C, 0xF8, 0x77, 0x51, 0xF1, 0x74, 0x16, 0xF4, 0x45, 0x26,
 196     0x77, 0x0A, 0x05, 0x96, 0x13, 0x12, 0x06, 0x86, 0x2B, 0xB8, 0x49, 0x82,
 197     0x69, 0x43, 0x0A, 0x57, 0xA7, 0x30, 0x19, 0x4C, 0xB8, 0x47, 0x82, 0x6E,
 198     0x64, 0x7A, 0x06, 0x13, 0x5A, 0x82, 0x98, 0xD6, 0x7A, 0x09, 0xEC, 0x03,
 199     0x8D, 0x03
 200 };
 201 #endif /* OPENSSL_NO_DH */
 202
 203 #ifndef OPENSSL_NO_EC
 204 /*
 205  * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
 206  * structure.
 207  */
 208 static const unsigned char kExampleECKeyDER[] = {
 209     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
 210     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
 211     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
 212     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 213     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
 214     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
 215     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
 216     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
 217     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
 218     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
 219     0xc1,
 220 };
 221
 222 /* P-384 sample EC private key in PKCS8 format (no public key) */
 223 static const unsigned char kExampleECKey2DER[] = {
 224     0x30, 0x4E, 0x02, 0x01, 0x00, 0x30, 0x10, 0x06, 0x07, 0x2A, 0x86, 0x48,
 225     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22, 0x04,
 226     0x37, 0x30, 0x35, 0x02, 0x01, 0x01, 0x04, 0x30, 0x73, 0xE3, 0x3A, 0x05,
 227     0xF2, 0xB6, 0x99, 0x6D, 0x0C, 0x33, 0x7F, 0x15, 0x9E, 0x10, 0xA9, 0x17,
 228     0x4C, 0x0A, 0x82, 0x57, 0x71, 0x13, 0x7A, 0xAC, 0x46, 0xA2, 0x5E, 0x1C,
 229     0xE0, 0xC7, 0xB2, 0xF8, 0x20, 0x40, 0xC2, 0x27, 0xC8, 0xBE, 0x02, 0x7E,
 230     0x96, 0x69, 0xE0, 0x04, 0xCB, 0x89, 0x0B, 0x42
 231 };
 232
 233 static const unsigned char kExampleECXKey2DER[] = {
 234     0x30, 0x2E, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e,
 235     0x04, 0x22, 0x04, 0x20, 0xc8, 0xa9, 0xd5, 0xa9, 0x10, 0x91, 0xad, 0x85,
 236     0x1c, 0x66, 0x8b, 0x07, 0x36, 0xc1, 0xc9, 0xa0, 0x29, 0x36, 0xc0, 0xd3,
 237     0xad, 0x62, 0x67, 0x08, 0x58, 0x08, 0x80, 0x47, 0xba, 0x05, 0x74, 0x75
 238 };
 239 #endif
 240
 241 typedef struct APK_DATA_st {
 242     const unsigned char *kder;
 243     size_t size;
 244     int evptype;
 245 } APK_DATA;
 246
 247 static APK_DATA keydata[] = {
 248     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
 249     {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
 250 #ifndef OPENSSL_NO_EC
 251     {kExampleECXKey2DER, sizeof(kExampleECXKey2DER), EVP_PKEY_X25519},
 252     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC},
 253     {kExampleECKey2DER, sizeof(kExampleECKey2DER), EVP_PKEY_EC},
 254 #endif
 255 #ifndef OPENSSL_NO_DH
 256     {kExampleDHPrivateKeyDER, sizeof(kExampleDHPrivateKeyDER), EVP_PKEY_DH},
 257 #endif
 258 };
 259
 260 static int pkey_has_private(EVP_PKEY *key, const char *privtag,
 261                             int use_octstring)
 262 {
 263     int ret = 0;
 264
 265     if (use_octstring) {
 266         unsigned char buf[64];
 267
 268         ret = EVP_PKEY_get_octet_string_param(key, privtag, buf, sizeof(buf),
 269                                               NULL);
 270     } else {
 271         BIGNUM *bn = NULL;
 272
 273         ret = EVP_PKEY_get_bn_param(key, privtag, &bn);
 274         BN_free(bn);
 275     }
 276     return ret;
 277 }
 278
 279 static int do_pkey_tofrom_data_select(EVP_PKEY *key, const char *keytype)
 280 {
 281     int ret = 0;
 282     OSSL_PARAM *pub_params = NULL, *keypair_params = NULL;
 283     EVP_PKEY *fromkey = NULL, *fromkeypair = NULL;
 284     EVP_PKEY_CTX *fromctx = NULL;
 285     const char *privtag = strcmp(keytype, "RSA") == 0 ? "d" : "priv";
 286     const int use_octstring = strcmp(keytype, "X25519") == 0;
 287
 288     /*
 289      * Select only the public key component when using EVP_PKEY_todata() and
 290      * check that the resulting param array does not contain a private key.
 291      */
 292     if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_PUBLIC_KEY, &pub_params), 1)
 293         || !TEST_ptr_null(OSSL_PARAM_locate(pub_params, privtag)))
 294         goto end;
 295     /*
 296      * Select the keypair when using EVP_PKEY_todata() and check that
 297      * the param array contains a private key.
 298      */
 299     if (!TEST_int_eq(EVP_PKEY_todata(key, EVP_PKEY_KEYPAIR, &keypair_params), 1)
 300         || !TEST_ptr(OSSL_PARAM_locate(keypair_params, privtag)))
 301         goto end;
 302
 303     /*
 304      * Select only the public key when using EVP_PKEY_fromdata() and check that
 305      * the resulting key does not contain a private key.
 306      */
 307     if (!TEST_ptr(fromctx = EVP_PKEY_CTX_new_from_name(mainctx, keytype, NULL))
 308         || !TEST_int_eq(EVP_PKEY_fromdata_init(fromctx), 1)
 309         || !TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkey, EVP_PKEY_PUBLIC_KEY,
 310                                           keypair_params), 1)
 311         || !TEST_false(pkey_has_private(fromkey, privtag, use_octstring)))
 312         goto end;
 313     /*
 314      * Select the keypair when using EVP_PKEY_fromdata() and check that
 315      * the resulting key contains a private key.
 316      */
 317     if (!TEST_int_eq(EVP_PKEY_fromdata(fromctx, &fromkeypair,
 318                                        EVP_PKEY_KEYPAIR, keypair_params), 1)
 319         || !TEST_true(pkey_has_private(fromkeypair, privtag, use_octstring)))
 320         goto end;
 321     ret = 1;
 322 end:
 323     EVP_PKEY_free(fromkeypair);
 324     EVP_PKEY_free(fromkey);
 325     EVP_PKEY_CTX_free(fromctx);
 326     OSSL_PARAM_free(keypair_params);
 327     OSSL_PARAM_free(pub_params);
 328     return ret;
 329 }
 330
 331 #ifndef OPENSSL_NO_DH
 332 static int test_dh_tofrom_data_select(void)
 333 {
 334     int ret;
 335     OSSL_PARAM params[2];
 336     EVP_PKEY *key = NULL;
 337     EVP_PKEY_CTX *gctx = NULL;
 338 # ifndef OPENSSL_NO_DEPRECATED_3_0
 339     const DH *dhkey;
 340     const BIGNUM *privkey;
 341 # endif
 342
 343     params[0] = OSSL_PARAM_construct_utf8_string("group", "ffdhe2048", 0);
 344     params[1] = OSSL_PARAM_construct_end();
 345     ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DHX", NULL))
 346           && TEST_int_gt(EVP_PKEY_keygen_init(gctx), 0)
 347           && TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
 348           && TEST_int_gt(EVP_PKEY_generate(gctx, &key), 0)
 349           && TEST_true(do_pkey_tofrom_data_select(key, "DHX"));
 350 # ifndef OPENSSL_NO_DEPRECATED_3_0
 351     ret = ret && TEST_ptr(dhkey = EVP_PKEY_get0_DH(key))
 352               && TEST_ptr(privkey = DH_get0_priv_key(dhkey))
 353               && TEST_int_le(BN_num_bits(privkey), 225);
 354 # endif
 355     EVP_PKEY_free(key);
 356     EVP_PKEY_CTX_free(gctx);
 357     return ret;
 358 }
 359
 360 static int test_dh_paramgen(void)
 361 {
 362     int ret;
 363     OSSL_PARAM params[3];
 364     EVP_PKEY *pkey = NULL;
 365     EVP_PKEY_CTX *gctx = NULL;
 366     unsigned int pbits = 512; /* minimum allowed for speed */
 367
 368     params[0] = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
 369     params[1] = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE,
 370                                                  "generator", 0);
 371     params[2] = OSSL_PARAM_construct_end();
 372
 373     ret = TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(mainctx, "DH", NULL))
 374           && TEST_int_gt(EVP_PKEY_paramgen_init(gctx), 0)
 375           && TEST_true(EVP_PKEY_CTX_set_params(gctx, params))
 376           && TEST_true(EVP_PKEY_paramgen(gctx, &pkey))
 377           && TEST_ptr(pkey);
 378
 379     EVP_PKEY_CTX_free(gctx);
 380     gctx = NULL;
 381
 382     ret = ret && TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
 383               && TEST_int_eq(EVP_PKEY_param_check(gctx), 1)
 384               && TEST_int_eq(EVP_PKEY_param_check_quick(gctx), 1);
 385
 386     EVP_PKEY_CTX_free(gctx);
 387     EVP_PKEY_free(pkey);
 388     return ret;
 389 }
 390
 391 static int set_fromdata_string(EVP_PKEY_CTX *ctx, const char *name, char *value)
 392 {
 393     int ret;
 394     OSSL_PARAM params[2];
 395     EVP_PKEY *pkey = NULL;
 396
 397     if (EVP_PKEY_fromdata_init(ctx) != 1)
 398         return -1;
 399     params[0] = OSSL_PARAM_construct_utf8_string(name, value, 0);
 400     params[1] = OSSL_PARAM_construct_end();
 401     ret = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params);
 402     EVP_PKEY_free(pkey);
 403     return ret;
 404 }
 405
 406 static int set_fromdata_uint(EVP_PKEY_CTX *ctx, const char *name)
 407 {
 408     int ret;
 409     unsigned int tmp = 0;
 410     OSSL_PARAM params[2];
 411     EVP_PKEY *pkey = NULL;
 412
 413     if (EVP_PKEY_fromdata_init(ctx) != 1)
 414         return -1;
 415     params[0] = OSSL_PARAM_construct_uint(name, &tmp);
 416     params[1] = OSSL_PARAM_construct_end();
 417     ret = EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params);
 418     EVP_PKEY_free(pkey);
 419     return ret;
 420 }
 421
 422 static int test_dh_paramfromdata(void)
 423 {
 424     EVP_PKEY_CTX *ctx = NULL;
 425     int ret = 0;
 426
 427     /* Test failure paths for FFC - mainly due to setting the wrong param type */
 428     ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DH", NULL))
 429           && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_GROUP_NAME), 0)
 430           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_GROUP_NAME, "bad"), 0)
 431           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_P, "bad"), 0)
 432           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_GINDEX, "bad"), 0)
 433           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_PCOUNTER, "bad"), 0)
 434           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_COFACTOR, "bad"), 0)
 435           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_H, "bad"), 0)
 436           && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_FFC_SEED), 0)
 437           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, "bad"), 0)
 438           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_G, "bad"), 0)
 439           && TEST_int_eq(set_fromdata_string(ctx, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, "bad"), 0)
 440           && TEST_int_eq(set_fromdata_uint(ctx, OSSL_PKEY_PARAM_FFC_DIGEST), 0);
 441
 442     EVP_PKEY_CTX_free(ctx);
 443     return ret;
 444 }
 445
 446 #endif
 447
 448 #ifndef OPENSSL_NO_EC
 449
 450 static int test_ec_d2i_i2d_pubkey(void)
 451 {
 452     int ret = 0;
 453     FILE *fp = NULL;
 454     EVP_PKEY *key = NULL, *outkey = NULL;
 455     static const char *filename = "pubkey.der";
 456
 457     if (!TEST_ptr(fp = fopen(filename, "wb"))
 458         || !TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
 459         || !TEST_true(i2d_PUBKEY_fp(fp, key))
 460         || !TEST_int_eq(fclose(fp), 0))
 461         goto err;
 462     fp = NULL;
 463
 464     if (!TEST_ptr(fp = fopen(filename, "rb"))
 465         || !TEST_ptr(outkey = d2i_PUBKEY_ex_fp(fp, NULL, mainctx, NULL))
 466         || !TEST_int_eq(EVP_PKEY_eq(key, outkey), 1))
 467         goto err;
 468
 469     ret = 1;
 470
 471 err:
 472     EVP_PKEY_free(outkey);
 473     EVP_PKEY_free(key);
 474     fclose(fp);
 475     return ret;
 476 }
 477
 478 static int test_ec_tofrom_data_select(void)
 479 {
 480     int ret;
 481     EVP_PKEY *key = NULL;
 482
 483     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
 484           && TEST_true(do_pkey_tofrom_data_select(key, "EC"));
 485     EVP_PKEY_free(key);
 486     return ret;
 487 }
 488
 489 static int test_ecx_tofrom_data_select(void)
 490 {
 491     int ret;
 492     EVP_PKEY *key = NULL;
 493
 494     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "X25519"))
 495           && TEST_true(do_pkey_tofrom_data_select(key, "X25519"));
 496     EVP_PKEY_free(key);
 497     return ret;
 498 }
 499 #endif
 500
 501 #ifndef OPENSSL_NO_SM2
 502 static int test_sm2_tofrom_data_select(void)
 503 {
 504     int ret;
 505     EVP_PKEY *key = NULL;
 506
 507     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "SM2"))
 508           && TEST_true(do_pkey_tofrom_data_select(key, "SM2"));
 509     EVP_PKEY_free(key);
 510     return ret;
 511 }
 512 #endif
 513
 514 static int test_rsa_tofrom_data_select(void)
 515 {
 516     int ret;
 517     EVP_PKEY *key = NULL;
 518     const unsigned char *pdata = kExampleRSAKeyDER;
 519     int pdata_len = sizeof(kExampleRSAKeyDER);
 520
 521     ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
 522                                                mainctx, NULL))
 523           && TEST_true(do_pkey_tofrom_data_select(key, "RSA"));
 524     EVP_PKEY_free(key);
 525     return ret;
 526 }
 527
 528 /* This is the equivalent of test_d2i_AutoPrivateKey in evp_extra_test */
 529 static int test_d2i_AutoPrivateKey_ex(int i)
 530 {
 531     int ret = 0;
 532     const unsigned char *p;
 533     EVP_PKEY *pkey = NULL;
 534     const APK_DATA *ak = &keydata[i];
 535     const unsigned char *input = ak->kder;
 536     size_t input_len = ak->size;
 537     int expected_id = ak->evptype;
 538     BIGNUM *p_bn = NULL;
 539     BIGNUM *g_bn = NULL;
 540     BIGNUM *priv_bn = NULL;
 541
 542     p = input;
 543     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &p, input_len, mainctx,
 544                                                NULL))
 545             || !TEST_ptr_eq(p, input + input_len)
 546             || !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
 547         goto done;
 548
 549     if (ak->evptype == EVP_PKEY_RSA) {
 550         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_D,
 551                                              &priv_bn)))
 552             goto done;
 553     } else if (ak->evptype == EVP_PKEY_X25519) {
 554         unsigned char buffer[32];
 555         size_t len;
 556
 557         if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey,
 558                                                        OSSL_PKEY_PARAM_PRIV_KEY,
 559                                                        buffer, sizeof(buffer),
 560                                                        &len)))
 561             goto done;
 562     } else {
 563         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
 564                                              &priv_bn)))
 565             goto done;
 566     }
 567
 568     if (ak->evptype == EVP_PKEY_DH) {
 569         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_P, &p_bn))
 570             || !TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_G,
 571                                                 &g_bn)))
 572             goto done;
 573     }
 574
 575     ret = 1;
 576 done:
 577     BN_free(p_bn);
 578     BN_free(g_bn);
 579     BN_free(priv_bn);
 580     EVP_PKEY_free(pkey);
 581     return ret;
 582 }
 583
 584 #ifndef OPENSSL_NO_DES
 585 static int test_pkcs8key_nid_bio(void)
 586 {
 587     int ret;
 588     const int nid = NID_pbe_WithSHA1And3_Key_TripleDES_CBC;
 589     static const char pwd[] = "PASSWORD";
 590     EVP_PKEY *pkey = NULL, *pkey_dec = NULL;
 591     BIO *in = NULL, *enc_bio = NULL;
 592     char *enc_data = NULL;
 593     long enc_datalen = 0;
 594     OSSL_PROVIDER *provider = NULL;
 595
 596     ret = TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
 597           && TEST_ptr(enc_bio = BIO_new(BIO_s_mem()))
 598           && TEST_ptr(in = BIO_new_mem_buf(kExampleRSAKeyPKCS8,
 599                                            sizeof(kExampleRSAKeyPKCS8)))
 600           && TEST_ptr(pkey = d2i_PrivateKey_ex_bio(in, NULL, NULL, NULL))
 601           && TEST_int_eq(i2d_PKCS8PrivateKey_nid_bio(enc_bio, pkey, nid,
 602                                                      pwd, sizeof(pwd) - 1,
 603                                                      NULL, NULL), 1)
 604           && TEST_int_gt(enc_datalen = BIO_get_mem_data(enc_bio, &enc_data), 0)
 605           && TEST_ptr(pkey_dec = d2i_PKCS8PrivateKey_bio(enc_bio, NULL, NULL,
 606                                                          (void *)pwd))
 607           && TEST_true(EVP_PKEY_eq(pkey, pkey_dec));
 608
 609     EVP_PKEY_free(pkey_dec);
 610     EVP_PKEY_free(pkey);
 611     BIO_free(in);
 612     BIO_free(enc_bio);
 613     OSSL_PROVIDER_unload(provider);
 614     return ret;
 615 }
 616 #endif /* OPENSSL_NO_DES */
 617
 618 static int test_alternative_default(void)
 619 {
 620     OSSL_LIB_CTX *oldctx;
 621     EVP_MD *sha256;
 622     int ok = 0;
 623
 624     /*
 625      * setup_tests() loaded the "null" provider in the current default, so
 626      * we know this fetch should fail.
 627      */
 628     if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 629         goto err;
 630
 631     /*
 632      * Now we switch to our main library context, and try again.  Since no
 633      * providers are loaded in this one, it should fall back to the default.
 634      */
 635     if (!TEST_ptr(oldctx = OSSL_LIB_CTX_set0_default(mainctx))
 636         || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 637         goto err;
 638     EVP_MD_free(sha256);
 639     sha256 = NULL;
 640
 641     /*
 642      * Switching back should give us our main library context back, and
 643      * fetching SHA2-256 should fail again.
 644      */
 645     if (!TEST_ptr_eq(OSSL_LIB_CTX_set0_default(oldctx), mainctx)
 646         || !TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 647         goto err;
 648
 649     ok = 1;
 650  err:
 651     EVP_MD_free(sha256);
 652     return ok;
 653 }
 654
 655 static int test_provider_unload_effective(int testid)
 656 {
 657     EVP_MD *sha256 = NULL;
 658     OSSL_PROVIDER *provider = NULL;
 659     int ok = 0;
 660
 661     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
 662         || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 663         goto err;
 664
 665     if (testid > 0) {
 666         OSSL_PROVIDER_unload(provider);
 667         provider = NULL;
 668         EVP_MD_free(sha256);
 669         sha256 = NULL;
 670     } else {
 671         EVP_MD_free(sha256);
 672         sha256 = NULL;
 673         OSSL_PROVIDER_unload(provider);
 674         provider = NULL;
 675     }
 676
 677     /*
 678      * setup_tests() loaded the "null" provider in the current default, and
 679      * we unloaded it above after the load so we know this fetch should fail.
 680      */
 681     if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 682         goto err;
 683
 684     ok = 1;
 685  err:
 686     EVP_MD_free(sha256);
 687     OSSL_PROVIDER_unload(provider);
 688     return ok;
 689 }
 690
 691 static int test_d2i_PrivateKey_ex(int testid)
 692 {
 693     int ok = 0;
 694     OSSL_PROVIDER *provider = NULL;
 695     BIO *key_bio = NULL;
 696     EVP_PKEY *pkey = NULL;
 697     int id = (testid == 0) ? 0 : 2;
 698
 699     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
 700         goto err;
 701     if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[id].kder, keydata[id].size)))
 702         goto err;
 703     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
 704         goto err;
 705
 706     ERR_clear_error();
 707     if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
 708         goto err;
 709     ok = TEST_ptr(pkey = d2i_PrivateKey_bio(key_bio, NULL));
 710     TEST_int_eq(ERR_peek_error(), 0);
 711     test_openssl_errors();
 712
 713  err:
 714     EVP_PKEY_free(pkey);
 715     BIO_free(key_bio);
 716     OSSL_PROVIDER_unload(provider);
 717
 718     return ok;
 719 }
 720
 721 static int test_PEM_read_bio_negative(int testid)
 722 {
 723     int ok = 0;
 724     OSSL_PROVIDER *provider = NULL;
 725     BIO *key_bio = NULL;
 726     EVP_PKEY *pkey = NULL;
 727
 728     if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[testid].kder, keydata[testid].size)))
 729         goto err;
 730     ERR_clear_error();
 731     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
 732         goto err;
 733     if (!TEST_int_ne(ERR_peek_error(), 0))
 734         goto err;
 735     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
 736         goto err;
 737     if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
 738         goto err;
 739     ERR_clear_error();
 740     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
 741         goto err;
 742     if (!TEST_int_ne(ERR_peek_error(), 0))
 743         goto err;
 744
 745     ok = 1;
 746
 747  err:
 748     test_openssl_errors();
 749     EVP_PKEY_free(pkey);
 750     BIO_free(key_bio);
 751     OSSL_PROVIDER_unload(provider);
 752
 753     return ok;
 754 }
 755
 756 static int do_fromdata_key_is_equal(const OSSL_PARAM params[],
 757                                     const EVP_PKEY *expected, const char *type)
 758 {
 759     EVP_PKEY_CTX *ctx = NULL;
 760     EVP_PKEY *pkey = NULL;
 761     int ret;
 762
 763     ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, type, NULL))
 764           && TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
 765           && TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey,
 766                                            EVP_PKEY_KEYPAIR,
 767                                            (OSSL_PARAM *)params), 1)
 768           && TEST_true(EVP_PKEY_eq(pkey, expected));
 769     EVP_PKEY_CTX_free(ctx);
 770     EVP_PKEY_free(pkey);
 771     return ret;
 772 }
 773
 774 #ifndef OPENSSL_NO_DSA
 775 /*
 776  * This data was generated using:
 777  * > openssl genpkey \
 778  *   -genparam -algorithm DSA -pkeyopt type:fips186_4 -text \
 779  *   -pkeyopt gindex:5 -out dsa_param.pem
 780  * > openssl genpkey \
 781  *   -paramfile dsa_param.pem -pkeyopt type:fips186_4 -out dsa_priv.pem
 782  */
 783 static const unsigned char dsa_key[] = {
 784     0x30, 0x82, 0x03, 0x4e, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
 785     0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66,
 786     0x17, 0xda, 0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21,
 787     0x3d, 0x85, 0xa3, 0x4a, 0xf0, 0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37,
 788     0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1, 0xf6, 0xc4, 0x42, 0x23,
 789     0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6, 0xe8,
 790     0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b,
 791     0xa8, 0xad, 0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21,
 792     0x55, 0x22, 0xce, 0xa2, 0xe9, 0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03,
 793     0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a, 0x07, 0x80, 0xfc, 0x4e,
 794     0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22, 0x55,
 795     0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2,
 796     0x62, 0x12, 0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec,
 797     0x70, 0xce, 0x0f, 0x8c, 0xff, 0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32,
 798     0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb, 0x28, 0xe2, 0xc1, 0x1a,
 799     0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa, 0x69,
 800     0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44,
 801     0xfb, 0x9a, 0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12,
 802     0x79, 0xbd, 0xa0, 0x70, 0x47, 0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07,
 803     0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f, 0x1a, 0xd1, 0xa2, 0x96,
 804     0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c, 0x40,
 805     0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c,
 806     0x5d, 0xbe, 0xfd, 0x1b, 0x02, 0x1d, 0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02,
 807     0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73, 0xf3, 0x7d, 0x31,
 808     0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31, 0x02,
 809     0x82, 0x01, 0x01, 0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5,
 810     0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c, 0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47,
 811     0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3, 0xd4, 0xd2, 0xe3,
 812     0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
 813     0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c,
 814     0x2a, 0x04, 0x7c, 0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2,
 815     0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb, 0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63,
 816     0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2, 0x5b, 0x40, 0x6d,
 817     0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
 818     0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50,
 819     0xd0, 0x44, 0x57, 0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80,
 820     0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a, 0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37,
 821     0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28, 0x05, 0xb5, 0xd8,
 822     0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
 823     0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97,
 824     0xb7, 0xeb, 0x67, 0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9,
 825     0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1, 0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12,
 826     0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e, 0x28, 0xa9, 0xfc,
 827     0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
 828     0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01,
 829     0x56, 0xfb, 0x78, 0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7,
 830     0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01, 0x9f, 0x34, 0x02, 0x82, 0x01, 0x00,
 831     0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30,
 832     0xeb, 0x8e, 0x44, 0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38,
 833     0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8, 0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2,
 834     0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52, 0x50, 0x15, 0x9c,
 835     0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
 836     0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3,
 837     0xd9, 0xd4, 0x66, 0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f,
 838     0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b, 0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e,
 839     0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27, 0xb7, 0x5f, 0x65,
 840     0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
 841     0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41,
 842     0xaf, 0x88, 0x23, 0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d,
 843     0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63, 0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07,
 844     0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7, 0x86, 0x99, 0x29,
 845     0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
 846     0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee,
 847     0x6b, 0x11, 0xdd, 0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f,
 848     0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55, 0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d,
 849     0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5, 0x47, 0xa9, 0xb5,
 850     0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
 851     0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf,
 852     0x07, 0x48, 0x45, 0xfd, 0x02, 0x1c, 0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b,
 853     0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3, 0x43, 0xb8, 0xa4,
 854     0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21,
 855 };
 856 static const unsigned char dsa_p[] = {
 857     0x00, 0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66, 0x17, 0xda,
 858     0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21, 0x3d, 0x85, 0xa3, 0x4a, 0xf0,
 859     0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37, 0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1,
 860     0xf6, 0xc4, 0x42, 0x23, 0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6,
 861     0xe8, 0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b, 0xa8, 0xad,
 862     0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21, 0x55, 0x22, 0xce, 0xa2, 0xe9,
 863     0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03, 0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a,
 864     0x07, 0x80, 0xfc, 0x4e, 0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22,
 865     0x55, 0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2, 0x62, 0x12,
 866     0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec, 0x70, 0xce, 0x0f, 0x8c, 0xff,
 867     0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32, 0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb,
 868     0x28, 0xe2, 0xc1, 0x1a, 0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa,
 869     0x69, 0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44, 0xfb, 0x9a,
 870     0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12, 0x79, 0xbd, 0xa0, 0x70, 0x47,
 871     0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07, 0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f,
 872     0x1a, 0xd1, 0xa2, 0x96, 0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c,
 873     0x40, 0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c, 0x5d, 0xbe,
 874     0xfd, 0x1b
 875 };
 876 static const unsigned char dsa_q[] = {
 877     0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02, 0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73,
 878     0xf3, 0x7d, 0x31, 0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31
 879 };
 880 static const unsigned char dsa_g[] = {
 881     0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5, 0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c,
 882     0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47, 0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3,
 883     0xd4, 0xd2, 0xe3, 0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
 884     0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c, 0x2a, 0x04, 0x7c,
 885     0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2, 0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb,
 886     0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63, 0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2,
 887     0x5b, 0x40, 0x6d, 0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
 888     0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50, 0xd0, 0x44, 0x57,
 889     0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80, 0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a,
 890     0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37, 0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28,
 891     0x05, 0xb5, 0xd8, 0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
 892     0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97, 0xb7, 0xeb, 0x67,
 893     0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9, 0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1,
 894     0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12, 0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e,
 895     0x28, 0xa9, 0xfc, 0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
 896     0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01, 0x56, 0xfb, 0x78,
 897     0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7, 0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01,
 898     0x9f, 0x34
 899 };
 900 static const unsigned char dsa_priv[] = {
 901     0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b, 0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3,
 902     0x43, 0xb8, 0xa4, 0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21
 903 };
 904 static const unsigned char dsa_pub[] = {
 905     0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30, 0xeb, 0x8e, 0x44,
 906     0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38, 0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8,
 907     0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2, 0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52,
 908     0x50, 0x15, 0x9c, 0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
 909     0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3, 0xd9, 0xd4, 0x66,
 910     0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f, 0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b,
 911     0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e, 0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27,
 912     0xb7, 0x5f, 0x65, 0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
 913     0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41, 0xaf, 0x88, 0x23,
 914     0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d, 0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63,
 915     0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07, 0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7,
 916     0x86, 0x99, 0x29, 0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
 917     0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee, 0x6b, 0x11, 0xdd,
 918     0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f, 0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55,
 919     0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d, 0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5,
 920     0x47, 0xa9, 0xb5, 0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
 921     0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf, 0x07, 0x48, 0x45,
 922     0xfd
 923 };
 924
 925 static int do_check_params(OSSL_PARAM key_params[], int expected)
 926 {
 927     EVP_PKEY_CTX *gen_ctx = NULL, *check_ctx = NULL;
 928     EVP_PKEY *pkey = NULL;
 929     int ret;
 930
 931     ret = TEST_ptr(gen_ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
 932           && TEST_int_eq(EVP_PKEY_fromdata_init(gen_ctx), 1)
 933           && TEST_int_eq(EVP_PKEY_fromdata(gen_ctx, &pkey,
 934                                            EVP_PKEY_KEYPAIR, key_params), 1)
 935           && TEST_ptr(check_ctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey,
 936                                                         NULL))
 937           && TEST_int_eq(EVP_PKEY_param_check(check_ctx), expected);
 938     EVP_PKEY_CTX_free(check_ctx);
 939     EVP_PKEY_CTX_free(gen_ctx);
 940     EVP_PKEY_free(pkey);
 941     return ret;
 942 }
 943
 944 static int do_check_bn(OSSL_PARAM params[], const char *key,
 945                        const unsigned char *expected, size_t expected_len)
 946 {
 947     OSSL_PARAM *p;
 948     BIGNUM *bn = NULL;
 949     unsigned char buffer[256 + 1];
 950     int ret, len;
 951
 952     ret = TEST_ptr(p = OSSL_PARAM_locate(params, key))
 953           && TEST_true(OSSL_PARAM_get_BN(p, &bn))
 954           && TEST_int_gt(len = BN_bn2binpad(bn, buffer, expected_len), 0)
 955           && TEST_mem_eq(expected, expected_len, buffer, len);
 956     BN_free(bn);
 957     return ret;
 958 }
 959
 960 static int do_check_int(OSSL_PARAM params[], const char *key, int expected)
 961 {
 962     OSSL_PARAM *p;
 963     int val = 0;
 964
 965     return TEST_ptr(p = OSSL_PARAM_locate(params, key))
 966            && TEST_true(OSSL_PARAM_get_int(p, &val))
 967            && TEST_int_eq(val, expected);
 968 }
 969
 970 static int test_dsa_tofrom_data_select(void)
 971 {
 972     int ret;
 973     EVP_PKEY *key = NULL;
 974     const unsigned char *pkeydata = dsa_key;
 975
 976     ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
 977                                                mainctx, NULL))
 978           && TEST_true(do_pkey_tofrom_data_select(key, "DSA"));
 979
 980     EVP_PKEY_free(key);
 981     return ret;
 982 }
 983
 984 static int test_dsa_todata(void)
 985 {
 986     EVP_PKEY *pkey = NULL;
 987     OSSL_PARAM *to_params = NULL, *all_params = NULL;
 988     OSSL_PARAM gen_params[4];
 989     int ret = 0;
 990     const unsigned char *pkeydata = dsa_key;
 991
 992     unsigned char dsa_seed[] = {
 993         0xbc, 0x8a, 0x81, 0x64, 0x9e, 0x9d, 0x63, 0xa7, 0xa3, 0x5d, 0x87, 0xdd,
 994         0x32, 0xf3, 0xc1, 0x9f, 0x18, 0x22, 0xeb, 0x73, 0x63, 0xad, 0x5e, 0x7b,
 995         0x90, 0xc1, 0xe3, 0xe0
 996     };
 997     int dsa_pcounter = 319;
 998     int dsa_gindex = 5;
 999
1000     gen_params[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_FFC_SEED,
1001                                                       (void*)dsa_seed,
1002                                                       sizeof(dsa_seed));
1003     gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
1004                                              &dsa_gindex);
1005     gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
1006                                              &dsa_pcounter);
1007     gen_params[3] = OSSL_PARAM_construct_end();
1008
1009     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
1010                                                mainctx, NULL))
1011         || !TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, &to_params), 1)
1012         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_P, dsa_p, sizeof(dsa_p))
1013         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_Q, dsa_q, sizeof(dsa_q))
1014         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_G, dsa_g, sizeof(dsa_g))
1015         || !do_check_bn(to_params, OSSL_PKEY_PARAM_PUB_KEY, dsa_pub,
1016                         sizeof(dsa_pub))
1017         || !do_check_bn(to_params, OSSL_PKEY_PARAM_PRIV_KEY, dsa_priv,
1018                         sizeof(dsa_priv))
1019         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_GINDEX, -1)
1020         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_PCOUNTER, -1)
1021         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_H, 0)
1022         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, 1)
1023         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_G, 1)
1024         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, 0)
1025         || !TEST_ptr_null(OSSL_PARAM_locate(to_params, OSSL_PKEY_PARAM_FFC_SEED)))
1026         goto err;
1027
1028     if (!do_fromdata_key_is_equal(to_params, pkey, "DSA"))
1029         goto err;
1030
1031     if (!TEST_ptr(all_params = OSSL_PARAM_merge(to_params, gen_params))
1032         || !do_check_params(all_params, 1))
1033         goto err;
1034     gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
1035                                              &dsa_gindex);
1036     gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
1037                                              &dsa_pcounter);
1038     /*
1039      * Check that modifying the shallow copy values used in OSSL_PARAM_merge()
1040      * results in an invalid key. This also verifies that the fips186-4
1041      * validation code is running.
1042      */
1043     dsa_gindex++;
1044     if (!do_check_params(all_params, 0))
1045         goto err;
1046     dsa_gindex--;
1047     dsa_pcounter++;
1048     if (!do_check_params(all_params, 0))
1049         goto err;
1050     dsa_pcounter--;
1051     dsa_seed[0] = 0xb0;
1052     if (!do_check_params(all_params, 0))
1053         goto err;
1054
1055     ret = 1;
1056 err:
1057     EVP_PKEY_free(pkey);
1058     OSSL_PARAM_free(all_params);
1059     OSSL_PARAM_free(to_params);
1060     return ret;
1061 }
1062
1063 /*
1064  * Test that OSSL_PKEY_PARAM_FFC_DIGEST_PROPS is set properly when using fromdata
1065  * This test:
1066  *   checks for failure when the property query is bad (tstid == 0)
1067  *   checks for success when the property query is valid (tstid == 1)
1068  */
1069 static int test_dsa_fromdata_digest_prop(int tstid)
1070 {
1071     EVP_PKEY_CTX *ctx = NULL, *gctx = NULL;
1072     EVP_PKEY *pkey = NULL,  *pkey2 = NULL;
1073     OSSL_PARAM params[4], *p = params;
1074     int ret = 0;
1075     int expected = (tstid == 0 ? 0 : 1);
1076     unsigned int pbits = 512; /* minimum allowed for speed */
1077
1078     *p++ = OSSL_PARAM_construct_uint(OSSL_PKEY_PARAM_FFC_PBITS, &pbits);
1079     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST, "SHA512", 0);
1080     /* Setting a bad prop query here should fail during paramgen - when it tries to do a fetch */
1081     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST_PROPS,
1082                                             tstid == 0 ? "provider=unknown" : "provider=default", 0);
1083     *p++ = OSSL_PARAM_construct_end();
1084
1085     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
1086         || !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
1087         || !TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey, EVP_PKEY_KEY_PARAMETERS, params), 1))
1088         goto err;
1089
1090     if (!TEST_ptr(gctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1091         || !TEST_int_eq(EVP_PKEY_paramgen_init(gctx), 1)
1092         || !TEST_int_eq(EVP_PKEY_paramgen(gctx, &pkey2), expected))
1093         goto err;
1094
1095     ret = 1;
1096 err:
1097     EVP_PKEY_free(pkey2);
1098     EVP_PKEY_free(pkey);
1099     EVP_PKEY_CTX_free(ctx);
1100     EVP_PKEY_CTX_free(gctx);
1101     return ret;
1102 }
1103 #endif /* OPENSSL_NO_DSA */
1104
1105 static int test_pkey_todata_null(void)
1106 {
1107     OSSL_PARAM *params = NULL;
1108     EVP_PKEY *pkey = NULL;
1109     int ret = 0;
1110     const unsigned char *pdata = keydata[0].kder;
1111
1112     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1113                                                 mainctx, NULL))
1114           && TEST_int_eq(EVP_PKEY_todata(NULL, EVP_PKEY_KEYPAIR, &params), 0)
1115           && TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, NULL), 0);
1116     EVP_PKEY_free(pkey);
1117     return ret;
1118 }
1119
1120 static OSSL_CALLBACK test_pkey_export_cb;
1121
1122 static int test_pkey_export_cb(const OSSL_PARAM params[], void *arg)
1123 {
1124     if (arg == NULL)
1125         return 0;
1126     return do_fromdata_key_is_equal(params, (EVP_PKEY *)arg, "RSA");
1127 }
1128
1129 static int test_pkey_export_null(void)
1130 {
1131     EVP_PKEY *pkey = NULL;
1132     int ret = 0;
1133     const unsigned char *pdata = keydata[0].kder;
1134
1135     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1136                                                 mainctx, NULL))
1137           && TEST_int_eq(EVP_PKEY_export(NULL, EVP_PKEY_KEYPAIR,
1138                                          test_pkey_export_cb, NULL), 0)
1139           && TEST_int_eq(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR, NULL, NULL), 0);
1140     EVP_PKEY_free(pkey);
1141     return ret;
1142 }
1143
1144 static int test_pkey_export(void)
1145 {
1146     EVP_PKEY *pkey = NULL;
1147 #ifndef OPENSSL_NO_DEPRECATED_3_0
1148     RSA *rsa = NULL;
1149 #endif
1150     int ret = 1;
1151     const unsigned char *pdata = keydata[0].kder;
1152     int pdata_len = keydata[0].size;
1153
1154     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
1155                                                mainctx, NULL))
1156         || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1157                                        test_pkey_export_cb, pkey))
1158         || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1159                                        test_pkey_export_cb, NULL)))
1160         ret = 0;
1161     EVP_PKEY_free(pkey);
1162
1163 #ifndef OPENSSL_NO_DEPRECATED_3_0
1164     /* Now, try with a legacy key */
1165     pdata = keydata[0].kder;
1166     pdata_len = keydata[0].size;
1167     if (!TEST_ptr(rsa = d2i_RSAPrivateKey(NULL, &pdata, pdata_len))
1168         || !TEST_ptr(pkey = EVP_PKEY_new())
1169         || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa))
1170         || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1171                                       test_pkey_export_cb, pkey))
1172         || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1173                                        test_pkey_export_cb, NULL)))
1174         ret = 0;
1175     EVP_PKEY_free(pkey);
1176 #endif
1177     return ret;
1178 }
1179
1180 static int test_rsa_pss_sign(void)
1181 {
1182     EVP_PKEY *pkey = NULL;
1183     EVP_PKEY_CTX *pctx = NULL;
1184     int ret = 0;
1185     const unsigned char *pdata = keydata[0].kder;
1186     const char *mdname = "SHA2-256";
1187     OSSL_PARAM sig_params[3];
1188     unsigned char mdbuf[256 / 8] = { 0 };
1189     int padding = RSA_PKCS1_PSS_PADDING;
1190     unsigned char *sig = NULL;
1191     size_t sig_len = 0;
1192
1193     sig_params[0] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_PAD_MODE,
1194                                              &padding);
1195     sig_params[1] = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1196                                                      (char *)mdname, 0);
1197     sig_params[2] = OSSL_PARAM_construct_end();
1198
1199     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1200                                                 mainctx, NULL))
1201           && TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1202           && TEST_int_gt(EVP_PKEY_sign_init_ex(pctx, sig_params), 0)
1203           && TEST_int_gt(EVP_PKEY_sign(pctx, NULL, &sig_len, mdbuf,
1204                                        sizeof(mdbuf)), 0)
1205           && TEST_int_gt(sig_len, 0)
1206           && TEST_ptr(sig = OPENSSL_malloc(sig_len))
1207           && TEST_int_gt(EVP_PKEY_sign(pctx, sig, &sig_len, mdbuf,
1208                                        sizeof(mdbuf)), 0);
1209
1210     EVP_PKEY_CTX_free(pctx);
1211     OPENSSL_free(sig);
1212     EVP_PKEY_free(pkey);
1213
1214     return ret;
1215 }
1216
1217 static int test_evp_md_ctx_dup(void)
1218 {
1219     EVP_MD_CTX *mdctx;
1220     EVP_MD_CTX *copyctx = NULL;
1221     int ret;
1222
1223     /* test copying freshly initialized context */
1224     ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1225           && TEST_ptr(copyctx = EVP_MD_CTX_dup(mdctx));
1226
1227     EVP_MD_CTX_free(mdctx);
1228     EVP_MD_CTX_free(copyctx);
1229     return ret;
1230 }
1231
1232 static int test_evp_md_ctx_copy(void)
1233 {
1234     EVP_MD_CTX *mdctx = NULL;
1235     EVP_MD_CTX *copyctx = NULL;
1236     int ret;
1237
1238     /* test copying freshly initialized context */
1239     ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1240           && TEST_ptr(copyctx = EVP_MD_CTX_new())
1241           && TEST_true(EVP_MD_CTX_copy_ex(copyctx, mdctx));
1242
1243     EVP_MD_CTX_free(mdctx);
1244     EVP_MD_CTX_free(copyctx);
1245     return ret;
1246 }
1247
1248 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1249 static int test_evp_pbe_alg_add(void)
1250 {
1251     int ret = 0;
1252     int cipher_nid = 0, md_nid = 0;
1253     EVP_PBE_KEYGEN_EX *keygen_ex = NULL;
1254     EVP_PBE_KEYGEN *keygen = NULL;
1255
1256     if (!TEST_true(EVP_PBE_alg_add(NID_pbeWithMD5AndDES_CBC, EVP_des_cbc(), EVP_md5(),
1257                                    PKCS5_PBE_keyivgen)))
1258         goto err;
1259
1260     if (!TEST_true(EVP_PBE_find_ex(EVP_PBE_TYPE_OUTER, NID_pbeWithMD5AndDES_CBC,
1261                                    &cipher_nid, &md_nid, &keygen, &keygen_ex)))
1262         goto err;
1263
1264     if (!TEST_true(keygen != NULL))
1265         goto err;
1266     if (!TEST_true(keygen_ex == NULL))
1267         goto err;
1268
1269     ret = 1;
1270
1271 err:
1272     return ret;
1273 }
1274 #endif
1275
1276 int setup_tests(void)
1277 {
1278     if (!test_get_libctx(&mainctx, &nullprov, NULL, NULL, NULL)) {
1279         OSSL_LIB_CTX_free(mainctx);
1280         mainctx = NULL;
1281         return 0;
1282     }
1283
1284     ADD_TEST(test_alternative_default);
1285     ADD_ALL_TESTS(test_d2i_AutoPrivateKey_ex, OSSL_NELEM(keydata));
1286 #ifndef OPENSSL_NO_EC
1287     ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 2);
1288     ADD_TEST(test_ec_tofrom_data_select);
1289     ADD_TEST(test_ecx_tofrom_data_select);
1290     ADD_TEST(test_ec_d2i_i2d_pubkey);
1291 #else
1292     ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 1);
1293 #endif
1294 #ifndef OPENSSL_NO_SM2
1295     ADD_TEST(test_sm2_tofrom_data_select);
1296 #endif
1297 #ifndef OPENSSL_NO_DSA
1298     ADD_TEST(test_dsa_todata);
1299     ADD_TEST(test_dsa_tofrom_data_select);
1300     ADD_ALL_TESTS(test_dsa_fromdata_digest_prop, 2);
1301 #endif
1302 #ifndef OPENSSL_NO_DH
1303     ADD_TEST(test_dh_tofrom_data_select);
1304     ADD_TEST(test_dh_paramgen);
1305     ADD_TEST(test_dh_paramfromdata);
1306 #endif
1307     ADD_TEST(test_rsa_tofrom_data_select);
1308
1309     ADD_TEST(test_pkey_todata_null);
1310     ADD_TEST(test_pkey_export_null);
1311     ADD_TEST(test_pkey_export);
1312 #ifndef OPENSSL_NO_DES
1313     ADD_TEST(test_pkcs8key_nid_bio);
1314 #endif
1315     ADD_ALL_TESTS(test_PEM_read_bio_negative, OSSL_NELEM(keydata));
1316     ADD_TEST(test_rsa_pss_sign);
1317     ADD_TEST(test_evp_md_ctx_dup);
1318     ADD_TEST(test_evp_md_ctx_copy);
1319     ADD_ALL_TESTS(test_provider_unload_effective, 2);
1320 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1321     ADD_TEST(test_evp_pbe_alg_add);
1322 #endif
1323     return 1;
1324 }
1325
1326 void cleanup_tests(void)
1327 {
1328     OSSL_LIB_CTX_free(mainctx);
1329     OSSL_PROVIDER_unload(nullprov);
1330 }