tadcore/TADCCore/TADC_Core.cpp

   1 /*
   2  * Copyright (c) 2000-2022 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         // ContentsType is treated as null-terminated string, hence 127
1059         // (zero is added in memset in line 1024)
1060         TADC_IF_MemCpy(t_FileHeader->ContentsType, inBuffer + i, 127);
1061         i += 128;
1062
1063         TADC_IF_MemCpy(&t_FileHeader->TotalSize, inBuffer + i, 8);
1064         i += 8;
1065         t_FileHeader->TotalSize = _hton64(t_FileHeader->TotalSize);
1066
1067         TADC_IF_MemCpy(&t_FileHeader->Offset1, inBuffer + i, 8);
1068         i += 8;
1069         t_FileHeader->Offset1 = _hton64(t_FileHeader->Offset1);
1070
1071         TADC_IF_MemCpy(&t_FileHeader->Offset2, inBuffer + i, 8);
1072         i += 8;
1073         t_FileHeader->Offset2 = _hton64(t_FileHeader->Offset2);
1074
1075         TADC_IF_MemCpy(&t_FileHeader->Offset3, inBuffer + i, 8);
1076         i += 8;
1077         t_FileHeader->Offset3 = _hton64(t_FileHeader->Offset3);
1078
1079         TADC_IF_MemCpy(&t_FileHeader->Offset4, inBuffer + i, 8);
1080         i += 8;
1081         t_FileHeader->Offset4 = _hton64(t_FileHeader->Offset4);
1082
1083         TADC_IF_MemCpy(&t_FileHeader->Offset5, inBuffer + i, 8);
1084         i += 8;
1085         t_FileHeader->Offset5 = _hton64(t_FileHeader->Offset5);
1086
1087         TADC_IF_MemCpy(&t_FileHeader->Offset6, inBuffer + i, 8);
1088         i += 8;
1089         t_FileHeader->Offset6 = _hton64(t_FileHeader->Offset6);
1090
1091         TADC_IF_MemCpy(&t_FileHeader->Offset7, inBuffer + i, 8);
1092         i += 8;
1093         t_FileHeader->Offset7 = _hton64(t_FileHeader->Offset7);
1094
1095         TADC_IF_MemCpy(&t_FileHeader->Offset8, inBuffer + i, 8);
1096         i += 8;
1097         t_FileHeader->Offset8 = _hton64(t_FileHeader->Offset8);
1098
1099         DRM_TAPPS_LOG("TADC_GetFileHeader Success!\n");
1100         return 0;
1101 }
1102
1103 int TADC_GetDRMHeader(unsigned char *inBuffer, T_DRM_HEADER *t_DRMHeader)
1104 {
1105         int i = 0;
1106
1107         //Check Param Bufffer
1108         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
1109         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1110
1111         //Init
1112         TADC_IF_MemSet(t_DRMHeader, 0, sizeof(T_DRM_HEADER));
1113
1114         if (TADC_IF_MemCmp(inBuffer, "TIZEN_DRM", 9)) {
1115                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_NOTTADCFILE_ERROR);
1116                 return -1;
1117         }
1118
1119         i += 9;
1120
1121         TADC_IF_MemCpy(t_DRMHeader->Version, inBuffer + i, 2);
1122         i += 2;
1123
1124         TADC_IF_MemCpy(&t_DRMHeader->XmlSize, inBuffer + i, 4);
1125         i += 4;
1126
1127         t_DRMHeader->XmlSize = htonl_(t_DRMHeader->XmlSize);
1128         DRM_TAPPS_LOG("TADC_GetDRMHeader Success!\n");
1129
1130         return 0;
1131 }
1132
1133 int TADC_GetDRMHeaderInfo(unsigned char *inBuffer, T_DRM_HEADER *t_DRMHeader)
1134 {
1135         int nResult = 0;
1136         CXMLFile oXMLFile;
1137         CXMLElement *pRoot, *pNode;
1138         CPointerArray paChilds;
1139         LPCTSTR pszValue;
1140
1141         BYTE sha1_tmp[20];
1142         unsigned char *ReqTemp = NULL;
1143
1144         TADC_U8 key[16];
1145         TADC_U8 iv[16];
1146
1147         int outlen = 0;
1148         long Length = 0;
1149
1150         //Check Param
1151         IF_TRUE_RETURN(inBuffer == NULL, TADC_PARAMETER_ERROR);
1152         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1153
1154         IF_TRUE_RETURN(t_DRMHeader->XmlSize <= 0 ||
1155                                    t_DRMHeader->XmlSize > ROXML_MAXSIZE, TADC_PARAMETER_ERROR);
1156
1157         ReqTemp = (TADC_U8 *)TADC_IF_Malloc(t_DRMHeader->XmlSize);
1158         IF_TRUE_RETURN(ReqTemp == NULL, TADC_MEMAlOC_ERROR);
1159
1160         TADC_IF_MemSet(ReqTemp, 0, t_DRMHeader->XmlSize);
1161         TADC_IF_MemSet(sha1_tmp, 0, sizeof(sha1_tmp));
1162
1163         //Get HMAC
1164         TADC_IF_MemCpy(ReqTemp, inBuffer + 20, t_DRMHeader->XmlSize);
1165         TADC_IF_SHA1(ReqTemp, t_DRMHeader->XmlSize, sha1_tmp);
1166
1167         if (ReqTemp != NULL) {
1168                 TADC_IF_Free(ReqTemp);
1169                 ReqTemp = NULL;
1170         }
1171
1172         TADC_IF_MemCpy(key, &g_baSignatureKey[0], 16);
1173         TADC_IF_MemCpy(iv, &g_baSignatureKey[16], 16);
1174         TADC_IF_AES_CTR(key, 16, iv, 20, (unsigned char *)sha1_tmp, &outlen,
1175                                         (unsigned char *)sha1_tmp);
1176
1177         if (TADC_IF_MemCmp(sha1_tmp, inBuffer, sizeof(sha1_tmp))) {
1178                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSHMAC_ERROR);
1179                 return -1;
1180         }
1181
1182         //Load XML Header
1183         nResult = oXMLFile.LoadFromStream((LPCTSTR)(inBuffer + 20));
1184
1185         if (nResult != 0) {
1186                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSXML_ERROR);
1187                 goto finish;
1188         }
1189
1190         pRoot = oXMLFile.GetRoot();
1191         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1192
1193         paChilds.RemoveAll();
1194         nResult = pRoot->Find(&paChilds, _T("SID"), NULL);
1195
1196         if (nResult == 0) {
1197                 if (paChilds.GetCount() == 1) {
1198                         pNode = (CXMLElement *)paChilds.Get(0);
1199                         pszValue = pNode->GetValue();
1200                         Length = TADC_IF_StrLen((char *)pszValue);
1201
1202                         if (Length > 0) {
1203                                 t_DRMHeader->SID = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1204                                 IF_TRUE_RETURN(t_DRMHeader->SID == NULL, TADC_MEMAlOC_ERROR);
1205                                 TADC_IF_MemSet(t_DRMHeader->SID, 0, Length + 1);
1206                                 TADC_IF_StrNCpy((CHAR *)t_DRMHeader->SID, pszValue, Length + 1);
1207                         }
1208                 }
1209         }
1210
1211         pRoot = oXMLFile.GetRoot();
1212         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1213
1214         paChilds.RemoveAll();
1215         nResult = pRoot->Find(&paChilds, _T("CID"), NULL);
1216
1217         if (nResult == 0) {
1218                 if (paChilds.GetCount() == 1) {
1219                         pNode = (CXMLElement *)paChilds.Get(0);
1220                         pszValue = pNode->GetValue();
1221                         Length = TADC_IF_StrLen((char *)pszValue);
1222
1223                         if (Length > 0) {
1224                                 t_DRMHeader->CID = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1225                                 IF_TRUE_RETURN(t_DRMHeader->CID == NULL, TADC_MEMAlOC_ERROR);
1226                                 TADC_IF_MemSet(t_DRMHeader->CID, 0, Length + 1);
1227                                 TADC_IF_StrNCpy((CHAR *)t_DRMHeader->CID, pszValue, Length + 1);
1228                         }
1229                 }
1230         }
1231
1232         pRoot = oXMLFile.GetRoot();
1233         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1234         paChilds.RemoveAll();
1235         nResult = pRoot->Find(&paChilds, _T("ContentType"), NULL);
1236
1237         if (nResult == 0) {
1238                 if (paChilds.GetCount() == 1) {
1239                         pNode = (CXMLElement *)paChilds.Get(0);
1240                         pszValue = pNode->GetValue();
1241                         Length = TADC_IF_StrLen((char *)pszValue);
1242                         if (Length > 0) {
1243                                 TADC_IF_MemSet(t_DRMHeader->ContentsType, 0, 128);
1244                                 TADC_IF_StrNCpy((CHAR *)t_DRMHeader->ContentsType, pszValue, Length + 1);
1245                         }
1246                 }
1247         }
1248
1249         pRoot = oXMLFile.GetRoot();
1250         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1251         paChilds.RemoveAll();
1252         nResult = pRoot->Find(&paChilds, _T("EncryptionMethod"), NULL);
1253
1254         if (nResult == 0) {
1255                 if (paChilds.GetCount() == 1) {
1256                         pNode = (CXMLElement *)paChilds.Get(0);
1257                         pszValue = pNode->GetValue();
1258                         t_DRMHeader->EncryptionMethod = TADC_IF_AtoI((char *)pszValue);
1259                 }
1260         }
1261
1262         pRoot = oXMLFile.GetRoot();
1263         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1264         paChilds.RemoveAll();
1265         nResult = pRoot->Find(&paChilds, _T("EncryptionLevel"), NULL);
1266
1267         if (nResult == 0) {
1268                 if (paChilds.GetCount() == 1) {
1269                         pNode = (CXMLElement *)paChilds.Get(0);
1270                         pszValue = pNode->GetValue();
1271                         t_DRMHeader->EncryptionLevel = TADC_IF_AtoI((char *)pszValue);
1272                 }
1273         }
1274
1275         pRoot = oXMLFile.GetRoot();
1276         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1277         paChilds.RemoveAll();
1278         nResult = pRoot->Find(&paChilds, _T("EncryptionRange"), NULL);
1279
1280         if (nResult == 0) {
1281                 if (paChilds.GetCount() == 1) {
1282                         pNode = (CXMLElement *)paChilds.Get(0);
1283                         pszValue = pNode->GetValue();
1284                         t_DRMHeader->EncryptionRange = TADC_IF_AtoI((char *)pszValue);
1285                 }
1286         }
1287
1288         pRoot = oXMLFile.GetRoot();
1289         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1290         paChilds.RemoveAll();
1291         nResult = pRoot->Find(&paChilds, _T("RIURL"), NULL);
1292
1293         if (nResult == 0) {
1294                 if (paChilds.GetCount() == 1) {
1295                         pNode = (CXMLElement *)paChilds.Get(0);
1296                         pszValue = pNode->GetValue();
1297                         Length = TADC_IF_StrLen((char *)pszValue);
1298
1299                         if (Length > 0) {
1300                                 t_DRMHeader->RIURL = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1301                                 IF_TRUE_RETURN(t_DRMHeader->RIURL == NULL, TADC_MEMAlOC_ERROR);
1302                                 TADC_IF_MemSet(t_DRMHeader->RIURL, 0, Length + 1);
1303                                 TADC_IF_StrNCpy((CHAR *)t_DRMHeader->RIURL, pszValue, Length + 1);
1304                         }
1305                 }
1306         }
1307
1308         // dummy RIURL(DRM Server spec changed)
1309         if (t_DRMHeader->RIURL == NULL) {
1310                 pszValue = "dummy_riurl";
1311                 Length = TADC_IF_StrLen(pszValue);
1312                 t_DRMHeader->RIURL = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1313                 IF_TRUE_RETURN(t_DRMHeader->RIURL == NULL, TADC_MEMAlOC_ERROR);
1314                 TADC_IF_MemSet(t_DRMHeader->RIURL, 0, Length + 1);
1315                 TADC_IF_StrNCpy((CHAR *)t_DRMHeader->RIURL, pszValue, Length + 1);
1316         }
1317
1318         DRM_TAPPS_LOG("t_DRMHeader->RIURL = %s\n", (char *)t_DRMHeader->RIURL);
1319
1320         pRoot = oXMLFile.GetRoot();
1321         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1322         paChilds.RemoveAll();
1323         nResult = pRoot->Find(&paChilds, _T("PlaintextSize"), NULL);
1324
1325         if (nResult == 0) {
1326                 if (paChilds.GetCount() == 1) {
1327                         pNode = (CXMLElement *)paChilds.Get(0);
1328                         pszValue = pNode->GetValue();
1329                         t_DRMHeader->PlaintextSize = TADC_IF_AtoI((char *)pszValue);
1330                 }
1331         }
1332
1333         pRoot = oXMLFile.GetRoot();
1334         IF_TRUE_GOTO(pRoot == NULL, ERROR_INVALID_DATA);
1335         paChilds.RemoveAll();
1336         nResult = pRoot->Find(&paChilds, _T("Packdate"), NULL);
1337
1338         if (nResult == 0) {
1339                 if (paChilds.GetCount() == 1) {
1340                         pNode = (CXMLElement *)paChilds.Get(0);
1341                         pszValue = pNode->GetValue();
1342                         Length = TADC_IF_StrLen((char *)pszValue);
1343
1344                         if (Length > 0) {
1345                                 t_DRMHeader->Packdate = (TADC_U8 *)TADC_IF_Malloc(Length + 1);
1346                                 IF_TRUE_RETURN(t_DRMHeader->Packdate == NULL, TADC_MEMAlOC_ERROR);
1347                                 TADC_IF_MemSet(t_DRMHeader->Packdate, 0, Length + 1);
1348                                 TADC_IF_StrNCpy((char *)t_DRMHeader->Packdate, pszValue, Length + 1);
1349                         }
1350                 }
1351         }
1352
1353 finish:
1354
1355         if (nResult != 0) {
1356                 DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_CONTENTSXML_ERROR);
1357                 STACKTRACE(_T("CNCG20File::_ParseHeader()"));
1358         }
1359
1360         DRM_TAPPS_LOG("TADC_GetDRMHeaderInfo Success! \n");
1361         return nResult;
1362 }
1363
1364 int TADC_GetCEK(T_DEVICE_INFO *t_DeviceInfo, T_RO *t_RODB,
1365                                 T_DRM_HEADER *t_DRMHeader)
1366 {
1367         int length1 = 0;
1368
1369         //Check Parameter Buffer
1370         IF_TRUE_RETURN(t_DeviceInfo == NULL, TADC_PARAMETER_ERROR);
1371         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1372         IF_TRUE_RETURN(t_DRMHeader->CID == NULL, TADC_PARAMETER_ERROR);
1373         IF_TRUE_RETURN(t_RODB == NULL, TADC_PARAMETER_ERROR);
1374         IF_TRUE_RETURN(t_RODB->t_Content.CID == NULL, TADC_PARAMETER_ERROR);
1375
1376         if (!TADC_IF_StrCmp((char *)t_DRMHeader->CID, (char *)t_RODB->t_Content.CID)) {
1377                 if ((t_RODB->PerFlag & DUID_RULE) &&
1378                                 (t_RODB->t_Permission.t_Individual.BindingType & DUID_RULE)) {
1379                         IF_TRUE_RETURN(t_RODB->t_Permission.t_Individual.DUID == NULL,
1380                                                    TADC_PARAMETER_ERROR);
1381                         length1 = TADC_IF_StrLen((char *)t_DeviceInfo->DUID);
1382                         DRM_TAPPS_LOG(
1383                                 "t_DeviceInfo->DUID = %s, "
1384                                 "t_RODB->t_Permission.t_Individual.DUID is %s, "
1385                                 "length1 is %d\n",
1386                                 t_DeviceInfo->DUID, t_RODB->t_Permission.t_Individual.DUID, length1);
1387                         /*if (TADC_IF_MemCmp(t_DeviceInfo->DUID,
1388                          *                   t_RODB->t_Permission.t_Individual.DUID, length1)) {
1389                             DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x",
1390                                                 TADC_RULE_DUID_ERROR);
1391                             return -1;
1392                         }*/
1393                 }
1394
1395                 IF_TRUE_RETURN(t_RODB->t_Content.CEK == NULL, TADC_PARAMETER_ERROR);
1396                 t_DRMHeader->CEK = (TADC_U8 *)TADC_IF_Malloc(CEK_SIZE + 1);
1397                 IF_TRUE_RETURN(t_DRMHeader->CEK == NULL, TADC_MEMAlOC_ERROR);
1398                 TADC_IF_MemSet(t_DRMHeader->CEK, 0, CEK_SIZE + 1);
1399                 TADC_IF_MemCpy(t_DRMHeader->CEK, t_RODB->t_Content.CEK, CEK_SIZE);
1400
1401                 DRM_TAPPS_LOG("TADC_GetCEK Success!\n");
1402                 return 0;
1403         }
1404
1405         DRM_TAPPS_EXCEPTION("TADC_IF_MemCmp Error Code = %x", TADC_RULE_NOINFOMATION);
1406
1407         return -1;
1408 }
1409
1410 int TADC_DecryptBlock(char *pbBuffer, int nSize,
1411                                           const T_DRM_HEADER *t_DRMHeader)
1412 {
1413         TADC_U8 key[16] = {0, };
1414         TADC_U8 iv[16] = {0, };
1415         int i = 0, nBlocks = 0, nIndex = 0;
1416         char baToBeEncrypted[32] = {0, };
1417         int nRemainBytes = 0, nBlockBytes = 0;
1418
1419         int nEncryptionLevel = 0;
1420         int nEncryptionMethod = 0;
1421
1422         char temp[512] = {0, };
1423         int length = 0;
1424         int totlength = 0;
1425
1426         TADC_IF_MemSet(temp, 0, sizeof(temp));
1427
1428         IF_TRUE_RETURN(pbBuffer == NULL, TADC_PARAMETER_ERROR);
1429         IF_TRUE_RETURN(t_DRMHeader == NULL, TADC_PARAMETER_ERROR);
1430
1431         IF_TRUE_RETURN(nSize > 512, TADC_PARAMETER_ERROR);
1432         IF_TRUE_RETURN(t_DRMHeader->CEK == NULL, TADC_PARAMETER_ERROR);
1433
1434         nEncryptionLevel = t_DRMHeader->EncryptionLevel;
1435         nEncryptionMethod = t_DRMHeader->EncryptionMethod;
1436
1437         IF_TRUE_RETURN(nEncryptionMethod != 1, TADC_PARAMETER_ERROR);
1438         IF_TRUE_RETURN(nEncryptionLevel < 0 ||
1439                                    nEncryptionLevel > 32, TADC_PARAMETER_ERROR);
1440
1441         TADC_IF_MemSet(baToBeEncrypted, 1, 32);
1442
1443         if (nEncryptionLevel > 16)
1444                 nBlocks = 16;
1445         else
1446                 nBlocks = nEncryptionLevel;
1447
1448         for (i = 0; i < nBlocks; i++) {
1449                 nIndex = 31 - (i * 2);
1450                 baToBeEncrypted[nIndex] = 0;
1451         }
1452
1453         for (i = 16; i < nEncryptionLevel; i++) {
1454                 nIndex = 30 - ((i - 16) * 2);
1455                 baToBeEncrypted[nIndex] = 0;
1456         }
1457
1458         nRemainBytes = nSize;
1459         nBlockBytes = 16;
1460
1461         length = 0;
1462         totlength = 0;
1463
1464         for (i = 0; i < 32; i++) {
1465                 if (nRemainBytes < 16)
1466                         nBlockBytes = nRemainBytes;
1467
1468                 if (baToBeEncrypted[i] == 1) {
1469                         TADC_IF_MemCpy(temp + length, pbBuffer + totlength, nBlockBytes);
1470                         length += nBlockBytes;
1471                 }
1472
1473                 nRemainBytes -= nBlockBytes;
1474                 totlength += nBlockBytes;
1475
1476                 if (nRemainBytes < 1)
1477                         break;
1478         }
1479
1480         TADC_IF_MemCpy(key, &t_DRMHeader->CEK[0], 16);
1481         TADC_IF_MemCpy(iv, &t_DRMHeader->CEK[16], 16);
1482         TADC_IF_AES_CTR(key, 16, iv, length, (unsigned char *)temp, &length,
1483                                         (unsigned char *)temp);
1484
1485         nRemainBytes = nSize;
1486         nBlockBytes = 16;
1487
1488         length = 0;
1489         totlength = 0;
1490
1491         for (i = 0; i < 32; i++) {
1492                 if (nRemainBytes < 16)
1493                         nBlockBytes = nRemainBytes;
1494
1495                 if (baToBeEncrypted[i] == 1) {
1496                         TADC_IF_MemCpy(pbBuffer + totlength, temp + length, nBlockBytes);
1497                         length += nBlockBytes;
1498                 }
1499
1500                 nRemainBytes -= nBlockBytes;
1501                 totlength += nBlockBytes;
1502
1503                 if (nRemainBytes < 1) {
1504                         break;
1505                 }
1506         }
1507
1508         return 0;
1509 }
1510
1511 int TADC_GetDRMHeaderFromFile(const char *pTADCFilepath,
1512                                                           T_FILE_HEADER *t_FileHeader, T_DRM_HEADER *t_DRMHeader)
1513 {
1514         unsigned char tempbuf[512];
1515         unsigned char *pbuf = NULL;
1516
1517         int ret = 0;
1518         ULONG readsize = 0, ReadLen = 0;
1519
1520         FILE *hFile = 0; //Apps drm file
1521
1522         //null check
1523         if (pTADCFilepath == NULL || t_FileHeader == NULL || t_DRMHeader == NULL) {
1524                 DRM_TAPPS_EXCEPTION("Error : Parameter Null.");
1525                 return -1;
1526         }
1527
1528         //Init
1529         TADC_IF_MemSet(tempbuf, 0, sizeof(tempbuf));
1530
1531         //File Open
1532         if ((hFile = fopen(pTADCFilepath, "rb")) == NULL) {
1533                 DRM_TAPPS_EXCEPTION("Error : fopen() error.");
1534                 return -1;
1535         }
1536
1537         readsize = 256;
1538
1539         //FmReadFile(hFile, tempbuf, readsize, &ReadLen);
1540         ReadLen = fread(tempbuf, 1, readsize, hFile);
1541
1542         if ((readsize != ReadLen) ||
1543                         (ret = TADC_GetFileHeader(tempbuf, t_FileHeader)) < 0) {
1544                 DRM_TAPPS_EXCEPTION("Error : fread() error.");
1545                 fclose(hFile);
1546                 return -1;
1547         }
1548
1549         TADC_IF_MemSet(tempbuf, 0, sizeof(tempbuf));
1550
1551         //Tizen Apps DRM Type Check
1552         if (t_FileHeader->DRMType & TIZEN_DRM) {
1553                 DRM_TAPPS_LOG("It's a TAPPS DCF = %s", pTADCFilepath);
1554                 readsize = 15;
1555                 ReadLen = fread(tempbuf, 1, readsize, hFile);
1556
1557                 if ((readsize != ReadLen) ||
1558                                 (ret = TADC_GetDRMHeader(tempbuf, t_DRMHeader)) < 0) {
1559                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1560                         fclose(hFile);
1561                         return -1;
1562                 }
1563
1564                 readsize = 20 + t_DRMHeader->XmlSize;
1565
1566                 pbuf = (unsigned char *)TADC_IF_Malloc(readsize * sizeof(char));
1567
1568                 if (pbuf == NULL) {
1569                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1570                         fclose(hFile);
1571                         return -1;
1572                 }
1573
1574                 ReadLen = fread(pbuf, 1, readsize, hFile);
1575
1576                 if (readsize != ReadLen) {
1577                         DRM_TAPPS_EXCEPTION("Error : fread() error.");
1578                         TADC_IF_Free(pbuf);
1579                         fclose(hFile);
1580                         return -1;
1581                 }
1582
1583                 if (TADC_GetDRMHeaderInfo(pbuf, t_DRMHeader) < 0) {
1584                         DRM_TAPPS_EXCEPTION("Error : TADC_GetDRMHeaderInfo error.");
1585                         TADC_IF_Free(pbuf);
1586                         fclose(hFile);
1587                         return -1;
1588                 }
1589
1590                 TADC_IF_Free(pbuf);
1591         } else {
1592                 DRM_TAPPS_EXCEPTION("Error : It's not a TApps DCF file.");
1593                 fclose(hFile);
1594                 return -1;
1595         }
1596
1597         fclose(hFile);
1598         return 0;
1599 }
1600
1601 DWORD TADC_GetLastError(void)
1602 {
1603         DWORD dwError = g_TADCErrorCode;
1604         g_TADCErrorCode = 0;
1605
1606         return dwError;
1607 }
1608
1609 int TADC_MEMFree_RO(T_RO *t_ro)
1610 {
1611         IF_TRUE_RETURN(t_ro == NULL, TADC_PARAMETER_ERROR);
1612         t_ro->PerFlag = 0;
1613
1614         if (t_ro->t_Content.CID != NULL) {
1615                 TADC_IF_Free(t_ro->t_Content.CID);
1616                 t_ro->t_Content.CID = NULL;
1617         }
1618
1619         if (t_ro->t_Content.CEK != NULL) {
1620                 TADC_IF_Free(t_ro->t_Content.CEK);
1621                 t_ro->t_Content.CEK = NULL;
1622         }
1623
1624         if (t_ro->t_Permission.t_Individual.DUID != NULL) {
1625                 TADC_IF_Free(t_ro->t_Permission.t_Individual.DUID);
1626                 t_ro->t_Permission.t_Individual.DUID = NULL;
1627         }
1628
1629         return 0;
1630 }
1631
1632 int TADC_MEMFree_FileHeader(T_FILE_HEADER *t_FileHeader)
1633 {
1634         IF_TRUE_RETURN(t_FileHeader == NULL, TADC_PARAMETER_ERROR);
1635         TADC_IF_MemSet(t_FileHeader, 0, sizeof(T_FILE_HEADER));
1636
1637         return 0;
1638 }
1639
1640 int TADC_MEMFree_DRMHeader(T_DRM_HEADER *t_DrmHeader)
1641 {
1642         IF_TRUE_RETURN(t_DrmHeader == NULL, TADC_PARAMETER_ERROR);
1643         t_DrmHeader->XmlSize = 0;
1644         TADC_IF_MemSet(t_DrmHeader->Version, 0, sizeof(t_DrmHeader->Version));
1645
1646         if (t_DrmHeader->SID != NULL) {
1647                 TADC_IF_Free(t_DrmHeader->SID);
1648                 t_DrmHeader->SID = NULL;
1649         }
1650
1651         if (t_DrmHeader->CID != NULL) {
1652                 TADC_IF_Free(t_DrmHeader->CID);
1653                 t_DrmHeader->CID = NULL;
1654         }
1655
1656         TADC_IF_MemSet(t_DrmHeader->ContentsType, 0, sizeof(t_DrmHeader->ContentsType));
1657         t_DrmHeader->EncryptionRange = 0;
1658
1659         if (t_DrmHeader->RIURL != NULL) {
1660                 TADC_IF_Free(t_DrmHeader->RIURL);
1661                 t_DrmHeader->RIURL = NULL;
1662         }
1663
1664         t_DrmHeader->PlaintextSize = 0;
1665
1666         if (t_DrmHeader->Packdate != NULL) {
1667                 TADC_IF_Free(t_DrmHeader->Packdate);
1668                 t_DrmHeader->Packdate = NULL;
1669         }
1670
1671         if (t_DrmHeader->CEK != NULL) {
1672                 TADC_IF_Free(t_DrmHeader->CEK);
1673                 t_DrmHeader->CEK = NULL;
1674         }
1675
1676         return 0;
1677 }
1678
1679 int TADC_MEMFree_ROAcqInfo(T_ROACQ_INFO *t_ROAcqInfo)
1680 {
1681         IF_TRUE_RETURN(t_ROAcqInfo == NULL, TADC_PARAMETER_ERROR);
1682
1683         if (t_ROAcqInfo->ROAcqURL != NULL) {
1684                 TADC_IF_Free(t_ROAcqInfo->ROAcqURL);
1685                 t_ROAcqInfo->ROAcqURL = NULL;
1686         }
1687
1688         if (t_ROAcqInfo->ReqID != NULL) {
1689                 TADC_IF_Free(t_ROAcqInfo->ReqID);
1690                 t_ROAcqInfo->ReqID = NULL;
1691         }
1692
1693         TADC_IF_MemSet(&t_ROAcqInfo->t_DHInfo, 0, sizeof(T_DH_INFO));
1694         return 0;
1695 }