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