1 /*
2 * Copyright (c) 2022-2023 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 "privacy_manager_stub.h"
17
18 #include "accesstoken_kit.h"
19 #include "accesstoken_common_log.h"
20 #include "ipc_skeleton.h"
21 #include "memory_guard.h"
22 #include "on_permission_used_record_callback_proxy.h"
23 #include "privacy_error.h"
24 #include "privacy_manager_proxy_death_param.h"
25 #include "string_ex.h"
26 #include "tokenid_kit.h"
27
28 namespace OHOS {
29 namespace Security {
30 namespace AccessToken {
31 namespace {
32 static const uint32_t PERM_LIST_SIZE_MAX = 1024;
33 constexpr const char* PERMISSION_USED_STATS = "ohos.permission.PERMISSION_USED_STATS";
34 constexpr const char* PERMISSION_RECORD_TOGGLE = "ohos.permission.PERMISSION_RECORD_TOGGLE";
35 constexpr const char* SET_FOREGROUND_HAP_REMINDER = "ohos.permission.SET_FOREGROUND_HAP_REMINDER";
36 constexpr const char* SET_MUTE_POLICY = "ohos.permission.SET_MUTE_POLICY";
37 }
38
PrivacyManagerStub()39 PrivacyManagerStub::PrivacyManagerStub()
40 {
41 SetPrivacyFuncInMap();
42 }
43
SetPrivacyFuncInMap()44 void PrivacyManagerStub::SetPrivacyFuncInMap()
45 {
46 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::ADD_PERMISSION_USED_RECORD)] =
47 &PrivacyManagerStub::AddPermissionUsedRecordInner;
48 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::START_USING_PERMISSION)] =
49 &PrivacyManagerStub::StartUsingPermissionInner;
50 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::START_USING_PERMISSION_CALLBACK)] =
51 &PrivacyManagerStub::StartUsingPermissionCallbackInner;
52 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::STOP_USING_PERMISSION)] =
53 &PrivacyManagerStub::StopUsingPermissionInner;
54 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::DELETE_PERMISSION_USED_RECORDS)] =
55 &PrivacyManagerStub::RemovePermissionUsedRecordsInner;
56 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::GET_PERMISSION_USED_RECORDS)] =
57 &PrivacyManagerStub::GetPermissionUsedRecordsInner;
58 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::GET_PERMISSION_USED_RECORDS_ASYNC)] =
59 &PrivacyManagerStub::GetPermissionUsedRecordsAsyncInner;
60 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::REGISTER_PERM_ACTIVE_STATUS_CHANGE_CALLBACK)] =
61 &PrivacyManagerStub::RegisterPermActiveStatusCallbackInner;
62 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::UNREGISTER_PERM_ACTIVE_STATUS_CHANGE_CALLBACK)] =
63 &PrivacyManagerStub::UnRegisterPermActiveStatusCallbackInner;
64 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::IS_ALLOWED_USING_PERMISSION)] =
65 &PrivacyManagerStub::IsAllowedUsingPermissionInner;
66 #ifdef SECURITY_COMPONENT_ENHANCE_ENABLE
67 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::REGISTER_SEC_COMP_ENHANCE)] =
68 &PrivacyManagerStub::RegisterSecCompEnhanceInner;
69 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::UPDATE_SEC_COMP_ENHANCE)] =
70 &PrivacyManagerStub::UpdateSecCompEnhanceInner;
71 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::GET_SEC_COMP_ENHANCE)] =
72 &PrivacyManagerStub::GetSecCompEnhanceInner;
73 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::GET_SPECIAL_SEC_COMP_ENHANCE)] =
74 &PrivacyManagerStub::GetSpecialSecCompEnhanceInner;
75 #endif
76 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::GET_PERMISSION_USED_TYPE_INFOS)] =
77 &PrivacyManagerStub::GetPermissionUsedTypeInfosInner;
78 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::SET_MUTE_POLICY)] =
79 &PrivacyManagerStub::SetMutePolicyInner;
80 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::SET_HAP_WITH_FOREGROUND_REMINDER)] =
81 &PrivacyManagerStub::SetHapWithFGReminderInner;
82 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::SET_PERMISSION_USED_RECORD_TOGGLE_STATUS)] =
83 &PrivacyManagerStub::SetPermissionUsedRecordToggleStatusInner;
84 requestMap_[static_cast<uint32_t>(PrivacyInterfaceCode::GET_PERMISSION_USED_RECORD_TOGGLE_STATUS)] =
85 &PrivacyManagerStub::GetPermissionUsedRecordToggleStatusInner;
86 }
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)87 int32_t PrivacyManagerStub::OnRemoteRequest(
88 uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
89 {
90 MemoryGuard cacheGuard;
91 std::u16string descriptor = data.ReadInterfaceToken();
92 if (descriptor != IPrivacyManager::GetDescriptor()) {
93 LOGE(PRI_DOMAIN, PRI_TAG, "Get unexpect descriptor: %{public}s", Str16ToStr8(descriptor).c_str());
94 return ERROR_IPC_REQUEST_FAIL;
95 }
96
97 auto itFunc = requestMap_.find(code);
98 if (itFunc != requestMap_.end()) {
99 auto requestFunc = itFunc->second;
100 if (requestFunc != nullptr) {
101 (this->*requestFunc)(data, reply);
102 return NO_ERROR;
103 }
104 }
105
106 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
107 }
108
AddPermissionUsedRecordInner(MessageParcel & data,MessageParcel & reply)109 void PrivacyManagerStub::AddPermissionUsedRecordInner(MessageParcel& data, MessageParcel& reply)
110 {
111 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
112 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
113 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
114 return;
115 }
116 if (!VerifyPermission(PERMISSION_USED_STATS)) {
117 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
118 return;
119 }
120 sptr<AddPermParamInfoParcel> infoParcel = data.ReadParcelable<AddPermParamInfoParcel>();
121 if (infoParcel == nullptr) {
122 LOGE(PRI_DOMAIN, PRI_TAG, "ReadParcelable faild");
123 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
124 return;
125 }
126 reply.WriteInt32(this->AddPermissionUsedRecord(*infoParcel));
127 }
128
SetPermissionUsedRecordToggleStatusInner(MessageParcel & data,MessageParcel & reply)129 void PrivacyManagerStub::SetPermissionUsedRecordToggleStatusInner(MessageParcel& data, MessageParcel& reply)
130 {
131 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
132 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
133 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
134 return;
135 }
136 if (!IsPrivilegedCalling() && !VerifyPermission(PERMISSION_RECORD_TOGGLE)) {
137 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
138 return;
139 }
140 int32_t userID = 0;
141 if (!data.ReadInt32(userID)) {
142 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read userId.");
143 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
144 return;
145 }
146 if (userID != 0 && !IsPrivilegedCalling()) {
147 LOGE(PRI_DOMAIN, PRI_TAG, "User version only get calling userID.");
148 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
149 return;
150 }
151 bool status = true;
152 if (!data.ReadBool(status)) {
153 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read status.");
154 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
155 return;
156 }
157 reply.WriteInt32(this->SetPermissionUsedRecordToggleStatus(userID, status));
158 }
159
GetPermissionUsedRecordToggleStatusInner(MessageParcel & data,MessageParcel & reply)160 void PrivacyManagerStub::GetPermissionUsedRecordToggleStatusInner(MessageParcel& data, MessageParcel& reply)
161 {
162 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
163 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
164 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
165 return;
166 }
167 if (!IsPrivilegedCalling() && !VerifyPermission(PERMISSION_USED_STATS)) {
168 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
169 return;
170 }
171 int32_t userID = 0;
172 if (!data.ReadInt32(userID)) {
173 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read userId.");
174 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
175 return;
176 }
177 if (userID != 0 && !IsPrivilegedCalling()) {
178 LOGE(PRI_DOMAIN, PRI_TAG, "User version only get calling userID.");
179 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
180 return;
181 }
182 bool status = true;
183 reply.WriteInt32(this->GetPermissionUsedRecordToggleStatus(userID, status));
184 reply.WriteBool(status);
185 }
186
StartUsingPermissionInner(MessageParcel & data,MessageParcel & reply)187 void PrivacyManagerStub::StartUsingPermissionInner(MessageParcel& data, MessageParcel& reply)
188 {
189 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
190 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
191 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
192 return;
193 }
194 if (!VerifyPermission(PERMISSION_USED_STATS)) {
195 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
196 return;
197 }
198 sptr<PermissionUsedTypeInfoParcel> info = data.ReadParcelable<PermissionUsedTypeInfoParcel>();
199 if (info == nullptr) {
200 LOGE(PRI_DOMAIN, PRI_TAG, "Read parcel fail.");
201 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
202 return;
203 }
204 sptr<IRemoteObject> anonyStub = data.ReadRemoteObject();
205 if (anonyStub == nullptr) {
206 LOGE(PRI_DOMAIN, PRI_TAG, "Read ReadRemoteObject fail.");
207 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
208 return;
209 }
210 reply.WriteInt32(this->StartUsingPermission(*info, anonyStub));
211 }
212
StartUsingPermissionCallbackInner(MessageParcel & data,MessageParcel & reply)213 void PrivacyManagerStub::StartUsingPermissionCallbackInner(MessageParcel& data, MessageParcel& reply)
214 {
215 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
216 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
217 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
218 return;
219 }
220
221 if (!VerifyPermission(PERMISSION_USED_STATS)) {
222 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
223 return;
224 }
225 sptr<PermissionUsedTypeInfoParcel> info = data.ReadParcelable<PermissionUsedTypeInfoParcel>();
226 if (info == nullptr) {
227 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
228 return;
229 }
230 sptr<IRemoteObject> callback = data.ReadRemoteObject();
231 if (callback == nullptr) {
232 LOGE(PRI_DOMAIN, PRI_TAG, "Read ReadRemoteObject fail");
233 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
234 return;
235 }
236 sptr<IRemoteObject> anonyStub = data.ReadRemoteObject();
237 if (anonyStub == nullptr) {
238 LOGE(PRI_DOMAIN, PRI_TAG, "Read ReadRemoteObject fail.");
239 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
240 return;
241 }
242 reply.WriteInt32(this->StartUsingPermission(*info, callback, anonyStub));
243 }
244
StopUsingPermissionInner(MessageParcel & data,MessageParcel & reply)245 void PrivacyManagerStub::StopUsingPermissionInner(MessageParcel& data, MessageParcel& reply)
246 {
247 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
248 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
249 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
250 return;
251 }
252 if (!VerifyPermission(PERMISSION_USED_STATS)) {
253 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
254 return;
255 }
256 AccessTokenID tokenId = data.ReadUint32();
257 int32_t pid = data.ReadInt32();
258 std::string permissionName = data.ReadString();
259 reply.WriteInt32(this->StopUsingPermission(tokenId, pid, permissionName));
260 }
261
RemovePermissionUsedRecordsInner(MessageParcel & data,MessageParcel & reply)262 void PrivacyManagerStub::RemovePermissionUsedRecordsInner(MessageParcel& data, MessageParcel& reply)
263 {
264 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
265 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
266 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
267 return;
268 }
269
270 if (!IsAccessTokenCalling() && !VerifyPermission(PERMISSION_USED_STATS)) {
271 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
272 return;
273 }
274
275 AccessTokenID tokenId = data.ReadUint32();
276 reply.WriteInt32(this->RemovePermissionUsedRecords(tokenId));
277 }
278
GetPermissionUsedRecordsInner(MessageParcel & data,MessageParcel & reply)279 void PrivacyManagerStub::GetPermissionUsedRecordsInner(MessageParcel& data, MessageParcel& reply)
280 {
281 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
282 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
283 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
284 return;
285 }
286 PermissionUsedResultParcel responseParcel;
287 if (!VerifyPermission(PERMISSION_USED_STATS)) {
288 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
289 return;
290 }
291 sptr<PermissionUsedRequestParcel> requestParcel = data.ReadParcelable<PermissionUsedRequestParcel>();
292 if (requestParcel == nullptr) {
293 LOGE(PRI_DOMAIN, PRI_TAG, "ReadParcelable faild");
294 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
295 return;
296 }
297 int32_t result = this->GetPermissionUsedRecords(*requestParcel, responseParcel);
298 reply.WriteInt32(result);
299 if (result != RET_SUCCESS) {
300 LOGE(PRI_DOMAIN, PRI_TAG, "WriteInt32 faild");
301 return;
302 }
303 reply.WriteParcelable(&responseParcel);
304 }
305
GetPermissionUsedRecordsAsyncInner(MessageParcel & data,MessageParcel & reply)306 void PrivacyManagerStub::GetPermissionUsedRecordsAsyncInner(MessageParcel& data, MessageParcel& reply)
307 {
308 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
309 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
310 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
311 return;
312 }
313
314 if (!VerifyPermission(PERMISSION_USED_STATS)) {
315 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
316 return;
317 }
318 sptr<PermissionUsedRequestParcel> requestParcel = data.ReadParcelable<PermissionUsedRequestParcel>();
319 if (requestParcel == nullptr) {
320 LOGE(PRI_DOMAIN, PRI_TAG, "ReadParcelable failed");
321 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
322 return;
323 }
324 sptr<OnPermissionUsedRecordCallback> callback = new OnPermissionUsedRecordCallbackProxy(data.ReadRemoteObject());
325 if (callback == nullptr) {
326 LOGE(PRI_DOMAIN, PRI_TAG, "Callback is null");
327 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
328 return;
329 }
330 reply.WriteInt32(this->GetPermissionUsedRecords(*requestParcel, callback));
331 }
332
RegisterPermActiveStatusCallbackInner(MessageParcel & data,MessageParcel & reply)333 void PrivacyManagerStub::RegisterPermActiveStatusCallbackInner(MessageParcel& data, MessageParcel& reply)
334 {
335 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
336 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
337 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
338 return;
339 }
340 if (!VerifyPermission(PERMISSION_USED_STATS)) {
341 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
342 return;
343 }
344 uint32_t permListSize = data.ReadUint32();
345 if (permListSize > PERM_LIST_SIZE_MAX) {
346 LOGE(PRI_DOMAIN, PRI_TAG, "Read permListSize fail");
347 reply.WriteInt32(PrivacyError::ERR_OVERSIZE);
348 return;
349 }
350 std::vector<std::string> permList;
351 for (uint32_t i = 0; i < permListSize; i++) {
352 std::string perm = data.ReadString();
353 permList.emplace_back(perm);
354 }
355 sptr<IRemoteObject> callback = data.ReadRemoteObject();
356 if (callback == nullptr) {
357 LOGE(PRI_DOMAIN, PRI_TAG, "Read ReadRemoteObject fail");
358 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
359 return;
360 }
361 reply.WriteInt32(this->RegisterPermActiveStatusCallback(permList, callback));
362 }
363
UnRegisterPermActiveStatusCallbackInner(MessageParcel & data,MessageParcel & reply)364 void PrivacyManagerStub::UnRegisterPermActiveStatusCallbackInner(MessageParcel& data, MessageParcel& reply)
365 {
366 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
367 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
368 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
369 return;
370 }
371 if (!VerifyPermission(PERMISSION_USED_STATS)) {
372 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
373 return;
374 }
375 sptr<IRemoteObject> callback = data.ReadRemoteObject();
376 if (callback == nullptr) {
377 LOGE(PRI_DOMAIN, PRI_TAG, "Read scopeParcel fail");
378 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
379 return;
380 }
381 reply.WriteInt32(this->UnRegisterPermActiveStatusCallback(callback));
382 }
383
IsAllowedUsingPermissionInner(MessageParcel & data,MessageParcel & reply)384 void PrivacyManagerStub::IsAllowedUsingPermissionInner(MessageParcel& data, MessageParcel& reply)
385 {
386 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
387 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
388 LOGE(PRI_DOMAIN, PRI_TAG, "Permission denied(tokenID=%{public}d)", callingTokenID);
389 reply.WriteBool(false);
390 return;
391 }
392
393 if (!VerifyPermission(PERMISSION_USED_STATS)) {
394 reply.WriteBool(false);
395 return;
396 }
397
398 AccessTokenID tokenId = data.ReadUint32();
399 std::string permissionName = data.ReadString();
400 int32_t pid = data.ReadInt32();
401
402 bool result = this->IsAllowedUsingPermission(tokenId, permissionName, pid);
403 if (!reply.WriteBool(result)) {
404 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteBool(%{public}s)", permissionName.c_str());
405 reply.WriteBool(false);
406 return;
407 }
408 }
409
410 #ifdef SECURITY_COMPONENT_ENHANCE_ENABLE
RegisterSecCompEnhanceInner(MessageParcel & data,MessageParcel & reply)411 void PrivacyManagerStub::RegisterSecCompEnhanceInner(MessageParcel& data, MessageParcel& reply)
412 {
413 sptr<SecCompEnhanceDataParcel> requestParcel = data.ReadParcelable<SecCompEnhanceDataParcel>();
414 if (requestParcel == nullptr) {
415 LOGE(PRI_DOMAIN, PRI_TAG, "ReadParcelable faild");
416 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
417 return;
418 }
419 reply.WriteInt32(this->RegisterSecCompEnhance(*requestParcel));
420 }
421
UpdateSecCompEnhanceInner(MessageParcel & data,MessageParcel & reply)422 void PrivacyManagerStub::UpdateSecCompEnhanceInner(MessageParcel& data, MessageParcel& reply)
423 {
424 if (!IsSecCompServiceCalling()) {
425 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
426 return;
427 }
428
429 int32_t pid = data.ReadInt32();
430 uint32_t seqNum = data.ReadUint32();
431 reply.WriteInt32(this->UpdateSecCompEnhance(pid, seqNum));
432 }
433
GetSecCompEnhanceInner(MessageParcel & data,MessageParcel & reply)434 void PrivacyManagerStub::GetSecCompEnhanceInner(MessageParcel& data, MessageParcel& reply)
435 {
436 if (!IsSecCompServiceCalling()) {
437 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
438 return;
439 }
440
441 int32_t pid = data.ReadInt32();
442 SecCompEnhanceDataParcel parcel;
443 int32_t result = this->GetSecCompEnhance(pid, parcel);
444 reply.WriteInt32(result);
445 if (result != RET_SUCCESS) {
446 return;
447 }
448
449 reply.WriteParcelable(&parcel);
450 }
451
GetSpecialSecCompEnhanceInner(MessageParcel & data,MessageParcel & reply)452 void PrivacyManagerStub::GetSpecialSecCompEnhanceInner(MessageParcel& data, MessageParcel& reply)
453 {
454 if (!IsSecCompServiceCalling()) {
455 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
456 return;
457 }
458
459 std::string bundleName = data.ReadString();
460 std::vector<SecCompEnhanceDataParcel> parcelList;
461 int32_t result = this->GetSpecialSecCompEnhance(bundleName, parcelList);
462 reply.WriteInt32(result);
463 if (result != RET_SUCCESS) {
464 return;
465 }
466 reply.WriteUint32(parcelList.size());
467 for (const auto& parcel : parcelList) {
468 reply.WriteParcelable(&parcel);
469 }
470 }
471
IsSecCompServiceCalling()472 bool PrivacyManagerStub::IsSecCompServiceCalling()
473 {
474 uint32_t tokenCaller = IPCSkeleton::GetCallingTokenID();
475 if (secCompTokenId_ == 0) {
476 secCompTokenId_ = AccessTokenKit::GetNativeTokenId("security_component_service");
477 }
478 return tokenCaller == secCompTokenId_;
479 }
480 #endif
481
GetPermissionUsedTypeInfosInner(MessageParcel & data,MessageParcel & reply)482 void PrivacyManagerStub::GetPermissionUsedTypeInfosInner(MessageParcel& data, MessageParcel& reply)
483 {
484 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
485 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
486 reply.WriteInt32(PrivacyError::ERR_NOT_SYSTEM_APP);
487 return;
488 }
489 if (!VerifyPermission(PERMISSION_USED_STATS)) {
490 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
491 return;
492 }
493 AccessTokenID tokenId = data.ReadUint32();
494 std::string permissionName = data.ReadString();
495 std::vector<PermissionUsedTypeInfoParcel> resultsParcel;
496 int32_t result = this->GetPermissionUsedTypeInfos(tokenId, permissionName, resultsParcel);
497 if (!reply.WriteInt32(result)) {
498 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteInt32(%{public}d-%{public}s)", tokenId, permissionName.c_str());
499 return;
500 }
501 reply.WriteUint32(resultsParcel.size());
502 for (const auto& parcel : resultsParcel) {
503 reply.WriteParcelable(&parcel);
504 }
505 }
506
SetMutePolicyInner(MessageParcel & data,MessageParcel & reply)507 void PrivacyManagerStub::SetMutePolicyInner(MessageParcel& data, MessageParcel& reply)
508 {
509 AccessTokenID callingTokenID = IPCSkeleton::GetCallingTokenID();
510 if ((AccessTokenKit::GetTokenTypeFlag(callingTokenID) != TOKEN_NATIVE) &&
511 (AccessTokenKit::GetTokenTypeFlag(callingTokenID) != TOKEN_SHELL)) {
512 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
513 return;
514 }
515
516 if (!VerifyPermission(SET_MUTE_POLICY)) {
517 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
518 return;
519 }
520 uint32_t policyType;
521 if (!data.ReadUint32(policyType)) {
522 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read policyType.");
523 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
524 return;
525 }
526 uint32_t callerType;
527 if (!data.ReadUint32(callerType)) {
528 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read callerType.");
529 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
530 return;
531 }
532 bool isMute;
533 if (!data.ReadBool(isMute)) {
534 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read isMute.");
535 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
536 return;
537 }
538 uint32_t tokenID;
539 if (!data.ReadUint32(tokenID)) {
540 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read tokenID.");
541 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
542 return;
543 }
544
545 int32_t result = this->SetMutePolicy(policyType, callerType, isMute, tokenID);
546 if (!reply.WriteInt32(result)) {
547 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteInt32.");
548 return;
549 }
550 }
551
SetHapWithFGReminderInner(MessageParcel & data,MessageParcel & reply)552 void PrivacyManagerStub::SetHapWithFGReminderInner(MessageParcel& data, MessageParcel& reply)
553 {
554 if (!VerifyPermission(SET_FOREGROUND_HAP_REMINDER)) {
555 reply.WriteInt32(PrivacyError::ERR_PERMISSION_DENIED);
556 return;
557 }
558 uint32_t tokenId;
559 if (!data.ReadUint32(tokenId)) {
560 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read tokenId.");
561 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
562 return;
563 }
564 bool isAllowed;
565 if (!data.ReadBool(isAllowed)) {
566 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read isAllowed.");
567 reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
568 return;
569 }
570
571 int32_t result = this->SetHapWithFGReminder(tokenId, isAllowed);
572 if (!reply.WriteInt32(result)) {
573 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteInt32.");
574 return;
575 }
576 }
577
IsPrivilegedCalling() const578 bool PrivacyManagerStub::IsPrivilegedCalling() const
579 {
580 // shell process is root in debug mode.
581 #ifndef ATM_BUILD_VARIANT_USER_ENABLE
582 int32_t callingUid = IPCSkeleton::GetCallingUid();
583 return callingUid == ROOT_UID;
584 #else
585 return false;
586 #endif
587 }
588
IsAccessTokenCalling() const589 bool PrivacyManagerStub::IsAccessTokenCalling() const
590 {
591 int32_t callingUid = IPCSkeleton::GetCallingUid();
592 return callingUid == ACCESSTOKEN_UID;
593 }
594
IsSystemAppCalling() const595 bool PrivacyManagerStub::IsSystemAppCalling() const
596 {
597 uint64_t fullTokenId = IPCSkeleton::GetCallingFullTokenID();
598 return TokenIdKit::IsSystemAppByFullTokenID(fullTokenId);
599 }
600
VerifyPermission(const std::string & permission) const601 bool PrivacyManagerStub::VerifyPermission(const std::string& permission) const
602 {
603 uint32_t callingTokenID = IPCSkeleton::GetCallingTokenID();
604 if (AccessTokenKit::VerifyAccessToken(callingTokenID, permission) == PERMISSION_DENIED) {
605 LOGE(PRI_DOMAIN, PRI_TAG, "Permission denied(callingTokenID=%{public}d)", callingTokenID);
606 return false;
607 }
608 return true;
609 }
610 } // namespace AccessToken
611 } // namespace Security
612 } // namespace OHOS
613