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