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