test/drm_testapps.cpp

   1 /*
   2  * Copyright (c) 2000-2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
   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 #include <vector>
  18 #include <fstream>
  19 #include <iostream>
  20
  21 #include "drm-tizen-apps.h"
  22 #include "drm-tizen-error.h"
  23 #include "TADC_Core.h"
  24 #include "TADC_IF.h"
  25 #include "DrmFileMgr.h"
  26
  27 #include "DTapps2Rights.h"
  28 #include "drm_testutil.h"
  29 #include "drm_testcore.h"
  30 #include <tzplatform_config.h>
  31
  32 #if 1
  33 static int first_key = 0;
  34 static int second_key = 0;
  35 static int third_key = 0;
  36
  37 bool _write_logfile(const char *filename, char *buf, unsigned int len)
  38 {
  39         FILE *fd = NULL;
  40
  41         if ((fd = fopen(filename,"w+b")) == NULL)
  42         {
  43                 return false;
  44         }
  45
  46         fwrite(buf, 1, len,fd);
  47         fclose(fd);
  48
  49         return true;
  50 }
  51
  52 bool _read_logfile(const char *filename, char *buf, unsigned int *pLen)
  53 {
  54         FILE *fd = NULL;
  55         int  nReadLen = 0;
  56
  57         if ((fd = fopen(filename,"r+b")) == NULL)
  58         {
  59                 return false;
  60         }
  61
  62         nReadLen = fread(buf, 1, *pLen,fd);
  63         *pLen = nReadLen;
  64
  65         fclose(fd);
  66
  67         return true;
  68 }
  69
  70 bool tc01_VerifyRoSignature_Positive_01(void)
  71 {
  72         printf("tc01_VerifyRoSignature_Positive_01() -------- Started! \n");
  73
  74         const char *pRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/38EIfBurLJ-1.0.2.ro");
  75
  76         auto buf = _read_ro_file(pRo);
  77
  78         int nRet = TADC_VerifyROSignature(buf.data());
  79         if (nRet != 0) {
  80                 printf("VerifyROSignature Failed! : %s, %d\n", pRo, nRet);
  81                 return false;
  82         }
  83
  84         printf("tc01_VerifyRoSignature_Positive_01() finished! -------- success \n");
  85
  86         return true;
  87 }
  88
  89 bool tc01_VerifyRoSignature_Positive_02(void)
  90 {
  91         printf("tc01_VerifyRoSignature_Positive_02() -------- Started! \n");
  92         const char *pRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/8SPXfqc6iL-1.0.0.ro");
  93
  94         auto buf = _read_ro_file(pRo);
  95
  96         int nRet = TADC_VerifyROSignature(buf.data());
  97         if (nRet != 0) {
  98                 printf("VerifyROSignature Failed! : %s, %d\n", pRo, nRet);
  99                 return false;
 100         }
 101
 102         printf("tc01_VerifyRoSignature_Positive_02() finished! -------- success \n");
 103         return true;
 104 }
 105
 106 bool tc01_VerifyRoSignature_Positive_03(void)
 107 {
 108         printf("tc01_VerifyRoSignature_Positive_03() -------- Started! \n");
 109
 110         const char *pRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/FightGuiIF-1.0.0.ro");
 111
 112         auto buf = _read_ro_file(pRo);
 113
 114         int nRet = TADC_VerifyROSignature(buf.data());
 115         if (nRet != 0)
 116         {
 117                 printf("VerifyROSignature Failed! : %s, %d\n", pRo, nRet);
 118                 return false;
 119         }
 120
 121         printf("tc01_VerifyRoSignature_Positive_03() finished! -------- success \n");
 122         return true;
 123 }
 124
 125 bool tc02_VerifyRoSignature_Negative_Cert_01(void)
 126 {
 127         printf("tc02_VerifyRoSignature_Negative_Cert_01() -------- Started! \n");
 128
 129         const char *pRo  = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/38EIfBurLJ-1.0.2.cert_only_selfsigned.ro");
 130
 131         auto buf = _read_ro_file(pRo);
 132
 133         int nRet = TADC_VerifyROSignature(buf.data());
 134         if (nRet >= 0) {
 135                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo, nRet);
 136                 return false;
 137         }
 138
 139         printf("tc02_VerifyRoSignature_Negative_Cert_01 finished! -------- success \n");
 140         return true;
 141 }
 142
 143 bool tc02_VerifyRoSignature_Negative_Cert_02(void)
 144 {
 145         printf("tc02_VerifyRoSignature_Negative_Cert_02() -------- Started! \n");
 146
 147         const char *pRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/38EIfBurLJ-1.0.2.cert_chain_invalid.ro");
 148
 149         auto buf = _read_ro_file(pRo);
 150
 151         int nRet = TADC_VerifyROSignature(buf.data());
 152         if (nRet >= 0) {
 153                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo, nRet);
 154                 return false;
 155         }
 156
 157         printf("tc02_VerifyRoSignature_Negative_Cert_02 finished! -------- success \n");
 158         return true;
 159 }
 160
 161 bool tc02_VerifyRoSignature_Negative_Cert_03(void)
 162 {
 163         printf("tc02_VerifyRoSignature_Negative_Cert_03() -------- Started! \n");
 164
 165         const char *pRo  = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/38EIfBurLJ-1.0.2.cert_invalid.ro");
 166
 167         auto buf = _read_ro_file(pRo);
 168
 169         int nRet = TADC_VerifyROSignature(buf.data());
 170         if (nRet >= 0) {
 171                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo, nRet);
 172                 return false;
 173         }
 174
 175         printf("tc02_VerifyRoSignature_Negative_Cert_03 finished! -------- success \n");
 176         return true;
 177 }
 178
 179 bool tc03_VerifyRoSignature_Negative_Signature_01(void)
 180 {
 181         printf("tc03_VerifyRoSignature_Negative_Signature_01() -------- Started! \n");
 182
 183         const char *pRo   = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/FightGuiIF-1.0.0.signature_invalid.ro");
 184
 185         auto buf = _read_ro_file(pRo);
 186
 187         int nRet = TADC_VerifyROSignature(buf.data());
 188         if (nRet >= 0) {
 189                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo, nRet);
 190                 return false;
 191         }
 192
 193         printf("tc03_VerifyRoSignature_Negative_Signature_01() finished! -------- success \n");
 194
 195         return true;
 196 }
 197
 198 bool tc03_VerifyRoSignature_Negative_Signature_02(void)
 199 {
 200         printf("tc03_VerifyRoSignature_Negative_Signature_02() -------- Started! \n");
 201
 202         const char *pRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/38EIfBurLJ-1.0.2.signature_invalid.ro");
 203
 204         auto buf = _read_ro_file(pRo);
 205
 206         int nRet = TADC_VerifyROSignature(buf.data());
 207         if (nRet >= 0) {
 208                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo, nRet);
 209                 return false;
 210         }
 211
 212         printf("tc03_VerifyRoSignature_Negative_Signature_01() finished! -------- success \n");
 213
 214         return true;
 215 }
 216
 217 bool tc03_VerifyRoSignature_Negative_Signature_03(void)
 218 {
 219         printf("tc03_VerifyRoSignature_Negative_Signature_03() -------- Started! \n");
 220
 221         const char *pRo  = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/8SPXfqc6iL-1.0.0.signature_invalid.ro");
 222
 223         auto buf = _read_ro_file(pRo);
 224
 225         int nRet = TADC_VerifyROSignature(buf.data());
 226         if (nRet >= 0) {
 227                 printf("VerifyROSignature have to be failed. But success! : %s, %d\n", pRo, nRet);
 228                 return false;
 229         }
 230
 231         printf("tc03_VerifyRoSignature_Negative_Signature_03() finished! -------- success \n");
 232
 233         return true;
 234 }
 235
 236 bool tc04_isDrmFile_Positive_01(void)
 237 {
 238         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/38EIfBurLJ.tpk");
 239
 240         printf("tc04_isDrmFile_Positive_01() -------- Started!\n");
 241
 242         int nRet = drm_tizen_is_drm_file(pDCF, strlen(pDCF));
 243         if (nRet != TADC_SUCCESS) {
 244                 printf("drm_tizen_is_drm_file failed. Path = %s, Ret = %d\n", pDCF,  nRet);
 245                 printf("%s file is not TADC file!\n", pDCF);
 246                 return false;
 247         }
 248
 249         printf("tc04_isDrmFile_Positive_01() finished! -------- success \n");
 250
 251         return true;
 252 }
 253
 254 bool tc04_isDrmFile_Positive_02(void)
 255 {
 256         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/8SPXfqc6iL.tpk");
 257
 258         printf("tc04_isDrmFile_Positive_02() -------- Started!\n");
 259
 260         int nRet = drm_tizen_is_drm_file(pDCF, strlen(pDCF));
 261         if (nRet != TADC_SUCCESS) {
 262                 printf("drm_tizen_is_drm_file failed. Path = %s, Ret = %d\n", pDCF,  nRet);
 263                 printf("%s file is not TADC file!\n", pDCF);
 264                 return false;
 265         }
 266
 267         printf("tc04_isDrmFile_Positive_02() finished! -------- success \n");
 268
 269         return true;
 270 }
 271
 272 bool tc04_isDrmFile_Positive_03(void)
 273 {
 274         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/FightGuiIF.tpk");
 275
 276         printf("tc04_isDrmFile_Positive_03() -------- Started!\n");
 277
 278         int nRet = drm_tizen_is_drm_file(pDCF, strlen(pDCF));
 279         if (nRet != TADC_SUCCESS) {
 280                 printf("drm_tizen_is_drm_file failed. Path = %s, Ret = %d\n", pDCF,  nRet);
 281                 printf("%s file is not TADC file!\n", pDCF);
 282                 return false;
 283         }
 284
 285         printf("tc04_isDrmFile_Positive_03() finished! -------- success \n");
 286
 287         return true;
 288 }
 289
 290 bool tc05_isDrmFile_Negative_01(void)
 291 {
 292         const char *pApp = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DecryptedApp/38EIfBurLJ_dec.tpk");
 293
 294         printf("tc05_isDrmFile_Negative_01() -------- Started! \n");
 295
 296         int nRet = drm_tizen_is_drm_file(pApp, strlen(pApp));
 297         if(nRet == TADC_SUCCESS) {
 298                 printf("drm_tizen_is_drm_file have to be failed. But Success!  Path = %s, Ret = %d\n", pApp,  nRet);
 299                 return false;
 300         }
 301
 302         printf("tc05_isDrmFile_Negative_01 finished! -------- success \n");
 303
 304         return true;
 305 }
 306
 307 bool tc05_isDrmFile_Negative_02(void)
 308 {
 309         const char *pApp = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DecryptedApp/8SPXfqc6iL_dec.tpk");
 310
 311         printf("tc05_isDrmFile_Negative_02() -------- Started! \n");
 312
 313         int nRet = drm_tizen_is_drm_file(pApp, strlen(pApp));
 314         if(nRet == TADC_SUCCESS) {
 315                 printf("drm_tizen_is_drm_file have to be failed. But Success!  Path = %s, Ret = %d\n", pApp,  nRet);
 316                 return false;
 317         }
 318
 319         printf("tc05_isDrmFile_Negative_02 finished! -------- success \n");
 320
 321         return true;
 322 }
 323
 324 bool tc05_isDrmFile_Negative_03(void)
 325 {
 326         const char *pApp = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DecryptedApp/FightGuiIF_dec.tpk");
 327
 328         printf("tc05_isDrmFile_Negative_03() -------- Started! \n");
 329
 330         int nRet = drm_tizen_is_drm_file(pApp, strlen(pApp));
 331         if(nRet == TADC_SUCCESS) {
 332                 printf("drm_tizen_is_drm_file have to be failed. But Success!  Path = %s, Ret = %d\n", pApp,  nRet);
 333                 return false;
 334         }
 335
 336         printf("tc05_isDrmFile_Negative_03 finished! -------- success \n");
 337
 338         return true;
 339 }
 340
 341 bool
 342 tc06_DrmFileHandlerPositive_01(void)
 343 {
 344         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/38EIfBurLJ.tpk");
 345         DrmFileHandler* pDcfHandler = NULL;
 346         unsigned char* pBufCEK = NULL;
 347         unsigned char pCEK[CEK_SIZE + 1] = {0xB1, 0x03, 0x4F, 0x30, 0xC8, 0x52, 0x45, 0x7E, 0x9D, 0xA2, 0x52, 0x25, 0x2E, 0xA9, 0x9B, 0x2B, 0x25, 0x36, 0xF1, 0x8D, 0x04, 0xD1, 0x4C, 0xE3, 0x96, 0x81, 0xD9, 0x98, 0xBB, 0xD7, 0x7E, 0xCA, 0x00};
 348         unsigned char pCID[32] = "38EIfBurLJ-1.0.2";
 349
 350         long encryptionLevel = 17;
 351         long long encryptionRange = 10;
 352         long long plainTextSize = 1630724;
 353         long long originalEndOffset = 1631570;
 354         int nRet = 0;
 355
 356         printf("tc06_DrmFileHandlerPositive_01() -------- Started! \n");
 357
 358         pBufCEK = (unsigned char*)malloc(CEK_SIZE + 1);
 359         memset(pBufCEK, 0x00, CEK_SIZE + 1);
 360
 361         pDcfHandler = new DrmFileHandler();
 362         if (pDcfHandler == NULL)
 363         {
 364                 goto CATCH;
 365         }
 366
 367         nRet = pDcfHandler->Construct(pDCF);
 368         if (nRet != 1)
 369         {
 370                 printf("tc06_DrmFileHandlerPositive_01 - Construct() failed : %s, %x\n", pDCF, nRet);
 371                 goto CATCH;
 372         }
 373
 374         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
 375         {
 376                 printf("tc06_DrmFileHandlerPositive_01 - CEK Comparison failed : %s\n", pDCF);
 377                 goto CATCH;
 378         }
 379
 380         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
 381         {
 382                 printf("tc06_DrmFileHandlerPositive_01 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
 383                 goto CATCH;
 384         }
 385
 386         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
 387         {
 388                 printf("tc06_DrmFileHandlerPositive_01 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
 389                 goto CATCH;
 390         }
 391
 392         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
 393         {
 394                 printf("tc06_DrmFileHandlerPositive_01 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
 395                 goto CATCH;
 396         }
 397
 398         if (pDcfHandler->m_encryptionRange != encryptionRange)
 399         {
 400                 printf("tc06_DrmFileHandlerPositive_01 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
 401                 goto CATCH;
 402         }
 403
 404         if (pDcfHandler->m_plaintextSize != plainTextSize)
 405         {
 406                 printf("tc06_DrmFileHandlerPositive_01 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
 407                 goto CATCH;
 408         }
 409
 410         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
 411         {
 412                 printf("tc06_DrmFileHandlerPositive_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
 413                 goto CATCH;
 414         }
 415
 416         if (pDcfHandler != NULL)
 417         {
 418                 delete pDcfHandler;
 419         }
 420
 421         if (pBufCEK != NULL)
 422         {
 423                 free(pBufCEK);
 424         }
 425
 426         printf("tc06_DrmFileHandlerPositive_01 finished! -------- success \n");
 427
 428         return true;
 429
 430 CATCH:
 431         if (pDcfHandler != NULL)
 432         {
 433                 delete pDcfHandler;
 434         }
 435
 436         if (pBufCEK != NULL)
 437         {
 438                 free(pBufCEK);
 439         }
 440
 441         return false;
 442 }
 443
 444 bool
 445 tc06_DrmFileHandlerPositive_02(void)
 446 {
 447         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/8SPXfqc6iL.tpk");
 448         unsigned char* pBufCEK = NULL;
 449         DrmFileHandler* pDcfHandler = NULL;
 450         unsigned char pCEK[CEK_SIZE + 1] = {0xBB, 0x87, 0x5D, 0xA8, 0x2C, 0xC4, 0x47, 0x81, 0x90, 0xBA, 0xD9, 0xB0, 0x0C, 0xD2, 0x94, 0xE9, 0x19, 0x0F, 0x24, 0x62, 0x5B, 0x0B, 0x49, 0x7A, 0xAE, 0x8E, 0x1D, 0x88, 0x7F, 0xF9, 0x96, 0xDB, 0x00};
 451         unsigned char pCID[32] = "8SPXfqc6iL-1.0.0";
 452
 453         long encryptionLevel = 17;
 454         long long encryptionRange = 10;
 455         long long plainTextSize = 705072;
 456         long long originalEndOffset = 705914;
 457         int nRet = 0;
 458
 459         printf("tc06_DrmFileHandlerPositive_02() -------- Started! \n");
 460
 461         pBufCEK = (unsigned char*)malloc(CEK_SIZE + 1);
 462         memset(pBufCEK, 0x00, CEK_SIZE + 1);
 463
 464         pDcfHandler = new DrmFileHandler();
 465         if (pDcfHandler == NULL)
 466         {
 467                 goto CATCH;
 468         }
 469
 470         nRet = pDcfHandler->Construct(pDCF);
 471         if (nRet != 1)
 472         {
 473                 printf("tc06_DrmFileHandlerPositive_02 - Construct() failed : %s, %x\n", pDCF, nRet);
 474                 goto CATCH;
 475         }
 476
 477         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
 478         {
 479                 printf("tc06_DrmFileHandlerPositive_02 - CEK Comparison failed : %s\n", pDCF);
 480                 goto CATCH;
 481         }
 482
 483         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
 484         {
 485                 printf("tc06_DrmFileHandlerPositive_02 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
 486                 goto CATCH;
 487         }
 488
 489         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
 490         {
 491                 printf("tc06_DrmFileHandlerPositive_02 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
 492                 goto CATCH;
 493         }
 494
 495         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
 496         {
 497                 printf("tc06_DrmFileHandlerPositive_02 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
 498                 goto CATCH;
 499         }
 500
 501         if (pDcfHandler->m_encryptionRange != encryptionRange)
 502         {
 503                 printf("tc06_DrmFileHandlerPositive_02 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
 504                 goto CATCH;
 505         }
 506
 507         if (pDcfHandler->m_plaintextSize != plainTextSize)
 508         {
 509                 printf("tc06_DrmFileHandlerPositive_02 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
 510                 goto CATCH;
 511         }
 512
 513         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
 514         {
 515                 printf("tc06_DrmFileHandlerPositive_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
 516                 goto CATCH;
 517         }
 518
 519         if (pDcfHandler != NULL)
 520         {
 521                 delete pDcfHandler;
 522         }
 523
 524         if (pBufCEK != NULL)
 525         {
 526                 free(pBufCEK);
 527         }
 528
 529         printf("tc06_DrmFileHandlerPositive_02 finished! -------- success \n");
 530
 531         return true;
 532
 533 CATCH:
 534         if (pDcfHandler != NULL)
 535         {
 536                 delete pDcfHandler;
 537         }
 538
 539         if (pBufCEK != NULL)
 540         {
 541                 free(pBufCEK);
 542         }
 543
 544         return false;
 545 }
 546
 547 bool
 548 tc06_DrmFileHandlerPositive_03(void)
 549 {
 550         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/FightGuiIF.tpk");
 551         unsigned char* pBufCEK = NULL;
 552         DrmFileHandler* pDcfHandler = NULL;
 553         unsigned char pCEK[CEK_SIZE + 1] = {0x34, 0x5A, 0x94, 0x28, 0xC3, 0xF4, 0x44, 0x3F, 0x86, 0x6D, 0xCF, 0xC5, 0x78, 0x1F, 0x23, 0xCE, 0xE9, 0x9B, 0xC4, 0x45, 0xA3, 0x30, 0x47, 0x1E, 0xB4, 0xE0, 0xAF, 0x96, 0x0F, 0xDE, 0xA9, 0xB4, 0x00};
 554         unsigned char pCID[32] = "FightGuiIF-1.0.0";
 555
 556         long encryptionLevel = 17;
 557         long long encryptionRange = 10;
 558         long long plainTextSize = 45193789;
 559         long long originalEndOffset = 45194636;
 560         int nRet = 0;
 561
 562         printf("tc06_DrmFileHandlerPositive_03() -------- Started! \n");
 563
 564         pBufCEK = (unsigned char*)malloc(CEK_SIZE + 1);
 565         memset(pBufCEK, 0x00, CEK_SIZE + 1);
 566
 567         pDcfHandler = new DrmFileHandler();
 568         if (pDcfHandler == NULL)
 569         {
 570                 goto CATCH;
 571         }
 572
 573         nRet = pDcfHandler->Construct(pDCF);
 574         if (nRet != 1)
 575         {
 576                 printf("tc06_DrmFileHandlerPositive_03 - Construct() failed : %s, %x\n", pDCF, nRet);
 577                 goto CATCH;
 578         }
 579
 580         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
 581         {
 582                 printf("tc06_DrmFileHandlerPositive_03 - CEK Comparison failed : %s\n", pDCF);
 583                 goto CATCH;
 584         }
 585
 586         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
 587         {
 588                 printf("tc06_DrmFileHandlerPositive_03 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
 589                 goto CATCH;
 590         }
 591
 592         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
 593         {
 594                 printf("tc06_DrmFileHandlerPositive_03 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
 595                 goto CATCH;
 596         }
 597
 598         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
 599         {
 600                 printf("tc06_DrmFileHandlerPositive_03 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
 601                 goto CATCH;
 602         }
 603
 604         if (pDcfHandler->m_encryptionRange != encryptionRange)
 605         {
 606                 printf("tc06_DrmFileHandlerPositive_03 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
 607                 goto CATCH;
 608         }
 609
 610         if (pDcfHandler->m_plaintextSize != plainTextSize)
 611         {
 612                 printf("tc06_DrmFileHandlerPositive_03 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
 613                 goto CATCH;
 614         }
 615
 616         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
 617         {
 618                 printf("tc06_DrmFileHandlerPositive_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
 619                 goto CATCH;
 620         }
 621
 622         if (pDcfHandler != NULL)
 623         {
 624                 delete pDcfHandler;
 625         }
 626
 627         if (pBufCEK != NULL)
 628         {
 629                 free(pBufCEK);
 630         }
 631
 632         printf("tc06_DrmFileHandlerPositive_03 finished! -------- success \n");
 633
 634         return true;
 635
 636 CATCH:
 637         if (pDcfHandler != NULL)
 638         {
 639                 delete pDcfHandler;
 640         }
 641
 642         if (pBufCEK != NULL)
 643         {
 644                 free(pBufCEK);
 645         }
 646
 647         return false;
 648 }
 649
 650 bool tc07_DrmFileMgrPositive_01(void)
 651 {
 652         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/38EIfBurLJ.tpk");
 653         int nRet = TADC_SUCCESS;
 654
 655         DrmFileMgr* pDrmFileMgr = NULL;
 656         DrmFileHandler *pDcfHandler = NULL;
 657
 658         unsigned char pCEK[CEK_SIZE + 1] = {0xB1, 0x03, 0x4F, 0x30, 0xC8, 0x52, 0x45, 0x7E, 0x9D, 0xA2, 0x52, 0x25, 0x2E, 0xA9, 0x9B, 0x2B, 0x25, 0x36, 0xF1, 0x8D, 0x04, 0xD1, 0x4C, 0xE3, 0x96, 0x81, 0xD9, 0x98, 0xBB, 0xD7, 0x7E, 0xCA, 0x00};
 659
 660         unsigned char pCID[32] = "38EIfBurLJ-1.0.2";
 661         long encryptionLevel = 17;
 662         long long encryptionRange = 10;
 663         long long plainTextSize = 1630724;
 664         long long originalEndOffset = 1631570;
 665
 666         printf("tc07_DrmFileMgrPositive_01() -------- Started! \n");
 667
 668         pDrmFileMgr = DrmFileMgr::GetInstance();
 669
 670         nRet = pDrmFileMgr->OpenFileHandler(pDCF, &first_key);
 671         if (nRet != TADC_SUCCESS)
 672         {
 673                 printf("tc07_DrmFileMgrPositive_01 - OpenFileHandler() failed : key = %d, file = %s, %x\n", first_key, pDCF, nRet);
 674                 goto CATCH;
 675         }
 676
 677         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
 678         if (nRet != TADC_SUCCESS)
 679         {
 680                 printf("tc07_DrmFileMgrPositive_01 - GetFileHandler() failed : key = %d, file = %s, %x\n", first_key, pDCF, nRet);
 681                 goto CATCH;
 682         }
 683
 684         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
 685         {
 686                 printf("tc07_DrmFileMgrPositive_01 - CEK Comparison failed : %s\n", pDCF);
 687                 goto CATCH;
 688         }
 689
 690         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
 691         {
 692                 printf("tc07_DrmFileMgrPositive_01 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
 693                 goto CATCH;
 694         }
 695
 696         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
 697         {
 698                 printf("tc07_DrmFileMgrPositive_01 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
 699                 goto CATCH;
 700         }
 701
 702         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
 703         {
 704                 printf("tc07_DrmFileMgrPositive_01 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
 705                 goto CATCH;
 706         }
 707
 708         if (pDcfHandler->m_encryptionRange != encryptionRange)
 709         {
 710                 printf("tc07_DrmFileMgrPositive_01 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
 711                 goto CATCH;
 712         }
 713
 714         if (pDcfHandler->m_plaintextSize != plainTextSize)
 715         {
 716                 printf("tc07_DrmFileMgrPositive_01 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
 717                 goto CATCH;
 718         }
 719
 720         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
 721         {
 722                 printf("tc07_DrmFileMgrPositive_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
 723                 goto CATCH;
 724         }
 725
 726         printf("tc07_DrmFileMgrPositive_01 finished! -------- success \n");
 727
 728         return true;
 729
 730 CATCH:
 731
 732         return false;
 733 }
 734
 735 bool tc07_DrmFileMgrPositive_02(void)
 736 {
 737         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/8SPXfqc6iL.tpk");
 738         int nRet = TADC_SUCCESS;
 739
 740         DrmFileMgr* pDrmFileMgr = NULL;
 741         DrmFileHandler *pDcfHandler = NULL;
 742
 743         unsigned char pCEK[CEK_SIZE + 1] = {0xBB, 0x87, 0x5D, 0xA8, 0x2C, 0xC4, 0x47, 0x81, 0x90, 0xBA, 0xD9, 0xB0, 0x0C, 0xD2, 0x94, 0xE9, 0x19, 0x0F, 0x24, 0x62, 0x5B, 0x0B, 0x49, 0x7A, 0xAE, 0x8E, 0x1D, 0x88, 0x7F, 0xF9, 0x96, 0xDB, 0x00};
 744         unsigned char pCID[32] = "8SPXfqc6iL-1.0.0";
 745
 746         long encryptionLevel = 17;
 747         long long encryptionRange = 10;
 748         long long plainTextSize = 705072;
 749         long long originalEndOffset = 705914;
 750
 751         printf("tc07_DrmFileMgrPositive_02() -------- Started! \n");
 752
 753         pDrmFileMgr = DrmFileMgr::GetInstance();
 754
 755         nRet = pDrmFileMgr->OpenFileHandler(pDCF, &second_key);
 756         if (nRet != TADC_SUCCESS)
 757         {
 758                 printf("tc07_DrmFileMgrPositive_02 - OpenFileHandler() failed : key = %d, file = %s, %x\n", second_key, pDCF, nRet);
 759                 goto CATCH;
 760         }
 761
 762         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
 763         if (nRet != TADC_SUCCESS)
 764         {
 765                 printf("tc07_DrmFileMgrPositive_02 - GetFileHandler() failed : key = %d, file = %s, %x\n", second_key, pDCF, nRet);
 766                 goto CATCH;
 767         }
 768
 769         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
 770         {
 771                 printf("tc07_DrmFileMgrPositive_02 - CEK Comparison failed : %s\n", pDCF);
 772                 goto CATCH;
 773         }
 774
 775         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
 776         {
 777                 printf("tc07_DrmFileMgrPositive_02 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
 778                 goto CATCH;
 779         }
 780
 781         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
 782         {
 783                 printf("tc07_DrmFileMgrPositive_02 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
 784                 goto CATCH;
 785         }
 786
 787         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
 788         {
 789                 printf("tc07_DrmFileMgrPositive_02 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
 790                 goto CATCH;
 791         }
 792
 793         if (pDcfHandler->m_encryptionRange != encryptionRange)
 794         {
 795                 printf("tc07_DrmFileMgrPositive_02 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
 796                 goto CATCH;
 797         }
 798
 799         if (pDcfHandler->m_plaintextSize != plainTextSize)
 800         {
 801                 printf("tc07_DrmFileMgrPositive_02 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
 802                 goto CATCH;
 803         }
 804
 805         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
 806         {
 807                 printf("tc07_DrmFileMgrPositive_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
 808                 goto CATCH;
 809         }
 810
 811         printf("tc07_DrmFileMgrPositive_02 finished! -------- success \n");
 812
 813         return true;
 814
 815 CATCH:
 816
 817         return false;
 818 }
 819
 820 bool tc07_DrmFileMgrPositive_03(void)
 821 {
 822         const char *pDCF  = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/FightGuiIF.tpk");
 823         int nRet = TADC_SUCCESS;
 824
 825         DrmFileMgr* pDrmFileMgr = NULL;
 826         DrmFileHandler *pDcfHandler = NULL;
 827
 828         unsigned char pCEK[CEK_SIZE + 1] = {0x34, 0x5A, 0x94, 0x28, 0xC3, 0xF4, 0x44, 0x3F, 0x86, 0x6D, 0xCF, 0xC5, 0x78, 0x1F, 0x23, 0xCE, 0xE9, 0x9B, 0xC4, 0x45, 0xA3, 0x30, 0x47, 0x1E, 0xB4, 0xE0, 0xAF, 0x96, 0x0F, 0xDE, 0xA9, 0xB4, 0x00};
 829
 830         unsigned char pCID[32] = "FightGuiIF-1.0.0";
 831
 832         long encryptionLevel = 17;
 833         long long encryptionRange = 10;
 834         long long plainTextSize = 45193789;
 835         long long originalEndOffset = 45194636;
 836
 837         printf("tc07_DrmFileMgrPositive_03() -------- Started! \n");
 838
 839         pDrmFileMgr = DrmFileMgr::GetInstance();
 840
 841         nRet = pDrmFileMgr->OpenFileHandler(pDCF, &third_key);
 842         if (nRet != TADC_SUCCESS)
 843         {
 844                 printf("tc07_DrmFileMgrPositive_03 - OpenFileHandler() failed : key = %d, file = %s, %x\n", third_key, pDCF, nRet);
 845                 goto CATCH;
 846         }
 847
 848         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
 849         if (nRet != TADC_SUCCESS)
 850         {
 851                 printf("tc07_DrmFileMgrPositive_03 - GetFileHandler() failed : key = %d, file = %s, %x\n", third_key, pDCF, nRet);
 852                 goto CATCH;
 853         }
 854
 855         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
 856         {
 857                 printf("tc07_DrmFileMgrPositive_03 - CEK Comparison failed : %s\n", pDCF);
 858                 goto CATCH;
 859         }
 860
 861         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
 862         {
 863                 printf("tc07_DrmFileMgrPositive_03 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
 864                 goto CATCH;
 865         }
 866
 867         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
 868         {
 869                 printf("tc07_DrmFileMgrPositive_03 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
 870                 goto CATCH;
 871         }
 872
 873         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
 874         {
 875                 printf("tc07_DrmFileMgrPositive_03 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
 876                 goto CATCH;
 877         }
 878
 879         if (pDcfHandler->m_encryptionRange != encryptionRange)
 880         {
 881                 printf("tc07_DrmFileMgrPositive_03 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
 882                 goto CATCH;
 883         }
 884
 885         if (pDcfHandler->m_plaintextSize != plainTextSize)
 886         {
 887                 printf("tc07_DrmFileMgrPositive_03 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
 888                 goto CATCH;
 889         }
 890
 891         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
 892         {
 893                 printf("tc07_DrmFileMgrPositive_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
 894                 goto CATCH;
 895         }
 896
 897         printf("tc07_DrmFileMgrPositive_03 finished! -------- success \n");
 898
 899         return true;
 900
 901 CATCH:
 902
 903         return false;
 904 }
 905
 906 bool tc08_DrmFileMgrPositive_GetFileHandler_01(void)
 907 {
 908         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/38EIfBurLJ.tpk");
 909         int nRet = TADC_SUCCESS;
 910
 911         DrmFileMgr* pDrmFileMgr = NULL;
 912         DrmFileHandler *pDcfHandler = NULL;
 913
 914         unsigned char pCEK[CEK_SIZE + 1] = {0xB1, 0x03, 0x4F, 0x30, 0xC8, 0x52, 0x45, 0x7E, 0x9D, 0xA2, 0x52, 0x25, 0x2E, 0xA9, 0x9B, 0x2B, 0x25, 0x36, 0xF1, 0x8D, 0x04, 0xD1, 0x4C, 0xE3, 0x96, 0x81, 0xD9, 0x98, 0xBB, 0xD7, 0x7E, 0xCA, 0x00};
 915
 916         unsigned char pCID[32] = "38EIfBurLJ-1.0.2";
 917
 918         long encryptionLevel = 17;
 919         long long encryptionRange = 10;
 920         long long plainTextSize = 1630724;
 921         long long originalEndOffset = 1631570;
 922
 923         printf("tc08_DrmFileMgrPositive_GetFileHandler_01() -------- Started! \n");
 924
 925         pDrmFileMgr = DrmFileMgr::GetInstance();
 926
 927         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
 928         if (nRet != TADC_SUCCESS)
 929         {
 930                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 failed : key = %d, file = %s, %x\n", first_key, pDCF, nRet);
 931                 goto CATCH;
 932         }
 933
 934         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
 935         {
 936                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - CEK Comparison failed : %s\n", pDCF);
 937                 goto CATCH;
 938         }
 939
 940         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
 941         {
 942                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
 943                 goto CATCH;
 944         }
 945
 946         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
 947         {
 948                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
 949                 goto CATCH;
 950         }
 951
 952         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
 953         {
 954                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
 955                 goto CATCH;
 956         }
 957
 958         if (pDcfHandler->m_encryptionRange != encryptionRange)
 959         {
 960                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
 961                 goto CATCH;
 962         }
 963
 964         if (pDcfHandler->m_plaintextSize != plainTextSize)
 965         {
 966                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
 967                 goto CATCH;
 968         }
 969
 970         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
 971         {
 972                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
 973                 goto CATCH;
 974         }
 975
 976         printf("tc08_DrmFileMgrPositive_GetFileHandler_01 finished! -------- success \n");
 977
 978         return true;
 979
 980 CATCH:
 981
 982         return false;
 983 }
 984
 985 bool tc08_DrmFileMgrPositive_GetFileHandler_02(void)
 986 {
 987         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/8SPXfqc6iL.tpk");
 988         int nRet = TADC_SUCCESS;
 989
 990         DrmFileMgr* pDrmFileMgr = NULL;
 991         DrmFileHandler *pDcfHandler = NULL;
 992
 993         unsigned char pCEK[CEK_SIZE + 1] = {0xBB, 0x87, 0x5D, 0xA8, 0x2C, 0xC4, 0x47, 0x81, 0x90, 0xBA, 0xD9, 0xB0, 0x0C, 0xD2, 0x94, 0xE9, 0x19, 0x0F, 0x24, 0x62, 0x5B, 0x0B, 0x49, 0x7A, 0xAE, 0x8E, 0x1D, 0x88, 0x7F, 0xF9, 0x96, 0xDB, 0x00};
 994
 995         unsigned char pCID[32] = "8SPXfqc6iL-1.0.0";
 996
 997         long encryptionLevel = 17;
 998         long long encryptionRange = 10;
 999         long long plainTextSize = 705072;
1000         long long originalEndOffset = 705914;
1001
1002         printf("tc08_DrmFileMgrPositive_GetFileHandler_02() -------- Started! \n");
1003
1004         pDrmFileMgr = DrmFileMgr::GetInstance();
1005
1006         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1007         if (nRet != TADC_SUCCESS)
1008         {
1009                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 failed : key = %d, file = %s, %x\n", second_key, pDCF, nRet);
1010                 goto CATCH;
1011         }
1012
1013         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
1014         {
1015                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - CEK Comparison failed : %s\n", pDCF);
1016                 goto CATCH;
1017         }
1018
1019         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
1020         {
1021                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
1022                 goto CATCH;
1023         }
1024
1025         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
1026         {
1027                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
1028                 goto CATCH;
1029         }
1030
1031         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
1032         {
1033                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
1034                 goto CATCH;
1035         }
1036
1037         if (pDcfHandler->m_encryptionRange != encryptionRange)
1038         {
1039                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
1040                 goto CATCH;
1041         }
1042
1043         if (pDcfHandler->m_plaintextSize != plainTextSize)
1044         {
1045                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
1046                 goto CATCH;
1047         }
1048
1049         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
1050         {
1051                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
1052                 goto CATCH;
1053         }
1054
1055         printf("tc08_DrmFileMgrPositive_GetFileHandler_02 finished! -------- success \n");
1056
1057         return true;
1058
1059 CATCH:
1060
1061         return false;
1062 }
1063
1064 bool tc08_DrmFileMgrPositive_GetFileHandler_03(void)
1065 {
1066         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/FightGuiIF.tpk");
1067         int nRet = TADC_SUCCESS;
1068
1069         DrmFileMgr* pDrmFileMgr = NULL;
1070         DrmFileHandler *pDcfHandler = NULL;
1071
1072         unsigned char pCEK[CEK_SIZE + 1] = {0x34, 0x5A, 0x94, 0x28, 0xC3, 0xF4, 0x44, 0x3F, 0x86, 0x6D, 0xCF, 0xC5, 0x78, 0x1F, 0x23, 0xCE, 0xE9, 0x9B, 0xC4, 0x45, 0xA3, 0x30, 0x47, 0x1E, 0xB4, 0xE0, 0xAF, 0x96, 0x0F, 0xDE, 0xA9, 0xB4, 0x00};
1073
1074         unsigned char pCID[32] = "FightGuiIF-1.0.0";
1075
1076         long encryptionLevel = 17;
1077         long long encryptionRange = 10;
1078         long long plainTextSize = 45193789;
1079         long long originalEndOffset = 45194636;
1080
1081         printf("tc08_DrmFileMgrPositive_GetFileHandler_03() -------- Started! \n");
1082
1083         pDrmFileMgr = DrmFileMgr::GetInstance();
1084
1085         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1086         if (nRet != TADC_SUCCESS)
1087         {
1088                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 failed : key = %d, file = %s, %x\n", third_key, pDCF, nRet);
1089                 goto CATCH;
1090         }
1091
1092         if (memcmp(pCEK, pDcfHandler->m_pCEK, CEK_SIZE) != 0)
1093         {
1094                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - CEK Comparison failed : %s\n", pDCF);
1095                 goto CATCH;
1096         }
1097
1098         if (memcmp(pDCF, pDcfHandler->m_pFilePath, strlen((char*)pDcfHandler->m_pFilePath)) != 0)
1099         {
1100                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - FilePath Comparison failed : %s\n", pDcfHandler->m_pFilePath);
1101                 goto CATCH;
1102         }
1103
1104         if (memcmp(pCID, pDcfHandler->m_pCID, strlen((char*)pDcfHandler->m_pCID)) != 0)
1105         {
1106                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - CID Comparison failed : %s\n", pDcfHandler->m_pCID);
1107                 goto CATCH;
1108         }
1109
1110         if (pDcfHandler->m_encryptionLevel != encryptionLevel)
1111         {
1112                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - encryptionLevel Comparison failed : origin = %ld, result = %ld\n", encryptionLevel, pDcfHandler->m_encryptionLevel);
1113                 goto CATCH;
1114         }
1115
1116         if (pDcfHandler->m_encryptionRange != encryptionRange)
1117         {
1118                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - encryptionRange Comparison failed : origin = %lld, result = %lld\n", encryptionRange, pDcfHandler->m_encryptionRange);
1119                 goto CATCH;
1120         }
1121
1122         if (pDcfHandler->m_plaintextSize != plainTextSize)
1123         {
1124                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - plainTextSize Comparison failed : origin = %lld, result = %lld\n", plainTextSize, pDcfHandler->m_plaintextSize);
1125                 goto CATCH;
1126         }
1127
1128         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
1129         {
1130                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
1131                 goto CATCH;
1132         }
1133
1134         printf("tc08_DrmFileMgrPositive_GetFileHandler_03 finished! -------- success \n");
1135
1136         return true;
1137
1138 CATCH:
1139
1140         return false;
1141 }
1142
1143 bool tc09_DrmFileMgrPositive_FileAPI_01(void)
1144 {
1145         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/38EIfBurLJ.tpk");
1146         int nRet = TADC_SUCCESS;
1147
1148         DrmFileMgr* pDrmFileMgr = NULL;
1149         DrmFileHandler *pDcfHandler = NULL;
1150
1151         long long originalEndOffset = 1631570;
1152         long long DrmCurOffset = 0;
1153         long long OriginCurOffset = 846;
1154         long long i = 0;
1155
1156         printf("tc09_DrmFileMgrPositive_FileAPI_01() -------- Started! \n");
1157
1158         pDrmFileMgr = DrmFileMgr::GetInstance();
1159
1160         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
1161         if (nRet != TADC_SUCCESS)
1162         {
1163                 printf("tc09_DrmFileMgrPositive_FileAPI_01 failed : key = %d, file = %s, %x\n", first_key, pDCF, nRet);
1164                 goto CATCH;
1165         }
1166
1167         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
1168         {
1169                 printf("tc09_DrmFileMgrPositive_FileAPI_01 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
1170                 goto CATCH;
1171         }
1172
1173         if (OriginCurOffset != pDcfHandler->m_OriginCurOffset)
1174         {
1175                 printf("tc09_DrmFileMgrPositive_FileAPI_01 - originalCurOffset Comparison failed : origin = %lld, result = %lld\n", OriginCurOffset, pDcfHandler->m_OriginCurOffset);
1176                 goto CATCH;
1177         }
1178
1179         for (i = 0 ; i <= pDcfHandler->m_DrmEndOffset ; i++)
1180         {
1181                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1182                 if (nRet != TADC_SUCCESS)
1183                 {
1184                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, forward) : key = %d, file = %s, i = %lld, ret = %x\n", first_key, pDCF, i, nRet);
1185                         goto CATCH;
1186                 }
1187
1188                 DrmCurOffset = pDcfHandler->DrmTell();
1189                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1190                 {
1191                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_SET, forward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1192                         goto CATCH;
1193                 }
1194         }
1195         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1196         {
1197                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_SET, forward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n", DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1198                 goto CATCH;
1199         }
1200
1201         for (i = pDcfHandler->m_DrmEndOffset ; i >= 0 ; i--)
1202         {
1203                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1204                 if (nRet != TADC_SUCCESS)
1205                 {
1206                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_SET, backward) : key=%d, file=%s, i=%lld, %x\n", first_key, pDCF, i, nRet);
1207                         goto CATCH;
1208                 }
1209
1210                 DrmCurOffset = pDcfHandler->DrmTell();
1211                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1212                 {
1213                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_SET, backward) : origin = %lld, result = %lld, i=%lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1214                         goto CATCH;
1215                 }
1216         }
1217         if (DrmCurOffset != 0)
1218         {
1219                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_SET, backward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1220                 goto CATCH;
1221         }
1222
1223         for (i = 0 ; i <= pDcfHandler->m_DrmEndOffset ; i++)
1224         {
1225                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1226                 if (nRet != TADC_SUCCESS)
1227                 {
1228                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, forward) : key=%d, file=%s, i=%lld, %x\n", first_key, pDCF, i, nRet);
1229                         goto CATCH;
1230                 }
1231
1232                 DrmCurOffset = pDcfHandler->DrmTell();
1233                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1234                 {
1235                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_END, forward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1236                         goto CATCH;
1237                 }
1238         }
1239         if (DrmCurOffset != 0)
1240         {
1241                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, forward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1242                 goto CATCH;
1243         }
1244
1245         for (i = pDcfHandler->m_DrmEndOffset ; i >= 0 ; i--)
1246         {
1247                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1248                 if (nRet != TADC_SUCCESS)
1249                 {
1250                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, backward) : key=%d, file=%s, i=%lld, %x\n", first_key, pDCF, i, nRet);
1251                         goto CATCH;
1252                 }
1253
1254                 DrmCurOffset = pDcfHandler->DrmTell();
1255                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1256                 {
1257                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_END, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1258                         goto CATCH;
1259                 }
1260         }
1261         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1262         {
1263                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_END, backward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n", DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1264                 goto CATCH;
1265         }
1266
1267         for (i = 0 ; i < pDcfHandler->m_DrmEndOffset ; i++)
1268         {
1269                 nRet = pDcfHandler->DrmSeek(-1, SEEK_CUR);
1270                 if (nRet != TADC_SUCCESS)
1271                 {
1272                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, forward) : key=%d, file=%s, i=%lld, %x\n", first_key, pDCF, i, nRet);
1273                         goto CATCH;
1274                 }
1275
1276                 DrmCurOffset = pDcfHandler->DrmTell();
1277                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1278                 {
1279                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed : origin=%lld, result=%lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset);
1280                         goto CATCH;
1281                 }
1282         }
1283         if (DrmCurOffset != 0)
1284         {
1285                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, forward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1286                 goto CATCH;
1287         }
1288
1289         for (i = 0 ; i < pDcfHandler->m_DrmEndOffset ; i++)
1290         {
1291                 nRet = pDcfHandler->DrmSeek(1, SEEK_CUR);
1292                 if (nRet != TADC_SUCCESS)
1293                 {
1294                         printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, backward) : key=%d, file=%s, i=%lld, %x\n", first_key, pDCF, i, nRet);
1295                         goto CATCH;
1296                 }
1297
1298                 DrmCurOffset = pDcfHandler->DrmTell();
1299                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1300                 {
1301                         printf("tc09_DrmFileMgrPositive_FileAPI_01 - DrmCurOffset Comparison failed (SEEK_CUR, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1302                         goto CATCH;
1303                 }
1304         }
1305         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1306         {
1307                 printf("tc09_DrmFileMgrPositive_FileAPI_01 DrmSeek failed (SEEK_CUR, backward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1308                 goto CATCH;
1309         }
1310
1311         printf("tc09_DrmFileMgrPositive_FileAPI_01 finished! -------- success \n");
1312
1313         return true;
1314
1315 CATCH:
1316         return false;
1317 }
1318
1319 bool tc09_DrmFileMgrPositive_FileAPI_02(void)
1320 {
1321         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/8SPXfqc6iL.tpk");
1322         int nRet = TADC_SUCCESS;
1323
1324         DrmFileMgr* pDrmFileMgr = NULL;
1325         DrmFileHandler *pDcfHandler = NULL;
1326
1327         long long originalEndOffset = 705914;
1328         long long DrmCurOffset = 0;
1329         long long OriginCurOffset = 842;
1330         long long i = 0;
1331
1332         printf("tc09_DrmFileMgrPositive_FileAPI_02() -------- Started! \n");
1333
1334         pDrmFileMgr = DrmFileMgr::GetInstance();
1335
1336         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1337         if (nRet != TADC_SUCCESS)
1338         {
1339                 printf("tc09_DrmFileMgrPositive_FileAPI_02 failed : key = %d, file = %s, %x\n", second_key, pDCF, nRet);
1340                 goto CATCH;
1341         }
1342
1343         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
1344         {
1345                 printf("tc09_DrmFileMgrPositive_FileAPI_02 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
1346                 goto CATCH;
1347         }
1348
1349         if (OriginCurOffset != pDcfHandler->m_OriginCurOffset)
1350         {
1351                 printf("tc09_DrmFileMgrPositive_FileAPI_02 - originalCurOffset Comparison failed : origin = %lld, result = %lld\n", OriginCurOffset, pDcfHandler->m_OriginCurOffset);
1352                 goto CATCH;
1353         }
1354
1355         for (i = 0 ; i <= pDcfHandler->m_DrmEndOffset ; i++)
1356         {
1357                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1358                 if (nRet != TADC_SUCCESS)
1359                 {
1360                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, forward) : key = %d, file = %s, i = %lld, ret = %x\n", second_key, pDCF, i, nRet);
1361                         goto CATCH;
1362                 }
1363
1364                 DrmCurOffset = pDcfHandler->DrmTell();
1365                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1366                 {
1367                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_SET, forward : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1368                         goto CATCH;
1369                 }
1370         }
1371         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1372         {
1373                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, forward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n", DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1374                 goto CATCH;
1375         }
1376
1377         for (i = pDcfHandler->m_DrmEndOffset ; i >= 0 ; i--)
1378         {
1379                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1380                 if (nRet != TADC_SUCCESS)
1381                 {
1382                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, backward) : key=%d, file=%s, i=%lld, %x\n", second_key, pDCF, i, nRet);
1383                         goto CATCH;
1384                 }
1385
1386                 DrmCurOffset = pDcfHandler->DrmTell();
1387                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1388                 {
1389                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_SET, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1390                         goto CATCH;
1391                 }
1392         }
1393         if (DrmCurOffset != 0)
1394         {
1395                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_SET, backward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1396                 goto CATCH;
1397         }
1398
1399         for (i = 0 ; i <= pDcfHandler->m_DrmEndOffset ; i++)
1400         {
1401                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1402                 if (nRet != TADC_SUCCESS)
1403                 {
1404                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, forward) : key=%d, file=%s, i=%lld, %x\n", second_key, pDCF, i, nRet);
1405                         goto CATCH;
1406                 }
1407
1408                 DrmCurOffset = pDcfHandler->DrmTell();
1409                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1410                 {
1411                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_END, forward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1412                         goto CATCH;
1413                 }
1414         }
1415         if (DrmCurOffset != 0)
1416         {
1417                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, forward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1418                 goto CATCH;
1419         }
1420
1421         for (i = pDcfHandler->m_DrmEndOffset ; i >= 0 ; i--)
1422         {
1423                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1424                 if (nRet != TADC_SUCCESS)
1425                 {
1426                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, backward) : key=%d, file=%s, i=%lld, %x\n", second_key, pDCF, i, nRet);
1427                         goto CATCH;
1428                 }
1429
1430                 DrmCurOffset = pDcfHandler->DrmTell();
1431                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1432                 {
1433                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_END, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1434                         goto CATCH;
1435                 }
1436         }
1437         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1438         {
1439                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_END, backward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n", DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1440                 goto CATCH;
1441         }
1442
1443         for (i = 0 ; i < pDcfHandler->m_DrmEndOffset ; i++)
1444         {
1445                 nRet = pDcfHandler->DrmSeek(-1, SEEK_CUR);
1446                 if (nRet != TADC_SUCCESS)
1447                 {
1448                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, forward) : key=%d, file=%s, i=%lld, %x\n", second_key, pDCF, i, nRet);
1449                         goto CATCH;
1450                 }
1451
1452                 DrmCurOffset = pDcfHandler->DrmTell();
1453                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1454                 {
1455                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed : origin=%lld, result=%lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset);
1456                         goto CATCH;
1457                 }
1458         }
1459         if (DrmCurOffset != 0)
1460         {
1461                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, forward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1462                 goto CATCH;
1463         }
1464
1465         for (i = 0 ; i < pDcfHandler->m_DrmEndOffset ; i++)
1466         {
1467                 nRet = pDcfHandler->DrmSeek(1, SEEK_CUR);
1468                 if (nRet != TADC_SUCCESS)
1469                 {
1470                         printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, backward) : key=%d, file=%s, i=%lld, %x\n", second_key, pDCF, i, nRet);
1471                         goto CATCH;
1472                 }
1473
1474                 DrmCurOffset = pDcfHandler->DrmTell();
1475                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1476                 {
1477                         printf("tc09_DrmFileMgrPositive_FileAPI_02 - DrmCurOffset Comparison failed (SEEK_CUR, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1478                         goto CATCH;
1479                 }
1480         }
1481         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1482         {
1483                 printf("tc09_DrmFileMgrPositive_FileAPI_02 DrmSeek failed (SEEK_CUR, backward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1484                 goto CATCH;
1485         }
1486
1487         printf("tc09_DrmFileMgrPositive_FileAPI_02 finished! -------- success \n");
1488
1489         return true;
1490
1491 CATCH:
1492         return false;
1493 }
1494
1495 bool tc09_DrmFileMgrPositive_FileAPI_03(void)
1496 {
1497         const char *pDCF = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/FightGuiIF.tpk");
1498         int nRet = TADC_SUCCESS;
1499
1500         DrmFileMgr* pDrmFileMgr = NULL;
1501         DrmFileHandler *pDcfHandler = NULL;
1502
1503         long long originalEndOffset = 45194636;
1504         long long DrmCurOffset = 0;
1505         long long OriginCurOffset = 847;
1506         long long i = 0;
1507
1508         printf("tc09_DrmFileMgrPositive_FileAPI_03() -------- Started! \n");
1509
1510         pDrmFileMgr = DrmFileMgr::GetInstance();
1511
1512         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1513         if (nRet != TADC_SUCCESS)
1514         {
1515                 printf("tc09_DrmFileMgrPositive_FileAPI_03 failed : key = %d, file = %s, %x\n", third_key, pDCF, nRet);
1516                 goto CATCH;
1517         }
1518
1519         if (pDcfHandler->m_OriginEndOffset != originalEndOffset)
1520         {
1521                 printf("tc09_DrmFileMgrPositive_FileAPI_03 - originalEndOffset Comparison failed : origin = %lld, result = %lld\n", originalEndOffset, pDcfHandler->m_OriginEndOffset);
1522                 goto CATCH;
1523         }
1524
1525         if (OriginCurOffset != pDcfHandler->m_OriginCurOffset)
1526         {
1527                 printf("tc09_DrmFileMgrPositive_FileAPI_03 - originalCurOffset Comparison failed : origin = %lld, result = %lld\n", OriginCurOffset, pDcfHandler->m_OriginCurOffset);
1528                 goto CATCH;
1529         }
1530
1531         for (i = 0 ; i <= pDcfHandler->m_DrmEndOffset ; i++)
1532         {
1533                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1534                 if (nRet != TADC_SUCCESS)
1535                 {
1536                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, forward) : key = %d, file = %s, i = %lld, ret = %x\n", third_key, pDCF, i, nRet);
1537                         goto CATCH;
1538                 }
1539
1540                 DrmCurOffset = pDcfHandler->DrmTell();
1541                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1542                 {
1543                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_SET, forward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1544                         goto CATCH;
1545                 }
1546         }
1547         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1548         {
1549                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, forward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n", DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1550                 goto CATCH;
1551         }
1552
1553         for (i = pDcfHandler->m_DrmEndOffset ; i >= 0 ; i--)
1554         {
1555                 nRet = pDcfHandler->DrmSeek(i, SEEK_SET);
1556                 if (nRet != TADC_SUCCESS)
1557                 {
1558                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, backward) : key=%d, file=%s, i=%lld, %x\n", third_key, pDCF, i, nRet);
1559                         goto CATCH;
1560                 }
1561
1562                 DrmCurOffset = pDcfHandler->DrmTell();
1563                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1564                 {
1565                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_SET, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1566                         goto CATCH;
1567                 }
1568         }
1569         if (DrmCurOffset != 0)
1570         {
1571                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_SET, backward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1572                 goto CATCH;
1573         }
1574
1575         for (i = 0 ; i <= pDcfHandler->m_DrmEndOffset ; i++)
1576         {
1577                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1578                 if (nRet != TADC_SUCCESS)
1579                 {
1580                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, forward) : key=%d, file=%s, i=%lld, %x\n", third_key, pDCF, i, nRet);
1581                         goto CATCH;
1582                 }
1583
1584                 DrmCurOffset = pDcfHandler->DrmTell();
1585                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1586                 {
1587                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_END, forward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1588                         goto CATCH;
1589                 }
1590         }
1591         if (DrmCurOffset != 0)
1592         {
1593                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, forward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1594                 goto CATCH;
1595         }
1596
1597         for (i = pDcfHandler->m_DrmEndOffset ; i >= 0 ; i--)
1598         {
1599                 nRet = pDcfHandler->DrmSeek(-i, SEEK_END);
1600                 if (nRet != TADC_SUCCESS)
1601                 {
1602                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, backward) : key=%d, file=%s, i=%lld, %x\n", third_key, pDCF, i, nRet);
1603                         goto CATCH;
1604                 }
1605
1606                 DrmCurOffset = pDcfHandler->DrmTell();
1607                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1608                 {
1609                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_END, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1610                         goto CATCH;
1611                 }
1612         }
1613         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1614         {
1615                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_END, backward), DrmCurOffset = %lld, RealEndOffset = %lld, %x\n", DrmCurOffset, pDcfHandler->m_DrmEndOffset, nRet);
1616                 goto CATCH;
1617         }
1618
1619         for (i = 0 ; i < pDcfHandler->m_DrmEndOffset ; i++)
1620         {
1621                 nRet = pDcfHandler->DrmSeek(-1, SEEK_CUR);
1622                 if (nRet != TADC_SUCCESS)
1623                 {
1624                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, forward) : key=%d, file=%s, i=%lld, %x\n", third_key, pDCF, i, nRet);
1625                         goto CATCH;
1626                 }
1627
1628                 DrmCurOffset = pDcfHandler->DrmTell();
1629                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1630                 {
1631                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed : origin=%lld, result=%lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset);
1632                         goto CATCH;
1633                 }
1634         }
1635         if (DrmCurOffset != 0)
1636         {
1637                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, forward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1638                 goto CATCH;
1639         }
1640
1641         for (i = 0 ; i < pDcfHandler->m_DrmEndOffset ; i++)
1642         {
1643                 nRet = pDcfHandler->DrmSeek(1, SEEK_CUR);
1644                 if (nRet != TADC_SUCCESS)
1645                 {
1646                         printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, backward) : key=%d, file=%s, i=%lld, %x\n", third_key, pDCF, i, nRet);
1647                         goto CATCH;
1648                 }
1649
1650                 DrmCurOffset = pDcfHandler->DrmTell();
1651                 if (DrmCurOffset != pDcfHandler->m_DrmCurOffset)
1652                 {
1653                         printf("tc09_DrmFileMgrPositive_FileAPI_03 - DrmCurOffset Comparison failed (SEEK_CUR, backward) : origin = %lld, result = %lld, i = %lld\n", DrmCurOffset, pDcfHandler->m_DrmCurOffset, i);
1654                         goto CATCH;
1655                 }
1656         }
1657         if (DrmCurOffset != pDcfHandler->m_DrmEndOffset)
1658         {
1659                 printf("tc09_DrmFileMgrPositive_FileAPI_03 DrmSeek failed (SEEK_CUR, backward), DrmCurOffset = %lld, %x\n", DrmCurOffset, nRet);
1660                 goto CATCH;
1661         }
1662
1663         printf("tc09_DrmFileMgrPositive_FileAPI_03 finished! -------- success \n");
1664
1665         return true;
1666
1667 CATCH:
1668         return false;
1669 }
1670
1671 bool tc10_DrmFileMgrPositive_CloseFileHandler_01(void)
1672 {
1673         int nRet = TADC_SUCCESS;
1674
1675         DrmFileMgr* pDrmFileMgr = NULL;
1676         DrmFileHandler *pDcfHandler = NULL;
1677
1678         printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 -------- Started! \n");
1679
1680         pDrmFileMgr = DrmFileMgr::GetInstance();
1681
1682         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
1683         if (nRet != TADC_SUCCESS)
1684         {
1685                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed : key = %d, ret=%x\n", first_key, nRet);
1686                 goto CATCH;
1687         }
1688
1689         nRet = pDrmFileMgr->CloseFileHandler(first_key);
1690         if (nRet != TADC_SUCCESS)
1691         {
1692                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed : key = %d, ret=%x\n", first_key, nRet);
1693                 goto CATCH;
1694         }
1695
1696         nRet = pDrmFileMgr->GetFileHandler(first_key, &pDcfHandler);
1697         if (nRet == TADC_SUCCESS)
1698         {
1699                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed : key = %d\n", first_key);
1700                 goto CATCH;
1701         }
1702
1703         printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 finished! -------- success \n");
1704
1705         return true;
1706
1707 CATCH:
1708         return false;
1709 }
1710
1711 bool tc10_DrmFileMgrPositive_CloseFileHandler_02(void)
1712 {
1713         int nRet = TADC_SUCCESS;
1714
1715         DrmFileMgr* pDrmFileMgr = NULL;
1716         DrmFileHandler *pDcfHandler = NULL;
1717
1718         printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 -------- Started! \n");
1719
1720         pDrmFileMgr = DrmFileMgr::GetInstance();
1721
1722         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1723         if (nRet != TADC_SUCCESS)
1724         {
1725                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed : key = %d, ret=%x\n", second_key, nRet);
1726                 goto CATCH;
1727         }
1728
1729         nRet = pDrmFileMgr->CloseFileHandler(second_key);
1730         if (nRet != TADC_SUCCESS)
1731         {
1732                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed : key = %d, ret=%x\n", second_key, nRet);
1733                 goto CATCH;
1734         }
1735
1736         nRet = pDrmFileMgr->GetFileHandler(second_key, &pDcfHandler);
1737         if (nRet == TADC_SUCCESS)
1738         {
1739                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed : key = %d\n", second_key);
1740                 goto CATCH;
1741         }
1742
1743         printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 finished! -------- success \n");
1744
1745         return true;
1746
1747 CATCH:
1748         return false;
1749 }
1750
1751 bool tc10_DrmFileMgrPositive_CloseFileHandler_03(void)
1752 {
1753         int nRet = TADC_SUCCESS;
1754
1755         DrmFileMgr* pDrmFileMgr = NULL;
1756         DrmFileHandler *pDcfHandler = NULL;
1757
1758         printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 -------- Started! \n");
1759
1760         pDrmFileMgr = DrmFileMgr::GetInstance();
1761
1762         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1763         if (nRet != TADC_SUCCESS)
1764         {
1765                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed : key = %d, ret=%x\n", third_key, nRet);
1766                 goto CATCH;
1767         }
1768
1769         nRet = pDrmFileMgr->CloseFileHandler(third_key);
1770         if (nRet != TADC_SUCCESS)
1771         {
1772                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed : key = %d, ret=%x\n", third_key, nRet);
1773                 goto CATCH;
1774         }
1775
1776         nRet = pDrmFileMgr->GetFileHandler(third_key, &pDcfHandler);
1777         if (nRet == TADC_SUCCESS)
1778         {
1779                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed : key = %d\n", third_key);
1780                 goto CATCH;
1781         }
1782
1783         printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 finished! -------- success \n");
1784
1785         return true;
1786
1787 CATCH:
1788         return false;
1789 }
1790
1791 bool tc11_GetDeviceId_01(void)
1792 {
1793         unsigned char DUID[33] = {0,};
1794         int nRet = 0;
1795
1796         printf("tc11_GetDeviceID_01() -------- Started! \n");
1797
1798         nRet = TADC_IF_GetDUID((char*)DUID);
1799         if (nRet !=TADC_SUCCESS)
1800         {
1801                 printf("tc11_GetDeviceID_01() failed.");
1802                 return false;
1803         }
1804
1805         printf("DUID=%s\n", (char*)DUID);
1806         printf("tc11_GetDeviceID_01() finished! -------- success \n");
1807
1808         return true;
1809 }
1810
1811 bool tc12_TADC_SetDeviceInfo_01(void)
1812 {
1813         int     nRet = TADC_SUCCESS;
1814         T_DEVICE_INFO   t_DeviceInfo;
1815
1816         printf("tc12_TADC_SetDeviceInfo_01() -------- Started! \n");
1817
1818         nRet = TADC_SetDeviceInfo(&t_DeviceInfo);
1819         if (nRet != TADC_SUCCESS)
1820         {
1821                 printf("tc12_TADC_SetDeviceInfo_01() failed.\n");
1822                 return false;
1823         }
1824         printf("DUID=%s\n", (char*)t_DeviceInfo.DUID);
1825         printf("tc12_TADC_SetDeviceInfo_01() finished! -------- success \n");
1826
1827         return true;
1828 }
1829
1830 bool tc13_DTappsInstallLicense_01(void)
1831 {
1832         printf("tc13_DTappsInstallLicense_01() -------- Started! \n");
1833
1834         const char *pFirstRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/38EIfBurLJ-1.0.2.ro");
1835
1836         auto buf = _read_ro_file(pFirstRo);
1837
1838         int nRet = DTappsInstallLicense(reinterpret_cast<char *>(buf.data()));
1839         if (nRet != TADC_SUCCESS) {
1840                 printf("tc13_DTappsInstallLicense_01() failed. nRet=%d\n", nRet);
1841                 return false;
1842         }
1843
1844         printf("tc13_DTappsInstallLicense_01() finished! -------- success \n");
1845         return true;
1846 }
1847
1848 bool tc13_DTappsInstallLicense_02(void)
1849 {
1850         printf("tc13_DTappsInstallLicense_02() -------- Started! \n");
1851
1852         const char *pFirstRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/8SPXfqc6iL-1.0.0.ro");
1853
1854         auto buf = _read_ro_file(pFirstRo);
1855
1856         int nRet = DTappsInstallLicense(reinterpret_cast<char *>(buf.data()));
1857         if (nRet != TADC_SUCCESS) {
1858                 printf("tc13_DTappsInstallLicense_02() failed. nRet=%d\n", nRet);
1859                 return false;
1860         }
1861
1862         printf("tc13_DTappsInstallLicense_02() finished! -------- success \n");
1863         return true;
1864 }
1865
1866 bool tc13_DTappsInstallLicense_03(void)
1867 {
1868         printf("tc13_DTappsInstallLicense_03() -------- Started! \n");
1869
1870         const char *pFirstRo = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/FightGuiIF-1.0.0.ro");
1871
1872         auto buf = _read_ro_file(pFirstRo);
1873
1874         int nRet = DTappsInstallLicense(reinterpret_cast<char *>(buf.data()));
1875         if (nRet != TADC_SUCCESS) {
1876                 printf("tc13_DTappsInstallLicense_03() failed. nRet=%d\n", nRet);
1877                 return false;
1878         }
1879
1880         printf("tc13_DTappsInstallLicense_03() finished! -------- success \n");
1881         return true;
1882 }
1883
1884 bool
1885 tc_local_01_drm_tizen_generate_license_request_p(void)
1886 {
1887     bool res = true;
1888     int ret_value = DRMTEST_SUCCESS;
1889
1890     char *purchase_response = NULL;
1891     char *req_id = NULL;
1892     unsigned int  req_buff_len = 1024*5;
1893     char req_buff[req_buff_len] = {0, };
1894     unsigned int  url_buff_len = 1024;
1895     char url_buff[url_buff_len] = {0, };
1896
1897     printf("[%s] test started\n", __func__);
1898     ret_value = generate_purchase_response(&purchase_response, &req_id);
1899     if(ret_value != DRMTEST_SUCCESS) {
1900         res = false;
1901         goto CATCH;
1902     }
1903     printf("...purchase_response:\n%s\n", purchase_response);
1904
1905     ret_value = drm_tizen_generate_license_request(purchase_response, strlen(purchase_response),
1906                                              req_buff, &req_buff_len, url_buff, &url_buff_len);
1907     if(ret_value != TADC_SUCCESS) {
1908         printf("...drm_tizen_generate_license_request failed. ret=%d\n", ret_value);
1909         res = false;
1910         goto CATCH;
1911     }
1912     printf("...license_request_url:%s\n", url_buff);
1913     printf("...license_request:\n%s\n", req_buff);
1914
1915     printf("[%s] test ended: result=%d\n", __func__, ret_value);
1916
1917 CATCH:
1918     if(purchase_response != NULL)
1919         free(purchase_response);
1920     if(req_id != NULL)
1921         free(req_id);
1922
1923     return res;
1924 }
1925
1926 bool
1927 tc_local_01_drm_tizen_full_test_p(void)
1928 {
1929     bool res = true;
1930     int ret_value = DRMTEST_SUCCESS;
1931
1932     char *purchase_response = NULL;
1933     char *req_id = NULL;
1934     unsigned int  req_buff_len = 1024*5;
1935     char req_buff[req_buff_len] = {0, };
1936     unsigned int  url_buff_len = 1024;
1937     char url_buff[url_buff_len] = {0, };
1938
1939     char* ro_request_buff = NULL;
1940     char* ro_response_buff = NULL;
1941     char* dh_key_p = NULL;
1942     char* dh_key_g = NULL;
1943     char* dh_key_a = NULL;
1944
1945     unsigned char duid[33] = {0,};
1946     const char* cid = "38EIfBurLJ-1.0.2";
1947     const char* ro_template_path = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/RO/38EIfBurLJ-1.0.2.ro_template");
1948
1949     const char* encrypted_file_path = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DCF/38EIfBurLJ.tpk");
1950     const char* plaintext_file_path = tzplatform_mkpath(TZ_SYS_DATA,"drm_test/DecryptedApp/38EIfBurLJ_dec.tpk");
1951     const char* decrypted_file_path = "/tmp/38EIfBurLJ.tpk";
1952
1953     int identical = DRMTEST_NOTIDENTICAL;
1954
1955     printf("[%s] test started\n", __func__);
1956
1957     if(ret_value != DRMTEST_SUCCESS) {
1958         res = false;
1959         goto CATCH;
1960     }
1961
1962     ret_value = generate_purchase_response(&purchase_response, &req_id);
1963     if(ret_value != DRMTEST_SUCCESS) {
1964         res = false;
1965         goto CATCH;
1966     }
1967     //printf("...purchase_response:\n%s\n", purchase_response);
1968
1969     ret_value = drm_tizen_generate_license_request(purchase_response, strlen(purchase_response),
1970                                              req_buff, &req_buff_len, url_buff, &url_buff_len);
1971     if(ret_value != TADC_SUCCESS) {
1972         printf("...drm_tizen_generate_license_request failed. ret=%d\n", ret_value);
1973         res = false;
1974         goto CATCH;
1975     }
1976     printf("...license_request_url:%s\n", url_buff);
1977     printf("...license_request:\n%s\n", req_buff);
1978
1979     ret_value = get_dh_key_from_ro_request(req_buff, &dh_key_p, &dh_key_g, &dh_key_a);
1980     if(ret_value != DRMTEST_SUCCESS) {
1981         res = false;
1982         goto CATCH;
1983     }
1984     //printf("...DH key: p=%s, g=%s, a=%s\n", dh_key_p, dh_key_g, dh_key_a);
1985
1986     ret_value = TADC_IF_GetDUID((char*)duid);
1987     if (ret_value != TADC_SUCCESS) {
1988         return false;
1989     }
1990     printf("duid=%s\n", (char*)duid);
1991
1992     ret_value = generate_right_object_response(dh_key_p, dh_key_g, dh_key_a, req_id,
1993                                                cid, ro_template_path, (const char*)duid, &ro_response_buff);
1994     if(ret_value != DRMTEST_SUCCESS) {
1995         res = false;
1996         goto CATCH;
1997     }
1998     printf("...right_object_response:\n%s\n", ro_response_buff);
1999
2000     ret_value = drm_tizen_register_license(ro_response_buff, strlen(ro_response_buff));
2001     if(ret_value != TADC_SUCCESS) {
2002         printf("...drm_tizen_register_license failed. ret=%d\n", ret_value);
2003         res = false;
2004         goto CATCH;
2005     }
2006     printf("...drm_tizen_register_license: succeeded\n");
2007
2008     ret_value = drm_tizen_decrypt_package(encrypted_file_path, strlen(encrypted_file_path),
2009                                           decrypted_file_path, strlen(decrypted_file_path));
2010     if(ret_value != TADC_SUCCESS) {
2011         printf("...drm_tizen_decrypt_package failed. ret=%d\n", ret_value);
2012         res = false;
2013         goto CATCH;
2014     }
2015     printf("...drm_tizen_decrypt_package: succeeded\n");
2016
2017     ret_value = is_identical_files(plaintext_file_path, decrypted_file_path, &identical);
2018     if(ret_value != DRMTEST_SUCCESS) {
2019         printf("...is_identical_files failed. ret=%d\n", ret_value);
2020         res = false;
2021         goto CATCH;
2022     }
2023     if(identical != DRMTEST_IDENTICAL) {
2024         printf("...the decrypted file is not same with a original plaintext file .\n");
2025         res = false;
2026         goto CATCH;
2027     }
2028     printf("...drm_tizen_decrypt_package: succeeded : the decrypted file is with a original plaintext file.\n");
2029
2030 CATCH:
2031     if(purchase_response != NULL)
2032         free(purchase_response);
2033     if(req_id != NULL)
2034         free(req_id);
2035     if(ro_request_buff != NULL)
2036         free(ro_request_buff);
2037     if(ro_response_buff != NULL)
2038         free(ro_response_buff);
2039
2040     return res;
2041 }
2042
2043
2044 /*
2045 bool tc15_DrmTdcDecryptPackge_01(void)
2046 {
2047         int     nRet = TADC_SUCCESS;
2048
2049 }
2050 */
2051 #endif
2052
2053 int main(int, char *[])
2054 {
2055         printf(" ---------- Test Tizen DRM core --- Start ....\n");
2056         test_drm_core();
2057         printf(" ---------- Test Tizen DRM core ---  End  ....\n");
2058
2059 #if 1
2060         printf(" ---------- Test Tizen DRM v2.0.1 APIs   ---  Start ....    \n");
2061
2062         int bRet = TADC_SUCCESS;
2063
2064         char ReqBuf[1024*5] = {0, };
2065         unsigned int ReqBufLen = 0;
2066
2067         char RespBuf[1024*10] = {0, };
2068         unsigned int RespBufLen = 0;
2069
2070 //      char DecLicenseBuf[1024*10] = {0, };
2071 //      unsigned int DecLicenseBufLen = 0;
2072
2073         char LicenseUrl[1024] = {0, };
2074         unsigned int LicenseUrlLen = 0;
2075
2076         //2011.03.08
2077         //DrmTdcFileHeader TDCFileHeader;
2078 //      char cid[1024] = {0, };
2079 //      char riurl[1024] = {0, };
2080
2081         char testFileName[256] = {0, };
2082         char tempBuf[256] = {0, };
2083
2084         bool isOk = false;
2085
2086         //----------------------------------------------------------------------------------------------------
2087         // 0. Static TC running
2088         //----------------------------------------------------------------------------------------------------
2089
2090         printf("\n0. Static TC  Start  ----------------------------------------\n");
2091 /*
2092         isOk = tc01_VerifyRoSignature_Positive_01();
2093         if (isOk != true)
2094         {
2095                 printf("tc01_VerifyRoSignature_Positive_01 failed!\n");
2096         }
2097
2098         isOk = tc01_VerifyRoSignature_Positive_02();
2099         if (isOk != true)
2100         {
2101                 printf("tc01_VerifyRoSignature_Positive_02 failed!\n");
2102         }
2103
2104         isOk = tc01_VerifyRoSignature_Positive_03();
2105         if (isOk != true)
2106         {
2107                 printf("tc01_VerifyRoSignature_Positive_03 failed!\n");
2108         }
2109
2110         isOk = tc02_VerifyRoSignature_Negative_Cert_01();
2111         if (isOk != true)
2112         {
2113                 printf("tc02_VerifyRoSignature_Negative_Cert_01 failed!\n");
2114         }
2115
2116         isOk = tc02_VerifyRoSignature_Negative_Cert_02();
2117         if (isOk != true)
2118         {
2119                 printf("tc02_VerifyRoSignature_Negative_Cert_02 failed!\n");
2120         }
2121
2122         isOk = tc02_VerifyRoSignature_Negative_Cert_03();
2123         if (isOk != true)
2124         {
2125                 printf("tc02_VerifyRoSignature_Negative_Cert_03 failed!\n");
2126         }
2127
2128         isOk = tc03_VerifyRoSignature_Negative_Signature_01();
2129         if (isOk != true)
2130         {
2131                 printf("tc03_VerifyRoSignature_Negative_Signature_01 failed!\n");
2132         }
2133
2134         isOk = tc03_VerifyRoSignature_Negative_Signature_02();
2135         if (isOk != true)
2136         {
2137                 printf("tc03_VerifyRoSignature_Negative_Signature_02 failed!\n");
2138         }
2139
2140         isOk = tc03_VerifyRoSignature_Negative_Signature_03();
2141         if (isOk != true)
2142         {
2143                 printf("tc03_VerifyRoSignature_Negative_Signature_03 failed!\n");
2144         }
2145
2146         isOk = tc04_isDrmFile_Positive_01();
2147         if (isOk != true)
2148         {
2149                 printf("tc04_isDrmFile_Positive_01 failed!\n");
2150         }
2151
2152         isOk = tc04_isDrmFile_Positive_02();
2153         if (isOk != true)
2154         {
2155                 printf("tc04_isDrmFile_Positive_02 failed!\n");
2156         }
2157
2158         isOk = tc04_isDrmFile_Positive_03();
2159         if (isOk != true)
2160         {
2161                 printf("tc04_isDrmFile_Positive_03 failed!\n");
2162         }
2163
2164         isOk = tc05_isDrmFile_Negative_01();
2165         if (isOk != true)
2166         {
2167                 printf("tc05_isDrmFile_Negative_01 failed!\n");
2168         }
2169
2170         isOk = tc05_isDrmFile_Negative_02();
2171         if (isOk != true)
2172         {
2173                 printf("tc05_isDrmFile_Negative_02 failed!\n");
2174         }
2175
2176         isOk = tc05_isDrmFile_Negative_03();
2177         if (isOk != true)
2178         {
2179                 printf("tc05_isDrmFile_Negative_03 failed!\n");
2180         }
2181
2182         isOk = tc13_DTappsInstallLicense_01();
2183         if (isOk != true)
2184         {
2185                 printf("tc13_DTappsInstallLicense_01 failed!\n");
2186         }
2187
2188         isOk = tc13_DTappsInstallLicense_02();
2189         if (isOk != true)
2190         {
2191                 printf("tc13_DTappsInstallLicense_02 failed!\n");
2192         }
2193
2194         isOk = tc13_DTappsInstallLicense_03();
2195         if (isOk != true)
2196         {
2197                 printf("tc13_DTappsInstallLicense_03 failed!\n");
2198         }
2199
2200         isOk = tc06_DrmFileHandlerPositive_01();
2201         if (isOk != true)
2202         {
2203                 printf("tc06_DrmFileHandlerPositive_01 failed!\n");
2204         }
2205
2206         isOk = tc06_DrmFileHandlerPositive_02();
2207         if (isOk != true)
2208         {
2209                 printf("tc06_DrmFileHandlerPositive_02 failed!\n");
2210         }
2211
2212         isOk = tc06_DrmFileHandlerPositive_03();
2213         if (isOk != true)
2214         {
2215                 printf("tc06_DrmFileHandlerPositive_03 failed!\n");
2216         }
2217
2218         isOk = tc07_DrmFileMgrPositive_01();
2219         if (isOk != true)
2220         {
2221                 printf("tc07_DrmFileMgrPositive_01 failed!\b");
2222         }
2223
2224         isOk = tc07_DrmFileMgrPositive_02();
2225         if (isOk != true)
2226         {
2227                 printf("tc07_DrmFileMgrPositive_02 failed!\n");
2228         }
2229
2230         isOk = tc07_DrmFileMgrPositive_03();
2231         if (isOk != true)
2232         {
2233                 printf("tc07_DrmFileMgrPositive_03 failed!\n");
2234         }
2235
2236         isOk = tc08_DrmFileMgrPositive_GetFileHandler_01();
2237         if (isOk != true)
2238         {
2239                 printf("tc08_DrmFileMgrPositive_GetFileHandler_01 failed!\n");
2240         }
2241
2242         isOk = tc08_DrmFileMgrPositive_GetFileHandler_02();
2243         if (isOk != true)
2244         {
2245                 printf("tc08_DrmFileMgrPositive_GetFileHandler_02 failed!\n");
2246         }
2247
2248         isOk = tc08_DrmFileMgrPositive_GetFileHandler_03();
2249         if (isOk != true)
2250         {
2251                 printf("tc08_DrmFileMgrPositive_GetFileHandler_03 failed!\n");
2252         }
2253
2254         isOk = tc09_DrmFileMgrPositive_FileAPI_01();
2255         if (isOk != true)
2256         {
2257                 printf("tc09_DrmFileMgrPositive_FileAPI_01 failed!\n");
2258         }
2259
2260         isOk = tc09_DrmFileMgrPositive_FileAPI_02();
2261         if (isOk != true)
2262         {
2263                 printf("tc09_DrmFileMgrPositive_FileAPI_02 failed!\n");
2264         }
2265
2266         isOk = tc09_DrmFileMgrPositive_FileAPI_03();
2267         if (isOk != true)
2268         {
2269                 printf("tc09_DrmFileMgrPositive_FileAPI_03 failed!\n");
2270         }
2271
2272         isOk = tc10_DrmFileMgrPositive_CloseFileHandler_01();
2273         if (isOk != true)
2274         {
2275                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_01 failed!\n");
2276         }
2277
2278         isOk = tc10_DrmFileMgrPositive_CloseFileHandler_02();
2279         if (isOk != true)
2280         {
2281                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_02 failed!\n");
2282         }
2283
2284         isOk = tc10_DrmFileMgrPositive_CloseFileHandler_03();
2285         if (isOk != true)
2286         {
2287                 printf("tc10_DrmFileMgrPositive_CloseFileHandler_03 failed!\n");
2288         }
2289
2290         isOk = tc11_GetDeviceId_01();
2291         if (isOk != true)
2292         {
2293                 printf("tc11_GetDeviceId_01 failed!\n");
2294         }
2295
2296         isOk = tc12_TADC_SetDeviceInfo_01();
2297         if (isOk != true)
2298         {
2299                 printf("tc12_TADC_SetDeviceInfo_01 failed!\n");
2300         }
2301
2302         isOk = tc11_GetDeviceId_01();
2303         if (isOk != true)
2304         {
2305                 printf("tc11_GetDeviceId_01 failed!\n");
2306         }
2307 */
2308     isOk = tc_local_01_drm_tizen_full_test_p();
2309     if (isOk != true)
2310     {
2311         printf("tc_local_01_drm_tizen_full_test_p failed!\n");
2312     }
2313
2314         //----------------------------------------------------------------------------------------------------
2315         // 1. Check is drm file
2316         //----------------------------------------------------------------------------------------------------
2317
2318         printf("===============================================================================\n");
2319         printf ("Enter test file name  -->  ");
2320
2321         isOk = scanf("%s", testFileName);
2322         if (isOk < 1)
2323         {
2324                 printf ("Input value wrong! scanf() failed!!");
2325                 return 0;
2326         }
2327         printf("\n1. drm_tizen_is_drm_file  Start  ----------------------------------------\n");
2328
2329         bRet = drm_tizen_is_drm_file(testFileName, strlen(testFileName));
2330         if (bRet != TADC_SUCCESS)
2331         {
2332                 printf("drm_tizen_is_drm_file Error! ret = %d\n", bRet);
2333                 return 0;
2334         }
2335         printf("%s file is TADC file!\n", testFileName);
2336
2337         //----------------------------------------------------------------------------------------------------
2338         // 2. Make PurchaseRequest Data
2339         //----------------------------------------------------------------------------------------------------
2340         printf("\n2. Make PurchaseRequest Data  Start  ----------------------------------------\n");
2341
2342         memset(ReqBuf, 0x00, sizeof(ReqBuf));
2343         memset(LicenseUrl, 0x00, sizeof(LicenseUrl));
2344         ReqBufLen = sizeof(ReqBuf);
2345         LicenseUrlLen = sizeof(LicenseUrl);
2346
2347         bRet = drm_tizen_generate_purchase_request(testFileName, ReqBuf, &ReqBufLen, LicenseUrl, &LicenseUrlLen);
2348         if (bRet == false)
2349         {
2350                 printf(" drm_tizen_generate_purchase_request Error!  \n");
2351                 return 0;
2352         }
2353
2354         printf("drm_tizen_generate_purchase_request - ReqBufLen : %d,  License Url : %s   \n", ReqBufLen, LicenseUrl);
2355         if ((bRet = _write_logfile("Request_1.dat", ReqBuf, ReqBufLen-1)) == false)
2356         {
2357                 printf(" drm_tizen_generate_purchase_request _write_logfile Error!  \n");
2358                 return 0;
2359         }
2360
2361         //break.... HTTP Request & Reaponse Processing...
2362         printf ("Enter any key after create Response_1.dat file. -->  ");
2363         std::cin >> tempBuf;
2364
2365         memset(RespBuf, 0x00, sizeof(RespBuf));
2366         RespBufLen = sizeof(RespBuf);
2367         if ((bRet = _read_logfile("Response_1.dat", RespBuf, &RespBufLen)) == false)
2368         {
2369                 printf(" drm_tizen_generate_purchase_request _read_logfile Error!  \n");
2370                 return 0;
2371         }
2372
2373         //----------------------------------------------------------------------------------------------------
2374         // 3. Make License Request Data
2375         //----------------------------------------------------------------------------------------------------
2376         printf("\n3. Make License Request Data  Start  ----------------------------------------\n");
2377
2378         memset(ReqBuf, 0x00, sizeof(ReqBuf));
2379         memset(LicenseUrl, 0x00, sizeof(LicenseUrl));
2380         ReqBufLen = sizeof(ReqBuf);
2381         LicenseUrlLen = sizeof(LicenseUrl);
2382
2383         bRet = drm_tizen_generate_license_request(RespBuf,  RespBufLen, ReqBuf, &ReqBufLen, LicenseUrl, &LicenseUrlLen);
2384         if (bRet != TADC_SUCCESS)
2385         {
2386                 printf(" drm_tizen_generate_license_request Error!  \n");
2387                 return 0;
2388         }
2389
2390         printf("drm_tizen_generate_license_request - ReqBufLen : %d,  RO Url : %s   \n", ReqBufLen, LicenseUrl);
2391         if ((bRet = _write_logfile("Request_2.dat", ReqBuf, ReqBufLen - 1)) == false)
2392         {
2393                 printf(" drm_tizen_generate_license_request _write_logfile Error!  \n");
2394                 return 0;
2395         }
2396
2397         //break.... HTTP Request & Reaponse Processing...
2398         printf ("Enter any key after create Response_2.dat file. -->  ");
2399         std::cin >> tempBuf;
2400
2401         memset(RespBuf, 0x00, sizeof(RespBuf));
2402         RespBufLen = sizeof(RespBuf);
2403         if ((bRet = _read_logfile("Response_2.dat", RespBuf, &RespBufLen)) == false)
2404         {
2405                 printf(" drm_tizen_generate_license_request _read_logfile Error! \n");
2406                 return 0;
2407         }
2408
2409         //----------------------------------------------------------------------------------------------------
2410         // 4. Decrypt DRM License
2411         //----------------------------------------------------------------------------------------------------
2412         printf("\n4. Decrypt DRM License Start  --------------------------------------------\n");
2413
2414         bRet = drm_tizen_register_license(RespBuf, RespBufLen);
2415         if (bRet != TADC_SUCCESS)
2416         {
2417                 printf(" drm_tizen_register_license  Error!  \n");
2418                 return 0;
2419         }
2420
2421         //---------------------------------------------------------------------------------------------------
2422         // 5. Decrypt DRM File
2423         //----------------------------------------------------------------------------------------------------
2424         printf("\n5. Decrypt DRM File Start  -----------------------------------------\n");
2425
2426         sprintf(tempBuf, "%s.dec", testFileName);
2427         bRet = drm_tizen_decrypt_package(testFileName, strlen(testFileName), tempBuf, strlen(tempBuf));
2428
2429         if (bRet != TADC_SUCCESS)
2430         {
2431                 printf(" drm_tizen_decrypt_package  Error!  \n");
2432                 return 0;
2433         }
2434
2435         printf("\n --------------Test Tizen Apps DRM APIs   ---  End ---------------\n");
2436
2437 #endif
2438 }