1 /*
2 * Copyright (c) 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 "napi_x509_crl_entry.h"
17
18 #include "napi/native_node_api.h"
19 #include "napi/native_api.h"
20 #include "log.h"
21 #include "memory.h"
22 #include "utils.h"
23 #include "object_base.h"
24 #include "result.h"
25 #include "napi_crypto_framework_defines.h"
26 #include "napi_utils.h"
27
28 namespace OHOS {
29 namespace CryptoFramework {
30 thread_local napi_ref NapiX509CrlEntry::classRef_ = nullptr;
31
32 struct CfCtx {
33 CfAsyncType asyncType = ASYNC_TYPE_CALLBACK;
34 napi_value promise = nullptr;
35 napi_ref callback = nullptr;
36 napi_deferred deferred = nullptr;
37 napi_async_work asyncWork = nullptr;
38
39 NapiX509CrlEntry *crlEntryClass = nullptr;
40
41 int32_t errCode = 0;
42 const char *errMsg = nullptr;
43 HcfEncodingBlob *encoded = nullptr;
44 HcfBlob *blob = nullptr;
45 };
46
FreeCryptoFwkCtx(napi_env env,CfCtx * context)47 static void FreeCryptoFwkCtx(napi_env env, CfCtx *context)
48 {
49 if (context == nullptr) {
50 return;
51 }
52
53 if (context->asyncWork != nullptr) {
54 napi_delete_async_work(env, context->asyncWork);
55 }
56
57 if (context->callback != nullptr) {
58 napi_delete_reference(env, context->callback);
59 }
60
61 HcfEncodingBlobDataFree(context->encoded);
62 HcfFree(context->encoded);
63 context->encoded = nullptr;
64
65 HcfBlobDataFree(context->blob);
66 HcfFree(context->blob);
67 context->blob = nullptr;
68
69 HcfFree(context);
70 }
71
ReturnCallbackResult(napi_env env,CfCtx * context,napi_value result)72 static void ReturnCallbackResult(napi_env env, CfCtx *context, napi_value result)
73 {
74 napi_value businessError = nullptr;
75 if (context->errCode != HCF_SUCCESS) {
76 businessError = GenerateBusinessError(env, context->errCode, context->errMsg, true);
77 }
78 napi_value params[ARGS_SIZE_TWO] = { businessError, result };
79
80 napi_value func = nullptr;
81 napi_get_reference_value(env, context->callback, &func);
82
83 napi_value recv = nullptr;
84 napi_value callFuncRet = nullptr;
85 napi_get_undefined(env, &recv);
86 napi_call_function(env, recv, func, ARGS_SIZE_TWO, params, &callFuncRet);
87 }
88
ReturnPromiseResult(napi_env env,CfCtx * context,napi_value result)89 static void ReturnPromiseResult(napi_env env, CfCtx *context, napi_value result)
90 {
91 if (context->errCode == HCF_SUCCESS) {
92 napi_resolve_deferred(env, context->deferred, result);
93 } else {
94 napi_reject_deferred(env, context->deferred,
95 GenerateBusinessError(env, context->errCode, context->errMsg, true));
96 }
97 }
98
ReturnResult(napi_env env,CfCtx * context,napi_value result)99 static void ReturnResult(napi_env env, CfCtx *context, napi_value result)
100 {
101 if (context->asyncType == ASYNC_TYPE_CALLBACK) {
102 ReturnCallbackResult(env, context, result);
103 } else {
104 ReturnPromiseResult(env, context, result);
105 }
106 }
107
CreateCallbackAndPromise(napi_env env,CfCtx * context,size_t argc,size_t maxCount,napi_value callbackValue)108 static bool CreateCallbackAndPromise(napi_env env, CfCtx *context, size_t argc,
109 size_t maxCount, napi_value callbackValue)
110 {
111 context->asyncType = (argc == maxCount) ? ASYNC_TYPE_CALLBACK : ASYNC_TYPE_PROMISE;
112 if (context->asyncType == ASYNC_TYPE_CALLBACK) {
113 if (!GetCallbackFromJSParams(env, callbackValue, &context->callback, true)) {
114 LOGE("get callback failed!");
115 return false;
116 }
117 } else {
118 napi_create_promise(env, &context->deferred, &context->promise);
119 }
120 return true;
121 }
122
NapiX509CrlEntry(HcfX509CrlEntry * x509CrlEntry)123 NapiX509CrlEntry::NapiX509CrlEntry(HcfX509CrlEntry *x509CrlEntry)
124 {
125 this->x509CrlEntry_ = x509CrlEntry;
126 }
127
~NapiX509CrlEntry()128 NapiX509CrlEntry::~NapiX509CrlEntry()
129 {
130 HcfObjDestroy(this->x509CrlEntry_);
131 }
132
GetEncodedExecute(napi_env env,void * data)133 static void GetEncodedExecute(napi_env env, void *data)
134 {
135 CfCtx *context = static_cast<CfCtx *>(data);
136 HcfX509CrlEntry *x509CrlEntry = context->crlEntryClass->GetX509CrlEntry();
137 HcfEncodingBlob *encodingBlob = static_cast<HcfEncodingBlob *>(HcfMalloc(sizeof(HcfEncodingBlob), 0));
138 if (encodingBlob == nullptr) {
139 LOGE("malloc encoding blob failed!");
140 context->errCode = HCF_ERR_MALLOC;
141 context->errMsg = "malloc encoding blob failed";
142 return;
143 }
144
145 context->errCode = x509CrlEntry->getEncoded(x509CrlEntry, encodingBlob);
146 if (context->errCode != HCF_SUCCESS) {
147 LOGE("get encoded failed!");
148 context->errMsg = "get encoded failed";
149 }
150 context->encoded = encodingBlob;
151 }
152
GetEncodedComplete(napi_env env,napi_status status,void * data)153 static void GetEncodedComplete(napi_env env, napi_status status, void *data)
154 {
155 CfCtx *context = static_cast<CfCtx *>(data);
156 if (context->errCode != HCF_SUCCESS) {
157 ReturnResult(env, context, nullptr);
158 FreeCryptoFwkCtx(env, context);
159 return;
160 }
161 napi_value returnEncodingBlob = ConvertEncodingBlobToNapiValue(env, context->encoded);
162 ReturnResult(env, context, returnEncodingBlob);
163 FreeCryptoFwkCtx(env, context);
164 }
165
GetEncoded(napi_env env,napi_callback_info info)166 napi_value NapiX509CrlEntry::GetEncoded(napi_env env, napi_callback_info info)
167 {
168 size_t argc = ARGS_SIZE_ONE;
169 napi_value argv[ARGS_SIZE_ONE] = { nullptr };
170 napi_value thisVar = nullptr;
171 napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr);
172 if (!CheckArgsCount(env, argc, ARGS_SIZE_ONE, false, true)) {
173 return nullptr;
174 }
175
176 CfCtx *context = static_cast<CfCtx *>(HcfMalloc(sizeof(CfCtx), 0));
177 if (context == nullptr) {
178 LOGE("malloc context failed!");
179 return nullptr;
180 }
181 context->crlEntryClass = this;
182
183 if (!CreateCallbackAndPromise(env, context, argc, ARGS_SIZE_ONE, argv[PARAM0])) {
184 FreeCryptoFwkCtx(env, context);
185 return nullptr;
186 }
187
188 napi_create_async_work(
189 env, nullptr, GetResourceName(env, "GetEncoded"),
190 GetEncodedExecute,
191 GetEncodedComplete,
192 static_cast<void *>(context),
193 &context->asyncWork);
194
195 napi_queue_async_work(env, context->asyncWork);
196 if (context->asyncType == ASYNC_TYPE_PROMISE) {
197 return context->promise;
198 } else {
199 return NapiGetNull(env);
200 }
201 }
202
GetSerialNumber(napi_env env,napi_callback_info info)203 napi_value NapiX509CrlEntry::GetSerialNumber(napi_env env, napi_callback_info info)
204 {
205 HcfX509CrlEntry *x509CrlEntry = GetX509CrlEntry();
206 long serialNumber = x509CrlEntry->getSerialNumber(x509CrlEntry);
207 napi_value result = nullptr;
208 napi_create_int64(env, serialNumber, &result);
209 return result;
210 }
211
GetCertificateIssuer(napi_env env,napi_callback_info info)212 napi_value NapiX509CrlEntry::GetCertificateIssuer(napi_env env, napi_callback_info info)
213 {
214 HcfBlob *blob = reinterpret_cast<HcfBlob *>(HcfMalloc(sizeof(HcfBlob), 0));
215 if (blob == nullptr) {
216 LOGE("malloc blob failed!");
217 return nullptr;
218 }
219
220 HcfX509CrlEntry *x509CrlEntry = GetX509CrlEntry();
221 HcfResult ret = x509CrlEntry->getCertIssuer(x509CrlEntry, blob);
222 if (ret != HCF_SUCCESS) {
223 napi_throw(env, GenerateBusinessError(env, ret, "get subject name failed", true));
224 LOGE("get cert issuer failed!");
225 HcfFree(blob);
226 blob = nullptr;
227 return nullptr;
228 }
229 napi_value returnValue = ConvertBlobToNapiValue(env, blob);
230 HcfBlobDataFree(blob);
231 HcfFree(blob);
232 blob = nullptr;
233 return returnValue;
234 }
235
GetRevocationDate(napi_env env,napi_callback_info info)236 napi_value NapiX509CrlEntry::GetRevocationDate(napi_env env, napi_callback_info info)
237 {
238 HcfX509CrlEntry *x509CrlEntry = GetX509CrlEntry();
239 HcfBlob *blob = reinterpret_cast<HcfBlob *>(HcfMalloc(sizeof(HcfBlob), 0));
240 if (blob == nullptr) {
241 LOGE("malloc blob failed!");
242 return nullptr;
243 }
244 HcfResult ret = x509CrlEntry->getRevocationDate(x509CrlEntry, blob);
245 if (ret != HCF_SUCCESS) {
246 napi_throw(env, GenerateBusinessError(env, ret, "get revocation date failed", true));
247 LOGE("get revocation date failed!");
248 HcfFree(blob);
249 blob = nullptr;
250 return nullptr;
251 }
252 napi_value returnDate = nullptr;
253 napi_create_string_utf8(env, reinterpret_cast<char *>(blob->data), blob->len, &returnDate);
254 HcfBlobDataFree(blob);
255 HcfFree(blob);
256 blob = nullptr;
257 return returnDate;
258 }
259
NapiGetEncoded(napi_env env,napi_callback_info info)260 static napi_value NapiGetEncoded(napi_env env, napi_callback_info info)
261 {
262 napi_value thisVar = nullptr;
263 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
264 NapiX509CrlEntry *x509CrlEntry = nullptr;
265 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&x509CrlEntry));
266 if (x509CrlEntry == nullptr) {
267 LOGE("x509CrlEntry is nullptr!");
268 return nullptr;
269 }
270 return x509CrlEntry->GetEncoded(env, info);
271 }
272
NapiGetSerialNumber(napi_env env,napi_callback_info info)273 static napi_value NapiGetSerialNumber(napi_env env, napi_callback_info info)
274 {
275 napi_value thisVar = nullptr;
276 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
277 NapiX509CrlEntry *x509CrlEntry = nullptr;
278 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&x509CrlEntry));
279 if (x509CrlEntry == nullptr) {
280 LOGE("x509CrlEntry is nullptr!");
281 return nullptr;
282 }
283 return x509CrlEntry->GetSerialNumber(env, info);
284 }
285
NapiGetCertificateIssuer(napi_env env,napi_callback_info info)286 static napi_value NapiGetCertificateIssuer(napi_env env, napi_callback_info info)
287 {
288 napi_value thisVar = nullptr;
289 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
290 NapiX509CrlEntry *x509CrlEntry = nullptr;
291 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&x509CrlEntry));
292 if (x509CrlEntry == nullptr) {
293 LOGE("x509CrlEntry is nullptr!");
294 return nullptr;
295 }
296 return x509CrlEntry->GetCertificateIssuer(env, info);
297 }
298
NapiGetRevocationDate(napi_env env,napi_callback_info info)299 static napi_value NapiGetRevocationDate(napi_env env, napi_callback_info info)
300 {
301 napi_value thisVar = nullptr;
302 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
303 NapiX509CrlEntry *x509CrlEntry = nullptr;
304 napi_unwrap(env, thisVar, reinterpret_cast<void **>(&x509CrlEntry));
305 if (x509CrlEntry == nullptr) {
306 LOGE("x509CrlEntry is nullptr!");
307 return nullptr;
308 }
309 return x509CrlEntry->GetRevocationDate(env, info);
310 }
311
X509CrlEntryConstructor(napi_env env,napi_callback_info info)312 static napi_value X509CrlEntryConstructor(napi_env env, napi_callback_info info)
313 {
314 napi_value thisVar = nullptr;
315 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
316 return thisVar;
317 }
318
DefineX509CrlEntryJSClass(napi_env env)319 void NapiX509CrlEntry::DefineX509CrlEntryJSClass(napi_env env)
320 {
321 napi_property_descriptor x509CrlEntryDesc[] = {
322 DECLARE_NAPI_FUNCTION("getEncoded", NapiGetEncoded),
323 DECLARE_NAPI_FUNCTION("getSerialNumber", NapiGetSerialNumber),
324 DECLARE_NAPI_FUNCTION("getCertIssuer", NapiGetCertificateIssuer),
325 DECLARE_NAPI_FUNCTION("getRevocationDate", NapiGetRevocationDate),
326 };
327 napi_value constructor = nullptr;
328 napi_define_class(env, "X509CrlEntry", NAPI_AUTO_LENGTH, X509CrlEntryConstructor, nullptr,
329 sizeof(x509CrlEntryDesc) / sizeof(x509CrlEntryDesc[0]), x509CrlEntryDesc, &constructor);
330 napi_create_reference(env, constructor, 1, &classRef_);
331 }
332
CreateX509CrlEntry(napi_env env)333 napi_value NapiX509CrlEntry::CreateX509CrlEntry(napi_env env)
334 {
335 napi_value constructor = nullptr;
336 napi_value instance = nullptr;
337 napi_get_reference_value(env, classRef_, &constructor);
338 napi_new_instance(env, constructor, 0, nullptr, &instance);
339 return instance;
340 }
341 } // namespace CryptoFramework
342 } // namespace OHOS
343