1 /*
2 * Copyright (C) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi_sym_key_generator.h"
17
18 #include "securec.h"
19 #include "log.h"
20 #include "memory.h"
21 #include "napi_sym_key.h"
22 #include "napi_utils.h"
23 #include "napi_crypto_framework_defines.h"
24
25 namespace OHOS {
26 namespace CryptoFramework {
27 thread_local napi_ref NapiSymKeyGenerator::classRef_ = nullptr;
28
29 struct SymKeyGeneratorFwkCtxT {
30 napi_env env = nullptr;
31 AsyncType asyncType = ASYNC_CALLBACK;
32 napi_ref callback = nullptr;
33 napi_deferred deferred = nullptr;
34 napi_value promise = nullptr;
35 napi_async_work asyncWork = nullptr;
36 napi_ref symKeyGeneratorRef = nullptr;
37
38 HcfResult errCode = HCF_SUCCESS;
39 HcfSymKey *returnSymKey = nullptr;
40 const char *errMsg = nullptr;
41
42 HcfSymKeyGenerator *generator = nullptr;
43 HcfBlob keyMaterial = { .data = nullptr, .len = 0 };
44 };
45
46 using SymKeyGeneratorFwkCtx = SymKeyGeneratorFwkCtxT *;
47
FreeSymKeyGeneratorFwkCtx(napi_env env,SymKeyGeneratorFwkCtx & context)48 static void FreeSymKeyGeneratorFwkCtx(napi_env env, SymKeyGeneratorFwkCtx &context)
49 {
50 if (context == nullptr) {
51 return;
52 }
53
54 if (context->asyncWork != nullptr) {
55 napi_delete_async_work(env, context->asyncWork);
56 context->asyncWork = nullptr;
57 }
58
59 if (context->callback != nullptr) {
60 napi_delete_reference(env, context->callback);
61 context->callback = nullptr;
62 }
63
64 if (context->symKeyGeneratorRef != nullptr) {
65 napi_delete_reference(env, context->symKeyGeneratorRef);
66 context->symKeyGeneratorRef = nullptr;
67 }
68
69 if (context->keyMaterial.data != nullptr) {
70 (void)memset_s(context->keyMaterial.data, context->keyMaterial.len, 0, context->keyMaterial.len);
71 HcfFree(context->keyMaterial.data);
72 context->keyMaterial.data = nullptr;
73 context->keyMaterial.len = 0;
74 }
75 context->errMsg = nullptr;
76
77 HcfFree(context);
78 context = nullptr;
79 }
80
BuildContextForGenerateKey(napi_env env,napi_callback_info info,SymKeyGeneratorFwkCtx context)81 static bool BuildContextForGenerateKey(napi_env env, napi_callback_info info, SymKeyGeneratorFwkCtx context)
82 {
83 napi_value thisVar = nullptr;
84 size_t expectedArgc = ARGS_SIZE_ONE;
85 size_t argc = ARGS_SIZE_ONE;
86 napi_value argv[ARGS_SIZE_ONE] = { nullptr };
87 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
88 if (argc != expectedArgc && argc != expectedArgc - 1) {
89 LOGE("wrong argument num. require 0 or 1 arguments. [Argc]: %{public}zu!", argc);
90 return false;
91 }
92 context->asyncType = isCallback(env, argv[expectedArgc - 1], argc, expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE;
93 NapiSymKeyGenerator *napiGenerator = nullptr;
94 napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiGenerator));
95 if (status != napi_ok || napiGenerator == nullptr) {
96 LOGE("failed to unwrap NapiSymKeyGenerator obj!");
97 return false;
98 }
99
100 context->generator = napiGenerator->GetSymKeyGenerator();
101 if (context->generator == nullptr) {
102 LOGE("failed to get generator obj!");
103 return false;
104 }
105
106 if (napi_create_reference(env, thisVar, 1, &context->symKeyGeneratorRef) != napi_ok) {
107 LOGE("create sym key generator ref failed when generate sym key!");
108 return false;
109 }
110
111 if (context->asyncType == ASYNC_PROMISE) {
112 napi_create_promise(env, &context->deferred, &context->promise);
113 return true;
114 } else {
115 return GetCallbackFromJSParams(env, argv[0], &context->callback);
116 }
117 }
118
BuildContextForConvertKey(napi_env env,napi_callback_info info,SymKeyGeneratorFwkCtx context)119 static bool BuildContextForConvertKey(napi_env env, napi_callback_info info, SymKeyGeneratorFwkCtx context)
120 {
121 napi_value thisVar = nullptr;
122 size_t expectedArgc = ARGS_SIZE_TWO;
123 size_t argc = ARGS_SIZE_TWO;
124 napi_value argv[ARGS_SIZE_TWO] = { nullptr };
125 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
126 if (argc != expectedArgc && argc != expectedArgc - 1) {
127 LOGE("wrong argument num. require 1 or 2 arguments. [Argc]: %{public}zu!", argc);
128 return false;
129 }
130 context->asyncType = isCallback(env, argv[expectedArgc - 1], argc, expectedArgc) ? ASYNC_CALLBACK : ASYNC_PROMISE;
131
132 NapiSymKeyGenerator *napiGenerator = nullptr;
133 napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiGenerator));
134 if (status != napi_ok || napiGenerator == nullptr) {
135 LOGE("failed to unwrap NapiSymKeyGenerator obj!");
136 return false;
137 }
138
139 context->generator = napiGenerator->GetSymKeyGenerator();
140 if (context->generator == nullptr) {
141 LOGE("failed to get generator obj!");
142 return false;
143 }
144
145 size_t index = 0;
146 HcfBlob *blob = GetBlobFromNapiDataBlob(env, argv[index++]);
147 if (blob == nullptr) {
148 LOGE("get keyMaterial failed!");
149 return false;
150 }
151 context->keyMaterial = *blob;
152 HcfFree(blob);
153 blob = nullptr;
154
155 if (napi_create_reference(env, thisVar, 1, &context->symKeyGeneratorRef) != napi_ok) {
156 LOGE("create sym key generator ref failed when covert sym key!");
157 return false;
158 }
159
160 if (context->asyncType == ASYNC_PROMISE) {
161 napi_create_promise(env, &context->deferred, &context->promise);
162 return true;
163 } else {
164 return GetCallbackFromJSParams(env, argv[index], &context->callback);
165 }
166 }
167
ReturnPromiseResult(napi_env env,SymKeyGeneratorFwkCtx context,napi_value result)168 static void ReturnPromiseResult(napi_env env, SymKeyGeneratorFwkCtx context, napi_value result)
169 {
170 if (context->errCode == HCF_SUCCESS) {
171 napi_resolve_deferred(env, context->deferred, result);
172 } else {
173 napi_reject_deferred(env, context->deferred,
174 GenerateBusinessError(env, context->errCode, context->errMsg));
175 }
176 }
177
ReturnCallbackResult(napi_env env,SymKeyGeneratorFwkCtx context,napi_value result)178 static void ReturnCallbackResult(napi_env env, SymKeyGeneratorFwkCtx context, napi_value result)
179 {
180 napi_value businessError = nullptr;
181 if (context->errCode != HCF_SUCCESS) {
182 businessError = GenerateBusinessError(env, context->errCode, context->errMsg);
183 }
184 napi_value params[ARGS_SIZE_TWO] = { businessError, result };
185
186 napi_value func = nullptr;
187 napi_get_reference_value(env, context->callback, &func);
188
189 napi_value recv = nullptr;
190 napi_value callFuncRet = nullptr;
191 napi_get_undefined(env, &recv);
192 napi_call_function(env, recv, func, ARGS_SIZE_TWO, params, &callFuncRet);
193 }
194
AsyncGenKeyProcess(napi_env env,void * data)195 static void AsyncGenKeyProcess(napi_env env, void *data)
196 {
197 SymKeyGeneratorFwkCtx context = static_cast<SymKeyGeneratorFwkCtx>(data);
198 HcfSymKeyGenerator *generator = context->generator;
199
200 HcfSymKey *key = nullptr;
201 context->errCode = generator->generateSymKey(generator, &key);
202 if (context->errCode != HCF_SUCCESS) {
203 LOGE("generate sym key failed.");
204 context->errMsg = "generate sym key failed.";
205 return;
206 }
207
208 context->errCode = HCF_SUCCESS;
209 context->returnSymKey = key;
210 }
211
AsyncKeyReturn(napi_env env,napi_status status,void * data)212 static void AsyncKeyReturn(napi_env env, napi_status status, void *data)
213 {
214 napi_value instance = NapiSymKey::CreateSymKey(env);
215 SymKeyGeneratorFwkCtx context = static_cast<SymKeyGeneratorFwkCtx>(data);
216 NapiSymKey *napiSymKey = new (std::nothrow) NapiSymKey(context->returnSymKey);
217 if (napiSymKey == nullptr) {
218 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "new napi sym key failed."));
219 FreeSymKeyGeneratorFwkCtx(env, context);
220 LOGE("new napi sym key failed.");
221 return;
222 }
223
224 napi_status ret = napi_wrap(env, instance, napiSymKey,
225 [](napi_env env, void *data, void *hint) {
226 NapiSymKey *napiSymKey = static_cast<NapiSymKey *>(data);
227 delete napiSymKey;
228 return;
229 }, nullptr, nullptr);
230 if (ret != napi_ok) {
231 LOGE("failed to wrap napiSymKey obj!");
232 context->errCode = HCF_INVALID_PARAMS;
233 context->errMsg = "failed to wrap napiSymKey obj!";
234 delete napiSymKey;
235 }
236
237 if (context->asyncType == ASYNC_CALLBACK) {
238 ReturnCallbackResult(env, context, instance);
239 } else {
240 ReturnPromiseResult(env, context, instance);
241 }
242 FreeSymKeyGeneratorFwkCtx(env, context);
243 }
244
AsyncConvertKeyProcess(napi_env env,void * data)245 static void AsyncConvertKeyProcess(napi_env env, void *data)
246 {
247 SymKeyGeneratorFwkCtx context = static_cast<SymKeyGeneratorFwkCtx>(data);
248 HcfSymKeyGenerator *generator = context->generator;
249
250 HcfSymKey *key = nullptr;
251 context->errCode = generator->convertSymKey(generator, &context->keyMaterial, &key);
252 if (context->errCode != HCF_SUCCESS) {
253 LOGE("convertSymKey key failed!");
254 context->errMsg = "convert sym key failed.";
255 return;
256 }
257
258 context->returnSymKey = key;
259 }
260
NewConvertKeyAsyncWork(napi_env env,SymKeyGeneratorFwkCtx context)261 static napi_value NewConvertKeyAsyncWork(napi_env env, SymKeyGeneratorFwkCtx context)
262 {
263 napi_value resourceName = nullptr;
264 napi_create_string_utf8(env, "convertSymKey", NAPI_AUTO_LENGTH, &resourceName);
265
266 napi_create_async_work(
267 env,
268 nullptr,
269 resourceName,
270 [](napi_env env, void *data) {
271 AsyncConvertKeyProcess(env, data);
272 return;
273 },
274 [](napi_env env, napi_status status, void *data) {
275 AsyncKeyReturn(env, status, data);
276 return;
277 },
278 static_cast<void *>(context),
279 &context->asyncWork);
280
281 napi_queue_async_work(env, context->asyncWork);
282 if (context->asyncType == ASYNC_PROMISE) {
283 return context->promise;
284 } else {
285 return NapiGetNull(env);
286 }
287 }
288
NewGenKeyAsyncWork(napi_env env,SymKeyGeneratorFwkCtx context)289 static napi_value NewGenKeyAsyncWork(napi_env env, SymKeyGeneratorFwkCtx context)
290 {
291 napi_value resourceName = nullptr;
292 napi_create_string_utf8(env, "generatorSymKey", NAPI_AUTO_LENGTH, &resourceName);
293
294 napi_create_async_work(
295 env,
296 nullptr,
297 resourceName,
298 [](napi_env env, void *data) {
299 AsyncGenKeyProcess(env, data);
300 return;
301 },
302 [](napi_env env, napi_status status, void *data) {
303 AsyncKeyReturn(env, status, data);
304 return;
305 },
306 static_cast<void *>(context),
307 &context->asyncWork);
308
309 napi_queue_async_work(env, context->asyncWork);
310 if (context->asyncType == ASYNC_PROMISE) {
311 return context->promise;
312 } else {
313 return NapiGetNull(env);
314 }
315 }
316
NapiSymKeyGenerator(HcfSymKeyGenerator * generator)317 NapiSymKeyGenerator::NapiSymKeyGenerator(HcfSymKeyGenerator *generator)
318 {
319 this->generator_ = generator;
320 }
321
~NapiSymKeyGenerator()322 NapiSymKeyGenerator::~NapiSymKeyGenerator()
323 {
324 HcfObjDestroy(this->generator_);
325 this->generator_ = nullptr;
326 }
327
GetSymKeyGenerator() const328 HcfSymKeyGenerator *NapiSymKeyGenerator::GetSymKeyGenerator() const
329 {
330 return this->generator_;
331 }
332
napiGetInstance(napi_env env,HcfSymKey * key,napi_value instance)333 static bool napiGetInstance(napi_env env, HcfSymKey *key, napi_value instance)
334 {
335 NapiSymKey *napiSymKey = new (std::nothrow) NapiSymKey(key);
336 if (napiSymKey == nullptr) {
337 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "new napi sym key failed."));
338 LOGE("new napi sym key failed.");
339 HcfObjDestroy(key);
340 key = nullptr;
341 return false;
342 }
343
344 napi_status wrapStatus = napi_wrap(
345 env, instance, napiSymKey,
346 [](napi_env env, void *data, void *hint) {
347 NapiSymKey *napiSymKey = static_cast<NapiSymKey *>(data);
348 delete napiSymKey;
349 return;
350 }, nullptr, nullptr);
351 if (wrapStatus != napi_ok) {
352 LOGE("failed to wrap napiSymKey obj!");
353 delete napiSymKey;
354 return false;
355 }
356
357 return true;
358 }
359
JsGenerateSymKey(napi_env env,napi_callback_info info)360 napi_value NapiSymKeyGenerator::JsGenerateSymKey(napi_env env, napi_callback_info info)
361 {
362 SymKeyGeneratorFwkCtx context = static_cast<SymKeyGeneratorFwkCtx>(HcfMalloc(sizeof(SymKeyGeneratorFwkCtxT), 0));
363 if (context == nullptr) {
364 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "Create context failed!"));
365 LOGE("Create context failed!");
366 return nullptr;
367 }
368
369 if (!BuildContextForGenerateKey(env, info, context)) {
370 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "Build context fail."));
371 LOGE("Build context fail.");
372 FreeSymKeyGeneratorFwkCtx(env, context);
373 return nullptr;
374 }
375
376 napi_value result = NewGenKeyAsyncWork(env, context);
377 if (result == nullptr) {
378 LOGE("NewGenKeyAsyncWork failed!");
379 FreeSymKeyGeneratorFwkCtx(env, context);
380 return nullptr;
381 }
382 return result;
383 }
384
JsGenerateSymKeySync(napi_env env,napi_callback_info info)385 napi_value NapiSymKeyGenerator::JsGenerateSymKeySync(napi_env env, napi_callback_info info)
386 {
387 napi_value thisVar = nullptr;
388 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
389 NapiSymKeyGenerator *napiGenerator = nullptr;
390 napi_status unwrapStatus = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiGenerator));
391 if (unwrapStatus != napi_ok || napiGenerator == nullptr) {
392 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "failed to unwrap NapiSymKeyGenerator obj."));
393 LOGE("failed to unwrap NapiSymKeyGenerator obj!");
394 return nullptr;
395 }
396
397 HcfSymKeyGenerator *generator = napiGenerator->GetSymKeyGenerator();
398 if (generator == nullptr) {
399 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "failed to get generator obj."));
400 LOGE("failed to get generator obj!");
401 return nullptr;
402 }
403
404 HcfSymKey *key = nullptr;
405 HcfResult ret = generator->generateSymKey(generator, &key);
406 if (ret != HCF_SUCCESS) {
407 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "generate sym key failed."));
408 LOGE("generate sym key failed.");
409 return nullptr;
410 }
411
412 napi_value instance = NapiSymKey::CreateSymKey(env);
413 if (!napiGetInstance(env, key, instance)) {
414 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "get instance failed!"));
415 LOGE("get instance failed!");
416 return nullptr;
417 }
418
419 return instance;
420 }
421
JsConvertKey(napi_env env,napi_callback_info info)422 napi_value NapiSymKeyGenerator::JsConvertKey(napi_env env, napi_callback_info info)
423 {
424 SymKeyGeneratorFwkCtx context = static_cast<SymKeyGeneratorFwkCtx>(HcfMalloc(sizeof(SymKeyGeneratorFwkCtxT), 0));
425 if (context == nullptr) {
426 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "malloc SymKeyGeneratorFwkCtx failed!"));
427 LOGE("malloc SymKeyGeneratorFwkCtx failed!");
428 return nullptr;
429 }
430
431 if (!BuildContextForConvertKey(env, info, context)) {
432 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "BuildContextForConvertKey failed!"));
433 LOGE("BuildContextForConvertKey failed!");
434 FreeSymKeyGeneratorFwkCtx(env, context);
435 return nullptr;
436 }
437
438 napi_value result = NewConvertKeyAsyncWork(env, context);
439 if (result == nullptr) {
440 LOGE("Get deviceauth async work failed!");
441 FreeSymKeyGeneratorFwkCtx(env, context);
442 return nullptr;
443 }
444 return result;
445 }
446
JsConvertKeySync(napi_env env,napi_callback_info info)447 napi_value NapiSymKeyGenerator::JsConvertKeySync(napi_env env, napi_callback_info info)
448 {
449 napi_value thisVar = nullptr;
450 size_t argc = ARGS_SIZE_ONE;
451 napi_value argv[ARGS_SIZE_ONE] = { nullptr };
452 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
453 if (argc != ARGS_SIZE_ONE) {
454 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "the input args num is invalid!"));
455 LOGE("wrong argument num. require 1 argument. [Argc]: %{public}zu!", argc);
456 return nullptr;
457 }
458
459 NapiSymKeyGenerator *napiGenerator = nullptr;
460 napi_status unwrapStatus = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiGenerator));
461 if (unwrapStatus != napi_ok || napiGenerator == nullptr) {
462 LOGE("failed to unwrap NapiSymKeyGenerator obj!");
463 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to unwrap NapiSymKeyGenerator obj!"));
464 return nullptr;
465 }
466
467 HcfSymKeyGenerator *generator = napiGenerator->GetSymKeyGenerator();
468 if (generator == nullptr) {
469 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "failed to get generator obj!"));
470 LOGE("failed to get generator obj!");
471 return nullptr;
472 }
473
474 HcfBlob *keyMaterial = GetBlobFromNapiDataBlob(env, argv[PARAM0]);
475 if (keyMaterial == nullptr) {
476 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "get keyMaterial failed!"));
477 LOGE("get keyMaterial failed!");
478 return nullptr;
479 }
480
481 HcfSymKey *key = nullptr;
482 HcfResult ret = generator->convertSymKey(generator, keyMaterial, &key);
483 HcfBlobDataClearAndFree(keyMaterial);
484 HcfFree(keyMaterial);
485 keyMaterial = nullptr;
486 if (ret != HCF_SUCCESS) {
487 napi_throw(env, GenerateBusinessError(env, ret, "convertSymKey key failed!"));
488 LOGE("convertSymKey key failed!");
489 return nullptr;
490 }
491
492 napi_value instance = NapiSymKey::CreateSymKey(env);
493 if (!napiGetInstance(env, key, instance)) {
494 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "get instance failed!"));
495 LOGE("get instance failed!");
496 return nullptr;
497 }
498
499 return instance;
500 }
501
SymKeyGeneratorConstructor(napi_env env,napi_callback_info info)502 napi_value NapiSymKeyGenerator::SymKeyGeneratorConstructor(napi_env env, napi_callback_info info)
503 {
504 napi_value thisVar = nullptr;
505 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
506 return thisVar;
507 }
508
CreateSymKeyGenerator(napi_env env,napi_callback_info info)509 napi_value NapiSymKeyGenerator::CreateSymKeyGenerator(napi_env env, napi_callback_info info)
510 {
511 LOGD("Enter CreateSymKeyGenerator...");
512 size_t expectedArgc = ARGS_SIZE_ONE;
513 size_t argc = ARGS_SIZE_ONE;
514 napi_value argv[ARGS_SIZE_ONE] = { nullptr };
515 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
516
517 if (argc != expectedArgc) {
518 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "The input args num is invalid."));
519 LOGE("The input args num is invalid.");
520 return nullptr;
521 }
522
523 napi_value instance;
524 napi_value constructor = nullptr;
525 napi_get_reference_value(env, classRef_, &constructor);
526 napi_new_instance(env, constructor, argc, argv, &instance);
527
528 std::string algoName;
529 if (!GetStringFromJSParams(env, argv[0], algoName)) {
530 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to get algoName."));
531 LOGE("failed to get algoName.");
532 return nullptr;
533 }
534
535 HcfSymKeyGenerator *generator = nullptr;
536 HcfResult res = HcfSymKeyGeneratorCreate(algoName.c_str(), &generator);
537 if (res != HCF_SUCCESS) {
538 napi_throw(env, GenerateBusinessError(env, res, "create C generator fail."));
539 LOGE("create C generator fail.");
540 return nullptr;
541 }
542 NapiSymKeyGenerator *napiSymKeyGenerator = new (std::nothrow) NapiSymKeyGenerator(generator);
543 if (napiSymKeyGenerator == nullptr) {
544 napi_throw(env, GenerateBusinessError(env, HCF_ERR_MALLOC, "new napi sym key generator failed."));
545 LOGE("new napi sym key generator failed!");
546 HcfObjDestroy(generator);
547 generator = nullptr;
548 return nullptr;
549 }
550
551 napi_status status = napi_wrap(env, instance, napiSymKeyGenerator,
552 [](napi_env env, void *data, void *hint) {
553 NapiSymKeyGenerator *napiSymKeyGenerator = static_cast<NapiSymKeyGenerator *>(data);
554 delete napiSymKeyGenerator;
555 return;
556 }, nullptr, nullptr);
557 if (status != napi_ok) {
558 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to wrap napiSymKeyGenerator obj!"));
559 LOGE("failed to wrap napiSymKeyGenerator obj!");
560 delete napiSymKeyGenerator;
561 return nullptr;
562 }
563 return instance;
564 }
565
JsGetAlgorithm(napi_env env,napi_callback_info info)566 napi_value NapiSymKeyGenerator::JsGetAlgorithm(napi_env env, napi_callback_info info)
567 {
568 napi_value thisVar = nullptr;
569 NapiSymKeyGenerator *napiSymKeyGenerator = nullptr;
570 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
571 napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&napiSymKeyGenerator));
572 if (status != napi_ok || napiSymKeyGenerator == nullptr) {
573 napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to unwrap napiSymKeyGenerator obj!"));
574 LOGE("failed to unwrap napiSymKeyGenerator obj!");
575 return nullptr;
576 }
577 HcfSymKeyGenerator *generator = napiSymKeyGenerator->GetSymKeyGenerator();
578
579 const char *algo = generator->getAlgoName(generator);
580 napi_value instance = nullptr;
581 napi_create_string_utf8(env, algo, NAPI_AUTO_LENGTH, &instance);
582 return instance;
583 }
584
DefineSymKeyGeneratorJSClass(napi_env env,napi_value exports)585 void NapiSymKeyGenerator::DefineSymKeyGeneratorJSClass(napi_env env, napi_value exports)
586 {
587 napi_property_descriptor desc[] = {
588 DECLARE_NAPI_FUNCTION("createSymKeyGenerator", NapiSymKeyGenerator::CreateSymKeyGenerator),
589 };
590 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
591
592 napi_property_descriptor classDesc[] = {
593 DECLARE_NAPI_FUNCTION("generateSymKey", NapiSymKeyGenerator::JsGenerateSymKey),
594 DECLARE_NAPI_FUNCTION("generateSymKeySync", NapiSymKeyGenerator::JsGenerateSymKeySync),
595 DECLARE_NAPI_FUNCTION("convertKey", NapiSymKeyGenerator::JsConvertKey),
596 DECLARE_NAPI_FUNCTION("convertKeySync", NapiSymKeyGenerator::JsConvertKeySync),
597 { .utf8name = "algName", .getter = NapiSymKeyGenerator::JsGetAlgorithm },
598 };
599 napi_value constructor = nullptr;
600 napi_define_class(env, "SymKeyGenerator", NAPI_AUTO_LENGTH,
601 NapiSymKeyGenerator::SymKeyGeneratorConstructor, nullptr,
602 sizeof(classDesc) / sizeof(classDesc[0]), classDesc, &constructor);
603 napi_create_reference(env, constructor, 1, &classRef_);
604 }
605 } // CryptoFramework
606 } // OHOS