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_Enveloped(void)
 475 {
 476     int ret = 0;
 477     EVP_CIPHER_CTX *ctx = NULL;
 478     EVP_PKEY *keypair = NULL;
 479     unsigned char *kek = NULL;
 480     unsigned char iv[EVP_MAX_IV_LENGTH];
 481     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 482     int len, kek_len, ciphertext_len, plaintext_len;
 483     unsigned char ciphertext[32], plaintext[16];
 484     const EVP_CIPHER *type = EVP_aes_256_cbc();
 485
 486     if (!TEST_ptr(keypair = load_example_rsa_key())
 487             || !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_size(keypair)))
 488             || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
 489             || !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
 490                                        &keypair, 1))
 491             || !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
 492                                          msg, sizeof(msg)))
 493             || !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
 494                                         &len)))
 495         goto err;
 496
 497     ciphertext_len += len;
 498
 499     if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
 500             || !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
 501                                          ciphertext, ciphertext_len))
 502             || !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
 503         goto err;
 504
 505     plaintext_len += len;
 506     if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
 507         goto err;
 508
 509     ret = 1;
 510 err:
 511     OPENSSL_free(kek);
 512     EVP_PKEY_free(keypair);
 513     EVP_CIPHER_CTX_free(ctx);
 514     return ret;
 515 }
 516
 517 /*
 518  * Test 0: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, RSA)
 519  * Test 1: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, DSA)
 520  * Test 2: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, HMAC)
 521  * Test 3: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, RSA)
 522  * Test 4: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, DSA)
 523  * Test 5: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch diegst, HMAC)
 524  * Test 6: Use an MD BIO to do the Update calls instead (RSA)
 525  * Test 7: Use an MD BIO to do the Update calls instead (DSA)
 526  * Test 8: Use an MD BIO to do the Update calls instead (HMAC)
 527  */
 528 static int test_EVP_DigestSignInit(int tst)
 529 {
 530     int ret = 0;
 531     EVP_PKEY *pkey = NULL;
 532     unsigned char *sig = NULL;
 533     size_t sig_len = 0;
 534     EVP_MD_CTX *md_ctx = NULL, *md_ctx_verify = NULL;
 535     EVP_MD_CTX *a_md_ctx = NULL, *a_md_ctx_verify = NULL;
 536     BIO *mdbio = NULL, *membio = NULL;
 537     size_t written;
 538     const EVP_MD *md;
 539     EVP_MD *mdexp = NULL;
 540
 541     if (tst >= 6) {
 542         membio = BIO_new(BIO_s_mem());
 543         mdbio = BIO_new(BIO_f_md());
 544         if (!TEST_ptr(membio) || !TEST_ptr(mdbio))
 545             goto out;
 546         BIO_push(mdbio, membio);
 547         if (!TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx), 0))
 548             goto out;
 549     } else {
 550         if (!TEST_ptr(a_md_ctx = md_ctx = EVP_MD_CTX_new())
 551                 || !TEST_ptr(a_md_ctx_verify = md_ctx_verify = EVP_MD_CTX_new()))
 552             goto out;
 553     }
 554
 555     if (tst == 0 || tst == 3 || tst == 6) {
 556         if (!TEST_ptr(pkey = load_example_rsa_key()))
 557                 goto out;
 558     } else if (tst == 1 || tst == 4 || tst == 7) {
 559 #ifndef OPENSSL_NO_DSA
 560         if (!TEST_ptr(pkey = load_example_dsa_key()))
 561                 goto out;
 562 #else
 563         ret = 1;
 564         goto out;
 565 #endif
 566     } else {
 567         if (!TEST_ptr(pkey = load_example_hmac_key()))
 568                 goto out;
 569     }
 570
 571     if (tst >= 3 && tst <= 5)
 572         md = mdexp = EVP_MD_fetch(NULL, "SHA256", NULL);
 573     else
 574         md = EVP_sha256();
 575
 576     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, md, NULL, pkey)))
 577         goto out;
 578
 579     if (tst >= 6) {
 580         if (!BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written))
 581             goto out;
 582     } else {
 583         if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 584             goto out;
 585     }
 586
 587     /* Determine the size of the signature. */
 588     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
 589             || !TEST_ptr(sig = OPENSSL_malloc(sig_len))
 590             || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 591         goto out;
 592
 593     if (tst >= 6) {
 594         if (!TEST_int_gt(BIO_reset(mdbio), 0)
 595                 || !TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx_verify), 0))
 596             goto out;
 597     }
 598
 599     /*
 600      * Ensure that the signature round-trips (Verification isn't supported for
 601      * HMAC via EVP_DigestVerify*)
 602      */
 603     if (tst != 2 && tst != 5 && tst != 8) {
 604         if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, md,
 605                                             NULL, pkey)))
 606             goto out;
 607
 608         if (tst >= 6) {
 609             if (!TEST_true(BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written)))
 610                 goto out;
 611         } else {
 612             if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg,
 613                                                   sizeof(kMsg))))
 614                 goto out;
 615         }
 616         if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 617             goto out;
 618     }
 619
 620     ret = 1;
 621
 622  out:
 623     BIO_free(membio);
 624     BIO_free(mdbio);
 625     EVP_MD_CTX_free(a_md_ctx);
 626     EVP_MD_CTX_free(a_md_ctx_verify);
 627     EVP_PKEY_free(pkey);
 628     OPENSSL_free(sig);
 629     EVP_MD_free(mdexp);
 630
 631     return ret;
 632 }
 633
 634 static int test_EVP_DigestVerifyInit(void)
 635 {
 636     int ret = 0;
 637     EVP_PKEY *pkey = NULL;
 638     EVP_MD_CTX *md_ctx = NULL;
 639
 640     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 641             || !TEST_ptr(pkey = load_example_rsa_key()))
 642         goto out;
 643
 644     if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 645             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
 646             || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
 647                                                  sizeof(kSignature))))
 648         goto out;
 649     ret = 1;
 650
 651  out:
 652     EVP_MD_CTX_free(md_ctx);
 653     EVP_PKEY_free(pkey);
 654     return ret;
 655 }
 656
 657 static int test_d2i_AutoPrivateKey(int i)
 658 {
 659     int ret = 0;
 660     const unsigned char *p;
 661     EVP_PKEY *pkey = NULL;
 662     const APK_DATA *ak = &keydata[i];
 663     const unsigned char *input = ak->kder;
 664     size_t input_len = ak->size;
 665     int expected_id = ak->evptype;
 666
 667     p = input;
 668     if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 669             || !TEST_ptr_eq(p, input + input_len)
 670             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
 671         goto done;
 672
 673     ret = 1;
 674
 675  done:
 676     EVP_PKEY_free(pkey);
 677     return ret;
 678 }
 679
 680 #ifndef OPENSSL_NO_EC
 681
 682 static const unsigned char ec_public_sect163k1_validxy[] = {
 683     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 684     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
 685     0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
 686     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b,
 687     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
 688     0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
 689 };
 690
 691 static const unsigned char ec_public_sect163k1_badx[] = {
 692     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 693     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
 694     0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
 695     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b,
 696     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
 697     0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
 698 };
 699
 700 static const unsigned char ec_public_sect163k1_bady[] = {
 701     0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 702     0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
 703     0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
 704     0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b,
 705     0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
 706     0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6
 707 };
 708
 709 static struct ec_der_pub_keys_st {
 710     const unsigned char *der;
 711     size_t len;
 712     int valid;
 713 } ec_der_pub_keys[] = {
 714     { ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 },
 715     { ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 },
 716     { ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 },
 717 };
 718
 719 /*
 720  * Tests the range of the decoded EC char2 public point.
 721  * See ec_GF2m_simple_oct2point().
 722  */
 723 static int test_invalide_ec_char2_pub_range_decode(int id)
 724 {
 725     int ret = 0;
 726     BIO *bio = NULL;
 727     EC_KEY *eckey = NULL;
 728
 729     if (!TEST_ptr(bio = BIO_new_mem_buf(ec_der_pub_keys[id].der,
 730                                         ec_der_pub_keys[id].len)))
 731         goto err;
 732     eckey = d2i_EC_PUBKEY_bio(bio, NULL);
 733     ret = (ec_der_pub_keys[id].valid && TEST_ptr(eckey))
 734           || TEST_ptr_null(eckey);
 735 err:
 736     EC_KEY_free(eckey);
 737     BIO_free(bio);
 738     return ret;
 739 }
 740
 741 /* Tests loading a bad key in PKCS8 format */
 742 static int test_EVP_PKCS82PKEY(void)
 743 {
 744     int ret = 0;
 745     const unsigned char *derp = kExampleBadECKeyDER;
 746     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
 747     EVP_PKEY *pkey = NULL;
 748
 749     if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
 750                                               sizeof(kExampleBadECKeyDER))))
 751         goto done;
 752
 753     if (!TEST_ptr_eq(derp,
 754                      kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
 755         goto done;
 756
 757     if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
 758         goto done;
 759
 760     ret = 1;
 761
 762  done:
 763     PKCS8_PRIV_KEY_INFO_free(p8inf);
 764     EVP_PKEY_free(pkey);
 765
 766     return ret;
 767 }
 768 #endif
 769
 770 /* This uses kExampleRSAKeyDER and kExampleRSAKeyPKCS8 to verify encoding */
 771 static int test_privatekey_to_pkcs8(void)
 772 {
 773     EVP_PKEY *pkey = NULL;
 774     BIO *membio = NULL;
 775     char *membuf = NULL;
 776     size_t membuf_len = 0;
 777     int ok = 0;
 778
 779     if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
 780         || !TEST_ptr(pkey = load_example_rsa_key())
 781         || !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
 782                                                 NULL, 0, NULL, NULL),
 783                         0)
 784         || !TEST_ptr((membuf_len = (size_t)BIO_get_mem_data(membio, &membuf),
 785                       membuf))
 786         || !TEST_mem_eq(membuf, membuf_len,
 787                         kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8))
 788         /*
 789          * We try to write PEM as well, just to see that it doesn't err, but
 790          * assume that the result is correct.
 791          */
 792         || !TEST_int_gt(PEM_write_bio_PKCS8PrivateKey(membio, pkey, NULL,
 793                                                       NULL, 0, NULL, NULL),
 794                         0))
 795         goto done;
 796
 797     ok = 1;
 798  done:
 799     EVP_PKEY_free(pkey);
 800     BIO_free_all(membio);
 801     return ok;
 802 }
 803
 804 #if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
 805
 806 static int test_EVP_SM2_verify(void)
 807 {
 808     /* From https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02#appendix-A */
 809     const char *pubkey =
 810        "-----BEGIN PUBLIC KEY-----\n"
 811        "MIIBMzCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEAhULWnkwETxjouSQ1\n"
 812        "v2/33kVyg5FcRVF9ci7biwjx38MwRAQgeHlotPoyw/0kF4Quc7v+/y88hItoMdfg\n"
 813        "7GUiizk35JgEIGPkxtOyOwyEnPhCQUhL/kj2HVmlsWugbm4S0donxSSaBEEEQh3r\n"
 814        "1hti6rZ0ZDTrw8wxXjIiCzut1QvcTE5sFH/t1D0GgFEry7QsB9RzSdIVO3DE5df9\n"
 815        "/L+jbqGoWEG55G4JogIhAIVC1p5MBE8Y6LkkNb9v990pdyBjBIVijVrnTufDLnm3\n"
 816        "AgEBA0IABArkx3mKoPEZRxvuEYJb5GICu3nipYRElel8BP9N8lSKfAJA+I8c1OFj\n"
 817        "Uqc8F7fxbwc1PlOhdtaEqf4Ma7eY6Fc=\n"
 818        "-----END PUBLIC KEY-----\n";
 819
 820     const char *msg = "message digest";
 821     const char *id = "ALICE123@YAHOO.COM";
 822
 823     const uint8_t signature[] = {
 824        0x30, 0x44, 0x02, 0x20,
 825
 826        0x40, 0xF1, 0xEC, 0x59, 0xF7, 0x93, 0xD9, 0xF4, 0x9E, 0x09, 0xDC,
 827        0xEF, 0x49, 0x13, 0x0D, 0x41, 0x94, 0xF7, 0x9F, 0xB1, 0xEE, 0xD2,
 828        0xCA, 0xA5, 0x5B, 0xAC, 0xDB, 0x49, 0xC4, 0xE7, 0x55, 0xD1,
 829
 830        0x02, 0x20,
 831
 832        0x6F, 0xC6, 0xDA, 0xC3, 0x2C, 0x5D, 0x5C, 0xF1, 0x0C, 0x77, 0xDF,
 833        0xB2, 0x0F, 0x7C, 0x2E, 0xB6, 0x67, 0xA4, 0x57, 0x87, 0x2F, 0xB0,
 834        0x9E, 0xC5, 0x63, 0x27, 0xA6, 0x7E, 0xC7, 0xDE, 0xEB, 0xE7
 835     };
 836
 837     int rc = 0;
 838     BIO *bio = NULL;
 839     EVP_PKEY *pkey = NULL;
 840     EVP_MD_CTX *mctx = NULL;
 841     EVP_PKEY_CTX *pctx = NULL;
 842
 843     bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
 844     if (!TEST_true(bio != NULL))
 845         goto done;
 846
 847     pkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
 848     if (!TEST_true(pkey != NULL))
 849         goto done;
 850
 851     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 852         goto done;
 853
 854     if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
 855         goto done;
 856
 857     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new(pkey, NULL)))
 858         goto done;
 859
 860     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, (const uint8_t *)id,
 861                                           strlen(id)), 0))
 862         goto done;
 863
 864     EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
 865
 866     if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, EVP_sm3(), NULL, pkey)))
 867         goto done;
 868
 869     if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
 870         goto done;
 871
 872     if (!TEST_true(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature))))
 873         goto done;
 874     rc = 1;
 875
 876  done:
 877     BIO_free(bio);
 878     EVP_PKEY_free(pkey);
 879     EVP_PKEY_CTX_free(pctx);
 880     EVP_MD_CTX_free(mctx);
 881     return rc;
 882 }
 883
 884 static int test_EVP_SM2(void)
 885 {
 886     int ret = 0;
 887     EVP_PKEY *pkey = NULL;
 888     EVP_PKEY *params = NULL;
 889     EVP_PKEY_CTX *pctx = NULL;
 890     EVP_PKEY_CTX *kctx = NULL;
 891     EVP_PKEY_CTX *sctx = NULL;
 892     size_t sig_len = 0;
 893     unsigned char *sig = NULL;
 894     EVP_MD_CTX *md_ctx = NULL;
 895     EVP_MD_CTX *md_ctx_verify = NULL;
 896     EVP_PKEY_CTX *cctx = NULL;
 897
 898     uint8_t ciphertext[128];
 899     size_t ctext_len = sizeof(ciphertext);
 900
 901     uint8_t plaintext[8];
 902     size_t ptext_len = sizeof(plaintext);
 903
 904     uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
 905
 906     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
 907     if (!TEST_ptr(pctx))
 908         goto done;
 909
 910     if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
 911         goto done;
 912
 913     if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
 914         goto done;
 915
 916     if (!TEST_true(EVP_PKEY_paramgen(pctx, &params)))
 917         goto done;
 918
 919     kctx = EVP_PKEY_CTX_new(params, NULL);
 920     if (!TEST_ptr(kctx))
 921         goto done;
 922
 923     if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
 924         goto done;
 925
 926     if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
 927         goto done;
 928
 929     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 930         goto done;
 931
 932     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
 933         goto done;
 934
 935     if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
 936         goto done;
 937
 938     if (!TEST_ptr(sctx = EVP_PKEY_CTX_new(pkey, NULL)))
 939         goto done;
 940
 941     EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
 942     EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
 943
 944     if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
 945         goto done;
 946
 947     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
 948         goto done;
 949
 950     if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 951         goto done;
 952
 953     /* Determine the size of the signature. */
 954     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
 955         goto done;
 956
 957     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
 958         goto done;
 959
 960     if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 961         goto done;
 962
 963     /* Ensure that the signature round-trips. */
 964
 965     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
 966         goto done;
 967
 968     if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
 969         goto done;
 970
 971     if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 972         goto done;
 973
 974     /* now check encryption/decryption */
 975
 976     if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
 977         goto done;
 978
 979     if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
 980         goto done;
 981
 982     if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
 983         goto done;
 984
 985     if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
 986         goto done;
 987
 988     if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
 989         goto done;
 990
 991     if (!TEST_true(ptext_len == sizeof(kMsg)))
 992         goto done;
 993
 994     if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
 995         goto done;
 996
 997     ret = 1;
 998 done:
 999     EVP_PKEY_CTX_free(pctx);
1000     EVP_PKEY_CTX_free(kctx);
1001     EVP_PKEY_CTX_free(sctx);
1002     EVP_PKEY_CTX_free(cctx);
1003     EVP_PKEY_free(pkey);
1004     EVP_PKEY_free(params);
1005     EVP_MD_CTX_free(md_ctx);
1006     EVP_MD_CTX_free(md_ctx_verify);
1007     OPENSSL_free(sig);
1008     return ret;
1009 }
1010
1011 #endif
1012
1013 static struct keys_st {
1014     int type;
1015     char *priv;
1016     char *pub;
1017 } keys[] = {
1018     {
1019         EVP_PKEY_HMAC, "0123456789", NULL
1020     }, {
1021         EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
1022     }, {
1023         EVP_PKEY_SIPHASH, "0123456789012345", NULL
1024     },
1025 #ifndef OPENSSL_NO_EC
1026     {
1027         EVP_PKEY_X25519, "01234567890123456789012345678901",
1028         "abcdefghijklmnopqrstuvwxyzabcdef"
1029     }, {
1030         EVP_PKEY_ED25519, "01234567890123456789012345678901",
1031         "abcdefghijklmnopqrstuvwxyzabcdef"
1032     }, {
1033         EVP_PKEY_X448,
1034         "01234567890123456789012345678901234567890123456789012345",
1035         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
1036     }, {
1037         EVP_PKEY_ED448,
1038         "012345678901234567890123456789012345678901234567890123456",
1039         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
1040     }
1041 #endif
1042 };
1043
1044 static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
1045 {
1046     int ret = 0;
1047     unsigned char buf[80];
1048     unsigned char *in;
1049     size_t inlen, len = 0;
1050     EVP_PKEY *pkey;
1051
1052     /* Check if this algorithm supports public keys */
1053     if (keys[tst].pub == NULL)
1054         return 1;
1055
1056     memset(buf, 0, sizeof(buf));
1057
1058     if (pub) {
1059         inlen = strlen(keys[tst].pub);
1060         in = (unsigned char *)keys[tst].pub;
1061         if (uselibctx) {
1062             pkey = EVP_PKEY_new_raw_public_key_with_libctx(
1063                         testctx,
1064                         OBJ_nid2sn(keys[tst].type),
1065                         NULL,
1066                         in,
1067                         inlen);
1068         } else {
1069             pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
1070                                                NULL,
1071                                                in,
1072                                                inlen);
1073         }
1074     } else {
1075         inlen = strlen(keys[tst].priv);
1076         in = (unsigned char *)keys[tst].priv;
1077         if (uselibctx) {
1078             pkey = EVP_PKEY_new_raw_private_key_with_libctx(
1079                         testctx, OBJ_nid2sn(keys[tst].type),
1080                         NULL,
1081                         in,
1082                         inlen);
1083         } else {
1084             pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
1085                                                 NULL,
1086                                                 in,
1087                                                 inlen);
1088         }
1089     }
1090
1091     if (!TEST_ptr(pkey)
1092             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
1093             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
1094             || !TEST_true(len == inlen)
1095             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
1096             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
1097             || !TEST_mem_eq(in, inlen, buf, len))
1098         goto done;
1099
1100     ret = 1;
1101  done:
1102     EVP_PKEY_free(pkey);
1103     return ret;
1104 }
1105
1106 static int test_set_get_raw_keys(int tst)
1107 {
1108     return test_set_get_raw_keys_int(tst, 0, 0)
1109            && test_set_get_raw_keys_int(tst, 0, 1)
1110            && test_set_get_raw_keys_int(tst, 1, 0)
1111            && test_set_get_raw_keys_int(tst, 1, 1);
1112 }
1113
1114 static int pkey_custom_check(EVP_PKEY *pkey)
1115 {
1116     return 0xbeef;
1117 }
1118
1119 static int pkey_custom_pub_check(EVP_PKEY *pkey)
1120 {
1121     return 0xbeef;
1122 }
1123
1124 static int pkey_custom_param_check(EVP_PKEY *pkey)
1125 {
1126     return 0xbeef;
1127 }
1128
1129 static EVP_PKEY_METHOD *custom_pmeth;
1130
1131 static int test_EVP_PKEY_check(int i)
1132 {
1133     int ret = 0;
1134     const unsigned char *p;
1135     EVP_PKEY *pkey = NULL;
1136 #ifndef OPENSSL_NO_EC
1137     EC_KEY *eckey = NULL;
1138 #endif
1139     EVP_PKEY_CTX *ctx = NULL;
1140     EVP_PKEY_CTX *ctx2 = NULL;
1141     const APK_DATA *ak = &keycheckdata[i];
1142     const unsigned char *input = ak->kder;
1143     size_t input_len = ak->size;
1144     int expected_id = ak->evptype;
1145     int expected_check = ak->check;
1146     int expected_pub_check = ak->pub_check;
1147     int expected_param_check = ak->param_check;
1148     int type = ak->type;
1149     BIO *pubkey = NULL;
1150
1151     p = input;
1152
1153     switch (type) {
1154     case 0:
1155         if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
1156             || !TEST_ptr_eq(p, input + input_len)
1157             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
1158             goto done;
1159         break;
1160 #ifndef OPENSSL_NO_EC
1161     case 1:
1162         if (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
1163             || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
1164             || !TEST_ptr(pkey = EVP_PKEY_new())
1165             || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1166             goto done;
1167         break;
1168     case 2:
1169         if (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
1170             || !TEST_ptr_eq(p, input + input_len)
1171             || !TEST_ptr(pkey = EVP_PKEY_new())
1172             || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1173             goto done;
1174         break;
1175 #endif
1176     default:
1177         return 0;
1178     }
1179
1180     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
1181         goto done;
1182
1183     if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
1184         goto done;
1185
1186     if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
1187         goto done;
1188
1189     if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
1190         goto done;
1191
1192     ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
1193     /* assign the pkey directly, as an internal test */
1194     EVP_PKEY_up_ref(pkey);
1195     ctx2->pkey = pkey;
1196
1197     if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
1198         goto done;
1199
1200     if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
1201         goto done;
1202
1203     if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
1204         goto done;
1205
1206     ret = 1;
1207
1208  done:
1209     EVP_PKEY_CTX_free(ctx);
1210     EVP_PKEY_CTX_free(ctx2);
1211     EVP_PKEY_free(pkey);
1212     BIO_free(pubkey);
1213     return ret;
1214 }
1215
1216 #ifndef OPENSSL_NO_CMAC
1217 static int test_CMAC_keygen(void)
1218 {
1219     /*
1220      * This is a legacy method for CMACs, but should still work.
1221      * This verifies that it works without an ENGINE.
1222      */
1223     EVP_PKEY_CTX *kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_CMAC, NULL);
1224     int ret = 0;
1225
1226     if (!TEST_true(EVP_PKEY_keygen_init(kctx) > 0)
1227         && !TEST_true(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
1228                                         EVP_PKEY_CTRL_CIPHER,
1229                                         0, (void *)EVP_aes_256_ecb()) > 0))
1230         goto done;
1231     ret = 1;
1232
1233  done:
1234     EVP_PKEY_CTX_free(kctx);
1235     return ret;
1236 }
1237 #endif
1238
1239 static int test_HKDF(void)
1240 {
1241     EVP_PKEY_CTX *pctx;
1242     unsigned char out[20];
1243     size_t outlen;
1244     int i, ret = 0;
1245     unsigned char salt[] = "0123456789";
1246     unsigned char key[] = "012345678901234567890123456789";
1247     unsigned char info[] = "infostring";
1248     const unsigned char expected[] = {
1249         0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
1250         0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
1251     };
1252     size_t expectedlen = sizeof(expected);
1253
1254     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1255         goto done;
1256
1257     /* We do this twice to test reuse of the EVP_PKEY_CTX */
1258     for (i = 0; i < 2; i++) {
1259         outlen = sizeof(out);
1260         memset(out, 0, outlen);
1261
1262         if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1263                 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1264                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1265                                                             sizeof(salt) - 1), 0)
1266                 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1267                                                            sizeof(key) - 1), 0)
1268                 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1269                                                             sizeof(info) - 1), 0)
1270                 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1271                 || !TEST_mem_eq(out, outlen, expected, expectedlen))
1272             goto done;
1273     }
1274
1275     ret = 1;
1276
1277  done:
1278     EVP_PKEY_CTX_free(pctx);
1279
1280     return ret;
1281 }
1282
1283 static int test_emptyikm_HKDF(void)
1284 {
1285     EVP_PKEY_CTX *pctx;
1286     unsigned char out[20];
1287     size_t outlen;
1288     int ret = 0;
1289     unsigned char salt[] = "9876543210";
1290     unsigned char key[] = "";
1291     unsigned char info[] = "stringinfo";
1292     const unsigned char expected[] = {
1293         0x68, 0x81, 0xa5, 0x3e, 0x5b, 0x9c, 0x7b, 0x6f, 0x2e, 0xec, 0xc8, 0x47,
1294         0x7c, 0xfa, 0x47, 0x35, 0x66, 0x82, 0x15, 0x30
1295     };
1296     size_t expectedlen = sizeof(expected);
1297
1298     if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1299         goto done;
1300
1301     outlen = sizeof(out);
1302     memset(out, 0, outlen);
1303
1304     if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1305             || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1306             || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1307                                                         sizeof(salt) - 1), 0)
1308             || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1309                                                        sizeof(key) - 1), 0)
1310             || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1311                                                         sizeof(info) - 1), 0)
1312             || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1313             || !TEST_mem_eq(out, outlen, expected, expectedlen))
1314         goto done;
1315
1316     ret = 1;
1317
1318  done:
1319     EVP_PKEY_CTX_free(pctx);
1320
1321     return ret;
1322 }
1323
1324 #ifndef OPENSSL_NO_EC
1325 static int test_X509_PUBKEY_inplace(void)
1326 {
1327   int ret = 0;
1328   X509_PUBKEY *xp = NULL;
1329   const unsigned char *p = kExampleECPubKeyDER;
1330   size_t input_len = sizeof(kExampleECPubKeyDER);
1331
1332   if (!TEST_ptr(xp = d2i_X509_PUBKEY(NULL, &p, input_len)))
1333     goto done;
1334
1335   if (!TEST_ptr(X509_PUBKEY_get0(xp)))
1336     goto done;
1337
1338   p = kExampleBadECPubKeyDER;
1339   input_len = sizeof(kExampleBadECPubKeyDER);
1340
1341   if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
1342     goto done;
1343
1344   if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
1345     goto done;
1346
1347   ret = 1;
1348
1349 done:
1350   X509_PUBKEY_free(xp);
1351   return ret;
1352 }
1353 #endif /* OPENSSL_NO_EC */
1354
1355 /* Test getting and setting parameters on an EVP_PKEY_CTX */
1356 static int test_EVP_PKEY_CTX_get_set_params(EVP_PKEY *pkey)
1357 {
1358     EVP_MD_CTX *mdctx = NULL;
1359     EVP_PKEY_CTX *ctx = NULL;
1360     const OSSL_PARAM *params;
1361     OSSL_PARAM ourparams[2], *param = ourparams, *param_md;
1362     int ret = 0;
1363     const EVP_MD *md;
1364     char mdname[OSSL_MAX_NAME_SIZE];
1365     char ssl3ms[48];
1366
1367     /* Initialise a sign operation */
1368     ctx = EVP_PKEY_CTX_new(pkey, NULL);
1369     if (!TEST_ptr(ctx)
1370             || !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0))
1371         goto err;
1372
1373     /*
1374      * We should be able to query the parameters now.
1375      */
1376     params = EVP_PKEY_CTX_settable_params(ctx);
1377     if (!TEST_ptr(params)
1378         || !TEST_ptr(OSSL_PARAM_locate_const(params,
1379                                              OSSL_SIGNATURE_PARAM_DIGEST)))
1380         goto err;
1381
1382     params = EVP_PKEY_CTX_gettable_params(ctx);
1383     if (!TEST_ptr(params)
1384         || !TEST_ptr(OSSL_PARAM_locate_const(params,
1385                                              OSSL_SIGNATURE_PARAM_ALGORITHM_ID))
1386         || !TEST_ptr(OSSL_PARAM_locate_const(params,
1387                                              OSSL_SIGNATURE_PARAM_DIGEST)))
1388         goto err;
1389
1390     /*
1391      * Test getting and setting params via EVP_PKEY_CTX_set_params() and
1392      * EVP_PKEY_CTX_get_params()
1393      */
1394     strcpy(mdname, "SHA512");
1395     param_md = param;
1396     *param++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1397                                                 mdname, 0);
1398     *param++ = OSSL_PARAM_construct_end();
1399
1400     if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams)))
1401         goto err;
1402
1403     mdname[0] = '\0';
1404     *param_md = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1405                                                  mdname, sizeof(mdname));
1406     if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams))
1407             || !TEST_str_eq(mdname, "SHA512"))
1408         goto err;
1409
1410     /*
1411      * Test the TEST_PKEY_CTX_set_signature_md() and
1412      * TEST_PKEY_CTX_get_signature_md() functions
1413      */
1414     if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0)
1415             || !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0)
1416             || !TEST_ptr_eq(md, EVP_sha256()))
1417         goto err;
1418
1419     /*
1420      * Test getting MD parameters via an associated EVP_PKEY_CTX
1421      */
1422     mdctx = EVP_MD_CTX_new();
1423     if (!TEST_ptr(mdctx)
1424         || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", NULL, pkey,
1425                                             NULL)))
1426         goto err;
1427
1428     /*
1429      * We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be
1430      * able to obtain the digest's settable parameters from the provider.
1431      */
1432     params = EVP_MD_CTX_settable_params(mdctx);
1433     if (!TEST_ptr(params)
1434             || !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0)
1435                /* The final key should be NULL */
1436             || !TEST_ptr_null(params[1].key))
1437         goto err;
1438
1439     param = ourparams;
1440     memset(ssl3ms, 0, sizeof(ssl3ms));
1441     *param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
1442                                                  ssl3ms, sizeof(ssl3ms));
1443     *param++ = OSSL_PARAM_construct_end();
1444
1445     if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams)))
1446         goto err;
1447
1448     ret = 1;
1449
1450  err:
1451     EVP_MD_CTX_free(mdctx);
1452     EVP_PKEY_CTX_free(ctx);
1453
1454     return ret;
1455 }
1456
1457 #ifndef OPENSSL_NO_DSA
1458 static int test_DSA_get_set_params(void)
1459 {
1460     DSA *dsa = NULL;
1461     BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub = NULL, *priv = NULL;
1462     EVP_PKEY *pkey = NULL;
1463     int ret = 0;
1464
1465     /*
1466      * Setup the parameters for our DSA object. For our purposes they don't
1467      * have to actually be *valid* parameters. We just need to set something.
1468      */
1469     dsa = DSA_new();
1470     p = BN_new();
1471     q = BN_new();
1472     g = BN_new();
1473     pub = BN_new();
1474     priv = BN_new();
1475     if (!TEST_ptr(dsa)
1476             || !TEST_ptr(p)
1477             || !TEST_ptr(q)
1478             || !TEST_ptr(g)
1479             || !TEST_ptr(pub)
1480             || !DSA_set0_pqg(dsa, p, q, g)
1481         || !DSA_set0_key(dsa, pub, priv))
1482         goto err;
1483     p = q = g = pub = priv = NULL;
1484
1485     pkey = EVP_PKEY_new();
1486     if (!TEST_ptr(pkey)
1487             || !TEST_true(EVP_PKEY_assign_DSA(pkey, dsa)))
1488         goto err;
1489
1490     dsa = NULL;
1491
1492     ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1493
1494  err:
1495     EVP_PKEY_free(pkey);
1496     DSA_free(dsa);
1497     BN_free(p);
1498     BN_free(q);
1499     BN_free(g);
1500     BN_free(pub);
1501     BN_free(priv);
1502
1503     return ret;
1504 }
1505 #endif
1506
1507 static int test_RSA_get_set_params(void)
1508 {
1509     RSA *rsa = NULL;
1510     BIGNUM *n = NULL, *e = NULL, *d = NULL;
1511     EVP_PKEY *pkey = NULL;
1512     int ret = 0;
1513
1514     /*
1515      * Setup the parameters for our RSA object. For our purposes they don't
1516      * have to actually be *valid* parameters. We just need to set something.
1517      */
1518     rsa = RSA_new();
1519     n = BN_new();
1520     e = BN_new();
1521     d = BN_new();
1522     if (!TEST_ptr(rsa)
1523             || !TEST_ptr(n)
1524             || !TEST_ptr(e)
1525             || !TEST_ptr(d)
1526         || !RSA_set0_key(rsa, n, e, d))
1527         goto err;
1528     n = e = d = NULL;
1529
1530     pkey = EVP_PKEY_new();
1531     if (!TEST_ptr(pkey)
1532             || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa)))
1533         goto err;
1534
1535     rsa = NULL;
1536
1537     ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1538
1539  err:
1540     EVP_PKEY_free(pkey);
1541     RSA_free(rsa);
1542     BN_free(n);
1543     BN_free(e);
1544     BN_free(d);
1545
1546     return ret;
1547 }
1548
1549 #if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1550 static int test_decrypt_null_chunks(void)
1551 {
1552     EVP_CIPHER_CTX* ctx = NULL;
1553     const unsigned char key[32] = {
1554         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1555         0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1556         0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1
1557     };
1558     unsigned char iv[12] = {
1559         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
1560     };
1561     unsigned char msg[] = "It was the best of times, it was the worst of times";
1562     unsigned char ciphertext[80];
1563     unsigned char plaintext[80];
1564     /* We initialise tmp to a non zero value on purpose */
1565     int ctlen, ptlen, tmp = 99;
1566     int ret = 0;
1567     const int enc_offset = 10, dec_offset = 20;
1568
1569     if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
1570             || !TEST_true(EVP_EncryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL,
1571                                              key, iv))
1572             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &ctlen, msg,
1573                                             enc_offset))
1574             /* Deliberate add a zero length update */
1575             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp, NULL,
1576                                             0))
1577             || !TEST_int_eq(tmp, 0)
1578             || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp,
1579                                             msg + enc_offset,
1580                                             sizeof(msg) - enc_offset))
1581             || !TEST_int_eq(ctlen += tmp, sizeof(msg))
1582             || !TEST_true(EVP_EncryptFinal(ctx, ciphertext + ctlen, &tmp))
1583             || !TEST_int_eq(tmp, 0))
1584         goto err;
1585
1586     /* Deliberately initialise tmp to a non zero value */
1587     tmp = 99;
1588     if (!TEST_true(EVP_DecryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL, key,
1589                                       iv))
1590             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext, &ptlen, ciphertext,
1591                                             dec_offset))
1592             /*
1593              * Deliberately add a zero length update. We also deliberately do
1594              * this at a different offset than for encryption.
1595              */
1596             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp, NULL,
1597                                             0))
1598             || !TEST_int_eq(tmp, 0)
1599             || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp,
1600                                             ciphertext + dec_offset,
1601                                             ctlen - dec_offset))
1602             || !TEST_int_eq(ptlen += tmp, sizeof(msg))
1603             || !TEST_true(EVP_DecryptFinal(ctx, plaintext + ptlen, &tmp))
1604             || !TEST_int_eq(tmp, 0)
1605             || !TEST_mem_eq(msg, sizeof(msg), plaintext, ptlen))
1606         goto err;
1607
1608     ret = 1;
1609  err:
1610     EVP_CIPHER_CTX_free(ctx);
1611     return ret;
1612 }
1613 #endif /* !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) */
1614
1615 #ifndef OPENSSL_NO_DH
1616 static int test_EVP_PKEY_set1_DH(void)
1617 {
1618     DH *x942dh = NULL, *noqdh = NULL;
1619     EVP_PKEY *pkey1 = NULL, *pkey2 = NULL;
1620     int ret = 0;
1621     BIGNUM *p, *g = NULL;
1622
1623     if (!TEST_ptr(p = BN_new())
1624             || !TEST_ptr(g = BN_new())
1625             || !BN_set_word(p, 9999)
1626             || !BN_set_word(g, 2)
1627             || !TEST_ptr(noqdh = DH_new())
1628             || !DH_set0_pqg(noqdh, p, NULL, g))
1629         goto err;
1630     p = g = NULL;
1631
1632     x942dh = DH_get_2048_256();
1633     pkey1 = EVP_PKEY_new();
1634     pkey2 = EVP_PKEY_new();
1635     if (!TEST_ptr(x942dh)
1636             || !TEST_ptr(noqdh)
1637             || !TEST_ptr(pkey1)
1638             || !TEST_ptr(pkey2))
1639         goto err;
1640
1641     if(!TEST_true(EVP_PKEY_set1_DH(pkey1, x942dh))
1642             || !TEST_int_eq(EVP_PKEY_id(pkey1), EVP_PKEY_DHX))
1643         goto err;
1644
1645     if(!TEST_true(EVP_PKEY_set1_DH(pkey2, noqdh))
1646             || !TEST_int_eq(EVP_PKEY_id(pkey2), EVP_PKEY_DH))
1647         goto err;
1648
1649     ret = 1;
1650  err:
1651     BN_free(p);
1652     BN_free(g);
1653     EVP_PKEY_free(pkey1);
1654     EVP_PKEY_free(pkey2);
1655     DH_free(x942dh);
1656     DH_free(noqdh);
1657
1658     return ret;
1659 }
1660 #endif
1661
1662 /*
1663  * We test what happens with an empty template.  For the sake of this test,
1664  * the template must be ignored, and we know that's the case for RSA keys
1665  * (this might arguably be a misfeature, but that's what we currently do,
1666  * even in provider code, since that's how the legacy RSA implementation
1667  * does things)
1668  */
1669 static int test_keygen_with_empty_template(int n)
1670 {
1671     EVP_PKEY_CTX *ctx = NULL;
1672     EVP_PKEY *pkey = NULL;
1673     EVP_PKEY *tkey = NULL;
1674     int ret = 0;
1675
1676     switch (n) {
1677     case 0:
1678         /* We do test with no template at all as well */
1679         if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
1680             goto err;
1681         break;
1682     case 1:
1683         /* Here we create an empty RSA key that serves as our template */
1684         if (!TEST_ptr(tkey = EVP_PKEY_new())
1685             || !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
1686             || !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
1687             goto err;
1688         break;
1689     }
1690
1691     if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1692         || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
1693         goto err;
1694
1695     ret = 1;
1696  err:
1697     EVP_PKEY_CTX_free(ctx);
1698     EVP_PKEY_free(pkey);
1699     EVP_PKEY_free(tkey);
1700     return ret;
1701 }
1702
1703 /*
1704  * Test that we fail if we attempt to use an algorithm that is not available
1705  * in the current library context (unless we are using an algorithm that should
1706  * be made available via legacy codepaths).
1707  */
1708 static int test_pkey_ctx_fail_without_provider(int tst)
1709 {
1710     OPENSSL_CTX *tmpctx = OPENSSL_CTX_new();
1711     OSSL_PROVIDER *nullprov = NULL;
1712     EVP_PKEY_CTX *pctx = NULL;
1713     int ret = 0;
1714
1715     if (!TEST_ptr(tmpctx))
1716         goto err;
1717
1718     nullprov = OSSL_PROVIDER_load(tmpctx, "null");
1719     if (!TEST_ptr(nullprov))
1720         goto err;
1721
1722     pctx = EVP_PKEY_CTX_new_from_name(tmpctx, tst == 0 ? "RSA" : "HMAC", "");
1723
1724     /* RSA is not available via any provider so we expect this to fail */
1725     if (tst == 0 && !TEST_ptr_null(pctx))
1726         goto err;
1727
1728     /*
1729      * HMAC is always available because it is implemented via legacy codepaths
1730      * and not in a provider at all. We expect this to pass.
1731      */
1732     if (tst == 1 && !TEST_ptr(pctx))
1733         goto err;
1734
1735     ret = 1;
1736
1737  err:
1738     EVP_PKEY_CTX_free(pctx);
1739     OSSL_PROVIDER_unload(nullprov);
1740     OPENSSL_CTX_free(tmpctx);
1741     return ret;
1742 }
1743
1744 int setup_tests(void)
1745 {
1746     testctx = OPENSSL_CTX_new();
1747
1748     if (!TEST_ptr(testctx))
1749         return 0;
1750
1751     ADD_ALL_TESTS(test_EVP_DigestSignInit, 9);
1752     ADD_TEST(test_EVP_DigestVerifyInit);
1753     ADD_TEST(test_EVP_Enveloped);
1754     ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
1755     ADD_TEST(test_privatekey_to_pkcs8);
1756 #ifndef OPENSSL_NO_EC
1757     ADD_TEST(test_EVP_PKCS82PKEY);
1758 #endif
1759 #if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
1760     ADD_TEST(test_EVP_SM2);
1761     ADD_TEST(test_EVP_SM2_verify);
1762 #endif
1763     ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
1764     custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
1765     if (!TEST_ptr(custom_pmeth))
1766         return 0;
1767     EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
1768     EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
1769     EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
1770     if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
1771         return 0;
1772     ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
1773 #ifndef OPENSSL_NO_CMAC
1774     ADD_TEST(test_CMAC_keygen);
1775 #endif
1776     ADD_TEST(test_HKDF);
1777     ADD_TEST(test_emptyikm_HKDF);
1778 #ifndef OPENSSL_NO_EC
1779     ADD_TEST(test_X509_PUBKEY_inplace);
1780     ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
1781                   OSSL_NELEM(ec_der_pub_keys));
1782 #endif
1783 #ifndef OPENSSL_NO_DSA
1784     ADD_TEST(test_DSA_get_set_params);
1785 #endif
1786     ADD_TEST(test_RSA_get_set_params);
1787 #if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1788     ADD_TEST(test_decrypt_null_chunks);
1789 #endif
1790 #ifndef OPENSSL_NO_DH
1791     ADD_TEST(test_EVP_PKEY_set1_DH);
1792 #endif
1793     ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
1794     ADD_ALL_TESTS(test_pkey_ctx_fail_without_provider, 2);
1795
1796     return 1;
1797 }
1798
1799 void cleanup_tests(void)
1800 {
1801     OPENSSL_CTX_free(testctx);
1802 }