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