1 /*
2 * Copyright (c) 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 "permission_managed_state_serializer.h"
17
18 #include <sstream>
19
20 #include "accesstoken_kit.h"
21 #include "cJSON.h"
22
23 #include "cjson_check.h"
24 #include "edm_access_token_manager_impl.h"
25 #include "edm_log.h"
26 #include "edm_sys_manager.h"
27
28 namespace OHOS {
29 namespace EDM {
30
31 const std::string APP_IDENTIFIER = "appIdentifier";
32 const std::string PERMISSION_NAME = "permissionName";
33 const std::string PERMISSION_NAMES = "permissionNames";
34 const std::string ACCOUNT_ID = "accountId";
35 const std::string APP_INDEX = "appIndex";
36 const std::string MANAGED_STATE = "managedState";
37 const std::string TOKEN_ID = "tokenId";
38
Deserialize(const std::string & data,std::map<std::string,PermissionManagedStateInfo> & result)39 bool PermissionManagedStateSerializer::Deserialize(const std::string &data,
40 std::map<std::string, PermissionManagedStateInfo> &result)
41 {
42 cJSON* root = cJSON_Parse(data.c_str());
43 if (root == nullptr) {
44 return true;
45 }
46 cJSON* item;
47 cJSON_ArrayForEach(item, root) {
48 cJSON* appIdentifier = cJSON_GetObjectItem(item, APP_IDENTIFIER.c_str());
49 cJSON* accountId = cJSON_GetObjectItem(item, ACCOUNT_ID.c_str());
50 cJSON* appIndex = cJSON_GetObjectItem(item, APP_INDEX.c_str());
51 cJSON* managedState = cJSON_GetObjectItem(item, MANAGED_STATE.c_str());
52 cJSON* permissionName = cJSON_GetObjectItem(item, PERMISSION_NAME.c_str());
53 cJSON* permissionNames = cJSON_GetObjectItem(item, PERMISSION_NAMES.c_str());
54 cJSON* tokenId = cJSON_GetObjectItem(item, TOKEN_ID.c_str());
55 if (managedState == nullptr || appIdentifier == nullptr || permissionNames == nullptr ||
56 accountId == nullptr || appIndex == nullptr || permissionName == nullptr || tokenId == nullptr ||
57 !cJSON_IsNumber(managedState) || !cJSON_IsString(appIdentifier) || !cJSON_IsArray(permissionNames) ||
58 !cJSON_IsNumber(accountId) || !cJSON_IsNumber(appIndex) || !cJSON_IsString(permissionName) ||
59 !cJSON_IsNumber(tokenId)) {
60 cJSON_Delete(root);
61 return false;
62 }
63
64 PermissionManagedStateInfo info;
65 info.appIdentifier = appIdentifier->valuestring;
66 info.accountId = accountId->valueint;
67 info.appIndex = appIndex->valueint;
68 info.managedState = managedState->valueint;
69 info.permissionName = permissionName->valuestring;
70 info.tokenId = tokenId->valueint;
71
72 std::stringstream appPermissionKey;
73 appPermissionKey << info.tokenId <<"\t"<< info.permissionName;
74 std::string appPermissionKeyStr = appPermissionKey.str();
75
76 result.insert(std::make_pair(appPermissionKeyStr, info));
77 }
78 cJSON_Delete(root);
79 return true;
80 }
81
Serialize(const std::map<std::string,PermissionManagedStateInfo> & result,std::string & data)82 bool PermissionManagedStateSerializer::Serialize(const std::map<std::string, PermissionManagedStateInfo> &result,
83 std::string &data)
84 {
85 if (result.empty()) {
86 return true;
87 }
88 cJSON* root = nullptr;
89 CJSON_CREATE_ARRAY_AND_CHECK(root, false);
90 for (auto& it : result) {
91 cJSON* item = nullptr;
92 CJSON_CREATE_OBJECT_AND_CHECK_AND_CLEAR(item, false, root);
93 cJSON_AddItemToArray(root, item);
94 cJSON_AddStringToObject(item, APP_IDENTIFIER.c_str(), it.second.appIdentifier.c_str());
95 cJSON_AddStringToObject(item, PERMISSION_NAME.c_str(), it.second.permissionName.c_str());
96 cJSON_AddNumberToObject(item, ACCOUNT_ID.c_str(), it.second.accountId);
97 cJSON_AddNumberToObject(item, APP_INDEX.c_str(), it.second.appIndex);
98 cJSON_AddNumberToObject(item, MANAGED_STATE.c_str(), it.second.managedState);
99 cJSON_AddNumberToObject(item, TOKEN_ID.c_str(), it.second.tokenId);
100 cJSON *permissionNames = cJSON_CreateArray();
101 if (permissionNames == nullptr) {
102 cJSON_Delete(root);
103 return false;
104 }
105 for (std::string permissionName: it.second.permissionNames) {
106 cJSON* permissionNameItem = cJSON_CreateString(permissionName.c_str());
107 if (permissionNameItem == nullptr) {
108 cJSON_Delete(root);
109 cJSON_Delete(permissionNames);
110 return false;
111 }
112 cJSON_AddItemToArray(permissionNames, permissionNameItem);
113 }
114 if (!cJSON_AddItemToObject(item, PERMISSION_NAMES.c_str(), permissionNames)) {
115 cJSON_Delete(root);
116 cJSON_Delete(permissionNames);
117 return false;
118 }
119 }
120 char* jsonStr = cJSON_Print(root);
121 if (jsonStr == nullptr) {
122 cJSON_Delete(root);
123 return false;
124 }
125 data = std::string(jsonStr);
126 cJSON_free(jsonStr);
127 cJSON_Delete(root);
128 return true;
129 }
130
GetPolicy(MessageParcel & data,std::map<std::string,PermissionManagedStateInfo> & result)131 bool PermissionManagedStateSerializer::GetPolicy(MessageParcel &data,
132 std::map<std::string, PermissionManagedStateInfo> &result)
133 {
134 PermissionManagedStateInfo info;
135 info.appIdentifier = data.ReadString();
136 info.accountId = data.ReadInt32();
137 info.appIndex = data.ReadInt32();
138 if (!data.ReadStringVector(&info.permissionNames)) {
139 EDMLOGE("PermissionManagedStateSerializer GetPolicy params error.");
140 return false;
141 }
142 info.managedState = data.ReadInt32();
143 Security::AccessToken::AccessTokenID accessTokenId;
144 EdmAccessTokenManagerImpl edmAccessTokenManagerImpl;
145 if (!edmAccessTokenManagerImpl.GetAccessTokenId(info.accountId, info.appIdentifier, info.appIndex, accessTokenId)) {
146 EDMLOGE("PermissionManagedStateSerializer GetAccessTokenId failed.");
147 return false;
148 }
149 info.tokenId = static_cast<int32_t>(accessTokenId);
150 for (std::string permissionName : info.permissionNames) {
151 std::stringstream appPermissionKey;
152 info.permissionName = permissionName;
153 appPermissionKey << info.tokenId <<"\t"<< info.permissionName;
154 std::string appPermissionKeyStr = appPermissionKey.str();
155 result.insert(std::make_pair(appPermissionKeyStr, info));
156 }
157 return true;
158 }
159
WritePolicy(MessageParcel & reply,std::map<std::string,PermissionManagedStateInfo> & result)160 bool PermissionManagedStateSerializer::WritePolicy(MessageParcel &reply,
161 std::map<std::string, PermissionManagedStateInfo> &result)
162 {
163 return true;
164 }
165
MergePolicy(std::vector<std::map<std::string,PermissionManagedStateInfo>> & data,std::map<std::string,PermissionManagedStateInfo> & result)166 bool PermissionManagedStateSerializer::MergePolicy(std::vector<std::map<std::string,
167 PermissionManagedStateInfo>> &data,
168 std::map<std::string, PermissionManagedStateInfo> &result)
169 {
170 for (auto policyMap : data) {
171 for (auto iter : policyMap) {
172 result.insert(std::make_pair(iter.first.c_str(), iter.second));
173 }
174 }
175 return true;
176 }
177 } // namespace EDM
178 } // namespace OHOS