test/evp_extra_test.c

   1 /*
   2  * Copyright 2015-2020 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 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <openssl/bio.h>
  14 #include <openssl/conf.h>
  15 #include <openssl/crypto.h>
  16 #include <openssl/err.h>
  17 #include <openssl/evp.h>
  18 #include <openssl/rsa.h>
  19 #include <openssl/x509.h>
  20 #include <openssl/pem.h>
  21 #include <openssl/kdf.h>
  22 #include <openssl/provider.h>
  23 #include <openssl/core_names.h>
  24 #include <openssl/params.h>
  25 #include <openssl/dsa.h>
  26 #include <openssl/dh.h>
  27 #include "testutil.h"
  28 #include "internal/nelem.h"
  29 #include "internal/sizes.h"
  30 #include "crypto/evp.h"
  31
  32 static OPENSSL_CTX *testctx = NULL;
  33
  34 /*
  35  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
  36  * should never use this key anywhere but in an example.
  37  */
  38 static const unsigned char kExampleRSAKeyDER[] = {
  39     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
  40     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
  41     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
  42     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
  43     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
  44     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
  45     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
  46     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
  47     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
  48     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
  49     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
  50     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
  51     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
  52     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
  53     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
  54     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
  55     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
  56     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
  57     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
  58     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
  59     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
  60     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
  61     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
  62     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
  63     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
  64     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
  65     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
  66     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
  67     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
  68     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
  69     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
  70     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
  71     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
  72     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
  73     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
  74     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
  75     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
  76     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
  77     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
  78     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
  79     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
  80     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
  81     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
  82     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
  83     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
  84     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
  85     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
  86     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
  87     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
  88     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
  89     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
  90 };
  91
  92 /*
  93 * kExampleDSAKeyDER is a DSA private key in ASN.1, DER format. Of course, you
  94  * should never use this key anywhere but in an example.
  95  */
  96 #ifndef OPENSSL_NO_DSA
  97 static const unsigned char kExampleDSAKeyDER[] = {
  98     0x30, 0x82, 0x01, 0xba, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0x9a,
  99     0x05, 0x6d, 0x33, 0xcd, 0x5d, 0x78, 0xa1, 0xbb, 0xcb, 0x7d, 0x5b, 0x8d,
 100     0xb4, 0xcc, 0xbf, 0x03, 0x99, 0x64, 0xde, 0x38, 0x78, 0x06, 0x15, 0x2f,
 101     0x86, 0x26, 0x77, 0xf3, 0xb1, 0x85, 0x00, 0xed, 0xfc, 0x28, 0x3a, 0x42,
 102     0x4d, 0xab, 0xab, 0xdf, 0xbc, 0x9c, 0x16, 0xd0, 0x22, 0x50, 0xd1, 0x38,
 103     0xdd, 0x3f, 0x64, 0x05, 0x9e, 0x68, 0x7a, 0x1e, 0xf1, 0x56, 0xbf, 0x1e,
 104     0x2c, 0xc5, 0x97, 0x2a, 0xfe, 0x7a, 0x22, 0xdc, 0x6c, 0x68, 0xb8, 0x2e,
 105     0x06, 0xdb, 0x41, 0xca, 0x98, 0xd8, 0x54, 0xc7, 0x64, 0x48, 0x24, 0x04,
 106     0x20, 0xbc, 0x59, 0xe3, 0x6b, 0xea, 0x7e, 0xfc, 0x7e, 0xc5, 0x4e, 0xd4,
 107     0xd8, 0x3a, 0xed, 0xcd, 0x5d, 0x99, 0xb8, 0x5c, 0xa2, 0x8b, 0xbb, 0x0b,
 108     0xac, 0xe6, 0x8e, 0x25, 0x56, 0x22, 0x3a, 0x2d, 0x3a, 0x56, 0x41, 0x14,
 109     0x1f, 0x1c, 0x8f, 0x53, 0x46, 0x13, 0x85, 0x02, 0x15, 0x00, 0x98, 0x7e,
 110     0x92, 0x81, 0x88, 0xc7, 0x3f, 0x70, 0x49, 0x54, 0xf6, 0x76, 0xb4, 0xa3,
 111     0x9e, 0x1d, 0x45, 0x98, 0x32, 0x7f, 0x02, 0x81, 0x80, 0x69, 0x4d, 0xef,
 112     0x55, 0xff, 0x4d, 0x59, 0x2c, 0x01, 0xfa, 0x6a, 0x38, 0xe0, 0x70, 0x9f,
 113     0x9e, 0x66, 0x8e, 0x3e, 0x8c, 0x52, 0x22, 0x9d, 0x15, 0x7e, 0x3c, 0xef,
 114     0x4c, 0x7a, 0x61, 0x26, 0xe0, 0x2b, 0x81, 0x3f, 0xeb, 0xaf, 0x35, 0x38,
 115     0x8d, 0xfe, 0xed, 0x46, 0xff, 0x5f, 0x03, 0x9b, 0x81, 0x92, 0xe7, 0x6f,
 116     0x76, 0x4f, 0x1d, 0xd9, 0xbb, 0x89, 0xc9, 0x3e, 0xd9, 0x0b, 0xf9, 0xf4,
 117     0x78, 0x11, 0x59, 0xc0, 0x1d, 0xcd, 0x0e, 0xa1, 0x6f, 0x15, 0xf1, 0x4d,
 118     0xc1, 0xc9, 0x22, 0xed, 0x8d, 0xad, 0x67, 0xc5, 0x4b, 0x95, 0x93, 0x86,
 119     0xa6, 0xaf, 0x8a, 0xee, 0x06, 0x89, 0x2f, 0x37, 0x7e, 0x64, 0xaa, 0xf6,
 120     0xe7, 0xb1, 0x5a, 0x0a, 0x93, 0x95, 0x5d, 0x3e, 0x53, 0x9a, 0xde, 0x8a,
 121     0xc2, 0x95, 0x45, 0x81, 0xbe, 0x5c, 0x2f, 0xc2, 0xb2, 0x92, 0x58, 0x19,
 122     0x72, 0x80, 0xe9, 0x79, 0xa1, 0x02, 0x81, 0x80, 0x07, 0xd7, 0x62, 0xff,
 123     0xdf, 0x1a, 0x3f, 0xed, 0x32, 0xd4, 0xd4, 0x88, 0x7b, 0x2c, 0x63, 0x7f,
 124     0x97, 0xdc, 0x44, 0xd4, 0x84, 0xa2, 0xdd, 0x17, 0x16, 0x85, 0x13, 0xe0,
 125     0xac, 0x51, 0x8d, 0x29, 0x1b, 0x75, 0x9a, 0xe4, 0xe3, 0x8a, 0x92, 0x69,
 126     0x09, 0x03, 0xc5, 0x68, 0xae, 0x5e, 0x94, 0xfe, 0xc9, 0x92, 0x6c, 0x07,
 127     0xb4, 0x1e, 0x64, 0x62, 0x87, 0xc6, 0xa4, 0xfd, 0x0d, 0x5f, 0xe5, 0xf9,
 128     0x1b, 0x4f, 0x85, 0x5f, 0xae, 0xf3, 0x11, 0xe5, 0x18, 0xd4, 0x4d, 0x79,
 129     0x9f, 0xc4, 0x79, 0x26, 0x04, 0x27, 0xf0, 0x0b, 0xee, 0x2b, 0x86, 0x9f,
 130     0x86, 0x61, 0xe6, 0x51, 0xce, 0x04, 0x9b, 0x5d, 0x6b, 0x34, 0x43, 0x8c,
 131     0x85, 0x3c, 0xf1, 0x51, 0x9b, 0x08, 0x23, 0x1b, 0xf5, 0x7e, 0x33, 0x12,
 132     0xea, 0xab, 0x1f, 0xb7, 0x2d, 0xe2, 0x5f, 0xe6, 0x97, 0x99, 0xb5, 0x45,
 133     0x16, 0x5b, 0xc3, 0x41, 0x02, 0x14, 0x61, 0xbf, 0x51, 0x60, 0xcf, 0xc8,
 134     0xf1, 0x8c, 0x82, 0x97, 0xf2, 0xf4, 0x19, 0xba, 0x2b, 0xf3, 0x16, 0xbe,
 135     0x40, 0x48
 136 };
 137 #endif
 138
 139 /*
 140  * kExampleBadRSAKeyDER is an RSA private key in ASN.1, DER format. The private
 141  * components are not correct.
 142  */
 143 static const unsigned char kExampleBadRSAKeyDER[] = {
 144     0x30, 0x82, 0x04, 0x27, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
 145     0xa6, 0x1a, 0x1e, 0x6e, 0x7b, 0xee, 0xc6, 0x89, 0x66, 0xe7, 0x93, 0xef,
 146     0x54, 0x12, 0x68, 0xea, 0xbf, 0x86, 0x2f, 0xdd, 0xd2, 0x79, 0xb8, 0xa9,
 147     0x6e, 0x03, 0xc2, 0xa3, 0xb9, 0xa3, 0xe1, 0x4b, 0x2a, 0xb3, 0xf8, 0xb4,
 148     0xcd, 0xea, 0xbe, 0x24, 0xa6, 0x57, 0x5b, 0x83, 0x1f, 0x0f, 0xf2, 0xd3,
 149     0xb7, 0xac, 0x7e, 0xd6, 0x8e, 0x6e, 0x1e, 0xbf, 0xb8, 0x73, 0x8c, 0x05,
 150     0x56, 0xe6, 0x35, 0x1f, 0xe9, 0x04, 0x0b, 0x09, 0x86, 0x7d, 0xf1, 0x26,
 151     0x08, 0x99, 0xad, 0x7b, 0xc8, 0x4d, 0x94, 0xb0, 0x0b, 0x8b, 0x38, 0xa0,
 152     0x5c, 0x62, 0xa0, 0xab, 0xd3, 0x8f, 0xd4, 0x09, 0x60, 0x72, 0x1e, 0x33,
 153     0x50, 0x80, 0x6e, 0x22, 0xa6, 0x77, 0x57, 0x6b, 0x9a, 0x33, 0x21, 0x66,
 154     0x87, 0x6e, 0x21, 0x7b, 0xc7, 0x24, 0x0e, 0xd8, 0x13, 0xdf, 0x83, 0xde,
 155     0xcd, 0x40, 0x58, 0x1d, 0x84, 0x86, 0xeb, 0xb8, 0x12, 0x4e, 0xd2, 0xfa,
 156     0x80, 0x1f, 0xe4, 0xe7, 0x96, 0x29, 0xb8, 0xcc, 0xce, 0x66, 0x6d, 0x53,
 157     0xca, 0xb9, 0x5a, 0xd7, 0xf6, 0x84, 0x6c, 0x2d, 0x9a, 0x1a, 0x14, 0x1c,
 158     0x4e, 0x93, 0x39, 0xba, 0x74, 0xed, 0xed, 0x87, 0x87, 0x5e, 0x48, 0x75,
 159     0x36, 0xf0, 0xbc, 0x34, 0xfb, 0x29, 0xf9, 0x9f, 0x96, 0x5b, 0x0b, 0xa7,
 160     0x54, 0x30, 0x51, 0x29, 0x18, 0x5b, 0x7d, 0xac, 0x0f, 0xd6, 0x5f, 0x7c,
 161     0xf8, 0x98, 0x8c, 0xd8, 0x86, 0x62, 0xb3, 0xdc, 0xff, 0x0f, 0xff, 0x7a,
 162     0xaf, 0x5c, 0x4c, 0x61, 0x49, 0x2e, 0xc8, 0x95, 0x86, 0xc4, 0x0e, 0x87,
 163     0xfc, 0x1d, 0xcf, 0x8b, 0x7c, 0x61, 0xf6, 0xd8, 0xd0, 0x69, 0xf6, 0xcd,
 164     0x8a, 0x8c, 0xf6, 0x62, 0xa2, 0x56, 0xa9, 0xe3, 0xd1, 0xcf, 0x4d, 0xa0,
 165     0xf6, 0x2d, 0x20, 0x0a, 0x04, 0xb7, 0xa2, 0xf7, 0xb5, 0x99, 0x47, 0x18,
 166     0x56, 0x85, 0x87, 0xc7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
 167     0x01, 0x00, 0x99, 0x41, 0x38, 0x1a, 0xd0, 0x96, 0x7a, 0xf0, 0x83, 0xd5,
 168     0xdf, 0x94, 0xce, 0x89, 0x3d, 0xec, 0x7a, 0x52, 0x21, 0x10, 0x16, 0x06,
 169     0xe0, 0xee, 0xd2, 0xe6, 0xfd, 0x4b, 0x7b, 0x19, 0x4d, 0xe1, 0xc0, 0xc0,
 170     0xd5, 0x14, 0x5d, 0x79, 0xdd, 0x7e, 0x8b, 0x4b, 0xc6, 0xcf, 0xb0, 0x75,
 171     0x52, 0xa3, 0x2d, 0xb1, 0x26, 0x46, 0x68, 0x9c, 0x0a, 0x1a, 0xf2, 0xe1,
 172     0x09, 0xac, 0x53, 0x85, 0x8c, 0x36, 0xa9, 0x14, 0x65, 0xea, 0xa0, 0x00,
 173     0xcb, 0xe3, 0x3f, 0xc4, 0x2b, 0x61, 0x2e, 0x6b, 0x06, 0x69, 0x77, 0xfd,
 174     0x38, 0x7e, 0x1d, 0x3f, 0x92, 0xe7, 0x77, 0x08, 0x19, 0xa7, 0x9d, 0x29,
 175     0x2d, 0xdc, 0x42, 0xc6, 0x7c, 0xd7, 0xd3, 0xa8, 0x01, 0x2c, 0xf2, 0xd5,
 176     0x82, 0x57, 0xcb, 0x55, 0x3d, 0xe7, 0xaa, 0xd2, 0x06, 0x30, 0x30, 0x05,
 177     0xe6, 0xf2, 0x47, 0x86, 0xba, 0xc6, 0x61, 0x64, 0xeb, 0x4f, 0x2a, 0x5e,
 178     0x07, 0x29, 0xe0, 0x96, 0xb2, 0x43, 0xff, 0x5f, 0x1a, 0x54, 0x16, 0xcf,
 179     0xb5, 0x56, 0x5c, 0xa0, 0x9b, 0x0c, 0xfd, 0xb3, 0xd2, 0xe3, 0x79, 0x1d,
 180     0x21, 0xe2, 0xd6, 0x13, 0xc4, 0x74, 0xa6, 0xf5, 0x8e, 0x8e, 0x81, 0xbb,
 181     0xb4, 0xad, 0x8a, 0xf0, 0x93, 0x0a, 0xd8, 0x0a, 0x42, 0x36, 0xbc, 0xe5,
 182     0x26, 0x2a, 0x0d, 0x5d, 0x57, 0x13, 0xc5, 0x4e, 0x2f, 0x12, 0x0e, 0xef,
 183     0xa7, 0x81, 0x1e, 0xc3, 0xa5, 0xdb, 0xc9, 0x24, 0xeb, 0x1a, 0xa1, 0xf9,
 184     0xf6, 0xa1, 0x78, 0x98, 0x93, 0x77, 0x42, 0x45, 0x03, 0xe2, 0xc9, 0xa2,
 185     0xfe, 0x2d, 0x77, 0xc8, 0xc6, 0xac, 0x9b, 0x98, 0x89, 0x6d, 0x9a, 0xe7,
 186     0x61, 0x63, 0xb7, 0xf2, 0xec, 0xd6, 0xb1, 0xa1, 0x6e, 0x0a, 0x1a, 0xff,
 187     0xfd, 0x43, 0x28, 0xc3, 0x0c, 0xdc, 0xf2, 0x47, 0x4f, 0x27, 0xaa, 0x99,
 188     0x04, 0x8e, 0xac, 0xe8, 0x7c, 0x01, 0x02, 0x04, 0x12, 0x34, 0x56, 0x78,
 189     0x02, 0x81, 0x81, 0x00, 0xca, 0x69, 0xe5, 0xbb, 0x3a, 0x90, 0x82, 0xcb,
 190     0x82, 0x50, 0x2f, 0x29, 0xe2, 0x76, 0x6a, 0x57, 0x55, 0x45, 0x4e, 0x35,
 191     0x18, 0x61, 0xe0, 0x12, 0x70, 0xc0, 0xab, 0xc7, 0x80, 0xa2, 0xd4, 0x46,
 192     0x34, 0x03, 0xa0, 0x19, 0x26, 0x23, 0x9e, 0xef, 0x1a, 0xcb, 0x75, 0xd6,
 193     0xba, 0x81, 0xf4, 0x7e, 0x52, 0xe5, 0x2a, 0xe8, 0xf1, 0x49, 0x6c, 0x0f,
 194     0x1a, 0xa0, 0xf9, 0xc6, 0xe7, 0xec, 0x60, 0xe4, 0xcb, 0x2a, 0xb5, 0x56,
 195     0xe9, 0x9c, 0xcd, 0x19, 0x75, 0x92, 0xb1, 0x66, 0xce, 0xc3, 0xd9, 0x3d,
 196     0x11, 0xcb, 0xc4, 0x09, 0xce, 0x1e, 0x30, 0xba, 0x2f, 0x60, 0x60, 0x55,
 197     0x8d, 0x02, 0xdc, 0x5d, 0xaf, 0xf7, 0x52, 0x31, 0x17, 0x07, 0x53, 0x20,
 198     0x33, 0xad, 0x8c, 0xd5, 0x2f, 0x5a, 0xd0, 0x57, 0xd7, 0xd1, 0x80, 0xd6,
 199     0x3a, 0x9b, 0x04, 0x4f, 0x35, 0xbf, 0xe7, 0xd5, 0xbc, 0x8f, 0xd4, 0x81,
 200     0x02, 0x81, 0x81, 0x00, 0xc0, 0x9f, 0xf8, 0xcd, 0xf7, 0x3f, 0x26, 0x8a,
 201     0x3d, 0x4d, 0x2b, 0x0c, 0x01, 0xd0, 0xa2, 0xb4, 0x18, 0xfe, 0xf7, 0x5e,
 202     0x2f, 0x06, 0x13, 0xcd, 0x63, 0xaa, 0x12, 0xa9, 0x24, 0x86, 0xe3, 0xf3,
 203     0x7b, 0xda, 0x1a, 0x3c, 0xb1, 0x38, 0x80, 0x80, 0xef, 0x64, 0x64, 0xa1,
 204     0x9b, 0xfe, 0x76, 0x63, 0x8e, 0x83, 0xd2, 0xd9, 0xb9, 0x86, 0xb0, 0xe6,
 205     0xa6, 0x0c, 0x7e, 0xa8, 0x84, 0x90, 0x98, 0x0c, 0x1e, 0xf3, 0x14, 0x77,
 206     0xe0, 0x5f, 0x81, 0x08, 0x11, 0x8f, 0xa6, 0x23, 0xc4, 0xba, 0xc0, 0x8a,
 207     0xe4, 0xc6, 0xe3, 0x5c, 0xbe, 0xc5, 0xec, 0x2c, 0xb9, 0xd8, 0x8c, 0x4d,
 208     0x1a, 0x9d, 0xe7, 0x7c, 0x85, 0x4c, 0x0d, 0x71, 0x4e, 0x72, 0x33, 0x1b,
 209     0xfe, 0xa9, 0x17, 0x72, 0x76, 0x56, 0x9d, 0x74, 0x7e, 0x52, 0x67, 0x9a,
 210     0x87, 0x9a, 0xdb, 0x30, 0xde, 0xe4, 0x49, 0x28, 0x3b, 0xd2, 0x67, 0xaf,
 211     0x02, 0x81, 0x81, 0x00, 0x89, 0x74, 0x9a, 0x8e, 0xa7, 0xb9, 0xa5, 0x28,
 212     0xc0, 0x68, 0xe5, 0x6e, 0x63, 0x1c, 0x99, 0x20, 0x8f, 0x86, 0x8e, 0x12,
 213     0x9e, 0x69, 0x30, 0xfa, 0x34, 0xd9, 0x92, 0x8d, 0xdb, 0x7c, 0x37, 0xfd,
 214     0x28, 0xab, 0x61, 0x98, 0x52, 0x7f, 0x14, 0x1a, 0x39, 0xae, 0xfb, 0x6a,
 215     0x03, 0xa3, 0xe6, 0xbd, 0xb6, 0x5b, 0x6b, 0xe5, 0x5e, 0x9d, 0xc6, 0xa5,
 216     0x07, 0x27, 0x54, 0x17, 0xd0, 0x3d, 0x84, 0x9b, 0x3a, 0xa0, 0xd9, 0x1e,
 217     0x99, 0x6c, 0x63, 0x17, 0xab, 0xf1, 0x1f, 0x49, 0xba, 0x95, 0xe3, 0x3b,
 218     0x86, 0x8f, 0x42, 0xa4, 0x89, 0xf5, 0x94, 0x8f, 0x8b, 0x46, 0xbe, 0x84,
 219     0xba, 0x4a, 0xbc, 0x0d, 0x5f, 0x46, 0xeb, 0xe8, 0xec, 0x43, 0x8c, 0x1e,
 220     0xad, 0x19, 0x69, 0x2f, 0x08, 0x86, 0x7a, 0x3f, 0x7d, 0x0f, 0x07, 0x97,
 221     0xf3, 0x9a, 0x7b, 0xb5, 0xb2, 0xc1, 0x8c, 0x95, 0x68, 0x04, 0xa0, 0x81,
 222     0x02, 0x81, 0x80, 0x4e, 0xbf, 0x7e, 0x1b, 0xcb, 0x13, 0x61, 0x75, 0x3b,
 223     0xdb, 0x59, 0x5f, 0xb1, 0xd4, 0xb8, 0xeb, 0x9e, 0x73, 0xb5, 0xe7, 0xf6,
 224     0x89, 0x3d, 0x1c, 0xda, 0xf0, 0x36, 0xff, 0x35, 0xbd, 0x1e, 0x0b, 0x74,
 225     0xe3, 0x9e, 0xf0, 0xf2, 0xf7, 0xd7, 0x82, 0xb7, 0x7b, 0x6a, 0x1b, 0x0e,
 226     0x30, 0x4a, 0x98, 0x0e, 0xb4, 0xf9, 0x81, 0x07, 0xe4, 0x75, 0x39, 0xe9,
 227     0x53, 0xca, 0xbb, 0x5c, 0xaa, 0x93, 0x07, 0x0e, 0xa8, 0x2f, 0xba, 0x98,
 228     0x49, 0x30, 0xa7, 0xcc, 0x1a, 0x3c, 0x68, 0x0c, 0xe1, 0xa4, 0xb1, 0x05,
 229     0xe6, 0xe0, 0x25, 0x78, 0x58, 0x14, 0x37, 0xf5, 0x1f, 0xe3, 0x22, 0xef,
 230     0xa8, 0x0e, 0x22, 0xa0, 0x94, 0x3a, 0xf6, 0xc9, 0x13, 0xe6, 0x06, 0xbf,
 231     0x7f, 0x99, 0xc6, 0xcc, 0xd8, 0xc6, 0xbe, 0xd9, 0x2e, 0x24, 0xc7, 0x69,
 232     0x8c, 0x95, 0xba, 0xf6, 0x04, 0xb3, 0x0a, 0xf4, 0xcb, 0xf0, 0xce,
 233 };
 234
 235 static const unsigned char kMsg[] = { 1, 2, 3, 4 };
 236
 237 static const unsigned char kSignature[] = {
 238     0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
 239     0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
 240     0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
 241     0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
 242     0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
 243     0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
 244     0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
 245     0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
 246     0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
 247     0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
 248     0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
 249 };
 250
 251 /*
 252  * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
 253  * PrivateKeyInfo.
 254  */
 255 static const unsigned char kExampleRSAKeyPKCS8[] = {
 256     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 257     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 258     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
 259     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
 260     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
 261     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
 262     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
 263     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
 264     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
 265     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
 266     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
 267     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
 268     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
 269     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
 270     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
 271     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
 272     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
 273     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
 274     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
 275     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
 276     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
 277     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
 278     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
 279     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
 280     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
 281     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
 282     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
 283     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
 284     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
 285     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
 286     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
 287     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
 288     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
 289     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
 290     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
 291     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
 292     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
 293     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
 294     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
 295     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
 296     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
 297     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
 298     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
 299     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
 300     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
 301     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
 302     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
 303     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
 304     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
 305     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
 306     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
 307     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
 308     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 309 };
 310
 311 #ifndef OPENSSL_NO_EC
 312 /*
 313  * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
 314  * structure.
 315  */
 316 static const unsigned char kExampleECKeyDER[] = {
 317     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
 318     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
 319     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
 320     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 321     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
 322     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
 323     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
 324     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
 325     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
 326     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
 327     0xc1,
 328 };
 329
 330 /*
 331  * kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
 332  * structure. The private key is equal to the order and will fail to import
 333  */
 334 static const unsigned char kExampleBadECKeyDER[] = {
 335     0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
 336     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
 337     0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
 338     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 339     0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
 340     0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
 341     0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
 342     0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
 343     0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
 344 };
 345
 346 /* prime256v1 */
 347 static const unsigned char kExampleECPubKeyDER[] = {
 348     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 349     0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 350     0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
 351     0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
 352     0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
 353     0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
 354     0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
 355     0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
 356 };
 357
 358 /*
 359  * kExampleBadECPubKeyDER is a sample EC public key with a wrong OID
 360  * 1.2.840.10045.2.2 instead of 1.2.840.10045.2.1 - EC Public Key
 361  */
 362 static const unsigned char kExampleBadECPubKeyDER[] = {
 363     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 364     0x02, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 365     0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
 366     0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
 367     0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
 368     0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
 369     0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
 370     0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
 371 };
 372
 373 static const unsigned char pExampleECParamDER[] = {
 374     0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
 375 };
 376 #endif
 377
 378 typedef struct APK_DATA_st {
 379     const unsigned char *kder;
 380     size_t size;
 381     int evptype;
 382     int check;
 383     int pub_check;
 384     int param_check;
 385     int type; /* 0 for private, 1 for public, 2 for params */
 386 } APK_DATA;
 387
 388 static APK_DATA keydata[] = {
 389     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
 390     {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
 391 #ifndef OPENSSL_NO_EC
 392     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
 393 #endif
 394 };
 395
 396 static APK_DATA keycheckdata[] = {
 397     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA, 1, -2, -2, 0},
 398     {kExampleBadRSAKeyDER, sizeof(kExampleBadRSAKeyDER), EVP_PKEY_RSA,
 399      0, -2, -2, 0},
 400 #ifndef OPENSSL_NO_EC
 401     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC, 1, 1, 1, 0},
 402     /* group is also associated in our pub key */
 403     {kExampleECPubKeyDER, sizeof(kExampleECPubKeyDER), EVP_PKEY_EC, 0, 1, 1, 1},
 404     {pExampleECParamDER, sizeof(pExampleECParamDER), EVP_PKEY_EC, 0, 0, 1, 2}
 405 #endif
 406 };
 407
 408 static EVP_PKEY *load_example_rsa_key(void)
 409 {
 410     EVP_PKEY *ret = NULL;
 411     const unsigned char *derp = kExampleRSAKeyDER;
 412     EVP_PKEY *pkey = NULL;
 413     RSA *rsa = NULL;
 414
 415     if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
 416         return NULL;
 417
 418     if (!TEST_ptr(pkey = EVP_PKEY_new())
 419             || !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
 420         goto end;
 421
 422     ret = pkey;
 423     pkey = NULL;
 424
 425 end:
 426     EVP_PKEY_free(pkey);
 427     RSA_free(rsa);
 428
 429     return ret;
 430 }
 431
 432 #ifndef OPENSSL_NO_DSA
 433 static EVP_PKEY *load_example_dsa_key(void)
 434 {
 435     EVP_PKEY *ret = NULL;
 436     const unsigned char *derp = kExampleDSAKeyDER;
 437     EVP_PKEY *pkey = NULL;
 438     DSA *dsa = NULL;
 439
 440     if (!TEST_true(d2i_DSAPrivateKey(&dsa, &derp, sizeof(kExampleDSAKeyDER))))
 441         return NULL;
 442
 443     if (!TEST_ptr(pkey = EVP_PKEY_new())
 444             || !TEST_true(EVP_PKEY_set1_DSA(pkey, dsa)))
 445         goto end;
 446
 447     ret = pkey;
 448     pkey = NULL;
 449
 450 end:
 451     EVP_PKEY_free(pkey);
 452     DSA_free(dsa);
 453
 454     return ret;
 455 }
 456 #endif
 457
 458 static EVP_PKEY *load_example_hmac_key(void)
 459 {
 460     EVP_PKEY *pkey = NULL;
 461     unsigned char key[] = {
 462         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
 463         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 464         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
 465     };
 466
 467     pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL, key, sizeof(key));
 468     if (!TEST_ptr(pkey))
 469         return NULL;
 470
 471     return pkey;
 472 }
 473
 474 static int test_EVP_set_default_properties(void)
 475 {
 476     OPENSSL_CTX *ctx;
 477     EVP_MD *md = NULL;
 478     int res = 0;
 479
 480     if (!TEST_ptr(ctx = OPENSSL_CTX_new())
 481             || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
 482         goto err;
 483     EVP_MD_free(md);
 484     md = NULL;
 485
 486     if (!TEST_true(EVP_set_default_properties(ctx, "provider=fizzbang"))
 487             || !TEST_ptr_null(md = EVP_MD_fetch(ctx, "sha256", NULL))
 488             || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", "-provider")))
 489         goto err;
 490     EVP_MD_free(md);
 491     md = NULL;
 492
 493     if (!TEST_true(EVP_set_default_properties(ctx, NULL))
 494             || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
 495         goto err;
 496     res = 1;
 497 err:
 498     EVP_MD_free(md);
 499     OPENSSL_CTX_free(ctx);
 500     return res;
 501 }
 502
 503 static int test_EVP_Enveloped(void)
 504 {
 505     int ret = 0;
 506     EVP_CIPHER_CTX *ctx = NULL;
 507     EVP_PKEY *keypair = NULL;
 508     unsigned char *kek = NULL;
 509     unsigned char iv[EVP_MAX_IV_LENGTH];
 510     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 511     int len, kek_len, ciphertext_len, plaintext_len;
 512     unsigned char ciphertext[32], plaintext[16];
 513     const EVP_CIPHER *type = EVP_aes_256_cbc();
 514
 515     if (!TEST_ptr(keypair = load_example_rsa_key())
 516             || !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_size(keypair)))
 517             || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
 518             || !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
 519                                        &keypair, 1))
 520             || !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
 521                                          msg, sizeof(msg)))
 522             || !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
 523                                         &len)))
 524         goto err;
 525
 526     ciphertext_len += len;
 527
 528     if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
 529             || !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
 530                                          ciphertext, ciphertext_len))
 531             || !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
 532         goto err;
 533
 534     plaintext_len += len;
 535     if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
 536         goto err;
 537
 538     ret = 1;
 539 err:
 540     OPENSSL_free(kek);
 541     EVP_PKEY_free(keypair);
 542     EVP_CIPHER_CTX_free(ctx);
 543     return ret;
 544 }
 545
 546 /*
 547  * Test 0: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, RSA)
 548  * Test 1: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, DSA)
 549  * Test 2: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, HMAC)
 550  * Test 3: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, RSA)
 551  * Test 4: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, DSA)
 552  * Test 5: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch diegst, HMAC)
 553  * Test 6: Use an MD BIO to do the Update calls instead (RSA)
 554  * Test 7: Use an MD BIO to do the Update calls instead (DSA)
 555  * Test 8: Use an MD BIO to do the Update calls instead (HMAC)
 556  */
 557 static int test_EVP_DigestSignInit(int tst)
 558 {
 559     int ret = 0;
 560     EVP_PKEY *pkey = NULL;
 561     unsigned char *sig = NULL;
 562     size_t sig_len = 0;
 563     EVP_MD_CTX *md_ctx = NULL, *md_ctx_verify = NULL;
 564     EVP_MD_CTX *a_md_ctx = NULL, *a_md_ctx_verify = NULL;
 565     BIO *mdbio = NULL, *membio = NULL;
 566     size_t written;
 567     const EVP_MD *md;
 568     EVP_MD *mdexp = NULL;
 569
 570     if (tst >= 6) {
 571         membio = BIO_new(BIO_s_mem());
 572         mdbio = BIO_new(BIO_f_md());
 573         if (!TEST_ptr(membio) || !TEST_ptr(mdbio))
 574             goto out;
 575         BIO_push(mdbio, membio);
 576         if (!TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx), 0))
 577             goto out;
 578     } else {
 579         if (!TEST_ptr(a_md_ctx = md_ctx = EVP_MD_CTX_new())
 580                 || !TEST_ptr(a_md_ctx_verify = md_ctx_verify = EVP_MD_CTX_new()))
 581             goto out;
 582     }
 583
 584     if (tst == 0 || tst == 3 || tst == 6) {
 585         if (!TEST_ptr(pkey = load_example_rsa_key()))
 586                 goto out;
 587     } else if (tst == 1 || tst == 4 || tst == 7) {
 588 #ifndef OPENSSL_NO_DSA
 589         if (!TEST_ptr(pkey = load_example_dsa_key()))
 590                 goto out;
 591 #else
 592         ret = 1;
 593         goto out;
 594 #endif
 595     } else {
 596         if (!TEST_ptr(pkey = load_example_hmac_key()))
 597                 goto out;
 598     }
 599
 600     if (tst >= 3 && tst <= 5)
 601         md = mdexp = EVP_MD_fetch(NULL, "SHA256", NULL);
 602     else
 603         md = EVP_sha256();
 604
 605     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, md, NULL, pkey)))
 606         goto out;
 607
 608     if (tst >= 6) {
 609         if (!BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written))
 610             goto out;
 611     } else {
 612         if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 613             goto out;
 614     }
 615
 616     /* Determine the size of the signature. */
 617     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
 618             || !TEST_ptr(sig = OPENSSL_malloc(sig_len))
 619             || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 620         goto out;
 621
 622     if (tst >= 6) {
 623         if (!TEST_int_gt(BIO_reset(mdbio), 0)
 624                 || !TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx_verify), 0))
 625             goto out;
 626     }
 627
 628     /*
 629      * Ensure that the signature round-trips (Verification isn't supported for
 630      * HMAC via EVP_DigestVerify*)
 631      */
 632     if (tst != 2 && tst != 5 && tst != 8) {
 633         if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, md,
 634                                             NULL, pkey)))
 635             goto out;
 636
 637         if (tst >= 6) {
 638             if (!TEST_true(BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written)))
 639                 goto out;
 640         } else {
 641             if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg,
 642                                                   sizeof(kMsg))))
 643                 goto out;
 644         }
 645         if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 646             goto out;
 647     }
 648
 649     ret = 1;
 650
 651  out:
 652     BIO_free(membio);
 653     BIO_free(mdbio);
 654     EVP_MD_CTX_free(a_md_ctx);
 655     EVP_MD_CTX_free(a_md_ctx_verify);
 656     EVP_PKEY_free(pkey);
 657     OPENSSL_free(sig);
 658     EVP_MD_free(mdexp);
 659
 660     return ret;
 661 }
 662
 663 static int test_EVP_DigestVerifyInit(void)
 664 {
 665     int ret = 0;
 666     EVP_PKEY *pkey = NULL;
 667     EVP_MD_CTX *md_ctx = NULL;
 668
 669     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 670             || !TEST_ptr(pkey = load_example_rsa_key()))
 671         goto out;
 672
 673     if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 674             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
 675             || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
 676                                                  sizeof(kSignature))))
 677         goto out;
 678     ret = 1;
 679
 680  out:
 681     EVP_MD_CTX_free(md_ctx);
 682     EVP_PKEY_free(pkey);
 683     return ret;
 684 }
 685
 686 static int test_d2i_AutoPrivateKey(int i)
 687 {
 688     int ret = 0;
 689     const unsigned char *p;
 690     EVP_PKEY *pkey = NULL;
 691     const APK_DATA *ak = &keydata[i];
 692     const unsigned char *input = ak->kder;
 693     size_t input_len = ak->size;
 694     int expected_id = ak->evptype;
 695
 696     p = input;
 697     if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 698             || !TEST_ptr_eq(p, input + input_len)
 699             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
 700         goto done;
 701
 702     ret = 1;
 703
 704  done:
 705     EVP_PKEY_free(pkey);
 706     return ret;
 707 }
 708
 709 #ifndef OPENSSL_NO_EC
 710
 711 static const unsigned char ec_public_sect163k1_validxy[] = {
 712     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 713     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
 714     0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
 715     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b,
 716     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
 717     0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
 718 };
 719
 720 static const unsigned char ec_public_sect163k1_badx[] = {
 721     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 722     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
 723     0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
 724     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b,
 725     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
 726     0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
 727 };
 728
 729 static const unsigned char ec_public_sect163k1_bady[] = {
 730     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 731     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
 732     0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
 733     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b,
 734     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
 735     0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6
 736 };
 737
 738 static struct ec_der_pub_keys_st {
 739     const unsigned char *der;
 740     size_t len;
 741     int valid;
 742 } ec_der_pub_keys[] = {
 743     { ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 },
 744     { ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 },
 745     { ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 },
 746 };
 747
 748 /*
 749  * Tests the range of the decoded EC char2 public point.
 750  * See ec_GF2m_simple_oct2point().
 751  */
 752 static int test_invalide_ec_char2_pub_range_decode(int id)
 753 {
 754     int ret = 0;
 755     BIO *bio = NULL;
 756     EC_KEY *eckey = NULL;
 757
 758     if (!TEST_ptr(bio = BIO_new_mem_buf(ec_der_pub_keys[id].der,
 759                                         ec_der_pub_keys[id].len)))
 760         goto err;
 761     eckey = d2i_EC_PUBKEY_bio(bio, NULL);
 762     ret = (ec_der_pub_keys[id].valid && TEST_ptr(eckey))
 763           || TEST_ptr_null(eckey);
 764 err:
 765     EC_KEY_free(eckey);
 766     BIO_free(bio);
 767     return ret;
 768 }
 769
 770 /* Tests loading a bad key in PKCS8 format */
 771 static int test_EVP_PKCS82PKEY(void)
 772 {
 773     int ret = 0;
 774     const unsigned char *derp = kExampleBadECKeyDER;
 775     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
 776     EVP_PKEY *pkey = NULL;
 777
 778     if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
 779                                               sizeof(kExampleBadECKeyDER))))
 780         goto done;
 781
 782     if (!TEST_ptr_eq(derp,
 783                      kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
 784         goto done;
 785
 786     if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
 787         goto done;
 788
 789     ret = 1;
 790
 791  done:
 792     PKCS8_PRIV_KEY_INFO_free(p8inf);
 793     EVP_PKEY_free(pkey);
 794
 795     return ret;
 796 }
 797 #endif
 798
 799 /* This uses kExampleRSAKeyDER and kExampleRSAKeyPKCS8 to verify encoding */
 800 static int test_privatekey_to_pkcs8(void)
 801 {
 802     EVP_PKEY *pkey = NULL;
 803     BIO *membio = NULL;
 804     char *membuf = NULL;
 805     size_t membuf_len = 0;
 806     int ok = 0;
 807
 808     if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
 809         || !TEST_ptr(pkey = load_example_rsa_key())
 810         || !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
 811                                                 NULL, 0, NULL, NULL),
 812                         0)
 813         || !TEST_ptr((membuf_len = (size_t)BIO_get_mem_data(membio, &membuf),
 814                       membuf))
 815         || !TEST_mem_eq(membuf, membuf_len,
 816                         kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8))
 817         /*
 818          * We try to write PEM as well, just to see that it doesn't err, but
 819          * assume that the result is correct.
 820          */
 821         || !TEST_int_gt(PEM_write_bio_PKCS8PrivateKey(membio, pkey, NULL,
 822                                                       NULL, 0, NULL, NULL),
 823                         0))
 824         goto done;
 825
 826     ok = 1;
 827  done:
 828     EVP_PKEY_free(pkey);
 829     BIO_free_all(membio);
 830     return ok;
 831 }
 832
 833 #if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
 834
 835 static int test_EVP_SM2_verify(void)
 836 {
 837     /* From https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02#appendix-A */
 838     const char *pubkey =
 839        "-----BEGIN PUBLIC KEY-----\n"
 840        "MIIBMzCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEAhULWnkwETxjouSQ1\n"
 841        "v2/33kVyg5FcRVF9ci7biwjx38MwRAQgeHlotPoyw/0kF4Quc7v+/y88hItoMdfg\n"
 842        "7GUiizk35JgEIGPkxtOyOwyEnPhCQUhL/kj2HVmlsWugbm4S0donxSSaBEEEQh3r\n"
 843        "1hti6rZ0ZDTrw8wxXjIiCzut1QvcTE5sFH/t1D0GgFEry7QsB9RzSdIVO3DE5df9\n"
 844        "/L+jbqGoWEG55G4JogIhAIVC1p5MBE8Y6LkkNb9v990pdyBjBIVijVrnTufDLnm3\n"
 845        "AgEBA0IABArkx3mKoPEZRxvuEYJb5GICu3nipYRElel8BP9N8lSKfAJA+I8c1OFj\n"
 846        "Uqc8F7fxbwc1PlOhdtaEqf4Ma7eY6Fc=\n"
 847        "-----END PUBLIC KEY-----\n";
 848
 849     const char *msg = "message digest";
 850     const char *id = "ALICE123@YAHOO.COM";
 851
 852     const uint8_t signature[] = {
 853        0x30, 0x44, 0x02, 0x20,
 854
 855        0x40, 0xF1, 0xEC, 0x59, 0xF7, 0x93, 0xD9, 0xF4, 0x9E, 0x09, 0xDC,
 856        0xEF, 0x49, 0x13, 0x0D, 0x41, 0x94, 0xF7, 0x9F, 0xB1, 0xEE, 0xD2,
 857        0xCA, 0xA5, 0x5B, 0xAC, 0xDB, 0x49, 0xC4, 0xE7, 0x55, 0xD1,
 858
 859        0x02, 0x20,
 860
 861        0x6F, 0xC6, 0xDA, 0xC3, 0x2C, 0x5D, 0x5C, 0xF1, 0x0C, 0x77, 0xDF,
 862        0xB2, 0x0F, 0x7C, 0x2E, 0xB6, 0x67, 0xA4, 0x57, 0x87, 0x2F, 0xB0,
 863        0x9E, 0xC5, 0x63, 0x27, 0xA6, 0x7E, 0xC7, 0xDE, 0xEB, 0xE7
 864     };
 865
 866     int rc = 0;
 867     BIO *bio = NULL;
 868     EVP_PKEY *pkey = NULL;
 869     EVP_MD_CTX *mctx = NULL;
 870     EVP_PKEY_CTX *pctx = NULL;
 871
 872     bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
 873     if (!TEST_true(bio != NULL))
 874         goto done;
 875
 876     pkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
 877     if (!TEST_true(pkey != NULL))
 878         goto done;
 879
 880     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 881         goto done;
 882
 883     if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
 884         goto done;
 885
 886     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new(pkey, NULL)))
 887         goto done;
 888
 889     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, (const uint8_t *)id,
 890                                           strlen(id)), 0))
 891         goto done;
 892
 893     EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
 894
 895     if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, EVP_sm3(), NULL, pkey)))
 896         goto done;
 897
 898     if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
 899         goto done;
 900
 901     if (!TEST_true(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature))))
 902         goto done;
 903     rc = 1;
 904
 905  done:
 906     BIO_free(bio);
 907     EVP_PKEY_free(pkey);
 908     EVP_PKEY_CTX_free(pctx);
 909     EVP_MD_CTX_free(mctx);
 910     return rc;
 911 }
 912
 913 static int test_EVP_SM2(void)
 914 {
 915     int ret = 0;
 916     EVP_PKEY *pkey = NULL;
 917     EVP_PKEY *params = NULL;
 918     EVP_PKEY_CTX *pctx = NULL;
 919     EVP_PKEY_CTX *kctx = NULL;
 920     EVP_PKEY_CTX *sctx = NULL;
 921     size_t sig_len = 0;
 922     unsigned char *sig = NULL;
 923     EVP_MD_CTX *md_ctx = NULL;
 924     EVP_MD_CTX *md_ctx_verify = NULL;
 925     EVP_PKEY_CTX *cctx = NULL;
 926
 927     uint8_t ciphertext[128];
 928     size_t ctext_len = sizeof(ciphertext);
 929
 930     uint8_t plaintext[8];
 931     size_t ptext_len = sizeof(plaintext);
 932
 933     uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
 934
 935     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
 936     if (!TEST_ptr(pctx))
 937         goto done;
 938
 939     if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
 940         goto done;
 941
 942     if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
 943         goto done;
 944
 945     if (!TEST_true(EVP_PKEY_paramgen(pctx, &params)))
 946         goto done;
 947
 948     kctx = EVP_PKEY_CTX_new(params, NULL);
 949     if (!TEST_ptr(kctx))
 950         goto done;
 951
 952     if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
 953         goto done;
 954
 955     if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
 956         goto done;
 957
 958     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 959         goto done;
 960
 961     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
 962         goto done;
 963
 964     if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
 965         goto done;
 966
 967     if (!TEST_ptr(sctx = EVP_PKEY_CTX_new(pkey, NULL)))
 968         goto done;
 969
 970     EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
 971     EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
 972
 973     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
 974         goto done;
 975
 976     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
 977         goto done;
 978
 979     if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 980         goto done;
 981
 982     /* Determine the size of the signature. */
 983     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
 984         goto done;
 985
 986     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
 987         goto done;
 988
 989     if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 990         goto done;
 991
 992     /* Ensure that the signature round-trips. */
 993
 994     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
 995         goto done;
 996
 997     if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
 998         goto done;
 999
1000     if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
1001         goto done;
1002
1003     /* now check encryption/decryption */
1004
1005     if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
1006         goto done;
1007
1008     if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
1009         goto done;
1010
1011     if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
1012         goto done;
1013
1014     if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
1015         goto done;
1016
1017     if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
1018         goto done;
1019
1020     if (!TEST_true(ptext_len == sizeof(kMsg)))
1021         goto done;
1022
1023     if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
1024         goto done;
1025
1026     ret = 1;
1027 done:
1028     EVP_PKEY_CTX_free(pctx);
1029     EVP_PKEY_CTX_free(kctx);
1030     EVP_PKEY_CTX_free(sctx);
1031     EVP_PKEY_CTX_free(cctx);
1032     EVP_PKEY_free(pkey);
1033     EVP_PKEY_free(params);
1034     EVP_MD_CTX_free(md_ctx);
1035     EVP_MD_CTX_free(md_ctx_verify);
1036     OPENSSL_free(sig);
1037     return ret;
1038 }
1039
1040 #endif
1041
1042 static struct keys_st {
1043     int type;
1044     char *priv;
1045     char *pub;
1046 } keys[] = {
1047     {
1048         EVP_PKEY_HMAC, "0123456789", NULL
1049     }, {
1050         EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
1051     }, {
1052         EVP_PKEY_SIPHASH, "0123456789012345", NULL
1053     },
1054 #ifndef OPENSSL_NO_EC
1055     {
1056         EVP_PKEY_X25519, "01234567890123456789012345678901",
1057         "abcdefghijklmnopqrstuvwxyzabcdef"
1058     }, {
1059         EVP_PKEY_ED25519, "01234567890123456789012345678901",
1060         "abcdefghijklmnopqrstuvwxyzabcdef"
1061     }, {
1062         EVP_PKEY_X448,
1063         "01234567890123456789012345678901234567890123456789012345",
1064         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
1065     }, {
1066         EVP_PKEY_ED448,
1067         "012345678901234567890123456789012345678901234567890123456",
1068         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
1069     }
1070 #endif
1071 };
1072
1073 static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
1074 {
1075     int ret = 0;
1076     unsigned char buf[80];
1077     unsigned char *in;
1078     size_t inlen, len = 0;
1079     EVP_PKEY *pkey;
1080
1081     /* Check if this algorithm supports public keys */
1082     if (keys[tst].pub == NULL)
1083         return 1;
1084
1085     memset(buf, 0, sizeof(buf));
1086
1087     if (pub) {
1088         inlen = strlen(keys[tst].pub);
1089         in = (unsigned char *)keys[tst].pub;
1090         if (uselibctx) {
1091             pkey = EVP_PKEY_new_raw_public_key_with_libctx(
1092                         testctx,
1093                         OBJ_nid2sn(keys[tst].type),
1094                         NULL,
1095                         in,
1096                         inlen);
1097         } else {
1098             pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
1099                                                NULL,
1100                                                in,
1101                                                inlen);
1102         }
1103     } else {
1104         inlen = strlen(keys[tst].priv);
1105         in = (unsigned char *)keys[tst].priv;
1106         if (uselibctx) {
1107             pkey = EVP_PKEY_new_raw_private_key_with_libctx(
1108                         testctx, OBJ_nid2sn(keys[tst].type),
1109                         NULL,
1110                         in,
1111                         inlen);
1112         } else {
1113             pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
1114                                                 NULL,
1115                                                 in,
1116                                                 inlen);
1117         }
1118     }
1119
1120     if (!TEST_ptr(pkey)
1121             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
1122             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
1123             || !TEST_true(len == inlen)
1124             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
1125             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
1126             || !TEST_mem_eq(in, inlen, buf, len))
1127         goto done;
1128
1129     ret = 1;
1130  done:
1131     EVP_PKEY_free(pkey);
1132     return ret;
1133 }
1134
1135 static int test_set_get_raw_keys(int tst)
1136 {
1137     return test_set_get_raw_keys_int(tst, 0, 0)
1138            && test_set_get_raw_keys_int(tst, 0, 1)
1139            && test_set_get_raw_keys_int(tst, 1, 0)
1140            && test_set_get_raw_keys_int(tst, 1, 1);
1141 }
1142
1143 static int pkey_custom_check(EVP_PKEY *pkey)
1144 {
1145     return 0xbeef;
1146 }
1147
1148 static int pkey_custom_pub_check(EVP_PKEY *pkey)
1149 {
1150     return 0xbeef;
1151 }
1152
1153 static int pkey_custom_param_check(EVP_PKEY *pkey)
1154 {
1155     return 0xbeef;
1156 }
1157
1158 static EVP_PKEY_METHOD *custom_pmeth;
1159
1160 static int test_EVP_PKEY_check(int i)
1161 {
1162     int ret = 0;
1163     const unsigned char *p;
1164     EVP_PKEY *pkey = NULL;
1165 #ifndef OPENSSL_NO_EC
1166     EC_KEY *eckey = NULL;
1167 #endif
1168     EVP_PKEY_CTX *ctx = NULL;
1169     EVP_PKEY_CTX *ctx2 = NULL;
1170     const APK_DATA *ak = &keycheckdata[i];
1171     const unsigned char *input = ak->kder;
1172     size_t input_len = ak->size;
1173     int expected_id = ak->evptype;
1174     int expected_check = ak->check;
1175     int expected_pub_check = ak->pub_check;
1176     int expected_param_check = ak->param_check;
1177     int type = ak->type;
1178     BIO *pubkey = NULL;
1179
1180     p = input;
1181
1182     switch (type) {
1183     case 0:
1184         if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
1185             || !TEST_ptr_eq(p, input + input_len)
1186             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
1187             goto done;
1188         break;
1189 #ifndef OPENSSL_NO_EC
1190     case 1:
1191         if (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
1192             || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
1193             || !TEST_ptr(pkey = EVP_PKEY_new())
1194             || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1195             goto done;
1196         break;
1197     case 2:
1198         if (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
1199             || !TEST_ptr_eq(p, input + input_len)
1200             || !TEST_ptr(pkey = EVP_PKEY_new())
1201             || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1202             goto done;
1203         break;
1204 #endif
1205     default:
1206         return 0;
1207     }
1208
1209     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
1210         goto done;
1211
1212     if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
1213         goto done;
1214
1215     if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
1216         goto done;
1217
1218     if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
1219         goto done;
1220
1221     ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
1222     /* assign the pkey directly, as an internal test */
1223     EVP_PKEY_up_ref(pkey);
1224     ctx2->pkey = pkey;
1225
1226     if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
1227         goto done;
1228
1229     if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
1230         goto done;
1231
1232     if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
1233         goto done;
1234
1235     ret = 1;
1236
1237  done:
1238     EVP_PKEY_CTX_free(ctx);
1239     EVP_PKEY_CTX_free(ctx2);
1240     EVP_PKEY_free(pkey);
1241     BIO_free(pubkey);
1242     return ret;
1243 }
1244
1245 #ifndef OPENSSL_NO_CMAC
1246 static int test_CMAC_keygen(void)
1247 {
1248     /*
1249      * This is a legacy method for CMACs, but should still work.
1250      * This verifies that it works without an ENGINE.
1251      */
1252     EVP_PKEY_CTX *kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_CMAC, NULL);
1253     int ret = 0;
1254
1255     if (!TEST_true(EVP_PKEY_keygen_init(kctx) > 0)
1256         && !TEST_true(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
1257                                         EVP_PKEY_CTRL_CIPHER,
1258                                         0, (void *)EVP_aes_256_ecb()) > 0))
1259         goto done;
1260     ret = 1;
1261
1262  done:
1263     EVP_PKEY_CTX_free(kctx);
1264     return ret;
1265 }
1266 #endif
1267
1268 static int test_HKDF(void)
1269 {
1270     EVP_PKEY_CTX *pctx;
1271     unsigned char out[20];
1272     size_t outlen;
1273     int i, ret = 0;
1274     unsigned char salt[] = "0123456789";
1275     unsigned char key[] = "012345678901234567890123456789";
1276     unsigned char info[] = "infostring";
1277     const unsigned char expected[] = {
1278         0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
1279         0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
1280     };
1281     size_t expectedlen = sizeof(expected);
1282
1283     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1284         goto done;
1285
1286     /* We do this twice to test reuse of the EVP_PKEY_CTX */
1287     for (i = 0; i < 2; i++) {
1288         outlen = sizeof(out);
1289         memset(out, 0, outlen);
1290
1291         if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1292                 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1293                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1294                                                             sizeof(salt) - 1), 0)
1295                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1296                                                            sizeof(key) - 1), 0)
1297                 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1298                                                             sizeof(info) - 1), 0)
1299                 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1300                 || !TEST_mem_eq(out, outlen, expected, expectedlen))
1301             goto done;
1302     }
1303
1304     ret = 1;
1305
1306  done:
1307     EVP_PKEY_CTX_free(pctx);
1308
1309     return ret;
1310 }
1311
1312 static int test_emptyikm_HKDF(void)
1313 {
1314     EVP_PKEY_CTX *pctx;
1315     unsigned char out[20];
1316     size_t outlen;
1317     int ret = 0;
1318     unsigned char salt[] = "9876543210";
1319     unsigned char key[] = "";
1320     unsigned char info[] = "stringinfo";
1321     const unsigned char expected[] = {
1322         0x68, 0x81, 0xa5, 0x3e, 0x5b, 0x9c, 0x7b, 0x6f, 0x2e, 0xec, 0xc8, 0x47,
1323         0x7c, 0xfa, 0x47, 0x35, 0x66, 0x82, 0x15, 0x30
1324     };
1325     size_t expectedlen = sizeof(expected);
1326
1327     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1328         goto done;
1329
1330     outlen = sizeof(out);
1331     memset(out, 0, outlen);
1332
1333     if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1334             || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1335             || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1336                                                         sizeof(salt) - 1), 0)
1337             || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1338                                                        sizeof(key) - 1), 0)
1339             || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1340                                                         sizeof(info) - 1), 0)
1341             || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1342             || !TEST_mem_eq(out, outlen, expected, expectedlen))
1343         goto done;
1344
1345     ret = 1;
1346
1347  done:
1348     EVP_PKEY_CTX_free(pctx);
1349
1350     return ret;
1351 }
1352
1353 #ifndef OPENSSL_NO_EC
1354 static int test_X509_PUBKEY_inplace(void)
1355 {
1356   int ret = 0;
1357   X509_PUBKEY *xp = NULL;
1358   const unsigned char *p = kExampleECPubKeyDER;
1359   size_t input_len = sizeof(kExampleECPubKeyDER);
1360
1361   if (!TEST_ptr(xp = d2i_X509_PUBKEY(NULL, &p, input_len)))
1362     goto done;
1363
1364   if (!TEST_ptr(X509_PUBKEY_get0(xp)))
1365     goto done;
1366
1367   p = kExampleBadECPubKeyDER;
1368   input_len = sizeof(kExampleBadECPubKeyDER);
1369
1370   if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
1371     goto done;
1372
1373   if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
1374     goto done;
1375
1376   ret = 1;
1377
1378 done:
1379   X509_PUBKEY_free(xp);
1380   return ret;
1381 }
1382 #endif /* OPENSSL_NO_EC */
1383
1384 /* Test getting and setting parameters on an EVP_PKEY_CTX */
1385 static int test_EVP_PKEY_CTX_get_set_params(EVP_PKEY *pkey)
1386 {
1387     EVP_MD_CTX *mdctx = NULL;
1388     EVP_PKEY_CTX *ctx = NULL;
1389     const OSSL_PARAM *params;
1390     OSSL_PARAM ourparams[2], *param = ourparams, *param_md;
1391     int ret = 0;
1392     const EVP_MD *md;
1393     char mdname[OSSL_MAX_NAME_SIZE];
1394     char ssl3ms[48];
1395
1396     /* Initialise a sign operation */
1397     ctx = EVP_PKEY_CTX_new(pkey, NULL);
1398     if (!TEST_ptr(ctx)
1399             || !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0))
1400         goto err;
1401
1402     /*
1403      * We should be able to query the parameters now.
1404      */
1405     params = EVP_PKEY_CTX_settable_params(ctx);
1406     if (!TEST_ptr(params)
1407         || !TEST_ptr(OSSL_PARAM_locate_const(params,
1408                                              OSSL_SIGNATURE_PARAM_DIGEST)))
1409         goto err;
1410
1411     params = EVP_PKEY_CTX_gettable_params(ctx);
1412     if (!TEST_ptr(params)
1413         || !TEST_ptr(OSSL_PARAM_locate_const(params,
1414                                              OSSL_SIGNATURE_PARAM_ALGORITHM_ID))
1415         || !TEST_ptr(OSSL_PARAM_locate_const(params,
1416                                              OSSL_SIGNATURE_PARAM_DIGEST)))
1417         goto err;
1418
1419     /*
1420      * Test getting and setting params via EVP_PKEY_CTX_set_params() and
1421      * EVP_PKEY_CTX_get_params()
1422      */
1423     strcpy(mdname, "SHA512");
1424     param_md = param;
1425     *param++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1426                                                 mdname, 0);
1427     *param++ = OSSL_PARAM_construct_end();
1428
1429     if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams)))
1430         goto err;
1431
1432     mdname[0] = '\0';
1433     *param_md = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1434                                                  mdname, sizeof(mdname));
1435     if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams))
1436             || !TEST_str_eq(mdname, "SHA512"))
1437         goto err;
1438
1439     /*
1440      * Test the TEST_PKEY_CTX_set_signature_md() and
1441      * TEST_PKEY_CTX_get_signature_md() functions
1442      */
1443     if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0)
1444             || !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0)
1445             || !TEST_ptr_eq(md, EVP_sha256()))
1446         goto err;
1447
1448     /*
1449      * Test getting MD parameters via an associated EVP_PKEY_CTX
1450      */
1451     mdctx = EVP_MD_CTX_new();
1452     if (!TEST_ptr(mdctx)
1453         || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", NULL, pkey,
1454                                             NULL)))
1455         goto err;
1456
1457     /*
1458      * We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be
1459      * able to obtain the digest's settable parameters from the provider.
1460      */
1461     params = EVP_MD_CTX_settable_params(mdctx);
1462     if (!TEST_ptr(params)
1463             || !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0)
1464                /* The final key should be NULL */
1465             || !TEST_ptr_null(params[1].key))
1466         goto err;
1467
1468     param = ourparams;
1469     memset(ssl3ms, 0, sizeof(ssl3ms));
1470     *param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
1471                                                  ssl3ms, sizeof(ssl3ms));
1472     *param++ = OSSL_PARAM_construct_end();
1473
1474     if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams)))
1475         goto err;
1476
1477     ret = 1;
1478
1479  err:
1480     EVP_MD_CTX_free(mdctx);
1481     EVP_PKEY_CTX_free(ctx);
1482
1483     return ret;
1484 }
1485
1486 #ifndef OPENSSL_NO_DSA
1487 static int test_DSA_get_set_params(void)
1488 {
1489     DSA *dsa = NULL;
1490     BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub = NULL, *priv = NULL;
1491     EVP_PKEY *pkey = NULL;
1492     int ret = 0;
1493
1494     /*
1495      * Setup the parameters for our DSA object. For our purposes they don't
1496      * have to actually be *valid* parameters. We just need to set something.
1497      */
1498     dsa = DSA_new();
1499     p = BN_new();
1500     q = BN_new();
1501     g = BN_new();
1502     pub = BN_new();
1503     priv = BN_new();
1504     if (!TEST_ptr(dsa)
1505             || !TEST_ptr(p)
1506             || !TEST_ptr(q)
1507             || !TEST_ptr(g)
1508             || !TEST_ptr(pub)
1509             || !DSA_set0_pqg(dsa, p, q, g)
1510         || !DSA_set0_key(dsa, pub, priv))
1511         goto err;
1512     p = q = g = pub = priv = NULL;
1513
1514     pkey = EVP_PKEY_new();
1515     if (!TEST_ptr(pkey)
1516             || !TEST_true(EVP_PKEY_assign_DSA(pkey, dsa)))
1517         goto err;
1518
1519     dsa = NULL;
1520
1521     ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1522
1523  err:
1524     EVP_PKEY_free(pkey);
1525     DSA_free(dsa);
1526     BN_free(p);
1527     BN_free(q);
1528     BN_free(g);
1529     BN_free(pub);
1530     BN_free(priv);
1531
1532     return ret;
1533 }
1534 #endif
1535
1536 static int test_RSA_get_set_params(void)
1537 {
1538     RSA *rsa = NULL;
1539     BIGNUM *n = NULL, *e = NULL, *d = NULL;
1540     EVP_PKEY *pkey = NULL;
1541     int ret = 0;
1542
1543     /*
1544      * Setup the parameters for our RSA object. For our purposes they don't
1545      * have to actually be *valid* parameters. We just need to set something.
1546      */
1547     rsa = RSA_new();
1548     n = BN_new();
1549     e = BN_new();
1550     d = BN_new();
1551     if (!TEST_ptr(rsa)
1552             || !TEST_ptr(n)
1553             || !TEST_ptr(e)
1554             || !TEST_ptr(d)
1555         || !RSA_set0_key(rsa, n, e, d))
1556         goto err;
1557     n = e = d = NULL;
1558
1559     pkey = EVP_PKEY_new();
1560     if (!TEST_ptr(pkey)
1561             || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa)))
1562         goto err;
1563
1564     rsa = NULL;
1565
1566     ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1567
1568  err:
1569     EVP_PKEY_free(pkey);
1570     RSA_free(rsa);
1571     BN_free(n);
1572     BN_free(e);
1573     BN_free(d);
1574
1575     return ret;
1576 }
1577
1578 #if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1579 static int test_decrypt_null_chunks(void)
1580 {
1581     EVP_CIPHER_CTX* ctx = NULL;
1582     const unsigned char key[32] = {
1583         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1584         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1585         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1
1586     };
1587     unsigned char iv[12] = {
1588         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
1589     };
1590     unsigned char msg[] = "It was the best of times, it was the worst of times";
1591     unsigned char ciphertext[80];
1592     unsigned char plaintext[80];
1593     /* We initialise tmp to a non zero value on purpose */
1594     int ctlen, ptlen, tmp = 99;
1595     int ret = 0;
1596     const int enc_offset = 10, dec_offset = 20;
1597
1598     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
1599             || !TEST_true(EVP_EncryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL,
1600                                              key, iv))
1601             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &ctlen, msg,
1602                                             enc_offset))
1603             /* Deliberate add a zero length update */
1604             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp, NULL,
1605                                             0))
1606             || !TEST_int_eq(tmp, 0)
1607             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp,
1608                                             msg + enc_offset,
1609                                             sizeof(msg) - enc_offset))
1610             || !TEST_int_eq(ctlen += tmp, sizeof(msg))
1611             || !TEST_true(EVP_EncryptFinal(ctx, ciphertext + ctlen, &tmp))
1612             || !TEST_int_eq(tmp, 0))
1613         goto err;
1614
1615     /* Deliberately initialise tmp to a non zero value */
1616     tmp = 99;
1617     if (!TEST_true(EVP_DecryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL, key,
1618                                       iv))
1619             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext, &ptlen, ciphertext,
1620                                             dec_offset))
1621             /*
1622              * Deliberately add a zero length update. We also deliberately do
1623              * this at a different offset than for encryption.
1624              */
1625             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp, NULL,
1626                                             0))
1627             || !TEST_int_eq(tmp, 0)
1628             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp,
1629                                             ciphertext + dec_offset,
1630                                             ctlen - dec_offset))
1631             || !TEST_int_eq(ptlen += tmp, sizeof(msg))
1632             || !TEST_true(EVP_DecryptFinal(ctx, plaintext + ptlen, &tmp))
1633             || !TEST_int_eq(tmp, 0)
1634             || !TEST_mem_eq(msg, sizeof(msg), plaintext, ptlen))
1635         goto err;
1636
1637     ret = 1;
1638  err:
1639     EVP_CIPHER_CTX_free(ctx);
1640     return ret;
1641 }
1642 #endif /* !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) */
1643
1644 #ifndef OPENSSL_NO_DH
1645 static int test_EVP_PKEY_set1_DH(void)
1646 {
1647     DH *x942dh = NULL, *noqdh = NULL;
1648     EVP_PKEY *pkey1 = NULL, *pkey2 = NULL;
1649     int ret = 0;
1650     BIGNUM *p, *g = NULL;
1651
1652     if (!TEST_ptr(p = BN_new())
1653             || !TEST_ptr(g = BN_new())
1654             || !BN_set_word(p, 9999)
1655             || !BN_set_word(g, 2)
1656             || !TEST_ptr(noqdh = DH_new())
1657             || !DH_set0_pqg(noqdh, p, NULL, g))
1658         goto err;
1659     p = g = NULL;
1660
1661     x942dh = DH_get_2048_256();
1662     pkey1 = EVP_PKEY_new();
1663     pkey2 = EVP_PKEY_new();
1664     if (!TEST_ptr(x942dh)
1665             || !TEST_ptr(noqdh)
1666             || !TEST_ptr(pkey1)
1667             || !TEST_ptr(pkey2))
1668         goto err;
1669
1670     if(!TEST_true(EVP_PKEY_set1_DH(pkey1, x942dh))
1671             || !TEST_int_eq(EVP_PKEY_id(pkey1), EVP_PKEY_DHX))
1672         goto err;
1673
1674     if(!TEST_true(EVP_PKEY_set1_DH(pkey2, noqdh))
1675             || !TEST_int_eq(EVP_PKEY_id(pkey2), EVP_PKEY_DH))
1676         goto err;
1677
1678     ret = 1;
1679  err:
1680     BN_free(p);
1681     BN_free(g);
1682     EVP_PKEY_free(pkey1);
1683     EVP_PKEY_free(pkey2);
1684     DH_free(x942dh);
1685     DH_free(noqdh);
1686
1687     return ret;
1688 }
1689 #endif
1690
1691 /*
1692  * We test what happens with an empty template.  For the sake of this test,
1693  * the template must be ignored, and we know that's the case for RSA keys
1694  * (this might arguably be a misfeature, but that's what we currently do,
1695  * even in provider code, since that's how the legacy RSA implementation
1696  * does things)
1697  */
1698 static int test_keygen_with_empty_template(int n)
1699 {
1700     EVP_PKEY_CTX *ctx = NULL;
1701     EVP_PKEY *pkey = NULL;
1702     EVP_PKEY *tkey = NULL;
1703     int ret = 0;
1704
1705     switch (n) {
1706     case 0:
1707         /* We do test with no template at all as well */
1708         if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
1709             goto err;
1710         break;
1711     case 1:
1712         /* Here we create an empty RSA key that serves as our template */
1713         if (!TEST_ptr(tkey = EVP_PKEY_new())
1714             || !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
1715             || !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
1716             goto err;
1717         break;
1718     }
1719
1720     if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1721         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
1722         goto err;
1723
1724     ret = 1;
1725  err:
1726     EVP_PKEY_CTX_free(ctx);
1727     EVP_PKEY_free(pkey);
1728     EVP_PKEY_free(tkey);
1729     return ret;
1730 }
1731
1732 /*
1733  * Test that we fail if we attempt to use an algorithm that is not available
1734  * in the current library context (unless we are using an algorithm that should
1735  * be made available via legacy codepaths).
1736  */
1737 static int test_pkey_ctx_fail_without_provider(int tst)
1738 {
1739     OPENSSL_CTX *tmpctx = OPENSSL_CTX_new();
1740     OSSL_PROVIDER *nullprov = NULL;
1741     EVP_PKEY_CTX *pctx = NULL;
1742     int ret = 0;
1743
1744     if (!TEST_ptr(tmpctx))
1745         goto err;
1746
1747     nullprov = OSSL_PROVIDER_load(tmpctx, "null");
1748     if (!TEST_ptr(nullprov))
1749         goto err;
1750
1751     pctx = EVP_PKEY_CTX_new_from_name(tmpctx, tst == 0 ? "RSA" : "HMAC", "");
1752
1753     /* RSA is not available via any provider so we expect this to fail */
1754     if (tst == 0 && !TEST_ptr_null(pctx))
1755         goto err;
1756
1757     /*
1758      * HMAC is always available because it is implemented via legacy codepaths
1759      * and not in a provider at all. We expect this to pass.
1760      */
1761     if (tst == 1 && !TEST_ptr(pctx))
1762         goto err;
1763
1764     ret = 1;
1765
1766  err:
1767     EVP_PKEY_CTX_free(pctx);
1768     OSSL_PROVIDER_unload(nullprov);
1769     OPENSSL_CTX_free(tmpctx);
1770     return ret;
1771 }
1772
1773 static int test_rand_agglomeration(void)
1774 {
1775     EVP_RAND *rand;
1776     EVP_RAND_CTX *ctx;
1777     OSSL_PARAM params[3], *p = params;
1778     int res;
1779     unsigned int step = 7;
1780     static unsigned char seed[] = "It does not matter how slowly you go "
1781                                   "as long as you do not stop.";
1782     unsigned char out[sizeof(seed)];
1783
1784     if (!TEST_int_ne(sizeof(seed) % step, 0)
1785             || !TEST_ptr(rand = EVP_RAND_fetch(NULL, "TEST-RAND", NULL)))
1786         return 0;
1787     ctx = EVP_RAND_CTX_new(rand, NULL);
1788     EVP_RAND_free(rand);
1789     if (!TEST_ptr(ctx))
1790         return 0;
1791
1792     memset(out, 0, sizeof(out));
1793     *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
1794                                              seed, sizeof(seed));
1795     *p++ = OSSL_PARAM_construct_uint(OSSL_DRBG_PARAM_MAX_REQUEST, &step);
1796     *p = OSSL_PARAM_construct_end();
1797     res = TEST_true(EVP_RAND_set_ctx_params(ctx, params))
1798           && TEST_true(EVP_RAND_generate(ctx, out, sizeof(out), 0, 1, NULL, 0))
1799           && TEST_mem_eq(seed, sizeof(seed), out, sizeof(out));
1800     EVP_RAND_CTX_free(ctx);
1801     return res;
1802 }
1803
1804 int setup_tests(void)
1805 {
1806     testctx = OPENSSL_CTX_new();
1807
1808     if (!TEST_ptr(testctx))
1809         return 0;
1810
1811     ADD_TEST(test_EVP_set_default_properties);
1812     ADD_ALL_TESTS(test_EVP_DigestSignInit, 9);
1813     ADD_TEST(test_EVP_DigestVerifyInit);
1814     ADD_TEST(test_EVP_Enveloped);
1815     ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
1816     ADD_TEST(test_privatekey_to_pkcs8);
1817 #ifndef OPENSSL_NO_EC
1818     ADD_TEST(test_EVP_PKCS82PKEY);
1819 #endif
1820 #if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
1821     ADD_TEST(test_EVP_SM2);
1822     ADD_TEST(test_EVP_SM2_verify);
1823 #endif
1824     ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
1825     custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
1826     if (!TEST_ptr(custom_pmeth))
1827         return 0;
1828     EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
1829     EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
1830     EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
1831     if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
1832         return 0;
1833     ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
1834 #ifndef OPENSSL_NO_CMAC
1835     ADD_TEST(test_CMAC_keygen);
1836 #endif
1837     ADD_TEST(test_HKDF);
1838     ADD_TEST(test_emptyikm_HKDF);
1839 #ifndef OPENSSL_NO_EC
1840     ADD_TEST(test_X509_PUBKEY_inplace);
1841     ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
1842                   OSSL_NELEM(ec_der_pub_keys));
1843 #endif
1844 #ifndef OPENSSL_NO_DSA
1845     ADD_TEST(test_DSA_get_set_params);
1846 #endif
1847     ADD_TEST(test_RSA_get_set_params);
1848 #if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1849     ADD_TEST(test_decrypt_null_chunks);
1850 #endif
1851 #ifndef OPENSSL_NO_DH
1852     ADD_TEST(test_EVP_PKEY_set1_DH);
1853 #endif
1854     ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
1855     ADD_ALL_TESTS(test_pkey_ctx_fail_without_provider, 2);
1856
1857     ADD_TEST(test_rand_agglomeration);
1858
1859     return 1;
1860 }
1861
1862 void cleanup_tests(void)
1863 {
1864     OPENSSL_CTX_free(testctx);
1865 }