mirror of
https://github.com/SabreTools/BinaryObjectScanner.git
synced 2026-02-13 21:31:04 +00:00
546 lines
22 KiB
C#
546 lines
22 KiB
C#
//this file is part of BurnOut
|
|
//Copyright (C)2005-2010 Gernot Knippen
|
|
//Ported code with augments Copyright (C)2018 Matt Nadareski
|
|
//
|
|
//This program is free software; you can redistribute it and/or
|
|
//modify it under the terms of the GNU General Public License
|
|
//as published by the Free Software Foundation; either
|
|
//version 2 of the License, or (at your option) any later version.
|
|
//
|
|
//This program is distributed in the hope that it will be useful,
|
|
//but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
//GNU General Public License for more details.
|
|
//
|
|
//You can get a copy of the GNU General Public License
|
|
//by writing to the Free Software
|
|
//Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using BurnOutSharp.FileType;
|
|
using BurnOutSharp.ProtectionType;
|
|
|
|
namespace BurnOutSharp
|
|
{
|
|
public static class ProtectionFind
|
|
{
|
|
/// <summary>
|
|
/// Progress indicator
|
|
/// </summary>
|
|
private static IProgress<FileProtection> FileProgress = null;
|
|
|
|
/// <summary>
|
|
/// Scan a path to find any known copy protection(s)
|
|
/// </summary>
|
|
/// <param name="path">Path to scan for protection(s)</param>
|
|
/// <param name="includePosition">True to include scanned copy protection position, false otherwise (default)</param>
|
|
/// <param name="progress">Optional progress indicator that will return a float in the range from 0 to 1</param>
|
|
/// <returns>Dictionary of filename to protection mappings, if possible</returns>
|
|
public static Dictionary<string, string> Scan(string path, bool includePosition = false, IProgress<FileProtection> progress = null)
|
|
{
|
|
// Set the progress indicator, if it's not set already
|
|
if (FileProgress == null)
|
|
FileProgress = progress;
|
|
|
|
// Initialize the protections dictionary
|
|
var protections = new Dictionary<string, string>();
|
|
|
|
// Checkpoint
|
|
FileProgress?.Report(new FileProtection(null, 0, null));
|
|
|
|
// Temp variables for reporting
|
|
string tempFilePath = Path.GetTempPath();
|
|
string tempFilePathWithGuid = Path.Combine(tempFilePath, Guid.NewGuid().ToString());
|
|
|
|
// If we have a file
|
|
if (File.Exists(path))
|
|
{
|
|
// Get the reportable file name
|
|
string reportableFileName = path;
|
|
if (reportableFileName.StartsWith(tempFilePath))
|
|
reportableFileName = reportableFileName.Substring(tempFilePathWithGuid.Length);
|
|
|
|
// Checkpoint
|
|
FileProgress?.Report(new FileProtection(reportableFileName, 1, "Checking file" + (path != reportableFileName ? " from archive" : string.Empty)));
|
|
|
|
// Try using just the file first to get protection info
|
|
string fileProtection = ScanPath(path, false);
|
|
if (!string.IsNullOrWhiteSpace(fileProtection))
|
|
protections[path] = fileProtection;
|
|
|
|
// Now check to see if the file contains any additional information
|
|
string contentProtection = ScanContent(path, includePosition)?.Replace("" + (char)0x00, "");
|
|
if (!string.IsNullOrWhiteSpace(contentProtection))
|
|
{
|
|
if (protections.ContainsKey(path))
|
|
protections[path] += $", {contentProtection}";
|
|
else
|
|
protections[path] = contentProtection;
|
|
}
|
|
|
|
// Checkpoint
|
|
protections.TryGetValue(path, out string fullProtection);
|
|
FileProgress?.Report(new FileProtection(reportableFileName, 1, fullProtection ?? string.Empty));
|
|
}
|
|
// If we have a directory
|
|
else if (Directory.Exists(path))
|
|
{
|
|
// Get the lists of files to be used
|
|
var files = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories);
|
|
|
|
// Try using just the path first to get protection info
|
|
string pathProtection = ScanPath(path, true);
|
|
if (!string.IsNullOrWhiteSpace(pathProtection))
|
|
protections[path] = pathProtection;
|
|
|
|
// Loop through all files and scan their contents
|
|
for (int i = 0; i < files.Count(); i++)
|
|
{
|
|
// Get the current file
|
|
string file = files.ElementAt(i);
|
|
|
|
// Get the reportable file name
|
|
string reportableFileName = file;
|
|
if (reportableFileName.StartsWith(tempFilePath))
|
|
reportableFileName = reportableFileName.Substring(tempFilePathWithGuid.Length);
|
|
|
|
// Checkpoint
|
|
FileProgress?.Report(new FileProtection(reportableFileName, i / (float)files.Count(), "Checking file" + (file != reportableFileName ? " from archive" : string.Empty)));
|
|
|
|
// Try using just the file first to get protection info
|
|
string fileProtection = ScanPath(file, false);
|
|
if (!string.IsNullOrWhiteSpace(fileProtection))
|
|
protections[file] = fileProtection;
|
|
|
|
// Now check to see if the file contains any additional information
|
|
string contentProtection = ScanContent(file, includePosition)?.Replace("" + (char)0x00, "");
|
|
if (!string.IsNullOrWhiteSpace(contentProtection))
|
|
{
|
|
if (protections.ContainsKey(file))
|
|
protections[file] += $", {contentProtection}";
|
|
else
|
|
protections[file] = contentProtection;
|
|
}
|
|
|
|
// Checkpoint
|
|
protections.TryGetValue(file, out string fullProtection);
|
|
FileProgress?.Report(new FileProtection(reportableFileName, (i + 1) / (float)files.Count(), fullProtection ?? string.Empty));
|
|
}
|
|
}
|
|
|
|
// If we have an empty list, we need to take care of that
|
|
if (protections.Count(p => !string.IsNullOrWhiteSpace(p.Value)) == 0)
|
|
{
|
|
protections = new Dictionary<string, string>();
|
|
}
|
|
|
|
return protections;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scan a path for indications of copy protection
|
|
/// </summary>
|
|
/// <param name="path"></param>
|
|
/// <param name="isDirectory"></param>
|
|
/// <returns></returns>
|
|
public static string ScanPath(string path, bool isDirectory)
|
|
{
|
|
List<string> protections = new List<string>();
|
|
string protection;
|
|
|
|
// If we have a directory, get the files in the directory for searching
|
|
IEnumerable<string> files = null;
|
|
if (isDirectory)
|
|
files = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories);
|
|
|
|
// AACS
|
|
protection = AACS.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Alpha-DVD
|
|
protection = AlphaDVD.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Bitpool
|
|
protection = Bitpool.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// ByteShield
|
|
protection = ByteShield.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Cactus Data Shield
|
|
protection = CactusDataShield.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// CD-Cops
|
|
protection = CDCops.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// CD-Lock
|
|
protection = CDLock.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// CD-Protector
|
|
protection = CDProtector.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// CD-X
|
|
protection = CDX.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
/*
|
|
// CopyKiller
|
|
protection = CopyKiller.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
*/
|
|
|
|
// DiscGuard
|
|
protection = DiscGuard.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// DVD Crypt
|
|
protection = DVDCrypt.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// DVD-Movie-PROTECT
|
|
protection = DVDMoviePROTECT.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// FreeLock
|
|
protection = FreeLock.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Games for Windows - Live
|
|
protection = GFWL.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Hexalock AutoLock
|
|
protection = HexalockAutoLock.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Impulse Reactor
|
|
protection = ImpulseReactor.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// IndyVCD
|
|
protection = IndyVCD.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Key2Audio XS
|
|
protection = Key2AudioXS.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// LaserLock
|
|
protection = LaserLock.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// MediaCloQ
|
|
protection = MediaCloQ.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// MediaMax CD3
|
|
protection = MediaMaxCD3.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Origin
|
|
protection = Origin.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Protect DVD-Video
|
|
protection = ProtectDVDVideo.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SafeCast
|
|
protection = SafeCast.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SafeDisc
|
|
protection = SafeDisc.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SafeDisc Lite
|
|
protection = SafeDiscLite.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SafeLock
|
|
protection = SafeLock.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SecuROM
|
|
protection = SecuROM.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SmartE
|
|
protection = SmartE.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SoftLock
|
|
protection = SoftLock.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// SolidShield
|
|
protection = SolidShield.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// StarForce
|
|
protection = StarForce.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Steam
|
|
protection = Steam.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// TAGES
|
|
protection = Tages.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// TZCopyProtector
|
|
protection = TZCopyProtector.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Uplay
|
|
protection = Uplay.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// VOB ProtectCD/DVD
|
|
protection = VOBProtectCDDVD.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Winlock
|
|
protection = Winlock.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// WTM CD Protect
|
|
protection = WTMCDProtect.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// XCP
|
|
protection = XCP.CheckPath(path, files, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Zzxzz
|
|
protection = Zzxzz.CheckPath(path, isDirectory);
|
|
if (!string.IsNullOrWhiteSpace(protection))
|
|
protections.Add(protection);
|
|
|
|
// Now combine any found protections, or null if empty
|
|
if (protections.Count() == 0)
|
|
return null;
|
|
else
|
|
return string.Join(", ", protections);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scan an individual file for copy protection
|
|
/// </summary>
|
|
/// <param name="file">File path for scanning</param>
|
|
/// <param name="includePosition">True to include scanned copy protection position, false otherwise (default)</param>
|
|
public static string ScanContent(string file, bool includePosition = false)
|
|
{
|
|
using (FileStream fs = File.OpenRead(file))
|
|
{
|
|
return ScanContent(fs, file, includePosition);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scan an individual stream for copy protection
|
|
/// </summary>
|
|
/// <param name="stream">Generic stream to scan</param>
|
|
/// <param name="file">File path to be used for name checks (optional)</param>
|
|
/// <param name="includePosition">True to include scanned copy protection position, false otherwise (default)</param>
|
|
public static string ScanContent(Stream stream, string file = null, bool includePosition = false)
|
|
{
|
|
// Get the extension for certain checks
|
|
string extension = Path.GetExtension(file).ToLower().TrimStart('.');
|
|
|
|
// Assume the first part of the stream is the start of a file
|
|
byte[] magic = new byte[16];
|
|
try
|
|
{
|
|
stream.Read(magic, 0, 16);
|
|
stream.Seek(-16, SeekOrigin.Current);
|
|
}
|
|
catch
|
|
{
|
|
// We don't care what the issue was, we can't read or seek the file
|
|
return null;
|
|
}
|
|
|
|
// Files can be protected in multiple ways
|
|
List<string> protections = new List<string>();
|
|
|
|
// 7-Zip archive
|
|
if (SevenZip.ShouldScan(magic))
|
|
protections.AddRange(SevenZip.Scan(stream, includePosition));
|
|
|
|
// BFPK archive
|
|
if (BFPK.ShouldScan(magic))
|
|
protections.AddRange(BFPK.Scan(stream, includePosition));
|
|
|
|
// BZip2
|
|
if (BZip2.ShouldScan(magic))
|
|
protections.AddRange(BZip2.Scan(stream, includePosition));
|
|
|
|
// Executable
|
|
if (Executable.ShouldScan(magic))
|
|
protections.AddRange(Executable.Scan(stream, file, includePosition));
|
|
|
|
// GZIP
|
|
if (GZIP.ShouldScan(magic))
|
|
protections.AddRange(GZIP.Scan(stream, includePosition));
|
|
|
|
// InstallShield Cabinet
|
|
if (file != null && InstallShieldCAB.ShouldScan(magic))
|
|
protections.AddRange(InstallShieldCAB.Scan(file, includePosition));
|
|
|
|
// Microsoft Cabinet
|
|
if (file != null && MicrosoftCAB.ShouldScan(magic))
|
|
protections.AddRange(MicrosoftCAB.Scan(file, includePosition));
|
|
|
|
// MSI
|
|
if (file != null && MSI.ShouldScan(magic))
|
|
protections.AddRange(MSI.Scan(file, includePosition));
|
|
|
|
// MPQ archive
|
|
if (file != null && MPQ.ShouldScan(magic))
|
|
protections.AddRange(MPQ.Scan(file, includePosition));
|
|
|
|
// PKZIP archive (and derivatives)
|
|
if (PKZIP.ShouldScan(magic))
|
|
protections.AddRange(PKZIP.Scan(stream, includePosition));
|
|
|
|
// RAR archive
|
|
if (RAR.ShouldScan(magic))
|
|
protections.AddRange(RAR.Scan(stream, includePosition));
|
|
|
|
// Tape Archive
|
|
if (TapeArchive.ShouldScan(magic))
|
|
protections.AddRange(TapeArchive.Scan(stream, includePosition));
|
|
|
|
// Text-based files
|
|
if (Textfile.ShouldScan(magic, extension))
|
|
protections.AddRange(Textfile.Scan(stream, includePosition));
|
|
|
|
// Valve archive formats
|
|
if (file != null && Valve.ShouldScan(magic))
|
|
protections.AddRange(Valve.Scan(file, includePosition));
|
|
|
|
// XZ
|
|
if (XZ.ShouldScan(magic))
|
|
protections.AddRange(XZ.Scan(stream, includePosition));
|
|
|
|
// Return blank if nothing found, or comma-separated list of protections
|
|
if (protections.Count() == 0)
|
|
return string.Empty;
|
|
else
|
|
return string.Join(", ", protections);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scan a disc sector by sector for protection
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// https://stackoverflow.com/questions/8819188/c-sharp-classes-to-undelete-files/8820157#8820157
|
|
/// TODO: Finish implementation
|
|
/// </remarks>
|
|
private static string ScanSectors(char driveLetter, int sectorsize)
|
|
{
|
|
string fsName = Utilities.GetFileSystemName(driveLetter);
|
|
|
|
// Gets a handle to the physical disk
|
|
IntPtr hDisk = Utilities.CreateFile($"\\\\.\\{driveLetter}:",
|
|
FileAccess.Read,
|
|
FileShare.ReadWrite,
|
|
IntPtr.Zero,
|
|
FileMode.Open,
|
|
0,
|
|
IntPtr.Zero);
|
|
|
|
// If we have a good pointer
|
|
if (hDisk.ToInt32() != -1)
|
|
{
|
|
// Setup vars
|
|
byte[] buffer = new byte[sectorsize];
|
|
IntPtr pt = IntPtr.Zero;
|
|
NativeOverlapped no = new NativeOverlapped();
|
|
|
|
// Set initial offset
|
|
Utilities.SetFilePointerEx(
|
|
hDisk,
|
|
0,
|
|
ref pt,
|
|
Utilities.FileBegin);
|
|
|
|
// Read a whole sector
|
|
while (true)
|
|
{
|
|
buffer = new byte[sectorsize];
|
|
Utilities.ReadFileEx(
|
|
hDisk,
|
|
buffer,
|
|
(uint)sectorsize,
|
|
ref no,
|
|
null);
|
|
|
|
Utilities.SetFilePointerEx(
|
|
hDisk,
|
|
sectorsize,
|
|
ref pt,
|
|
Utilities.FileCurrent);
|
|
}
|
|
}
|
|
|
|
Utilities.CloseHandle(hDisk);
|
|
|
|
return null;
|
|
}
|
|
}
|
|
}
|