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