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