1 /*
2 * Copyright (c) 2023-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 "security_manager_addon.h"
17
18 #include "cJSON.h"
19 #include "cjson_check.h"
20 #include "device_settings_proxy.h"
21 #include "edm_constants.h"
22 #include "edm_log.h"
23
24 using namespace OHOS::EDM;
25
26 constexpr int64_t MAX_VALIDITY_PERIOD = 31536000000000; // 60 * 60 * 24 * 365 * 1000 * 1000
27 static const std::string VALIDITY_PERIOD_OUT_OF_RANGE_ERROR = "validityPeriod out of range!";
28
Init(napi_env env,napi_value exports)29 napi_value SecurityManagerAddon::Init(napi_env env, napi_value exports)
30 {
31 napi_value nClipboardPolicy = nullptr;
32 NAPI_CALL(env, napi_create_object(env, &nClipboardPolicy));
33 CreateClipboardPolicyObject(env, nClipboardPolicy);
34 napi_property_descriptor property[] = {
35 DECLARE_NAPI_FUNCTION("getSecurityPatchTag", GetSecurityPatchTag),
36 DECLARE_NAPI_FUNCTION("getDeviceEncryptionStatus", GetDeviceEncryptionStatus),
37 DECLARE_NAPI_FUNCTION("setPasswordPolicy", SetPasswordPolicy),
38 DECLARE_NAPI_FUNCTION("getPasswordPolicy", GetPasswordPolicy),
39 DECLARE_NAPI_FUNCTION("getSecurityStatus", GetSecurityStatus),
40 DECLARE_NAPI_FUNCTION("installUserCertificate", InstallUserCertificate),
41 DECLARE_NAPI_FUNCTION("uninstallUserCertificate", UninstallUserCertificate),
42 DECLARE_NAPI_FUNCTION("setAppClipboardPolicy", SetAppClipboardPolicy),
43 DECLARE_NAPI_FUNCTION("getAppClipboardPolicy", GetAppClipboardPolicy),
44 DECLARE_NAPI_PROPERTY("ClipboardPolicy", nClipboardPolicy),
45 };
46 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
47 return exports;
48 }
49
GetSecurityPatchTag(napi_env env,napi_callback_info info)50 napi_value SecurityManagerAddon::GetSecurityPatchTag(napi_env env, napi_callback_info info)
51 {
52 EDMLOGI("NAPI_GetSecurityPatchTag called");
53 size_t argc = ARGS_SIZE_ONE;
54 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
55 napi_value thisArg = nullptr;
56 void *data = nullptr;
57 OHOS::AppExecFwk::ElementName elementName;
58
59 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
60 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
61 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter type error");
62 bool boolret = ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]);
63 ASSERT_AND_THROW_PARAM_ERROR(env, boolret, "element name param error");
64 EDMLOGD(
65 "EnableAdmin: elementName.bundlename %{public}s, "
66 "elementName.abilityname:%{public}s",
67 elementName.GetBundleName().c_str(),
68 elementName.GetAbilityName().c_str());
69 std::string stringRet;
70 auto securityManagerProxy = SecurityManagerProxy::GetSecurityManagerProxy();
71 int32_t ret = securityManagerProxy->GetSecurityPatchTag(elementName, stringRet);
72 if (FAILED(ret)) {
73 napi_throw(env, CreateError(env, ret));
74 return nullptr;
75 }
76 napi_value securityPatchTag;
77 napi_create_string_utf8(env, stringRet.c_str(), stringRet.size(), &securityPatchTag);
78 return securityPatchTag;
79 }
80
GetDeviceEncryptionStatus(napi_env env,napi_callback_info info)81 napi_value SecurityManagerAddon::GetDeviceEncryptionStatus(napi_env env, napi_callback_info info)
82 {
83 EDMLOGI("NAPI_GetDeviceEncryptionStatus called");
84 size_t argc = ARGS_SIZE_ONE;
85 napi_value argv[ARGS_SIZE_ONE] = { nullptr };
86 napi_value thisArg = nullptr;
87 void* data = nullptr;
88 OHOS::AppExecFwk::ElementName elementName;
89 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
90 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
91 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter type error");
92 bool boolret = ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]);
93 ASSERT_AND_THROW_PARAM_ERROR(env, boolret, "element name param error");
94 EDMLOGD(
95 "EnableAdmin: elementName.bundlename %{public}s, "
96 "elementName.abilityname:%{public}s",
97 elementName.GetBundleName().c_str(),
98 elementName.GetAbilityName().c_str());
99 DeviceEncryptionStatus deviceEncryptionStatus;
100 auto securityManagerProxy = SecurityManagerProxy::GetSecurityManagerProxy();
101 int32_t ret = securityManagerProxy->GetDeviceEncryptionStatus(elementName, deviceEncryptionStatus);
102 if (FAILED(ret)) {
103 napi_throw(env, CreateError(env, ret));
104 return nullptr;
105 }
106 return ConvertDeviceEncryptionStatus(env, deviceEncryptionStatus);
107 }
108
ConvertDeviceEncryptionStatus(napi_env env,DeviceEncryptionStatus & deviceEncryptionStatus)109 napi_value SecurityManagerAddon::ConvertDeviceEncryptionStatus(napi_env env,
110 DeviceEncryptionStatus &deviceEncryptionStatus)
111 {
112 napi_value objDeviceEncryptionStatus = nullptr;
113 napi_create_object(env, &objDeviceEncryptionStatus);
114 napi_value nIsEncrypted;
115 napi_get_boolean(env, deviceEncryptionStatus.isEncrypted, &nIsEncrypted);
116 napi_set_named_property(env, objDeviceEncryptionStatus, "isEncrypted", nIsEncrypted);
117 return objDeviceEncryptionStatus;
118 }
119
SetPasswordPolicy(napi_env env,napi_callback_info info)120 napi_value SecurityManagerAddon::SetPasswordPolicy(napi_env env, napi_callback_info info)
121 {
122 EDMLOGI("NAPI_SetPasswordPolicy called");
123 size_t argc = ARGS_SIZE_TWO;
124 napi_value argv[ARGS_SIZE_TWO] = { nullptr };
125 napi_value thisArg = nullptr;
126 void* data = nullptr;
127 OHOS::AppExecFwk::ElementName elementName;
128 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
129 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
130 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "admin type error");
131 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object),
132 "passwordPolicy type error");
133
134 PasswordPolicy policy;
135 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
136 "Parameter admin error");
137 ASSERT_AND_THROW_PARAM_ERROR(env,
138 JsObjectToString(env, argv[ARR_INDEX_ONE], "complexityRegex", false, policy.complexityReg),
139 "Parameter passwordPolicy error");
140 ASSERT_AND_THROW_PARAM_ERROR(env,
141 JsObjectToLong(env, argv[ARR_INDEX_ONE], "validityPeriod", false, policy.validityPeriod),
142 "Parameter passwordPolicy error");
143 if (policy.validityPeriod > MAX_VALIDITY_PERIOD || policy.validityPeriod < 0) {
144 napi_throw(env, CreateError(env, EdmReturnErrCode::PARAM_ERROR, VALIDITY_PERIOD_OUT_OF_RANGE_ERROR));
145 return nullptr;
146 }
147 ASSERT_AND_THROW_PARAM_ERROR(env,
148 JsObjectToString(env, argv[ARR_INDEX_ONE], "additionalDescription", false, policy.additionalDescription),
149 "Parameter passwordPolicy error");
150 int32_t retCode = SecurityManagerProxy::GetSecurityManagerProxy()->SetPasswordPolicy(elementName, policy);
151 if (FAILED(retCode)) {
152 napi_throw(env, CreateError(env, retCode));
153 }
154 return nullptr;
155 }
156
GetPasswordPolicy(napi_env env,napi_callback_info info)157 napi_value SecurityManagerAddon::GetPasswordPolicy(napi_env env, napi_callback_info info)
158 {
159 EDMLOGI("NAPI_GetPasswordPolicy called");
160 size_t argc = ARGS_SIZE_ONE;
161 napi_value argv[ARGS_SIZE_ONE] = { nullptr };
162 napi_value thisArg = nullptr;
163 void* data = nullptr;
164 OHOS::AppExecFwk::ElementName elementName;
165 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
166
167 PasswordPolicy policy;
168 int32_t retCode = EdmReturnErrCode::SYSTEM_ABNORMALLY;
169 if (argc >= ARGS_SIZE_ONE) {
170 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "admin type error");
171 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
172 "Parameter admin error");
173 retCode = SecurityManagerProxy::GetSecurityManagerProxy()->GetPasswordPolicy(elementName, policy);
174 } else {
175 retCode = SecurityManagerProxy::GetSecurityManagerProxy()->GetPasswordPolicy(policy);
176 }
177
178 if (FAILED(retCode)) {
179 napi_throw(env, CreateError(env, retCode));
180 return nullptr;
181 }
182 napi_value ret;
183 napi_value complexityReg;
184 napi_value validityPeriod;
185 napi_value additionalDescription;
186 napi_create_object(env, &ret);
187 napi_create_string_utf8(env, policy.complexityReg.c_str(), NAPI_AUTO_LENGTH, &complexityReg);
188 napi_create_int64(env, policy.validityPeriod, &validityPeriod);
189 napi_create_string_utf8(env, policy.additionalDescription.c_str(), NAPI_AUTO_LENGTH, &additionalDescription);
190 napi_set_named_property(env, ret, "complexityRegex", complexityReg);
191 napi_set_named_property(env, ret, "validityPeriod", validityPeriod);
192 napi_set_named_property(env, ret, "additionalDescription", additionalDescription);
193 return ret;
194 }
195
GetSecurityStatus(napi_env env,napi_callback_info info)196 napi_value SecurityManagerAddon::GetSecurityStatus(napi_env env, napi_callback_info info)
197 {
198 EDMLOGI("NAPI_GetSecurityStatus called");
199 size_t argc = ARGS_SIZE_TWO;
200 napi_value argv[ARGS_SIZE_TWO] = { nullptr };
201 napi_value thisArg = nullptr;
202 void* data = nullptr;
203 OHOS::AppExecFwk::ElementName elementName;
204 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
205 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
206 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter type error");
207 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string),
208 "The second parameter must be string.");
209 bool boolret = ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]);
210 ASSERT_AND_THROW_PARAM_ERROR(env, boolret, "element name param error");
211 EDMLOGD(
212 "EnableAdmin: elementName.bundlename %{public}s, "
213 "elementName.abilityname:%{public}s",
214 elementName.GetBundleName().c_str(),
215 elementName.GetAbilityName().c_str());
216 std::string item;
217 boolret = ParseString(env, item, argv[ARR_INDEX_ONE]);
218 ASSERT_AND_THROW_PARAM_ERROR(env, boolret, "param 'item' parse error");
219 std::string stringRet;
220 auto securityManagerProxy = SecurityManagerProxy::GetSecurityManagerProxy();
221 int32_t ret = ERR_OK;
222 if (item == EdmConstants::SecurityManager::PATCH) {
223 ret = securityManagerProxy->GetSecurityPatchTag(elementName, stringRet);
224 } else if (item == EdmConstants::SecurityManager::ENCRYPTION) {
225 DeviceEncryptionStatus deviceEncryptionStatus;
226 ret = securityManagerProxy->GetDeviceEncryptionStatus(elementName, deviceEncryptionStatus);
227 if (SUCCEEDED(ret)) {
228 ret = ConvertDeviceEncryptionToJson(env, deviceEncryptionStatus, stringRet);
229 }
230 } else if (item == EdmConstants::SecurityManager::ROOT) {
231 ret = securityManagerProxy->GetRootCheckStatus(elementName, stringRet);
232 } else {
233 ret = EdmReturnErrCode::INTERFACE_UNSUPPORTED;
234 }
235 if (FAILED(ret)) {
236 napi_throw(env, CreateError(env, ret));
237 return nullptr;
238 }
239 napi_value status;
240 napi_create_string_utf8(env, stringRet.c_str(), stringRet.size(), &status);
241 return status;
242 }
243
ConvertDeviceEncryptionToJson(napi_env env,DeviceEncryptionStatus & deviceEncryptionStatus,std::string & stringRet)244 int32_t SecurityManagerAddon::ConvertDeviceEncryptionToJson(napi_env env,
245 DeviceEncryptionStatus &deviceEncryptionStatus, std::string &stringRet)
246 {
247 cJSON *json = nullptr;
248 CJSON_CREATE_OBJECT_AND_CHECK(json, EdmReturnErrCode::SYSTEM_ABNORMALLY);
249 cJSON_AddBoolToObject(json, "isEncrypted", deviceEncryptionStatus.isEncrypted);
250 char *jsonStr = cJSON_PrintUnformatted(json);
251 if (jsonStr == nullptr) {
252 cJSON_Delete(json);
253 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
254 }
255 stringRet = std::string(jsonStr);
256 cJSON_Delete(json);
257 cJSON_free(jsonStr);
258 return ERR_OK;
259 }
260
InstallUserCertificate(napi_env env,napi_callback_info info)261 napi_value SecurityManagerAddon::InstallUserCertificate(napi_env env, napi_callback_info info)
262 {
263 EDMLOGI("NAPI_InstallUserCertificate called");
264 size_t argc = ARGS_SIZE_THREE;
265 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
266 napi_value thisArg = nullptr;
267 void *data = nullptr;
268 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
269 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
270 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
271 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter want error");
272 matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
273 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter certblob error");
274 auto asyncCallbackInfo = new (std::nothrow) AsyncCertCallbackInfo();
275 if (asyncCallbackInfo == nullptr) {
276 return nullptr;
277 }
278 std::unique_ptr<AsyncCertCallbackInfo> callbackPtr{asyncCallbackInfo};
279 bool retAdmin = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
280 ASSERT_AND_THROW_PARAM_ERROR(env, retAdmin, "element name param error");
281 EDMLOGD(
282 "InstallUserCertificate: asyncCallbackInfo->elementName.bundlename %{public}s, "
283 "asyncCallbackInfo->abilityname:%{public}s",
284 asyncCallbackInfo->elementName.GetBundleName().c_str(),
285 asyncCallbackInfo->elementName.GetAbilityName().c_str());
286
287 bool retCertBlob = ParseCertBlob(env, argv[ARR_INDEX_ONE], asyncCallbackInfo);
288 ASSERT_AND_THROW_PARAM_ERROR(env, retCertBlob, "element cert blob error");
289
290 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "InstallUserCertificate",
291 NativeInstallUserCertificate, NativeStringCallbackComplete);
292 callbackPtr.release();
293 return asyncWorkReturn;
294 }
295
NativeInstallUserCertificate(napi_env env,void * data)296 void SecurityManagerAddon::NativeInstallUserCertificate(napi_env env, void *data)
297 {
298 EDMLOGI("NAPI_NativeInstallUserCertificate called");
299 if (data == nullptr) {
300 EDMLOGE("data is nullptr");
301 return;
302 }
303 AsyncCertCallbackInfo *asyncCallbackInfo = static_cast<AsyncCertCallbackInfo *>(data);
304 asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->InstallUserCertificate(
305 asyncCallbackInfo->elementName, asyncCallbackInfo->certArray, asyncCallbackInfo->alias,
306 asyncCallbackInfo->stringRet, asyncCallbackInfo->innerCodeMsg);
307 }
308
UninstallUserCertificate(napi_env env,napi_callback_info info)309 napi_value SecurityManagerAddon::UninstallUserCertificate(napi_env env, napi_callback_info info)
310 {
311 EDMLOGI("NAPI_UninstallUserCertificate called");
312 size_t argc = ARGS_SIZE_THREE;
313 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
314 napi_value thisArg = nullptr;
315 void *data = nullptr;
316 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
317 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
318 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
319 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter want error");
320 matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
321 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter uri error");
322 auto asyncCallbackInfo = new (std::nothrow) AsyncCertCallbackInfo();
323 if (asyncCallbackInfo == nullptr) {
324 return nullptr;
325 }
326 std::unique_ptr<AsyncCertCallbackInfo> callbackPtr{asyncCallbackInfo};
327 bool retAdmin = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
328 ASSERT_AND_THROW_PARAM_ERROR(env, retAdmin, "element name param error");
329 EDMLOGD(
330 "UninstallUserCertificate: asyncCallbackInfo->elementName.bundlename %{public}s, "
331 "asyncCallbackInfo->abilityname:%{public}s",
332 asyncCallbackInfo->elementName.GetBundleName().c_str(),
333 asyncCallbackInfo->elementName.GetAbilityName().c_str());
334
335 bool retAlias = ParseString(env, asyncCallbackInfo->alias, argv[ARR_INDEX_ONE]);
336 ASSERT_AND_THROW_PARAM_ERROR(env, retAlias, "element alias error");
337
338 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "uninstallUserCertificate",
339 NativeUninstallUserCertificate, NativeVoidCallbackComplete);
340 callbackPtr.release();
341 return asyncWorkReturn;
342 }
343
NativeUninstallUserCertificate(napi_env env,void * data)344 void SecurityManagerAddon::NativeUninstallUserCertificate(napi_env env, void *data)
345 {
346 EDMLOGI("NAPI_NativeUninstallUserCertificate called");
347 if (data == nullptr) {
348 EDMLOGE("data is nullptr");
349 return;
350 }
351 AsyncCertCallbackInfo *asyncCallbackInfo = static_cast<AsyncCertCallbackInfo *>(data);
352 asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->UninstallUserCertificate(
353 asyncCallbackInfo->elementName, asyncCallbackInfo->alias, asyncCallbackInfo->innerCodeMsg);
354 }
355
ParseCertBlob(napi_env env,napi_value object,AsyncCertCallbackInfo * asyncCertCallbackInfo)356 bool SecurityManagerAddon::ParseCertBlob(napi_env env, napi_value object, AsyncCertCallbackInfo *asyncCertCallbackInfo)
357 {
358 napi_valuetype type = napi_undefined;
359 NAPI_CALL_BASE(env, napi_typeof(env, object, &type), false);
360 if (type != napi_object) {
361 EDMLOGE("type of param certblob is not object");
362 return false;
363 }
364 if (!JsObjectToU8Vector(env, object, "inData", asyncCertCallbackInfo->certArray)) {
365 EDMLOGE("uint8Array to vector failed");
366 return false;
367 }
368 return JsObjectToString(env, object, "alias", true, asyncCertCallbackInfo->alias);
369 }
370
SetAppClipboardPolicy(napi_env env,napi_callback_info info)371 napi_value SecurityManagerAddon::SetAppClipboardPolicy(napi_env env, napi_callback_info info)
372 {
373 EDMLOGI("NAPI_SetAppClipboardPolicy called");
374 size_t argc = ARGS_SIZE_THREE;
375 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
376 napi_value thisArg = nullptr;
377 void *data = nullptr;
378 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
379 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
380 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "admin type error");
381 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "tokenId type error");
382 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
383 "clipboardPolicy type error");
384
385 OHOS::AppExecFwk::ElementName elementName;
386 int32_t tokenId = 0;
387 int32_t policy = 0;
388 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
389 "Parameter admin error");
390 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, tokenId, argv[ARR_INDEX_ONE]),
391 "Parameter tokenId error");
392 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, policy, argv[ARR_INDEX_TWO]),
393 "Parameter clipboardPolicy error");
394 int32_t retCode =
395 SecurityManagerProxy::GetSecurityManagerProxy()->SetAppClipboardPolicy(elementName, tokenId, policy);
396 if (FAILED(retCode)) {
397 napi_throw(env, CreateError(env, retCode));
398 }
399 return nullptr;
400 }
401
GetAppClipboardPolicy(napi_env env,napi_callback_info info)402 napi_value SecurityManagerAddon::GetAppClipboardPolicy(napi_env env, napi_callback_info info)
403 {
404 EDMLOGI("NAPI_GetAppClipboardPolicy called");
405 size_t argc = ARGS_SIZE_TWO;
406 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
407 napi_value thisArg = nullptr;
408 void *data = nullptr;
409 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
410 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
411 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "admin type error");
412
413 OHOS::AppExecFwk::ElementName elementName;
414 int32_t tokenId = 0;
415 std::string policy;
416 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
417 "Parameter admin error");
418
419 if (argc > ARGS_SIZE_ONE) {
420 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "tokenId type error");
421 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, tokenId, argv[ARR_INDEX_ONE]),
422 "Parameter tokenId error");
423 }
424 int32_t retCode =
425 SecurityManagerProxy::GetSecurityManagerProxy()->GetAppClipboardPolicy(elementName, tokenId, policy);
426 if (FAILED(retCode)) {
427 napi_throw(env, CreateError(env, retCode));
428 return nullptr;
429 }
430 napi_value clipboardPolicy;
431 napi_create_string_utf8(env, policy.c_str(), NAPI_AUTO_LENGTH, &clipboardPolicy);
432 return clipboardPolicy;
433 }
434
CreateClipboardPolicyObject(napi_env env,napi_value value)435 void SecurityManagerAddon::CreateClipboardPolicyObject(napi_env env, napi_value value)
436 {
437 napi_value nDefault;
438 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(ClipboardPolicy::DEFAULT), &nDefault));
439 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DEFAULT", nDefault));
440 napi_value nInApp;
441 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(ClipboardPolicy::IN_APP), &nInApp));
442 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "IN_APP", nInApp));
443 napi_value nLocalDevice;
444 NAPI_CALL_RETURN_VOID(env,
445 napi_create_int32(env, static_cast<int32_t>(ClipboardPolicy::LOCAL_DEVICE), &nLocalDevice));
446 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "LOCAL_DEVICE", nLocalDevice));
447 napi_value nCrossDevice;
448 NAPI_CALL_RETURN_VOID(env,
449 napi_create_int32(env, static_cast<int32_t>(ClipboardPolicy::CROSS_DEVICE), &nCrossDevice));
450 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "CROSS_DEVICE", nCrossDevice));
451 }
452
453 static napi_module g_securityModule = {
454 .nm_version = 1,
455 .nm_flags = 0,
456 .nm_filename = nullptr,
457 .nm_register_func = SecurityManagerAddon::Init,
458 .nm_modname = "enterprise.securityManager",
459 .nm_priv = ((void *)0),
460 .reserved = {0},
461 };
462
SecurityManagerRegister()463 extern "C" __attribute__((constructor)) void SecurityManagerRegister()
464 {
465 napi_module_register(&g_securityModule);
466 }
467