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