tadcore/Svc/DrmTdcSvc.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  * @file    DrmTdcSvc.cpp
  17  * @brief   TADC Testcase temporarily.
  18  * @author  Sangil Yoon (si83.yoon@samsung.com)
  19  * @version 1.0
  20  *
  21 */
  22
  23 #include "TADC_Core.h"
  24 #include "TADC_IF.h"
  25
  26 #include "TADC_ErrorCode.h"
  27
  28 #include "DrmTdcSvc.h"
  29
  30 #define DHINFO_MAX        100
  31 #define DHINFO_REQIDLEN   20
  32
  33 #define TDC_DECRYPT_IOLEN 1024 * 1024 // 1024 Kbyte
  34
  35 //DH Session Info Structure
  36 typedef struct {
  37         BYTE hashReqID[DHINFO_MAX][DHINFO_REQIDLEN]; //LicenseRequest Request ID Hash 20byte
  38         T_ROACQ_INFO t_ROAcqInfo[DHINFO_MAX];        //DH Info
  39 } DrmTdcDHInfo;
  40
  41
  42 static DrmTdcDHInfo g_DrmTdcDHInfo;
  43 static BOOL g_DrmTdcDHFlag = FALSE;
  44
  45 static char g_sTimeStamp[21]; //2011.03.08, GMT ("CCCC-YY-MMThh:mm:ssZ")
  46
  47 bool DrmTdcGetFileHeader(const char *pTADCFilepath,
  48                                                  DrmTdcFileHeader *pFileHeader)
  49 {
  50         T_FILE_HEADER t_FileHeader;
  51         T_DRM_HEADER t_DRMHeader;
  52
  53         //null check
  54         if (!pTADCFilepath || !pFileHeader) {
  55                 DRM_TAPPS_EXCEPTION("DrmTdcGetFileHeader Error : Parameter Null");
  56                 return FALSE;
  57         }
  58
  59         //Init
  60         memset(&t_FileHeader, 0x00, sizeof(T_FILE_HEADER));
  61         memset(&t_DRMHeader, 0x00, sizeof(T_DRM_HEADER));
  62         memset(pFileHeader, 0x00, sizeof(DrmTdcFileHeader));
  63
  64         //Get DRM Header Info
  65         if (TADC_GetDRMHeaderFromFile(pTADCFilepath, &t_FileHeader, &t_DRMHeader) < 0) {
  66                 DRM_TAPPS_EXCEPTION("TADC_GetDRMHeaderFromFile (%s)", pTADCFilepath);
  67                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
  68                 return FALSE;
  69         }
  70
  71         //Copy to pFileHeader ( CID, RIURL )
  72         if ((sizeof(pFileHeader->cid) < strlen((char *)t_DRMHeader.CID) + 1) ||
  73                         (sizeof(pFileHeader->riurl) < strlen((char *)t_DRMHeader.RIURL) + 1)) {
  74                 DRM_TAPPS_EXCEPTION("TADC_GetDRMHeaderFromFile. Invalid cid or riurl(%s)",
  75                                                         pTADCFilepath);
  76                 TADC_MEMFree_FileHeader(&t_FileHeader);
  77                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
  78                 return FALSE;
  79         }
  80
  81         memcpy(pFileHeader->cid, t_DRMHeader.CID, strlen((char *)t_DRMHeader.CID) + 1);
  82         memcpy(pFileHeader->riurl, t_DRMHeader.RIURL,
  83                    strlen((char *)t_DRMHeader.RIURL) + 1);
  84
  85         //Free
  86         TADC_MEMFree_FileHeader(&t_FileHeader);
  87         TADC_MEMFree_DRMHeader(&t_DRMHeader);
  88
  89         return TRUE;
  90 }
  91
  92 bool DrmTdcDecryptPackage(const char *pTADCFilepath, const char *pLicenseBuf,
  93                                                   unsigned int licenseBufLen, const char *pDecryptedFile)
  94 {
  95         T_FILE_HEADER t_FileHeader;
  96         T_DRM_HEADER t_DRMHeader;
  97         T_DEVICE_INFO t_DeviceInfo;
  98         T_RO t_RO;
  99
 100         FILE *hFile1 = INVALID_HOBJ; //TDC drm file
 101         FILE *hFile2 = INVALID_HOBJ; //Decrypted file
 102
 103         //2011.03.08, init
 104         memset(&t_FileHeader, 0x00, sizeof(T_FILE_HEADER));
 105         memset(&t_DRMHeader, 0x00, sizeof(T_DRM_HEADER));
 106         memset(&t_DeviceInfo, 0x00, sizeof(T_DEVICE_INFO));
 107         memset(&t_RO, 0x00, sizeof(T_RO));
 108
 109         //null check
 110         if (!pTADCFilepath
 111                         || !pLicenseBuf
 112                         || !pDecryptedFile
 113                         || licenseBufLen < 1) {
 114                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage Error : Parameter Null");
 115                 return FALSE;
 116         }
 117
 118         //Set DeviceInfo
 119         if (TADC_SetDeviceInfo(&t_DeviceInfo) < 0) {
 120                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage Error : TADC_SetDeviceInfo");
 121                 return FALSE;
 122         }
 123
 124         auto pReadBuf = (TADC_U8 *)TADC_IF_Malloc(TDC_DECRYPT_IOLEN);
 125
 126         if (!pReadBuf) {
 127                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage Error : pReadBuf Malloc Fail");
 128                 return FALSE;
 129         }
 130
 131         //Get DRM Header Info
 132         if (TADC_GetDRMHeaderFromFile(pTADCFilepath, &t_FileHeader, &t_DRMHeader) < 0) {
 133                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage Error : TADC_GetDRMHeaderFromFile");
 134                 TADC_MEMFree_FileHeader(&t_FileHeader);
 135                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 136                 TADC_IF_Free(pReadBuf);
 137                 return FALSE;
 138         }
 139
 140         // RO XML Parser
 141         if (TADC_GetResponseROInfo((unsigned char *)pLicenseBuf, &t_RO) < 0) {
 142                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage Error : TADC_GetResponseROInfo");
 143                 TADC_MEMFree_FileHeader(&t_FileHeader);
 144                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 145                 TADC_MEMFree_RO(&t_RO);
 146                 TADC_IF_Free(pReadBuf);
 147
 148                 return FALSE;
 149         }
 150
 151         //Get CEK
 152         if (TADC_GetCEK(&t_DeviceInfo, &t_RO, &t_DRMHeader) < 0) {
 153                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage Error : TADC_GetCEK");
 154                 TADC_MEMFree_FileHeader(&t_FileHeader);
 155                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 156                 TADC_MEMFree_RO(&t_RO);
 157                 TADC_IF_Free(pReadBuf);
 158                 return FALSE;
 159         }
 160
 161         //Decrypt File
 162         //File Open ( DRM File )
 163         if ((hFile1 = fopen(pTADCFilepath, "rb")) == INVALID_HOBJ) {
 164                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage Error : DRM FmOpenFile (%s)",
 165                                                         pTADCFilepath);
 166                 TADC_MEMFree_FileHeader(&t_FileHeader);
 167                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 168                 TADC_MEMFree_RO(&t_RO);
 169                 TADC_IF_Free(pReadBuf);
 170                 return FALSE;
 171         }
 172
 173         //File Create ( Decrypted File )
 174         if ((hFile2 = fopen(pDecryptedFile, "w+b")) == INVALID_HOBJ) {
 175                 DRM_TAPPS_EXCEPTION("Decrypted File FmOpenFile (%s)", pDecryptedFile);
 176                 fclose(hFile1);
 177                 TADC_MEMFree_FileHeader(&t_FileHeader);
 178                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 179                 TADC_MEMFree_RO(&t_RO);
 180                 TADC_IF_Free(pReadBuf);
 181                 return FALSE;
 182         }
 183
 184         if (fseek(hFile1, 0, SEEK_END) != 0) {
 185                 DRM_TAPPS_EXCEPTION("fseek failed");
 186                 fclose(hFile1);
 187                 fclose(hFile2);
 188                 TADC_MEMFree_FileHeader(&t_FileHeader);
 189                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 190                 TADC_MEMFree_RO(&t_RO);
 191                 TADC_IF_Free(pReadBuf);
 192                 return FALSE;
 193         }
 194         long size1 = ftell(hFile1);
 195
 196         long offset = static_cast<long>(t_FileHeader.Offset1 + 35 + t_DRMHeader.XmlSize);
 197         if (fseek(hFile1, offset, SEEK_SET) != 0) {
 198                 DRM_TAPPS_EXCEPTION("fseek failed");
 199                 fclose(hFile1);
 200                 fclose(hFile2);
 201                 TADC_MEMFree_FileHeader(&t_FileHeader);
 202                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 203                 TADC_MEMFree_RO(&t_RO);
 204                 TADC_IF_Free(pReadBuf);
 205                 return FALSE;
 206         }
 207
 208         if (size1 < offset) {
 209                 DRM_TAPPS_EXCEPTION("Invalid offset... offset is bigger than file size");
 210                 fclose(hFile1);
 211                 fclose(hFile2);
 212                 TADC_MEMFree_FileHeader(&t_FileHeader);
 213                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 214                 TADC_MEMFree_RO(&t_RO);
 215                 TADC_IF_Free(pReadBuf);
 216                 return FALSE;
 217         }
 218
 219         long size2 = size1 - offset; //plain file size
 220         long BlockCnt = (size2 / 512) + ((size2 % 512) ? 1 : 0);
 221
 222         long EncBlockCnt = BlockCnt;
 223
 224         if (t_DRMHeader.EncryptionRange != -1)
 225                 EncBlockCnt = t_DRMHeader.EncryptionRange;
 226
 227         long int i = 0;
 228
 229         while (i < BlockCnt) {
 230                 size_t ReadLen = fread(pReadBuf, 1, TDC_DECRYPT_IOLEN, hFile1);
 231
 232                 if (ReadLen < 1)
 233                         break;
 234
 235                 for (size_t k = 0; k < ReadLen; k += 512) {
 236                         if (i < EncBlockCnt) {
 237                                 size_t DecLen = ReadLen - k;
 238                                 DecLen = (DecLen > 512) ? 512 : DecLen;
 239
 240                                 if (TADC_DecryptBlock((char *)pReadBuf + k, DecLen, &t_DRMHeader) < 0) {
 241                                         DRM_TAPPS_EXCEPTION("TADC_DecryptBlock");
 242                                         fclose(hFile1);
 243                                         fclose(hFile2);
 244                                         TADC_MEMFree_FileHeader(&t_FileHeader);
 245                                         TADC_MEMFree_DRMHeader(&t_DRMHeader);
 246                                         TADC_MEMFree_RO(&t_RO);
 247                                         TADC_IF_Free(pReadBuf);
 248                                         return FALSE;
 249                                 }
 250                         }
 251
 252                         i += 1;
 253                 }
 254
 255                 fwrite(pReadBuf, 1, ReadLen, hFile2);
 256         }
 257
 258         fclose(hFile1); //sample drm file
 259         fclose(hFile2); //plain file
 260
 261         TADC_MEMFree_FileHeader(&t_FileHeader);
 262         TADC_MEMFree_DRMHeader(&t_DRMHeader);
 263         TADC_MEMFree_RO(&t_RO);
 264         TADC_IF_Free(pReadBuf);
 265
 266         return TRUE;
 267 }
 268
 269 bool DrmTdcDecryptPackage2(const char *pTADCFilepath, T_RO t_RO,
 270                                                    const char *pDecryptedFile)
 271 {
 272         T_FILE_HEADER t_FileHeader;
 273         T_DRM_HEADER t_DRMHeader;
 274         T_DEVICE_INFO t_DeviceInfo;
 275
 276         FILE *hFile1 = INVALID_HOBJ; //TDC drm file
 277         FILE *hFile2 = INVALID_HOBJ; //Decrypted file
 278
 279         //2011.03.08, init
 280         memset(&t_FileHeader, 0x00, sizeof(T_FILE_HEADER));
 281         memset(&t_DRMHeader, 0x00, sizeof(T_DRM_HEADER));
 282         memset(&t_DeviceInfo, 0x00, sizeof(T_DEVICE_INFO));
 283
 284         if (!pTADCFilepath || !pDecryptedFile) {
 285                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage2 Error : Parameter Null");
 286                 return FALSE;
 287         }
 288
 289         //Set DeviceInfo
 290         if (TADC_SetDeviceInfo(&t_DeviceInfo) == TADC_GETDUID_ERROR) {
 291                 DRM_TAPPS_EXCEPTION("DrmTdcDecryptPackage2 Error : TADC_SetDeviceInfo");
 292                 return FALSE;
 293         }
 294
 295         auto pReadBuf = (TADC_U8 *)TADC_IF_Malloc(TDC_DECRYPT_IOLEN);
 296
 297         if (!pReadBuf) {
 298                 DRM_TAPPS_EXCEPTION("pReadBuf Malloc Fail");
 299                 return FALSE;
 300         }
 301
 302         //Get DRM Header Info
 303         if (TADC_GetDRMHeaderFromFile(pTADCFilepath, &t_FileHeader, &t_DRMHeader) < 0) {
 304                 DRM_TAPPS_EXCEPTION("TADC_GetDRMHeaderFromFile");
 305                 TADC_MEMFree_FileHeader(&t_FileHeader);
 306                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 307                 TADC_IF_Free(pReadBuf);
 308                 return FALSE;
 309         }
 310
 311         //Get CEK
 312         if (TADC_GetCEK(&t_DeviceInfo, &t_RO, &t_DRMHeader) < 0) {
 313                 DRM_TAPPS_EXCEPTION("TADC_GetCEK");
 314                 TADC_MEMFree_FileHeader(&t_FileHeader);
 315                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 316                 TADC_IF_Free(pReadBuf);
 317                 return FALSE;
 318         }
 319
 320         //Decrypt File
 321         //File Open ( DRM File )
 322         if ((hFile1 = fopen(pTADCFilepath, "rb")) == INVALID_HOBJ) {
 323                 DRM_TAPPS_EXCEPTION("DRM FmOpenFile (%s)", pTADCFilepath);
 324                 TADC_MEMFree_FileHeader(&t_FileHeader);
 325                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 326                 TADC_IF_Free(pReadBuf);
 327                 return FALSE;
 328         }
 329
 330         //File Create ( Decrypted File )
 331         if ((hFile2 = fopen(pDecryptedFile, "w+b")) == INVALID_HOBJ) {
 332                 DRM_TAPPS_EXCEPTION("Decrypted File FmOpenFile (%s)", pDecryptedFile);
 333                 fclose(hFile1);
 334                 TADC_MEMFree_FileHeader(&t_FileHeader);
 335                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 336                 TADC_IF_Free(pReadBuf);
 337                 return FALSE;
 338         }
 339
 340         if (fseek(hFile1, 0, SEEK_END) != 0) {
 341                 DRM_TAPPS_EXCEPTION("fseek failed");
 342                 fclose(hFile1);
 343                 fclose(hFile2);
 344                 TADC_MEMFree_FileHeader(&t_FileHeader);
 345                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 346                 TADC_IF_Free(pReadBuf);
 347                 return FALSE;
 348         }
 349         long size1 = ftell(hFile1);
 350
 351         long offset = static_cast<long>(t_FileHeader.Offset1 + 35 + t_DRMHeader.XmlSize);
 352         if (fseek(hFile1, offset, SEEK_SET) != 0) {
 353                 DRM_TAPPS_EXCEPTION("fseek failed");
 354                 fclose(hFile1);
 355                 fclose(hFile2);
 356                 TADC_MEMFree_FileHeader(&t_FileHeader);
 357                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 358                 TADC_IF_Free(pReadBuf);
 359                 return FALSE;
 360         }
 361
 362         if (size1 < offset) {
 363                 DRM_TAPPS_EXCEPTION("Invalid offset... offset is bigger than file size");
 364                 fclose(hFile1);
 365                 fclose(hFile2);
 366                 TADC_MEMFree_FileHeader(&t_FileHeader);
 367                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 368                 TADC_IF_Free(pReadBuf);
 369                 return FALSE;
 370         }
 371
 372         long size2 = size1 - offset; //plain file size
 373         long BlockCnt = (size2 / 512) + ((size2 % 512) ? 1 : 0);
 374
 375         long EncBlockCnt = BlockCnt;
 376
 377         if (t_DRMHeader.EncryptionRange != -1)
 378                 EncBlockCnt = t_DRMHeader.EncryptionRange;
 379
 380         long int i = 0;
 381
 382         while (i < BlockCnt) {
 383                 auto ReadLen = fread(pReadBuf, 1, TDC_DECRYPT_IOLEN, hFile1);
 384
 385                 if (ReadLen < 1)
 386                         break;
 387
 388                 for (size_t k = 0; k < ReadLen; k += 512) {
 389                         if (i < EncBlockCnt) {
 390                                 auto DecLen = ReadLen - k;
 391                                 DecLen = (DecLen > 512) ? 512 : DecLen;
 392
 393                                 if (TADC_DecryptBlock((char *)pReadBuf + k, DecLen, &t_DRMHeader) < 0) {
 394                                         DRM_TAPPS_EXCEPTION("TADC_DecryptBlock");
 395                                         fclose(hFile1);
 396                                         fclose(hFile2);
 397                                         TADC_MEMFree_FileHeader(&t_FileHeader);
 398                                         TADC_MEMFree_DRMHeader(&t_DRMHeader);
 399                                         TADC_IF_Free(pReadBuf);
 400                                         return FALSE;
 401                                 }
 402                         }
 403
 404                         i += 1;
 405                 }
 406
 407                 fwrite(pReadBuf, 1, ReadLen, hFile2);
 408         }
 409
 410         fclose(hFile1); //sample drm file
 411         fclose(hFile2); //plain file
 412
 413         TADC_MEMFree_FileHeader(&t_FileHeader);
 414         TADC_MEMFree_DRMHeader(&t_DRMHeader);
 415         TADC_IF_Free(pReadBuf);
 416
 417         return TRUE;
 418 }
 419
 420 bool DrmTdcGeneratePurchaseRequest(const char *pTADCFilepath, char *pReqBuf,
 421                                                                    unsigned int *pReqBufLen, char *pLicenseUrl,
 422                                                                    unsigned int *pLicenseUrlLen)
 423 {
 424         T_FILE_HEADER t_FileHeader;
 425         T_DRM_HEADER t_DRMHeader;
 426         T_DEVICE_INFO t_DeviceInfo;
 427         char ReqLicBuf[REQU_MAXSIZE] = {0, };
 428
 429         //null check
 430         if (!pTADCFilepath
 431                         || !pReqBuf
 432                         || !pLicenseUrl
 433                         || *pReqBufLen < 512
 434                         || *pLicenseUrlLen < 512) {
 435                 DRM_TAPPS_EXCEPTION("Parameter Null");
 436                 return FALSE;
 437         }
 438
 439         memset(&t_FileHeader, 0x00, sizeof(T_FILE_HEADER));
 440         memset(&t_DRMHeader, 0x00, sizeof(T_DRM_HEADER));
 441         memset(&t_DeviceInfo, 0x00, sizeof(T_DEVICE_INFO));
 442
 443         //Set DeviceInfo
 444         if (TADC_SetDeviceInfo(&t_DeviceInfo) == TADC_GETDUID_ERROR) {
 445                 DRM_TAPPS_EXCEPTION("TADC_SetDeviceInfo");
 446                 return FALSE;
 447         }
 448
 449         //Get DRM Header Info
 450         if (TADC_GetDRMHeaderFromFile(pTADCFilepath, &t_FileHeader, &t_DRMHeader) < 0) {
 451                 DRM_TAPPS_EXCEPTION("TADC_GetDRMHeaderFromFile");
 452                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 453                 return FALSE;
 454         }
 455
 456         if (TADC_MakeRequestLicense(&t_DeviceInfo, &t_FileHeader, &t_DRMHeader,
 457                                                                 (unsigned char *)ReqLicBuf, sizeof(ReqLicBuf)) < 0) {
 458                 DRM_TAPPS_EXCEPTION("TADC_MakeRequestLicense");
 459                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 460                 return FALSE;
 461         }
 462
 463         //Copy pReqBuf
 464         size_t tmpLen = strlen((char *)ReqLicBuf);
 465
 466         if (*pReqBufLen <= tmpLen) {
 467                 DRM_TAPPS_EXCEPTION("*pReqBufLen(%d) <= %d", *pReqBufLen, tmpLen);
 468                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 469                 return FALSE;
 470         }
 471
 472         memcpy(pReqBuf, ReqLicBuf, tmpLen + 1);
 473
 474         //Copy License URL
 475         tmpLen = strlen((char *)t_DRMHeader.RIURL);
 476
 477         if (*pLicenseUrlLen <= tmpLen) {
 478                 DRM_TAPPS_EXCEPTION("*pLicenseUrlLen(%d) <= %d", *pLicenseUrlLen, tmpLen);
 479                 TADC_MEMFree_DRMHeader(&t_DRMHeader);
 480                 return FALSE;
 481         }
 482
 483         memcpy(pLicenseUrl, t_DRMHeader.RIURL, tmpLen + 1);
 484
 485         //Free
 486         TADC_MEMFree_FileHeader(&t_FileHeader);
 487         TADC_MEMFree_DRMHeader(&t_DRMHeader);
 488
 489         return TRUE;
 490 }
 491
 492 int DrmTdcGenerateLicenseRequest(const char *pRespBuf, unsigned int respBufLen,
 493                                                                  char *pReqBuf, unsigned int *pReqBufLen, char *pLicenseUrl,
 494                                                                  unsigned int *pLicenseUrlLen)
 495 {
 496         T_ROACQ_INFO *pt_ROAcqInfo = NULL;
 497
 498         char ReqROBuf[REQU_MAXSIZE] = {0}; //Request buff max size. (2011.03.08)
 499         BYTE sha1_tmp[DHINFO_REQIDLEN] = {0};
 500         int idx = 0;
 501         unsigned char ROVer[2]; //2011.03.08
 502
 503         //null check
 504         if (!pRespBuf
 505                         || !pReqBuf
 506                         || !pLicenseUrl
 507                         || respBufLen < 1
 508                         || *pReqBufLen < 512
 509                         ||  *pLicenseUrlLen < 512) {
 510                 DRM_TAPPS_EXCEPTION("Parameter Null");
 511                 return TADC_PARAMETER_ERROR;
 512         }
 513
 514         if (g_DrmTdcDHFlag == FALSE) {
 515                 DrmTdcDHInfoInit();
 516                 g_DrmTdcDHFlag = TRUE;
 517         }
 518
 519         for (idx = 0; idx < DHINFO_MAX; idx++) {
 520                 if (!TADC_IF_MemCmp(
 521                                         g_DrmTdcDHInfo.hashReqID[idx], sha1_tmp, DHINFO_REQIDLEN)) {
 522                         pt_ROAcqInfo = &g_DrmTdcDHInfo.t_ROAcqInfo[idx];
 523                         break;
 524                 }
 525         }
 526
 527         // Debug
 528         DRM_TAPPS_LOG("DrmTdcGenerateLicenseRequest ID Idx = %d", idx);
 529
 530         if (idx == DHINFO_MAX) {
 531                 DRM_TAPPS_EXCEPTION("idx == DHINFO_MAX");
 532                 return TADC_DHINFO_MAX_ERROR;
 533         }
 534
 535         //Get ReqID
 536         if (TADC_GetROAcqInfo((unsigned char *)pRespBuf, pt_ROAcqInfo) < 0) {
 537                 DRM_TAPPS_EXCEPTION("TADC_GetROAcqInfo");
 538                 return TADC_GET_ROACQ_INFO_ERROR;
 539         }
 540
 541         ROVer[0] = 2;
 542         ROVer[1] = 0;
 543
 544         if (TADC_MakeRequestRO(pt_ROAcqInfo, (unsigned char *)ReqROBuf,
 545                                                    sizeof(ReqROBuf), ROVer) < 0) {
 546                 DRM_TAPPS_EXCEPTION("TADC_MakeRequestRO");
 547                 return TADC_MAKE_LICENSEREQ_ERROR;
 548         }
 549
 550         // Debug
 551         DRM_TAPPS_LOG("Debug Log == Copy ReqID Hash Successfully Done!");
 552
 553         //Copy ReqID Hash
 554         TADC_IF_SHA1(pt_ROAcqInfo -> ReqID,
 555                                  TADC_IF_StrLen((char *)pt_ROAcqInfo -> ReqID),
 556                                  g_DrmTdcDHInfo.hashReqID[idx]);
 557
 558         //Copy pReqBuf
 559         size_t tmpLen = strlen((char *)ReqROBuf);
 560
 561         if (*pReqBufLen <= tmpLen) {
 562                 DRM_TAPPS_EXCEPTION("*pReqBufLen(%d) <= %d", *pReqBufLen, tmpLen);
 563                 return TADC_MEMAlOC_ERROR;
 564         }
 565
 566         memcpy(pReqBuf, ReqROBuf, tmpLen + 1);
 567
 568         //Copy License URL
 569         tmpLen = strlen((char *)pt_ROAcqInfo->ROAcqURL);
 570
 571         if (*pLicenseUrlLen <= tmpLen) {
 572                 DRM_TAPPS_EXCEPTION("*pLicenseUrlLen(%d) <= %d", *pLicenseUrlLen, tmpLen);
 573                 return TADC_MEMAlOC_ERROR;
 574         }
 575
 576         memcpy(pLicenseUrl, (char *)pt_ROAcqInfo->ROAcqURL, tmpLen + 1);
 577
 578         // Debug
 579         DRM_TAPPS_LOG("Debug Log == DrmTdcGenerateLicenseRequest Successfully Done!");
 580
 581         return TADC_SUCCESS;
 582 }
 583
 584 int DrmTdcDecryptLicense(const char *pRespBuf, unsigned int respBufLen,
 585                                                  char *pDecLicenseBuf, unsigned int *decLicenseBufLen)
 586 {
 587         T_ROACQ_INFO *pt_ROAcqInfo = NULL;
 588         T_RO t_RO;
 589         int ret = 0;
 590         int idx = 0;
 591         BYTE sha1_tmp[20] = {0};
 592
 593         //null check
 594         if (!pRespBuf
 595                         || !pDecLicenseBuf
 596                         || respBufLen < 1
 597                         || *decLicenseBufLen < 512) {
 598                 DRM_TAPPS_EXCEPTION("Parameter Null");
 599                 return TADC_PARAMETER_ERROR;
 600         }
 601
 602         memset(&t_RO, 0x00, sizeof(T_RO));
 603
 604         if (TADC_GetHashReqID((unsigned char *)pRespBuf, sha1_tmp) < 0) {
 605                 DRM_TAPPS_EXCEPTION("TADC_GetHashReqID");
 606                 return TADC_GET_HASHREQID_ERROR;
 607         }
 608
 609         for (idx = 0; idx < DHINFO_MAX; idx++) {
 610                 if (!TADC_IF_MemCmp(g_DrmTdcDHInfo.hashReqID[idx], sha1_tmp, 20)) {
 611                         pt_ROAcqInfo = &g_DrmTdcDHInfo.t_ROAcqInfo[idx];
 612                         break;
 613                 }
 614         }
 615
 616         if (idx == DHINFO_MAX) {
 617                 DRM_TAPPS_EXCEPTION("idx == DHINFO_MAX!, Session-key is not same.");
 618                 return TADC_DHINFO_MAX_ERROR;
 619         }
 620
 621         if (pt_ROAcqInfo == NULL) {
 622                 DRM_TAPPS_EXCEPTION("pt_ROAcqInfo is NULL.");
 623                 return TADC_DHINFO_MAX_ERROR;
 624         }
 625
 626         //Get Decrypted License
 627         if ((ret = TADC_GetResponseRO((unsigned char *)pRespBuf, pt_ROAcqInfo, &t_RO,
 628                                                                   (unsigned char *)pDecLicenseBuf)) < 0) {
 629                 DrmTdcDHInfoFree(idx); //2010.02.26
 630                 DRM_TAPPS_EXCEPTION("TADC_GetResponseRO! Ret[%x]", ret);
 631                 return TADC_GET_RORES_INFO_ERROR;
 632         }
 633
 634         *decLicenseBufLen = strlen(pDecLicenseBuf) + 1;
 635
 636         // Check Signature and Certificate Chain
 637         if ((ret = TADC_VerifyROSignature((unsigned char *)pDecLicenseBuf))) {
 638                 DRM_TAPPS_EXCEPTION("TADC_VerifyROSignature Error Code = %x", ret);
 639                 return TADC_RO_SIGNATURE_ERROR;
 640         }
 641
 642         //2011.03.08, return time stamp
 643         memcpy(g_sTimeStamp, pt_ROAcqInfo->sTimeStamp,
 644                    strlen((char *)pt_ROAcqInfo->sTimeStamp) + 1);
 645
 646         //Free
 647         TADC_MEMFree_RO(&t_RO);
 648         DrmTdcDHInfoFree(idx);
 649
 650         return TADC_SUCCESS;
 651 }
 652
 653 void DrmTdcDHInfoInit(void)
 654 {
 655         memset(&g_DrmTdcDHInfo, 0x00, sizeof(DrmTdcDHInfo));
 656 }
 657
 658 bool DrmTdcDHInfoFree(int idx)
 659 {
 660         memset(&g_DrmTdcDHInfo.hashReqID[idx], 0x00,
 661                    sizeof(g_DrmTdcDHInfo.hashReqID[idx]));
 662
 663         if (TADC_MEMFree_ROAcqInfo(&g_DrmTdcDHInfo.t_ROAcqInfo[idx]) < 0)
 664                 return FALSE;
 665
 666         return TRUE;
 667 }