1 /*
2  * Copyright (c) 2021-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 "huks_napi.h"
17 
18 #include "napi/native_api.h"
19 #include "napi/native_node_api.h"
20 
21 #include "hks_type.h"
22 #include "huks_napi_abort.h"
23 #include "huks_napi_abort_session.h"
24 #include "huks_napi_attest_key_item_as_user.h"
25 #include "huks_napi_attest_key_item.h"
26 #include "huks_napi_delete_key.h"
27 #include "huks_napi_delete_key_item_as_user.h"
28 #include "huks_napi_delete_key_item.h"
29 #include "huks_napi_export_key.h"
30 #include "huks_napi_export_key_item_as_user.h"
31 #include "huks_napi_export_key_item.h"
32 #include "huks_napi_generate_key.h"
33 #include "huks_napi_generate_key_item_as_user.h"
34 #include "huks_napi_generate_key_item.h"
35 #include "huks_napi_get_key_item_properties_as_user.h"
36 #include "huks_napi_get_key_item_properties.h"
37 #include "huks_napi_get_key_properties.h"
38 #include "huks_napi_get_sdk_version.h"
39 #include "huks_napi_has_key_item_as_user.h"
40 #include "huks_napi_has_key_item.h"
41 #include "huks_napi_import_key.h"
42 #include "huks_napi_import_key_item_as_user.h"
43 #include "huks_napi_import_key_item.h"
44 #include "huks_napi_import_wrapped_key_item_as_user.h"
45 #include "huks_napi_import_wrapped_key_item.h"
46 #include "huks_napi_init.h"
47 #include "huks_napi_init_session_as_user.h"
48 #include "huks_napi_init_session.h"
49 #include "huks_napi_is_key_exist.h"
50 #include "huks_napi_is_key_item_exist.h"
51 #include "huks_napi_list_aliases.h"
52 #include "huks_napi_update_finish.h"
53 #include "huks_napi_update_finish_session.h"
54 
55 namespace HuksNapi {
AddInt32Property(napi_env env,napi_value object,const char * name,int32_t value)56 inline void AddInt32Property(napi_env env, napi_value object, const char *name, int32_t value)
57 {
58     napi_value property = nullptr;
59     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, value, &property));
60     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name, property));
61 }
62 
AddHuksTagPart1(napi_env env,napi_value tag)63 static void AddHuksTagPart1(napi_env env, napi_value tag)
64 {
65     /* Invalid TAG */
66     AddInt32Property(env, tag, "HUKS_TAG_INVALID", HKS_TAG_INVALID);
67 
68     /* Base algrithom TAG: 1 - 200 */
69     AddInt32Property(env, tag, "HUKS_TAG_ALGORITHM", HKS_TAG_ALGORITHM);
70     AddInt32Property(env, tag, "HUKS_TAG_PURPOSE", HKS_TAG_PURPOSE);
71     AddInt32Property(env, tag, "HUKS_TAG_KEY_SIZE", HKS_TAG_KEY_SIZE);
72     AddInt32Property(env, tag, "HUKS_TAG_DIGEST", HKS_TAG_DIGEST);
73     AddInt32Property(env, tag, "HUKS_TAG_PADDING", HKS_TAG_PADDING);
74     AddInt32Property(env, tag, "HUKS_TAG_BLOCK_MODE", HKS_TAG_BLOCK_MODE);
75     AddInt32Property(env, tag, "HUKS_TAG_KEY_TYPE", HKS_TAG_KEY_TYPE);
76     AddInt32Property(env, tag, "HUKS_TAG_ASSOCIATED_DATA", HKS_TAG_ASSOCIATED_DATA);
77     AddInt32Property(env, tag, "HUKS_TAG_NONCE", HKS_TAG_NONCE);
78     AddInt32Property(env, tag, "HUKS_TAG_IV", HKS_TAG_IV);
79 
80     /* Key derivation TAG */
81     AddInt32Property(env, tag, "HUKS_TAG_INFO", HKS_TAG_INFO);
82     AddInt32Property(env, tag, "HUKS_TAG_SALT", HKS_TAG_SALT);
83     AddInt32Property(env, tag, "HUKS_TAG_PWD", HKS_TAG_PWD);
84     AddInt32Property(env, tag, "HUKS_TAG_ITERATION", HKS_TAG_ITERATION);
85 
86     AddInt32Property(env, tag, "HUKS_TAG_KEY_GENERATE_TYPE", HKS_TAG_KEY_GENERATE_TYPE);
87     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_MAIN_KEY", HKS_TAG_DERIVE_MAIN_KEY);
88     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_FACTOR", HKS_TAG_DERIVE_FACTOR);
89     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_ALG", HKS_TAG_DERIVE_ALG);
90     AddInt32Property(env, tag, "HUKS_TAG_AGREE_ALG", HKS_TAG_AGREE_ALG);
91     AddInt32Property(env, tag, "HUKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS", HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS);
92     AddInt32Property(env, tag, "HUKS_TAG_AGREE_PRIVATE_KEY_ALIAS", HKS_TAG_AGREE_PRIVATE_KEY_ALIAS);
93     AddInt32Property(env, tag, "HUKS_TAG_AGREE_PUBLIC_KEY", HKS_TAG_AGREE_PUBLIC_KEY);
94     AddInt32Property(env, tag, "HUKS_TAG_KEY_ALIAS", HKS_TAG_KEY_ALIAS);
95     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_KEY_SIZE", HKS_TAG_DERIVE_KEY_SIZE);
96 
97     /*
98      * Key authentication related TAG: 201 - 300
99      *
100      * Start of validity
101      */
102     AddInt32Property(env, tag, "HUKS_TAG_ACTIVE_DATETIME", HKS_TAG_ACTIVE_DATETIME);
103 
104     /* Date when new "messages" should not be created. */
105     AddInt32Property(env, tag, "HUKS_TAG_ORIGINATION_EXPIRE_DATETIME", HKS_TAG_ORIGINATION_EXPIRE_DATETIME);
106 
107     /* Date when existing "messages" should not be used. */
108     AddInt32Property(env, tag, "HUKS_TAG_USAGE_EXPIRE_DATETIME", HKS_TAG_USAGE_EXPIRE_DATETIME);
109 
110     /* Key creation time */
111     AddInt32Property(env, tag, "HUKS_TAG_CREATION_DATETIME", HKS_TAG_CREATION_DATETIME);
112 
113     /* Other authentication related TAG: 301 - 500 */
114     AddInt32Property(env, tag, "HUKS_TAG_ALL_USERS", HKS_TAG_ALL_USERS);
115     AddInt32Property(env, tag, "HUKS_TAG_USER_ID", HKS_TAG_USER_ID);
116     AddInt32Property(env, tag, "HUKS_TAG_NO_AUTH_REQUIRED", HKS_TAG_NO_AUTH_REQUIRED);
117     AddInt32Property(env, tag, "HUKS_TAG_USER_AUTH_TYPE", HKS_TAG_USER_AUTH_TYPE);
118     AddInt32Property(env, tag, "HUKS_TAG_AUTH_TIMEOUT", HKS_TAG_AUTH_TIMEOUT);
119     AddInt32Property(env, tag, "HUKS_TAG_AUTH_TOKEN", HKS_TAG_AUTH_TOKEN);
120     AddInt32Property(env, tag, "HUKS_TAG_AUTH_STORAGE_LEVEL", HKS_TAG_AUTH_STORAGE_LEVEL);
121     AddInt32Property(env, tag, "HUKS_TAG_USER_AUTH_MODE", HKS_TAG_USER_AUTH_MODE);
122 }
123 
AddHuksTagPart2(napi_env env,napi_value tag)124 static void AddHuksTagPart2(napi_env env, napi_value tag)
125 {
126     /* Attestation related TAG: 501 - 600 */
127     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_CHALLENGE", HKS_TAG_ATTESTATION_CHALLENGE);
128     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_APPLICATION_ID", HKS_TAG_ATTESTATION_APPLICATION_ID);
129     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_BRAND", HKS_TAG_ATTESTATION_ID_BRAND);
130     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_DEVICE", HKS_TAG_ATTESTATION_ID_DEVICE);
131     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_PRODUCT", HKS_TAG_ATTESTATION_ID_PRODUCT);
132     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_SERIAL", HKS_TAG_ATTESTATION_ID_SERIAL);
133     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_IMEI", HKS_TAG_ATTESTATION_ID_IMEI);
134     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_MEID", HKS_TAG_ATTESTATION_ID_MEID);
135     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_MANUFACTURER", HKS_TAG_ATTESTATION_ID_MANUFACTURER);
136     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_MODEL", HKS_TAG_ATTESTATION_ID_MODEL);
137     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_ALIAS", HKS_TAG_ATTESTATION_ID_ALIAS);
138     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_SOCID", HKS_TAG_ATTESTATION_ID_SOCID);
139     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_UDID", HKS_TAG_ATTESTATION_ID_UDID);
140     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO", HKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO);
141     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_VERSION_INFO", HKS_TAG_ATTESTATION_ID_VERSION_INFO);
142 
143     /*
144      * Other reserved TAG: 601 - 1000
145      *
146      * Extention TAG: 1001 - 9999
147      */
148     AddInt32Property(env, tag, "HUKS_TAG_IS_KEY_ALIAS", HKS_TAG_IS_KEY_ALIAS);
149     AddInt32Property(env, tag, "HUKS_TAG_KEY_STORAGE_FLAG", HKS_TAG_KEY_STORAGE_FLAG);
150     AddInt32Property(env, tag, "HUKS_TAG_IS_ALLOWED_WRAP", HKS_TAG_IS_ALLOWED_WRAP);
151     AddInt32Property(env, tag, "HUKS_TAG_KEY_WRAP_TYPE", HKS_TAG_KEY_WRAP_TYPE);
152     AddInt32Property(env, tag, "HUKS_TAG_KEY_AUTH_ID", HKS_TAG_KEY_AUTH_ID);
153     AddInt32Property(env, tag, "HUKS_TAG_KEY_ROLE", HKS_TAG_KEY_ROLE);
154     AddInt32Property(env, tag, "HUKS_TAG_KEY_FLAG", HKS_TAG_KEY_FLAG);
155     AddInt32Property(env, tag, "HUKS_TAG_IS_ASYNCHRONIZED", HKS_TAG_IS_ASYNCHRONIZED);
156     AddInt32Property(env, tag, "HUKS_TAG_SECURE_KEY_ALIAS", HKS_TAG_SECURE_KEY_ALIAS);
157     AddInt32Property(env, tag, "HUKS_TAG_SECURE_KEY_UUID", HKS_TAG_SECURE_KEY_UUID);
158     AddInt32Property(env, tag, "HUKS_TAG_KEY_DOMAIN", HKS_TAG_KEY_DOMAIN);
159     AddInt32Property(env, tag, "HUKS_TAG_IS_DEVICE_PASSWORD_SET", HKS_TAG_IS_DEVICE_PASSWORD_SET);
160 
161     /* Inner-use TAG: 10001 - 10999 */
162     AddInt32Property(env, tag, "HUKS_TAG_PROCESS_NAME", HKS_TAG_PROCESS_NAME);
163     AddInt32Property(env, tag, "HUKS_TAG_PACKAGE_NAME", HKS_TAG_PACKAGE_NAME);
164     AddInt32Property(env, tag, "HUKS_TAG_ACCESS_TIME", HKS_TAG_ACCESS_TIME);
165     AddInt32Property(env, tag, "HUKS_TAG_USES_TIME", HKS_TAG_USES_TIME);
166     AddInt32Property(env, tag, "HUKS_TAG_CRYPTO_CTX", HKS_TAG_CRYPTO_CTX);
167     AddInt32Property(env, tag, "HUKS_TAG_KEY", HKS_TAG_KEY);
168     AddInt32Property(env, tag, "HUKS_TAG_KEY_VERSION", HKS_TAG_KEY_VERSION);
169     AddInt32Property(env, tag, "HUKS_TAG_PAYLOAD_LEN", HKS_TAG_PAYLOAD_LEN);
170     AddInt32Property(env, tag, "HUKS_TAG_AE_TAG", HKS_TAG_AE_TAG);
171     AddInt32Property(env, tag, "HUKS_TAG_IS_KEY_HANDLE", HKS_TAG_IS_KEY_HANDLE);
172 }
173 
AddHuksTagPart3(napi_env env,napi_value tag)174 static void AddHuksTagPart3(napi_env env, napi_value tag)
175 {
176     /* Os version related TAG */
177     AddInt32Property(env, tag, "HUKS_TAG_OS_VERSION", HKS_TAG_OS_VERSION);
178     AddInt32Property(env, tag, "HUKS_TAG_OS_PATCHLEVEL", HKS_TAG_OS_PATCHLEVEL);
179 
180     /*
181      * Reversed TAGs for SOTER: 11000 - 12000
182      *
183      * Other TAGs: 20001 - N
184      * TAGs used for paramSetOut
185      */
186     AddInt32Property(env, tag, "HUKS_TAG_SYMMETRIC_KEY_DATA", HKS_TAG_SYMMETRIC_KEY_DATA);
187     AddInt32Property(env, tag, "HUKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA", HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA);
188     AddInt32Property(env, tag, "HUKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA", HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA);
189     AddInt32Property(env, tag, "HUKS_TAG_IMPORT_KEY_TYPE", HKS_TAG_IMPORT_KEY_TYPE);
190     AddInt32Property(env, tag, "HUKS_TAG_UNWRAP_ALGORITHM_SUITE", HKS_TAG_UNWRAP_ALGORITHM_SUITE);
191     AddInt32Property(env, tag, "HUKS_TAG_DERIVED_AGREED_KEY_STORAGE_FLAG", HKS_TAG_DERIVE_AGREE_KEY_STORAGE_FLAG);
192     AddInt32Property(env, tag, "HUKS_TAG_RSA_PSS_SALT_LEN_TYPE", HKS_TAG_RSA_PSS_SALT_LEN_TYPE);
193 
194     AddInt32Property(env, tag, "HUKS_TAG_KEY_AUTH_ACCESS_TYPE", HKS_TAG_KEY_AUTH_ACCESS_TYPE);
195     AddInt32Property(env, tag, "HUKS_TAG_KEY_SECURE_SIGN_TYPE", HKS_TAG_KEY_SECURE_SIGN_TYPE);
196     AddInt32Property(env, tag, "HUKS_TAG_CHALLENGE_TYPE", HKS_TAG_CHALLENGE_TYPE);
197     AddInt32Property(env, tag, "HUKS_TAG_CHALLENGE_POS", HKS_TAG_CHALLENGE_POS);
198     AddInt32Property(env, tag, "HUKS_TAG_KEY_AUTH_PURPOSE", HKS_TAG_KEY_AUTH_PURPOSE);
199 }
200 
CreateHuksTag(napi_env env)201 static napi_value CreateHuksTag(napi_env env)
202 {
203     napi_value tag = nullptr;
204     NAPI_CALL(env, napi_create_object(env, &tag));
205 
206     AddHuksTagPart1(env, tag);
207     AddHuksTagPart2(env, tag);
208     AddHuksTagPart3(env, tag);
209 
210     return tag;
211 }
212 
CreateHuksKeySize(napi_env env)213 static napi_value CreateHuksKeySize(napi_env env)
214 {
215     napi_value keySize = nullptr;
216     NAPI_CALL(env, napi_create_object(env, &keySize));
217 
218     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_512", HKS_RSA_KEY_SIZE_512);
219     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_768", HKS_RSA_KEY_SIZE_768);
220     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_1024", HKS_RSA_KEY_SIZE_1024);
221     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_2048", HKS_RSA_KEY_SIZE_2048);
222     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_3072", HKS_RSA_KEY_SIZE_3072);
223     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_4096", HKS_RSA_KEY_SIZE_4096);
224 
225     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_224", HKS_ECC_KEY_SIZE_224);
226     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_256", HKS_ECC_KEY_SIZE_256);
227     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_384", HKS_ECC_KEY_SIZE_384);
228     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_521", HKS_ECC_KEY_SIZE_521);
229 
230     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_128", HKS_AES_KEY_SIZE_128);
231     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_192", HKS_AES_KEY_SIZE_192);
232     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_256", HKS_AES_KEY_SIZE_256);
233     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_512", HKS_AES_KEY_SIZE_512);
234 
235     AddInt32Property(env, keySize, "HUKS_CURVE25519_KEY_SIZE_256", HKS_CURVE25519_KEY_SIZE_256);
236 
237     AddInt32Property(env, keySize, "HUKS_DH_KEY_SIZE_2048", HKS_DH_KEY_SIZE_2048);
238     AddInt32Property(env, keySize, "HUKS_DH_KEY_SIZE_3072", HKS_DH_KEY_SIZE_3072);
239     AddInt32Property(env, keySize, "HUKS_DH_KEY_SIZE_4096", HKS_DH_KEY_SIZE_4096);
240 
241     AddInt32Property(env, keySize, "HUKS_SM2_KEY_SIZE_256", HKS_SM2_KEY_SIZE_256);
242     AddInt32Property(env, keySize, "HUKS_SM4_KEY_SIZE_128", HKS_SM4_KEY_SIZE_128);
243 
244     AddInt32Property(env, keySize, "HUKS_DES_KEY_SIZE_64", HKS_DES_KEY_SIZE_64);
245     AddInt32Property(env, keySize, "HUKS_3DES_KEY_SIZE_128", HKS_3DES_KEY_SIZE_128);
246     AddInt32Property(env, keySize, "HUKS_3DES_KEY_SIZE_192", HKS_3DES_KEY_SIZE_192);
247 
248     return keySize;
249 }
250 
CreateHuksKeyAlg(napi_env env)251 static napi_value CreateHuksKeyAlg(napi_env env)
252 {
253     napi_value keyAlg = nullptr;
254     NAPI_CALL(env, napi_create_object(env, &keyAlg));
255 
256     AddInt32Property(env, keyAlg, "HUKS_ALG_RSA", HKS_ALG_RSA);
257     AddInt32Property(env, keyAlg, "HUKS_ALG_ECC", HKS_ALG_ECC);
258     AddInt32Property(env, keyAlg, "HUKS_ALG_DSA", HKS_ALG_DSA);
259 
260     AddInt32Property(env, keyAlg, "HUKS_ALG_AES", HKS_ALG_AES);
261     AddInt32Property(env, keyAlg, "HUKS_ALG_HMAC", HKS_ALG_HMAC);
262     AddInt32Property(env, keyAlg, "HUKS_ALG_HKDF", HKS_ALG_HKDF);
263     AddInt32Property(env, keyAlg, "HUKS_ALG_PBKDF2", HKS_ALG_PBKDF2);
264 
265     AddInt32Property(env, keyAlg, "HUKS_ALG_ECDH", HKS_ALG_ECDH);
266     AddInt32Property(env, keyAlg, "HUKS_ALG_X25519", HKS_ALG_X25519);
267     AddInt32Property(env, keyAlg, "HUKS_ALG_ED25519", HKS_ALG_ED25519);
268     AddInt32Property(env, keyAlg, "HUKS_ALG_DH", HKS_ALG_DH);
269 
270     AddInt32Property(env, keyAlg, "HUKS_ALG_SM2", HKS_ALG_SM2);
271     AddInt32Property(env, keyAlg, "HUKS_ALG_SM3", HKS_ALG_SM3);
272     AddInt32Property(env, keyAlg, "HUKS_ALG_SM4", HKS_ALG_SM4);
273 
274     AddInt32Property(env, keyAlg, "HUKS_ALG_DES", HKS_ALG_DES);
275     AddInt32Property(env, keyAlg, "HUKS_ALG_3DES", HKS_ALG_3DES);
276     AddInt32Property(env, keyAlg, "HUKS_ALG_CMAC", HKS_ALG_CMAC);
277 
278     return keyAlg;
279 }
280 
CreateHuksKeyPurpose(napi_env env)281 static napi_value CreateHuksKeyPurpose(napi_env env)
282 {
283     napi_value keyPurpose = nullptr;
284     NAPI_CALL(env, napi_create_object(env, &keyPurpose));
285 
286     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_ENCRYPT", HKS_KEY_PURPOSE_ENCRYPT);
287     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_DECRYPT", HKS_KEY_PURPOSE_DECRYPT);
288     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_SIGN", HKS_KEY_PURPOSE_SIGN);
289     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_VERIFY", HKS_KEY_PURPOSE_VERIFY);
290     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_DERIVE", HKS_KEY_PURPOSE_DERIVE);
291     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_WRAP", HKS_KEY_PURPOSE_WRAP);
292     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_UNWRAP", HKS_KEY_PURPOSE_UNWRAP);
293     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_MAC", HKS_KEY_PURPOSE_MAC);
294     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_AGREE", HKS_KEY_PURPOSE_AGREE);
295 
296     return keyPurpose;
297 }
298 
CreateHuksKeyPadding(napi_env env)299 static napi_value CreateHuksKeyPadding(napi_env env)
300 {
301     napi_value keyPadding = nullptr;
302     NAPI_CALL(env, napi_create_object(env, &keyPadding));
303 
304     AddInt32Property(env, keyPadding, "HUKS_PADDING_NONE", HKS_PADDING_NONE);
305     AddInt32Property(env, keyPadding, "HUKS_PADDING_OAEP", HKS_PADDING_OAEP);
306     AddInt32Property(env, keyPadding, "HUKS_PADDING_PSS", HKS_PADDING_PSS);
307     AddInt32Property(env, keyPadding, "HUKS_PADDING_PKCS1_V1_5", HKS_PADDING_PKCS1_V1_5);
308     AddInt32Property(env, keyPadding, "HUKS_PADDING_PKCS5", HKS_PADDING_PKCS5);
309     AddInt32Property(env, keyPadding, "HUKS_PADDING_PKCS7", HKS_PADDING_PKCS7);
310     AddInt32Property(env, keyPadding, "HUKS_PADDING_ISO_IEC_9796_2", HKS_PADDING_ISO_IEC_9796_2);
311     AddInt32Property(env, keyPadding, "HUKS_PADDING_ISO_IEC_9797_1", HKS_PADDING_ISO_IEC_9797_1);
312 
313     return keyPadding;
314 }
315 
CreateHuksCipherMode(napi_env env)316 static napi_value CreateHuksCipherMode(napi_env env)
317 {
318     napi_value keyCipherMode = nullptr;
319     NAPI_CALL(env, napi_create_object(env, &keyCipherMode));
320 
321     AddInt32Property(env, keyCipherMode, "HUKS_MODE_ECB", HKS_MODE_ECB);
322     AddInt32Property(env, keyCipherMode, "HUKS_MODE_CBC", HKS_MODE_CBC);
323     AddInt32Property(env, keyCipherMode, "HUKS_MODE_CTR", HKS_MODE_CTR);
324     AddInt32Property(env, keyCipherMode, "HUKS_MODE_OFB", HKS_MODE_OFB);
325     AddInt32Property(env, keyCipherMode, "HUKS_MODE_CFB", HKS_MODE_CFB);
326     AddInt32Property(env, keyCipherMode, "HUKS_MODE_CCM", HKS_MODE_CCM);
327     AddInt32Property(env, keyCipherMode, "HUKS_MODE_GCM", HKS_MODE_GCM);
328 
329     return keyCipherMode;
330 }
331 
CreateHuksKeyStorageType(napi_env env)332 static napi_value CreateHuksKeyStorageType(napi_env env)
333 {
334     napi_value keyStorageType = nullptr;
335     NAPI_CALL(env, napi_create_object(env, &keyStorageType));
336 
337     AddInt32Property(env, keyStorageType, "HUKS_STORAGE_TEMP", HKS_STORAGE_TEMP);
338     AddInt32Property(env, keyStorageType, "HUKS_STORAGE_PERSISTENT", HKS_STORAGE_PERSISTENT);
339     AddInt32Property(env, keyStorageType, "HUKS_STORAGE_ONLY_USED_IN_HUKS", HKS_STORAGE_ONLY_USED_IN_HUKS);
340     AddInt32Property(env, keyStorageType, "HUKS_STORAGE_KEY_EXPORT_ALLOWED", HKS_STORAGE_ALLOW_KEY_EXPORTED);
341 
342     return keyStorageType;
343 }
344 
CreateHuksUnwrapSuite(napi_env env)345 static napi_value CreateHuksUnwrapSuite(napi_env env)
346 {
347     napi_value huksUnwrapSuite = nullptr;
348     NAPI_CALL(env, napi_create_object(env, &huksUnwrapSuite));
349 
350     AddInt32Property(env, huksUnwrapSuite, "HUKS_UNWRAP_SUITE_X25519_AES_256_GCM_NOPADDING",
351                      HKS_UNWRAP_SUITE_X25519_AES_256_GCM_NOPADDING);
352     AddInt32Property(env, huksUnwrapSuite, "HUKS_UNWRAP_SUITE_ECDH_AES_256_GCM_NOPADDING",
353                      HKS_UNWRAP_SUITE_ECDH_AES_256_GCM_NOPADDING);
354     return huksUnwrapSuite;
355 }
356 
AddHuksErrorCodePart1(napi_env env,napi_value errorCode)357 static void AddHuksErrorCodePart1(napi_env env, napi_value errorCode)
358 {
359     AddInt32Property(env, errorCode, "HUKS_SUCCESS", HKS_SUCCESS);
360     AddInt32Property(env, errorCode, "HUKS_FAILURE", HKS_FAILURE);
361     AddInt32Property(env, errorCode, "HUKS_ERROR_BAD_STATE", HKS_ERROR_BAD_STATE);
362     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_ARGUMENT", HKS_ERROR_INVALID_ARGUMENT);
363     AddInt32Property(env, errorCode, "HUKS_ERROR_NOT_SUPPORTED", HKS_ERROR_NOT_SUPPORTED);
364     AddInt32Property(env, errorCode, "HUKS_ERROR_NO_PERMISSION", HKS_ERROR_NO_PERMISSION);
365     AddInt32Property(env, errorCode, "HUKS_ERROR_INSUFFICIENT_DATA", HKS_ERROR_INSUFFICIENT_DATA);
366     AddInt32Property(env, errorCode, "HUKS_ERROR_BUFFER_TOO_SMALL", HKS_ERROR_BUFFER_TOO_SMALL);
367     AddInt32Property(env, errorCode, "HUKS_ERROR_INSUFFICIENT_MEMORY", HKS_ERROR_INSUFFICIENT_MEMORY);
368     AddInt32Property(env, errorCode, "HUKS_ERROR_COMMUNICATION_FAILURE", HKS_ERROR_COMMUNICATION_FAILURE);
369     AddInt32Property(env, errorCode, "HUKS_ERROR_STORAGE_FAILURE", HKS_ERROR_STORAGE_FAILURE);
370     AddInt32Property(env, errorCode, "HUKS_ERROR_HARDWARE_FAILURE", HKS_ERROR_HARDWARE_FAILURE);
371     AddInt32Property(env, errorCode, "HUKS_ERROR_ALREADY_EXISTS", HKS_ERROR_ALREADY_EXISTS);
372     AddInt32Property(env, errorCode, "HUKS_ERROR_NOT_EXIST", HKS_ERROR_NOT_EXIST);
373     AddInt32Property(env, errorCode, "HUKS_ERROR_NULL_POINTER", HKS_ERROR_NULL_POINTER);
374     AddInt32Property(env, errorCode, "HUKS_ERROR_FILE_SIZE_FAIL", HKS_ERROR_FILE_SIZE_FAIL);
375     AddInt32Property(env, errorCode, "HUKS_ERROR_READ_FILE_FAIL", HKS_ERROR_READ_FILE_FAIL);
376     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PUBLIC_KEY", HKS_ERROR_INVALID_PUBLIC_KEY);
377     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PRIVATE_KEY", HKS_ERROR_INVALID_PRIVATE_KEY);
378     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_KEY_INFO", HKS_ERROR_INVALID_KEY_INFO);
379     AddInt32Property(env, errorCode, "HUKS_ERROR_HASH_NOT_EQUAL", HKS_ERROR_HASH_NOT_EQUAL);
380     AddInt32Property(env, errorCode, "HUKS_ERROR_MALLOC_FAIL", HKS_ERROR_MALLOC_FAIL);
381     AddInt32Property(env, errorCode, "HUKS_ERROR_WRITE_FILE_FAIL", HKS_ERROR_WRITE_FILE_FAIL);
382     AddInt32Property(env, errorCode, "HUKS_ERROR_REMOVE_FILE_FAIL", HKS_ERROR_REMOVE_FILE_FAIL);
383     AddInt32Property(env, errorCode, "HUKS_ERROR_OPEN_FILE_FAIL", HKS_ERROR_OPEN_FILE_FAIL);
384     AddInt32Property(env, errorCode, "HUKS_ERROR_CLOSE_FILE_FAIL", HKS_ERROR_CLOSE_FILE_FAIL);
385     AddInt32Property(env, errorCode, "HUKS_ERROR_MAKE_DIR_FAIL", HKS_ERROR_MAKE_DIR_FAIL);
386     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_KEY_FILE", HKS_ERROR_INVALID_KEY_FILE);
387     AddInt32Property(env, errorCode, "HUKS_ERROR_IPC_MSG_FAIL", HKS_ERROR_IPC_MSG_FAIL);
388     AddInt32Property(env, errorCode, "HUKS_ERROR_REQUEST_OVERFLOWS", HKS_ERROR_REQUEST_OVERFLOWS);
389     AddInt32Property(env, errorCode, "HUKS_ERROR_PARAM_NOT_EXIST", HKS_ERROR_PARAM_NOT_EXIST);
390     AddInt32Property(env, errorCode, "HUKS_ERROR_CRYPTO_ENGINE_ERROR", HKS_ERROR_CRYPTO_ENGINE_ERROR);
391     AddInt32Property(env, errorCode, "HUKS_ERROR_COMMUNICATION_TIMEOUT", HKS_ERROR_COMMUNICATION_TIMEOUT);
392     AddInt32Property(env, errorCode, "HUKS_ERROR_IPC_INIT_FAIL", HKS_ERROR_IPC_INIT_FAIL);
393     AddInt32Property(env, errorCode, "HUKS_ERROR_IPC_DLOPEN_FAIL", HKS_ERROR_IPC_DLOPEN_FAIL);
394     AddInt32Property(env, errorCode, "HUKS_ERROR_EFUSE_READ_FAIL", HKS_ERROR_EFUSE_READ_FAIL);
395     AddInt32Property(env, errorCode, "HUKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST", HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST);
396     AddInt32Property(env, errorCode, "HUKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL",
397         HKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL);
398     AddInt32Property(env, errorCode, "HUKS_ERROR_VERIFICATION_FAILED", HKS_ERROR_VERIFICATION_FAILED);
399 }
400 
AddHuksErrorCodePart2(napi_env env,napi_value errorCode)401 static void AddHuksErrorCodePart2(napi_env env, napi_value errorCode)
402 {
403     AddInt32Property(env, errorCode, "HUKS_ERROR_GET_USERIAM_SECINFO_FAILED", HKS_ERROR_GET_USERIAM_SECINFO_FAILED);
404     AddInt32Property(env, errorCode, "HUKS_ERROR_GET_USERIAM_AUTHINFO_FAILED", HKS_ERROR_GET_USERIAM_AUTHINFO_FAILED);
405     AddInt32Property(env, errorCode, "HUKS_ERROR_USER_AUTH_TYPE_NOT_SUPPORT", HKS_ERROR_USER_AUTH_TYPE_NOT_SUPPORT);
406     AddInt32Property(env, errorCode, "HUKS_ERROR_KEY_AUTH_FAILED", HKS_ERROR_KEY_AUTH_FAILED);
407     AddInt32Property(env, errorCode, "HUKS_ERROR_DEVICE_NO_CREDENTIAL", HKS_ERROR_DEVICE_NO_CREDENTIAL);
408     AddInt32Property(env, errorCode, "HUKS_ERROR_API_NOT_SUPPORTED", HKS_ERROR_API_NOT_SUPPORTED);
409     AddInt32Property(env, errorCode, "HUKS_ERROR_KEY_AUTH_PERMANENTLY_INVALIDATED",
410         HKS_ERROR_KEY_AUTH_PERMANENTLY_INVALIDATED);
411     AddInt32Property(env, errorCode, "HUKS_ERROR_KEY_AUTH_VERIFY_FAILED", HKS_ERROR_KEY_AUTH_VERIFY_FAILED);
412     AddInt32Property(env, errorCode, "HUKS_ERROR_KEY_AUTH_TIME_OUT", HKS_ERROR_KEY_AUTH_TIME_OUT);
413     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST", HKS_ERROR_CREDENTIAL_NOT_EXIST);
414 
415     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_ALG_FAIL", HKS_ERROR_CHECK_GET_ALG_FAIL);
416     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_KEY_SIZE_FAIL", HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL);
417     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_PADDING_FAIL", HKS_ERROR_CHECK_GET_PADDING_FAIL);
418     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_PURPOSE_FAIL", HKS_ERROR_CHECK_GET_PURPOSE_FAIL);
419     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_DIGEST_FAIL", HKS_ERROR_CHECK_GET_DIGEST_FAIL);
420     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_MODE_FAIL", HKS_ERROR_CHECK_GET_MODE_FAIL);
421     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_NONCE_FAIL", HKS_ERROR_CHECK_GET_NONCE_FAIL);
422     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_AAD_FAIL", HKS_ERROR_CHECK_GET_AAD_FAIL);
423     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_IV_FAIL", HKS_ERROR_CHECK_GET_IV_FAIL);
424     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_AE_TAG_FAIL", HKS_ERROR_CHECK_GET_AE_TAG_FAIL);
425     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_SALT_FAIL", HKS_ERROR_CHECK_GET_SALT_FAIL);
426     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_ITERATION_FAIL", HKS_ERROR_CHECK_GET_ITERATION_FAIL);
427     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_ALGORITHM", HKS_ERROR_INVALID_ALGORITHM);
428     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_KEY_SIZE", HKS_ERROR_INVALID_KEY_SIZE);
429     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PADDING", HKS_ERROR_INVALID_PADDING);
430     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PURPOSE", HKS_ERROR_INVALID_PURPOSE);
431     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_MODE", HKS_ERROR_INVALID_MODE);
432     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_DIGEST", HKS_ERROR_INVALID_DIGEST);
433     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_SIGNATURE_SIZE", HKS_ERROR_INVALID_SIGNATURE_SIZE);
434     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_IV", HKS_ERROR_INVALID_IV);
435     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_AAD", HKS_ERROR_INVALID_AAD);
436     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_NONCE", HKS_ERROR_INVALID_NONCE);
437     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_AE_TAG", HKS_ERROR_INVALID_AE_TAG);
438     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_SALT", HKS_ERROR_INVALID_SALT);
439     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_ITERATION", HKS_ERROR_INVALID_ITERATION);
440     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_OPERATION", HKS_ERROR_INVALID_OPERATION);
441     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_WRAPPED_FORMAT", HKS_ERROR_INVALID_WRAPPED_FORMAT);
442     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_USAGE_OF_KEY", HKS_ERROR_INVALID_USAGE_OF_KEY);
443     AddInt32Property(env, errorCode, "HUKS_ERROR_INTERNAL_ERROR", HKS_ERROR_INTERNAL_ERROR);
444     AddInt32Property(env, errorCode, "HUKS_ERROR_UNKNOWN_ERROR", HKS_ERROR_UNKNOWN_ERROR);
445 }
446 
AddHuksErrorCodePart3(napi_env env,napi_value errorCode)447 static void AddHuksErrorCodePart3(napi_env env, napi_value errorCode)
448 {
449     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_AUTH_TYP_FAILED", HKS_ERROR_CHECK_GET_AUTH_TYP_FAILED);
450     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_CHALLENGE_TYPE_FAILED",
451         HKS_ERROR_CHECK_GET_CHALLENGE_TYPE_FAILED);
452     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_ACCESS_TYPE_FAILED",
453         HKS_ERROR_CHECK_GET_ACCESS_TYPE_FAILED);
454     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_AUTH_TOKEN_FAILED", HKS_ERROR_CHECK_GET_AUTH_TOKEN_FAILED);
455     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_TIME_OUT", HKS_ERROR_INVALID_TIME_OUT);
456     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_AUTH_TYPE", HKS_ERROR_INVALID_AUTH_TYPE);
457     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_CHALLENGE_TYPE", HKS_ERROR_INVALID_CHALLENGE_TYPE);
458     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_ACCESS_TYPE", HKS_ERROR_INVALID_ACCESS_TYPE);
459     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_AUTH_TOKEN", HKS_ERROR_INVALID_AUTH_TOKEN);
460     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_SECURE_SIGN_TYPE", HKS_ERROR_INVALID_SECURE_SIGN_TYPE);
461 }
462 
CreateHuksErrorCode(napi_env env)463 static napi_value CreateHuksErrorCode(napi_env env)
464 {
465     napi_value errorCode = nullptr;
466     NAPI_CALL(env, napi_create_object(env, &errorCode));
467 
468     AddHuksErrorCodePart1(env, errorCode);
469     AddHuksErrorCodePart2(env, errorCode);
470     AddHuksErrorCodePart3(env, errorCode);
471 
472     return errorCode;
473 }
474 
AddHuksErrCodePart(napi_env env,napi_value errorCode)475 static void AddHuksErrCodePart(napi_env env, napi_value errorCode)
476 {
477     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_PERMISSION_FAIL", HUKS_ERR_CODE_PERMISSION_FAIL);
478     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_NOT_SYSTEM_APP", HUKS_ERR_CODE_NOT_SYSTEM_APP);
479     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_ILLEGAL_ARGUMENT", HUKS_ERR_CODE_ILLEGAL_ARGUMENT);
480     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_NOT_SUPPORTED_API", HUKS_ERR_CODE_NOT_SUPPORTED_API);
481     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED", HUKS_ERR_CODE_FEATURE_NOT_SUPPORTED);
482     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT",
483         HUKS_ERR_CODE_MISSING_CRYPTO_ALG_ARGUMENT);
484     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT",
485         HUKS_ERR_CODE_INVALID_CRYPTO_ALG_ARGUMENT);
486     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_FILE_OPERATION_FAIL", HUKS_ERR_CODE_FILE_OPERATION_FAIL);
487     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_COMMUNICATION_FAIL", HUKS_ERR_CODE_COMMUNICATION_FAIL);
488     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_CRYPTO_FAIL", HUKS_ERR_CODE_CRYPTO_FAIL);
489     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED",
490         HUKS_ERR_CODE_KEY_AUTH_PERMANENTLY_INVALIDATED);
491     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED", HUKS_ERR_CODE_KEY_AUTH_VERIFY_FAILED);
492     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_KEY_AUTH_TIME_OUT", HUKS_ERR_CODE_KEY_AUTH_TIME_OUT);
493     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_SESSION_LIMIT", HUKS_ERR_CODE_SESSION_LIMIT);
494     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_ITEM_NOT_EXIST", HUKS_ERR_CODE_ITEM_NOT_EXIST);
495     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_EXTERNAL_ERROR", HUKS_ERR_CODE_EXTERNAL_ERROR);
496     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST", HUKS_ERR_CODE_CREDENTIAL_NOT_EXIST);
497     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_INSUFFICIENT_MEMORY", HUKS_ERR_CODE_INSUFFICIENT_MEMORY);
498     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_CALL_SERVICE_FAILED", HUKS_ERR_CODE_CALL_SERVICE_FAILED);
499     AddInt32Property(env, errorCode, "HUKS_ERR_CODE_DEVICE_PASSWORD_UNSET", HUKS_ERR_CODE_DEVICE_PASSWORD_UNSET);
500 }
501 
CreateHuksErrCode(napi_env env)502 static napi_value CreateHuksErrCode(napi_env env)
503 {
504     napi_value errorCode = nullptr;
505     NAPI_CALL(env, napi_create_object(env, &errorCode));
506 
507     AddHuksErrCodePart(env, errorCode);
508 
509     return errorCode;
510 }
511 
CreateHuksKeyDigest(napi_env env)512 static napi_value CreateHuksKeyDigest(napi_env env)
513 {
514     napi_value keyDisgest = nullptr;
515     NAPI_CALL(env, napi_create_object(env, &keyDisgest));
516 
517     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_NONE", HKS_DIGEST_NONE);
518     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_MD5", HKS_DIGEST_MD5);
519     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA1", HKS_DIGEST_SHA1);
520     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA224", HKS_DIGEST_SHA224);
521     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA256", HKS_DIGEST_SHA256);
522     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA384", HKS_DIGEST_SHA384);
523     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA512", HKS_DIGEST_SHA512);
524     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SM3", HKS_DIGEST_SM3);
525 
526     return keyDisgest;
527 }
528 
CreateHuksKeyGenerateType(napi_env env)529 static napi_value CreateHuksKeyGenerateType(napi_env env)
530 {
531     napi_value keyGenerateType = nullptr;
532     NAPI_CALL(env, napi_create_object(env, &keyGenerateType));
533 
534     AddInt32Property(env, keyGenerateType, "HUKS_KEY_GENERATE_TYPE_DEFAULT", HKS_KEY_GENERATE_TYPE_DEFAULT);
535     AddInt32Property(env, keyGenerateType, "HUKS_KEY_GENERATE_TYPE_DERIVE", HKS_KEY_GENERATE_TYPE_DERIVE);
536     AddInt32Property(env, keyGenerateType, "HUKS_KEY_GENERATE_TYPE_AGREE", HKS_KEY_GENERATE_TYPE_AGREE);
537 
538     return keyGenerateType;
539 }
540 
CreateHuksKeyFlag(napi_env env)541 static napi_value CreateHuksKeyFlag(napi_env env)
542 {
543     napi_value keyFlag = nullptr;
544     NAPI_CALL(env, napi_create_object(env, &keyFlag));
545 
546     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_IMPORT_KEY", HKS_KEY_FLAG_IMPORT_KEY);
547     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_GENERATE_KEY", HKS_KEY_FLAG_GENERATE_KEY);
548     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_AGREE_KEY", HKS_KEY_FLAG_AGREE_KEY);
549     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_DERIVE_KEY", HKS_KEY_FLAG_DERIVE_KEY);
550 
551     return keyFlag;
552 }
553 
CreateHuksTagType(napi_env env)554 static napi_value CreateHuksTagType(napi_env env)
555 {
556     napi_value tagType = nullptr;
557     NAPI_CALL(env, napi_create_object(env, &tagType));
558 
559     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_INVALID", HKS_TAG_TYPE_INVALID);
560     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_INT", HKS_TAG_TYPE_INT);
561     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_UINT", HKS_TAG_TYPE_UINT);
562     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_ULONG", HKS_TAG_TYPE_ULONG);
563     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_BOOL", HKS_TAG_TYPE_BOOL);
564     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_BYTES", HKS_TAG_TYPE_BYTES);
565 
566     return tagType;
567 }
568 
CreateHuksImportKeyType(napi_env env)569 static napi_value CreateHuksImportKeyType(napi_env env)
570 {
571     napi_value ImportKeyType = nullptr;
572     NAPI_CALL(env, napi_create_object(env, &ImportKeyType));
573 
574     AddInt32Property(env, ImportKeyType, "HUKS_KEY_TYPE_PUBLIC_KEY", HKS_KEY_TYPE_PUBLIC_KEY);
575     AddInt32Property(env, ImportKeyType, "HUKS_KEY_TYPE_PRIVATE_KEY", HKS_KEY_TYPE_PRIVATE_KEY);
576     AddInt32Property(env, ImportKeyType, "HUKS_KEY_TYPE_KEY_PAIR", HKS_KEY_TYPE_KEY_PAIR);
577 
578     return ImportKeyType;
579 }
580 
CreateHuksSendType(napi_env env)581 static napi_value CreateHuksSendType(napi_env env)
582 {
583     napi_value sendType = nullptr;
584     NAPI_CALL(env, napi_create_object(env, &sendType));
585 
586     AddInt32Property(env, sendType, "HUKS_SEND_TYPE_ASYNC", HKS_SEND_TYPE_ASYNC);
587     AddInt32Property(env, sendType, "HUKS_SEND_TYPE_SYNC", HKS_SEND_TYPE_SYNC);
588 
589     return sendType;
590 }
591 
CreateHuksUserAuthType(napi_env env)592 static napi_value CreateHuksUserAuthType(napi_env env)
593 {
594     napi_value value = nullptr;
595     NAPI_CALL(env, napi_create_object(env, &value));
596 
597     AddInt32Property(env, value, "HUKS_USER_AUTH_TYPE_FINGERPRINT", HKS_USER_AUTH_TYPE_FINGERPRINT);
598     AddInt32Property(env, value, "HUKS_USER_AUTH_TYPE_FACE", HKS_USER_AUTH_TYPE_FACE);
599     AddInt32Property(env, value, "HUKS_USER_AUTH_TYPE_PIN", HKS_USER_AUTH_TYPE_PIN);
600 
601     return value;
602 }
603 
CreateHuksAuthAccessType(napi_env env)604 static napi_value CreateHuksAuthAccessType(napi_env env)
605 {
606     napi_value value = nullptr;
607     NAPI_CALL(env, napi_create_object(env, &value));
608 
609     AddInt32Property(env, value, "HUKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD", HKS_AUTH_ACCESS_INVALID_CLEAR_PASSWORD);
610     AddInt32Property(env, value, "HUKS_AUTH_ACCESS_INVALID_NEW_BIO_ENROLL", HKS_AUTH_ACCESS_INVALID_NEW_BIO_ENROLL);
611     AddInt32Property(env, value, "HUKS_AUTH_ACCESS_ALWAYS_VALID", HKS_AUTH_ACCESS_ALWAYS_VALID);
612 
613     return value;
614 }
615 
CreateHuksChallengeType(napi_env env)616 static napi_value CreateHuksChallengeType(napi_env env)
617 {
618     napi_value value = nullptr;
619     NAPI_CALL(env, napi_create_object(env, &value));
620 
621     AddInt32Property(env, value, "HUKS_CHALLENGE_TYPE_NORMAL", HKS_CHALLENGE_TYPE_NORMAL);
622     AddInt32Property(env, value, "HUKS_CHALLENGE_TYPE_CUSTOM", HKS_CHALLENGE_TYPE_CUSTOM);
623     AddInt32Property(env, value, "HUKS_CHALLENGE_TYPE_NONE", HKS_CHALLENGE_TYPE_NONE);
624 
625     return value;
626 }
627 
CreateHuksUserAuthMode(napi_env env)628 static napi_value CreateHuksUserAuthMode(napi_env env)
629 {
630     napi_value value = nullptr;
631     NAPI_CALL(env, napi_create_object(env, &value));
632 
633     AddInt32Property(env, value, "HUKS_USER_AUTH_MODE_LOCAL", HKS_USER_AUTH_MODE_LOCAL);
634     AddInt32Property(env, value, "HUKS_USER_AUTH_MODE_COAUTH", HKS_USER_AUTH_MODE_COAUTH);
635 
636     return value;
637 }
638 
CreateHuksChallengePosition(napi_env env)639 static napi_value CreateHuksChallengePosition(napi_env env)
640 {
641     napi_value value = nullptr;
642     NAPI_CALL(env, napi_create_object(env, &value));
643 
644     AddInt32Property(env, value, "HUKS_CHALLENGE_POS_0", HKS_CHALLENGE_POS_0);
645     AddInt32Property(env, value, "HUKS_CHALLENGE_POS_1", HKS_CHALLENGE_POS_1);
646     AddInt32Property(env, value, "HUKS_CHALLENGE_POS_2", HKS_CHALLENGE_POS_2);
647     AddInt32Property(env, value, "HUKS_CHALLENGE_POS_3", HKS_CHALLENGE_POS_3);
648 
649     return value;
650 }
651 
CreateHuksSecureSignType(napi_env env)652 static napi_value CreateHuksSecureSignType(napi_env env)
653 {
654     napi_value value = nullptr;
655     NAPI_CALL(env, napi_create_object(env, &value));
656 
657     AddInt32Property(env, value, "HUKS_SECURE_SIGN_WITH_AUTHINFO", HKS_SECURE_SIGN_WITH_AUTHINFO);
658 
659     return value;
660 }
661 
CreateHuksRsaPssSaltLenType(napi_env env)662 static napi_value CreateHuksRsaPssSaltLenType(napi_env env)
663 {
664     napi_value rsaPssSaltLenType = nullptr;
665     NAPI_CALL(env, napi_create_object(env, &rsaPssSaltLenType));
666 
667     AddInt32Property(env, rsaPssSaltLenType, "HUKS_RSA_PSS_SALT_LEN_DIGEST", HKS_RSA_PSS_SALTLEN_DIGEST);
668     AddInt32Property(env, rsaPssSaltLenType, "HUKS_RSA_PSS_SALT_LEN_MAX", HKS_RSA_PSS_SALTLEN_MAX);
669 
670     return rsaPssSaltLenType;
671 }
672 
CreateHuksAuthStorageLevel(napi_env env)673 static napi_value CreateHuksAuthStorageLevel(napi_env env)
674 {
675     napi_value value = nullptr;
676     NAPI_CALL(env, napi_create_object(env, &value));
677 
678     AddInt32Property(env, value, "HUKS_AUTH_STORAGE_LEVEL_DE", HKS_AUTH_STORAGE_LEVEL_DE);
679     AddInt32Property(env, value, "HUKS_AUTH_STORAGE_LEVEL_CE", HKS_AUTH_STORAGE_LEVEL_CE);
680     AddInt32Property(env, value, "HUKS_AUTH_STORAGE_LEVEL_ECE", HKS_AUTH_STORAGE_LEVEL_ECE);
681     return value;
682 }
683 }  // namespace HuksNapi
684 
685 using namespace HuksNapi;
686 using namespace HuksNapiItem;
687 
688 extern "C" {
689 napi_property_descriptor NAPI_FUNC_DESC[] = {
690     DECLARE_NAPI_FUNCTION("generateKey", HuksNapiGenerateKey),
691     DECLARE_NAPI_FUNCTION("deleteKey", HuksNapiDeleteKey),
692     DECLARE_NAPI_FUNCTION("getSdkVersion", HuksNapiGetSdkVersion),
693     DECLARE_NAPI_FUNCTION("importKey", HuksNapiImportKey),
694     DECLARE_NAPI_FUNCTION("exportKey", HuksNapiExportKey),
695     DECLARE_NAPI_FUNCTION("getKeyProperties", HuksNapiGetKeyProperties),
696     DECLARE_NAPI_FUNCTION("isKeyExist", HuksNapiIsKeyExist),
697     DECLARE_NAPI_FUNCTION("init", HuksNapiInit),
698     DECLARE_NAPI_FUNCTION("update", HuksNapiUpdate),
699     DECLARE_NAPI_FUNCTION("finish", HuksNapiFinish),
700     DECLARE_NAPI_FUNCTION("abort", HuksNapiAbort),
701 
702     DECLARE_NAPI_FUNCTION("generateKeyItem", HuksNapiItemGenerateKey),
703     DECLARE_NAPI_FUNCTION("generateKeyItemAsUser", HuksNapiItemGenerateKeyAsUser),
704     DECLARE_NAPI_FUNCTION("deleteKeyItem", HuksNapiDeleteKeyItem),
705     DECLARE_NAPI_FUNCTION("deleteKeyItemAsUser", HuksNapiDeleteKeyItemAsUser),
706     DECLARE_NAPI_FUNCTION("importKeyItem", HuksNapiImportKeyItem),
707     DECLARE_NAPI_FUNCTION("importKeyItemAsUser", HuksNapiImportKeyItemAsUser),
708     DECLARE_NAPI_FUNCTION("importWrappedKeyItem", HuksNapiImportWrappedKeyItem),
709     DECLARE_NAPI_FUNCTION("importWrappedKeyItemAsUser", HuksNapiImportWrappedKeyItemAsUser),
710     DECLARE_NAPI_FUNCTION("exportKeyItem", HuksNapiExportKeyItem),
711     DECLARE_NAPI_FUNCTION("exportKeyItemAsUser", HuksNapiExportKeyItemAsUser),
712     DECLARE_NAPI_FUNCTION("getKeyItemProperties", HuksNapiGetKeyItemProperties),
713     DECLARE_NAPI_FUNCTION("getKeyItemPropertiesAsUser", HuksNapiGetKeyItemPropertiesAsUser),
714     DECLARE_NAPI_FUNCTION("isKeyItemExist", HuksNapiIsKeyItemExist),
715     DECLARE_NAPI_FUNCTION("hasKeyItem", HuksNapihasKeyItem),
716     DECLARE_NAPI_FUNCTION("hasKeyItemAsUser", HuksNapiHasKeyItemAsUser),
717     DECLARE_NAPI_FUNCTION("attestKeyItem", HuksNapiAttestKeyItem),
718     DECLARE_NAPI_FUNCTION("attestKeyItemAsUser", HuksNapiAttestKeyItemAsUser),
719     DECLARE_NAPI_FUNCTION("anonAttestKeyItem", HuksNapiAnonAttestKeyItem),
720     DECLARE_NAPI_FUNCTION("anonAttestKeyItemAsUser", HuksNapiAnonAttestKeyItemAsUser),
721     DECLARE_NAPI_FUNCTION("initSession", HuksNapiInitSession),
722     DECLARE_NAPI_FUNCTION("initSessionAsUser", HuksNapiInitSessionAsUser),
723     DECLARE_NAPI_FUNCTION("updateSession", HuksNapiUpdateSession),
724     DECLARE_NAPI_FUNCTION("finishSession", HuksNapiFinishSession),
725     DECLARE_NAPI_FUNCTION("abortSession", HuksNapiAbortSession),
726     DECLARE_NAPI_FUNCTION("listAliases", HuksNapiListAliases),
727 };
728 
HuksNapiRegister(napi_env env,napi_value exports)729 static napi_value HuksNapiRegister(napi_env env, napi_value exports)
730 {
731     napi_property_descriptor propDesc[] = {
732         DECLARE_NAPI_PROPERTY("HuksExceptionErrCode", CreateHuksErrCode(env)),
733         DECLARE_NAPI_PROPERTY("HuksErrorCode", CreateHuksErrorCode(env)),
734         DECLARE_NAPI_PROPERTY("HuksKeyPurpose", CreateHuksKeyPurpose(env)),
735         DECLARE_NAPI_PROPERTY("HuksKeyDigest", CreateHuksKeyDigest(env)),
736         DECLARE_NAPI_PROPERTY("HuksKeyPadding", CreateHuksKeyPadding(env)),
737         DECLARE_NAPI_PROPERTY("HuksCipherMode", CreateHuksCipherMode(env)),
738         DECLARE_NAPI_PROPERTY("HuksKeySize", CreateHuksKeySize(env)),
739         DECLARE_NAPI_PROPERTY("HuksKeyAlg", CreateHuksKeyAlg(env)),
740         DECLARE_NAPI_PROPERTY("HuksKeyGenerateType", CreateHuksKeyGenerateType(env)),
741         DECLARE_NAPI_PROPERTY("HuksKeyFlag", CreateHuksKeyFlag(env)),
742         DECLARE_NAPI_PROPERTY("HuksKeyStorageType", CreateHuksKeyStorageType(env)),
743         DECLARE_NAPI_PROPERTY("HuksTagType", CreateHuksTagType(env)),
744         DECLARE_NAPI_PROPERTY("HuksTag", CreateHuksTag(env)),
745         DECLARE_NAPI_PROPERTY("HuksImportKeyType", CreateHuksImportKeyType(env)),
746         DECLARE_NAPI_PROPERTY("HuksUnwrapSuite", CreateHuksUnwrapSuite(env)),
747         DECLARE_NAPI_PROPERTY("HuksSendType", CreateHuksSendType(env)),
748         DECLARE_NAPI_PROPERTY("HuksUserAuthType", CreateHuksUserAuthType(env)),
749         DECLARE_NAPI_PROPERTY("HuksAuthAccessType", CreateHuksAuthAccessType(env)),
750         DECLARE_NAPI_PROPERTY("HuksChallengeType", CreateHuksChallengeType(env)),
751         DECLARE_NAPI_PROPERTY("HuksUserAuthMode", CreateHuksUserAuthMode(env)),
752         DECLARE_NAPI_PROPERTY("HuksChallengePosition", CreateHuksChallengePosition(env)),
753         DECLARE_NAPI_PROPERTY("HuksSecureSignType", CreateHuksSecureSignType(env)),
754         DECLARE_NAPI_PROPERTY("HuksRsaPssSaltLenType", CreateHuksRsaPssSaltLenType(env)),
755         DECLARE_NAPI_PROPERTY("HuksAuthStorageLevel", CreateHuksAuthStorageLevel(env)),
756     };
757     napi_property_descriptor desc[HKS_ARRAY_SIZE(NAPI_FUNC_DESC) + HKS_ARRAY_SIZE(propDesc)];
758 
759     for (uint32_t i = 0; i < HKS_ARRAY_SIZE(NAPI_FUNC_DESC); ++i) {
760         desc[i] = NAPI_FUNC_DESC[i];
761     }
762 
763     for (uint32_t i = 0; i < HKS_ARRAY_SIZE(propDesc); ++i) {
764         desc[HKS_ARRAY_SIZE(NAPI_FUNC_DESC) + i] = propDesc[i];
765     }
766 
767     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
768     return exports;
769 }
770 
771 static napi_module g_module = {
772     .nm_version = 1,
773     .nm_flags = 0,
774     .nm_filename = nullptr,
775     .nm_register_func = HuksNapiRegister,
776     .nm_modname = "security.huks",
777     .nm_priv = reinterpret_cast<void *>(0),
778     .reserved = { 0 },
779 };
780 
RegisterModule(void)781 __attribute__((constructor)) void RegisterModule(void)
782 {
783     napi_module_register(&g_module);
784 }
785 }
786