Key zeroization fix for EVP_SealInit + added simple test
[openssl.git] / 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 }