]> 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
Fix incomplete deprecation guard in test/sslapitest.c
[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
41bbba53
P		 10/* We need to use some deprecated APIs */
11#define OPENSSL_SUPPRESS_DEPRECATED
12
71ea6b48
MC		 13#include <stdio.h>
14#include <stdlib.h>
bb5f281a 15#include <string.h>
71ea6b48 16#include <openssl/bio.h>
7bb82f92 17#include <openssl/conf.h>
71ea6b48
MC		 18#include <openssl/crypto.h>
19#include <openssl/err.h>
20#include <openssl/evp.h>
71ea6b48 21#include <openssl/x509.h>
4803717f 22#include <openssl/pem.h>
10d5b415 23#include <openssl/kdf.h>
847d0f81 24#include <openssl/provider.h>
9c45222d 25#include <openssl/core_names.h>
f54a4101 26#include <openssl/params.h>
d7e498ac 27#include <openssl/param_build.h>
9c45222d 28#include <openssl/dsa.h>
e295de1d 29#include <openssl/dh.h>
e5bc0ce2 30#include <openssl/aes.h>
d7e498ac 31#include <openssl/decoder.h>
adcd8e37 32#include "testutil.h"
176db6dc 33#include "internal/nelem.h"
00bc1ad9 34#include "internal/sizes.h"
25f2138b 35#include "crypto/evp.h"
f0c62c53 36#include "../e_os.h" /* strcasecmp */
71ea6b48 37
b4250010 38static OSSL_LIB_CTX *testctx = NULL;
86dc26ba 39
71ea6b48
MC		 40/*
41 * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
42 * should never use this key anywhere but in an example.
43 */
44static const unsigned char kExampleRSAKeyDER[] = {
45 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0xf8,
46 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5, 0xb4, 0x59,
47 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e, 0xd3, 0x37,
48 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34, 0x75, 0x71,
49 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde, 0x97, 0x8a,
50 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8, 0x50, 0xe4,
51 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b, 0xdc, 0xec,
52 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83, 0x58, 0x76,
53 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48, 0x1a, 0xd8,
54 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a, 0x5c, 0xd7,
55 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2, 0xa7, 0x2c,
56 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01, 0x00, 0x01,
57 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a, 0x6d, 0xc7,
58 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5, 0x32, 0x85,
59 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6, 0x5f, 0xee,
60 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8, 0x66, 0x85,
61 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6, 0xa4, 0x0a,
62 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f, 0xc2, 0x15,
63 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c, 0x5b, 0x83,
64 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78, 0x80, 0x1b,
65 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71, 0x99, 0x73,
66 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60, 0x1f, 0x99,
67 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d, 0xb1, 0x02,
68 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3, 0x40, 0x41,
69 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d, 0x3d, 0x59,
70 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18, 0xc6, 0xd9,
71 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d, 0x9f, 0xef,
72 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32, 0x46, 0x87,
73 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc, 0x2c, 0xdf,
74 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63, 0x55, 0xf5,
75 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05, 0xcd, 0xb5,
76 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16, 0xb3, 0x62,
77 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3, 0x9b, 0x64,
78 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85, 0xfa, 0xb8,
79 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97, 0xe8, 0xba,
80 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7, 0xe7, 0xfe,
81 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99, 0x75, 0xe7,
82 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4, 0x9d, 0xfe,
83 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d, 0xf1, 0xdb,
84 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40, 0x5a, 0x34,
85 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26, 0x84, 0x27,
86 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1, 0xe9, 0xc0,
87 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c, 0xb9, 0xba,
88 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30, 0x10, 0x06,
89 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea, 0x52, 0x2c,
90 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b, 0xc4, 0x1e,
91 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e, 0x49, 0xaf,
92 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9, 0xd1, 0x8a,
93 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae, 0x17, 0x17,
94 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d, 0x08, 0xf1,
95 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
96};
97
59d0e6c8
MC		 98/*
99* kExampleDSAKeyDER is a DSA private key in ASN.1, DER format. Of course, you
100 * should never use this key anywhere but in an example.
101 */
f650ab47 102#ifndef OPENSSL_NO_DSA
59d0e6c8
MC		 103static const unsigned char kExampleDSAKeyDER[] = {
104 0x30, 0x82, 0x01, 0xba, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81, 0x00, 0x9a,
105 0x05, 0x6d, 0x33, 0xcd, 0x5d, 0x78, 0xa1, 0xbb, 0xcb, 0x7d, 0x5b, 0x8d,
106 0xb4, 0xcc, 0xbf, 0x03, 0x99, 0x64, 0xde, 0x38, 0x78, 0x06, 0x15, 0x2f,
107 0x86, 0x26, 0x77, 0xf3, 0xb1, 0x85, 0x00, 0xed, 0xfc, 0x28, 0x3a, 0x42,
108 0x4d, 0xab, 0xab, 0xdf, 0xbc, 0x9c, 0x16, 0xd0, 0x22, 0x50, 0xd1, 0x38,
109 0xdd, 0x3f, 0x64, 0x05, 0x9e, 0x68, 0x7a, 0x1e, 0xf1, 0x56, 0xbf, 0x1e,
110 0x2c, 0xc5, 0x97, 0x2a, 0xfe, 0x7a, 0x22, 0xdc, 0x6c, 0x68, 0xb8, 0x2e,
111 0x06, 0xdb, 0x41, 0xca, 0x98, 0xd8, 0x54, 0xc7, 0x64, 0x48, 0x24, 0x04,
112 0x20, 0xbc, 0x59, 0xe3, 0x6b, 0xea, 0x7e, 0xfc, 0x7e, 0xc5, 0x4e, 0xd4,
113 0xd8, 0x3a, 0xed, 0xcd, 0x5d, 0x99, 0xb8, 0x5c, 0xa2, 0x8b, 0xbb, 0x0b,
114 0xac, 0xe6, 0x8e, 0x25, 0x56, 0x22, 0x3a, 0x2d, 0x3a, 0x56, 0x41, 0x14,
115 0x1f, 0x1c, 0x8f, 0x53, 0x46, 0x13, 0x85, 0x02, 0x15, 0x00, 0x98, 0x7e,
116 0x92, 0x81, 0x88, 0xc7, 0x3f, 0x70, 0x49, 0x54, 0xf6, 0x76, 0xb4, 0xa3,
117 0x9e, 0x1d, 0x45, 0x98, 0x32, 0x7f, 0x02, 0x81, 0x80, 0x69, 0x4d, 0xef,
118 0x55, 0xff, 0x4d, 0x59, 0x2c, 0x01, 0xfa, 0x6a, 0x38, 0xe0, 0x70, 0x9f,
119 0x9e, 0x66, 0x8e, 0x3e, 0x8c, 0x52, 0x22, 0x9d, 0x15, 0x7e, 0x3c, 0xef,
120 0x4c, 0x7a, 0x61, 0x26, 0xe0, 0x2b, 0x81, 0x3f, 0xeb, 0xaf, 0x35, 0x38,
121 0x8d, 0xfe, 0xed, 0x46, 0xff, 0x5f, 0x03, 0x9b, 0x81, 0x92, 0xe7, 0x6f,
122 0x76, 0x4f, 0x1d, 0xd9, 0xbb, 0x89, 0xc9, 0x3e, 0xd9, 0x0b, 0xf9, 0xf4,
123 0x78, 0x11, 0x59, 0xc0, 0x1d, 0xcd, 0x0e, 0xa1, 0x6f, 0x15, 0xf1, 0x4d,
124 0xc1, 0xc9, 0x22, 0xed, 0x8d, 0xad, 0x67, 0xc5, 0x4b, 0x95, 0x93, 0x86,
125 0xa6, 0xaf, 0x8a, 0xee, 0x06, 0x89, 0x2f, 0x37, 0x7e, 0x64, 0xaa, 0xf6,
126 0xe7, 0xb1, 0x5a, 0x0a, 0x93, 0x95, 0x5d, 0x3e, 0x53, 0x9a, 0xde, 0x8a,
127 0xc2, 0x95, 0x45, 0x81, 0xbe, 0x5c, 0x2f, 0xc2, 0xb2, 0x92, 0x58, 0x19,
128 0x72, 0x80, 0xe9, 0x79, 0xa1, 0x02, 0x81, 0x80, 0x07, 0xd7, 0x62, 0xff,
129 0xdf, 0x1a, 0x3f, 0xed, 0x32, 0xd4, 0xd4, 0x88, 0x7b, 0x2c, 0x63, 0x7f,
130 0x97, 0xdc, 0x44, 0xd4, 0x84, 0xa2, 0xdd, 0x17, 0x16, 0x85, 0x13, 0xe0,
131 0xac, 0x51, 0x8d, 0x29, 0x1b, 0x75, 0x9a, 0xe4, 0xe3, 0x8a, 0x92, 0x69,
132 0x09, 0x03, 0xc5, 0x68, 0xae, 0x5e, 0x94, 0xfe, 0xc9, 0x92, 0x6c, 0x07,
133 0xb4, 0x1e, 0x64, 0x62, 0x87, 0xc6, 0xa4, 0xfd, 0x0d, 0x5f, 0xe5, 0xf9,
134 0x1b, 0x4f, 0x85, 0x5f, 0xae, 0xf3, 0x11, 0xe5, 0x18, 0xd4, 0x4d, 0x79,
135 0x9f, 0xc4, 0x79, 0x26, 0x04, 0x27, 0xf0, 0x0b, 0xee, 0x2b, 0x86, 0x9f,
136 0x86, 0x61, 0xe6, 0x51, 0xce, 0x04, 0x9b, 0x5d, 0x6b, 0x34, 0x43, 0x8c,
137 0x85, 0x3c, 0xf1, 0x51, 0x9b, 0x08, 0x23, 0x1b, 0xf5, 0x7e, 0x33, 0x12,
138 0xea, 0xab, 0x1f, 0xb7, 0x2d, 0xe2, 0x5f, 0xe6, 0x97, 0x99, 0xb5, 0x45,
139 0x16, 0x5b, 0xc3, 0x41, 0x02, 0x14, 0x61, 0xbf, 0x51, 0x60, 0xcf, 0xc8,
140 0xf1, 0x8c, 0x82, 0x97, 0xf2, 0xf4, 0x19, 0xba, 0x2b, 0xf3, 0x16, 0xbe,
141 0x40, 0x48
142};
f650ab47 143#endif
59d0e6c8 144
2aee35d3
PY		 145/*
146 * kExampleBadRSAKeyDER is an RSA private key in ASN.1, DER format. The private
147 * components are not correct.
148 */
149static const unsigned char kExampleBadRSAKeyDER[] = {
150 0x30, 0x82, 0x04, 0x27, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
151 0xa6, 0x1a, 0x1e, 0x6e, 0x7b, 0xee, 0xc6, 0x89, 0x66, 0xe7, 0x93, 0xef,
152 0x54, 0x12, 0x68, 0xea, 0xbf, 0x86, 0x2f, 0xdd, 0xd2, 0x79, 0xb8, 0xa9,
153 0x6e, 0x03, 0xc2, 0xa3, 0xb9, 0xa3, 0xe1, 0x4b, 0x2a, 0xb3, 0xf8, 0xb4,
154 0xcd, 0xea, 0xbe, 0x24, 0xa6, 0x57, 0x5b, 0x83, 0x1f, 0x0f, 0xf2, 0xd3,
155 0xb7, 0xac, 0x7e, 0xd6, 0x8e, 0x6e, 0x1e, 0xbf, 0xb8, 0x73, 0x8c, 0x05,
156 0x56, 0xe6, 0x35, 0x1f, 0xe9, 0x04, 0x0b, 0x09, 0x86, 0x7d, 0xf1, 0x26,
157 0x08, 0x99, 0xad, 0x7b, 0xc8, 0x4d, 0x94, 0xb0, 0x0b, 0x8b, 0x38, 0xa0,
158 0x5c, 0x62, 0xa0, 0xab, 0xd3, 0x8f, 0xd4, 0x09, 0x60, 0x72, 0x1e, 0x33,
159 0x50, 0x80, 0x6e, 0x22, 0xa6, 0x77, 0x57, 0x6b, 0x9a, 0x33, 0x21, 0x66,
160 0x87, 0x6e, 0x21, 0x7b, 0xc7, 0x24, 0x0e, 0xd8, 0x13, 0xdf, 0x83, 0xde,
161 0xcd, 0x40, 0x58, 0x1d, 0x84, 0x86, 0xeb, 0xb8, 0x12, 0x4e, 0xd2, 0xfa,
162 0x80, 0x1f, 0xe4, 0xe7, 0x96, 0x29, 0xb8, 0xcc, 0xce, 0x66, 0x6d, 0x53,
163 0xca, 0xb9, 0x5a, 0xd7, 0xf6, 0x84, 0x6c, 0x2d, 0x9a, 0x1a, 0x14, 0x1c,
164 0x4e, 0x93, 0x39, 0xba, 0x74, 0xed, 0xed, 0x87, 0x87, 0x5e, 0x48, 0x75,
165 0x36, 0xf0, 0xbc, 0x34, 0xfb, 0x29, 0xf9, 0x9f, 0x96, 0x5b, 0x0b, 0xa7,
166 0x54, 0x30, 0x51, 0x29, 0x18, 0x5b, 0x7d, 0xac, 0x0f, 0xd6, 0x5f, 0x7c,
167 0xf8, 0x98, 0x8c, 0xd8, 0x86, 0x62, 0xb3, 0xdc, 0xff, 0x0f, 0xff, 0x7a,
168 0xaf, 0x5c, 0x4c, 0x61, 0x49, 0x2e, 0xc8, 0x95, 0x86, 0xc4, 0x0e, 0x87,
169 0xfc, 0x1d, 0xcf, 0x8b, 0x7c, 0x61, 0xf6, 0xd8, 0xd0, 0x69, 0xf6, 0xcd,
170 0x8a, 0x8c, 0xf6, 0x62, 0xa2, 0x56, 0xa9, 0xe3, 0xd1, 0xcf, 0x4d, 0xa0,
171 0xf6, 0x2d, 0x20, 0x0a, 0x04, 0xb7, 0xa2, 0xf7, 0xb5, 0x99, 0x47, 0x18,
172 0x56, 0x85, 0x87, 0xc7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
173 0x01, 0x00, 0x99, 0x41, 0x38, 0x1a, 0xd0, 0x96, 0x7a, 0xf0, 0x83, 0xd5,
174 0xdf, 0x94, 0xce, 0x89, 0x3d, 0xec, 0x7a, 0x52, 0x21, 0x10, 0x16, 0x06,
175 0xe0, 0xee, 0xd2, 0xe6, 0xfd, 0x4b, 0x7b, 0x19, 0x4d, 0xe1, 0xc0, 0xc0,
176 0xd5, 0x14, 0x5d, 0x79, 0xdd, 0x7e, 0x8b, 0x4b, 0xc6, 0xcf, 0xb0, 0x75,
177 0x52, 0xa3, 0x2d, 0xb1, 0x26, 0x46, 0x68, 0x9c, 0x0a, 0x1a, 0xf2, 0xe1,
178 0x09, 0xac, 0x53, 0x85, 0x8c, 0x36, 0xa9, 0x14, 0x65, 0xea, 0xa0, 0x00,
179 0xcb, 0xe3, 0x3f, 0xc4, 0x2b, 0x61, 0x2e, 0x6b, 0x06, 0x69, 0x77, 0xfd,
180 0x38, 0x7e, 0x1d, 0x3f, 0x92, 0xe7, 0x77, 0x08, 0x19, 0xa7, 0x9d, 0x29,
181 0x2d, 0xdc, 0x42, 0xc6, 0x7c, 0xd7, 0xd3, 0xa8, 0x01, 0x2c, 0xf2, 0xd5,
182 0x82, 0x57, 0xcb, 0x55, 0x3d, 0xe7, 0xaa, 0xd2, 0x06, 0x30, 0x30, 0x05,
183 0xe6, 0xf2, 0x47, 0x86, 0xba, 0xc6, 0x61, 0x64, 0xeb, 0x4f, 0x2a, 0x5e,
184 0x07, 0x29, 0xe0, 0x96, 0xb2, 0x43, 0xff, 0x5f, 0x1a, 0x54, 0x16, 0xcf,
185 0xb5, 0x56, 0x5c, 0xa0, 0x9b, 0x0c, 0xfd, 0xb3, 0xd2, 0xe3, 0x79, 0x1d,
186 0x21, 0xe2, 0xd6, 0x13, 0xc4, 0x74, 0xa6, 0xf5, 0x8e, 0x8e, 0x81, 0xbb,
187 0xb4, 0xad, 0x8a, 0xf0, 0x93, 0x0a, 0xd8, 0x0a, 0x42, 0x36, 0xbc, 0xe5,
188 0x26, 0x2a, 0x0d, 0x5d, 0x57, 0x13, 0xc5, 0x4e, 0x2f, 0x12, 0x0e, 0xef,
189 0xa7, 0x81, 0x1e, 0xc3, 0xa5, 0xdb, 0xc9, 0x24, 0xeb, 0x1a, 0xa1, 0xf9,
190 0xf6, 0xa1, 0x78, 0x98, 0x93, 0x77, 0x42, 0x45, 0x03, 0xe2, 0xc9, 0xa2,
191 0xfe, 0x2d, 0x77, 0xc8, 0xc6, 0xac, 0x9b, 0x98, 0x89, 0x6d, 0x9a, 0xe7,
192 0x61, 0x63, 0xb7, 0xf2, 0xec, 0xd6, 0xb1, 0xa1, 0x6e, 0x0a, 0x1a, 0xff,
193 0xfd, 0x43, 0x28, 0xc3, 0x0c, 0xdc, 0xf2, 0x47, 0x4f, 0x27, 0xaa, 0x99,
194 0x04, 0x8e, 0xac, 0xe8, 0x7c, 0x01, 0x02, 0x04, 0x12, 0x34, 0x56, 0x78,
195 0x02, 0x81, 0x81, 0x00, 0xca, 0x69, 0xe5, 0xbb, 0x3a, 0x90, 0x82, 0xcb,
196 0x82, 0x50, 0x2f, 0x29, 0xe2, 0x76, 0x6a, 0x57, 0x55, 0x45, 0x4e, 0x35,
197 0x18, 0x61, 0xe0, 0x12, 0x70, 0xc0, 0xab, 0xc7, 0x80, 0xa2, 0xd4, 0x46,
198 0x34, 0x03, 0xa0, 0x19, 0x26, 0x23, 0x9e, 0xef, 0x1a, 0xcb, 0x75, 0xd6,
199 0xba, 0x81, 0xf4, 0x7e, 0x52, 0xe5, 0x2a, 0xe8, 0xf1, 0x49, 0x6c, 0x0f,
200 0x1a, 0xa0, 0xf9, 0xc6, 0xe7, 0xec, 0x60, 0xe4, 0xcb, 0x2a, 0xb5, 0x56,
201 0xe9, 0x9c, 0xcd, 0x19, 0x75, 0x92, 0xb1, 0x66, 0xce, 0xc3, 0xd9, 0x3d,
202 0x11, 0xcb, 0xc4, 0x09, 0xce, 0x1e, 0x30, 0xba, 0x2f, 0x60, 0x60, 0x55,
203 0x8d, 0x02, 0xdc, 0x5d, 0xaf, 0xf7, 0x52, 0x31, 0x17, 0x07, 0x53, 0x20,
204 0x33, 0xad, 0x8c, 0xd5, 0x2f, 0x5a, 0xd0, 0x57, 0xd7, 0xd1, 0x80, 0xd6,
205 0x3a, 0x9b, 0x04, 0x4f, 0x35, 0xbf, 0xe7, 0xd5, 0xbc, 0x8f, 0xd4, 0x81,
206 0x02, 0x81, 0x81, 0x00, 0xc0, 0x9f, 0xf8, 0xcd, 0xf7, 0x3f, 0x26, 0x8a,
207 0x3d, 0x4d, 0x2b, 0x0c, 0x01, 0xd0, 0xa2, 0xb4, 0x18, 0xfe, 0xf7, 0x5e,
208 0x2f, 0x06, 0x13, 0xcd, 0x63, 0xaa, 0x12, 0xa9, 0x24, 0x86, 0xe3, 0xf3,
209 0x7b, 0xda, 0x1a, 0x3c, 0xb1, 0x38, 0x80, 0x80, 0xef, 0x64, 0x64, 0xa1,
210 0x9b, 0xfe, 0x76, 0x63, 0x8e, 0x83, 0xd2, 0xd9, 0xb9, 0x86, 0xb0, 0xe6,
211 0xa6, 0x0c, 0x7e, 0xa8, 0x84, 0x90, 0x98, 0x0c, 0x1e, 0xf3, 0x14, 0x77,
212 0xe0, 0x5f, 0x81, 0x08, 0x11, 0x8f, 0xa6, 0x23, 0xc4, 0xba, 0xc0, 0x8a,
213 0xe4, 0xc6, 0xe3, 0x5c, 0xbe, 0xc5, 0xec, 0x2c, 0xb9, 0xd8, 0x8c, 0x4d,
214 0x1a, 0x9d, 0xe7, 0x7c, 0x85, 0x4c, 0x0d, 0x71, 0x4e, 0x72, 0x33, 0x1b,
215 0xfe, 0xa9, 0x17, 0x72, 0x76, 0x56, 0x9d, 0x74, 0x7e, 0x52, 0x67, 0x9a,
216 0x87, 0x9a, 0xdb, 0x30, 0xde, 0xe4, 0x49, 0x28, 0x3b, 0xd2, 0x67, 0xaf,
217 0x02, 0x81, 0x81, 0x00, 0x89, 0x74, 0x9a, 0x8e, 0xa7, 0xb9, 0xa5, 0x28,
218 0xc0, 0x68, 0xe5, 0x6e, 0x63, 0x1c, 0x99, 0x20, 0x8f, 0x86, 0x8e, 0x12,
219 0x9e, 0x69, 0x30, 0xfa, 0x34, 0xd9, 0x92, 0x8d, 0xdb, 0x7c, 0x37, 0xfd,
220 0x28, 0xab, 0x61, 0x98, 0x52, 0x7f, 0x14, 0x1a, 0x39, 0xae, 0xfb, 0x6a,
221 0x03, 0xa3, 0xe6, 0xbd, 0xb6, 0x5b, 0x6b, 0xe5, 0x5e, 0x9d, 0xc6, 0xa5,
222 0x07, 0x27, 0x54, 0x17, 0xd0, 0x3d, 0x84, 0x9b, 0x3a, 0xa0, 0xd9, 0x1e,
223 0x99, 0x6c, 0x63, 0x17, 0xab, 0xf1, 0x1f, 0x49, 0xba, 0x95, 0xe3, 0x3b,
224 0x86, 0x8f, 0x42, 0xa4, 0x89, 0xf5, 0x94, 0x8f, 0x8b, 0x46, 0xbe, 0x84,
225 0xba, 0x4a, 0xbc, 0x0d, 0x5f, 0x46, 0xeb, 0xe8, 0xec, 0x43, 0x8c, 0x1e,
226 0xad, 0x19, 0x69, 0x2f, 0x08, 0x86, 0x7a, 0x3f, 0x7d, 0x0f, 0x07, 0x97,
227 0xf3, 0x9a, 0x7b, 0xb5, 0xb2, 0xc1, 0x8c, 0x95, 0x68, 0x04, 0xa0, 0x81,
228 0x02, 0x81, 0x80, 0x4e, 0xbf, 0x7e, 0x1b, 0xcb, 0x13, 0x61, 0x75, 0x3b,
229 0xdb, 0x59, 0x5f, 0xb1, 0xd4, 0xb8, 0xeb, 0x9e, 0x73, 0xb5, 0xe7, 0xf6,
230 0x89, 0x3d, 0x1c, 0xda, 0xf0, 0x36, 0xff, 0x35, 0xbd, 0x1e, 0x0b, 0x74,
231 0xe3, 0x9e, 0xf0, 0xf2, 0xf7, 0xd7, 0x82, 0xb7, 0x7b, 0x6a, 0x1b, 0x0e,
232 0x30, 0x4a, 0x98, 0x0e, 0xb4, 0xf9, 0x81, 0x07, 0xe4, 0x75, 0x39, 0xe9,
233 0x53, 0xca, 0xbb, 0x5c, 0xaa, 0x93, 0x07, 0x0e, 0xa8, 0x2f, 0xba, 0x98,
234 0x49, 0x30, 0xa7, 0xcc, 0x1a, 0x3c, 0x68, 0x0c, 0xe1, 0xa4, 0xb1, 0x05,
235 0xe6, 0xe0, 0x25, 0x78, 0x58, 0x14, 0x37, 0xf5, 0x1f, 0xe3, 0x22, 0xef,
236 0xa8, 0x0e, 0x22, 0xa0, 0x94, 0x3a, 0xf6, 0xc9, 0x13, 0xe6, 0x06, 0xbf,
237 0x7f, 0x99, 0xc6, 0xcc, 0xd8, 0xc6, 0xbe, 0xd9, 0x2e, 0x24, 0xc7, 0x69,
238 0x8c, 0x95, 0xba, 0xf6, 0x04, 0xb3, 0x0a, 0xf4, 0xcb, 0xf0, 0xce,
239};
240
71ea6b48
MC		 241static const unsigned char kMsg[] = { 1, 2, 3, 4 };
242
243static const unsigned char kSignature[] = {
244 0xa5, 0xf0, 0x8a, 0x47, 0x5d, 0x3c, 0xb3, 0xcc, 0xa9, 0x79, 0xaf, 0x4d,
245 0x8c, 0xae, 0x4c, 0x14, 0xef, 0xc2, 0x0b, 0x34, 0x36, 0xde, 0xf4, 0x3e,
246 0x3d, 0xbb, 0x4a, 0x60, 0x5c, 0xc8, 0x91, 0x28, 0xda, 0xfb, 0x7e, 0x04,
247 0x96, 0x7e, 0x63, 0x13, 0x90, 0xce, 0xb9, 0xb4, 0x62, 0x7a, 0xfd, 0x09,
248 0x3d, 0xc7, 0x67, 0x78, 0x54, 0x04, 0xeb, 0x52, 0x62, 0x6e, 0x24, 0x67,
249 0xb4, 0x40, 0xfc, 0x57, 0x62, 0xc6, 0xf1, 0x67, 0xc1, 0x97, 0x8f, 0x6a,
250 0xa8, 0xae, 0x44, 0x46, 0x5e, 0xab, 0x67, 0x17, 0x53, 0x19, 0x3a, 0xda,
251 0x5a, 0xc8, 0x16, 0x3e, 0x86, 0xd5, 0xc5, 0x71, 0x2f, 0xfc, 0x23, 0x48,
252 0xd9, 0x0b, 0x13, 0xdd, 0x7b, 0x5a, 0x25, 0x79, 0xef, 0xa5, 0x7b, 0x04,
253 0xed, 0x44, 0xf6, 0x18, 0x55, 0xe4, 0x0a, 0xe9, 0x57, 0x79, 0x5d, 0xd7,
254 0x55, 0xa7, 0xab, 0x45, 0x02, 0x97, 0x60, 0x42,
255};
256
257/*
258 * kExampleRSAKeyPKCS8 is kExampleRSAKeyDER encoded in a PKCS #8
259 * PrivateKeyInfo.
260 */
261static const unsigned char kExampleRSAKeyPKCS8[] = {
262 0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
263 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
264 0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01, 0x00, 0x02, 0x81, 0x81,
265 0x00, 0xf8, 0xb8, 0x6c, 0x83, 0xb4, 0xbc, 0xd9, 0xa8, 0x57, 0xc0, 0xa5,
266 0xb4, 0x59, 0x76, 0x8c, 0x54, 0x1d, 0x79, 0xeb, 0x22, 0x52, 0x04, 0x7e,
267 0xd3, 0x37, 0xeb, 0x41, 0xfd, 0x83, 0xf9, 0xf0, 0xa6, 0x85, 0x15, 0x34,
268 0x75, 0x71, 0x5a, 0x84, 0xa8, 0x3c, 0xd2, 0xef, 0x5a, 0x4e, 0xd3, 0xde,
269 0x97, 0x8a, 0xdd, 0xff, 0xbb, 0xcf, 0x0a, 0xaa, 0x86, 0x92, 0xbe, 0xb8,
270 0x50, 0xe4, 0xcd, 0x6f, 0x80, 0x33, 0x30, 0x76, 0x13, 0x8f, 0xca, 0x7b,
271 0xdc, 0xec, 0x5a, 0xca, 0x63, 0xc7, 0x03, 0x25, 0xef, 0xa8, 0x8a, 0x83,
272 0x58, 0x76, 0x20, 0xfa, 0x16, 0x77, 0xd7, 0x79, 0x92, 0x63, 0x01, 0x48,
273 0x1a, 0xd8, 0x7b, 0x67, 0xf1, 0x52, 0x55, 0x49, 0x4e, 0xd6, 0x6e, 0x4a,
274 0x5c, 0xd7, 0x7a, 0x37, 0x36, 0x0c, 0xde, 0xdd, 0x8f, 0x44, 0xe8, 0xc2,
275 0xa7, 0x2c, 0x2b, 0xb5, 0xaf, 0x64, 0x4b, 0x61, 0x07, 0x02, 0x03, 0x01,
276 0x00, 0x01, 0x02, 0x81, 0x80, 0x74, 0x88, 0x64, 0x3f, 0x69, 0x45, 0x3a,
277 0x6d, 0xc7, 0x7f, 0xb9, 0xa3, 0xc0, 0x6e, 0xec, 0xdc, 0xd4, 0x5a, 0xb5,
278 0x32, 0x85, 0x5f, 0x19, 0xd4, 0xf8, 0xd4, 0x3f, 0x3c, 0xfa, 0xc2, 0xf6,
279 0x5f, 0xee, 0xe6, 0xba, 0x87, 0x74, 0x2e, 0xc7, 0x0c, 0xd4, 0x42, 0xb8,
280 0x66, 0x85, 0x9c, 0x7b, 0x24, 0x61, 0xaa, 0x16, 0x11, 0xf6, 0xb5, 0xb6,
281 0xa4, 0x0a, 0xc9, 0x55, 0x2e, 0x81, 0xa5, 0x47, 0x61, 0xcb, 0x25, 0x8f,
282 0xc2, 0x15, 0x7b, 0x0e, 0x7c, 0x36, 0x9f, 0x3a, 0xda, 0x58, 0x86, 0x1c,
283 0x5b, 0x83, 0x79, 0xe6, 0x2b, 0xcc, 0xe6, 0xfa, 0x2c, 0x61, 0xf2, 0x78,
284 0x80, 0x1b, 0xe2, 0xf3, 0x9d, 0x39, 0x2b, 0x65, 0x57, 0x91, 0x3d, 0x71,
285 0x99, 0x73, 0xa5, 0xc2, 0x79, 0x20, 0x8c, 0x07, 0x4f, 0xe5, 0xb4, 0x60,
286 0x1f, 0x99, 0xa2, 0xb1, 0x4f, 0x0c, 0xef, 0xbc, 0x59, 0x53, 0x00, 0x7d,
287 0xb1, 0x02, 0x41, 0x00, 0xfc, 0x7e, 0x23, 0x65, 0x70, 0xf8, 0xce, 0xd3,
288 0x40, 0x41, 0x80, 0x6a, 0x1d, 0x01, 0xd6, 0x01, 0xff, 0xb6, 0x1b, 0x3d,
289 0x3d, 0x59, 0x09, 0x33, 0x79, 0xc0, 0x4f, 0xde, 0x96, 0x27, 0x4b, 0x18,
290 0xc6, 0xd9, 0x78, 0xf1, 0xf4, 0x35, 0x46, 0xe9, 0x7c, 0x42, 0x7a, 0x5d,
291 0x9f, 0xef, 0x54, 0xb8, 0xf7, 0x9f, 0xc4, 0x33, 0x6c, 0xf3, 0x8c, 0x32,
292 0x46, 0x87, 0x67, 0x30, 0x7b, 0xa7, 0xac, 0xe3, 0x02, 0x41, 0x00, 0xfc,
293 0x2c, 0xdf, 0x0c, 0x0d, 0x88, 0xf5, 0xb1, 0x92, 0xa8, 0x93, 0x47, 0x63,
294 0x55, 0xf5, 0xca, 0x58, 0x43, 0xba, 0x1c, 0xe5, 0x9e, 0xb6, 0x95, 0x05,
295 0xcd, 0xb5, 0x82, 0xdf, 0xeb, 0x04, 0x53, 0x9d, 0xbd, 0xc2, 0x38, 0x16,
296 0xb3, 0x62, 0xdd, 0xa1, 0x46, 0xdb, 0x6d, 0x97, 0x93, 0x9f, 0x8a, 0xc3,
297 0x9b, 0x64, 0x7e, 0x42, 0xe3, 0x32, 0x57, 0x19, 0x1b, 0xd5, 0x6e, 0x85,
298 0xfa, 0xb8, 0x8d, 0x02, 0x41, 0x00, 0xbc, 0x3d, 0xde, 0x6d, 0xd6, 0x97,
299 0xe8, 0xba, 0x9e, 0x81, 0x37, 0x17, 0xe5, 0xa0, 0x64, 0xc9, 0x00, 0xb7,
300 0xe7, 0xfe, 0xf4, 0x29, 0xd9, 0x2e, 0x43, 0x6b, 0x19, 0x20, 0xbd, 0x99,
301 0x75, 0xe7, 0x76, 0xf8, 0xd3, 0xae, 0xaf, 0x7e, 0xb8, 0xeb, 0x81, 0xf4,
302 0x9d, 0xfe, 0x07, 0x2b, 0x0b, 0x63, 0x0b, 0x5a, 0x55, 0x90, 0x71, 0x7d,
303 0xf1, 0xdb, 0xd9, 0xb1, 0x41, 0x41, 0x68, 0x2f, 0x4e, 0x39, 0x02, 0x40,
304 0x5a, 0x34, 0x66, 0xd8, 0xf5, 0xe2, 0x7f, 0x18, 0xb5, 0x00, 0x6e, 0x26,
305 0x84, 0x27, 0x14, 0x93, 0xfb, 0xfc, 0xc6, 0x0f, 0x5e, 0x27, 0xe6, 0xe1,
306 0xe9, 0xc0, 0x8a, 0xe4, 0x34, 0xda, 0xe9, 0xa2, 0x4b, 0x73, 0xbc, 0x8c,
307 0xb9, 0xba, 0x13, 0x6c, 0x7a, 0x2b, 0x51, 0x84, 0xa3, 0x4a, 0xe0, 0x30,
308 0x10, 0x06, 0x7e, 0xed, 0x17, 0x5a, 0x14, 0x00, 0xc9, 0xef, 0x85, 0xea,
309 0x52, 0x2c, 0xbc, 0x65, 0x02, 0x40, 0x51, 0xe3, 0xf2, 0x83, 0x19, 0x9b,
310 0xc4, 0x1e, 0x2f, 0x50, 0x3d, 0xdf, 0x5a, 0xa2, 0x18, 0xca, 0x5f, 0x2e,
311 0x49, 0xaf, 0x6f, 0xcc, 0xfa, 0x65, 0x77, 0x94, 0xb5, 0xa1, 0x0a, 0xa9,
312 0xd1, 0x8a, 0x39, 0x37, 0xf4, 0x0b, 0xa0, 0xd7, 0x82, 0x27, 0x5e, 0xae,
313 0x17, 0x17, 0xa1, 0x1e, 0x54, 0x34, 0xbf, 0x6e, 0xc4, 0x8e, 0x99, 0x5d,
314 0x08, 0xf1, 0x2d, 0x86, 0x9d, 0xa5, 0x20, 0x1b, 0xe5, 0xdf,
315};
316
a9880362 317#ifndef OPENSSL_NO_EC
71ea6b48
MC		 318/*
319 * kExampleECKeyDER is a sample EC private key encoded as an ECPrivateKey
320 * structure.
321 */
322static const unsigned char kExampleECKeyDER[] = {
323 0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20, 0x07, 0x0f, 0x08, 0x72, 0x7a,
324 0xd4, 0xa0, 0x4a, 0x9c, 0xdd, 0x59, 0xc9, 0x4d, 0x89, 0x68, 0x77, 0x08,
325 0xb5, 0x6f, 0xc9, 0x5d, 0x30, 0x77, 0x0e, 0xe8, 0xd1, 0xc9, 0xce, 0x0a,
326 0x8b, 0xb4, 0x6a, 0xa0, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
327 0x03, 0x01, 0x07, 0xa1, 0x44, 0x03, 0x42, 0x00, 0x04, 0xe6, 0x2b, 0x69,
328 0xe2, 0xbf, 0x65, 0x9f, 0x97, 0xbe, 0x2f, 0x1e, 0x0d, 0x94, 0x8a, 0x4c,
329 0xd5, 0x97, 0x6b, 0xb7, 0xa9, 0x1e, 0x0d, 0x46, 0xfb, 0xdd, 0xa9, 0xa9,
330 0x1e, 0x9d, 0xdc, 0xba, 0x5a, 0x01, 0xe7, 0xd6, 0x97, 0xa8, 0x0a, 0x18,
331 0xf9, 0xc3, 0xc4, 0xa3, 0x1e, 0x56, 0xe2, 0x7c, 0x83, 0x48, 0xdb, 0x16,
332 0x1a, 0x1c, 0xf5, 0x1d, 0x7e, 0xf1, 0x94, 0x2d, 0x4b, 0xcf, 0x72, 0x22,
333 0xc1,
334};
335
336/*
337 * kExampleBadECKeyDER is a sample EC private key encoded as an ECPrivateKey
338 * structure. The private key is equal to the order and will fail to import
339 */
340static const unsigned char kExampleBadECKeyDER[] = {
341 0x30, 0x66, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48,
342 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03,
343 0x01, 0x07, 0x04, 0x4C, 0x30, 0x4A, 0x02, 0x01, 0x01, 0x04, 0x20, 0xFF,
344 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
345 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3,
346 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51, 0xA1, 0x23, 0x03, 0x21, 0x00,
347 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
348 0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
349 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
350};
b0004708
PY		 351
352/* prime256v1 */
353static const unsigned char kExampleECPubKeyDER[] = {
354 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
355 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
356 0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
357 0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
358 0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
359 0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
360 0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
361 0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
362};
363
5dc40a83 364/*
87762939 365 * kExampleBadECPubKeyDER is a sample EC public key with a wrong OID
5dc40a83
BE		 366 * 1.2.840.10045.2.2 instead of 1.2.840.10045.2.1 - EC Public Key
367 */
368static const unsigned char kExampleBadECPubKeyDER[] = {
369 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
370 0x02, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
371 0x42, 0x00, 0x04, 0xba, 0xeb, 0x83, 0xfb, 0x3b, 0xb2, 0xff, 0x30, 0x53,
372 0xdb, 0xce, 0x32, 0xf2, 0xac, 0xae, 0x44, 0x0d, 0x3d, 0x13, 0x53, 0xb8,
373 0xd1, 0x68, 0x55, 0xde, 0x44, 0x46, 0x05, 0xa6, 0xc9, 0xd2, 0x04, 0xb7,
374 0xe3, 0xa2, 0x96, 0xc8, 0xb2, 0x5e, 0x22, 0x03, 0xd7, 0x03, 0x7a, 0x8b,
375 0x13, 0x5c, 0x42, 0x49, 0xc2, 0xab, 0x86, 0xd6, 0xac, 0x6b, 0x93, 0x20,
376 0x56, 0x6a, 0xc6, 0xc8, 0xa5, 0x0b, 0xe5
377};
378
b0004708
PY		 379static const unsigned char pExampleECParamDER[] = {
380 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07
381};
a9880362 382#endif
71ea6b48 383
adcd8e37
RS		 384typedef struct APK_DATA_st {
385 const unsigned char *kder;
386 size_t size;
387 int evptype;
2aee35d3 388 int check;
b0004708
PY		 389 int pub_check;
390 int param_check;
391 int type; /* 0 for private, 1 for public, 2 for params */
adcd8e37
RS		 392} APK_DATA;
393
394static APK_DATA keydata[] = {
395 {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
396 {kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
aa24cd1b 397#ifndef OPENSSL_NO_EC
adcd8e37 398 {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
aa24cd1b 399#endif
adcd8e37
RS		 400};
401
2aee35d3 402static APK_DATA keycheckdata[] = {
e6774a72 403 {kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA, 1, 1, 1, 0},
b0004708 404 {kExampleBadRSAKeyDER, sizeof(kExampleBadRSAKeyDER), EVP_PKEY_RSA,
e6774a72 405 0, 1, 1, 0},
2aee35d3 406#ifndef OPENSSL_NO_EC
b0004708
PY		 407 {kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC, 1, 1, 1, 0},
408 /* group is also associated in our pub key */
409 {kExampleECPubKeyDER, sizeof(kExampleECPubKeyDER), EVP_PKEY_EC, 0, 1, 1, 1},
410 {pExampleECParamDER, sizeof(pExampleECParamDER), EVP_PKEY_EC, 0, 0, 1, 2}
2aee35d3
PY		 411#endif
412};
413
d7e498ac
RL		 414static EVP_PKEY *load_example_key(const char *keytype,
415 const unsigned char *data, size_t data_len)
71ea6b48 416{
d7e498ac 417 const unsigned char **pdata = &data;
71ea6b48 418 EVP_PKEY *pkey = NULL;
d7e498ac
RL		 419 OSSL_DECODER_CTX *dctx =
420 OSSL_DECODER_CTX_new_by_EVP_PKEY(&pkey, "DER", NULL, keytype, 0,
421 testctx, NULL);
71ea6b48 422
d7e498ac
RL		 423 /* |pkey| will be NULL on error */
424 (void)OSSL_DECODER_from_data(dctx, pdata, &data_len);
425 OSSL_DECODER_CTX_free(dctx);
426 return pkey;
427}
71ea6b48 428
d7e498ac
RL		 429static EVP_PKEY *load_example_rsa_key(void)
430{
431 return load_example_key("RSA", kExampleRSAKeyDER,
432 sizeof(kExampleRSAKeyDER));
71ea6b48
MC		 433}
434
f650ab47 435#ifndef OPENSSL_NO_DSA
59d0e6c8
MC		 436static EVP_PKEY *load_example_dsa_key(void)
437{
6ed4022c
RL		 438 return load_example_key("DSA", kExampleDSAKeyDER,
439 sizeof(kExampleDSAKeyDER));
59d0e6c8 440}
f650ab47 441#endif
59d0e6c8 442
6d242fa5
MC		 443static EVP_PKEY *load_example_hmac_key(void)
444{
445 EVP_PKEY *pkey = NULL;
446 unsigned char key[] = {
447 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
448 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
449 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
450 };
451
452 pkey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL, key, sizeof(key));
453 if (!TEST_ptr(pkey))
454 return NULL;
455
456 return pkey;
457}
458
f9e504e8
P		 459static int test_EVP_set_default_properties(void)
460{
b4250010 461 OSSL_LIB_CTX *ctx;
f9e504e8
P		 462 EVP_MD *md = NULL;
463 int res = 0;
464
b4250010 465 if (!TEST_ptr(ctx = OSSL_LIB_CTX_new())
f9e504e8
P		 466 || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
467 goto err;
468 EVP_MD_free(md);
469 md = NULL;
470
471 if (!TEST_true(EVP_set_default_properties(ctx, "provider=fizzbang"))
472 || !TEST_ptr_null(md = EVP_MD_fetch(ctx, "sha256", NULL))
473 || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", "-provider")))
474 goto err;
475 EVP_MD_free(md);
476 md = NULL;
477
478 if (!TEST_true(EVP_set_default_properties(ctx, NULL))
479 || !TEST_ptr(md = EVP_MD_fetch(ctx, "sha256", NULL)))
480 goto err;
481 res = 1;
482err:
483 EVP_MD_free(md);
b4250010 484 OSSL_LIB_CTX_free(ctx);
f9e504e8
P		 485 return res;
486}
487
2eb2b4f3
SL		 488static int test_EVP_Enveloped(void)
489{
490 int ret = 0;
491 EVP_CIPHER_CTX *ctx = NULL;
492 EVP_PKEY *keypair = NULL;
493 unsigned char *kek = NULL;
494 unsigned char iv[EVP_MAX_IV_LENGTH];
495 static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
496 int len, kek_len, ciphertext_len, plaintext_len;
497 unsigned char ciphertext[32], plaintext[16];
498 const EVP_CIPHER *type = EVP_aes_256_cbc();
499
500 if (!TEST_ptr(keypair = load_example_rsa_key())
501 || !TEST_ptr(kek = OPENSSL_zalloc(EVP_PKEY_size(keypair)))
502 || !TEST_ptr(ctx = EVP_CIPHER_CTX_new())
503 || !TEST_true(EVP_SealInit(ctx, type, &kek, &kek_len, iv,
504 &keypair, 1))
505 || !TEST_true(EVP_SealUpdate(ctx, ciphertext, &ciphertext_len,
506 msg, sizeof(msg)))
507 || !TEST_true(EVP_SealFinal(ctx, ciphertext + ciphertext_len,
508 &len)))
509 goto err;
510
511 ciphertext_len += len;
512
513 if (!TEST_true(EVP_OpenInit(ctx, type, kek, kek_len, iv, keypair))
514 || !TEST_true(EVP_OpenUpdate(ctx, plaintext, &plaintext_len,
515 ciphertext, ciphertext_len))
516 || !TEST_true(EVP_OpenFinal(ctx, plaintext + plaintext_len, &len)))
517 goto err;
518
519 plaintext_len += len;
520 if (!TEST_mem_eq(msg, sizeof(msg), plaintext, plaintext_len))
521 goto err;
522
523 ret = 1;
524err:
525 OPENSSL_free(kek);
526 EVP_PKEY_free(keypair);
527 EVP_CIPHER_CTX_free(ctx);
528 return ret;
529}
530
59d0e6c8 531/*
6d242fa5
MC		 532 * Test 0: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, RSA)
533 * Test 1: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, DSA)
534 * Test 2: Standard calls to EVP_DigestSignInit/Update/Final (Implicit fetch digest, HMAC)
535 * Test 3: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, RSA)
536 * Test 4: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch digest, DSA)
537 * Test 5: Standard calls to EVP_DigestSignInit/Update/Final (Explicit fetch diegst, HMAC)
538 * Test 6: Use an MD BIO to do the Update calls instead (RSA)
539 * Test 7: Use an MD BIO to do the Update calls instead (DSA)
540 * Test 8: Use an MD BIO to do the Update calls instead (HMAC)
59d0e6c8
MC		 541 */
542static int test_EVP_DigestSignInit(int tst)
71ea6b48
MC		 543{
544 int ret = 0;
545 EVP_PKEY *pkey = NULL;
546 unsigned char *sig = NULL;
547 size_t sig_len = 0;
59d0e6c8
MC		 548 EVP_MD_CTX *md_ctx = NULL, *md_ctx_verify = NULL;
549 EVP_MD_CTX *a_md_ctx = NULL, *a_md_ctx_verify = NULL;
550 BIO *mdbio = NULL, *membio = NULL;
551 size_t written;
6d242fa5
MC		 552 const EVP_MD *md;
553 EVP_MD *mdexp = NULL;
59d0e6c8 554
6d242fa5 555 if (tst >= 6) {
59d0e6c8
MC		 556 membio = BIO_new(BIO_s_mem());
557 mdbio = BIO_new(BIO_f_md());
558 if (!TEST_ptr(membio) || !TEST_ptr(mdbio))
559 goto out;
560 BIO_push(mdbio, membio);
561 if (!TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx), 0))
562 goto out;
563 } else {
564 if (!TEST_ptr(a_md_ctx = md_ctx = EVP_MD_CTX_new())
565 || !TEST_ptr(a_md_ctx_verify = md_ctx_verify = EVP_MD_CTX_new()))
566 goto out;
567 }
71ea6b48 568
6d242fa5 569 if (tst == 0 || tst == 3 || tst == 6) {
59d0e6c8
MC		 570 if (!TEST_ptr(pkey = load_example_rsa_key()))
571 goto out;
6d242fa5 572 } else if (tst == 1 || tst == 4 || tst == 7) {
f650ab47 573#ifndef OPENSSL_NO_DSA
59d0e6c8
MC		 574 if (!TEST_ptr(pkey = load_example_dsa_key()))
575 goto out;
f650ab47
MC		 576#else
577 ret = 1;
578 goto out;
579#endif
6d242fa5
MC		 580 } else {
581 if (!TEST_ptr(pkey = load_example_hmac_key()))
582 goto out;
59d0e6c8 583 }
71ea6b48 584
6d242fa5
MC		 585 if (tst >= 3 && tst <= 5)
586 md = mdexp = EVP_MD_fetch(NULL, "SHA256", NULL);
587 else
588 md = EVP_sha256();
589
590 if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, md, NULL, pkey)))
71ea6b48 591 goto out;
adcd8e37 592
6d242fa5 593 if (tst >= 6) {
59d0e6c8
MC		 594 if (!BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written))
595 goto out;
596 } else {
597 if (!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
598 goto out;
599 }
600
71ea6b48 601 /* Determine the size of the signature. */
adcd8e37 602 if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
0a054d2a 603 || !TEST_ptr(sig = OPENSSL_malloc(sig_len))
adcd8e37 604 || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
71ea6b48 605 goto out;
71ea6b48 606
6d242fa5 607 if (tst >= 6) {
59d0e6c8
MC		 608 if (!TEST_int_gt(BIO_reset(mdbio), 0)
609 || !TEST_int_gt(BIO_get_md_ctx(mdbio, &md_ctx_verify), 0))
610 goto out;
611 }
612
6d242fa5
MC		 613 /*
614 * Ensure that the signature round-trips (Verification isn't supported for
615 * HMAC via EVP_DigestVerify*)
616 */
617 if (tst != 2 && tst != 5 && tst != 8) {
618 if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, md,
619 NULL, pkey)))
59d0e6c8 620 goto out;
6d242fa5
MC		 621
622 if (tst >= 6) {
623 if (!TEST_true(BIO_write_ex(mdbio, kMsg, sizeof(kMsg), &written)))
624 goto out;
625 } else {
626 if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg,
627 sizeof(kMsg))))
628 goto out;
629 }
630 if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
59d0e6c8
MC		 631 goto out;
632 }
71ea6b48
MC		 633
634 ret = 1;
635
636 out:
59d0e6c8
MC		 637 BIO_free(membio);
638 BIO_free(mdbio);
639 EVP_MD_CTX_free(a_md_ctx);
640 EVP_MD_CTX_free(a_md_ctx_verify);
c5ba2d99 641 EVP_PKEY_free(pkey);
b548a1f1 642 OPENSSL_free(sig);
6d242fa5 643 EVP_MD_free(mdexp);
71ea6b48
MC		 644
645 return ret;
646}
647
648static int test_EVP_DigestVerifyInit(void)
649{
650 int ret = 0;
651 EVP_PKEY *pkey = NULL;
adcd8e37 652 EVP_MD_CTX *md_ctx = NULL;
71ea6b48 653
adcd8e37
RS		 654 if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
655 || !TEST_ptr(pkey = load_example_rsa_key()))
656 goto out;
71ea6b48 657
adcd8e37
RS		 658 if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
659 || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
660 || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
661 sizeof(kSignature))))
71ea6b48 662 goto out;
71ea6b48
MC		 663 ret = 1;
664
665 out:
bfb0641f 666 EVP_MD_CTX_free(md_ctx);
c5ba2d99 667 EVP_PKEY_free(pkey);
71ea6b48
MC		 668 return ret;
669}
670
8d8dd09b
TM		 671/*
672 * Test corner cases of EVP_DigestInit/Update/Final API call behavior.
673 */
674static int test_EVP_Digest(void)
675{
676 int ret = 0;
677 EVP_MD_CTX *md_ctx = NULL;
678 unsigned char md[EVP_MAX_MD_SIZE];
679
680 if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
681 goto out;
682
683 if (!TEST_true(EVP_DigestInit_ex(md_ctx, EVP_sha256(), NULL))
684 || !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
685 || !TEST_true(EVP_DigestFinal(md_ctx, md, NULL))
686 /* EVP_DigestFinal resets the EVP_MD_CTX. */
687 || !TEST_ptr_eq(EVP_MD_CTX_md(md_ctx), NULL))
688 goto out;
689
690 if (!TEST_true(EVP_DigestInit_ex(md_ctx, EVP_sha256(), NULL))
691 || !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
692 || !TEST_true(EVP_DigestFinal_ex(md_ctx, md, NULL))
693 /* EVP_DigestFinal_ex does not reset the EVP_MD_CTX. */
694 || !TEST_ptr(EVP_MD_CTX_md(md_ctx))
695 /*
696 * EVP_DigestInit_ex with NULL type should work on
697 * pre-initialized context.
698 */
699 || !TEST_true(EVP_DigestInit_ex(md_ctx, NULL, NULL)))
700 goto out;
701
702 if (!TEST_true(EVP_DigestInit_ex(md_ctx, EVP_shake256(), NULL))
703 || !TEST_true(EVP_DigestUpdate(md_ctx, kMsg, sizeof(kMsg)))
704 || !TEST_true(EVP_DigestFinalXOF(md_ctx, md, sizeof(md)))
705 /* EVP_DigestFinalXOF does not reset the EVP_MD_CTX. */
706 || !TEST_ptr(EVP_MD_CTX_md(md_ctx))
707 || !TEST_true(EVP_DigestInit_ex(md_ctx, NULL, NULL)))
708 goto out;
709 ret = 1;
710
711 out:
712 EVP_MD_CTX_free(md_ctx);
713 return ret;
714}
715
adcd8e37 716static int test_d2i_AutoPrivateKey(int i)
71ea6b48
MC		 717{
718 int ret = 0;
719 const unsigned char *p;
720 EVP_PKEY *pkey = NULL;
adcd8e37
RS		 721 const APK_DATA *ak = &keydata[i];
722 const unsigned char *input = ak->kder;
723 size_t input_len = ak->size;
724 int expected_id = ak->evptype;
71ea6b48
MC		 725
726 p = input;
adcd8e37
RS		 727 if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
728 || !TEST_ptr_eq(p, input + input_len)
729 || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
71ea6b48 730 goto done;
71ea6b48
MC		 731
732 ret = 1;
733
734 done:
c5ba2d99 735 EVP_PKEY_free(pkey);
71ea6b48
MC		 736 return ret;
737}
738
a9880362 739#ifndef OPENSSL_NO_EC
cad8347b
SL		 740
741static const unsigned char ec_public_sect163k1_validxy[] = {
742 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
743 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
744 0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
745 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x02, 0xd1, 0x7b,
746 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
747 0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
748};
749
750static const unsigned char ec_public_sect163k1_badx[] = {
751 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
752 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
753 0x0a, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
754 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0xb0, 0x02, 0xd1, 0x7b,
755 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
756 0x6a, 0xd8, 0x17, 0x65, 0x41, 0x2f
757};
758
759static const unsigned char ec_public_sect163k1_bady[] = {
760 0x30, 0x40, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
761 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x01, 0x03, 0x2c, 0x00, 0x04,
762 0x02, 0x84, 0x58, 0xa6, 0xd4, 0xa0, 0x35, 0x2b, 0xae, 0xf0, 0xc0, 0x69,
763 0x05, 0xcf, 0x2a, 0x50, 0x33, 0xf9, 0xe3, 0x92, 0x79, 0x0a, 0xd1, 0x7b,
764 0x9f, 0x22, 0x00, 0xf0, 0x3b, 0x0e, 0x5d, 0x2e, 0xb7, 0x23, 0x24, 0xf3,
765 0x6a, 0xd8, 0x17, 0x65, 0x41, 0xe6
766};
767
768static struct ec_der_pub_keys_st {
769 const unsigned char *der;
770 size_t len;
771 int valid;
772} ec_der_pub_keys[] = {
773 { ec_public_sect163k1_validxy, sizeof(ec_public_sect163k1_validxy), 1 },
774 { ec_public_sect163k1_badx, sizeof(ec_public_sect163k1_badx), 0 },
775 { ec_public_sect163k1_bady, sizeof(ec_public_sect163k1_bady), 0 },
776};
777
778/*
779 * Tests the range of the decoded EC char2 public point.
780 * See ec_GF2m_simple_oct2point().
781 */
782static int test_invalide_ec_char2_pub_range_decode(int id)
783{
784 int ret = 0;
785 BIO *bio = NULL;
786 EC_KEY *eckey = NULL;
787
788 if (!TEST_ptr(bio = BIO_new_mem_buf(ec_der_pub_keys[id].der,
789 ec_der_pub_keys[id].len)))
790 goto err;
791 eckey = d2i_EC_PUBKEY_bio(bio, NULL);
792 ret = (ec_der_pub_keys[id].valid && TEST_ptr(eckey))
793 || TEST_ptr_null(eckey);
794err:
795 EC_KEY_free(eckey);
796 BIO_free(bio);
797 return ret;
798}
799
71ea6b48
MC		 800/* Tests loading a bad key in PKCS8 format */
801static int test_EVP_PKCS82PKEY(void)
802{
803 int ret = 0;
804 const unsigned char *derp = kExampleBadECKeyDER;
805 PKCS8_PRIV_KEY_INFO *p8inf = NULL;
806 EVP_PKEY *pkey = NULL;
807
adcd8e37
RS		 808 if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
809 sizeof(kExampleBadECKeyDER))))
810 goto done;
71ea6b48 811
adcd8e37
RS		 812 if (!TEST_ptr_eq(derp,
813 kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
71ea6b48 814 goto done;
71ea6b48 815
adcd8e37 816 if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
71ea6b48 817 goto done;
71ea6b48
MC		 818
819 ret = 1;
820
821 done:
e0e920b1 822 PKCS8_PRIV_KEY_INFO_free(p8inf);
c5ba2d99 823 EVP_PKEY_free(pkey);
71ea6b48
MC		 824
825 return ret;
826}
a9880362 827#endif
71ea6b48 828
29c49b25
RL		 829/* This uses kExampleRSAKeyDER and kExampleRSAKeyPKCS8 to verify encoding */
830static int test_privatekey_to_pkcs8(void)
831{
832 EVP_PKEY *pkey = NULL;
833 BIO *membio = NULL;
834 char *membuf = NULL;
e2cc68c8 835 long membuf_len = 0;
29c49b25
RL		 836 int ok = 0;
837
838 if (!TEST_ptr(membio = BIO_new(BIO_s_mem()))
839 || !TEST_ptr(pkey = load_example_rsa_key())
840 || !TEST_int_gt(i2d_PKCS8PrivateKey_bio(membio, pkey, NULL,
841 NULL, 0, NULL, NULL),
842 0)
e2cc68c8
SL		 843 || !TEST_int_gt(membuf_len = BIO_get_mem_data(membio, &membuf), 0)
844 || !TEST_ptr(membuf)
845 || !TEST_mem_eq(membuf, (size_t)membuf_len,
29c49b25
RL		 846 kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8))
847 /*
848 * We try to write PEM as well, just to see that it doesn't err, but
849 * assume that the result is correct.
850 */
851 || !TEST_int_gt(PEM_write_bio_PKCS8PrivateKey(membio, pkey, NULL,
852 NULL, 0, NULL, NULL),
853 0))
854 goto done;
855
856 ok = 1;
857 done:
858 EVP_PKEY_free(pkey);
859 BIO_free_all(membio);
860 return ok;
861}
862
f0c62c53
RL		 863#ifndef OPENSSL_NO_EC
864static const struct {
865 int encoding;
866 const char *encoding_name;
867} ec_encodings[] = {
868 { OPENSSL_EC_EXPLICIT_CURVE, OSSL_PKEY_EC_ENCODING_EXPLICIT },
869 { OPENSSL_EC_NAMED_CURVE, OSSL_PKEY_EC_ENCODING_GROUP }
870};
871
872static int ec_export_get_encoding_cb(const OSSL_PARAM params[], void *arg)
873{
874 const OSSL_PARAM *p;
875 const char *enc_name = NULL;
876 int *enc = arg;
877 size_t i;
878
879 *enc = -1;
880
881 if (!TEST_ptr(p = OSSL_PARAM_locate_const(params,
882 OSSL_PKEY_PARAM_EC_ENCODING))
883 || !TEST_true(OSSL_PARAM_get_utf8_string_ptr(p, &enc_name)))
884 return 0;
885
886 for (i = 0; i < OSSL_NELEM(ec_encodings); i++) {
887 if (strcasecmp(enc_name, ec_encodings[i].encoding_name) == 0) {
888 *enc = ec_encodings[i].encoding;
889 break;
890 }
891 }
892
893 return (*enc != -1);
894}
895
896static int test_EC_keygen_with_enc(int idx)
897{
898 EVP_PKEY *params = NULL, *key = NULL;
899 EVP_PKEY_CTX *pctx = NULL, *kctx = NULL;
900 int enc;
901 int ret = 0;
902
903 enc = ec_encodings[idx].encoding;
904
905 /* Create key parameters */
906 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "EC", NULL))
907 || !TEST_true(EVP_PKEY_paramgen_init(pctx))
908 || !TEST_true(EVP_PKEY_CTX_set_group_name(pctx, "P-256"))
909 || !TEST_true(EVP_PKEY_CTX_set_ec_param_enc(pctx, enc))
910 || !TEST_true(EVP_PKEY_paramgen(pctx, &params))
911 || !TEST_ptr(params))
912 goto done;
913
914 /* Create key */
915 if (!TEST_ptr(kctx = EVP_PKEY_CTX_new_from_pkey(testctx, params, NULL))
916 || !TEST_true(EVP_PKEY_keygen_init(kctx))
917 || !TEST_true(EVP_PKEY_keygen(kctx, &key))
918 || !TEST_ptr(key))
919 goto done;
920
921 /* Check that the encoding got all the way into the key */
922 if (!TEST_true(evp_keymgmt_util_export(key, OSSL_KEYMGMT_SELECT_ALL,
923 ec_export_get_encoding_cb, &enc))
924 || !TEST_int_eq(enc, ec_encodings[idx].encoding))
925 goto done;
926
927 ret = 1;
928 done:
929 EVP_PKEY_free(key);
930 EVP_PKEY_free(params);
931 EVP_PKEY_CTX_free(kctx);
932 EVP_PKEY_CTX_free(pctx);
933 return ret;
934}
935#endif
936
f844f9eb 937#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
ddb634fe 938
a6c4cb84
JL		 939static int test_EVP_SM2_verify(void)
940{
a6c4cb84 941 const char *pubkey =
d0b79f86
PY		 942 "-----BEGIN PUBLIC KEY-----\n"
943 "MFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAEp1KLWq1ZE2jmoAnnBJE1LBGxVr18\n"
944 "YvvqECWCpXfAQ9qUJ+UmthnUPf0iM3SaXKHe6PlLIDyNlWMWb9RUh/yU3g==\n"
945 "-----END PUBLIC KEY-----\n";
a6c4cb84
JL		 946
947 const char *msg = "message digest";
948 const char *id = "ALICE123@YAHOO.COM";
949
950 const uint8_t signature[] = {
d0b79f86
PY		 951 0x30, 0x44, 0x02, 0x20, 0x5b, 0xdb, 0xab, 0x81, 0x4f, 0xbb,
952 0x8b, 0x69, 0xb1, 0x05, 0x9c, 0x99, 0x3b, 0xb2, 0x45, 0x06,
953 0x4a, 0x30, 0x15, 0x59, 0x84, 0xcd, 0xee, 0x30, 0x60, 0x36,
954 0x57, 0x87, 0xef, 0x5c, 0xd0, 0xbe, 0x02, 0x20, 0x43, 0x8d,
955 0x1f, 0xc7, 0x77, 0x72, 0x39, 0xbb, 0x72, 0xe1, 0xfd, 0x07,
956 0x58, 0xd5, 0x82, 0xc8, 0x2d, 0xba, 0x3b, 0x2c, 0x46, 0x24,
957 0xe3, 0x50, 0xff, 0x04, 0xc7, 0xa0, 0x71, 0x9f, 0xa4, 0x70
a6c4cb84
JL		 958 };
959
960 int rc = 0;
961 BIO *bio = NULL;
962 EVP_PKEY *pkey = NULL;
963 EVP_MD_CTX *mctx = NULL;
964 EVP_PKEY_CTX *pctx = NULL;
965
966 bio = BIO_new_mem_buf(pubkey, strlen(pubkey));
967 if (!TEST_true(bio != NULL))
968 goto done;
969
970 pkey = PEM_read_bio_PUBKEY(bio, NULL, NULL, NULL);
971 if (!TEST_true(pkey != NULL))
972 goto done;
973
8a288609 974 if (!TEST_true(EVP_PKEY_is_a(pkey, "SM2")))
a6c4cb84
JL		 975 goto done;
976
977 if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
978 goto done;
979
980 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new(pkey, NULL)))
981 goto done;
982
a6c4cb84
JL		 983 EVP_MD_CTX_set_pkey_ctx(mctx, pctx);
984
985 if (!TEST_true(EVP_DigestVerifyInit(mctx, NULL, EVP_sm3(), NULL, pkey)))
986 goto done;
987
d0b79f86
PY		 988 if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(pctx, id, strlen(id)), 0))
989 goto done;
990
a6c4cb84
JL		 991 if (!TEST_true(EVP_DigestVerifyUpdate(mctx, msg, strlen(msg))))
992 goto done;
993
994 if (!TEST_true(EVP_DigestVerifyFinal(mctx, signature, sizeof(signature))))
995 goto done;
996 rc = 1;
997
998 done:
999 BIO_free(bio);
1000 EVP_PKEY_free(pkey);
1001 EVP_PKEY_CTX_free(pctx);
1002 EVP_MD_CTX_free(mctx);
1003 return rc;
1004}
1005
ddb634fe
JL		 1006static int test_EVP_SM2(void)
1007{
1008 int ret = 0;
1009 EVP_PKEY *pkey = NULL;
bfb56a97 1010 EVP_PKEY *pkeyparams = NULL;
ddb634fe
JL		 1011 EVP_PKEY_CTX *pctx = NULL;
1012 EVP_PKEY_CTX *kctx = NULL;
4803717f 1013 EVP_PKEY_CTX *sctx = NULL;
ddb634fe
JL		 1014 size_t sig_len = 0;
1015 unsigned char *sig = NULL;
1016 EVP_MD_CTX *md_ctx = NULL;
1017 EVP_MD_CTX *md_ctx_verify = NULL;
1018 EVP_PKEY_CTX *cctx = NULL;
1019
1020 uint8_t ciphertext[128];
1021 size_t ctext_len = sizeof(ciphertext);
1022
1023 uint8_t plaintext[8];
1024 size_t ptext_len = sizeof(plaintext);
1025
4803717f
PY		 1026 uint8_t sm2_id[] = {1, 2, 3, 4, 'l', 'e', 't', 't', 'e', 'r'};
1027
bfb56a97
MC		 1028 OSSL_PARAM sparams[2] = {OSSL_PARAM_END, OSSL_PARAM_END};
1029 OSSL_PARAM gparams[2] = {OSSL_PARAM_END, OSSL_PARAM_END};
1030 int i;
1031 char mdname[20];
1032
d0b79f86 1033 pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_SM2, NULL);
ddb634fe
JL		 1034 if (!TEST_ptr(pctx))
1035 goto done;
1036
1037 if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
1038 goto done;
1039
d0b79f86 1040 /* TODO is this even needed? */
ddb634fe
JL		 1041 if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
1042 goto done;
1043
bfb56a97 1044 if (!TEST_true(EVP_PKEY_paramgen(pctx, &pkeyparams)))
ddb634fe
JL		 1045 goto done;
1046
bfb56a97 1047 kctx = EVP_PKEY_CTX_new(pkeyparams, NULL);
ddb634fe
JL		 1048 if (!TEST_ptr(kctx))
1049 goto done;
1050
1051 if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
1052 goto done;
1053
1054 if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
1055 goto done;
1056
ddb634fe
JL		 1057 if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
1058 goto done;
1059
1060 if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
1061 goto done;
1062
4803717f
PY		 1063 if (!TEST_ptr(sctx = EVP_PKEY_CTX_new(pkey, NULL)))
1064 goto done;
1065
1066 EVP_MD_CTX_set_pkey_ctx(md_ctx, sctx);
1067 EVP_MD_CTX_set_pkey_ctx(md_ctx_verify, sctx);
1068
d0b79f86 1069 if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
4803717f
PY		 1070 goto done;
1071
d0b79f86 1072 if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
ddb634fe
JL		 1073 goto done;
1074
1075 if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
1076 goto done;
1077
1078 /* Determine the size of the signature. */
1079 if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
1080 goto done;
1081
ddb634fe
JL		 1082 if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
1083 goto done;
1084
1085 if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
1086 goto done;
1087
1088 /* Ensure that the signature round-trips. */
1089
1090 if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
1091 goto done;
1092
d0b79f86
PY		 1093 if (!TEST_int_gt(EVP_PKEY_CTX_set1_id(sctx, sm2_id, sizeof(sm2_id)), 0))
1094 goto done;
1095
ddb634fe
JL		 1096 if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
1097 goto done;
1098
1099 if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
1100 goto done;
1101
1102 /* now check encryption/decryption */
1103
bfb56a97
MC		 1104 gparams[0] = OSSL_PARAM_construct_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST,
1105 mdname, sizeof(mdname));
1106 for (i = 0; i < 2; i++) {
1107 EVP_PKEY_CTX_free(cctx);
ddb634fe 1108
bfb56a97
MC		 1109 sparams[0] = OSSL_PARAM_construct_utf8_string(OSSL_ASYM_CIPHER_PARAM_DIGEST,
1110 i == 0 ? "SM3" : "SHA2-256",
1111 0);
ddb634fe 1112
bfb56a97
MC		 1113 if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
1114 goto done;
ddb634fe 1115
bfb56a97
MC		 1116 if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
1117 goto done;
ddb634fe 1118
bfb56a97
MC		 1119 if (!TEST_true(EVP_PKEY_CTX_set_params(cctx, sparams)))
1120 goto done;
ddb634fe 1121
bfb56a97
MC		 1122 if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg,
1123 sizeof(kMsg))))
1124 goto done;
ddb634fe 1125
bfb56a97
MC		 1126 if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
1127 goto done;
1128
1129 if (!TEST_true(EVP_PKEY_CTX_set_params(cctx, sparams)))
1130 goto done;
1131
1132 if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext,
1133 ctext_len)))
1134 goto done;
1135
1136 if (!TEST_true(EVP_PKEY_CTX_get_params(cctx, gparams)))
1137 goto done;
1138
1139 /* Test we're still using the digest we think we are */
1140 if (i == 0 && !TEST_int_eq(strcmp(mdname, "SM3"), 0))
1141 goto done;
1142 if (i == 1 && !TEST_int_eq(strcmp(mdname, "SHA2-256"), 0))
1143 goto done;
1144
1145 if (!TEST_true(ptext_len == sizeof(kMsg)))
1146 goto done;
1147
1148 if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
1149 goto done;
1150 }
ddb634fe
JL		 1151
1152 ret = 1;
1153done:
1154 EVP_PKEY_CTX_free(pctx);
1155 EVP_PKEY_CTX_free(kctx);
4803717f 1156 EVP_PKEY_CTX_free(sctx);
ddb634fe
JL		 1157 EVP_PKEY_CTX_free(cctx);
1158 EVP_PKEY_free(pkey);
bfb56a97 1159 EVP_PKEY_free(pkeyparams);
ddb634fe
JL		 1160 EVP_MD_CTX_free(md_ctx);
1161 EVP_MD_CTX_free(md_ctx_verify);
1162 OPENSSL_free(sig);
1163 return ret;
1164}
1165
1166#endif
1167
bb5f281a
MC		 1168static struct keys_st {
1169 int type;
1170 char *priv;
1171 char *pub;
1172} keys[] = {
1173 {
1174 EVP_PKEY_HMAC, "0123456789", NULL
1175 }, {
1176 EVP_PKEY_POLY1305, "01234567890123456789012345678901", NULL
1177 }, {
1178 EVP_PKEY_SIPHASH, "0123456789012345", NULL
896dcb80
MC		 1179 },
1180#ifndef OPENSSL_NO_EC
1181 {
bb5f281a
MC		 1182 EVP_PKEY_X25519, "01234567890123456789012345678901",
1183 "abcdefghijklmnopqrstuvwxyzabcdef"
1184 }, {
1185 EVP_PKEY_ED25519, "01234567890123456789012345678901",
1186 "abcdefghijklmnopqrstuvwxyzabcdef"
1187 }, {
1188 EVP_PKEY_X448,
1189 "01234567890123456789012345678901234567890123456789012345",
1190 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd"
1191 }, {
1192 EVP_PKEY_ED448,
1193 "012345678901234567890123456789012345678901234567890123456",
1194 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcde"
1195 }
896dcb80 1196#endif
bb5f281a
MC		 1197};
1198
86dc26ba 1199static int test_set_get_raw_keys_int(int tst, int pub, int uselibctx)
bb5f281a
MC		 1200{
1201 int ret = 0;
1202 unsigned char buf[80];
1203 unsigned char *in;
1204 size_t inlen, len = 0;
1205 EVP_PKEY *pkey;
1206
1207 /* Check if this algorithm supports public keys */
1208 if (keys[tst].pub == NULL)
1209 return 1;
1210
1211 memset(buf, 0, sizeof(buf));
1212
1213 if (pub) {
1214 inlen = strlen(keys[tst].pub);
1215 in = (unsigned char *)keys[tst].pub;
86dc26ba 1216 if (uselibctx) {
d8652be0 1217 pkey = EVP_PKEY_new_raw_public_key_ex(
86dc26ba
MC		 1218 testctx,
1219 OBJ_nid2sn(keys[tst].type),
1220 NULL,
1221 in,
1222 inlen);
1223 } else {
1224 pkey = EVP_PKEY_new_raw_public_key(keys[tst].type,
1225 NULL,
1226 in,
1227 inlen);
1228 }
bb5f281a
MC		 1229 } else {
1230 inlen = strlen(keys[tst].priv);
1231 in = (unsigned char *)keys[tst].priv;
86dc26ba 1232 if (uselibctx) {
d8652be0 1233 pkey = EVP_PKEY_new_raw_private_key_ex(
86dc26ba
MC		 1234 testctx, OBJ_nid2sn(keys[tst].type),
1235 NULL,
1236 in,
1237 inlen);
1238 } else {
1239 pkey = EVP_PKEY_new_raw_private_key(keys[tst].type,
1240 NULL,
1241 in,
1242 inlen);
1243 }
bb5f281a
MC		 1244 }
1245
1246 if (!TEST_ptr(pkey)
1247 || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, NULL, &len)))
1248 || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, NULL, &len)))
1249 || !TEST_true(len == inlen)
1250 || (!pub && !TEST_true(EVP_PKEY_get_raw_private_key(pkey, buf, &len)))
1251 || (pub && !TEST_true(EVP_PKEY_get_raw_public_key(pkey, buf, &len)))
1252 || !TEST_mem_eq(in, inlen, buf, len))
1253 goto done;
1254
1255 ret = 1;
1256 done:
1257 EVP_PKEY_free(pkey);
1258 return ret;
1259}
1260
1261static int test_set_get_raw_keys(int tst)
1262{
86dc26ba
MC		 1263 return test_set_get_raw_keys_int(tst, 0, 0)
1264 && test_set_get_raw_keys_int(tst, 0, 1)
1265 && test_set_get_raw_keys_int(tst, 1, 0)
1266 && test_set_get_raw_keys_int(tst, 1, 1);
bb5f281a
MC		 1267}
1268
41bbba53 1269#ifndef OPENSSL_NO_DEPRECATED_3_0
2aee35d3
PY		 1270static int pkey_custom_check(EVP_PKEY *pkey)
1271{
1272 return 0xbeef;
1273}
1274
b0004708
PY		 1275static int pkey_custom_pub_check(EVP_PKEY *pkey)
1276{
1277 return 0xbeef;
1278}
1279
1280static int pkey_custom_param_check(EVP_PKEY *pkey)
1281{
1282 return 0xbeef;
1283}
1284
2aee35d3 1285static EVP_PKEY_METHOD *custom_pmeth;
41bbba53 1286#endif
2aee35d3
PY		 1287
1288static int test_EVP_PKEY_check(int i)
1289{
1290 int ret = 0;
1291 const unsigned char *p;
1292 EVP_PKEY *pkey = NULL;
8a8bc665 1293#ifndef OPENSSL_NO_EC
b0004708 1294 EC_KEY *eckey = NULL;
8a8bc665 1295#endif
2aee35d3 1296 EVP_PKEY_CTX *ctx = NULL;
41bbba53 1297#ifndef OPENSSL_NO_DEPRECATED_3_0
2aee35d3 1298 EVP_PKEY_CTX *ctx2 = NULL;
41bbba53 1299#endif
2aee35d3
PY		 1300 const APK_DATA *ak = &keycheckdata[i];
1301 const unsigned char *input = ak->kder;
1302 size_t input_len = ak->size;
1303 int expected_id = ak->evptype;
1304 int expected_check = ak->check;
b0004708
PY		 1305 int expected_pub_check = ak->pub_check;
1306 int expected_param_check = ak->param_check;
1307 int type = ak->type;
1308 BIO *pubkey = NULL;
2aee35d3
PY		 1309
1310 p = input;
b0004708 1311
35db366c
DMSP		 1312 switch (type) {
1313 case 0:
1314 if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
1315 || !TEST_ptr_eq(p, input + input_len)
1316 || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
1317 goto done;
1318 break;
8a8bc665 1319#ifndef OPENSSL_NO_EC
35db366c
DMSP		 1320 case 1:
1321 if (!TEST_ptr(pubkey = BIO_new_mem_buf(input, input_len))
1322 || !TEST_ptr(eckey = d2i_EC_PUBKEY_bio(pubkey, NULL))
1323 || !TEST_ptr(pkey = EVP_PKEY_new())
1324 || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1325 goto done;
1326 break;
1327 case 2:
1328 if (!TEST_ptr(eckey = d2i_ECParameters(NULL, &p, input_len))
1329 || !TEST_ptr_eq(p, input + input_len)
1330 || !TEST_ptr(pkey = EVP_PKEY_new())
1331 || !TEST_true(EVP_PKEY_assign_EC_KEY(pkey, eckey)))
1332 goto done;
1333 break;
8a8bc665 1334#endif
35db366c
DMSP		 1335 default:
1336 return 0;
1337 }
2aee35d3
PY		 1338
1339 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)))
1340 goto done;
1341
b0004708
PY		 1342 if (!TEST_int_eq(EVP_PKEY_check(ctx), expected_check))
1343 goto done;
1344
1345 if (!TEST_int_eq(EVP_PKEY_public_check(ctx), expected_pub_check))
1346 goto done;
1347
1348 if (!TEST_int_eq(EVP_PKEY_param_check(ctx), expected_param_check))
1349 goto done;
2aee35d3 1350
41bbba53 1351#ifndef OPENSSL_NO_DEPRECATED_3_0
2aee35d3
PY		 1352 ctx2 = EVP_PKEY_CTX_new_id(0xdefaced, NULL);
1353 /* assign the pkey directly, as an internal test */
1354 EVP_PKEY_up_ref(pkey);
1355 ctx2->pkey = pkey;
1356
1357 if (!TEST_int_eq(EVP_PKEY_check(ctx2), 0xbeef))
1358 goto done;
1359
b0004708
PY		 1360 if (!TEST_int_eq(EVP_PKEY_public_check(ctx2), 0xbeef))
1361 goto done;
1362
1363 if (!TEST_int_eq(EVP_PKEY_param_check(ctx2), 0xbeef))
1364 goto done;
41bbba53 1365#endif
b0004708 1366
2aee35d3
PY		 1367 ret = 1;
1368
1369 done:
1370 EVP_PKEY_CTX_free(ctx);
41bbba53 1371#ifndef OPENSSL_NO_DEPRECATED_3_0
2aee35d3 1372 EVP_PKEY_CTX_free(ctx2);
41bbba53 1373#endif
2aee35d3 1374 EVP_PKEY_free(pkey);
b0004708 1375 BIO_free(pubkey);
2aee35d3
PY		 1376 return ret;
1377}
1378
fab8fde3 1379#ifndef OPENSSL_NO_CMAC
e5bc0ce2
MC		 1380static int get_cmac_val(EVP_PKEY *pkey, unsigned char *mac)
1381{
1382 EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
1383 const char msg[] = "Hello World";
1384 size_t maclen;
1385 int ret = 1;
1386
1387 if (!TEST_ptr(mdctx)
1388 || !TEST_true(EVP_DigestSignInit(mdctx, NULL, NULL, NULL, pkey))
1389 || !TEST_true(EVP_DigestSignUpdate(mdctx, msg, sizeof(msg)))
1390 || !TEST_true(EVP_DigestSignFinal(mdctx, mac, &maclen))
1391 || !TEST_size_t_eq(maclen, AES_BLOCK_SIZE))
1392 ret = 0;
1393
1394 EVP_MD_CTX_free(mdctx);
1395
1396 return ret;
1397}
a87820e1
RL		 1398static int test_CMAC_keygen(void)
1399{
e5bc0ce2
MC		 1400 static unsigned char key[] = {
1401 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1402 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1403 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f
1404 };
a87820e1
RL		 1405 /*
1406 * This is a legacy method for CMACs, but should still work.
1407 * This verifies that it works without an ENGINE.
1408 */
1409 EVP_PKEY_CTX *kctx = EVP_PKEY_CTX_new_id(EVP_PKEY_CMAC, NULL);
1410 int ret = 0;
e5bc0ce2
MC		 1411 EVP_PKEY *pkey = NULL;
1412 unsigned char mac[AES_BLOCK_SIZE], mac2[AES_BLOCK_SIZE];
1413
1414 /* Test a CMAC key created using the "generated" method */
1415 if (!TEST_int_gt(EVP_PKEY_keygen_init(kctx), 0)
1416 || !TEST_int_gt(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
1417 EVP_PKEY_CTRL_CIPHER,
1418 0, (void *)EVP_aes_256_ecb()), 0)
1419 || !TEST_int_gt(EVP_PKEY_CTX_ctrl(kctx, -1, EVP_PKEY_OP_KEYGEN,
1420 EVP_PKEY_CTRL_SET_MAC_KEY,
1421 sizeof(key), (void *)key), 0)
1422 || !TEST_int_gt(EVP_PKEY_keygen(kctx, &pkey), 0)
1423 || !TEST_ptr(pkey)
1424 || !TEST_true(get_cmac_val(pkey, mac)))
1425 goto done;
a87820e1 1426
e5bc0ce2
MC		 1427 EVP_PKEY_free(pkey);
1428
1429 /*
1430 * Test a CMAC key using the direct method, and compare with the mac
1431 * created above.
1432 */
1433 pkey = EVP_PKEY_new_CMAC_key(NULL, key, sizeof(key), EVP_aes_256_ecb());
1434 if (!TEST_ptr(pkey)
1435 || !TEST_true(get_cmac_val(pkey, mac2))
1436 || !TEST_mem_eq(mac, sizeof(mac), mac2, sizeof(mac2)))
a87820e1 1437 goto done;
e5bc0ce2 1438
a87820e1
RL		 1439 ret = 1;
1440
1441 done:
e5bc0ce2 1442 EVP_PKEY_free(pkey);
a87820e1
RL		 1443 EVP_PKEY_CTX_free(kctx);
1444 return ret;
1445}
fab8fde3 1446#endif
a87820e1 1447
10d5b415
MC		 1448static int test_HKDF(void)
1449{
1450 EVP_PKEY_CTX *pctx;
1451 unsigned char out[20];
1452 size_t outlen;
1453 int i, ret = 0;
1454 unsigned char salt[] = "0123456789";
1455 unsigned char key[] = "012345678901234567890123456789";
1456 unsigned char info[] = "infostring";
1457 const unsigned char expected[] = {
1458 0xe5, 0x07, 0x70, 0x7f, 0xc6, 0x78, 0xd6, 0x54, 0x32, 0x5f, 0x7e, 0xc5,
1459 0x7b, 0x59, 0x3e, 0xd8, 0x03, 0x6b, 0xed, 0xca
1460 };
1461 size_t expectedlen = sizeof(expected);
1462
1463 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1464 goto done;
1465
1466 /* We do this twice to test reuse of the EVP_PKEY_CTX */
1467 for (i = 0; i < 2; i++) {
1468 outlen = sizeof(out);
1469 memset(out, 0, outlen);
1470
1471 if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1472 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1473 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1474 sizeof(salt) - 1), 0)
1475 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1476 sizeof(key) - 1), 0)
1477 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1478 sizeof(info) - 1), 0)
1479 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1480 || !TEST_mem_eq(out, outlen, expected, expectedlen))
1481 goto done;
1482 }
1483
1484 ret = 1;
1485
1486 done:
1487 EVP_PKEY_CTX_free(pctx);
1488
1489 return ret;
1490}
1491
2cd3ebc7
BK		 1492static int test_emptyikm_HKDF(void)
1493{
1494 EVP_PKEY_CTX *pctx;
1495 unsigned char out[20];
1496 size_t outlen;
1497 int ret = 0;
1498 unsigned char salt[] = "9876543210";
1499 unsigned char key[] = "";
1500 unsigned char info[] = "stringinfo";
1501 const unsigned char expected[] = {
1502 0x68, 0x81, 0xa5, 0x3e, 0x5b, 0x9c, 0x7b, 0x6f, 0x2e, 0xec, 0xc8, 0x47,
1503 0x7c, 0xfa, 0x47, 0x35, 0x66, 0x82, 0x15, 0x30
1504 };
1505 size_t expectedlen = sizeof(expected);
1506
1507 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL)))
1508 goto done;
1509
1510 outlen = sizeof(out);
1511 memset(out, 0, outlen);
1512
1513 if (!TEST_int_gt(EVP_PKEY_derive_init(pctx), 0)
1514 || !TEST_int_gt(EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()), 0)
1515 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt,
1516 sizeof(salt) - 1), 0)
1517 || !TEST_int_gt(EVP_PKEY_CTX_set1_hkdf_key(pctx, key,
1518 sizeof(key) - 1), 0)
1519 || !TEST_int_gt(EVP_PKEY_CTX_add1_hkdf_info(pctx, info,
1520 sizeof(info) - 1), 0)
1521 || !TEST_int_gt(EVP_PKEY_derive(pctx, out, &outlen), 0)
1522 || !TEST_mem_eq(out, outlen, expected, expectedlen))
1523 goto done;
1524
1525 ret = 1;
1526
1527 done:
1528 EVP_PKEY_CTX_free(pctx);
1529
1530 return ret;
1531}
1532
5dc40a83
BE		 1533#ifndef OPENSSL_NO_EC
1534static int test_X509_PUBKEY_inplace(void)
1535{
1536 int ret = 0;
1537 X509_PUBKEY *xp = NULL;
1538 const unsigned char *p = kExampleECPubKeyDER;
1539 size_t input_len = sizeof(kExampleECPubKeyDER);
1540
1541 if (!TEST_ptr(xp = d2i_X509_PUBKEY(NULL, &p, input_len)))
1542 goto done;
1543
1544 if (!TEST_ptr(X509_PUBKEY_get0(xp)))
1545 goto done;
1546
1547 p = kExampleBadECPubKeyDER;
1548 input_len = sizeof(kExampleBadECPubKeyDER);
1549
1550 if (!TEST_ptr(xp = d2i_X509_PUBKEY(&xp, &p, input_len)))
1551 goto done;
1552
1553 if (!TEST_true(X509_PUBKEY_get0(xp) == NULL))
1554 goto done;
1555
1556 ret = 1;
1557
1558done:
1559 X509_PUBKEY_free(xp);
1560 return ret;
1561}
7bb82f92 1562#endif /* OPENSSL_NO_EC */
784883fc 1563
9c45222d 1564/* Test getting and setting parameters on an EVP_PKEY_CTX */
f54a4101 1565static int test_EVP_PKEY_CTX_get_set_params(EVP_PKEY *pkey)
9c45222d 1566{
9a071fef 1567 EVP_MD_CTX *mdctx = NULL;
9c45222d 1568 EVP_PKEY_CTX *ctx = NULL;
9c45222d 1569 const OSSL_PARAM *params;
00bc1ad9 1570 OSSL_PARAM ourparams[2], *param = ourparams, *param_md;
9c45222d
MC		 1571 int ret = 0;
1572 const EVP_MD *md;
00bc1ad9 1573 char mdname[OSSL_MAX_NAME_SIZE];
9a071fef 1574 char ssl3ms[48];
9c45222d 1575
9c45222d
MC		 1576 /* Initialise a sign operation */
1577 ctx = EVP_PKEY_CTX_new(pkey, NULL);
9c45222d 1578 if (!TEST_ptr(ctx)
c9c4a356 1579 || !TEST_int_gt(EVP_PKEY_sign_init(ctx), 0))
9c45222d
MC		 1580 goto err;
1581
1582 /*
f54a4101 1583 * We should be able to query the parameters now.
9c45222d
MC		 1584 */
1585 params = EVP_PKEY_CTX_settable_params(ctx);
1586 if (!TEST_ptr(params)
0cb3f4f9
RL		 1587 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1588 OSSL_SIGNATURE_PARAM_DIGEST)))
9c45222d
MC		 1589 goto err;
1590
9c45222d
MC		 1591 params = EVP_PKEY_CTX_gettable_params(ctx);
1592 if (!TEST_ptr(params)
0cb3f4f9
RL		 1593 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1594 OSSL_SIGNATURE_PARAM_ALGORITHM_ID))
0cb3f4f9
RL		 1595 || !TEST_ptr(OSSL_PARAM_locate_const(params,
1596 OSSL_SIGNATURE_PARAM_DIGEST)))
9c45222d
MC		 1597 goto err;
1598
1599 /*
1600 * Test getting and setting params via EVP_PKEY_CTX_set_params() and
1601 * EVP_PKEY_CTX_get_params()
1602 */
00bc1ad9
RL		 1603 strcpy(mdname, "SHA512");
1604 param_md = param;
1605 *param++ = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1606 mdname, 0);
9c45222d
MC		 1607 *param++ = OSSL_PARAM_construct_end();
1608
1609 if (!TEST_true(EVP_PKEY_CTX_set_params(ctx, ourparams)))
1610 goto err;
1611
00bc1ad9
RL		 1612 mdname[0] = '\0';
1613 *param_md = OSSL_PARAM_construct_utf8_string(OSSL_SIGNATURE_PARAM_DIGEST,
1614 mdname, sizeof(mdname));
9c45222d 1615 if (!TEST_true(EVP_PKEY_CTX_get_params(ctx, ourparams))
00bc1ad9 1616 || !TEST_str_eq(mdname, "SHA512"))
9c45222d
MC		 1617 goto err;
1618
1619 /*
1620 * Test the TEST_PKEY_CTX_set_signature_md() and
1621 * TEST_PKEY_CTX_get_signature_md() functions
1622 */
1623 if (!TEST_int_gt(EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()), 0)
1624 || !TEST_int_gt(EVP_PKEY_CTX_get_signature_md(ctx, &md), 0)
1625 || !TEST_ptr_eq(md, EVP_sha256()))
1626 goto err;
1627
9a071fef
MC		 1628 /*
1629 * Test getting MD parameters via an associated EVP_PKEY_CTX
1630 */
1631 mdctx = EVP_MD_CTX_new();
1632 if (!TEST_ptr(mdctx)
d8652be0
MC		 1633 || !TEST_true(EVP_DigestSignInit_ex(mdctx, NULL, "SHA1", NULL, NULL,
1634 pkey)))
9a071fef
MC		 1635 goto err;
1636
1637 /*
1638 * We now have an EVP_MD_CTX with an EVP_PKEY_CTX inside it. We should be
1639 * able to obtain the digest's settable parameters from the provider.
1640 */
1641 params = EVP_MD_CTX_settable_params(mdctx);
1642 if (!TEST_ptr(params)
1643 || !TEST_int_eq(strcmp(params[0].key, OSSL_DIGEST_PARAM_SSL3_MS), 0)
1644 /* The final key should be NULL */
1645 || !TEST_ptr_null(params[1].key))
1646 goto err;
1647
1648 param = ourparams;
1649 memset(ssl3ms, 0, sizeof(ssl3ms));
1650 *param++ = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
1651 ssl3ms, sizeof(ssl3ms));
1652 *param++ = OSSL_PARAM_construct_end();
1653
1654 if (!TEST_true(EVP_MD_CTX_set_params(mdctx, ourparams)))
1655 goto err;
1656
9c45222d
MC		 1657 ret = 1;
1658
1659 err:
9a071fef 1660 EVP_MD_CTX_free(mdctx);
9c45222d 1661 EVP_PKEY_CTX_free(ctx);
f54a4101
RL		 1662
1663 return ret;
1664}
1665
1666#ifndef OPENSSL_NO_DSA
1667static int test_DSA_get_set_params(void)
1668{
6ed4022c
RL		 1669 OSSL_PARAM_BLD *bld = NULL;
1670 OSSL_PARAM *params = NULL;
f54a4101 1671 BIGNUM *p = NULL, *q = NULL, *g = NULL, *pub = NULL, *priv = NULL;
6ed4022c 1672 EVP_PKEY_CTX *pctx = NULL;
f54a4101
RL		 1673 EVP_PKEY *pkey = NULL;
1674 int ret = 0;
1675
1676 /*
1677 * Setup the parameters for our DSA object. For our purposes they don't
1678 * have to actually be *valid* parameters. We just need to set something.
1679 */
6ed4022c
RL		 1680 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "DSA", NULL))
1681 || !TEST_ptr(bld = OSSL_PARAM_BLD_new())
1682 || !TEST_ptr(p = BN_new())
1683 || !TEST_ptr(q = BN_new())
1684 || !TEST_ptr(g = BN_new())
1685 || !TEST_ptr(pub = BN_new())
1686 || !TEST_ptr(priv = BN_new()))
1687 goto err;
1688 if (!TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_P, p))
1689 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_Q, q))
1690 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_FFC_G, g))
1691 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PUB_KEY,
1692 pub))
1693 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
1694 priv)))
1695 goto err;
1696 if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
f54a4101 1697 goto err;
f54a4101 1698
6ed4022c
RL		 1699 if (!TEST_int_gt(EVP_PKEY_key_fromdata_init(pctx), 0)
1700 || !TEST_int_gt(EVP_PKEY_fromdata(pctx, &pkey, params), 0))
f54a4101
RL		 1701 goto err;
1702
6ed4022c
RL		 1703 if (!TEST_ptr(pkey))
1704 goto err;
f54a4101
RL		 1705
1706 ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1707
1708 err:
9c45222d 1709 EVP_PKEY_free(pkey);
6ed4022c
RL		 1710 EVP_PKEY_CTX_free(pctx);
1711 OSSL_PARAM_BLD_free_params(params);
1712 OSSL_PARAM_BLD_free(bld);
9c45222d
MC		 1713 BN_free(p);
1714 BN_free(q);
1715 BN_free(g);
cd32a0f5
RL		 1716 BN_free(pub);
1717 BN_free(priv);
9c45222d
MC		 1718
1719 return ret;
1720}
8d0f8c81 1721#endif
9c45222d 1722
f54a4101
RL		 1723static int test_RSA_get_set_params(void)
1724{
d7e498ac
RL		 1725 OSSL_PARAM_BLD *bld = NULL;
1726 OSSL_PARAM *params = NULL;
f54a4101 1727 BIGNUM *n = NULL, *e = NULL, *d = NULL;
d7e498ac 1728 EVP_PKEY_CTX *pctx = NULL;
f54a4101
RL		 1729 EVP_PKEY *pkey = NULL;
1730 int ret = 0;
1731
1732 /*
1733 * Setup the parameters for our RSA object. For our purposes they don't
1734 * have to actually be *valid* parameters. We just need to set something.
1735 */
d7e498ac
RL		 1736 if (!TEST_ptr(pctx = EVP_PKEY_CTX_new_from_name(testctx, "RSA", NULL))
1737 || !TEST_ptr(bld = OSSL_PARAM_BLD_new())
1738 || !TEST_ptr(n = BN_new())
1739 || !TEST_ptr(e = BN_new())
1740 || !TEST_ptr(d = BN_new()))
1741 goto err;
1742 if (!TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n))
1743 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e))
1744 || !TEST_true(OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d)))
1745 goto err;
1746 if (!TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld)))
f54a4101 1747 goto err;
f54a4101 1748
d7e498ac
RL		 1749 if (!TEST_int_gt(EVP_PKEY_key_fromdata_init(pctx), 0)
1750 || !TEST_int_gt(EVP_PKEY_fromdata(pctx, &pkey, params), 0))
f54a4101
RL		 1751 goto err;
1752
d7e498ac
RL		 1753 if (!TEST_ptr(pkey))
1754 goto err;
f54a4101
RL		 1755
1756 ret = test_EVP_PKEY_CTX_get_set_params(pkey);
1757
1758 err:
1759 EVP_PKEY_free(pkey);
d7e498ac
RL		 1760 EVP_PKEY_CTX_free(pctx);
1761 OSSL_PARAM_BLD_free_params(params);
1762 OSSL_PARAM_BLD_free(bld);
f54a4101
RL		 1763 BN_free(n);
1764 BN_free(e);
1765 BN_free(d);
1766
1767 return ret;
1768}
1769
b4be6937
MC		 1770#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
1771static int test_decrypt_null_chunks(void)
1772{
1773 EVP_CIPHER_CTX* ctx = NULL;
1774 const unsigned char key[32] = {
1775 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
1776 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1777 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1
1778 };
1779 unsigned char iv[12] = {
1780 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b
1781 };
1782 unsigned char msg[] = "It was the best of times, it was the worst of times";
1783 unsigned char ciphertext[80];
1784 unsigned char plaintext[80];
1785 /* We initialise tmp to a non zero value on purpose */
1786 int ctlen, ptlen, tmp = 99;
1787 int ret = 0;
1788 const int enc_offset = 10, dec_offset = 20;
1789
1790 if (!TEST_ptr(ctx = EVP_CIPHER_CTX_new())
1791 || !TEST_true(EVP_EncryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL,
1792 key, iv))
1793 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &ctlen, msg,
1794 enc_offset))
1795 /* Deliberate add a zero length update */
1796 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp, NULL,
1797 0))
1798 || !TEST_int_eq(tmp, 0)
1799 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext + ctlen, &tmp,
1800 msg + enc_offset,
1801 sizeof(msg) - enc_offset))
1802 || !TEST_int_eq(ctlen += tmp, sizeof(msg))
1803 || !TEST_true(EVP_EncryptFinal(ctx, ciphertext + ctlen, &tmp))
1804 || !TEST_int_eq(tmp, 0))
1805 goto err;
1806
1807 /* Deliberately initialise tmp to a non zero value */
1808 tmp = 99;
1809 if (!TEST_true(EVP_DecryptInit_ex(ctx, EVP_chacha20_poly1305(), NULL, key,
1810 iv))
1811 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext, &ptlen, ciphertext,
1812 dec_offset))
1813 /*
1814 * Deliberately add a zero length update. We also deliberately do
1815 * this at a different offset than for encryption.
1816 */
1817 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp, NULL,
1818 0))
1819 || !TEST_int_eq(tmp, 0)
1820 || !TEST_true(EVP_DecryptUpdate(ctx, plaintext + ptlen, &tmp,
1821 ciphertext + dec_offset,
1822 ctlen - dec_offset))
1823 || !TEST_int_eq(ptlen += tmp, sizeof(msg))
1824 || !TEST_true(EVP_DecryptFinal(ctx, plaintext + ptlen, &tmp))
1825 || !TEST_int_eq(tmp, 0)
1826 || !TEST_mem_eq(msg, sizeof(msg), plaintext, ptlen))
1827 goto err;
1828
1829 ret = 1;
1830 err:
1831 EVP_CIPHER_CTX_free(ctx);
1832 return ret;
1833}
1834#endif /* !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305) */
1835
d4c2f498 1836#if !defined(OPENSSL_NO_DH) && !defined(OPENSSL_NO_DEPRECATED_3_0)
e295de1d
MC		 1837static int test_EVP_PKEY_set1_DH(void)
1838{
ca2bf555
SL		 1839 DH *x942dh = NULL, *noqdh = NULL;
1840 EVP_PKEY *pkey1 = NULL, *pkey2 = NULL;
e295de1d 1841 int ret = 0;
ca2bf555
SL		 1842 BIGNUM *p, *g = NULL;
1843
1844 if (!TEST_ptr(p = BN_new())
1845 || !TEST_ptr(g = BN_new())
1846 || !BN_set_word(p, 9999)
1847 || !BN_set_word(g, 2)
1848 || !TEST_ptr(noqdh = DH_new())
1849 || !DH_set0_pqg(noqdh, p, NULL, g))
1850 goto err;
1851 p = g = NULL;
e295de1d
MC		 1852
1853 x942dh = DH_get_2048_256();
e295de1d
MC		 1854 pkey1 = EVP_PKEY_new();
1855 pkey2 = EVP_PKEY_new();
1856 if (!TEST_ptr(x942dh)
ca2bf555 1857 || !TEST_ptr(noqdh)
e295de1d
MC		 1858 || !TEST_ptr(pkey1)
1859 || !TEST_ptr(pkey2))
1860 goto err;
1861
1862 if(!TEST_true(EVP_PKEY_set1_DH(pkey1, x942dh))
1863 || !TEST_int_eq(EVP_PKEY_id(pkey1), EVP_PKEY_DHX))
1864 goto err;
1865
ca2bf555 1866 if(!TEST_true(EVP_PKEY_set1_DH(pkey2, noqdh))
e295de1d
MC		 1867 || !TEST_int_eq(EVP_PKEY_id(pkey2), EVP_PKEY_DH))
1868 goto err;
1869
1870 ret = 1;
1871 err:
ca2bf555
SL		 1872 BN_free(p);
1873 BN_free(g);
e295de1d
MC		 1874 EVP_PKEY_free(pkey1);
1875 EVP_PKEY_free(pkey2);
1876 DH_free(x942dh);
ca2bf555 1877 DH_free(noqdh);
e295de1d
MC		 1878
1879 return ret;
1880}
501fcfb8 1881#endif
e295de1d 1882
8a5cb596
RL		 1883/*
1884 * We test what happens with an empty template. For the sake of this test,
1885 * the template must be ignored, and we know that's the case for RSA keys
1886 * (this might arguably be a misfeature, but that's what we currently do,
1887 * even in provider code, since that's how the legacy RSA implementation
1888 * does things)
1889 */
1890static int test_keygen_with_empty_template(int n)
1891{
1892 EVP_PKEY_CTX *ctx = NULL;
1893 EVP_PKEY *pkey = NULL;
1894 EVP_PKEY *tkey = NULL;
1895 int ret = 0;
1896
1897 switch (n) {
1898 case 0:
1899 /* We do test with no template at all as well */
1900 if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL)))
1901 goto err;
1902 break;
1903 case 1:
1904 /* Here we create an empty RSA key that serves as our template */
1905 if (!TEST_ptr(tkey = EVP_PKEY_new())
1906 || !TEST_true(EVP_PKEY_set_type(tkey, EVP_PKEY_RSA))
1907 || !TEST_ptr(ctx = EVP_PKEY_CTX_new(tkey, NULL)))
1908 goto err;
1909 break;
1910 }
1911
1912 if (!TEST_int_gt(EVP_PKEY_keygen_init(ctx), 0)
1913 || !TEST_int_gt(EVP_PKEY_keygen(ctx, &pkey), 0))
1914 goto err;
1915
1916 ret = 1;
1917 err:
1918 EVP_PKEY_CTX_free(ctx);
1919 EVP_PKEY_free(pkey);
1920 EVP_PKEY_free(tkey);
1921 return ret;
1922}
1923
5ddec6a7
MC		 1924/*
1925 * Test that we fail if we attempt to use an algorithm that is not available
08497fc6
RL		 1926 * in the current library context (unless we are using an algorithm that
1927 * should be made available via legacy codepaths).
1928 *
1929 * 0: RSA
1930 * 1: SM2
5ddec6a7
MC		 1931 */
1932static int test_pkey_ctx_fail_without_provider(int tst)
1933{
b4250010 1934 OSSL_LIB_CTX *tmpctx = OSSL_LIB_CTX_new();
5ddec6a7
MC		 1935 OSSL_PROVIDER *nullprov = NULL;
1936 EVP_PKEY_CTX *pctx = NULL;
08497fc6
RL		 1937 const char *keytype = NULL;
1938 int expect_null = 0;
5ddec6a7
MC		 1939 int ret = 0;
1940
1941 if (!TEST_ptr(tmpctx))
1942 goto err;
1943
1944 nullprov = OSSL_PROVIDER_load(tmpctx, "null");
1945 if (!TEST_ptr(nullprov))
1946 goto err;
1947
5ddec6a7 1948 /*
08497fc6
RL		 1949 * We check for certain algos in the null provider.
1950 * If an algo is expected to have a provider keymgmt, contructing an
1951 * EVP_PKEY_CTX is expected to fail (return NULL).
1952 * Otherwise, if it's expected to have legacy support, contructing an
1953 * EVP_PKEY_CTX is expected to succeed (return non-NULL).
5ddec6a7 1954 */
08497fc6
RL		 1955 switch (tst) {
1956 case 0:
1957 keytype = "RSA";
1958 expect_null = 1;
1959 break;
1960 case 1:
1961 keytype = "SM2";
d0b79f86 1962 expect_null = 1;
08497fc6
RL		 1963#ifdef OPENSSL_NO_EC
1964 TEST_info("EC disable, skipping SM2 check...");
1965 goto end;
1966#endif
1967#ifdef OPENSSL_NO_SM2
1968 TEST_info("SM2 disable, skipping SM2 check...");
1969 goto end;
1970#endif
1971 break;
1972 default:
1973 TEST_error("No test for case %d", tst);
1974 goto err;
1975 }
1976
1977 pctx = EVP_PKEY_CTX_new_from_name(tmpctx, keytype, "");
1978 if (expect_null ? !TEST_ptr_null(pctx) : !TEST_ptr(pctx))
5ddec6a7
MC		 1979 goto err;
1980
08497fc6
RL		 1981#if defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_SM2)
1982 end:
1983#endif
5ddec6a7
MC		 1984 ret = 1;
1985
1986 err:
1987 EVP_PKEY_CTX_free(pctx);
1988 OSSL_PROVIDER_unload(nullprov);
b4250010 1989 OSSL_LIB_CTX_free(tmpctx);
5ddec6a7
MC		 1990 return ret;
1991}
1992
1c19ff3c
P		 1993static int test_rand_agglomeration(void)
1994{
1995 EVP_RAND *rand;
1996 EVP_RAND_CTX *ctx;
1997 OSSL_PARAM params[3], *p = params;
1998 int res;
1999 unsigned int step = 7;
2000 static unsigned char seed[] = "It does not matter how slowly you go "
2001 "as long as you do not stop.";
2002 unsigned char out[sizeof(seed)];
2003
2004 if (!TEST_int_ne(sizeof(seed) % step, 0)
2005 || !TEST_ptr(rand = EVP_RAND_fetch(NULL, "TEST-RAND", NULL)))
2006 return 0;
2007 ctx = EVP_RAND_CTX_new(rand, NULL);
2008 EVP_RAND_free(rand);
2009 if (!TEST_ptr(ctx))
2010 return 0;
2011
2012 memset(out, 0, sizeof(out));
2013 *p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY,
2014 seed, sizeof(seed));
0d4460d2 2015 *p++ = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_MAX_REQUEST, &step);
1c19ff3c
P		 2016 *p = OSSL_PARAM_construct_end();
2017 res = TEST_true(EVP_RAND_set_ctx_params(ctx, params))
2018 && TEST_true(EVP_RAND_generate(ctx, out, sizeof(out), 0, 1, NULL, 0))
2019 && TEST_mem_eq(seed, sizeof(seed), out, sizeof(out));
2020 EVP_RAND_CTX_free(ctx);
2021 return res;
2022}
2023
440b852a
BK		 2024/*
2025 * Test that we correctly return the original or "running" IV after
2026 * an encryption operation.
2027 * Run multiple times for some different relevant algorithms/modes.
2028 */
2029static int test_evp_iv(int idx)
2030{
2031 int ret = 0;
2032 EVP_CIPHER_CTX *ctx = NULL;
2033 unsigned char key[16] = {0x4c, 0x43, 0xdb, 0xdd, 0x42, 0x73, 0x47, 0xd1,
2034 0xe5, 0x62, 0x7d, 0xcd, 0x4d, 0x76, 0x4d, 0x57};
2035 unsigned char init_iv[EVP_MAX_IV_LENGTH] =
2036 {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98, 0x82,
2037 0x5a, 0x55, 0x91, 0x81, 0x42, 0xa8, 0x89, 0x34};
2038 static const unsigned char msg[] = { 1, 2, 3, 4, 5, 6, 7, 8,
2039 9, 10, 11, 12, 13, 14, 15, 16 };
2040 unsigned char ciphertext[32], oiv[16], iv[16];
2041 unsigned char *ref_iv;
2042 unsigned char cbc_state[16] = {0x10, 0x2f, 0x05, 0xcc, 0xc2, 0x55, 0x72, 0xb9,
2043 0x88, 0xe6, 0x4a, 0x17, 0x10, 0x74, 0x22, 0x5e};
2044
2045 unsigned char ofb_state[16] = {0x76, 0xe6, 0x66, 0x61, 0xd0, 0x8a, 0xe4, 0x64,
2046 0xdd, 0x66, 0xbf, 0x00, 0xf0, 0xe3, 0x6f, 0xfd};
2047 unsigned char gcm_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
2048 0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
2049 unsigned char ccm_state[7] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b, 0x98};
2050#ifndef OPENSSL_NO_OCB
2051 unsigned char ocb_state[12] = {0x57, 0x71, 0x7d, 0xad, 0xdb, 0x9b,
2052 0x98, 0x82, 0x5a, 0x55, 0x91, 0x81};
2053#endif
2054 int len = sizeof(ciphertext);
2055 size_t ivlen, ref_len;
2056 const EVP_CIPHER *type = NULL;
2057
2058 switch(idx) {
2059 case 0:
2060 type = EVP_aes_128_cbc();
2061 /* FALLTHROUGH */
2062 case 5:
2063 type = (type != NULL) ? type :
2064 EVP_CIPHER_fetch(testctx, "aes-128-cbc", NULL);
2065 ref_iv = cbc_state;
2066 ref_len = sizeof(cbc_state);
2067 break;
2068 case 1:
2069 type = EVP_aes_128_ofb();
2070 /* FALLTHROUGH */
2071 case 6:
2072 type = (type != NULL) ? type :
2073 EVP_CIPHER_fetch(testctx, "aes-128-ofb", NULL);
2074 ref_iv = ofb_state;
2075 ref_len = sizeof(ofb_state);
2076 break;
2077 case 2:
2078 type = EVP_aes_128_gcm();
2079 /* FALLTHROUGH */
2080 case 7:
2081 type = (type != NULL) ? type :
2082 EVP_CIPHER_fetch(testctx, "aes-128-gcm", NULL);
2083 ref_iv = gcm_state;
2084 ref_len = sizeof(gcm_state);
2085 break;
2086 case 3:
2087 type = EVP_aes_128_ccm();
2088 /* FALLTHROUGH */
2089 case 8:
2090 type = (type != NULL) ? type :
2091 EVP_CIPHER_fetch(testctx, "aes-128-ccm", NULL);
2092 ref_iv = ccm_state;
2093 ref_len = sizeof(ccm_state);
2094 break;
2095#ifdef OPENSSL_NO_OCB
2096 case 4:
2097 case 9:
2098 return 1;
2099#else
2100 case 4:
2101 type = EVP_aes_128_ocb();
2102 /* FALLTHROUGH */
2103 case 9:
2104 type = (type != NULL) ? type :
2105 EVP_CIPHER_fetch(testctx, "aes-128-ocb", NULL);
2106 ref_iv = ocb_state;
2107 ref_len = sizeof(ocb_state);
2108 break;
2109#endif
2110 default:
2111 return 0;
2112 }
2113
2114 if (!TEST_ptr(type)
2115 || !TEST_ptr((ctx = EVP_CIPHER_CTX_new()))
2116 || !TEST_true(EVP_EncryptInit_ex(ctx, type, NULL, key, init_iv))
2117 || !TEST_true(EVP_EncryptUpdate(ctx, ciphertext, &len, msg,
2118 (int)sizeof(msg)))
2119 || !TEST_true(EVP_CIPHER_CTX_get_iv(ctx, oiv, sizeof(oiv)))
2120 || !TEST_true(EVP_CIPHER_CTX_get_iv_state(ctx, iv, sizeof(iv)))
2121 || !TEST_true(EVP_EncryptFinal_ex(ctx, ciphertext, &len)))
2122 goto err;
2123 ivlen = EVP_CIPHER_CTX_iv_length(ctx);
2124 if (!TEST_mem_eq(init_iv, ivlen, oiv, ivlen)
2125 || !TEST_mem_eq(ref_iv, ref_len, iv, ivlen))
2126 goto err;
2127
2128 ret = 1;
2129err:
2130 EVP_CIPHER_CTX_free(ctx);
2131 if (idx >= 5)
2132 EVP_CIPHER_free((EVP_CIPHER *)type);
2133 return ret;
2134}
2135
ad887416 2136int setup_tests(void)
71ea6b48 2137{
b4250010 2138 testctx = OSSL_LIB_CTX_new();
86dc26ba
MC		 2139
2140 if (!TEST_ptr(testctx))
2141 return 0;
2142
f9e504e8 2143 ADD_TEST(test_EVP_set_default_properties);
6d242fa5 2144 ADD_ALL_TESTS(test_EVP_DigestSignInit, 9);
adcd8e37 2145 ADD_TEST(test_EVP_DigestVerifyInit);
8d8dd09b 2146 ADD_TEST(test_EVP_Digest);
2eb2b4f3 2147 ADD_TEST(test_EVP_Enveloped);
ad887416 2148 ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
29c49b25 2149 ADD_TEST(test_privatekey_to_pkcs8);
a9880362 2150#ifndef OPENSSL_NO_EC
adcd8e37 2151 ADD_TEST(test_EVP_PKCS82PKEY);
ddb634fe 2152#endif
f0c62c53
RL		 2153#ifndef OPENSSL_NO_EC
2154 ADD_ALL_TESTS(test_EC_keygen_with_enc, OSSL_NELEM(ec_encodings));
2155#endif
f844f9eb 2156#if !defined(OPENSSL_NO_SM2) && !defined(FIPS_MODULE)
ddb634fe 2157 ADD_TEST(test_EVP_SM2);
a6c4cb84 2158 ADD_TEST(test_EVP_SM2_verify);
a9880362 2159#endif
bb5f281a 2160 ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
41bbba53 2161#ifndef OPENSSL_NO_DEPRECATED_3_0
2aee35d3
PY		 2162 custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
2163 if (!TEST_ptr(custom_pmeth))
2164 return 0;
2165 EVP_PKEY_meth_set_check(custom_pmeth, pkey_custom_check);
b0004708
PY		 2166 EVP_PKEY_meth_set_public_check(custom_pmeth, pkey_custom_pub_check);
2167 EVP_PKEY_meth_set_param_check(custom_pmeth, pkey_custom_param_check);
2aee35d3
PY		 2168 if (!TEST_int_eq(EVP_PKEY_meth_add0(custom_pmeth), 1))
2169 return 0;
41bbba53 2170#endif
2aee35d3 2171 ADD_ALL_TESTS(test_EVP_PKEY_check, OSSL_NELEM(keycheckdata));
fab8fde3 2172#ifndef OPENSSL_NO_CMAC
a87820e1 2173 ADD_TEST(test_CMAC_keygen);
fab8fde3 2174#endif
10d5b415 2175 ADD_TEST(test_HKDF);
2cd3ebc7 2176 ADD_TEST(test_emptyikm_HKDF);
5dc40a83
BE		 2177#ifndef OPENSSL_NO_EC
2178 ADD_TEST(test_X509_PUBKEY_inplace);
cad8347b
SL		 2179 ADD_ALL_TESTS(test_invalide_ec_char2_pub_range_decode,
2180 OSSL_NELEM(ec_der_pub_keys));
5dc40a83 2181#endif
8d0f8c81 2182#ifndef OPENSSL_NO_DSA
f54a4101 2183 ADD_TEST(test_DSA_get_set_params);
b4be6937 2184#endif
f54a4101 2185 ADD_TEST(test_RSA_get_set_params);
b4be6937
MC		 2186#if !defined(OPENSSL_NO_CHACHA) && !defined(OPENSSL_NO_POLY1305)
2187 ADD_TEST(test_decrypt_null_chunks);
8d0f8c81 2188#endif
d4c2f498 2189#if !defined(OPENSSL_NO_DH) && !defined(OPENSSL_NO_DEPRECATED_3_0)
e295de1d 2190 ADD_TEST(test_EVP_PKEY_set1_DH);
501fcfb8 2191#endif
8a5cb596 2192 ADD_ALL_TESTS(test_keygen_with_empty_template, 2);
5ddec6a7 2193 ADD_ALL_TESTS(test_pkey_ctx_fail_without_provider, 2);
e295de1d 2194
1c19ff3c 2195 ADD_TEST(test_rand_agglomeration);
440b852a 2196 ADD_ALL_TESTS(test_evp_iv, 10);
1c19ff3c 2197
ad887416 2198 return 1;
71ea6b48 2199}
86dc26ba
MC		 2200
2201void cleanup_tests(void)
2202{
b4250010 2203 OSSL_LIB_CTX_free(testctx);
86dc26ba 2204}
A mirror of the official openssl repository