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