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