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 #endif
 391
 392 #ifndef OPENSSL_NO_EC
 393
 394 static int test_ec_d2i_i2d_pubkey(void)
 395 {
 396     int ret = 0;
 397     FILE *fp = NULL;
 398     EVP_PKEY *key = NULL, *outkey = NULL;
 399     static const char *filename = "pubkey.der";
 400
 401     if (!TEST_ptr(fp = fopen(filename, "wb"))
 402         || !TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
 403         || !TEST_true(i2d_PUBKEY_fp(fp, key))
 404         || !TEST_int_eq(fclose(fp), 0))
 405         goto err;
 406     fp = NULL;
 407
 408     if (!TEST_ptr(fp = fopen(filename, "rb"))
 409         || !TEST_ptr(outkey = d2i_PUBKEY_ex_fp(fp, NULL, mainctx, NULL))
 410         || !TEST_int_eq(EVP_PKEY_eq(key, outkey), 1))
 411         goto err;
 412
 413     ret = 1;
 414
 415 err:
 416     EVP_PKEY_free(outkey);
 417     EVP_PKEY_free(key);
 418     fclose(fp);
 419     return ret;
 420 }
 421
 422 static int test_ec_tofrom_data_select(void)
 423 {
 424     int ret;
 425     EVP_PKEY *key = NULL;
 426
 427     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "EC", "P-256"))
 428           && TEST_true(do_pkey_tofrom_data_select(key, "EC"));
 429     EVP_PKEY_free(key);
 430     return ret;
 431 }
 432
 433 static int test_ecx_tofrom_data_select(void)
 434 {
 435     int ret;
 436     EVP_PKEY *key = NULL;
 437
 438     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "X25519"))
 439           && TEST_true(do_pkey_tofrom_data_select(key, "X25519"));
 440     EVP_PKEY_free(key);
 441     return ret;
 442 }
 443 #endif
 444
 445 #ifndef OPENSSL_NO_SM2
 446 static int test_sm2_tofrom_data_select(void)
 447 {
 448     int ret;
 449     EVP_PKEY *key = NULL;
 450
 451     ret = TEST_ptr(key = EVP_PKEY_Q_keygen(mainctx, NULL, "SM2"))
 452           && TEST_true(do_pkey_tofrom_data_select(key, "SM2"));
 453     EVP_PKEY_free(key);
 454     return ret;
 455 }
 456 #endif
 457
 458 static int test_rsa_tofrom_data_select(void)
 459 {
 460     int ret;
 461     EVP_PKEY *key = NULL;
 462     const unsigned char *pdata = kExampleRSAKeyDER;
 463     int pdata_len = sizeof(kExampleRSAKeyDER);
 464
 465     ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
 466                                                mainctx, NULL))
 467           && TEST_true(do_pkey_tofrom_data_select(key, "RSA"));
 468     EVP_PKEY_free(key);
 469     return ret;
 470 }
 471
 472 /* This is the equivalent of test_d2i_AutoPrivateKey in evp_extra_test */
 473 static int test_d2i_AutoPrivateKey_ex(int i)
 474 {
 475     int ret = 0;
 476     const unsigned char *p;
 477     EVP_PKEY *pkey = NULL;
 478     const APK_DATA *ak = &keydata[i];
 479     const unsigned char *input = ak->kder;
 480     size_t input_len = ak->size;
 481     int expected_id = ak->evptype;
 482     BIGNUM *p_bn = NULL;
 483     BIGNUM *g_bn = NULL;
 484     BIGNUM *priv_bn = NULL;
 485
 486     p = input;
 487     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &p, input_len, mainctx,
 488                                                NULL))
 489             || !TEST_ptr_eq(p, input + input_len)
 490             || !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
 491         goto done;
 492
 493     if (ak->evptype == EVP_PKEY_RSA) {
 494         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_D,
 495                                              &priv_bn)))
 496             goto done;
 497     } else if (ak->evptype == EVP_PKEY_X25519) {
 498         unsigned char buffer[32];
 499         size_t len;
 500
 501         if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey,
 502                                                        OSSL_PKEY_PARAM_PRIV_KEY,
 503                                                        buffer, sizeof(buffer),
 504                                                        &len)))
 505             goto done;
 506     } else {
 507         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
 508                                              &priv_bn)))
 509             goto done;
 510     }
 511
 512     if (ak->evptype == EVP_PKEY_DH) {
 513         if (!TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_P, &p_bn))
 514             || !TEST_true(EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_FFC_G,
 515                                                 &g_bn)))
 516             goto done;
 517     }
 518
 519     ret = 1;
 520 done:
 521     BN_free(p_bn);
 522     BN_free(g_bn);
 523     BN_free(priv_bn);
 524     EVP_PKEY_free(pkey);
 525     return ret;
 526 }
 527
 528 #ifndef OPENSSL_NO_DES
 529 static int test_pkcs8key_nid_bio(void)
 530 {
 531     int ret;
 532     const int nid = NID_pbe_WithSHA1And3_Key_TripleDES_CBC;
 533     static const char pwd[] = "PASSWORD";
 534     EVP_PKEY *pkey = NULL, *pkey_dec = NULL;
 535     BIO *in = NULL, *enc_bio = NULL;
 536     char *enc_data = NULL;
 537     long enc_datalen = 0;
 538     OSSL_PROVIDER *provider = NULL;
 539
 540     ret = TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
 541           && TEST_ptr(enc_bio = BIO_new(BIO_s_mem()))
 542           && TEST_ptr(in = BIO_new_mem_buf(kExampleRSAKeyPKCS8,
 543                                            sizeof(kExampleRSAKeyPKCS8)))
 544           && TEST_ptr(pkey = d2i_PrivateKey_ex_bio(in, NULL, NULL, NULL))
 545           && TEST_int_eq(i2d_PKCS8PrivateKey_nid_bio(enc_bio, pkey, nid,
 546                                                      pwd, sizeof(pwd) - 1,
 547                                                      NULL, NULL), 1)
 548           && TEST_int_gt(enc_datalen = BIO_get_mem_data(enc_bio, &enc_data), 0)
 549           && TEST_ptr(pkey_dec = d2i_PKCS8PrivateKey_bio(enc_bio, NULL, NULL,
 550                                                          (void *)pwd))
 551           && TEST_true(EVP_PKEY_eq(pkey, pkey_dec));
 552
 553     EVP_PKEY_free(pkey_dec);
 554     EVP_PKEY_free(pkey);
 555     BIO_free(in);
 556     BIO_free(enc_bio);
 557     OSSL_PROVIDER_unload(provider);
 558     return ret;
 559 }
 560 #endif /* OPENSSL_NO_DES */
 561
 562 static int test_alternative_default(void)
 563 {
 564     OSSL_LIB_CTX *oldctx;
 565     EVP_MD *sha256;
 566     int ok = 0;
 567
 568     /*
 569      * setup_tests() loaded the "null" provider in the current default, so
 570      * we know this fetch should fail.
 571      */
 572     if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 573         goto err;
 574
 575     /*
 576      * Now we switch to our main library context, and try again.  Since no
 577      * providers are loaded in this one, it should fall back to the default.
 578      */
 579     if (!TEST_ptr(oldctx = OSSL_LIB_CTX_set0_default(mainctx))
 580         || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 581         goto err;
 582     EVP_MD_free(sha256);
 583     sha256 = NULL;
 584
 585     /*
 586      * Switching back should give us our main library context back, and
 587      * fetching SHA2-256 should fail again.
 588      */
 589     if (!TEST_ptr_eq(OSSL_LIB_CTX_set0_default(oldctx), mainctx)
 590         || !TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 591         goto err;
 592
 593     ok = 1;
 594  err:
 595     EVP_MD_free(sha256);
 596     return ok;
 597 }
 598
 599 static int test_provider_unload_effective(int testid)
 600 {
 601     EVP_MD *sha256 = NULL;
 602     OSSL_PROVIDER *provider = NULL;
 603     int ok = 0;
 604
 605     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default"))
 606         || !TEST_ptr(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 607         goto err;
 608
 609     if (testid > 0) {
 610         OSSL_PROVIDER_unload(provider);
 611         provider = NULL;
 612         EVP_MD_free(sha256);
 613         sha256 = NULL;
 614     } else {
 615         EVP_MD_free(sha256);
 616         sha256 = NULL;
 617         OSSL_PROVIDER_unload(provider);
 618         provider = NULL;
 619     }
 620
 621     /*
 622      * setup_tests() loaded the "null" provider in the current default, and
 623      * we unloaded it above after the load so we know this fetch should fail.
 624      */
 625     if (!TEST_ptr_null(sha256 = EVP_MD_fetch(NULL, "SHA2-256", NULL)))
 626         goto err;
 627
 628     ok = 1;
 629  err:
 630     EVP_MD_free(sha256);
 631     OSSL_PROVIDER_unload(provider);
 632     return ok;
 633 }
 634
 635 static int test_d2i_PrivateKey_ex(int testid)
 636 {
 637     int ok = 0;
 638     OSSL_PROVIDER *provider = NULL;
 639     BIO *key_bio = NULL;
 640     EVP_PKEY *pkey = NULL;
 641     int id = (testid == 0) ? 0 : 2;
 642
 643     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
 644         goto err;
 645     if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[id].kder, keydata[id].size)))
 646         goto err;
 647     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
 648         goto err;
 649
 650     ERR_clear_error();
 651     if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
 652         goto err;
 653     ok = TEST_ptr(pkey = d2i_PrivateKey_bio(key_bio, NULL));
 654     TEST_int_eq(ERR_peek_error(), 0);
 655     test_openssl_errors();
 656
 657  err:
 658     EVP_PKEY_free(pkey);
 659     BIO_free(key_bio);
 660     OSSL_PROVIDER_unload(provider);
 661
 662     return ok;
 663 }
 664
 665 static int test_PEM_read_bio_negative(int testid)
 666 {
 667     int ok = 0;
 668     OSSL_PROVIDER *provider = NULL;
 669     BIO *key_bio = NULL;
 670     EVP_PKEY *pkey = NULL;
 671
 672     if (!TEST_ptr(key_bio = BIO_new_mem_buf(keydata[testid].kder, keydata[testid].size)))
 673         goto err;
 674     ERR_clear_error();
 675     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
 676         goto err;
 677     if (!TEST_int_ne(ERR_peek_error(), 0))
 678         goto err;
 679     if (!TEST_ptr(provider = OSSL_PROVIDER_load(NULL, "default")))
 680         goto err;
 681     if (!TEST_int_ge(BIO_seek(key_bio, 0), 0))
 682         goto err;
 683     ERR_clear_error();
 684     if (!TEST_ptr_null(pkey = PEM_read_bio_PrivateKey(key_bio, NULL, NULL, NULL)))
 685         goto err;
 686     if (!TEST_int_ne(ERR_peek_error(), 0))
 687         goto err;
 688
 689     ok = 1;
 690
 691  err:
 692     test_openssl_errors();
 693     EVP_PKEY_free(pkey);
 694     BIO_free(key_bio);
 695     OSSL_PROVIDER_unload(provider);
 696
 697     return ok;
 698 }
 699
 700 static int do_fromdata_key_is_equal(const OSSL_PARAM params[],
 701                                     const EVP_PKEY *expected, const char *type)
 702 {
 703     EVP_PKEY_CTX *ctx = NULL;
 704     EVP_PKEY *pkey = NULL;
 705     int ret;
 706
 707     ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(mainctx, type, NULL))
 708           && TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
 709           && TEST_int_eq(EVP_PKEY_fromdata(ctx, &pkey,
 710                                            EVP_PKEY_KEYPAIR,
 711                                            (OSSL_PARAM *)params), 1)
 712           && TEST_true(EVP_PKEY_eq(pkey, expected));
 713     EVP_PKEY_CTX_free(ctx);
 714     EVP_PKEY_free(pkey);
 715     return ret;
 716 }
 717
 718 #ifndef OPENSSL_NO_DSA
 719 /*
 720  * This data was generated using:
 721  * > openssl genpkey \
 722  *   -genparam -algorithm DSA -pkeyopt type:fips186_4 -text \
 723  *   -pkeyopt gindex:5 -out dsa_param.pem
 724  * > openssl genpkey \
 725  *   -paramfile dsa_param.pem -pkeyopt type:fips186_4 -out dsa_priv.pem
 726  */
 727 static const unsigned char dsa_key[] = {
 728     0x30, 0x82, 0x03, 0x4e, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
 729     0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66,
 730     0x17, 0xda, 0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21,
 731     0x3d, 0x85, 0xa3, 0x4a, 0xf0, 0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37,
 732     0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1, 0xf6, 0xc4, 0x42, 0x23,
 733     0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6, 0xe8,
 734     0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b,
 735     0xa8, 0xad, 0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21,
 736     0x55, 0x22, 0xce, 0xa2, 0xe9, 0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03,
 737     0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a, 0x07, 0x80, 0xfc, 0x4e,
 738     0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22, 0x55,
 739     0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2,
 740     0x62, 0x12, 0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec,
 741     0x70, 0xce, 0x0f, 0x8c, 0xff, 0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32,
 742     0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb, 0x28, 0xe2, 0xc1, 0x1a,
 743     0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa, 0x69,
 744     0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44,
 745     0xfb, 0x9a, 0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12,
 746     0x79, 0xbd, 0xa0, 0x70, 0x47, 0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07,
 747     0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f, 0x1a, 0xd1, 0xa2, 0x96,
 748     0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c, 0x40,
 749     0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c,
 750     0x5d, 0xbe, 0xfd, 0x1b, 0x02, 0x1d, 0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02,
 751     0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73, 0xf3, 0x7d, 0x31,
 752     0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31, 0x02,
 753     0x82, 0x01, 0x01, 0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5,
 754     0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c, 0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47,
 755     0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3, 0xd4, 0xd2, 0xe3,
 756     0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
 757     0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c,
 758     0x2a, 0x04, 0x7c, 0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2,
 759     0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb, 0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63,
 760     0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2, 0x5b, 0x40, 0x6d,
 761     0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
 762     0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50,
 763     0xd0, 0x44, 0x57, 0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80,
 764     0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a, 0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37,
 765     0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28, 0x05, 0xb5, 0xd8,
 766     0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
 767     0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97,
 768     0xb7, 0xeb, 0x67, 0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9,
 769     0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1, 0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12,
 770     0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e, 0x28, 0xa9, 0xfc,
 771     0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
 772     0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01,
 773     0x56, 0xfb, 0x78, 0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7,
 774     0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01, 0x9f, 0x34, 0x02, 0x82, 0x01, 0x00,
 775     0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30,
 776     0xeb, 0x8e, 0x44, 0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38,
 777     0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8, 0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2,
 778     0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52, 0x50, 0x15, 0x9c,
 779     0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
 780     0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3,
 781     0xd9, 0xd4, 0x66, 0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f,
 782     0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b, 0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e,
 783     0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27, 0xb7, 0x5f, 0x65,
 784     0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
 785     0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41,
 786     0xaf, 0x88, 0x23, 0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d,
 787     0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63, 0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07,
 788     0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7, 0x86, 0x99, 0x29,
 789     0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
 790     0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee,
 791     0x6b, 0x11, 0xdd, 0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f,
 792     0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55, 0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d,
 793     0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5, 0x47, 0xa9, 0xb5,
 794     0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
 795     0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf,
 796     0x07, 0x48, 0x45, 0xfd, 0x02, 0x1c, 0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b,
 797     0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3, 0x43, 0xb8, 0xa4,
 798     0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21,
 799 };
 800 static const unsigned char dsa_p[] = {
 801     0x00, 0xda, 0xb3, 0x46, 0x4d, 0x54, 0x57, 0xc7, 0xb4, 0x61, 0xa0, 0x6f, 0x66, 0x17, 0xda,
 802     0xeb, 0x90, 0xf0, 0xa3, 0xd1, 0x29, 0xc9, 0x5f, 0xf2, 0x21, 0x3d, 0x85, 0xa3, 0x4a, 0xf0,
 803     0xf8, 0x36, 0x39, 0x1b, 0xe3, 0xee, 0x37, 0x70, 0x06, 0x9b, 0xe8, 0xe3, 0x0a, 0xd2, 0xf1,
 804     0xf6, 0xc4, 0x42, 0x23, 0x1f, 0x74, 0x78, 0xc2, 0x16, 0xf5, 0xce, 0xd6, 0xab, 0xa0, 0xc6,
 805     0xe8, 0x99, 0x3d, 0xf8, 0x8b, 0xfb, 0x47, 0xf8, 0x5e, 0x05, 0x68, 0x6d, 0x8b, 0xa8, 0xad,
 806     0xa1, 0xc2, 0x3a, 0x4e, 0xe0, 0xad, 0xec, 0x38, 0x75, 0x21, 0x55, 0x22, 0xce, 0xa2, 0xe9,
 807     0xe5, 0x3b, 0xd7, 0x44, 0xeb, 0x5a, 0x03, 0x59, 0xa0, 0xc5, 0x7a, 0x92, 0x59, 0x7d, 0x7a,
 808     0x07, 0x80, 0xfc, 0x4e, 0xf8, 0x56, 0x7e, 0xf1, 0x06, 0xe0, 0xba, 0xb2, 0xe7, 0x5b, 0x22,
 809     0x55, 0xee, 0x4b, 0x42, 0x61, 0x67, 0x2c, 0x43, 0x9a, 0x38, 0x2b, 0x17, 0xc2, 0x62, 0x12,
 810     0x8b, 0x0b, 0x22, 0x8c, 0x0c, 0x1c, 0x1c, 0x92, 0xb1, 0xec, 0x70, 0xce, 0x0f, 0x8c, 0xff,
 811     0x8d, 0x21, 0xf9, 0x19, 0x68, 0x4d, 0x32, 0x59, 0x78, 0x42, 0x1d, 0x0c, 0xc5, 0x1a, 0xcb,
 812     0x28, 0xe2, 0xc1, 0x1a, 0x35, 0xf1, 0x42, 0x0a, 0x19, 0x39, 0xfa, 0x83, 0xd1, 0xb4, 0xaa,
 813     0x69, 0x0f, 0xc2, 0x8e, 0xf9, 0x59, 0x2c, 0xee, 0x11, 0xfc, 0x3e, 0x4b, 0x44, 0xfb, 0x9a,
 814     0x32, 0xc8, 0x78, 0x23, 0x56, 0x85, 0x49, 0x21, 0x43, 0x12, 0x79, 0xbd, 0xa0, 0x70, 0x47,
 815     0x2f, 0xae, 0xb6, 0xd7, 0x6c, 0xc6, 0x07, 0x76, 0xa9, 0x8a, 0xa2, 0x16, 0x02, 0x89, 0x1f,
 816     0x1a, 0xd1, 0xa2, 0x96, 0x56, 0xd1, 0x1f, 0x10, 0xe1, 0xe5, 0x9f, 0x3f, 0xdd, 0x09, 0x0c,
 817     0x40, 0x90, 0x71, 0xef, 0x14, 0x41, 0x02, 0x82, 0x3a, 0x6b, 0xe1, 0xf8, 0x2c, 0x5d, 0xbe,
 818     0xfd, 0x1b
 819 };
 820 static const unsigned char dsa_q[] = {
 821     0x00, 0xe0, 0x20, 0xe0, 0x7c, 0x02, 0x16, 0xa7, 0x6c, 0x6a, 0x19, 0xba, 0xd5, 0x83, 0x73,
 822     0xf3, 0x7d, 0x31, 0xef, 0xa7, 0xe1, 0x5d, 0x5b, 0x7f, 0xf3, 0xfc, 0xda, 0x84, 0x31
 823 };
 824 static const unsigned char dsa_g[] = {
 825     0x00, 0x83, 0xdb, 0xa1, 0xbc, 0x3e, 0xc7, 0x29, 0xa5, 0x6a, 0x5c, 0x2c, 0xe8, 0x7a, 0x8c,
 826     0x7e, 0xe8, 0xb8, 0x3e, 0x13, 0x47, 0xcd, 0x36, 0x7e, 0x79, 0x30, 0x7a, 0x28, 0x03, 0xd3,
 827     0xd4, 0xd2, 0xe3, 0xee, 0x3b, 0x46, 0xda, 0xe0, 0x71, 0xe6, 0xcf, 0x46, 0x86, 0x0a, 0x37,
 828     0x57, 0xb6, 0xe9, 0xcf, 0xa1, 0x78, 0x19, 0xb8, 0x72, 0x9f, 0x30, 0x8c, 0x2a, 0x04, 0x7c,
 829     0x2f, 0x0c, 0x27, 0xa7, 0xb3, 0x23, 0xe0, 0x46, 0xf2, 0x75, 0x0c, 0x03, 0x4c, 0xad, 0xfb,
 830     0xc1, 0xcb, 0x28, 0xcd, 0xa0, 0x63, 0xdb, 0x44, 0x88, 0xe0, 0xda, 0x6c, 0x5b, 0x89, 0xb2,
 831     0x5b, 0x40, 0x6d, 0xeb, 0x78, 0x7a, 0xd5, 0xaf, 0x40, 0x52, 0x46, 0x63, 0x92, 0x13, 0x0d,
 832     0xee, 0xee, 0xf9, 0x53, 0xca, 0x2d, 0x4e, 0x3b, 0x13, 0xd8, 0x0f, 0x50, 0xd0, 0x44, 0x57,
 833     0x67, 0x0f, 0x45, 0x8f, 0x21, 0x30, 0x97, 0x9e, 0x80, 0xd9, 0xd0, 0x91, 0xb7, 0xc9, 0x5a,
 834     0x69, 0xda, 0xeb, 0xd5, 0xea, 0x37, 0xf6, 0xb3, 0xbe, 0x1f, 0x24, 0xf1, 0x55, 0x14, 0x28,
 835     0x05, 0xb5, 0xd8, 0x84, 0x0f, 0x62, 0x85, 0xaa, 0xec, 0x77, 0x64, 0xfd, 0x80, 0x7c, 0x41,
 836     0x00, 0x88, 0xa3, 0x79, 0x7d, 0x4f, 0x6f, 0xe3, 0x76, 0xf4, 0xb5, 0x97, 0xb7, 0xeb, 0x67,
 837     0x28, 0xba, 0x07, 0x1a, 0x59, 0x32, 0xc1, 0x53, 0xd9, 0x05, 0x6b, 0x63, 0x93, 0xce, 0xa1,
 838     0xd9, 0x7a, 0xb2, 0xff, 0x1c, 0x12, 0x0a, 0x9a, 0xe5, 0x51, 0x1e, 0xba, 0xfc, 0x95, 0x2e,
 839     0x28, 0xa9, 0xfc, 0x4c, 0xed, 0x7b, 0x05, 0xca, 0x67, 0xe0, 0x2d, 0xd7, 0x54, 0xb3, 0x05,
 840     0x1c, 0x23, 0x2b, 0x35, 0x2e, 0x19, 0x48, 0x59, 0x0e, 0x58, 0xa8, 0x01, 0x56, 0xfb, 0x78,
 841     0x90, 0xba, 0x08, 0x77, 0x94, 0x45, 0x05, 0x13, 0xc7, 0x6b, 0x96, 0xd2, 0xa3, 0xa6, 0x01,
 842     0x9f, 0x34
 843 };
 844 static const unsigned char dsa_priv[] = {
 845     0x2f, 0x68, 0x44, 0xcb, 0xfb, 0x6b, 0xcb, 0x8d, 0x02, 0x49, 0x7c, 0xee, 0xd2, 0xa6, 0xd3,
 846     0x43, 0xb8, 0xa4, 0x09, 0xb7, 0xc1, 0xd4, 0x4b, 0xc3, 0x66, 0xa7, 0xe0, 0x21
 847 };
 848 static const unsigned char dsa_pub[] = {
 849     0x16, 0x1a, 0xb4, 0x6d, 0x9f, 0x16, 0x6c, 0xcc, 0x91, 0x66, 0xfe, 0x30, 0xeb, 0x8e, 0x44,
 850     0xba, 0x2b, 0x7a, 0xc9, 0xa8, 0x95, 0xf2, 0xa6, 0x38, 0xd8, 0xaf, 0x3e, 0x91, 0x68, 0xe8,
 851     0x52, 0xf3, 0x97, 0x37, 0x70, 0xf2, 0x47, 0xa3, 0xf4, 0x62, 0x26, 0xf5, 0x3b, 0x71, 0x52,
 852     0x50, 0x15, 0x9c, 0x6d, 0xa6, 0x6d, 0x92, 0x4c, 0x48, 0x76, 0x31, 0x54, 0x48, 0xa5, 0x99,
 853     0x7a, 0xd4, 0x61, 0xf7, 0x21, 0x44, 0xe7, 0xd8, 0x82, 0xc3, 0x50, 0xd3, 0xd9, 0xd4, 0x66,
 854     0x20, 0xab, 0x70, 0x4c, 0x97, 0x9b, 0x8d, 0xac, 0x1f, 0x78, 0x27, 0x1e, 0x47, 0xf8, 0x3b,
 855     0xd1, 0x55, 0x73, 0xf3, 0xb4, 0x8e, 0x6d, 0x45, 0x40, 0x54, 0xc6, 0xd8, 0x95, 0x15, 0x27,
 856     0xb7, 0x5f, 0x65, 0xaa, 0xcb, 0x24, 0xc9, 0x49, 0x87, 0x32, 0xad, 0xcb, 0xf8, 0x35, 0x63,
 857     0x56, 0x72, 0x7c, 0x4e, 0x6c, 0xad, 0x5f, 0x26, 0x8c, 0xd2, 0x80, 0x41, 0xaf, 0x88, 0x23,
 858     0x20, 0x03, 0xa4, 0xd5, 0x3c, 0x53, 0x54, 0xb0, 0x3d, 0xed, 0x0e, 0x9e, 0x53, 0x0a, 0x63,
 859     0x5f, 0xfd, 0x28, 0x57, 0x09, 0x07, 0x73, 0xf4, 0x0c, 0xd4, 0x71, 0x5d, 0x6b, 0xa0, 0xd7,
 860     0x86, 0x99, 0x29, 0x9b, 0xca, 0xfb, 0xcc, 0xd6, 0x2f, 0xfe, 0xbe, 0x94, 0xef, 0x1a, 0x0e,
 861     0x55, 0x84, 0xa7, 0xaf, 0x7b, 0xfa, 0xed, 0x77, 0x61, 0x28, 0x22, 0xee, 0x6b, 0x11, 0xdd,
 862     0xb0, 0x17, 0x1e, 0x06, 0xe4, 0x29, 0x4c, 0xc2, 0x3f, 0xd6, 0x75, 0xb6, 0x08, 0x04, 0x55,
 863     0x13, 0x48, 0x4f, 0x44, 0xea, 0x8d, 0xaf, 0xcb, 0xac, 0x22, 0xc4, 0x6a, 0xb3, 0x86, 0xe5,
 864     0x47, 0xa9, 0xb5, 0x72, 0x17, 0x23, 0x11, 0x81, 0x7f, 0x00, 0x00, 0x67, 0x5c, 0xf4, 0x58,
 865     0xcc, 0xe2, 0x46, 0xce, 0xf5, 0x6d, 0xd8, 0x18, 0x91, 0xc4, 0x20, 0xbf, 0x07, 0x48, 0x45,
 866     0xfd
 867 };
 868
 869 static int do_check_params(OSSL_PARAM key_params[], int expected)
 870 {
 871     EVP_PKEY_CTX *gen_ctx = NULL, *check_ctx = NULL;
 872     EVP_PKEY *pkey = NULL;
 873     int ret;
 874
 875     ret = TEST_ptr(gen_ctx = EVP_PKEY_CTX_new_from_name(mainctx, "DSA", NULL))
 876           && TEST_int_eq(EVP_PKEY_fromdata_init(gen_ctx), 1)
 877           && TEST_int_eq(EVP_PKEY_fromdata(gen_ctx, &pkey,
 878                                            EVP_PKEY_KEYPAIR, key_params), 1)
 879           && TEST_ptr(check_ctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey,
 880                                                         NULL))
 881           && TEST_int_eq(EVP_PKEY_param_check(check_ctx), expected);
 882     EVP_PKEY_CTX_free(check_ctx);
 883     EVP_PKEY_CTX_free(gen_ctx);
 884     EVP_PKEY_free(pkey);
 885     return ret;
 886 }
 887
 888 static int do_check_bn(OSSL_PARAM params[], const char *key,
 889                        const unsigned char *expected, size_t expected_len)
 890 {
 891     OSSL_PARAM *p;
 892     BIGNUM *bn = NULL;
 893     unsigned char buffer[256 + 1];
 894     int ret, len;
 895
 896     ret = TEST_ptr(p = OSSL_PARAM_locate(params, key))
 897           && TEST_true(OSSL_PARAM_get_BN(p, &bn))
 898           && TEST_int_gt(len = BN_bn2binpad(bn, buffer, expected_len), 0)
 899           && TEST_mem_eq(expected, expected_len, buffer, len);
 900     BN_free(bn);
 901     return ret;
 902 }
 903
 904 static int do_check_int(OSSL_PARAM params[], const char *key, int expected)
 905 {
 906     OSSL_PARAM *p;
 907     int val = 0;
 908
 909     return TEST_ptr(p = OSSL_PARAM_locate(params, key))
 910            && TEST_true(OSSL_PARAM_get_int(p, &val))
 911            && TEST_int_eq(val, expected);
 912 }
 913
 914 static int test_dsa_tofrom_data_select(void)
 915 {
 916     int ret;
 917     EVP_PKEY *key = NULL;
 918     const unsigned char *pkeydata = dsa_key;
 919
 920     ret = TEST_ptr(key = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
 921                                                mainctx, NULL))
 922           && TEST_true(do_pkey_tofrom_data_select(key, "DSA"));
 923
 924     EVP_PKEY_free(key);
 925     return ret;
 926 }
 927
 928 static int test_dsa_todata(void)
 929 {
 930     EVP_PKEY *pkey = NULL;
 931     OSSL_PARAM *to_params = NULL, *all_params = NULL;
 932     OSSL_PARAM gen_params[4];
 933     int ret = 0;
 934     const unsigned char *pkeydata = dsa_key;
 935
 936     unsigned char dsa_seed[] = {
 937         0xbc, 0x8a, 0x81, 0x64, 0x9e, 0x9d, 0x63, 0xa7, 0xa3, 0x5d, 0x87, 0xdd,
 938         0x32, 0xf3, 0xc1, 0x9f, 0x18, 0x22, 0xeb, 0x73, 0x63, 0xad, 0x5e, 0x7b,
 939         0x90, 0xc1, 0xe3, 0xe0
 940     };
 941     int dsa_pcounter = 319;
 942     int dsa_gindex = 5;
 943
 944     gen_params[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_FFC_SEED,
 945                                                       (void*)dsa_seed,
 946                                                       sizeof(dsa_seed));
 947     gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
 948                                              &dsa_gindex);
 949     gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
 950                                              &dsa_pcounter);
 951     gen_params[3] = OSSL_PARAM_construct_end();
 952
 953     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pkeydata, sizeof(dsa_key),
 954                                                mainctx, NULL))
 955         || !TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, &to_params), 1)
 956         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_P, dsa_p, sizeof(dsa_p))
 957         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_Q, dsa_q, sizeof(dsa_q))
 958         || !do_check_bn(to_params, OSSL_PKEY_PARAM_FFC_G, dsa_g, sizeof(dsa_g))
 959         || !do_check_bn(to_params, OSSL_PKEY_PARAM_PUB_KEY, dsa_pub,
 960                         sizeof(dsa_pub))
 961         || !do_check_bn(to_params, OSSL_PKEY_PARAM_PRIV_KEY, dsa_priv,
 962                         sizeof(dsa_priv))
 963         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_GINDEX, -1)
 964         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_PCOUNTER, -1)
 965         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_H, 0)
 966         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_PQ, 1)
 967         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_G, 1)
 968         || !do_check_int(to_params, OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY, 0)
 969         || !TEST_ptr_null(OSSL_PARAM_locate(to_params, OSSL_PKEY_PARAM_FFC_SEED)))
 970         goto err;
 971
 972     if (!do_fromdata_key_is_equal(to_params, pkey, "DSA"))
 973         goto err;
 974
 975     if (!TEST_ptr(all_params = OSSL_PARAM_merge(to_params, gen_params))
 976         || !do_check_params(all_params, 1))
 977         goto err;
 978     gen_params[1] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_GINDEX,
 979                                              &dsa_gindex);
 980     gen_params[2] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_FFC_PCOUNTER,
 981                                              &dsa_pcounter);
 982     /*
 983      * Check that modifying the shallow copy values used in OSSL_PARAM_merge()
 984      * results in an invalid key. This also verifies that the fips186-4
 985      * validation code is running.
 986      */
 987     dsa_gindex++;
 988     if (!do_check_params(all_params, 0))
 989         goto err;
 990     dsa_gindex--;
 991     dsa_pcounter++;
 992     if (!do_check_params(all_params, 0))
 993         goto err;
 994     dsa_pcounter--;
 995     dsa_seed[0] = 0xb0;
 996     if (!do_check_params(all_params, 0))
 997         goto err;
 998
 999     ret = 1;
1000 err:
1001     EVP_PKEY_free(pkey);
1002     OSSL_PARAM_free(all_params);
1003     OSSL_PARAM_free(to_params);
1004     return ret;
1005 }
1006 #endif /* OPENSSL_NO_DSA */
1007
1008 static int test_pkey_todata_null(void)
1009 {
1010     OSSL_PARAM *params = NULL;
1011     EVP_PKEY *pkey = NULL;
1012     int ret = 0;
1013     const unsigned char *pdata = keydata[0].kder;
1014
1015     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1016                                                 mainctx, NULL))
1017           && TEST_int_eq(EVP_PKEY_todata(NULL, EVP_PKEY_KEYPAIR, &params), 0)
1018           && TEST_int_eq(EVP_PKEY_todata(pkey, EVP_PKEY_KEYPAIR, NULL), 0);
1019     EVP_PKEY_free(pkey);
1020     return ret;
1021 }
1022
1023 static OSSL_CALLBACK test_pkey_export_cb;
1024
1025 static int test_pkey_export_cb(const OSSL_PARAM params[], void *arg)
1026 {
1027     if (arg == NULL)
1028         return 0;
1029     return do_fromdata_key_is_equal(params, (EVP_PKEY *)arg, "RSA");
1030 }
1031
1032 static int test_pkey_export_null(void)
1033 {
1034     EVP_PKEY *pkey = NULL;
1035     int ret = 0;
1036     const unsigned char *pdata = keydata[0].kder;
1037
1038     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1039                                                 mainctx, NULL))
1040           && TEST_int_eq(EVP_PKEY_export(NULL, EVP_PKEY_KEYPAIR,
1041                                          test_pkey_export_cb, NULL), 0)
1042           && TEST_int_eq(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR, NULL, NULL), 0);
1043     EVP_PKEY_free(pkey);
1044     return ret;
1045 }
1046
1047 static int test_pkey_export(void)
1048 {
1049     EVP_PKEY *pkey = NULL;
1050 #ifndef OPENSSL_NO_DEPRECATED_3_0
1051     RSA *rsa = NULL;
1052 #endif
1053     int ret = 1;
1054     const unsigned char *pdata = keydata[0].kder;
1055     int pdata_len = keydata[0].size;
1056
1057     if (!TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, pdata_len,
1058                                                mainctx, NULL))
1059         || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1060                                        test_pkey_export_cb, pkey))
1061         || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1062                                        test_pkey_export_cb, NULL)))
1063         ret = 0;
1064     EVP_PKEY_free(pkey);
1065
1066 #ifndef OPENSSL_NO_DEPRECATED_3_0
1067     /* Now, try with a legacy key */
1068     pdata = keydata[0].kder;
1069     pdata_len = keydata[0].size;
1070     if (!TEST_ptr(rsa = d2i_RSAPrivateKey(NULL, &pdata, pdata_len))
1071         || !TEST_ptr(pkey = EVP_PKEY_new())
1072         || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa))
1073         || !TEST_true(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1074                                       test_pkey_export_cb, pkey))
1075         || !TEST_false(EVP_PKEY_export(pkey, EVP_PKEY_KEYPAIR,
1076                                        test_pkey_export_cb, NULL)))
1077         ret = 0;
1078     EVP_PKEY_free(pkey);
1079 #endif
1080     return ret;
1081 }
1082
1083 static int test_rsa_pss_sign(void)
1084 {
1085     EVP_PKEY *pkey = NULL;
1086     EVP_PKEY_CTX *pctx = NULL;
1087     int ret = 0;
1088     const unsigned char *pdata = keydata[0].kder;
1089     const char *mdname = "SHA2-256";
1090     OSSL_PARAM sig_params[3];
1091     unsigned char mdbuf[256 / 8] = { 0 };
1092     int padding = RSA_PKCS1_PSS_PADDING;
1093     unsigned char *sig = NULL;
1094     size_t sig_len = 0;
1095
1096     sig_params[0] = OSSL_PARAM_construct_int(OSSL_PKEY_PARAM_PAD_MODE,
1097                                              &padding);
1098     sig_params[1] = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1099                                                      (char *)mdname, 0);
1100     sig_params[2] = OSSL_PARAM_construct_end();
1101
1102     ret = TEST_ptr(pkey = d2i_AutoPrivateKey_ex(NULL, &pdata, keydata[0].size,
1103                                                 mainctx, NULL))
1104           && TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(mainctx, pkey, NULL))
1105           && TEST_int_gt(EVP_PKEY_sign_init_ex(pctx, sig_params), 0)
1106           && TEST_int_gt(EVP_PKEY_sign(pctx, NULL, &sig_len, mdbuf,
1107                                        sizeof(mdbuf)), 0)
1108           && TEST_int_gt(sig_len, 0)
1109           && TEST_ptr(sig = OPENSSL_malloc(sig_len))
1110           && TEST_int_gt(EVP_PKEY_sign(pctx, sig, &sig_len, mdbuf,
1111                                        sizeof(mdbuf)), 0);
1112
1113     EVP_PKEY_CTX_free(pctx);
1114     OPENSSL_free(sig);
1115     EVP_PKEY_free(pkey);
1116
1117     return ret;
1118 }
1119
1120 static int test_evp_md_ctx_dup(void)
1121 {
1122     EVP_MD_CTX *mdctx;
1123     EVP_MD_CTX *copyctx = NULL;
1124     int ret;
1125
1126     /* test copying freshly initialized context */
1127     ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1128           && TEST_ptr(copyctx = EVP_MD_CTX_dup(mdctx));
1129
1130     EVP_MD_CTX_free(mdctx);
1131     EVP_MD_CTX_free(copyctx);
1132     return ret;
1133 }
1134
1135 static int test_evp_md_ctx_copy(void)
1136 {
1137     EVP_MD_CTX *mdctx = NULL;
1138     EVP_MD_CTX *copyctx = NULL;
1139     int ret;
1140
1141     /* test copying freshly initialized context */
1142     ret = TEST_ptr(mdctx = EVP_MD_CTX_new())
1143           && TEST_ptr(copyctx = EVP_MD_CTX_new())
1144           && TEST_true(EVP_MD_CTX_copy_ex(copyctx, mdctx));
1145
1146     EVP_MD_CTX_free(mdctx);
1147     EVP_MD_CTX_free(copyctx);
1148     return ret;
1149 }
1150
1151 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1152 static int test_evp_pbe_alg_add(void)
1153 {
1154     int ret = 0;
1155     int cipher_nid = 0, md_nid = 0;
1156     EVP_PBE_KEYGEN_EX *keygen_ex = NULL;
1157     EVP_PBE_KEYGEN *keygen = NULL;
1158
1159     if (!TEST_true(EVP_PBE_alg_add(NID_pbeWithMD5AndDES_CBC, EVP_des_cbc(), EVP_md5(),
1160                                    PKCS5_PBE_keyivgen)))
1161         goto err;
1162
1163     if (!TEST_true(EVP_PBE_find_ex(EVP_PBE_TYPE_OUTER, NID_pbeWithMD5AndDES_CBC,
1164                                    &cipher_nid, &md_nid, &keygen, &keygen_ex)))
1165         goto err;
1166
1167     if (!TEST_true(keygen != NULL))
1168         goto err;
1169     if (!TEST_true(keygen_ex == NULL))
1170         goto err;
1171
1172     ret = 1;
1173
1174 err:
1175     return ret;
1176 }
1177 #endif
1178
1179 int setup_tests(void)
1180 {
1181     if (!test_get_libctx(&mainctx, &nullprov, NULL, NULL, NULL)) {
1182         OSSL_LIB_CTX_free(mainctx);
1183         mainctx = NULL;
1184         return 0;
1185     }
1186
1187     ADD_TEST(test_alternative_default);
1188     ADD_ALL_TESTS(test_d2i_AutoPrivateKey_ex, OSSL_NELEM(keydata));
1189 #ifndef OPENSSL_NO_EC
1190     ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 2);
1191     ADD_TEST(test_ec_tofrom_data_select);
1192     ADD_TEST(test_ecx_tofrom_data_select);
1193     ADD_TEST(test_ec_d2i_i2d_pubkey);
1194 #else
1195     ADD_ALL_TESTS(test_d2i_PrivateKey_ex, 1);
1196 #endif
1197 #ifndef OPENSSL_NO_SM2
1198     ADD_TEST(test_sm2_tofrom_data_select);
1199 #endif
1200 #ifndef OPENSSL_NO_DSA
1201     ADD_TEST(test_dsa_todata);
1202     ADD_TEST(test_dsa_tofrom_data_select);
1203 #endif
1204 #ifndef OPENSSL_NO_DH
1205     ADD_TEST(test_dh_tofrom_data_select);
1206     ADD_TEST(test_dh_paramgen);
1207 #endif
1208     ADD_TEST(test_rsa_tofrom_data_select);
1209
1210     ADD_TEST(test_pkey_todata_null);
1211     ADD_TEST(test_pkey_export_null);
1212     ADD_TEST(test_pkey_export);
1213 #ifndef OPENSSL_NO_DES
1214     ADD_TEST(test_pkcs8key_nid_bio);
1215 #endif
1216     ADD_ALL_TESTS(test_PEM_read_bio_negative, OSSL_NELEM(keydata));
1217     ADD_TEST(test_rsa_pss_sign);
1218     ADD_TEST(test_evp_md_ctx_dup);
1219     ADD_TEST(test_evp_md_ctx_copy);
1220     ADD_ALL_TESTS(test_provider_unload_effective, 2);
1221 #if !defined OPENSSL_NO_DES && !defined OPENSSL_NO_MD5
1222     ADD_TEST(test_evp_pbe_alg_add);
1223 #endif
1224     return 1;
1225 }
1226
1227 void cleanup_tests(void)
1228 {
1229     OSSL_LIB_CTX_free(mainctx);
1230     OSSL_PROVIDER_unload(nullprov);
1231 }