test/evp_extra_test.c

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