]> git.ipfire.org Git - thirdparty/openssl.git/blame - test/evp_extra_test.c
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
TEST: Test i2d_PKCS8PrivateKey_bio() and PEM_write_bio_PKCS8PrivateKey()
[thirdparty/openssl.git] / test / evp_extra_test.c
CommitLineData
440e5d80 1/*
33388b44 2 * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved.
71ea6b48 3 *
909f1a2e 4 * Licensed under the Apache License 2.0 (the "License"). You may not use
440e5d80
RS		 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
71ea6b48
MC		 8 */
9
10#include <stdio.h>
11#include <stdlib.h>
bb5f281a 12#include <string.h>
71ea6b48 13#include <openssl/bio.h>
7bb82f92 14#include <openssl/conf.h>
71ea6b48
MC		 15#include <openssl/crypto.h>
16#include <openssl/err.h>
17#include <openssl/evp.h>
18#include <openssl/rsa.h>
19#include <openssl/x509.h>
4803717f 20#include <openssl/pem.h>
10d5b415 21#include <openssl/kdf.h>
847d0f81 22#include <openssl/provider.h>
9c45222d 23#include <openssl/core_names.h>
f54a4101 24#include <openssl/params.h>
9c45222d 25#include <openssl/dsa.h>
e295de1d 26#include <openssl/dh.h>
adcd8e37 27#include "testutil.h"
176db6dc 28#include "internal/nelem.h"
00bc1ad9 29#include "internal/sizes.h"
25f2138b 30#include "crypto/evp.h"
71ea6b48 31
86dc26ba
MC		 32static OPENSSL_CTX *testctx = NULL;
33
71ea6b48
MC		 34/*
35 * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
36 * should never use this key anywhere but in an example.
37 */
38static const unsigned char kExampleRSAKeyDER[] = {
39 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
40 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
41 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
42 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
43 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
44 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
45 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
46 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
47 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
48 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
49 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
50 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
51 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
52 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
53 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
54 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
55 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
56 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
57 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
58 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
59 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
60 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
61 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
62 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
63 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
64 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
65 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
66 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
67 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
68 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
69 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
70 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
71 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
72 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
73 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
74 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
75 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
76 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
77 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
78 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
79 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
80 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
81 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
82 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
83 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
84 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
85 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
86 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
87 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
88 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
89 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
90};
91
59d0e6c8
MC		 92/*
93* kExampleDSAKeyDER is a DSA private key in ASN.1, DER format. Of course, you
94 * should never use this key anywhere but in an example.
95 */
f650ab47 96#ifndef OPENSSL_NO_DSA
59d0e6c8
MC		 97static const unsigned char kExampleDSAKeyDER[] = {
98 0x30, 0x82, 0x01, 0xba, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0x9a,
99 0x05, 0x6d, 0x33, 0xcd, 0x5d, 0x78, 0xa1, 0xbb, 0xcb, 0x7d, 0x5b, 0x8d,
100 0xb4, 0xcc, 0xbf, 0x03, 0x99, 0x64, 0xde, 0x38, 0x78, 0x06, 0x15, 0x2f,
101 0x86, 0x26, 0x77, 0xf3, 0xb1, 0x85, 0x00, 0xed, 0xfc, 0x28, 0x3a, 0x42,
102 0x4d, 0xab, 0xab, 0xdf, 0xbc, 0x9c, 0x16, 0xd0, 0x22, 0x50, 0xd1, 0x38,
103 0xdd, 0x3f, 0x64, 0x05, 0x9e, 0x68, 0x7a, 0x1e, 0xf1, 0x56, 0xbf, 0x1e,
104 0x2c, 0xc5, 0x97, 0x2a, 0xfe, 0x7a, 0x22, 0xdc, 0x6c, 0x68, 0xb8, 0x2e,
105 0x06, 0xdb, 0x41, 0xca, 0x98, 0xd8, 0x54, 0xc7, 0x64, 0x48, 0x24, 0x04,
106 0x20, 0xbc, 0x59, 0xe3, 0x6b, 0xea, 0x7e, 0xfc, 0x7e, 0xc5, 0x4e, 0xd4,
107 0xd8, 0x3a, 0xed, 0xcd, 0x5d, 0x99, 0xb8, 0x5c, 0xa2, 0x8b, 0xbb, 0x0b,
108 0xac, 0xe6, 0x8e, 0x25, 0x56, 0x22, 0x3a, 0x2d, 0x3a, 0x56, 0x41, 0x14,
109 0x1f, 0x1c, 0x8f, 0x53, 0x46, 0x13, 0x85, 0x02, 0x15, 0x00, 0x98, 0x7e,
110 0x92, 0x81, 0x88, 0xc7, 0x3f, 0x70, 0x49, 0x54, 0xf6, 0x76, 0xb4, 0xa3,
111 0x9e, 0x1d, 0x45, 0x98, 0x32, 0x7f, 0x02, 0x81, 0x80, 0x69, 0x4d, 0xef,
112 0x55, 0xff, 0x4d, 0x59, 0x2c, 0x01, 0xfa, 0x6a, 0x38, 0xe0, 0x70, 0x9f,
113 0x9e, 0x66, 0x8e, 0x3e, 0x8c, 0x52, 0x22, 0x9d, 0x15, 0x7e, 0x3c, 0xef,
114 0x4c, 0x7a, 0x61, 0x26, 0xe0, 0x2b, 0x81, 0x3f, 0xeb, 0xaf, 0x35, 0x38,
115 0x8d, 0xfe, 0xed, 0x46, 0xff, 0x5f, 0x03, 0x9b, 0x81, 0x92, 0xe7, 0x6f,
116 0x76, 0x4f, 0x1d, 0xd9, 0xbb, 0x89, 0xc9, 0x3e, 0xd9, 0x0b, 0xf9, 0xf4,
117 0x78, 0x11, 0x59, 0xc0, 0x1d, 0xcd, 0x0e, 0xa1, 0x6f, 0x15, 0xf1, 0x4d,
118 0xc1, 0xc9, 0x22, 0xed, 0x8d, 0xad, 0x67, 0xc5, 0x4b, 0x95, 0x93, 0x86,
119 0xa6, 0xaf, 0x8a, 0xee, 0x06, 0x89, 0x2f, 0x37, 0x7e, 0x64, 0xaa, 0xf6,
120 0xe7, 0xb1, 0x5a, 0x0a, 0x93, 0x95, 0x5d, 0x3e, 0x53, 0x9a, 0xde, 0x8a,
121 0xc2, 0x95, 0x45, 0x81, 0xbe, 0x5c, 0x2f, 0xc2, 0xb2, 0x92, 0x58, 0x19,
122 0x72, 0x80, 0xe9, 0x79, 0xa1, 0x02, 0x81, 0x80, 0x07, 0xd7, 0x62, 0xff,
123 0xdf, 0x1a, 0x3f, 0xed, 0x32, 0xd4, 0xd4, 0x88, 0x7b, 0x2c, 0x63, 0x7f,
124 0x97, 0xdc, 0x44, 0xd4, 0x84, 0xa2, 0xdd, 0x17, 0x16, 0x85, 0x13, 0xe0,
125 0xac, 0x51, 0x8d, 0x29, 0x1b, 0x75, 0x9a, 0xe4, 0xe3, 0x8a, 0x92, 0x69,
126 0x09, 0x03, 0xc5, 0x68, 0xae, 0x5e, 0x94, 0xfe, 0xc9, 0x92, 0x6c, 0x07,
127 0xb4, 0x1e, 0x64, 0x62, 0x87, 0xc6, 0xa4, 0xfd, 0x0d, 0x5f, 0xe5, 0xf9,
128 0x1b, 0x4f, 0x85, 0x5f, 0xae, 0xf3, 0x11, 0xe5, 0x18, 0xd4, 0x4d, 0x79,
129 0x9f, 0xc4, 0x79, 0x26, 0x04, 0x27, 0xf0, 0x0b, 0xee, 0x2b, 0x86, 0x9f,
130 0x86, 0x61, 0xe6, 0x51, 0xce, 0x04, 0x9b, 0x5d, 0x6b, 0x34, 0x43, 0x8c,
131 0x85, 0x3c, 0xf1, 0x51, 0x9b, 0x08, 0x23, 0x1b, 0xf5, 0x7e, 0x33, 0x12,
132 0xea, 0xab, 0x1f, 0xb7, 0x2d, 0xe2, 0x5f, 0xe6, 0x97, 0x99, 0xb5, 0x45,
133 0x16, 0x5b, 0xc3, 0x41, 0x02, 0x14, 0x61, 0xbf, 0x51, 0x60, 0xcf, 0xc8,
134 0xf1, 0x8c, 0x82, 0x97, 0xf2, 0xf4, 0x19, 0xba, 0x2b, 0xf3, 0x16, 0xbe,
135 0x40, 0x48
136};
f650ab47 137#endif
59d0e6c8 138
2aee35d3
PY		 139/*
140 * kExampleBadRSAKeyDER is an RSA private key in ASN.1, DER format. The private
141 * components are not correct.
142 */
143static const unsigned char kExampleBadRSAKeyDER[] = {
144 0x30, 0x82, 0x04, 0x27, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
145 0xa6, 0x1a, 0x1e, 0x6e, 0x7b, 0xee, 0xc6, 0x89, 0x66, 0xe7, 0x93, 0xef,
146 0x54, 0x12, 0x68, 0xea, 0xbf, 0x86, 0x2f, 0xdd, 0xd2, 0x79, 0xb8, 0xa9,
147 0x6e, 0x03, 0xc2, 0xa3, 0xb9, 0xa3, 0xe1, 0x4b, 0x2a, 0xb3, 0xf8, 0xb4,
148 0xcd, 0xea, 0xbe, 0x24, 0xa6, 0x57, 0x5b, 0x83, 0x1f, 0x0f, 0xf2, 0xd3,
149 0xb7, 0xac, 0x7e, 0xd6, 0x8e, 0x6e, 0x1e, 0xbf, 0xb8, 0x73, 0x8c, 0x05,
150 0x56, 0xe6, 0x35, 0x1f, 0xe9, 0x04, 0x0b, 0x09, 0x86, 0x7d, 0xf1, 0x26,
151 0x08, 0x99, 0xad, 0x7b, 0xc8, 0x4d, 0x94, 0xb0, 0x0b, 0x8b, 0x38, 0xa0,
152 0x5c, 0x62, 0xa0, 0xab, 0xd3, 0x8f, 0xd4, 0x09, 0x60, 0x72, 0x1e, 0x33,
153 0x50, 0x80, 0x6e, 0x22, 0xa6, 0x77, 0x57, 0x6b, 0x9a, 0x33, 0x21, 0x66,
154 0x87, 0x6e, 0x21, 0x7b, 0xc7, 0x24, 0x0e, 0xd8, 0x13, 0xdf, 0x83, 0xde,
155 0xcd, 0x40, 0x58, 0x1d, 0x84, 0x86, 0xeb, 0xb8, 0x12, 0x4e, 0xd2, 0xfa,
156 0x80, 0x1f, 0xe4, 0xe7, 0x96, 0x29, 0xb8, 0xcc, 0xce, 0x66, 0x6d, 0x53,
157 0xca, 0xb9, 0x5a, 0xd7, 0xf6, 0x84, 0x6c, 0x2d, 0x9a, 0x1a, 0x14, 0x1c,
158 0x4e, 0x93, 0x39, 0xba, 0x74, 0xed, 0xed, 0x87, 0x87, 0x5e, 0x48, 0x75,
159 0x36, 0xf0, 0xbc, 0x34, 0xfb, 0x29, 0xf9, 0x9f, 0x96, 0x5b, 0x0b, 0xa7,
160 0x54, 0x30, 0x51, 0x29, 0x18, 0x5b, 0x7d, 0xac, 0x0f, 0xd6, 0x5f, 0x7c,
161 0xf8, 0x98, 0x8c, 0xd8, 0x86, 0x62, 0xb3, 0xdc, 0xff, 0x0f, 0xff, 0x7a,
162 0xaf, 0x5c, 0x4c, 0x61, 0x49, 0x2e, 0xc8, 0x95, 0x86, 0xc4, 0x0e, 0x87,
163 0xfc, 0x1d, 0xcf, 0x8b, 0x7c, 0x61, 0xf6, 0xd8, 0xd0, 0x69, 0xf6, 0xcd,
164 0x8a, 0x8c, 0xf6, 0x62, 0xa2, 0x56, 0xa9, 0xe3, 0xd1, 0xcf, 0x4d, 0xa0,
165 0xf6, 0x2d, 0x20, 0x0a, 0x04, 0xb7, 0xa2, 0xf7, 0xb5, 0x99, 0x47, 0x18,
166 0x56, 0x85, 0x87, 0xc7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
167 0x01, 0x00, 0x99, 0x41, 0x38, 0x1a, 0xd0, 0x96, 0x7a, 0xf0, 0x83, 0xd5,
168 0xdf, 0x94, 0xce, 0x89, 0x3d, 0xec, 0x7a, 0x52, 0x21, 0x10, 0x16, 0x06,
169 0xe0, 0xee, 0xd2, 0xe6, 0xfd, 0x4b, 0x7b, 0x19, 0x4d, 0xe1, 0xc0, 0xc0,
170 0xd5, 0x14, 0x5d, 0x79, 0xdd, 0x7e, 0x8b, 0x4b, 0xc6, 0xcf, 0xb0, 0x75,
171 0x52, 0xa3, 0x2d, 0xb1, 0x26, 0x46, 0x68, 0x9c, 0x0a, 0x1a, 0xf2, 0xe1,
172 0x09, 0xac, 0x53, 0x85, 0x8c, 0x36, 0xa9, 0x14, 0x65, 0xea, 0xa0, 0x00,
173 0xcb, 0xe3, 0x3f, 0xc4, 0x2b, 0x61, 0x2e, 0x6b, 0x06, 0x69, 0x77, 0xfd,
174 0x38, 0x7e, 0x1d, 0x3f, 0x92, 0xe7, 0x77, 0x08, 0x19, 0xa7, 0x9d, 0x29,
175 0x2d, 0xdc, 0x42, 0xc6, 0x7c, 0xd7, 0xd3, 0xa8, 0x01, 0x2c, 0xf2, 0xd5,
176 0x82, 0x57, 0xcb, 0x55, 0x3d, 0xe7, 0xaa, 0xd2, 0x06, 0x30, 0x30, 0x05,
177 0xe6, 0xf2, 0x47, 0x86, 0xba, 0xc6, 0x61, 0x64, 0xeb, 0x4f, 0x2a, 0x5e,
178 0x07, 0x29, 0xe0, 0x96, 0xb2, 0x43, 0xff, 0x5f, 0x1a, 0x54, 0x16, 0xcf,
179 0xb5, 0x56, 0x5c, 0xa0, 0x9b, 0x0c, 0xfd, 0xb3, 0xd2, 0xe3, 0x79, 0x1d,
180 0x21, 0xe2, 0xd6, 0x13, 0xc4, 0x74, 0xa6, 0xf5, 0x8e, 0x8e, 0x81, 0xbb,
181 0xb4, 0xad, 0x8a, 0xf0, 0x93, 0x0a, 0xd8, 0x0a, 0x42, 0x36, 0xbc, 0xe5,
182 0x26, 0x2a, 0x0d, 0x5d, 0x57, 0x13, 0xc5, 0x4e, 0x2f, 0x12, 0x0e, 0xef,
183 0xa7, 0x81, 0x1e, 0xc3, 0xa5, 0xdb, 0xc9, 0x24, 0xeb, 0x1a, 0xa1, 0xf9,
184 0xf6, 0xa1, 0x78, 0x98, 0x93, 0x77, 0x42, 0x45, 0x03, 0xe2, 0xc9, 0xa2,
185 0xfe, 0x2d, 0x77, 0xc8, 0xc6, 0xac, 0x9b, 0x98, 0x89, 0x6d, 0x9a, 0xe7,
186 0x61, 0x63, 0xb7, 0xf2, 0xec, 0xd6, 0xb1, 0xa1, 0x6e, 0x0a, 0x1a, 0xff,
187 0xfd, 0x43, 0x28, 0xc3, 0x0c, 0xdc, 0xf2, 0x47, 0x4f, 0x27, 0xaa, 0x99,
188 0x04, 0x8e, 0xac, 0xe8, 0x7c, 0x01, 0x02, 0x04, 0x12, 0x34, 0x56, 0x78,
189 0x02, 0x81, 0x81, 0x00, 0xca, 0x69, 0xe5, 0xbb, 0x3a, 0x90, 0x82, 0xcb,
190 0x82, 0x50, 0x2f, 0x29, 0xe2, 0x76, 0x6a, 0x57, 0x55, 0x45, 0x4e, 0x35,
191 0x18, 0x61, 0xe0, 0x12, 0x70, 0xc0, 0xab, 0xc7, 0x80, 0xa2, 0xd4, 0x46,
192 0x34, 0x03, 0xa0, 0x19, 0x26, 0x23, 0x9e, 0xef, 0x1a, 0xcb, 0x75, 0xd6,
193 0xba, 0x81, 0xf4, 0x7e, 0x52, 0xe5, 0x2a, 0xe8, 0xf1, 0x49, 0x6c, 0x0f,
194 0x1a, 0xa0, 0xf9, 0xc6, 0xe7, 0xec, 0x60, 0xe4, 0xcb, 0x2a, 0xb5, 0x56,
195 0xe9, 0x9c, 0xcd, 0x19, 0x75, 0x92, 0xb1, 0x66, 0xce, 0xc3, 0xd9, 0x3d,
196 0x11, 0xcb, 0xc4, 0x09, 0xce, 0x1e, 0x30, 0xba, 0x2f, 0x60, 0x60, 0x55,
197 0x8d, 0x02, 0xdc, 0x5d, 0xaf, 0xf7, 0x52, 0x31, 0x17, 0x07, 0x53, 0x20,
198 0x33, 0xad, 0x8c, 0xd5, 0x2f, 0x5a, 0xd0, 0x57, 0xd7, 0xd1, 0x80, 0xd6,
199 0x3a, 0x9b, 0x04, 0x4f, 0x35, 0xbf, 0xe7, 0xd5, 0xbc, 0x8f, 0xd4, 0x81,
200 0x02, 0x81, 0x81, 0x00, 0xc0, 0x9f, 0xf8, 0xcd, 0xf7, 0x3f, 0x26, 0x8a,
201 0x3d, 0x4d, 0x2b, 0x0c, 0x01, 0xd0, 0xa2, 0xb4, 0x18, 0xfe, 0xf7, 0x5e,
202 0x2f, 0x06, 0x13, 0xcd, 0x63, 0xaa, 0x12, 0xa9, 0x24, 0x86, 0xe3, 0xf3,
203 0x7b, 0xda, 0x1a, 0x3c, 0xb1, 0x38, 0x80, 0x80, 0xef, 0x64, 0x64, 0xa1,
204 0x9b, 0xfe, 0x76, 0x63, 0x8e, 0x83, 0xd2, 0xd9, 0xb9, 0x86, 0xb0, 0xe6,
205 0xa6, 0x0c, 0x7e, 0xa8, 0x84, 0x90, 0x98, 0x0c, 0x1e, 0xf3, 0x14, 0x77,
206 0xe0, 0x5f, 0x81, 0x08, 0x11, 0x8f, 0xa6, 0x23, 0xc4, 0xba, 0xc0, 0x8a,
207 0xe4, 0xc6, 0xe3, 0x5c, 0xbe, 0xc5, 0xec, 0x2c, 0xb9, 0xd8, 0x8c, 0x4d,
208 0x1a, 0x9d, 0xe7, 0x7c, 0x85, 0x4c, 0x0d, 0x71, 0x4e, 0x72, 0x33, 0x1b,
209 0xfe, 0xa9, 0x17, 0x72, 0x76, 0x56, 0x9d, 0x74, 0x7e, 0x52, 0x67, 0x9a,
210 0x87, 0x9a, 0xdb, 0x30, 0xde, 0xe4, 0x49, 0x28, 0x3b, 0xd2, 0x67, 0xaf,
211 0x02, 0x81, 0x81, 0x00, 0x89, 0x74, 0x9a, 0x8e, 0xa7, 0xb9, 0xa5, 0x28,
212 0xc0, 0x68, 0xe5, 0x6e, 0x63, 0x1c, 0x99, 0x20, 0x8f, 0x86, 0x8e, 0x12,
213 0x9e, 0x69, 0x30, 0xfa, 0x34, 0xd9, 0x92, 0x8d, 0xdb, 0x7c, 0x37, 0xfd,
214 0x28, 0xab, 0x61, 0x98, 0x52, 0x7f, 0x14, 0x1a, 0x39, 0xae, 0xfb, 0x6a,
215 0x03, 0xa3, 0xe6, 0xbd, 0xb6, 0x5b, 0x6b, 0xe5, 0x5e, 0x9d, 0xc6, 0xa5,
216 0x07, 0x27, 0x54, 0x17, 0xd0, 0x3d, 0x84, 0x9b, 0x3a, 0xa0, 0xd9, 0x1e,
217 0x99, 0x6c, 0x63, 0x17, 0xab, 0xf1, 0x1f, 0x49, 0xba, 0x95, 0xe3, 0x3b,
218 0x86, 0x8f, 0x42, 0xa4, 0x89, 0xf5, 0x94, 0x8f, 0x8b, 0x46, 0xbe, 0x84,
219 0xba, 0x4a, 0xbc, 0x0d, 0x5f, 0x46, 0xeb, 0xe8, 0xec, 0x43, 0x8c, 0x1e,
220 0xad, 0x19, 0x69, 0x2f, 0x08, 0x86, 0x7a, 0x3f, 0x7d, 0x0f, 0x07, 0x97,
221 0xf3, 0x9a, 0x7b, 0xb5, 0xb2, 0xc1, 0x8c, 0x95, 0x68, 0x04, 0xa0, 0x81,
222 0x02, 0x81, 0x80, 0x4e, 0xbf, 0x7e, 0x1b, 0xcb, 0x13, 0x61, 0x75, 0x3b,
223 0xdb, 0x59, 0x5f, 0xb1, 0xd4, 0xb8, 0xeb, 0x9e, 0x73, 0xb5, 0xe7, 0xf6,
224 0x89, 0x3d, 0x1c, 0xda, 0xf0, 0x36, 0xff, 0x35, 0xbd, 0x1e, 0x0b, 0x74,
225 0xe3, 0x9e, 0xf0, 0xf2, 0xf7, 0xd7, 0x82, 0xb7, 0x7b, 0x6a, 0x1b, 0x0e,
226 0x30, 0x4a, 0x98, 0x0e, 0xb4, 0xf9, 0x81, 0x07, 0xe4, 0x75, 0x39, 0xe9,
227 0x53, 0xca, 0xbb, 0x5c, 0xaa, 0x93, 0x07, 0x0e, 0xa8, 0x2f, 0xba, 0x98,
228 0x49, 0x30, 0xa7, 0xcc, 0x1a, 0x3c, 0x68, 0x0c, 0xe1, 0xa4, 0xb1, 0x05,
229 0xe6, 0xe0, 0x25, 0x78, 0x58, 0x14, 0x37, 0xf5, 0x1f, 0xe3, 0x22, 0xef,
230 0xa8, 0x0e, 0x22, 0xa0, 0x94, 0x3a, 0xf6, 0xc9, 0x13, 0xe6, 0x06, 0xbf,
231 0x7f, 0x99, 0xc6, 0xcc, 0xd8, 0xc6, 0xbe, 0xd9, 0x2e, 0x24, 0xc7, 0x69,
232 0x8c, 0x95, 0xba, 0xf6, 0x04, 0xb3, 0x0a, 0xf4, 0xcb, 0xf0, 0xce,
233};
234
71ea6b48
MC		 235static const unsigned char kMsg[] = { 1, 2, 3, 4 };
236
237static const unsigned char kSignature[] = {
238 0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
239 0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
240 0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
241 0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
242 0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
243 0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
244 0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
245 0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
246 0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
247 0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
248 0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
249};
250
251/*
252 * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
253 * PrivateKeyInfo.
254 */
255static const unsigned char kExampleRSAKeyPKCS8[] = {
256 0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
257 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
258 0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
259 0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
260 0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
261 0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
262 0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
263 0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
264 0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
265 0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
266 0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
267 0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
268 0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
269 0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
270 0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
271 0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
272 0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
273 0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
274 0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
275 0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
276 0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
277 0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
278 0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
279 0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
280 0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
281 0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
282 0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
283 0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
284 0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
285 0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
286 0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
287 0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
288 0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
289 0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
290 0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
291 0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
292 0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
293 0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
294 0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
295 0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
296 0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
297 0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
298 0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
299 0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
300 0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
301 0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
302 0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
303 0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
304 0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
305 0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
306 0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
307 0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
308 0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
309};
310
a9880362 311#ifndef OPENSSL_NO_EC
71ea6b48
MC		 312/*
313 * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
314 * structure.
315 */
316static const unsigned char kExampleECKeyDER[] = {
317 0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
318 0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
319 0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
320 0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
321 0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
322 0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
323 0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
324 0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
325 0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
326 0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
327 0xc1,
328};
329
330/*
331 * kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
332 * structure. The private key is equal to the order and will fail to import
333 */
334static const unsigned char kExampleBadECKeyDER[] = {
335 0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
336 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
337 0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
338 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
339 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
340 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
341 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
342 0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
343 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
344};
b0004708
PY		 345
346/* prime256v1 */
347static const unsigned char kExampleECPubKeyDER[] = {
348 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
349 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
350 0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
351 0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
352 0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
353 0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
354 0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
355 0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
356};
357
5dc40a83 358/*
87762939 359 * kExampleBadECPubKeyDER is a sample EC public key with a wrong OID
5dc40a83
BE		 360 * 1.2.840.10045.2.2 instead of 1.2.840.10045.2.1 - EC Public Key
361 */
362static const unsigned char kExampleBadECPubKeyDER[] = {
363 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
364 0x02, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
365 0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
366 0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
367 0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
368 0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
369 0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
370 0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
371};
372
b0004708
PY		 373static const unsigned char pExampleECParamDER[] = {
374 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
375};
a9880362 376#endif
71ea6b48 377
adcd8e37
RS		 378typedef struct APK_DATA_st {
379 const unsigned char *kder;
380 size_t size;
381 int evptype;
2aee35d3 382 int check;
b0004708
PY		 383 int pub_check;
384 int param_check;
385 int type; /* 0 for private, 1 for public, 2 for params */
adcd8e37
RS		 386} APK_DATA;
387
388static APK_DATA keydata[] = {
389 {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
390 {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
aa24cd1b 391#ifndef OPENSSL_NO_EC
adcd8e37 392 {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
aa24cd1b 393#endif
adcd8e37
RS		 394};
395
2aee35d3 396static APK_DATA keycheckdata[] = {
b0004708
PY		 397 {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA, 1, -2, -2, 0},
398 {kExampleBadRSAKeyDER, sizeof(kExampleBadRSAKeyDER), EVP_PKEY_RSA,
399 0, -2, -2, 0},
2aee35d3 400#ifndef OPENSSL_NO_EC
b0004708
PY		 401 {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC, 1, 1, 1, 0},
402 /* group is also associated in our pub key */
403 {kExampleECPubKeyDER, sizeof(kExampleECPubKeyDER), EVP_PKEY_EC, 0, 1, 1, 1},
404 {pExampleECParamDER, sizeof(pExampleECParamDER), EVP_PKEY_EC, 0, 0, 1, 2}
2aee35d3
PY		 405#endif
406};
407
71ea6b48
MC		 408static EVP_PKEY *load_example_rsa_key(void)
409{
410 EVP_PKEY *ret = NULL;
411 const unsigned char *derp = kExampleRSAKeyDER;
412 EVP_PKEY *pkey = NULL;
413 RSA *rsa = NULL;
414
adcd8e37 415 if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
71ea6b48 416 return NULL;
71ea6b48 417
adcd8e37
RS		 418 if (!TEST_ptr(pkey = EVP_PKEY_new())
419 || !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
420 goto end;
71ea6b48
MC		 421
422 ret = pkey;
423 pkey = NULL;
424
adcd8e37 425end:
c5ba2d99 426 EVP_PKEY_free(pkey);
d6407083 427 RSA_free(rsa);
71ea6b48
MC		 428
429 return ret;
430}
431
f650ab47 432#ifndef OPENSSL_NO_DSA
59d0e6c8
MC		 433static EVP_PKEY *load_example_dsa_key(void)
434{
435 EVP_PKEY *ret = NULL;
436 const unsigned char *derp = kExampleDSAKeyDER;
437 EVP_PKEY *pkey = NULL;
438 DSA *dsa = NULL;
439
440 if (!TEST_true(d2i_DSAPrivateKey(&dsa, &derp, sizeof(kExampleDSAKeyDER))))
441 return NULL;
442
443 if (!TEST_ptr(pkey = EVP_PKEY_new())
444 || !TEST_true(EVP_PKEY_set1_DSA(pkey, dsa)))
445 goto end;
446
447 ret = pkey;
448 pkey = NULL;
449
450end:
451 EVP_PKEY_free(pkey);
452 DSA_free(dsa);
453
454 return ret;
455}
f650ab47 456#endif
59d0e6c8 457
6d242fa5
MC		 458static EVP_PKEY *load_example_hmac_key(void)
459{
460 EVP_PKEY *pkey = NULL;
461 unsigned char key[] = {
462 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
463 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
464 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
465 };
466
467 pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL, key, sizeof(key));
468 if (!TEST_ptr(pkey))
469 return NULL;
470
471 return pkey;
472}
473
2eb2b4f3
SL		 474static int test_EVP_Enveloped(void)
475{
476 int ret = 0;
477 EVP_CIPHER_CTX *ctx = NULL;
478 EVP_PKEY *keypair = NULL;
479 unsigned char *kek = NULL;
480 unsigned char iv[EVP_MAX_IV_LENGTH];
481 static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
482 int len, kek_len, ciphertext_len, plaintext_len;
483 unsigned char ciphertext[32], plaintext[16];
484 const EVP_CIPHER *type = EVP_aes_256_cbc();
485
486 if (!TEST_ptr(keypair = load_example_rsa_key())
487 || !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_size(keypair)))
488 || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
489 || !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
490 &keypair, 1))
491 || !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
492 msg, sizeof(msg)))
493 || !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
494 &len)))
495 goto err;
496
497 ciphertext_len += len;
498
499 if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
500 || !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
501 ciphertext, ciphertext_len))
502 || !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
503 goto err;
504
505 plaintext_len += len;
506 if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
507 goto err;
508
509 ret = 1;
510err:
511 OPENSSL_free(kek);
512 EVP_PKEY_free(keypair);
513 EVP_CIPHER_CTX_free(ctx);
514 return ret;
515}
516
59d0e6c8 517/*
6d242fa5
MC		 518 * Test 0: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, RSA)
519 * Test 1: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, DSA)
520 * Test 2: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, HMAC)
521 * Test 3: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, RSA)
522 * Test 4: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, DSA)
523 * Test 5: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch diegst, HMAC)
524 * Test 6: Use an MD BIO to do the Update calls instead (RSA)
525 * Test 7: Use an MD BIO to do the Update calls instead (DSA)
526 * Test 8: Use an MD BIO to do the Update calls instead (HMAC)
59d0e6c8
MC		 527 */
528static int test_EVP_DigestSignInit(int tst)
71ea6b48
MC		 529{
530 int ret = 0;
531 EVP_PKEY *pkey = NULL;
532 unsigned char *sig = NULL;
533 size_t sig_len = 0;
59d0e6c8
MC		 534 EVP_MD_CTX *md_ctx = NULL, *md_ctx_verify = NULL;
535 EVP_MD_CTX *a_md_ctx = NULL, *a_md_ctx_verify = NULL;
536 BIO *mdbio = NULL, *membio = NULL;
537 size_t written;
6d242fa5
MC		 538 const EVP_MD *md;
539 EVP_MD *mdexp = NULL;
59d0e6c8 540
6d242fa5 541 if (tst >= 6) {
59d0e6c8
MC		 542 membio = BIO_new(BIO_s_mem());
543 mdbio = BIO_new(BIO_f_md());
544 if (!TEST_ptr(membio) || !TEST_ptr(mdbio))
545 goto out;
546 BIO_push(mdbio, membio);
547 if (!TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx), 0))
548 goto out;
549 } else {
550 if (!TEST_ptr(a_md_ctx = md_ctx = EVP_MD_CTX_new())
551 || !TEST_ptr(a_md_ctx_verify = md_ctx_verify = EVP_MD_CTX_new()))
552 goto out;
553 }
71ea6b48 554
6d242fa5 555 if (tst == 0 || tst == 3 || tst == 6) {
59d0e6c8
MC		 556 if (!TEST_ptr(pkey = load_example_rsa_key()))
557 goto out;
6d242fa5 558 } else if (tst == 1 || tst == 4 || tst == 7) {
f650ab47 559#ifndef OPENSSL_NO_DSA
59d0e6c8
MC		 560 if (!TEST_ptr(pkey = load_example_dsa_key()))
561 goto out;
f650ab47
MC		 562#else
563 ret = 1;
564 goto out;
565#endif
6d242fa5
MC		 566 } else {
567 if (!TEST_ptr(pkey = load_example_hmac_key()))
568 goto out;
59d0e6c8 569 }
71ea6b48 570
6d242fa5
MC		 571 if (tst >= 3 && tst <= 5)
572 md = mdexp = EVP_MD_fetch(NULL, "SHA256", NULL);
573 else
574 md = EVP_sha256();
575
576 if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, md, NULL, pkey)))
71ea6b48 577 goto out;
adcd8e37 578
6d242fa5 579 if (tst >= 6) {
59d0e6c8
MC		 580 if (!BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written))
581 goto out;
582 } else {
583 if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
584 goto out;
585 }
586
71ea6b48 587 /* Determine the size of the signature. */
adcd8e37 588 if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
0a054d2a 589 || !TEST_ptr(sig = OPENSSL_malloc(sig_len))
adcd8e37 590 || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
71ea6b48 591 goto out;
71ea6b48 592
6d242fa5 593 if (tst >= 6) {
59d0e6c8
MC		 594 if (!TEST_int_gt(BIO_reset(mdbio), 0)
595 || !TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx_verify), 0))
596 goto out;
597 }
598
6d242fa5
MC		 599 /*
600 * Ensure that the signature round-trips (Verification isn't supported for
601 * HMAC via EVP_DigestVerify*)
602 */
603 if (tst != 2 && tst != 5 && tst != 8) {
604 if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, md,
605 NULL, pkey)))
59d0e6c8 606 goto out;
6d242fa5
MC		 607
608 if (tst >= 6) {
609 if (!TEST_true(BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written)))
610 goto out;
611 } else {
612 if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg,
613 sizeof(kMsg))))
614 goto out;
615 }
616 if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
59d0e6c8
MC		 617 goto out;
618 }
71ea6b48
MC		 619
620 ret = 1;
621
622 out:
59d0e6c8
MC		 623 BIO_free(membio);
624 BIO_free(mdbio);
625 EVP_MD_CTX_free(a_md_ctx);
626 EVP_MD_CTX_free(a_md_ctx_verify);
c5ba2d99 627 EVP_PKEY_free(pkey);
b548a1f1 628 OPENSSL_free(sig);
6d242fa5 629 EVP_MD_free(mdexp);
71ea6b48
MC		 630
631 return ret;
632}
633
634static int test_EVP_DigestVerifyInit(void)
635{
636 int ret = 0;
637 EVP_PKEY *pkey = NULL;
adcd8e37 638 EVP_MD_CTX *md_ctx = NULL;
71ea6b48 639
adcd8e37
RS		 640 if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
641 || !TEST_ptr(pkey = load_example_rsa_key()))
642 goto out;
71ea6b48 643
adcd8e37
RS		 644 if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
645 || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
646 || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
647 sizeof(kSignature))))
71ea6b48 648 goto out;
71ea6b48
MC		 649 ret = 1;
650
651 out:
bfb0641f 652 EVP_MD_CTX_free(md_ctx);
c5ba2d99 653 EVP_PKEY_free(pkey);
71ea6b48
MC		 654 return ret;
655}
656
adcd8e37 657static int test_d2i_AutoPrivateKey(int i)
71ea6b48
MC		 658{
659 int ret = 0;
660 const unsigned char *p;
661 EVP_PKEY *pkey = NULL;
adcd8e37
RS		 662 const APK_DATA *ak = &keydata[i];
663 const unsigned char *input = ak->kder;
664 size_t input_len = ak->size;
665 int expected_id = ak->evptype;
71ea6b48
MC		 666
667 p = input;
adcd8e37
RS		 668 if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
669 || !TEST_ptr_eq(p, input + input_len)
670 || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
71ea6b48 671 goto done;
71ea6b48
MC		 672
673 ret = 1;
674
675 done:
c5ba2d99 676 EVP_PKEY_free(pkey);
71ea6b48
MC		 677 return ret;
678}
679
a9880362 680#ifndef OPENSSL_NO_EC
cad8347b
SL		 681
682static const unsigned char ec_public_sect163k1_validxy[] = {
683 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
684 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
685 0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
686 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b,
687 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
688 0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
689};
690
691static const unsigned char ec_public_sect163k1_badx[] = {
692 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
693 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
694 0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
695 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b,
696 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
697 0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
698};
699
700static const unsigned char ec_public_sect163k1_bady[] = {
701 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
702 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
703 0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
704 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b,
705 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
706 0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6
707};
708
709static struct ec_der_pub_keys_st {
710 const unsigned char *der;
711 size_t len;
712 int valid;
713} ec_der_pub_keys[] = {
714 { ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 },
715 { ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 },
716 { ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 },
717};
718
719/*
720 * Tests the range of the decoded EC char2 public point.
721 * See ec_GF2m_simple_oct2point().
722 */
723static int test_invalide_ec_char2_pub_range_decode(int id)
724{
725 int ret = 0;
726 BIO *bio = NULL;
727 EC_KEY *eckey = NULL;
728
729 if (!TEST_ptr(bio = BIO_new_mem_buf(ec_der_pub_keys[id].der,
730 ec_der_pub_keys[id].len)))
731 goto err;
732 eckey = d2i_EC_PUBKEY_bio(bio, NULL);
733 ret = (ec_der_pub_keys[id].valid && TEST_ptr(eckey))
734 || TEST_ptr_null(eckey);
735err:
736 EC_KEY_free(eckey);
737 BIO_free(bio);
738 return ret;
739}
740
71ea6b48
MC		 741/* Tests loading a bad key in PKCS8 format */
742static int test_EVP_PKCS82PKEY(void)
743{
744 int ret = 0;
745 const unsigned char *derp = kExampleBadECKeyDER;
746 PKCS8_PRIV_KEY_INFO *p8inf = NULL;
747 EVP_PKEY *pkey = NULL;
748
adcd8e37
RS		 749 if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
750 sizeof(kExampleBadECKeyDER))))
751 goto done;
71ea6b48 752
adcd8e37
RS		 753 if (!TEST_ptr_eq(derp,
754 kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
71ea6b48 755 goto done;
71ea6b48 756
adcd8e37 757 if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
71ea6b48 758 goto done;
71ea6b48
MC		 759
760 ret = 1;
761
762 done:
e0e920b1 763 PKCS8_PRIV_KEY_INFO_free(p8inf);
c5ba2d99 764 EVP_PKEY_free(pkey);
71ea6b48
MC		 765
766 return ret;
767}
a9880362 768#endif
71ea6b48 769
29c49b25
RL		 770/* This uses kExampleRSAKeyDER and kExampleRSAKeyPKCS8 to verify encoding */
771static int test_privatekey_to_pkcs8(void)
772{
773 EVP_PKEY *pkey = NULL;
774 BIO *membio = NULL;
775 char *membuf = NULL;
776 size_t membuf_len = 0;
777 int ok = 0;
778
779 if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
780 || !TEST_ptr(pkey = load_example_rsa_key())
781 || !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
782 NULL, 0, NULL, NULL),
783 0)
784 || !TEST_ptr((membuf_len = (size_t)BIO_get_mem_data(membio, &membuf),
785 membuf))
786 || !TEST_mem_eq(membuf, membuf_len,
787 kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8))
788 /*
789 * We try to write PEM as well, just to see that it doesn't err, but
790 * assume that the result is correct.
791 */
792 || !TEST_int_gt(PEM_write_bio_PKCS8PrivateKey(membio, pkey, NULL,
793 NULL, 0, NULL, NULL),
794 0))
795 goto done;
796
797 ok = 1;
798 done:
799 EVP_PKEY_free(pkey);
800 BIO_free_all(membio);
801 return ok;
802}
803
f844f9eb 804#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
ddb634fe 805
a6c4cb84
JL		 806static int test_EVP_SM2_verify(void)
807{
808 /* From https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02#appendix-A */
809 const char *pubkey =
810 "-----BEGIN PUBLIC KEY-----\n"
811 "MIIBMzCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEAhULWnkwETxjouSQ1\n"
812 "v2/33kVyg5FcRVF9ci7biwjx38MwRAQgeHlotPoyw/0kF4Quc7v+/y88hItoMdfg\n"
813 "7GUiizk35JgEIGPkxtOyOwyEnPhCQUhL/kj2HVmlsWugbm4S0donxSSaBEEEQh3r\n"
814 "1hti6rZ0ZDTrw8wxXjIiCzut1QvcTE5sFH/t1D0GgFEry7QsB9RzSdIVO3DE5df9\n"
815 "/L+jbqGoWEG55G4JogIhAIVC1p5MBE8Y6LkkNb9v990pdyBjBIVijVrnTufDLnm3\n"
816 "AgEBA0IABArkx3mKoPEZRxvuEYJb5GICu3nipYRElel8BP9N8lSKfAJA+I8c1OFj\n"
817 "Uqc8F7fxbwc1PlOhdtaEqf4Ma7eY6Fc=\n"
818 "-----END PUBLIC KEY-----\n";
819
820 const char *msg = "message digest";
821 const char *id = "ALICE123@YAHOO.COM";
822
823 const uint8_t signature[] = {
824 0x30, 0x44, 0x02, 0x20,
825
826 0x40, 0xF1, 0xEC, 0x59, 0xF7, 0x93, 0xD9, 0xF4, 0x9E, 0x09, 0xDC,
827 0xEF, 0x49, 0x13, 0x0D, 0x41, 0x94, 0xF7, 0x9F, 0xB1, 0xEE, 0xD2,
828 0xCA, 0xA5, 0x5B, 0xAC, 0xDB, 0x49, 0xC4, 0xE7, 0x55, 0xD1,
829
830 0x02, 0x20,
831
832 0x6F, 0xC6, 0xDA, 0xC3, 0x2C, 0x5D, 0x5C, 0xF1, 0x0C, 0x77, 0xDF,
833 0xB2, 0x0F, 0x7C, 0x2E, 0xB6, 0x67, 0xA4, 0x57, 0x87, 0x2F, 0xB0,
834 0x9E, 0xC5, 0x63, 0x27, 0xA6, 0x7E, 0xC7, 0xDE, 0xEB, 0xE7
835 };
836
837 int rc = 0;
838 BIO *bio = NULL;
839 EVP_PKEY *pkey = NULL;
840 EVP_MD_CTX *mctx = NULL;
841 EVP_PKEY_CTX *pctx = NULL;
842
843 bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
844 if (!TEST_true(bio != NULL))
845 goto done;
846
847 pkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
848 if (!TEST_true(pkey != NULL))
849 goto done;
850
851 if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
852 goto done;
853
854 if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
855 goto done;
856
857 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new(pkey, NULL)))
858 goto done;
859
860 if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, (const uint8_t *)id,
861 strlen(id)), 0))
862 goto done;
863
864 EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
865
866 if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, EVP_sm3(), NULL, pkey)))
867 goto done;
868
869 if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
870 goto done;
871
872 if (!TEST_true(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature))))
873 goto done;
874 rc = 1;
875
876 done:
877 BIO_free(bio);
878 EVP_PKEY_free(pkey);
879 EVP_PKEY_CTX_free(pctx);
880 EVP_MD_CTX_free(mctx);
881 return rc;
882}
883
ddb634fe
JL		 884static int test_EVP_SM2(void)
885{
886 int ret = 0;
887 EVP_PKEY *pkey = NULL;
888 EVP_PKEY *params = NULL;
889 EVP_PKEY_CTX *pctx = NULL;
890 EVP_PKEY_CTX *kctx = NULL;
4803717f 891 EVP_PKEY_CTX *sctx = NULL;
ddb634fe
JL		 892 size_t sig_len = 0;
893 unsigned char *sig = NULL;
894 EVP_MD_CTX *md_ctx = NULL;
895 EVP_MD_CTX *md_ctx_verify = NULL;
896 EVP_PKEY_CTX *cctx = NULL;
897
898 uint8_t ciphertext[128];
899 size_t ctext_len = sizeof(ciphertext);
900
901 uint8_t plaintext[8];
902 size_t ptext_len = sizeof(plaintext);
903
4803717f
PY		 904 uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
905
ddb634fe
JL		 906 pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
907 if (!TEST_ptr(pctx))
908 goto done;
909
910 if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
911 goto done;
912
913 if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
914 goto done;
915
916 if (!TEST_true(EVP_PKEY_paramgen(pctx, &params)))
917 goto done;
918
919 kctx = EVP_PKEY_CTX_new(params, NULL);
920 if (!TEST_ptr(kctx))
921 goto done;
922
923 if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
924 goto done;
925
926 if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
927 goto done;
928
929 if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
930 goto done;
931
932 if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
933 goto done;
934
935 if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
936 goto done;
937
4803717f
PY		 938 if (!TEST_ptr(sctx = EVP_PKEY_CTX_new(pkey, NULL)))
939 goto done;
940
941 EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
942 EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
943
944 if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
945 goto done;
946
ddb634fe
JL		 947 if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
948 goto done;
949
950 if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
951 goto done;
952
953 /* Determine the size of the signature. */
954 if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
955 goto done;
956
ddb634fe
JL		 957 if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
958 goto done;
959
960 if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
961 goto done;
962
963 /* Ensure that the signature round-trips. */
964
965 if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
966 goto done;
967
968 if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
969 goto done;
970
971 if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
972 goto done;
973
974 /* now check encryption/decryption */
975
976 if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
977 goto done;
978
979 if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
980 goto done;
981
982 if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
983 goto done;
984
985 if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
986 goto done;
987
988 if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
989 goto done;
990
991 if (!TEST_true(ptext_len == sizeof(kMsg)))
992 goto done;
993
994 if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
995 goto done;
996
997 ret = 1;
998done:
999 EVP_PKEY_CTX_free(pctx);
1000 EVP_PKEY_CTX_free(kctx);
4803717f 1001 EVP_PKEY_CTX_free(sctx);
ddb634fe
JL		 1002 EVP_PKEY_CTX_free(cctx);
1003 EVP_PKEY_free(pkey);
1004 EVP_PKEY_free(params);
1005 EVP_MD_CTX_free(md_ctx);
1006 EVP_MD_CTX_free(md_ctx_verify);
1007 OPENSSL_free(sig);
1008 return ret;
1009}
1010
1011#endif
1012
bb5f281a
MC		 1013static struct keys_st {
1014 int type;
1015 char *priv;
1016 char *pub;
1017} keys[] = {
1018 {
1019 EVP_PKEY_HMAC, "0123456789", NULL
1020 }, {
1021 EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
1022 }, {
1023 EVP_PKEY_SIPHASH, "0123456789012345", NULL
896dcb80
MC		 1024 },
1025#ifndef OPENSSL_NO_EC
1026 {
bb5f281a
MC		 1027 EVP_PKEY_X25519, "01234567890123456789012345678901",
1028 "abcdefghijklmnopqrstuvwxyzabcdef"
1029 }, {
1030 EVP_PKEY_ED25519, "01234567890123456789012345678901",
1031 "abcdefghijklmnopqrstuvwxyzabcdef"
1032 }, {
1033 EVP_PKEY_X448,
1034 "01234567890123456789012345678901234567890123456789012345",
1035 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
1036 }, {
1037 EVP_PKEY_ED448,
1038 "012345678901234567890123456789012345678901234567890123456",
1039 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
1040 }
896dcb80 1041#endif
bb5f281a
MC		 1042};
1043
86dc26ba 1044static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
bb5f281a
MC		 1045{
1046 int ret = 0;
1047 unsigned char buf[80];
1048 unsigned char *in;
1049 size_t inlen, len = 0;
1050 EVP_PKEY *pkey;
1051
1052 /* Check if this algorithm supports public keys */
1053 if (keys[tst].pub == NULL)
1054 return 1;
1055
1056 memset(buf, 0, sizeof(buf));
1057
1058 if (pub) {
1059 inlen = strlen(keys[tst].pub);
1060 in = (unsigned char *)keys[tst].pub;
86dc26ba
MC		 1061 if (uselibctx) {
1062 pkey = EVP_PKEY_new_raw_public_key_with_libctx(
1063 testctx,
1064 OBJ_nid2sn(keys[tst].type),
1065 NULL,
1066 in,
1067 inlen);
1068 } else {
1069 pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
1070 NULL,
1071 in,
1072 inlen);
1073 }
bb5f281a
MC		 1074 } else {
1075 inlen = strlen(keys[tst].priv);
1076 in = (unsigned char *)keys[tst].priv;
86dc26ba
MC		 1077 if (uselibctx) {
1078 pkey = EVP_PKEY_new_raw_private_key_with_libctx(
1079 testctx, OBJ_nid2sn(keys[tst].type),
1080 NULL,
1081 in,
1082 inlen);
1083 } else {
1084 pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
1085 NULL,
1086 in,
1087 inlen);
1088 }
bb5f281a
MC		 1089 }
1090
1091 if (!TEST_ptr(pkey)
1092 || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
1093 || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
1094 || !TEST_true(len == inlen)
1095 || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
1096 || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
1097 || !TEST_mem_eq(in, inlen, buf, len))
1098 goto done;
1099
1100 ret = 1;
1101 done:
1102 EVP_PKEY_free(pkey);
1103 return ret;
1104}
1105
1106static int test_set_get_raw_keys(int tst)
1107{
86dc26ba
MC		 1108 return test_set_get_raw_keys_int(tst, 0, 0)
1109 && test_set_get_raw_keys_int(tst, 0, 1)
1110 && test_set_get_raw_keys_int(tst, 1, 0)
1111 && test_set_get_raw_keys_int(tst, 1, 1);
bb5f281a
MC		 1112}
1113
2aee35d3
PY		 1114static int pkey_custom_check(EVP_PKEY *pkey)
1115{
1116 return 0xbeef;
1117}
1118
b0004708
PY		 1119static int pkey_custom_pub_check(EVP_PKEY *pkey)
1120{
1121 return 0xbeef;
1122}
1123
1124static int pkey_custom_param_check(EVP_PKEY *pkey)
1125{
1126 return 0xbeef;
1127}
1128
2aee35d3
PY		 1129static EVP_PKEY_METHOD *custom_pmeth;
1130
1131static int test_EVP_PKEY_check(int i)
1132{
1133 int ret = 0;
1134 const unsigned char *p;
1135 EVP_PKEY *pkey = NULL;
8a8bc665 1136#ifndef OPENSSL_NO_EC
b0004708 1137 EC_KEY *eckey = NULL;
8a8bc665 1138#endif
2aee35d3
PY		 1139 EVP_PKEY_CTX *ctx = NULL;
1140 EVP_PKEY_CTX *ctx2 = NULL;
1141 const APK_DATA *ak = &keycheckdata[i];
1142 const unsigned char *input = ak->kder;
1143 size_t input_len = ak->size;
1144 int expected_id = ak->evptype;
1145 int expected_check = ak->check;
b0004708
PY		 1146 int expected_pub_check = ak->pub_check;
1147 int expected_param_check = ak->param_check;
1148 int type = ak->type;
1149 BIO *pubkey = NULL;
2aee35d3
PY		 1150
1151 p = input;
b0004708 1152
35db366c
DMSP		 1153 switch (type) {
1154 case 0:
1155 if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
1156 || !TEST_ptr_eq(p, input + input_len)
1157 || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
1158 goto done;
1159 break;
8a8bc665 1160#ifndef OPENSSL_NO_EC
35db366c
DMSP		 1161 case 1:
1162 if (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
1163 || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
1164 || !TEST_ptr(pkey = EVP_PKEY_new())
1165 || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1166 goto done;
1167 break;
1168 case 2:
1169 if (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
1170 || !TEST_ptr_eq(p, input + input_len)
1171 || !TEST_ptr(pkey = EVP_PKEY_new())
1172 || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1173 goto done;
1174 break;
8a8bc665 1175#endif
35db366c
DMSP		 1176 default:
1177 return 0;
1178 }
2aee35d3
PY		 1179
1180 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
1181 goto done;
1182
b0004708
PY		 1183 if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
1184 goto done;
1185
1186 if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
1187 goto done;
1188
1189 if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
1190 goto done;
2aee35d3
PY		 1191
1192 ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
1193 /* assign the pkey directly, as an internal test */
1194 EVP_PKEY_up_ref(pkey);
1195 ctx2->pkey = pkey;
1196
1197 if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
1198 goto done;
1199
b0004708
PY		 1200 if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
1201 goto done;
1202
1203 if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
1204 goto done;
1205
2aee35d3
PY		 1206 ret = 1;
1207
1208 done:
1209 EVP_PKEY_CTX_free(ctx);
1210 EVP_PKEY_CTX_free(ctx2);
1211 EVP_PKEY_free(pkey);
b0004708 1212 BIO_free(pubkey);
2aee35d3
PY		 1213 return ret;
1214}
1215
fab8fde3 1216#ifndef OPENSSL_NO_CMAC
a87820e1
RL		 1217static int test_CMAC_keygen(void)
1218{
1219 /*
1220 * This is a legacy method for CMACs, but should still work.
1221 * This verifies that it works without an ENGINE.
1222 */
1223 EVP_PKEY_CTX *kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_CMAC, NULL);
1224 int ret = 0;
1225
1226 if (!TEST_true(EVP_PKEY_keygen_init(kctx) > 0)
1227 && !TEST_true(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
1228 EVP_PKEY_CTRL_CIPHER,
1229 0, (void *)EVP_aes_256_ecb()) > 0))
1230 goto done;
1231 ret = 1;
1232
1233 done:
1234 EVP_PKEY_CTX_free(kctx);
1235 return ret;
1236}
fab8fde3 1237#endif
a87820e1 1238
10d5b415
MC		 1239static int test_HKDF(void)
1240{
1241 EVP_PKEY_CTX *pctx;
1242 unsigned char out[20];
1243 size_t outlen;
1244 int i, ret = 0;
1245 unsigned char salt[] = "0123456789";
1246 unsigned char key[] = "012345678901234567890123456789";
1247 unsigned char info[] = "infostring";
1248 const unsigned char expected[] = {
1249 0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
1250 0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
1251 };
1252 size_t expectedlen = sizeof(expected);
1253
1254 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1255 goto done;
1256
1257 /* We do this twice to test reuse of the EVP_PKEY_CTX */
1258 for (i = 0; i < 2; i++) {
1259 outlen = sizeof(out);
1260 memset(out, 0, outlen);
1261
1262 if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1263 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1264 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1265 sizeof(salt) - 1), 0)
1266 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1267 sizeof(key) - 1), 0)
1268 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1269 sizeof(info) - 1), 0)
1270 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1271 || !TEST_mem_eq(out, outlen, expected, expectedlen))
1272 goto done;
1273 }
1274
1275 ret = 1;
1276
1277 done:
1278 EVP_PKEY_CTX_free(pctx);
1279
1280 return ret;
1281}
1282
2cd3ebc7
BK		 1283static int test_emptyikm_HKDF(void)
1284{
1285 EVP_PKEY_CTX *pctx;
1286 unsigned char out[20];
1287 size_t outlen;
1288 int ret = 0;
1289 unsigned char salt[] = "9876543210";
1290 unsigned char key[] = "";
1291 unsigned char info[] = "stringinfo";
1292 const unsigned char expected[] = {
1293 0x68, 0x81, 0xa5, 0x3e, 0x5b, 0x9c, 0x7b, 0x6f, 0x2e, 0xec, 0xc8, 0x47,
1294 0x7c, 0xfa, 0x47, 0x35, 0x66, 0x82, 0x15, 0x30
1295 };
1296 size_t expectedlen = sizeof(expected);
1297
1298 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1299 goto done;
1300
1301 outlen = sizeof(out);
1302 memset(out, 0, outlen);
1303
1304 if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1305 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1306 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1307 sizeof(salt) - 1), 0)
1308 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1309 sizeof(key) - 1), 0)
1310 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1311 sizeof(info) - 1), 0)
1312 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1313 || !TEST_mem_eq(out, outlen, expected, expectedlen))
1314 goto done;
1315
1316 ret = 1;
1317
1318 done:
1319 EVP_PKEY_CTX_free(pctx);
1320
1321 return ret;
1322}
1323
5dc40a83
BE		 1324#ifndef OPENSSL_NO_EC
1325static int test_X509_PUBKEY_inplace(void)
1326{
1327 int ret = 0;
1328 X509_PUBKEY *xp = NULL;
1329 const unsigned char *p = kExampleECPubKeyDER;
1330 size_t input_len = sizeof(kExampleECPubKeyDER);
1331
1332 if (!TEST_ptr(xp = d2i_X509_PUBKEY(NULL, &p, input_len)))
1333 goto done;
1334
1335 if (!TEST_ptr(X509_PUBKEY_get0(xp)))
1336 goto done;
1337
1338 p = kExampleBadECPubKeyDER;
1339 input_len = sizeof(kExampleBadECPubKeyDER);
1340
1341 if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
1342 goto done;
1343
1344 if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
1345 goto done;
1346
1347 ret = 1;
1348
1349done:
1350 X509_PUBKEY_free(xp);
1351 return ret;
1352}
7bb82f92 1353#endif /* OPENSSL_NO_EC */
784883fc 1354
9c45222d 1355/* Test getting and setting parameters on an EVP_PKEY_CTX */
f54a4101 1356static int test_EVP_PKEY_CTX_get_set_params(EVP_PKEY *pkey)
9c45222d 1357{
9a071fef 1358 EVP_MD_CTX *mdctx = NULL;
9c45222d 1359 EVP_PKEY_CTX *ctx = NULL;
9c45222d 1360 const OSSL_PARAM *params;
00bc1ad9 1361 OSSL_PARAM ourparams[2], *param = ourparams, *param_md;
9c45222d
MC		 1362 int ret = 0;
1363 const EVP_MD *md;
00bc1ad9 1364 char mdname[OSSL_MAX_NAME_SIZE];
9a071fef 1365 char ssl3ms[48];
9c45222d 1366
9c45222d
MC		 1367 /* Initialise a sign operation */
1368 ctx = EVP_PKEY_CTX_new(pkey, NULL);
9c45222d 1369 if (!TEST_ptr(ctx)
c9c4a356 1370 || !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0))
9c45222d
MC		 1371 goto err;
1372
1373 /*
f54a4101 1374 * We should be able to query the parameters now.
9c45222d
MC		 1375 */
1376 params = EVP_PKEY_CTX_settable_params(ctx);
1377 if (!TEST_ptr(params)
0cb3f4f9
RL		 1378 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1379 OSSL_SIGNATURE_PARAM_DIGEST)))
9c45222d
MC		 1380 goto err;
1381
9c45222d
MC		 1382 params = EVP_PKEY_CTX_gettable_params(ctx);
1383 if (!TEST_ptr(params)
0cb3f4f9
RL		 1384 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1385 OSSL_SIGNATURE_PARAM_ALGORITHM_ID))
0cb3f4f9
RL		 1386 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1387 OSSL_SIGNATURE_PARAM_DIGEST)))
9c45222d
MC		 1388 goto err;
1389
1390 /*
1391 * Test getting and setting params via EVP_PKEY_CTX_set_params() and
1392 * EVP_PKEY_CTX_get_params()
1393 */
00bc1ad9
RL		 1394 strcpy(mdname, "SHA512");
1395 param_md = param;
1396 *param++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1397 mdname, 0);
9c45222d
MC		 1398 *param++ = OSSL_PARAM_construct_end();
1399
1400 if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams)))
1401 goto err;
1402
00bc1ad9
RL		 1403 mdname[0] = '\0';
1404 *param_md = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1405 mdname, sizeof(mdname));
9c45222d 1406 if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams))
00bc1ad9 1407 || !TEST_str_eq(mdname, "SHA512"))
9c45222d
MC		 1408 goto err;
1409
1410 /*
1411 * Test the TEST_PKEY_CTX_set_signature_md() and
1412 * TEST_PKEY_CTX_get_signature_md() functions
1413 */
1414 if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0)
1415 || !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0)
1416 || !TEST_ptr_eq(md, EVP_sha256()))
1417 goto err;
1418
9a071fef
MC		 1419 /*
1420 * Test getting MD parameters via an associated EVP_PKEY_CTX
1421 */
1422 mdctx = EVP_MD_CTX_new();
1423 if (!TEST_ptr(mdctx)
a45694a3
MC		 1424 || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", NULL, pkey,
1425 NULL)))
9a071fef
MC		 1426 goto err;
1427
1428 /*
1429 * We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be
1430 * able to obtain the digest's settable parameters from the provider.
1431 */
1432 params = EVP_MD_CTX_settable_params(mdctx);
1433 if (!TEST_ptr(params)
1434 || !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0)
1435 /* The final key should be NULL */
1436 || !TEST_ptr_null(params[1].key))
1437 goto err;
1438
1439 param = ourparams;
1440 memset(ssl3ms, 0, sizeof(ssl3ms));
1441 *param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
1442 ssl3ms, sizeof(ssl3ms));
1443 *param++ = OSSL_PARAM_construct_end();
1444
1445 if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams)))
1446 goto err;
1447
9c45222d
MC		 1448 ret = 1;
1449
1450 err:
9a071fef 1451 EVP_MD_CTX_free(mdctx);
9c45222d 1452 EVP_PKEY_CTX_free(ctx);
f54a4101
RL		 1453
1454 return ret;
1455}
1456
1457#ifndef OPENSSL_NO_DSA
1458static int test_DSA_get_set_params(void)
1459{
1460 DSA *dsa = NULL;
1461 BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub = NULL, *priv = NULL;
1462 EVP_PKEY *pkey = NULL;
1463 int ret = 0;
1464
1465 /*
1466 * Setup the parameters for our DSA object. For our purposes they don't
1467 * have to actually be *valid* parameters. We just need to set something.
1468 */
1469 dsa = DSA_new();
1470 p = BN_new();
1471 q = BN_new();
1472 g = BN_new();
1473 pub = BN_new();
1474 priv = BN_new();
1475 if (!TEST_ptr(dsa)
1476 || !TEST_ptr(p)
1477 || !TEST_ptr(q)
1478 || !TEST_ptr(g)
1479 || !TEST_ptr(pub)
1480 || !DSA_set0_pqg(dsa, p, q, g)
1481 || !DSA_set0_key(dsa, pub, priv))
1482 goto err;
1483 p = q = g = pub = priv = NULL;
1484
1485 pkey = EVP_PKEY_new();
1486 if (!TEST_ptr(pkey)
1487 || !TEST_true(EVP_PKEY_assign_DSA(pkey, dsa)))
1488 goto err;
1489
1490 dsa = NULL;
1491
1492 ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1493
1494 err:
9c45222d
MC		 1495 EVP_PKEY_free(pkey);
1496 DSA_free(dsa);
1497 BN_free(p);
1498 BN_free(q);
1499 BN_free(g);
cd32a0f5
RL		 1500 BN_free(pub);
1501 BN_free(priv);
9c45222d
MC		 1502
1503 return ret;
1504}
8d0f8c81 1505#endif
9c45222d 1506
f54a4101
RL		 1507static int test_RSA_get_set_params(void)
1508{
1509 RSA *rsa = NULL;
1510 BIGNUM *n = NULL, *e = NULL, *d = NULL;
1511 EVP_PKEY *pkey = NULL;
1512 int ret = 0;
1513
1514 /*
1515 * Setup the parameters for our RSA object. For our purposes they don't
1516 * have to actually be *valid* parameters. We just need to set something.
1517 */
1518 rsa = RSA_new();
1519 n = BN_new();
1520 e = BN_new();
1521 d = BN_new();
1522 if (!TEST_ptr(rsa)
1523 || !TEST_ptr(n)
1524 || !TEST_ptr(e)
1525 || !TEST_ptr(d)
1526 || !RSA_set0_key(rsa, n, e, d))
1527 goto err;
1528 n = e = d = NULL;
1529
1530 pkey = EVP_PKEY_new();
1531 if (!TEST_ptr(pkey)
1532 || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa)))
1533 goto err;
1534
1535 rsa = NULL;
1536
1537 ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1538
1539 err:
1540 EVP_PKEY_free(pkey);
1541 RSA_free(rsa);
1542 BN_free(n);
1543 BN_free(e);
1544 BN_free(d);
1545
1546 return ret;
1547}
1548
b4be6937
MC		 1549#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1550static int test_decrypt_null_chunks(void)
1551{
1552 EVP_CIPHER_CTX* ctx = NULL;
1553 const unsigned char key[32] = {
1554 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1555 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1556 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1
1557 };
1558 unsigned char iv[12] = {
1559 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
1560 };
1561 unsigned char msg[] = "It was the best of times, it was the worst of times";
1562 unsigned char ciphertext[80];
1563 unsigned char plaintext[80];
1564 /* We initialise tmp to a non zero value on purpose */
1565 int ctlen, ptlen, tmp = 99;
1566 int ret = 0;
1567 const int enc_offset = 10, dec_offset = 20;
1568
1569 if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
1570 || !TEST_true(EVP_EncryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL,
1571 key, iv))
1572 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &ctlen, msg,
1573 enc_offset))
1574 /* Deliberate add a zero length update */
1575 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp, NULL,
1576 0))
1577 || !TEST_int_eq(tmp, 0)
1578 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp,
1579 msg + enc_offset,
1580 sizeof(msg) - enc_offset))
1581 || !TEST_int_eq(ctlen += tmp, sizeof(msg))
1582 || !TEST_true(EVP_EncryptFinal(ctx, ciphertext + ctlen, &tmp))
1583 || !TEST_int_eq(tmp, 0))
1584 goto err;
1585
1586 /* Deliberately initialise tmp to a non zero value */
1587 tmp = 99;
1588 if (!TEST_true(EVP_DecryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL, key,
1589 iv))
1590 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext, &ptlen, ciphertext,
1591 dec_offset))
1592 /*
1593 * Deliberately add a zero length update. We also deliberately do
1594 * this at a different offset than for encryption.
1595 */
1596 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp, NULL,
1597 0))
1598 || !TEST_int_eq(tmp, 0)
1599 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp,
1600 ciphertext + dec_offset,
1601 ctlen - dec_offset))
1602 || !TEST_int_eq(ptlen += tmp, sizeof(msg))
1603 || !TEST_true(EVP_DecryptFinal(ctx, plaintext + ptlen, &tmp))
1604 || !TEST_int_eq(tmp, 0)
1605 || !TEST_mem_eq(msg, sizeof(msg), plaintext, ptlen))
1606 goto err;
1607
1608 ret = 1;
1609 err:
1610 EVP_CIPHER_CTX_free(ctx);
1611 return ret;
1612}
1613#endif /* !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) */
1614
501fcfb8 1615#ifndef OPENSSL_NO_DH
e295de1d
MC		 1616static int test_EVP_PKEY_set1_DH(void)
1617{
ca2bf555
SL		 1618 DH *x942dh = NULL, *noqdh = NULL;
1619 EVP_PKEY *pkey1 = NULL, *pkey2 = NULL;
e295de1d 1620 int ret = 0;
ca2bf555
SL		 1621 BIGNUM *p, *g = NULL;
1622
1623 if (!TEST_ptr(p = BN_new())
1624 || !TEST_ptr(g = BN_new())
1625 || !BN_set_word(p, 9999)
1626 || !BN_set_word(g, 2)
1627 || !TEST_ptr(noqdh = DH_new())
1628 || !DH_set0_pqg(noqdh, p, NULL, g))
1629 goto err;
1630 p = g = NULL;
e295de1d
MC		 1631
1632 x942dh = DH_get_2048_256();
e295de1d
MC		 1633 pkey1 = EVP_PKEY_new();
1634 pkey2 = EVP_PKEY_new();
1635 if (!TEST_ptr(x942dh)
ca2bf555 1636 || !TEST_ptr(noqdh)
e295de1d
MC		 1637 || !TEST_ptr(pkey1)
1638 || !TEST_ptr(pkey2))
1639 goto err;
1640
1641 if(!TEST_true(EVP_PKEY_set1_DH(pkey1, x942dh))
1642 || !TEST_int_eq(EVP_PKEY_id(pkey1), EVP_PKEY_DHX))
1643 goto err;
1644
ca2bf555 1645 if(!TEST_true(EVP_PKEY_set1_DH(pkey2, noqdh))
e295de1d
MC		 1646 || !TEST_int_eq(EVP_PKEY_id(pkey2), EVP_PKEY_DH))
1647 goto err;
1648
1649 ret = 1;
1650 err:
ca2bf555
SL		 1651 BN_free(p);
1652 BN_free(g);
e295de1d
MC		 1653 EVP_PKEY_free(pkey1);
1654 EVP_PKEY_free(pkey2);
1655 DH_free(x942dh);
ca2bf555 1656 DH_free(noqdh);
e295de1d
MC		 1657
1658 return ret;
1659}
501fcfb8 1660#endif
e295de1d 1661
8a5cb596
RL		 1662/*
1663 * We test what happens with an empty template. For the sake of this test,
1664 * the template must be ignored, and we know that's the case for RSA keys
1665 * (this might arguably be a misfeature, but that's what we currently do,
1666 * even in provider code, since that's how the legacy RSA implementation
1667 * does things)
1668 */
1669static int test_keygen_with_empty_template(int n)
1670{
1671 EVP_PKEY_CTX *ctx = NULL;
1672 EVP_PKEY *pkey = NULL;
1673 EVP_PKEY *tkey = NULL;
1674 int ret = 0;
1675
1676 switch (n) {
1677 case 0:
1678 /* We do test with no template at all as well */
1679 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
1680 goto err;
1681 break;
1682 case 1:
1683 /* Here we create an empty RSA key that serves as our template */
1684 if (!TEST_ptr(tkey = EVP_PKEY_new())
1685 || !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
1686 || !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
1687 goto err;
1688 break;
1689 }
1690
1691 if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1692 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
1693 goto err;
1694
1695 ret = 1;
1696 err:
1697 EVP_PKEY_CTX_free(ctx);
1698 EVP_PKEY_free(pkey);
1699 EVP_PKEY_free(tkey);
1700 return ret;
1701}
1702
5ddec6a7
MC		 1703/*
1704 * Test that we fail if we attempt to use an algorithm that is not available
1705 * in the current library context (unless we are using an algorithm that should
1706 * be made available via legacy codepaths).
1707 */
1708static int test_pkey_ctx_fail_without_provider(int tst)
1709{
1710 OPENSSL_CTX *tmpctx = OPENSSL_CTX_new();
1711 OSSL_PROVIDER *nullprov = NULL;
1712 EVP_PKEY_CTX *pctx = NULL;
1713 int ret = 0;
1714
1715 if (!TEST_ptr(tmpctx))
1716 goto err;
1717
1718 nullprov = OSSL_PROVIDER_load(tmpctx, "null");
1719 if (!TEST_ptr(nullprov))
1720 goto err;
1721
1722 pctx = EVP_PKEY_CTX_new_from_name(tmpctx, tst == 0 ? "RSA" : "HMAC", "");
1723
1724 /* RSA is not available via any provider so we expect this to fail */
1725 if (tst == 0 && !TEST_ptr_null(pctx))
1726 goto err;
1727
1728 /*
1729 * HMAC is always available because it is implemented via legacy codepaths
1730 * and not in a provider at all. We expect this to pass.
1731 */
1732 if (tst == 1 && !TEST_ptr(pctx))
1733 goto err;
1734
1735 ret = 1;
1736
1737 err:
1738 EVP_PKEY_CTX_free(pctx);
1739 OSSL_PROVIDER_unload(nullprov);
1740 OPENSSL_CTX_free(tmpctx);
1741 return ret;
1742}
1743
ad887416 1744int setup_tests(void)
71ea6b48 1745{
86dc26ba
MC		 1746 testctx = OPENSSL_CTX_new();
1747
1748 if (!TEST_ptr(testctx))
1749 return 0;
1750
6d242fa5 1751 ADD_ALL_TESTS(test_EVP_DigestSignInit, 9);
adcd8e37 1752 ADD_TEST(test_EVP_DigestVerifyInit);
2eb2b4f3 1753 ADD_TEST(test_EVP_Enveloped);
ad887416 1754 ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
29c49b25 1755 ADD_TEST(test_privatekey_to_pkcs8);
a9880362 1756#ifndef OPENSSL_NO_EC
adcd8e37 1757 ADD_TEST(test_EVP_PKCS82PKEY);
ddb634fe 1758#endif
f844f9eb 1759#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
ddb634fe 1760 ADD_TEST(test_EVP_SM2);
a6c4cb84 1761 ADD_TEST(test_EVP_SM2_verify);
a9880362 1762#endif
bb5f281a 1763 ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
2aee35d3
PY		 1764 custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
1765 if (!TEST_ptr(custom_pmeth))
1766 return 0;
1767 EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
b0004708
PY		 1768 EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
1769 EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
2aee35d3
PY		 1770 if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
1771 return 0;
1772 ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
fab8fde3 1773#ifndef OPENSSL_NO_CMAC
a87820e1 1774 ADD_TEST(test_CMAC_keygen);
fab8fde3 1775#endif
10d5b415 1776 ADD_TEST(test_HKDF);
2cd3ebc7 1777 ADD_TEST(test_emptyikm_HKDF);
5dc40a83
BE		 1778#ifndef OPENSSL_NO_EC
1779 ADD_TEST(test_X509_PUBKEY_inplace);
cad8347b
SL		 1780 ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
1781 OSSL_NELEM(ec_der_pub_keys));
5dc40a83 1782#endif
8d0f8c81 1783#ifndef OPENSSL_NO_DSA
f54a4101 1784 ADD_TEST(test_DSA_get_set_params);
b4be6937 1785#endif
f54a4101 1786 ADD_TEST(test_RSA_get_set_params);
b4be6937
MC		 1787#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1788 ADD_TEST(test_decrypt_null_chunks);
8d0f8c81 1789#endif
501fcfb8 1790#ifndef OPENSSL_NO_DH
e295de1d 1791 ADD_TEST(test_EVP_PKEY_set1_DH);
501fcfb8 1792#endif
8a5cb596 1793 ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
5ddec6a7 1794 ADD_ALL_TESTS(test_pkey_ctx_fail_without_provider, 2);
e295de1d 1795
ad887416 1796 return 1;
71ea6b48 1797}
86dc26ba
MC		 1798
1799void cleanup_tests(void)
1800{
1801 OPENSSL_CTX_free(testctx);
1802}
A mirror of the official openssl repository