tadcore/TADCCore/TADC_Core.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    TADC_Core.cpp
  19  * @brief   This file includes implementations of the Tizen Apps DRM Core APIs.
  20 */
  21
  22 #include "drm-tizen-error.h"
  23 #include "TADC_Util.h"
  24 #include "TADC_Sub.h"
  25 #include "TADC_IF.h"
  26 #include "TADC_ErrorCode.h"
  27
  28 static BYTE g_baSignatureKey[32] = {
  29         0x29, 0x2b, 0xf2, 0x29, 0x1f, 0x8b, 0x47, 0x81, 0x95, 0x0a, 0x84, 0xf8, 0x91, 0xda, 0x07, 0xd0,
  30         0x9c, 0xde, 0x32, 0x3e, 0x9e, 0x46, 0x4a, 0xfc, 0xa4, 0xcc, 0x55, 0x6e, 0xf2, 0x81, 0x61, 0xdb
  31 };
  32
  33 static BYTE g_baAESKey[32] = {
  34         0xf8, 0x87, 0x0a, 0xc5, 0xd3, 0x6d, 0x44, 0x49, 0x03, 0x9f, 0xbd, 0x1e, 0xa8, 0x2f, 0xf6, 0xc3,
  35         0xdf, 0x3b, 0x02, 0x13, 0x58, 0x1b, 0x12, 0x30, 0x1c, 0xd7, 0xad, 0xa5, 0x1f, 0x5d, 0x01, 0x33
  36 };
  37
  38 //Error Code
  39 static DWORD g_TADCErrorCode = 0;
  40
  41 int TADC_SetDeviceInfo(T_DEVICE_INFO *t_DeviceInfo)
  42 {
  43         int nResult = 0;
  44
  45         TADC_IF_MemSet(t_DeviceInfo, 0, sizeof(T_DEVICE_INFO));
  46
  47 // Mandatory value
  48         nResult = TADC_IF_GetDUID((CHAR*)t_DeviceInfo->DUID);
  49         IF_ERROR_RETURN(nResult, TADC_GETDUID_ERROR);
  50
  51         return nResult;
  52 }
  53
  54 int TADC_MakeRequestLicense(T_DEVICE_INFO *t_DeviceInfo,
  55                                                         T_FILE_HEADER *t_FileHeader,
  56                                                         T_DRM_HEADER *t_DRMHeader,
  57                                                         unsigned char * outBuffer,
  58                                                         size_t outBufferSize)
  59 {
  60         int nResult = 0;
  61         size_t length = 0;
  62
  63         //Param Check
  64         IF_TRUE_RETURN(outBuffer == NULL, TADC_PARAMETER_ERROR);
  65
  66         snprintf(
  67                 (char*)outBuffer,
  68                 outBufferSize,
  69                 "<?xml version='1.0'?>\n<request>\n<DeviceInfo>\n<duid>%s</duid>\n</DeviceInfo>\n",
  70                         t_DeviceInfo->DUID);
  71         length = TADC_IF_StrLen((char*)outBuffer);
  72         IF_TRUE_RETURN(length <= 0, TADC_XMLPARSER_ERROR);
  73
  74         //Null Check
  75         IF_TRUE_RETURN(t_DRMHeader->SID == NULL, TADC_SID_NULL_ERROR);
  76         IF_TRUE_RETURN(t_DRMHeader->CID == NULL, TADC_CID_NULL_ERROR);
  77
  78         snprintf(
  79                 (char*)outBuffer + length,
  80                 outBufferSize - length,
  81                 "<ContentInfo>\n<DRMType>%d</DRMType>\n<sid>%s</sid>\n<cid>%s</cid>\n</ContentInfo>\n</request>",
  82                         t_FileHeader->DRMType,
  83                         t_DRMHeader->SID,
  84                         t_DRMHeader->CID);
  85         length = TADC_IF_StrLen((char*)outBuffer);
  86         IF_TRUE_RETURN(length <= 0, TADC_XMLPARSER_ERROR);
  87
  88         DRM_TAPPS_LOG("TADC_MakeRequestLicense Success!\n");
  89
  90         return nResult;
  91 }
  92
  93 int TADC_GetROAcqInfo(unsigned char * inBuffer, T_ROACQ_INFO *t_ROAcqInfo)
  94 {
  95         int nResult = -1;
  96         int i = 0, j = 0;
  97         int nSize = 0;
  98         int length = 0;
  99
 100         //Check Param buffer
 101         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
 102         nSize = TADC_IF_StrLen((char*) inBuffer);
 103         IF_TRUE_RETURN( nSize<=40 || nSize>RESP_MAXSIZE, TADC_PARAMETER_ERROR);
 104
 105         //Check XML Result Code ( Success result='0' )
 106         nResult = -1;
 107         for (i = 0 ; i < nSize ; i++)
 108         {
 109                 if (!TADC_IF_MemCmp((char*)(inBuffer+i), "<response result=", 17))
 110                 {
 111                         i += 17;
 112                         if ((!memcmp((char*)(inBuffer+i), "'0'", 3)) || (!memcmp((char*)(inBuffer+i), "\"0\"", 3)))
 113                         {
 114                                 nResult = 0;
 115                                 break;
 116                         }
 117                         else
 118                         {
 119                                 nResult = -1;
 120                         }
 121                 }
 122         }
 123         IF_TRUE_RETURN(((i == nSize) || (nResult < 0)), TADC_RESPONSEMESSAGE_ERROR);
 124
 125
 126         //Init
 127         TADC_IF_MemSet(t_ROAcqInfo, 0, sizeof(T_ROACQ_INFO));
 128
 129         //Get RIURL
 130         length = 0;
 131
 132         for (i = 0 ; i < nSize ; i++)
 133         {
 134                 if (!TADC_IF_MemCmp((char*)(inBuffer + i), "<riurl>", 7))
 135                 {
 136                         i += 7;
 137                         for (j = i ; j < nSize ; j++)
 138                         {
 139                                 if (!TADC_IF_MemCmp((char*)(inBuffer + j), "</riurl>", 8))
 140                                 {
 141                                         length = j - i;
 142                                         IF_TRUE_RETURN(length <= 0, TADC_PARAMETER_ERROR);
 143                                         t_ROAcqInfo->ROAcqURL = (TADC_U8*)TADC_IF_Malloc(length + 1);
 144                                         IF_TRUE_RETURN(t_ROAcqInfo->ROAcqURL == NULL, TADC_MEMAlOC_ERROR);
 145                                         TADC_IF_MemSet(t_ROAcqInfo->ROAcqURL, 0, length + 1);
 146                                         TADC_IF_MemCpy(t_ROAcqInfo->ROAcqURL, inBuffer + i, length);
 147                                         break;
 148                                 }
 149                         }
 150                         break;
 151                 }
 152         }
 153         IF_TRUE_RETURN(length <= 0, TADC_RESPONSEMESSAGE_ERROR);
 154
 155         //Get ReqID
 156         length = 0;
 157
 158         for (i = 0 ; i < nSize ; i++)
 159         {
 160                 if (!TADC_IF_MemCmp((char*)(inBuffer + i), "<reqid>", 7))
 161                 {
 162                         i += 7;
 163                         for (j = i ; j < nSize ; j++)
 164                         {
 165                                 if (!TADC_IF_MemCmp((char*)(inBuffer + j), "</reqid>", 8))
 166                                 {
 167                                         length = j - i;
 168                                         IF_TRUE_RETURN(length <= 0, TADC_PARAMETER_ERROR);
 169                                         t_ROAcqInfo->ReqID = (TADC_U8*)TADC_IF_Malloc(length + 1);
 170                                         IF_TRUE_RETURN(t_ROAcqInfo->ReqID == NULL, TADC_MEMAlOC_ERROR);
 171                                         TADC_IF_MemSet(t_ROAcqInfo->ReqID, 0, length + 1);
 172                                         TADC_IF_MemCpy(t_ROAcqInfo->ReqID, inBuffer+i, length);
 173                                         break;
 174                                 }
 175                         }
 176                         break;
 177                 }
 178         }
 179         IF_TRUE_RETURN(length <= 0, TADC_RESPONSEMESSAGE_ERROR);
 180         DRM_TAPPS_LOG("TADC_GetROAcqInfo Success!\n");
 181
 182         return nResult;
 183 }
 184
 185 int TADC_MakeRequestRO(T_ROACQ_INFO *t_ROAcqInfo, unsigned char * outBuffer, size_t outBufferSize, unsigned char * ROVer)
 186 {
 187         BYTE sha1_tmp[20];
 188         TADC_U8* ReqTemp;
 189         LPSTR psz64Parameter = NULL;
 190
 191         TADC_U8 key[16];
 192         TADC_U8 iv[16];
 193
 194         int outlen = 0;
 195         int nResult = 0;
 196
 197         size_t StrSize = 0;
 198         size_t len = 0;
 199         size_t i = 0;
 200         long k = 0;
 201         size_t reqdataset_size = 0;
 202
 203         // Debug
 204         DRM_TAPPS_LOG("Debug Log == TADC_MakeRequestRO  : Start    \n");
 205
 206         //Check Param Buffer
 207         IF_TRUE_RETURN(outBuffer == NULL, TADC_PARAMETER_ERROR);
 208         IF_TRUE_RETURN(t_ROAcqInfo->ReqID == NULL, TADC_PARAMETER_ERROR);
 209
 210         // Debug
 211         DRM_TAPPS_LOG("Debug Log == TADC_MakeRequestRO  : After Check Param Buffer   \n");
 212         len = TADC_IF_StrLen((char*)t_ROAcqInfo->ReqID);
 213         IF_TRUE_RETURN( (len <= 0 || len > 512), TADC_PARAMETER_ERROR);
 214
 215         // Debug
 216         DRM_TAPPS_LOG("Debug Log == TADC_MakeRequestRO  : After Check t_ROAcqInfo->ReqID Len   \n");
 217         nResult = TADC_IF_GetDHKey(&t_ROAcqInfo->t_DHInfo);
 218         IF_ERROR_RETURN(nResult, TADC_GETDHKEY_ERROR);
 219
 220         // Debug
 221         DRM_TAPPS_LOG("Debug Log == TADC_MakeRequestRO  : After TADC_IF_GetDHKey  \n");
 222         IF_TRUE_RETURN(t_ROAcqInfo->t_DHInfo.pSize <= 0 || t_ROAcqInfo->t_DHInfo.pSize > DHKey_SIZE, TADC_PARAMETER_ERROR);
 223         IF_TRUE_RETURN(t_ROAcqInfo->t_DHInfo.ASize <= 0 || t_ROAcqInfo->t_DHInfo.ASize > DHKey_SIZE, TADC_PARAMETER_ERROR);
 224
 225         //If ROVer 2.0 then add <reqversion> element. 2011.03.08
 226         if (ROVer != NULL && ROVer[0] >= 2)
 227         {
 228                 snprintf(
 229                         (char*)outBuffer,
 230                         outBufferSize,
 231                         "<?xml version='1.0'?>\n<request>\n<reqversion>%d.%d</reqversion>\n<reqid>%s</reqid>\n<reqdataset>",
 232                                 ROVer[0],
 233                                 ROVer[1],
 234                                 t_ROAcqInfo->ReqID);
 235         }
 236         else
 237         {
 238                 snprintf(
 239                         (char*)outBuffer,
 240                         outBufferSize,
 241                         "<?xml version='1.0'?>\n<request>\n<reqid>%s</reqid>\n<reqdataset>",
 242                                 t_ROAcqInfo->ReqID);
 243         }
 244
 245         len = TADC_IF_StrLen((char*)outBuffer);
 246         i += len;
 247
 248         reqdataset_size = i;
 249
 250         TADC_IF_StrNCpy((char*)outBuffer+i, "p=", 2);
 251         i += 2;
 252
 253         for (k = 0 ; k < t_ROAcqInfo->t_DHInfo.pSize ; k++)
 254         {
 255                 snprintf(
 256                         (char*)outBuffer + i + (k * 2),
 257                         outBufferSize - i - (k * 2),
 258                         "%02X",
 259                                 t_ROAcqInfo->t_DHInfo.p[k]);
 260         }
 261         i += (k * 2);
 262
 263         snprintf(
 264                 (char*)outBuffer + i,
 265                 outBufferSize - i,
 266                 ";g=%ld",
 267                         t_ROAcqInfo->t_DHInfo.g);
 268         i += 4;
 269
 270         TADC_IF_StrNCpy((char*)outBuffer + i, ";A=", 3);
 271         i += 3;
 272
 273         for (k = 0 ; k < t_ROAcqInfo->t_DHInfo.ASize ; k++)
 274         {
 275                 snprintf(
 276                         (char*)outBuffer + i + (k * 2),
 277                         outBufferSize - i - (k * 2),
 278                         "%02X",
 279                                 t_ROAcqInfo->t_DHInfo.A[k]);
 280         }
 281         i += (k * 2);
 282
 283         outBuffer[i] = 0;
 284
 285         StrSize = i - reqdataset_size;
 286
 287         //MemAlloc
 288         ReqTemp = (TADC_U8*)TADC_IF_Malloc(StrSize);
 289         IF_TRUE_RETURN(ReqTemp == NULL, TADC_MEMAlOC_ERROR);
 290
 291         TADC_IF_MemSet(ReqTemp, 0, StrSize);
 292         TADC_IF_MemCpy(ReqTemp, outBuffer+reqdataset_size, StrSize);
 293         TADC_IF_SHA1(ReqTemp, StrSize, sha1_tmp);
 294
 295         TADC_IF_MemCpy(key, &g_baAESKey[0], 16);
 296         TADC_IF_MemCpy(iv, &g_baAESKey[16], 16);
 297         TADC_IF_AES_CTR(key, 16, iv, 20, (unsigned char*)sha1_tmp, &outlen, (unsigned char*)sha1_tmp);
 298
 299         // Debug
 300         DRM_TAPPS_LOG("Debug Log == TADC_MakeRequestRO  : After TADC_IF_AES_CTR  \n");
 301
 302         psz64Parameter = Base64Encode(sha1_tmp, sizeof(sha1_tmp));      //MemAlloc
 303         if (psz64Parameter == NULL)
 304         {
 305                 TADC_IF_Free(ReqTemp);
 306                 return TADC_MEMAlOC_ERROR;
 307         }
 308
 309         // Debug
 310         DRM_TAPPS_LOG("Debug Log == TADC_MakeRequestRO  : After Base64Encode  \n");
 311
 312         TADC_IF_StrNCpy((char*)(outBuffer + i), ";hmac=", 6);
 313         len = TADC_IF_StrLen((char*)psz64Parameter);
 314         TADC_IF_MemCpy(outBuffer + i + 6, psz64Parameter, len);
 315         TADC_IF_StrNCpy((char*)outBuffer + i + 6 + len, "</reqdataset>\n</request>", 24);
 316
 317         //MemFree
 318         if (ReqTemp != NULL)
 319         {
 320                 TADC_IF_Free(ReqTemp);
 321                 ReqTemp = NULL;
 322         }
 323         if (psz64Parameter != NULL)
 324         {
 325                 TADC_IF_Free(psz64Parameter);
 326                 psz64Parameter = NULL;
 327         }
 328
 329         len = TADC_IF_StrLen((char*)outBuffer);
 330         IF_TRUE_RETURN(len <= 0, TADC_REQMAKEHMAC_ERROR);
 331
 332         DRM_TAPPS_LOG("TADC_MakeRequestRO Success!\n");
 333
 334         return len;
 335 }
 336
 337 int TADC_GetHashReqID(unsigned char * inBuffer, unsigned char *hashReqID)
 338 {
 339         //Check Param Buffer
 340         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
 341         IF_TRUE_RETURN(hashReqID == NULL, TADC_PARAMETER_ERROR);
 342         int nSize = TADC_IF_StrLen((char*)inBuffer);
 343         IF_TRUE_RETURN(nSize <= 40 || nSize>RESP_MAXSIZE, TADC_PARAMETER_ERROR);
 344
 345         //Check XML Result Code ( Success result='0' )
 346         int nResult = -1;
 347         int i = 0;
 348
 349         for (i = 0 ; i < nSize ; i++)
 350         {
 351                 if (!TADC_IF_MemCmp((char*)(inBuffer + i), "<response result=", 17))
 352                 {
 353                         i += 17;
 354                         if ((!memcmp((char*)(inBuffer + i), "'0'", 3)) || (!memcmp((char*)(inBuffer + i), "\"0\"", 3)))
 355                         {
 356                                 nResult = 0;
 357                                 break;
 358                         }
 359                         else
 360                         {
 361                                 nResult = -1;
 362                         }
 363                 }
 364         }
 365         IF_TRUE_RETURN(((i == nSize) || (nResult < 0)), TADC_RESPONSEMESSAGE_ERROR);
 366
 367         //Get reqid
 368         int length = 0;
 369         char tmpbuf[512] = {0, };
 370
 371         for (i = 0 ; i < nSize ; i++)
 372         {
 373                 if (!TADC_IF_MemCmp(inBuffer + i, "reqid=", 6))
 374                 {
 375                         i += 6;
 376                         length = 40;
 377                         IF_TRUE_RETURN(i + length > nSize || inBuffer[i + length] != ';',
 378                                         TADC_RESPONSEMESSAGE_ERROR);
 379
 380                         TADC_IF_StrNCpy(tmpbuf, (char*)(inBuffer + i), length);
 381                         tmpbuf[length] = '\0';
 382
 383                         break;
 384                 }
 385         }
 386
 387         // reqid not found
 388         IF_TRUE_RETURN(length == 0, TADC_RESPONSEMESSAGE_ERROR);
 389
 390         if ((nResult = HEX2BIN((char*)tmpbuf, hashReqID, &length)) < 0)
 391         {
 392                 return -1;
 393         }
 394
 395         if (length != 20)
 396         {
 397                 return -1;
 398         }
 399
 400         return 0;
 401 }
 402
 403 int TADC_GetResponseRO(unsigned char * inBuffer, T_ROACQ_INFO *t_ROAcqInfo, T_RO *t_RO, unsigned char *outBuffer)
 404 {
 405         int nHMacSize = 28; // Base64 Enc length of SHA1 20byte
 406         TADC_U8 sha1_tmp[20] = {0, };
 407         char hmacBuf[512] = {0, };
 408         BYTE *ReqTemp = NULL;
 409         LPBYTE pbBuffer = NULL;
 410
 411         TADC_U8 key[16] = {0, };
 412         TADC_U8 iv[16] = {0, };
 413
 414         int outlen = 0;
 415
 416         char *License = NULL;
 417         TCHAR tmpDH_B[DHKey_SIZE * 2 + 1] = {0, };
 418
 419         // RO XML Parser
 420         CXMLFile XMLParser;
 421         CPointerArray paChilds;
 422
 423         //2011.03.08
 424         char *timeStamp = NULL;
 425         int retLen = 0;
 426         int i = 0, j = 0;
 427         int nSize = 0;
 428         int length = 0;
 429         int req_length = 0;
 430         int nResult = 0;
 431
 432         char pRoHeader[36] = {'<', '?', 'x', 'm', 'l', ' ', 'v', 'e', 'r', 's', 'i', 'o', 'n', '=', '"', '1', '.', '0', '"', '?', '>', 0x0A,
 433                                                 '<', 'T', 'i', 'z', 'e', 'n', 'L', 'i', 'c', 'e', 'n', 's', 'e', '>'};
 434
 435         //Check Param Buffer
 436         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
 437         IF_TRUE_RETURN(t_ROAcqInfo== NULL, TADC_PARAMETER_ERROR);
 438         IF_TRUE_RETURN(t_RO == NULL, TADC_PARAMETER_ERROR);
 439
 440         nSize = TADC_IF_StrLen((char*)inBuffer);
 441         IF_TRUE_RETURN( nSize <= 40 || nSize>RESP_MAXSIZE, TADC_PARAMETER_ERROR);
 442
 443         IF_TRUE_RETURN(t_ROAcqInfo->t_DHInfo.pSize<=0 || t_ROAcqInfo->t_DHInfo.pSize>DHKey_SIZE, TADC_PARAMETER_ERROR);
 444         IF_TRUE_RETURN(t_ROAcqInfo->t_DHInfo.ASize<=0 || t_ROAcqInfo->t_DHInfo.ASize>DHKey_SIZE, TADC_PARAMETER_ERROR);
 445
 446         //Check XML Result Code ( Success result='0' )
 447         nResult = -1;
 448         for (i = 0 ; i < nSize ; i++)
 449         {
 450                 if (!TADC_IF_MemCmp((char*)(inBuffer + i), "<response result=", 17))
 451                 {
 452                         i += 17;
 453                         if ((!memcmp((char*)(inBuffer + i), "'0'", 3)) || (!memcmp((char*)(inBuffer + i), "\"0\"", 3)))
 454                         {
 455                                 nResult = 0;
 456                                 break;
 457                         }
 458                         else
 459                         {
 460                                 nResult = -1;
 461                         }
 462                 }
 463         }
 464         IF_TRUE_RETURN(((i == nSize) || (nResult < 0)), TADC_RESPONSEMESSAGE_ERROR);
 465
 466         //Init
 467         TADC_IF_MemSet(t_RO, 0, sizeof(T_RO));
 468         TADC_IF_MemSet(tmpDH_B, 0, sizeof(tmpDH_B));
 469         TADC_IF_MemSet(sha1_tmp, 0, sizeof(sha1_tmp));
 470         TADC_IF_MemSet(hmacBuf, 0, sizeof(hmacBuf));
 471
 472         //Check HMAC
 473         req_length = 0;
 474
 475         for (i = 0 ; i < nSize ; i++)
 476         {
 477                 if (!TADC_IF_MemCmp((char*)(inBuffer + i), "<responsedata>", 14))
 478                 {
 479                         i += 14;
 480                         for (j = i ; j < nSize ; j++)
 481                         {
 482                                 if (!TADC_IF_MemCmp((char*)(inBuffer+j), ";hmac=", 6))
 483                                 {
 484                                         req_length = j-i;
 485                                         IF_TRUE_RETURN(req_length <= 0 || req_length >= RESP_MAXSIZE, TADC_PARAMETER_ERROR);
 486
 487                                         ReqTemp = (TADC_U8*)TADC_IF_Malloc(req_length);
 488                                         IF_TRUE_RETURN(ReqTemp == NULL, TADC_MEMAlOC_ERROR);
 489
 490                                         TADC_IF_MemSet(ReqTemp, 0, req_length);
 491                                         TADC_IF_MemCpy(ReqTemp, inBuffer+i, req_length);
 492
 493                                         i += req_length;
 494
 495                                         TADC_IF_StrNCpy(hmacBuf, (char*)(inBuffer + i + 6), nHMacSize);
 496                                         break;
 497                                 }
 498                         }
 499                         break;
 500                 }
 501         }
 502         IF_TRUE_RETURN(req_length <= 0, TADC_RESPONSEMESSAGE_ERROR);
 503
 504         pbBuffer = Base64Decode( (LPCSTR)hmacBuf, &length );
 505         if (pbBuffer == NULL)
 506         {
 507                 TADC_IF_Free(ReqTemp);
 508                 ReqTemp = NULL;
 509                 return -1;
 510         }
 511
 512         TADC_IF_MemCpy(key, &g_baAESKey[0], 16 );
 513         TADC_IF_MemCpy(iv, &g_baAESKey[16], 16 );
 514         TADC_IF_AES_CTR(key, 16, iv, 20, (unsigned char*)pbBuffer, &outlen, (unsigned char*)pbBuffer);
 515
 516         TADC_IF_SHA1(ReqTemp, req_length, sha1_tmp);
 517         if (ReqTemp != NULL)
 518         {
 519                 TADC_IF_Free(ReqTemp);
 520                 ReqTemp = NULL;
 521         }
 522
 523         if (TADC_IF_MemCmp(sha1_tmp, pbBuffer, sizeof(sha1_tmp)))
 524         {
 525                 TADC_IF_Free(pbBuffer);
 526                 pbBuffer = NULL;
 527                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_RESPONSESIGNATURE_ERROR);
 528                 return TADC_RESPONSESIGNATURE_ERROR;
 529         }
 530
 531         TADC_IF_Free(pbBuffer);
 532         pbBuffer = NULL;
 533
 534         req_length = 0;
 535
 536         for (i = 0 ; i < nSize ; i++)
 537         {
 538                 if (!TADC_IF_MemCmp(inBuffer + i, "B=", 2))
 539                 {
 540                         i += 2;
 541                         for (j = i ; j < nSize ; j++)
 542                         {
 543                                 if (!TADC_IF_MemCmp(inBuffer + j, ";", 1))
 544                                 {
 545                                         req_length = j - i;
 546                                         IF_TRUE_RETURN(req_length <= 0 || req_length >= (int)sizeof(tmpDH_B), TADC_PARAMETER_ERROR);
 547                                         TADC_IF_StrNCpy((char*)tmpDH_B, (char*)(inBuffer + i), req_length);
 548                                         tmpDH_B[req_length] = 0;
 549                                         break;
 550                                 }
 551                         }
 552                         break;
 553                 }
 554         }
 555         IF_TRUE_RETURN(req_length <= 0, TADC_RESPONSEMESSAGE_ERROR);
 556
 557         TADC_IF_MemSet(t_ROAcqInfo->t_DHInfo.B, 0, sizeof(t_ROAcqInfo->t_DHInfo.B));
 558         TADC_IF_MemCpy(t_ROAcqInfo->t_DHInfo.B, tmpDH_B, sizeof(t_ROAcqInfo->t_DHInfo.B));
 559
 560         if (HEX2BIN((char*)tmpDH_B, t_ROAcqInfo->t_DHInfo.B, (int*)&t_ROAcqInfo->t_DHInfo.BSize) < 0)
 561         {
 562                 return TADC_GETDHKEY_ERROR;
 563         }
 564
 565         if(t_ROAcqInfo->t_DHInfo.BSize != 16 && t_ROAcqInfo->t_DHInfo.BSize != 64)
 566         {
 567                 return TADC_GETDHKEY_ERROR;
 568         }
 569
 570         TADC_IF_MemSet(t_ROAcqInfo->t_DHInfo.K, 0, sizeof(t_ROAcqInfo->t_DHInfo.K));
 571
 572         nResult = TADC_IF_GetDHKey_K(&t_ROAcqInfo->t_DHInfo);
 573         IF_ERROR_RETURN(nResult, TADC_GETDHKEY_ERROR);
 574
 575         req_length = 0;
 576
 577         for (i = 0 ; i < nSize ; i++)
 578         {
 579                 if (!TADC_IF_MemCmp((char*)(inBuffer + i), "license=", 8))
 580                 {
 581                         i += 8;
 582                         for (j = i ; j < nSize ; j++)
 583                         {
 584                                 if (!TADC_IF_MemCmp((char*)(inBuffer + j), ";hmac=", 6))
 585                                 {
 586                                         req_length = j - i;
 587                                         IF_TRUE_RETURN(req_length <= 0 || req_length >= RESP_MAXSIZE, TADC_PARAMETER_ERROR);
 588
 589                                         License = (char*)TADC_IF_Malloc(req_length + 1);
 590                                         IF_TRUE_RETURN(License == NULL, TADC_MEMAlOC_ERROR);
 591
 592                                         TADC_IF_MemSet(License, 0, req_length + 1);
 593                                         TADC_IF_StrNCpy(License, (char*)(inBuffer + i), req_length);
 594                                         break;
 595                                 }
 596                         }
 597                         break;
 598                 }
 599         }
 600         IF_TRUE_RETURN(req_length <= 0, TADC_RESPONSEMESSAGE_ERROR);
 601
 602         // Get RO License Info
 603         pbBuffer = Base64Decode((LPCSTR)License, &length);
 604         if(!pbBuffer)
 605         {
 606                 TADC_IF_Free(License);
 607                 License = NULL;
 608                 return -1;
 609         }
 610
 611         pbBuffer[length] = 0;
 612         TADC_IF_Free(License);
 613         License = NULL;
 614
 615         // Decrypt License
 616         TADC_IF_MemCpy(key, &t_ROAcqInfo->t_DHInfo.K[0], 16);
 617         TADC_IF_MemCpy(iv, &t_ROAcqInfo->t_DHInfo.K[16], 16);
 618         TADC_IF_AES_CTR(key, 16, iv, length, (unsigned char*)pbBuffer, &outlen, (unsigned char*)pbBuffer);
 619
 620         // Test Code for get the plaintext ro
 621         /*
 622         strcat(tmpPath, (char*)t_RO->t_Content.CID);
 623         strcat(tmpPath, ".ro");
 624         fd = fopen(tmpPath, "w+b");
 625         */
 626 #if 0
 627         DRM_TAPPS_LOG("fopen started.");
 628         fd = fopen("/tmp/1.ro", "w+b");
 629         if (fd == NULL)
 630         {
 631                 DRM_TAPPS_EXCEPTION("fopen() failed.");
 632                 return -1;
 633         }
 634         DRM_TAPPS_LOG("fopen done.");
 635         fwrite(pbBuffer, 1, strlen((char*)pbBuffer), fd);
 636         DRM_TAPPS_LOG("fwrite done.");
 637         fclose(fd);
 638         DRM_TAPPS_LOG("fclose done.");
 639         DRM_TAPPS_LOG("Save decrypted RO success!, path = %s", tmpPath);
 640 #endif
 641         // Test Code Done!
 642
 643         if(TADC_IF_MemCmp((char*)pbBuffer, pRoHeader, 36))
 644         {
 645                 TADC_IF_Free(pbBuffer);
 646                 pbBuffer = NULL;
 647                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_LICENSEXMLPARSING_ERROR);
 648                 return TADC_LICENSEXMLPARSING_ERROR;
 649         }
 650         TADC_IF_MemCpy(outBuffer, pbBuffer, length);
 651         TADC_IF_Free(pbBuffer);
 652         pbBuffer = NULL;
 653
 654         /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 655         // 2011.03.08
 656         // Get timeStamp
 657         /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 658         retLen = length;
 659         // <timeStamp>
 660         req_length = 0;
 661
 662         DRM_TAPPS_LOG("timeStamp parsing start");
 663
 664         i = FindString(inBuffer, nSize, (unsigned char *)"<timeStamp>", 11);
 665         if (i < 0) {
 666                 DRM_TAPPS_LOG("No timeStamp. TADC_GetResponseRO Success!");
 667                 return retLen;
 668         }
 669
 670         i += 11;
 671         j = FindString(inBuffer, nSize, (unsigned char *)"</timeStamp>", 12);
 672         IF_TRUE_RETURN(j < i, TADC_LICENSEXMLPARSING_ERROR);
 673         req_length = j - i;
 674         IF_TRUE_RETURN(req_length > ROXML_MAXSIZE, TADC_PARAMETER_ERROR);
 675
 676         if (req_length <= 0)
 677                 return retLen;
 678
 679         timeStamp =  (char*)TADC_IF_Malloc(req_length + 1);
 680         IF_TRUE_RETURN(timeStamp == NULL, TADC_MEMAlOC_ERROR);
 681
 682         TADC_IF_MemSet(timeStamp, 0, req_length + 1);
 683         TADC_IF_StrNCpy(timeStamp, (char*)(inBuffer + i), req_length);
 684
 685         DRM_TAPPS_LOG("timeStamp parsing end.. req_length[%d]", req_length);
 686
 687         // Get RO License Info
 688         pbBuffer = Base64Decode((LPCSTR)timeStamp, &length);
 689         if (!pbBuffer)
 690         {
 691                 TADC_IF_Free(timeStamp);
 692                 timeStamp = NULL;
 693                 DRM_TAPPS_EXCEPTION("Base64Decode Failed");
 694                 return -1;
 695         }
 696
 697         pbBuffer[length] = 0;
 698         TADC_IF_Free(timeStamp);
 699         timeStamp = NULL;
 700
 701         DRM_TAPPS_LOG("Decrypt timeStamp starts");
 702
 703         // Decrypt timeStamp
 704         TADC_IF_MemCpy(key, &t_ROAcqInfo->t_DHInfo.K[0], 16);
 705         TADC_IF_MemCpy(iv, &t_ROAcqInfo->t_DHInfo.K[16], 16);
 706         TADC_IF_AES_CTR(key, 16, iv, length, (unsigned char*)pbBuffer, &outlen, (unsigned char*)pbBuffer);
 707
 708         if (length >= (int)sizeof(t_ROAcqInfo->sTimeStamp))
 709         {
 710                 TADC_IF_Free(pbBuffer);
 711                 pbBuffer = NULL;
 712                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_RESPONSEMESSAGE_ERROR);
 713                 return TADC_RESPONSEMESSAGE_ERROR;
 714         }
 715
 716         TADC_IF_MemCpy(t_ROAcqInfo->sTimeStamp, pbBuffer, length);
 717         t_ROAcqInfo->sTimeStamp[length] = 0;
 718
 719         TADC_IF_Free(pbBuffer);
 720         pbBuffer = NULL;
 721
 722         DRM_TAPPS_LOG("timeStamp found. TADC_GetResponseRO Success!");
 723         return retLen;
 724 }
 725
 726 int TADC_VerifyROSignature(IN LPBYTE pszXML)
 727 {
 728         int nResult = 0;
 729         int length = 0, i = 0, i2 = 0;
 730
 731         unsigned char* pSigData = NULL;
 732         unsigned char* pRICert = NULL;
 733         unsigned char* pRICACert = NULL;
 734
 735         int inLen = 0, sigLen = 0, certLen = 0, certLen2 = 0;
 736
 737         unsigned char* p;
 738         char TempBuf[CERT_MAXSIZE] = {0, };
 739
 740         //Check Param Buffer
 741         IF_TRUE_RETURN(pszXML == NULL, TADC_PARAMETER_ERROR);
 742
 743         //Check Version
 744         i = FindString(pszXML, TADC_IF_StrLen((char*)pszXML), (LPBYTE)"<version>2.0</version>", 22);
 745         if (i < 0)
 746         {
 747                 DRM_TAPPS_EXCEPTION("TADC_IF_VerifyROSignature Debug : It is not the TAD-RO2.0 format. \n");
 748                 return 0;
 749         }
 750
 751         DRM_TAPPS_LOG("TADC_IF_VerifyROSignature Debug : It is the TAD-RO2.0 format.\n");
 752
 753         //Get Certificates ( RI Cert )
 754         TADC_IF_MemSet(TempBuf, 0x00, CERT_MAXSIZE);
 755
 756         i = FindString(pszXML, TADC_IF_StrLen((char*)pszXML), (LPBYTE)"<CertificateChain>", 18);
 757         IF_TRUE_RETURN(i < 0, TADC_RO_CERTIFICATE_ERROR);
 758
 759         p = pszXML + i; // <certificateChain>
 760         length = TADC_IF_StrLen((char*)pszXML) - i;
 761
 762         i = FindString(p, length, (LPBYTE)"<Certificate>", 13);
 763         IF_TRUE_RETURN(i < 0, TADC_RO_CERTIFICATE_ERROR);
 764         i += 13; // start position of RI Cert
 765
 766         i2 = FindString(p, length, (LPBYTE)"</Certificate>", 14);
 767         IF_TRUE_RETURN(i2 < (i + 13), TADC_RO_CERTIFICATE_ERROR);
 768         certLen = i2 - i; // size of RI Cert
 769
 770         TADC_IF_StrNCpy(TempBuf, (char*)p+i, certLen);
 771
 772         pRICert = Base64Decode( (LPCSTR)TempBuf, &certLen );
 773         IF_TRUE_RETURN(pRICert == NULL, TADC_RO_CERTIFICATE_ERROR);
 774         TADC_IF_MemSet(TempBuf, 0x00, CERT_MAXSIZE);
 775
 776         //Get Certificates ( RICA Cert )
 777         p = p + (i2 + 14); // first </certificate>
 778         length = length - (i2 + 14);
 779
 780         i = FindString(p, length, (LPBYTE)"<Certificate>", 13);
 781         IF_TRUE_RETURN2(i < 0, TADC_IF_Free(pRICert),,,TADC_RO_CERTIFICATE_ERROR);
 782         i += 13; // start position of RICA Cert
 783
 784         i2 = FindString(p, length, (LPBYTE)"</Certificate>", 14);
 785         IF_TRUE_RETURN2(i2 < (i + 13), TADC_IF_Free(pRICert),,,TADC_RO_CERTIFICATE_ERROR);
 786         certLen2 = i2 - i; // size of RICA Cert
 787
 788         TADC_IF_StrNCpy(TempBuf, (char*)p + i, certLen2);
 789
 790         pRICACert = Base64Decode((LPCSTR)TempBuf, &certLen2);
 791         IF_TRUE_RETURN2(pRICACert == NULL, TADC_IF_Free(pRICert),,,TADC_RO_CERTIFICATE_ERROR);
 792         TADC_IF_MemSet(TempBuf, 0x00, CERT_MAXSIZE);
 793
 794         //Get position of indata
 795         inLen = FindString(pszXML, TADC_IF_StrLen((char*)pszXML), (LPBYTE)"</CertificateChain>", 19);
 796         IF_TRUE_RETURN2(inLen < 0, TADC_IF_Free(pRICert),TADC_IF_Free(pRICACert),,TADC_RO_CERTIFICATE_ERROR);
 797         inLen += 19;
 798
 799         //Get signature value </certificateChain>
 800         p = pszXML + inLen;
 801         length = TADC_IF_StrLen((char*)pszXML)-inLen;
 802
 803         i = FindString(p, length, (LPBYTE)"<SignatureValue>", 16);
 804         IF_TRUE_RETURN2(i < 0, TADC_IF_Free(pRICert),TADC_IF_Free(pRICACert),,TADC_RO_SIGNATURE_ERROR);
 805         i += 16; // start position of signature value
 806
 807         i2 = FindString(p, length, (LPBYTE)"</SignatureValue>", 17);
 808         IF_TRUE_RETURN2(i2 < (i + 16), TADC_IF_Free(pRICert),TADC_IF_Free(pRICACert),,TADC_RO_SIGNATURE_ERROR);
 809         sigLen = i2 - i; // size of signature value
 810
 811         TADC_IF_StrNCpy(TempBuf, (char*)p + i, sigLen);
 812
 813         pSigData = Base64Decode( (LPCSTR)TempBuf, &sigLen );
 814         IF_TRUE_RETURN2(pSigData == NULL, TADC_IF_Free(pRICert),TADC_IF_Free(pRICACert),,TADC_RO_SIGNATURE_ERROR);
 815         TADC_IF_MemSet(TempBuf, 0x00, CERT_MAXSIZE);
 816
 817         //Verify the certificate chain
 818         nResult = TADC_IF_VerifyCertChain(pRICACert, certLen2, pRICert, certLen);
 819         if (nResult == 0)
 820         {
 821                 nResult = TADC_IF_VerifySignature(pszXML, inLen, pSigData, sigLen, pRICert, certLen);
 822         }
 823
 824         TADC_IF_Free(pRICert);
 825         TADC_IF_Free(pRICACert);
 826         TADC_IF_Free(pSigData);
 827
 828         return nResult;
 829 }
 830
 831 int TADC_GetResponseROInfo(IN LPBYTE pszXML,  T_RO *t_RO)
 832 {
 833         int nResult = 0;
 834         CXMLFile oXMLFile;
 835         CXMLElement* pRoot, *pElement;
 836         CPointerArray paChilds;
 837         LPCTSTR pszValue;
 838         LPBYTE pbBuffer = NULL;
 839         int length = 0;
 840         TADC_U8 TempVersion[3] = {0, };
 841
 842         char pRoHeader[36] = {'<', '?', 'x', 'm', 'l', ' ', 'v', 'e', 'r', 's', 'i', 'o', 'n', '=', '"', '1', '.', '0', '"', '?', '>', 0x0A,
 843                                                 '<', 'T', 'i', 'z', 'e', 'n', 'L', 'i', 'c', 'e', 'n', 's', 'e', '>'};
 844
 845         //Check Param Buffer
 846         IF_TRUE_RETURN(pszXML == NULL, TADC_PARAMETER_ERROR);
 847         IF_TRUE_RETURN(t_RO == NULL, TADC_PARAMETER_ERROR);
 848
 849         //Init
 850         TADC_IF_MemSet(t_RO, 0, sizeof(T_RO));
 851         TADC_IF_MemSet(TempVersion, 0, sizeof(TempVersion));
 852
 853         if (TADC_IF_MemCmp((char*)pszXML, pRoHeader, 36))
 854         {
 855                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_XMLPARSER_ERROR);
 856                 return -1;
 857         }
 858
 859         // Verify the signature ( 2011.03.08, Joseph Ahn )
 860         nResult = TADC_VerifyROSignature(pszXML);
 861         if (nResult != 0)
 862         {
 863                 DRM_TAPPS_EXCEPTION("TADC_VerifyROSignature Error Code = %x", nResult);
 864                 return -1;
 865         }
 866
 867         nResult = oXMLFile.LoadFromStream((LPCTSTR)pszXML);
 868         if (nResult < 0)
 869         {
 870                 DRM_TAPPS_EXCEPTION("oXMLFile.LoadFromStream is failed\n");
 871                 nResult = -1;
 872                 goto finish;
 873         }
 874
 875         // Set Version
 876         pRoot = oXMLFile.GetRoot();
 877         if (pRoot == NULL)
 878         {
 879                 DRM_TAPPS_EXCEPTION("oXMLFile.GetRoot is failed\n");
 880                 nResult = -1;
 881                 goto finish;
 882         }
 883
 884         paChilds.RemoveAll();
 885         nResult = pRoot->Find( &paChilds, _T("ContentInfo"), _T("cid"), NULL);
 886         if (nResult != 0)
 887         {
 888                 DRM_TAPPS_EXCEPTION("pRoot->Find is failed\n");
 889                 nResult = -1;
 890                 goto finish;
 891         }
 892
 893         if (paChilds.GetCount() != 1)
 894         {
 895                 DRM_TAPPS_EXCEPTION("paChilds.GetCount() is failed\n");
 896                 nResult = -1;
 897                 goto finish;
 898         }
 899
 900         pElement = (CXMLElement*)paChilds.Get(0);
 901         pszValue = pElement->GetValue();
 902         if (pszValue == NULL)
 903         {
 904                 DRM_TAPPS_EXCEPTION("pElement->GetValue() is failed\n");
 905                 nResult = -1;
 906                 goto finish;
 907         }
 908
 909         length = TADC_IF_StrLen((char*)pszValue);
 910         if (length <= 0 || length > CID_SIZE)
 911         {
 912                 DRM_TAPPS_EXCEPTION("TADC_IF_StrLen is failed(%d) -  %s\n", length, pszValue);
 913                 nResult = -1;
 914                 goto finish;
 915         }
 916
 917         t_RO->t_Content.CID = (TADC_U8*)TADC_IF_Malloc(length + 1); //2011.03.08 ( CID_SIZE -> length )
 918         IF_TRUE_GOTO(t_RO->t_Content.CID == NULL, -2);
 919         TADC_IF_MemSet(t_RO->t_Content.CID, 0, length + 1); //2011.03.08 ( CID_SIZE -> length )
 920         TADC_IF_StrNCpy((CHAR*)t_RO->t_Content.CID, pszValue, length);
 921
 922         // Get KeyValue (CEK)
 923         pRoot = oXMLFile.GetRoot();
 924         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
 925
 926         paChilds.RemoveAll();
 927         nResult = pRoot->Find( &paChilds, _T("KeyInfo"), _T("CipherValue"), NULL);
 928
 929         IF_TRUE_GOTO(nResult != 0, ERROR_INVALID_DATA);
 930         IF_TRUE_GOTO(paChilds.GetCount() != 1, ERROR_INVALID_DATA);
 931
 932         pElement = (CXMLElement*)paChilds.Get(0);
 933         pszValue = pElement->GetValue();
 934         IF_TRUE_GOTO(pszValue == NULL, -2);
 935
 936         pbBuffer = Base64Decode(pszValue, &length);
 937         if (pbBuffer == NULL)
 938         {
 939                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_XMLPARSER_ERROR);
 940                 return -1;
 941         }
 942
 943         if (length <= 0 || length > CEK_SIZE)
 944         {
 945                 TADC_IF_Free(pbBuffer);
 946                 pbBuffer = NULL;
 947                 nResult = -1;
 948                 goto finish;
 949         }
 950
 951         t_RO->t_Content.CEK = (TADC_U8*)TADC_IF_Malloc(length + 1); //2011.03.08 ( CEK_SIZE -> length )
 952         IF_TRUE_GOTO(t_RO->t_Content.CEK == NULL, -2);
 953         TADC_IF_MemSet(t_RO->t_Content.CEK, 0, length + 1); //2011.03.08 ( CEK_SIZE -> length )
 954         TADC_IF_MemCpy(t_RO->t_Content.CEK, pbBuffer, length);
 955
 956         TADC_IF_Free(pbBuffer);
 957         pbBuffer = NULL;
 958
 959         // Get individual
 960         pRoot = oXMLFile.GetRoot();
 961         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
 962
 963         paChilds.RemoveAll();
 964         nResult = pRoot->Find( &paChilds, _T("DeviceInfo"), _T("DUID"), NULL);
 965
 966         IF_TRUE_GOTO(nResult != 0, ERROR_INVALID_DATA);
 967         IF_TRUE_GOTO(paChilds.GetCount() != 1, ERROR_INVALID_DATA);
 968
 969         pElement = (CXMLElement*)paChilds.Get(0);
 970         pszValue = pElement->GetValue();
 971         IF_TRUE_GOTO(pszValue == NULL, -1);
 972         length = TADC_IF_StrLen((char*)pszValue);
 973         if (length <= 0)
 974         {
 975                 nResult = -1;
 976                 goto finish;
 977         }
 978
 979         t_RO->PerFlag |= DUID_RULE;
 980         t_RO->t_Permission.t_Individual.BindingType |= DUID_RULE;
 981         t_RO->t_Permission.t_Individual.DUID = (TADC_U8*)TADC_IF_Malloc(length + 1);
 982
 983         if (t_RO->t_Permission.t_Individual.DUID == NULL)
 984         {
 985                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_MEMAlOC_ERROR);
 986                 nResult = -2;
 987                 goto finish;
 988         }
 989
 990         TADC_IF_MemSet(t_RO->t_Permission.t_Individual.DUID, 0, length + 1);
 991         TADC_IF_MemCpy((CHAR*)t_RO->t_Permission.t_Individual.DUID, pszValue, length);
 992
 993         nResult = 0;
 994
 995 finish:
 996         pszValue = NULL;
 997
 998         if (nResult < 0)
 999         {
1000                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_XMLPARSER_ERROR);
1001         }
1002
1003         if (nResult == -2)
1004         {
1005                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_MEMAlOC_ERROR);
1006         }
1007
1008         TADC_IF_Free(pbBuffer);
1009
1010         return nResult;
1011 }
1012
1013 int TADC_GetFileHeader(unsigned char * inBuffer,  T_FILE_HEADER *t_FileHeader)
1014 {
1015         int i = 0;
1016         BYTE FixedFileType[8] = {0x00,0x00,0x00,0x14,0x66,0x74,0x79,0x70};
1017         char tmp[2];
1018
1019         //Check Param Bufffer
1020         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
1021         IF_TRUE_RETURN(t_FileHeader == NULL, TADC_PARAMETER_ERROR);
1022
1023         //Init
1024         TADC_IF_MemSet(t_FileHeader, 0, sizeof(T_FILE_HEADER));
1025         TADC_IF_MemSet(tmp, 0, sizeof(tmp));
1026
1027         if (TADC_IF_MemCmp(inBuffer, FixedFileType, sizeof(FixedFileType)))
1028         {
1029                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSSTRUCT_ERROR);
1030                 return -1;
1031         }
1032         i += 8;
1033
1034         if (TADC_IF_MemCmp(inBuffer+i, "TADF", 4))
1035         {
1036                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSSTRUCT_ERROR);
1037                 return -2;
1038         }
1039         i += 4;
1040
1041         t_FileHeader->Version[0] = '1';
1042         t_FileHeader->Version[1] = '0';
1043         i += 4;
1044
1045         if (TADC_IF_MemCmp(inBuffer+i, "TADF", 4))
1046         {
1047                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSSTRUCT_ERROR);
1048                 return -2;
1049         }
1050         i += 4;
1051
1052         t_FileHeader->DRMType = inBuffer[i];
1053         i += 1;
1054
1055         TADC_IF_MemCpy(t_FileHeader->ContentsType, inBuffer+i, 128);
1056         i += 128;
1057
1058         TADC_IF_MemCpy(&t_FileHeader->TotalSize, inBuffer+i, 8);
1059         i += 8;
1060         t_FileHeader->TotalSize = _hton64(t_FileHeader->TotalSize);
1061
1062         TADC_IF_MemCpy(&t_FileHeader->Offset1, inBuffer+i, 8);
1063         i += 8;
1064         t_FileHeader->Offset1 = _hton64(t_FileHeader->Offset1);
1065
1066         TADC_IF_MemCpy(&t_FileHeader->Offset2, inBuffer+i, 8);
1067         i += 8;
1068         t_FileHeader->Offset2 = _hton64(t_FileHeader->Offset2);
1069
1070         TADC_IF_MemCpy(&t_FileHeader->Offset3, inBuffer+i, 8);
1071         i += 8;
1072         t_FileHeader->Offset3 = _hton64(t_FileHeader->Offset3);
1073
1074         TADC_IF_MemCpy(&t_FileHeader->Offset4, inBuffer+i, 8);
1075         i += 8;
1076         t_FileHeader->Offset4 = _hton64(t_FileHeader->Offset4);
1077
1078         TADC_IF_MemCpy(&t_FileHeader->Offset5, inBuffer+i, 8);
1079         i += 8;
1080         t_FileHeader->Offset5 = _hton64(t_FileHeader->Offset5);
1081
1082         TADC_IF_MemCpy(&t_FileHeader->Offset6, inBuffer+i, 8);
1083         i += 8;
1084         t_FileHeader->Offset6 = _hton64(t_FileHeader->Offset6);
1085
1086         TADC_IF_MemCpy(&t_FileHeader->Offset7, inBuffer+i, 8);
1087         i += 8;
1088         t_FileHeader->Offset7 = _hton64(t_FileHeader->Offset7);
1089
1090         TADC_IF_MemCpy(&t_FileHeader->Offset8, inBuffer+i, 8);
1091         i += 8;
1092         t_FileHeader->Offset8 = _hton64(t_FileHeader->Offset8);
1093
1094         DRM_TAPPS_LOG("TADC_GetFileHeader Success!\n");
1095         return 0;
1096 }
1097
1098 int TADC_GetDRMHeader(unsigned char * inBuffer, T_DRM_HEADER *t_DRMHeader)
1099 {
1100         int i = 0;
1101
1102         //Check Param Bufffer
1103         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
1104         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1105
1106         //Init
1107         TADC_IF_MemSet(t_DRMHeader, 0, sizeof(T_DRM_HEADER));
1108
1109         if (TADC_IF_MemCmp(inBuffer, "TIZEN_DRM", 9))
1110         {
1111                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_NOTTADCFILE_ERROR);
1112                 return -1;
1113         }
1114         i += 9;
1115
1116         TADC_IF_MemCpy(t_DRMHeader->Version, inBuffer+i, 2);
1117         i += 2;
1118
1119         TADC_IF_MemCpy(&t_DRMHeader->XmlSize, inBuffer+i, 4);
1120         i += 4;
1121
1122         t_DRMHeader->XmlSize = htonl_(t_DRMHeader->XmlSize);
1123         DRM_TAPPS_LOG("TADC_GetDRMHeader Success!\n");
1124
1125         return 0;
1126 }
1127
1128 int TADC_GetDRMHeaderInfo(unsigned char * inBuffer, T_DRM_HEADER *t_DRMHeader)
1129 {
1130         int nResult = 0;
1131         CXMLFile oXMLFile;
1132         CXMLElement* pRoot, *pNode;
1133         CPointerArray paChilds;
1134         LPCTSTR pszValue;
1135
1136         BYTE sha1_tmp[20];
1137         unsigned char *ReqTemp=NULL;
1138
1139         TADC_U8 key[16];
1140         TADC_U8 iv[16];
1141
1142         int outlen=0;
1143         long Length=0;
1144
1145         //Check Param
1146         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
1147         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1148
1149         IF_TRUE_RETURN(t_DRMHeader->XmlSize <= 0 || t_DRMHeader->XmlSize > ROXML_MAXSIZE, TADC_PARAMETER_ERROR);
1150
1151         ReqTemp = (TADC_U8*)TADC_IF_Malloc(t_DRMHeader->XmlSize);
1152         IF_TRUE_RETURN(ReqTemp == NULL, TADC_MEMAlOC_ERROR);
1153
1154         TADC_IF_MemSet(ReqTemp, 0, t_DRMHeader->XmlSize);
1155         TADC_IF_MemSet(sha1_tmp, 0, sizeof(sha1_tmp)  );
1156
1157         //Get HMAC
1158         TADC_IF_MemCpy(ReqTemp, inBuffer + 20, t_DRMHeader->XmlSize);
1159         TADC_IF_SHA1(ReqTemp, t_DRMHeader->XmlSize, sha1_tmp);
1160
1161         if (ReqTemp != NULL)
1162         {
1163                 TADC_IF_Free(ReqTemp);
1164                 ReqTemp = NULL;
1165         }
1166
1167         TADC_IF_MemCpy(key, &g_baSignatureKey[0], 16);
1168         TADC_IF_MemCpy(iv, &g_baSignatureKey[16], 16);
1169         TADC_IF_AES_CTR(key, 16, iv, 20, (unsigned char*)sha1_tmp, &outlen, (unsigned char*)sha1_tmp);
1170
1171         if (TADC_IF_MemCmp(sha1_tmp, inBuffer, sizeof(sha1_tmp)))
1172         {
1173                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSHMAC_ERROR);
1174                 return -1;
1175         }
1176
1177         //Load XML Header
1178         nResult = oXMLFile.LoadFromStream((LPCTSTR)(inBuffer + 20));
1179
1180         if (nResult != 0)
1181         {
1182                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSXML_ERROR);
1183                 goto finish;
1184         }
1185
1186         pRoot = oXMLFile.GetRoot();
1187         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1188
1189         paChilds.RemoveAll();
1190         nResult = pRoot->Find( &paChilds, _T("SID"), NULL );
1191
1192         if (nResult == 0)
1193         {
1194                 if (paChilds.GetCount() == 1)
1195                 {
1196                         pNode = (CXMLElement*)paChilds.Get(0);
1197                         pszValue = pNode->GetValue();
1198                         Length = TADC_IF_StrLen((char*)pszValue);
1199
1200                         if (Length > 0)
1201                         {
1202                                 t_DRMHeader->SID = (TADC_U8*)TADC_IF_Malloc(Length + 1);
1203                                 IF_TRUE_RETURN(t_DRMHeader->SID == NULL, TADC_MEMAlOC_ERROR);
1204                                 TADC_IF_MemSet(t_DRMHeader->SID, 0, Length + 1);
1205                                 TADC_IF_StrNCpy((CHAR*)t_DRMHeader->SID, pszValue, Length);
1206                         }
1207                 }
1208         }
1209
1210         pRoot = oXMLFile.GetRoot();
1211         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1212
1213         paChilds.RemoveAll();
1214         nResult = pRoot->Find( &paChilds, _T("CID"), NULL );
1215
1216         if (nResult == 0)
1217         {
1218                 if (paChilds.GetCount() == 1)
1219                 {
1220                         pNode = (CXMLElement*)paChilds.Get(0);
1221                         pszValue = pNode->GetValue();
1222                         Length = TADC_IF_StrLen((char*)pszValue); //2011.03.08
1223
1224                         if (Length > 0)
1225                         {
1226                                 t_DRMHeader->CID = (TADC_U8*)TADC_IF_Malloc(Length + 1); //2011.03.08 ( CID_SIZE -> Length )
1227                                 IF_TRUE_RETURN(t_DRMHeader->CID == NULL, TADC_MEMAlOC_ERROR);
1228                                 TADC_IF_MemSet(t_DRMHeader->CID, 0, Length + 1); //2011.03.08 ( CID_SIZE -> Length )
1229                                 TADC_IF_StrNCpy((CHAR*)t_DRMHeader->CID, pszValue, Length); //2011.03.08 ( CID_SIZE -> Length )
1230                         }
1231                 }
1232         }
1233
1234         pRoot = oXMLFile.GetRoot();
1235         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1236         paChilds.RemoveAll();
1237         nResult = pRoot->Find(&paChilds, _T("ContentType"), NULL);
1238
1239         if (nResult == 0)
1240         {
1241                 if (paChilds.GetCount() == 1)
1242                 {
1243                         pNode = (CXMLElement*)paChilds.Get(0);
1244                         pszValue = pNode->GetValue();
1245                         Length = TADC_IF_StrLen((char*)pszValue);
1246                         TADC_IF_MemSet(t_DRMHeader->ContentsType, 0, 128);
1247                         TADC_IF_StrNCpy((CHAR*)t_DRMHeader->ContentsType, pszValue, Length);
1248                 }
1249         }
1250
1251         pRoot = oXMLFile.GetRoot();
1252         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1253         paChilds.RemoveAll();
1254         nResult = pRoot->Find( &paChilds, _T("EncryptionMethod"), NULL );
1255
1256         if (nResult == 0)
1257         {
1258                 if (paChilds.GetCount() == 1)
1259                 {
1260                         pNode = (CXMLElement*)paChilds.Get(0);
1261                         pszValue = pNode->GetValue();
1262                         t_DRMHeader->EncryptionMethod = TADC_IF_AtoI((char*)pszValue);
1263                 }
1264         }
1265
1266         pRoot = oXMLFile.GetRoot();
1267         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1268         paChilds.RemoveAll();
1269         nResult = pRoot->Find( &paChilds, _T("EncryptionLevel"), NULL );
1270
1271         if (nResult == 0)
1272         {
1273                 if (paChilds.GetCount() == 1)
1274                 {
1275                         pNode = (CXMLElement*)paChilds.Get(0);
1276                         pszValue = pNode->GetValue();
1277                         t_DRMHeader->EncryptionLevel = TADC_IF_AtoI((char*)pszValue);
1278                 }
1279         }
1280
1281         pRoot = oXMLFile.GetRoot();
1282         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1283         paChilds.RemoveAll();
1284         nResult = pRoot->Find( &paChilds, _T("EncryptionRange"), NULL );
1285
1286         if (nResult == 0)
1287         {
1288                 if (paChilds.GetCount() == 1)
1289                 {
1290                         pNode = (CXMLElement*)paChilds.Get(0);
1291                         pszValue = pNode->GetValue();
1292                         t_DRMHeader->EncryptionRange = TADC_IF_AtoI((char*)pszValue);
1293                 }
1294         }
1295
1296         pRoot = oXMLFile.GetRoot();
1297         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1298         paChilds.RemoveAll();
1299         nResult = pRoot->Find( &paChilds, _T("RIURL"), NULL );
1300
1301         if (nResult == 0)
1302         {
1303                 if (paChilds.GetCount() == 1)
1304                 {
1305                         pNode = (CXMLElement*)paChilds.Get(0);
1306                         pszValue = pNode->GetValue();
1307                         Length = TADC_IF_StrLen((char*)pszValue);
1308
1309                         if (Length > 0)
1310                         {
1311                                 t_DRMHeader->RIURL = (TADC_U8*)TADC_IF_Malloc(Length+1);
1312                                 IF_TRUE_RETURN(t_DRMHeader->RIURL == NULL, TADC_MEMAlOC_ERROR);
1313                                 TADC_IF_MemSet(t_DRMHeader->RIURL, 0, Length+1);
1314                                 TADC_IF_StrNCpy((CHAR*)t_DRMHeader->RIURL, pszValue, Length);
1315                         }
1316                 }
1317         }
1318
1319         // dummy RIURL(DRM Server spec changed)
1320         if (t_DRMHeader->RIURL == NULL)
1321         {
1322                 pszValue = "dummy_riurl";
1323                 Length = TADC_IF_StrLen(pszValue);
1324                 t_DRMHeader->RIURL = (TADC_U8*)TADC_IF_Malloc(Length+1);
1325                 IF_TRUE_RETURN(t_DRMHeader->RIURL == NULL, TADC_MEMAlOC_ERROR);
1326                 TADC_IF_MemSet(t_DRMHeader->RIURL, 0, Length+1);
1327                 TADC_IF_StrNCpy((CHAR*)t_DRMHeader->RIURL, pszValue, Length);
1328         }
1329
1330         DRM_TAPPS_LOG("t_DRMHeader->RIURL = %s\n", (char*)t_DRMHeader->RIURL);
1331
1332         pRoot = oXMLFile.GetRoot();
1333         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1334         paChilds.RemoveAll();
1335         nResult = pRoot->Find( &paChilds, _T("PlaintextSize"), NULL );
1336
1337         if (nResult == 0)
1338         {
1339                 if (paChilds.GetCount() == 1)
1340                 {
1341                         pNode = (CXMLElement*)paChilds.Get(0);
1342                         pszValue = pNode->GetValue();
1343                         t_DRMHeader->PlaintextSize = TADC_IF_AtoI((char*)pszValue);
1344                 }
1345         }
1346
1347         pRoot = oXMLFile.GetRoot();
1348         IF_TRUE_GOTO( pRoot == NULL, ERROR_INVALID_DATA );
1349         paChilds.RemoveAll();
1350         nResult = pRoot->Find( &paChilds, _T("Packdate"), NULL );
1351
1352         if (nResult == 0)
1353         {
1354                 if (paChilds.GetCount() == 1)
1355                 {
1356                         pNode = (CXMLElement*)paChilds.Get(0);
1357                         pszValue = pNode->GetValue();
1358                         Length = TADC_IF_StrLen((char*)pszValue);
1359
1360                         if (Length > 0)
1361                         {
1362                                 t_DRMHeader->Packdate = (TADC_U8*)TADC_IF_Malloc(Length+1);
1363                                 IF_TRUE_RETURN(t_DRMHeader->Packdate == NULL, TADC_MEMAlOC_ERROR);
1364                                 TADC_IF_MemSet(t_DRMHeader->Packdate, 0, Length+1);
1365                                 TADC_IF_StrNCpy((char*)t_DRMHeader->Packdate, pszValue, Length);
1366                         }
1367                 }
1368         }
1369
1370 finish:
1371         if (nResult != 0)
1372         {
1373                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSXML_ERROR);
1374                 STACKTRACE( _T( "CNCG20File::_ParseHeader()" ) );
1375         }
1376         DRM_TAPPS_LOG("TADC_GetDRMHeaderInfo Success! \n");
1377         return nResult;
1378 }
1379
1380 int TADC_GetCEK(T_DEVICE_INFO *t_DeviceInfo, T_RO *t_RODB, T_DRM_HEADER *t_DRMHeader)
1381 {
1382         int length1 = 0;
1383
1384         //Check Parameter Buffer
1385         IF_TRUE_RETURN(t_DeviceInfo == NULL, TADC_PARAMETER_ERROR);
1386         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1387         IF_TRUE_RETURN(t_DRMHeader->CID == NULL, TADC_PARAMETER_ERROR);
1388         IF_TRUE_RETURN(t_RODB == NULL, TADC_PARAMETER_ERROR);
1389         IF_TRUE_RETURN(t_RODB->t_Content.CID == NULL, TADC_PARAMETER_ERROR);
1390
1391         if(!TADC_IF_StrCmp((char*)t_DRMHeader->CID, (char*)t_RODB->t_Content.CID)) //2011.03.08 ( TADC_IF_MemCmp -> TADC_IF_StrCmp )
1392         {
1393                 if((t_RODB->PerFlag & DUID_RULE) && (t_RODB->t_Permission.t_Individual.BindingType & DUID_RULE))
1394                 {
1395                         IF_TRUE_RETURN(t_RODB->t_Permission.t_Individual.DUID == NULL, TADC_PARAMETER_ERROR);
1396                         length1 = TADC_IF_StrLen((char*)t_DeviceInfo->DUID);
1397                         DRM_TAPPS_LOG("t_DeviceInfo->DUID = %s, t_RODB->t_Permission.t_Individual.DUID is %s, length1 is %d\n", t_DeviceInfo->DUID, t_RODB->t_Permission.t_Individual.DUID, length1);
1398                         /*if(TADC_IF_MemCmp(t_DeviceInfo->DUID, t_RODB->t_Permission.t_Individual.DUID, length1))
1399                         {
1400                                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_RULE_DUID_ERROR);
1401                                 return -1;
1402                         } */
1403                 }
1404                 IF_TRUE_RETURN(t_RODB->t_Content.CEK == NULL, TADC_PARAMETER_ERROR);
1405                 t_DRMHeader->CEK = (TADC_U8*)TADC_IF_Malloc(CEK_SIZE + 1);
1406                 IF_TRUE_RETURN(t_DRMHeader->CEK == NULL, TADC_MEMAlOC_ERROR);
1407                 TADC_IF_MemSet(t_DRMHeader->CEK, 0, CEK_SIZE + 1);
1408                 TADC_IF_MemCpy(t_DRMHeader->CEK, t_RODB->t_Content.CEK, CEK_SIZE);
1409
1410                 DRM_TAPPS_LOG("TADC_GetCEK Success!\n");
1411                 return 0;
1412         }
1413
1414         DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_RULE_NOINFOMATION);
1415
1416         return -1;
1417 }
1418
1419 int TADC_DecryptBlock(char *pbBuffer, int nSize, const T_DRM_HEADER *t_DRMHeader)
1420 {
1421         TADC_U8 key[16] = {0, };
1422         TADC_U8 iv[16] = {0, };
1423         int i = 0, nBlocks = 0, nIndex = 0;
1424         char baToBeEncrypted[32] = {0, };
1425         int nRemainBytes = 0, nBlockBytes = 0;
1426
1427         int nEncryptionLevel = 0;
1428         int nEncryptionMethod = 0;
1429
1430         char temp[512] = {0, };
1431         int length = 0;
1432         int totlength = 0;
1433
1434         TADC_IF_MemSet(temp, 0, sizeof(temp));
1435
1436         IF_TRUE_RETURN(pbBuffer == NULL, TADC_PARAMETER_ERROR);
1437         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1438
1439         IF_TRUE_RETURN(nSize > 512, TADC_PARAMETER_ERROR);
1440         IF_TRUE_RETURN(t_DRMHeader->CEK == NULL, TADC_PARAMETER_ERROR);
1441
1442         nEncryptionLevel = t_DRMHeader->EncryptionLevel;
1443         nEncryptionMethod = t_DRMHeader->EncryptionMethod;
1444
1445         IF_TRUE_RETURN(nEncryptionMethod != 1, TADC_PARAMETER_ERROR);
1446         IF_TRUE_RETURN(nEncryptionLevel < 0 || nEncryptionLevel > 32, TADC_PARAMETER_ERROR);
1447
1448         TADC_IF_MemSet( baToBeEncrypted, 1, 32 );
1449
1450         if (nEncryptionLevel > 16)
1451         {
1452                 nBlocks = 16;
1453         }
1454         else
1455         {
1456                 nBlocks = nEncryptionLevel;
1457         }
1458
1459         for (i = 0 ; i < nBlocks ; i++)
1460         {
1461                 nIndex = 31 - (i * 2);
1462                 baToBeEncrypted[nIndex] = 0;
1463         }
1464
1465         for (i = 16 ; i < nEncryptionLevel ; i++)
1466         {
1467                 nIndex = 30 - ((i - 16) * 2);
1468                 baToBeEncrypted[nIndex] = 0;
1469         }
1470
1471         nRemainBytes = nSize;
1472         nBlockBytes = 16;
1473
1474         length = 0;
1475         totlength = 0;
1476
1477         for (i = 0 ; i < 32 ; i++)
1478         {
1479                 if (nRemainBytes < 16)
1480                 {
1481                         nBlockBytes = nRemainBytes;
1482                 }
1483
1484                 if (baToBeEncrypted[i] == 1)
1485                 {
1486                         TADC_IF_MemCpy(temp + length, pbBuffer + totlength, nBlockBytes);
1487                         length += nBlockBytes;
1488                 }
1489
1490                 nRemainBytes -= nBlockBytes;
1491                 totlength += nBlockBytes;
1492
1493                 if (nRemainBytes < 1)
1494                 {
1495                         break;
1496                 }
1497         }
1498
1499         TADC_IF_MemCpy(key, &t_DRMHeader->CEK[0], 16);
1500         TADC_IF_MemCpy(iv, &t_DRMHeader->CEK[16], 16);
1501         TADC_IF_AES_CTR(key, 16, iv, length, (unsigned char*)temp, &length, (unsigned char*)temp);
1502
1503         nRemainBytes = nSize;
1504         nBlockBytes = 16;
1505
1506         length = 0;
1507         totlength = 0;
1508
1509         for (i = 0 ; i < 32 ; i++)
1510         {
1511                 if (nRemainBytes < 16)
1512                 {
1513                         nBlockBytes = nRemainBytes;
1514                 }
1515
1516                 if (baToBeEncrypted[i] == 1)
1517                 {
1518                         TADC_IF_MemCpy(pbBuffer + totlength, temp + length, nBlockBytes);
1519                         length += nBlockBytes;
1520                 }
1521
1522                 nRemainBytes -= nBlockBytes;
1523                 totlength += nBlockBytes;
1524
1525                 if (nRemainBytes < 1)
1526                 {
1527                         break;
1528                 }
1529         }
1530         return 0;
1531 }
1532
1533 int TADC_GetDRMHeaderFromFile(const char *pTADCFilepath, T_FILE_HEADER *t_FileHeader, T_DRM_HEADER *t_DRMHeader )
1534 {
1535
1536         unsigned char tempbuf[512];
1537         unsigned char *pbuf = NULL;
1538
1539         int ret=0;
1540         ULONG readsize=0, ReadLen=0;
1541
1542         FILE *hFile =  0; //Apps drm file
1543
1544         //null check
1545         if (pTADCFilepath == NULL || t_FileHeader == NULL || t_DRMHeader == NULL)
1546         {
1547                 DRM_TAPPS_EXCEPTION("Error : Parameter Null.");
1548                 return -1;
1549         }
1550
1551         //Init
1552         TADC_IF_MemSet(tempbuf, 0, sizeof(tempbuf));
1553
1554         //File Open
1555         if ((hFile = fopen(pTADCFilepath, "rb")) == NULL)
1556         {
1557                 DRM_TAPPS_EXCEPTION("Error : fopen() error.");
1558                 return -1;
1559         }
1560
1561         readsize = 256;
1562
1563         //FmReadFile(hFile, tempbuf, readsize, &ReadLen);
1564         ReadLen = fread(tempbuf, 1, readsize, hFile);
1565         if ((readsize != ReadLen) || (ret=TADC_GetFileHeader(tempbuf, t_FileHeader)) < 0)
1566         {
1567                 DRM_TAPPS_EXCEPTION("Error : fread() error.");
1568                 fclose(hFile);
1569                 return -1;
1570         }
1571         TADC_IF_MemSet(tempbuf, 0, sizeof(tempbuf));
1572
1573         //Tizen Apps DRM Type Check
1574         if (t_FileHeader->DRMType & TIZEN_DRM)
1575         {
1576                 DRM_TAPPS_LOG("It's a TAPPS DCF = %s", pTADCFilepath);
1577                 readsize = 15;
1578                 ReadLen = fread(tempbuf, 1, readsize, hFile);
1579                 if ((readsize != ReadLen) || (ret=TADC_GetDRMHeader(tempbuf, t_DRMHeader)) < 0)
1580                 {
1581                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1582                         fclose(hFile);
1583                         return -1;
1584                 }
1585
1586                 readsize = 20 + t_DRMHeader->XmlSize;
1587                 if ((pbuf = (unsigned char*)TADC_IF_Malloc( readsize * sizeof(char))) == NULL)
1588                 {
1589                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1590                         fclose(hFile);
1591                         return -1;
1592                 }
1593
1594                 ReadLen = fread(pbuf, 1, readsize, hFile);
1595                 if (readsize != ReadLen)
1596                 {
1597                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1598                         TADC_IF_Free(pbuf);
1599                         fclose(hFile);
1600                         return -1;
1601                 }
1602
1603                 if (TADC_GetDRMHeaderInfo(pbuf, t_DRMHeader) < 0)
1604                 {
1605                         DRM_TAPPS_EXCEPTION("Error : TADC_GetDRMHeaderInfo error.");
1606                         TADC_IF_Free(pbuf);
1607                         fclose(hFile);
1608                         return -1;
1609                 }
1610                 TADC_IF_Free(pbuf);
1611         }
1612         else
1613         {
1614                 DRM_TAPPS_EXCEPTION("Error : It's not a TApps DCF file.");
1615                 fclose(hFile);
1616                 return -1;
1617         }
1618
1619         fclose(hFile);
1620         return 0;
1621 }
1622
1623 DWORD TADC_GetLastError(void)
1624 {
1625         DWORD dwError = g_TADCErrorCode;
1626         g_TADCErrorCode = 0;
1627
1628         return dwError;
1629 }
1630
1631 int TADC_MEMFree_RO(T_RO *t_ro)
1632 {
1633         IF_TRUE_RETURN(t_ro == NULL, TADC_PARAMETER_ERROR);
1634         t_ro->PerFlag = 0;
1635
1636         if (t_ro->t_Content.CID != NULL)
1637         {
1638                 TADC_IF_Free(t_ro->t_Content.CID);
1639                 t_ro->t_Content.CID = NULL;
1640         }
1641
1642         if (t_ro->t_Content.CEK!= NULL)
1643         {
1644                 TADC_IF_Free(t_ro->t_Content.CEK);
1645                 t_ro->t_Content.CEK = NULL;
1646         }
1647
1648         if (t_ro->t_Permission.t_Individual.DUID != NULL)
1649         {
1650                 TADC_IF_Free(t_ro->t_Permission.t_Individual.DUID);
1651                 t_ro->t_Permission.t_Individual.DUID = NULL;
1652         }
1653
1654         return 0;
1655 }
1656
1657 int TADC_MEMFree_FileHeader(T_FILE_HEADER *t_FileHeader)
1658 {
1659         IF_TRUE_RETURN(t_FileHeader == NULL, TADC_PARAMETER_ERROR);
1660         TADC_IF_MemSet(t_FileHeader, 0, sizeof(T_FILE_HEADER));
1661
1662         return 0;
1663 }
1664
1665 int TADC_MEMFree_DRMHeader(T_DRM_HEADER *t_DrmHeader)
1666 {
1667         IF_TRUE_RETURN(t_DrmHeader == NULL, TADC_PARAMETER_ERROR);
1668         t_DrmHeader->XmlSize = 0;
1669         TADC_IF_MemSet(t_DrmHeader->Version, 0, sizeof(t_DrmHeader->Version));
1670
1671         if (t_DrmHeader->SID != NULL)
1672         {
1673                 TADC_IF_Free(t_DrmHeader->SID);
1674                 t_DrmHeader->SID = NULL;
1675         }
1676
1677         if (t_DrmHeader->CID != NULL)
1678         {
1679                 TADC_IF_Free(t_DrmHeader->CID);
1680                 t_DrmHeader->CID = NULL;
1681         }
1682
1683         TADC_IF_MemSet(t_DrmHeader->ContentsType, 0, sizeof(t_DrmHeader->ContentsType));
1684         t_DrmHeader->EncryptionRange = 0;
1685
1686         if (t_DrmHeader->RIURL != NULL)
1687         {
1688                 TADC_IF_Free(t_DrmHeader->RIURL);
1689                 t_DrmHeader->RIURL = NULL;
1690         }
1691
1692         t_DrmHeader->PlaintextSize = 0;
1693         if (t_DrmHeader->Packdate != NULL)
1694         {
1695                 TADC_IF_Free(t_DrmHeader->Packdate);
1696                 t_DrmHeader->Packdate = NULL;
1697         }
1698
1699         if (t_DrmHeader->CEK != NULL)
1700         {
1701                 TADC_IF_Free(t_DrmHeader->CEK);
1702                 t_DrmHeader->CEK = NULL;
1703         }
1704         return 0;
1705 }
1706
1707 int TADC_MEMFree_ROAcqInfo(T_ROACQ_INFO *t_ROAcqInfo)
1708 {
1709         IF_TRUE_RETURN(t_ROAcqInfo == NULL, TADC_PARAMETER_ERROR);
1710
1711         if (t_ROAcqInfo->ROAcqURL != NULL)
1712         {
1713                 TADC_IF_Free(t_ROAcqInfo->ROAcqURL);
1714                 t_ROAcqInfo->ROAcqURL = NULL;
1715         }
1716
1717         if (t_ROAcqInfo->ReqID != NULL)
1718         {
1719                 TADC_IF_Free(t_ROAcqInfo->ReqID);
1720                 t_ROAcqInfo->ReqID = NULL;
1721         }
1722
1723         TADC_IF_MemSet(&t_ROAcqInfo->t_DHInfo, 0, sizeof(T_DH_INFO));
1724         return 0;
1725 }