1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "asykeygenerator_fuzzer.h"
17 #include <cstddef>
18 #include <cstdint>
19 #include <string>
20 #include "securec.h"
21
22 #include "asy_key_generator.h"
23 #include "blob.h"
24 #include "detailed_alg_25519_key_params.h"
25 #include "detailed_dh_key_params.h"
26 #include "detailed_dsa_key_params.h"
27 #include "detailed_ecc_key_params.h"
28 #include "detailed_rsa_key_params.h"
29 #include "ecc_openssl_common_param_spec.h"
30 #include "ecc_common.h"
31 #include "ecc_key_util.h"
32 #include "dh_key_util.h"
33 #include "key_utils.h"
34 #include "memory.h"
35 #include "result.h"
36
37 using namespace std;
38
39 namespace {
40 HcfEccCommParamsSpec *g_sm2256CommSpec = nullptr;
41 HcfEccCommParamsSpec *g_brainpoolP160r1CommSpec = nullptr;
42 HcfDhCommParamsSpec *g_dhCommSpec = nullptr;
43 static string g_ed25519AlgoName = "Ed25519";
44 static string g_x25519AlgoName = "X25519";
45 }
46
47 static const uint32_t ASCII_CODE_ZERO = 48;
IsBigEndian(void)48 static bool IsBigEndian(void)
49 {
50 uint32_t *pointer = const_cast<uint32_t *>(&ASCII_CODE_ZERO);
51 char firstChar = *reinterpret_cast<char *>(pointer);
52 if (firstChar == '0') {
53 return false;
54 } else {
55 return true;
56 }
57 }
58
59 namespace OHOS {
60 constexpr int32_t PLEN_BITS = 3072;
61 constexpr int32_t SKLEN_BITS = 256;
62
63 enum class GenerateType {
64 FUZZ_COMMON = 0,
65 FUZZ_PUBKEY = 1,
66 FUZZ_PRIKEY = 2,
67 FUZZ_KEYPAIR = 3,
68 };
69 static bool g_testFlag = true;
70 static const int ECC224_PUB_KEY_LEN = 80;
71 static const int ECC224_PRI_KEY_LEN = 44;
72 static const int SM2256_PUB_KEY_LEN = 91;
73 static const int SM2256_PRI_KEY_LEN = 51;
74 static const int BRAINPOOLP160R1_PUB_KEY_LEN = 68;
75 static const int BRAINPOOLP160R1_PRI_KEY_LEN = 40;
76 static const int ED25519_PUB_KEY_LEN = 44;
77 static const int ED25519_PRI_KEY_LEN = 48;
78 static const int X25519_PUB_KEY_LEN = 44;
79 static const int X25519_PRI_KEY_LEN = 48;
80 static const int DH_PUB_KEY_LEN = 553;
81 static const int DH_PRI_KEY_LEN = 323;
82 static uint8_t g_mockEcc224PubKey[ECC224_PUB_KEY_LEN] = { 48, 78, 48, 16, 6, 7, 42, 134, 72, 206,
83 61, 2, 1, 6, 5, 43, 129, 4, 0, 33, 3, 58, 0, 4, 252, 171, 11, 115, 79, 252, 109, 120, 46, 97, 131, 145, 207,
84 141, 146, 235, 133, 37, 218, 180, 8, 149, 47, 244, 137, 238, 207, 95, 153, 65, 250, 32, 77, 184, 249, 181,
85 172, 192, 2, 99, 194, 170, 25, 44, 255, 87, 246, 42, 133, 83, 66, 197, 97, 95, 12, 84 };
86
87 static uint8_t g_mockEcc224PriKey[ECC224_PRI_KEY_LEN] = { 48, 42, 2, 1, 1, 4, 28, 250, 86, 6,
88 147, 222, 43, 252, 139, 90, 139, 5, 33, 184, 230, 26, 68, 94, 57, 145, 229, 146, 49, 221, 119, 206, 32, 198,
89 19, 160, 7, 6, 5, 43, 129, 4, 0, 33 };
90
91 static uint8_t g_mockSm2256PubKey[SM2256_PUB_KEY_LEN] = { 48, 89, 48, 19, 6, 7, 42, 134, 72, 206, 61, 2, 1, 6, 8,
92 42, 129, 28, 207, 85, 1, 130, 45, 3, 66, 0, 4, 84, 128, 137, 18, 201, 132, 210, 60, 20, 222, 30, 185, 219, 9,
93 72, 46, 148, 231, 101, 110, 21, 148, 127, 148, 90, 64, 20, 254, 155, 69, 61, 249, 46, 238, 158, 218, 72, 159,
94 102, 22, 2, 54, 42, 255, 37, 96, 92, 193, 152, 172, 86, 64, 228, 244, 125, 115, 97, 211, 232, 74, 79, 25,
95 217, 239 };
96
97 static uint8_t g_mockSm2256PriKey[SM2256_PRI_KEY_LEN] = { 48, 49, 2, 1, 1, 4, 32, 78, 6, 176, 182, 178, 223, 78,
98 63, 118, 13, 15, 35, 44, 56, 78, 69, 212, 192, 65, 232, 103, 124, 247, 30, 211, 81, 139, 187, 28, 165, 8, 248,
99 160, 10, 6, 8, 42, 129, 28, 207, 85, 1, 130, 45 };
100
101 static uint8_t g_mockBrainpoolPubKey[BRAINPOOLP160R1_PUB_KEY_LEN] = { 48, 66, 48, 20, 6, 7, 42, 134, 72, 206, 61,
102 2, 1, 6, 9, 43, 36, 3, 3, 2, 8, 1, 1, 1, 3, 42, 0, 4, 37, 67, 178, 178, 176, 241, 23, 119, 74, 231, 82, 88,
103 215, 227, 37, 24, 129, 177, 152, 142, 144, 155, 44, 97, 145, 114, 242, 156, 129, 225, 186, 196, 113, 41, 198,
104 85, 186, 69, 198, 146 };
105
106 static uint8_t g_mockBrainpoolPriKey[BRAINPOOLP160R1_PRI_KEY_LEN] = { 48, 38, 2, 1, 1, 4, 20, 116, 221, 96, 238,
107 46, 76, 111, 184, 30, 42, 223, 86, 187, 131, 127, 41, 28, 223, 93, 134, 160, 11, 6, 9, 43, 36, 3, 3, 2, 8, 1,
108 1, 1 };
109
110 static uint8_t g_mockEd25519PubKey[ED25519_PUB_KEY_LEN] = { 48, 42, 48, 5, 6, 3, 43, 101, 112, 3, 33, 0, 101, 94,
111 172, 9, 171, 197, 147, 204, 102, 87, 132, 67, 59, 108, 68, 121, 150, 93, 83, 26, 173, 99, 63, 125, 86, 91, 77,
112 207, 147, 216, 158, 5 };
113
114 static uint8_t g_mockEd25519PriKey[ED25519_PRI_KEY_LEN] = { 48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4,
115 32, 31, 229, 164, 209, 117, 143, 227, 85, 227, 67, 214, 165, 40, 220, 217, 105, 123, 246, 71, 104, 129, 79, 19,
116 173, 36, 32, 69, 83, 25, 136, 92, 25 };
117
118 static uint8_t g_mockX25519PubKey[X25519_PUB_KEY_LEN] = { 48, 42, 48, 5, 6, 3, 43, 101, 110, 3, 33, 0, 173, 38, 49,
119 140, 12, 119, 139, 84, 170, 234, 223, 247, 240, 167, 79, 192, 41, 114, 211, 76, 38, 151, 123, 141, 209, 44, 31,
120 97, 16, 137, 236, 5 };
121
122 static uint8_t g_mockX25519PriKey[X25519_PRI_KEY_LEN] = { 48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 110, 4, 34, 4, 32,
123 96, 70, 225, 130, 145, 57, 68, 247, 129, 6, 13, 185, 167, 100, 237, 166, 63, 125, 219, 75, 59, 27, 123, 100, 68,
124 136, 52, 93, 100, 253, 222, 80 };
125
126 static uint8_t g_mockDhPubKey[DH_PUB_KEY_LEN] = { 48, 130, 2, 37, 48, 130, 1, 23, 6, 9, 42, 134, 72, 134, 247, 13,
127 1, 3, 1, 48, 130, 1, 8, 2, 130, 1, 1, 0, 255, 255, 255, 255, 255, 255, 255, 255, 201, 15, 218, 162, 33, 104,
128 194, 52, 196, 198, 98, 139, 128, 220, 28, 209, 41, 2, 78, 8, 138, 103, 204, 116, 2, 11, 190, 166, 59, 19, 155,
129 34, 81, 74, 8, 121, 142, 52, 4, 221, 239, 149, 25, 179, 205, 58, 67, 27, 48, 43, 10, 109, 242, 95, 20, 55, 79,
130 225, 53, 109, 109, 81, 194, 69, 228, 133, 181, 118, 98, 94, 126, 198, 244, 76, 66, 233, 166, 55, 237, 107, 11,
131 255, 92, 182, 244, 6, 183, 237, 238, 56, 107, 251, 90, 137, 159, 165, 174, 159, 36, 17, 124, 75, 31, 230, 73,
132 40, 102, 81, 236, 228, 91, 61, 194, 0, 124, 184, 161, 99, 191, 5, 152, 218, 72, 54, 28, 85, 211, 154, 105, 22,
133 63, 168, 253, 36, 207, 95, 131, 101, 93, 35, 220, 163, 173, 150, 28, 98, 243, 86, 32, 133, 82, 187, 158, 213,
134 41, 7, 112, 150, 150, 109, 103, 12, 53, 78, 74, 188, 152, 4, 241, 116, 108, 8, 202, 24, 33, 124, 50, 144, 94,
135 70, 46, 54, 206, 59, 227, 158, 119, 44, 24, 14, 134, 3, 155, 39, 131, 162, 236, 7, 162, 143, 181, 197, 93, 240,
136 111, 76, 82, 201, 222, 43, 203, 246, 149, 88, 23, 24, 57, 149, 73, 124, 234, 149, 106, 229, 21, 210, 38, 24,
137 152, 250, 5, 16, 21, 114, 142, 90, 138, 172, 170, 104, 255, 255, 255, 255, 255, 255, 255, 255, 2, 1, 2, 3, 130,
138 1, 6, 0, 2, 130, 1, 1, 0, 228, 194, 161, 19, 145, 70, 104, 142, 66, 200, 1, 158, 107, 23, 93, 212, 19, 223,
139 145, 196, 11, 179, 169, 69, 136, 163, 136, 142, 122, 230, 238, 249, 102, 227, 49, 92, 64, 255, 8, 185, 238, 5,
140 97, 253, 174, 161, 140, 70, 40, 159, 105, 249, 76, 206, 35, 97, 16, 138, 185, 172, 90, 77, 248, 8, 242, 31,
141 212, 84, 224, 226, 60, 71, 162, 47, 158, 148, 251, 118, 206, 151, 80, 23, 158, 241, 181, 139, 129, 240, 26,
142 150, 180, 237, 252, 73, 84, 173, 63, 215, 130, 6, 124, 97, 118, 165, 133, 66, 235, 97, 143, 148, 105, 86, 174,
143 71, 254, 169, 22, 172, 116, 130, 198, 237, 131, 230, 113, 12, 228, 21, 138, 128, 168, 40, 207, 205, 190, 160,
144 114, 156, 90, 210, 114, 54, 42, 191, 167, 99, 100, 138, 145, 120, 165, 62, 162, 238, 62, 76, 162, 90, 97, 245,
145 30, 55, 157, 139, 36, 118, 121, 242, 214, 79, 0, 27, 36, 4, 243, 62, 107, 34, 222, 110, 252, 24, 202, 3, 216,
146 160, 83, 228, 254, 253, 87, 198, 235, 234, 210, 80, 124, 218, 188, 82, 116, 144, 70, 40, 231, 124, 172, 59,
147 154, 6, 87, 22, 9, 198, 113, 142, 39, 64, 137, 34, 100, 195, 55, 75, 204, 185, 1, 222, 27, 245, 213, 22, 222,
148 83, 0, 222, 8, 194, 21, 85, 90, 32, 236, 205, 86, 38, 70, 57, 171, 248, 168, 52, 85, 46, 1, 149 };
149
150 static uint8_t g_mockDhPriKey[DH_PRI_KEY_LEN] = { 48, 130, 1, 63, 2, 1, 0, 48, 130, 1, 23, 6, 9, 42, 134, 72, 134,
151 247, 13, 1, 3, 1, 48, 130, 1, 8, 2, 130, 1, 1, 0, 255, 255, 255, 255, 255, 255, 255, 255, 201, 15, 218, 162,
152 33, 104, 194, 52, 196, 198, 98, 139, 128, 220, 28, 209, 41, 2, 78, 8, 138, 103, 204, 116, 2, 11, 190, 166, 59,
153 19, 155, 34, 81, 74, 8, 121, 142, 52, 4, 221, 239, 149, 25, 179, 205, 58, 67, 27, 48, 43, 10, 109, 242, 95, 20,
154 55, 79, 225, 53, 109, 109, 81, 194, 69, 228, 133, 181, 118, 98, 94, 126, 198, 244, 76, 66, 233, 166, 55, 237,
155 107, 11, 255, 92, 182, 244, 6, 183, 237, 238, 56, 107, 251, 90, 137, 159, 165, 174, 159, 36, 17, 124, 75, 31,
156 230, 73, 40, 102, 81, 236, 228, 91, 61, 194, 0, 124, 184, 161, 99, 191, 5, 152, 218, 72, 54, 28, 85, 211, 154,
157 105, 22, 63, 168, 253, 36, 207, 95, 131, 101, 93, 35, 220, 163, 173, 150, 28, 98, 243, 86, 32, 133, 82, 187,
158 158, 213, 41, 7, 112, 150, 150, 109, 103, 12, 53, 78, 74, 188, 152, 4, 241, 116, 108, 8, 202, 24, 33, 124, 50,
159 144, 94, 70, 46, 54, 206, 59, 227, 158, 119, 44, 24, 14, 134, 3, 155, 39, 131, 162, 236, 7, 162, 143, 181, 197,
160 93, 240, 111, 76, 82, 201, 222, 43, 203, 246, 149, 88, 23, 24, 57, 149, 73, 124, 234, 149, 106, 229, 21, 210,
161 38, 24, 152, 250, 5, 16, 21, 114, 142, 90, 138, 172, 170, 104, 255, 255, 255, 255, 255, 255, 255, 255, 2, 1, 2,
162 4, 31, 2, 29, 0, 237, 124, 61, 162, 122, 242, 226, 132, 236, 155, 58, 14, 154, 128, 233, 85, 121, 59, 252, 255,
163 157, 145, 75, 251, 236, 154, 85, 203 };
164
165 constexpr uint32_t DSA2048_PRI_SIZE = 20;
166 constexpr uint32_t DSA2048_PUB_SIZE = 256;
167 constexpr uint32_t DSA2048_P_SIZE = 256;
168 constexpr uint32_t DSA2048_Q_SIZE = 20;
169 constexpr uint32_t DSA2048_G_SIZE = 256;
170 static const char *g_algNameDSA = "DSA";
171
172 static unsigned char g_dsa2048PrivBigE[] = {
173 0x32, 0x67, 0x92, 0xf6, 0xc4, 0xe2, 0xe2, 0xe8, 0xa0, 0x8b, 0x6b, 0x45,
174 0x0c, 0x8a, 0x76, 0xb0, 0xee, 0xcf, 0x91, 0xa7,
175 };
176
177 static unsigned char g_dsa2048PrivLittleE[] = {
178 0xa7, 0x91, 0xcf, 0xee, 0xb0, 0x76, 0x8a, 0x0c, 0x45, 0x6b, 0x8b, 0xa0,
179 0xe8, 0xe2, 0xe2, 0xc4, 0xf6, 0x92, 0x67, 0x32,
180 };
181
182 static unsigned char g_dsa2048PubBigE[] = {
183 0x17, 0x8f, 0xa8, 0x11, 0x84, 0x92, 0xec, 0x83, 0x47, 0xc7, 0x6a, 0xb0,
184 0x92, 0xaf, 0x5a, 0x20, 0x37, 0xa3, 0x64, 0x79, 0xd2, 0xd0, 0x3d, 0xcd,
185 0xe0, 0x61, 0x88, 0x88, 0x21, 0xcc, 0x74, 0x5d, 0xce, 0x4c, 0x51, 0x47,
186 0xf0, 0xc5, 0x5c, 0x4c, 0x82, 0x7a, 0xaf, 0x72, 0xad, 0xb9, 0xe0, 0x53,
187 0xf2, 0x78, 0xb7, 0xf0, 0xb5, 0x48, 0x7f, 0x8a, 0x3a, 0x18, 0xd1, 0x9f,
188 0x8b, 0x7d, 0xa5, 0x47, 0xb7, 0x95, 0xab, 0x98, 0xf8, 0x7b, 0x74, 0x50,
189 0x56, 0x8e, 0x57, 0xf0, 0xee, 0xf5, 0xb7, 0xba, 0xab, 0x85, 0x86, 0xf9,
190 0x2b, 0xef, 0x41, 0x56, 0xa0, 0xa4, 0x9f, 0xb7, 0x38, 0x00, 0x46, 0x0a,
191 0xa6, 0xf1, 0xfc, 0x1f, 0xd8, 0x4e, 0x85, 0x44, 0x92, 0x43, 0x21, 0x5d,
192 0x6e, 0xcc, 0xc2, 0xcb, 0x26, 0x31, 0x0d, 0x21, 0xc4, 0xbd, 0x8d, 0x24,
193 0xbc, 0xd9, 0x18, 0x19, 0xd7, 0xdc, 0xf1, 0xe7, 0x93, 0x50, 0x48, 0x03,
194 0x2c, 0xae, 0x2e, 0xe7, 0x49, 0x88, 0x5f, 0x93, 0x57, 0x27, 0x99, 0x36,
195 0xb4, 0x20, 0xab, 0xfc, 0xa7, 0x2b, 0xf2, 0xd9, 0x98, 0xd7, 0xd4, 0x34,
196 0x9d, 0x96, 0x50, 0x58, 0x9a, 0xea, 0x54, 0xf3, 0xee, 0xf5, 0x63, 0x14,
197 0xee, 0x85, 0x83, 0x74, 0x76, 0xe1, 0x52, 0x95, 0xc3, 0xf7, 0xeb, 0x04,
198 0x04, 0x7b, 0xa7, 0x28, 0x1b, 0xcc, 0xea, 0x4a, 0x4e, 0x84, 0xda, 0xd8,
199 0x9c, 0x79, 0xd8, 0x9b, 0x66, 0x89, 0x2f, 0xcf, 0xac, 0xd7, 0x79, 0xf9,
200 0xa9, 0xd8, 0x45, 0x13, 0x78, 0xb9, 0x00, 0x14, 0xc9, 0x7e, 0x22, 0x51,
201 0x86, 0x67, 0xb0, 0x9f, 0x26, 0x11, 0x23, 0xc8, 0x38, 0xd7, 0x70, 0x1d,
202 0x15, 0x8e, 0x4d, 0x4f, 0x95, 0x97, 0x40, 0xa1, 0xc2, 0x7e, 0x01, 0x18,
203 0x72, 0xf4, 0x10, 0xe6, 0x8d, 0x52, 0x16, 0x7f, 0xf2, 0xc9, 0xf8, 0x33,
204 0x8b, 0x33, 0xb7, 0xce,
205 };
206
207 static unsigned char g_dsa2048PubLittleE[] = {
208 0xce, 0xb7, 0x33, 0x8b, 0x33, 0xf8, 0xc9, 0xf2, 0x7f, 0x16, 0x52, 0x8d,
209 0xe6, 0x10, 0xf4, 0x72, 0x18, 0x01, 0x7e, 0xc2, 0xa1, 0x40, 0x97, 0x95,
210 0x4f, 0x4d, 0x8e, 0x15, 0x1d, 0x70, 0xd7, 0x38, 0xc8, 0x23, 0x11, 0x26,
211 0x9f, 0xb0, 0x67, 0x86, 0x51, 0x22, 0x7e, 0xc9, 0x14, 0x00, 0xb9, 0x78,
212 0x13, 0x45, 0xd8, 0xa9, 0xf9, 0x79, 0xd7, 0xac, 0xcf, 0x2f, 0x89, 0x66,
213 0x9b, 0xd8, 0x79, 0x9c, 0xd8, 0xda, 0x84, 0x4e, 0x4a, 0xea, 0xcc, 0x1b,
214 0x28, 0xa7, 0x7b, 0x04, 0x04, 0xeb, 0xf7, 0xc3, 0x95, 0x52, 0xe1, 0x76,
215 0x74, 0x83, 0x85, 0xee, 0x14, 0x63, 0xf5, 0xee, 0xf3, 0x54, 0xea, 0x9a,
216 0x58, 0x50, 0x96, 0x9d, 0x34, 0xd4, 0xd7, 0x98, 0xd9, 0xf2, 0x2b, 0xa7,
217 0xfc, 0xab, 0x20, 0xb4, 0x36, 0x99, 0x27, 0x57, 0x93, 0x5f, 0x88, 0x49,
218 0xe7, 0x2e, 0xae, 0x2c, 0x03, 0x48, 0x50, 0x93, 0xe7, 0xf1, 0xdc, 0xd7,
219 0x19, 0x18, 0xd9, 0xbc, 0x24, 0x8d, 0xbd, 0xc4, 0x21, 0x0d, 0x31, 0x26,
220 0xcb, 0xc2, 0xcc, 0x6e, 0x5d, 0x21, 0x43, 0x92, 0x44, 0x85, 0x4e, 0xd8,
221 0x1f, 0xfc, 0xf1, 0xa6, 0x0a, 0x46, 0x00, 0x38, 0xb7, 0x9f, 0xa4, 0xa0,
222 0x56, 0x41, 0xef, 0x2b, 0xf9, 0x86, 0x85, 0xab, 0xba, 0xb7, 0xf5, 0xee,
223 0xf0, 0x57, 0x8e, 0x56, 0x50, 0x74, 0x7b, 0xf8, 0x98, 0xab, 0x95, 0xb7,
224 0x47, 0xa5, 0x7d, 0x8b, 0x9f, 0xd1, 0x18, 0x3a, 0x8a, 0x7f, 0x48, 0xb5,
225 0xf0, 0xb7, 0x78, 0xf2, 0x53, 0xe0, 0xb9, 0xad, 0x72, 0xaf, 0x7a, 0x82,
226 0x4c, 0x5c, 0xc5, 0xf0, 0x47, 0x51, 0x4c, 0xce, 0x5d, 0x74, 0xcc, 0x21,
227 0x88, 0x88, 0x61, 0xe0, 0xcd, 0x3d, 0xd0, 0xd2, 0x79, 0x64, 0xa3, 0x37,
228 0x20, 0x5a, 0xaf, 0x92, 0xb0, 0x6a, 0xc7, 0x47, 0x83, 0xec, 0x92, 0x84,
229 0x11, 0xa8, 0x8f, 0x17,
230 };
231
232 static unsigned char g_dsa2048PBigE[] = {
233 0xA0, 0x25, 0xFA, 0xAD, 0xF4, 0x8E, 0xB9, 0xE5, 0x99, 0xF3, 0x5D, 0x6F,
234 0x4F, 0x83, 0x34, 0xE2, 0x7E, 0xCF, 0x6F, 0xBF, 0x30, 0xAF, 0x6F, 0x81,
235 0xEB, 0xF8, 0xC4, 0x13, 0xD9, 0xA0, 0x5D, 0x8B, 0x5C, 0x8E, 0xDC, 0xC2,
236 0x1D, 0x0B, 0x41, 0x32, 0xB0, 0x1F, 0xFE, 0xEF, 0x0C, 0xC2, 0xA2, 0x7E,
237 0x68, 0x5C, 0x28, 0x21, 0xE9, 0xF5, 0xB1, 0x58, 0x12, 0x63, 0x4C, 0x19,
238 0x4E, 0xFF, 0x02, 0x4B, 0x92, 0xED, 0xD2, 0x07, 0x11, 0x4D, 0x8C, 0x58,
239 0x16, 0x5C, 0x55, 0x8E, 0xAD, 0xA3, 0x67, 0x7D, 0xB9, 0x86, 0x6E, 0x0B,
240 0xE6, 0x54, 0x6F, 0x40, 0xAE, 0x0E, 0x67, 0x4C, 0xF9, 0x12, 0x5B, 0x3C,
241 0x08, 0x7A, 0xF7, 0xFC, 0x67, 0x86, 0x69, 0xE7, 0x0A, 0x94, 0x40, 0xBF,
242 0x8B, 0x76, 0xFE, 0x26, 0xD1, 0xF2, 0xA1, 0x1A, 0x84, 0xA1, 0x43, 0x56,
243 0x28, 0xBC, 0x9A, 0x5F, 0xD7, 0x3B, 0x69, 0x89, 0x8A, 0x36, 0x2C, 0x51,
244 0xDF, 0x12, 0x77, 0x2F, 0x57, 0x7B, 0xA0, 0xAA, 0xDD, 0x7F, 0xA1, 0x62,
245 0x3B, 0x40, 0x7B, 0x68, 0x1A, 0x8F, 0x0D, 0x38, 0xBB, 0x21, 0x5D, 0x18,
246 0xFC, 0x0F, 0x46, 0xF7, 0xA3, 0xB0, 0x1D, 0x23, 0xC3, 0xD2, 0xC7, 0x72,
247 0x51, 0x18, 0xDF, 0x46, 0x95, 0x79, 0xD9, 0xBD, 0xB5, 0x19, 0x02, 0x2C,
248 0x87, 0xDC, 0xE7, 0x57, 0x82, 0x7E, 0xF1, 0x8B, 0x06, 0x3D, 0x00, 0xA5,
249 0x7B, 0x6B, 0x26, 0x27, 0x91, 0x0F, 0x6A, 0x77, 0xE4, 0xD5, 0x04, 0xE4,
250 0x12, 0x2C, 0x42, 0xFF, 0xD2, 0x88, 0xBB, 0xD3, 0x92, 0xA0, 0xF9, 0xC8,
251 0x51, 0x64, 0x14, 0x5C, 0xD8, 0xF9, 0x6C, 0x47, 0x82, 0xB4, 0x1C, 0x7F,
252 0x09, 0xB8, 0xF0, 0x25, 0x83, 0x1D, 0x3F, 0x3F, 0x05, 0xB3, 0x21, 0x0A,
253 0x5D, 0xA7, 0xD8, 0x54, 0xC3, 0x65, 0x7D, 0xC3, 0xB0, 0x1D, 0xBF, 0xAE,
254 0xF8, 0x68, 0xCF, 0x9B,
255 };
256
257 static unsigned char g_dsa2048PLittleE[] = {
258 0x9b, 0xcf, 0x68, 0xf8, 0xae, 0xbf, 0x1d, 0xb0, 0xc3, 0x7d, 0x65, 0xc3,
259 0x54, 0xd8, 0xa7, 0x5d, 0x0a, 0x21, 0xb3, 0x05, 0x3f, 0x3f, 0x1d, 0x83,
260 0x25, 0xf0, 0xb8, 0x09, 0x7f, 0x1c, 0xb4, 0x82, 0x47, 0x6c, 0xf9, 0xd8,
261 0x5c, 0x14, 0x64, 0x51, 0xc8, 0xf9, 0xa0, 0x92, 0xd3, 0xbb, 0x88, 0xd2,
262 0xff, 0x42, 0x2c, 0x12, 0xe4, 0x04, 0xd5, 0xe4, 0x77, 0x6a, 0x0f, 0x91,
263 0x27, 0x26, 0x6b, 0x7b, 0xa5, 0x00, 0x3d, 0x06, 0x8b, 0xf1, 0x7e, 0x82,
264 0x57, 0xe7, 0xdc, 0x87, 0x2c, 0x02, 0x19, 0xb5, 0xbd, 0xd9, 0x79, 0x95,
265 0x46, 0xdf, 0x18, 0x51, 0x72, 0xc7, 0xd2, 0xc3, 0x23, 0x1d, 0xb0, 0xa3,
266 0xf7, 0x46, 0x0f, 0xfc, 0x18, 0x5d, 0x21, 0xbb, 0x38, 0x0d, 0x8f, 0x1a,
267 0x68, 0x7b, 0x40, 0x3b, 0x62, 0xa1, 0x7f, 0xdd, 0xaa, 0xa0, 0x7b, 0x57,
268 0x2f, 0x77, 0x12, 0xdf, 0x51, 0x2c, 0x36, 0x8a, 0x89, 0x69, 0x3b, 0xd7,
269 0x5f, 0x9a, 0xbc, 0x28, 0x56, 0x43, 0xa1, 0x84, 0x1a, 0xa1, 0xf2, 0xd1,
270 0x26, 0xfe, 0x76, 0x8b, 0xbf, 0x40, 0x94, 0x0a, 0xe7, 0x69, 0x86, 0x67,
271 0xfc, 0xf7, 0x7a, 0x08, 0x3c, 0x5b, 0x12, 0xf9, 0x4c, 0x67, 0x0e, 0xae,
272 0x40, 0x6f, 0x54, 0xe6, 0x0b, 0x6e, 0x86, 0xb9, 0x7d, 0x67, 0xa3, 0xad,
273 0x8e, 0x55, 0x5c, 0x16, 0x58, 0x8c, 0x4d, 0x11, 0x07, 0xd2, 0xed, 0x92,
274 0x4b, 0x02, 0xff, 0x4e, 0x19, 0x4c, 0x63, 0x12, 0x58, 0xb1, 0xf5, 0xe9,
275 0x21, 0x28, 0x5c, 0x68, 0x7e, 0xa2, 0xc2, 0x0c, 0xef, 0xfe, 0x1f, 0xb0,
276 0x32, 0x41, 0x0b, 0x1d, 0xc2, 0xdc, 0x8e, 0x5c, 0x8b, 0x5d, 0xa0, 0xd9,
277 0x13, 0xc4, 0xf8, 0xeb, 0x81, 0x6f, 0xaf, 0x30, 0xbf, 0x6f, 0xcf, 0x7e,
278 0xe2, 0x34, 0x83, 0x4f, 0x6f, 0x5d, 0xf3, 0x99, 0xe5, 0xb9, 0x8e, 0xf4,
279 0xad, 0xfa, 0x25, 0xa0,
280 };
281
282 static unsigned char g_dsa2048QBigE[] = {
283 0x97, 0xE7, 0x33, 0x4D, 0xD3, 0x94, 0x3E, 0x0B, 0xDB, 0x62, 0x74, 0xC6,
284 0xA1, 0x08, 0xDD, 0x19, 0xA3, 0x75, 0x17, 0x1B,
285 };
286
287 static unsigned char g_dsa2048QLittleE[] = {
288 0x1b, 0x17, 0x75, 0xa3, 0x19, 0xdd, 0x08, 0xa1, 0xc6, 0x74, 0x62, 0xdb,
289 0x0b, 0x3e, 0x94, 0xd3, 0x4d, 0x33, 0xe7, 0x97,
290 };
291
292 static unsigned char g_dsa2048GBigE[] = {
293 0x2C, 0x78, 0x16, 0x59, 0x34, 0x63, 0xF4, 0xF3, 0x92, 0xFC, 0xB5, 0xA5,
294 0x4F, 0x13, 0xDE, 0x2F, 0x1C, 0xA4, 0x3C, 0xAE, 0xAD, 0x38, 0x3F, 0x7E,
295 0x90, 0xBF, 0x96, 0xA6, 0xAE, 0x25, 0x90, 0x72, 0xF5, 0x8E, 0x80, 0x0C,
296 0x39, 0x1C, 0xD9, 0xEC, 0xBA, 0x90, 0x5B, 0x3A, 0xE8, 0x58, 0x6C, 0x9E,
297 0x30, 0x42, 0x37, 0x02, 0x31, 0x82, 0xBC, 0x6A, 0xDF, 0x6A, 0x09, 0x29,
298 0xE3, 0xC0, 0x46, 0xD1, 0xCB, 0x85, 0xEC, 0x0C, 0x30, 0x5E, 0xEA, 0xC8,
299 0x39, 0x8E, 0x22, 0x9F, 0x22, 0x10, 0xD2, 0x34, 0x61, 0x68, 0x37, 0x3D,
300 0x2E, 0x4A, 0x5B, 0x9A, 0xF5, 0xC1, 0x48, 0xC6, 0xF6, 0xDC, 0x63, 0x1A,
301 0xD3, 0x96, 0x64, 0xBA, 0x34, 0xC9, 0xD1, 0xA0, 0xD1, 0xAE, 0x6C, 0x2F,
302 0x48, 0x17, 0x93, 0x14, 0x43, 0xED, 0xF0, 0x21, 0x30, 0x19, 0xC3, 0x1B,
303 0x5F, 0xDE, 0xA3, 0xF0, 0x70, 0x78, 0x18, 0xE1, 0xA8, 0xE4, 0xEE, 0x2E,
304 0x00, 0xA5, 0xE4, 0xB3, 0x17, 0xC8, 0x0C, 0x7D, 0x6E, 0x42, 0xDC, 0xB7,
305 0x46, 0x00, 0x36, 0x4D, 0xD4, 0x46, 0xAA, 0x3D, 0x3C, 0x46, 0x89, 0x40,
306 0xBF, 0x1D, 0x84, 0x77, 0x0A, 0x75, 0xF3, 0x87, 0x1D, 0x08, 0x4C, 0xA6,
307 0xD1, 0xA9, 0x1C, 0x1E, 0x12, 0x1E, 0xE1, 0xC7, 0x30, 0x28, 0x76, 0xA5,
308 0x7F, 0x6C, 0x85, 0x96, 0x2B, 0x6F, 0xDB, 0x80, 0x66, 0x26, 0xAE, 0xF5,
309 0x93, 0xC7, 0x8E, 0xAE, 0x9A, 0xED, 0xE4, 0xCA, 0x04, 0xEA, 0x3B, 0x72,
310 0xEF, 0xDC, 0x87, 0xED, 0x0D, 0xA5, 0x4C, 0x4A, 0xDD, 0x71, 0x22, 0x64,
311 0x59, 0x69, 0x4E, 0x8E, 0xBF, 0x43, 0xDC, 0xAB, 0x8E, 0x66, 0xBB, 0x01,
312 0xB6, 0xF4, 0xE7, 0xFD, 0xD2, 0xAD, 0x9F, 0x36, 0xC1, 0xA0, 0x29, 0x99,
313 0xD1, 0x96, 0x70, 0x59, 0x06, 0x78, 0x35, 0xBD, 0x65, 0x55, 0x52, 0x9E,
314 0xF8, 0xB2, 0xE5, 0x38,
315 };
316
317 static unsigned char g_dsa2048GLittleE[] = {
318 0x38, 0xe5, 0xb2, 0xf8, 0x9e, 0x52, 0x55, 0x65, 0xbd, 0x35, 0x78, 0x06,
319 0x59, 0x70, 0x96, 0xd1, 0x99, 0x29, 0xa0, 0xc1, 0x36, 0x9f, 0xad, 0xd2,
320 0xfd, 0xe7, 0xf4, 0xb6, 0x01, 0xbb, 0x66, 0x8e, 0xab, 0xdc, 0x43, 0xbf,
321 0x8e, 0x4e, 0x69, 0x59, 0x64, 0x22, 0x71, 0xdd, 0x4a, 0x4c, 0xa5, 0x0d,
322 0xed, 0x87, 0xdc, 0xef, 0x72, 0x3b, 0xea, 0x04, 0xca, 0xe4, 0xed, 0x9a,
323 0xae, 0x8e, 0xc7, 0x93, 0xf5, 0xae, 0x26, 0x66, 0x80, 0xdb, 0x6f, 0x2b,
324 0x96, 0x85, 0x6c, 0x7f, 0xa5, 0x76, 0x28, 0x30, 0xc7, 0xe1, 0x1e, 0x12,
325 0x1e, 0x1c, 0xa9, 0xd1, 0xa6, 0x4c, 0x08, 0x1d, 0x87, 0xf3, 0x75, 0x0a,
326 0x77, 0x84, 0x1d, 0xbf, 0x40, 0x89, 0x46, 0x3c, 0x3d, 0xaa, 0x46, 0xd4,
327 0x4d, 0x36, 0x00, 0x46, 0xb7, 0xdc, 0x42, 0x6e, 0x7d, 0x0c, 0xc8, 0x17,
328 0xb3, 0xe4, 0xa5, 0x00, 0x2e, 0xee, 0xe4, 0xa8, 0xe1, 0x18, 0x78, 0x70,
329 0xf0, 0xa3, 0xde, 0x5f, 0x1b, 0xc3, 0x19, 0x30, 0x21, 0xf0, 0xed, 0x43,
330 0x14, 0x93, 0x17, 0x48, 0x2f, 0x6c, 0xae, 0xd1, 0xa0, 0xd1, 0xc9, 0x34,
331 0xba, 0x64, 0x96, 0xd3, 0x1a, 0x63, 0xdc, 0xf6, 0xc6, 0x48, 0xc1, 0xf5,
332 0x9a, 0x5b, 0x4a, 0x2e, 0x3d, 0x37, 0x68, 0x61, 0x34, 0xd2, 0x10, 0x22,
333 0x9f, 0x22, 0x8e, 0x39, 0xc8, 0xea, 0x5e, 0x30, 0x0c, 0xec, 0x85, 0xcb,
334 0xd1, 0x46, 0xc0, 0xe3, 0x29, 0x09, 0x6a, 0xdf, 0x6a, 0xbc, 0x82, 0x31,
335 0x02, 0x37, 0x42, 0x30, 0x9e, 0x6c, 0x58, 0xe8, 0x3a, 0x5b, 0x90, 0xba,
336 0xec, 0xd9, 0x1c, 0x39, 0x0c, 0x80, 0x8e, 0xf5, 0x72, 0x90, 0x25, 0xae,
337 0xa6, 0x96, 0xbf, 0x90, 0x7e, 0x3f, 0x38, 0xad, 0xae, 0x3c, 0xa4, 0x1c,
338 0x2f, 0xde, 0x13, 0x4f, 0xa5, 0xb5, 0xfc, 0x92, 0xf3, 0xf4, 0x63, 0x34,
339 0x59, 0x16, 0x78, 0x2c,
340 };
341
342 static HcfBigInteger sk_BN = {
343 .data = IsBigEndian() ? g_dsa2048PrivBigE : g_dsa2048PrivLittleE, .len = DSA2048_PRI_SIZE };
344 static HcfBigInteger pk_BN = {
345 .data = IsBigEndian() ? g_dsa2048PubBigE : g_dsa2048PubLittleE, .len = DSA2048_PUB_SIZE };
346 static HcfBigInteger p_BN = { .data = IsBigEndian() ? g_dsa2048PBigE : g_dsa2048PLittleE, .len = DSA2048_P_SIZE };
347 static HcfBigInteger q_BN = { .data = IsBigEndian() ? g_dsa2048QBigE : g_dsa2048QLittleE, .len = DSA2048_Q_SIZE };
348 static HcfBigInteger g_BN = { .data = IsBigEndian() ? g_dsa2048GBigE : g_dsa2048GLittleE, .len = DSA2048_G_SIZE };
349
350 static HcfAsyKeyParamsSpec asySpecComm = {
351 .algName = const_cast<char *>(g_algNameDSA),
352 .specType = HCF_COMMON_PARAMS_SPEC
353 };
354 static HcfAsyKeyParamsSpec asySpecPk = {
355 .algName = const_cast<char *>(g_algNameDSA),
356 .specType = HCF_PUBLIC_KEY_SPEC
357 };
358 static HcfAsyKeyParamsSpec asySpecKeyPair = {
359 .algName = const_cast<char *>(g_algNameDSA),
360 .specType = HCF_KEY_PAIR_SPEC
361 };
362
363 static HcfDsaCommParamsSpec dsaCommonSpec = { .base = asySpecComm, .p = p_BN, .q = q_BN, .g = g_BN };
364 static HcfDsaPubKeyParamsSpec dsaPkSpec = {
365 .base = {
366 .base = asySpecPk,
367 .p = p_BN,
368 .q = q_BN,
369 .g = g_BN
370 },
371 .pk = pk_BN
372 };
373 static HcfDsaKeyPairParamsSpec dsaKeyPairSpec = {
374 .base = {
375 .base = asySpecKeyPair,
376 .p = p_BN,
377 .q = q_BN,
378 .g = g_BN
379 },
380 .pk = pk_BN,
381 .sk = sk_BN
382 };
383
384 static string g_eccAlgName = "ECC";
385 static string g_eccFieldType = "Fp";
386 static int32_t g_ecc224CorrectH = 1;
387
388 HcfEccCommParamsSpec g_ecc224CommSpec;
389 HcfEccPubKeyParamsSpec g_ecc224PubKeySpec;
390 HcfEccPriKeyParamsSpec g_ecc224PriKeySpec;
391 HcfEccKeyPairParamsSpec g_ecc224KeyPairSpec;
392 HcfECFieldFp g_fieldFp;
393
394 constexpr uint32_t RSA_2048_N_BYTE_SIZE = 256;
395 constexpr uint32_t RSA_2048_D_BYTE_SIZE = 256;
396 constexpr uint32_t RSA_2048_E_BYTE_SIZE = 3;
397
398 constexpr unsigned char CORRECT_N[] =
399 "\x92\x60\xd0\x75\x0a\xe1\x17\xee\xe5\x5c\x3f\x3d\xea\xba\x74\x91"
400 "\x75\x21\xa2\x62\xee\x76\x00\x7c\xdf\x8a\x56\x75\x5a\xd7\x3a\x15"
401 "\x98\xa1\x40\x84\x10\xa0\x14\x34\xc3\xf5\xbc\x54\xa8\x8b\x57\xfa"
402 "\x19\xfc\x43\x28\xda\xea\x07\x50\xa4\xc4\x4e\x88\xcf\xf3\xb2\x38"
403 "\x26\x21\xb8\x0f\x67\x04\x64\x43\x3e\x43\x36\xe6\xd0\x03\xe8\xcd"
404 "\x65\xbf\xf2\x11\xda\x14\x4b\x88\x29\x1c\x22\x59\xa0\x0a\x72\xb7"
405 "\x11\xc1\x16\xef\x76\x86\xe8\xfe\xe3\x4e\x4d\x93\x3c\x86\x81\x87"
406 "\xbd\xc2\x6f\x7b\xe0\x71\x49\x3c\x86\xf7\xa5\x94\x1c\x35\x10\x80"
407 "\x6a\xd6\x7b\x0f\x94\xd8\x8f\x5c\xf5\xc0\x2a\x09\x28\x21\xd8\x62"
408 "\x6e\x89\x32\xb6\x5c\x5b\xd8\xc9\x20\x49\xc2\x10\x93\x2b\x7a\xfa"
409 "\x7a\xc5\x9c\x0e\x88\x6a\xe5\xc1\xed\xb0\x0d\x8c\xe2\xc5\x76\x33"
410 "\xdb\x26\xbd\x66\x39\xbf\xf7\x3c\xee\x82\xbe\x92\x75\xc4\x02\xb4"
411 "\xcf\x2a\x43\x88\xda\x8c\xf8\xc6\x4e\xef\xe1\xc5\xa0\xf5\xab\x80"
412 "\x57\xc3\x9f\xa5\xc0\x58\x9c\x3e\x25\x3f\x09\x60\x33\x23\x00\xf9"
413 "\x4b\xea\x44\x87\x7b\x58\x8e\x1e\xdb\xde\x97\xcf\x23\x60\x72\x7a"
414 "\x09\xb7\x75\x26\x2d\x7e\xe5\x52\xb3\x31\x9b\x92\x66\xf0\x5a\x25";
415
416 constexpr unsigned char CORRECT_E[] = "\x01\x00\x01";
417
418 constexpr unsigned char CORRECT_D[] =
419 "\x6a\x7d\xf2\xca\x63\xea\xd4\xdd\xa1\x91\xd6\x14\xb6\xb3\x85\xe0"
420 "\xd9\x05\x6a\x3d\x6d\x5c\xfe\x07\xdb\x1d\xaa\xbe\xe0\x22\xdb\x08"
421 "\x21\x2d\x97\x61\x3d\x33\x28\xe0\x26\x7c\x9d\xd2\x3d\x78\x7a\xbd"
422 "\xe2\xaf\xcb\x30\x6a\xeb\x7d\xfc\xe6\x92\x46\xcc\x73\xf5\xc8\x7f"
423 "\xdf\x06\x03\x01\x79\xa2\x11\x4b\x76\x7d\xb1\xf0\x83\xff\x84\x1c"
424 "\x02\x5d\x7d\xc0\x0c\xd8\x24\x35\xb9\xa9\x0f\x69\x53\x69\xe9\x4d"
425 "\xf2\x3d\x2c\xe4\x58\xbc\x3b\x32\x83\xad\x8b\xba\x2b\x8f\xa1\xba"
426 "\x62\xe2\xdc\xe9\xac\xcf\xf3\x79\x9a\xae\x7c\x84\x00\x16\xf3\xba"
427 "\x8e\x00\x48\xc0\xb6\xcc\x43\x39\xaf\x71\x61\x00\x3a\x5b\xeb\x86"
428 "\x4a\x01\x64\xb2\xc1\xc9\x23\x7b\x64\xbc\x87\x55\x69\x94\x35\x1b"
429 "\x27\x50\x6c\x33\xd4\xbc\xdf\xce\x0f\x9c\x49\x1a\x7d\x6b\x06\x28"
430 "\xc7\xc8\x52\xbe\x4f\x0a\x9c\x31\x32\xb2\xed\x3a\x2c\x88\x81\xe9"
431 "\xaa\xb0\x7e\x20\xe1\x7d\xeb\x07\x46\x91\xbe\x67\x77\x76\xa7\x8b"
432 "\x5c\x50\x2e\x05\xd9\xbd\xde\x72\x12\x6b\x37\x38\x69\x5e\x2d\xd1"
433 "\xa0\xa9\x8a\x14\x24\x7c\x65\xd8\xa7\xee\x79\x43\x2a\x09\x2c\xb0"
434 "\x72\x1a\x12\xdf\x79\x8e\x44\xf7\xcf\xce\x0c\x49\x81\x47\xa9\xb1";
435
436 const char *g_rsaAlgName = "RSA";
437
RemoveLastChar(const unsigned char * str,unsigned char * dest,uint32_t destLen)438 static void RemoveLastChar(const unsigned char *str, unsigned char *dest, uint32_t destLen)
439 {
440 for (size_t i = 0; i < destLen; i++) {
441 dest[i] = str[i];
442 }
443 return;
444 }
445
EndianSwap(unsigned char * pData,int startIndex,int length)446 static void EndianSwap(unsigned char *pData, int startIndex, int length)
447 {
448 int cnt = length / 2;
449 int start = startIndex;
450 int end = startIndex + length - 1;
451 unsigned char tmp;
452 for (int i = 0; i < cnt; i++) {
453 tmp = pData[start + i];
454 pData[start + i] = pData[end - i];
455 pData[end - i] = tmp;
456 }
457 }
458
GenerateRsa2048CorrectCommonKeySpec(unsigned char * dataN,HcfRsaCommParamsSpec * returnSpec)459 static void GenerateRsa2048CorrectCommonKeySpec(unsigned char *dataN, HcfRsaCommParamsSpec *returnSpec)
460 {
461 RemoveLastChar(CORRECT_N, dataN, RSA_2048_N_BYTE_SIZE);
462 if (!IsBigEndian()) {
463 // the device is not big endian
464 EndianSwap(dataN, 0, RSA_2048_N_BYTE_SIZE);
465 }
466 returnSpec->n.data = dataN;
467 returnSpec->n.len = RSA_2048_N_BYTE_SIZE;
468 returnSpec->base.algName = const_cast<char *>(g_rsaAlgName);
469 returnSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
470 return;
471 }
472
GenerateRsa2048CorrectPubKeySpec(unsigned char * dataN,unsigned char * dataE,HcfRsaPubKeyParamsSpec * returnPubSpec)473 static void GenerateRsa2048CorrectPubKeySpec(unsigned char *dataN, unsigned char *dataE,
474 HcfRsaPubKeyParamsSpec *returnPubSpec)
475 {
476 HcfRsaCommParamsSpec rsaCommSpec = {};
477 GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
478 RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
479 if (!IsBigEndian()) {
480 EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
481 }
482 returnPubSpec->pk.data = dataE;
483 returnPubSpec->pk.len = RSA_2048_E_BYTE_SIZE;
484 returnPubSpec->base = rsaCommSpec;
485 returnPubSpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
486 }
487
GenerateRsa2048CorrectKeyPairSpec(unsigned char * dataN,unsigned char * dataE,unsigned char * dataD,HcfRsaKeyPairParamsSpec * returnPairSpec)488 static void GenerateRsa2048CorrectKeyPairSpec(unsigned char *dataN, unsigned char *dataE, unsigned char *dataD,
489 HcfRsaKeyPairParamsSpec *returnPairSpec)
490 {
491 HcfRsaCommParamsSpec rsaCommSpec = {};
492 GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
493 RemoveLastChar(CORRECT_E, dataE, RSA_2048_E_BYTE_SIZE);
494 RemoveLastChar(CORRECT_D, dataD, RSA_2048_D_BYTE_SIZE);
495 if (!IsBigEndian()) {
496 // the device is not big endian
497 EndianSwap(dataE, 0, RSA_2048_E_BYTE_SIZE);
498 EndianSwap(dataD, 0, RSA_2048_D_BYTE_SIZE);
499 }
500 returnPairSpec->pk.data = dataE;
501 returnPairSpec->pk.len = RSA_2048_E_BYTE_SIZE;
502 returnPairSpec->sk.data = dataD;
503 returnPairSpec->sk.len = RSA_2048_D_BYTE_SIZE;
504 returnPairSpec->base = rsaCommSpec;
505 returnPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
506 }
507
ConstructEcc224CommParamsSpec(HcfAsyKeyParamsSpec ** spec)508 static HcfResult ConstructEcc224CommParamsSpec(HcfAsyKeyParamsSpec **spec)
509 {
510 HcfEccCommParamsSpec *eccCommSpec = &g_ecc224CommSpec;
511 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
512
513 eccCommSpec->base.algName = const_cast<char *>(g_eccAlgName.c_str());
514 eccCommSpec->base.specType = HCF_COMMON_PARAMS_SPEC;
515 eccCommSpec->field = tmpField;
516 eccCommSpec->field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
517 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.data =
518 (IsBigEndian() ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
519 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.len = NID_secp224r1_len;
520 eccCommSpec->a.data = (IsBigEndian() ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
521 eccCommSpec->a.len = NID_secp224r1_len;
522 eccCommSpec->b.data = (IsBigEndian() ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
523 eccCommSpec->b.len = NID_secp224r1_len;
524 eccCommSpec->g.x.data = (IsBigEndian() ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
525 eccCommSpec->g.x.len = NID_secp224r1_len;
526 eccCommSpec->g.y.data = (IsBigEndian() ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
527 eccCommSpec->g.y.len = NID_secp224r1_len;
528 eccCommSpec->n.data = (IsBigEndian() ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
529 eccCommSpec->n.len = NID_secp224r1_len;
530 eccCommSpec->h = g_ecc224CorrectH;
531
532 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec);
533 return HCF_SUCCESS;
534 }
535
ConstructEcc224PubKeyParamsSpec(HcfAsyKeyParamsSpec ** spec)536 static HcfResult ConstructEcc224PubKeyParamsSpec(HcfAsyKeyParamsSpec **spec)
537 {
538 HcfEccPubKeyParamsSpec *eccPubKeySpec = &g_ecc224PubKeySpec;
539 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
540
541 eccPubKeySpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
542 eccPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
543 eccPubKeySpec->base.field = tmpField;
544 eccPubKeySpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
545 (reinterpret_cast<HcfECFieldFp *>(eccPubKeySpec->base.field))->p.data =
546 (IsBigEndian() ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
547 (reinterpret_cast<HcfECFieldFp *>(eccPubKeySpec->base.field))->p.len = NID_secp224r1_len;
548 eccPubKeySpec->base.a.data = (IsBigEndian() ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
549 eccPubKeySpec->base.a.len = NID_secp224r1_len;
550 eccPubKeySpec->base.b.data = (IsBigEndian() ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
551 eccPubKeySpec->base.b.len = NID_secp224r1_len;
552 eccPubKeySpec->base.g.x.data = (IsBigEndian() ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
553 eccPubKeySpec->base.g.x.len = NID_secp224r1_len;
554 eccPubKeySpec->base.g.y.data = (IsBigEndian() ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
555 eccPubKeySpec->base.g.y.len = NID_secp224r1_len;
556 eccPubKeySpec->base.n.data = (IsBigEndian() ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
557 eccPubKeySpec->base.n.len = NID_secp224r1_len;
558 eccPubKeySpec->base.h = g_ecc224CorrectH;
559 eccPubKeySpec->pk.x.data = (IsBigEndian() ? g_ecc224CorrectBigPkX : g_ecc224CorrectLittlePkX);
560 eccPubKeySpec->pk.x.len = NID_secp224r1_len;
561 eccPubKeySpec->pk.y.data = (IsBigEndian() ? g_ecc224CorrectBigPkY : g_ecc224CorrectLittlePkY);
562 eccPubKeySpec->pk.y.len = NID_secp224r1_len;
563
564 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPubKeySpec);
565 return HCF_SUCCESS;
566 }
567
ConstructEcc224PriKeyParamsSpec(HcfAsyKeyParamsSpec ** spec)568 static HcfResult ConstructEcc224PriKeyParamsSpec(HcfAsyKeyParamsSpec **spec)
569 {
570 HcfEccPriKeyParamsSpec *eccPriKeySpec = &g_ecc224PriKeySpec;
571 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
572
573 eccPriKeySpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
574 eccPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC;
575 eccPriKeySpec->base.field = tmpField;
576 eccPriKeySpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
577 (reinterpret_cast<HcfECFieldFp *>(eccPriKeySpec->base.field))->p.data =
578 (IsBigEndian() ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
579 (reinterpret_cast<HcfECFieldFp *>(eccPriKeySpec->base.field))->p.len = NID_secp224r1_len;
580 eccPriKeySpec->base.a.data = (IsBigEndian() ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
581 eccPriKeySpec->base.a.len = NID_secp224r1_len;
582 eccPriKeySpec->base.b.data = (IsBigEndian() ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
583 eccPriKeySpec->base.b.len = NID_secp224r1_len;
584 eccPriKeySpec->base.g.x.data = (IsBigEndian() ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
585 eccPriKeySpec->base.g.x.len = NID_secp224r1_len;
586 eccPriKeySpec->base.g.y.data = (IsBigEndian() ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
587 eccPriKeySpec->base.g.y.len = NID_secp224r1_len;
588 eccPriKeySpec->base.n.data = (IsBigEndian() ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
589 eccPriKeySpec->base.n.len = NID_secp224r1_len;
590 eccPriKeySpec->base.h = g_ecc224CorrectH;
591 eccPriKeySpec->sk.data = (IsBigEndian() ? g_ecc224CorrectBigSk : g_ecc224CorrectLittleSk);
592 eccPriKeySpec->sk.len = NID_secp224r1_len;
593
594 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPriKeySpec);
595 return HCF_SUCCESS;
596 }
597
ConstructEcc224KeyPairParamsSpec(HcfAsyKeyParamsSpec ** spec)598 static HcfResult ConstructEcc224KeyPairParamsSpec(HcfAsyKeyParamsSpec **spec)
599 {
600 HcfEccKeyPairParamsSpec *eccKeyPairSpec = &g_ecc224KeyPairSpec;
601 HcfECField *tmpField = (HcfECField *)(&g_fieldFp);
602
603 eccKeyPairSpec->base.base.algName = const_cast<char *>(g_eccAlgName.c_str());
604 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
605 eccKeyPairSpec->base.field = tmpField;
606 eccKeyPairSpec->base.field->fieldType = const_cast<char *>(g_eccFieldType.c_str());
607 (reinterpret_cast<HcfECFieldFp *>(eccKeyPairSpec->base.field))->p.data =
608 (IsBigEndian() ? g_ecc224CorrectBigP : g_ecc224CorrectLittleP);
609 (reinterpret_cast<HcfECFieldFp *>(eccKeyPairSpec->base.field))->p.len = NID_secp224r1_len;
610 eccKeyPairSpec->base.a.data = (IsBigEndian() ? g_ecc224CorrectBigA : g_ecc224CorrectLittleA);
611 eccKeyPairSpec->base.a.len = NID_secp224r1_len;
612 eccKeyPairSpec->base.b.data = (IsBigEndian() ? g_ecc224CorrectBigB : g_ecc224CorrectLittleB);
613 eccKeyPairSpec->base.b.len = NID_secp224r1_len;
614 eccKeyPairSpec->base.g.x.data = (IsBigEndian() ? g_ecc224CorrectBigGX : g_ecc224CorrectLittleGX);
615 eccKeyPairSpec->base.g.x.len = NID_secp224r1_len;
616 eccKeyPairSpec->base.g.y.data = (IsBigEndian() ? g_ecc224CorrectBigGY : g_ecc224CorrectLittleGY);
617 eccKeyPairSpec->base.g.y.len = NID_secp224r1_len;
618 eccKeyPairSpec->base.n.data = (IsBigEndian() ? g_ecc224CorrectBigN : g_ecc224CorrectLittleN);
619 eccKeyPairSpec->base.n.len = NID_secp224r1_len;
620 eccKeyPairSpec->base.h = g_ecc224CorrectH;
621 eccKeyPairSpec->pk.x.data = (IsBigEndian() ? g_ecc224CorrectBigPkX : g_ecc224CorrectLittlePkX);
622 eccKeyPairSpec->pk.x.len = NID_secp224r1_len;
623 eccKeyPairSpec->pk.y.data = (IsBigEndian() ? g_ecc224CorrectBigPkY : g_ecc224CorrectLittlePkY);
624 eccKeyPairSpec->pk.y.len = NID_secp224r1_len;
625 eccKeyPairSpec->sk.data = (IsBigEndian() ? g_ecc224CorrectBigSk : g_ecc224CorrectLittleSk);
626 eccKeyPairSpec->sk.len = NID_secp224r1_len;
627
628 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec);
629 return HCF_SUCCESS;
630 }
631
ConstructSm2256CommParamsSpec(const std::string & algoName,HcfEccCommParamsSpec ** spec)632 static HcfResult ConstructSm2256CommParamsSpec(const std::string &algoName, HcfEccCommParamsSpec **spec)
633 {
634 HcfEccCommParamsSpec *eccCommSpec = nullptr;
635
636 HcfEccKeyUtilCreate(algoName.c_str(), &eccCommSpec);
637 if (eccCommSpec == nullptr) {
638 return HCF_INVALID_PARAMS;
639 }
640 *spec = eccCommSpec;
641 return HCF_SUCCESS;
642 }
643
ConstructSm2256PubKeyBigInt(HcfKeyPair * keyPair,HcfEccPubKeyParamsSpec * eccPubKeySpec)644 static HcfResult ConstructSm2256PubKeyBigInt(HcfKeyPair *keyPair, HcfEccPubKeyParamsSpec *eccPubKeySpec)
645 {
646 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
647 HcfResult res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt);
648 if (res != HCF_SUCCESS) {
649 return res;
650 }
651 eccPubKeySpec->pk.x.data = retBigInt.data;
652 eccPubKeySpec->pk.x.len = retBigInt.len;
653
654 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt);
655 if (res != HCF_SUCCESS) {
656 HcfFree(eccPubKeySpec->pk.x.data);
657 eccPubKeySpec->pk.x.data = nullptr;
658 eccPubKeySpec->pk.x.len = 0;
659 return res;
660 }
661 eccPubKeySpec->pk.y.data = retBigInt.data;
662 eccPubKeySpec->pk.y.len = retBigInt.len;
663 return HCF_SUCCESS;
664 }
665
ConstructSm2256PubKeyParamsSpec(const std::string & algoName,HcfEccCommParamsSpec * eccCommSpec,HcfAsyKeyParamsSpec ** spec)666 HcfResult ConstructSm2256PubKeyParamsSpec(const std::string &algoName, HcfEccCommParamsSpec *eccCommSpec,
667 HcfAsyKeyParamsSpec **spec)
668 {
669 HcfResult res = HCF_ERR_CRYPTO_OPERATION;
670 HcfAsyKeyGenerator *generator = nullptr;
671 if (HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator) != HCF_SUCCESS) {
672 return res;
673 }
674
675 HcfKeyPair *keyPair = nullptr;
676 if (generator->generateKeyPair(generator, nullptr, &keyPair) != HCF_SUCCESS) {
677 HcfObjDestroy(generator);
678 return res;
679 }
680
681 auto eccPubKeySpec = reinterpret_cast<HcfEccPubKeyParamsSpec *>(HcfMalloc(sizeof(HcfEccPubKeyParamsSpec), 0));
682 if (eccPubKeySpec != nullptr) {
683 eccPubKeySpec->base.base.algName = eccCommSpec->base.algName;
684 eccPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
685 eccPubKeySpec->base.field = eccCommSpec->field;
686 eccPubKeySpec->base.field->fieldType = eccCommSpec->field->fieldType;
687 (reinterpret_cast<HcfECFieldFp *>(eccPubKeySpec->base.field))->p.data =
688 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.data;
689 (reinterpret_cast<HcfECFieldFp *>(eccPubKeySpec->base.field))->p.len =
690 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.len;
691 eccPubKeySpec->base.a.data = eccCommSpec->a.data;
692 eccPubKeySpec->base.a.len = eccCommSpec->a.len;
693 eccPubKeySpec->base.b.data = eccCommSpec->b.data;
694 eccPubKeySpec->base.b.len = eccCommSpec->b.len;
695 eccPubKeySpec->base.g.x.data = eccCommSpec->g.x.data;
696 eccPubKeySpec->base.g.x.len = eccCommSpec->g.x.len;
697 eccPubKeySpec->base.g.y.data = eccCommSpec->g.y.data;
698 eccPubKeySpec->base.g.y.len = eccCommSpec->g.y.len;
699 eccPubKeySpec->base.n.data = eccCommSpec->n.data;
700 eccPubKeySpec->base.n.len = eccCommSpec->n.len;
701 eccPubKeySpec->base.h = eccCommSpec->h;
702 if (ConstructSm2256PubKeyBigInt(keyPair, eccPubKeySpec) != HCF_SUCCESS) {
703 HcfFree(eccPubKeySpec);
704 } else {
705 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPubKeySpec);
706 res = HCF_SUCCESS;
707 }
708 }
709
710 HcfObjDestroy(generator);
711 HcfObjDestroy(keyPair);
712 return res;
713 }
714
ConstructSm2256PriKeyParamsSpec(const std::string & algoName,HcfEccCommParamsSpec * eccCommSpec,HcfAsyKeyParamsSpec ** spec)715 HcfResult ConstructSm2256PriKeyParamsSpec(const std::string &algoName, HcfEccCommParamsSpec *eccCommSpec,
716 HcfAsyKeyParamsSpec **spec)
717 {
718 HcfResult res = HCF_ERR_CRYPTO_OPERATION;
719 HcfAsyKeyGenerator *generator = nullptr;
720 if (HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator) != HCF_SUCCESS) {
721 return res;
722 }
723
724 HcfKeyPair *keyPair = nullptr;
725 if (generator->generateKeyPair(generator, nullptr, &keyPair) != HCF_SUCCESS) {
726 HcfObjDestroy(generator);
727 return res;
728 }
729
730 auto eccPriKeySpec = reinterpret_cast<HcfEccPriKeyParamsSpec *>(HcfMalloc(sizeof(HcfEccPriKeyParamsSpec), 0));
731 if (eccPriKeySpec != nullptr) {
732 eccPriKeySpec->base.base.algName = eccCommSpec->base.algName;
733 eccPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC;
734 eccPriKeySpec->base.field = eccCommSpec->field;
735 eccPriKeySpec->base.field->fieldType = eccCommSpec->field->fieldType;
736 (reinterpret_cast<HcfECFieldFp *>(eccPriKeySpec->base.field))->p.data =
737 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.data;
738 (reinterpret_cast<HcfECFieldFp *>(eccPriKeySpec->base.field))->p.len =
739 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.len;
740 eccPriKeySpec->base.a.data = eccCommSpec->a.data;
741 eccPriKeySpec->base.a.len = eccCommSpec->a.len;
742 eccPriKeySpec->base.b.data = eccCommSpec->b.data;
743 eccPriKeySpec->base.b.len = eccCommSpec->b.len;
744 eccPriKeySpec->base.g.x.data = eccCommSpec->g.x.data;
745 eccPriKeySpec->base.g.x.len = eccCommSpec->g.x.len;
746 eccPriKeySpec->base.g.y.data = eccCommSpec->g.y.data;
747 eccPriKeySpec->base.g.y.len = eccCommSpec->g.y.len;
748 eccPriKeySpec->base.n.data = eccCommSpec->n.data;
749 eccPriKeySpec->base.n.len = eccCommSpec->n.len;
750 eccPriKeySpec->base.h = eccCommSpec->h;
751 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
752 if (keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt) != HCF_SUCCESS) {
753 HcfFree(eccPriKeySpec);
754 } else {
755 eccPriKeySpec->sk.data = retBigInt.data;
756 eccPriKeySpec->sk.len = retBigInt.len;
757 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(eccPriKeySpec);
758 res = HCF_SUCCESS;
759 }
760 }
761 HcfObjDestroy(generator);
762 HcfObjDestroy(keyPair);
763 return res;
764 }
765
ConstructSm2256KeyPairBigInt(HcfKeyPair * keyPair,HcfEccKeyPairParamsSpec * eccKeyPairSpec)766 static HcfResult ConstructSm2256KeyPairBigInt(HcfKeyPair *keyPair, HcfEccKeyPairParamsSpec *eccKeyPairSpec)
767 {
768 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
769 HcfResult res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_X_BN, &retBigInt);
770 if (res != HCF_SUCCESS) {
771 return res;
772 }
773 eccKeyPairSpec->pk.x.data = retBigInt.data;
774 eccKeyPairSpec->pk.x.len = retBigInt.len;
775
776 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ECC_PK_Y_BN, &retBigInt);
777 if (res != HCF_SUCCESS) {
778 HcfFree(eccKeyPairSpec->pk.x.data);
779 eccKeyPairSpec->pk.x.data = nullptr;
780 eccKeyPairSpec->pk.x.len = 0;
781 return res;
782 }
783 eccKeyPairSpec->pk.y.data = retBigInt.data;
784 eccKeyPairSpec->pk.y.len = retBigInt.len;
785
786 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ECC_SK_BN, &retBigInt);
787 if (res != HCF_SUCCESS) {
788 HcfFree(eccKeyPairSpec->pk.x.data);
789 eccKeyPairSpec->pk.x.data = nullptr;
790 eccKeyPairSpec->pk.x.len = 0;
791 HcfFree(eccKeyPairSpec->pk.y.data);
792 eccKeyPairSpec->pk.y.data = nullptr;
793 eccKeyPairSpec->pk.y.len = 0;
794 return res;
795 }
796 eccKeyPairSpec->sk.data = retBigInt.data;
797 eccKeyPairSpec->sk.len = retBigInt.len;
798 return HCF_SUCCESS;
799 }
800
ConstructSm2256KeyPairParamsSpec(const std::string & algoName,HcfEccCommParamsSpec * eccCommSpec,HcfAsyKeyParamsSpec ** spec)801 HcfResult ConstructSm2256KeyPairParamsSpec(const std::string &algoName,
802 HcfEccCommParamsSpec *eccCommSpec, HcfAsyKeyParamsSpec **spec)
803 {
804 HcfAsyKeyGenerator *generator = nullptr;
805 HcfResult res = HCF_ERR_CRYPTO_OPERATION;
806 if (HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator) != HCF_SUCCESS) {
807 return res;
808 }
809 HcfKeyPair *keyPair = nullptr;
810 if (generator->generateKeyPair(generator, nullptr, &keyPair) != HCF_SUCCESS) {
811 HcfObjDestroy(generator);
812 return res;
813 }
814
815 auto eccKeyPairSpec =
816 reinterpret_cast<HcfEccKeyPairParamsSpec*>(HcfMalloc(sizeof(HcfEccKeyPairParamsSpec), 0));
817 if (eccKeyPairSpec != nullptr) {
818 eccKeyPairSpec->base.base.algName = eccCommSpec->base.algName;
819 eccKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
820 eccKeyPairSpec->base.field = eccCommSpec->field;
821 eccKeyPairSpec->base.field->fieldType = eccCommSpec->field->fieldType;
822 (reinterpret_cast<HcfECFieldFp *>(eccKeyPairSpec->base.field))->p.data =
823 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.data;
824 (reinterpret_cast<HcfECFieldFp *>(eccKeyPairSpec->base.field))->p.len =
825 (reinterpret_cast<HcfECFieldFp *>(eccCommSpec->field))->p.len;
826 eccKeyPairSpec->base.a.data = eccCommSpec->a.data;
827 eccKeyPairSpec->base.a.len = eccCommSpec->a.len;
828 eccKeyPairSpec->base.b.data = eccCommSpec->b.data;
829 eccKeyPairSpec->base.b.len = eccCommSpec->b.len;
830 eccKeyPairSpec->base.g.x.data = eccCommSpec->g.x.data;
831 eccKeyPairSpec->base.g.x.len = eccCommSpec->g.x.len;
832 eccKeyPairSpec->base.g.y.data = eccCommSpec->g.y.data;
833 eccKeyPairSpec->base.g.y.len = eccCommSpec->g.y.len;
834 eccKeyPairSpec->base.n.data = eccCommSpec->n.data;
835 eccKeyPairSpec->base.n.len = eccCommSpec->n.len;
836 eccKeyPairSpec->base.h = eccCommSpec->h;
837 if (ConstructSm2256KeyPairBigInt(keyPair, eccKeyPairSpec) != HCF_SUCCESS) {
838 HcfFree(eccKeyPairSpec);
839 } else {
840 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(eccKeyPairSpec);
841 res = HCF_SUCCESS;
842 }
843 }
844 HcfObjDestroy(generator);
845 HcfObjDestroy(keyPair);
846 return res;
847 }
848
CreateAlg25519KeyPairSpec(bool choose,HcfAlg25519KeyPairParamsSpec ** alg25519KeyPairSpec)849 static HcfResult CreateAlg25519KeyPairSpec(bool choose, HcfAlg25519KeyPairParamsSpec **alg25519KeyPairSpec)
850 {
851 *alg25519KeyPairSpec =
852 reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(HcfMalloc(sizeof(HcfAlg25519KeyPairParamsSpec), 0));
853 if (*alg25519KeyPairSpec == nullptr) {
854 return HCF_ERR_MALLOC;
855 }
856 if (choose) {
857 (*alg25519KeyPairSpec)->base.algName = static_cast<char *>(HcfMalloc(sizeof(g_ed25519AlgoName), 0));
858 if ((*alg25519KeyPairSpec)->base.algName == nullptr) {
859 HcfFree(*alg25519KeyPairSpec);
860 *alg25519KeyPairSpec = nullptr;
861 return HCF_ERR_MALLOC;
862 }
863 (void)memcpy_s((*alg25519KeyPairSpec)->base.algName, g_ed25519AlgoName.length(),
864 g_ed25519AlgoName.data(), g_ed25519AlgoName.length());
865 } else {
866 (*alg25519KeyPairSpec)->base.algName = static_cast<char *>(HcfMalloc(sizeof(g_x25519AlgoName), 0));
867 if ((*alg25519KeyPairSpec)->base.algName == nullptr) {
868 HcfFree(*alg25519KeyPairSpec);
869 *alg25519KeyPairSpec = nullptr;
870 return HCF_ERR_MALLOC;
871 }
872 (void)memcpy_s((*alg25519KeyPairSpec)->base.algName, g_x25519AlgoName.length(),
873 g_x25519AlgoName.data(), g_x25519AlgoName.length());
874 }
875 return HCF_SUCCESS;
876 }
877
ConstructAlg25519KeyPairParamsSpec(const string & algoName,bool choose,HcfAsyKeyParamsSpec ** spec)878 static HcfResult ConstructAlg25519KeyPairParamsSpec(const string &algoName, bool choose,
879 HcfAsyKeyParamsSpec **spec)
880 {
881 HcfResult res = HCF_ERR_CRYPTO_OPERATION;
882 HcfAsyKeyGenerator *generator = nullptr;
883 if (HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator) != HCF_SUCCESS) {
884 return res;
885 }
886
887 HcfKeyPair *keyPair = nullptr;
888 if (generator->generateKeyPair(generator, nullptr, &keyPair) != HCF_SUCCESS) {
889 HcfObjDestroy(generator);
890 return res;
891 }
892
893 HcfAlg25519KeyPairParamsSpec *alg25519KeyPairSpec = nullptr;
894 if (CreateAlg25519KeyPairSpec(choose, &alg25519KeyPairSpec) == HCF_SUCCESS) {
895 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
896 alg25519KeyPairSpec->base.specType = HCF_KEY_PAIR_SPEC;
897 if (choose) {
898 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &retBigInt);
899 } else {
900 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, X25519_PK_BN, &retBigInt);
901 }
902
903 if (res == HCF_SUCCESS) {
904 alg25519KeyPairSpec->pk.data = retBigInt.data;
905 alg25519KeyPairSpec->pk.len = retBigInt.len;
906
907 if (choose) {
908 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &retBigInt);
909 } else {
910 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, X25519_SK_BN, &retBigInt);
911 }
912 if (res == HCF_SUCCESS) {
913 alg25519KeyPairSpec->sk.data = retBigInt.data;
914 alg25519KeyPairSpec->sk.len = retBigInt.len;
915 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(alg25519KeyPairSpec);
916 } else {
917 HcfFree(alg25519KeyPairSpec->pk.data);
918 alg25519KeyPairSpec->pk.data = nullptr;
919 alg25519KeyPairSpec->pk.len = 0;
920 }
921 }
922 if (res != HCF_SUCCESS) {
923 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(alg25519KeyPairSpec));
924 }
925 }
926 HcfObjDestroy(generator);
927 HcfObjDestroy(keyPair);
928 return res;
929 }
930
CreateAlg25519PubKeySpec(bool choose,HcfAlg25519PubKeyParamsSpec ** alg25519PubKeySpec)931 static HcfResult CreateAlg25519PubKeySpec(bool choose, HcfAlg25519PubKeyParamsSpec **alg25519PubKeySpec)
932 {
933 *alg25519PubKeySpec =
934 reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(HcfMalloc(sizeof(HcfAlg25519PubKeyParamsSpec), 0));
935 if (*alg25519PubKeySpec == nullptr) {
936 return HCF_ERR_MALLOC;
937 }
938 if (choose) {
939 (*alg25519PubKeySpec)->base.algName = static_cast<char *>(HcfMalloc(sizeof(g_ed25519AlgoName), 0));
940 if ((*alg25519PubKeySpec)->base.algName == nullptr) {
941 HcfFree(*alg25519PubKeySpec);
942 *alg25519PubKeySpec = nullptr;
943 return HCF_ERR_MALLOC;
944 }
945 (void)memcpy_s((*alg25519PubKeySpec)->base.algName, g_ed25519AlgoName.length(),
946 g_ed25519AlgoName.data(), g_ed25519AlgoName.length());
947 } else {
948 (*alg25519PubKeySpec)->base.algName = static_cast<char *>(HcfMalloc(sizeof(g_x25519AlgoName), 0));
949 if ((*alg25519PubKeySpec)->base.algName == nullptr) {
950 HcfFree(*alg25519PubKeySpec);
951 *alg25519PubKeySpec = nullptr;
952 return HCF_ERR_MALLOC;
953 }
954 (void)memcpy_s((*alg25519PubKeySpec)->base.algName, g_x25519AlgoName.length(),
955 g_x25519AlgoName.data(), g_x25519AlgoName.length());
956 }
957 return HCF_SUCCESS;
958 }
959
ConstructAlg25519PubKeyParamsSpec(const string & algoName,bool choose,HcfAsyKeyParamsSpec ** spec)960 static HcfResult ConstructAlg25519PubKeyParamsSpec(const string &algoName, bool choose,
961 HcfAsyKeyParamsSpec **spec)
962 {
963 HcfResult res = HCF_ERR_CRYPTO_OPERATION;
964 HcfAsyKeyGenerator *generator = nullptr;
965 if (HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator) != HCF_SUCCESS) {
966 return res;
967 }
968
969 HcfKeyPair *keyPair = nullptr;
970 if (generator->generateKeyPair(generator, nullptr, &keyPair) != HCF_SUCCESS) {
971 HcfObjDestroy(generator);
972 return res;
973 }
974
975 HcfAlg25519PubKeyParamsSpec *alg25519PubKeySpec = nullptr;
976 if (CreateAlg25519PubKeySpec(choose, &alg25519PubKeySpec) == HCF_SUCCESS) {
977 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
978 alg25519PubKeySpec->base.specType = HCF_PUBLIC_KEY_SPEC;
979 if (choose) {
980 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, ED25519_PK_BN, &retBigInt);
981 } else {
982 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, X25519_PK_BN, &retBigInt);
983 }
984 if (res == HCF_SUCCESS) {
985 alg25519PubKeySpec->pk.data = retBigInt.data;
986 alg25519PubKeySpec->pk.len = retBigInt.len;
987 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(alg25519PubKeySpec);
988 } else {
989 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(alg25519PubKeySpec));
990 }
991 }
992
993 HcfObjDestroy(generator);
994 HcfObjDestroy(keyPair);
995 return res;
996 }
997
CreateAlg25519PriKeySpec(bool choose,HcfAlg25519PriKeyParamsSpec ** alg25519PriKeySpec)998 static HcfResult CreateAlg25519PriKeySpec(bool choose, HcfAlg25519PriKeyParamsSpec **alg25519PriKeySpec)
999 {
1000 *alg25519PriKeySpec =
1001 reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(HcfMalloc(sizeof(HcfAlg25519PriKeyParamsSpec), 0));
1002 if (*alg25519PriKeySpec == nullptr) {
1003 return HCF_ERR_MALLOC;
1004 }
1005 if (choose) {
1006 (*alg25519PriKeySpec)->base.algName = static_cast<char *>(HcfMalloc(sizeof(g_ed25519AlgoName), 0));
1007 if ((*alg25519PriKeySpec)->base.algName == nullptr) {
1008 HcfFree(*alg25519PriKeySpec);
1009 *alg25519PriKeySpec = nullptr;
1010 return HCF_ERR_MALLOC;
1011 }
1012 (void)memcpy_s((*alg25519PriKeySpec)->base.algName, g_ed25519AlgoName.length(),
1013 g_ed25519AlgoName.data(), g_ed25519AlgoName.length());
1014 } else {
1015 (*alg25519PriKeySpec)->base.algName = static_cast<char *>(HcfMalloc(sizeof(g_x25519AlgoName), 0));
1016 if ((*alg25519PriKeySpec)->base.algName == nullptr) {
1017 HcfFree(*alg25519PriKeySpec);
1018 *alg25519PriKeySpec = nullptr;
1019 return HCF_ERR_MALLOC;
1020 }
1021 (void)memcpy_s((*alg25519PriKeySpec)->base.algName, g_x25519AlgoName.length(),
1022 g_x25519AlgoName.data(), g_x25519AlgoName.length());
1023 }
1024 return HCF_SUCCESS;
1025 }
1026
ConstructAlg25519PriKeyParamsSpec(const string & algoName,bool choose,HcfAsyKeyParamsSpec ** spec)1027 static HcfResult ConstructAlg25519PriKeyParamsSpec(const string &algoName, bool choose,
1028 HcfAsyKeyParamsSpec **spec)
1029 {
1030 HcfResult res = HCF_ERR_CRYPTO_OPERATION;
1031 HcfAsyKeyGenerator *generator = nullptr;
1032 if (HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator) != HCF_SUCCESS) {
1033 return res;
1034 }
1035
1036 HcfKeyPair *keyPair = nullptr;
1037 if (generator->generateKeyPair(generator, nullptr, &keyPair) != HCF_SUCCESS) {
1038 HcfObjDestroy(generator);
1039 return res;
1040 }
1041 HcfAlg25519PriKeyParamsSpec *alg25519PriKeySpec = nullptr;
1042 if (CreateAlg25519PriKeySpec(choose, &alg25519PriKeySpec) == HCF_SUCCESS) {
1043 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
1044 alg25519PriKeySpec->base.specType = HCF_PRIVATE_KEY_SPEC;
1045 if (choose) {
1046 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, ED25519_SK_BN, &retBigInt);
1047 } else {
1048 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, X25519_SK_BN, &retBigInt);
1049 }
1050 if (res == HCF_SUCCESS) {
1051 alg25519PriKeySpec->sk.data = retBigInt.data;
1052 alg25519PriKeySpec->sk.len = retBigInt.len;
1053 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(alg25519PriKeySpec);
1054 } else {
1055 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(alg25519PriKeySpec));
1056 }
1057 }
1058 HcfObjDestroy(generator);
1059 HcfObjDestroy(keyPair);
1060 return res;
1061 }
1062
ConstructDhCommParamsSpec(int32_t pLen,int32_t skLen,HcfDhCommParamsSpec ** spec)1063 static HcfResult ConstructDhCommParamsSpec(int32_t pLen, int32_t skLen, HcfDhCommParamsSpec **spec)
1064 {
1065 HcfDhCommParamsSpec *dhCommSpec = nullptr;
1066
1067 HcfDhKeyUtilCreate(pLen, skLen, &dhCommSpec);
1068 if (dhCommSpec == nullptr) {
1069 return HCF_INVALID_PARAMS;
1070 }
1071 *spec = dhCommSpec;
1072 return HCF_SUCCESS;
1073 }
1074
ConstructDhPubKeyParamsSpec(const std::string & algoName,HcfDhCommParamsSpec * dhCommParamsSpec,HcfAsyKeyParamsSpec ** spec)1075 static HcfResult ConstructDhPubKeyParamsSpec(const std::string &algoName,
1076 HcfDhCommParamsSpec *dhCommParamsSpec, HcfAsyKeyParamsSpec **spec)
1077 {
1078 HcfAsyKeyGenerator *generator = nullptr;
1079 HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
1080 if (res != HCF_SUCCESS) {
1081 return res;
1082 }
1083
1084 HcfKeyPair *keyPair = nullptr;
1085 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1086 if (res != HCF_SUCCESS) {
1087 HcfObjDestroy(generator);
1088 return res;
1089 }
1090
1091 HcfDhPubKeyParamsSpec *dhPubKeySpec =
1092 reinterpret_cast<HcfDhPubKeyParamsSpec *>(HcfMalloc(sizeof(HcfDhPubKeyParamsSpec), 0));
1093 if (dhPubKeySpec == nullptr) {
1094 HcfObjDestroy(generator);
1095 HcfObjDestroy(keyPair);
1096 return HCF_ERR_MALLOC;
1097 }
1098 dhPubKeySpec->base.base.algName = dhCommParamsSpec->base.algName;
1099 dhPubKeySpec->base.base.specType = HCF_PUBLIC_KEY_SPEC;
1100 dhPubKeySpec->base.p.data = dhCommParamsSpec->p.data;
1101 dhPubKeySpec->base.p.len = dhCommParamsSpec->p.len;
1102 dhPubKeySpec->base.g.data = dhCommParamsSpec->g.data;
1103 dhPubKeySpec->base.g.len = dhCommParamsSpec->g.len;
1104 dhPubKeySpec->base.length = dhCommParamsSpec->length;
1105 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
1106 res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DH_PK_BN, &retBigInt);
1107 if (res != HCF_SUCCESS) {
1108 HcfObjDestroy(generator);
1109 HcfObjDestroy(keyPair);
1110 HcfFree(dhPubKeySpec);
1111 return res;
1112 }
1113 dhPubKeySpec->pk.data = retBigInt.data;
1114 dhPubKeySpec->pk.len = retBigInt.len;
1115
1116 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(dhPubKeySpec);
1117 HcfObjDestroy(generator);
1118 HcfObjDestroy(keyPair);
1119 return HCF_SUCCESS;
1120 }
1121
ConstructDhPriKeyParamsSpec(const std::string & algoName,HcfDhCommParamsSpec * dhCommParamsSpec,HcfAsyKeyParamsSpec ** spec)1122 static HcfResult ConstructDhPriKeyParamsSpec(const std::string &algoName,
1123 HcfDhCommParamsSpec *dhCommParamsSpec, HcfAsyKeyParamsSpec **spec)
1124 {
1125 HcfAsyKeyGenerator *generator = nullptr;
1126 HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
1127 if (res != HCF_SUCCESS) {
1128 return res;
1129 }
1130 HcfKeyPair *keyPair = nullptr;
1131 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1132 if (res != HCF_SUCCESS) {
1133 HcfObjDestroy(generator);
1134 return res;
1135 }
1136
1137 HcfDhPriKeyParamsSpec *dhPriKeySpec =
1138 reinterpret_cast<HcfDhPriKeyParamsSpec *>(HcfMalloc(sizeof(HcfDhPriKeyParamsSpec), 0));
1139 if (dhPriKeySpec == nullptr) {
1140 HcfObjDestroy(generator);
1141 HcfObjDestroy(keyPair);
1142 return HCF_ERR_MALLOC;
1143 }
1144 dhPriKeySpec->base.base.algName = dhCommParamsSpec->base.algName;
1145 dhPriKeySpec->base.base.specType = HCF_PRIVATE_KEY_SPEC;
1146 dhPriKeySpec->base.p.data = dhCommParamsSpec->p.data;
1147 dhPriKeySpec->base.p.len = dhCommParamsSpec->p.len;
1148 dhPriKeySpec->base.g.data = dhCommParamsSpec->g.data;
1149 dhPriKeySpec->base.g.len = dhCommParamsSpec->g.len;
1150 dhPriKeySpec->base.length = dhCommParamsSpec->length;
1151 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
1152 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DH_SK_BN, &retBigInt);
1153 if (res != HCF_SUCCESS) {
1154 HcfObjDestroy(generator);
1155 HcfObjDestroy(keyPair);
1156 HcfFree(dhPriKeySpec);
1157 return res;
1158 }
1159 dhPriKeySpec->sk.data = retBigInt.data;
1160 dhPriKeySpec->sk.len = retBigInt.len;
1161
1162 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(dhPriKeySpec);
1163 HcfObjDestroy(generator);
1164 HcfObjDestroy(keyPair);
1165 return HCF_SUCCESS;
1166 }
1167
ConstructDhKeyPairBigInt(HcfKeyPair * keyPair,HcfDhKeyPairParamsSpec * dhKeyPairSpec)1168 static HcfResult ConstructDhKeyPairBigInt(HcfKeyPair *keyPair, HcfDhKeyPairParamsSpec *dhKeyPairSpec)
1169 {
1170 HcfBigInteger retBigInt = { .data = nullptr, .len = 0 };
1171 HcfResult res = keyPair->pubKey->getAsyKeySpecBigInteger(keyPair->pubKey, DH_PK_BN, &retBigInt);
1172 if (res != HCF_SUCCESS) {
1173 return res;
1174 }
1175 dhKeyPairSpec->pk.data = retBigInt.data;
1176 dhKeyPairSpec->pk.len = retBigInt.len;
1177
1178 res = keyPair->priKey->getAsyKeySpecBigInteger(keyPair->priKey, DH_SK_BN, &retBigInt);
1179 if (res != HCF_SUCCESS) {
1180 HcfFree(dhKeyPairSpec->pk.data);
1181 dhKeyPairSpec->pk.data = nullptr;
1182 dhKeyPairSpec->pk.len = 0;
1183 return res;
1184 }
1185 dhKeyPairSpec->sk.data = retBigInt.data;
1186 dhKeyPairSpec->sk.len = retBigInt.len;
1187 return HCF_SUCCESS;
1188 }
1189
ConstructDhKeyPairParamsSpec(const std::string & algoName,HcfDhCommParamsSpec * dhCommParamsSpec,HcfAsyKeyParamsSpec ** spec)1190 static HcfResult ConstructDhKeyPairParamsSpec(const std::string &algoName,
1191 HcfDhCommParamsSpec *dhCommParamsSpec, HcfAsyKeyParamsSpec **spec)
1192 {
1193 HcfAsyKeyGenerator *generator = nullptr;
1194 HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
1195 if (res != HCF_SUCCESS) {
1196 return res;
1197 }
1198
1199 HcfKeyPair *keyPair = nullptr;
1200 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1201 if (res != HCF_SUCCESS) {
1202 HcfObjDestroy(generator);
1203 return res;
1204 }
1205
1206 HcfDhKeyPairParamsSpec *dhKeyPairSpec =
1207 reinterpret_cast<HcfDhKeyPairParamsSpec*>(HcfMalloc(sizeof(HcfDhKeyPairParamsSpec), 0));
1208 if (dhKeyPairSpec != nullptr) {
1209 dhKeyPairSpec->base.base.algName = dhCommParamsSpec->base.algName;
1210 dhKeyPairSpec->base.base.specType = HCF_KEY_PAIR_SPEC;
1211 dhKeyPairSpec->base.p.data = dhCommParamsSpec->p.data;
1212 dhKeyPairSpec->base.p.len = dhCommParamsSpec->p.len;
1213 dhKeyPairSpec->base.g.data = dhCommParamsSpec->g.data;
1214 dhKeyPairSpec->base.g.len = dhCommParamsSpec->g.len;
1215 dhKeyPairSpec->base.length = dhCommParamsSpec->length;
1216 res = ConstructDhKeyPairBigInt(keyPair, dhKeyPairSpec);
1217 if (res != HCF_SUCCESS) {
1218 HcfObjDestroy(generator);
1219 HcfObjDestroy(keyPair);
1220 HcfFree(dhKeyPairSpec);
1221 return res;
1222 }
1223 *spec = reinterpret_cast<HcfAsyKeyParamsSpec *>(dhKeyPairSpec);
1224 }
1225
1226 HcfObjDestroy(generator);
1227 HcfObjDestroy(keyPair);
1228 return HCF_SUCCESS;
1229 }
1230
TestEccKey(void)1231 static void TestEccKey(void)
1232 {
1233 HcfAsyKeyGenerator *generator = nullptr;
1234 HcfResult res = HcfAsyKeyGeneratorCreate("ECC224", &generator);
1235 if (res != HCF_SUCCESS) {
1236 return;
1237 }
1238 (void)generator->getAlgoName(generator);
1239 HcfKeyPair *keyPair = nullptr;
1240 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1241 if (res != HCF_SUCCESS) {
1242 HcfObjDestroy(generator);
1243 return;
1244 }
1245 HcfKeyPair *convertKeyPair = nullptr;
1246 static HcfBlob mockEcc224PubKeyBlob = {
1247 .data = g_mockEcc224PubKey,
1248 .len = ECC224_PUB_KEY_LEN
1249 };
1250
1251 static HcfBlob mockEcc224PriKeyBlob = {
1252 .data = g_mockEcc224PriKey,
1253 .len = ECC224_PRI_KEY_LEN
1254 };
1255 (void)generator->convertKey(generator, nullptr, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &convertKeyPair);
1256 HcfObjDestroy(keyPair);
1257 HcfObjDestroy(generator);
1258 HcfObjDestroy(convertKeyPair);
1259 }
1260
TestRsaKey(void)1261 static void TestRsaKey(void)
1262 {
1263 HcfAsyKeyGenerator *generator = nullptr;
1264 HcfResult res = HcfAsyKeyGeneratorCreate("RSA1024", &generator);
1265 if (res != HCF_SUCCESS) {
1266 return;
1267 }
1268 HcfKeyPair *keyPair = nullptr;
1269 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1270 if (res != HCF_SUCCESS) {
1271 HcfObjDestroy(generator);
1272 return;
1273 }
1274 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
1275 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
1276 (void)keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1277 (void)keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1278
1279 HcfKeyPair *dupKeyPair = nullptr;
1280 (void)generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
1281 HcfPubKey *pubKey = dupKeyPair->pubKey;
1282 (void)pubKey->base.getAlgorithm(&(pubKey->base));
1283 (void)pubKey->base.getFormat(&(pubKey->base));
1284 (void)pubKey->base.base.getClass();
1285
1286 HcfBlobDataFree(&pubKeyBlob);
1287 HcfBlobDataFree(&priKeyBlob);
1288 HcfObjDestroy(generator);
1289 HcfObjDestroy(keyPair);
1290 HcfObjDestroy(dupKeyPair);
1291 }
1292
TestDsaKey(void)1293 static void TestDsaKey(void)
1294 {
1295 HcfAsyKeyGenerator *generator = nullptr;
1296 HcfResult res = HcfAsyKeyGeneratorCreate("DSA2048", &generator);
1297 if (res != HCF_SUCCESS) {
1298 return;
1299 }
1300 HcfKeyPair *keyPair = nullptr;
1301 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1302 if (res != HCF_SUCCESS) {
1303 HcfObjDestroy(generator);
1304 return;
1305 }
1306 HcfBlob pubKeyBlob = {.data = nullptr, .len = 0};
1307 HcfBlob priKeyBlob = {.data = nullptr, .len = 0};
1308 (void)keyPair->pubKey->base.getEncoded(&(keyPair->pubKey->base), &pubKeyBlob);
1309 (void)keyPair->priKey->base.getEncoded(&(keyPair->priKey->base), &priKeyBlob);
1310
1311 HcfKeyPair *dupKeyPair = nullptr;
1312 (void)generator->convertKey(generator, nullptr, &pubKeyBlob, &priKeyBlob, &dupKeyPair);
1313 HcfPubKey *pubKey = dupKeyPair->pubKey;
1314 (void)pubKey->base.getAlgorithm(&(pubKey->base));
1315 (void)pubKey->base.getFormat(&(pubKey->base));
1316 (void)pubKey->base.base.getClass();
1317
1318 HcfBlobDataFree(&pubKeyBlob);
1319 HcfBlobDataFree(&priKeyBlob);
1320 HcfObjDestroy(generator);
1321 HcfObjDestroy(keyPair);
1322 HcfObjDestroy(dupKeyPair);
1323 }
1324
TestSm2Key(void)1325 static void TestSm2Key(void)
1326 {
1327 HcfAsyKeyGenerator *generator = nullptr;
1328 HcfResult res = HcfAsyKeyGeneratorCreate("SM2_256", &generator);
1329 if (res != HCF_SUCCESS) {
1330 return;
1331 }
1332 (void)generator->getAlgoName(generator);
1333 HcfKeyPair *keyPair = nullptr;
1334 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1335 if (res != HCF_SUCCESS) {
1336 HcfObjDestroy(generator);
1337 return;
1338 }
1339 HcfKeyPair *convertKeyPair = nullptr;
1340 static HcfBlob mockEcc224PubKeyBlob = {
1341 .data = g_mockSm2256PubKey,
1342 .len = SM2256_PUB_KEY_LEN
1343 };
1344
1345 static HcfBlob mockEcc224PriKeyBlob = {
1346 .data = g_mockSm2256PriKey,
1347 .len = SM2256_PRI_KEY_LEN
1348 };
1349 (void)generator->convertKey(generator, nullptr, &mockEcc224PubKeyBlob, &mockEcc224PriKeyBlob, &convertKeyPair);
1350 HcfObjDestroy(keyPair);
1351 HcfObjDestroy(generator);
1352 HcfObjDestroy(convertKeyPair);
1353 }
1354
TestBrainpoolKey(void)1355 static void TestBrainpoolKey(void)
1356 {
1357 HcfAsyKeyGenerator *generator = nullptr;
1358 HcfResult res = HcfAsyKeyGeneratorCreate("ECC_BrainPoolP160r1", &generator);
1359 if (res != HCF_SUCCESS) {
1360 return;
1361 }
1362 (void)generator->getAlgoName(generator);
1363 HcfKeyPair *keyPair = nullptr;
1364 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1365 if (res != HCF_SUCCESS) {
1366 HcfObjDestroy(generator);
1367 return;
1368 }
1369 HcfKeyPair *convertKeyPair = nullptr;
1370 static HcfBlob mockBrainpoolPubKeyBlob = {
1371 .data = g_mockBrainpoolPubKey,
1372 .len = BRAINPOOLP160R1_PUB_KEY_LEN
1373 };
1374
1375 static HcfBlob mockBrainpoolPriKeyBlob = {
1376 .data = g_mockBrainpoolPriKey,
1377 .len = BRAINPOOLP160R1_PRI_KEY_LEN
1378 };
1379 (void)generator->convertKey(generator, nullptr, &mockBrainpoolPubKeyBlob, &mockBrainpoolPriKeyBlob,
1380 &convertKeyPair);
1381 HcfObjDestroy(keyPair);
1382 HcfObjDestroy(generator);
1383 HcfObjDestroy(convertKeyPair);
1384 }
1385
TestEd25519Key(void)1386 static void TestEd25519Key(void)
1387 {
1388 HcfAsyKeyGenerator *generator = nullptr;
1389 HcfResult res = HcfAsyKeyGeneratorCreate("Ed25519", &generator);
1390 if (res != HCF_SUCCESS) {
1391 return;
1392 }
1393 (void)generator->getAlgoName(generator);
1394 HcfKeyPair *keyPair = nullptr;
1395 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1396 if (res != HCF_SUCCESS) {
1397 HcfObjDestroy(generator);
1398 return;
1399 }
1400 HcfKeyPair *convertKeyPair = nullptr;
1401 static HcfBlob mockEd25519PubKeyBlob = {
1402 .data = g_mockEd25519PubKey,
1403 .len = ED25519_PUB_KEY_LEN
1404 };
1405
1406 static HcfBlob mockEd25519PriKeyBlob = {
1407 .data = g_mockEd25519PriKey,
1408 .len = ED25519_PRI_KEY_LEN
1409 };
1410 (void)generator->convertKey(generator, nullptr, &mockEd25519PubKeyBlob, &mockEd25519PriKeyBlob,
1411 &convertKeyPair);
1412 HcfObjDestroy(keyPair);
1413 HcfObjDestroy(generator);
1414 HcfObjDestroy(convertKeyPair);
1415 }
1416
TestX25519Key(void)1417 static void TestX25519Key(void)
1418 {
1419 HcfAsyKeyGenerator *generator = nullptr;
1420 HcfResult res = HcfAsyKeyGeneratorCreate("X25519", &generator);
1421 if (res != HCF_SUCCESS) {
1422 return;
1423 }
1424 (void)generator->getAlgoName(generator);
1425 HcfKeyPair *keyPair = nullptr;
1426 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1427 if (res != HCF_SUCCESS) {
1428 HcfObjDestroy(generator);
1429 return;
1430 }
1431 HcfKeyPair *convertKeyPair = nullptr;
1432 static HcfBlob mockX25519PubKeyBlob = {
1433 .data = g_mockX25519PubKey,
1434 .len = X25519_PUB_KEY_LEN
1435 };
1436
1437 static HcfBlob mockX25519PriKeyBlob = {
1438 .data = g_mockX25519PriKey,
1439 .len = X25519_PRI_KEY_LEN
1440 };
1441 (void)generator->convertKey(generator, nullptr, &mockX25519PubKeyBlob, &mockX25519PriKeyBlob,
1442 &convertKeyPair);
1443 HcfObjDestroy(keyPair);
1444 HcfObjDestroy(generator);
1445 HcfObjDestroy(convertKeyPair);
1446 }
1447
TestDhKey(void)1448 static void TestDhKey(void)
1449 {
1450 HcfAsyKeyGenerator *generator = nullptr;
1451 HcfResult res = HcfAsyKeyGeneratorCreate("DH_modp2048", &generator);
1452 if (res != HCF_SUCCESS) {
1453 return;
1454 }
1455 (void)generator->getAlgoName(generator);
1456 HcfKeyPair *keyPair = nullptr;
1457 res = generator->generateKeyPair(generator, nullptr, &keyPair);
1458 if (res != HCF_SUCCESS) {
1459 HcfObjDestroy(generator);
1460 return;
1461 }
1462 HcfKeyPair *convertKeyPair = nullptr;
1463 static HcfBlob mockDhPubKeyBlob = {
1464 .data = g_mockDhPubKey,
1465 .len = DH_PUB_KEY_LEN
1466 };
1467
1468 static HcfBlob mockX25519PriKeyBlob = {
1469 .data = g_mockDhPriKey,
1470 .len = DH_PRI_KEY_LEN
1471 };
1472 (void)generator->convertKey(generator, nullptr, &mockDhPubKeyBlob, &mockX25519PriKeyBlob,
1473 &convertKeyPair);
1474 HcfObjDestroy(keyPair);
1475 HcfObjDestroy(generator);
1476 HcfObjDestroy(convertKeyPair);
1477 }
1478
GenEccKeyBySpec(GenerateType type)1479 static void GenEccKeyBySpec(GenerateType type)
1480 {
1481 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1482 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1483 HcfKeyPair *keyPair = nullptr;
1484 HcfPriKey *priKey = nullptr;
1485 HcfPubKey *pubKey = nullptr;
1486 HcfResult res = HCF_SUCCESS;
1487 switch (type) {
1488 case GenerateType::FUZZ_COMMON:
1489 res = ConstructEcc224CommParamsSpec(¶mSpec);
1490 break;
1491 case GenerateType::FUZZ_PRIKEY:
1492 res = ConstructEcc224PriKeyParamsSpec(¶mSpec);
1493 break;
1494 case GenerateType::FUZZ_PUBKEY:
1495 res = ConstructEcc224PubKeyParamsSpec(¶mSpec);
1496 break;
1497 case GenerateType::FUZZ_KEYPAIR:
1498 res = ConstructEcc224KeyPairParamsSpec(¶mSpec);
1499 break;
1500 default:
1501 return;
1502 }
1503 if (res != HCF_SUCCESS) {
1504 return;
1505 }
1506 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1507 if (res != HCF_SUCCESS) {
1508 return;
1509 }
1510 (void)generator->generateKeyPair(generator, &keyPair);
1511 (void)generator->generatePriKey(generator, &priKey);
1512 (void)generator->generatePubKey(generator, &pubKey);
1513 HcfObjDestroy(generator);
1514 HcfObjDestroy(keyPair);
1515 HcfObjDestroy(priKey);
1516 HcfObjDestroy(pubKey);
1517 }
1518
TestEccKeyBySpec(void)1519 static void TestEccKeyBySpec(void)
1520 {
1521 GenEccKeyBySpec(GenerateType::FUZZ_COMMON);
1522 GenEccKeyBySpec(GenerateType::FUZZ_PRIKEY);
1523 GenEccKeyBySpec(GenerateType::FUZZ_PUBKEY);
1524 GenEccKeyBySpec(GenerateType::FUZZ_KEYPAIR);
1525 }
1526
GenRsaKeyBySpec(GenerateType type)1527 static void GenRsaKeyBySpec(GenerateType type)
1528 {
1529 HcfRsaKeyPairParamsSpec rsaPairSpec = {};
1530 HcfRsaPubKeyParamsSpec rsaPubKeySpec = {};
1531 HcfRsaCommParamsSpec rsaCommSpec = {};
1532 unsigned char dataN[RSA_2048_N_BYTE_SIZE] = {0};
1533 unsigned char dataE[RSA_2048_E_BYTE_SIZE] = {0};
1534 unsigned char dataD[RSA_2048_D_BYTE_SIZE] = {0};
1535 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1536 HcfKeyPair *keyPair = nullptr;
1537 HcfPriKey *priKey = nullptr;
1538 HcfPubKey *pubKey = nullptr;
1539 HcfResult res = HCF_SUCCESS;
1540 switch (type) {
1541 case GenerateType::FUZZ_COMMON:
1542 GenerateRsa2048CorrectCommonKeySpec(dataN, &rsaCommSpec);
1543 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaCommSpec),
1544 &generator);
1545 break;
1546 case GenerateType::FUZZ_PUBKEY:
1547 GenerateRsa2048CorrectPubKeySpec(dataN, dataE, &rsaPubKeySpec);
1548 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPubKeySpec),
1549 &generator);
1550 break;
1551 case GenerateType::FUZZ_KEYPAIR:
1552 GenerateRsa2048CorrectKeyPairSpec(dataN, dataE, dataD, &rsaPairSpec);
1553 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&rsaPairSpec),
1554 &generator);
1555 break;
1556 default:
1557 return;
1558 }
1559 if (res != HCF_SUCCESS) {
1560 return;
1561 }
1562 (void)generator->generateKeyPair(generator, &keyPair);
1563 (void)generator->generatePriKey(generator, &priKey);
1564 (void)generator->generatePubKey(generator, &pubKey);
1565 HcfObjDestroy(generator);
1566 HcfObjDestroy(keyPair);
1567 HcfObjDestroy(priKey);
1568 HcfObjDestroy(pubKey);
1569 }
1570
TestRsaKeyBySpec(void)1571 static void TestRsaKeyBySpec(void)
1572 {
1573 GenRsaKeyBySpec(GenerateType::FUZZ_COMMON);
1574 GenRsaKeyBySpec(GenerateType::FUZZ_PUBKEY);
1575 GenRsaKeyBySpec(GenerateType::FUZZ_KEYPAIR);
1576 }
1577
GenDsaKeyBySpec(GenerateType type)1578 static void GenDsaKeyBySpec(GenerateType type)
1579 {
1580 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1581 HcfKeyPair *keyPair = nullptr;
1582 HcfPriKey *priKey = nullptr;
1583 HcfPubKey *pubKey = nullptr;
1584 HcfResult res = HCF_SUCCESS;
1585 switch (type) {
1586 case GenerateType::FUZZ_COMMON:
1587 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaCommonSpec),
1588 &generator);
1589 break;
1590 case GenerateType::FUZZ_PUBKEY:
1591 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaPkSpec),
1592 &generator);
1593 break;
1594 case GenerateType::FUZZ_KEYPAIR:
1595 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(&dsaKeyPairSpec),
1596 &generator);
1597 break;
1598 default:
1599 return;
1600 }
1601 if (res != HCF_SUCCESS) {
1602 return;
1603 }
1604 (void)generator->generateKeyPair(generator, &keyPair);
1605 (void)generator->generatePriKey(generator, &priKey);
1606 (void)generator->generatePubKey(generator, &pubKey);
1607 HcfObjDestroy(generator);
1608 HcfObjDestroy(keyPair);
1609 HcfObjDestroy(priKey);
1610 HcfObjDestroy(pubKey);
1611 }
1612
TestDsaKeyBySpec(void)1613 static void TestDsaKeyBySpec(void)
1614 {
1615 GenDsaKeyBySpec(GenerateType::FUZZ_COMMON);
1616 GenDsaKeyBySpec(GenerateType::FUZZ_PUBKEY);
1617 GenDsaKeyBySpec(GenerateType::FUZZ_KEYPAIR);
1618 }
1619
GenSm2KeyBySpec(GenerateType type,const std::string & algoName,HcfEccCommParamsSpec * eccCommParamsSpec)1620 static void GenSm2KeyBySpec(GenerateType type, const std::string &algoName,
1621 HcfEccCommParamsSpec *eccCommParamsSpec)
1622 {
1623 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1624 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1625 HcfKeyPair *keyPair = nullptr;
1626 HcfPriKey *priKey = nullptr;
1627 HcfPubKey *pubKey = nullptr;
1628 HcfResult res = HCF_SUCCESS;
1629 switch (type) {
1630 case GenerateType::FUZZ_PRIKEY:
1631 res = ConstructSm2256PriKeyParamsSpec(algoName, eccCommParamsSpec, ¶mSpec);
1632 break;
1633 case GenerateType::FUZZ_PUBKEY:
1634 res = ConstructSm2256PubKeyParamsSpec(algoName, eccCommParamsSpec, ¶mSpec);
1635 break;
1636 case GenerateType::FUZZ_KEYPAIR:
1637 res = ConstructSm2256KeyPairParamsSpec(algoName, eccCommParamsSpec, ¶mSpec);
1638 break;
1639 default:
1640 break;
1641 }
1642 if ((res != HCF_SUCCESS) || (HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator) != HCF_SUCCESS)) {
1643 FreeEccCommParamsSpec(eccCommParamsSpec);
1644 return;
1645 }
1646 (void)generator->generateKeyPair(generator, &keyPair);
1647 (void)generator->generatePriKey(generator, &priKey);
1648 (void)generator->generatePubKey(generator, &pubKey);
1649 switch (type) {
1650 case GenerateType::FUZZ_PRIKEY:
1651 DestroyEccPriKeySpec(reinterpret_cast<HcfEccPriKeyParamsSpec *>(paramSpec));
1652 break;
1653 case GenerateType::FUZZ_PUBKEY:
1654 DestroyEccPubKeySpec(reinterpret_cast<HcfEccPubKeyParamsSpec *>(paramSpec));
1655 break;
1656 case GenerateType::FUZZ_KEYPAIR:
1657 DestroyEccKeyPairSpec(reinterpret_cast<HcfEccKeyPairParamsSpec *>(paramSpec));
1658 break;
1659 default:
1660 break;
1661 }
1662 HcfObjDestroy(pubKey);
1663 HcfObjDestroy(priKey);
1664 HcfObjDestroy(keyPair);
1665 HcfObjDestroy(generator);
1666 }
1667
GenSm2KeyCommonBySpec(HcfEccCommParamsSpec * eccCommSpec)1668 static void GenSm2KeyCommonBySpec(HcfEccCommParamsSpec *eccCommSpec)
1669 {
1670 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1671 HcfKeyPair *keyPair = nullptr;
1672 HcfPriKey *priKey = nullptr;
1673 HcfPubKey *pubKey = nullptr;
1674 HcfResult res = HCF_SUCCESS;
1675 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(eccCommSpec), &generator);
1676 if (res != HCF_SUCCESS) {
1677 return;
1678 }
1679 (void)generator->generateKeyPair(generator, &keyPair);
1680 (void)generator->generatePriKey(generator, &priKey);
1681 (void)generator->generatePubKey(generator, &pubKey);
1682 HcfObjDestroy(generator);
1683 HcfObjDestroy(keyPair);
1684 HcfObjDestroy(priKey);
1685 HcfObjDestroy(pubKey);
1686 }
1687
TestSm2KeyBySpec(void)1688 static void TestSm2KeyBySpec(void)
1689 {
1690 if (ConstructSm2256CommParamsSpec("NID_sm2", &g_sm2256CommSpec) != HCF_SUCCESS) {
1691 return;
1692 }
1693 GenSm2KeyCommonBySpec(g_sm2256CommSpec);
1694 GenSm2KeyBySpec(GenerateType::FUZZ_PRIKEY, "SM2_256", g_sm2256CommSpec);
1695 if (ConstructSm2256CommParamsSpec("NID_sm2", &g_sm2256CommSpec) != HCF_SUCCESS) {
1696 return;
1697 }
1698 GenSm2KeyBySpec(GenerateType::FUZZ_PUBKEY, "SM2_256", g_sm2256CommSpec);
1699 if (ConstructSm2256CommParamsSpec("NID_sm2", &g_sm2256CommSpec) != HCF_SUCCESS) {
1700 return;
1701 }
1702 GenSm2KeyBySpec(GenerateType::FUZZ_KEYPAIR, "SM2_256", g_sm2256CommSpec);
1703 }
1704
TestBrainpoolKeyBySpec(void)1705 static void TestBrainpoolKeyBySpec(void)
1706 {
1707 if (ConstructSm2256CommParamsSpec("NID_brainpoolP160r1", &g_brainpoolP160r1CommSpec) != HCF_SUCCESS) {
1708 return;
1709 }
1710 GenSm2KeyCommonBySpec(g_brainpoolP160r1CommSpec);
1711 GenSm2KeyBySpec(GenerateType::FUZZ_PRIKEY, "ECC_BrainPoolP160r1", g_brainpoolP160r1CommSpec);
1712 if (ConstructSm2256CommParamsSpec("NID_brainpoolP160r1", &g_brainpoolP160r1CommSpec) != HCF_SUCCESS) {
1713 return;
1714 }
1715 GenSm2KeyBySpec(GenerateType::FUZZ_PUBKEY, "ECC_BrainPoolP160r1", g_brainpoolP160r1CommSpec);
1716 if (ConstructSm2256CommParamsSpec("NID_brainpoolP160r1", &g_brainpoolP160r1CommSpec) != HCF_SUCCESS) {
1717 return;
1718 }
1719 GenSm2KeyBySpec(GenerateType::FUZZ_KEYPAIR, "ECC_BrainPoolP160r1", g_brainpoolP160r1CommSpec);
1720 }
1721
GenAlg25519KeyBySpec(GenerateType type,const std::string & algoName,bool choose)1722 static void GenAlg25519KeyBySpec(GenerateType type, const std::string &algoName,
1723 bool choose)
1724 {
1725 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1726 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1727 HcfKeyPair *keyPair = nullptr;
1728 HcfPriKey *priKey = nullptr;
1729 HcfPubKey *pubKey = nullptr;
1730 HcfResult res = HCF_SUCCESS;
1731 switch (type) {
1732 case GenerateType::FUZZ_PRIKEY:
1733 res = ConstructAlg25519PriKeyParamsSpec(algoName, choose, ¶mSpec);
1734 break;
1735 case GenerateType::FUZZ_PUBKEY:
1736 res = ConstructAlg25519PubKeyParamsSpec(algoName, choose, ¶mSpec);
1737 break;
1738 case GenerateType::FUZZ_KEYPAIR:
1739 res = ConstructAlg25519KeyPairParamsSpec(algoName, choose, ¶mSpec);
1740 break;
1741 default:
1742 break;
1743 }
1744 if (res != HCF_SUCCESS) {
1745 return;
1746 }
1747 res = HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator);
1748 if (res != HCF_SUCCESS) {
1749 return;
1750 }
1751 (void)generator->generateKeyPair(generator, &keyPair);
1752 (void)generator->generatePriKey(generator, &priKey);
1753 (void)generator->generatePubKey(generator, &pubKey);
1754 switch (type) {
1755 case GenerateType::FUZZ_PRIKEY:
1756 DestroyAlg25519PriKeySpec(reinterpret_cast<HcfAlg25519PriKeyParamsSpec *>(paramSpec));
1757 break;
1758 case GenerateType::FUZZ_PUBKEY:
1759 DestroyAlg25519PubKeySpec(reinterpret_cast<HcfAlg25519PubKeyParamsSpec *>(paramSpec));
1760 break;
1761 case GenerateType::FUZZ_KEYPAIR:
1762 DestroyAlg25519KeyPairSpec(reinterpret_cast<HcfAlg25519KeyPairParamsSpec *>(paramSpec));
1763 break;
1764 default:
1765 break;
1766 }
1767 HcfObjDestroy(pubKey);
1768 HcfObjDestroy(priKey);
1769 HcfObjDestroy(keyPair);
1770 HcfObjDestroy(generator);
1771 }
1772
TestEd25519KeyBySpec(void)1773 static void TestEd25519KeyBySpec(void)
1774 {
1775 GenAlg25519KeyBySpec(GenerateType::FUZZ_PRIKEY, "Ed25519", true);
1776 GenAlg25519KeyBySpec(GenerateType::FUZZ_PUBKEY, "Ed25519", true);
1777 GenAlg25519KeyBySpec(GenerateType::FUZZ_KEYPAIR, "Ed25519", true);
1778 }
1779
TestX25519KeyBySpec(void)1780 static void TestX25519KeyBySpec(void)
1781 {
1782 GenAlg25519KeyBySpec(GenerateType::FUZZ_PRIKEY, "X25519", false);
1783 GenAlg25519KeyBySpec(GenerateType::FUZZ_PUBKEY, "X25519", false);
1784 GenAlg25519KeyBySpec(GenerateType::FUZZ_KEYPAIR, "X25519", false);
1785 }
1786
GenDhKeyBySpec(GenerateType type,const std::string & algoName,HcfDhCommParamsSpec * dhCommParamsSpec)1787 static void GenDhKeyBySpec(GenerateType type, const std::string &algoName,
1788 HcfDhCommParamsSpec *dhCommParamsSpec)
1789 {
1790 HcfAsyKeyParamsSpec *paramSpec = nullptr;
1791 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1792 HcfKeyPair *keyPair = nullptr;
1793 HcfPriKey *priKey = nullptr;
1794 HcfPubKey *pubKey = nullptr;
1795 HcfResult res = HCF_SUCCESS;
1796 switch (type) {
1797 case GenerateType::FUZZ_PRIKEY:
1798 res = ConstructDhPriKeyParamsSpec(algoName, dhCommParamsSpec, ¶mSpec);
1799 break;
1800 case GenerateType::FUZZ_PUBKEY:
1801 res = ConstructDhPubKeyParamsSpec(algoName, dhCommParamsSpec, ¶mSpec);
1802 break;
1803 case GenerateType::FUZZ_KEYPAIR:
1804 res = ConstructDhKeyPairParamsSpec(algoName, dhCommParamsSpec, ¶mSpec);
1805 break;
1806 default:
1807 break;
1808 }
1809 if ((res != HCF_SUCCESS) || (HcfAsyKeyGeneratorBySpecCreate(paramSpec, &generator) != HCF_SUCCESS)) {
1810 FreeDhCommParamsSpec(dhCommParamsSpec);
1811 return;
1812 }
1813 (void)generator->generateKeyPair(generator, &keyPair);
1814 (void)generator->generatePriKey(generator, &priKey);
1815 (void)generator->generatePubKey(generator, &pubKey);
1816 switch (type) {
1817 case GenerateType::FUZZ_PRIKEY:
1818 DestroyDhPriKeySpec(reinterpret_cast<HcfDhPriKeyParamsSpec *>(paramSpec));
1819 break;
1820 case GenerateType::FUZZ_PUBKEY:
1821 DestroyDhPubKeySpec(reinterpret_cast<HcfDhPubKeyParamsSpec *>(paramSpec));
1822 break;
1823 case GenerateType::FUZZ_KEYPAIR:
1824 DestroyDhKeyPairSpec(reinterpret_cast<HcfDhKeyPairParamsSpec *>(paramSpec));
1825 break;
1826 default:
1827 break;
1828 }
1829 HcfObjDestroy(pubKey);
1830 HcfObjDestroy(priKey);
1831 HcfObjDestroy(keyPair);
1832 HcfObjDestroy(generator);
1833 }
1834
GenDhKeyCommonBySpec(HcfDhCommParamsSpec * dhCommSpec)1835 static void GenDhKeyCommonBySpec(HcfDhCommParamsSpec *dhCommSpec)
1836 {
1837 HcfAsyKeyGeneratorBySpec *generator = nullptr;
1838 HcfKeyPair *keyPair = nullptr;
1839 HcfPriKey *priKey = nullptr;
1840 HcfPubKey *pubKey = nullptr;
1841 HcfResult res = HCF_SUCCESS;
1842 res = HcfAsyKeyGeneratorBySpecCreate(reinterpret_cast<HcfAsyKeyParamsSpec *>(dhCommSpec), &generator);
1843 if (res != HCF_SUCCESS) {
1844 return;
1845 }
1846 (void)generator->generateKeyPair(generator, &keyPair);
1847 (void)generator->generatePriKey(generator, &priKey);
1848 (void)generator->generatePubKey(generator, &pubKey);
1849 HcfObjDestroy(generator);
1850 HcfObjDestroy(keyPair);
1851 HcfObjDestroy(priKey);
1852 HcfObjDestroy(pubKey);
1853 }
1854
TestDhKeyBySpec(void)1855 static void TestDhKeyBySpec(void)
1856 {
1857 if (ConstructDhCommParamsSpec(PLEN_BITS, SKLEN_BITS, &g_dhCommSpec) != HCF_SUCCESS) {
1858 return;
1859 }
1860 GenDhKeyCommonBySpec(g_dhCommSpec);
1861 GenDhKeyBySpec(GenerateType::FUZZ_PRIKEY, "DH_ffdhe3072", g_dhCommSpec);
1862 if (ConstructDhCommParamsSpec(PLEN_BITS, SKLEN_BITS, &g_dhCommSpec) != HCF_SUCCESS) {
1863 return;
1864 }
1865 GenDhKeyBySpec(GenerateType::FUZZ_PUBKEY, "DH_ffdhe3072", g_dhCommSpec);
1866 if (ConstructDhCommParamsSpec(PLEN_BITS, SKLEN_BITS, &g_dhCommSpec) != HCF_SUCCESS) {
1867 return;
1868 }
1869 GenDhKeyBySpec(GenerateType::FUZZ_KEYPAIR, "DH_ffdhe3072", g_dhCommSpec);
1870 }
1871
AsyKeyGeneratorFuzzTest(const uint8_t * data,size_t size)1872 bool AsyKeyGeneratorFuzzTest(const uint8_t* data, size_t size)
1873 {
1874 if (g_testFlag) {
1875 TestEccKey();
1876 TestRsaKey();
1877 TestDsaKey();
1878 TestSm2Key();
1879 TestBrainpoolKey();
1880 TestEd25519Key();
1881 TestX25519Key();
1882 TestDhKey();
1883 TestEccKeyBySpec();
1884 TestRsaKeyBySpec();
1885 TestDsaKeyBySpec();
1886 TestSm2KeyBySpec();
1887 TestBrainpoolKeyBySpec();
1888 TestEd25519KeyBySpec();
1889 TestX25519KeyBySpec();
1890 TestDhKeyBySpec();
1891 g_testFlag = false;
1892 }
1893 HcfAsyKeyGenerator *generator = nullptr;
1894 std::string algoName(reinterpret_cast<const char *>(data), size);
1895 HcfResult res = HcfAsyKeyGeneratorCreate(algoName.c_str(), &generator);
1896 if (res != HCF_SUCCESS) {
1897 return false;
1898 }
1899 HcfObjDestroy(generator);
1900 return true;
1901 }
1902 }
1903
1904 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1905 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1906 {
1907 /* Run your code on data */
1908 OHOS::AsyKeyGeneratorFuzzTest(data, size);
1909 return 0;
1910 }
1911