src/third_party/boringssl/src/crypto/evp/evp_test.c

   1 /* Copyright (c) 2014, Google Inc.
   2  *
   3  * Permission to use, copy, modify, and/or distribute this software for any
   4  * purpose with or without fee is hereby granted, provided that the above
   5  * copyright notice and this permission notice appear in all copies.
   6  *
   7  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   8  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   9  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  10  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  11  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  12  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  13  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
  14
  15 #include <stdint.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18
  19 #include <openssl/bio.h>
  20 #include <openssl/bytestring.h>
  21 #include <openssl/crypto.h>
  22 #include <openssl/digest.h>
  23 #include <openssl/err.h>
  24 #include <openssl/evp.h>
  25 #include <openssl/rsa.h>
  26 #include <openssl/x509.h>
  27
  28
  29 /* kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
  30  * should never use this key anywhere but in an example. */
  31 static const uint8_t kExampleRSAKeyDER[] = {
  32     0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
  33     0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
  34     0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
  35     0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
  36     0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
  37     0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
  38     0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
  39     0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
  40     0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
  41     0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
  42     0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
  43     0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
  44     0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
  45     0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
  46     0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
  47     0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
  48     0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
  49     0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
  50     0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
  51     0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
  52     0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
  53     0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
  54     0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
  55     0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
  56     0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
  57     0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
  58     0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
  59     0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
  60     0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
  61     0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
  62     0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
  63     0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
  64     0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
  65     0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
  66     0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
  67     0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
  68     0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
  69     0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
  70     0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
  71     0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
  72     0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
  73     0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
  74     0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
  75     0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
  76     0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
  77     0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
  78     0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
  79     0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
  80     0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
  81     0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
  82     0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
  83 };
  84
  85 static const uint8_t kMsg[] = {1, 2, 3, 4};
  86
  87 static const uint8_t kSignature[] = {
  88     0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
  89     0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
  90     0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
  91     0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
  92     0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
  93     0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
  94     0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
  95     0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
  96     0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
  97     0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
  98     0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
  99 };
 100
 101 /* kExamplePSSCert is an example self-signed certificate, signed with
 102  * kExampleRSAKeyDER using RSA-PSS with default hash functions. */
 103 static const uint8_t kExamplePSSCert[] = {
 104     0x30, 0x82, 0x02, 0x62, 0x30, 0x82, 0x01, 0xc6, 0xa0, 0x03, 0x02, 0x01,
 105     0x02, 0x02, 0x09, 0x00, 0x8d, 0xea, 0x53, 0x24, 0xfa, 0x48, 0x87, 0xf3,
 106     0x30, 0x12, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
 107     0x0a, 0x30, 0x05, 0xa2, 0x03, 0x02, 0x01, 0x6a, 0x30, 0x45, 0x31, 0x0b,
 108     0x30, 0x09, 0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31,
 109     0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f,
 110     0x6d, 0x65, 0x2d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f,
 111     0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72,
 112     0x6e, 0x65, 0x74, 0x20, 0x57, 0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20,
 113     0x50, 0x74, 0x79, 0x20, 0x4c, 0x74, 0x64, 0x30, 0x1e, 0x17, 0x0d, 0x31,
 114     0x34, 0x31, 0x30, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39, 0x35, 0x35, 0x5a,
 115     0x17, 0x0d, 0x31, 0x35, 0x31, 0x30, 0x30, 0x39, 0x31, 0x39, 0x30, 0x39,
 116     0x35, 0x35, 0x5a, 0x30, 0x45, 0x31, 0x0b, 0x30, 0x09, 0x06, 0x03, 0x55,
 117     0x04, 0x06, 0x13, 0x02, 0x41, 0x55, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03,
 118     0x55, 0x04, 0x08, 0x0c, 0x0a, 0x53, 0x6f, 0x6d, 0x65, 0x2d, 0x53, 0x74,
 119     0x61, 0x74, 0x65, 0x31, 0x21, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x04, 0x0a,
 120     0x0c, 0x18, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x20, 0x57,
 121     0x69, 0x64, 0x67, 0x69, 0x74, 0x73, 0x20, 0x50, 0x74, 0x79, 0x20, 0x4c,
 122     0x74, 0x64, 0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48,
 123     0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00,
 124     0x30, 0x81, 0x89, 0x02, 0x81, 0x81, 0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4,
 125     0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d,
 126     0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83,
 127     0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c,
 128     0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf,
 129     0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33,
 130     0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7,
 131     0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76, 0x20, 0xfa, 0x16, 0x77,
 132     0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52,
 133     0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c,
 134     0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64,
 135     0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01, 0xa3, 0x50, 0x30, 0x4e,
 136     0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0xd0,
 137     0x41, 0xfb, 0x89, 0x41, 0x1e, 0xa7, 0xad, 0x5a, 0xec, 0x34, 0x5d, 0x49,
 138     0x11, 0xf9, 0x55, 0x81, 0x78, 0x1f, 0x13, 0x30, 0x1f, 0x06, 0x03, 0x55,
 139     0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0xd0, 0x41, 0xfb, 0x89,
 140     0x41, 0x1e, 0xa7, 0xad, 0x5a, 0xec, 0x34, 0x5d, 0x49, 0x11, 0xf9, 0x55,
 141     0x81, 0x78, 0x1f, 0x13, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x04,
 142     0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x12, 0x06, 0x09, 0x2a, 0x86,
 143     0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0a, 0x30, 0x05, 0xa2, 0x03, 0x02,
 144     0x01, 0x6a, 0x03, 0x81, 0x81, 0x00, 0x49, 0x4c, 0xb6, 0x45, 0x97, 0x20,
 145     0x35, 0xb3, 0x50, 0x64, 0x0d, 0x3f, 0xec, 0x5f, 0x95, 0xd5, 0x84, 0xcb,
 146     0x11, 0x7c, 0x03, 0xd7, 0xa6, 0xe6, 0xfa, 0x24, 0x95, 0x9f, 0x31, 0xb0,
 147     0xb5, 0xec, 0x66, 0x41, 0x51, 0x18, 0x21, 0x91, 0xbb, 0xe0, 0xaf, 0xf0,
 148     0xc5, 0xb7, 0x59, 0x41, 0xd4, 0xdb, 0xa4, 0xd2, 0x64, 0xa7, 0x54, 0x0f,
 149     0x8c, 0xf7, 0xe1, 0xd3, 0x3b, 0x1a, 0xb7, 0x0e, 0x9d, 0x9a, 0xde, 0x50,
 150     0xa1, 0x9f, 0x0a, 0xf0, 0xda, 0x34, 0x0e, 0x34, 0x7d, 0x76, 0x07, 0xfe,
 151     0x5a, 0xfb, 0xf9, 0x58, 0x9b, 0xc9, 0x50, 0x84, 0x01, 0xa0, 0x05, 0x4d,
 152     0x67, 0x42, 0x0b, 0xf8, 0xe4, 0x05, 0xcf, 0xaf, 0x8b, 0x71, 0x31, 0xf1,
 153     0x0f, 0x6e, 0xc9, 0x24, 0x27, 0x9b, 0xac, 0x04, 0xd7, 0x64, 0x0d, 0x30,
 154     0x4e, 0x11, 0x93, 0x40, 0x39, 0xbb, 0x72, 0xb2, 0xfe, 0x6b, 0xe4, 0xae,
 155     0x8c, 0x16,
 156 };
 157
 158 /* kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
 159  * PrivateKeyInfo. */
 160 static const uint8_t kExampleRSAKeyPKCS8[] = {
 161     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 162     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 163     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
 164     0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
 165     0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
 166     0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
 167     0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
 168     0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
 169     0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
 170     0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
 171     0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
 172     0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
 173     0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
 174     0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
 175     0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
 176     0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
 177     0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
 178     0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
 179     0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
 180     0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
 181     0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
 182     0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
 183     0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
 184     0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
 185     0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
 186     0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
 187     0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
 188     0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
 189     0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
 190     0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
 191     0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
 192     0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
 193     0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
 194     0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
 195     0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
 196     0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
 197     0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
 198     0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
 199     0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
 200     0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
 201     0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
 202     0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
 203     0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
 204     0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
 205     0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
 206     0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
 207     0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
 208     0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
 209     0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
 210     0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
 211     0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
 212     0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
 213     0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
 214 };
 215
 216 /* kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
 217  * structure. */
 218 static const uint8_t kExampleECKeyDER[] = {
 219     0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
 220     0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
 221     0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
 222     0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
 223     0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
 224     0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
 225     0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
 226     0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
 227     0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
 228     0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
 229     0xc1,
 230 };
 231
 232 static EVP_PKEY *load_example_rsa_key(void) {
 233   EVP_PKEY *ret = NULL;
 234   const uint8_t *derp = kExampleRSAKeyDER;
 235   EVP_PKEY *pkey = NULL;
 236   RSA *rsa = NULL;
 237
 238   if (!d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))) {
 239     return NULL;
 240   }
 241
 242   pkey = EVP_PKEY_new();
 243   if (pkey == NULL || !EVP_PKEY_set1_RSA(pkey, rsa)) {
 244     goto out;
 245   }
 246
 247   ret = pkey;
 248   pkey = NULL;
 249
 250 out:
 251   if (pkey) {
 252     EVP_PKEY_free(pkey);
 253   }
 254   if (rsa) {
 255     RSA_free(rsa);
 256   }
 257
 258   return ret;
 259 }
 260
 261 static int test_EVP_DigestSignInit(void) {
 262   int ret = 0;
 263   EVP_PKEY *pkey = NULL;
 264   uint8_t *sig = NULL;
 265   size_t sig_len = 0;
 266   EVP_MD_CTX md_ctx, md_ctx_verify;
 267
 268   EVP_MD_CTX_init(&md_ctx);
 269   EVP_MD_CTX_init(&md_ctx_verify);
 270
 271   pkey = load_example_rsa_key();
 272   if (pkey == NULL ||
 273       !EVP_DigestSignInit(&md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
 274       !EVP_DigestSignUpdate(&md_ctx, kMsg, sizeof(kMsg))) {
 275     goto out;
 276   }
 277   /* Determine the size of the signature. */
 278   if (!EVP_DigestSignFinal(&md_ctx, NULL, &sig_len)) {
 279     goto out;
 280   }
 281   /* Sanity check for testing. */
 282   if (sig_len != EVP_PKEY_size(pkey)) {
 283     fprintf(stderr, "sig_len mismatch\n");
 284     goto out;
 285   }
 286
 287   sig = malloc(sig_len);
 288   if (sig == NULL || !EVP_DigestSignFinal(&md_ctx, sig, &sig_len)) {
 289     goto out;
 290   }
 291
 292   /* Ensure that the signature round-trips. */
 293   if (!EVP_DigestVerifyInit(&md_ctx_verify, NULL, EVP_sha256(), NULL, pkey) ||
 294       !EVP_DigestVerifyUpdate(&md_ctx_verify, kMsg, sizeof(kMsg)) ||
 295       !EVP_DigestVerifyFinal(&md_ctx_verify, sig, sig_len)) {
 296     goto out;
 297   }
 298
 299   ret = 1;
 300
 301 out:
 302   if (!ret) {
 303     BIO_print_errors_fp(stderr);
 304   }
 305
 306   EVP_MD_CTX_cleanup(&md_ctx);
 307   EVP_MD_CTX_cleanup(&md_ctx_verify);
 308   if (pkey) {
 309     EVP_PKEY_free(pkey);
 310   }
 311   if (sig) {
 312     free(sig);
 313   }
 314
 315   return ret;
 316 }
 317
 318 static int test_EVP_DigestVerifyInit(void) {
 319   int ret = 0;
 320   EVP_PKEY *pkey = NULL;
 321   EVP_MD_CTX md_ctx;
 322
 323   EVP_MD_CTX_init(&md_ctx);
 324
 325   pkey = load_example_rsa_key();
 326   if (pkey == NULL ||
 327       !EVP_DigestVerifyInit(&md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
 328       !EVP_DigestVerifyUpdate(&md_ctx, kMsg, sizeof(kMsg)) ||
 329       !EVP_DigestVerifyFinal(&md_ctx, kSignature, sizeof(kSignature))) {
 330     goto out;
 331   }
 332   ret = 1;
 333
 334 out:
 335   if (!ret) {
 336     BIO_print_errors_fp(stderr);
 337   }
 338
 339   EVP_MD_CTX_cleanup(&md_ctx);
 340   if (pkey) {
 341     EVP_PKEY_free(pkey);
 342   }
 343
 344   return ret;
 345 }
 346
 347 /* test_algorithm_roundtrip signs a message using an already-initialized
 348  * |md_ctx|, sampling the AlgorithmIdentifier. It then uses |pkey| and the
 349  * AlgorithmIdentifier to verify the signature. */
 350 static int test_algorithm_roundtrip(EVP_MD_CTX *md_ctx, EVP_PKEY *pkey) {
 351   int ret = 0;
 352   uint8_t *sig = NULL;
 353   size_t sig_len = 0;
 354   EVP_MD_CTX md_ctx_verify;
 355   X509_ALGOR *algor = NULL;
 356
 357   EVP_MD_CTX_init(&md_ctx_verify);
 358
 359   if (!EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))) {
 360     goto out;
 361   }
 362
 363   /* Save the algorithm. */
 364   algor = X509_ALGOR_new();
 365   if (algor == NULL || !EVP_DigestSignAlgorithm(md_ctx, algor)) {
 366     goto out;
 367   }
 368
 369   /* Determine the size of the signature. */
 370   if (!EVP_DigestSignFinal(md_ctx, NULL, &sig_len)) {
 371     goto out;
 372   }
 373   /* Sanity check for testing. */
 374   if (sig_len != EVP_PKEY_size(pkey)) {
 375     fprintf(stderr, "sig_len mismatch\n");
 376     goto out;
 377   }
 378
 379   sig = malloc(sig_len);
 380   if (sig == NULL || !EVP_DigestSignFinal(md_ctx, sig, &sig_len)) {
 381     goto out;
 382   }
 383
 384   /* Ensure that the signature round-trips. */
 385   if (!EVP_DigestVerifyInitFromAlgorithm(&md_ctx_verify, algor, pkey) ||
 386       !EVP_DigestVerifyUpdate(&md_ctx_verify, kMsg, sizeof(kMsg)) ||
 387       !EVP_DigestVerifyFinal(&md_ctx_verify, sig, sig_len)) {
 388     goto out;
 389   }
 390
 391   ret = 1;
 392
 393 out:
 394   EVP_MD_CTX_cleanup(&md_ctx_verify);
 395   if (sig) {
 396     free(sig);
 397   }
 398   if (algor) {
 399     X509_ALGOR_free(algor);
 400   }
 401
 402   return ret;
 403 }
 404
 405 static int test_EVP_DigestSignAlgorithm(void) {
 406   int ret = 0;
 407   EVP_PKEY *pkey = NULL;
 408   EVP_MD_CTX md_ctx;
 409   EVP_PKEY_CTX *pkey_ctx;
 410
 411   EVP_MD_CTX_init(&md_ctx);
 412
 413   pkey = load_example_rsa_key();
 414   if (pkey == NULL) {
 415     goto out;
 416   }
 417
 418   /* Test a simple AlgorithmIdentifier. */
 419   if (!EVP_DigestSignInit(&md_ctx, &pkey_ctx, EVP_sha256(), NULL, pkey) ||
 420       !test_algorithm_roundtrip(&md_ctx, pkey)) {
 421     fprintf(stderr, "RSA with SHA-256 failed\n");
 422     goto out;
 423   }
 424
 425   EVP_MD_CTX_cleanup(&md_ctx);
 426   EVP_MD_CTX_init(&md_ctx);
 427
 428   /* Test RSA-PSS with custom parameters. */
 429   if (!EVP_DigestSignInit(&md_ctx, &pkey_ctx, EVP_sha256(), NULL, pkey) ||
 430       EVP_PKEY_CTX_set_rsa_padding(pkey_ctx, RSA_PKCS1_PSS_PADDING) != 1 ||
 431       EVP_PKEY_CTX_set_rsa_mgf1_md(pkey_ctx, EVP_sha512()) != 1 ||
 432       !test_algorithm_roundtrip(&md_ctx, pkey)) {
 433     fprintf(stderr, "RSA-PSS failed\n");
 434     goto out;
 435   }
 436
 437   ret = 1;
 438
 439 out:
 440   if (!ret) {
 441     BIO_print_errors_fp(stderr);
 442   }
 443
 444   EVP_MD_CTX_cleanup(&md_ctx);
 445   if (pkey) {
 446     EVP_PKEY_free(pkey);
 447   }
 448
 449   return ret;
 450 }
 451
 452 static int test_EVP_DigestVerifyInitFromAlgorithm(void) {
 453   int ret = 0;
 454   CBS cert, cert_body, tbs_cert, algorithm, signature;
 455   uint8_t padding;
 456   X509_ALGOR *algor = NULL;
 457   const uint8_t *derp;
 458   EVP_PKEY *pkey = NULL;
 459   EVP_MD_CTX md_ctx;
 460
 461   EVP_MD_CTX_init(&md_ctx);
 462
 463   CBS_init(&cert, kExamplePSSCert, sizeof(kExamplePSSCert));
 464   if (!CBS_get_asn1(&cert, &cert_body, CBS_ASN1_SEQUENCE) ||
 465       CBS_len(&cert) != 0 ||
 466       !CBS_get_any_asn1_element(&cert_body, &tbs_cert, NULL, NULL) ||
 467       !CBS_get_asn1_element(&cert_body, &algorithm, CBS_ASN1_SEQUENCE) ||
 468       !CBS_get_asn1(&cert_body, &signature, CBS_ASN1_BITSTRING) ||
 469       CBS_len(&cert_body) != 0) {
 470     fprintf(stderr, "Failed to parse certificate\n");
 471     goto out;
 472   }
 473
 474   /* Signatures are BIT STRINGs, but they have are multiple of 8 bytes, so the
 475      leading phase byte is just a zero. */
 476   if (!CBS_get_u8(&signature, &padding) || padding != 0) {
 477     fprintf(stderr, "Invalid signature padding\n");
 478     goto out;
 479   }
 480
 481   derp = CBS_data(&algorithm);
 482   if (!d2i_X509_ALGOR(&algor, &derp, CBS_len(&algorithm)) ||
 483       derp != CBS_data(&algorithm) + CBS_len(&algorithm)) {
 484     fprintf(stderr, "Failed to parse algorithm\n");
 485   }
 486
 487   pkey = load_example_rsa_key();
 488   if (pkey == NULL ||
 489       !EVP_DigestVerifyInitFromAlgorithm(&md_ctx, algor, pkey) ||
 490       !EVP_DigestVerifyUpdate(&md_ctx, CBS_data(&tbs_cert),
 491                               CBS_len(&tbs_cert)) ||
 492       !EVP_DigestVerifyFinal(&md_ctx, CBS_data(&signature),
 493                              CBS_len(&signature))) {
 494     goto out;
 495   }
 496   ret = 1;
 497
 498 out:
 499   if (!ret) {
 500     BIO_print_errors_fp(stderr);
 501   }
 502
 503   EVP_MD_CTX_cleanup(&md_ctx);
 504   if (pkey) {
 505     EVP_PKEY_free(pkey);
 506   }
 507
 508   return ret;
 509 }
 510
 511 static int test_d2i_AutoPrivateKey(const uint8_t *input, size_t input_len,
 512                                    int expected_id) {
 513   int ret = 0;
 514   const uint8_t *p;
 515   EVP_PKEY *pkey = NULL;
 516
 517   p = input;
 518   pkey = d2i_AutoPrivateKey(NULL, &p, input_len);
 519   if (pkey == NULL || p != input + input_len) {
 520     fprintf(stderr, "d2i_AutoPrivateKey failed\n");
 521     goto done;
 522   }
 523
 524   if (EVP_PKEY_id(pkey) != expected_id) {
 525     fprintf(stderr, "Did not decode expected type\n");
 526     goto done;
 527   }
 528
 529   ret = 1;
 530
 531 done:
 532   if (!ret) {
 533     BIO_print_errors_fp(stderr);
 534   }
 535
 536   if (pkey != NULL) {
 537     EVP_PKEY_free(pkey);
 538   }
 539   return ret;
 540 }
 541
 542 int main(void) {
 543   CRYPTO_library_init();
 544   ERR_load_crypto_strings();
 545
 546   if (!test_EVP_DigestSignInit()) {
 547     fprintf(stderr, "EVP_DigestSignInit failed\n");
 548     return 1;
 549   }
 550
 551   if (!test_EVP_DigestVerifyInit()) {
 552     fprintf(stderr, "EVP_DigestVerifyInit failed\n");
 553     return 1;
 554   }
 555
 556   if (!test_EVP_DigestSignAlgorithm()) {
 557     fprintf(stderr, "EVP_DigestSignInit failed\n");
 558     return 1;
 559   }
 560
 561   if (!test_EVP_DigestVerifyInitFromAlgorithm()) {
 562     fprintf(stderr, "EVP_DigestVerifyInitFromAlgorithm failed\n");
 563     return 1;
 564   }
 565
 566   if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),
 567                                EVP_PKEY_RSA)) {
 568     fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed\n");
 569     return 1;
 570   }
 571
 572   if (!test_d2i_AutoPrivateKey(kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8),
 573                                EVP_PKEY_RSA)) {
 574     fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed\n");
 575     return 1;
 576   }
 577
 578   if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),
 579                                EVP_PKEY_EC)) {
 580     fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed\n");
 581     return 1;
 582   }
 583
 584   printf("PASS\n");
 585   return 0;
 586 }