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         SysTryReturn(NID_SEC, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 261
 262         pEnum.reset(this->__privilegeList.GetEnumeratorN());
 263         SysTryReturn(NID_SEC, pEnum != null, null, 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
 274 result
 275 _PrivilegeInfo::Construct(const _PrivilegeInfo& privilegeInfo)
 276 {
 277         result r = E_SUCCESS;
 278
 279         SysTryReturnResult(NID_SEC, privilegeInfo.__appId.GetLength() > 0 && privilegeInfo.__appId.GetLength() == MAX_APP_ID_SIZE, E_INVALID_ARG, "The argument is invalid.");
 280
 281         __bitwiseLength = privilegeInfo.__bitwiseLength;
 282
 283         __appId = privilegeInfo.__appId;
 284         memcpy(__bitwisePrivilege, privilegeInfo.__bitwisePrivilege, __bitwiseLength);
 285
 286         __apiVisibility = privilegeInfo.__apiVisibility;
 287
 288         __privilegeList.Construct();
 289
 290         IEnumerator* pEnum = privilegeInfo.__privilegeList.GetEnumeratorN();
 291         while (pEnum->MoveNext() == E_SUCCESS)
 292         {
 293                 String* tempString = static_cast< String* >(pEnum->GetCurrent());
 294                 __privilegeList.Add(new String(*tempString));
 295         }
 296
 297         delete pEnum;
 298         return r;
 299 }
 300
 301 const String
 302 _PrivilegeInfo::GetAppId(void) const
 303 {
 304         return __appId;
 305 }
 306
 307 result
 308 _PrivilegeInfo::GetBitwisePrivilegeN(byte*& pBitwisePrivilege) const
 309 {
 310         byte* pReturn = null;
 311         result r = E_SUCCESS;
 312
 313         pReturn = (byte*) malloc(sizeof(byte) * MAX_BITWISE_PRIV_SIZE);
 314         SysTryReturnResult(NID_SEC, pReturn != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 315         memcpy(pReturn, __bitwisePrivilege, MAX_BITWISE_PRIV_SIZE);
 316
 317         pBitwisePrivilege = pReturn;
 318
 319         return r;
 320 }
 321
 322 result
 323 _PrivilegeInfo::GetEncryptedBitwise(String& encryptedPrivileges) const
 324 {
 325         result r = E_SUCCESS;
 326         ByteBuffer ivByte;
 327         std::unique_ptr<ISecretKey> pKey(null);
 328         std::unique_ptr<ByteBuffer> pEncryptedBitwisePrivilege(null);
 329         std::unique_ptr<ByteBuffer> pBitwisePrivilege(null);
 330         AesCipher cipherEnc;
 331         const byte ivector[_IV_LEN] = { 0x3E, 0xB5, 0x01, 0x45, 0xE4, 0xF8, 0x75, 0x3F, 0x08, 0x9D, 0x9F, 0x57, 0x3B, 0x63, 0xEF, 0x4B};
 332
 333         pBitwisePrivilege.reset(new (std::nothrow) ByteBuffer());
 334         SysTryReturnResult(NID_SEC, pBitwisePrivilege != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 335
 336         r = pBitwisePrivilege->Construct(__bitwiseLength);
 337         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 338
 339         r = ivByte.Construct(_IV_LEN);
 340         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 341
 342         r = ivByte.SetArray(ivector, 0, _IV_LEN);
 343         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 344         ivByte.Flip();
 345
 346         r = pBitwisePrivilege->SetArray(__bitwisePrivilege, 0, __bitwiseLength);
 347         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 348         pBitwisePrivilege->Flip();
 349
 350         r = cipherEnc.Construct(L"CBC/128/PKCS7PADDING", CIPHER_ENCRYPT);
 351         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 352
 353         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 354         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "An unexpected system error occurred.");
 355
 356         r = cipherEnc.SetKey(*(pKey.get()));
 357         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 358
 359         r = cipherEnc.SetInitialVector(ivByte);
 360         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 361
 362         pEncryptedBitwisePrivilege.reset(cipherEnc.EncryptN(*(pBitwisePrivilege.get())));
 363         SysTryReturnResult(NID_SEC, pEncryptedBitwisePrivilege != null, E_SYSTEM, "An unexpected system error occurred.");
 364
 365         r = StringUtil::EncodeToBase64String(*(pEncryptedBitwisePrivilege.get()), encryptedPrivileges);
 366         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 367
 368         return r;
 369 }
 370
 371 result
 372 _PrivilegeInfo::GetChecksum(String& checksum) const
 373 {
 374         result r = E_SUCCESS;
 375         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 376
 377         ByteBuffer ivByte;
 378         ByteBuffer input;
 379         std::unique_ptr<ISecretKey> pKey(null);
 380         std::unique_ptr<IHmac> pHmac(null);
 381         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 382         std::unique_ptr<char[]> pAppId(null);
 383
 384         pAppId.reset(_StringConverter::CopyToCharArrayN(__appId));
 385         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 386
 387         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 388         memcpy(tempChecksumString + MAX_APP_ID_SIZE, __bitwisePrivilege, __bitwiseLength);
 389
 390         pAppId.reset(null);
 391
 392         r = input.Construct(MAX_APP_ID_SIZE + __bitwiseLength);
 393         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 394
 395         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + __bitwiseLength);
 396         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 397         input.Flip();
 398
 399         pHmac.reset(new (std::nothrow) Sha1Hmac());
 400         SysTryReturnResult(NID_SEC, pHmac != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation is failed.");
 401
 402         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 403         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 404
 405         r = pHmac->SetKey(*(pKey.get()));
 406         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 407
 408         pChecksumByteBuffer.reset(pHmac->GetHmacN(input));
 409         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 410
 411         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), checksum);
 412         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] An unexpected system error occurred.");
 413
 414         return r;
 415 }
 416
 417 bool
 418 _PrivilegeInfo::HasPrivilege(_Privilege privilege) const
 419 {
 420         bool ret = false;
 421         int targetIndex = static_cast< int >(privilege) / _BITS_IN_BYTE;
 422         byte privilegeBit = (byte) (static_cast< int >(privilege) % _BITS_IN_BYTE);
 423         byte bitwiseTargetPrivilege = 0;
 424         byte tempBitwisePrivilege = 0;
 425
 426         if (__apiVisibility != _API_VISIBILITY_NONE) // To be removed
 427         {
 428                 if (visibilityLevelListTable[privilege][_PRV_API_VER_2_0] > __apiVisibility)
 429                 {
 430                         SysLog(NID_SEC, "Result : FALSE [Visibility]");
 431                         return ret;
 432                 }
 433         }
 434
 435         bitwiseTargetPrivilege = bitwiseTargetPrivilege | (1 << privilegeBit);
 436         tempBitwisePrivilege = __bitwisePrivilege[targetIndex] & bitwiseTargetPrivilege;
 437
 438         if (bitwiseTargetPrivilege == tempBitwisePrivilege)
 439         {
 440                 SysLog(NID_SEC, "Result : TRUE");
 441                 ret = true;
 442         }
 443         else
 444         {
 445                 SysLogException(NID_SEC, E_PRIVILEGE_DENIED, "Result : FALSE [%ls, %ls]", __appId.GetPointer(), privilegeListTable[privilege].privilegeString);
 446         }
 447
 448         return ret;
 449 }
 450
 451 bool
 452 _PrivilegeInfo::HasPrivilegeEx(_Privilege privilege) const
 453 {
 454         bool ret = false;
 455         int targetIndex = static_cast< int >(privilege) / _BITS_IN_BYTE;
 456         byte privilegeBit = (byte) (static_cast< int >(privilege) % _BITS_IN_BYTE);
 457         byte bitwiseTargetPrivilege = 0;
 458         byte tempBitwisePrivilege = 0;
 459
 460         if (__apiVisibility != _API_VISIBILITY_NONE) // To be removed
 461         {
 462                 if (visibilityLevelListTable[privilege][_PRV_API_VER_2_0] > __apiVisibility)
 463                 {
 464                         return ret;
 465                 }
 466         }
 467
 468         bitwiseTargetPrivilege = bitwiseTargetPrivilege | (1 << privilegeBit);
 469         tempBitwisePrivilege = __bitwisePrivilege[targetIndex] & bitwiseTargetPrivilege;
 470
 471         if (bitwiseTargetPrivilege == tempBitwisePrivilege)
 472         {
 473                 SysLog(NID_SEC, "Result : TRUE");
 474                 ret = true;
 475         }
 476
 477         return ret;
 478 }
 479
 480 bool
 481 _PrivilegeInfo::HasPrivilege(const String& privilege) const
 482 {
 483     bool ret = false;
 484     bool validStringFlag = false;
 485     int privilegeEnum = -1;
 486     int index = 0;
 487
 488         String privilegeURI = L"http://tizen.org/privilege/";
 489     String privilegeSubString;
 490     String privilegeSubStringURI;
 491     privilege.SubString(0, privilegeURI.GetLength(), privilegeSubStringURI);
 492
 493     if (privilegeSubStringURI.Equals(privilegeURI, true))
 494     {
 495         privilege.SubString(privilegeURI.GetLength(), privilege.GetLength() - privilegeURI.GetLength(), privilegeSubString);
 496         for (index = 0; index < _MAX_PRIVILEGE_ENUM; index++)
 497                 {
 498                         if (wcscmp(privilegeListTable[index].privilegeString, privilegeSubString.GetPointer()) == 0)
 499                         {
 500                                 validStringFlag = true;
 501                                 privilegeEnum = index;
 502                                 break;
 503                         }
 504                 }
 505     }
 506
 507     if (validStringFlag)
 508     {
 509         ret = HasPrivilege(privilegeListTable[index].privilege);
 510
 511     }
 512     else
 513     {
 514         ret = __privilegeList.Contains(privilege);
 515         if (ret)
 516                 {
 517                         SysLog(NID_SEC, "Result : TRUE");
 518                 }
 519                 else
 520                 {
 521                         SysLogException(NID_SEC, E_PRIVILEGE_DENIED, "Result : FALSE [%ls, %ls]", __appId.GetPointer(), privilege.GetPointer());
 522                 }
 523     }
 524
 525         return ret;
 526 }
 527
 528 result
 529 _PrivilegeInfo::VerifyIntegrity(const AppId& appId, const byte* targetBitwisePrivilege, const Tizen::Base::String& storedChecksum, int length)
 530 {
 531         result r = E_SUCCESS;
 532         bool verifyResult = false;
 533         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 534         String base64EncodedChecksum;
 535         ByteBuffer input;
 536         std::unique_ptr<IHash> pHash(null);
 537         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 538         std::unique_ptr<char> pAppId(null);
 539
 540         SysTryReturnResult(NID_SEC, length <= MAX_BITWISE_PRIV_SIZE, E_INVALID_ARG, "The privilege information of %ls is invalid.", appId.GetPointer());
 541
 542         pAppId.reset(_StringConverter::CopyToCharArrayN(appId));
 543         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 544
 545         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 546         memcpy(tempChecksumString + MAX_APP_ID_SIZE, targetBitwisePrivilege, length);
 547
 548         pAppId.reset(null);
 549
 550         r = input.Construct(MAX_APP_ID_SIZE + length);
 551         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 552
 553         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + length);
 554         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 555         input.Flip();
 556
 557         pHash.reset(new (std::nothrow) Sha1Hash());
 558         SysTryReturnResult(NID_SEC, pHash != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 559
 560         pChecksumByteBuffer.reset(pHash->GetHashN(input));
 561         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 562
 563         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), base64EncodedChecksum);
 564         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 565
 566         verifyResult = storedChecksum.Equals(base64EncodedChecksum, true);
 567         if (verifyResult != true)
 568         {
 569                 r = E_INVALID_ARG;
 570         }
 571
 572         return r;
 573 }
 574
 575 result
 576 _PrivilegeInfo::VerifyIntegrityEx(const AppId& appId, const byte* targetBitwisePrivilege, const Tizen::Base::String& storedChecksum, int length)
 577 {
 578         result r = E_SUCCESS;
 579         bool verifyResult = false;
 580         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 581         String base64EncodedChecksum;
 582         ByteBuffer ivByte;
 583         ByteBuffer input;
 584         std::unique_ptr<IHmac> pHmac(null);
 585         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 586         std::unique_ptr<ISecretKey> pKey(null);
 587         std::unique_ptr<char[]> pAppId(null);
 588
 589         SysTryReturnResult(NID_SEC, length <= MAX_BITWISE_PRIV_SIZE, E_INVALID_ARG, "The privilege information of [%ls] is invalid.", appId.GetPointer());
 590
 591         pAppId.reset(_StringConverter::CopyToCharArrayN(appId));
 592         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 593
 594         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 595         memcpy(tempChecksumString + MAX_APP_ID_SIZE, targetBitwisePrivilege, length);
 596
 597         pAppId.reset(null);
 598
 599         r = input.Construct(MAX_APP_ID_SIZE + length);
 600         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 601
 602         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + length);
 603         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 604         input.Flip();
 605
 606         pHmac.reset(new (std::nothrow) Sha1Hmac());
 607         SysTryReturnResult(NID_SEC, pHmac != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 608
 609         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 610         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "An unexpected system error occurred.");
 611
 612         r = pHmac->SetKey(*(pKey.get()));
 613         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 614
 615         pChecksumByteBuffer.reset(pHmac->GetHmacN(input));
 616         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 617
 618         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), base64EncodedChecksum);
 619         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 620
 621         verifyResult = storedChecksum.Equals(base64EncodedChecksum, true);
 622         if (verifyResult != true)
 623         {
 624                 r = E_INVALID_ARG;
 625         }
 626
 627         return r;
 628 }
 629
 630 result
 631 _PrivilegeInfo::VerifyIntegrity(const AppId& appId, const byte* targetBitwisePrivilege, const Tizen::Base::String& storedChecksum, int length, int visibility, const Tizen::Base::String& storedVisibilityChecksum)
 632 {
 633         result r = E_SUCCESS;
 634         bool verifyResult = false;
 635         byte tempChecksumString[MAX_BITWISE_PRIV_SIZE + MAX_APP_ID_SIZE];
 636         byte tempVisibilityChecksumString[sizeof(int) + MAX_APP_ID_SIZE];
 637         String base64EncodedChecksum;
 638         String base64EncodedVisibilityChecksum;
 639         ByteBuffer ivByte;
 640         ByteBuffer input;
 641         ByteBuffer visibilityInput;
 642         std::unique_ptr<IHmac> pHmac(null);
 643         std::unique_ptr<ByteBuffer> pChecksumByteBuffer(null);
 644         std::unique_ptr<ByteBuffer> pVisibilityChecksumByteBuffer(null);
 645         std::unique_ptr<ISecretKey> pKey(null);
 646         std::unique_ptr<char[]> pAppId(null);
 647
 648         SysTryReturnResult(NID_SEC, length <= MAX_BITWISE_PRIV_SIZE, E_INVALID_ARG, "The privilege information of [%ls] is invalid.", appId.GetPointer());
 649
 650         pAppId.reset(_StringConverter::CopyToCharArrayN(appId));
 651         SysTryReturnResult(NID_SEC, pAppId != null, E_SYSTEM, "An unexpected system error occurred.");
 652
 653         memcpy(tempChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 654         memcpy(tempChecksumString + MAX_APP_ID_SIZE, targetBitwisePrivilege, length);
 655
 656         memcpy(tempVisibilityChecksumString, pAppId.get(), MAX_APP_ID_SIZE);
 657         memcpy(tempVisibilityChecksumString + MAX_APP_ID_SIZE, (byte*)(&visibility), sizeof(int));
 658
 659         pAppId.reset(null);
 660
 661         r = input.Construct(MAX_APP_ID_SIZE + length);
 662         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 663
 664         r = input.SetArray(tempChecksumString, 0, MAX_APP_ID_SIZE + length);
 665         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 666         input.Flip();
 667
 668         r = visibilityInput.Construct(MAX_APP_ID_SIZE + sizeof(int));
 669         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 670
 671         r = visibilityInput.SetArray(tempVisibilityChecksumString, 0, MAX_APP_ID_SIZE + sizeof(int));
 672         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 673         visibilityInput.Flip();
 674
 675         pHmac.reset(new (std::nothrow) Sha1Hmac());
 676         SysTryReturnResult(NID_SEC, pHmac != null, E_OUT_OF_MEMORY, "Memory allocation is failed.");
 677
 678         pKey.reset(_DeviceKeyGenerator::GenerateDeviceKeyN(_KEY_LEN));
 679         SysTryReturnResult(NID_SEC, pKey != null, E_SYSTEM, "An unexpected system error occurred.");
 680
 681         r = pHmac->SetKey(*(pKey.get()));
 682         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 683
 684         pChecksumByteBuffer.reset(pHmac->GetHmacN(input));
 685         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 686
 687         r = StringUtil::EncodeToBase64String(*(pChecksumByteBuffer.get()), base64EncodedChecksum);
 688         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 689
 690         verifyResult = storedChecksum.Equals(base64EncodedChecksum, true);
 691         if (verifyResult != true)
 692         {
 693                 r = E_INVALID_ARG;
 694         }
 695
 696         pVisibilityChecksumByteBuffer.reset(pHmac->GetHmacN(visibilityInput));
 697         SysTryReturnResult(NID_SEC, pChecksumByteBuffer != null, E_SYSTEM, "An unexpected system error occurred.");
 698
 699         r = StringUtil::EncodeToBase64String(*(pVisibilityChecksumByteBuffer.get()), base64EncodedVisibilityChecksum);
 700         SysTryReturnResult(NID_SEC, r == E_SUCCESS, E_SYSTEM, "An unexpected system error occurred.");
 701
 702         verifyResult = storedVisibilityChecksum.Equals(base64EncodedVisibilityChecksum, true);
 703         if (verifyResult != true)
 704         {
 705                 r = E_INVALID_ARG;
 706         }
 707
 708         return r;
 709 }
 710
 711 }} //Tizen::Security