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