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_Enveloped(void)
 360 {
 361     int ret = 0;
 362     EVP_CIPHER_CTX *ctx = NULL;
 363     EVP_PKEY *keypair = NULL;
 364     unsigned char *kek = NULL;
 365     unsigned char iv[EVP_MAX_IV_LENGTH];
 366     static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 367     int len, kek_len, ciphertext_len, plaintext_len;
 368     unsigned char ciphertext[32], plaintext[16];
 369     const EVP_CIPHER *type = EVP_aes_256_cbc();
 370
 371     if (!TEST_ptr(keypair = load_example_rsa_key())
 372             || !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_size(keypair)))
 373             || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
 374             || !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
 375                                        &keypair, 1))
 376             || !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
 377                                          msg, sizeof(msg)))
 378             || !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
 379                                         &len)))
 380         goto err;
 381
 382     ciphertext_len += len;
 383
 384     if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
 385             || !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
 386                                          ciphertext, ciphertext_len))
 387             || !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
 388         goto err;
 389
 390     plaintext_len += len;
 391     if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
 392         goto err;
 393
 394     ret = 1;
 395 err:
 396     OPENSSL_free(kek);
 397     EVP_PKEY_free(keypair);
 398     EVP_CIPHER_CTX_free(ctx);
 399     return ret;
 400 }
 401
 402
 403 static int test_EVP_DigestSignInit(void)
 404 {
 405     int ret = 0;
 406     EVP_PKEY *pkey = NULL;
 407     unsigned char *sig = NULL;
 408     size_t sig_len = 0;
 409     EVP_MD_CTX *md_ctx, *md_ctx_verify = NULL;
 410
 411     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 412             || !TEST_ptr(md_ctx_verify = EVP_MD_CTX_new())
 413             || !TEST_ptr(pkey = load_example_rsa_key()))
 414         goto out;
 415
 416     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 417             || !TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 418         goto out;
 419
 420     /* Determine the size of the signature. */
 421     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
 422             || !TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
 423         goto out;
 424
 425     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len))
 426             || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 427         goto out;
 428
 429     /* Ensure that the signature round-trips. */
 430     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(),
 431                                         NULL, pkey))
 432             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify,
 433                                                  kMsg, sizeof(kMsg)))
 434             || !TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 435         goto out;
 436
 437     ret = 1;
 438
 439  out:
 440     EVP_MD_CTX_free(md_ctx);
 441     EVP_MD_CTX_free(md_ctx_verify);
 442     EVP_PKEY_free(pkey);
 443     OPENSSL_free(sig);
 444
 445     return ret;
 446 }
 447
 448 static int test_EVP_DigestVerifyInit(void)
 449 {
 450     int ret = 0;
 451     EVP_PKEY *pkey = NULL;
 452     EVP_MD_CTX *md_ctx = NULL;
 453
 454     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
 455             || !TEST_ptr(pkey = load_example_rsa_key()))
 456         goto out;
 457
 458     if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
 459             || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
 460             || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
 461                                                  sizeof(kSignature))))
 462         goto out;
 463     ret = 1;
 464
 465  out:
 466     EVP_MD_CTX_free(md_ctx);
 467     EVP_PKEY_free(pkey);
 468     return ret;
 469 }
 470
 471 static int test_d2i_AutoPrivateKey(int i)
 472 {
 473     int ret = 0;
 474     const unsigned char *p;
 475     EVP_PKEY *pkey = NULL;
 476     const APK_DATA *ak = &keydata[i];
 477     const unsigned char *input = ak->kder;
 478     size_t input_len = ak->size;
 479     int expected_id = ak->evptype;
 480
 481     p = input;
 482     if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 483             || !TEST_ptr_eq(p, input + input_len)
 484             || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
 485         goto done;
 486
 487     ret = 1;
 488
 489  done:
 490     EVP_PKEY_free(pkey);
 491     return ret;
 492 }
 493
 494 #ifndef OPENSSL_NO_EC
 495 /* Tests loading a bad key in PKCS8 format */
 496 static int test_EVP_PKCS82PKEY(void)
 497 {
 498     int ret = 0;
 499     const unsigned char *derp = kExampleBadECKeyDER;
 500     PKCS8_PRIV_KEY_INFO *p8inf = NULL;
 501     EVP_PKEY *pkey = NULL;
 502
 503     if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
 504                                               sizeof(kExampleBadECKeyDER))))
 505         goto done;
 506
 507     if (!TEST_ptr_eq(derp,
 508                      kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
 509         goto done;
 510
 511     if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
 512         goto done;
 513
 514     ret = 1;
 515
 516  done:
 517     PKCS8_PRIV_KEY_INFO_free(p8inf);
 518     EVP_PKEY_free(pkey);
 519
 520     return ret;
 521 }
 522 #endif
 523
 524 #ifndef OPENSSL_NO_SM2
 525
 526 static int test_EVP_SM2(void)
 527 {
 528     int ret = 0;
 529     EVP_PKEY *pkey = NULL;
 530     EVP_PKEY *params = NULL;
 531     EVP_PKEY_CTX *pctx = NULL;
 532     EVP_PKEY_CTX *kctx = NULL;
 533     size_t sig_len = 0;
 534     unsigned char *sig = NULL;
 535     EVP_MD_CTX *md_ctx = NULL;
 536     EVP_MD_CTX *md_ctx_verify = NULL;
 537     EVP_PKEY_CTX *cctx = NULL;
 538
 539     uint8_t ciphertext[128];
 540     size_t ctext_len = sizeof(ciphertext);
 541
 542     uint8_t plaintext[8];
 543     size_t ptext_len = sizeof(plaintext);
 544
 545     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
 546     if (!TEST_ptr(pctx))
 547         goto done;
 548
 549     if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
 550         goto done;
 551
 552     if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
 553         goto done;
 554
 555     if (!TEST_true(EVP_PKEY_paramgen(pctx, &params)))
 556         goto done;
 557
 558     kctx = EVP_PKEY_CTX_new(params, NULL);
 559     if (!TEST_ptr(kctx))
 560         goto done;
 561
 562     if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
 563         goto done;
 564
 565     if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
 566         goto done;
 567
 568     if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
 569         goto done;
 570
 571     if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
 572         goto done;
 573
 574     if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
 575         goto done;
 576
 577     if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
 578         goto done;
 579
 580     if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
 581         goto done;
 582
 583     /* Determine the size of the signature. */
 584     if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
 585         goto done;
 586
 587     if (!TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
 588         goto done;
 589
 590     if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
 591         goto done;
 592
 593     if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
 594         goto done;
 595
 596     /* Ensure that the signature round-trips. */
 597
 598     if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
 599         goto done;
 600
 601     if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
 602         goto done;
 603
 604     if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
 605         goto done;
 606
 607     /* now check encryption/decryption */
 608
 609     if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
 610         goto done;
 611
 612     if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
 613         goto done;
 614
 615     if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
 616         goto done;
 617
 618     if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
 619         goto done;
 620
 621     if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
 622         goto done;
 623
 624     if (!TEST_true(ptext_len == sizeof(kMsg)))
 625         goto done;
 626
 627     if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
 628         goto done;
 629
 630     ret = 1;
 631 done:
 632     EVP_PKEY_CTX_free(pctx);
 633     EVP_PKEY_CTX_free(kctx);
 634     EVP_PKEY_CTX_free(cctx);
 635     EVP_PKEY_free(pkey);
 636     EVP_PKEY_free(params);
 637     EVP_MD_CTX_free(md_ctx);
 638     EVP_MD_CTX_free(md_ctx_verify);
 639     OPENSSL_free(sig);
 640     return ret;
 641 }
 642
 643 #endif
 644
 645 static struct keys_st {
 646     int type;
 647     char *priv;
 648     char *pub;
 649 } keys[] = {
 650     {
 651         EVP_PKEY_HMAC, "0123456789", NULL
 652     }, {
 653         EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
 654     }, {
 655         EVP_PKEY_SIPHASH, "0123456789012345", NULL
 656     },
 657 #ifndef OPENSSL_NO_EC
 658     {
 659         EVP_PKEY_X25519, "01234567890123456789012345678901",
 660         "abcdefghijklmnopqrstuvwxyzabcdef"
 661     }, {
 662         EVP_PKEY_ED25519, "01234567890123456789012345678901",
 663         "abcdefghijklmnopqrstuvwxyzabcdef"
 664     }, {
 665         EVP_PKEY_X448,
 666         "01234567890123456789012345678901234567890123456789012345",
 667         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
 668     }, {
 669         EVP_PKEY_ED448,
 670         "012345678901234567890123456789012345678901234567890123456",
 671         "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
 672     }
 673 #endif
 674 };
 675
 676 static int test_set_get_raw_keys_int(int tst, int pub)
 677 {
 678     int ret = 0;
 679     unsigned char buf[80];
 680     unsigned char *in;
 681     size_t inlen, len = 0;
 682     EVP_PKEY *pkey;
 683
 684     /* Check if this algorithm supports public keys */
 685     if (keys[tst].pub == NULL)
 686         return 1;
 687
 688     memset(buf, 0, sizeof(buf));
 689
 690     if (pub) {
 691         inlen = strlen(keys[tst].pub);
 692         in = (unsigned char *)keys[tst].pub;
 693         pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
 694                                            NULL,
 695                                            in,
 696                                            inlen);
 697     } else {
 698         inlen = strlen(keys[tst].priv);
 699         in = (unsigned char *)keys[tst].priv;
 700         pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
 701                                             NULL,
 702                                             in,
 703                                             inlen);
 704     }
 705
 706     if (!TEST_ptr(pkey)
 707             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
 708             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
 709             || !TEST_true(len == inlen)
 710             || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
 711             || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
 712             || !TEST_mem_eq(in, inlen, buf, len))
 713         goto done;
 714
 715     ret = 1;
 716  done:
 717     EVP_PKEY_free(pkey);
 718     return ret;
 719 }
 720
 721 static int test_set_get_raw_keys(int tst)
 722 {
 723     return test_set_get_raw_keys_int(tst, 0)
 724            && test_set_get_raw_keys_int(tst, 1);
 725 }
 726
 727 static int pkey_custom_check(EVP_PKEY *pkey)
 728 {
 729     return 0xbeef;
 730 }
 731
 732 static int pkey_custom_pub_check(EVP_PKEY *pkey)
 733 {
 734     return 0xbeef;
 735 }
 736
 737 static int pkey_custom_param_check(EVP_PKEY *pkey)
 738 {
 739     return 0xbeef;
 740 }
 741
 742 static EVP_PKEY_METHOD *custom_pmeth;
 743
 744 static int test_EVP_PKEY_check(int i)
 745 {
 746     int ret = 0;
 747     const unsigned char *p;
 748     EVP_PKEY *pkey = NULL;
 749 #ifndef OPENSSL_NO_EC
 750     EC_KEY *eckey = NULL;
 751 #endif
 752     EVP_PKEY_CTX *ctx = NULL;
 753     EVP_PKEY_CTX *ctx2 = NULL;
 754     const APK_DATA *ak = &keycheckdata[i];
 755     const unsigned char *input = ak->kder;
 756     size_t input_len = ak->size;
 757     int expected_id = ak->evptype;
 758     int expected_check = ak->check;
 759     int expected_pub_check = ak->pub_check;
 760     int expected_param_check = ak->param_check;
 761     int type = ak->type;
 762     BIO *pubkey = NULL;
 763
 764     p = input;
 765
 766     if (type == 0 &&
 767             (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
 768              || !TEST_ptr_eq(p, input + input_len)
 769              || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id)))
 770         goto done;
 771
 772 #ifndef OPENSSL_NO_EC
 773     if (type == 1 &&
 774             (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
 775              || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
 776              || !TEST_ptr(pkey = EVP_PKEY_new())
 777              || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey))))
 778         goto done;
 779
 780     if (type == 2 &&
 781             (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
 782              || !TEST_ptr_eq(p, input + input_len)
 783              || !TEST_ptr(pkey = EVP_PKEY_new())
 784              || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey))))
 785         goto done;
 786 #endif
 787
 788     if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
 789         goto done;
 790
 791     if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
 792         goto done;
 793
 794     if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
 795         goto done;
 796
 797     if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
 798         goto done;
 799
 800     ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
 801     /* assign the pkey directly, as an internal test */
 802     EVP_PKEY_up_ref(pkey);
 803     ctx2->pkey = pkey;
 804
 805     if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
 806         goto done;
 807
 808     if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
 809         goto done;
 810
 811     if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
 812         goto done;
 813
 814     ret = 1;
 815
 816  done:
 817     EVP_PKEY_CTX_free(ctx);
 818     EVP_PKEY_CTX_free(ctx2);
 819     EVP_PKEY_free(pkey);
 820     BIO_free(pubkey);
 821     return ret;
 822 }
 823
 824 int setup_tests(void)
 825 {
 826     ADD_TEST(test_EVP_DigestSignInit);
 827     ADD_TEST(test_EVP_DigestVerifyInit);
 828     ADD_TEST(test_EVP_Enveloped);
 829     ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
 830 #ifndef OPENSSL_NO_EC
 831     ADD_TEST(test_EVP_PKCS82PKEY);
 832 #endif
 833 #ifndef OPENSSL_NO_SM2
 834     ADD_TEST(test_EVP_SM2);
 835 #endif
 836     ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
 837     custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
 838     if (!TEST_ptr(custom_pmeth))
 839         return 0;
 840     EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
 841     EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
 842     EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
 843     if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
 844         return 0;
 845     ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
 846     return 1;
 847 }