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 "dlp_permission_api.h"
17
18 #include <string>
19 #include "securec.h"
20 #include "dlp_permission.h"
21 #include "dlp_permission_log.h"
22 #include "dlp_permission_kit.h"
23
24 using namespace OHOS::Security::DlpPermission;
25
26 namespace {
27 static const char *DLP_FILE_SUFFIX = ".dlp";
28 static const uint32_t MAX_FILE_NAME_LEN = 256;
29 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpPermissionCapi"};
30 static const std::unordered_map<int32_t, DLP_ErrCode> NATIVE_CODE_TO_C_CODE_MAP = {
31 { DLP_OK, ERR_OH_SUCCESS },
32
33 // ERR_OH_INVALID_PARAMETER
34 { DLP_SERVICE_ERROR_VALUE_INVALID, ERR_OH_INVALID_PARAMETER },
35 { DLP_PARSE_ERROR_VALUE_INVALID, ERR_OH_INVALID_PARAMETER },
36 { DLP_PARSE_ERROR_DIGEST_INVALID, ERR_OH_INVALID_PARAMETER },
37 { DLP_PARSE_ERROR_FD_ERROR, ERR_OH_INVALID_PARAMETER },
38 { DLP_PARSE_ERROR_PTR_NULL, ERR_OH_INVALID_PARAMETER },
39 { DLP_PARSE_ERROR_CIPHER_PARAMS_INVALID, ERR_OH_INVALID_PARAMETER },
40 { DLP_PARSE_ERROR_ACCOUNT_INVALID, ERR_OH_INVALID_PARAMETER },
41 { DLP_FUSE_ERROR_VALUE_INVALID, ERR_OH_INVALID_PARAMETER },
42 { DLP_FUSE_ERROR_DLP_FILE_NULL, ERR_OH_INVALID_PARAMETER },
43 { DLP_KV_DATE_INFO_EMPTY_ERROR, ERR_OH_INVALID_PARAMETER },
44 { DLP_RETENTION_ERROR_VALUE_INVALID, ERR_OH_INVALID_PARAMETER },
45
46 // ERR_OH_API_ONLY_FOR_SANDBOX
47 { DLP_SERVICE_ERROR_API_ONLY_FOR_SANDBOX_ERROR, ERR_OH_API_ONLY_FOR_SANDBOX },
48
49 // ERR_OH_API_NOT_FOR_SANDBOX
50 { DLP_SERVICE_ERROR_API_NOT_FOR_SANDBOX_ERROR, ERR_OH_API_NOT_FOR_SANDBOX },
51
52 // ERR_OH_SYSTEM_SERVICE_EXCEPTION
53 { DLP_NAPI_ERROR_NATIVE_BINDING_FAIL, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
54 { DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
55 { DLP_SERVICE_ERROR_JSON_OPERATE_FAIL, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
56 { DLP_SERVICE_ERROR_IPC_REQUEST_FAIL, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
57 { DLP_SERVICE_ERROR_APPOBSERVER_NULL, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
58 { DLP_SERVICE_ERROR_APPOBSERVER_ERROR, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
59 { DLP_SERVICE_ERROR_SERVICE_NOT_EXIST, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
60 { DLP_SERVICE_ERROR_GET_ACCOUNT_FAIL, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
61 { DLP_PARSE_ERROR_CRYPT_FAIL, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
62 { DLP_PARSE_ERROR_CRYPTO_ENGINE_ERROR, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
63 { DLP_PARSE_ERROR_OPERATION_UNSUPPORTED, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
64 { DLP_QUERY_DISTRIBUTE_DATA_ERROR, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
65 { DLP_COMMON_CHECK_KVSTORE_ERROR, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
66 { DLP_COMMON_DELETE_KEY_FROM_KVSTORE_ERROR, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
67 { DLP_CREDENTIAL_ERROR_VALUE_INVALID, ERR_OH_SYSTEM_SERVICE_EXCEPTION },
68
69 // ERR_OH_OUT_OF_MEMORY
70 { DLP_SERVICE_ERROR_MEMORY_OPERATE_FAIL, ERR_OH_OUT_OF_MEMORY },
71 { DLP_PARSE_ERROR_MEMORY_OPERATE_FAIL, ERR_OH_OUT_OF_MEMORY },
72 { DLP_FUSE_ERROR_MEMORY_OPERATE_FAIL, ERR_OH_OUT_OF_MEMORY },
73
74 // ERR_OH_APPLICATION_NOT_AUTHORIZED
75 { DLP_CREDENTIAL_ERROR_APPID_NOT_AUTHORIZED, ERR_OH_APPLICATION_NOT_AUTHORIZED},
76 };
77 } // namespace
78
ConvertApiResult(int32_t result)79 static DLP_ErrCode ConvertApiResult(int32_t result)
80 {
81 auto iter = NATIVE_CODE_TO_C_CODE_MAP.find(result);
82 if (iter != NATIVE_CODE_TO_C_CODE_MAP.end()) {
83 return iter->second;
84 }
85 return ERR_OH_SYSTEM_SERVICE_EXCEPTION;
86 }
87
OH_DLP_GetDlpPermissionInfo(DLP_FileAccess * dlpFileAccess,uint32_t * flag)88 DLP_ErrCode OH_DLP_GetDlpPermissionInfo(DLP_FileAccess *dlpFileAccess, uint32_t *flag)
89 {
90 if (dlpFileAccess == nullptr || flag == nullptr) {
91 DLP_LOG_ERROR(LABEL, "Invalid parameter.");
92 return ERR_OH_INVALID_PARAMETER;
93 }
94
95 DLPPermissionInfo info = {};
96 int32_t result = DlpPermissionKit::QueryDlpFileAccess(info);
97 if (result != DLP_OK) {
98 DLP_LOG_ERROR(LABEL, "query dlpFileAccess error.");
99 return ConvertApiResult(result);
100 }
101
102 (void)memcpy_s(dlpFileAccess, sizeof(DLP_FileAccess), &info.dlpFileAccess, sizeof(DLP_FileAccess));
103 (void)memcpy_s(flag, sizeof(uint32_t), &info.flags, sizeof(uint32_t));
104 return ConvertApiResult(result);
105 }
106
OH_DLP_GetOriginalFileName(const char * fileName,char ** originalFileName)107 DLP_ErrCode OH_DLP_GetOriginalFileName(const char *fileName, char **originalFileName)
108 {
109 *originalFileName = nullptr;
110 if (fileName == nullptr) {
111 DLP_LOG_ERROR(LABEL, "Invalid parameter.");
112 return ERR_OH_INVALID_PARAMETER;
113 }
114
115 uint32_t suffixLen = strlen(DLP_FILE_SUFFIX);
116 uint32_t fileNameLen = strlen(fileName);
117 if (fileNameLen <= suffixLen || fileNameLen > MAX_FILE_NAME_LEN) {
118 DLP_LOG_ERROR(LABEL, "file name len is error.");
119 return ERR_OH_INVALID_PARAMETER;
120 }
121
122 if (strncmp(fileName + fileNameLen - suffixLen, DLP_FILE_SUFFIX, suffixLen) != 0) {
123 DLP_LOG_ERROR(LABEL, "Not a dlp file.");
124 return ERR_OH_INVALID_PARAMETER;
125 }
126
127 *originalFileName = static_cast<char *>(malloc(fileNameLen - suffixLen + 1));
128 if (*originalFileName == nullptr) {
129 DLP_LOG_ERROR(LABEL, "Malloc *originalFileName error.");
130 return ERR_OH_OUT_OF_MEMORY;
131 }
132
133 (void)memcpy_s(*originalFileName, fileNameLen - suffixLen, fileName, fileNameLen - suffixLen);
134 (*originalFileName)[fileNameLen - suffixLen] = 0;
135 return ERR_OH_SUCCESS;
136 }
137
OH_DLP_IsInSandbox(bool * isInSandbox)138 DLP_ErrCode OH_DLP_IsInSandbox(bool *isInSandbox)
139 {
140 if (isInSandbox == nullptr) {
141 DLP_LOG_ERROR(LABEL, "Invalid parameter.");
142 return ERR_OH_INVALID_PARAMETER;
143 }
144 int32_t result = DlpPermissionKit::IsInDlpSandbox(*isInSandbox);
145 if (result != DLP_OK) {
146 DLP_LOG_ERROR(LABEL, "get isInDlpSandbox error.");
147 }
148 return ConvertApiResult(result);
149 }
150
OH_DLP_SetSandboxAppConfig(const char * configInfo)151 DLP_ErrCode OH_DLP_SetSandboxAppConfig(const char *configInfo)
152 {
153 if (configInfo == nullptr) {
154 DLP_LOG_ERROR(LABEL, "Invalid parameter.");
155 return ERR_OH_INVALID_PARAMETER;
156 }
157 std::string strConfigInfo(configInfo);
158 int32_t result = DlpPermissionKit::SetSandboxAppConfig(strConfigInfo);
159 if (result != DLP_OK) {
160 DLP_LOG_ERROR(LABEL, "set sandboxAppConfig error.");
161 }
162 return ConvertApiResult(result);
163 }
164
OH_DLP_GetSandboxAppConfig(char ** configInfo)165 DLP_ErrCode OH_DLP_GetSandboxAppConfig(char **configInfo)
166 {
167 *configInfo = nullptr;
168 std::string strConfigInfo = "";
169 int32_t result = DlpPermissionKit::GetSandboxAppConfig(strConfigInfo);
170 if (result != DLP_OK) {
171 DLP_LOG_ERROR(LABEL, "get sandboxAppConfig error.");
172 return ConvertApiResult(result);
173 }
174
175 *configInfo = static_cast<char *>(malloc(strConfigInfo.size() + 1));
176 if (*configInfo == nullptr) {
177 DLP_LOG_ERROR(LABEL, "Malloc *configInfo error.");
178 return ERR_OH_OUT_OF_MEMORY;
179 }
180 (void)memcpy_s(*configInfo, strConfigInfo.size() + 1, strConfigInfo.c_str(), strConfigInfo.size() + 1);
181 return ERR_OH_SUCCESS;
182 }
183
OH_DLP_CleanSandboxAppConfig()184 DLP_ErrCode OH_DLP_CleanSandboxAppConfig()
185 {
186 int32_t result = DlpPermissionKit::CleanSandboxAppConfig();
187 if (result != DLP_OK) {
188 DLP_LOG_ERROR(LABEL, "clean sandboxAppConfig error.");
189 }
190 return ConvertApiResult(result);
191 }