src/security/FSec_PrivilegeManager.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                FSec_PrivilegeManager.cpp
  19  * @brief               This is the implementation for the _PrivilegeManager class.
  20  */
  21
  22 #include <stdlib.h>
  23 #include <pthread.h>
  24 #include <unique_ptr.h>
  25 #include <pkgmgr-info.h>
  26 #include <FAppPkg_PackageInfoImpl.h>
  27 #include <FAppPkg_PackageManagerImpl.h>
  28 #include <FBaseString.h>
  29 #include <FBaseSysLog.h>
  30 #include <FBase_StringConverter.h>
  31 #include <FIo_IpcClient.h>
  32 #include "FSec_AccessControlTypes.h"
  33 #include "FSec_PrivilegeManager.h"
  34 #include "FSec_PrivilegeManagerMessage.h"
  35 #include "FSec_PrivilegeCache.h"
  36 #include "FSec_PrivilegeInfo.h"
  37
  38 using namespace Tizen::App;
  39 using namespace Tizen::App::Package;
  40 using namespace Tizen::Base;
  41 using namespace Tizen::Base::Collection;
  42 using namespace Tizen::Io;
  43
  44 namespace Tizen { namespace Security
  45 {
  46
  47 _PrivilegeManager* _PrivilegeManager::__pPrivilegeManagerInstance  = null;
  48
  49 _PrivilegeManager::_PrivilegeManager(void)
  50         : __pPrivilegeCache(null)
  51 {
  52         return;
  53 }
  54
  55 _PrivilegeManager::~_PrivilegeManager(void)
  56 {
  57         delete __pPrivilegeCache;
  58         return;
  59 }
  60
  61 result
  62 _PrivilegeManager::Construct(void)
  63 {
  64         result r = E_SUCCESS;
  65
  66         _PackageManagerImpl* pPackageManagerImpl = null;
  67
  68         pPackageManagerImpl = _PackageManagerImpl::GetInstance();
  69         SysTryReturnResult(NID_SEC, pPackageManagerImpl != null, E_SYSTEM, "An unexpected system error occurred.");
  70
  71         //pPackageManagerImpl->RemoveEventListener(this);
  72         r = pPackageManagerImpl->AddEventListener(this);
  73         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
  74
  75         __pPrivilegeCache = new (std::nothrow) _PrivilegeCache();
  76         SysTryReturnResult(NID_SEC, __pPrivilegeCache != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
  77
  78         r = __pPrivilegeCache->Construct();
  79         SysTryCatch(NID_SEC, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
  80
  81         return r;
  82
  83 CATCH:
  84
  85         delete __pPrivilegeCache;
  86         return r;
  87 }
  88
  89 void
  90 _PrivilegeManager::InitInstance(void)
  91 {
  92         result r = E_SUCCESS;
  93         static _PrivilegeManager instance;
  94
  95         ClearLastResult();
  96
  97         r = instance.Construct();
  98         SysTryReturnVoidResult(NID_SEC, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
  99
 100         __pPrivilegeManagerInstance = &instance;
 101
 102         return;
 103 }
 104
 105 _PrivilegeManager*
 106 _PrivilegeManager::GetInstance(void)
 107 {
 108         result r = E_SUCCESS;
 109         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 110
 111         ClearLastResult();
 112
 113     if (__pPrivilegeManagerInstance == null)
 114     {
 115         pthread_once(&onceBlock, InitInstance);
 116
 117         r = GetLastResult();
 118         if (IsFailed(r))
 119         {
 120             onceBlock = PTHREAD_ONCE_INIT;
 121         }
 122     }
 123
 124     return __pPrivilegeManagerInstance;
 125 }
 126
 127 int GetPrivilegeListCallback (const char *privilege_name, void *user_data)
 128 {
 129         ArrayList* pPrivilegeList = static_cast<ArrayList*>(user_data);
 130         pPrivilegeList->Add(new String(privilege_name));
 131
 132         return 0;
 133 }
 134
 135 IList*
 136 _PrivilegeManager::GetPrivilegeListN(const AppId& appId)
 137 {
 138         ClearLastResult();
 139
 140         result r = E_SUCCESS;
 141         int res = PMINFO_R_OK;
 142         std::unique_ptr<ArrayList> pReturnPrivilegeList(null);
 143
 144         pReturnPrivilegeList.reset(new (std::nothrow) ArrayList());
 145         SysTryReturn(NID_SEC, pReturnPrivilegeList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 146
 147         r = pReturnPrivilegeList->Construct();
 148         SysTryReturn(NID_SEC, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 149
 150         std::unique_ptr<char[]> pPackageId(null);
 151         pPackageId.reset(_StringConverter::CopyToCharArrayN(appId));
 152         SysTryReturn(NID_SEC, pPackageId != null, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 153
 154         pkgmgrinfo_pkginfo_h handle;
 155         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &handle);
 156         SysTryReturn(NID_SEC, res == PMINFO_R_OK, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 157
 158         res = pkgmgrinfo_pkginfo_foreach_privilege(handle, GetPrivilegeListCallback, pReturnPrivilegeList.get());
 159         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
 160         SysTryReturn(NID_SEC, res == PMINFO_R_OK, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 161
 162         return pReturnPrivilegeList.release();
 163 }
 164
 165 result
 166 _PrivilegeManager::RetrieveCipherPrivilegeN(const AppId& appId, Tizen::Base::String& encryptedPrivileges, Tizen::Base::String& checksum, ArrayList*& pPrivilegeList)
 167 {
 168         result r = E_SUCCESS;
 169         ArrayList tempPrivilegeList;
 170
 171         encryptedPrivileges.Clear();
 172         checksum.Clear();
 173
 174         r = tempPrivilegeList.Construct();
 175         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 176
 177         _PackageInfoImpl infoImpl;
 178         r = infoImpl.Construct(appId);
 179         if (r == E_APP_NOT_INSTALLED)
 180         {
 181                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 182                 return E_DATA_NOT_FOUND;
 183         }
 184         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 185
 186         r = infoImpl.GetPrivileges(encryptedPrivileges, checksum, tempPrivilegeList);
 187         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 188         SysTryReturnResult(NID_SEC, encryptedPrivileges.IsEmpty() != true, E_DATA_NOT_FOUND, "The privilege information does not exist.");
 189         SysTryReturnResult(NID_SEC, checksum.IsEmpty() != true, E_SYSTEM, "An unexpected system error occurred.");
 190
 191         pPrivilegeList = new ArrayList;
 192         r = pPrivilegeList->Construct();
 193
 194         IEnumerator* pEnum = tempPrivilegeList.GetEnumeratorN();
 195         while (pEnum->MoveNext() == E_SUCCESS)
 196         {
 197                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
 198                 pPrivilegeList->Add(new String(*tempString));
 199         }
 200
 201         tempPrivilegeList.RemoveAll(true);
 202         return r;
 203 }
 204
 205 result
 206 _PrivilegeManager::RetrieveCipherPrivilegeExN(const AppId& appId, Tizen::Base::String& encryptedPrivileges, Tizen::Base::String& checksum, ArrayList*& pPrivilegeList)
 207 {
 208         result r = E_SUCCESS;
 209
 210         encryptedPrivileges.Clear();
 211         checksum.Clear();
 212
 213         String tempEncryptedPrivileges;
 214         String tempChecksum;
 215         ArrayList tempPrivilegeList;
 216
 217         r = tempPrivilegeList.Construct();
 218         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 219
 220         _PackageInfoImpl infoImpl;
 221         r = infoImpl.Construct(appId);
 222         if (r == E_APP_NOT_INSTALLED)
 223         {
 224                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 225                 return E_DATA_NOT_FOUND;
 226         }
 227         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 228
 229         r = infoImpl.GetPrivileges(tempEncryptedPrivileges, tempChecksum, tempPrivilegeList);
 230         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 231         SysTryReturnResult(NID_SEC, tempEncryptedPrivileges.IsEmpty() != true, E_DATA_NOT_FOUND, "The privilege information does not exist.");
 232         SysTryReturnResult(NID_SEC, tempChecksum.IsEmpty() != true, E_SYSTEM, "An unexpected system error occurred.");
 233
 234         _PrivilegeInfo privilegeInfo;
 235
 236         r = privilegeInfo.Construct(appId, tempEncryptedPrivileges, tempChecksum, &tempPrivilegeList);
 237         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 238
 239         r = privilegeInfo.GetEncryptedBitwise(encryptedPrivileges);
 240         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 241
 242         r = privilegeInfo.GetChecksum(checksum);
 243         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 244
 245         pPrivilegeList = new ArrayList;
 246         r = pPrivilegeList->Construct();
 247
 248         IEnumerator* pEnum = tempPrivilegeList.GetEnumeratorN();
 249         while (pEnum->MoveNext() == E_SUCCESS)
 250         {
 251                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
 252                 pPrivilegeList->Add(new String(*tempString));
 253         }
 254
 255         tempPrivilegeList.RemoveAll(true);
 256         return r;
 257 }
 258
 259 _PrivilegeInfo*
 260 _PrivilegeManager::RetrievePrivilegeInfoN(const AppId& appId) const
 261 {
 262         result r = E_SUCCESS;
 263
 264         String encryptedPrivileges;
 265         String checksum;
 266         std::unique_ptr<_PrivilegeInfo> pPrivilegeInfo(null);
 267         _PackageInfoImpl infoImpl;
 268         ArrayList* pPrivilegeList = null;
 269
 270         ClearLastResult();
 271
 272         pPrivilegeInfo.reset(__pPrivilegeCache->GetPrivilegeInfoN(appId));
 273         r = GetLastResult();
 274
 275         if (r == E_SUCCESS)
 276         {
 277                 // nothing to do.
 278         }
 279         else if (r == E_DATA_NOT_FOUND)
 280         {
 281                 r = RetrieveCipherPrivilegeN(appId, encryptedPrivileges, checksum, pPrivilegeList);
 282                 if (r == E_DATA_NOT_FOUND)
 283                 {
 284                         SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The privilege information does not exist.");
 285                         return null;
 286                 }
 287                 SysTryReturn(NID_SEC, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 288
 289                 pPrivilegeInfo.reset(new (std::nothrow) _PrivilegeInfo());
 290                 SysTryReturn(NID_SEC, pPrivilegeInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 291
 292                 r = pPrivilegeInfo->Construct(appId, encryptedPrivileges, checksum, pPrivilegeList);
 293                 SysTryReturn(NID_SEC, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 294
 295                 r = __pPrivilegeCache->AddPrivilegeInfo(*(pPrivilegeInfo.get()));
 296                 SysTryReturn(NID_SEC, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 297
 298                 if (pPrivilegeList != null)
 299                 {
 300                         pPrivilegeList->RemoveAll(true);
 301                         delete pPrivilegeList;
 302                 }
 303         }
 304         else
 305         {
 306                 r = E_SYSTEM;
 307                 SysLogException(NID_SEC, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 308                 return null;
 309         }
 310
 311         return pPrivilegeInfo.release();
 312 }
 313
 314
 315 IList*
 316 _PrivilegeManager::UnpackPrivilegeN(const byte* pBitwisePrivilege)
 317 {
 318         result r = E_SUCCESS;
 319         byte maskFlag = 0;
 320         int bitPosition = 0;
 321         int bytePosition = 0;
 322         int index = 0;
 323         int privilegeBit = 0;
 324         int privilegeEnum = 0;
 325         std::unique_ptr<ArrayList> pPrivilegeList(null);
 326
 327         ClearLastResult();
 328
 329         SysTryReturn(NID_SEC, pBitwisePrivilege != null, null, E_INVALID_ARG, "One of the argument is invalid.");
 330
 331         pPrivilegeList.reset(new (std::nothrow) ArrayList());
 332         SysTryReturn(NID_SEC, pPrivilegeList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 333
 334         r = pPrivilegeList->Construct();
 335         SysTryReturn(NID_SEC, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 336
 337         for (bytePosition = 0; bytePosition < MAX_BITWISE_PRIV_SIZE; bytePosition++)
 338         {
 339                 maskFlag = 1;
 340
 341                 if (!(pBitwisePrivilege[bytePosition] & 0xFF))
 342                 {
 343                         // Pass the checking of empty byte filed.
 344                         continue;
 345                 }
 346
 347                 for (bitPosition = 0; bitPosition < _BITS_IN_BYTE; bitPosition++)
 348                 {
 349                         privilegeBit = (int) (pBitwisePrivilege[bytePosition] & maskFlag);
 350                         if (!privilegeBit)
 351                         {
 352                                 // Shift the maskFlag by 1 bit when face the empty bit.
 353                                 maskFlag = maskFlag << 1;
 354                                 continue;
 355                         }
 356
 357                         privilegeEnum = (bytePosition * _BITS_IN_BYTE) + bitPosition;
 358
 359                         for (index = 0; index < _MAX_PRIVILEGE_ENUM; index++)
 360                         {
 361                                 if (privilegeEnum == privilegeListTable[index].privilege)
 362                                 {
 363                                         String* privilegeString = new (std::nothrow) String(L"http://tizen.org/privilege/");
 364                                         privilegeString->Append(privilegeListTable[index].privilegeString);
 365                                         SysTryCatch(NID_SEC, privilegeString != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 366                                                         "[E_OUT_OF_MEMORY]The memory is insufficient.");
 367
 368                                         pPrivilegeList->Add(*privilegeString);
 369                                         break;
 370                                 }
 371                         }
 372
 373                         // Shift the maskFlag by 1 bit to check the next byte filed.
 374                         maskFlag = maskFlag << 1;
 375                 }
 376         }
 377
 378         return pPrivilegeList.release();
 379
 380 CATCH:
 381
 382         pPrivilegeList->RemoveAll(true);
 383         return null;
 384 }
 385
 386 void
 387 _PrivilegeManager::OnPackageInstallationCompleted(const PackageId& packageId, PackageInstallationResult installationResult)
 388 {
 389         __pPrivilegeCache->RemovePrivilegeInfo(packageId);
 390         SysLog(NID_SEC, "%ls is removed.", packageId.GetPointer());
 391
 392         return;
 393 }
 394
 395 }} //Tizen::Security