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