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