diff --git a/frameworks/js/napi/crypto/inc/napi_key_agreement.h b/frameworks/js/napi/crypto/inc/napi_key_agreement.h index 45f409d5368132af3e3932d8d361e4ccd32a16d8..43b456e7e630d82d1f0c88e68463d1daa6a945a5 100644 --- a/frameworks/js/napi/crypto/inc/napi_key_agreement.h +++ b/frameworks/js/napi/crypto/inc/napi_key_agreement.h @@ -36,6 +36,7 @@ public: static napi_value CreateJsKeyAgreement(napi_env env, napi_callback_info info); static napi_value JsGenerateSecret(napi_env env, napi_callback_info info); + static napi_value JsGenerateSecretSync(napi_env env, napi_callback_info info); static napi_value JsGetAlgorithm(napi_env env, napi_callback_info info); static thread_local napi_ref classRef_; diff --git a/frameworks/js/napi/crypto/inc/napi_sign.h b/frameworks/js/napi/crypto/inc/napi_sign.h index 483380650a27014017ca23079e58404cc7ca4643..fa88a43726dbf1337d9ef09bd1cd1bcb46a2b23a 100644 --- a/frameworks/js/napi/crypto/inc/napi_sign.h +++ b/frameworks/js/napi/crypto/inc/napi_sign.h @@ -38,6 +38,9 @@ public: static napi_value JsInit(napi_env env, napi_callback_info info); static napi_value JsUpdate(napi_env env, napi_callback_info info); static napi_value JsSign(napi_env env, napi_callback_info info); + static napi_value JsInitSync(napi_env env, napi_callback_info info); + static napi_value JsUpdateSync(napi_env env, napi_callback_info info); + static napi_value JsSignSync(napi_env env, napi_callback_info info); static napi_value JsSetSignSpec(napi_env env, napi_callback_info info); static napi_value JsGetSignSpec(napi_env env, napi_callback_info info); diff --git a/frameworks/js/napi/crypto/inc/napi_verify.h b/frameworks/js/napi/crypto/inc/napi_verify.h index 748f05fb73ee423e15fed0d332913c8e3d16dd9d..a5298ca5824714721b4c007fe010f52c0237f493 100644 --- a/frameworks/js/napi/crypto/inc/napi_verify.h +++ b/frameworks/js/napi/crypto/inc/napi_verify.h @@ -39,6 +39,9 @@ public: static napi_value JsUpdate(napi_env env, napi_callback_info info); static napi_value JsVerify(napi_env env, napi_callback_info info); static napi_value JsRecover(napi_env env, napi_callback_info info); + static napi_value JsInitSync(napi_env env, napi_callback_info info); + static napi_value JsUpdateSync(napi_env env, napi_callback_info info); + static napi_value JsVerifySync(napi_env env, napi_callback_info info); static napi_value JsRecoverSync(napi_env env, napi_callback_info info); static napi_value JsSetVerifySpec(napi_env env, napi_callback_info info); diff --git a/frameworks/js/napi/crypto/src/napi_key_agreement.cpp b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp index 74e730356d07f39ce0947c1356881f264b0e89ae..e02c680d7dc4bcf3786e32eb3298640f487274ce 100644 --- a/frameworks/js/napi/crypto/src/napi_key_agreement.cpp +++ b/frameworks/js/napi/crypto/src/napi_key_agreement.cpp @@ -279,6 +279,57 @@ napi_value NapiKeyAgreement::JsGenerateSecret(napi_env env, napi_callback_info i return NewKeyAgreementAsyncWork(env, ctx); } +napi_value NapiKeyAgreement::JsGenerateSecretSync(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argc = PARAMS_NUM_TWO; + napi_value argv[PARAMS_NUM_TWO] = { nullptr }; + napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); + if (argc != PARAMS_NUM_TWO) { + LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_TWO, argc); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "wrong argument num.")); + return nullptr; + } + + NapiKeyAgreement *napiKeyAgreement = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiKeyAgreement)); + if (status != napi_ok || napiKeyAgreement == nullptr) { + LOGE("failed to unwrap napi verify obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi verify obj.")); + return nullptr; + } + + NapiPriKey *napiPriKey = nullptr; + status = napi_unwrap(env, argv[PARAM0], reinterpret_cast(&napiPriKey)); + if (status != napi_ok || napiPriKey == nullptr) { + LOGE("failed to unwrap priKey verify obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap priKey verify obj.")); + return nullptr; + } + + NapiPubKey *napiPubKey = nullptr; + status = napi_unwrap(env, argv[PARAM1], reinterpret_cast(&napiPubKey)); + if (status != napi_ok || napiPubKey == nullptr) { + LOGE("failed to unwrap napi pubKey obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi pubKey obj.")); + return nullptr; + } + + HcfKeyAgreement *keyAgreement = napiKeyAgreement->GetKeyAgreement(); + HcfPriKey *priKey = napiPriKey->GetPriKey(); + HcfPubKey *pubKey = napiPubKey->GetPubKey(); + HcfBlob *returnSecret = static_cast(HcfMalloc(sizeof(HcfBlob), 0)); + HcfResult ret = keyAgreement->generateSecret(keyAgreement, priKey, pubKey, returnSecret); + if (ret != HCF_SUCCESS) { + LOGD("generate secret fail."); + napi_throw(env, GenerateBusinessError(env, ret, "generate secret fail.")); + delete returnSecret; + return nullptr; + } + + return ConvertBlobToNapiValue(env, returnSecret); +} + napi_value NapiKeyAgreement::KeyAgreementConstructor(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; @@ -370,6 +421,7 @@ void NapiKeyAgreement::DefineKeyAgreementJSClass(napi_env env, napi_value export napi_property_descriptor classDesc[] = { DECLARE_NAPI_FUNCTION("generateSecret", NapiKeyAgreement::JsGenerateSecret), + DECLARE_NAPI_FUNCTION("generateSecretSync", NapiKeyAgreement::JsGenerateSecretSync), {.utf8name = "algName", .getter = NapiKeyAgreement::JsGetAlgorithm}, }; napi_value constructor = nullptr; diff --git a/frameworks/js/napi/crypto/src/napi_sign.cpp b/frameworks/js/napi/crypto/src/napi_sign.cpp index 56becc2689953a3683c0badfd520d1fce901bb9e..85a2424235b4e6577050256e17418fe72d269901 100644 --- a/frameworks/js/napi/crypto/src/napi_sign.cpp +++ b/frameworks/js/napi/crypto/src/napi_sign.cpp @@ -573,6 +573,48 @@ napi_value NapiSign::JsInit(napi_env env, napi_callback_info info) return NewSignJsInitAsyncWork(env, ctx); } +napi_value NapiSign::JsInitSync(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t expectedArgc = PARAMS_NUM_ONE; + size_t argc = expectedArgc; + napi_value argv[PARAMS_NUM_ONE] = { nullptr }; + napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); + if (argc != PARAMS_NUM_ONE) { + LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_ONE, argc); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "wrong argument num.")); + return nullptr; + } + + NapiSign *napiSign = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiSign)); + if (status != napi_ok || napiSign == nullptr) { + LOGE("failed to unwrap napi sign obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi sign obj.")); + return nullptr; + } + + NapiPriKey *napiPriKey = nullptr; + status = napi_unwrap(env, argv[PARAM0], reinterpret_cast(&napiPriKey)); + if (status != napi_ok || napiPriKey == nullptr) { + LOGE("failed to unwrap napi priKey obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi priKey obj.")); + return nullptr; + } + + HcfSign *sign = napiSign->GetSign(); + HcfParamsSpec *params = nullptr; + HcfPriKey *priKey = napiPriKey->GetPriKey(); + HcfResult ret = sign->init(sign, params, priKey); + if (ret != HCF_SUCCESS) { + LOGD("sign init fail."); + napi_throw(env, GenerateBusinessError(env, ret, "sign init fail.")); + return nullptr; + } + napi_value instance = NapiGetNull(env); + return instance; +} + napi_value NapiSign::JsUpdate(napi_env env, napi_callback_info info) { SignUpdateCtx *ctx = static_cast(HcfMalloc(sizeof(SignUpdateCtx), 0)); @@ -592,6 +634,44 @@ napi_value NapiSign::JsUpdate(napi_env env, napi_callback_info info) return NewSignJsUpdateAsyncWork(env, ctx); } +napi_value NapiSign::JsUpdateSync(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argc = PARAMS_NUM_ONE; + napi_value argv[PARAMS_NUM_ONE] = { nullptr }; + napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); + if (argc != PARAMS_NUM_ONE) { + LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_ONE, argc); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "wrong argument num.")); + return nullptr; + } + + NapiSign *napiSign = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiSign)); + if (status != napi_ok || napiSign == nullptr) { + LOGE("failed to unwrap napi sign obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi sign obj.")); + return nullptr; + } + + HcfBlob *blob = GetBlobFromNapiDataBlob(env, argv[PARAM0]); + if (blob == nullptr) { + LOGE("failed to get data."); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to get data.")); + return nullptr; + } + + HcfSign *sign = napiSign->GetSign(); + HcfResult ret = sign->update(sign, blob); + if (ret != HCF_SUCCESS) { + LOGD("sign update fail."); + napi_throw(env, GenerateBusinessError(env, ret, "sign update fail.")); + return nullptr; + } + napi_value instance = NapiGetNull(env); + return instance; +} + napi_value NapiSign::JsSign(napi_env env, napi_callback_info info) { SignDoFinalCtx *ctx = static_cast(HcfMalloc(sizeof(SignDoFinalCtx), 0)); @@ -611,6 +691,51 @@ napi_value NapiSign::JsSign(napi_env env, napi_callback_info info) return NewSignJsDoFinalAsyncWork(env, ctx); } +napi_value NapiSign::JsSignSync(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argc = PARAMS_NUM_ONE; + napi_value argv[PARAMS_NUM_ONE] = { nullptr }; + napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); + if (argc != PARAMS_NUM_ONE) { + LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_ONE, argc); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "wrong argument num.")); + return nullptr; + } + + NapiSign *napiSign = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiSign)); + if (status != napi_ok || napiSign == nullptr) { + LOGE("failed to unwrap napi sign obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi sign obj.")); + return nullptr; + } + + napi_valuetype valueType; + napi_typeof(env, argv[PARAM0], &valueType); + HcfBlob *data = nullptr; + if (valueType != napi_null) { + data = GetBlobFromNapiDataBlob(env, argv[PARAM0]); + if (data == nullptr) { + LOGE("failed to get data."); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to get data.")); + return nullptr; + } + } + + HcfSign *sign = napiSign->GetSign(); + HcfBlob *returnSignatureData = static_cast(HcfMalloc(sizeof(HcfBlob), 0)); + HcfResult ret = sign->sign(sign, data, returnSignatureData); + if (ret != HCF_SUCCESS) { + LOGD("sign doFinal fail."); + napi_throw(env, GenerateBusinessError(env, ret, "sign doFinal fail.")); + delete returnSignatureData; + return nullptr; + } + + return ConvertBlobToNapiValue(env, returnSignatureData); +} + napi_value NapiSign::SignConstructor(napi_env env, napi_callback_info info) { napi_value thisVar = nullptr; @@ -860,6 +985,9 @@ void NapiSign::DefineSignJSClass(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("init", NapiSign::JsInit), DECLARE_NAPI_FUNCTION("update", NapiSign::JsUpdate), DECLARE_NAPI_FUNCTION("sign", NapiSign::JsSign), + DECLARE_NAPI_FUNCTION("initSync", NapiSign::JsInitSync), + DECLARE_NAPI_FUNCTION("updateSync", NapiSign::JsUpdateSync), + DECLARE_NAPI_FUNCTION("signSync", NapiSign::JsSignSync), DECLARE_NAPI_FUNCTION("setSignSpec", NapiSign::JsSetSignSpec), DECLARE_NAPI_FUNCTION("getSignSpec", NapiSign::JsGetSignSpec), }; diff --git a/frameworks/js/napi/crypto/src/napi_utils.cpp b/frameworks/js/napi/crypto/src/napi_utils.cpp index c86bc51da9473c7962a11a57c73f6d36ff878e45..e697a92ef558cb55f45fe0203a9102cd862a58b2 100644 --- a/frameworks/js/napi/crypto/src/napi_utils.cpp +++ b/frameworks/js/napi/crypto/src/napi_utils.cpp @@ -1663,7 +1663,7 @@ static uint32_t GetJsErrValueByErrCode(HcfResult errCode) return JS_ERR_NOT_SUPPORT; case HCF_ERR_MALLOC: return JS_ERR_OUT_OF_MEMORY; - case HCF_ERR_COPY: + case HCF_ERR_NAPI: return JS_ERR_RUNTIME_ERROR; case HCF_ERR_CRYPTO_OPERATION: return JS_ERR_CRYPTO_OPERATION; diff --git a/frameworks/js/napi/crypto/src/napi_verify.cpp b/frameworks/js/napi/crypto/src/napi_verify.cpp index 76faf5d995eca03fc06dd351059baeffa2985837..216e9038aefbcc47054806b4eaa8548baa6ac45c 100644 --- a/frameworks/js/napi/crypto/src/napi_verify.cpp +++ b/frameworks/js/napi/crypto/src/napi_verify.cpp @@ -699,6 +699,48 @@ napi_value NapiVerify::JsInit(napi_env env, napi_callback_info info) return NewVerifyJsInitAsyncWork(env, ctx); } +napi_value NapiVerify::JsInitSync(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argc = PARAMS_NUM_ONE; + napi_value argv[PARAMS_NUM_ONE] = { nullptr }; + napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); + if (argc != PARAMS_NUM_ONE) { + LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_ONE, argc); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "wrong argument num.")); + return nullptr; + } + + NapiVerify *napiVerify = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiVerify)); + if (status != napi_ok || napiVerify == nullptr) { + LOGE("failed to unwrap napi verify obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi verify obj.")); + return nullptr; + } + + NapiPubKey *napiPubKey = nullptr; + status = napi_unwrap(env, argv[PARAM0], reinterpret_cast(&napiPubKey)); + if (status != napi_ok || napiPubKey == nullptr) { + LOGE("failed to unwrap napi pubKey obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi pubKey obj.")); + return nullptr; + } + + HcfVerify *verify = napiVerify->GetVerify(); + HcfParamsSpec *params = nullptr; + HcfPubKey *pubKey = napiPubKey->GetPubKey(); + + HcfResult ret = verify->init(verify, params, pubKey); + if (ret != HCF_SUCCESS) { + LOGE("verify init fail."); + napi_throw(env, GenerateBusinessError(env, ret, "verify init fail.")); + return nullptr; + } + napi_value instance = NapiGetNull(env); + return instance; +} + napi_value NapiVerify::JsUpdate(napi_env env, napi_callback_info info) { VerifyUpdateCtx *ctx = static_cast(HcfMalloc(sizeof(VerifyUpdateCtx), 0)); @@ -718,6 +760,43 @@ napi_value NapiVerify::JsUpdate(napi_env env, napi_callback_info info) return NewVerifyJsUpdateAsyncWork(env, ctx); } +napi_value NapiVerify::JsUpdateSync(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argc = PARAMS_NUM_ONE; + napi_value argv[PARAMS_NUM_ONE] = { nullptr }; + napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); + if (argc != PARAMS_NUM_ONE) { + LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_ONE, argc); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "wrong argument num.")); + return nullptr; + } + + NapiVerify *napiVerify = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiVerify)); + if (status != napi_ok || napiVerify == nullptr) { + LOGE("failed to unwrap napi verify obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi verify obj.")); + return nullptr; + } + + HcfBlob *blob = GetBlobFromNapiDataBlob(env, argv[PARAM0]); + if (blob == nullptr) { + LOGE("failed to get blob data from napi."); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "failed to get blob data from napi.")); + return nullptr; + } + + HcfVerify *verify = napiVerify->GetVerify(); + HcfResult ret = verify->update(verify, blob); + if (ret != HCF_SUCCESS) { + LOGE("verify update fail."); + napi_throw(env, GenerateBusinessError(env, ret, "verify update fail.")); + } + napi_value instance = NapiGetNull(env); + return instance; +} + napi_value NapiVerify::JsVerify(napi_env env, napi_callback_info info) { VerifyDoFinalCtx *ctx = static_cast(HcfMalloc(sizeof(VerifyDoFinalCtx), 0)); @@ -737,6 +816,44 @@ napi_value NapiVerify::JsVerify(napi_env env, napi_callback_info info) return NewVerifyJsDoFinalAsyncWork(env, ctx); } +napi_value NapiVerify::JsVerifySync(napi_env env, napi_callback_info info) +{ + napi_value thisVar = nullptr; + size_t argc = PARAMS_NUM_TWO; + napi_value argv[PARAMS_NUM_TWO] = { nullptr, nullptr }; + napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr); + if (argc != PARAMS_NUM_TWO) { + LOGE("wrong argument num. require %d arguments. [Argc]: %zu!", PARAMS_NUM_TWO, argc); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "wrong argument num.")); + return nullptr; + } + + NapiVerify *napiVerify = nullptr; + napi_status status = napi_unwrap(env, thisVar, reinterpret_cast(&napiVerify)); + if (status != napi_ok || napiVerify == nullptr) { + LOGE("failed to unwrap napi verify obj."); + napi_throw(env, GenerateBusinessError(env, HCF_ERR_NAPI, "failed to unwrap napi verify obj.")); + return nullptr; + } + + HcfBlob *data = nullptr; + HcfBlob *signatureData = nullptr; + if (!GetDataBlobAndSignatureFromInput(env, argv[PARAM0], argv[PARAM1], &data, &signatureData)) { + return nullptr; + } + + HcfVerify *verify = napiVerify->GetVerify(); + bool isVerifySucc = verify->verify(verify, data, signatureData); + if (!isVerifySucc) { + LOGD("verify doFinal fail."); + napi_throw(env, GenerateBusinessError(env, HCF_INVALID_PARAMS, "verify doFinal fail.")); + return nullptr; + } + napi_value result = nullptr; + napi_get_boolean(env, isVerifySucc, &result); + return result; +} + static bool BuildVerifyJsRecoverCtx(napi_env env, napi_callback_info info, VerifyRecoverCtx *ctx) { napi_value thisVar = nullptr; @@ -1097,6 +1214,9 @@ void NapiVerify::DefineVerifyJSClass(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("init", NapiVerify::JsInit), DECLARE_NAPI_FUNCTION("update", NapiVerify::JsUpdate), DECLARE_NAPI_FUNCTION("verify", NapiVerify::JsVerify), + DECLARE_NAPI_FUNCTION("initSync", NapiVerify::JsInitSync), + DECLARE_NAPI_FUNCTION("updateSync", NapiVerify::JsUpdateSync), + DECLARE_NAPI_FUNCTION("verifySync", NapiVerify::JsVerifySync), DECLARE_NAPI_FUNCTION("recover", NapiVerify::JsRecover), DECLARE_NAPI_FUNCTION("recoverSync", NapiVerify::JsRecoverSync), DECLARE_NAPI_FUNCTION("setVerifySpec", NapiVerify::JsSetVerifySpec), diff --git a/interfaces/innerkits/common/result.h b/interfaces/innerkits/common/result.h index 38de2d647ab6129baaa7c47b8d6546ea10a1ace5..24088e20afeb9f8c77d64831db600191453c79cb 100644 --- a/interfaces/innerkits/common/result.h +++ b/interfaces/innerkits/common/result.h @@ -26,8 +26,8 @@ typedef enum HcfResult { /** Indicates that memory malloc fails. */ HCF_ERR_MALLOC = -20001, - /** Indicates that memory copy fails. */ - HCF_ERR_COPY = -20002, + /** Indicates that call napi api fails. */ + HCF_ERR_NAPI = -20002, /** Indicates that third part has something wrong. */ HCF_ERR_CRYPTO_OPERATION = -30001,