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