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