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)
 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, 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                         TADC_IF_MemSet(t_DRMHeader->ContentsType, 0, 128);
1241                         TADC_IF_StrNCpy((CHAR *)t_DRMHeader->ContentsType, pszValue, Length + 1);
1242                 }
1243         }
1244
1245         pRoot = oXMLFile.GetRoot();
1246         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1247         paChilds.RemoveAll();
1248         nResult = pRoot->Find(&paChilds, _T("EncryptionMethod"), NULL);
1249
1250         if (nResult == 0) {
1251                 if (paChilds.GetCount() == 1) {
1252                         pNode = (CXMLElement *)paChilds.Get(0);
1253                         pszValue = pNode->GetValue();
1254                         t_DRMHeader->EncryptionMethod = TADC_IF_AtoI((char *)pszValue);
1255                 }
1256         }
1257
1258         pRoot = oXMLFile.GetRoot();
1259         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1260         paChilds.RemoveAll();
1261         nResult = pRoot->Find(&paChilds, _T("EncryptionLevel"), NULL);
1262
1263         if (nResult == 0) {
1264                 if (paChilds.GetCount() == 1) {
1265                         pNode = (CXMLElement *)paChilds.Get(0);
1266                         pszValue = pNode->GetValue();
1267                         t_DRMHeader->EncryptionLevel = TADC_IF_AtoI((char *)pszValue);
1268                 }
1269         }
1270
1271         pRoot = oXMLFile.GetRoot();
1272         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1273         paChilds.RemoveAll();
1274         nResult = pRoot->Find(&paChilds, _T("EncryptionRange"), NULL);
1275
1276         if (nResult == 0) {
1277                 if (paChilds.GetCount() == 1) {
1278                         pNode = (CXMLElement *)paChilds.Get(0);
1279                         pszValue = pNode->GetValue();
1280                         t_DRMHeader->EncryptionRange = TADC_IF_AtoI((char *)pszValue);
1281                 }
1282         }
1283
1284         pRoot = oXMLFile.GetRoot();
1285         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1286         paChilds.RemoveAll();
1287         nResult = pRoot->Find(&paChilds, _T("RIURL"), NULL);
1288
1289         if (nResult == 0) {
1290                 if (paChilds.GetCount() == 1) {
1291                         pNode = (CXMLElement *)paChilds.Get(0);
1292                         pszValue = pNode->GetValue();
1293                         Length = TADC_IF_StrLen((char *)pszValue);
1294
1295                         if (Length > 0) {
1296                                 t_DRMHeader->RIURL = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1297                                 IF_TRUE_RETURN(t_DRMHeader->RIURL == NULL, TADC_MEMAlOC_ERROR);
1298                                 TADC_IF_MemSet(t_DRMHeader->RIURL, 0, Length + 1);
1299                                 TADC_IF_StrNCpy((CHAR *)t_DRMHeader->RIURL, pszValue, Length + 1);
1300                         }
1301                 }
1302         }
1303
1304         // dummy RIURL(DRM Server spec changed)
1305         if (t_DRMHeader->RIURL == NULL) {
1306                 pszValue = "dummy_riurl";
1307                 Length = TADC_IF_StrLen(pszValue);
1308                 t_DRMHeader->RIURL = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1309                 IF_TRUE_RETURN(t_DRMHeader->RIURL == NULL, TADC_MEMAlOC_ERROR);
1310                 TADC_IF_MemSet(t_DRMHeader->RIURL, 0, Length + 1);
1311                 TADC_IF_StrNCpy((CHAR *)t_DRMHeader->RIURL, pszValue, Length + 1);
1312         }
1313
1314         DRM_TAPPS_LOG("t_DRMHeader->RIURL = %s\n", (char *)t_DRMHeader->RIURL);
1315
1316         pRoot = oXMLFile.GetRoot();
1317         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1318         paChilds.RemoveAll();
1319         nResult = pRoot->Find(&paChilds, _T("PlaintextSize"), NULL);
1320
1321         if (nResult == 0) {
1322                 if (paChilds.GetCount() == 1) {
1323                         pNode = (CXMLElement *)paChilds.Get(0);
1324                         pszValue = pNode->GetValue();
1325                         t_DRMHeader->PlaintextSize = TADC_IF_AtoI((char *)pszValue);
1326                 }
1327         }
1328
1329         pRoot = oXMLFile.GetRoot();
1330         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1331         paChilds.RemoveAll();
1332         nResult = pRoot->Find(&paChilds, _T("Packdate"), NULL);
1333
1334         if (nResult == 0) {
1335                 if (paChilds.GetCount() == 1) {
1336                         pNode = (CXMLElement *)paChilds.Get(0);
1337                         pszValue = pNode->GetValue();
1338                         Length = TADC_IF_StrLen((char *)pszValue);
1339
1340                         if (Length > 0) {
1341                                 t_DRMHeader->Packdate = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1342                                 IF_TRUE_RETURN(t_DRMHeader->Packdate == NULL, TADC_MEMAlOC_ERROR);
1343                                 TADC_IF_MemSet(t_DRMHeader->Packdate, 0, Length + 1);
1344                                 TADC_IF_StrNCpy((char *)t_DRMHeader->Packdate, pszValue, Length + 1);
1345                         }
1346                 }
1347         }
1348
1349 finish:
1350
1351         if (nResult != 0) {
1352                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSXML_ERROR);
1353                 STACKTRACE(_T("CNCG20File::_ParseHeader()"));
1354         }
1355
1356         DRM_TAPPS_LOG("TADC_GetDRMHeaderInfo Success! \n");
1357         return nResult;
1358 }
1359
1360 int TADC_GetCEK(T_DEVICE_INFO *t_DeviceInfo, T_RO *t_RODB,
1361                                 T_DRM_HEADER *t_DRMHeader)
1362 {
1363         int length1 = 0;
1364
1365         //Check Parameter Buffer
1366         IF_TRUE_RETURN(t_DeviceInfo == NULL, TADC_PARAMETER_ERROR);
1367         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1368         IF_TRUE_RETURN(t_DRMHeader->CID == NULL, TADC_PARAMETER_ERROR);
1369         IF_TRUE_RETURN(t_RODB == NULL, TADC_PARAMETER_ERROR);
1370         IF_TRUE_RETURN(t_RODB->t_Content.CID == NULL, TADC_PARAMETER_ERROR);
1371
1372         if (!TADC_IF_StrCmp((char *)t_DRMHeader->CID, (char *)t_RODB->t_Content.CID)) {
1373                 if ((t_RODB->PerFlag & DUID_RULE) &&
1374                                 (t_RODB->t_Permission.t_Individual.BindingType & DUID_RULE)) {
1375                         IF_TRUE_RETURN(t_RODB->t_Permission.t_Individual.DUID == NULL,
1376                                                    TADC_PARAMETER_ERROR);
1377                         length1 = TADC_IF_StrLen((char *)t_DeviceInfo->DUID);
1378                         DRM_TAPPS_LOG(
1379                                 "t_DeviceInfo->DUID = %s, "
1380                                 "t_RODB->t_Permission.t_Individual.DUID is %s, "
1381                                 "length1 is %d\n",
1382                                 t_DeviceInfo->DUID, t_RODB->t_Permission.t_Individual.DUID, length1);
1383                         /*if (TADC_IF_MemCmp(t_DeviceInfo->DUID,
1384                          *                   t_RODB->t_Permission.t_Individual.DUID, length1)) {
1385                             DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x",
1386                                                 TADC_RULE_DUID_ERROR);
1387                             return -1;
1388                         }*/
1389                 }
1390
1391                 IF_TRUE_RETURN(t_RODB->t_Content.CEK == NULL, TADC_PARAMETER_ERROR);
1392                 t_DRMHeader->CEK = (TADC_U8 *)TADC_IF_Malloc(CEK_SIZE + 1);
1393                 IF_TRUE_RETURN(t_DRMHeader->CEK == NULL, TADC_MEMAlOC_ERROR);
1394                 TADC_IF_MemSet(t_DRMHeader->CEK, 0, CEK_SIZE + 1);
1395                 TADC_IF_MemCpy(t_DRMHeader->CEK, t_RODB->t_Content.CEK, CEK_SIZE);
1396
1397                 DRM_TAPPS_LOG("TADC_GetCEK Success!\n");
1398                 return 0;
1399         }
1400
1401         DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_RULE_NOINFOMATION);
1402
1403         return -1;
1404 }
1405
1406 int TADC_DecryptBlock(char *pbBuffer, int nSize,
1407                                           const T_DRM_HEADER *t_DRMHeader)
1408 {
1409         TADC_U8 key[16] = {0, };
1410         TADC_U8 iv[16] = {0, };
1411         int i = 0, nBlocks = 0, nIndex = 0;
1412         char baToBeEncrypted[32] = {0, };
1413         int nRemainBytes = 0, nBlockBytes = 0;
1414
1415         int nEncryptionLevel = 0;
1416         int nEncryptionMethod = 0;
1417
1418         char temp[512] = {0, };
1419         int length = 0;
1420         int totlength = 0;
1421
1422         TADC_IF_MemSet(temp, 0, sizeof(temp));
1423
1424         IF_TRUE_RETURN(pbBuffer == NULL, TADC_PARAMETER_ERROR);
1425         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1426
1427         IF_TRUE_RETURN(nSize > 512, TADC_PARAMETER_ERROR);
1428         IF_TRUE_RETURN(t_DRMHeader->CEK == NULL, TADC_PARAMETER_ERROR);
1429
1430         nEncryptionLevel = t_DRMHeader->EncryptionLevel;
1431         nEncryptionMethod = t_DRMHeader->EncryptionMethod;
1432
1433         IF_TRUE_RETURN(nEncryptionMethod != 1, TADC_PARAMETER_ERROR);
1434         IF_TRUE_RETURN(nEncryptionLevel < 0 ||
1435                                    nEncryptionLevel > 32, TADC_PARAMETER_ERROR);
1436
1437         TADC_IF_MemSet(baToBeEncrypted, 1, 32);
1438
1439         if (nEncryptionLevel > 16)
1440                 nBlocks = 16;
1441         else
1442                 nBlocks = nEncryptionLevel;
1443
1444         for (i = 0; i < nBlocks; i++) {
1445                 nIndex = 31 - (i * 2);
1446                 baToBeEncrypted[nIndex] = 0;
1447         }
1448
1449         for (i = 16; i < nEncryptionLevel; i++) {
1450                 nIndex = 30 - ((i - 16) * 2);
1451                 baToBeEncrypted[nIndex] = 0;
1452         }
1453
1454         nRemainBytes = nSize;
1455         nBlockBytes = 16;
1456
1457         length = 0;
1458         totlength = 0;
1459
1460         for (i = 0; i < 32; i++) {
1461                 if (nRemainBytes < 16)
1462                         nBlockBytes = nRemainBytes;
1463
1464                 if (baToBeEncrypted[i] == 1) {
1465                         TADC_IF_MemCpy(temp + length, pbBuffer + totlength, nBlockBytes);
1466                         length += nBlockBytes;
1467                 }
1468
1469                 nRemainBytes -= nBlockBytes;
1470                 totlength += nBlockBytes;
1471
1472                 if (nRemainBytes < 1)
1473                         break;
1474         }
1475
1476         TADC_IF_MemCpy(key, &t_DRMHeader->CEK[0], 16);
1477         TADC_IF_MemCpy(iv, &t_DRMHeader->CEK[16], 16);
1478         TADC_IF_AES_CTR(key, 16, iv, length, (unsigned char *)temp, &length,
1479                                         (unsigned char *)temp);
1480
1481         nRemainBytes = nSize;
1482         nBlockBytes = 16;
1483
1484         length = 0;
1485         totlength = 0;
1486
1487         for (i = 0; i < 32; i++) {
1488                 if (nRemainBytes < 16)
1489                         nBlockBytes = nRemainBytes;
1490
1491                 if (baToBeEncrypted[i] == 1) {
1492                         TADC_IF_MemCpy(pbBuffer + totlength, temp + length, nBlockBytes);
1493                         length += nBlockBytes;
1494                 }
1495
1496                 nRemainBytes -= nBlockBytes;
1497                 totlength += nBlockBytes;
1498
1499                 if (nRemainBytes < 1) {
1500                         break;
1501                 }
1502         }
1503
1504         return 0;
1505 }
1506
1507 int TADC_GetDRMHeaderFromFile(const char *pTADCFilepath,
1508                                                           T_FILE_HEADER *t_FileHeader, T_DRM_HEADER *t_DRMHeader)
1509 {
1510         unsigned char tempbuf[512];
1511         unsigned char *pbuf = NULL;
1512
1513         int ret = 0;
1514         ULONG readsize = 0, ReadLen = 0;
1515
1516         FILE *hFile = 0; //Apps drm file
1517
1518         //null check
1519         if (pTADCFilepath == NULL || t_FileHeader == NULL || t_DRMHeader == NULL) {
1520                 DRM_TAPPS_EXCEPTION("Error : Parameter Null.");
1521                 return -1;
1522         }
1523
1524         //Init
1525         TADC_IF_MemSet(tempbuf, 0, sizeof(tempbuf));
1526
1527         //File Open
1528         if ((hFile = fopen(pTADCFilepath, "rb")) == NULL) {
1529                 DRM_TAPPS_EXCEPTION("Error : fopen() error.");
1530                 return -1;
1531         }
1532
1533         readsize = 256;
1534
1535         //FmReadFile(hFile, tempbuf, readsize, &ReadLen);
1536         ReadLen = fread(tempbuf, 1, readsize, hFile);
1537
1538         if ((readsize != ReadLen) ||
1539                         (ret = TADC_GetFileHeader(tempbuf, t_FileHeader)) < 0) {
1540                 DRM_TAPPS_EXCEPTION("Error : fread() error.");
1541                 fclose(hFile);
1542                 return -1;
1543         }
1544
1545         TADC_IF_MemSet(tempbuf, 0, sizeof(tempbuf));
1546
1547         //Tizen Apps DRM Type Check
1548         if (t_FileHeader->DRMType & TIZEN_DRM) {
1549                 DRM_TAPPS_LOG("It's a TAPPS DCF = %s", pTADCFilepath);
1550                 readsize = 15;
1551                 ReadLen = fread(tempbuf, 1, readsize, hFile);
1552
1553                 if ((readsize != ReadLen) ||
1554                                 (ret = TADC_GetDRMHeader(tempbuf, t_DRMHeader)) < 0) {
1555                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1556                         fclose(hFile);
1557                         return -1;
1558                 }
1559
1560                 readsize = 20 + t_DRMHeader->XmlSize;
1561
1562                 pbuf = (unsigned char *)TADC_IF_Malloc(readsize * sizeof(char));
1563
1564                 if (pbuf == NULL) {
1565                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1566                         fclose(hFile);
1567                         return -1;
1568                 }
1569
1570                 ReadLen = fread(pbuf, 1, readsize, hFile);
1571
1572                 if (readsize != ReadLen) {
1573                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1574                         TADC_IF_Free(pbuf);
1575                         fclose(hFile);
1576                         return -1;
1577                 }
1578
1579                 if (TADC_GetDRMHeaderInfo(pbuf, t_DRMHeader) < 0) {
1580                         DRM_TAPPS_EXCEPTION("Error : TADC_GetDRMHeaderInfo error.");
1581                         TADC_IF_Free(pbuf);
1582                         fclose(hFile);
1583                         return -1;
1584                 }
1585
1586                 TADC_IF_Free(pbuf);
1587         } else {
1588                 DRM_TAPPS_EXCEPTION("Error : It's not a TApps DCF file.");
1589                 fclose(hFile);
1590                 return -1;
1591         }
1592
1593         fclose(hFile);
1594         return 0;
1595 }
1596
1597 DWORD TADC_GetLastError(void)
1598 {
1599         DWORD dwError = g_TADCErrorCode;
1600         g_TADCErrorCode = 0;
1601
1602         return dwError;
1603 }
1604
1605 int TADC_MEMFree_RO(T_RO *t_ro)
1606 {
1607         IF_TRUE_RETURN(t_ro == NULL, TADC_PARAMETER_ERROR);
1608         t_ro->PerFlag = 0;
1609
1610         if (t_ro->t_Content.CID != NULL) {
1611                 TADC_IF_Free(t_ro->t_Content.CID);
1612                 t_ro->t_Content.CID = NULL;
1613         }
1614
1615         if (t_ro->t_Content.CEK != NULL) {
1616                 TADC_IF_Free(t_ro->t_Content.CEK);
1617                 t_ro->t_Content.CEK = NULL;
1618         }
1619
1620         if (t_ro->t_Permission.t_Individual.DUID != NULL) {
1621                 TADC_IF_Free(t_ro->t_Permission.t_Individual.DUID);
1622                 t_ro->t_Permission.t_Individual.DUID = NULL;
1623         }
1624
1625         return 0;
1626 }
1627
1628 int TADC_MEMFree_FileHeader(T_FILE_HEADER *t_FileHeader)
1629 {
1630         IF_TRUE_RETURN(t_FileHeader == NULL, TADC_PARAMETER_ERROR);
1631         TADC_IF_MemSet(t_FileHeader, 0, sizeof(T_FILE_HEADER));
1632
1633         return 0;
1634 }
1635
1636 int TADC_MEMFree_DRMHeader(T_DRM_HEADER *t_DrmHeader)
1637 {
1638         IF_TRUE_RETURN(t_DrmHeader == NULL, TADC_PARAMETER_ERROR);
1639         t_DrmHeader->XmlSize = 0;
1640         TADC_IF_MemSet(t_DrmHeader->Version, 0, sizeof(t_DrmHeader->Version));
1641
1642         if (t_DrmHeader->SID != NULL) {
1643                 TADC_IF_Free(t_DrmHeader->SID);
1644                 t_DrmHeader->SID = NULL;
1645         }
1646
1647         if (t_DrmHeader->CID != NULL) {
1648                 TADC_IF_Free(t_DrmHeader->CID);
1649                 t_DrmHeader->CID = NULL;
1650         }
1651
1652         TADC_IF_MemSet(t_DrmHeader->ContentsType, 0, sizeof(t_DrmHeader->ContentsType));
1653         t_DrmHeader->EncryptionRange = 0;
1654
1655         if (t_DrmHeader->RIURL != NULL) {
1656                 TADC_IF_Free(t_DrmHeader->RIURL);
1657                 t_DrmHeader->RIURL = NULL;
1658         }
1659
1660         t_DrmHeader->PlaintextSize = 0;
1661
1662         if (t_DrmHeader->Packdate != NULL) {
1663                 TADC_IF_Free(t_DrmHeader->Packdate);
1664                 t_DrmHeader->Packdate = NULL;
1665         }
1666
1667         if (t_DrmHeader->CEK != NULL) {
1668                 TADC_IF_Free(t_DrmHeader->CEK);
1669                 t_DrmHeader->CEK = NULL;
1670         }
1671
1672         return 0;
1673 }
1674
1675 int TADC_MEMFree_ROAcqInfo(T_ROACQ_INFO *t_ROAcqInfo)
1676 {
1677         IF_TRUE_RETURN(t_ROAcqInfo == NULL, TADC_PARAMETER_ERROR);
1678
1679         if (t_ROAcqInfo->ROAcqURL != NULL) {
1680                 TADC_IF_Free(t_ROAcqInfo->ROAcqURL);
1681                 t_ROAcqInfo->ROAcqURL = NULL;
1682         }
1683
1684         if (t_ROAcqInfo->ReqID != NULL) {
1685                 TADC_IF_Free(t_ROAcqInfo->ReqID);
1686                 t_ROAcqInfo->ReqID = NULL;
1687         }
1688
1689         TADC_IF_MemSet(&t_ROAcqInfo->t_DHInfo, 0, sizeof(T_DH_INFO));
1690         return 0;
1691 }