• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_agree_key.h"
23 #include "huks_napi_attest_key.h"
24 #include "huks_napi_decrypt.h"
25 #include "huks_napi_delete_key.h"
26 #include "huks_napi_derive_key.h"
27 #include "huks_napi_encrypt.h"
28 #include "huks_napi_export_key.h"
29 #include "huks_napi_generate_key.h"
30 #include "huks_napi_get_certificate_chain.h"
31 #include "huks_napi_get_key_properties.h"
32 #include "huks_napi_get_sdk_version.h"
33 #include "huks_napi_import_key.h"
34 #include "huks_napi_is_key_exist.h"
35 #include "huks_napi_mac.h"
36 #include "huks_napi_sign.h"
37 #include "huks_napi_unwrap_key.h"
38 #include "huks_napi_verify.h"
39 #include "huks_napi_wrap_key.h"
40 
41 #include "huks_napi_abort.h"
42 #include "huks_napi_finish.h"
43 #include "huks_napi_init.h"
44 #include "huks_napi_update.h"
45 
46 namespace HuksNapi {
AddInt32Property(napi_env env,napi_value object,const char * name,int32_t value)47 inline void AddInt32Property(napi_env env, napi_value object, const char *name, int32_t value)
48 {
49     napi_value property = nullptr;
50     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, value, &property));
51     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, name, property));
52 }
53 
AddHuksTagPart1(napi_env env,napi_value tag)54 static void AddHuksTagPart1(napi_env env, napi_value tag)
55 {
56     /* Invalid TAG */
57     AddInt32Property(env, tag, "HUKS_TAG_INVALID", HKS_TAG_INVALID);
58 
59     /* Base algrithom TAG: 1 - 200 */
60     AddInt32Property(env, tag, "HUKS_TAG_ALGORITHM", HKS_TAG_ALGORITHM);
61     AddInt32Property(env, tag, "HUKS_TAG_PURPOSE", HKS_TAG_PURPOSE);
62     AddInt32Property(env, tag, "HUKS_TAG_KEY_SIZE", HKS_TAG_KEY_SIZE);
63     AddInt32Property(env, tag, "HUKS_TAG_DIGEST", HKS_TAG_DIGEST);
64     AddInt32Property(env, tag, "HUKS_TAG_PADDING", HKS_TAG_PADDING);
65     AddInt32Property(env, tag, "HUKS_TAG_BLOCK_MODE", HKS_TAG_BLOCK_MODE);
66     AddInt32Property(env, tag, "HUKS_TAG_KEY_TYPE", HKS_TAG_KEY_TYPE);
67     AddInt32Property(env, tag, "HUKS_TAG_ASSOCIATED_DATA", HKS_TAG_ASSOCIATED_DATA);
68     AddInt32Property(env, tag, "HUKS_TAG_NONCE", HKS_TAG_NONCE);
69     AddInt32Property(env, tag, "HUKS_TAG_IV", HKS_TAG_IV);
70 
71     /* Key derivation TAG */
72     AddInt32Property(env, tag, "HUKS_TAG_INFO", HKS_TAG_INFO);
73     AddInt32Property(env, tag, "HUKS_TAG_SALT", HKS_TAG_SALT);
74     AddInt32Property(env, tag, "HUKS_TAG_PWD", HKS_TAG_PWD);
75     AddInt32Property(env, tag, "HUKS_TAG_ITERATION", HKS_TAG_ITERATION);
76 
77     AddInt32Property(env, tag, "HUKS_TAG_KEY_GENERATE_TYPE", HKS_TAG_KEY_GENERATE_TYPE);
78     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_MAIN_KEY", HKS_TAG_DERIVE_MAIN_KEY);
79     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_FACTOR", HKS_TAG_DERIVE_FACTOR);
80     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_ALG", HKS_TAG_DERIVE_ALG);
81     AddInt32Property(env, tag, "HUKS_TAG_AGREE_ALG", HKS_TAG_AGREE_ALG);
82     AddInt32Property(env, tag, "HUKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS", HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS);
83     AddInt32Property(env, tag, "HUKS_TAG_AGREE_PRIVATE_KEY_ALIAS", HKS_TAG_AGREE_PRIVATE_KEY_ALIAS);
84     AddInt32Property(env, tag, "HUKS_TAG_AGREE_PUBLIC_KEY", HKS_TAG_AGREE_PUBLIC_KEY);
85     AddInt32Property(env, tag, "HUKS_TAG_KEY_ALIAS", HKS_TAG_KEY_ALIAS);
86     AddInt32Property(env, tag, "HUKS_TAG_DERIVE_KEY_SIZE", HKS_TAG_DERIVE_KEY_SIZE);
87 
88     /*
89      * Key authentication related TAG: 201 - 300
90      *
91      * Start of validity
92      */
93     AddInt32Property(env, tag, "HUKS_TAG_ACTIVE_DATETIME", HKS_TAG_ACTIVE_DATETIME);
94 
95     /* Date when new "messages" should not be created. */
96     AddInt32Property(env, tag, "HUKS_TAG_ORIGINATION_EXPIRE_DATETIME", HKS_TAG_ORIGINATION_EXPIRE_DATETIME);
97 
98     /* Date when existing "messages" should not be used. */
99     AddInt32Property(env, tag, "HUKS_TAG_USAGE_EXPIRE_DATETIME", HKS_TAG_USAGE_EXPIRE_DATETIME);
100 
101     /* Key creation time */
102     AddInt32Property(env, tag, "HUKS_TAG_CREATION_DATETIME", HKS_TAG_CREATION_DATETIME);
103 
104     /* Other authentication related TAG: 301 - 500 */
105     AddInt32Property(env, tag, "HUKS_TAG_ALL_USERS", HKS_TAG_ALL_USERS);
106     AddInt32Property(env, tag, "HUKS_TAG_USER_ID", HKS_TAG_USER_ID);
107     AddInt32Property(env, tag, "HUKS_TAG_NO_AUTH_REQUIRED", HKS_TAG_NO_AUTH_REQUIRED);
108     AddInt32Property(env, tag, "HUKS_TAG_USER_AUTH_TYPE", HKS_TAG_USER_AUTH_TYPE);
109     AddInt32Property(env, tag, "HUKS_TAG_AUTH_TIMEOUT", HKS_TAG_AUTH_TIMEOUT);
110     AddInt32Property(env, tag, "HUKS_TAG_AUTH_TOKEN", HKS_TAG_AUTH_TOKEN);
111 
112     /* Attestation related TAG: 501 - 600 */
113     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_CHALLENGE", HKS_TAG_ATTESTATION_CHALLENGE);
114     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_APPLICATION_ID", HKS_TAG_ATTESTATION_APPLICATION_ID);
115     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_BRAND", HKS_TAG_ATTESTATION_ID_BRAND);
116     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_DEVICE", HKS_TAG_ATTESTATION_ID_DEVICE);
117     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_PRODUCT", HKS_TAG_ATTESTATION_ID_PRODUCT);
118     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_SERIAL", HKS_TAG_ATTESTATION_ID_SERIAL);
119     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_IMEI", HKS_TAG_ATTESTATION_ID_IMEI);
120     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_MEID", HKS_TAG_ATTESTATION_ID_MEID);
121     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_MANUFACTURER", HKS_TAG_ATTESTATION_ID_MANUFACTURER);
122     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_MODEL", HKS_TAG_ATTESTATION_ID_MODEL);
123     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_ALIAS", HKS_TAG_ATTESTATION_ID_ALIAS);
124     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_SOCID", HKS_TAG_ATTESTATION_ID_SOCID);
125     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_UDID", HKS_TAG_ATTESTATION_ID_UDID);
126     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO", HKS_TAG_ATTESTATION_ID_SEC_LEVEL_INFO);
127     AddInt32Property(env, tag, "HUKS_TAG_ATTESTATION_ID_VERSION_INFO", HKS_TAG_ATTESTATION_ID_VERSION_INFO);
128 }
129 
AddHuksTagPart2(napi_env env,napi_value tag)130 static void AddHuksTagPart2(napi_env env, napi_value tag)
131 {
132     /*
133      * Other reserved TAG: 601 - 1000
134      *
135      * Extention TAG: 1001 - 9999
136      */
137     AddInt32Property(env, tag, "HUKS_TAG_IS_KEY_ALIAS", HKS_TAG_IS_KEY_ALIAS);
138     AddInt32Property(env, tag, "HUKS_TAG_KEY_STORAGE_FLAG", HKS_TAG_KEY_STORAGE_FLAG);
139     AddInt32Property(env, tag, "HUKS_TAG_IS_ALLOWED_WRAP", HKS_TAG_IS_ALLOWED_WRAP);
140     AddInt32Property(env, tag, "HUKS_TAG_KEY_WRAP_TYPE", HKS_TAG_KEY_WRAP_TYPE);
141     AddInt32Property(env, tag, "HUKS_TAG_KEY_AUTH_ID", HKS_TAG_KEY_AUTH_ID);
142     AddInt32Property(env, tag, "HUKS_TAG_KEY_ROLE", HKS_TAG_KEY_ROLE);
143     AddInt32Property(env, tag, "HUKS_TAG_KEY_FLAG", HKS_TAG_KEY_FLAG);
144     AddInt32Property(env, tag, "HUKS_TAG_IS_ASYNCHRONIZED", HKS_TAG_IS_ASYNCHRONIZED);
145     AddInt32Property(env, tag, "HUKS_TAG_SECURE_KEY_ALIAS", HKS_TAG_SECURE_KEY_ALIAS);
146     AddInt32Property(env, tag, "HUKS_TAG_SECURE_KEY_UUID", HKS_TAG_SECURE_KEY_UUID);
147     AddInt32Property(env, tag, "HUKS_TAG_KEY_DOMAIN", HKS_TAG_KEY_DOMAIN);
148 
149     /* Inner-use TAG: 10001 - 10999 */
150     AddInt32Property(env, tag, "HUKS_TAG_PROCESS_NAME", HKS_TAG_PROCESS_NAME);
151     AddInt32Property(env, tag, "HUKS_TAG_PACKAGE_NAME", HKS_TAG_PACKAGE_NAME);
152     AddInt32Property(env, tag, "HUKS_TAG_ACCESS_TIME", HKS_TAG_ACCESS_TIME);
153     AddInt32Property(env, tag, "HUKS_TAG_USES_TIME", HKS_TAG_USES_TIME);
154     AddInt32Property(env, tag, "HUKS_TAG_CRYPTO_CTX", HKS_TAG_CRYPTO_CTX);
155     AddInt32Property(env, tag, "HUKS_TAG_KEY", HKS_TAG_KEY);
156     AddInt32Property(env, tag, "HUKS_TAG_KEY_VERSION", HKS_TAG_KEY_VERSION);
157     AddInt32Property(env, tag, "HUKS_TAG_PAYLOAD_LEN", HKS_TAG_PAYLOAD_LEN);
158     AddInt32Property(env, tag, "HUKS_TAG_AE_TAG", HKS_TAG_AE_TAG);
159     AddInt32Property(env, tag, "HUKS_TAG_IS_KEY_HANDLE", HKS_TAG_IS_KEY_HANDLE);
160 
161     /* Os version related TAG */
162     AddInt32Property(env, tag, "HUKS_TAG_OS_VERSION", HKS_TAG_OS_VERSION);
163     AddInt32Property(env, tag, "HUKS_TAG_OS_PATCHLEVEL", HKS_TAG_OS_PATCHLEVEL);
164 
165     /*
166      * Reversed TAGs for SOTER: 11000 - 12000
167      *
168      * Other TAGs: 20001 - N
169      * TAGs used for paramSetOut
170      */
171     AddInt32Property(env, tag, "HUKS_TAG_SYMMETRIC_KEY_DATA", HKS_TAG_SYMMETRIC_KEY_DATA);
172     AddInt32Property(env, tag, "HUKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA", HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA);
173     AddInt32Property(env, tag, "HUKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA", HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA);
174 }
175 
CreateHuksTag(napi_env env)176 static napi_value CreateHuksTag(napi_env env)
177 {
178     napi_value tag = nullptr;
179     NAPI_CALL(env, napi_create_object(env, &tag));
180 
181     AddHuksTagPart1(env, tag);
182     AddHuksTagPart2(env, tag);
183 
184     return tag;
185 }
186 
AddHksTagPart1(napi_env env,napi_value tag)187 static void AddHksTagPart1(napi_env env, napi_value tag)
188 {
189     /* Invalid TAG */
190     AddInt32Property(env, tag, "HKS_TAG_INVALID", HKS_TAG_INVALID);
191 
192     /* Base algrithom TAG: 1 - 200 */
193     AddInt32Property(env, tag, "HKS_TAG_ALGORITHM", HKS_TAG_ALGORITHM);
194     AddInt32Property(env, tag, "HKS_TAG_PURPOSE", HKS_TAG_PURPOSE);
195     AddInt32Property(env, tag, "HKS_TAG_KEY_SIZE", HKS_TAG_KEY_SIZE);
196     AddInt32Property(env, tag, "HKS_TAG_DIGEST", HKS_TAG_DIGEST);
197     AddInt32Property(env, tag, "HKS_TAG_PADDING", HKS_TAG_PADDING);
198     AddInt32Property(env, tag, "HKS_TAG_BLOCK_MODE", HKS_TAG_BLOCK_MODE);
199     AddInt32Property(env, tag, "HKS_TAG_KEY_TYPE", HKS_TAG_KEY_TYPE);
200     AddInt32Property(env, tag, "HKS_TAG_ASSOCIATED_DATA", HKS_TAG_ASSOCIATED_DATA);
201     AddInt32Property(env, tag, "HKS_TAG_NONCE", HKS_TAG_NONCE);
202     AddInt32Property(env, tag, "HKS_TAG_IV", HKS_TAG_IV);
203 
204     /* Key derivation TAG */
205     AddInt32Property(env, tag, "HKS_TAG_INFO", HKS_TAG_INFO);
206     AddInt32Property(env, tag, "HKS_TAG_SALT", HKS_TAG_SALT);
207     AddInt32Property(env, tag, "HKS_TAG_PWD", HKS_TAG_PWD);
208     AddInt32Property(env, tag, "HKS_TAG_ITERATION", HKS_TAG_ITERATION);
209 
210     AddInt32Property(env, tag, "HKS_TAG_KEY_GENERATE_TYPE", HKS_TAG_KEY_GENERATE_TYPE);
211     AddInt32Property(env, tag, "HKS_TAG_DERIVE_MAIN_KEY", HKS_TAG_DERIVE_MAIN_KEY);
212     AddInt32Property(env, tag, "HKS_TAG_DERIVE_FACTOR", HKS_TAG_DERIVE_FACTOR);
213     AddInt32Property(env, tag, "HKS_TAG_DERIVE_ALG", HKS_TAG_DERIVE_ALG);
214     AddInt32Property(env, tag, "HKS_TAG_AGREE_ALG", HKS_TAG_AGREE_ALG);
215     AddInt32Property(env, tag, "HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS", HKS_TAG_AGREE_PUBLIC_KEY_IS_KEY_ALIAS);
216     AddInt32Property(env, tag, "HKS_TAG_AGREE_PRIVATE_KEY_ALIAS", HKS_TAG_AGREE_PRIVATE_KEY_ALIAS);
217     AddInt32Property(env, tag, "HKS_TAG_AGREE_PUBLIC_KEY", HKS_TAG_AGREE_PUBLIC_KEY);
218     AddInt32Property(env, tag, "HKS_TAG_KEY_ALIAS", HKS_TAG_KEY_ALIAS);
219     AddInt32Property(env, tag, "HKS_TAG_DERIVE_KEY_SIZE", HKS_TAG_DERIVE_KEY_SIZE);
220 
221     /*
222      * Key authentication related TAG: 201 - 300
223      *
224      * Start of validity
225      */
226     AddInt32Property(env, tag, "HKS_TAG_ACTIVE_DATETIME", HKS_TAG_ACTIVE_DATETIME);
227 
228     /* Date when new "messages" should not be created. */
229     AddInt32Property(env, tag, "HKS_TAG_ORIGINATION_EXPIRE_DATETIME", HKS_TAG_ORIGINATION_EXPIRE_DATETIME);
230 
231     /* Date when existing "messages" should not be used. */
232     AddInt32Property(env, tag, "HKS_TAG_USAGE_EXPIRE_DATETIME", HKS_TAG_USAGE_EXPIRE_DATETIME);
233 
234     /* Key creation time */
235     AddInt32Property(env, tag, "HKS_TAG_CREATION_DATETIME", HKS_TAG_CREATION_DATETIME);
236 
237     /* Other authentication related TAG: 301 - 500 */
238     AddInt32Property(env, tag, "HKS_TAG_ALL_USERS", HKS_TAG_ALL_USERS);
239     AddInt32Property(env, tag, "HKS_TAG_USER_ID", HKS_TAG_USER_ID);
240     AddInt32Property(env, tag, "HKS_TAG_NO_AUTH_REQUIRED", HKS_TAG_NO_AUTH_REQUIRED);
241     AddInt32Property(env, tag, "HKS_TAG_USER_AUTH_TYPE", HKS_TAG_USER_AUTH_TYPE);
242     AddInt32Property(env, tag, "HKS_TAG_AUTH_TIMEOUT", HKS_TAG_AUTH_TIMEOUT);
243     AddInt32Property(env, tag, "HKS_TAG_AUTH_TOKEN", HKS_TAG_AUTH_TOKEN);
244 
245     /* Attestation related TAG: 501 - 600 */
246     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_CHALLENGE", HKS_TAG_ATTESTATION_CHALLENGE);
247     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_APPLICATION_ID", HKS_TAG_ATTESTATION_APPLICATION_ID);
248     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_BRAND", HKS_TAG_ATTESTATION_ID_BRAND);
249     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_DEVICE", HKS_TAG_ATTESTATION_ID_DEVICE);
250     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_PRODUCT", HKS_TAG_ATTESTATION_ID_PRODUCT);
251     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_SERIAL", HKS_TAG_ATTESTATION_ID_SERIAL);
252     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_IMEI", HKS_TAG_ATTESTATION_ID_IMEI);
253     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_MEID", HKS_TAG_ATTESTATION_ID_MEID);
254     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_MANUFACTURER", HKS_TAG_ATTESTATION_ID_MANUFACTURER);
255     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_MODEL", HKS_TAG_ATTESTATION_ID_MODEL);
256     AddInt32Property(env, tag, "HKS_TAG_ATTESTATION_ID_ALIAS", HKS_TAG_ATTESTATION_ID_ALIAS);
257 }
258 
AddHksTagPart2(napi_env env,napi_value tag)259 static void AddHksTagPart2(napi_env env, napi_value tag)
260 {
261     /*
262      * Other reserved TAG: 601 - 1000
263      *
264      * Extention TAG: 1001 - 9999
265      */
266     AddInt32Property(env, tag, "HKS_TAG_IS_KEY_ALIAS", HKS_TAG_IS_KEY_ALIAS);
267     AddInt32Property(env, tag, "HKS_TAG_KEY_STORAGE_FLAG", HKS_TAG_KEY_STORAGE_FLAG);
268     AddInt32Property(env, tag, "HKS_TAG_IS_ALLOWED_WRAP", HKS_TAG_IS_ALLOWED_WRAP);
269     AddInt32Property(env, tag, "HKS_TAG_KEY_WRAP_TYPE", HKS_TAG_KEY_WRAP_TYPE);
270     AddInt32Property(env, tag, "HKS_TAG_KEY_AUTH_ID", HKS_TAG_KEY_AUTH_ID);
271     AddInt32Property(env, tag, "HKS_TAG_KEY_ROLE", HKS_TAG_KEY_ROLE);
272     AddInt32Property(env, tag, "HKS_TAG_KEY_FLAG", HKS_TAG_KEY_FLAG);
273     AddInt32Property(env, tag, "HKS_TAG_IS_ASYNCHRONIZED", HKS_TAG_IS_ASYNCHRONIZED);
274     AddInt32Property(env, tag, "HKS_TAG_SECURE_KEY_ALIAS", HKS_TAG_SECURE_KEY_ALIAS);
275     AddInt32Property(env, tag, "HKS_TAG_SECURE_KEY_UUID", HKS_TAG_SECURE_KEY_UUID);
276     AddInt32Property(env, tag, "HKS_TAG_KEY_DOMAIN", HKS_TAG_KEY_DOMAIN);
277 
278     /* Inner-use TAG: 10001 - 10999 */
279     AddInt32Property(env, tag, "HKS_TAG_PROCESS_NAME", HKS_TAG_PROCESS_NAME);
280     AddInt32Property(env, tag, "HKS_TAG_PACKAGE_NAME", HKS_TAG_PACKAGE_NAME);
281     AddInt32Property(env, tag, "HKS_TAG_ACCESS_TIME", HKS_TAG_ACCESS_TIME);
282     AddInt32Property(env, tag, "HKS_TAG_USES_TIME", HKS_TAG_USES_TIME);
283     AddInt32Property(env, tag, "HKS_TAG_CRYPTO_CTX", HKS_TAG_CRYPTO_CTX);
284     AddInt32Property(env, tag, "HKS_TAG_KEY", HKS_TAG_KEY);
285     AddInt32Property(env, tag, "HKS_TAG_KEY_VERSION", HKS_TAG_KEY_VERSION);
286     AddInt32Property(env, tag, "HKS_TAG_PAYLOAD_LEN", HKS_TAG_PAYLOAD_LEN);
287     AddInt32Property(env, tag, "HKS_TAG_AE_TAG", HKS_TAG_AE_TAG);
288     AddInt32Property(env, tag, "HKS_TAG_IS_KEY_HANDLE", HKS_TAG_IS_KEY_HANDLE);
289 
290     /* Os version related TAG */
291     AddInt32Property(env, tag, "HKS_TAG_OS_VERSION", HKS_TAG_OS_VERSION);
292     AddInt32Property(env, tag, "HKS_TAG_OS_PATCHLEVEL", HKS_TAG_OS_PATCHLEVEL);
293 
294     /*
295      * Reversed TAGs for SOTER: 11000 - 12000
296      *
297      * Other TAGs: 20001 - N
298      * TAGs used for paramSetOut
299      */
300     AddInt32Property(env, tag, "HKS_TAG_SYMMETRIC_KEY_DATA", HKS_TAG_SYMMETRIC_KEY_DATA);
301     AddInt32Property(env, tag, "HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA", HKS_TAG_ASYMMETRIC_PUBLIC_KEY_DATA);
302     AddInt32Property(env, tag, "HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA", HKS_TAG_ASYMMETRIC_PRIVATE_KEY_DATA);
303 }
304 
CreateHksTag(napi_env env)305 static napi_value CreateHksTag(napi_env env)
306 {
307     napi_value tag = nullptr;
308     NAPI_CALL(env, napi_create_object(env, &tag));
309 
310     AddHksTagPart1(env, tag);
311     AddHksTagPart2(env, tag);
312 
313     return tag;
314 }
315 
CreateHuksKeySize(napi_env env)316 static napi_value CreateHuksKeySize(napi_env env)
317 {
318     napi_value keySize = nullptr;
319     NAPI_CALL(env, napi_create_object(env, &keySize));
320 
321     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_512", HKS_RSA_KEY_SIZE_512);
322     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_768", HKS_RSA_KEY_SIZE_768);
323     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_1024", HKS_RSA_KEY_SIZE_1024);
324     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_2048", HKS_RSA_KEY_SIZE_2048);
325     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_3072", HKS_RSA_KEY_SIZE_3072);
326     AddInt32Property(env, keySize, "HUKS_RSA_KEY_SIZE_4096", HKS_RSA_KEY_SIZE_4096);
327 
328     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_224", HKS_ECC_KEY_SIZE_224);
329     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_256", HKS_ECC_KEY_SIZE_256);
330     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_384", HKS_ECC_KEY_SIZE_384);
331     AddInt32Property(env, keySize, "HUKS_ECC_KEY_SIZE_521", HKS_ECC_KEY_SIZE_521);
332 
333     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_128", HKS_AES_KEY_SIZE_128);
334     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_192", HKS_AES_KEY_SIZE_192);
335     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_256", HKS_AES_KEY_SIZE_256);
336     AddInt32Property(env, keySize, "HUKS_AES_KEY_SIZE_512", HKS_AES_KEY_SIZE_512);
337 
338     AddInt32Property(env, keySize, "HUKS_CURVE25519_KEY_SIZE_256", HKS_CURVE25519_KEY_SIZE_256);
339 
340     AddInt32Property(env, keySize, "HUKS_DH_KEY_SIZE_2048", HKS_DH_KEY_SIZE_2048);
341     AddInt32Property(env, keySize, "HUKS_DH_KEY_SIZE_3072", HKS_DH_KEY_SIZE_3072);
342     AddInt32Property(env, keySize, "HUKS_DH_KEY_SIZE_4096", HKS_DH_KEY_SIZE_4096);
343 
344     return keySize;
345 }
346 
CreateHksKeySize(napi_env env)347 static napi_value CreateHksKeySize(napi_env env)
348 {
349     napi_value keySize = nullptr;
350     NAPI_CALL(env, napi_create_object(env, &keySize));
351 
352     AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_512", HKS_RSA_KEY_SIZE_512);
353     AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_768", HKS_RSA_KEY_SIZE_768);
354     AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_1024", HKS_RSA_KEY_SIZE_1024);
355     AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_2048", HKS_RSA_KEY_SIZE_2048);
356     AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_3072", HKS_RSA_KEY_SIZE_3072);
357     AddInt32Property(env, keySize, "HKS_RSA_KEY_SIZE_4096", HKS_RSA_KEY_SIZE_4096);
358 
359     AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_224", HKS_ECC_KEY_SIZE_224);
360     AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_256", HKS_ECC_KEY_SIZE_256);
361     AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_384", HKS_ECC_KEY_SIZE_384);
362     AddInt32Property(env, keySize, "HKS_ECC_KEY_SIZE_521", HKS_ECC_KEY_SIZE_521);
363 
364     AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_128", HKS_AES_KEY_SIZE_128);
365     AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_192", HKS_AES_KEY_SIZE_192);
366     AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_256", HKS_AES_KEY_SIZE_256);
367     AddInt32Property(env, keySize, "HKS_AES_KEY_SIZE_512", HKS_AES_KEY_SIZE_512);
368 
369     AddInt32Property(env, keySize, "HKS_CURVE25519_KEY_SIZE_256", HKS_CURVE25519_KEY_SIZE_256);
370 
371     AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_2048", HKS_DH_KEY_SIZE_2048);
372     AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_3072", HKS_DH_KEY_SIZE_3072);
373     AddInt32Property(env, keySize, "HKS_DH_KEY_SIZE_4096", HKS_DH_KEY_SIZE_4096);
374 
375     return keySize;
376 }
377 
CreateHuksKeyAlg(napi_env env)378 static napi_value CreateHuksKeyAlg(napi_env env)
379 {
380     napi_value keyAlg = nullptr;
381     NAPI_CALL(env, napi_create_object(env, &keyAlg));
382 
383     AddInt32Property(env, keyAlg, "HUKS_ALG_RSA", HKS_ALG_RSA);
384     AddInt32Property(env, keyAlg, "HUKS_ALG_ECC", HKS_ALG_ECC);
385     AddInt32Property(env, keyAlg, "HUKS_ALG_DSA", HKS_ALG_DSA);
386 
387     AddInt32Property(env, keyAlg, "HUKS_ALG_AES", HKS_ALG_AES);
388     AddInt32Property(env, keyAlg, "HUKS_ALG_HMAC", HKS_ALG_HMAC);
389     AddInt32Property(env, keyAlg, "HUKS_ALG_HKDF", HKS_ALG_HKDF);
390     AddInt32Property(env, keyAlg, "HUKS_ALG_PBKDF2", HKS_ALG_PBKDF2);
391 
392     AddInt32Property(env, keyAlg, "HUKS_ALG_ECDH", HKS_ALG_ECDH);
393     AddInt32Property(env, keyAlg, "HUKS_ALG_X25519", HKS_ALG_X25519);
394     AddInt32Property(env, keyAlg, "HUKS_ALG_ED25519", HKS_ALG_ED25519);
395     AddInt32Property(env, keyAlg, "HUKS_ALG_DH", HKS_ALG_DH);
396 
397     return keyAlg;
398 }
399 
CreateHksKeyAlg(napi_env env)400 static napi_value CreateHksKeyAlg(napi_env env)
401 {
402     napi_value keyAlg = nullptr;
403     NAPI_CALL(env, napi_create_object(env, &keyAlg));
404 
405     AddInt32Property(env, keyAlg, "HKS_ALG_RSA", HKS_ALG_RSA);
406     AddInt32Property(env, keyAlg, "HKS_ALG_ECC", HKS_ALG_ECC);
407     AddInt32Property(env, keyAlg, "HKS_ALG_DSA", HKS_ALG_DSA);
408 
409     AddInt32Property(env, keyAlg, "HKS_ALG_AES", HKS_ALG_AES);
410     AddInt32Property(env, keyAlg, "HKS_ALG_HMAC", HKS_ALG_HMAC);
411     AddInt32Property(env, keyAlg, "HKS_ALG_HKDF", HKS_ALG_HKDF);
412     AddInt32Property(env, keyAlg, "HKS_ALG_PBKDF2", HKS_ALG_PBKDF2);
413 
414     AddInt32Property(env, keyAlg, "HKS_ALG_ECDH", HKS_ALG_ECDH);
415     AddInt32Property(env, keyAlg, "HKS_ALG_X25519", HKS_ALG_X25519);
416     AddInt32Property(env, keyAlg, "HKS_ALG_ED25519", HKS_ALG_ED25519);
417     AddInt32Property(env, keyAlg, "HKS_ALG_DH", HKS_ALG_DH);
418 
419     return keyAlg;
420 }
421 
CreateHuksKeyPurpose(napi_env env)422 static napi_value CreateHuksKeyPurpose(napi_env env)
423 {
424     napi_value keyPurpose = nullptr;
425     NAPI_CALL(env, napi_create_object(env, &keyPurpose));
426 
427     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_ENCRYPT", HKS_KEY_PURPOSE_ENCRYPT);
428     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_DECRYPT", HKS_KEY_PURPOSE_DECRYPT);
429     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_SIGN", HKS_KEY_PURPOSE_SIGN);
430     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_VERIFY", HKS_KEY_PURPOSE_VERIFY);
431     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_DERIVE", HKS_KEY_PURPOSE_DERIVE);
432     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_WRAP", HKS_KEY_PURPOSE_WRAP);
433     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_UNWRAP", HKS_KEY_PURPOSE_UNWRAP);
434     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_MAC", HKS_KEY_PURPOSE_MAC);
435     AddInt32Property(env, keyPurpose, "HUKS_KEY_PURPOSE_AGREE", HKS_KEY_PURPOSE_AGREE);
436 
437     return keyPurpose;
438 }
439 
CreateHksKeyPurpose(napi_env env)440 static napi_value CreateHksKeyPurpose(napi_env env)
441 {
442     napi_value keyPurpose = nullptr;
443     NAPI_CALL(env, napi_create_object(env, &keyPurpose));
444 
445     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_ENCRYPT", HKS_KEY_PURPOSE_ENCRYPT);
446     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_DECRYPT", HKS_KEY_PURPOSE_DECRYPT);
447     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_SIGN", HKS_KEY_PURPOSE_SIGN);
448     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_VERIFY", HKS_KEY_PURPOSE_VERIFY);
449     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_DERIVE", HKS_KEY_PURPOSE_DERIVE);
450     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_WRAP", HKS_KEY_PURPOSE_WRAP);
451     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_UNWRAP", HKS_KEY_PURPOSE_UNWRAP);
452     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_MAC", HKS_KEY_PURPOSE_MAC);
453     AddInt32Property(env, keyPurpose, "HKS_KEY_PURPOSE_AGREE", HKS_KEY_PURPOSE_AGREE);
454 
455     return keyPurpose;
456 }
457 
CreateHuksKeyPadding(napi_env env)458 static napi_value CreateHuksKeyPadding(napi_env env)
459 {
460     napi_value keyPadding = nullptr;
461     NAPI_CALL(env, napi_create_object(env, &keyPadding));
462 
463     AddInt32Property(env, keyPadding, "HUKS_PADDING_NONE", HKS_PADDING_NONE);
464     AddInt32Property(env, keyPadding, "HUKS_PADDING_OAEP", HKS_PADDING_OAEP);
465     AddInt32Property(env, keyPadding, "HUKS_PADDING_PSS", HKS_PADDING_PSS);
466     AddInt32Property(env, keyPadding, "HUKS_PADDING_PKCS1_V1_5", HKS_PADDING_PKCS1_V1_5);
467     AddInt32Property(env, keyPadding, "HUKS_PADDING_PKCS5", HKS_PADDING_PKCS5);
468     AddInt32Property(env, keyPadding, "HUKS_PADDING_PKCS7", HKS_PADDING_PKCS7);
469 
470     return keyPadding;
471 }
472 
CreateHksKeyPadding(napi_env env)473 static napi_value CreateHksKeyPadding(napi_env env)
474 {
475     napi_value keyPadding = nullptr;
476     NAPI_CALL(env, napi_create_object(env, &keyPadding));
477 
478     AddInt32Property(env, keyPadding, "HKS_PADDING_NONE", HKS_PADDING_NONE);
479     AddInt32Property(env, keyPadding, "HKS_PADDING_OAEP", HKS_PADDING_OAEP);
480     AddInt32Property(env, keyPadding, "HKS_PADDING_PSS", HKS_PADDING_PSS);
481     AddInt32Property(env, keyPadding, "HKS_PADDING_PKCS1_V1_5", HKS_PADDING_PKCS1_V1_5);
482     AddInt32Property(env, keyPadding, "HKS_PADDING_PKCS5", HKS_PADDING_PKCS5);
483     AddInt32Property(env, keyPadding, "HKS_PADDING_PKCS7", HKS_PADDING_PKCS7);
484 
485     return keyPadding;
486 }
487 
CreateHuksCipherMode(napi_env env)488 static napi_value CreateHuksCipherMode(napi_env env)
489 {
490     napi_value keyCipherMode = nullptr;
491     NAPI_CALL(env, napi_create_object(env, &keyCipherMode));
492 
493     AddInt32Property(env, keyCipherMode, "HUKS_MODE_ECB", HKS_MODE_ECB);
494     AddInt32Property(env, keyCipherMode, "HUKS_MODE_CBC", HKS_MODE_CBC);
495     AddInt32Property(env, keyCipherMode, "HUKS_MODE_CTR", HKS_MODE_CTR);
496     AddInt32Property(env, keyCipherMode, "HUKS_MODE_OFB", HKS_MODE_OFB);
497     AddInt32Property(env, keyCipherMode, "HUKS_MODE_CCM", HKS_MODE_CCM);
498     AddInt32Property(env, keyCipherMode, "HUKS_MODE_GCM", HKS_MODE_GCM);
499 
500     return keyCipherMode;
501 }
502 
CreateHksCipherMode(napi_env env)503 static napi_value CreateHksCipherMode(napi_env env)
504 {
505     napi_value keyCipherMode = nullptr;
506     NAPI_CALL(env, napi_create_object(env, &keyCipherMode));
507 
508     AddInt32Property(env, keyCipherMode, "HKS_MODE_ECB", HKS_MODE_ECB);
509     AddInt32Property(env, keyCipherMode, "HKS_MODE_CBC", HKS_MODE_CBC);
510     AddInt32Property(env, keyCipherMode, "HKS_MODE_CTR", HKS_MODE_CTR);
511     AddInt32Property(env, keyCipherMode, "HKS_MODE_OFB", HKS_MODE_OFB);
512     AddInt32Property(env, keyCipherMode, "HKS_MODE_CCM", HKS_MODE_CCM);
513     AddInt32Property(env, keyCipherMode, "HKS_MODE_GCM", HKS_MODE_GCM);
514 
515     return keyCipherMode;
516 }
517 
CreateHuksKeyStorageType(napi_env env)518 static napi_value CreateHuksKeyStorageType(napi_env env)
519 {
520     napi_value keyStorageType = nullptr;
521     NAPI_CALL(env, napi_create_object(env, &keyStorageType));
522 
523     AddInt32Property(env, keyStorageType, "HUKS_STORAGE_TEMP", HKS_STORAGE_TEMP);
524     AddInt32Property(env, keyStorageType, "HUKS_STORAGE_PERSISTENT", HKS_STORAGE_PERSISTENT);
525 
526     return keyStorageType;
527 }
528 
CreateHksKeyStorageType(napi_env env)529 static napi_value CreateHksKeyStorageType(napi_env env)
530 {
531     napi_value keyStorageType = nullptr;
532     NAPI_CALL(env, napi_create_object(env, &keyStorageType));
533 
534     AddInt32Property(env, keyStorageType, "HKS_STORAGE_TEMP", HKS_STORAGE_TEMP);
535     AddInt32Property(env, keyStorageType, "HKS_STORAGE_PERSISTENT", HKS_STORAGE_PERSISTENT);
536 
537     return keyStorageType;
538 }
539 
AddHuksErrorCodePart1(napi_env env,napi_value errorCode)540 static void AddHuksErrorCodePart1(napi_env env, napi_value errorCode)
541 {
542     AddInt32Property(env, errorCode, "HUKS_SUCCESS", HKS_SUCCESS);
543     AddInt32Property(env, errorCode, "HUKS_FAILURE", HKS_FAILURE);
544     AddInt32Property(env, errorCode, "HUKS_ERROR_BAD_STATE", HKS_ERROR_BAD_STATE);
545     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_ARGUMENT", HKS_ERROR_INVALID_ARGUMENT);
546     AddInt32Property(env, errorCode, "HUKS_ERROR_NOT_SUPPORTED", HKS_ERROR_NOT_SUPPORTED);
547     AddInt32Property(env, errorCode, "HUKS_ERROR_NO_PERMISSION", HKS_ERROR_NO_PERMISSION);
548     AddInt32Property(env, errorCode, "HUKS_ERROR_INSUFFICIENT_DATA", HKS_ERROR_INSUFFICIENT_DATA);
549     AddInt32Property(env, errorCode, "HUKS_ERROR_BUFFER_TOO_SMALL", HKS_ERROR_BUFFER_TOO_SMALL);
550     AddInt32Property(env, errorCode, "HUKS_ERROR_INSUFFICIENT_MEMORY", HKS_ERROR_INSUFFICIENT_MEMORY);
551     AddInt32Property(env, errorCode, "HUKS_ERROR_COMMUNICATION_FAILURE", HKS_ERROR_COMMUNICATION_FAILURE);
552     AddInt32Property(env, errorCode, "HUKS_ERROR_STORAGE_FAILURE", HKS_ERROR_STORAGE_FAILURE);
553     AddInt32Property(env, errorCode, "HUKS_ERROR_HARDWARE_FAILURE", HKS_ERROR_HARDWARE_FAILURE);
554     AddInt32Property(env, errorCode, "HUKS_ERROR_ALREADY_EXISTS", HKS_ERROR_ALREADY_EXISTS);
555     AddInt32Property(env, errorCode, "HUKS_ERROR_NOT_EXIST", HKS_ERROR_NOT_EXIST);
556     AddInt32Property(env, errorCode, "HUKS_ERROR_NULL_POINTER", HKS_ERROR_NULL_POINTER);
557     AddInt32Property(env, errorCode, "HUKS_ERROR_FILE_SIZE_FAIL", HKS_ERROR_FILE_SIZE_FAIL);
558     AddInt32Property(env, errorCode, "HUKS_ERROR_READ_FILE_FAIL", HKS_ERROR_READ_FILE_FAIL);
559     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PUBLIC_KEY", HKS_ERROR_INVALID_PUBLIC_KEY);
560     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PRIVATE_KEY", HKS_ERROR_INVALID_PRIVATE_KEY);
561     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_KEY_INFO", HKS_ERROR_INVALID_KEY_INFO);
562     AddInt32Property(env, errorCode, "HUKS_ERROR_HASH_NOT_EQUAL", HKS_ERROR_HASH_NOT_EQUAL);
563     AddInt32Property(env, errorCode, "HUKS_ERROR_MALLOC_FAIL", HKS_ERROR_MALLOC_FAIL);
564     AddInt32Property(env, errorCode, "HUKS_ERROR_WRITE_FILE_FAIL", HKS_ERROR_WRITE_FILE_FAIL);
565     AddInt32Property(env, errorCode, "HUKS_ERROR_REMOVE_FILE_FAIL", HKS_ERROR_REMOVE_FILE_FAIL);
566     AddInt32Property(env, errorCode, "HUKS_ERROR_OPEN_FILE_FAIL", HKS_ERROR_OPEN_FILE_FAIL);
567     AddInt32Property(env, errorCode, "HUKS_ERROR_CLOSE_FILE_FAIL", HKS_ERROR_CLOSE_FILE_FAIL);
568     AddInt32Property(env, errorCode, "HUKS_ERROR_MAKE_DIR_FAIL", HKS_ERROR_MAKE_DIR_FAIL);
569     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_KEY_FILE", HKS_ERROR_INVALID_KEY_FILE);
570     AddInt32Property(env, errorCode, "HUKS_ERROR_IPC_MSG_FAIL", HKS_ERROR_IPC_MSG_FAIL);
571     AddInt32Property(env, errorCode, "HUKS_ERROR_REQUEST_OVERFLOWS", HKS_ERROR_REQUEST_OVERFLOWS);
572     AddInt32Property(env, errorCode, "HUKS_ERROR_PARAM_NOT_EXIST", HKS_ERROR_PARAM_NOT_EXIST);
573     AddInt32Property(env, errorCode, "HUKS_ERROR_CRYPTO_ENGINE_ERROR", HKS_ERROR_CRYPTO_ENGINE_ERROR);
574     AddInt32Property(env, errorCode, "HUKS_ERROR_COMMUNICATION_TIMEOUT", HKS_ERROR_COMMUNICATION_TIMEOUT);
575     AddInt32Property(env, errorCode, "HUKS_ERROR_IPC_INIT_FAIL", HKS_ERROR_IPC_INIT_FAIL);
576     AddInt32Property(env, errorCode, "HUKS_ERROR_IPC_DLOPEN_FAIL", HKS_ERROR_IPC_DLOPEN_FAIL);
577     AddInt32Property(env, errorCode, "HUKS_ERROR_EFUSE_READ_FAIL", HKS_ERROR_EFUSE_READ_FAIL);
578     AddInt32Property(env, errorCode, "HUKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST", HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST);
579     AddInt32Property(
580         env, errorCode, "HUKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL", HKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL);
581     AddInt32Property(env, errorCode, "HUKS_ERROR_VERIFICATION_FAILED", HKS_ERROR_VERIFICATION_FAILED);
582 }
583 
AddHuksErrorCodePart2(napi_env env,napi_value errorCode)584 static void AddHuksErrorCodePart2(napi_env env, napi_value errorCode)
585 {
586     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_ALG_FAIL", HKS_ERROR_CHECK_GET_ALG_FAIL);
587     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_KEY_SIZE_FAIL", HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL);
588     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_PADDING_FAIL", HKS_ERROR_CHECK_GET_PADDING_FAIL);
589     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_PURPOSE_FAIL", HKS_ERROR_CHECK_GET_PURPOSE_FAIL);
590     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_DIGEST_FAIL", HKS_ERROR_CHECK_GET_DIGEST_FAIL);
591     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_MODE_FAIL", HKS_ERROR_CHECK_GET_MODE_FAIL);
592     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_NONCE_FAIL", HKS_ERROR_CHECK_GET_NONCE_FAIL);
593     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_AAD_FAIL", HKS_ERROR_CHECK_GET_AAD_FAIL);
594     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_IV_FAIL", HKS_ERROR_CHECK_GET_IV_FAIL);
595     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_AE_TAG_FAIL", HKS_ERROR_CHECK_GET_AE_TAG_FAIL);
596     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_SALT_FAIL", HKS_ERROR_CHECK_GET_SALT_FAIL);
597     AddInt32Property(env, errorCode, "HUKS_ERROR_CHECK_GET_ITERATION_FAIL", HKS_ERROR_CHECK_GET_ITERATION_FAIL);
598     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_ALGORITHM", HKS_ERROR_INVALID_ALGORITHM);
599     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_KEY_SIZE", HKS_ERROR_INVALID_KEY_SIZE);
600     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PADDING", HKS_ERROR_INVALID_PADDING);
601     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_PURPOSE", HKS_ERROR_INVALID_PURPOSE);
602     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_MODE", HKS_ERROR_INVALID_MODE);
603     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_DIGEST", HKS_ERROR_INVALID_DIGEST);
604     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_SIGNATURE_SIZE", HKS_ERROR_INVALID_SIGNATURE_SIZE);
605     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_IV", HKS_ERROR_INVALID_IV);
606     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_AAD", HKS_ERROR_INVALID_AAD);
607     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_NONCE", HKS_ERROR_INVALID_NONCE);
608     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_AE_TAG", HKS_ERROR_INVALID_AE_TAG);
609     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_SALT", HKS_ERROR_INVALID_SALT);
610     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_ITERATION", HKS_ERROR_INVALID_ITERATION);
611     AddInt32Property(env, errorCode, "HUKS_ERROR_INVALID_OPERATION", HKS_ERROR_INVALID_OPERATION);
612 
613     AddInt32Property(env, errorCode, "HUKS_ERROR_INTERNAL_ERROR", HKS_ERROR_INTERNAL_ERROR);
614     AddInt32Property(env, errorCode, "HUKS_ERROR_UNKNOWN_ERROR", HKS_ERROR_UNKNOWN_ERROR);
615 }
616 
CreateHuksErrorCode(napi_env env)617 static napi_value CreateHuksErrorCode(napi_env env)
618 {
619     napi_value errorCode = nullptr;
620     NAPI_CALL(env, napi_create_object(env, &errorCode));
621 
622     AddHuksErrorCodePart1(env, errorCode);
623     AddHuksErrorCodePart2(env, errorCode);
624 
625     return errorCode;
626 }
627 
AddHksErrorCodePart1(napi_env env,napi_value errorCode)628 static void AddHksErrorCodePart1(napi_env env, napi_value errorCode)
629 {
630     AddInt32Property(env, errorCode, "HKS_SUCCESS", HKS_SUCCESS);
631     AddInt32Property(env, errorCode, "HKS_FAILURE", HKS_FAILURE);
632     AddInt32Property(env, errorCode, "HKS_ERROR_BAD_STATE", HKS_ERROR_BAD_STATE);
633     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_ARGUMENT", HKS_ERROR_INVALID_ARGUMENT);
634     AddInt32Property(env, errorCode, "HKS_ERROR_NOT_SUPPORTED", HKS_ERROR_NOT_SUPPORTED);
635     AddInt32Property(env, errorCode, "HKS_ERROR_NO_PERMISSION", HKS_ERROR_NO_PERMISSION);
636     AddInt32Property(env, errorCode, "HKS_ERROR_INSUFFICIENT_DATA", HKS_ERROR_INSUFFICIENT_DATA);
637     AddInt32Property(env, errorCode, "HKS_ERROR_BUFFER_TOO_SMALL", HKS_ERROR_BUFFER_TOO_SMALL);
638     AddInt32Property(env, errorCode, "HKS_ERROR_INSUFFICIENT_MEMORY", HKS_ERROR_INSUFFICIENT_MEMORY);
639     AddInt32Property(env, errorCode, "HKS_ERROR_COMMUNICATION_FAILURE", HKS_ERROR_COMMUNICATION_FAILURE);
640     AddInt32Property(env, errorCode, "HKS_ERROR_STORAGE_FAILURE", HKS_ERROR_STORAGE_FAILURE);
641     AddInt32Property(env, errorCode, "HKS_ERROR_HARDWARE_FAILURE", HKS_ERROR_HARDWARE_FAILURE);
642     AddInt32Property(env, errorCode, "HKS_ERROR_ALREADY_EXISTS", HKS_ERROR_ALREADY_EXISTS);
643     AddInt32Property(env, errorCode, "HKS_ERROR_NOT_EXIST", HKS_ERROR_NOT_EXIST);
644     AddInt32Property(env, errorCode, "HKS_ERROR_NULL_POINTER", HKS_ERROR_NULL_POINTER);
645     AddInt32Property(env, errorCode, "HKS_ERROR_FILE_SIZE_FAIL", HKS_ERROR_FILE_SIZE_FAIL);
646     AddInt32Property(env, errorCode, "HKS_ERROR_READ_FILE_FAIL", HKS_ERROR_READ_FILE_FAIL);
647     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PUBLIC_KEY", HKS_ERROR_INVALID_PUBLIC_KEY);
648     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PRIVATE_KEY", HKS_ERROR_INVALID_PRIVATE_KEY);
649     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_KEY_INFO", HKS_ERROR_INVALID_KEY_INFO);
650     AddInt32Property(env, errorCode, "HKS_ERROR_HASH_NOT_EQUAL", HKS_ERROR_HASH_NOT_EQUAL);
651     AddInt32Property(env, errorCode, "HKS_ERROR_MALLOC_FAIL", HKS_ERROR_MALLOC_FAIL);
652     AddInt32Property(env, errorCode, "HKS_ERROR_WRITE_FILE_FAIL", HKS_ERROR_WRITE_FILE_FAIL);
653     AddInt32Property(env, errorCode, "HKS_ERROR_REMOVE_FILE_FAIL", HKS_ERROR_REMOVE_FILE_FAIL);
654     AddInt32Property(env, errorCode, "HKS_ERROR_OPEN_FILE_FAIL", HKS_ERROR_OPEN_FILE_FAIL);
655     AddInt32Property(env, errorCode, "HKS_ERROR_CLOSE_FILE_FAIL", HKS_ERROR_CLOSE_FILE_FAIL);
656     AddInt32Property(env, errorCode, "HKS_ERROR_MAKE_DIR_FAIL", HKS_ERROR_MAKE_DIR_FAIL);
657     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_KEY_FILE", HKS_ERROR_INVALID_KEY_FILE);
658     AddInt32Property(env, errorCode, "HKS_ERROR_IPC_MSG_FAIL", HKS_ERROR_IPC_MSG_FAIL);
659     AddInt32Property(env, errorCode, "HKS_ERROR_REQUEST_OVERFLOWS", HKS_ERROR_REQUEST_OVERFLOWS);
660     AddInt32Property(env, errorCode, "HKS_ERROR_PARAM_NOT_EXIST", HKS_ERROR_PARAM_NOT_EXIST);
661     AddInt32Property(env, errorCode, "HKS_ERROR_CRYPTO_ENGINE_ERROR", HKS_ERROR_CRYPTO_ENGINE_ERROR);
662     AddInt32Property(env, errorCode, "HKS_ERROR_COMMUNICATION_TIMEOUT", HKS_ERROR_COMMUNICATION_TIMEOUT);
663     AddInt32Property(env, errorCode, "HKS_ERROR_IPC_INIT_FAIL", HKS_ERROR_IPC_INIT_FAIL);
664     AddInt32Property(env, errorCode, "HKS_ERROR_IPC_DLOPEN_FAIL", HKS_ERROR_IPC_DLOPEN_FAIL);
665     AddInt32Property(env, errorCode, "HKS_ERROR_EFUSE_READ_FAIL", HKS_ERROR_EFUSE_READ_FAIL);
666     AddInt32Property(env, errorCode, "HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST", HKS_ERROR_NEW_ROOT_KEY_MATERIAL_EXIST);
667     AddInt32Property(
668         env, errorCode, "HKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL", HKS_ERROR_UPDATE_ROOT_KEY_MATERIAL_FAIL);
669 }
670 
AddHksErrorCodePart2(napi_env env,napi_value errorCode)671 static void AddHksErrorCodePart2(napi_env env, napi_value errorCode)
672 {
673     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_ALG_FAIL", HKS_ERROR_CHECK_GET_ALG_FAIL);
674     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL", HKS_ERROR_CHECK_GET_KEY_SIZE_FAIL);
675     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_PADDING_FAIL", HKS_ERROR_CHECK_GET_PADDING_FAIL);
676     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_PURPOSE_FAIL", HKS_ERROR_CHECK_GET_PURPOSE_FAIL);
677     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_DIGEST_FAIL", HKS_ERROR_CHECK_GET_DIGEST_FAIL);
678     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_MODE_FAIL", HKS_ERROR_CHECK_GET_MODE_FAIL);
679     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_NONCE_FAIL", HKS_ERROR_CHECK_GET_NONCE_FAIL);
680     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_AAD_FAIL", HKS_ERROR_CHECK_GET_AAD_FAIL);
681     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_IV_FAIL", HKS_ERROR_CHECK_GET_IV_FAIL);
682     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_AE_TAG_FAIL", HKS_ERROR_CHECK_GET_AE_TAG_FAIL);
683     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_SALT_FAIL", HKS_ERROR_CHECK_GET_SALT_FAIL);
684     AddInt32Property(env, errorCode, "HKS_ERROR_CHECK_GET_ITERATION_FAIL", HKS_ERROR_CHECK_GET_ITERATION_FAIL);
685     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_ALGORITHM", HKS_ERROR_INVALID_ALGORITHM);
686     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_KEY_SIZE", HKS_ERROR_INVALID_KEY_SIZE);
687     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PADDING", HKS_ERROR_INVALID_PADDING);
688     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_PURPOSE", HKS_ERROR_INVALID_PURPOSE);
689     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_MODE", HKS_ERROR_INVALID_MODE);
690     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_DIGEST", HKS_ERROR_INVALID_DIGEST);
691     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_SIGNATURE_SIZE", HKS_ERROR_INVALID_SIGNATURE_SIZE);
692     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_IV", HKS_ERROR_INVALID_IV);
693     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_AAD", HKS_ERROR_INVALID_AAD);
694     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_NONCE", HKS_ERROR_INVALID_NONCE);
695     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_AE_TAG", HKS_ERROR_INVALID_AE_TAG);
696     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_SALT", HKS_ERROR_INVALID_SALT);
697     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_ITERATION", HKS_ERROR_INVALID_ITERATION);
698     AddInt32Property(env, errorCode, "HKS_ERROR_INVALID_OPERATION", HKS_ERROR_INVALID_OPERATION);
699 
700     AddInt32Property(env, errorCode, "HKS_ERROR_INTERNAL_ERROR", HKS_ERROR_INTERNAL_ERROR);
701     AddInt32Property(env, errorCode, "HKS_ERROR_UNKNOWN_ERROR", HKS_ERROR_UNKNOWN_ERROR);
702 }
703 
CreateHksErrorCode(napi_env env)704 static napi_value CreateHksErrorCode(napi_env env)
705 {
706     napi_value errorCode = nullptr;
707     NAPI_CALL(env, napi_create_object(env, &errorCode));
708 
709     AddHksErrorCodePart1(env, errorCode);
710     AddHksErrorCodePart2(env, errorCode);
711 
712     return errorCode;
713 }
714 
CreateHksKeyType(napi_env env)715 static napi_value CreateHksKeyType(napi_env env)
716 {
717     napi_value keyType = nullptr;
718     NAPI_CALL(env, napi_create_object(env, &keyType));
719 
720     AddInt32Property(env, keyType, "HKS_KEY_TYPE_RSA_PUBLIC_KEY", HKS_KEY_TYPE_RSA_PUBLIC_KEY);
721     AddInt32Property(env, keyType, "HKS_KEY_TYPE_RSA_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR);
722 
723     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P256_PUBLIC_KEY", HKS_KEY_TYPE_RSA_KEYPAIR);
724     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P256_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR);
725     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P384_PUBLIC_KEY", HKS_KEY_TYPE_RSA_KEYPAIR);
726     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P384_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR);
727     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P521_PUBLIC_KEY", HKS_KEY_TYPE_RSA_KEYPAIR);
728     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ECC_P521_KEYPAIR", HKS_KEY_TYPE_RSA_KEYPAIR);
729 
730     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ED25519_PUBLIC_KEY", HKS_KEY_TYPE_ED25519_PUBLIC_KEY);
731     AddInt32Property(env, keyType, "HKS_KEY_TYPE_ED25519_KEYPAIR", HKS_KEY_TYPE_ED25519_KEYPAIR);
732     AddInt32Property(env, keyType, "HKS_KEY_TYPE_X25519_PUBLIC_KEY", HKS_KEY_TYPE_X25519_PUBLIC_KEY);
733     AddInt32Property(env, keyType, "HKS_KEY_TYPE_X25519_KEYPAIR", HKS_KEY_TYPE_X25519_KEYPAIR);
734 
735     AddInt32Property(env, keyType, "HKS_KEY_TYPE_AES", HKS_KEY_TYPE_AES);
736     AddInt32Property(env, keyType, "HKS_KEY_TYPE_CHACHA20", HKS_KEY_TYPE_CHACHA20);
737     AddInt32Property(env, keyType, "HKS_KEY_TYPE_CHACHA20_POLY1305", HKS_KEY_TYPE_CHACHA20_POLY1305);
738 
739     AddInt32Property(env, keyType, "HKS_KEY_TYPE_HMAC", HKS_KEY_TYPE_HMAC);
740     AddInt32Property(env, keyType, "HKS_KEY_TYPE_HKDF", HKS_KEY_TYPE_HKDF);
741     AddInt32Property(env, keyType, "HKS_KEY_TYPE_PBKDF2", HKS_KEY_TYPE_PBKDF2);
742 
743     return keyType;
744 }
745 
CreateHuksKeyDigest(napi_env env)746 static napi_value CreateHuksKeyDigest(napi_env env)
747 {
748     napi_value keyDisgest = nullptr;
749     NAPI_CALL(env, napi_create_object(env, &keyDisgest));
750 
751     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_NONE", HKS_DIGEST_NONE);
752     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_MD5", HKS_DIGEST_MD5);
753     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA1", HKS_DIGEST_SHA1);
754     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA224", HKS_DIGEST_SHA224);
755     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA256", HKS_DIGEST_SHA256);
756     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA384", HKS_DIGEST_SHA384);
757     AddInt32Property(env, keyDisgest, "HUKS_DIGEST_SHA512", HKS_DIGEST_SHA512);
758 
759     return keyDisgest;
760 }
761 
CreateHksKeyDigest(napi_env env)762 static napi_value CreateHksKeyDigest(napi_env env)
763 {
764     napi_value keyDisgest = nullptr;
765     NAPI_CALL(env, napi_create_object(env, &keyDisgest));
766 
767     AddInt32Property(env, keyDisgest, "HKS_DIGEST_NONE", HKS_DIGEST_NONE);
768     AddInt32Property(env, keyDisgest, "HKS_DIGEST_MD5", HKS_DIGEST_MD5);
769     AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA1", HKS_DIGEST_SHA1);
770     AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA224", HKS_DIGEST_SHA224);
771     AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA256", HKS_DIGEST_SHA256);
772     AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA384", HKS_DIGEST_SHA384);
773     AddInt32Property(env, keyDisgest, "HKS_DIGEST_SHA512", HKS_DIGEST_SHA512);
774 
775     return keyDisgest;
776 }
777 
CreateHuksKeyGenerateType(napi_env env)778 static napi_value CreateHuksKeyGenerateType(napi_env env)
779 {
780     napi_value keyGenerateType = nullptr;
781     NAPI_CALL(env, napi_create_object(env, &keyGenerateType));
782 
783     AddInt32Property(env, keyGenerateType, "HUKS_KEY_GENERATE_TYPE_DEFAULT", HKS_KEY_GENERATE_TYPE_DEFAULT);
784     AddInt32Property(env, keyGenerateType, "HUKS_KEY_GENERATE_TYPE_DERIVE", HKS_KEY_GENERATE_TYPE_DERIVE);
785     AddInt32Property(env, keyGenerateType, "HUKS_KEY_GENERATE_TYPE_AGREE", HKS_KEY_GENERATE_TYPE_AGREE);
786 
787     return keyGenerateType;
788 }
789 
CreateHksKeyGenerateType(napi_env env)790 static napi_value CreateHksKeyGenerateType(napi_env env)
791 {
792     napi_value keyGenerateType = nullptr;
793     NAPI_CALL(env, napi_create_object(env, &keyGenerateType));
794 
795     AddInt32Property(env, keyGenerateType, "HKS_KEY_GENERATE_TYPE_DEFAULT", HKS_KEY_GENERATE_TYPE_DEFAULT);
796     AddInt32Property(env, keyGenerateType, "HKS_KEY_GENERATE_TYPE_DERIVE", HKS_KEY_GENERATE_TYPE_DERIVE);
797     AddInt32Property(env, keyGenerateType, "HKS_KEY_GENERATE_TYPE_AGREE", HKS_KEY_GENERATE_TYPE_AGREE);
798 
799     return keyGenerateType;
800 }
801 
CreateHuksKeyFlag(napi_env env)802 static napi_value CreateHuksKeyFlag(napi_env env)
803 {
804     napi_value keyFlag = nullptr;
805     NAPI_CALL(env, napi_create_object(env, &keyFlag));
806 
807     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_IMPORT_KEY", HKS_KEY_FLAG_IMPORT_KEY);
808     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_GENERATE_KEY", HKS_KEY_FLAG_GENERATE_KEY);
809     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_AGREE_KEY", HKS_KEY_FLAG_AGREE_KEY);
810     AddInt32Property(env, keyFlag, "HUKS_KEY_FLAG_DERIVE_KEY", HKS_KEY_FLAG_DERIVE_KEY);
811 
812     return keyFlag;
813 }
814 
CreateHksKeyFlag(napi_env env)815 static napi_value CreateHksKeyFlag(napi_env env)
816 {
817     napi_value keyFlag = nullptr;
818     NAPI_CALL(env, napi_create_object(env, &keyFlag));
819 
820     AddInt32Property(env, keyFlag, "HKS_KEY_FLAG_IMPORT_KEY", HKS_KEY_FLAG_IMPORT_KEY);
821     AddInt32Property(env, keyFlag, "HKS_KEY_FLAG_GENERATE_KEY", HKS_KEY_FLAG_GENERATE_KEY);
822     AddInt32Property(env, keyFlag, "HKS_KEY_FLAG_AGREE_KEY", HKS_KEY_FLAG_AGREE_KEY);
823     AddInt32Property(env, keyFlag, "HKS_KEY_FLAG_DERIVE_KEY", HKS_KEY_FLAG_DERIVE_KEY);
824 
825     return keyFlag;
826 }
827 
CreateHuksTagType(napi_env env)828 static napi_value CreateHuksTagType(napi_env env)
829 {
830     napi_value tagType = nullptr;
831     NAPI_CALL(env, napi_create_object(env, &tagType));
832 
833     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_INVALID", HKS_TAG_TYPE_INVALID);
834     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_INT", HKS_TAG_TYPE_INT);
835     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_UINT", HKS_TAG_TYPE_UINT);
836     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_ULONG", HKS_TAG_TYPE_ULONG);
837     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_BOOL", HKS_TAG_TYPE_BOOL);
838     AddInt32Property(env, tagType, "HUKS_TAG_TYPE_BYTES", HKS_TAG_TYPE_BYTES);
839 
840     return tagType;
841 }
842 
CreateHksTagType(napi_env env)843 static napi_value CreateHksTagType(napi_env env)
844 {
845     napi_value tagType = nullptr;
846     NAPI_CALL(env, napi_create_object(env, &tagType));
847 
848     AddInt32Property(env, tagType, "HKS_TAG_TYPE_INVALID", HKS_TAG_TYPE_INVALID);
849     AddInt32Property(env, tagType, "HKS_TAG_TYPE_INT", HKS_TAG_TYPE_INT);
850     AddInt32Property(env, tagType, "HKS_TAG_TYPE_UINT", HKS_TAG_TYPE_UINT);
851     AddInt32Property(env, tagType, "HKS_TAG_TYPE_ULONG", HKS_TAG_TYPE_ULONG);
852     AddInt32Property(env, tagType, "HKS_TAG_TYPE_BOOL", HKS_TAG_TYPE_BOOL);
853     AddInt32Property(env, tagType, "HKS_TAG_TYPE_BYTES", HKS_TAG_TYPE_BYTES);
854 
855     return tagType;
856 }
857 
CreateHuksSendType(napi_env env)858 static napi_value CreateHuksSendType(napi_env env)
859 {
860     napi_value sendType = nullptr;
861     NAPI_CALL(env, napi_create_object(env, &sendType));
862 
863     AddInt32Property(env, sendType, "HUKS_SEND_TYPE_ASYNC", HKS_SEND_TYPE_ASYNC);
864     AddInt32Property(env, sendType, "HUKS_SEND_TYPE_SYNC", HKS_SEND_TYPE_SYNC);
865 
866     return sendType;
867 }
868 }  // namespace HuksNapi
869 
870 using namespace HuksNapi;
871 
872 extern "C" {
HuksNapiRegister(napi_env env,napi_value exports)873 static napi_value HuksNapiRegister(napi_env env, napi_value exports)
874 {
875     napi_property_descriptor desc[] = {
876         DECLARE_NAPI_PROPERTY("HksErrorCode", CreateHksErrorCode(env)),
877         DECLARE_NAPI_PROPERTY("HksKeyType", CreateHksKeyType(env)),
878         DECLARE_NAPI_PROPERTY("HksKeyPurpose", CreateHksKeyPurpose(env)),
879         DECLARE_NAPI_PROPERTY("HksKeyDigest", CreateHksKeyDigest(env)),
880         DECLARE_NAPI_PROPERTY("HksKeyPadding", CreateHksKeyPadding(env)),
881         DECLARE_NAPI_PROPERTY("HksCipherMode", CreateHksCipherMode(env)),
882         DECLARE_NAPI_PROPERTY("HksKeySize", CreateHksKeySize(env)),
883         DECLARE_NAPI_PROPERTY("HksKeyAlg", CreateHksKeyAlg(env)),
884         DECLARE_NAPI_PROPERTY("HksKeyGenerateType", CreateHksKeyGenerateType(env)),
885         DECLARE_NAPI_PROPERTY("HksKeyFlag", CreateHksKeyFlag(env)),
886         DECLARE_NAPI_PROPERTY("HksKeyStorageType", CreateHksKeyStorageType(env)),
887         DECLARE_NAPI_PROPERTY("HksTagType", CreateHksTagType(env)),
888         DECLARE_NAPI_PROPERTY("HksTag", CreateHksTag(env)),
889 
890         DECLARE_NAPI_PROPERTY("HuksErrorCode", CreateHuksErrorCode(env)),
891         DECLARE_NAPI_PROPERTY("HuksKeyPurpose", CreateHuksKeyPurpose(env)),
892         DECLARE_NAPI_PROPERTY("HuksKeyDigest", CreateHuksKeyDigest(env)),
893         DECLARE_NAPI_PROPERTY("HuksKeyPadding", CreateHuksKeyPadding(env)),
894         DECLARE_NAPI_PROPERTY("HuksCipherMode", CreateHuksCipherMode(env)),
895         DECLARE_NAPI_PROPERTY("HuksKeySize", CreateHuksKeySize(env)),
896         DECLARE_NAPI_PROPERTY("HuksKeyAlg", CreateHuksKeyAlg(env)),
897         DECLARE_NAPI_PROPERTY("HuksKeyGenerateType", CreateHuksKeyGenerateType(env)),
898         DECLARE_NAPI_PROPERTY("HuksKeyFlag", CreateHuksKeyFlag(env)),
899         DECLARE_NAPI_PROPERTY("HuksKeyStorageType", CreateHuksKeyStorageType(env)),
900         DECLARE_NAPI_PROPERTY("HuksTagType", CreateHuksTagType(env)),
901         DECLARE_NAPI_PROPERTY("HuksTag", CreateHuksTag(env)),
902         DECLARE_NAPI_PROPERTY("HuksSendType", CreateHuksSendType(env)),
903 
904         DECLARE_NAPI_FUNCTION("generateKey", HuksNapiGenerateKey),
905         DECLARE_NAPI_FUNCTION("deleteKey", HuksNapiDeleteKey),
906         DECLARE_NAPI_FUNCTION("encrypt", HuksNapiEncrypt),
907         DECLARE_NAPI_FUNCTION("decrypt", HuksNapiDecrypt),
908         DECLARE_NAPI_FUNCTION("getSdkVersion", HuksNapiGetSdkVersion),
909         DECLARE_NAPI_FUNCTION("importKey", HuksNapiImportKey),
910         DECLARE_NAPI_FUNCTION("exportKey", HuksNapiExportKey),
911         DECLARE_NAPI_FUNCTION("getKeyProperties", HuksNapiGetKeyProperties),
912         DECLARE_NAPI_FUNCTION("isKeyExist", HuksNapiIsKeyExist),
913         DECLARE_NAPI_FUNCTION("sign", HuksNapiSign),
914         DECLARE_NAPI_FUNCTION("verify", HuksNapiVerify),
915         DECLARE_NAPI_FUNCTION("agreeKey", HuksNapiAgreeKey),
916         DECLARE_NAPI_FUNCTION("deriveKey", HuksNapiDeriveKey),
917         DECLARE_NAPI_FUNCTION("mac", HuksNapiMac),
918         DECLARE_NAPI_FUNCTION("attestKey", HuksNapiAttestKey),
919         DECLARE_NAPI_FUNCTION("getCertificateChain", HuksNapiGetCertificateChain),
920         DECLARE_NAPI_FUNCTION("wrapKey", HuksNapiWrapKey),
921         DECLARE_NAPI_FUNCTION("unwrapKey", HuksNapiUnwrapKey),
922         DECLARE_NAPI_FUNCTION("init", HuksNapiInit),
923         DECLARE_NAPI_FUNCTION("update", HuksNapiUpdate),
924         DECLARE_NAPI_FUNCTION("finish", HuksNapiFinish),
925         DECLARE_NAPI_FUNCTION("abort", HuksNapiAbort),
926     };
927     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
928     return exports;
929 }
930 
931 static napi_module g_module = {
932     .nm_version = 1,
933     .nm_flags = 0,
934     .nm_filename = nullptr,
935     .nm_register_func = HuksNapiRegister,
936     .nm_modname = "security.huks",
937     .nm_priv = ((void *)0),
938     .reserved = {0},
939 };
940 
RegisterModule(void)941 __attribute__((constructor)) void RegisterModule(void)
942 {
943     napi_module_register(&g_module);
944 }
945 }
946