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 "auth_common.h"
17 #include <iremote_broker.h>
18 #include "useridm_hilog_wrapper.h"
19 #include "napi/native_api.h"
20 #include "napi/native_common.h"
21 #include "useridentity_manager.h"
22
23 namespace OHOS {
24 namespace UserIAM {
25 namespace UserIDM {
SaveCallback(napi_env env,size_t argc,napi_value * argv,AsyncCallbackContext * asyncCallbackContext)26 void AuthCommon::SaveCallback(napi_env env, size_t argc, napi_value* argv,
27 AsyncCallbackContext* asyncCallbackContext)
28 {
29 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
30 napi_valuetype valueType;
31 napi_status status = napi_typeof(env, argv[argc], &valueType);
32 if (status != napi_ok) {
33 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_typeof failed");
34 return;
35 }
36 if (valueType == napi_object) {
37 asyncCallbackContext->callbackInfo.env = env;
38 status = napi_get_named_property(env, argv[argc], "onResult",
39 &asyncCallbackContext->idmCallOnResult);
40 if (status != napi_ok) {
41 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_named_property failed");
42 return;
43 }
44 status = napi_create_reference(
45 env, asyncCallbackContext->idmCallOnResult, 1, &asyncCallbackContext->callbackInfo.onResult);
46 if (status != napi_ok) {
47 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_create_reference failed");
48 return;
49 }
50 status = napi_get_named_property(
51 env, argv[argc], "onAcquireInfo", &asyncCallbackContext->idmCallonAcquireInfo);
52 if (status != napi_ok) {
53 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_named_property failed");
54 return;
55 }
56 status = napi_create_reference(
57 env, asyncCallbackContext->idmCallonAcquireInfo, 1, &asyncCallbackContext->callbackInfo.onAcquireInfo);
58 if (status != napi_ok) {
59 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_create_reference failed");
60 return;
61 }
62 } else {
63 USERIDM_HILOGE(MODULE_JS_NAPI, "type mismatch");
64 }
65 }
66
GetNamedProperty(napi_env env,napi_value obj,const std::string & keyStr)67 int32_t AuthCommon::GetNamedProperty(napi_env env, napi_value obj, const std::string &keyStr)
68 {
69 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
70 napi_value value = nullptr;
71 napi_status status = napi_get_named_property(env, obj, keyStr.c_str(), &value);
72 if (status != napi_ok) {
73 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_named_property failed");
74 return 0;
75 }
76 napi_valuetype valueType = napi_undefined;
77 status = napi_typeof(env, value, &valueType);
78 if (status != napi_ok) {
79 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_typeof failed");
80 return 0;
81 }
82 if (valueType != napi_number) {
83 USERIDM_HILOGE(MODULE_JS_NAPI, "valueType not number %{public}d", valueType);
84 return 0;
85 }
86 int32_t property;
87 status = napi_get_value_int32(env, value, &property);
88 if (status != napi_ok) {
89 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_value_int32 failed");
90 return 0;
91 }
92 return property;
93 }
94
GetNamedAttribute(napi_env env,napi_value obj)95 std::vector<uint8_t> AuthCommon::GetNamedAttribute(napi_env env, napi_value obj)
96 {
97 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
98 std::vector<uint8_t> retNull = {0};
99 napi_value token;
100 napi_status status = napi_get_named_property(env, obj, PROPERTY_KEY_EVENT, &token);
101 if (status != napi_ok) {
102 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_named_property failed");
103 return retNull;
104 }
105 napi_typedarray_type arraytype;
106 size_t length = 0;
107 napi_value buffer = nullptr;
108 size_t offset = 0;
109 uint8_t *data = nullptr;
110 bool isTypedArray = false;
111 napi_is_typedarray(env, token, &isTypedArray);
112 if (isTypedArray) {
113 USERIDM_HILOGI(MODULE_JS_NAPI, "token is a array");
114 } else {
115 USERIDM_HILOGE(MODULE_JS_NAPI, "token is not a array");
116 return retNull;
117 }
118 napi_get_typedarray_info(env, token, &arraytype, &length, reinterpret_cast<void **>(&data), &buffer, &offset);
119 if (arraytype == napi_uint8_array) {
120 USERIDM_HILOGI(MODULE_JS_NAPI, "token is uint8 array");
121 } else {
122 USERIDM_HILOGE(MODULE_JS_NAPI, "token is not a uint8 array");
123 return retNull;
124 }
125 if (offset != 0) {
126 USERIDM_HILOGE(MODULE_JS_NAPI, "offset is %{public}zu", offset);
127 return retNull;
128 }
129 std::vector<uint8_t> result(data, data + length);
130 return result;
131 }
132
CreateObject(napi_env env,const std::string & keyStr,uint64_t credentialId)133 napi_value AuthCommon::CreateObject(napi_env env, const std::string& keyStr, uint64_t credentialId)
134 {
135 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
136 napi_value obj;
137 napi_value napiCredentialId = nullptr;
138 NAPI_CALL(env, napi_create_object(env, &obj));
139 if (keyStr.compare(FUNC_ONRESULT) == 0 || keyStr.compare(FUNC_ONACQUIREINFO) == 0) {
140 void* data = nullptr;
141 napi_value arrayBuffer = nullptr;
142 size_t length = sizeof(credentialId);
143 size_t bufferSize = length;
144 NAPI_CALL(env, napi_create_arraybuffer(env, bufferSize, &data, &arrayBuffer));
145 if (memcpy_s(data, bufferSize, reinterpret_cast<const void*>(&credentialId), bufferSize) != EOK) {
146 USERIDM_HILOGE(MODULE_JS_NAPI, "memcpy_s failed");
147 return nullptr;
148 }
149 NAPI_CALL(env, napi_create_typedarray(env, napi_uint8_array, bufferSize, arrayBuffer, 0, &napiCredentialId));
150 }
151 NAPI_CALL(env, napi_set_named_property(env, obj, "credentialId", napiCredentialId));
152 return obj;
153 }
154
JudgeObjectType(napi_env env,napi_callback_info info,AsyncCallbackContext * asyncCallbackContext)155 napi_status AuthCommon::JudgeObjectType (
156 napi_env env, napi_callback_info info, AsyncCallbackContext* asyncCallbackContext)
157 {
158 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
159 size_t argc = TWO_PARAMETER;
160 napi_value argv[TWO_PARAMETER] = {0};
161 napi_status status = napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
162 if (status != napi_ok) {
163 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_cb_info failed");
164 return status;
165 }
166 if (argc != TWO_PARAMETER) {
167 USERIDM_HILOGE(MODULE_JS_NAPI, "get parameter size failed %{public}zu", argc);
168 return napi_invalid_arg;
169 }
170 napi_valuetype valueType = napi_undefined;
171 status = napi_typeof(env, argv[ZERO_PARAMETER], &valueType);
172 if (status != napi_ok) {
173 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_typeof failed");
174 return status;
175 }
176 if (valueType == napi_object) {
177 asyncCallbackContext->authType = static_cast<AuthType>(GetNamedProperty(env, argv[0], PROPERTY_KEY_NAME));
178 asyncCallbackContext->authSubType = static_cast<AuthSubType>(GetNamedProperty(env, argv[0], PROPERTY_KEY_ID));
179 asyncCallbackContext->token = GetNamedAttribute(env, argv[0]);
180 if (asyncCallbackContext->token.empty()) {
181 USERIDM_HILOGE(MODULE_JS_NAPI, "GetNamedAttribute token failed");
182 asyncCallbackContext->token.push_back(0);
183 }
184 }
185 SaveCallback(env, ONE_PARAMETER, argv, asyncCallbackContext);
186 return status;
187 }
188
JudgeDelUserType(napi_env env,napi_callback_info info,AsyncCallbackContext * asyncCallbackContext)189 void AuthCommon::JudgeDelUserType(napi_env env, napi_callback_info info, AsyncCallbackContext* asyncCallbackContext)
190 {
191 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
192 napi_status status;
193 size_t argc = TWO_PARAMETER;
194 napi_value argv[TWO_PARAMETER] = {0};
195 status = napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
196 if (status != napi_ok) {
197 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_cb_info failed");
198 return;
199 }
200 asyncCallbackContext->token = JudgeArryType(env, ZERO_PARAMETER, argv);
201 if (asyncCallbackContext->token.empty()) {
202 USERIDM_HILOGE(MODULE_JS_NAPI, "JudgeArryType token failed");
203 asyncCallbackContext->token.push_back(0);
204 }
205 SaveCallback(env, ONE_PARAMETER, argv, asyncCallbackContext);
206 }
207
JudgeDelCredType(napi_env env,napi_callback_info info,AsyncCallbackContext * asyncCallbackContext)208 void AuthCommon::JudgeDelCredType(napi_env env, napi_callback_info info, AsyncCallbackContext* asyncCallbackContext)
209 {
210 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
211 napi_status status;
212 size_t argc = THREE_PARAMETER;
213 napi_value argv[THREE_PARAMETER] = {0};
214 status = napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
215 if (status != napi_ok) {
216 USERIDM_HILOGE(MODULE_JS_NAPI, "napi_get_cb_info failed");
217 return;
218 }
219 asyncCallbackContext->credentialId = JudgeArryType(env, ZERO_PARAMETER, argv);
220 if (asyncCallbackContext->credentialId.empty()) {
221 USERIDM_HILOGE(MODULE_JS_NAPI, "JudgeArryType credentialId failed");
222 return;
223 }
224 asyncCallbackContext->token = JudgeArryType(env, ONE_PARAMETER, argv);
225 if (asyncCallbackContext->token.empty()) {
226 USERIDM_HILOGE(MODULE_JS_NAPI, "JudgeArryType token failed");
227 return;
228 }
229 SaveCallback(env, TWO_PARAMETER, argv, asyncCallbackContext);
230 }
231
JudgeArryType(napi_env env,size_t argc,napi_value * argv)232 std::vector<uint8_t> AuthCommon::JudgeArryType(napi_env env, size_t argc, napi_value* argv)
233 {
234 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
235 std::vector<uint8_t> retNull = {0};
236 napi_typedarray_type arraytype;
237 size_t length = 0;
238 napi_value buffer = nullptr;
239 size_t offset = 0;
240 uint8_t *data = nullptr;
241 bool isTypedArray = false;
242 napi_is_typedarray(env, argv[argc], &isTypedArray);
243 if (isTypedArray) {
244 USERIDM_HILOGI(MODULE_JS_NAPI, "this is a array");
245 } else {
246 USERIDM_HILOGE(MODULE_JS_NAPI, "this is not a array");
247 return retNull;
248 }
249 napi_get_typedarray_info(env, argv[argc], &arraytype, &length, reinterpret_cast<void **>(&data), &buffer, &offset);
250 if (arraytype == napi_uint8_array) {
251 USERIDM_HILOGI(MODULE_JS_NAPI, "this is a uint8 array");
252 } else {
253 USERIDM_HILOGE(MODULE_JS_NAPI, "this is not a uint8 array");
254 return retNull;
255 }
256 if (offset != 0) {
257 USERIDM_HILOGE(MODULE_JS_NAPI, "offset is %{public}zu", offset);
258 return retNull;
259 }
260 std::vector<uint8_t> result(data, data + length);
261 return result;
262 }
263
GCreateAsyncInfo(napi_env env)264 AsyncGetAuthInfo* GCreateAsyncInfo(napi_env env)
265 {
266 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
267 return new (std::nothrow) AsyncGetAuthInfo {
268 .env = env,
269 .deferred = nullptr,
270 };
271 }
272
OCreateAsyncInfo(napi_env env)273 AsyncOpenSession* OCreateAsyncInfo(napi_env env)
274 {
275 USERIDM_HILOGI(MODULE_JS_NAPI, "%{public}s, start", __func__);
276 return new (std::nothrow) AsyncOpenSession {
277 .env = env,
278 .asyncWork = nullptr,
279 .deferred = nullptr,
280 };
281 }
282 } // UserIDM
283 } // USerIAM
284 } // namespace OHOS
285