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