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