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