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