src/security/FSec_PrivilegeInfo.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FSec_PrivilegeManagerInfo.cpp
  20  * @brief               This is the implementation for the Privilege Information class.
  21  */
  22
  23 #include <unique_ptr.h>
  24 #include <stdlib.h>
  25 #include <FBaseSysLog.h>
  26 #include <FBase_StringConverter.h>
  27 #include <FBaseString.h>
  28 #include <FAppPkg_PackageInfoImpl.h>
  29 #include <FSecCryptoAesCipher.h>
  30 #include <FSecCryptoSha1Hmac.h>
  31 #include <FSecCryptoSha1Hash.h>
  32 #include <FBaseColArrayList.h>
  33
  34 #include "FSec_DeviceKeyGenerator.h"
  35 #include "FSec_PrivilegeInfo.h"
  36
  37 using namespace Tizen::App;
  38 using namespace Tizen::App::Package;
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Base::Collection;
  41 using namespace Tizen::Base::Utility;
  42 using namespace Tizen::Security::Crypto;
  43 using namespace Tizen::Text;
  44
  45 namespace Tizen { namespace Security
  46 {
  47
  48 _PrivilegeInfo::_PrivilegeInfo(void)
  49 {
  50         memset(__bitwisePrivilege, 0, MAX_BITWISE_PRIV_SIZE);
  51         __bitwiseLength = 0;
  52         __apiVisibility = 0;
  53 }
  54
  55 _PrivilegeInfo::~_PrivilegeInfo(void)
  56 {
  57         __privilegeList.RemoveAll(true);
  58 }
  59
  60 result
  61 _PrivilegeInfo::Construct(const AppId& appId, const byte* pBitwisePrivilege, const ArrayList* pPrivilegeList)
  62 {
  63         result r = E_SUCCESS;
  64
  65         SysTryReturnResult(NID_SEC, (pBitwisePrivilege != null), E_INVALID_ARG, "One of the argument is invalid.");
  66         SysTryReturnResult(NID_SEC,
  67                                           appId.GetLength() > 0 && appId.GetLength() == MAX_APP_ID_SIZE, E_INVALID_ARG,
  68                                           "One of the argument is invalid.");
  69
  70         // Set base length of privilege information to max
  71         __bitwiseLength = MAX_BITWISE_PRIV_SIZE;
  72
  73         __appId = appId;
  74         memcpy(__bitwisePrivilege, pBitwisePrivilege, __bitwiseLength);
  75
  76
  77         std::unique_ptr<IEnumerator> pEnum(null);
  78         r = __privilegeList.Construct();
  79         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
  80
  81         pEnum.reset(pPrivilegeList->GetEnumeratorN());
  82         SysTryReturnResult(NID_SEC, pEnum != null, E_SYSTEM, "An unexpected system error occurred.");
  83
  84         while (pEnum->MoveNext() == E_SUCCESS)
  85         {
  86                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
  87                 __privilegeList.Add(new String(*tempString));
  88         }
  89
  90         return r;
  91 }
  92
  93 result
  94 _PrivilegeInfo::Construct(const AppId& appId, const String& encryptedPrivileges, const String& checksum, const ArrayList* pPrivilegeList)
  95 {
  96         result r = E_SUCCESS;
  97         byte* pDecrytpedBitwisePrivilege = null;
  98
  99         std::unique_ptr<ByteBuffer> pBitwisePrivilege(null);
 100         _PackageInfoImpl infoImpl;
 101
 102         SysTryReturnResult(NID_SEC,
 103                                           appId.GetLength() > 0 && appId.GetLength() == MAX_APP_ID_SIZE, E_INVALID_ARG,
 104                                           "One of the argument is invalid.");
 105         SysTryReturnResult(NID_SEC, encryptedPrivileges.GetLength() > 0, E_INVALID_ARG, "One of the argument is invalid.");
 106         SysTryReturnResult(NID_SEC, checksum.GetLength() > 0, E_INVALID_ARG, "One of the argument is invalid.");
 107
 108         pBitwisePrivilege.reset(StringUtil::DecodeBase64StringN(encryptedPrivileges));
 109         SysTryReturnResult(NID_SEC, pBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 110
 111         pDecrytpedBitwisePrivilege = const_cast <byte*>(pBitwisePrivilege->GetPointer());
 112         SysTryReturnResult(NID_SEC, pDecrytpedBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 113
 114         r = VerifyIntegrity(appId, pDecrytpedBitwisePrivilege, checksum, pBitwisePrivilege->GetLimit());
 115         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_INVALID_ARG, "The checksum is abnormal.");
 116
 117         // Set base length of privilege information
 118         __bitwiseLength = pBitwisePrivilege->GetLimit();
 119
 120         memcpy(__bitwisePrivilege, pDecrytpedBitwisePrivilege, __bitwiseLength);
 121         __appId = appId;
 122
 123         r = infoImpl.Construct(appId);
 124         if (r == E_APP_NOT_INSTALLED)
 125         {
 126                 SysLogException(NID_SEC, E_DATA_NOT_FOUND, "[E_DATA_NOT_FOUND] The package information does not exist.");
 127                 return E_DATA_NOT_FOUND;
 128         }
 129         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 130
 131         __apiVisibility = infoImpl.GetApiVisibility();
 132         SysTryReturnResult(NID_SEC, __apiVisibility >= 0, E_SYSTEM, "An unexpected system error occurred.");
 133
 134         std::unique_ptr<IEnumerator> pEnum(null);
 135         r = __privilegeList.Construct();
 136         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 137
 138         pEnum.reset(pPrivilegeList->GetEnumeratorN());
 139         SysTryReturnResult(NID_SEC, pEnum != null, E_SYSTEM, "An unexpected system error occurred.");
 140
 141         while (pEnum->MoveNext() == E_SUCCESS)
 142         {
 143                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
 144                 __privilegeList.Add(new String(*tempString));
 145         }
 146
 147         return r;
 148 }
 149
 150 result
 151 _PrivilegeInfo::Construct(const AppId& appId, const String& encryptedPrivileges, const String& checksum, const String& encryptedVisibiliity, const String& visibilityChecksum, const ArrayList* pPrivilegeList)
 152 {
 153         result r = E_SUCCESS;
 154         byte* pDecrytpedBitwisePrivilege = null;
 155         int visibility = 0;
 156
 157         ByteBuffer ivByte;
 158         std::unique_ptr<ISecretKey> pKey(null);
 159         std::unique_ptr<ByteBuffer> pEncryptedBitwisePrivilege(null);
 160         std::unique_ptr<ByteBuffer> pBitwisePrivilege(null);
 161         std::unique_ptr<ByteBuffer> pEncryptedVisibility(null);
 162         std::unique_ptr<ByteBuffer> pVisibility(null);
 163         AesCipher cipherDec;
 164         _PackageInfoImpl infoImpl;
 165         const byte ivector[_IV_LEN] =
 166         {
 167                 0x3E, 0xB5, 0x01, 0x45, 0xE4, 0xF8, 0x75, 0x3F,
 168                 0x08, 0x9D, 0x9F, 0x57, 0x3B, 0x63, 0xEF, 0x4B
 169         };
 170
 171         SysTryReturnResult(NID_SEC,
 172                                           appId.GetLength() > 0 && appId.GetLength() == MAX_APP_ID_SIZE, E_INVALID_ARG,
 173                                           "One of the argument is invalid.");
 174         SysTryReturnResult(NID_SEC, encryptedPrivileges.GetLength() > 0, E_INVALID_ARG, "One of the argument is invalid.");
 175         SysTryReturnResult(NID_SEC, checksum.GetLength() > 0, E_INVALID_ARG, "One of the argument is invalid.");
 176
 177         pEncryptedBitwisePrivilege.reset(StringUtil::DecodeBase64StringN(encryptedPrivileges));
 178         SysTryReturnResult(NID_SEC, pEncryptedBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 179
 180         pEncryptedVisibility.reset(StringUtil::DecodeBase64StringN(encryptedVisibiliity));
 181         SysTryReturnResult(NID_SEC, pEncryptedVisibility != null, E_SYSTEM, "An unexpected system error occurred.");
 182
 183         r = ivByte.Construct(_IV_LEN);
 184         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 185
 186         r = ivByte.SetArray(ivector, 0, _IV_LEN);
 187         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 188         ivByte.Flip();
 189
 190         r = cipherDec.Construct(L"CBC/128/PKCS7PADDING", CIPHER_DECRYPT);
 191         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 192
 193         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 194         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "An unexpected system error occurred.");
 195
 196         r = cipherDec.SetKey(*pKey.get());
 197         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 198
 199         r = cipherDec.SetInitialVector(ivByte);
 200         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 201
 202         pBitwisePrivilege.reset(cipherDec.DecryptN(*pEncryptedBitwisePrivilege.get()));
 203         SysTryReturnResult(NID_SEC, pBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 204
 205         pVisibility.reset(cipherDec.DecryptN(*pEncryptedVisibility.get()));
 206         SysTryReturnResult(NID_SEC, pBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 207
 208         pDecrytpedBitwisePrivilege = const_cast <byte*>(pBitwisePrivilege->GetPointer());
 209         SysTryReturnResult(NID_SEC, pDecrytpedBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 210
 211         visibility = static_cast<int>(*(pVisibility->GetPointer()));
 212
 213         r = VerifyIntegrity(appId, pDecrytpedBitwisePrivilege, checksum, pBitwisePrivilege->GetLimit(), visibility, visibilityChecksum);
 214         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_INVALID_ARG, "The checksum is abnormal.");
 215
 216         // Set base length of privilege information
 217         __bitwiseLength = pBitwisePrivilege->GetLimit();
 218
 219         memcpy(__bitwisePrivilege, pDecrytpedBitwisePrivilege, __bitwiseLength);
 220         __appId = appId;
 221
 222         __apiVisibility = visibility;
 223
 224         std::unique_ptr<IEnumerator> pEnum(null);
 225         r = __privilegeList.Construct();
 226         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 227
 228         pEnum.reset(pPrivilegeList->GetEnumeratorN());
 229         SysTryReturnResult(NID_SEC, pEnum != null, E_SYSTEM, "An unexpected system error occurred.");
 230
 231         while (pEnum->MoveNext() == E_SUCCESS)
 232         {
 233                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
 234                 __privilegeList.Add(new String(*tempString));
 235         }
 236
 237         return r;
 238 }
 239
 240
 241 _PrivilegeInfo*
 242 _PrivilegeInfo::CloneN(void) const
 243 {
 244         _PrivilegeInfo* pPrivilegeInfo = null;
 245         result r = E_SUCCESS;
 246
 247         ClearLastResult();
 248
 249         pPrivilegeInfo = new (std::nothrow) _PrivilegeInfo();
 250         SysTryReturn(NID_SEC, pPrivilegeInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 251
 252         pPrivilegeInfo->__bitwiseLength = this->__bitwiseLength;
 253
 254         pPrivilegeInfo->__appId.Clear();
 255         pPrivilegeInfo->__appId.Append(this->__appId);
 256         memcpy(pPrivilegeInfo->__bitwisePrivilege, this->__bitwisePrivilege, pPrivilegeInfo->__bitwiseLength);
 257
 258         std::unique_ptr<IEnumerator> pEnum(null);
 259         r = pPrivilegeInfo->__privilegeList.Construct();
 260         SysTryCatch(NID_SEC, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 261
 262         pEnum.reset(this->__privilegeList.GetEnumeratorN());
 263         SysTryCatch(NID_SEC, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 264
 265         while (pEnum->MoveNext() == E_SUCCESS)
 266         {
 267                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
 268                 pPrivilegeInfo->__privilegeList.Add(new String(*tempString));
 269         }
 270
 271         return pPrivilegeInfo;
 272
 273 CATCH:
 274
 275         SetLastResult(r);
 276
 277         delete pPrivilegeInfo;
 278         return null;
 279 }
 280
 281 result
 282 _PrivilegeInfo::Construct(const _PrivilegeInfo& privilegeInfo)
 283 {
 284         result r = E_SUCCESS;
 285
 286         SysTryReturnResult(NID_SEC, privilegeInfo.__appId.GetLength() > 0 && privilegeInfo.__appId.GetLength() == MAX_APP_ID_SIZE, E_INVALID_ARG, "The argument is invalid.");
 287
 288         __bitwiseLength = privilegeInfo.__bitwiseLength;
 289
 290         __appId = privilegeInfo.__appId;
 291         memcpy(__bitwisePrivilege, privilegeInfo.__bitwisePrivilege, __bitwiseLength);
 292
 293         __apiVisibility = privilegeInfo.__apiVisibility;
 294
 295         __privilegeList.Construct();
 296
 297         IEnumerator* pEnum = privilegeInfo.__privilegeList.GetEnumeratorN();
 298         while (pEnum->MoveNext() == E_SUCCESS)
 299         {
 300                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
 301                 __privilegeList.Add(new String(*tempString));
 302         }
 303
 304         delete pEnum;
 305         return r;
 306 }
 307
 308 const String
 309 _PrivilegeInfo::GetAppId(void) const
 310 {
 311         return __appId;
 312 }
 313
 314 result
 315 _PrivilegeInfo::GetBitwisePrivilegeN(byte*& pBitwisePrivilege) const
 316 {
 317         byte* pReturn = null;
 318         result r = E_SUCCESS;
 319
 320         pReturn = (byte*) malloc(sizeof(byte) * MAX_BITWISE_PRIV_SIZE);
 321         SysTryReturnResult(NID_SEC, pReturn != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 322         memcpy(pReturn, __bitwisePrivilege, MAX_BITWISE_PRIV_SIZE);
 323
 324         pBitwisePrivilege = pReturn;
 325
 326         return r;
 327 }
 328
 329 result
 330 _PrivilegeInfo::GetEncryptedBitwise(String& encryptedPrivileges) const
 331 {
 332         result r = E_SUCCESS;
 333         ByteBuffer ivByte;
 334         std::unique_ptr<ISecretKey> pKey(null);
 335         std::unique_ptr<ByteBuffer> pEncryptedBitwisePrivilege(null);
 336         std::unique_ptr<ByteBuffer> pBitwisePrivilege(null);
 337         AesCipher cipherEnc;
 338         const byte ivector[_IV_LEN] = { 0x3E, 0xB5, 0x01, 0x45, 0xE4, 0xF8, 0x75, 0x3F, 0x08, 0x9D, 0x9F, 0x57, 0x3B, 0x63, 0xEF, 0x4B};
 339
 340         pBitwisePrivilege.reset(new (std::nothrow) ByteBuffer());
 341         SysTryReturnResult(NID_SEC, pBitwisePrivilege != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 342
 343         r = pBitwisePrivilege->Construct(__bitwiseLength);
 344         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 345
 346         r = ivByte.Construct(_IV_LEN);
 347         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 348
 349         r = ivByte.SetArray(ivector, 0, _IV_LEN);
 350         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 351         ivByte.Flip();
 352
 353         r = pBitwisePrivilege->SetArray(__bitwisePrivilege, 0, __bitwiseLength);
 354         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 355         pBitwisePrivilege->Flip();
 356
 357         r = cipherEnc.Construct(L"CBC/128/PKCS7PADDING", CIPHER_ENCRYPT);
 358         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 359
 360         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 361         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "An unexpected system error occurred.");
 362
 363         r = cipherEnc.SetKey(*(pKey.get()));
 364         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 365
 366         r = cipherEnc.SetInitialVector(ivByte);
 367         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 368
 369         pEncryptedBitwisePrivilege.reset(cipherEnc.EncryptN(*(pBitwisePrivilege.get())));
 370         SysTryReturnResult(NID_SEC, pEncryptedBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 371
 372         r = StringUtil::EncodeToBase64String(*(pEncryptedBitwisePrivilege.get()), encryptedPrivileges);
 373         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 374
 375         return r;
 376 }
 377
 378 result
 379 _PrivilegeInfo::GetChecksum(String& checksum) const
 380 {
 381         result r = E_SUCCESS;
 382         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 383
 384         ByteBuffer ivByte;
 385         ByteBuffer input;
 386         std::unique_ptr<ISecretKey> pKey(null);
 387         std::unique_ptr<IHmac> pHmac(null);
 388         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 389         std::unique_ptr<char[]> pAppId(null);
 390
 391         pAppId.reset(_StringConverter::CopyToCharArrayN(__appId));
 392         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 393
 394         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 395         memcpy(tempChecksumString + MAX_APP_ID_SIZE, __bitwisePrivilege, __bitwiseLength);
 396
 397         pAppId.reset(null);
 398
 399         r = input.Construct(MAX_APP_ID_SIZE + __bitwiseLength);
 400         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 401
 402         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + __bitwiseLength);
 403         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 404         input.Flip();
 405
 406         pHmac.reset(new (std::nothrow) Sha1Hmac());
 407         SysTryReturnResult(NID_SEC, pHmac != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 408
 409         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 410         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 411
 412         r = pHmac->SetKey(*(pKey.get()));
 413         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 414
 415         pChecksumByteBuffer.reset(pHmac->GetHmacN(input));
 416         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 417
 418         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), checksum);
 419         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 420
 421         return r;
 422 }
 423
 424 bool
 425 _PrivilegeInfo::HasPrivilege(_Privilege privilege) const
 426 {
 427         bool ret = false;
 428         int targetIndex = static_cast< int >(privilege) / _BITS_IN_BYTE;
 429         byte privilegeBit = (byte) (static_cast< int >(privilege) % _BITS_IN_BYTE);
 430         byte bitwiseTargetPrivilege = 0;
 431         byte tempBitwisePrivilege = 0;
 432
 433         if (__apiVisibility != _API_VISIBILITY_NONE) // To be removed
 434         {
 435                 if (visibilityLevelListTable[privilege][_PRV_API_VER_2_0] > __apiVisibility)
 436                 {
 437                         SysLog(NID_SEC, "Result : FALSE [Visibility]");
 438                         return ret;
 439                 }
 440         }
 441
 442         bitwiseTargetPrivilege = bitwiseTargetPrivilege | (1 << privilegeBit);
 443         tempBitwisePrivilege = __bitwisePrivilege[targetIndex] & bitwiseTargetPrivilege;
 444
 445         if (bitwiseTargetPrivilege == tempBitwisePrivilege)
 446         {
 447                 SysLog(NID_SEC, "Result : TRUE");
 448                 ret = true;
 449         }
 450         else
 451         {
 452                 SysLogException(NID_SEC, E_PRIVILEGE_DENIED, "Result : FALSE [%ls, %ls]", __appId.GetPointer(), privilegeListTable[privilege].privilegeString);
 453         }
 454
 455         return ret;
 456 }
 457
 458 bool
 459 _PrivilegeInfo::HasPrivilegeEx(_Privilege privilege) const
 460 {
 461         bool ret = false;
 462         int targetIndex = static_cast< int >(privilege) / _BITS_IN_BYTE;
 463         byte privilegeBit = (byte) (static_cast< int >(privilege) % _BITS_IN_BYTE);
 464         byte bitwiseTargetPrivilege = 0;
 465         byte tempBitwisePrivilege = 0;
 466
 467         if (__apiVisibility != _API_VISIBILITY_NONE) // To be removed
 468         {
 469                 if (visibilityLevelListTable[privilege][_PRV_API_VER_2_0] > __apiVisibility)
 470                 {
 471                         return ret;
 472                 }
 473         }
 474
 475         bitwiseTargetPrivilege = bitwiseTargetPrivilege | (1 << privilegeBit);
 476         tempBitwisePrivilege = __bitwisePrivilege[targetIndex] & bitwiseTargetPrivilege;
 477
 478         if (bitwiseTargetPrivilege == tempBitwisePrivilege)
 479         {
 480                 SysLog(NID_SEC, "Result : TRUE");
 481                 ret = true;
 482         }
 483
 484         return ret;
 485 }
 486
 487 bool
 488 _PrivilegeInfo::HasPrivilege(const String& privilege) const
 489 {
 490     bool ret = false;
 491     bool validStringFlag = false;
 492     int privilegeEnum = -1;
 493     int index = 0;
 494
 495         String privilegeURI = L"http://tizen.org/privilege/";
 496     String privilegeSubString;
 497     String privilegeSubStringURI;
 498     privilege.SubString(0, privilegeURI.GetLength(), privilegeSubStringURI);
 499
 500     if (privilegeSubStringURI.Equals(privilegeURI, true))
 501     {
 502         privilege.SubString(privilegeURI.GetLength(), privilege.GetLength() - privilegeURI.GetLength(), privilegeSubString);
 503         for (index = 0; index < _MAX_PRIVILEGE_ENUM; index++)
 504                 {
 505                         if (wcscmp(privilegeListTable[index].privilegeString, privilegeSubString.GetPointer()) == 0)
 506                         {
 507                                 validStringFlag = true;
 508                                 privilegeEnum = index;
 509                                 break;
 510                         }
 511                 }
 512     }
 513
 514     if (validStringFlag)
 515     {
 516         ret = HasPrivilege(privilegeListTable[index].privilege);
 517
 518     }
 519     else
 520     {
 521         ret = __privilegeList.Contains(privilege);
 522         if (ret)
 523                 {
 524                         SysLog(NID_SEC, "Result : TRUE");
 525                 }
 526                 else
 527                 {
 528                         SysLogException(NID_SEC, E_PRIVILEGE_DENIED, "Result : FALSE [%ls, %ls]", __appId.GetPointer(), privilege.GetPointer());
 529                 }
 530     }
 531
 532         return ret;
 533 }
 534
 535 result
 536 _PrivilegeInfo::VerifyIntegrity(const AppId& appId, const byte* targetBitwisePrivilege, const Tizen::Base::String& storedChecksum, int length)
 537 {
 538         result r = E_SUCCESS;
 539         bool verifyResult = false;
 540         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 541         String base64EncodedChecksum;
 542         ByteBuffer input;
 543         std::unique_ptr<IHash> pHash(null);
 544         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 545         std::unique_ptr<char> pAppId(null);
 546
 547         SysTryReturnResult(NID_SEC, length <= MAX_BITWISE_PRIV_SIZE, E_INVALID_ARG, "The privilege information of %ls is invalid.", appId.GetPointer());
 548
 549         pAppId.reset(_StringConverter::CopyToCharArrayN(appId));
 550         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 551
 552         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 553         memcpy(tempChecksumString + MAX_APP_ID_SIZE, targetBitwisePrivilege, length);
 554
 555         pAppId.reset(null);
 556
 557         r = input.Construct(MAX_APP_ID_SIZE + length);
 558         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 559
 560         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + length);
 561         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 562         input.Flip();
 563
 564         pHash.reset(new (std::nothrow) Sha1Hash());
 565         SysTryReturnResult(NID_SEC, pHash != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 566
 567         pChecksumByteBuffer.reset(pHash->GetHashN(input));
 568         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 569
 570         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), base64EncodedChecksum);
 571         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 572
 573         verifyResult = storedChecksum.Equals(base64EncodedChecksum, true);
 574         if (verifyResult != true)
 575         {
 576                 r = E_INVALID_ARG;
 577         }
 578
 579         return r;
 580 }
 581
 582 result
 583 _PrivilegeInfo::VerifyIntegrityEx(const AppId& appId, const byte* targetBitwisePrivilege, const Tizen::Base::String& storedChecksum, int length)
 584 {
 585         result r = E_SUCCESS;
 586         bool verifyResult = false;
 587         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 588         String base64EncodedChecksum;
 589         ByteBuffer ivByte;
 590         ByteBuffer input;
 591         std::unique_ptr<IHmac> pHmac(null);
 592         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 593         std::unique_ptr<ISecretKey> pKey(null);
 594         std::unique_ptr<char[]> pAppId(null);
 595
 596         SysTryReturnResult(NID_SEC, length <= MAX_BITWISE_PRIV_SIZE, E_INVALID_ARG, "The privilege information of [%ls] is invalid.", appId.GetPointer());
 597
 598         pAppId.reset(_StringConverter::CopyToCharArrayN(appId));
 599         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 600
 601         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 602         memcpy(tempChecksumString + MAX_APP_ID_SIZE, targetBitwisePrivilege, length);
 603
 604         pAppId.reset(null);
 605
 606         r = input.Construct(MAX_APP_ID_SIZE + length);
 607         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 608
 609         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + length);
 610         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 611         input.Flip();
 612
 613         pHmac.reset(new (std::nothrow) Sha1Hmac());
 614         SysTryReturnResult(NID_SEC, pHmac != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 615
 616         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 617         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "An unexpected system error occurred.");
 618
 619         r = pHmac->SetKey(*(pKey.get()));
 620         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 621
 622         pChecksumByteBuffer.reset(pHmac->GetHmacN(input));
 623         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 624
 625         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), base64EncodedChecksum);
 626         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 627
 628         verifyResult = storedChecksum.Equals(base64EncodedChecksum, true);
 629         if (verifyResult != true)
 630         {
 631                 r = E_INVALID_ARG;
 632         }
 633
 634         return r;
 635 }
 636
 637 result
 638 _PrivilegeInfo::VerifyIntegrity(const AppId& appId, const byte* targetBitwisePrivilege, const Tizen::Base::String& storedChecksum, int length, int visibility, const Tizen::Base::String& storedVisibilityChecksum)
 639 {
 640         result r = E_SUCCESS;
 641         bool verifyResult = false;
 642         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 643         byte tempVisibilityChecksumString[sizeof(int) + MAX_APP_ID_SIZE];
 644         String base64EncodedChecksum;
 645         String base64EncodedVisibilityChecksum;
 646         ByteBuffer ivByte;
 647         ByteBuffer input;
 648         ByteBuffer visibilityInput;
 649         std::unique_ptr<IHmac> pHmac(null);
 650         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 651         std::unique_ptr<ByteBuffer> pVisibilityChecksumByteBuffer(null);
 652         std::unique_ptr<ISecretKey> pKey(null);
 653         std::unique_ptr<char[]> pAppId(null);
 654
 655         SysTryReturnResult(NID_SEC, length <= MAX_BITWISE_PRIV_SIZE, E_INVALID_ARG, "The privilege information of [%ls] is invalid.", appId.GetPointer());
 656
 657         pAppId.reset(_StringConverter::CopyToCharArrayN(appId));
 658         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 659
 660         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 661         memcpy(tempChecksumString + MAX_APP_ID_SIZE, targetBitwisePrivilege, length);
 662
 663         memcpy(tempVisibilityChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 664         memcpy(tempVisibilityChecksumString + MAX_APP_ID_SIZE, (byte*)(&visibility), sizeof(int));
 665
 666         pAppId.reset(null);
 667
 668         r = input.Construct(MAX_APP_ID_SIZE + length);
 669         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 670
 671         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + length);
 672         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 673         input.Flip();
 674
 675         r = visibilityInput.Construct(MAX_APP_ID_SIZE + sizeof(int));
 676         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 677
 678         r = visibilityInput.SetArray(tempVisibilityChecksumString, 0, MAX_APP_ID_SIZE + sizeof(int));
 679         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 680         visibilityInput.Flip();
 681
 682         pHmac.reset(new (std::nothrow) Sha1Hmac());
 683         SysTryReturnResult(NID_SEC, pHmac != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 684
 685         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 686         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "An unexpected system error occurred.");
 687
 688         r = pHmac->SetKey(*(pKey.get()));
 689         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 690
 691         pChecksumByteBuffer.reset(pHmac->GetHmacN(input));
 692         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 693
 694         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), base64EncodedChecksum);
 695         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 696
 697         verifyResult = storedChecksum.Equals(base64EncodedChecksum, true);
 698         if (verifyResult != true)
 699         {
 700                 r = E_INVALID_ARG;
 701         }
 702
 703         pVisibilityChecksumByteBuffer.reset(pHmac->GetHmacN(visibilityInput));
 704         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 705
 706         r = StringUtil::EncodeToBase64String(*(pVisibilityChecksumByteBuffer.get()), base64EncodedVisibilityChecksum);
 707         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 708
 709         verifyResult = storedVisibilityChecksum.Equals(base64EncodedVisibilityChecksum, true);
 710         if (verifyResult != true)
 711         {
 712                 r = E_INVALID_ARG;
 713         }
 714
 715         return r;
 716 }
 717
 718 }} //Tizen::Security