test/evp_extra_test.c

   1 /*
   2  * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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/crypto.h>
  15 #include <openssl/err.h>
  16 #include <openssl/evp.h>
  17 #include <openssl/rsa.h>
  18 #include <openssl/x509.h>
  19 #include "testutil.h"
  20 #include "internal/nelem.h"
  21 #include "internal/evp_int.h"
  22
  23 /*
  24  * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
  25  * should never use this key anywhere but in an example.
  26  */
  27 static const unsigned char kExampleRSAKeyDER[] = {
  28     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
  29     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
  30     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
  31     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
  32     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
  33     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
  34     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
  35     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
  36     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
  37     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
  38     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
  39     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
  40     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
  41     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
  42     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
  43     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
  44     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
  45     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
  46     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
  47     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
  48     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
  49     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
  50     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
  51     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
  52     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
  53     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
  54     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
  55     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
  56     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
  57     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
  58     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
  59     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
  60     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
  61     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
  62     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
  63     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
  64     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
  65     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
  66     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
  67     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
  68     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
  69     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
  70     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
  71     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
  72     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
  73     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
  74     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
  75     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
  76     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
  77     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
  78     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
  79 };
  80
  81 /*
  82  * kExampleBadRSAKeyDER is an RSA private key in ASN.1, DER format. The private
  83  * components are not correct.
  84  */
  85 static const unsigned char kExampleBadRSAKeyDER[] = {
  86     0x30, 0x82, 0x04, 0x27, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
  87     0xa6, 0x1a, 0x1e, 0x6e, 0x7b, 0xee, 0xc6, 0x89, 0x66, 0xe7, 0x93, 0xef,
  88     0x54, 0x12, 0x68, 0xea, 0xbf, 0x86, 0x2f, 0xdd, 0xd2, 0x79, 0xb8, 0xa9,
  89     0x6e, 0x03, 0xc2, 0xa3, 0xb9, 0xa3, 0xe1, 0x4b, 0x2a, 0xb3, 0xf8, 0xb4,
  90     0xcd, 0xea, 0xbe, 0x24, 0xa6, 0x57, 0x5b, 0x83, 0x1f, 0x0f, 0xf2, 0xd3,
  91     0xb7, 0xac, 0x7e, 0xd6, 0x8e, 0x6e, 0x1e, 0xbf, 0xb8, 0x73, 0x8c, 0x05,
  92     0x56, 0xe6, 0x35, 0x1f, 0xe9, 0x04, 0x0b, 0x09, 0x86, 0x7d, 0xf1, 0x26,
  93     0x08, 0x99, 0xad, 0x7b, 0xc8, 0x4d, 0x94, 0xb0, 0x0b, 0x8b, 0x38, 0xa0,
  94     0x5c, 0x62, 0xa0, 0xab, 0xd3, 0x8f, 0xd4, 0x09, 0x60, 0x72, 0x1e, 0x33,
  95     0x50, 0x80, 0x6e, 0x22, 0xa6, 0x77, 0x57, 0x6b, 0x9a, 0x33, 0x21, 0x66,
  96     0x87, 0x6e, 0x21, 0x7b, 0xc7, 0x24, 0x0e, 0xd8, 0x13, 0xdf, 0x83, 0xde,
  97     0xcd, 0x40, 0x58, 0x1d, 0x84, 0x86, 0xeb, 0xb8, 0x12, 0x4e, 0xd2, 0xfa,
  98     0x80, 0x1f, 0xe4, 0xe7, 0x96, 0x29, 0xb8, 0xcc, 0xce, 0x66, 0x6d, 0x53,
  99     0xca, 0xb9, 0x5a, 0xd7, 0xf6, 0x84, 0x6c, 0x2d, 0x9a, 0x1a, 0x14, 0x1c,
 100     0x4e, 0x93, 0x39, 0xba, 0x74, 0xed, 0xed, 0x87, 0x87, 0x5e, 0x48, 0x75,
 101     0x36, 0xf0, 0xbc, 0x34, 0xfb, 0x29, 0xf9, 0x9f, 0x96, 0x5b, 0x0b, 0xa7,
 102     0x54, 0x30, 0x51, 0x29, 0x18, 0x5b, 0x7d, 0xac, 0x0f, 0xd6, 0x5f, 0x7c,
 103     0xf8, 0x98, 0x8c, 0xd8, 0x86, 0x62, 0xb3, 0xdc, 0xff, 0x0f, 0xff, 0x7a,
 104     0xaf, 0x5c, 0x4c, 0x61, 0x49, 0x2e, 0xc8, 0x95, 0x86, 0xc4, 0x0e, 0x87,
 105     0xfc, 0x1d, 0xcf, 0x8b, 0x7c, 0x61, 0xf6, 0xd8, 0xd0, 0x69, 0xf6, 0xcd,
 106     0x8a, 0x8c, 0xf6, 0x62, 0xa2, 0x56, 0xa9, 0xe3, 0xd1, 0xcf, 0x4d, 0xa0,
 107     0xf6, 0x2d, 0x20, 0x0a, 0x04, 0xb7, 0xa2, 0xf7, 0xb5, 0x99, 0x47, 0x18,
 108     0x56, 0x85, 0x87, 0xc7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
 109     0x01, 0x00, 0x99, 0x41, 0x38, 0x1a, 0xd0, 0x96, 0x7a, 0xf0, 0x83, 0xd5,
 110     0xdf, 0x94, 0xce, 0x89, 0x3d, 0xec, 0x7a, 0x52, 0x21, 0x10, 0x16, 0x06,
 111     0xe0, 0xee, 0xd2, 0xe6, 0xfd, 0x4b, 0x7b, 0x19, 0x4d, 0xe1, 0xc0, 0xc0,
 112     0xd5, 0x14, 0x5d, 0x79, 0xdd, 0x7e, 0x8b, 0x4b, 0xc6, 0xcf, 0xb0, 0x75,
 113     0x52, 0xa3, 0x2d, 0xb1, 0x26, 0x46, 0x68, 0x9c, 0x0a, 0x1a, 0xf2, 0xe1,
 114     0x09, 0xac, 0x53, 0x85, 0x8c, 0x36, 0xa9, 0x14, 0x65, 0xea, 0xa0, 0x00,
 115     0xcb, 0xe3, 0x3f, 0xc4, 0x2b, 0x61, 0x2e, 0x6b, 0x06, 0x69, 0x77, 0xfd,
 116     0x38, 0x7e, 0x1d, 0x3f, 0x92, 0xe7, 0x77, 0x08, 0x19, 0xa7, 0x9d, 0x29,
 117     0x2d, 0xdc, 0x42, 0xc6, 0x7c, 0xd7, 0xd3, 0xa8, 0x01, 0x2c, 0xf2, 0xd5,
 118     0x82, 0x57, 0xcb, 0x55, 0x3d, 0xe7, 0xaa, 0xd2, 0x06, 0x30, 0x30, 0x05,
 119     0xe6, 0xf2, 0x47, 0x86, 0xba, 0xc6, 0x61, 0x64, 0xeb, 0x4f, 0x2a, 0x5e,
 120     0x07, 0x29, 0xe0, 0x96, 0xb2, 0x43, 0xff, 0x5f, 0x1a, 0x54, 0x16, 0xcf,
 121     0xb5, 0x56, 0x5c, 0xa0, 0x9b, 0x0c, 0xfd, 0xb3, 0xd2, 0xe3, 0x79, 0x1d,
 122     0x21, 0xe2, 0xd6, 0x13, 0xc4, 0x74, 0xa6, 0xf5, 0x8e, 0x8e, 0x81, 0xbb,
 123     0xb4, 0xad, 0x8a, 0xf0, 0x93, 0x0a, 0xd8, 0x0a, 0x42, 0x36, 0xbc, 0xe5,
 124     0x26, 0x2a, 0x0d, 0x5d, 0x57, 0x13, 0xc5, 0x4e, 0x2f, 0x12, 0x0e, 0xef,
 125     0xa7, 0x81, 0x1e, 0xc3, 0xa5, 0xdb, 0xc9, 0x24, 0xeb, 0x1a, 0xa1, 0xf9,
 126     0xf6, 0xa1, 0x78, 0x98, 0x93, 0x77, 0x42, 0x45, 0x03, 0xe2, 0xc9, 0xa2,
 127     0xfe, 0x2d, 0x77, 0xc8, 0xc6, 0xac, 0x9b, 0x98, 0x89, 0x6d, 0x9a, 0xe7,
 128     0x61, 0x63, 0xb7, 0xf2, 0xec, 0xd6, 0xb1, 0xa1, 0x6e, 0x0a, 0x1a, 0xff,
 129     0xfd, 0x43, 0x28, 0xc3, 0x0c, 0xdc, 0xf2, 0x47, 0x4f, 0x27, 0xaa, 0x99,
 130     0x04, 0x8e, 0xac, 0xe8, 0x7c, 0x01, 0x02, 0x04, 0x12, 0x34, 0x56, 0x78,
 131     0x02, 0x81, 0x81, 0x00, 0xca, 0x69, 0xe5, 0xbb, 0x3a, 0x90, 0x82, 0xcb,
 132     0x82, 0x50, 0x2f, 0x29, 0xe2, 0x76, 0x6a, 0x57, 0x55, 0x45, 0x4e, 0x35,
 133     0x18, 0x61, 0xe0, 0x12, 0x70, 0xc0, 0xab, 0xc7, 0x80, 0xa2, 0xd4, 0x46,
 134     0x34, 0x03, 0xa0, 0x19, 0x26, 0x23, 0x9e, 0xef, 0x1a, 0xcb, 0x75, 0xd6,
 135     0xba, 0x81, 0xf4, 0x7e, 0x52, 0xe5, 0x2a, 0xe8, 0xf1, 0x49, 0x6c, 0x0f,
 136     0x1a, 0xa0, 0xf9, 0xc6, 0xe7, 0xec, 0x60, 0xe4, 0xcb, 0x2a, 0xb5, 0x56,
 137     0xe9, 0x9c, 0xcd, 0x19, 0x75, 0x92, 0xb1, 0x66, 0xce, 0xc3, 0xd9, 0x3d,
 138     0x11, 0xcb, 0xc4, 0x09, 0xce, 0x1e, 0x30, 0xba, 0x2f, 0x60, 0x60, 0x55,
 139     0x8d, 0x02, 0xdc, 0x5d, 0xaf, 0xf7, 0x52, 0x31, 0x17, 0x07, 0x53, 0x20,
 140     0x33, 0xad, 0x8c, 0xd5, 0x2f, 0x5a, 0xd0, 0x57, 0xd7, 0xd1, 0x80, 0xd6,
 141     0x3a, 0x9b, 0x04, 0x4f, 0x35, 0xbf, 0xe7, 0xd5, 0xbc, 0x8f, 0xd4, 0x81,
 142     0x02, 0x81, 0x81, 0x00, 0xc0, 0x9f, 0xf8, 0xcd, 0xf7, 0x3f, 0x26, 0x8a,
 143     0x3d, 0x4d, 0x2b, 0x0c, 0x01, 0xd0, 0xa2, 0xb4, 0x18, 0xfe, 0xf7, 0x5e,
 144     0x2f, 0x06, 0x13, 0xcd, 0x63, 0xaa, 0x12, 0xa9, 0x24, 0x86, 0xe3, 0xf3,
 145     0x7b, 0xda, 0x1a, 0x3c, 0xb1, 0x38, 0x80, 0x80, 0xef, 0x64, 0x64, 0xa1,
 146     0x9b, 0xfe, 0x76, 0x63, 0x8e, 0x83, 0xd2, 0xd9, 0xb9, 0x86, 0xb0, 0xe6,
 147     0xa6, 0x0c, 0x7e, 0xa8, 0x84, 0x90, 0x98, 0x0c, 0x1e, 0xf3, 0x14, 0x77,
 148     0xe0, 0x5f, 0x81, 0x08, 0x11, 0x8f, 0xa6, 0x23, 0xc4, 0xba, 0xc0, 0x8a,
 149     0xe4, 0xc6, 0xe3, 0x5c, 0xbe, 0xc5, 0xec, 0x2c, 0xb9, 0xd8, 0x8c, 0x4d,
 150     0x1a, 0x9d, 0xe7, 0x7c, 0x85, 0x4c, 0x0d, 0x71, 0x4e, 0x72, 0x33, 0x1b,
 151     0xfe, 0xa9, 0x17, 0x72, 0x76, 0x56, 0x9d, 0x74, 0x7e, 0x52, 0x67, 0x9a,
 152     0x87, 0x9a, 0xdb, 0x30, 0xde, 0xe4, 0x49, 0x28, 0x3b, 0xd2, 0x67, 0xaf,
 153     0x02, 0x81, 0x81, 0x00, 0x89, 0x74, 0x9a, 0x8e, 0xa7, 0xb9, 0xa5, 0x28,
 154     0xc0, 0x68, 0xe5, 0x6e, 0x63, 0x1c, 0x99, 0x20, 0x8f, 0x86, 0x8e, 0x12,
 155     0x9e, 0x69, 0x30, 0xfa, 0x34, 0xd9, 0x92, 0x8d, 0xdb, 0x7c, 0x37, 0xfd,
 156     0x28, 0xab, 0x61, 0x98, 0x52, 0x7f, 0x14, 0x1a, 0x39, 0xae, 0xfb, 0x6a,
 157     0x03, 0xa3, 0xe6, 0xbd, 0xb6, 0x5b, 0x6b, 0xe5, 0x5e, 0x9d, 0xc6, 0xa5,
 158     0x07, 0x27, 0x54, 0x17, 0xd0, 0x3d, 0x84, 0x9b, 0x3a, 0xa0, 0xd9, 0x1e,
 159     0x99, 0x6c, 0x63, 0x17, 0xab, 0xf1, 0x1f, 0x49, 0xba, 0x95, 0xe3, 0x3b,
 160     0x86, 0x8f, 0x42, 0xa4, 0x89, 0xf5, 0x94, 0x8f, 0x8b, 0x46, 0xbe, 0x84,
 161     0xba, 0x4a, 0xbc, 0x0d, 0x5f, 0x46, 0xeb, 0xe8, 0xec, 0x43, 0x8c, 0x1e,
 162     0xad, 0x19, 0x69, 0x2f, 0x08, 0x86, 0x7a, 0x3f, 0x7d, 0x0f, 0x07, 0x97,
 163     0xf3, 0x9a, 0x7b, 0xb5, 0xb2, 0xc1, 0x8c, 0x95, 0x68, 0x04, 0xa0, 0x81,
 164     0x02, 0x81, 0x80, 0x4e, 0xbf, 0x7e, 0x1b, 0xcb, 0x13, 0x61, 0x75, 0x3b,
 165     0xdb, 0x59, 0x5f, 0xb1, 0xd4, 0xb8, 0xeb, 0x9e, 0x73, 0xb5, 0xe7, 0xf6,
 166     0x89, 0x3d, 0x1c, 0xda, 0xf0, 0x36, 0xff, 0x35, 0xbd, 0x1e, 0x0b, 0x74,
 167     0xe3, 0x9e, 0xf0, 0xf2, 0xf7, 0xd7, 0x82, 0xb7, 0x7b, 0x6a, 0x1b, 0x0e,
 168     0x30, 0x4a, 0x98, 0x0e, 0xb4, 0xf9, 0x81, 0x07, 0xe4, 0x75, 0x39, 0xe9,
 169     0x53, 0xca, 0xbb, 0x5c, 0xaa, 0x93, 0x07, 0x0e, 0xa8, 0x2f, 0xba, 0x98,
 170     0x49, 0x30, 0xa7, 0xcc, 0x1a, 0x3c, 0x68, 0x0c, 0xe1, 0xa4, 0xb1, 0x05,
 171     0xe6, 0xe0, 0x25, 0x78, 0x58, 0x14, 0x37, 0xf5, 0x1f, 0xe3, 0x22, 0xef,
 172     0xa8, 0x0e, 0x22, 0xa0, 0x94, 0x3a, 0xf6, 0xc9, 0x13, 0xe6, 0x06, 0xbf,
 173     0x7f, 0x99, 0xc6, 0xcc, 0xd8, 0xc6, 0xbe, 0xd9, 0x2e, 0x24, 0xc7, 0x69,
 174     0x8c, 0x95, 0xba, 0xf6, 0x04, 0xb3, 0x0a, 0xf4, 0xcb, 0xf0, 0xce,
 175 };
 176
 177 static const unsigned char kMsg[] = { 1, 2, 3, 4 };
 178
 179 static const unsigned char kSignature[] = {
 180     0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
 181     0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
 182     0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
 183     0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
 184     0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
 185     0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
 186     0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
 187     0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
 188     0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
 189     0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
 190     0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
 191 };
 192
 193 /*
 194  * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
 195  * PrivateKeyInfo.
 196  */
 197 static const unsigned char kExampleRSAKeyPKCS8[] = {
 198     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 199     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 200     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
 201     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
 202     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
 203     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
 204     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
 205     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
 206     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
 207     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
 208     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
 209     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
 210     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
 211     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
 212     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
 213     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
 214     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
 215     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
 216     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
 217     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
 218     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
 219     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
 220     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
 221     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
 222     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
 223     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
 224     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
 225     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
 226     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
 227     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
 228     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
 229     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
 230     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
 231     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
 232     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
 233     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
 234     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
 235     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
 236     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
 237     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
 238     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
 239     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
 240     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
 241     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
 242     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
 243     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
 244     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
 245     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
 246     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
 247     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
 248     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
 249     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
 250     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 251 };
 252
 253 #ifndef OPENSSL_NO_EC
 254 /*
 255  * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
 256  * structure.
 257  */
 258 static const unsigned char kExampleECKeyDER[] = {
 259     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
 260     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
 261     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
 262     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 263     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
 264     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
 265     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
 266     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
 267     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
 268     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
 269     0xc1,
 270 };
 271
 272 /*
 273  * kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
 274  * structure. The private key is equal to the order and will fail to import
 275  */
 276 static const unsigned char kExampleBadECKeyDER[] = {
 277     0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
 278     0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
 279     0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
 280     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 281     0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
 282     0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
 283     0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
 284     0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
 285     0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
 286 };
 287
 288 /* prime256v1 */
 289 static const unsigned char kExampleECPubKeyDER[] = {
 290     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 291     0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 292     0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
 293     0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
 294     0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
 295     0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
 296     0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
 297     0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
 298 };
 299
 300 static const unsigned char pExampleECParamDER[] = {
 301     0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
 302 };
 303 #endif
 304
 305 typedef struct APK_DATA_st {
 306     const unsigned char *kder;
 307     size_t size;
 308     int evptype;
 309     int check;
 310     int pub_check;
 311     int param_check;
 312     int type; /* 0 for private, 1 for public, 2 for params */
 313 } APK_DATA;
 314
 315 static APK_DATA keydata[] = {
 316     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
 317     {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
 318 #ifndef OPENSSL_NO_EC
 319     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
 320 #endif
 321 };
 322
 323 static APK_DATA keycheckdata[] = {
 324     {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA, 1, -2, -2, 0},
 325     {kExampleBadRSAKeyDER, sizeof(kExampleBadRSAKeyDER), EVP_PKEY_RSA,
 326      0, -2, -2, 0},
 327 #ifndef OPENSSL_NO_EC
 328     {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC, 1, 1, 1, 0},
 329     /* group is also associated in our pub key */
 330     {kExampleECPubKeyDER, sizeof(kExampleECPubKeyDER), EVP_PKEY_EC, 0, 1, 1, 1},
 331     {pExampleECParamDER, sizeof(pExampleECParamDER), EVP_PKEY_EC, 0, 0, 1, 2}
 332 #endif
 333 };
 334
 335 static EVP_PKEY *load_example_rsa_key(void)
 336 {
 337     EVP_PKEY *ret = NULL;
 338     const unsigned char *derp = kExampleRSAKeyDER;
 339     EVP_PKEY *pkey = NULL;
 340     RSA *rsa = NULL;
 341
 342     if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
 343         return NULL;
 344
 345     if (!TEST_ptr(pkey = EVP_PKEY_new())
 346             || !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
 347         goto end;
 348
 349     ret = pkey;
 350     pkey = NULL;
 351
 352 end:
 353     EVP_PKEY_free(pkey);
 354     RSA_free(rsa);
 355
 356     return ret;
 357 }
 358
 359 static int test_EVP_DigestSignInit(void)
 360 {
 361     int ret = 0;
 362     EVP_PKEY *pkey = NULL;
 363     unsigned char *sig = NULL;
 364     size_t sig_len = 0;
 365     EVP_MD_CTX *md_ctx, *md_ctx_verify = NULL;
 366
 367     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 368             || !TEST_ptr(md_ctx_verify = EVP_MD_CTX_new())
 369             || !TEST_ptr(pkey = load_example_rsa_key()))
 370         goto out;
 371
 372     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 373             || !TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 374         goto out;
 375
 376     /* Determine the size of the signature. */
 377     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
 378             || !TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
 379         goto out;
 380
 381     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len))
 382             || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 383         goto out;
 384
 385     /* Ensure that the signature round-trips. */
 386     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(),
 387                                         NULL, pkey))
 388             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify,
 389                                                  kMsg, sizeof(kMsg)))
 390             || !TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 391         goto out;
 392
 393     ret = 1;
 394
 395  out:
 396     EVP_MD_CTX_free(md_ctx);
 397     EVP_MD_CTX_free(md_ctx_verify);
 398     EVP_PKEY_free(pkey);
 399     OPENSSL_free(sig);
 400
 401     return ret;
 402 }
 403
 404 static int test_EVP_DigestVerifyInit(void)
 405 {
 406     int ret = 0;
 407     EVP_PKEY *pkey = NULL;
 408     EVP_MD_CTX *md_ctx = NULL;
 409
 410     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 411             || !TEST_ptr(pkey = load_example_rsa_key()))
 412         goto out;
 413
 414     if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 415             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
 416             || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
 417                                                  sizeof(kSignature))))
 418         goto out;
 419     ret = 1;
 420
 421  out:
 422     EVP_MD_CTX_free(md_ctx);
 423     EVP_PKEY_free(pkey);
 424     return ret;
 425 }
 426
 427 static int test_d2i_AutoPrivateKey(int i)
 428 {
 429     int ret = 0;
 430     const unsigned char *p;
 431     EVP_PKEY *pkey = NULL;
 432     const APK_DATA *ak = &keydata[i];
 433     const unsigned char *input = ak->kder;
 434     size_t input_len = ak->size;
 435     int expected_id = ak->evptype;
 436
 437     p = input;
 438     if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 439             || !TEST_ptr_eq(p, input + input_len)
 440             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
 441         goto done;
 442
 443     ret = 1;
 444
 445  done:
 446     EVP_PKEY_free(pkey);
 447     return ret;
 448 }
 449
 450 #ifndef OPENSSL_NO_EC
 451 /* Tests loading a bad key in PKCS8 format */
 452 static int test_EVP_PKCS82PKEY(void)
 453 {
 454     int ret = 0;
 455     const unsigned char *derp = kExampleBadECKeyDER;
 456     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
 457     EVP_PKEY *pkey = NULL;
 458
 459     if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
 460                                               sizeof(kExampleBadECKeyDER))))
 461         goto done;
 462
 463     if (!TEST_ptr_eq(derp,
 464                      kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
 465         goto done;
 466
 467     if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
 468         goto done;
 469
 470     ret = 1;
 471
 472  done:
 473     PKCS8_PRIV_KEY_INFO_free(p8inf);
 474     EVP_PKEY_free(pkey);
 475
 476     return ret;
 477 }
 478 #endif
 479
 480 #ifndef OPENSSL_NO_SM2
 481
 482 static int test_EVP_SM2(void)
 483 {
 484     int ret = 0;
 485     EVP_PKEY *pkey = NULL;
 486     EVP_PKEY *params = NULL;
 487     EVP_PKEY_CTX *pctx = NULL;
 488     EVP_PKEY_CTX *kctx = NULL;
 489     size_t sig_len = 0;
 490     unsigned char *sig = NULL;
 491     EVP_MD_CTX *md_ctx = NULL;
 492     EVP_MD_CTX *md_ctx_verify = NULL;
 493     EVP_PKEY_CTX *cctx = NULL;
 494
 495     uint8_t ciphertext[128];
 496     size_t ctext_len = sizeof(ciphertext);
 497
 498     uint8_t plaintext[8];
 499     size_t ptext_len = sizeof(plaintext);
 500
 501     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
 502     if (!TEST_ptr(pctx))
 503         goto done;
 504
 505     if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
 506         goto done;
 507
 508     if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
 509         goto done;
 510
 511     if (!TEST_true(EVP_PKEY_paramgen(pctx, &params)))
 512         goto done;
 513
 514     kctx = EVP_PKEY_CTX_new(params, NULL);
 515     if (!TEST_ptr(kctx))
 516         goto done;
 517
 518     if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
 519         goto done;
 520
 521     if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
 522         goto done;
 523
 524     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 525         goto done;
 526
 527     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
 528         goto done;
 529
 530     if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
 531         goto done;
 532
 533     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
 534         goto done;
 535
 536     if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 537         goto done;
 538
 539     /* Determine the size of the signature. */
 540     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
 541         goto done;
 542
 543     if (!TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
 544         goto done;
 545
 546     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
 547         goto done;
 548
 549     if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 550         goto done;
 551
 552     /* Ensure that the signature round-trips. */
 553
 554     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
 555         goto done;
 556
 557     if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
 558         goto done;
 559
 560     if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 561         goto done;
 562
 563     /* now check encryption/decryption */
 564
 565     if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
 566         goto done;
 567
 568     if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
 569         goto done;
 570
 571     if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
 572         goto done;
 573
 574     if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
 575         goto done;
 576
 577     if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
 578         goto done;
 579
 580     if (!TEST_true(ptext_len == sizeof(kMsg)))
 581         goto done;
 582
 583     if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
 584         goto done;
 585
 586     ret = 1;
 587 done:
 588     EVP_PKEY_CTX_free(pctx);
 589     EVP_PKEY_CTX_free(kctx);
 590     EVP_PKEY_CTX_free(cctx);
 591     EVP_PKEY_free(pkey);
 592     EVP_PKEY_free(params);
 593     EVP_MD_CTX_free(md_ctx);
 594     EVP_MD_CTX_free(md_ctx_verify);
 595     OPENSSL_free(sig);
 596     return ret;
 597 }
 598
 599 #endif
 600
 601 static struct keys_st {
 602     int type;
 603     char *priv;
 604     char *pub;
 605 } keys[] = {
 606     {
 607         EVP_PKEY_HMAC, "0123456789", NULL
 608     }, {
 609         EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
 610     }, {
 611         EVP_PKEY_SIPHASH, "0123456789012345", NULL
 612     },
 613 #ifndef OPENSSL_NO_EC
 614     {
 615         EVP_PKEY_X25519, "01234567890123456789012345678901",
 616         "abcdefghijklmnopqrstuvwxyzabcdef"
 617     }, {
 618         EVP_PKEY_ED25519, "01234567890123456789012345678901",
 619         "abcdefghijklmnopqrstuvwxyzabcdef"
 620     }, {
 621         EVP_PKEY_X448,
 622         "01234567890123456789012345678901234567890123456789012345",
 623         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
 624     }, {
 625         EVP_PKEY_ED448,
 626         "012345678901234567890123456789012345678901234567890123456",
 627         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
 628     }
 629 #endif
 630 };
 631
 632 static int test_set_get_raw_keys_int(int tst, int pub)
 633 {
 634     int ret = 0;
 635     unsigned char buf[80];
 636     unsigned char *in;
 637     size_t inlen, len = 0;
 638     EVP_PKEY *pkey;
 639
 640     /* Check if this algorithm supports public keys */
 641     if (keys[tst].pub == NULL)
 642         return 1;
 643
 644     memset(buf, 0, sizeof(buf));
 645
 646     if (pub) {
 647         inlen = strlen(keys[tst].pub);
 648         in = (unsigned char *)keys[tst].pub;
 649         pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
 650                                            NULL,
 651                                            in,
 652                                            inlen);
 653     } else {
 654         inlen = strlen(keys[tst].priv);
 655         in = (unsigned char *)keys[tst].priv;
 656         pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
 657                                             NULL,
 658                                             in,
 659                                             inlen);
 660     }
 661
 662     if (!TEST_ptr(pkey)
 663             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
 664             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
 665             || !TEST_true(len == inlen)
 666             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
 667             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
 668             || !TEST_mem_eq(in, inlen, buf, len))
 669         goto done;
 670
 671     ret = 1;
 672  done:
 673     EVP_PKEY_free(pkey);
 674     return ret;
 675 }
 676
 677 static int test_set_get_raw_keys(int tst)
 678 {
 679     return test_set_get_raw_keys_int(tst, 0)
 680            && test_set_get_raw_keys_int(tst, 1);
 681 }
 682
 683 static int pkey_custom_check(EVP_PKEY *pkey)
 684 {
 685     return 0xbeef;
 686 }
 687
 688 static int pkey_custom_pub_check(EVP_PKEY *pkey)
 689 {
 690     return 0xbeef;
 691 }
 692
 693 static int pkey_custom_param_check(EVP_PKEY *pkey)
 694 {
 695     return 0xbeef;
 696 }
 697
 698 static EVP_PKEY_METHOD *custom_pmeth;
 699
 700 static int test_EVP_PKEY_check(int i)
 701 {
 702     int ret = 0;
 703     const unsigned char *p;
 704     EVP_PKEY *pkey = NULL;
 705 #ifndef OPENSSL_NO_EC
 706     EC_KEY *eckey = NULL;
 707 #endif
 708     EVP_PKEY_CTX *ctx = NULL;
 709     EVP_PKEY_CTX *ctx2 = NULL;
 710     const APK_DATA *ak = &keycheckdata[i];
 711     const unsigned char *input = ak->kder;
 712     size_t input_len = ak->size;
 713     int expected_id = ak->evptype;
 714     int expected_check = ak->check;
 715     int expected_pub_check = ak->pub_check;
 716     int expected_param_check = ak->param_check;
 717     int type = ak->type;
 718     BIO *pubkey = NULL;
 719
 720     p = input;
 721
 722     if (type == 0 &&
 723             (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 724              || !TEST_ptr_eq(p, input + input_len)
 725              || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id)))
 726         goto done;
 727
 728 #ifndef OPENSSL_NO_EC
 729     if (type == 1 &&
 730             (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
 731              || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
 732              || !TEST_ptr(pkey = EVP_PKEY_new())
 733              || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey))))
 734         goto done;
 735
 736     if (type == 2 &&
 737             (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
 738              || !TEST_ptr_eq(p, input + input_len)
 739              || !TEST_ptr(pkey = EVP_PKEY_new())
 740              || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey))))
 741         goto done;
 742 #endif
 743
 744     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
 745         goto done;
 746
 747     if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
 748         goto done;
 749
 750     if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
 751         goto done;
 752
 753     if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
 754         goto done;
 755
 756     ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
 757     /* assign the pkey directly, as an internal test */
 758     EVP_PKEY_up_ref(pkey);
 759     ctx2->pkey = pkey;
 760
 761     if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
 762         goto done;
 763
 764     if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
 765         goto done;
 766
 767     if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
 768         goto done;
 769
 770     ret = 1;
 771
 772  done:
 773     EVP_PKEY_CTX_free(ctx);
 774     EVP_PKEY_CTX_free(ctx2);
 775     EVP_PKEY_free(pkey);
 776     BIO_free(pubkey);
 777     return ret;
 778 }
 779
 780 int setup_tests(void)
 781 {
 782     ADD_TEST(test_EVP_DigestSignInit);
 783     ADD_TEST(test_EVP_DigestVerifyInit);
 784     ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
 785 #ifndef OPENSSL_NO_EC
 786     ADD_TEST(test_EVP_PKCS82PKEY);
 787 #endif
 788 #ifndef OPENSSL_NO_SM2
 789     ADD_TEST(test_EVP_SM2);
 790 #endif
 791     ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
 792     custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
 793     if (!TEST_ptr(custom_pmeth))
 794         return 0;
 795     EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
 796     EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
 797     EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
 798     if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
 799         return 0;
 800     ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
 801     return 1;
 802 }