1 /*
2 * Copyright (C) 2022-2024 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 "params_parser.h"
17
18 #include <stdbool.h>
19 #include <stddef.h>
20 #include <string.h>
21 #include "hcf_string.h"
22 #include "log.h"
23
24 static const HcfParaConfig PARAM_CONFIG[] = {
25 {"ECC224", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_224},
26 {"ECC256", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_256},
27 {"ECC384", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_384},
28 {"ECC521", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_521},
29
30 {"AES128", HCF_ALG_KEY_TYPE, HCF_ALG_AES_128},
31 {"AES192", HCF_ALG_KEY_TYPE, HCF_ALG_AES_192},
32 {"AES256", HCF_ALG_KEY_TYPE, HCF_ALG_AES_256},
33 {"SM4_128", HCF_ALG_KEY_TYPE, HCF_ALG_SM4_128},
34 {"3DES192", HCF_ALG_KEY_TYPE, HCF_ALG_3DES_192},
35 {"DES64", HCF_ALG_KEY_TYPE, HCF_ALG_DES_64},
36
37 {"ECB", HCF_ALG_MODE, HCF_ALG_MODE_ECB},
38 {"CBC", HCF_ALG_MODE, HCF_ALG_MODE_CBC},
39 {"CTR", HCF_ALG_MODE, HCF_ALG_MODE_CTR},
40 {"OFB", HCF_ALG_MODE, HCF_ALG_MODE_OFB},
41 {"CFB", HCF_ALG_MODE, HCF_ALG_MODE_CFB},
42 {"CFB1", HCF_ALG_MODE, HCF_ALG_MODE_CFB1},
43 {"CFB8", HCF_ALG_MODE, HCF_ALG_MODE_CFB8},
44 {"CFB64", HCF_ALG_MODE, HCF_ALG_MODE_CFB64},
45 {"CFB128", HCF_ALG_MODE, HCF_ALG_MODE_CFB128},
46 {"CCM", HCF_ALG_MODE, HCF_ALG_MODE_CCM},
47 {"GCM", HCF_ALG_MODE, HCF_ALG_MODE_GCM},
48
49 {"NoPadding", HCF_ALG_PADDING_TYPE, HCF_ALG_NOPADDING},
50 {"PKCS5", HCF_ALG_PADDING_TYPE, HCF_ALG_PADDING_PKCS5},
51 {"PKCS7", HCF_ALG_PADDING_TYPE, HCF_ALG_PADDING_PKCS7},
52
53 {"RSA512", HCF_ALG_KEY_TYPE, HCF_OPENSSL_RSA_512},
54 {"RSA768", HCF_ALG_KEY_TYPE, HCF_OPENSSL_RSA_768},
55 {"RSA1024", HCF_ALG_KEY_TYPE, HCF_OPENSSL_RSA_1024},
56 {"RSA2048", HCF_ALG_KEY_TYPE, HCF_OPENSSL_RSA_2048},
57 {"RSA3072", HCF_ALG_KEY_TYPE, HCF_OPENSSL_RSA_3072},
58 {"RSA4096", HCF_ALG_KEY_TYPE, HCF_OPENSSL_RSA_4096},
59 {"RSA8192", HCF_ALG_KEY_TYPE, HCF_OPENSSL_RSA_8192},
60
61 {"DH_modp1536", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_MODP_1536},
62 {"DH_modp2048", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_MODP_2048},
63 {"DH_modp3072", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_MODP_3072},
64 {"DH_modp4096", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_MODP_4096},
65 {"DH_modp6144", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_MODP_6144},
66 {"DH_modp8192", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_MODP_8192},
67
68 {"DH_ffdhe2048", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_FFDHE_2048},
69 {"DH_ffdhe3072", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_FFDHE_3072},
70 {"DH_ffdhe4096", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_FFDHE_4096},
71 {"DH_ffdhe6144", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_FFDHE_6144},
72 {"DH_ffdhe8192", HCF_ALG_KEY_TYPE, HCF_OPENSSL_DH_FFDHE_8192},
73
74 {"PKCS1", HCF_ALG_PADDING_TYPE, HCF_OPENSSL_RSA_PKCS1_PADDING},
75 {"PKCS1_OAEP", HCF_ALG_PADDING_TYPE, HCF_OPENSSL_RSA_PKCS1_OAEP_PADDING},
76 {"PSS", HCF_ALG_PADDING_TYPE, HCF_OPENSSL_RSA_PSS_PADDING},
77
78 {"NoHash", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_NONE},
79 {"MD5", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_MD5},
80 {"SM3", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_SM3},
81 {"SHA1", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_SHA1},
82 {"SHA224", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_SHA224},
83 {"SHA256", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_SHA256},
84 {"SHA384", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_SHA384},
85 {"SHA512", HCF_ALG_DIGEST, HCF_OPENSSL_DIGEST_SHA512},
86
87 {"MGF1_MD5", HCF_ALG_MGF1_DIGEST, HCF_OPENSSL_DIGEST_MD5},
88 {"MGF1_SHA1", HCF_ALG_MGF1_DIGEST, HCF_OPENSSL_DIGEST_SHA1},
89 {"MGF1_SHA224", HCF_ALG_MGF1_DIGEST, HCF_OPENSSL_DIGEST_SHA224},
90 {"MGF1_SHA256", HCF_ALG_MGF1_DIGEST, HCF_OPENSSL_DIGEST_SHA256},
91 {"MGF1_SHA384", HCF_ALG_MGF1_DIGEST, HCF_OPENSSL_DIGEST_SHA384},
92 {"MGF1_SHA512", HCF_ALG_MGF1_DIGEST, HCF_OPENSSL_DIGEST_SHA512},
93
94 {"PRIMES_2", HCF_ALG_PRIMES, HCF_OPENSSL_PRIMES_2},
95 {"PRIMES_3", HCF_ALG_PRIMES, HCF_OPENSSL_PRIMES_3},
96 {"PRIMES_4", HCF_ALG_PRIMES, HCF_OPENSSL_PRIMES_4},
97 {"PRIMES_5", HCF_ALG_PRIMES, HCF_OPENSSL_PRIMES_5},
98
99 {"DSA1024", HCF_ALG_KEY_TYPE, HCF_ALG_DSA_1024},
100 {"DSA2048", HCF_ALG_KEY_TYPE, HCF_ALG_DSA_2048},
101 {"DSA3072", HCF_ALG_KEY_TYPE, HCF_ALG_DSA_3072},
102
103 {"SM2_256", HCF_ALG_KEY_TYPE, HCF_ALG_SM2_256},
104
105 {"RSA", HCF_ALG_TYPE, HCF_ALG_RSA_DEFAULT},
106 {"DSA", HCF_ALG_TYPE, HCF_ALG_DSA_DEFAULT},
107 {"ECC", HCF_ALG_TYPE, HCF_ALG_ECC_DEFAULT},
108 {"SM2", HCF_ALG_TYPE, HCF_ALG_SM2_DEFAULT},
109 {"AES", HCF_ALG_TYPE, HCF_ALG_AES_DEFAULT},
110 {"SM4", HCF_ALG_TYPE, HCF_ALG_SM4_DEFAULT},
111 {"DES", HCF_ALG_TYPE, HCF_ALG_DES_DEFAULT},
112 {"3DES", HCF_ALG_TYPE, HCF_ALG_3DES_DEFAULT},
113 {"HMAC", HCF_ALG_TYPE, HCF_ALG_HMAC_DEFAULT},
114 {"PBKDF2", HCF_ALG_TYPE, HCF_ALG_PBKDF2_DEFAULT},
115 {"HKDF", HCF_ALG_TYPE, HCF_ALG_HKDF_DEFAULT},
116 {"SCRYPT", HCF_ALG_TYPE, HCF_ALG_SCRYPT_DEFAULT},
117 {"EXTRACT_AND_EXPAND", HCF_ALG_MODE, HCF_ALG_MODE_EXTRACT_AND_EXPAND},
118 {"EXTRACT_ONLY", HCF_ALG_MODE, HCF_ALG_MODE_EXTRACT_ONLY},
119 {"EXPAND_ONLY", HCF_ALG_MODE, HCF_ALG_MODE_EXPAND_ONLY},
120 {"ECC_BP", HCF_ALG_TYPE, HCF_ALG_ECC_BRAINPOOL_DEFAULT},
121 {"X25519_BP", HCF_ALG_TYPE, HCF_ALG_X25519_DEFAULT},
122 {"DH", HCF_ALG_TYPE, HCF_ALG_DH_DEFAULT},
123
124 {"C1C3C2", HCF_ALG_TEXT_FORMAT, HCF_ALG_TEXT_FORMAT_C1C3C2},
125 {"C1C2C3", HCF_ALG_TEXT_FORMAT, HCF_ALG_TEXT_FORMAT_C1C2C3},
126
127 {"ECC_BrainPoolP160r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP160R1},
128 {"ECC_BrainPoolP160t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP160T1},
129 {"ECC_BrainPoolP192r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP192R1},
130 {"ECC_BrainPoolP192t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP192T1},
131 {"ECC_BrainPoolP224r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP224R1},
132 {"ECC_BrainPoolP224t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP224T1},
133 {"ECC_BrainPoolP256r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP256R1},
134 {"ECC_BrainPoolP256t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP256T1},
135 {"ECC_BrainPoolP320r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP320R1},
136 {"ECC_BrainPoolP320t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP320T1},
137 {"ECC_BrainPoolP384r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP384R1},
138 {"ECC_BrainPoolP384t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP384T1},
139 {"ECC_BrainPoolP512r1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP512R1},
140 {"ECC_BrainPoolP512t1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_BP512T1},
141 {"ECC_Secp256k1", HCF_ALG_KEY_TYPE, HCF_ALG_ECC_SECP256K1},
142
143 {"Ed25519", HCF_ALG_KEY_TYPE, HCF_ALG_ED25519_256},
144 {"X25519", HCF_ALG_KEY_TYPE, HCF_ALG_X25519_256},
145
146 {"OnlySign", HCF_ALG_SIGN_TYPE, HCF_ALG_ONLY_SIGN},
147 {"Recover", HCF_ALG_VERIFY_TYPE, HCF_ALG_VERIFY_RECOVER}
148 };
149
150 static const HcfAlgMap ALG_MAP[] = {
151 {"DSA", HCF_ALG_DSA},
152 {"RSA", HCF_ALG_RSA},
153 {"ECC", HCF_ALG_ECC},
154 {"SM2", HCF_ALG_SM2},
155 {"Ed25519", HCF_ALG_ED25519},
156 {"X25519", HCF_ALG_X25519},
157 {"DH", HCF_ALG_DH}
158 };
159
160 static const HcfCurveMap CURVE_MAP[] = {
161 {"NID_secp224r1", HCF_ALG_ECC_224},
162 {"NID_X9_62_prime256v1", HCF_ALG_ECC_256},
163 {"NID_secp384r1", HCF_ALG_ECC_384},
164 {"NID_secp521r1", HCF_ALG_ECC_521},
165 {"NID_sm2", HCF_ALG_SM2_256},
166 {"NID_brainpoolP160r1", HCF_ALG_ECC_BP160R1},
167 {"NID_brainpoolP160t1", HCF_ALG_ECC_BP160T1},
168 {"NID_brainpoolP192r1", HCF_ALG_ECC_BP192R1},
169 {"NID_brainpoolP192t1", HCF_ALG_ECC_BP192T1},
170 {"NID_brainpoolP224r1", HCF_ALG_ECC_BP224R1},
171 {"NID_brainpoolP224t1", HCF_ALG_ECC_BP224T1},
172 {"NID_brainpoolP256r1", HCF_ALG_ECC_BP256R1},
173 {"NID_brainpoolP256t1", HCF_ALG_ECC_BP256T1},
174 {"NID_brainpoolP320r1", HCF_ALG_ECC_BP320R1},
175 {"NID_brainpoolP320t1", HCF_ALG_ECC_BP320T1},
176 {"NID_brainpoolP384r1", HCF_ALG_ECC_BP384R1},
177 {"NID_brainpoolP384t1", HCF_ALG_ECC_BP384T1},
178 {"NID_brainpoolP512r1", HCF_ALG_ECC_BP512R1},
179 {"NID_brainpoolP512t1", HCF_ALG_ECC_BP512T1},
180 {"NID_secp256k1", HCF_ALG_ECC_SECP256K1}
181 };
182
183 static const HcfFormatMap FORMAT_MAP[] = {
184 {"UNCOMPRESSED", HCF_UNCOMPRESSED_FORMAT_VALUE},
185 {"COMPRESSED", HCF_COMPRESSED_FORMAT_VALUE}
186 };
187
FindConfig(const HcString * tag)188 static const HcfParaConfig *FindConfig(const HcString* tag)
189 {
190 if (tag == NULL) {
191 return NULL;
192 }
193
194 for (uint32_t i = 0; i < sizeof(PARAM_CONFIG) / sizeof(HcfParaConfig); ++i) {
195 if (StringCompare(tag, PARAM_CONFIG[i].tag) == 0) {
196 return &PARAM_CONFIG[i];
197 }
198 }
199 return NULL;
200 }
201
ParseAndSetParameter(const char * paramsStr,void * params,SetParameterFunc setFunc)202 HcfResult ParseAndSetParameter(const char *paramsStr, void *params, SetParameterFunc setFunc)
203 {
204 if (paramsStr == NULL || setFunc == NULL) {
205 return HCF_INVALID_PARAMS;
206 }
207 HcString str = CreateString();
208 HcString subStr = CreateString();
209 if (!StringSetPointer(&str, paramsStr)) {
210 DeleteString(&subStr);
211 DeleteString(&str);
212 return HCF_INVALID_PARAMS;
213 }
214 HcfResult ret = HCF_INVALID_PARAMS;
215 uint32_t pos = 0;
216 do {
217 int findPos = StringFind(&str, '|', pos);
218 if (findPos >= 0) {
219 if (!StringSubString(&str, pos, findPos - pos, &subStr)) {
220 LOGE("StringSubString failed!");
221 break;
222 }
223 ret = (*setFunc)(FindConfig(&subStr), params);
224 if (ret != HCF_SUCCESS) {
225 break;
226 }
227 pos = findPos + 1;
228 } else {
229 uint32_t strLen = StringLength(&str);
230 if (strLen < pos) {
231 break;
232 }
233 if (!StringSubString(&str, pos, strLen - pos, &subStr)) {
234 LOGE("get last string failed!");
235 break;
236 }
237 ret = (*setFunc)(FindConfig(&subStr), params);
238 break;
239 }
240 } while (true);
241
242 DeleteString(&subStr);
243 DeleteString(&str);
244 return ret;
245 }
246
ParseAlgNameToParams(const char * algNameStr,HcfAsyKeyGenParams * params)247 HcfResult ParseAlgNameToParams(const char *algNameStr, HcfAsyKeyGenParams *params)
248 {
249 if (algNameStr == NULL || params == NULL) {
250 return HCF_INVALID_PARAMS;
251 }
252 for (uint32_t i = 0; i < sizeof(ALG_MAP) / sizeof(HcfAlgMap); ++i) {
253 if (strcmp(algNameStr, ALG_MAP[i].algNameStr) == 0) {
254 params->algo = ALG_MAP[i].algValue;
255 params->bits = 0;
256 return HCF_SUCCESS;
257 }
258 }
259 LOGE("Not support algorithm name: %{public}s", algNameStr);
260 return HCF_INVALID_PARAMS;
261 }
262
ParseCurveNameToParams(const char * curveNameStr,HcfAsyKeyGenParams * params)263 HcfResult ParseCurveNameToParams(const char *curveNameStr, HcfAsyKeyGenParams *params)
264 {
265 if (curveNameStr == NULL || params == NULL) {
266 LOGE("curveName to Params failed!");
267 return HCF_INVALID_PARAMS;
268 }
269 for (uint32_t i = 0; i < sizeof(CURVE_MAP) / sizeof(HcfCurveMap); ++i) {
270 if (strcmp(curveNameStr, CURVE_MAP[i].curveNameStr) == 0) {
271 params->algo = HCF_ALG_ECC;
272 params->bits = CURVE_MAP[i].algValue;
273 return HCF_SUCCESS;
274 }
275 }
276 LOGE("Not support algorithm name: %{public}s", curveNameStr);
277 return HCF_NOT_SUPPORT;
278 }
279
GetAlgValueByCurveName(const char * curveNameStr,HcfAlgParaValue * algValue)280 HcfResult GetAlgValueByCurveName(const char *curveNameStr, HcfAlgParaValue *algValue)
281 {
282 if (curveNameStr == NULL || algValue == NULL) {
283 LOGE("Invalid parameter!");
284 return HCF_INVALID_PARAMS;
285 }
286 for (uint32_t i = 0; i < sizeof(CURVE_MAP) / sizeof(CURVE_MAP[0]); i++) {
287 if (strcmp(CURVE_MAP[i].curveNameStr, curveNameStr) == 0) {
288 *algValue = CURVE_MAP[i].algValue;
289 return HCF_SUCCESS;
290 }
291 }
292 LOGE("Invalid curve name: %{public}s", curveNameStr);
293 return HCF_INVALID_PARAMS;
294 }
295
GetFormatValueByFormatName(const char * formatName,HcfFormatValue * formatValue)296 HcfResult GetFormatValueByFormatName(const char *formatName, HcfFormatValue *formatValue)
297 {
298 if (formatName == NULL || formatValue == NULL) {
299 LOGE("Invalid parameter!");
300 return HCF_INVALID_PARAMS;
301 }
302
303 for (uint32_t i = 0; i < sizeof(FORMAT_MAP) / sizeof(FORMAT_MAP[0]); i++) {
304 if (strcmp(FORMAT_MAP[i].formatName, formatName) == 0) {
305 *formatValue = FORMAT_MAP[i].formatValue;
306 return HCF_SUCCESS;
307 }
308 }
309 LOGE("Invalid format name: %{public}s", formatName);
310 return HCF_INVALID_PARAMS;
311 }
312