test/evp_extra_test.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 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <openssl/bio.h>
  17 #include <openssl/conf.h>
  18 #include <openssl/crypto.h>
  19 #include <openssl/err.h>
  20 #include <openssl/evp.h>
  21 #include <openssl/x509.h>
  22 #include <openssl/pem.h>
  23 #include <openssl/kdf.h>
  24 #include <openssl/provider.h>
  25 #include <openssl/core_names.h>
  26 #include <openssl/params.h>
  27 #include <openssl/param_build.h>
  28 #include <openssl/dsa.h>
  29 #include <openssl/dh.h>
  30 #include <openssl/aes.h>
  31 #include <openssl/decoder.h>
  32 #include <openssl/rsa.h>
  33 #include <openssl/engine.h>
  34 #include "testutil.h"
  35 #include "internal/nelem.h"
  36 #include "internal/sizes.h"
  37 #include "crypto/evp.h"
  38
  39 static OSSL_LIB_CTX *testctx = NULL;
  40 static char *testpropq = NULL;
  41
  42 static OSSL_PROVIDER *nullprov = NULL;
  43 static OSSL_PROVIDER *deflprov = NULL;
  44 static OSSL_PROVIDER *lgcyprov = NULL;
  45
  46 /*
  47  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
  48  * should never use this key anywhere but in an example.
  49  */
  50 static const unsigned char kExampleRSAKeyDER[] = {
  51     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
  52     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
  53     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
  54     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
  55     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
  56     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
  57     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
  58     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
  59     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
  60     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
  61     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
  62     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
  63     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
  64     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
  65     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
  66     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
  67     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
  68     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
  69     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
  70     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
  71     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
  72     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
  73     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
  74     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
  75     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
  76     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
  77     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
  78     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
  79     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
  80     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
  81     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
  82     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
  83     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
  84     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
  85     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
  86     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
  87     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
  88     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
  89     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
  90     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
  91     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
  92     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
  93     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
  94     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
  95     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
  96     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
  97     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
  98     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
  99     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
 100     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
 101     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 102 };
 103
 104 /*
 105 * kExampleDSAKeyDER is a DSA private key in ASN.1, DER format. Of course, you
 106  * should never use this key anywhere but in an example.
 107  */
 108 #ifndef OPENSSL_NO_DSA
 109 static const unsigned char kExampleDSAKeyDER[] = {
 110     0x30, 0x82, 0x01, 0xba, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0x9a,
 111     0x05, 0x6d, 0x33, 0xcd, 0x5d, 0x78, 0xa1, 0xbb, 0xcb, 0x7d, 0x5b, 0x8d,
 112     0xb4, 0xcc, 0xbf, 0x03, 0x99, 0x64, 0xde, 0x38, 0x78, 0x06, 0x15, 0x2f,
 113     0x86, 0x26, 0x77, 0xf3, 0xb1, 0x85, 0x00, 0xed, 0xfc, 0x28, 0x3a, 0x42,
 114     0x4d, 0xab, 0xab, 0xdf, 0xbc, 0x9c, 0x16, 0xd0, 0x22, 0x50, 0xd1, 0x38,
 115     0xdd, 0x3f, 0x64, 0x05, 0x9e, 0x68, 0x7a, 0x1e, 0xf1, 0x56, 0xbf, 0x1e,
 116     0x2c, 0xc5, 0x97, 0x2a, 0xfe, 0x7a, 0x22, 0xdc, 0x6c, 0x68, 0xb8, 0x2e,
 117     0x06, 0xdb, 0x41, 0xca, 0x98, 0xd8, 0x54, 0xc7, 0x64, 0x48, 0x24, 0x04,
 118     0x20, 0xbc, 0x59, 0xe3, 0x6b, 0xea, 0x7e, 0xfc, 0x7e, 0xc5, 0x4e, 0xd4,
 119     0xd8, 0x3a, 0xed, 0xcd, 0x5d, 0x99, 0xb8, 0x5c, 0xa2, 0x8b, 0xbb, 0x0b,
 120     0xac, 0xe6, 0x8e, 0x25, 0x56, 0x22, 0x3a, 0x2d, 0x3a, 0x56, 0x41, 0x14,
 121     0x1f, 0x1c, 0x8f, 0x53, 0x46, 0x13, 0x85, 0x02, 0x15, 0x00, 0x98, 0x7e,
 122     0x92, 0x81, 0x88, 0xc7, 0x3f, 0x70, 0x49, 0x54, 0xf6, 0x76, 0xb4, 0xa3,
 123     0x9e, 0x1d, 0x45, 0x98, 0x32, 0x7f, 0x02, 0x81, 0x80, 0x69, 0x4d, 0xef,
 124     0x55, 0xff, 0x4d, 0x59, 0x2c, 0x01, 0xfa, 0x6a, 0x38, 0xe0, 0x70, 0x9f,
 125     0x9e, 0x66, 0x8e, 0x3e, 0x8c, 0x52, 0x22, 0x9d, 0x15, 0x7e, 0x3c, 0xef,
 126     0x4c, 0x7a, 0x61, 0x26, 0xe0, 0x2b, 0x81, 0x3f, 0xeb, 0xaf, 0x35, 0x38,
 127     0x8d, 0xfe, 0xed, 0x46, 0xff, 0x5f, 0x03, 0x9b, 0x81, 0x92, 0xe7, 0x6f,
 128     0x76, 0x4f, 0x1d, 0xd9, 0xbb, 0x89, 0xc9, 0x3e, 0xd9, 0x0b, 0xf9, 0xf4,
 129     0x78, 0x11, 0x59, 0xc0, 0x1d, 0xcd, 0x0e, 0xa1, 0x6f, 0x15, 0xf1, 0x4d,
 130     0xc1, 0xc9, 0x22, 0xed, 0x8d, 0xad, 0x67, 0xc5, 0x4b, 0x95, 0x93, 0x86,
 131     0xa6, 0xaf, 0x8a, 0xee, 0x06, 0x89, 0x2f, 0x37, 0x7e, 0x64, 0xaa, 0xf6,
 132     0xe7, 0xb1, 0x5a, 0x0a, 0x93, 0x95, 0x5d, 0x3e, 0x53, 0x9a, 0xde, 0x8a,
 133     0xc2, 0x95, 0x45, 0x81, 0xbe, 0x5c, 0x2f, 0xc2, 0xb2, 0x92, 0x58, 0x19,
 134     0x72, 0x80, 0xe9, 0x79, 0xa1, 0x02, 0x81, 0x80, 0x07, 0xd7, 0x62, 0xff,
 135     0xdf, 0x1a, 0x3f, 0xed, 0x32, 0xd4, 0xd4, 0x88, 0x7b, 0x2c, 0x63, 0x7f,
 136     0x97, 0xdc, 0x44, 0xd4, 0x84, 0xa2, 0xdd, 0x17, 0x16, 0x85, 0x13, 0xe0,
 137     0xac, 0x51, 0x8d, 0x29, 0x1b, 0x75, 0x9a, 0xe4, 0xe3, 0x8a, 0x92, 0x69,
 138     0x09, 0x03, 0xc5, 0x68, 0xae, 0x5e, 0x94, 0xfe, 0xc9, 0x92, 0x6c, 0x07,
 139     0xb4, 0x1e, 0x64, 0x62, 0x87, 0xc6, 0xa4, 0xfd, 0x0d, 0x5f, 0xe5, 0xf9,
 140     0x1b, 0x4f, 0x85, 0x5f, 0xae, 0xf3, 0x11, 0xe5, 0x18, 0xd4, 0x4d, 0x79,
 141     0x9f, 0xc4, 0x79, 0x26, 0x04, 0x27, 0xf0, 0x0b, 0xee, 0x2b, 0x86, 0x9f,
 142     0x86, 0x61, 0xe6, 0x51, 0xce, 0x04, 0x9b, 0x5d, 0x6b, 0x34, 0x43, 0x8c,
 143     0x85, 0x3c, 0xf1, 0x51, 0x9b, 0x08, 0x23, 0x1b, 0xf5, 0x7e, 0x33, 0x12,
 144     0xea, 0xab, 0x1f, 0xb7, 0x2d, 0xe2, 0x5f, 0xe6, 0x97, 0x99, 0xb5, 0x45,
 145     0x16, 0x5b, 0xc3, 0x41, 0x02, 0x14, 0x61, 0xbf, 0x51, 0x60, 0xcf, 0xc8,
 146     0xf1, 0x8c, 0x82, 0x97, 0xf2, 0xf4, 0x19, 0xba, 0x2b, 0xf3, 0x16, 0xbe,
 147     0x40, 0x48
 148 };
 149 #endif
 150
 151 /*
 152  * kExampleBadRSAKeyDER is an RSA private key in ASN.1, DER format. The private
 153  * components are not correct.
 154  */
 155 static const unsigned char kExampleBadRSAKeyDER[] = {
 156     0x30, 0x82, 0x04, 0x27, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
 157     0xa6, 0x1a, 0x1e, 0x6e, 0x7b, 0xee, 0xc6, 0x89, 0x66, 0xe7, 0x93, 0xef,
 158     0x54, 0x12, 0x68, 0xea, 0xbf, 0x86, 0x2f, 0xdd, 0xd2, 0x79, 0xb8, 0xa9,
 159     0x6e, 0x03, 0xc2, 0xa3, 0xb9, 0xa3, 0xe1, 0x4b, 0x2a, 0xb3, 0xf8, 0xb4,
 160     0xcd, 0xea, 0xbe, 0x24, 0xa6, 0x57, 0x5b, 0x83, 0x1f, 0x0f, 0xf2, 0xd3,
 161     0xb7, 0xac, 0x7e, 0xd6, 0x8e, 0x6e, 0x1e, 0xbf, 0xb8, 0x73, 0x8c, 0x05,
 162     0x56, 0xe6, 0x35, 0x1f, 0xe9, 0x04, 0x0b, 0x09, 0x86, 0x7d, 0xf1, 0x26,
 163     0x08, 0x99, 0xad, 0x7b, 0xc8, 0x4d, 0x94, 0xb0, 0x0b, 0x8b, 0x38, 0xa0,
 164     0x5c, 0x62, 0xa0, 0xab, 0xd3, 0x8f, 0xd4, 0x09, 0x60, 0x72, 0x1e, 0x33,
 165     0x50, 0x80, 0x6e, 0x22, 0xa6, 0x77, 0x57, 0x6b, 0x9a, 0x33, 0x21, 0x66,
 166     0x87, 0x6e, 0x21, 0x7b, 0xc7, 0x24, 0x0e, 0xd8, 0x13, 0xdf, 0x83, 0xde,
 167     0xcd, 0x40, 0x58, 0x1d, 0x84, 0x86, 0xeb, 0xb8, 0x12, 0x4e, 0xd2, 0xfa,
 168     0x80, 0x1f, 0xe4, 0xe7, 0x96, 0x29, 0xb8, 0xcc, 0xce, 0x66, 0x6d, 0x53,
 169     0xca, 0xb9, 0x5a, 0xd7, 0xf6, 0x84, 0x6c, 0x2d, 0x9a, 0x1a, 0x14, 0x1c,
 170     0x4e, 0x93, 0x39, 0xba, 0x74, 0xed, 0xed, 0x87, 0x87, 0x5e, 0x48, 0x75,
 171     0x36, 0xf0, 0xbc, 0x34, 0xfb, 0x29, 0xf9, 0x9f, 0x96, 0x5b, 0x0b, 0xa7,
 172     0x54, 0x30, 0x51, 0x29, 0x18, 0x5b, 0x7d, 0xac, 0x0f, 0xd6, 0x5f, 0x7c,
 173     0xf8, 0x98, 0x8c, 0xd8, 0x86, 0x62, 0xb3, 0xdc, 0xff, 0x0f, 0xff, 0x7a,
 174     0xaf, 0x5c, 0x4c, 0x61, 0x49, 0x2e, 0xc8, 0x95, 0x86, 0xc4, 0x0e, 0x87,
 175     0xfc, 0x1d, 0xcf, 0x8b, 0x7c, 0x61, 0xf6, 0xd8, 0xd0, 0x69, 0xf6, 0xcd,
 176     0x8a, 0x8c, 0xf6, 0x62, 0xa2, 0x56, 0xa9, 0xe3, 0xd1, 0xcf, 0x4d, 0xa0,
 177     0xf6, 0x2d, 0x20, 0x0a, 0x04, 0xb7, 0xa2, 0xf7, 0xb5, 0x99, 0x47, 0x18,
 178     0x56, 0x85, 0x87, 0xc7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
 179     0x01, 0x00, 0x99, 0x41, 0x38, 0x1a, 0xd0, 0x96, 0x7a, 0xf0, 0x83, 0xd5,
 180     0xdf, 0x94, 0xce, 0x89, 0x3d, 0xec, 0x7a, 0x52, 0x21, 0x10, 0x16, 0x06,
 181     0xe0, 0xee, 0xd2, 0xe6, 0xfd, 0x4b, 0x7b, 0x19, 0x4d, 0xe1, 0xc0, 0xc0,
 182     0xd5, 0x14, 0x5d, 0x79, 0xdd, 0x7e, 0x8b, 0x4b, 0xc6, 0xcf, 0xb0, 0x75,
 183     0x52, 0xa3, 0x2d, 0xb1, 0x26, 0x46, 0x68, 0x9c, 0x0a, 0x1a, 0xf2, 0xe1,
 184     0x09, 0xac, 0x53, 0x85, 0x8c, 0x36, 0xa9, 0x14, 0x65, 0xea, 0xa0, 0x00,
 185     0xcb, 0xe3, 0x3f, 0xc4, 0x2b, 0x61, 0x2e, 0x6b, 0x06, 0x69, 0x77, 0xfd,
 186     0x38, 0x7e, 0x1d, 0x3f, 0x92, 0xe7, 0x77, 0x08, 0x19, 0xa7, 0x9d, 0x29,
 187     0x2d, 0xdc, 0x42, 0xc6, 0x7c, 0xd7, 0xd3, 0xa8, 0x01, 0x2c, 0xf2, 0xd5,
 188     0x82, 0x57, 0xcb, 0x55, 0x3d, 0xe7, 0xaa, 0xd2, 0x06, 0x30, 0x30, 0x05,
 189     0xe6, 0xf2, 0x47, 0x86, 0xba, 0xc6, 0x61, 0x64, 0xeb, 0x4f, 0x2a, 0x5e,
 190     0x07, 0x29, 0xe0, 0x96, 0xb2, 0x43, 0xff, 0x5f, 0x1a, 0x54, 0x16, 0xcf,
 191     0xb5, 0x56, 0x5c, 0xa0, 0x9b, 0x0c, 0xfd, 0xb3, 0xd2, 0xe3, 0x79, 0x1d,
 192     0x21, 0xe2, 0xd6, 0x13, 0xc4, 0x74, 0xa6, 0xf5, 0x8e, 0x8e, 0x81, 0xbb,
 193     0xb4, 0xad, 0x8a, 0xf0, 0x93, 0x0a, 0xd8, 0x0a, 0x42, 0x36, 0xbc, 0xe5,
 194     0x26, 0x2a, 0x0d, 0x5d, 0x57, 0x13, 0xc5, 0x4e, 0x2f, 0x12, 0x0e, 0xef,
 195     0xa7, 0x81, 0x1e, 0xc3, 0xa5, 0xdb, 0xc9, 0x24, 0xeb, 0x1a, 0xa1, 0xf9,
 196     0xf6, 0xa1, 0x78, 0x98, 0x93, 0x77, 0x42, 0x45, 0x03, 0xe2, 0xc9, 0xa2,
 197     0xfe, 0x2d, 0x77, 0xc8, 0xc6, 0xac, 0x9b, 0x98, 0x89, 0x6d, 0x9a, 0xe7,
 198     0x61, 0x63, 0xb7, 0xf2, 0xec, 0xd6, 0xb1, 0xa1, 0x6e, 0x0a, 0x1a, 0xff,
 199     0xfd, 0x43, 0x28, 0xc3, 0x0c, 0xdc, 0xf2, 0x47, 0x4f, 0x27, 0xaa, 0x99,
 200     0x04, 0x8e, 0xac, 0xe8, 0x7c, 0x01, 0x02, 0x04, 0x12, 0x34, 0x56, 0x78,
 201     0x02, 0x81, 0x81, 0x00, 0xca, 0x69, 0xe5, 0xbb, 0x3a, 0x90, 0x82, 0xcb,
 202     0x82, 0x50, 0x2f, 0x29, 0xe2, 0x76, 0x6a, 0x57, 0x55, 0x45, 0x4e, 0x35,
 203     0x18, 0x61, 0xe0, 0x12, 0x70, 0xc0, 0xab, 0xc7, 0x80, 0xa2, 0xd4, 0x46,
 204     0x34, 0x03, 0xa0, 0x19, 0x26, 0x23, 0x9e, 0xef, 0x1a, 0xcb, 0x75, 0xd6,
 205     0xba, 0x81, 0xf4, 0x7e, 0x52, 0xe5, 0x2a, 0xe8, 0xf1, 0x49, 0x6c, 0x0f,
 206     0x1a, 0xa0, 0xf9, 0xc6, 0xe7, 0xec, 0x60, 0xe4, 0xcb, 0x2a, 0xb5, 0x56,
 207     0xe9, 0x9c, 0xcd, 0x19, 0x75, 0x92, 0xb1, 0x66, 0xce, 0xc3, 0xd9, 0x3d,
 208     0x11, 0xcb, 0xc4, 0x09, 0xce, 0x1e, 0x30, 0xba, 0x2f, 0x60, 0x60, 0x55,
 209     0x8d, 0x02, 0xdc, 0x5d, 0xaf, 0xf7, 0x52, 0x31, 0x17, 0x07, 0x53, 0x20,
 210     0x33, 0xad, 0x8c, 0xd5, 0x2f, 0x5a, 0xd0, 0x57, 0xd7, 0xd1, 0x80, 0xd6,
 211     0x3a, 0x9b, 0x04, 0x4f, 0x35, 0xbf, 0xe7, 0xd5, 0xbc, 0x8f, 0xd4, 0x81,
 212     0x02, 0x81, 0x81, 0x00, 0xc0, 0x9f, 0xf8, 0xcd, 0xf7, 0x3f, 0x26, 0x8a,
 213     0x3d, 0x4d, 0x2b, 0x0c, 0x01, 0xd0, 0xa2, 0xb4, 0x18, 0xfe, 0xf7, 0x5e,
 214     0x2f, 0x06, 0x13, 0xcd, 0x63, 0xaa, 0x12, 0xa9, 0x24, 0x86, 0xe3, 0xf3,
 215     0x7b, 0xda, 0x1a, 0x3c, 0xb1, 0x38, 0x80, 0x80, 0xef, 0x64, 0x64, 0xa1,
 216     0x9b, 0xfe, 0x76, 0x63, 0x8e, 0x83, 0xd2, 0xd9, 0xb9, 0x86, 0xb0, 0xe6,
 217     0xa6, 0x0c, 0x7e, 0xa8, 0x84, 0x90, 0x98, 0x0c, 0x1e, 0xf3, 0x14, 0x77,
 218     0xe0, 0x5f, 0x81, 0x08, 0x11, 0x8f, 0xa6, 0x23, 0xc4, 0xba, 0xc0, 0x8a,
 219     0xe4, 0xc6, 0xe3, 0x5c, 0xbe, 0xc5, 0xec, 0x2c, 0xb9, 0xd8, 0x8c, 0x4d,
 220     0x1a, 0x9d, 0xe7, 0x7c, 0x85, 0x4c, 0x0d, 0x71, 0x4e, 0x72, 0x33, 0x1b,
 221     0xfe, 0xa9, 0x17, 0x72, 0x76, 0x56, 0x9d, 0x74, 0x7e, 0x52, 0x67, 0x9a,
 222     0x87, 0x9a, 0xdb, 0x30, 0xde, 0xe4, 0x49, 0x28, 0x3b, 0xd2, 0x67, 0xaf,
 223     0x02, 0x81, 0x81, 0x00, 0x89, 0x74, 0x9a, 0x8e, 0xa7, 0xb9, 0xa5, 0x28,
 224     0xc0, 0x68, 0xe5, 0x6e, 0x63, 0x1c, 0x99, 0x20, 0x8f, 0x86, 0x8e, 0x12,
 225     0x9e, 0x69, 0x30, 0xfa, 0x34, 0xd9, 0x92, 0x8d, 0xdb, 0x7c, 0x37, 0xfd,
 226     0x28, 0xab, 0x61, 0x98, 0x52, 0x7f, 0x14, 0x1a, 0x39, 0xae, 0xfb, 0x6a,
 227     0x03, 0xa3, 0xe6, 0xbd, 0xb6, 0x5b, 0x6b, 0xe5, 0x5e, 0x9d, 0xc6, 0xa5,
 228     0x07, 0x27, 0x54, 0x17, 0xd0, 0x3d, 0x84, 0x9b, 0x3a, 0xa0, 0xd9, 0x1e,
 229     0x99, 0x6c, 0x63, 0x17, 0xab, 0xf1, 0x1f, 0x49, 0xba, 0x95, 0xe3, 0x3b,
 230     0x86, 0x8f, 0x42, 0xa4, 0x89, 0xf5, 0x94, 0x8f, 0x8b, 0x46, 0xbe, 0x84,
 231     0xba, 0x4a, 0xbc, 0x0d, 0x5f, 0x46, 0xeb, 0xe8, 0xec, 0x43, 0x8c, 0x1e,
 232     0xad, 0x19, 0x69, 0x2f, 0x08, 0x86, 0x7a, 0x3f, 0x7d, 0x0f, 0x07, 0x97,
 233     0xf3, 0x9a, 0x7b, 0xb5, 0xb2, 0xc1, 0x8c, 0x95, 0x68, 0x04, 0xa0, 0x81,
 234     0x02, 0x81, 0x80, 0x4e, 0xbf, 0x7e, 0x1b, 0xcb, 0x13, 0x61, 0x75, 0x3b,
 235     0xdb, 0x59, 0x5f, 0xb1, 0xd4, 0xb8, 0xeb, 0x9e, 0x73, 0xb5, 0xe7, 0xf6,
 236     0x89, 0x3d, 0x1c, 0xda, 0xf0, 0x36, 0xff, 0x35, 0xbd, 0x1e, 0x0b, 0x74,
 237     0xe3, 0x9e, 0xf0, 0xf2, 0xf7, 0xd7, 0x82, 0xb7, 0x7b, 0x6a, 0x1b, 0x0e,
 238     0x30, 0x4a, 0x98, 0x0e, 0xb4, 0xf9, 0x81, 0x07, 0xe4, 0x75, 0x39, 0xe9,
 239     0x53, 0xca, 0xbb, 0x5c, 0xaa, 0x93, 0x07, 0x0e, 0xa8, 0x2f, 0xba, 0x98,
 240     0x49, 0x30, 0xa7, 0xcc, 0x1a, 0x3c, 0x68, 0x0c, 0xe1, 0xa4, 0xb1, 0x05,
 241     0xe6, 0xe0, 0x25, 0x78, 0x58, 0x14, 0x37, 0xf5, 0x1f, 0xe3, 0x22, 0xef,
 242     0xa8, 0x0e, 0x22, 0xa0, 0x94, 0x3a, 0xf6, 0xc9, 0x13, 0xe6, 0x06, 0xbf,
 243     0x7f, 0x99, 0xc6, 0xcc, 0xd8, 0xc6, 0xbe, 0xd9, 0x2e, 0x24, 0xc7, 0x69,
 244     0x8c, 0x95, 0xba, 0xf6, 0x04, 0xb3, 0x0a, 0xf4, 0xcb, 0xf0, 0xce,
 245 };
 246
 247 static const unsigned char kMsg[] = { 1, 2, 3, 4 };
 248
 249 static const unsigned char kSignature[] = {
 250     0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
 251     0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
 252     0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
 253     0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
 254     0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
 255     0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
 256     0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
 257     0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
 258     0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
 259     0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
 260     0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
 261 };
 262
 263 /*
 264  * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
 265  * PrivateKeyInfo.
 266  */
 267 static const unsigned char kExampleRSAKeyPKCS8[] = {
 268     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 269     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 270     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
 271     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
 272     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
 273     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
 274     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
 275     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
 276     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
 277     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
 278     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
 279     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
 280     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
 281     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
 282     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
 283     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
 284     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
 285     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
 286     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
 287     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
 288     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
 289     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
 290     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
 291     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
 292     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
 293     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
 294     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
 295     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
 296     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
 297     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
 298     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
 299     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
 300     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
 301     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
 302     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
 303     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
 304     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
 305     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
 306     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
 307     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
 308     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
 309     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
 310     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
 311     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
 312     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
 313     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
 314     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
 315     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
 316     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
 317     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
 318     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
 319     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
 320     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 321 };
 322
 323 #ifndef OPENSSL_NO_EC
 324 /*
 325  * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
 326  * structure.
 327  */
 328 static const unsigned char kExampleECKeyDER[] = {
 329     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
 330     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
 331     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
 332     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 333     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
 334     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
 335     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
 336     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
 337     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
 338     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
 339     0xc1,
 340 };
 341
 342 /*
 343  * kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
 344  * structure. The private key is equal to the order and will fail to import
 345  */
 346 static const unsigned char kExampleBadECKeyDER[] = {
 347     0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
 348     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
 349     0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
 350     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 351     0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
 352     0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
 353     0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
 354     0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
 355     0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
 356 };
 357
 358 /* prime256v1 */
 359 static const unsigned char kExampleECPubKeyDER[] = {
 360     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 361     0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 362     0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
 363     0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
 364     0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
 365     0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
 366     0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
 367     0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
 368 };
 369
 370 /*
 371  * kExampleBadECPubKeyDER is a sample EC public key with a wrong OID
 372  * 1.2.840.10045.2.2 instead of 1.2.840.10045.2.1 - EC Public Key
 373  */
 374 static const unsigned char kExampleBadECPubKeyDER[] = {
 375     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 376     0x02, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 377     0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
 378     0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
 379     0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
 380     0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
 381     0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
 382     0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
 383 };
 384
 385 static const unsigned char pExampleECParamDER[] = {
 386     0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
 387 };
 388
 389 static const unsigned char kExampleED25519KeyDER[] = {
 390     0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70,
 391     0x04, 0x22, 0x04, 0x20, 0xba, 0x7b, 0xba, 0x20, 0x1b, 0x02, 0x75, 0x3a,
 392     0xe8, 0x88, 0xfe, 0x00, 0xcd, 0x8b, 0xc6, 0xf4, 0x5c, 0x47, 0x09, 0x46,
 393     0x66, 0xe4, 0x72, 0x85, 0x25, 0x26, 0x5e, 0x12, 0x33, 0x48, 0xf6, 0x50
 394 };
 395
 396 static const unsigned char kExampleED25519PubKeyDER[] = {
 397     0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,
 398     0xf5, 0xc5, 0xeb, 0x52, 0x3e, 0x7d, 0x07, 0x86, 0xb2, 0x55, 0x07, 0x45,
 399     0xef, 0x5b, 0x7c, 0x20, 0xe8, 0x66, 0x28, 0x30, 0x3c, 0x8a, 0x82, 0x40,
 400     0x97, 0xa3, 0x08, 0xdc, 0x65, 0x80, 0x39, 0x29
 401 };
 402
 403 # ifndef OPENSSL_NO_DEPRECATED_3_0
 404 static const unsigned char kExampleX25519KeyDER[] = {
 405     0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e,
 406     0x04, 0x22, 0x04, 0x20, 0xa0, 0x24, 0x3a, 0x31, 0x24, 0xc3, 0x3f, 0xf6,
 407     0x7b, 0x96, 0x0b, 0xd4, 0x8f, 0xd1, 0xee, 0x67, 0xf2, 0x9b, 0x88, 0xac,
 408     0x50, 0xce, 0x97, 0x36, 0xdd, 0xaf, 0x25, 0xf6, 0x10, 0x34, 0x96, 0x6e
 409 };
 410 # endif
 411 #endif
 412
 413 /* kExampleDHKeyDER is a DH private key in ASN.1, DER format. */
 414 #ifndef OPENSSL_NO_DEPRECATED_3_0
 415 # ifndef OPENSSL_NO_DH
 416 static const unsigned char kExampleDHKeyDER[] = {
 417     0x30, 0x82, 0x01, 0x21, 0x02, 0x01, 0x00, 0x30, 0x81, 0x95, 0x06, 0x09,
 418     0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x03, 0x01, 0x30, 0x81, 0x87,
 419     0x02, 0x81, 0x81, 0x00, 0xf7, 0x52, 0xc2, 0x68, 0xcc, 0x66, 0xc4, 0x8d,
 420     0x03, 0x3f, 0xfa, 0x9c, 0x52, 0xd0, 0xd8, 0x33, 0xf2, 0xe1, 0xc9, 0x9e,
 421     0xb7, 0xe7, 0x6e, 0x90, 0x97, 0xeb, 0x92, 0x91, 0x6a, 0x9a, 0x85, 0x63,
 422     0x92, 0x79, 0xab, 0xb6, 0x3d, 0x23, 0x58, 0x5a, 0xe8, 0x45, 0x06, 0x81,
 423     0x97, 0x77, 0xe1, 0xcc, 0x34, 0x4e, 0xae, 0x36, 0x80, 0xf2, 0xc4, 0x7f,
 424     0x8a, 0x52, 0xb8, 0xdb, 0x58, 0xc8, 0x4b, 0x12, 0x4c, 0xf1, 0x4c, 0x53,
 425     0xc1, 0x89, 0x39, 0x8d, 0xb6, 0x06, 0xd8, 0xea, 0x7f, 0x2d, 0x36, 0x53,
 426     0x96, 0x29, 0xbe, 0xb6, 0x75, 0xfc, 0xe7, 0xf3, 0x36, 0xd6, 0xf4, 0x8f,
 427     0x16, 0xa6, 0xc7, 0xec, 0x7b, 0xce, 0x42, 0x8d, 0x48, 0x2e, 0xb7, 0x74,
 428     0x00, 0x11, 0x52, 0x61, 0xb4, 0x19, 0x35, 0xec, 0x5c, 0xe4, 0xbe, 0x34,
 429     0xc6, 0x59, 0x64, 0x5e, 0x42, 0x61, 0x70, 0x54, 0xf4, 0xe9, 0x6b, 0x53,
 430     0x02, 0x01, 0x02, 0x04, 0x81, 0x83, 0x02, 0x81, 0x80, 0x64, 0xc2, 0xe3,
 431     0x09, 0x69, 0x37, 0x3c, 0xd2, 0x4a, 0xba, 0xc3, 0x78, 0x6a, 0x9b, 0x8a,
 432     0x2a, 0xdb, 0xe7, 0xe6, 0xc0, 0xfa, 0x3a, 0xbe, 0x39, 0x67, 0xc0, 0xa9,
 433     0x2a, 0xf0, 0x0a, 0xc1, 0x53, 0x1c, 0xdb, 0xfa, 0x1a, 0x26, 0x98, 0xb0,
 434     0x8c, 0xc6, 0x06, 0x4a, 0xa2, 0x48, 0xd3, 0xa4, 0x3b, 0xbd, 0x05, 0x48,
 435     0xea, 0x59, 0xdb, 0x18, 0xa4, 0xca, 0x66, 0xd9, 0x5d, 0xb8, 0x95, 0xd1,
 436     0xeb, 0x97, 0x3d, 0x66, 0x97, 0x5c, 0x86, 0x8f, 0x7e, 0x90, 0xd3, 0x43,
 437     0xd1, 0xa2, 0x0d, 0xcb, 0xe7, 0xeb, 0x90, 0xea, 0x09, 0x40, 0xb1, 0x6f,
 438     0xf7, 0x4c, 0xf2, 0x41, 0x83, 0x1d, 0xd0, 0x76, 0xef, 0xaf, 0x55, 0x6f,
 439     0x5d, 0xa9, 0xa3, 0x55, 0x81, 0x2a, 0xd1, 0x5d, 0x9d, 0x22, 0x77, 0x97,
 440     0x83, 0xde, 0xad, 0xb6, 0x5d, 0x19, 0xc1, 0x53, 0xec, 0xfb, 0xaf, 0x06,
 441     0x2e, 0x87, 0x2a, 0x0b, 0x7a
 442 };
 443 # endif
 444 #endif
 445
 446 static const unsigned char kCFBDefaultKey[] = {
 447     0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88,
 448     0x09, 0xCF, 0x4F, 0x3C
 449 };
 450
 451 static const unsigned char kGCMDefaultKey[32] = { 0 };
 452
 453 static const unsigned char kGCMResetKey[] = {
 454     0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c, 0x6d, 0x6a, 0x8f, 0x94,
 455     0x67, 0x30, 0x83, 0x08, 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
 456     0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
 457 };
 458
 459 static const unsigned char iCFBIV[] = {
 460     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
 461     0x0C, 0x0D, 0x0E, 0x0F
 462 };
 463
 464 static const unsigned char iGCMDefaultIV[12] = { 0 };
 465
 466 static const unsigned char iGCMResetIV1[] = {
 467     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad
 468 };
 469
 470 static const unsigned char iGCMResetIV2[] = {
 471     0xca, 0xfe, 0xba, 0xbe, 0xfa, 0xce, 0xdb, 0xad, 0xde, 0xca, 0xf8, 0x88
 472 };
 473
 474 static const unsigned char cfbPlaintext[] = {
 475     0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96, 0xE9, 0x3D, 0x7E, 0x11,
 476     0x73, 0x93, 0x17, 0x2A
 477 };
 478
 479 static const unsigned char gcmDefaultPlaintext[16] = { 0 };
 480
 481 static const unsigned char gcmResetPlaintext[] = {
 482     0xd9, 0x31, 0x32, 0x25, 0xf8, 0x84, 0x06, 0xe5, 0xa5, 0x59, 0x09, 0xc5,
 483     0xaf, 0xf5, 0x26, 0x9a, 0x86, 0xa7, 0xa9, 0x53, 0x15, 0x34, 0xf7, 0xda,
 484     0x2e, 0x4c, 0x30, 0x3d, 0x8a, 0x31, 0x8a, 0x72, 0x1c, 0x3c, 0x0c, 0x95,
 485     0x95, 0x68, 0x09, 0x53, 0x2f, 0xcf, 0x0e, 0x24, 0x49, 0xa6, 0xb5, 0x25,
 486     0xb1, 0x6a, 0xed, 0xf5, 0xaa, 0x0d, 0xe6, 0x57, 0xba, 0x63, 0x7b, 0x39
 487 };
 488
 489 static const unsigned char cfbCiphertext[] = {
 490     0x3B, 0x3F, 0xD9, 0x2E, 0xB7, 0x2D, 0xAD, 0x20, 0x33, 0x34, 0x49, 0xF8,
 491     0xE8, 0x3C, 0xFB, 0x4A
 492 };
 493
 494 static const unsigned char gcmDefaultCiphertext[] = {
 495     0xce, 0xa7, 0x40, 0x3d, 0x4d, 0x60, 0x6b, 0x6e, 0x07, 0x4e, 0xc5, 0xd3,
 496     0xba, 0xf3, 0x9d, 0x18
 497 };
 498
 499 static const unsigned char gcmResetCiphertext1[] = {
 500     0xc3, 0x76, 0x2d, 0xf1, 0xca, 0x78, 0x7d, 0x32, 0xae, 0x47, 0xc1, 0x3b,
 501     0xf1, 0x98, 0x44, 0xcb, 0xaf, 0x1a, 0xe1, 0x4d, 0x0b, 0x97, 0x6a, 0xfa,
 502     0xc5, 0x2f, 0xf7, 0xd7, 0x9b, 0xba, 0x9d, 0xe0, 0xfe, 0xb5, 0x82, 0xd3,
 503     0x39, 0x34, 0xa4, 0xf0, 0x95, 0x4c, 0xc2, 0x36, 0x3b, 0xc7, 0x3f, 0x78,
 504     0x62, 0xac, 0x43, 0x0e, 0x64, 0xab, 0xe4, 0x99, 0xf4, 0x7c, 0x9b, 0x1f
 505 };
 506
 507 static const unsigned char gcmResetCiphertext2[] = {
 508     0x52, 0x2d, 0xc1, 0xf0, 0x99, 0x56, 0x7d, 0x07, 0xf4, 0x7f, 0x37, 0xa3,
 509     0x2a, 0x84, 0x42, 0x7d, 0x64, 0x3a, 0x8c, 0xdc, 0xbf, 0xe5, 0xc0, 0xc9,
 510     0x75, 0x98, 0xa2, 0xbd, 0x25, 0x55, 0xd1, 0xaa, 0x8c, 0xb0, 0x8e, 0x48,
 511     0x59, 0x0d, 0xbb, 0x3d, 0xa7, 0xb0, 0x8b, 0x10, 0x56, 0x82, 0x88, 0x38,
 512     0xc5, 0xf6, 0x1e, 0x63, 0x93, 0xba, 0x7a, 0x0a, 0xbc, 0xc9, 0xf6, 0x62
 513 };
 514
 515 static const unsigned char gcmAAD[] = {
 516     0xfe, 0xed, 0xfa, 0xce, 0xde, 0xad, 0xbe, 0xef, 0xfe, 0xed, 0xfa, 0xce,
 517     0xde, 0xad, 0xbe, 0xef, 0xab, 0xad, 0xda, 0xd2
 518 };
 519
 520 static const unsigned char gcmDefaultTag[] = {
 521     0xd0, 0xd1, 0xc8, 0xa7, 0x99, 0x99, 0x6b, 0xf0, 0x26, 0x5b, 0x98, 0xb5,
 522     0xd4, 0x8a, 0xb9, 0x19
 523 };
 524
 525 static const unsigned char gcmResetTag1[] = {
 526     0x3a, 0x33, 0x7d, 0xbf, 0x46, 0xa7, 0x92, 0xc4, 0x5e, 0x45, 0x49, 0x13,
 527     0xfe, 0x2e, 0xa8, 0xf2
 528 };
 529
 530 static const unsigned char gcmResetTag2[] = {
 531     0x76, 0xfc, 0x6e, 0xce, 0x0f, 0x4e, 0x17, 0x68, 0xcd, 0xdf, 0x88, 0x53,
 532     0xbb, 0x2d, 0x55, 0x1b
 533 };
 534
 535 typedef struct APK_DATA_st {
 536     const unsigned char *kder;
 537     size_t size;
 538     const char *keytype;
 539     int evptype;
 540     int check;
 541     int pub_check;
 542     int param_check;
 543     int type; /* 0 for private, 1 for public, 2 for params */
 544 } APK_DATA;
 545
 546 static APK_DATA keydata[] = {
 547     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), "RSA", EVP_PKEY_RSA},
 548     {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), "RSA", EVP_PKEY_RSA},
 549 #ifndef OPENSSL_NO_EC
 550     {kExampleECKeyDER, sizeof(kExampleECKeyDER), "EC", EVP_PKEY_EC}
 551 #endif
 552 };
 553
 554 static APK_DATA keycheckdata[] = {
 555     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), "RSA", EVP_PKEY_RSA, 1, 1, 1,
 556      0},
 557     {kExampleBadRSAKeyDER, sizeof(kExampleBadRSAKeyDER), "RSA", EVP_PKEY_RSA,
 558      0, 1, 1, 0},
 559 #ifndef OPENSSL_NO_EC
 560     {kExampleECKeyDER, sizeof(kExampleECKeyDER), "EC", EVP_PKEY_EC, 1, 1, 1, 0},
 561     /* group is also associated in our pub key */
 562     {kExampleECPubKeyDER, sizeof(kExampleECPubKeyDER), "EC", EVP_PKEY_EC, 0, 1,
 563      1, 1},
 564     {pExampleECParamDER, sizeof(pExampleECParamDER), "EC", EVP_PKEY_EC, 0, 0, 1,
 565      2},
 566     {kExampleED25519KeyDER, sizeof(kExampleED25519KeyDER), "ED25519",
 567      EVP_PKEY_ED25519, 1, 1, 1, 0},
 568     {kExampleED25519PubKeyDER, sizeof(kExampleED25519PubKeyDER), "ED25519",
 569      EVP_PKEY_ED25519, 0, 1, 1, 1},
 570 #endif
 571 };
 572
 573 static EVP_PKEY *load_example_key(const char *keytype,
 574                                   const unsigned char *data, size_t data_len)
 575 {
 576     const unsigned char **pdata = &data;
 577     EVP_PKEY *pkey = NULL;
 578     OSSL_DECODER_CTX *dctx =
 579         OSSL_DECODER_CTX_new_for_pkey(&pkey, "DER", NULL, keytype, 0,
 580                                       testctx, testpropq);
 581
 582     /* |pkey| will be NULL on error */
 583     (void)OSSL_DECODER_from_data(dctx, pdata, &data_len);
 584     OSSL_DECODER_CTX_free(dctx);
 585     return pkey;
 586 }
 587
 588 static EVP_PKEY *load_example_rsa_key(void)
 589 {
 590     return load_example_key("RSA", kExampleRSAKeyDER,
 591                             sizeof(kExampleRSAKeyDER));
 592 }
 593
 594 #ifndef OPENSSL_NO_DSA
 595 static EVP_PKEY *load_example_dsa_key(void)
 596 {
 597     return load_example_key("DSA", kExampleDSAKeyDER,
 598                             sizeof(kExampleDSAKeyDER));
 599 }
 600 #endif
 601
 602 #ifndef OPENSSL_NO_EC
 603 static EVP_PKEY *load_example_ec_key(void)
 604 {
 605     return load_example_key("EC", kExampleECKeyDER,
 606                             sizeof(kExampleECKeyDER));
 607 }
 608 #endif
 609
 610 #ifndef OPENSSL_NO_DEPRECATED_3_0
 611 # ifndef OPENSSL_NO_DH
 612 static EVP_PKEY *load_example_dh_key(void)
 613 {
 614     return load_example_key("DH", kExampleDHKeyDER,
 615                             sizeof(kExampleDHKeyDER));
 616 }
 617 # endif
 618
 619 # ifndef OPENSSL_NO_EC
 620 static EVP_PKEY *load_example_ed25519_key(void)
 621 {
 622     return load_example_key("ED25519", kExampleED25519KeyDER,
 623                             sizeof(kExampleED25519KeyDER));
 624 }
 625
 626 static EVP_PKEY *load_example_x25519_key(void)
 627 {
 628     return load_example_key("X25519", kExampleX25519KeyDER,
 629                             sizeof(kExampleX25519KeyDER));
 630 }
 631 # endif
 632 #endif /* OPENSSL_NO_DEPRECATED_3_0 */
 633
 634 static EVP_PKEY *load_example_hmac_key(void)
 635 {
 636     EVP_PKEY *pkey = NULL;
 637     unsigned char key[] = {
 638         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
 639         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 640         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
 641     };
 642
 643     pkey = EVP_PKEY_new_raw_private_key_ex(testctx, "HMAC",
 644                                            NULL, key, sizeof(key));
 645     if (!TEST_ptr(pkey))
 646         return NULL;
 647
 648     return pkey;
 649 }
 650
 651 static int test_EVP_set_default_properties(void)
 652 {
 653     OSSL_LIB_CTX *ctx;
 654     EVP_MD *md = NULL;
 655     int res = 0;
 656
 657     if (!TEST_ptr(ctx = OSSL_LIB_CTX_new())
 658             || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
 659         goto err;
 660     EVP_MD_free(md);
 661     md = NULL;
 662
 663     if (!TEST_true(EVP_set_default_properties(ctx, "provider=fizzbang"))
 664             || !TEST_ptr_null(md = EVP_MD_fetch(ctx, "sha256", NULL))
 665             || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", "-provider")))
 666         goto err;
 667     EVP_MD_free(md);
 668     md = NULL;
 669
 670     if (!TEST_true(EVP_set_default_properties(ctx, NULL))
 671             || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
 672         goto err;
 673     res = 1;
 674 err:
 675     EVP_MD_free(md);
 676     OSSL_LIB_CTX_free(ctx);
 677     return res;
 678 }
 679
 680 #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_EC)
 681 static EVP_PKEY *make_key_fromdata(char *keytype, OSSL_PARAM *params)
 682 {
 683     EVP_PKEY_CTX *pctx = NULL;
 684     EVP_PKEY *tmp_pkey = NULL, *pkey = NULL;
 685
 686     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, keytype, testpropq)))
 687         goto err;
 688     if (!TEST_int_gt(EVP_PKEY_fromdata_init(pctx), 0)
 689         || !TEST_int_gt(EVP_PKEY_fromdata(pctx, &tmp_pkey, EVP_PKEY_KEYPAIR,
 690                                           params), 0))
 691         goto err;
 692
 693     if (!TEST_ptr(tmp_pkey))
 694         goto err;
 695
 696     pkey = tmp_pkey;
 697     tmp_pkey = NULL;
 698  err:
 699     EVP_PKEY_free(tmp_pkey);
 700     EVP_PKEY_CTX_free(pctx);
 701     return pkey;
 702 }
 703
 704 static int test_selection(EVP_PKEY *pkey, int selection)
 705 {
 706     int testresult = 0;
 707     int ret;
 708     BIO *bio = BIO_new(BIO_s_mem());
 709
 710     ret = PEM_write_bio_PUBKEY(bio, pkey);
 711     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) {
 712         if (!TEST_true(ret))
 713             goto err;
 714     } else {
 715         if (!TEST_false(ret))
 716             goto err;
 717     }
 718     ret = PEM_write_bio_PrivateKey_ex(bio, pkey, NULL, NULL, 0, NULL, NULL,
 719                                       testctx, NULL);
 720     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) {
 721         if (!TEST_true(ret))
 722             goto err;
 723     } else {
 724         if (!TEST_false(ret))
 725             goto err;
 726     }
 727
 728     testresult = 1;
 729  err:
 730     BIO_free(bio);
 731
 732     return testresult;
 733 }
 734 #endif /* !OPENSSL_NO_DH || !OPENSSL_NO_DSA || !OPENSSL_NO_EC */
 735
 736 /*
 737  * Test combinations of private, public, missing and private + public key
 738  * params to ensure they are all accepted
 739  */
 740 #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_DSA)
 741 static int test_EVP_PKEY_ffc_priv_pub(char *keytype)
 742 {
 743     OSSL_PARAM_BLD *bld = NULL;
 744     OSSL_PARAM *params = NULL;
 745     EVP_PKEY *just_params = NULL;
 746     EVP_PKEY *params_and_priv = NULL;
 747     EVP_PKEY *params_and_pub = NULL;
 748     EVP_PKEY *params_and_keypair = NULL;
 749     BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub = NULL, *priv = NULL;
 750     int ret = 0;
 751
 752     /*
 753      * Setup the parameters for our pkey object. For our purposes they don't
 754      * have to actually be *valid* parameters. We just need to set something.
 755      */
 756     if (!TEST_ptr(p = BN_new())
 757         || !TEST_ptr(q = BN_new())
 758         || !TEST_ptr(g = BN_new())
 759         || !TEST_ptr(pub = BN_new())
 760         || !TEST_ptr(priv = BN_new()))
 761         goto err;
 762
 763     /* Test !priv and !pub */
 764     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 765         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
 766         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
 767         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g)))
 768         goto err;
 769     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 770         || !TEST_ptr(just_params = make_key_fromdata(keytype, params)))
 771         goto err;
 772
 773     OSSL_PARAM_free(params);
 774     OSSL_PARAM_BLD_free(bld);
 775     params = NULL;
 776     bld = NULL;
 777
 778     if (!test_selection(just_params, OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
 779         || test_selection(just_params, OSSL_KEYMGMT_SELECT_KEYPAIR))
 780         goto err;
 781
 782     /* Test priv and !pub */
 783     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 784         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
 785         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
 786         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
 787         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
 788                                              priv)))
 789         goto err;
 790     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 791         || !TEST_ptr(params_and_priv = make_key_fromdata(keytype, params)))
 792         goto err;
 793
 794     OSSL_PARAM_free(params);
 795     OSSL_PARAM_BLD_free(bld);
 796     params = NULL;
 797     bld = NULL;
 798
 799     if (!test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_PRIVATE_KEY)
 800         || test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_PUBLIC_KEY))
 801         goto err;
 802
 803     /* Test !priv and pub */
 804     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 805         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
 806         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
 807         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
 808         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
 809                                              pub)))
 810         goto err;
 811     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 812         || !TEST_ptr(params_and_pub = make_key_fromdata(keytype, params)))
 813         goto err;
 814
 815     OSSL_PARAM_free(params);
 816     OSSL_PARAM_BLD_free(bld);
 817     params = NULL;
 818     bld = NULL;
 819
 820     if (!test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PUBLIC_KEY)
 821         || test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PRIVATE_KEY))
 822         goto err;
 823
 824     /* Test priv and pub */
 825     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 826         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
 827         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
 828         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
 829         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
 830                                              pub))
 831         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
 832                                              priv)))
 833         goto err;
 834     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 835         || !TEST_ptr(params_and_keypair = make_key_fromdata(keytype, params)))
 836         goto err;
 837
 838     if (!test_selection(params_and_keypair, EVP_PKEY_KEYPAIR))
 839         goto err;
 840
 841     ret = 1;
 842  err:
 843     OSSL_PARAM_free(params);
 844     OSSL_PARAM_BLD_free(bld);
 845     EVP_PKEY_free(just_params);
 846     EVP_PKEY_free(params_and_priv);
 847     EVP_PKEY_free(params_and_pub);
 848     EVP_PKEY_free(params_and_keypair);
 849     BN_free(p);
 850     BN_free(q);
 851     BN_free(g);
 852     BN_free(pub);
 853     BN_free(priv);
 854
 855     return ret;
 856 }
 857 #endif /* !OPENSSL_NO_DH || !OPENSSL_NO_DSA */
 858
 859 /*
 860  * Test combinations of private, public, missing and private + public key
 861  * params to ensure they are all accepted for EC keys
 862  */
 863 #ifndef OPENSSL_NO_EC
 864 static unsigned char ec_priv[] = {
 865     0xe9, 0x25, 0xf7, 0x66, 0x58, 0xa4, 0xdd, 0x99, 0x61, 0xe7, 0xe8, 0x23,
 866     0x85, 0xc2, 0xe8, 0x33, 0x27, 0xc5, 0x5c, 0xeb, 0xdb, 0x43, 0x9f, 0xd5,
 867     0xf2, 0x5a, 0x75, 0x55, 0xd0, 0x2e, 0x6d, 0x16
 868 };
 869 static unsigned char ec_pub[] = {
 870     0x04, 0xad, 0x11, 0x90, 0x77, 0x4b, 0x46, 0xee, 0x72, 0x51, 0x15, 0x97,
 871     0x4a, 0x6a, 0xa7, 0xaf, 0x59, 0xfa, 0x4b, 0xf2, 0x41, 0xc8, 0x3a, 0x81,
 872     0x23, 0xb6, 0x90, 0x04, 0x6c, 0x67, 0x66, 0xd0, 0xdc, 0xf2, 0x15, 0x1d,
 873     0x41, 0x61, 0xb7, 0x95, 0x85, 0x38, 0x5a, 0x84, 0x56, 0xe8, 0xb3, 0x0e,
 874     0xf5, 0xc6, 0x5d, 0xa4, 0x54, 0x26, 0xb0, 0xf7, 0xa5, 0x4a, 0x33, 0xf1,
 875     0x08, 0x09, 0xb8, 0xdb, 0x03
 876 };
 877
 878 static int test_EC_priv_pub(void)
 879 {
 880     OSSL_PARAM_BLD *bld = NULL;
 881     OSSL_PARAM *params = NULL;
 882     EVP_PKEY *just_params = NULL;
 883     EVP_PKEY *params_and_priv = NULL;
 884     EVP_PKEY *params_and_pub = NULL;
 885     EVP_PKEY *params_and_keypair = NULL;
 886     BIGNUM *priv = NULL;
 887     int ret = 0;
 888
 889     /*
 890      * Setup the parameters for our pkey object. For our purposes they don't
 891      * have to actually be *valid* parameters. We just need to set something.
 892      */
 893     if (!TEST_ptr(priv = BN_bin2bn(ec_priv, sizeof(ec_priv), NULL)))
 894         goto err;
 895
 896     /* Test !priv and !pub */
 897     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 898         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 899                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 900                                                       "P-256", 0)))
 901         goto err;
 902     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 903         || !TEST_ptr(just_params = make_key_fromdata("EC", params)))
 904         goto err;
 905
 906     OSSL_PARAM_free(params);
 907     OSSL_PARAM_BLD_free(bld);
 908     params = NULL;
 909     bld = NULL;
 910
 911     if (!test_selection(just_params, OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
 912         || test_selection(just_params, OSSL_KEYMGMT_SELECT_KEYPAIR))
 913         goto err;
 914
 915     /* Test priv and !pub */
 916     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 917         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 918                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 919                                                       "P-256", 0))
 920         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
 921                                              priv)))
 922         goto err;
 923     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 924         || !TEST_ptr(params_and_priv = make_key_fromdata("EC", params)))
 925         goto err;
 926
 927     OSSL_PARAM_free(params);
 928     OSSL_PARAM_BLD_free(bld);
 929     params = NULL;
 930     bld = NULL;
 931
 932     /*
 933      * We indicate only parameters here, in spite of having built a key that
 934      * has a private part, because the PEM_write_bio_PrivateKey_ex call is
 935      * expected to fail because it does not support exporting a private EC
 936      * key without a corresponding public key
 937      */
 938     if (!test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_ALL_PARAMETERS)
 939         || test_selection(params_and_priv, OSSL_KEYMGMT_SELECT_PUBLIC_KEY))
 940         goto err;
 941
 942     /* Test !priv and pub */
 943     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 944         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 945                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 946                                                       "P-256", 0))
 947         || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
 948                                                        OSSL_PKEY_PARAM_PUB_KEY,
 949                                                        ec_pub, sizeof(ec_pub))))
 950         goto err;
 951     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 952         || !TEST_ptr(params_and_pub = make_key_fromdata("EC", params)))
 953         goto err;
 954
 955     OSSL_PARAM_free(params);
 956     OSSL_PARAM_BLD_free(bld);
 957     params = NULL;
 958     bld = NULL;
 959
 960     if (!test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PUBLIC_KEY)
 961         || test_selection(params_and_pub, OSSL_KEYMGMT_SELECT_PRIVATE_KEY))
 962         goto err;
 963
 964     /* Test priv and pub */
 965     if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
 966         || !TEST_true(OSSL_PARAM_BLD_push_utf8_string(bld,
 967                                                       OSSL_PKEY_PARAM_GROUP_NAME,
 968                                                       "P-256", 0))
 969         || !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
 970                                                        OSSL_PKEY_PARAM_PUB_KEY,
 971                                                        ec_pub, sizeof(ec_pub)))
 972         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
 973                                              priv)))
 974         goto err;
 975     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
 976         || !TEST_ptr(params_and_keypair = make_key_fromdata("EC", params)))
 977         goto err;
 978
 979     if (!test_selection(params_and_keypair, EVP_PKEY_KEYPAIR))
 980         goto err;
 981
 982     /* Try key equality */
 983     if (!TEST_int_gt(EVP_PKEY_parameters_eq(just_params, just_params), 0)
 984         || !TEST_int_gt(EVP_PKEY_parameters_eq(just_params, params_and_pub),
 985                         0)
 986         || !TEST_int_gt(EVP_PKEY_parameters_eq(just_params, params_and_priv),
 987                         0)
 988         || !TEST_int_gt(EVP_PKEY_parameters_eq(just_params, params_and_keypair),
 989                         0)
 990         || !TEST_int_gt(EVP_PKEY_eq(params_and_pub, params_and_pub), 0)
 991         || !TEST_int_gt(EVP_PKEY_eq(params_and_priv, params_and_priv), 0)
 992         || !TEST_int_gt(EVP_PKEY_eq(params_and_keypair, params_and_pub), 0)
 993         || !TEST_int_gt(EVP_PKEY_eq(params_and_keypair, params_and_priv), 0))
 994         goto err;
 995
 996     ret = 1;
 997  err:
 998     OSSL_PARAM_free(params);
 999     OSSL_PARAM_BLD_free(bld);
1000     EVP_PKEY_free(just_params);
1001     EVP_PKEY_free(params_and_priv);
1002     EVP_PKEY_free(params_and_pub);
1003     EVP_PKEY_free(params_and_keypair);
1004     BN_free(priv);
1005
1006     return ret;
1007 }
1008
1009 /* Test that using a legacy EC key with only a private key in it works */
1010 # ifndef OPENSSL_NO_DEPRECATED_3_0
1011 static int test_EC_priv_only_legacy(void)
1012 {
1013     BIGNUM *priv = NULL;
1014     int ret = 0;
1015     EC_KEY *eckey = NULL;
1016     EVP_PKEY *pkey = NULL, *dup_pk = NULL;
1017     EVP_MD_CTX *ctx = NULL;
1018
1019     /* Create the low level EC_KEY */
1020     if (!TEST_ptr(priv = BN_bin2bn(ec_priv, sizeof(ec_priv), NULL)))
1021         goto err;
1022
1023     eckey = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
1024     if (!TEST_ptr(eckey))
1025         goto err;
1026
1027     if (!TEST_true(EC_KEY_set_private_key(eckey, priv)))
1028         goto err;
1029
1030     pkey = EVP_PKEY_new();
1031     if (!TEST_ptr(pkey))
1032         goto err;
1033
1034     if (!TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1035         goto err;
1036     eckey = NULL;
1037
1038     while (dup_pk == NULL) {
1039         ret = 0;
1040         ctx = EVP_MD_CTX_new();
1041         if (!TEST_ptr(ctx))
1042             goto err;
1043
1044         /*
1045          * The EVP_DigestSignInit function should create the key on the
1046          * provider side which is sufficient for this test.
1047          */
1048         if (!TEST_true(EVP_DigestSignInit_ex(ctx, NULL, NULL, testctx,
1049                                              testpropq, pkey, NULL)))
1050             goto err;
1051         EVP_MD_CTX_free(ctx);
1052         ctx = NULL;
1053
1054         if (!TEST_ptr(dup_pk = EVP_PKEY_dup(pkey)))
1055             goto err;
1056         /* EVP_PKEY_eq() returns -2 with missing public keys */
1057         ret = TEST_int_eq(EVP_PKEY_eq(pkey, dup_pk), -2);
1058         EVP_PKEY_free(pkey);
1059         pkey = dup_pk;
1060         if (!ret)
1061             goto err;
1062     }
1063
1064  err:
1065     EVP_MD_CTX_free(ctx);
1066     EVP_PKEY_free(pkey);
1067     EC_KEY_free(eckey);
1068     BN_free(priv);
1069
1070     return ret;
1071 }
1072 # endif /* OPENSSL_NO_DEPRECATED_3_0 */
1073 #endif /* OPENSSL_NO_EC */
1074
1075 static int test_EVP_PKEY_sign(int tst)
1076 {
1077     int ret = 0;
1078     EVP_PKEY *pkey = NULL;
1079     unsigned char *sig = NULL;
1080     size_t sig_len = 0, shortsig_len = 1;
1081     EVP_PKEY_CTX *ctx = NULL;
1082     unsigned char tbs[] = {
1083         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1084         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13
1085     };
1086
1087     if (tst == 0) {
1088         if (!TEST_ptr(pkey = load_example_rsa_key()))
1089                 goto out;
1090     } else if (tst == 1) {
1091 #ifndef OPENSSL_NO_DSA
1092         if (!TEST_ptr(pkey = load_example_dsa_key()))
1093                 goto out;
1094 #else
1095         ret = 1;
1096         goto out;
1097 #endif
1098     } else {
1099 #ifndef OPENSSL_NO_EC
1100         if (!TEST_ptr(pkey = load_example_ec_key()))
1101                 goto out;
1102 #else
1103         ret = 1;
1104         goto out;
1105 #endif
1106     }
1107
1108     ctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, NULL);
1109     if (!TEST_ptr(ctx)
1110             || !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0)
1111             || !TEST_int_gt(EVP_PKEY_sign(ctx, NULL, &sig_len, tbs,
1112                                           sizeof(tbs)), 0))
1113         goto out;
1114     sig = OPENSSL_malloc(sig_len);
1115     if (!TEST_ptr(sig)
1116             /* Test sending a signature buffer that is too short is rejected */
1117             || !TEST_int_le(EVP_PKEY_sign(ctx, sig, &shortsig_len, tbs,
1118                                           sizeof(tbs)), 0)
1119             || !TEST_int_gt(EVP_PKEY_sign(ctx, sig, &sig_len, tbs, sizeof(tbs)),
1120                             0)
1121             /* Test the signature round-trips */
1122             || !TEST_int_gt(EVP_PKEY_verify_init(ctx), 0)
1123             || !TEST_int_gt(EVP_PKEY_verify(ctx, sig, sig_len, tbs, sizeof(tbs)),
1124                             0))
1125         goto out;
1126
1127     ret = 1;
1128  out:
1129     EVP_PKEY_CTX_free(ctx);
1130     OPENSSL_free(sig);
1131     EVP_PKEY_free(pkey);
1132     return ret;
1133 }
1134
1135 /*
1136  * n = 0 => test using legacy cipher
1137  * n = 1 => test using fetched cipher
1138  */
1139 static int test_EVP_Enveloped(int n)
1140 {
1141     int ret = 0;
1142     EVP_CIPHER_CTX *ctx = NULL;
1143     EVP_PKEY *keypair = NULL;
1144     unsigned char *kek = NULL;
1145     unsigned char iv[EVP_MAX_IV_LENGTH];
1146     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
1147     int len, kek_len, ciphertext_len, plaintext_len;
1148     unsigned char ciphertext[32], plaintext[16];
1149     EVP_CIPHER *type = NULL;
1150
1151     if (nullprov != NULL)
1152         return TEST_skip("Test does not support a non-default library context");
1153
1154     if (n == 0)
1155         type = (EVP_CIPHER *)EVP_aes_256_cbc();
1156     else if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, "AES-256-CBC",
1157                                                testpropq)))
1158         goto err;
1159
1160     if (!TEST_ptr(keypair = load_example_rsa_key())
1161             || !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_get_size(keypair)))
1162             || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
1163             || !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
1164                                        &keypair, 1))
1165             || !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
1166                                          msg, sizeof(msg)))
1167             || !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
1168                                         &len)))
1169         goto err;
1170
1171     ciphertext_len += len;
1172
1173     if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
1174             || !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
1175                                          ciphertext, ciphertext_len))
1176             || !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
1177         goto err;
1178
1179     plaintext_len += len;
1180     if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
1181         goto err;
1182
1183     ret = 1;
1184 err:
1185     if (n != 0)
1186         EVP_CIPHER_free(type);
1187     OPENSSL_free(kek);
1188     EVP_PKEY_free(keypair);
1189     EVP_CIPHER_CTX_free(ctx);
1190     return ret;
1191 }
1192
1193 /*
1194  * Test 0: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, RSA)
1195  * Test 1: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, DSA)
1196  * Test 2: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, HMAC)
1197  * Test 3: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, RSA)
1198  * Test 4: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, DSA)
1199  * Test 5: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch diegst, HMAC)
1200  * Test 6: Use an MD BIO to do the Update calls instead (RSA)
1201  * Test 7: Use an MD BIO to do the Update calls instead (DSA)
1202  * Test 8: Use an MD BIO to do the Update calls instead (HMAC)
1203  * Test 9: Use EVP_DigestSign (Implicit fetch digest, RSA, short sig)
1204  * Test 10: Use EVP_DigestSign (Implicit fetch digest, DSA, short sig)
1205  * Test 11: Use EVP_DigestSign (Implicit fetch digest, HMAC, short sig)
1206  * Test 12: Use EVP_DigestSign (Implicit fetch digest, RSA)
1207  * Test 13: Use EVP_DigestSign (Implicit fetch digest, DSA)
1208  * Test 14: Use EVP_DigestSign (Implicit fetch digest, HMAC)
1209  * Test 15-29: Same as above with reinitialization
1210  */
1211 static int test_EVP_DigestSignInit(int tst)
1212 {
1213     int ret = 0;
1214     EVP_PKEY *pkey = NULL;
1215     unsigned char *sig = NULL, *sig2 = NULL;
1216     size_t sig_len = 0, sig2_len = 0, shortsig_len = 1;
1217     EVP_MD_CTX *md_ctx = NULL, *md_ctx_verify = NULL;
1218     EVP_MD_CTX *a_md_ctx = NULL, *a_md_ctx_verify = NULL;
1219     BIO *mdbio = NULL, *membio = NULL;
1220     size_t written;
1221     const EVP_MD *md;
1222     EVP_MD *mdexp = NULL;
1223     int reinit = 0;
1224
1225     if (nullprov != NULL)
1226         return TEST_skip("Test does not support a non-default library context");
1227
1228     if (tst >= 15) {
1229         reinit = 1;
1230         tst -= 15;
1231     }
1232
1233     if (tst >= 6 && tst <= 8) {
1234         membio = BIO_new(BIO_s_mem());
1235         mdbio = BIO_new(BIO_f_md());
1236         if (!TEST_ptr(membio) || !TEST_ptr(mdbio))
1237             goto out;
1238         BIO_push(mdbio, membio);
1239         if (!TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx), 0))
1240             goto out;
1241     } else {
1242         if (!TEST_ptr(a_md_ctx = md_ctx = EVP_MD_CTX_new())
1243                 || !TEST_ptr(a_md_ctx_verify = md_ctx_verify = EVP_MD_CTX_new()))
1244             goto out;
1245     }
1246
1247     if (tst % 3 == 0) {
1248         if (!TEST_ptr(pkey = load_example_rsa_key()))
1249                 goto out;
1250     } else if (tst % 3 == 1) {
1251 #ifndef OPENSSL_NO_DSA
1252         if (!TEST_ptr(pkey = load_example_dsa_key()))
1253                 goto out;
1254 #else
1255         ret = 1;
1256         goto out;
1257 #endif
1258     } else {
1259         if (!TEST_ptr(pkey = load_example_hmac_key()))
1260                 goto out;
1261     }
1262
1263     if (tst >= 3 && tst <= 5)
1264         md = mdexp = EVP_MD_fetch(NULL, "SHA256", NULL);
1265     else
1266         md = EVP_sha256();
1267
1268     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, md, NULL, pkey)))
1269         goto out;
1270
1271     if (reinit && !TEST_true(EVP_DigestSignInit(md_ctx, NULL, NULL, NULL, NULL)))
1272         goto out;
1273
1274     if (tst >= 6 && tst <= 8) {
1275         if (!BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written))
1276             goto out;
1277     } else if (tst < 6) {
1278         if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
1279             goto out;
1280     }
1281
1282     if (tst >= 9) {
1283         /* Determine the size of the signature. */
1284         if (!TEST_true(EVP_DigestSign(md_ctx, NULL, &sig_len, kMsg,
1285                                       sizeof(kMsg)))
1286                 || !TEST_ptr(sig = OPENSSL_malloc(sig_len)))
1287             goto out;
1288         if (tst <= 11) {
1289             /* Test that supply a short sig buffer fails */
1290             if (!TEST_false(EVP_DigestSign(md_ctx, sig, &shortsig_len, kMsg,
1291                                            sizeof(kMsg))))
1292                 goto out;
1293             /*
1294              * We end here because once EVP_DigestSign() has failed you should
1295              * not call it again without re-initing the ctx
1296              */
1297             ret = 1;
1298             goto out;
1299         }
1300         if (!TEST_true(EVP_DigestSign(md_ctx, sig, &sig_len, kMsg,
1301                                       sizeof(kMsg))))
1302             goto out;
1303     } else {
1304         /* Determine the size of the signature. */
1305         if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
1306                 || !TEST_ptr(sig = OPENSSL_malloc(sig_len))
1307                 /*
1308                     * Trying to create a signature with a deliberately short
1309                     * buffer should fail.
1310                     */
1311                 || !TEST_false(EVP_DigestSignFinal(md_ctx, sig, &shortsig_len))
1312                 || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
1313             goto out;
1314     }
1315
1316     /*
1317      * Ensure that the signature round-trips (Verification isn't supported for
1318      * HMAC via EVP_DigestVerify*)
1319      */
1320     if (tst % 3 != 2) {
1321         if (tst >= 6 && tst <= 8) {
1322             if (!TEST_int_gt(BIO_reset(mdbio), 0)
1323                 || !TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx_verify), 0))
1324                 goto out;
1325         }
1326
1327         if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, md,
1328                                             NULL, pkey)))
1329             goto out;
1330
1331         if (tst >= 6 && tst <= 8) {
1332             if (!TEST_true(BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written)))
1333                 goto out;
1334         } else {
1335             if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg,
1336                                                   sizeof(kMsg))))
1337                 goto out;
1338         }
1339         if (!TEST_int_gt(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1340             goto out;
1341
1342         /* Multiple calls to EVP_DigestVerifyFinal should work */
1343         if (!TEST_int_gt(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1344             goto out;
1345     } else {
1346         /*
1347          * For HMAC a doubled call to DigestSignFinal should produce the same
1348          * value as finalization should not happen.
1349          */
1350         if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig2_len))
1351             || !TEST_ptr(sig2 = OPENSSL_malloc(sig2_len))
1352             || !TEST_true(EVP_DigestSignFinal(md_ctx, sig2, &sig2_len)))
1353             goto out;
1354
1355         if (!TEST_mem_eq(sig, sig_len, sig2, sig2_len))
1356             goto out;
1357     }
1358
1359     ret = 1;
1360
1361  out:
1362     BIO_free(membio);
1363     BIO_free(mdbio);
1364     EVP_MD_CTX_free(a_md_ctx);
1365     EVP_MD_CTX_free(a_md_ctx_verify);
1366     EVP_PKEY_free(pkey);
1367     OPENSSL_free(sig);
1368     OPENSSL_free(sig2);
1369     EVP_MD_free(mdexp);
1370
1371     return ret;
1372 }
1373
1374 static int test_EVP_DigestVerifyInit(void)
1375 {
1376     int ret = 0;
1377     EVP_PKEY *pkey = NULL;
1378     EVP_MD_CTX *md_ctx = NULL;
1379
1380     if (nullprov != NULL)
1381         return TEST_skip("Test does not support a non-default library context");
1382
1383     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
1384             || !TEST_ptr(pkey = load_example_rsa_key()))
1385         goto out;
1386
1387     if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
1388             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
1389             || !TEST_int_gt(EVP_DigestVerifyFinal(md_ctx, kSignature,
1390                                                  sizeof(kSignature)), 0))
1391         goto out;
1392
1393     /* test with reinitialization */
1394     if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, NULL, NULL, NULL))
1395             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
1396             || !TEST_int_gt(EVP_DigestVerifyFinal(md_ctx, kSignature,
1397                                                  sizeof(kSignature)), 0))
1398         goto out;
1399     ret = 1;
1400
1401  out:
1402     EVP_MD_CTX_free(md_ctx);
1403     EVP_PKEY_free(pkey);
1404     return ret;
1405 }
1406
1407 #ifndef OPENSSL_NO_SIPHASH
1408 /* test SIPHASH MAC via EVP_PKEY with non-default parameters and reinit */
1409 static int test_siphash_digestsign(void)
1410 {
1411     unsigned char key[16];
1412     unsigned char buf[8], digest[8];
1413     unsigned char expected[8] = {
1414         0x6d, 0x3e, 0x54, 0xc2, 0x2f, 0xf1, 0xfe, 0xe2
1415     };
1416     EVP_PKEY *pkey = NULL;
1417     EVP_MD_CTX *mdctx = NULL;
1418     EVP_PKEY_CTX *ctx = NULL;
1419     int ret = 0;
1420     size_t len = 8;
1421
1422     if (nullprov != NULL)
1423         return TEST_skip("Test does not support a non-default library context");
1424
1425     memset(buf, 0, 8);
1426     memset(key, 1, 16);
1427     if (!TEST_ptr(pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_SIPHASH, NULL,
1428                                                       key, 16)))
1429         goto out;
1430
1431     if (!TEST_ptr(mdctx = EVP_MD_CTX_create()))
1432         goto out;
1433
1434     if (!TEST_true(EVP_DigestSignInit(mdctx, &ctx, NULL, NULL, pkey)))
1435         goto out;
1436     if (!TEST_int_eq(EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_SIGNCTX,
1437                                        EVP_PKEY_CTRL_SET_DIGEST_SIZE,
1438                                        8, NULL), 1))
1439         goto out;
1440     /* reinitialize */
1441     if (!TEST_true(EVP_DigestSignInit(mdctx, NULL, NULL, NULL, NULL)))
1442         goto out;
1443     if (!TEST_true(EVP_DigestSignUpdate(mdctx, buf, 8)))
1444         goto out;
1445     if (!TEST_true(EVP_DigestSignFinal(mdctx, digest, &len)))
1446         goto out;
1447     if (!TEST_mem_eq(digest, len, expected, sizeof(expected)))
1448         goto out;
1449
1450     ret = 1;
1451  out:
1452     EVP_PKEY_free(pkey);
1453     EVP_MD_CTX_free(mdctx);
1454     return ret;
1455 }
1456 #endif
1457
1458 /*
1459  * Test corner cases of EVP_DigestInit/Update/Final API call behavior.
1460  */
1461 static int test_EVP_Digest(void)
1462 {
1463     int ret = 0;
1464     EVP_MD_CTX *md_ctx = NULL;
1465     unsigned char md[EVP_MAX_MD_SIZE];
1466     EVP_MD *sha256 = NULL;
1467     EVP_MD *shake256 = NULL;
1468
1469     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
1470         goto out;
1471
1472     if (!TEST_ptr(sha256 = EVP_MD_fetch(testctx, "sha256", testpropq))
1473             || !TEST_ptr(shake256 = EVP_MD_fetch(testctx, "shake256", testpropq)))
1474         goto out;
1475
1476     if (!TEST_true(EVP_DigestInit_ex(md_ctx, sha256, NULL))
1477             || !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
1478             || !TEST_true(EVP_DigestFinal(md_ctx, md, NULL))
1479             /* EVP_DigestFinal resets the EVP_MD_CTX. */
1480             || !TEST_ptr_eq(EVP_MD_CTX_get0_md(md_ctx), NULL))
1481         goto out;
1482
1483     if (!TEST_true(EVP_DigestInit_ex(md_ctx, sha256, NULL))
1484             || !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
1485             || !TEST_true(EVP_DigestFinal_ex(md_ctx, md, NULL))
1486             /* EVP_DigestFinal_ex does not reset the EVP_MD_CTX. */
1487             || !TEST_ptr(EVP_MD_CTX_get0_md(md_ctx))
1488             /*
1489              * EVP_DigestInit_ex with NULL type should work on
1490              * pre-initialized context.
1491              */
1492             || !TEST_true(EVP_DigestInit_ex(md_ctx, NULL, NULL)))
1493         goto out;
1494
1495     if (!TEST_true(EVP_DigestInit_ex(md_ctx, shake256, NULL))
1496             || !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
1497             || !TEST_true(EVP_DigestFinalXOF(md_ctx, md, sizeof(md)))
1498             /* EVP_DigestFinalXOF does not reset the EVP_MD_CTX. */
1499             || !TEST_ptr(EVP_MD_CTX_get0_md(md_ctx))
1500             || !TEST_true(EVP_DigestInit_ex(md_ctx, NULL, NULL)))
1501         goto out;
1502     ret = 1;
1503
1504  out:
1505     EVP_MD_CTX_free(md_ctx);
1506     EVP_MD_free(sha256);
1507     EVP_MD_free(shake256);
1508     return ret;
1509 }
1510
1511 static int test_EVP_md_null(void)
1512 {
1513     int ret = 0;
1514     EVP_MD_CTX *md_ctx = NULL;
1515     const EVP_MD *md_null = EVP_md_null();
1516     unsigned char md_value[EVP_MAX_MD_SIZE];
1517     unsigned int md_len = sizeof(md_value);
1518
1519     if (nullprov != NULL)
1520         return TEST_skip("Test does not support a non-default library context");
1521
1522     if (!TEST_ptr(md_null)
1523         || !TEST_ptr(md_ctx = EVP_MD_CTX_new()))
1524         goto out;
1525
1526     if (!TEST_true(EVP_DigestInit_ex(md_ctx, md_null, NULL))
1527         || !TEST_true(EVP_DigestUpdate(md_ctx, "test", 4))
1528         || !TEST_true(EVP_DigestFinal_ex(md_ctx, md_value, &md_len)))
1529         goto out;
1530
1531     if (!TEST_uint_eq(md_len, 0))
1532         goto out;
1533
1534     ret = 1;
1535  out:
1536     EVP_MD_CTX_free(md_ctx);
1537     return ret;
1538 }
1539
1540 static int test_d2i_AutoPrivateKey(int i)
1541 {
1542     int ret = 0;
1543     const unsigned char *p;
1544     EVP_PKEY *pkey = NULL;
1545     const APK_DATA *ak = &keydata[i];
1546     const unsigned char *input = ak->kder;
1547     size_t input_len = ak->size;
1548     int expected_id = ak->evptype;
1549
1550     p = input;
1551     if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
1552             || !TEST_ptr_eq(p, input + input_len)
1553             || !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
1554         goto done;
1555
1556     ret = 1;
1557
1558  done:
1559     EVP_PKEY_free(pkey);
1560     return ret;
1561 }
1562
1563 #ifndef OPENSSL_NO_EC
1564
1565 static const unsigned char ec_public_sect163k1_validxy[] = {
1566     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
1567     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
1568     0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
1569     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b,
1570     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
1571     0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
1572 };
1573
1574 static const unsigned char ec_public_sect163k1_badx[] = {
1575     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
1576     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
1577     0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
1578     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b,
1579     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
1580     0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
1581 };
1582
1583 static const unsigned char ec_public_sect163k1_bady[] = {
1584     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
1585     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
1586     0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
1587     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b,
1588     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
1589     0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6
1590 };
1591
1592 static struct ec_der_pub_keys_st {
1593     const unsigned char *der;
1594     size_t len;
1595     int valid;
1596 } ec_der_pub_keys[] = {
1597     { ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 },
1598     { ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 },
1599     { ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 },
1600 };
1601
1602 /*
1603  * Tests the range of the decoded EC char2 public point.
1604  * See ec_GF2m_simple_oct2point().
1605  */
1606 static int test_invalide_ec_char2_pub_range_decode(int id)
1607 {
1608     int ret = 0;
1609     EVP_PKEY *pkey;
1610
1611     pkey = load_example_key("EC", ec_der_pub_keys[id].der,
1612                             ec_der_pub_keys[id].len);
1613
1614     ret = (ec_der_pub_keys[id].valid && TEST_ptr(pkey))
1615           || TEST_ptr_null(pkey);
1616     EVP_PKEY_free(pkey);
1617     return ret;
1618 }
1619
1620 /* Tests loading a bad key in PKCS8 format */
1621 static int test_EVP_PKCS82PKEY(void)
1622 {
1623     int ret = 0;
1624     const unsigned char *derp = kExampleBadECKeyDER;
1625     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
1626     EVP_PKEY *pkey = NULL;
1627
1628     if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
1629                                               sizeof(kExampleBadECKeyDER))))
1630         goto done;
1631
1632     if (!TEST_ptr_eq(derp,
1633                      kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
1634         goto done;
1635
1636     if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
1637         goto done;
1638
1639     ret = 1;
1640
1641  done:
1642     PKCS8_PRIV_KEY_INFO_free(p8inf);
1643     EVP_PKEY_free(pkey);
1644
1645     return ret;
1646 }
1647
1648 #endif
1649 static int test_EVP_PKCS82PKEY_wrong_tag(void)
1650 {
1651     EVP_PKEY *pkey = NULL;
1652     EVP_PKEY *pkey2 = NULL;
1653     BIO *membio = NULL;
1654     char *membuf = NULL;
1655     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
1656     int ok = 0;
1657
1658     if (testctx != NULL)
1659         /* test not supported with non-default context */
1660         return 1;
1661
1662     if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
1663         || !TEST_ptr(pkey = load_example_rsa_key())
1664         || !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
1665                                                 NULL, 0, NULL, NULL),
1666                         0)
1667         || !TEST_int_gt(BIO_get_mem_data(membio, &membuf), 0)
1668         || !TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO_bio(membio, NULL))
1669         || !TEST_ptr(pkey2 = EVP_PKCS82PKEY(p8inf))
1670         || !TEST_int_eq(ERR_peek_last_error(), 0)) {
1671         goto done;
1672     }
1673
1674     ok = 1;
1675  done:
1676     EVP_PKEY_free(pkey);
1677     EVP_PKEY_free(pkey2);
1678     PKCS8_PRIV_KEY_INFO_free(p8inf);
1679     BIO_free_all(membio);
1680     return ok;
1681 }
1682
1683 /* This uses kExampleRSAKeyDER and kExampleRSAKeyPKCS8 to verify encoding */
1684 static int test_privatekey_to_pkcs8(void)
1685 {
1686     EVP_PKEY *pkey = NULL;
1687     BIO *membio = NULL;
1688     char *membuf = NULL;
1689     long membuf_len = 0;
1690     int ok = 0;
1691
1692     if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
1693         || !TEST_ptr(pkey = load_example_rsa_key())
1694         || !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
1695                                                 NULL, 0, NULL, NULL),
1696                         0)
1697         || !TEST_int_gt(membuf_len = BIO_get_mem_data(membio, &membuf), 0)
1698         || !TEST_ptr(membuf)
1699         || !TEST_mem_eq(membuf, (size_t)membuf_len,
1700                         kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8))
1701         /*
1702          * We try to write PEM as well, just to see that it doesn't err, but
1703          * assume that the result is correct.
1704          */
1705         || !TEST_int_gt(PEM_write_bio_PKCS8PrivateKey(membio, pkey, NULL,
1706                                                       NULL, 0, NULL, NULL),
1707                         0))
1708         goto done;
1709
1710     ok = 1;
1711  done:
1712     EVP_PKEY_free(pkey);
1713     BIO_free_all(membio);
1714     return ok;
1715 }
1716
1717 #ifndef OPENSSL_NO_EC
1718 static const struct {
1719     int encoding;
1720     const char *encoding_name;
1721 } ec_encodings[] = {
1722     { OPENSSL_EC_EXPLICIT_CURVE, OSSL_PKEY_EC_ENCODING_EXPLICIT },
1723     { OPENSSL_EC_NAMED_CURVE,    OSSL_PKEY_EC_ENCODING_GROUP }
1724 };
1725
1726 static int ec_export_get_encoding_cb(const OSSL_PARAM params[], void *arg)
1727 {
1728     const OSSL_PARAM *p;
1729     const char *enc_name = NULL;
1730     int *enc = arg;
1731     size_t i;
1732
1733     *enc = -1;
1734
1735     if (!TEST_ptr(p = OSSL_PARAM_locate_const(params,
1736                                               OSSL_PKEY_PARAM_EC_ENCODING))
1737         || !TEST_true(OSSL_PARAM_get_utf8_string_ptr(p, &enc_name)))
1738         return 0;
1739
1740     for (i = 0; i < OSSL_NELEM(ec_encodings); i++) {
1741         if (OPENSSL_strcasecmp(enc_name, ec_encodings[i].encoding_name) == 0) {
1742             *enc = ec_encodings[i].encoding;
1743             break;
1744         }
1745     }
1746
1747     return (*enc != -1);
1748 }
1749
1750 static int test_EC_keygen_with_enc(int idx)
1751 {
1752     EVP_PKEY *params = NULL, *key = NULL;
1753     EVP_PKEY_CTX *pctx = NULL, *kctx = NULL;
1754     int enc;
1755     int ret = 0;
1756
1757     enc = ec_encodings[idx].encoding;
1758
1759     /* Create key parameters */
1760     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "EC", NULL))
1761         || !TEST_int_gt(EVP_PKEY_paramgen_init(pctx), 0)
1762         || !TEST_true(EVP_PKEY_CTX_set_group_name(pctx, "P-256"))
1763         || !TEST_true(EVP_PKEY_CTX_set_ec_param_enc(pctx, enc))
1764         || !TEST_true(EVP_PKEY_paramgen(pctx, &params))
1765         || !TEST_ptr(params))
1766         goto done;
1767
1768     /* Create key */
1769     if (!TEST_ptr(kctx = EVP_PKEY_CTX_new_from_pkey(testctx, params, NULL))
1770         || !TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
1771         || !TEST_true(EVP_PKEY_keygen(kctx, &key))
1772         || !TEST_ptr(key))
1773         goto done;
1774
1775     /* Check that the encoding got all the way into the key */
1776     if (!TEST_true(evp_keymgmt_util_export(key, OSSL_KEYMGMT_SELECT_ALL,
1777                                            ec_export_get_encoding_cb, &enc))
1778         || !TEST_int_eq(enc, ec_encodings[idx].encoding))
1779         goto done;
1780
1781     ret = 1;
1782  done:
1783     EVP_PKEY_free(key);
1784     EVP_PKEY_free(params);
1785     EVP_PKEY_CTX_free(kctx);
1786     EVP_PKEY_CTX_free(pctx);
1787     return ret;
1788 }
1789 #endif
1790
1791 #if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
1792
1793 static int test_EVP_SM2_verify(void)
1794 {
1795     const char *pubkey =
1796         "-----BEGIN PUBLIC KEY-----\n"
1797         "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEp1KLWq1ZE2jmoAnnBJE1LBGxVr18\n"
1798         "YvvqECWCpXfAQ9qUJ+UmthnUPf0iM3SaXKHe6PlLIDyNlWMWb9RUh/yU3g==\n"
1799         "-----END PUBLIC KEY-----\n";
1800
1801     const char *msg = "message digest";
1802     const char *id = "ALICE123@YAHOO.COM";
1803
1804     const uint8_t signature[] = {
1805         0x30, 0x44, 0x02, 0x20, 0x5b, 0xdb, 0xab, 0x81, 0x4f, 0xbb,
1806         0x8b, 0x69, 0xb1, 0x05, 0x9c, 0x99, 0x3b, 0xb2, 0x45, 0x06,
1807         0x4a, 0x30, 0x15, 0x59, 0x84, 0xcd, 0xee, 0x30, 0x60, 0x36,
1808         0x57, 0x87, 0xef, 0x5c, 0xd0, 0xbe, 0x02, 0x20, 0x43, 0x8d,
1809         0x1f, 0xc7, 0x77, 0x72, 0x39, 0xbb, 0x72, 0xe1, 0xfd, 0x07,
1810         0x58, 0xd5, 0x82, 0xc8, 0x2d, 0xba, 0x3b, 0x2c, 0x46, 0x24,
1811         0xe3, 0x50, 0xff, 0x04, 0xc7, 0xa0, 0x71, 0x9f, 0xa4, 0x70
1812     };
1813
1814     int rc = 0;
1815     BIO *bio = NULL;
1816     EVP_PKEY *pkey = NULL;
1817     EVP_MD_CTX *mctx = NULL;
1818     EVP_PKEY_CTX *pctx = NULL;
1819     EVP_MD *sm3 = NULL;
1820
1821     bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
1822     if (!TEST_true(bio != NULL))
1823         goto done;
1824
1825     pkey = PEM_read_bio_PUBKEY_ex(bio, NULL, NULL, NULL, testctx, testpropq);
1826     if (!TEST_true(pkey != NULL))
1827         goto done;
1828
1829     if (!TEST_true(EVP_PKEY_is_a(pkey, "SM2")))
1830         goto done;
1831
1832     if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
1833         goto done;
1834
1835     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq)))
1836         goto done;
1837
1838     EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
1839
1840     if (!TEST_ptr(sm3 = EVP_MD_fetch(testctx, "sm3", testpropq)))
1841         goto done;
1842
1843     if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, sm3, NULL, pkey)))
1844         goto done;
1845
1846     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, id, strlen(id)), 0))
1847         goto done;
1848
1849     if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
1850         goto done;
1851
1852     if (!TEST_int_gt(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature)), 0))
1853         goto done;
1854     rc = 1;
1855
1856  done:
1857     BIO_free(bio);
1858     EVP_PKEY_free(pkey);
1859     EVP_PKEY_CTX_free(pctx);
1860     EVP_MD_CTX_free(mctx);
1861     EVP_MD_free(sm3);
1862     return rc;
1863 }
1864
1865 static int test_EVP_SM2(void)
1866 {
1867     int ret = 0;
1868     EVP_PKEY *pkey = NULL;
1869     EVP_PKEY *pkeyparams = NULL;
1870     EVP_PKEY_CTX *pctx = NULL;
1871     EVP_PKEY_CTX *kctx = NULL;
1872     EVP_PKEY_CTX *sctx = NULL;
1873     size_t sig_len = 0;
1874     unsigned char *sig = NULL;
1875     EVP_MD_CTX *md_ctx = NULL;
1876     EVP_MD_CTX *md_ctx_verify = NULL;
1877     EVP_PKEY_CTX *cctx = NULL;
1878     EVP_MD *check_md = NULL;
1879
1880     uint8_t ciphertext[128];
1881     size_t ctext_len = sizeof(ciphertext);
1882
1883     uint8_t plaintext[8];
1884     size_t ptext_len = sizeof(plaintext);
1885
1886     uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
1887
1888     OSSL_PARAM sparams[2] = {OSSL_PARAM_END, OSSL_PARAM_END};
1889     OSSL_PARAM gparams[2] = {OSSL_PARAM_END, OSSL_PARAM_END};
1890     int i;
1891     char mdname[OSSL_MAX_NAME_SIZE];
1892
1893     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx,
1894                                                     "SM2", testpropq)))
1895         goto done;
1896
1897     if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
1898         goto done;
1899
1900     if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
1901         goto done;
1902
1903     if (!TEST_true(EVP_PKEY_paramgen(pctx, &pkeyparams)))
1904         goto done;
1905
1906     if (!TEST_ptr(kctx = EVP_PKEY_CTX_new_from_pkey(testctx,
1907                                                     pkeyparams, testpropq)))
1908         goto done;
1909
1910     if (!TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0))
1911         goto done;
1912
1913     if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
1914         goto done;
1915
1916     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
1917         goto done;
1918
1919     if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
1920         goto done;
1921
1922     if (!TEST_ptr(sctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq)))
1923         goto done;
1924
1925     EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
1926     EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
1927
1928     if (!TEST_ptr(check_md = EVP_MD_fetch(testctx, "sm3", testpropq)))
1929         goto done;
1930
1931     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, check_md, NULL, pkey)))
1932         goto done;
1933
1934     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
1935         goto done;
1936
1937     if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
1938         goto done;
1939
1940     /* Determine the size of the signature. */
1941     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
1942         goto done;
1943
1944     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
1945         goto done;
1946
1947     if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
1948         goto done;
1949
1950     /* Ensure that the signature round-trips. */
1951
1952     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, check_md, NULL,
1953                                         pkey)))
1954         goto done;
1955
1956     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
1957         goto done;
1958
1959     if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
1960         goto done;
1961
1962     if (!TEST_int_gt(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1963         goto done;
1964
1965     /*
1966      * Try verify again with non-matching 0 length id but ensure that it can
1967      * be set on the context and overrides the previous value.
1968      */
1969
1970     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, check_md, NULL,
1971                                         pkey)))
1972         goto done;
1973
1974     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, NULL, 0), 0))
1975         goto done;
1976
1977     if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
1978         goto done;
1979
1980     if (!TEST_int_eq(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len), 0))
1981         goto done;
1982
1983     /* now check encryption/decryption */
1984
1985     gparams[0] = OSSL_PARAM_construct_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST,
1986                                                   mdname, sizeof(mdname));
1987     for (i = 0; i < 2; i++) {
1988         const char *mdnames[] = {
1989 #ifndef OPENSSL_NO_SM3
1990             "SM3",
1991 #else
1992             NULL,
1993 #endif
1994             "SHA2-256" };
1995         EVP_PKEY_CTX_free(cctx);
1996
1997         if (mdnames[i] == NULL)
1998             continue;
1999
2000         sparams[0] =
2001             OSSL_PARAM_construct_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST,
2002                                              (char *)mdnames[i], 0);
2003
2004         if (!TEST_ptr(cctx = EVP_PKEY_CTX_new_from_pkey(testctx,
2005                                                         pkey, testpropq)))
2006             goto done;
2007
2008         if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
2009             goto done;
2010
2011         if (!TEST_true(EVP_PKEY_CTX_set_params(cctx, sparams)))
2012             goto done;
2013
2014         if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg,
2015                                         sizeof(kMsg))))
2016             goto done;
2017
2018         if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
2019             goto done;
2020
2021         if (!TEST_true(EVP_PKEY_CTX_set_params(cctx, sparams)))
2022             goto done;
2023
2024         if (!TEST_int_gt(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext,
2025                                         ctext_len), 0))
2026             goto done;
2027
2028         if (!TEST_true(EVP_PKEY_CTX_get_params(cctx, gparams)))
2029             goto done;
2030
2031         /*
2032          * Test we're still using the digest we think we are.
2033          * Because of aliases, the easiest is to fetch the digest and
2034          * check the name with EVP_MD_is_a().
2035          */
2036         EVP_MD_free(check_md);
2037         if (!TEST_ptr(check_md = EVP_MD_fetch(testctx, mdname, testpropq)))
2038             goto done;
2039         if (!TEST_true(EVP_MD_is_a(check_md, mdnames[i]))) {
2040             TEST_info("Fetched md %s isn't %s", mdname, mdnames[i]);
2041             goto done;
2042         }
2043
2044         if (!TEST_true(ptext_len == sizeof(kMsg)))
2045             goto done;
2046
2047         if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
2048             goto done;
2049     }
2050
2051     ret = 1;
2052 done:
2053     EVP_PKEY_CTX_free(pctx);
2054     EVP_PKEY_CTX_free(kctx);
2055     EVP_PKEY_CTX_free(sctx);
2056     EVP_PKEY_CTX_free(cctx);
2057     EVP_PKEY_free(pkey);
2058     EVP_PKEY_free(pkeyparams);
2059     EVP_MD_CTX_free(md_ctx);
2060     EVP_MD_CTX_free(md_ctx_verify);
2061     EVP_MD_free(check_md);
2062     OPENSSL_free(sig);
2063     return ret;
2064 }
2065
2066 #endif
2067
2068 static struct keys_st {
2069     int type;
2070     char *priv;
2071     char *pub;
2072 } keys[] = {
2073     {
2074         EVP_PKEY_HMAC, "0123456789", NULL
2075     },
2076     {
2077         EVP_PKEY_HMAC, "", NULL
2078 #ifndef OPENSSL_NO_POLY1305
2079     }, {
2080         EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
2081 #endif
2082 #ifndef OPENSSL_NO_SIPHASH
2083     }, {
2084         EVP_PKEY_SIPHASH, "0123456789012345", NULL
2085 #endif
2086     },
2087 #ifndef OPENSSL_NO_EC
2088     {
2089         EVP_PKEY_X25519, "01234567890123456789012345678901",
2090         "abcdefghijklmnopqrstuvwxyzabcdef"
2091     }, {
2092         EVP_PKEY_ED25519, "01234567890123456789012345678901",
2093         "abcdefghijklmnopqrstuvwxyzabcdef"
2094     }, {
2095         EVP_PKEY_X448,
2096         "01234567890123456789012345678901234567890123456789012345",
2097         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
2098     }, {
2099         EVP_PKEY_ED448,
2100         "012345678901234567890123456789012345678901234567890123456",
2101         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
2102     }
2103 #endif
2104 };
2105
2106 static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
2107 {
2108     int ret = 0;
2109     unsigned char buf[80];
2110     unsigned char *in;
2111     size_t inlen, len = 0, shortlen = 1;
2112     EVP_PKEY *pkey;
2113
2114     /* Check if this algorithm supports public keys */
2115     if (pub && keys[tst].pub == NULL)
2116         return 1;
2117
2118     memset(buf, 0, sizeof(buf));
2119
2120     if (pub) {
2121 #ifndef OPENSSL_NO_EC
2122         inlen = strlen(keys[tst].pub);
2123         in = (unsigned char *)keys[tst].pub;
2124         if (uselibctx) {
2125             pkey = EVP_PKEY_new_raw_public_key_ex(
2126                         testctx,
2127                         OBJ_nid2sn(keys[tst].type),
2128                         NULL,
2129                         in,
2130                         inlen);
2131         } else {
2132             pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
2133                                                NULL,
2134                                                in,
2135                                                inlen);
2136         }
2137 #else
2138         return 1;
2139 #endif
2140     } else {
2141         inlen = strlen(keys[tst].priv);
2142         in = (unsigned char *)keys[tst].priv;
2143         if (uselibctx) {
2144             pkey = EVP_PKEY_new_raw_private_key_ex(
2145                         testctx, OBJ_nid2sn(keys[tst].type),
2146                         NULL,
2147                         in,
2148                         inlen);
2149         } else {
2150             pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
2151                                                 NULL,
2152                                                 in,
2153                                                 inlen);
2154         }
2155     }
2156
2157     if (!TEST_ptr(pkey)
2158             || !TEST_int_eq(EVP_PKEY_eq(pkey, pkey), 1)
2159             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
2160             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
2161             || !TEST_true(len == inlen))
2162         goto done;
2163     if (tst != 1) {
2164         /*
2165          * Test that supplying a buffer that is too small fails. Doesn't apply
2166          * to HMAC with a zero length key
2167          */
2168         if ((!pub && !TEST_false(EVP_PKEY_get_raw_private_key(pkey, buf,
2169                                                                  &shortlen)))
2170                 || (pub && !TEST_false(EVP_PKEY_get_raw_public_key(pkey, buf,
2171                                                                    &shortlen))))
2172             goto done;
2173     }
2174     if ((!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
2175             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
2176             || !TEST_mem_eq(in, inlen, buf, len))
2177         goto done;
2178
2179     ret = 1;
2180  done:
2181     EVP_PKEY_free(pkey);
2182     return ret;
2183 }
2184
2185 static int test_set_get_raw_keys(int tst)
2186 {
2187     return (nullprov != NULL || test_set_get_raw_keys_int(tst, 0, 0))
2188            && test_set_get_raw_keys_int(tst, 0, 1)
2189            && (nullprov != NULL || test_set_get_raw_keys_int(tst, 1, 0))
2190            && test_set_get_raw_keys_int(tst, 1, 1);
2191 }
2192
2193 #ifndef OPENSSL_NO_DEPRECATED_3_0
2194 static int pkey_custom_check(EVP_PKEY *pkey)
2195 {
2196     return 0xbeef;
2197 }
2198
2199 static int pkey_custom_pub_check(EVP_PKEY *pkey)
2200 {
2201     return 0xbeef;
2202 }
2203
2204 static int pkey_custom_param_check(EVP_PKEY *pkey)
2205 {
2206     return 0xbeef;
2207 }
2208
2209 static EVP_PKEY_METHOD *custom_pmeth;
2210 #endif
2211
2212 static int test_EVP_PKEY_check(int i)
2213 {
2214     int ret = 0;
2215     EVP_PKEY *pkey = NULL;
2216     EVP_PKEY_CTX *ctx = NULL;
2217 #ifndef OPENSSL_NO_DEPRECATED_3_0
2218     EVP_PKEY_CTX *ctx2 = NULL;
2219 #endif
2220     const APK_DATA *ak = &keycheckdata[i];
2221     const unsigned char *input = ak->kder;
2222     size_t input_len = ak->size;
2223     int expected_id = ak->evptype;
2224     int expected_check = ak->check;
2225     int expected_pub_check = ak->pub_check;
2226     int expected_param_check = ak->param_check;
2227     int type = ak->type;
2228
2229     if (!TEST_ptr(pkey = load_example_key(ak->keytype, input, input_len)))
2230         goto done;
2231     if (type == 0
2232         && !TEST_int_eq(EVP_PKEY_get_id(pkey), expected_id))
2233         goto done;
2234
2235     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq)))
2236         goto done;
2237
2238     if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
2239         goto done;
2240
2241     if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
2242         goto done;
2243
2244     if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
2245         goto done;
2246
2247 #ifndef OPENSSL_NO_DEPRECATED_3_0
2248     ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
2249     /* assign the pkey directly, as an internal test */
2250     EVP_PKEY_up_ref(pkey);
2251     ctx2->pkey = pkey;
2252
2253     if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
2254         goto done;
2255
2256     if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
2257         goto done;
2258
2259     if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
2260         goto done;
2261 #endif
2262
2263     ret = 1;
2264
2265  done:
2266     EVP_PKEY_CTX_free(ctx);
2267 #ifndef OPENSSL_NO_DEPRECATED_3_0
2268     EVP_PKEY_CTX_free(ctx2);
2269 #endif
2270     EVP_PKEY_free(pkey);
2271     return ret;
2272 }
2273
2274 #ifndef OPENSSL_NO_CMAC
2275 static int get_cmac_val(EVP_PKEY *pkey, unsigned char *mac)
2276 {
2277     EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
2278     const char msg[] = "Hello World";
2279     size_t maclen = AES_BLOCK_SIZE;
2280     int ret = 1;
2281
2282     if (!TEST_ptr(mdctx)
2283             || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, NULL, testctx,
2284                                                 testpropq, pkey, NULL))
2285             || !TEST_true(EVP_DigestSignUpdate(mdctx, msg, sizeof(msg)))
2286             || !TEST_true(EVP_DigestSignFinal(mdctx, mac, &maclen))
2287             || !TEST_size_t_eq(maclen, AES_BLOCK_SIZE))
2288         ret = 0;
2289
2290     EVP_MD_CTX_free(mdctx);
2291
2292     return ret;
2293 }
2294 static int test_CMAC_keygen(void)
2295 {
2296     static unsigned char key[] = {
2297         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
2298         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2299         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
2300     };
2301     EVP_PKEY_CTX *kctx = NULL;
2302     int ret = 0;
2303     EVP_PKEY *pkey = NULL;
2304     unsigned char mac[AES_BLOCK_SIZE];
2305 # if !defined(OPENSSL_NO_DEPRECATED_3_0)
2306     unsigned char mac2[AES_BLOCK_SIZE];
2307 # endif
2308
2309     if (nullprov != NULL)
2310         return TEST_skip("Test does not support a non-default library context");
2311
2312     /*
2313      * This is a legacy method for CMACs, but should still work.
2314      * This verifies that it works without an ENGINE.
2315      */
2316     kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_CMAC, NULL);
2317
2318     /* Test a CMAC key created using the "generated" method */
2319     if (!TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
2320             || !TEST_int_gt(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
2321                                             EVP_PKEY_CTRL_CIPHER,
2322                                             0, (void *)EVP_aes_256_ecb()), 0)
2323             || !TEST_int_gt(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
2324                                             EVP_PKEY_CTRL_SET_MAC_KEY,
2325                                             sizeof(key), (void *)key), 0)
2326             || !TEST_int_gt(EVP_PKEY_keygen(kctx, &pkey), 0)
2327             || !TEST_ptr(pkey)
2328             || !TEST_true(get_cmac_val(pkey, mac)))
2329         goto done;
2330
2331 # if !defined(OPENSSL_NO_DEPRECATED_3_0)
2332     EVP_PKEY_free(pkey);
2333
2334     /*
2335      * Test a CMAC key using the direct method, and compare with the mac
2336      * created above.
2337      */
2338     pkey = EVP_PKEY_new_CMAC_key(NULL, key, sizeof(key), EVP_aes_256_ecb());
2339     if (!TEST_ptr(pkey)
2340             || !TEST_true(get_cmac_val(pkey, mac2))
2341             || !TEST_mem_eq(mac, sizeof(mac), mac2, sizeof(mac2)))
2342         goto done;
2343 # endif
2344
2345     ret = 1;
2346
2347  done:
2348     EVP_PKEY_free(pkey);
2349     EVP_PKEY_CTX_free(kctx);
2350     return ret;
2351 }
2352 #endif
2353
2354 static int test_HKDF(void)
2355 {
2356     EVP_PKEY_CTX *pctx;
2357     unsigned char out[20];
2358     size_t outlen;
2359     int i, ret = 0;
2360     unsigned char salt[] = "0123456789";
2361     unsigned char key[] = "012345678901234567890123456789";
2362     unsigned char info[] = "infostring";
2363     const unsigned char expected[] = {
2364         0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
2365         0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
2366     };
2367     size_t expectedlen = sizeof(expected);
2368
2369     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "HKDF", testpropq)))
2370         goto done;
2371
2372     /* We do this twice to test reuse of the EVP_PKEY_CTX */
2373     for (i = 0; i < 2; i++) {
2374         outlen = sizeof(out);
2375         memset(out, 0, outlen);
2376
2377         if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
2378                 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
2379                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
2380                                                             sizeof(salt) - 1), 0)
2381                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
2382                                                            sizeof(key) - 1), 0)
2383                 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
2384                                                             sizeof(info) - 1), 0)
2385                 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
2386                 || !TEST_mem_eq(out, outlen, expected, expectedlen))
2387             goto done;
2388     }
2389
2390     ret = 1;
2391
2392  done:
2393     EVP_PKEY_CTX_free(pctx);
2394
2395     return ret;
2396 }
2397
2398 static int test_emptyikm_HKDF(void)
2399 {
2400     EVP_PKEY_CTX *pctx;
2401     unsigned char out[20];
2402     size_t outlen;
2403     int ret = 0;
2404     unsigned char salt[] = "9876543210";
2405     unsigned char key[] = "";
2406     unsigned char info[] = "stringinfo";
2407     const unsigned char expected[] = {
2408         0x68, 0x81, 0xa5, 0x3e, 0x5b, 0x9c, 0x7b, 0x6f, 0x2e, 0xec, 0xc8, 0x47,
2409         0x7c, 0xfa, 0x47, 0x35, 0x66, 0x82, 0x15, 0x30
2410     };
2411     size_t expectedlen = sizeof(expected);
2412
2413     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "HKDF", testpropq)))
2414         goto done;
2415
2416     outlen = sizeof(out);
2417     memset(out, 0, outlen);
2418
2419     if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
2420             || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
2421             || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
2422                                                         sizeof(salt) - 1), 0)
2423             || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
2424                                                        sizeof(key) - 1), 0)
2425             || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
2426                                                         sizeof(info) - 1), 0)
2427             || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
2428             || !TEST_mem_eq(out, outlen, expected, expectedlen))
2429         goto done;
2430
2431     ret = 1;
2432
2433  done:
2434     EVP_PKEY_CTX_free(pctx);
2435
2436     return ret;
2437 }
2438
2439 #ifndef OPENSSL_NO_EC
2440 static int test_X509_PUBKEY_inplace(void)
2441 {
2442     int ret = 0;
2443     X509_PUBKEY *xp = X509_PUBKEY_new_ex(testctx, testpropq);
2444     const unsigned char *p = kExampleECPubKeyDER;
2445     size_t input_len = sizeof(kExampleECPubKeyDER);
2446
2447     if (!TEST_ptr(xp))
2448         goto done;
2449     if (!TEST_ptr(d2i_X509_PUBKEY(&xp, &p, input_len)))
2450         goto done;
2451
2452     if (!TEST_ptr(X509_PUBKEY_get0(xp)))
2453         goto done;
2454
2455     p = kExampleBadECPubKeyDER;
2456     input_len = sizeof(kExampleBadECPubKeyDER);
2457
2458     if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
2459         goto done;
2460
2461     if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
2462         goto done;
2463
2464     ret = 1;
2465
2466  done:
2467     X509_PUBKEY_free(xp);
2468     return ret;
2469 }
2470
2471 static int test_X509_PUBKEY_dup(void)
2472 {
2473     int ret = 0;
2474     X509_PUBKEY *xp = NULL, *xq = NULL;
2475     const unsigned char *p = kExampleECPubKeyDER;
2476     size_t input_len = sizeof(kExampleECPubKeyDER);
2477
2478     xp = X509_PUBKEY_new_ex(testctx, testpropq);
2479     if (!TEST_ptr(xp)
2480             || !TEST_ptr(d2i_X509_PUBKEY(&xp, &p, input_len))
2481             || !TEST_ptr(xq = X509_PUBKEY_dup(xp))
2482             || !TEST_ptr_ne(xp, xq))
2483         goto done;
2484
2485     if (!TEST_ptr(X509_PUBKEY_get0(xq))
2486             || !TEST_ptr(X509_PUBKEY_get0(xp))
2487             || !TEST_ptr_ne(X509_PUBKEY_get0(xq), X509_PUBKEY_get0(xp)))
2488         goto done;
2489
2490     X509_PUBKEY_free(xq);
2491     xq = NULL;
2492     p = kExampleBadECPubKeyDER;
2493     input_len = sizeof(kExampleBadECPubKeyDER);
2494
2495     if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len))
2496             || !TEST_ptr(xq = X509_PUBKEY_dup(xp)))
2497         goto done;
2498
2499     X509_PUBKEY_free(xp);
2500     xp = NULL;
2501     if (!TEST_true(X509_PUBKEY_get0(xq) == NULL))
2502         goto done;
2503
2504     ret = 1;
2505
2506  done:
2507     X509_PUBKEY_free(xp);
2508     X509_PUBKEY_free(xq);
2509     return ret;
2510 }
2511 #endif /* OPENSSL_NO_EC */
2512
2513 /* Test getting and setting parameters on an EVP_PKEY_CTX */
2514 static int test_EVP_PKEY_CTX_get_set_params(EVP_PKEY *pkey)
2515 {
2516     EVP_MD_CTX *mdctx = NULL;
2517     EVP_PKEY_CTX *ctx = NULL;
2518     const OSSL_PARAM *params;
2519     OSSL_PARAM ourparams[2], *param = ourparams, *param_md;
2520     int ret = 0;
2521     const EVP_MD *md;
2522     char mdname[OSSL_MAX_NAME_SIZE];
2523     char ssl3ms[48];
2524
2525     /* Initialise a sign operation */
2526     ctx = EVP_PKEY_CTX_new_from_pkey(testctx, pkey, testpropq);
2527     if (!TEST_ptr(ctx)
2528             || !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0))
2529         goto err;
2530
2531     /*
2532      * We should be able to query the parameters now.
2533      */
2534     params = EVP_PKEY_CTX_settable_params(ctx);
2535     if (!TEST_ptr(params)
2536         || !TEST_ptr(OSSL_PARAM_locate_const(params,
2537                                              OSSL_SIGNATURE_PARAM_DIGEST)))
2538         goto err;
2539
2540     params = EVP_PKEY_CTX_gettable_params(ctx);
2541     if (!TEST_ptr(params)
2542         || !TEST_ptr(OSSL_PARAM_locate_const(params,
2543                                              OSSL_SIGNATURE_PARAM_ALGORITHM_ID))
2544         || !TEST_ptr(OSSL_PARAM_locate_const(params,
2545                                              OSSL_SIGNATURE_PARAM_DIGEST)))
2546         goto err;
2547
2548     /*
2549      * Test getting and setting params via EVP_PKEY_CTX_set_params() and
2550      * EVP_PKEY_CTX_get_params()
2551      */
2552     strcpy(mdname, "SHA512");
2553     param_md = param;
2554     *param++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
2555                                                 mdname, 0);
2556     *param++ = OSSL_PARAM_construct_end();
2557
2558     if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams)))
2559         goto err;
2560
2561     mdname[0] = '\0';
2562     *param_md = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
2563                                                  mdname, sizeof(mdname));
2564     if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams))
2565             || !TEST_str_eq(mdname, "SHA512"))
2566         goto err;
2567
2568     /*
2569      * Test the TEST_PKEY_CTX_set_signature_md() and
2570      * TEST_PKEY_CTX_get_signature_md() functions
2571      */
2572     if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0)
2573             || !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0)
2574             || !TEST_ptr_eq(md, EVP_sha256()))
2575         goto err;
2576
2577     /*
2578      * Test getting MD parameters via an associated EVP_PKEY_CTX
2579      */
2580     mdctx = EVP_MD_CTX_new();
2581     if (!TEST_ptr(mdctx)
2582         || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", testctx, testpropq,
2583                                             pkey, NULL)))
2584         goto err;
2585
2586     /*
2587      * We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be
2588      * able to obtain the digest's settable parameters from the provider.
2589      */
2590     params = EVP_MD_CTX_settable_params(mdctx);
2591     if (!TEST_ptr(params)
2592             || !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0)
2593                /* The final key should be NULL */
2594             || !TEST_ptr_null(params[1].key))
2595         goto err;
2596
2597     param = ourparams;
2598     memset(ssl3ms, 0, sizeof(ssl3ms));
2599     *param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
2600                                                  ssl3ms, sizeof(ssl3ms));
2601     *param++ = OSSL_PARAM_construct_end();
2602
2603     if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams)))
2604         goto err;
2605
2606     ret = 1;
2607
2608  err:
2609     EVP_MD_CTX_free(mdctx);
2610     EVP_PKEY_CTX_free(ctx);
2611
2612     return ret;
2613 }
2614
2615 #ifndef OPENSSL_NO_DSA
2616 static int test_DSA_get_set_params(void)
2617 {
2618     OSSL_PARAM_BLD *bld = NULL;
2619     OSSL_PARAM *params = NULL;
2620     BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub = NULL, *priv = NULL;
2621     EVP_PKEY_CTX *pctx = NULL;
2622     EVP_PKEY *pkey = NULL;
2623     int ret = 0;
2624
2625     /*
2626      * Setup the parameters for our DSA object. For our purposes they don't
2627      * have to actually be *valid* parameters. We just need to set something.
2628      */
2629     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "DSA", NULL))
2630         || !TEST_ptr(bld = OSSL_PARAM_BLD_new())
2631         || !TEST_ptr(p = BN_new())
2632         || !TEST_ptr(q = BN_new())
2633         || !TEST_ptr(g = BN_new())
2634         || !TEST_ptr(pub = BN_new())
2635         || !TEST_ptr(priv = BN_new()))
2636         goto err;
2637     if (!TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
2638         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
2639         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
2640         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
2641                                              pub))
2642         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
2643                                              priv)))
2644         goto err;
2645     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
2646         goto err;
2647
2648     if (!TEST_int_gt(EVP_PKEY_fromdata_init(pctx), 0)
2649         || !TEST_int_gt(EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_KEYPAIR,
2650                                           params), 0))
2651         goto err;
2652
2653     if (!TEST_ptr(pkey))
2654         goto err;
2655
2656     ret = test_EVP_PKEY_CTX_get_set_params(pkey);
2657
2658  err:
2659     EVP_PKEY_free(pkey);
2660     EVP_PKEY_CTX_free(pctx);
2661     OSSL_PARAM_free(params);
2662     OSSL_PARAM_BLD_free(bld);
2663     BN_free(p);
2664     BN_free(q);
2665     BN_free(g);
2666     BN_free(pub);
2667     BN_free(priv);
2668
2669     return ret;
2670 }
2671
2672 /*
2673  * Test combinations of private, public, missing and private + public key
2674  * params to ensure they are all accepted
2675  */
2676 static int test_DSA_priv_pub(void)
2677 {
2678     return test_EVP_PKEY_ffc_priv_pub("DSA");
2679 }
2680
2681 #endif /* !OPENSSL_NO_DSA */
2682
2683 static int test_RSA_get_set_params(void)
2684 {
2685     OSSL_PARAM_BLD *bld = NULL;
2686     OSSL_PARAM *params = NULL;
2687     BIGNUM *n = NULL, *e = NULL, *d = NULL;
2688     EVP_PKEY_CTX *pctx = NULL;
2689     EVP_PKEY *pkey = NULL;
2690     int ret = 0;
2691
2692     /*
2693      * Setup the parameters for our RSA object. For our purposes they don't
2694      * have to actually be *valid* parameters. We just need to set something.
2695      */
2696     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "RSA", NULL))
2697         || !TEST_ptr(bld = OSSL_PARAM_BLD_new())
2698         || !TEST_ptr(n = BN_new())
2699         || !TEST_ptr(e = BN_new())
2700         || !TEST_ptr(d = BN_new()))
2701         goto err;
2702     if (!TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
2703         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
2704         || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d)))
2705         goto err;
2706     if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
2707         goto err;
2708
2709     if (!TEST_int_gt(EVP_PKEY_fromdata_init(pctx), 0)
2710         || !TEST_int_gt(EVP_PKEY_fromdata(pctx, &pkey, EVP_PKEY_KEYPAIR,
2711                                           params), 0))
2712         goto err;
2713
2714     if (!TEST_ptr(pkey))
2715         goto err;
2716
2717     ret = test_EVP_PKEY_CTX_get_set_params(pkey);
2718
2719  err:
2720     EVP_PKEY_free(pkey);
2721     EVP_PKEY_CTX_free(pctx);
2722     OSSL_PARAM_free(params);
2723     OSSL_PARAM_BLD_free(bld);
2724     BN_free(n);
2725     BN_free(e);
2726     BN_free(d);
2727
2728     return ret;
2729 }
2730
2731 #if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
2732 static int test_decrypt_null_chunks(void)
2733 {
2734     EVP_CIPHER_CTX* ctx = NULL;
2735     EVP_CIPHER *cipher = NULL;
2736     const unsigned char key[32] = {
2737         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
2738         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2739         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1
2740     };
2741     unsigned char iv[12] = {
2742         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
2743     };
2744     unsigned char msg[] = "It was the best of times, it was the worst of times";
2745     unsigned char ciphertext[80];
2746     unsigned char plaintext[80];
2747     /* We initialise tmp to a non zero value on purpose */
2748     int ctlen, ptlen, tmp = 99;
2749     int ret = 0;
2750     const int enc_offset = 10, dec_offset = 20;
2751
2752     if (!TEST_ptr(cipher = EVP_CIPHER_fetch(testctx, "ChaCha20-Poly1305", testpropq))
2753             || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
2754             || !TEST_true(EVP_EncryptInit_ex(ctx, cipher, NULL,
2755                                              key, iv))
2756             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &ctlen, msg,
2757                                             enc_offset))
2758             /* Deliberate add a zero length update */
2759             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp, NULL,
2760                                             0))
2761             || !TEST_int_eq(tmp, 0)
2762             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp,
2763                                             msg + enc_offset,
2764                                             sizeof(msg) - enc_offset))
2765             || !TEST_int_eq(ctlen += tmp, sizeof(msg))
2766             || !TEST_true(EVP_EncryptFinal(ctx, ciphertext + ctlen, &tmp))
2767             || !TEST_int_eq(tmp, 0))
2768         goto err;
2769
2770     /* Deliberately initialise tmp to a non zero value */
2771     tmp = 99;
2772     if (!TEST_true(EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv))
2773             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext, &ptlen, ciphertext,
2774                                             dec_offset))
2775             /*
2776              * Deliberately add a zero length update. We also deliberately do
2777              * this at a different offset than for encryption.
2778              */
2779             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp, NULL,
2780                                             0))
2781             || !TEST_int_eq(tmp, 0)
2782             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp,
2783                                             ciphertext + dec_offset,
2784                                             ctlen - dec_offset))
2785             || !TEST_int_eq(ptlen += tmp, sizeof(msg))
2786             || !TEST_true(EVP_DecryptFinal(ctx, plaintext + ptlen, &tmp))
2787             || !TEST_int_eq(tmp, 0)
2788             || !TEST_mem_eq(msg, sizeof(msg), plaintext, ptlen))
2789         goto err;
2790
2791     ret = 1;
2792  err:
2793     EVP_CIPHER_CTX_free(ctx);
2794     EVP_CIPHER_free(cipher);
2795     return ret;
2796 }
2797 #endif /* !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) */
2798
2799 #ifndef OPENSSL_NO_DH
2800 /*
2801  * Test combinations of private, public, missing and private + public key
2802  * params to ensure they are all accepted
2803  */
2804 static int test_DH_priv_pub(void)
2805 {
2806     return test_EVP_PKEY_ffc_priv_pub("DH");
2807 }
2808
2809 # ifndef OPENSSL_NO_DEPRECATED_3_0
2810 static int test_EVP_PKEY_set1_DH(void)
2811 {
2812     DH *x942dh = NULL, *noqdh = NULL;
2813     EVP_PKEY *pkey1 = NULL, *pkey2 = NULL;
2814     int ret = 0;
2815     BIGNUM *p, *g = NULL;
2816     BIGNUM *pubkey = NULL;
2817     unsigned char pub[2048 / 8];
2818     size_t len = 0;
2819
2820     if (!TEST_ptr(p = BN_new())
2821             || !TEST_ptr(g = BN_new())
2822             || !TEST_ptr(pubkey = BN_new())
2823             || !TEST_true(BN_set_word(p, 9999))
2824             || !TEST_true(BN_set_word(g, 2))
2825             || !TEST_true(BN_set_word(pubkey, 4321))
2826             || !TEST_ptr(noqdh = DH_new())
2827             || !TEST_true(DH_set0_pqg(noqdh, p, NULL, g))
2828             || !TEST_true(DH_set0_key(noqdh, pubkey, NULL))
2829             || !TEST_ptr(pubkey = BN_new())
2830             || !TEST_true(BN_set_word(pubkey, 4321)))
2831         goto err;
2832     p = g = NULL;
2833
2834     x942dh = DH_get_2048_256();
2835     pkey1 = EVP_PKEY_new();
2836     pkey2 = EVP_PKEY_new();
2837     if (!TEST_ptr(x942dh)
2838             || !TEST_ptr(noqdh)
2839             || !TEST_ptr(pkey1)
2840             || !TEST_ptr(pkey2)
2841             || !TEST_true(DH_set0_key(x942dh, pubkey, NULL)))
2842         goto err;
2843     pubkey = NULL;
2844
2845     if (!TEST_true(EVP_PKEY_set1_DH(pkey1, x942dh))
2846             || !TEST_int_eq(EVP_PKEY_get_id(pkey1), EVP_PKEY_DHX))
2847         goto err;
2848
2849     if (!TEST_true(EVP_PKEY_get_bn_param(pkey1, OSSL_PKEY_PARAM_PUB_KEY,
2850                                          &pubkey))
2851             || !TEST_ptr(pubkey))
2852         goto err;
2853
2854     if (!TEST_true(EVP_PKEY_set1_DH(pkey2, noqdh))
2855             || !TEST_int_eq(EVP_PKEY_get_id(pkey2), EVP_PKEY_DH))
2856         goto err;
2857
2858     if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey2,
2859                                                    OSSL_PKEY_PARAM_PUB_KEY,
2860                                                    pub, sizeof(pub), &len))
2861             || !TEST_size_t_ne(len, 0))
2862         goto err;
2863
2864     ret = 1;
2865  err:
2866     BN_free(p);
2867     BN_free(g);
2868     BN_free(pubkey);
2869     EVP_PKEY_free(pkey1);
2870     EVP_PKEY_free(pkey2);
2871     DH_free(x942dh);
2872     DH_free(noqdh);
2873
2874     return ret;
2875 }
2876 # endif /* !OPENSSL_NO_DEPRECATED_3_0 */
2877 #endif /* !OPENSSL_NO_DH */
2878
2879 /*
2880  * We test what happens with an empty template.  For the sake of this test,
2881  * the template must be ignored, and we know that's the case for RSA keys
2882  * (this might arguably be a misfeature, but that's what we currently do,
2883  * even in provider code, since that's how the legacy RSA implementation
2884  * does things)
2885  */
2886 static int test_keygen_with_empty_template(int n)
2887 {
2888     EVP_PKEY_CTX *ctx = NULL;
2889     EVP_PKEY *pkey = NULL;
2890     EVP_PKEY *tkey = NULL;
2891     int ret = 0;
2892
2893     if (nullprov != NULL)
2894         return TEST_skip("Test does not support a non-default library context");
2895
2896     switch (n) {
2897     case 0:
2898         /* We do test with no template at all as well */
2899         if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
2900             goto err;
2901         break;
2902     case 1:
2903         /* Here we create an empty RSA key that serves as our template */
2904         if (!TEST_ptr(tkey = EVP_PKEY_new())
2905             || !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
2906             || !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
2907             goto err;
2908         break;
2909     }
2910
2911     if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
2912         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
2913         goto err;
2914
2915     ret = 1;
2916  err:
2917     EVP_PKEY_CTX_free(ctx);
2918     EVP_PKEY_free(pkey);
2919     EVP_PKEY_free(tkey);
2920     return ret;
2921 }
2922
2923 /*
2924  * Test that we fail if we attempt to use an algorithm that is not available
2925  * in the current library context (unless we are using an algorithm that
2926  * should be made available via legacy codepaths).
2927  *
2928  * 0:   RSA
2929  * 1:   SM2
2930  */
2931 static int test_pkey_ctx_fail_without_provider(int tst)
2932 {
2933     OSSL_LIB_CTX *tmpctx = OSSL_LIB_CTX_new();
2934     OSSL_PROVIDER *tmpnullprov = NULL;
2935     EVP_PKEY_CTX *pctx = NULL;
2936     const char *keytype = NULL;
2937     int expect_null = 0;
2938     int ret = 0;
2939
2940     if (!TEST_ptr(tmpctx))
2941         goto err;
2942
2943     tmpnullprov = OSSL_PROVIDER_load(tmpctx, "null");
2944     if (!TEST_ptr(tmpnullprov))
2945         goto err;
2946
2947     /*
2948      * We check for certain algos in the null provider.
2949      * If an algo is expected to have a provider keymgmt, constructing an
2950      * EVP_PKEY_CTX is expected to fail (return NULL).
2951      * Otherwise, if it's expected to have legacy support, constructing an
2952      * EVP_PKEY_CTX is expected to succeed (return non-NULL).
2953      */
2954     switch (tst) {
2955     case 0:
2956         keytype = "RSA";
2957         expect_null = 1;
2958         break;
2959     case 1:
2960         keytype = "SM2";
2961         expect_null = 1;
2962 #ifdef OPENSSL_NO_EC
2963         TEST_info("EC disable, skipping SM2 check...");
2964         goto end;
2965 #endif
2966 #ifdef OPENSSL_NO_SM2
2967         TEST_info("SM2 disable, skipping SM2 check...");
2968         goto end;
2969 #endif
2970         break;
2971     default:
2972         TEST_error("No test for case %d", tst);
2973         goto err;
2974     }
2975
2976     pctx = EVP_PKEY_CTX_new_from_name(tmpctx, keytype, "");
2977     if (expect_null ? !TEST_ptr_null(pctx) : !TEST_ptr(pctx))
2978         goto err;
2979
2980 #if defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_SM2)
2981  end:
2982 #endif
2983     ret = 1;
2984
2985  err:
2986     EVP_PKEY_CTX_free(pctx);
2987     OSSL_PROVIDER_unload(tmpnullprov);
2988     OSSL_LIB_CTX_free(tmpctx);
2989     return ret;
2990 }
2991
2992 static int test_rand_agglomeration(void)
2993 {
2994     EVP_RAND *rand;
2995     EVP_RAND_CTX *ctx;
2996     OSSL_PARAM params[3], *p = params;
2997     int res;
2998     unsigned int step = 7;
2999     static unsigned char seed[] = "It does not matter how slowly you go "
3000                                   "as long as you do not stop.";
3001     unsigned char out[sizeof(seed)];
3002
3003     if (!TEST_int_ne(sizeof(seed) % step, 0)
3004             || !TEST_ptr(rand = EVP_RAND_fetch(testctx, "TEST-RAND", testpropq)))
3005         return 0;
3006     ctx = EVP_RAND_CTX_new(rand, NULL);
3007     EVP_RAND_free(rand);
3008     if (!TEST_ptr(ctx))
3009         return 0;
3010
3011     memset(out, 0, sizeof(out));
3012     *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
3013                                              seed, sizeof(seed));
3014     *p++ = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_MAX_REQUEST, &step);
3015     *p = OSSL_PARAM_construct_end();
3016     res = TEST_true(EVP_RAND_CTX_set_params(ctx, params))
3017           && TEST_true(EVP_RAND_generate(ctx, out, sizeof(out), 0, 1, NULL, 0))
3018           && TEST_mem_eq(seed, sizeof(seed), out, sizeof(out));
3019     EVP_RAND_CTX_free(ctx);
3020     return res;
3021 }
3022
3023 /*
3024  * Test that we correctly return the original or "running" IV after
3025  * an encryption operation.
3026  * Run multiple times for some different relevant algorithms/modes.
3027  */
3028 static int test_evp_iv_aes(int idx)
3029 {
3030     int ret = 0;
3031     EVP_CIPHER_CTX *ctx = NULL;
3032     unsigned char key[16] = {0x4c, 0x43, 0xdb, 0xdd, 0x42, 0x73, 0x47, 0xd1,
3033                              0xe5, 0x62, 0x7d, 0xcd, 0x4d, 0x76, 0x4d, 0x57};
3034     unsigned char init_iv[EVP_MAX_IV_LENGTH] =
3035         {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98, 0x82,
3036          0x5a, 0x55, 0x91, 0x81, 0x42, 0xa8, 0x89, 0x34};
3037     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8,
3038                                          9, 10, 11, 12, 13, 14, 15, 16 };
3039     unsigned char ciphertext[32], oiv[16], iv[16];
3040     unsigned char *ref_iv;
3041     unsigned char cbc_state[16] = {0x10, 0x2f, 0x05, 0xcc, 0xc2, 0x55, 0x72, 0xb9,
3042                                    0x88, 0xe6, 0x4a, 0x17, 0x10, 0x74, 0x22, 0x5e};
3043
3044     unsigned char ofb_state[16] = {0x76, 0xe6, 0x66, 0x61, 0xd0, 0x8a, 0xe4, 0x64,
3045                                    0xdd, 0x66, 0xbf, 0x00, 0xf0, 0xe3, 0x6f, 0xfd};
3046     unsigned char cfb_state[16] = {0x77, 0xe4, 0x65, 0x65, 0xd5, 0x8c, 0xe3, 0x6c,
3047                                    0xd4, 0x6c, 0xb4, 0x0c, 0xfd, 0xed, 0x60, 0xed};
3048     unsigned char gcm_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
3049                                    0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
3050     unsigned char ccm_state[7] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98};
3051 #ifndef OPENSSL_NO_OCB
3052     unsigned char ocb_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
3053                                    0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
3054 #endif
3055     int len = sizeof(ciphertext);
3056     size_t ivlen, ref_len;
3057     const EVP_CIPHER *type = NULL;
3058     int iv_reset = 0;
3059
3060     if (nullprov != NULL && idx < 6)
3061         return TEST_skip("Test does not support a non-default library context");
3062
3063     switch (idx) {
3064     case 0:
3065         type = EVP_aes_128_cbc();
3066         /* FALLTHROUGH */
3067     case 6:
3068         type = (type != NULL) ? type :
3069                                 EVP_CIPHER_fetch(testctx, "aes-128-cbc", testpropq);
3070         ref_iv = cbc_state;
3071         ref_len = sizeof(cbc_state);
3072         iv_reset = 1;
3073         break;
3074     case 1:
3075         type = EVP_aes_128_ofb();
3076         /* FALLTHROUGH */
3077     case 7:
3078         type = (type != NULL) ? type :
3079                                 EVP_CIPHER_fetch(testctx, "aes-128-ofb", testpropq);
3080         ref_iv = ofb_state;
3081         ref_len = sizeof(ofb_state);
3082         iv_reset = 1;
3083         break;
3084     case 2:
3085         type = EVP_aes_128_cfb();
3086         /* FALLTHROUGH */
3087     case 8:
3088         type = (type != NULL) ? type :
3089                                 EVP_CIPHER_fetch(testctx, "aes-128-cfb", testpropq);
3090         ref_iv = cfb_state;
3091         ref_len = sizeof(cfb_state);
3092         iv_reset = 1;
3093         break;
3094     case 3:
3095         type = EVP_aes_128_gcm();
3096         /* FALLTHROUGH */
3097     case 9:
3098         type = (type != NULL) ? type :
3099                                 EVP_CIPHER_fetch(testctx, "aes-128-gcm", testpropq);
3100         ref_iv = gcm_state;
3101         ref_len = sizeof(gcm_state);
3102         break;
3103     case 4:
3104         type = EVP_aes_128_ccm();
3105         /* FALLTHROUGH */
3106     case 10:
3107         type = (type != NULL) ? type :
3108                                 EVP_CIPHER_fetch(testctx, "aes-128-ccm", testpropq);
3109         ref_iv = ccm_state;
3110         ref_len = sizeof(ccm_state);
3111         break;
3112 #ifdef OPENSSL_NO_OCB
3113     case 5:
3114     case 11:
3115         return 1;
3116 #else
3117     case 5:
3118         type = EVP_aes_128_ocb();
3119         /* FALLTHROUGH */
3120     case 11:
3121         type = (type != NULL) ? type :
3122                                 EVP_CIPHER_fetch(testctx, "aes-128-ocb", testpropq);
3123         ref_iv = ocb_state;
3124         ref_len = sizeof(ocb_state);
3125         break;
3126 #endif
3127     default:
3128         return 0;
3129     }
3130
3131     if (!TEST_ptr(type)
3132             || !TEST_ptr((ctx = EVP_CIPHER_CTX_new()))
3133             || !TEST_true(EVP_EncryptInit_ex(ctx, type, NULL, key, init_iv))
3134             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &len, msg,
3135                           (int)sizeof(msg)))
3136             || !TEST_true(EVP_CIPHER_CTX_get_original_iv(ctx, oiv, sizeof(oiv)))
3137             || !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv)))
3138             || !TEST_true(EVP_EncryptFinal_ex(ctx, ciphertext, &len)))
3139         goto err;
3140     ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
3141     if (!TEST_mem_eq(init_iv, ivlen, oiv, ivlen)
3142             || !TEST_mem_eq(ref_iv, ref_len, iv, ivlen))
3143         goto err;
3144
3145     /* CBC, OFB, and CFB modes: the updated iv must be reset after reinit */
3146     if (!TEST_true(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL))
3147         || !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv))))
3148         goto err;
3149     if (iv_reset) {
3150         if (!TEST_mem_eq(init_iv, ivlen, iv, ivlen))
3151             goto err;
3152     } else {
3153         if (!TEST_mem_eq(ref_iv, ivlen, iv, ivlen))
3154             goto err;
3155     }
3156
3157     ret = 1;
3158 err:
3159     EVP_CIPHER_CTX_free(ctx);
3160     if (idx >= 6)
3161         EVP_CIPHER_free((EVP_CIPHER *)type);
3162     return ret;
3163 }
3164
3165 #ifndef OPENSSL_NO_DES
3166 static int test_evp_iv_des(int idx)
3167 {
3168     int ret = 0;
3169     EVP_CIPHER_CTX *ctx = NULL;
3170     static const unsigned char key[24] = {
3171         0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
3172         0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86,
3173         0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3174     };
3175     static const unsigned char init_iv[8] = {
3176         0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
3177     };
3178     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8,
3179                                          9, 10, 11, 12, 13, 14, 15, 16 };
3180     unsigned char ciphertext[32], oiv[8], iv[8];
3181     unsigned const char *ref_iv;
3182     static const unsigned char cbc_state_des[8] = {
3183         0x4f, 0xa3, 0x85, 0xcd, 0x8b, 0xf3, 0x06, 0x2a
3184     };
3185     static const unsigned char cbc_state_3des[8] = {
3186         0x35, 0x27, 0x7d, 0x65, 0x6c, 0xfb, 0x50, 0xd9
3187     };
3188     static const unsigned char ofb_state_des[8] = {
3189         0xa7, 0x0d, 0x1d, 0x45, 0xf9, 0x96, 0x3f, 0x2c
3190     };
3191     static const unsigned char ofb_state_3des[8] = {
3192         0xab, 0x16, 0x24, 0xbb, 0x5b, 0xac, 0xed, 0x5e
3193     };
3194     static const unsigned char cfb_state_des[8] = {
3195         0x91, 0xeb, 0x6d, 0x29, 0x4b, 0x08, 0xbd, 0x73
3196     };
3197     static const unsigned char cfb_state_3des[8] = {
3198         0x34, 0xdd, 0xfb, 0x47, 0x33, 0x1c, 0x61, 0xf7
3199     };
3200     int len = sizeof(ciphertext);
3201     size_t ivlen, ref_len;
3202     EVP_CIPHER *type = NULL;
3203
3204     if (lgcyprov == NULL && idx < 3)
3205         return TEST_skip("Test requires legacy provider to be loaded");
3206
3207     switch (idx) {
3208     case 0:
3209         type = EVP_CIPHER_fetch(testctx, "des-cbc", testpropq);
3210         ref_iv = cbc_state_des;
3211         ref_len = sizeof(cbc_state_des);
3212         break;
3213     case 1:
3214         type = EVP_CIPHER_fetch(testctx, "des-ofb", testpropq);
3215         ref_iv = ofb_state_des;
3216         ref_len = sizeof(ofb_state_des);
3217         break;
3218     case 2:
3219         type = EVP_CIPHER_fetch(testctx, "des-cfb", testpropq);
3220         ref_iv = cfb_state_des;
3221         ref_len = sizeof(cfb_state_des);
3222         break;
3223     case 3:
3224         type = EVP_CIPHER_fetch(testctx, "des-ede3-cbc", testpropq);
3225         ref_iv = cbc_state_3des;
3226         ref_len = sizeof(cbc_state_3des);
3227         break;
3228     case 4:
3229         type = EVP_CIPHER_fetch(testctx, "des-ede3-ofb", testpropq);
3230         ref_iv = ofb_state_3des;
3231         ref_len = sizeof(ofb_state_3des);
3232         break;
3233     case 5:
3234         type = EVP_CIPHER_fetch(testctx, "des-ede3-cfb", testpropq);
3235         ref_iv = cfb_state_3des;
3236         ref_len = sizeof(cfb_state_3des);
3237         break;
3238     default:
3239         return 0;
3240     }
3241
3242     if (!TEST_ptr(type)
3243             || !TEST_ptr((ctx = EVP_CIPHER_CTX_new()))
3244             || !TEST_true(EVP_EncryptInit_ex(ctx, type, NULL, key, init_iv))
3245             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &len, msg,
3246                           (int)sizeof(msg)))
3247             || !TEST_true(EVP_CIPHER_CTX_get_original_iv(ctx, oiv, sizeof(oiv)))
3248             || !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv)))
3249             || !TEST_true(EVP_EncryptFinal_ex(ctx, ciphertext, &len)))
3250         goto err;
3251     ivlen = EVP_CIPHER_CTX_get_iv_length(ctx);
3252     if (!TEST_mem_eq(init_iv, ivlen, oiv, ivlen)
3253             || !TEST_mem_eq(ref_iv, ref_len, iv, ivlen))
3254         goto err;
3255
3256     if (!TEST_true(EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, NULL))
3257         || !TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv))))
3258         goto err;
3259     if (!TEST_mem_eq(init_iv, ivlen, iv, ivlen))
3260         goto err;
3261
3262     ret = 1;
3263 err:
3264     EVP_CIPHER_CTX_free(ctx);
3265     EVP_CIPHER_free(type);
3266     return ret;
3267 }
3268 #endif
3269
3270 #ifndef OPENSSL_NO_EC
3271 static int ecpub_nids[] = {
3272     NID_brainpoolP256r1, NID_X9_62_prime256v1,
3273     NID_secp384r1, NID_secp521r1,
3274 # ifndef OPENSSL_NO_EC2M
3275     NID_sect233k1, NID_sect233r1, NID_sect283r1,
3276     NID_sect409k1, NID_sect409r1, NID_sect571k1, NID_sect571r1,
3277 # endif
3278     NID_brainpoolP384r1, NID_brainpoolP512r1
3279 };
3280
3281 static int test_ecpub(int idx)
3282 {
3283     int ret = 0, len, savelen;
3284     int nid;
3285     unsigned char buf[1024];
3286     unsigned char *p;
3287     EVP_PKEY *pkey = NULL;
3288     EVP_PKEY_CTX *ctx = NULL;
3289 # ifndef OPENSSL_NO_DEPRECATED_3_0
3290     const unsigned char *q;
3291     EVP_PKEY *pkey2 = NULL;
3292     EC_KEY *ec = NULL;
3293 # endif
3294
3295     if (nullprov != NULL)
3296         return TEST_skip("Test does not support a non-default library context");
3297
3298     nid = ecpub_nids[idx];
3299
3300     ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
3301     if (!TEST_ptr(ctx)
3302         || !TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
3303         || !TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid))
3304         || !TEST_true(EVP_PKEY_keygen(ctx, &pkey)))
3305         goto done;
3306     len = i2d_PublicKey(pkey, NULL);
3307     savelen = len;
3308     if (!TEST_int_ge(len, 1)
3309         || !TEST_int_lt(len, 1024))
3310         goto done;
3311     p = buf;
3312     len = i2d_PublicKey(pkey, &p);
3313     if (!TEST_int_ge(len, 1)
3314             || !TEST_int_eq(len, savelen))
3315         goto done;
3316
3317 # ifndef OPENSSL_NO_DEPRECATED_3_0
3318     /* Now try to decode the just-created DER. */
3319     q = buf;
3320     if (!TEST_ptr((pkey2 = EVP_PKEY_new()))
3321             || !TEST_ptr((ec = EC_KEY_new_by_curve_name(nid)))
3322             || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey2, ec)))
3323         goto done;
3324     /* EC_KEY ownership transferred */
3325     ec = NULL;
3326     if (!TEST_ptr(d2i_PublicKey(EVP_PKEY_EC, &pkey2, &q, savelen)))
3327         goto done;
3328     /* The keys should match. */
3329     if (!TEST_int_eq(EVP_PKEY_eq(pkey, pkey2), 1))
3330         goto done;
3331 # endif
3332
3333     ret = 1;
3334
3335  done:
3336     EVP_PKEY_CTX_free(ctx);
3337     EVP_PKEY_free(pkey);
3338 # ifndef OPENSSL_NO_DEPRECATED_3_0
3339     EVP_PKEY_free(pkey2);
3340     EC_KEY_free(ec);
3341 # endif
3342     return ret;
3343 }
3344 #endif
3345
3346 static int test_EVP_rsa_pss_with_keygen_bits(void)
3347 {
3348     int ret = 0;
3349     EVP_PKEY_CTX *ctx = NULL;
3350     EVP_PKEY *pkey = NULL;
3351     EVP_MD *md;
3352
3353     md = EVP_MD_fetch(testctx, "sha256", testpropq);
3354     ret = TEST_ptr(md)
3355         && TEST_ptr((ctx = EVP_PKEY_CTX_new_from_name(testctx, "RSA", testpropq)))
3356         && TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
3357         && TEST_int_gt(EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 512), 0)
3358         && TEST_true(EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx, md))
3359         && TEST_true(EVP_PKEY_keygen(ctx, &pkey));
3360
3361     EVP_MD_free(md);
3362     EVP_PKEY_free(pkey);
3363     EVP_PKEY_CTX_free(ctx);
3364     return ret;
3365 }
3366
3367 static int test_EVP_rsa_pss_set_saltlen(void)
3368 {
3369     int ret = 0;
3370     EVP_PKEY *pkey = NULL;
3371     EVP_PKEY_CTX *pkey_ctx = NULL;
3372     EVP_MD *sha256 = NULL;
3373     EVP_MD_CTX *sha256_ctx = NULL;
3374     int saltlen = 9999; /* buggy EVP_PKEY_CTX_get_rsa_pss_saltlen() didn't update this */
3375     const int test_value = 32;
3376
3377     ret = TEST_ptr(pkey = load_example_rsa_key())
3378         && TEST_ptr(sha256 = EVP_MD_fetch(testctx, "sha256", NULL))
3379         && TEST_ptr(sha256_ctx = EVP_MD_CTX_new())
3380         && TEST_true(EVP_DigestSignInit(sha256_ctx, &pkey_ctx, sha256, NULL, pkey))
3381         && TEST_true(EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING))
3382         && TEST_true(EVP_PKEY_CTX_set_rsa_pss_saltlen(pkey_ctx, test_value))
3383         && TEST_true(EVP_PKEY_CTX_get_rsa_pss_saltlen(pkey_ctx, &saltlen))
3384         && TEST_int_eq(saltlen, test_value);
3385
3386     EVP_MD_CTX_free(sha256_ctx);
3387     EVP_PKEY_free(pkey);
3388     EVP_MD_free(sha256);
3389
3390     return ret;
3391 }
3392
3393 static int success = 1;
3394 static void md_names(const char *name, void *vctx)
3395 {
3396     OSSL_LIB_CTX *ctx = (OSSL_LIB_CTX *)vctx;
3397     /* Force a namemap update */
3398     EVP_CIPHER *aes128 = EVP_CIPHER_fetch(ctx, "AES-128-CBC", NULL);
3399
3400     if (!TEST_ptr(aes128))
3401         success = 0;
3402
3403     EVP_CIPHER_free(aes128);
3404 }
3405
3406 /*
3407  * Test that changing the namemap in a user callback works in a names_do_all
3408  * function.
3409  */
3410 static int test_names_do_all(void)
3411 {
3412     /* We use a custom libctx so that we know the state of the namemap */
3413     OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new();
3414     EVP_MD *sha256 = NULL;
3415     int testresult = 0;
3416
3417     if (!TEST_ptr(ctx))
3418         goto err;
3419
3420     sha256 = EVP_MD_fetch(ctx, "SHA2-256", NULL);
3421     if (!TEST_ptr(sha256))
3422         goto err;
3423
3424     /*
3425      * We loop through all the names for a given digest. This should still work
3426      * even if the namemap changes part way through.
3427      */
3428     if (!TEST_true(EVP_MD_names_do_all(sha256, md_names, ctx)))
3429         goto err;
3430
3431     if (!TEST_true(success))
3432         goto err;
3433
3434     testresult = 1;
3435  err:
3436     EVP_MD_free(sha256);
3437     OSSL_LIB_CTX_free(ctx);
3438     return testresult;
3439 }
3440
3441 typedef struct {
3442     const char *cipher;
3443     const unsigned char *key;
3444     const unsigned char *iv;
3445     const unsigned char *input;
3446     const unsigned char *expected;
3447     const unsigned char *tag;
3448     size_t ivlen; /* 0 if we do not need to set a specific IV len */
3449     size_t inlen;
3450     size_t expectedlen;
3451     size_t taglen;
3452     int keyfirst;
3453     int initenc;
3454     int finalenc;
3455 } EVP_INIT_TEST_st;
3456
3457 static const EVP_INIT_TEST_st evp_init_tests[] = {
3458     {
3459         "aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbPlaintext,
3460         cfbCiphertext, NULL, 0, sizeof(cfbPlaintext), sizeof(cfbCiphertext),
3461         0, 1, 0, 1
3462     },
3463     {
3464         "aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultPlaintext,
3465         gcmDefaultCiphertext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3466         sizeof(gcmDefaultPlaintext), sizeof(gcmDefaultCiphertext),
3467         sizeof(gcmDefaultTag), 1, 0, 1
3468     },
3469     {
3470         "aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbPlaintext,
3471         cfbCiphertext, NULL, 0, sizeof(cfbPlaintext), sizeof(cfbCiphertext),
3472         0, 0, 0, 1
3473     },
3474     {
3475         "aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultPlaintext,
3476         gcmDefaultCiphertext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3477         sizeof(gcmDefaultPlaintext), sizeof(gcmDefaultCiphertext),
3478         sizeof(gcmDefaultTag), 0, 0, 1
3479     },
3480     {
3481         "aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbCiphertext,
3482         cfbPlaintext, NULL, 0, sizeof(cfbCiphertext), sizeof(cfbPlaintext),
3483         0, 1, 1, 0
3484     },
3485     {
3486         "aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultCiphertext,
3487         gcmDefaultPlaintext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3488         sizeof(gcmDefaultCiphertext), sizeof(gcmDefaultPlaintext),
3489         sizeof(gcmDefaultTag), 1, 1, 0
3490     },
3491     {
3492         "aes-128-cfb", kCFBDefaultKey, iCFBIV, cfbCiphertext,
3493         cfbPlaintext, NULL, 0, sizeof(cfbCiphertext), sizeof(cfbPlaintext),
3494         0, 0, 1, 0
3495     },
3496     {
3497         "aes-256-gcm", kGCMDefaultKey, iGCMDefaultIV, gcmDefaultCiphertext,
3498         gcmDefaultPlaintext, gcmDefaultTag, sizeof(iGCMDefaultIV),
3499         sizeof(gcmDefaultCiphertext), sizeof(gcmDefaultPlaintext),
3500         sizeof(gcmDefaultTag), 0, 1, 0
3501     }
3502 };
3503
3504 static int evp_init_seq_set_iv(EVP_CIPHER_CTX *ctx, const EVP_INIT_TEST_st *t)
3505 {
3506     int res = 0;
3507
3508     if (t->ivlen != 0) {
3509         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen, NULL)))
3510             goto err;
3511     }
3512     if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, t->iv, -1)))
3513         goto err;
3514     res = 1;
3515  err:
3516     return res;
3517 }
3518
3519 /*
3520  * Test step-wise cipher initialization via EVP_CipherInit_ex where the
3521  * arguments are given one at a time and a final adjustment to the enc
3522  * parameter sets the correct operation.
3523  */
3524 static int test_evp_init_seq(int idx)
3525 {
3526     int outlen1, outlen2;
3527     int testresult = 0;
3528     unsigned char outbuf[1024];
3529     unsigned char tag[16];
3530     const EVP_INIT_TEST_st *t = &evp_init_tests[idx];
3531     EVP_CIPHER_CTX *ctx = NULL;
3532     EVP_CIPHER *type = NULL;
3533     size_t taglen = sizeof(tag);
3534     char *errmsg = NULL;
3535
3536     ctx = EVP_CIPHER_CTX_new();
3537     if (ctx == NULL) {
3538         errmsg = "CTX_ALLOC";
3539         goto err;
3540     }
3541     if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, t->cipher, testpropq))) {
3542         errmsg = "CIPHER_FETCH";
3543         goto err;
3544     }
3545     if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, NULL, NULL, t->initenc))) {
3546         errmsg = "EMPTY_ENC_INIT";
3547         goto err;
3548     }
3549     if (!TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))) {
3550         errmsg = "PADDING";
3551         goto err;
3552     }
3553     if (t->keyfirst && !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, t->key, NULL, -1))) {
3554         errmsg = "KEY_INIT (before iv)";
3555         goto err;
3556     }
3557     if (!evp_init_seq_set_iv(ctx, t)) {
3558         errmsg = "IV_INIT";
3559         goto err;
3560     }
3561     if (t->keyfirst == 0 &&  !TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, t->key, NULL, -1))) {
3562         errmsg = "KEY_INIT (after iv)";
3563         goto err;
3564     }
3565     if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, t->finalenc))) {
3566         errmsg = "FINAL_ENC_INIT";
3567         goto err;
3568     }
3569     if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
3570         errmsg = "CIPHER_UPDATE";
3571         goto err;
3572     }
3573     if (t->finalenc == 0 && t->tag != NULL) {
3574         /* Set expected tag */
3575         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
3576                                            t->taglen, (void *)t->tag))) {
3577             errmsg = "SET_TAG";
3578             goto err;
3579         }
3580     }
3581     if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3582         errmsg = "CIPHER_FINAL";
3583         goto err;
3584     }
3585     if (!TEST_mem_eq(t->expected, t->expectedlen, outbuf, outlen1 + outlen2)) {
3586         errmsg = "WRONG_RESULT";
3587         goto err;
3588     }
3589     if (t->finalenc != 0 && t->tag != NULL) {
3590         if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag))) {
3591             errmsg = "GET_TAG";
3592             goto err;
3593         }
3594         if (!TEST_mem_eq(t->tag, t->taglen, tag, taglen)) {
3595             errmsg = "TAG_ERROR";
3596             goto err;
3597         }
3598     }
3599     testresult = 1;
3600  err:
3601     if (errmsg != NULL)
3602         TEST_info("evp_init_test %d: %s", idx, errmsg);
3603     EVP_CIPHER_CTX_free(ctx);
3604     EVP_CIPHER_free(type);
3605     return testresult;
3606 }
3607
3608 typedef struct {
3609     const unsigned char *input;
3610     const unsigned char *expected;
3611     size_t inlen;
3612     size_t expectedlen;
3613     int enc;
3614 } EVP_RESET_TEST_st;
3615
3616 static const EVP_RESET_TEST_st evp_reset_tests[] = {
3617     {
3618         cfbPlaintext, cfbCiphertext,
3619         sizeof(cfbPlaintext), sizeof(cfbCiphertext), 1
3620     },
3621     {
3622         cfbCiphertext, cfbPlaintext,
3623         sizeof(cfbCiphertext), sizeof(cfbPlaintext), 0
3624     }
3625 };
3626
3627 /*
3628  * Test a reset of a cipher via EVP_CipherInit_ex after the cipher has already
3629  * been used.
3630  */
3631 static int test_evp_reset(int idx)
3632 {
3633     const EVP_RESET_TEST_st *t = &evp_reset_tests[idx];
3634     int outlen1, outlen2;
3635     int testresult = 0;
3636     unsigned char outbuf[1024];
3637     EVP_CIPHER_CTX *ctx = NULL;
3638     EVP_CIPHER *type = NULL;
3639     char *errmsg = NULL;
3640
3641     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())) {
3642         errmsg = "CTX_ALLOC";
3643         goto err;
3644     }
3645     if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, "aes-128-cfb", testpropq))) {
3646         errmsg = "CIPHER_FETCH";
3647         goto err;
3648     }
3649     if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, kCFBDefaultKey, iCFBIV, t->enc))) {
3650         errmsg = "CIPHER_INIT";
3651         goto err;
3652     }
3653     if (!TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))) {
3654         errmsg = "PADDING";
3655         goto err;
3656     }
3657     if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
3658         errmsg = "CIPHER_UPDATE";
3659         goto err;
3660     }
3661     if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3662         errmsg = "CIPHER_FINAL";
3663         goto err;
3664     }
3665     if (!TEST_mem_eq(t->expected, t->expectedlen, outbuf, outlen1 + outlen2)) {
3666         errmsg = "WRONG_RESULT";
3667         goto err;
3668     }
3669     if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, NULL, -1))) {
3670         errmsg = "CIPHER_REINIT";
3671         goto err;
3672     }
3673     if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, t->input, t->inlen))) {
3674         errmsg = "CIPHER_UPDATE (reinit)";
3675         goto err;
3676     }
3677     if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3678         errmsg = "CIPHER_FINAL (reinit)";
3679         goto err;
3680     }
3681     if (!TEST_mem_eq(t->expected, t->expectedlen, outbuf, outlen1 + outlen2)) {
3682         errmsg = "WRONG_RESULT (reinit)";
3683         goto err;
3684     }
3685     testresult = 1;
3686  err:
3687     if (errmsg != NULL)
3688         TEST_info("test_evp_reset %d: %s", idx, errmsg);
3689     EVP_CIPHER_CTX_free(ctx);
3690     EVP_CIPHER_free(type);
3691     return testresult;
3692 }
3693
3694 typedef struct {
3695     const char *cipher;
3696     int enc;
3697 } EVP_UPDATED_IV_TEST_st;
3698
3699 static const EVP_UPDATED_IV_TEST_st evp_updated_iv_tests[] = {
3700     {
3701         "aes-128-cfb", 1
3702     },
3703     {
3704         "aes-128-cfb", 0
3705     },
3706     {
3707         "aes-128-cfb1", 1
3708     },
3709     {
3710         "aes-128-cfb1", 0
3711     },
3712     {
3713         "aes-128-cfb8", 1
3714     },
3715     {
3716         "aes-128-cfb8", 0
3717     },
3718     {
3719         "aes-128-ofb", 1
3720     },
3721     {
3722         "aes-128-ofb", 0
3723     },
3724     {
3725         "aes-128-ctr", 1
3726     },
3727     {
3728         "aes-128-ctr", 0
3729     },
3730     {
3731         "aes-128-cbc", 1
3732     },
3733     {
3734         "aes-128-cbc", 0
3735     }
3736 };
3737
3738 /*
3739  * Test that the IV in the context is updated during a crypto operation for CFB
3740  * and OFB.
3741  */
3742 static int test_evp_updated_iv(int idx)
3743 {
3744     const EVP_UPDATED_IV_TEST_st *t = &evp_updated_iv_tests[idx];
3745     int outlen1, outlen2;
3746     int testresult = 0;
3747     unsigned char outbuf[1024];
3748     EVP_CIPHER_CTX *ctx = NULL;
3749     EVP_CIPHER *type = NULL;
3750     unsigned char updated_iv[EVP_MAX_IV_LENGTH];
3751     int iv_len;
3752     char *errmsg = NULL;
3753
3754     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())) {
3755         errmsg = "CTX_ALLOC";
3756         goto err;
3757     }
3758     if ((type = EVP_CIPHER_fetch(testctx, t->cipher, testpropq)) == NULL) {
3759         TEST_info("cipher %s not supported, skipping", t->cipher);
3760         goto ok;
3761     }
3762
3763     if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, kCFBDefaultKey, iCFBIV, t->enc))) {
3764         errmsg = "CIPHER_INIT";
3765         goto err;
3766     }
3767     if (!TEST_true(EVP_CIPHER_CTX_set_padding(ctx, 0))) {
3768         errmsg = "PADDING";
3769         goto err;
3770     }
3771     if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, cfbPlaintext, sizeof(cfbPlaintext)))) {
3772         errmsg = "CIPHER_UPDATE";
3773         goto err;
3774     }
3775     if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, updated_iv, sizeof(updated_iv)))) {
3776         errmsg = "CIPHER_CTX_GET_UPDATED_IV";
3777         goto err;
3778     }
3779     if (!TEST_true(iv_len = EVP_CIPHER_CTX_get_iv_length(ctx))) {
3780         errmsg = "CIPHER_CTX_GET_IV_LEN";
3781         goto err;
3782     }
3783     if (!TEST_mem_ne(iCFBIV, sizeof(iCFBIV), updated_iv, iv_len)) {
3784         errmsg = "IV_NOT_UPDATED";
3785         goto err;
3786     }
3787     if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3788         errmsg = "CIPHER_FINAL";
3789         goto err;
3790     }
3791  ok:
3792     testresult = 1;
3793  err:
3794     if (errmsg != NULL)
3795         TEST_info("test_evp_updated_iv %d: %s", idx, errmsg);
3796     EVP_CIPHER_CTX_free(ctx);
3797     EVP_CIPHER_free(type);
3798     return testresult;
3799 }
3800
3801 typedef struct {
3802     const unsigned char *iv1;
3803     const unsigned char *iv2;
3804     const unsigned char *expected1;
3805     const unsigned char *expected2;
3806     const unsigned char *tag1;
3807     const unsigned char *tag2;
3808     size_t ivlen1;
3809     size_t ivlen2;
3810     size_t expectedlen1;
3811     size_t expectedlen2;
3812 } TEST_GCM_IV_REINIT_st;
3813
3814 static const TEST_GCM_IV_REINIT_st gcm_reinit_tests[] = {
3815     {
3816         iGCMResetIV1, iGCMResetIV2, gcmResetCiphertext1, gcmResetCiphertext2,
3817         gcmResetTag1, gcmResetTag2, sizeof(iGCMResetIV1), sizeof(iGCMResetIV2),
3818         sizeof(gcmResetCiphertext1), sizeof(gcmResetCiphertext2)
3819     },
3820     {
3821         iGCMResetIV2, iGCMResetIV1, gcmResetCiphertext2, gcmResetCiphertext1,
3822         gcmResetTag2, gcmResetTag1, sizeof(iGCMResetIV2), sizeof(iGCMResetIV1),
3823         sizeof(gcmResetCiphertext2), sizeof(gcmResetCiphertext1)
3824     }
3825 };
3826
3827 static int test_gcm_reinit(int idx)
3828 {
3829     int outlen1, outlen2, outlen3;
3830     int testresult = 0;
3831     unsigned char outbuf[1024];
3832     unsigned char tag[16];
3833     const TEST_GCM_IV_REINIT_st *t = &gcm_reinit_tests[idx];
3834     EVP_CIPHER_CTX *ctx = NULL;
3835     EVP_CIPHER *type = NULL;
3836     size_t taglen = sizeof(tag);
3837     char *errmsg = NULL;
3838
3839     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())) {
3840         errmsg = "CTX_ALLOC";
3841         goto err;
3842     }
3843     if (!TEST_ptr(type = EVP_CIPHER_fetch(testctx, "aes-256-gcm", testpropq))) {
3844         errmsg = "CIPHER_FETCH";
3845         goto err;
3846     }
3847     if (!TEST_true(EVP_CipherInit_ex(ctx, type, NULL, NULL, NULL, 1))) {
3848         errmsg = "ENC_INIT";
3849         goto err;
3850     }
3851     if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen1, NULL))) {
3852         errmsg = "SET_IVLEN1";
3853         goto err;
3854     }
3855     if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, kGCMResetKey, t->iv1, 1))) {
3856         errmsg = "SET_IV1";
3857         goto err;
3858     }
3859     if (!TEST_true(EVP_CipherUpdate(ctx, NULL, &outlen3, gcmAAD, sizeof(gcmAAD)))) {
3860         errmsg = "AAD1";
3861         goto err;
3862     }
3863     EVP_CIPHER_CTX_set_padding(ctx, 0);
3864     if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, gcmResetPlaintext,
3865                                     sizeof(gcmResetPlaintext)))) {
3866         errmsg = "CIPHER_UPDATE1";
3867         goto err;
3868     }
3869     if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3870         errmsg = "CIPHER_FINAL1";
3871         goto err;
3872     }
3873     if (!TEST_mem_eq(t->expected1, t->expectedlen1, outbuf, outlen1 + outlen2)) {
3874         errmsg = "WRONG_RESULT1";
3875         goto err;
3876     }
3877     if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag))) {
3878         errmsg = "GET_TAG1";
3879         goto err;
3880     }
3881     if (!TEST_mem_eq(t->tag1, taglen, tag, taglen)) {
3882         errmsg = "TAG_ERROR1";
3883         goto err;
3884     }
3885     /* Now reinit */
3886     if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, t->ivlen2, NULL))) {
3887         errmsg = "SET_IVLEN2";
3888         goto err;
3889     }
3890     if (!TEST_true(EVP_CipherInit_ex(ctx, NULL, NULL, NULL, t->iv2, -1))) {
3891         errmsg = "SET_IV2";
3892         goto err;
3893     }
3894     if (!TEST_true(EVP_CipherUpdate(ctx, NULL, &outlen3, gcmAAD, sizeof(gcmAAD)))) {
3895         errmsg = "AAD2";
3896         goto err;
3897     }
3898     if (!TEST_true(EVP_CipherUpdate(ctx, outbuf, &outlen1, gcmResetPlaintext,
3899                                     sizeof(gcmResetPlaintext)))) {
3900         errmsg = "CIPHER_UPDATE2";
3901         goto err;
3902     }
3903     if (!TEST_true(EVP_CipherFinal_ex(ctx, outbuf + outlen1, &outlen2))) {
3904         errmsg = "CIPHER_FINAL2";
3905         goto err;
3906     }
3907     if (!TEST_mem_eq(t->expected2, t->expectedlen2, outbuf, outlen1 + outlen2)) {
3908         errmsg = "WRONG_RESULT2";
3909         goto err;
3910     }
3911     if (!TEST_true(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, taglen, tag))) {
3912         errmsg = "GET_TAG2";
3913         goto err;
3914     }
3915     if (!TEST_mem_eq(t->tag2, taglen, tag, taglen)) {
3916         errmsg = "TAG_ERROR2";
3917         goto err;
3918     }
3919     testresult = 1;
3920  err:
3921     if (errmsg != NULL)
3922         TEST_info("evp_init_test %d: %s", idx, errmsg);
3923     EVP_CIPHER_CTX_free(ctx);
3924     EVP_CIPHER_free(type);
3925     return testresult;
3926 }
3927
3928 #ifndef OPENSSL_NO_DEPRECATED_3_0
3929 static EVP_PKEY_METHOD *custom_pmeth =  NULL;
3930 static const EVP_PKEY_METHOD *orig_pmeth = NULL;
3931
3932 # define EVP_PKEY_CTRL_MY_COMMAND 9999
3933
3934 static int custom_pmeth_init(EVP_PKEY_CTX *ctx)
3935 {
3936     int (*pinit)(EVP_PKEY_CTX *ctx);
3937
3938     EVP_PKEY_meth_get_init(orig_pmeth, &pinit);
3939     return pinit(ctx);
3940 }
3941
3942 static void custom_pmeth_cleanup(EVP_PKEY_CTX *ctx)
3943 {
3944     void (*pcleanup)(EVP_PKEY_CTX *ctx);
3945
3946     EVP_PKEY_meth_get_cleanup(orig_pmeth, &pcleanup);
3947     pcleanup(ctx);
3948 }
3949
3950 static int custom_pmeth_sign(EVP_PKEY_CTX *ctx, unsigned char *out,
3951                              size_t *outlen, const unsigned char *in,
3952                              size_t inlen)
3953 {
3954     int (*psign)(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
3955                  const unsigned char *tbs, size_t tbslen);
3956
3957     EVP_PKEY_meth_get_sign(orig_pmeth, NULL, &psign);
3958     return psign(ctx, out, outlen, in, inlen);
3959 }
3960
3961 static int custom_pmeth_digestsign(EVP_MD_CTX *ctx, unsigned char *sig,
3962                                    size_t *siglen, const unsigned char *tbs,
3963                                    size_t tbslen)
3964 {
3965     int (*pdigestsign)(EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen,
3966                        const unsigned char *tbs, size_t tbslen);
3967
3968     EVP_PKEY_meth_get_digestsign(orig_pmeth, &pdigestsign);
3969     return pdigestsign(ctx, sig, siglen, tbs, tbslen);
3970 }
3971
3972 static int custom_pmeth_derive(EVP_PKEY_CTX *ctx, unsigned char *key,
3973                                size_t *keylen)
3974 {
3975     int (*pderive)(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen);
3976
3977     EVP_PKEY_meth_get_derive(orig_pmeth, NULL, &pderive);
3978     return pderive(ctx, key, keylen);
3979 }
3980
3981 static int custom_pmeth_copy(EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src)
3982 {
3983     int (*pcopy)(EVP_PKEY_CTX *dst, const EVP_PKEY_CTX *src);
3984
3985     EVP_PKEY_meth_get_copy(orig_pmeth, &pcopy);
3986     return pcopy(dst, src);
3987 }
3988
3989 static int ctrl_called;
3990
3991 static int custom_pmeth_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
3992 {
3993     int (*pctrl)(EVP_PKEY_CTX *ctx, int type, int p1, void *p2);
3994
3995     EVP_PKEY_meth_get_ctrl(orig_pmeth, &pctrl, NULL);
3996
3997     if (type == EVP_PKEY_CTRL_MY_COMMAND) {
3998         ctrl_called = 1;
3999         return 1;
4000     }
4001
4002     return pctrl(ctx, type, p1, p2);
4003 }
4004
4005 static int test_custom_pmeth(int idx)
4006 {
4007     EVP_PKEY_CTX *pctx = NULL;
4008     EVP_MD_CTX *ctx = NULL;
4009     EVP_PKEY *pkey = NULL;
4010     int id, orig_id, orig_flags;
4011     int testresult = 0;
4012     size_t reslen;
4013     unsigned char *res = NULL;
4014     unsigned char msg[] = { 'H', 'e', 'l', 'l', 'o' };
4015     const EVP_MD *md = EVP_sha256();
4016     int doderive = 0;
4017
4018     ctrl_called = 0;
4019
4020     /* We call deprecated APIs so this test doesn't support a custom libctx */
4021     if (testctx != NULL)
4022         return 1;
4023
4024     switch (idx) {
4025     case 0:
4026     case 6:
4027         id = EVP_PKEY_RSA;
4028         pkey = load_example_rsa_key();
4029         break;
4030     case 1:
4031     case 7:
4032 # ifndef OPENSSL_NO_DSA
4033         id = EVP_PKEY_DSA;
4034         pkey = load_example_dsa_key();
4035         break;
4036 # else
4037         return 1;
4038 # endif
4039     case 2:
4040     case 8:
4041 # ifndef OPENSSL_NO_EC
4042         id = EVP_PKEY_EC;
4043         pkey = load_example_ec_key();
4044         break;
4045 # else
4046         return 1;
4047 # endif
4048     case 3:
4049     case 9:
4050 # ifndef OPENSSL_NO_EC
4051         id = EVP_PKEY_ED25519;
4052         md = NULL;
4053         pkey = load_example_ed25519_key();
4054         break;
4055 # else
4056         return 1;
4057 # endif
4058     case 4:
4059     case 10:
4060 # ifndef OPENSSL_NO_DH
4061         id = EVP_PKEY_DH;
4062         doderive = 1;
4063         pkey = load_example_dh_key();
4064         break;
4065 # else
4066         return 1;
4067 # endif
4068     case 5:
4069     case 11:
4070 # ifndef OPENSSL_NO_EC
4071         id = EVP_PKEY_X25519;
4072         doderive = 1;
4073         pkey = load_example_x25519_key();
4074         break;
4075 # else
4076         return 1;
4077 # endif
4078     default:
4079         TEST_error("Should not happen");
4080         goto err;
4081     }
4082
4083     if (!TEST_ptr(pkey))
4084         goto err;
4085
4086     if (idx < 6) {
4087         if (!TEST_true(evp_pkey_is_provided(pkey)))
4088             goto err;
4089     } else {
4090         EVP_PKEY *tmp = pkey;
4091
4092         /* Convert to a legacy key */
4093         pkey = EVP_PKEY_new();
4094         if (!TEST_ptr(pkey)) {
4095             pkey = tmp;
4096             goto err;
4097         }
4098         if (!TEST_true(evp_pkey_copy_downgraded(&pkey, tmp))) {
4099             EVP_PKEY_free(tmp);
4100             goto err;
4101         }
4102         EVP_PKEY_free(tmp);
4103         if (!TEST_true(evp_pkey_is_legacy(pkey)))
4104             goto err;
4105     }
4106
4107     if (!TEST_ptr(orig_pmeth = EVP_PKEY_meth_find(id))
4108             || !TEST_ptr(pkey))
4109         goto err;
4110
4111     EVP_PKEY_meth_get0_info(&orig_id, &orig_flags, orig_pmeth);
4112     if (!TEST_int_eq(orig_id, id)
4113             || !TEST_ptr(custom_pmeth = EVP_PKEY_meth_new(id, orig_flags)))
4114         goto err;
4115
4116     if (id == EVP_PKEY_ED25519) {
4117         EVP_PKEY_meth_set_digestsign(custom_pmeth, custom_pmeth_digestsign);
4118     } if (id == EVP_PKEY_DH || id == EVP_PKEY_X25519) {
4119         EVP_PKEY_meth_set_derive(custom_pmeth, NULL, custom_pmeth_derive);
4120     } else {
4121         EVP_PKEY_meth_set_sign(custom_pmeth, NULL, custom_pmeth_sign);
4122     }
4123     if (id != EVP_PKEY_ED25519 && id != EVP_PKEY_X25519) {
4124         EVP_PKEY_meth_set_init(custom_pmeth, custom_pmeth_init);
4125         EVP_PKEY_meth_set_cleanup(custom_pmeth, custom_pmeth_cleanup);
4126         EVP_PKEY_meth_set_copy(custom_pmeth, custom_pmeth_copy);
4127     }
4128     EVP_PKEY_meth_set_ctrl(custom_pmeth, custom_pmeth_ctrl, NULL);
4129     if (!TEST_true(EVP_PKEY_meth_add0(custom_pmeth)))
4130         goto err;
4131
4132     if (doderive) {
4133         pctx = EVP_PKEY_CTX_new(pkey, NULL);
4134         if (!TEST_ptr(pctx)
4135                 || !TEST_int_eq(EVP_PKEY_derive_init(pctx), 1)
4136                 || !TEST_int_ge(EVP_PKEY_CTX_ctrl(pctx, -1, -1,
4137                                                 EVP_PKEY_CTRL_MY_COMMAND, 0, NULL),
4138                                 1)
4139                 || !TEST_int_eq(ctrl_called, 1)
4140                 || !TEST_int_ge(EVP_PKEY_derive_set_peer(pctx, pkey), 1)
4141                 || !TEST_int_ge(EVP_PKEY_derive(pctx, NULL, &reslen), 1)
4142                 || !TEST_ptr(res = OPENSSL_malloc(reslen))
4143                 || !TEST_int_ge(EVP_PKEY_derive(pctx, res, &reslen), 1))
4144             goto err;
4145     } else {
4146         ctx = EVP_MD_CTX_new();
4147         reslen = EVP_PKEY_size(pkey);
4148         res = OPENSSL_malloc(reslen);
4149         if (!TEST_ptr(ctx)
4150                 || !TEST_ptr(res)
4151                 || !TEST_true(EVP_DigestSignInit(ctx, &pctx, md, NULL, pkey))
4152                 || !TEST_int_ge(EVP_PKEY_CTX_ctrl(pctx, -1, -1,
4153                                                 EVP_PKEY_CTRL_MY_COMMAND, 0, NULL),
4154                                 1)
4155                 || !TEST_int_eq(ctrl_called, 1))
4156             goto err;
4157
4158         if (id == EVP_PKEY_ED25519) {
4159             if (!TEST_true(EVP_DigestSign(ctx, res, &reslen, msg, sizeof(msg))))
4160                 goto err;
4161         } else {
4162             if (!TEST_true(EVP_DigestUpdate(ctx, msg, sizeof(msg)))
4163                     || !TEST_true(EVP_DigestSignFinal(ctx, res, &reslen)))
4164                 goto err;
4165         }
4166     }
4167
4168     testresult = 1;
4169  err:
4170     OPENSSL_free(res);
4171     EVP_MD_CTX_free(ctx);
4172     if (doderive)
4173         EVP_PKEY_CTX_free(pctx);
4174     EVP_PKEY_free(pkey);
4175     EVP_PKEY_meth_remove(custom_pmeth);
4176     EVP_PKEY_meth_free(custom_pmeth);
4177     custom_pmeth = NULL;
4178     return testresult;
4179 }
4180
4181 static int test_evp_md_cipher_meth(void)
4182 {
4183     EVP_MD *md = EVP_MD_meth_dup(EVP_sha256());
4184     EVP_CIPHER *ciph = EVP_CIPHER_meth_dup(EVP_aes_128_cbc());
4185     int testresult = 0;
4186
4187     if (!TEST_ptr(md) || !TEST_ptr(ciph))
4188         goto err;
4189
4190     testresult = 1;
4191
4192  err:
4193     EVP_MD_meth_free(md);
4194     EVP_CIPHER_meth_free(ciph);
4195
4196     return testresult;
4197 }
4198
4199 typedef struct {
4200         int data;
4201 } custom_dgst_ctx;
4202
4203 static int custom_md_init_called = 0;
4204 static int custom_md_cleanup_called = 0;
4205
4206 static int custom_md_init(EVP_MD_CTX *ctx)
4207 {
4208     custom_dgst_ctx *p = EVP_MD_CTX_md_data(ctx);
4209
4210     if (p == NULL)
4211         return 0;
4212
4213     custom_md_init_called++;
4214     return 1;
4215 }
4216
4217 static int custom_md_cleanup(EVP_MD_CTX *ctx)
4218 {
4219     custom_dgst_ctx *p = EVP_MD_CTX_md_data(ctx);
4220
4221     if (p == NULL)
4222         /* Nothing to do */
4223         return 1;
4224
4225     custom_md_cleanup_called++;
4226     return 1;
4227 }
4228
4229 static int test_custom_md_meth(void)
4230 {
4231     EVP_MD_CTX *mdctx = NULL;
4232     EVP_MD *tmp = NULL;
4233     char mess[] = "Test Message\n";
4234     unsigned char md_value[EVP_MAX_MD_SIZE];
4235     unsigned int md_len;
4236     int testresult = 0;
4237     int nid;
4238
4239     /*
4240      * We are testing deprecated functions. We don't support a non-default
4241      * library context in this test.
4242      */
4243     if (testctx != NULL)
4244         return 1;
4245
4246     custom_md_init_called = custom_md_cleanup_called = 0;
4247
4248     nid = OBJ_create("1.3.6.1.4.1.16604.998866.1", "custom-md", "custom-md");
4249     if (!TEST_int_ne(nid, NID_undef))
4250         goto err;
4251     tmp = EVP_MD_meth_new(nid, NID_undef);
4252     if (!TEST_ptr(tmp))
4253         goto err;
4254
4255     if (!TEST_true(EVP_MD_meth_set_init(tmp, custom_md_init))
4256             || !TEST_true(EVP_MD_meth_set_cleanup(tmp, custom_md_cleanup))
4257             || !TEST_true(EVP_MD_meth_set_app_datasize(tmp,
4258                                                        sizeof(custom_dgst_ctx))))
4259         goto err;
4260
4261     mdctx = EVP_MD_CTX_new();
4262     if (!TEST_ptr(mdctx)
4263                /*
4264                 * Initing our custom md and then initing another md should
4265                 * result in the init and cleanup functions of the custom md
4266                 * from being called.
4267                 */
4268             || !TEST_true(EVP_DigestInit_ex(mdctx, tmp, NULL))
4269             || !TEST_true(EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL))
4270             || !TEST_true(EVP_DigestUpdate(mdctx, mess, strlen(mess)))
4271             || !TEST_true(EVP_DigestFinal_ex(mdctx, md_value, &md_len))
4272             || !TEST_int_eq(custom_md_init_called, 1)
4273             || !TEST_int_eq(custom_md_cleanup_called, 1))
4274         goto err;
4275
4276     testresult = 1;
4277  err:
4278     EVP_MD_CTX_free(mdctx);
4279     EVP_MD_meth_free(tmp);
4280     return testresult;
4281 }
4282
4283 # ifndef OPENSSL_NO_DYNAMIC_ENGINE
4284 /* Test we can create a signature keys with an associated ENGINE */
4285 static int test_signatures_with_engine(int tst)
4286 {
4287     ENGINE *e;
4288     const char *engine_id = "dasync";
4289     EVP_PKEY *pkey = NULL;
4290     const unsigned char badcmackey[] = { 0x00, 0x01 };
4291     const unsigned char cmackey[] = {
4292         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
4293         0x0c, 0x0d, 0x0e, 0x0f
4294     };
4295     const unsigned char ed25519key[] = {
4296         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
4297         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
4298         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
4299     };
4300     const unsigned char msg[] = { 0x00, 0x01, 0x02, 0x03 };
4301     int testresult = 0;
4302     EVP_MD_CTX *ctx = NULL;
4303     unsigned char *mac = NULL;
4304     size_t maclen = 0;
4305     int ret;
4306
4307 #  ifdef OPENSSL_NO_CMAC
4308     /* Skip CMAC tests in a no-cmac build */
4309     if (tst <= 1)
4310         return 1;
4311 #  endif
4312
4313     if (!TEST_ptr(e = ENGINE_by_id(engine_id)))
4314         return 0;
4315
4316     if (!TEST_true(ENGINE_init(e))) {
4317         ENGINE_free(e);
4318         return 0;
4319     }
4320
4321     switch (tst) {
4322     case 0:
4323         pkey = EVP_PKEY_new_CMAC_key(e, cmackey, sizeof(cmackey),
4324                                      EVP_aes_128_cbc());
4325         break;
4326     case 1:
4327         pkey = EVP_PKEY_new_CMAC_key(e, badcmackey, sizeof(badcmackey),
4328                                      EVP_aes_128_cbc());
4329         break;
4330     case 2:
4331         pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_ED25519, e, ed25519key,
4332                                             sizeof(ed25519key));
4333         break;
4334     default:
4335         TEST_error("Invalid test case");
4336         goto err;
4337     }
4338     if (!TEST_ptr(pkey))
4339         goto err;
4340
4341     if (!TEST_ptr(ctx = EVP_MD_CTX_new()))
4342         goto err;
4343
4344     ret = EVP_DigestSignInit(ctx, NULL, tst == 2 ? NULL : EVP_sha256(), NULL,
4345                              pkey);
4346     if (tst == 0) {
4347         if (!TEST_true(ret))
4348             goto err;
4349
4350         if (!TEST_true(EVP_DigestSignUpdate(ctx, msg, sizeof(msg)))
4351                 || !TEST_true(EVP_DigestSignFinal(ctx, NULL, &maclen)))
4352             goto err;
4353
4354         if (!TEST_ptr(mac = OPENSSL_malloc(maclen)))
4355             goto err;
4356
4357         if (!TEST_true(EVP_DigestSignFinal(ctx, mac, &maclen)))
4358             goto err;
4359     } else {
4360         /* We used a bad key. We expect a failure here */
4361         if (!TEST_false(ret))
4362             goto err;
4363     }
4364
4365     testresult = 1;
4366  err:
4367     EVP_MD_CTX_free(ctx);
4368     OPENSSL_free(mac);
4369     EVP_PKEY_free(pkey);
4370     ENGINE_finish(e);
4371     ENGINE_free(e);
4372
4373     return testresult;
4374 }
4375
4376 static int test_cipher_with_engine(void)
4377 {
4378     ENGINE *e;
4379     const char *engine_id = "dasync";
4380     const unsigned char keyiv[] = {
4381         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
4382         0x0c, 0x0d, 0x0e, 0x0f
4383     };
4384     const unsigned char msg[] = { 0x00, 0x01, 0x02, 0x03 };
4385     int testresult = 0;
4386     EVP_CIPHER_CTX *ctx = NULL, *ctx2 = NULL;
4387     unsigned char buf[AES_BLOCK_SIZE];
4388     int len = 0;
4389
4390     if (!TEST_ptr(e = ENGINE_by_id(engine_id)))
4391         return 0;
4392
4393     if (!TEST_true(ENGINE_init(e))) {
4394         ENGINE_free(e);
4395         return 0;
4396     }
4397
4398     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
4399             || !TEST_ptr(ctx2 = EVP_CIPHER_CTX_new()))
4400         goto err;
4401
4402     if (!TEST_true(EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), e, keyiv, keyiv)))
4403         goto err;
4404
4405     /* Copy the ctx, and complete the operation with the new ctx */
4406     if (!TEST_true(EVP_CIPHER_CTX_copy(ctx2, ctx)))
4407         goto err;
4408
4409     if (!TEST_true(EVP_EncryptUpdate(ctx2, buf, &len, msg, sizeof(msg)))
4410             || !TEST_true(EVP_EncryptFinal_ex(ctx2, buf + len, &len)))
4411         goto err;
4412
4413     testresult = 1;
4414  err:
4415     EVP_CIPHER_CTX_free(ctx);
4416     EVP_CIPHER_CTX_free(ctx2);
4417     ENGINE_finish(e);
4418     ENGINE_free(e);
4419
4420     return testresult;
4421 }
4422 # endif /* OPENSSL_NO_DYNAMIC_ENGINE */
4423 #endif /* OPENSSL_NO_DEPRECATED_3_0 */
4424
4425 static int ecxnids[] = {
4426     NID_X25519,
4427     NID_X448,
4428     NID_ED25519,
4429     NID_ED448
4430 };
4431
4432 /* Test that creating ECX keys with a short private key fails as expected */
4433 static int test_ecx_short_keys(int tst)
4434 {
4435     unsigned char ecxkeydata = 1;
4436     EVP_PKEY *pkey;
4437
4438
4439     pkey = EVP_PKEY_new_raw_private_key(ecxnids[tst], NULL, &ecxkeydata, 1);
4440     if (!TEST_ptr_null(pkey)) {
4441         EVP_PKEY_free(pkey);
4442         return 0;
4443     }
4444     return 1;
4445 }
4446
4447 typedef enum OPTION_choice {
4448     OPT_ERR = -1,
4449     OPT_EOF = 0,
4450     OPT_CONTEXT,
4451     OPT_TEST_ENUM
4452 } OPTION_CHOICE;
4453
4454 const OPTIONS *test_get_options(void)
4455 {
4456     static const OPTIONS options[] = {
4457         OPT_TEST_OPTIONS_DEFAULT_USAGE,
4458         { "context", OPT_CONTEXT, '-', "Explicitly use a non-default library context" },
4459         { NULL }
4460     };
4461     return options;
4462 }
4463
4464 int setup_tests(void)
4465 {
4466     OPTION_CHOICE o;
4467
4468     while ((o = opt_next()) != OPT_EOF) {
4469         switch (o) {
4470         case OPT_CONTEXT:
4471             /* Set up an alternate library context */
4472             testctx = OSSL_LIB_CTX_new();
4473             if (!TEST_ptr(testctx))
4474                 return 0;
4475             /* Swap the libctx to test non-default context only */
4476             nullprov = OSSL_PROVIDER_load(NULL, "null");
4477             deflprov = OSSL_PROVIDER_load(testctx, "default");
4478             lgcyprov = OSSL_PROVIDER_load(testctx, "legacy");
4479             break;
4480         case OPT_TEST_CASES:
4481             break;
4482         default:
4483             return 0;
4484         }
4485     }
4486
4487     ADD_TEST(test_EVP_set_default_properties);
4488     ADD_ALL_TESTS(test_EVP_DigestSignInit, 30);
4489     ADD_TEST(test_EVP_DigestVerifyInit);
4490 #ifndef OPENSSL_NO_SIPHASH
4491     ADD_TEST(test_siphash_digestsign);
4492 #endif
4493     ADD_TEST(test_EVP_Digest);
4494     ADD_TEST(test_EVP_md_null);
4495     ADD_ALL_TESTS(test_EVP_PKEY_sign, 3);
4496     ADD_ALL_TESTS(test_EVP_Enveloped, 2);
4497     ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
4498     ADD_TEST(test_privatekey_to_pkcs8);
4499     ADD_TEST(test_EVP_PKCS82PKEY_wrong_tag);
4500 #ifndef OPENSSL_NO_EC
4501     ADD_TEST(test_EVP_PKCS82PKEY);
4502 #endif
4503 #ifndef OPENSSL_NO_EC
4504     ADD_ALL_TESTS(test_EC_keygen_with_enc, OSSL_NELEM(ec_encodings));
4505 #endif
4506 #if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
4507     ADD_TEST(test_EVP_SM2);
4508     ADD_TEST(test_EVP_SM2_verify);
4509 #endif
4510     ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
4511 #ifndef OPENSSL_NO_DEPRECATED_3_0
4512     custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
4513     if (!TEST_ptr(custom_pmeth))
4514         return 0;
4515     EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
4516     EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
4517     EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
4518     if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
4519         return 0;
4520 #endif
4521     ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
4522 #ifndef OPENSSL_NO_CMAC
4523     ADD_TEST(test_CMAC_keygen);
4524 #endif
4525     ADD_TEST(test_HKDF);
4526     ADD_TEST(test_emptyikm_HKDF);
4527 #ifndef OPENSSL_NO_EC
4528     ADD_TEST(test_X509_PUBKEY_inplace);
4529     ADD_TEST(test_X509_PUBKEY_dup);
4530     ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
4531                   OSSL_NELEM(ec_der_pub_keys));
4532 #endif
4533 #ifndef OPENSSL_NO_DSA
4534     ADD_TEST(test_DSA_get_set_params);
4535     ADD_TEST(test_DSA_priv_pub);
4536 #endif
4537     ADD_TEST(test_RSA_get_set_params);
4538 #if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
4539     ADD_TEST(test_decrypt_null_chunks);
4540 #endif
4541 #ifndef OPENSSL_NO_DH
4542     ADD_TEST(test_DH_priv_pub);
4543 # ifndef OPENSSL_NO_DEPRECATED_3_0
4544     ADD_TEST(test_EVP_PKEY_set1_DH);
4545 # endif
4546 #endif
4547 #ifndef OPENSSL_NO_EC
4548     ADD_TEST(test_EC_priv_pub);
4549 # ifndef OPENSSL_NO_DEPRECATED_3_0
4550     ADD_TEST(test_EC_priv_only_legacy);
4551 # endif
4552 #endif
4553     ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
4554     ADD_ALL_TESTS(test_pkey_ctx_fail_without_provider, 2);
4555
4556     ADD_TEST(test_rand_agglomeration);
4557     ADD_ALL_TESTS(test_evp_iv_aes, 12);
4558 #ifndef OPENSSL_NO_DES
4559     ADD_ALL_TESTS(test_evp_iv_des, 6);
4560 #endif
4561     ADD_TEST(test_EVP_rsa_pss_with_keygen_bits);
4562     ADD_TEST(test_EVP_rsa_pss_set_saltlen);
4563 #ifndef OPENSSL_NO_EC
4564     ADD_ALL_TESTS(test_ecpub, OSSL_NELEM(ecpub_nids));
4565 #endif
4566
4567     ADD_TEST(test_names_do_all);
4568
4569     ADD_ALL_TESTS(test_evp_init_seq, OSSL_NELEM(evp_init_tests));
4570     ADD_ALL_TESTS(test_evp_reset, OSSL_NELEM(evp_reset_tests));
4571     ADD_ALL_TESTS(test_gcm_reinit, OSSL_NELEM(gcm_reinit_tests));
4572     ADD_ALL_TESTS(test_evp_updated_iv, OSSL_NELEM(evp_updated_iv_tests));
4573
4574 #ifndef OPENSSL_NO_DEPRECATED_3_0
4575     ADD_ALL_TESTS(test_custom_pmeth, 12);
4576     ADD_TEST(test_evp_md_cipher_meth);
4577     ADD_TEST(test_custom_md_meth);
4578
4579 # ifndef OPENSSL_NO_DYNAMIC_ENGINE
4580     /* Tests only support the default libctx */
4581     if (testctx == NULL) {
4582 #  ifndef OPENSSL_NO_EC
4583         ADD_ALL_TESTS(test_signatures_with_engine, 3);
4584 #  else
4585         ADD_ALL_TESTS(test_signatures_with_engine, 2);
4586 #  endif
4587         ADD_TEST(test_cipher_with_engine);
4588     }
4589 # endif
4590 #endif
4591
4592     ADD_ALL_TESTS(test_ecx_short_keys, OSSL_NELEM(ecxnids));
4593
4594     return 1;
4595 }
4596
4597 void cleanup_tests(void)
4598 {
4599     OSSL_PROVIDER_unload(nullprov);
4600     OSSL_PROVIDER_unload(deflprov);
4601     OSSL_PROVIDER_unload(lgcyprov);
4602     OSSL_LIB_CTX_free(testctx);
4603 }