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 <FIoFile.h>
  32 #include <FIo_IpcClient.h>
  33 #include <FSecAccessController.h>
  34 #include <FSec_AccessController.h>
  35 #include "FSec_AccessControlTypes.h"
  36 #include "FSec_PrivilegeManager.h"
  37 #include "FSec_PrivilegeManagerMessage.h"
  38 #include "FSec_PrivilegeInfo.h"
  39
  40
  41 using namespace Tizen::App;
  42 using namespace Tizen::App::Package;
  43 using namespace Tizen::Base;
  44 using namespace Tizen::Base::Collection;
  45 using namespace Tizen::Io;
  46
  47 static bool isConstructed = false;
  48 static std::unique_ptr<_IpcClient> pIpcClient(null);
  49 static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
  50 static pthread_once_t ipcOnceBlock = PTHREAD_ONCE_INIT;
  51
  52 namespace Tizen { namespace Security
  53 {
  54
  55 AccessController::AccessController(void)
  56 {
  57
  58 }
  59
  60 AccessController::~AccessController(void)
  61 {
  62
  63 }
  64
  65 static _PrivilegeInfo privilegeInfo;
  66
  67
  68 void
  69 AccessController::InitIpcClient(void)
  70 {
  71         std::unique_ptr<_IpcClient> pLocalIpcClient(new (std::nothrow) _IpcClient);
  72         SysTryReturnVoidResult(NID_SEC, pLocalIpcClient != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
  73
  74         result r = pLocalIpcClient->Construct(L"osp.security.ipcserver.privilegemanager", null);
  75         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "Failed to construct the instance of IPC.");
  76
  77         pIpcClient = std::move(pLocalIpcClient);
  78         return;
  79 }
  80
  81 void
  82 AccessController::Initialize(void)
  83 {
  84         result r = E_SUCCESS;
  85
  86         if (pIpcClient == null)
  87     {
  88         pthread_once(&ipcOnceBlock, InitIpcClient);
  89         r = GetLastResult();
  90         if (IsFailed(r))
  91         {
  92                 ipcOnceBlock = PTHREAD_ONCE_INIT;
  93                         SysLogException(NID_SEC, r, "[%s] Propagated.", GetErrorMessage(r));
  94                         return;
  95         }
  96     }
  97
  98     std::unique_ptr<String> pEncryptedPrivileges(new (std::nothrow) String());
  99         SysTryReturnVoidResult(NID_SEC, pEncryptedPrivileges != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 100
 101         std::unique_ptr<String> pChecksum(new (std::nothrow) String());
 102         SysTryReturnVoidResult(NID_SEC, pChecksum != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 103
 104         std::unique_ptr<ArrayList> pPrivilegeList(new ArrayList());
 105         SysTryReturnVoidResult(NID_SEC, pPrivilegeList != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 106
 107         pPrivilegeList->Construct();
 108
 109         std::unique_ptr<IPC::Message> pCipherPrivilegeMessage(new (std::nothrow) PrivilegeManagerMsg_retrieve(pEncryptedPrivileges.get(), pChecksum.get(), pPrivilegeList.get(), &r));
 110         SysTryReturnVoidResult(NID_SEC, pCipherPrivilegeMessage != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 111
 112         result ipcResult = pIpcClient->SendRequest(pCipherPrivilegeMessage.get());
 113         SysTryReturnVoidResult(NID_SEC, ipcResult == E_SUCCESS, E_SYSTEM, "Failed to send IPC message.");
 114         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, r, "Failed to retrieve privilege information");
 115
 116         std::unique_ptr<String> pEncryptedVisibility(new (std::nothrow) String());
 117         SysTryReturnVoidResult(NID_SEC, pEncryptedVisibility != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 118
 119         std::unique_ptr<String> pVisibilityChecksum(new (std::nothrow) String());
 120         SysTryReturnVoidResult(NID_SEC, pVisibilityChecksum != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 121
 122         std::unique_ptr<IPC::Message> pCipherVisibilityMessage(new (std::nothrow) PrivilegeManagerMsg_retrieveEx(pEncryptedVisibility.get(), pVisibilityChecksum.get(), &r));
 123         SysTryReturnVoidResult(NID_SEC, pCipherVisibilityMessage != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 124
 125         ipcResult = pIpcClient->SendRequest(pCipherVisibilityMessage.get());
 126         SysTryReturnVoidResult(NID_SEC, ipcResult == E_SUCCESS, E_SYSTEM, "Failed to send IPC message.");
 127         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, r, "Failed to retrieve privilege information");
 128
 129         PackageId packageId = _AppInfo::GetPackageId();
 130         packageId[0] = packageId[0];
 131
 132         r = privilegeInfo.Construct(packageId, *(pEncryptedPrivileges.get()), *(pChecksum.get()), *(pEncryptedVisibility.get()), *(pVisibilityChecksum.get()), pPrivilegeList.get());
 133         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 134
 135         pPrivilegeList->RemoveAll(true);
 136         isConstructed = true;
 137
 138         return;
 139 }
 140
 141 result
 142 AccessController::CheckPrivilege(int privilege)
 143 {
 144         result r = E_SUCCESS;
 145         bool ret = false;
 146         ClearLastResult();
 147
 148         SysTryReturnResult(NID_SEC, (privilege >= 0) && (privilege < _MAX_PRIVILEGE_ENUM), E_INVALID_ARG, "The privilege enumerator is invalid");
 149
 150         if (!isConstructed)
 151         {
 152                 pthread_once(&onceBlock, Initialize);
 153                 r = GetLastResult();
 154                 if (IsFailed(r))
 155                 {
 156                         if (r == E_DATA_NOT_FOUND)
 157                         {
 158                                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 159                                 goto CATCH;
 160                         }
 161                         else
 162                         {
 163                                 onceBlock = PTHREAD_ONCE_INIT;
 164                                 SysLogException(NID_SEC, r, "[%s] Propagated.", GetErrorMessage(r));
 165                         }
 166                         return r;
 167                 }
 168         }
 169
 170         if (privilegeInfo.GetAppId().IsEmpty())
 171         {
 172                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 173                 r = E_DATA_NOT_FOUND;
 174                 goto CATCH;
 175         }
 176         else
 177         {
 178                 SysLog(NID_SEC, "%ls is in the cache [client]", privilegeInfo.GetAppId().GetPointer());
 179         }
 180
 181         ret = privilegeInfo.HasPrivilege(static_cast< _Privilege >(privilege));
 182         if (!ret)
 183         {
 184                 r = E_PRIVILEGE_DENIED;
 185                 goto CATCH;
 186         }
 187
 188         r = _AccessController::CheckPrivacy(privilegeInfo.GetAppId(), static_cast< _Privilege >(privilege));
 189         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
 190
 191         return r;
 192
 193 CATCH:
 194
 195         SysLogException(NID_SEC,  r, "[E_PRIVILEGE_DENIED] The application does not have the privilege to call this method.");
 196         return r;
 197 }
 198
 199 result
 200 AccessController::CheckPrivilege(const String& privilege)
 201 {
 202         result r = E_SUCCESS;
 203         bool ret = false;
 204         ClearLastResult();
 205
 206         if (!isConstructed)
 207         {
 208                 pthread_once(&onceBlock, Initialize);
 209                 r = GetLastResult();
 210                 if (IsFailed(r))
 211                 {
 212                         if (r == E_DATA_NOT_FOUND)
 213                         {
 214                                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 215                                 goto CATCH;
 216                         }
 217                         else
 218                         {
 219                                 onceBlock = PTHREAD_ONCE_INIT;
 220                                 SysLogException(NID_SEC, r, "[%s] Propagated.", GetErrorMessage(r));
 221                         }
 222                         return r;
 223                 }
 224         }
 225
 226         if (privilegeInfo.GetAppId().IsEmpty())
 227         {
 228                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 229                 r = E_DATA_NOT_FOUND;
 230                 goto CATCH;
 231         }
 232         else
 233         {
 234                 SysLog(NID_SEC, "%ls is in the cache [client]", privilegeInfo.GetAppId().GetPointer());
 235         }
 236
 237         ret = privilegeInfo.HasPrivilege(privilege);
 238         if (!ret)
 239         {
 240                 r = E_PRIVILEGE_DENIED;
 241                 goto CATCH;
 242         }
 243
 244         r = _AccessController::CheckPrivacy(privilegeInfo.GetAppId(), privilege);
 245         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
 246
 247         return r;
 248
 249 CATCH:
 250
 251         SysLogException(NID_SEC,  r, "[E_PRIVILEGE_DENIED] The application does not have the privilege to call this method.");
 252         return r;
 253 }
 254
 255 _PrivilegeManager* AccessController::__pPrivilegeManager = null;
 256
 257 result
 258 AccessController::CheckPrivilege(const PackageId& packageId, const String& privilege)
 259 {
 260         bool ret = false;
 261         result r = _AccessController::CheckUserPrivilege(_PRV_PRIVILEGEMANAGER_READ);
 262         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 263
 264         String subAppId;
 265         packageId.SubString(0, MAX_APP_ID_SIZE, subAppId);
 266
 267         _PackageInfoImpl infoImpl;
 268         r = infoImpl.Construct(packageId);
 269         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 270
 271         String appType;
 272         String webAppType(L"wgt");
 273         String cAppType(L"rpm");
 274         appType = infoImpl.GetAppType();
 275         if (appType.Equals(webAppType, true))
 276         {
 277                 return E_SUCCESS;
 278         }
 279         else if (appType.Equals(cAppType, true))
 280         {
 281                 r = _AccessController::CheckPrivacy(packageId, privilege);
 282                 SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
 283
 284                 return r;
 285         }
 286
 287         if (__pPrivilegeManager == null)
 288         {
 289                 __pPrivilegeManager = _PrivilegeManager::GetInstance();
 290         }
 291         SysTryReturnResult(NID_SEC, __pPrivilegeManager != null, E_SYSTEM, "An unexpected system error occurred.");
 292
 293         std::unique_ptr<_PrivilegeInfo> pPrivilegeInfo(__pPrivilegeManager->RetrievePrivilegeInfoN(subAppId));
 294         r = GetLastResult();
 295
 296         if (r == E_SUCCESS)
 297         {
 298                 // nothing to do.
 299         }
 300         else if (r == E_DATA_NOT_FOUND)
 301         {
 302                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 303                 goto CATCH;
 304         }
 305         else
 306         {
 307                 SysLogException(NID_SEC, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 308                 return E_SYSTEM;
 309         }
 310
 311         ret = pPrivilegeInfo->HasPrivilege(privilege);
 312         if (!ret)
 313         {
 314                 r = E_PRIVILEGE_DENIED;
 315                 goto CATCH;
 316         }
 317
 318         r = _AccessController::CheckPrivacy(packageId, privilege);
 319         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_USER_NOT_CONSENTED, "The user blocks an application from calling the method.");
 320
 321         return r;
 322
 323 CATCH:
 324
 325         SysLogException(NID_SEC,  r, "[E_PRIVILEGE_DENIED] The application does not have the privilege to call this method.");
 326         return r;
 327 }
 328
 329 }} //Tizen::Security