]> 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
EVP: Only use the engine when one is defined, in pkey_mac_ctrl()
[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
f844f9eb 770#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
ddb634fe 771
a6c4cb84
JL		 772static int test_EVP_SM2_verify(void)
773{
774 /* From https://tools.ietf.org/html/draft-shen-sm2-ecdsa-02#appendix-A */
775 const char *pubkey =
776 "-----BEGIN PUBLIC KEY-----\n"
777 "MIIBMzCB7AYHKoZIzj0CATCB4AIBATAsBgcqhkjOPQEBAiEAhULWnkwETxjouSQ1\n"
778 "v2/33kVyg5FcRVF9ci7biwjx38MwRAQgeHlotPoyw/0kF4Quc7v+/y88hItoMdfg\n"
779 "7GUiizk35JgEIGPkxtOyOwyEnPhCQUhL/kj2HVmlsWugbm4S0donxSSaBEEEQh3r\n"
780 "1hti6rZ0ZDTrw8wxXjIiCzut1QvcTE5sFH/t1D0GgFEry7QsB9RzSdIVO3DE5df9\n"
781 "/L+jbqGoWEG55G4JogIhAIVC1p5MBE8Y6LkkNb9v990pdyBjBIVijVrnTufDLnm3\n"
782 "AgEBA0IABArkx3mKoPEZRxvuEYJb5GICu3nipYRElel8BP9N8lSKfAJA+I8c1OFj\n"
783 "Uqc8F7fxbwc1PlOhdtaEqf4Ma7eY6Fc=\n"
784 "-----END PUBLIC KEY-----\n";
785
786 const char *msg = "message digest";
787 const char *id = "ALICE123@YAHOO.COM";
788
789 const uint8_t signature[] = {
790 0x30, 0x44, 0x02, 0x20,
791
792 0x40, 0xF1, 0xEC, 0x59, 0xF7, 0x93, 0xD9, 0xF4, 0x9E, 0x09, 0xDC,
793 0xEF, 0x49, 0x13, 0x0D, 0x41, 0x94, 0xF7, 0x9F, 0xB1, 0xEE, 0xD2,
794 0xCA, 0xA5, 0x5B, 0xAC, 0xDB, 0x49, 0xC4, 0xE7, 0x55, 0xD1,
795
796 0x02, 0x20,
797
798 0x6F, 0xC6, 0xDA, 0xC3, 0x2C, 0x5D, 0x5C, 0xF1, 0x0C, 0x77, 0xDF,
799 0xB2, 0x0F, 0x7C, 0x2E, 0xB6, 0x67, 0xA4, 0x57, 0x87, 0x2F, 0xB0,
800 0x9E, 0xC5, 0x63, 0x27, 0xA6, 0x7E, 0xC7, 0xDE, 0xEB, 0xE7
801 };
802
803 int rc = 0;
804 BIO *bio = NULL;
805 EVP_PKEY *pkey = NULL;
806 EVP_MD_CTX *mctx = NULL;
807 EVP_PKEY_CTX *pctx = NULL;
808
809 bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
810 if (!TEST_true(bio != NULL))
811 goto done;
812
813 pkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
814 if (!TEST_true(pkey != NULL))
815 goto done;
816
817 if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
818 goto done;
819
820 if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
821 goto done;
822
823 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new(pkey, NULL)))
824 goto done;
825
826 if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, (const uint8_t *)id,
827 strlen(id)), 0))
828 goto done;
829
830 EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
831
832 if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, EVP_sm3(), NULL, pkey)))
833 goto done;
834
835 if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
836 goto done;
837
838 if (!TEST_true(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature))))
839 goto done;
840 rc = 1;
841
842 done:
843 BIO_free(bio);
844 EVP_PKEY_free(pkey);
845 EVP_PKEY_CTX_free(pctx);
846 EVP_MD_CTX_free(mctx);
847 return rc;
848}
849
ddb634fe
JL		 850static int test_EVP_SM2(void)
851{
852 int ret = 0;
853 EVP_PKEY *pkey = NULL;
854 EVP_PKEY *params = NULL;
855 EVP_PKEY_CTX *pctx = NULL;
856 EVP_PKEY_CTX *kctx = NULL;
4803717f 857 EVP_PKEY_CTX *sctx = NULL;
ddb634fe
JL		 858 size_t sig_len = 0;
859 unsigned char *sig = NULL;
860 EVP_MD_CTX *md_ctx = NULL;
861 EVP_MD_CTX *md_ctx_verify = NULL;
862 EVP_PKEY_CTX *cctx = NULL;
863
864 uint8_t ciphertext[128];
865 size_t ctext_len = sizeof(ciphertext);
866
867 uint8_t plaintext[8];
868 size_t ptext_len = sizeof(plaintext);
869
4803717f
PY		 870 uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
871
ddb634fe
JL		 872 pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
873 if (!TEST_ptr(pctx))
874 goto done;
875
876 if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
877 goto done;
878
879 if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
880 goto done;
881
882 if (!TEST_true(EVP_PKEY_paramgen(pctx, &params)))
883 goto done;
884
885 kctx = EVP_PKEY_CTX_new(params, NULL);
886 if (!TEST_ptr(kctx))
887 goto done;
888
889 if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
890 goto done;
891
892 if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
893 goto done;
894
895 if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
896 goto done;
897
898 if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
899 goto done;
900
901 if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
902 goto done;
903
4803717f
PY		 904 if (!TEST_ptr(sctx = EVP_PKEY_CTX_new(pkey, NULL)))
905 goto done;
906
907 EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
908 EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
909
910 if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
911 goto done;
912
ddb634fe
JL		 913 if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
914 goto done;
915
916 if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
917 goto done;
918
919 /* Determine the size of the signature. */
920 if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
921 goto done;
922
ddb634fe
JL		 923 if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
924 goto done;
925
926 if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
927 goto done;
928
929 /* Ensure that the signature round-trips. */
930
931 if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
932 goto done;
933
934 if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
935 goto done;
936
937 if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
938 goto done;
939
940 /* now check encryption/decryption */
941
942 if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
943 goto done;
944
945 if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
946 goto done;
947
948 if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
949 goto done;
950
951 if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
952 goto done;
953
954 if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
955 goto done;
956
957 if (!TEST_true(ptext_len == sizeof(kMsg)))
958 goto done;
959
960 if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
961 goto done;
962
963 ret = 1;
964done:
965 EVP_PKEY_CTX_free(pctx);
966 EVP_PKEY_CTX_free(kctx);
4803717f 967 EVP_PKEY_CTX_free(sctx);
ddb634fe
JL		 968 EVP_PKEY_CTX_free(cctx);
969 EVP_PKEY_free(pkey);
970 EVP_PKEY_free(params);
971 EVP_MD_CTX_free(md_ctx);
972 EVP_MD_CTX_free(md_ctx_verify);
973 OPENSSL_free(sig);
974 return ret;
975}
976
977#endif
978
bb5f281a
MC		 979static struct keys_st {
980 int type;
981 char *priv;
982 char *pub;
983} keys[] = {
984 {
985 EVP_PKEY_HMAC, "0123456789", NULL
986 }, {
987 EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
988 }, {
989 EVP_PKEY_SIPHASH, "0123456789012345", NULL
896dcb80
MC		 990 },
991#ifndef OPENSSL_NO_EC
992 {
bb5f281a
MC		 993 EVP_PKEY_X25519, "01234567890123456789012345678901",
994 "abcdefghijklmnopqrstuvwxyzabcdef"
995 }, {
996 EVP_PKEY_ED25519, "01234567890123456789012345678901",
997 "abcdefghijklmnopqrstuvwxyzabcdef"
998 }, {
999 EVP_PKEY_X448,
1000 "01234567890123456789012345678901234567890123456789012345",
1001 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
1002 }, {
1003 EVP_PKEY_ED448,
1004 "012345678901234567890123456789012345678901234567890123456",
1005 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
1006 }
896dcb80 1007#endif
bb5f281a
MC		 1008};
1009
86dc26ba 1010static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
bb5f281a
MC		 1011{
1012 int ret = 0;
1013 unsigned char buf[80];
1014 unsigned char *in;
1015 size_t inlen, len = 0;
1016 EVP_PKEY *pkey;
1017
1018 /* Check if this algorithm supports public keys */
1019 if (keys[tst].pub == NULL)
1020 return 1;
1021
1022 memset(buf, 0, sizeof(buf));
1023
1024 if (pub) {
1025 inlen = strlen(keys[tst].pub);
1026 in = (unsigned char *)keys[tst].pub;
86dc26ba
MC		 1027 if (uselibctx) {
1028 pkey = EVP_PKEY_new_raw_public_key_with_libctx(
1029 testctx,
1030 OBJ_nid2sn(keys[tst].type),
1031 NULL,
1032 in,
1033 inlen);
1034 } else {
1035 pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
1036 NULL,
1037 in,
1038 inlen);
1039 }
bb5f281a
MC		 1040 } else {
1041 inlen = strlen(keys[tst].priv);
1042 in = (unsigned char *)keys[tst].priv;
86dc26ba
MC		 1043 if (uselibctx) {
1044 pkey = EVP_PKEY_new_raw_private_key_with_libctx(
1045 testctx, OBJ_nid2sn(keys[tst].type),
1046 NULL,
1047 in,
1048 inlen);
1049 } else {
1050 pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
1051 NULL,
1052 in,
1053 inlen);
1054 }
bb5f281a
MC		 1055 }
1056
1057 if (!TEST_ptr(pkey)
1058 || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
1059 || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
1060 || !TEST_true(len == inlen)
1061 || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
1062 || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
1063 || !TEST_mem_eq(in, inlen, buf, len))
1064 goto done;
1065
1066 ret = 1;
1067 done:
1068 EVP_PKEY_free(pkey);
1069 return ret;
1070}
1071
1072static int test_set_get_raw_keys(int tst)
1073{
86dc26ba
MC		 1074 return test_set_get_raw_keys_int(tst, 0, 0)
1075 && test_set_get_raw_keys_int(tst, 0, 1)
1076 && test_set_get_raw_keys_int(tst, 1, 0)
1077 && test_set_get_raw_keys_int(tst, 1, 1);
bb5f281a
MC		 1078}
1079
2aee35d3
PY		 1080static int pkey_custom_check(EVP_PKEY *pkey)
1081{
1082 return 0xbeef;
1083}
1084
b0004708
PY		 1085static int pkey_custom_pub_check(EVP_PKEY *pkey)
1086{
1087 return 0xbeef;
1088}
1089
1090static int pkey_custom_param_check(EVP_PKEY *pkey)
1091{
1092 return 0xbeef;
1093}
1094
2aee35d3
PY		 1095static EVP_PKEY_METHOD *custom_pmeth;
1096
1097static int test_EVP_PKEY_check(int i)
1098{
1099 int ret = 0;
1100 const unsigned char *p;
1101 EVP_PKEY *pkey = NULL;
8a8bc665 1102#ifndef OPENSSL_NO_EC
b0004708 1103 EC_KEY *eckey = NULL;
8a8bc665 1104#endif
2aee35d3
PY		 1105 EVP_PKEY_CTX *ctx = NULL;
1106 EVP_PKEY_CTX *ctx2 = NULL;
1107 const APK_DATA *ak = &keycheckdata[i];
1108 const unsigned char *input = ak->kder;
1109 size_t input_len = ak->size;
1110 int expected_id = ak->evptype;
1111 int expected_check = ak->check;
b0004708
PY		 1112 int expected_pub_check = ak->pub_check;
1113 int expected_param_check = ak->param_check;
1114 int type = ak->type;
1115 BIO *pubkey = NULL;
2aee35d3
PY		 1116
1117 p = input;
b0004708 1118
35db366c
DMSP		 1119 switch (type) {
1120 case 0:
1121 if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
1122 || !TEST_ptr_eq(p, input + input_len)
1123 || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
1124 goto done;
1125 break;
8a8bc665 1126#ifndef OPENSSL_NO_EC
35db366c
DMSP		 1127 case 1:
1128 if (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
1129 || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
1130 || !TEST_ptr(pkey = EVP_PKEY_new())
1131 || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1132 goto done;
1133 break;
1134 case 2:
1135 if (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
1136 || !TEST_ptr_eq(p, input + input_len)
1137 || !TEST_ptr(pkey = EVP_PKEY_new())
1138 || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1139 goto done;
1140 break;
8a8bc665 1141#endif
35db366c
DMSP		 1142 default:
1143 return 0;
1144 }
2aee35d3
PY		 1145
1146 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
1147 goto done;
1148
b0004708
PY		 1149 if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
1150 goto done;
1151
1152 if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
1153 goto done;
1154
1155 if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
1156 goto done;
2aee35d3
PY		 1157
1158 ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
1159 /* assign the pkey directly, as an internal test */
1160 EVP_PKEY_up_ref(pkey);
1161 ctx2->pkey = pkey;
1162
1163 if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
1164 goto done;
1165
b0004708
PY		 1166 if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
1167 goto done;
1168
1169 if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
1170 goto done;
1171
2aee35d3
PY		 1172 ret = 1;
1173
1174 done:
1175 EVP_PKEY_CTX_free(ctx);
1176 EVP_PKEY_CTX_free(ctx2);
1177 EVP_PKEY_free(pkey);
b0004708 1178 BIO_free(pubkey);
2aee35d3
PY		 1179 return ret;
1180}
1181
10d5b415
MC		 1182static int test_HKDF(void)
1183{
1184 EVP_PKEY_CTX *pctx;
1185 unsigned char out[20];
1186 size_t outlen;
1187 int i, ret = 0;
1188 unsigned char salt[] = "0123456789";
1189 unsigned char key[] = "012345678901234567890123456789";
1190 unsigned char info[] = "infostring";
1191 const unsigned char expected[] = {
1192 0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
1193 0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
1194 };
1195 size_t expectedlen = sizeof(expected);
1196
1197 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1198 goto done;
1199
1200 /* We do this twice to test reuse of the EVP_PKEY_CTX */
1201 for (i = 0; i < 2; i++) {
1202 outlen = sizeof(out);
1203 memset(out, 0, outlen);
1204
1205 if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1206 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1207 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1208 sizeof(salt) - 1), 0)
1209 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1210 sizeof(key) - 1), 0)
1211 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1212 sizeof(info) - 1), 0)
1213 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1214 || !TEST_mem_eq(out, outlen, expected, expectedlen))
1215 goto done;
1216 }
1217
1218 ret = 1;
1219
1220 done:
1221 EVP_PKEY_CTX_free(pctx);
1222
1223 return ret;
1224}
1225
5dc40a83
BE		 1226#ifndef OPENSSL_NO_EC
1227static int test_X509_PUBKEY_inplace(void)
1228{
1229 int ret = 0;
1230 X509_PUBKEY *xp = NULL;
1231 const unsigned char *p = kExampleECPubKeyDER;
1232 size_t input_len = sizeof(kExampleECPubKeyDER);
1233
1234 if (!TEST_ptr(xp = d2i_X509_PUBKEY(NULL, &p, input_len)))
1235 goto done;
1236
1237 if (!TEST_ptr(X509_PUBKEY_get0(xp)))
1238 goto done;
1239
1240 p = kExampleBadECPubKeyDER;
1241 input_len = sizeof(kExampleBadECPubKeyDER);
1242
1243 if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
1244 goto done;
1245
1246 if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
1247 goto done;
1248
1249 ret = 1;
1250
1251done:
1252 X509_PUBKEY_free(xp);
1253 return ret;
1254}
7bb82f92 1255#endif /* OPENSSL_NO_EC */
784883fc 1256
9c45222d 1257/* Test getting and setting parameters on an EVP_PKEY_CTX */
f54a4101 1258static int test_EVP_PKEY_CTX_get_set_params(EVP_PKEY *pkey)
9c45222d 1259{
9a071fef 1260 EVP_MD_CTX *mdctx = NULL;
9c45222d 1261 EVP_PKEY_CTX *ctx = NULL;
9c45222d 1262 const OSSL_PARAM *params;
00bc1ad9 1263 OSSL_PARAM ourparams[2], *param = ourparams, *param_md;
9c45222d
MC		 1264 int ret = 0;
1265 const EVP_MD *md;
00bc1ad9 1266 char mdname[OSSL_MAX_NAME_SIZE];
9a071fef 1267 char ssl3ms[48];
9c45222d 1268
9c45222d
MC		 1269 /* Initialise a sign operation */
1270 ctx = EVP_PKEY_CTX_new(pkey, NULL);
9c45222d 1271 if (!TEST_ptr(ctx)
c9c4a356 1272 || !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0))
9c45222d
MC		 1273 goto err;
1274
1275 /*
f54a4101 1276 * We should be able to query the parameters now.
9c45222d
MC		 1277 */
1278 params = EVP_PKEY_CTX_settable_params(ctx);
1279 if (!TEST_ptr(params)
0cb3f4f9
RL		 1280 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1281 OSSL_SIGNATURE_PARAM_DIGEST)))
9c45222d
MC		 1282 goto err;
1283
9c45222d
MC		 1284 params = EVP_PKEY_CTX_gettable_params(ctx);
1285 if (!TEST_ptr(params)
0cb3f4f9
RL		 1286 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1287 OSSL_SIGNATURE_PARAM_ALGORITHM_ID))
0cb3f4f9
RL		 1288 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1289 OSSL_SIGNATURE_PARAM_DIGEST)))
9c45222d
MC		 1290 goto err;
1291
1292 /*
1293 * Test getting and setting params via EVP_PKEY_CTX_set_params() and
1294 * EVP_PKEY_CTX_get_params()
1295 */
00bc1ad9
RL		 1296 strcpy(mdname, "SHA512");
1297 param_md = param;
1298 *param++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1299 mdname, 0);
9c45222d
MC		 1300 *param++ = OSSL_PARAM_construct_end();
1301
1302 if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams)))
1303 goto err;
1304
00bc1ad9
RL		 1305 mdname[0] = '\0';
1306 *param_md = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1307 mdname, sizeof(mdname));
9c45222d 1308 if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams))
00bc1ad9 1309 || !TEST_str_eq(mdname, "SHA512"))
9c45222d
MC		 1310 goto err;
1311
1312 /*
1313 * Test the TEST_PKEY_CTX_set_signature_md() and
1314 * TEST_PKEY_CTX_get_signature_md() functions
1315 */
1316 if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0)
1317 || !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0)
1318 || !TEST_ptr_eq(md, EVP_sha256()))
1319 goto err;
1320
9a071fef
MC		 1321 /*
1322 * Test getting MD parameters via an associated EVP_PKEY_CTX
1323 */
1324 mdctx = EVP_MD_CTX_new();
1325 if (!TEST_ptr(mdctx)
a45694a3
MC		 1326 || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", NULL, pkey,
1327 NULL)))
9a071fef
MC		 1328 goto err;
1329
1330 /*
1331 * We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be
1332 * able to obtain the digest's settable parameters from the provider.
1333 */
1334 params = EVP_MD_CTX_settable_params(mdctx);
1335 if (!TEST_ptr(params)
1336 || !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0)
1337 /* The final key should be NULL */
1338 || !TEST_ptr_null(params[1].key))
1339 goto err;
1340
1341 param = ourparams;
1342 memset(ssl3ms, 0, sizeof(ssl3ms));
1343 *param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
1344 ssl3ms, sizeof(ssl3ms));
1345 *param++ = OSSL_PARAM_construct_end();
1346
1347 if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams)))
1348 goto err;
1349
9c45222d
MC		 1350 ret = 1;
1351
1352 err:
9a071fef 1353 EVP_MD_CTX_free(mdctx);
9c45222d 1354 EVP_PKEY_CTX_free(ctx);
f54a4101
RL		 1355
1356 return ret;
1357}
1358
1359#ifndef OPENSSL_NO_DSA
1360static int test_DSA_get_set_params(void)
1361{
1362 DSA *dsa = NULL;
1363 BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub = NULL, *priv = NULL;
1364 EVP_PKEY *pkey = NULL;
1365 int ret = 0;
1366
1367 /*
1368 * Setup the parameters for our DSA object. For our purposes they don't
1369 * have to actually be *valid* parameters. We just need to set something.
1370 */
1371 dsa = DSA_new();
1372 p = BN_new();
1373 q = BN_new();
1374 g = BN_new();
1375 pub = BN_new();
1376 priv = BN_new();
1377 if (!TEST_ptr(dsa)
1378 || !TEST_ptr(p)
1379 || !TEST_ptr(q)
1380 || !TEST_ptr(g)
1381 || !TEST_ptr(pub)
1382 || !DSA_set0_pqg(dsa, p, q, g)
1383 || !DSA_set0_key(dsa, pub, priv))
1384 goto err;
1385 p = q = g = pub = priv = NULL;
1386
1387 pkey = EVP_PKEY_new();
1388 if (!TEST_ptr(pkey)
1389 || !TEST_true(EVP_PKEY_assign_DSA(pkey, dsa)))
1390 goto err;
1391
1392 dsa = NULL;
1393
1394 ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1395
1396 err:
9c45222d
MC		 1397 EVP_PKEY_free(pkey);
1398 DSA_free(dsa);
1399 BN_free(p);
1400 BN_free(q);
1401 BN_free(g);
cd32a0f5
RL		 1402 BN_free(pub);
1403 BN_free(priv);
9c45222d
MC		 1404
1405 return ret;
1406}
8d0f8c81 1407#endif
9c45222d 1408
f54a4101
RL		 1409static int test_RSA_get_set_params(void)
1410{
1411 RSA *rsa = NULL;
1412 BIGNUM *n = NULL, *e = NULL, *d = NULL;
1413 EVP_PKEY *pkey = NULL;
1414 int ret = 0;
1415
1416 /*
1417 * Setup the parameters for our RSA object. For our purposes they don't
1418 * have to actually be *valid* parameters. We just need to set something.
1419 */
1420 rsa = RSA_new();
1421 n = BN_new();
1422 e = BN_new();
1423 d = BN_new();
1424 if (!TEST_ptr(rsa)
1425 || !TEST_ptr(n)
1426 || !TEST_ptr(e)
1427 || !TEST_ptr(d)
1428 || !RSA_set0_key(rsa, n, e, d))
1429 goto err;
1430 n = e = d = NULL;
1431
1432 pkey = EVP_PKEY_new();
1433 if (!TEST_ptr(pkey)
1434 || !TEST_true(EVP_PKEY_assign_RSA(pkey, rsa)))
1435 goto err;
1436
1437 rsa = NULL;
1438
1439 ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1440
1441 err:
1442 EVP_PKEY_free(pkey);
1443 RSA_free(rsa);
1444 BN_free(n);
1445 BN_free(e);
1446 BN_free(d);
1447
1448 return ret;
1449}
1450
b4be6937
MC		 1451#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1452static int test_decrypt_null_chunks(void)
1453{
1454 EVP_CIPHER_CTX* ctx = NULL;
1455 const unsigned char key[32] = {
1456 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1457 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1458 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1
1459 };
1460 unsigned char iv[12] = {
1461 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
1462 };
1463 unsigned char msg[] = "It was the best of times, it was the worst of times";
1464 unsigned char ciphertext[80];
1465 unsigned char plaintext[80];
1466 /* We initialise tmp to a non zero value on purpose */
1467 int ctlen, ptlen, tmp = 99;
1468 int ret = 0;
1469 const int enc_offset = 10, dec_offset = 20;
1470
1471 if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
1472 || !TEST_true(EVP_EncryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL,
1473 key, iv))
1474 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &ctlen, msg,
1475 enc_offset))
1476 /* Deliberate add a zero length update */
1477 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp, NULL,
1478 0))
1479 || !TEST_int_eq(tmp, 0)
1480 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp,
1481 msg + enc_offset,
1482 sizeof(msg) - enc_offset))
1483 || !TEST_int_eq(ctlen += tmp, sizeof(msg))
1484 || !TEST_true(EVP_EncryptFinal(ctx, ciphertext + ctlen, &tmp))
1485 || !TEST_int_eq(tmp, 0))
1486 goto err;
1487
1488 /* Deliberately initialise tmp to a non zero value */
1489 tmp = 99;
1490 if (!TEST_true(EVP_DecryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL, key,
1491 iv))
1492 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext, &ptlen, ciphertext,
1493 dec_offset))
1494 /*
1495 * Deliberately add a zero length update. We also deliberately do
1496 * this at a different offset than for encryption.
1497 */
1498 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp, NULL,
1499 0))
1500 || !TEST_int_eq(tmp, 0)
1501 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp,
1502 ciphertext + dec_offset,
1503 ctlen - dec_offset))
1504 || !TEST_int_eq(ptlen += tmp, sizeof(msg))
1505 || !TEST_true(EVP_DecryptFinal(ctx, plaintext + ptlen, &tmp))
1506 || !TEST_int_eq(tmp, 0)
1507 || !TEST_mem_eq(msg, sizeof(msg), plaintext, ptlen))
1508 goto err;
1509
1510 ret = 1;
1511 err:
1512 EVP_CIPHER_CTX_free(ctx);
1513 return ret;
1514}
1515#endif /* !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) */
1516
501fcfb8 1517#ifndef OPENSSL_NO_DH
e295de1d
MC		 1518static int test_EVP_PKEY_set1_DH(void)
1519{
ca2bf555
SL		 1520 DH *x942dh = NULL, *noqdh = NULL;
1521 EVP_PKEY *pkey1 = NULL, *pkey2 = NULL;
e295de1d 1522 int ret = 0;
ca2bf555
SL		 1523 BIGNUM *p, *g = NULL;
1524
1525 if (!TEST_ptr(p = BN_new())
1526 || !TEST_ptr(g = BN_new())
1527 || !BN_set_word(p, 9999)
1528 || !BN_set_word(g, 2)
1529 || !TEST_ptr(noqdh = DH_new())
1530 || !DH_set0_pqg(noqdh, p, NULL, g))
1531 goto err;
1532 p = g = NULL;
e295de1d
MC		 1533
1534 x942dh = DH_get_2048_256();
e295de1d
MC		 1535 pkey1 = EVP_PKEY_new();
1536 pkey2 = EVP_PKEY_new();
1537 if (!TEST_ptr(x942dh)
ca2bf555 1538 || !TEST_ptr(noqdh)
e295de1d
MC		 1539 || !TEST_ptr(pkey1)
1540 || !TEST_ptr(pkey2))
1541 goto err;
1542
1543 if(!TEST_true(EVP_PKEY_set1_DH(pkey1, x942dh))
1544 || !TEST_int_eq(EVP_PKEY_id(pkey1), EVP_PKEY_DHX))
1545 goto err;
1546
ca2bf555 1547 if(!TEST_true(EVP_PKEY_set1_DH(pkey2, noqdh))
e295de1d
MC		 1548 || !TEST_int_eq(EVP_PKEY_id(pkey2), EVP_PKEY_DH))
1549 goto err;
1550
1551 ret = 1;
1552 err:
ca2bf555
SL		 1553 BN_free(p);
1554 BN_free(g);
e295de1d
MC		 1555 EVP_PKEY_free(pkey1);
1556 EVP_PKEY_free(pkey2);
1557 DH_free(x942dh);
ca2bf555 1558 DH_free(noqdh);
e295de1d
MC		 1559
1560 return ret;
1561}
501fcfb8 1562#endif
e295de1d 1563
8a5cb596
RL		 1564/*
1565 * We test what happens with an empty template. For the sake of this test,
1566 * the template must be ignored, and we know that's the case for RSA keys
1567 * (this might arguably be a misfeature, but that's what we currently do,
1568 * even in provider code, since that's how the legacy RSA implementation
1569 * does things)
1570 */
1571static int test_keygen_with_empty_template(int n)
1572{
1573 EVP_PKEY_CTX *ctx = NULL;
1574 EVP_PKEY *pkey = NULL;
1575 EVP_PKEY *tkey = NULL;
1576 int ret = 0;
1577
1578 switch (n) {
1579 case 0:
1580 /* We do test with no template at all as well */
1581 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
1582 goto err;
1583 break;
1584 case 1:
1585 /* Here we create an empty RSA key that serves as our template */
1586 if (!TEST_ptr(tkey = EVP_PKEY_new())
1587 || !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
1588 || !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
1589 goto err;
1590 break;
1591 }
1592
1593 if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1594 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
1595 goto err;
1596
1597 ret = 1;
1598 err:
1599 EVP_PKEY_CTX_free(ctx);
1600 EVP_PKEY_free(pkey);
1601 EVP_PKEY_free(tkey);
1602 return ret;
1603}
1604
ad887416 1605int setup_tests(void)
71ea6b48 1606{
86dc26ba
MC		 1607 testctx = OPENSSL_CTX_new();
1608
1609 if (!TEST_ptr(testctx))
1610 return 0;
1611
6d242fa5 1612 ADD_ALL_TESTS(test_EVP_DigestSignInit, 9);
adcd8e37 1613 ADD_TEST(test_EVP_DigestVerifyInit);
2eb2b4f3 1614 ADD_TEST(test_EVP_Enveloped);
ad887416 1615 ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
a9880362 1616#ifndef OPENSSL_NO_EC
adcd8e37 1617 ADD_TEST(test_EVP_PKCS82PKEY);
ddb634fe 1618#endif
f844f9eb 1619#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
ddb634fe 1620 ADD_TEST(test_EVP_SM2);
a6c4cb84 1621 ADD_TEST(test_EVP_SM2_verify);
a9880362 1622#endif
bb5f281a 1623 ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
2aee35d3
PY		 1624 custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
1625 if (!TEST_ptr(custom_pmeth))
1626 return 0;
1627 EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
b0004708
PY		 1628 EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
1629 EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
2aee35d3
PY		 1630 if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
1631 return 0;
1632 ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
10d5b415 1633 ADD_TEST(test_HKDF);
5dc40a83
BE		 1634#ifndef OPENSSL_NO_EC
1635 ADD_TEST(test_X509_PUBKEY_inplace);
cad8347b
SL		 1636 ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
1637 OSSL_NELEM(ec_der_pub_keys));
5dc40a83 1638#endif
8d0f8c81 1639#ifndef OPENSSL_NO_DSA
f54a4101 1640 ADD_TEST(test_DSA_get_set_params);
b4be6937 1641#endif
f54a4101 1642 ADD_TEST(test_RSA_get_set_params);
b4be6937
MC		 1643#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1644 ADD_TEST(test_decrypt_null_chunks);
8d0f8c81 1645#endif
501fcfb8 1646#ifndef OPENSSL_NO_DH
e295de1d 1647 ADD_TEST(test_EVP_PKEY_set1_DH);
501fcfb8 1648#endif
8a5cb596 1649 ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
e295de1d 1650
ad887416 1651 return 1;
71ea6b48 1652}
86dc26ba
MC		 1653
1654void cleanup_tests(void)
1655{
1656 OPENSSL_CTX_free(testctx);
1657}
A mirror of the official openssl repository