Merge from tizen_2.2.1
[platform/framework/native/appfw.git] / src / security / FSecAccessController.cpp
1 //
2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Apache License, Version 2.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //     http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 /**
18  * @file        FSecAccessController.cpp
19  * @brief       This is the implementation for the AccessController class.
20  */
21
22 #include <unique_ptr.h>
23 #include <FAppTypes.h>
24 #include <FAppApplication.h>
25 #include <FApp_AppInfo.h>
26 #include <FApp_AppManagerImpl.h>
27 #include <FAppPkg_PackageInfoImpl.h>
28 #include <FBaseSysLog.h>
29 #include <FBaseString.h>
30 #include <FBaseColArrayList.h>
31 #include <FBaseColArrayListT.h>
32 #include <FBaseColIEnumeratorT.h>
33 #include <FIoFile.h>
34 #include <FIo_IpcClient.h>
35 #include <FSecAccessController.h>
36 #include <FSec_AccessController.h>
37 #include "FSec_AccessControlTypes.h"
38 #include "FSec_PrivilegeManager.h"
39 #include "FSec_PrivilegeManagerMessage.h"
40 #include "FSec_PrivilegeInfo.h"
41
42
43 using namespace Tizen::App;
44 using namespace Tizen::App::Package;
45 using namespace Tizen::Base;
46 using namespace Tizen::Base::Collection;
47 using namespace Tizen::Io;
48
49 static bool isConstructed = false;
50 static std::unique_ptr<_IpcClient> pIpcClient(null);
51 static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
52 static pthread_once_t ipcOnceBlock = PTHREAD_ONCE_INIT;
53
54 namespace Tizen { namespace Security
55 {
56
57 AccessController::AccessController(void)
58 {
59
60 }
61
62 AccessController::~AccessController(void)
63 {
64
65 }
66
67 static _PrivilegeInfo privilegeInfo;
68
69
70 void
71 AccessController::InitIpcClient(void)
72 {
73         std::unique_ptr<_IpcClient> pLocalIpcClient(new (std::nothrow) _IpcClient);
74         SysTryReturnVoidResult(NID_SEC, pLocalIpcClient != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
75
76         result r = pLocalIpcClient->Construct(L"osp.security.ipcserver.privilegemanager", null);
77         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "Failed to construct the instance of IPC.");
78
79         pIpcClient = std::move(pLocalIpcClient);
80         return;
81 }
82
83 void
84 AccessController::Initialize(void)
85 {
86         result r = E_SUCCESS;
87
88         if (pIpcClient == null)
89     {
90         pthread_once(&ipcOnceBlock, InitIpcClient);
91         r = GetLastResult();
92         if (IsFailed(r))
93         {
94                 ipcOnceBlock = PTHREAD_ONCE_INIT;
95                         SysLogException(NID_SEC, r, "[%s] Propagated.", GetErrorMessage(r));
96                         return;
97         }
98     }
99
100     std::unique_ptr<String> pEncryptedPrivileges(new (std::nothrow) String());
101         SysTryReturnVoidResult(NID_SEC, pEncryptedPrivileges != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
102
103         std::unique_ptr<String> pChecksum(new (std::nothrow) String());
104         SysTryReturnVoidResult(NID_SEC, pChecksum != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
105
106         std::unique_ptr< ArrayListT< String > > pPrivilegeListT(new ArrayListT< String >());
107         SysTryReturnVoidResult(NID_SEC, pPrivilegeListT != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
108
109         pPrivilegeListT->Construct();
110
111         std::unique_ptr<IPC::Message> pCipherPrivilegeMessage(new (std::nothrow) PrivilegeManagerMsg_retrieve(pEncryptedPrivileges.get(), pChecksum.get(), pPrivilegeListT.get(), &r));
112         SysTryReturnVoidResult(NID_SEC, pCipherPrivilegeMessage != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
113
114         result ipcResult = pIpcClient->SendRequest(pCipherPrivilegeMessage.get());
115         SysTryReturnVoidResult(NID_SEC, ipcResult == E_SUCCESS, E_SYSTEM, "Failed to send IPC message.");
116         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, r, "Failed to retrieve privilege information");
117
118         std::unique_ptr<ArrayList> pPrivilegeList(new ArrayList());
119         SysTryReturnVoidResult(NID_SEC, pPrivilegeList != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
120
121         pPrivilegeList->Construct();
122
123         std::unique_ptr<IEnumeratorT< String > > pEnum(pPrivilegeListT->GetEnumeratorN());
124         while (pEnum->MoveNext() == E_SUCCESS)
125         {
126                 String tempString;
127                 pEnum->GetCurrent(tempString);
128                 pPrivilegeList->Add(new String(tempString));
129         }
130         pPrivilegeListT->RemoveAll();
131
132         std::unique_ptr<String> pEncryptedVisibility(new (std::nothrow) String());
133         SysTryReturnVoidResult(NID_SEC, pEncryptedVisibility != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
134
135         std::unique_ptr<String> pVisibilityChecksum(new (std::nothrow) String());
136         SysTryReturnVoidResult(NID_SEC, pVisibilityChecksum != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
137
138         std::unique_ptr<IPC::Message> pCipherVisibilityMessage(new (std::nothrow) PrivilegeManagerMsg_retrieveEx(pEncryptedVisibility.get(), pVisibilityChecksum.get(), &r));
139         SysTryReturnVoidResult(NID_SEC, pCipherVisibilityMessage != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
140
141         ipcResult = pIpcClient->SendRequest(pCipherVisibilityMessage.get());
142         SysTryReturnVoidResult(NID_SEC, ipcResult == E_SUCCESS, E_SYSTEM, "Failed to send IPC message.");
143         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, r, "Failed to retrieve privilege information");
144
145         PackageId packageId = _AppInfo::GetPackageId();
146         packageId[0] = packageId[0];
147
148         r = privilegeInfo.Construct(packageId, *(pEncryptedPrivileges.get()), *(pChecksum.get()), *(pEncryptedVisibility.get()), *(pVisibilityChecksum.get()), pPrivilegeList.get());
149         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
150
151         pPrivilegeList->RemoveAll(true);
152         isConstructed = true;
153
154         return;
155 }
156
157 result
158 AccessController::CheckPrivilege(int privilege)
159 {
160         result r = E_SUCCESS;
161         bool ret = false;
162         ClearLastResult();
163
164         SysTryReturnResult(NID_SEC, (privilege >= 0) && (privilege < _MAX_PRIVILEGE_ENUM), E_INVALID_ARG, "The privilege enumerator is invalid");
165
166         if (!isConstructed)
167         {
168                 pthread_once(&onceBlock, Initialize);
169                 r = GetLastResult();
170                 if (IsFailed(r))
171                 {
172                         if (r == E_DATA_NOT_FOUND)
173                         {
174                                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
175                                 goto CATCH;
176                         }
177                         else
178                         {
179                                 onceBlock = PTHREAD_ONCE_INIT;
180                                 SysLogException(NID_SEC, r, "[%s] Propagated.", GetErrorMessage(r));
181                         }
182                         return r;
183                 }
184         }
185
186         if (privilegeInfo.GetAppId().IsEmpty())
187         {
188                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
189                 r = E_DATA_NOT_FOUND;
190                 goto CATCH;
191         }
192         else
193         {
194                 SysLog(NID_SEC, "%ls is in the cache [client]", privilegeInfo.GetAppId().GetPointer());
195         }
196
197         ret = privilegeInfo.HasPrivilege(static_cast< _Privilege >(privilege));
198         if (!ret)
199         {
200                 r = E_PRIVILEGE_DENIED;
201                 goto CATCH;
202         }
203
204         r = _AccessController::CheckPrivacy(privilegeInfo.GetAppId(), static_cast< _Privilege >(privilege));
205         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
206
207         return r;
208
209 CATCH:
210
211         SysLogException(NID_SEC,  r, "[E_PRIVILEGE_DENIED] The application does not have the privilege to call this method.");
212         return r;
213 }
214
215 result
216 AccessController::CheckPrivilege(const String& privilege)
217 {
218         result r = E_SUCCESS;
219         bool ret = false;
220         ClearLastResult();
221
222         if (!isConstructed)
223         {
224                 pthread_once(&onceBlock, Initialize);
225                 r = GetLastResult();
226                 if (IsFailed(r))
227                 {
228                         if (r == E_DATA_NOT_FOUND)
229                         {
230                                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
231                                 goto CATCH;
232                         }
233                         else
234                         {
235                                 onceBlock = PTHREAD_ONCE_INIT;
236                                 SysLogException(NID_SEC, r, "[%s] Propagated.", GetErrorMessage(r));
237                         }
238                         return r;
239                 }
240         }
241
242         if (privilegeInfo.GetAppId().IsEmpty())
243         {
244                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
245                 r = E_DATA_NOT_FOUND;
246                 goto CATCH;
247         }
248         else
249         {
250                 SysLog(NID_SEC, "%ls is in the cache [client]", privilegeInfo.GetAppId().GetPointer());
251         }
252
253         ret = privilegeInfo.HasPrivilege(privilege);
254         if (!ret)
255         {
256                 r = E_PRIVILEGE_DENIED;
257                 goto CATCH;
258         }
259
260         r = _AccessController::CheckPrivacy(privilegeInfo.GetAppId(), privilege);
261         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
262
263         return r;
264
265 CATCH:
266
267         SysLogException(NID_SEC,  r, "[E_PRIVILEGE_DENIED] The application does not have the privilege to call this method.");
268         return r;
269 }
270
271 _PrivilegeManager* AccessController::__pPrivilegeManager = null;
272
273 result
274 AccessController::CheckPrivilege(const PackageId& packageId, const String& privilege)
275 {
276         bool ret = false;
277         result r = _AccessController::CheckUserPrivilege(_PRV_PRIVILEGEMANAGER_READ);
278         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
279
280         String subAppId;
281         packageId.SubString(0, MAX_APP_ID_SIZE, subAppId);
282
283         _PackageInfoImpl infoImpl;
284         r = infoImpl.Construct(packageId);
285         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
286
287         String appType;
288         String webAppType(L"wgt");
289         String cAppType(L"rpm");
290         appType = infoImpl.GetAppType();
291         if (appType.Equals(webAppType, true))
292         {
293                 return E_SUCCESS;
294         }
295         else if (appType.Equals(cAppType, true))
296         {
297                 r = _AccessController::CheckPrivacy(packageId, privilege);
298                 SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
299
300                 return r;
301         }
302
303         if (__pPrivilegeManager == null)
304         {
305                 __pPrivilegeManager = _PrivilegeManager::GetInstance();
306         }
307         SysTryReturnResult(NID_SEC, __pPrivilegeManager != null, E_SYSTEM, "An unexpected system error occurred.");
308
309         std::unique_ptr<_PrivilegeInfo> pPrivilegeInfo(__pPrivilegeManager->RetrievePrivilegeInfoN(subAppId));
310         r = GetLastResult();
311
312         if (r == E_SUCCESS)
313         {
314                 // nothing to do.
315         }
316         else if (r == E_DATA_NOT_FOUND)
317         {
318                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
319                 goto CATCH;
320         }
321         else
322         {
323                 SysLogException(NID_SEC, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
324                 return E_SYSTEM;
325         }
326
327         ret = pPrivilegeInfo->HasPrivilege(privilege);
328         if (!ret)
329         {
330                 r = E_PRIVILEGE_DENIED;
331                 goto CATCH;
332         }
333
334         r = _AccessController::CheckPrivacy(packageId, privilege);
335         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
336
337         return r;
338
339 CATCH:
340
341         SysLogException(NID_SEC,  r, "[E_PRIVILEGE_DENIED] The application does not have the privilege to call this method.");
342         return r;
343 }
344
345 }} //Tizen::Security