src/decss/VobFile.cpp

   1 #include "StdAfx.h"
   2 #include <io.h>
   3 #include "VobFile.h"
   4 #include "CSSauth.h"
   5 #include "CSSscramble.h"
   6 #include "udf.h"
   7
   8 //
   9 // CDVDSession
  10 //
  11
  12 CDVDSession::CDVDSession()
  13         : m_session(DVD_END_ALL_SESSIONS)
  14         , m_hDrive(INVALID_HANDLE_VALUE)
  15 {
  16 }
  17
  18 CDVDSession::~CDVDSession()
  19 {
  20         EndSession();
  21 }
  22
  23 bool CDVDSession::Open(LPCTSTR path)
  24 {
  25         Close();
  26
  27         CString fn = path;
  28         CString drive = _T("\\\\.\\") + fn.Left(fn.Find(':')+1);
  29
  30         m_hDrive = CreateFile(drive, GENERIC_READ, FILE_SHARE_READ, NULL,
  31                 OPEN_EXISTING, FILE_ATTRIBUTE_READONLY|FILE_FLAG_SEQUENTIAL_SCAN, (HANDLE)NULL);
  32         if(m_hDrive == INVALID_HANDLE_VALUE)
  33                 return(false);
  34
  35         return(true);
  36 }
  37
  38 void CDVDSession::Close()
  39 {
  40         if(m_hDrive != INVALID_HANDLE_VALUE)
  41         {
  42                 CloseHandle(m_hDrive);
  43                 m_hDrive = INVALID_HANDLE_VALUE;
  44         }
  45 }
  46
  47 bool CDVDSession::BeginSession()
  48 {
  49         EndSession();
  50
  51         if(m_hDrive == INVALID_HANDLE_VALUE)
  52                 return(false);
  53
  54         DWORD BytesReturned;
  55         if(!DeviceIoControl(m_hDrive, IOCTL_DVD_START_SESSION, NULL, 0, &m_session, sizeof(m_session), &BytesReturned, NULL))
  56         {
  57                 m_session = DVD_END_ALL_SESSIONS;
  58                 if(!DeviceIoControl(m_hDrive, IOCTL_DVD_END_SESSION, &m_session, sizeof(m_session), NULL, 0, &BytesReturned, NULL)
  59                 || !DeviceIoControl(m_hDrive, IOCTL_DVD_START_SESSION, NULL, 0, &m_session, sizeof(m_session), &BytesReturned, NULL))
  60                 {
  61                         CloseHandle(m_hDrive);
  62                         DWORD err = GetLastError();
  63                         return(false);
  64                 }
  65         }
  66
  67         return(true);
  68 }
  69
  70 void CDVDSession::EndSession()
  71 {
  72         if(m_session != DVD_END_ALL_SESSIONS)
  73         {
  74                 DWORD BytesReturned;
  75                 DeviceIoControl(m_hDrive, IOCTL_DVD_END_SESSION, &m_session, sizeof(m_session), NULL, 0, &BytesReturned, NULL);
  76         m_session = DVD_END_ALL_SESSIONS;
  77         }
  78 }
  79
  80 bool CDVDSession::Authenticate()
  81 {
  82         if(m_session == DVD_END_ALL_SESSIONS)
  83                 return(false);
  84
  85         BYTE Challenge[10], Key[10];
  86
  87         for(int i = 0; i < 10; i++) Challenge[i] = i;
  88
  89         if(!SendKey(DvdChallengeKey, Challenge))
  90                 return(false);
  91
  92         if(!ReadKey(DvdBusKey1, Key))
  93                 return(false);
  94
  95         int varient = -1;
  96
  97         for(int i = 31; i >= 0; i--)
  98         {
  99                 BYTE KeyCheck[5];
 100                 CSSkey1(i, Challenge, KeyCheck);
 101                 if(!memcmp(KeyCheck, Key, 5))
 102                         varient = i;
 103         }
 104
 105         if(!ReadKey(DvdChallengeKey, Challenge))
 106                 return(false);
 107
 108         CSSkey2(varient, Challenge, &Key[5]);
 109
 110         if(!SendKey(DvdBusKey2, &Key[5]))
 111                 return(false);
 112
 113         CSSbuskey(varient, Key, m_SessionKey);
 114
 115         return(true);
 116 }
 117
 118 bool CDVDSession::GetDiscKey()
 119 {
 120         if(m_session == DVD_END_ALL_SESSIONS)
 121                 return(false);
 122
 123         BYTE DiscKeys[2048];
 124         if(!ReadKey(DvdDiskKey, DiscKeys))
 125                 return(false);
 126
 127         for(int i = 0; i < g_nPlayerKeys; i++)
 128         {
 129                 for(int j = 1; j < 409; j++)
 130                 {
 131                         BYTE DiscKey[6];
 132                         memcpy(DiscKey, &DiscKeys[j*5], 5);
 133                         DiscKey[5] = 0;
 134
 135                         CSSdisckey(DiscKey, g_PlayerKeys[i]);
 136
 137                         BYTE Hash[6];
 138                         memcpy(Hash, &DiscKeys[0], 5);
 139                         Hash[5] = 0;
 140
 141                         CSSdisckey(Hash, DiscKey);
 142
 143                         if(!memcmp(Hash, DiscKey, 6))
 144                         {
 145                                 memcpy(m_DiscKey, DiscKey, 6);
 146                                 return(true);
 147                         }
 148                 }
 149         }
 150
 151         return(false);
 152 }
 153
 154 bool CDVDSession::GetTitleKey(int lba, BYTE* pKey)
 155 {
 156         if(m_session == DVD_END_ALL_SESSIONS)
 157                 return(false);
 158
 159         if(!ReadKey(DvdTitleKey, pKey, lba))
 160                 return(false);
 161
 162         if(!(pKey[0]|pKey[1]|pKey[2]|pKey[3]|pKey[4]))
 163                 return(false);
 164
 165         pKey[5] = 0;
 166
 167         CSStitlekey(pKey, m_DiscKey);
 168
 169         return(true);
 170 }
 171
 172 static void Reverse(BYTE* d, BYTE* s, int len)
 173 {
 174         if(d == s)
 175         {
 176                 for(s += len-1; d < s; d++, s--)
 177                         *d ^= *s, *s ^= *d, *d ^= *s;
 178         }
 179         else
 180         {
 181                 for(int i = 0; i < len; i++)
 182                         d[i] = s[len-1 - i];
 183         }
 184 }
 185
 186 bool CDVDSession::SendKey(DVD_KEY_TYPE KeyType, BYTE* pKeyData)
 187 {
 188         CAutoPtr<DVD_COPY_PROTECT_KEY> key;
 189
 190         switch(KeyType)
 191         {
 192                 case DvdChallengeKey:
 193                         key.Attach((DVD_COPY_PROTECT_KEY*)new BYTE[DVD_CHALLENGE_KEY_LENGTH]);
 194                         key->KeyLength = DVD_CHALLENGE_KEY_LENGTH;
 195                         Reverse(key->KeyData, pKeyData, 10);
 196                         break;
 197                 case DvdBusKey2:
 198                         key.Attach((DVD_COPY_PROTECT_KEY*)new BYTE[DVD_BUS_KEY_LENGTH]);
 199                         key->KeyLength = DVD_BUS_KEY_LENGTH;
 200                         Reverse(key->KeyData, pKeyData, 5);
 201                         break;
 202                 default:
 203                         break;
 204         }
 205
 206         if(!key)
 207                 return(false);
 208
 209         key->SessionId = m_session;
 210         key->KeyType = KeyType;
 211         key->KeyFlags = 0;
 212
 213         DWORD BytesReturned;
 214         return(!!DeviceIoControl(m_hDrive, IOCTL_DVD_SEND_KEY, key, key->KeyLength, NULL, 0, &BytesReturned, NULL));
 215 }
 216
 217 bool CDVDSession::ReadKey(DVD_KEY_TYPE KeyType, BYTE* pKeyData, int lba)
 218 {
 219         CAutoPtr<DVD_COPY_PROTECT_KEY> key;
 220
 221         switch(KeyType)
 222         {
 223                 case DvdChallengeKey:
 224                         key.Attach((DVD_COPY_PROTECT_KEY*)new BYTE[DVD_CHALLENGE_KEY_LENGTH]);
 225                         key->KeyLength = DVD_CHALLENGE_KEY_LENGTH;
 226                         key->Parameters.TitleOffset.QuadPart = 0;
 227                         break;
 228                 case DvdBusKey1:
 229                         key.Attach((DVD_COPY_PROTECT_KEY*)new BYTE[DVD_BUS_KEY_LENGTH]);
 230                         key->KeyLength = DVD_BUS_KEY_LENGTH;
 231                         key->Parameters.TitleOffset.QuadPart = 0;
 232                         break;
 233                 case DvdDiskKey:
 234                         key.Attach((DVD_COPY_PROTECT_KEY*)new BYTE[DVD_DISK_KEY_LENGTH]);
 235                         key->KeyLength = DVD_DISK_KEY_LENGTH;
 236                         key->Parameters.TitleOffset.QuadPart = 0;
 237                         break;
 238                 case DvdTitleKey:
 239                         key.Attach((DVD_COPY_PROTECT_KEY*)new BYTE[DVD_TITLE_KEY_LENGTH]);
 240                         key->KeyLength = DVD_TITLE_KEY_LENGTH;
 241                         key->Parameters.TitleOffset.QuadPart = 2048i64*lba;
 242                         break;
 243                 default:
 244                         break;
 245         }
 246
 247         if(!key)
 248                 return(false);
 249
 250         key->SessionId = m_session;
 251         key->KeyType = KeyType;
 252         key->KeyFlags = 0;
 253
 254         DWORD BytesReturned;
 255         if(!DeviceIoControl(m_hDrive, IOCTL_DVD_READ_KEY, key, key->KeyLength, key, key->KeyLength, &BytesReturned, NULL))
 256         {
 257                 DWORD err = GetLastError();
 258                 return(false);
 259         }
 260
 261         switch(KeyType)
 262         {
 263                 case DvdChallengeKey:
 264                         Reverse(pKeyData, key->KeyData, 10);
 265                         break;
 266                 case DvdBusKey1:
 267                         Reverse(pKeyData, key->KeyData, 5);
 268                         break;
 269                 case DvdDiskKey:
 270                         memcpy(pKeyData, key->KeyData, 2048);
 271                         for(int i = 0; i < 2048/5; i++)
 272                                 pKeyData[i] ^= m_SessionKey[4-(i%5)];
 273                         break;
 274                 case DvdTitleKey:
 275                         memcpy(pKeyData, key->KeyData, 5);
 276                         for(int i = 0; i < 5; i++)
 277                                 pKeyData[i] ^= m_SessionKey[4-(i%5)];
 278                         break;
 279                 default:
 280                         break;
 281         }
 282
 283         return(true);
 284 }
 285
 286 //
 287 // CLBAFile
 288 //
 289
 290 CLBAFile::CLBAFile()
 291 {
 292 }
 293
 294 CLBAFile::~CLBAFile()
 295 {
 296 }
 297
 298 bool CLBAFile::IsOpen()
 299 {
 300         return(m_hFile != hFileNull);
 301 }
 302
 303 bool CLBAFile::Open(LPCTSTR path)
 304 {
 305         Close();
 306
 307         return(!!CFile::Open(path, modeRead|typeBinary|shareDenyWrite|osSequentialScan));
 308 }
 309
 310 void CLBAFile::Close()
 311 {
 312         if(m_hFile != hFileNull)
 313                 CFile::Close();
 314 }
 315
 316 int CLBAFile::GetLength()
 317 {
 318         return (int)(CFile::GetLength()/2048);
 319 }
 320
 321 int CLBAFile::GetPosition()
 322 {
 323         return (int)(CFile::GetPosition()/2048);
 324 }
 325
 326 int CLBAFile::Seek(int lba)
 327 {
 328         return (int)(CFile::Seek(2048i64*lba, CFile::begin)/2048);
 329 }
 330
 331 bool CLBAFile::Read(BYTE* buff)
 332 {
 333         return CFile::Read(buff, 2048) == 2048;
 334 }
 335
 336 //
 337 // CVobFile
 338 //
 339
 340 CVobFile::CVobFile()
 341 {
 342         Close();
 343 }
 344
 345 CVobFile::~CVobFile()
 346 {
 347 }
 348
 349 bool CVobFile::IsDVD()
 350 {
 351         return m_fDVD;
 352 }
 353
 354 bool CVobFile::HasDiscKey(BYTE* key)
 355 {
 356         if(key) memcpy(key, m_DiscKey, 5);
 357         return m_fHasDiscKey;
 358 }
 359
 360 bool CVobFile::HasTitleKey(BYTE* key)
 361 {
 362         if(key) memcpy(key, m_TitleKey, 5);
 363         return m_fHasTitleKey;
 364 }
 365
 366 bool CVobFile::Open(CString fn, CAtlList<CString>& vobs)
 367 {
 368         CFile f;
 369         if(!f.Open(fn, CFile::modeRead|CFile::typeBinary|CFile::shareDenyWrite))
 370                 return(false);
 371
 372         char hdr[13];
 373         f.Read(hdr, 12);
 374         hdr[12] = 0;
 375         if(strcmp(hdr, "DVDVIDEO-VTS"))
 376                 return(false);
 377
 378         f.Close();
 379
 380         int offset = -1;
 381
 382         vobs.RemoveAll();
 383
 384         fn = fn.Left(fn.ReverseFind('.')+1);
 385         fn.TrimRight(_T(".0123456789"));
 386         for(int i = 0; i < 100; i++)
 387         {
 388                 CString vob;
 389                 vob.Format(_T("%s%d.vob"), fn, i);
 390
 391                 CFileStatus status;
 392                 if(!CFile::GetStatus(vob, status))
 393                 {
 394                         if(i == 0) continue;
 395                         else break;
 396                 }
 397
 398                 if(status.m_size&0x7ff)
 399                 {
 400                         vobs.RemoveAll();
 401                         break;
 402                 }
 403
 404                 if(status.m_size > 0)
 405                         vobs.AddTail(vob);
 406
 407                 if(i == 0)
 408                         offset = (int)(status.m_size/0x800);
 409         }
 410
 411         return Open(vobs, offset);
 412 }
 413
 414 bool CVobFile::Open(CAtlList<CString>& vobs, int offset)
 415 {
 416         Close();
 417
 418         if(vobs.GetCount() == 0)
 419                 return(false);
 420
 421         if(vobs.GetCount() == 1)
 422                 offset = -1;
 423
 424         m_offset = offset;
 425
 426         POSITION pos = vobs.GetHeadPosition();
 427         while(pos)
 428         {
 429                 CString fn = vobs.GetNext(pos);
 430
 431                 WIN32_FIND_DATA fd;
 432                 HANDLE h = FindFirstFile(fn, &fd);
 433                 if(h == INVALID_HANDLE_VALUE)
 434                 {
 435                         m_files.RemoveAll();
 436                         return(false);
 437                 }
 438                 FindClose(h);
 439
 440                 file_t f;
 441                 f.fn = fn;
 442                 f.size = (int)(((__int64(fd.nFileSizeHigh)<<32)|fd.nFileSizeLow)/2048);
 443                 m_files.Add(f);
 444
 445                 m_size += f.size;
 446         }
 447
 448         if(m_files.GetCount() > 0 && CDVDSession::Open(m_files[0].fn))
 449         {
 450                 for(int i = 0; !m_fHasTitleKey && i < m_files.GetCount(); i++)
 451                 {
 452                         if(BeginSession())
 453                         {
 454                                 m_fDVD = true;
 455                                 Authenticate();
 456                                 m_fHasDiscKey = GetDiscKey();
 457                                 EndSession();
 458                         }
 459                         else
 460                         {
 461                                 CString fn = m_files[0].fn;
 462                                 fn.MakeLower();
 463
 464                                 if(fn.Find(_T(":\\video_ts")) == 1 && GetDriveType(fn.Left(3)) == DRIVE_CDROM)
 465                                 {
 466                                         m_fDVD = true;
 467                                 }
 468
 469                                 break;
 470                         }
 471
 472                         if(tp_udf_file f = udf_find_file(m_hDrive, 0, CStringA(m_files[i].fn.Mid(m_files[i].fn.Find(':')+1))))
 473                         {
 474                                 DWORD start, end;
 475                                 if(udf_get_lba(m_hDrive, f, &start, &end))
 476                                 {
 477                                         if(BeginSession())
 478                                         {
 479                                                 Authenticate();
 480                                                 m_fHasTitleKey = GetTitleKey(start + f->partition_lba, m_TitleKey);
 481                                                 EndSession();
 482                                         }
 483                                 }
 484
 485                                 udf_free(f);
 486                         }
 487
 488                         BYTE key[5];
 489                         if(HasTitleKey(key) && i == 0 && offset >= 0)
 490                         {
 491                                 i++;
 492
 493                                 if(BeginSession())
 494                                 {
 495                                         m_fDVD = true;
 496                                         Authenticate();
 497                                         m_fHasDiscKey = GetDiscKey();
 498                                         EndSession();
 499                                 }
 500                                 else
 501                                 {
 502                                         break;
 503                                 }
 504
 505                                 if(tp_udf_file f = udf_find_file(m_hDrive, 0, CStringA(m_files[i].fn.Mid(m_files[i].fn.Find(':')+1))))
 506                                 {
 507                                         DWORD start, end;
 508                                         if(udf_get_lba(m_hDrive, f, &start, &end))
 509                                         {
 510                                                 if(BeginSession())
 511                                                 {
 512                                                         Authenticate();
 513                                                         m_fHasTitleKey = GetTitleKey(start + f->partition_lba, m_TitleKey);
 514                                                         EndSession();
 515                                                 }
 516                                         }
 517
 518                                         udf_free(f);
 519                                 }
 520
 521                                 if(!m_fHasTitleKey)
 522                                 {
 523                                         memcpy(m_TitleKey, key, 5);
 524                                         m_fHasTitleKey = true;
 525                                 }
 526                         }
 527                 }
 528         }
 529 /*
 530         if(m_files.GetCount() > 0 && !m_fDVD)
 531         {
 532                 CString fn = m_files[0].fn;
 533                 fn.MakeLower();
 534
 535                 if(fn.Find(_T(":\\video_ts")) == 1 && GetDriveType(fn.Left(3)) == DRIVE_CDROM)
 536                 {
 537                         m_fDVD = true;
 538                 }
 539         }
 540 */
 541         m_offset = max(offset, 0);
 542
 543         return(true);
 544 }
 545
 546 void CVobFile::Close()
 547 {
 548         CDVDSession::Close();
 549         m_files.RemoveAll();
 550         m_iFile = -1;
 551         m_pos = m_size = m_offset = 0;
 552         m_file.Close();
 553         m_fDVD = m_fHasDiscKey = m_fHasTitleKey = false;
 554 }
 555
 556 int CVobFile::GetLength()
 557 {
 558         return(m_size - m_offset);
 559 }
 560
 561 int CVobFile::GetPosition()
 562 {
 563         return(m_pos - m_offset);
 564 }
 565
 566 int CVobFile::Seek(int pos)
 567 {
 568         pos = min(max(pos+m_offset, m_offset), m_size-1);
 569
 570         int i = -1;
 571         int size = 0;
 572
 573         // this suxx, but won't take long
 574         do size += m_files[++i].size;
 575         while(i < m_files.GetCount() && pos >= size);
 576
 577         if(i != m_iFile && i < m_files.GetCount())
 578         {
 579                 if(!m_file.Open(m_files[i].fn))
 580                         return(m_pos);
 581
 582                 m_iFile = i;
 583         }
 584
 585         m_pos = pos;
 586
 587         pos -= (size - m_files[i].size);
 588         m_file.Seek(pos);
 589
 590         return(GetPosition());
 591 }
 592
 593 bool CVobFile::Read(BYTE* buff)
 594 {
 595         if(m_pos >= m_size) return(false);
 596
 597         if(m_file.IsOpen() && m_file.GetPosition() == m_file.GetLength())
 598         {
 599                 m_file.Close();
 600         }
 601
 602         if(!m_file.IsOpen())
 603         {
 604                 if(m_iFile >= m_files.GetCount()-1)
 605                 {
 606                         return(false);
 607                 }
 608
 609                 if(!m_file.Open(m_files[++m_iFile].fn))
 610                 {
 611                         m_iFile = -1;
 612                         return(false);
 613                 }
 614         }
 615
 616         if(!m_file.Read(buff))
 617         {
 618                 // dvd still locked?
 619                 return(false);
 620         }
 621
 622         m_pos++;
 623
 624         if(buff[0x14] & 0x30)
 625         {
 626                 if(m_fHasTitleKey)
 627                 {
 628                         CSSdescramble(buff, m_TitleKey);
 629                         buff[0x14] &= ~0x30;
 630                 }
 631                 else
 632                 {
 633                         // under win9x this is normal, but I'm not developing under win9x :P
 634                         ASSERT(0);
 635                 }
 636         }
 637
 638         return(true);
 639 }