public class Scanner

{

#region Instance Variables

/// <summary>

/// Determines whether archives are decompressed and scanned

/// </summary>

private readonly bool _scanArchives;

/// <summary>

/// Determines if content matches are used

/// </summary>

private readonly bool _scanContents;

/// <summary>

/// Determines if path matches are used

/// </summary>

private readonly bool _scanPaths;

/// <summary>

/// Determines if subdirectories are scanned

/// </summary>

private readonly bool _scanSubdirectories;

/// <summary>

/// Determines if debug information is output

/// </summary>

private readonly bool _includeDebug;

/// <summary>

/// Optional progress callback during scanning

/// </summary>

private readonly IProgress<ProtectionProgress>? _fileProgress;

#endregion

/// <summary>

/// Constructor

/// </summary>

/// <param name="scanArchives">Enable scanning archive contents</param>

/// <param name="scanContents">Enable including content detections in output</param>

/// <param name="scanPaths">Enable including path detections in output</param>

/// <param name="scanSubdirectories">Enable scanning subdirectories</param>

/// <param name="includeDebug">Enable including debug information</param>

/// <param name="fileProgress">Optional progress callback</param>

public Scanner(bool scanArchives,

bool scanContents,

bool scanPaths,

bool scanSubdirectories,

bool includeDebug,

IProgress<ProtectionProgress>? fileProgress = null)

{

_scanArchives = scanArchives;

_scanContents = scanContents;

_scanPaths = scanPaths;

_scanSubdirectories = scanSubdirectories;

_includeDebug = includeDebug;

_fileProgress = fileProgress;

#if NET462_OR_GREATER || NETCOREAPP || NETSTANDARD2_0_OR_GREATER

// Register the codepages

System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);

#endif

}

#region Scanning

/// <summary>

/// Scan a single path and get all found protections

/// </summary>

/// <param name="path">Path to scan</param>

/// <returns>Dictionary of list of strings representing the found protections</returns>

public Dictionary<string, List<string>> GetProtections(string path)

=> GetProtectionsImpl(path, depth: 0).ToDictionary();

/// <summary>

/// Scan the list of paths and get all found protections

/// </summary>

/// <param name="paths">Paths to scan</param>

/// <returns>Dictionary of list of strings representing the found protections</returns>

public Dictionary<string, List<string>> GetProtections(List<string>? paths)

=> GetProtectionsImpl(paths, depth: 0).ToDictionary();

/// <summary>

/// Scan a single path and get all found protections

/// </summary>

/// <param name="path">Path to scan</param>

/// <param name="depth">Depth of the current scanner pertaining to extracted data</param>

/// <returns>Dictionary of list of strings representing the found protections</returns>

private ProtectionDictionary GetProtectionsImpl(string path, int depth)

=> GetProtectionsImpl([path], depth);

/// <summary>

/// Scan a single path and get all found protections

/// </summary>

/// <param name="paths">Paths to scan</param>

/// <param name="depth">Depth of the current scanner pertaining to extracted data</param>

/// <returns>Dictionary of list of strings representing the found protections</returns>

private ProtectionDictionary GetProtectionsImpl(List<string>? paths, int depth)

{

// If we have no paths, we can't scan

if (paths is null || paths.Count == 0)

{

if (_includeDebug) Console.WriteLine("No paths found to scan, skipping...");

return [];

}

// Set a starting starting time for debug output

DateTime startTime = DateTime.UtcNow;

// Checkpoint

_fileProgress?.Report(new ProtectionProgress(null, depth, 0, null));

// Temp variables for reporting

string tempFilePath = Path.GetTempPath();

string tempFilePathWithGuid = Path.Combine(tempFilePath, Guid.NewGuid().ToString());

// Loop through each path and get the returned values

var protections = new ProtectionDictionary();

foreach (string path in paths)

{

// Directories scan each internal file individually

if (Directory.Exists(path))

{

// Enumerate all files at first for easier access

SearchOption searchOption = _scanSubdirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;

List<string> files = [.. IOExtensions.SafeGetFiles(path, "*", searchOption)];

// Scan for path-detectable protections

if (_scanPaths)

{

var directoryPathProtections = HandlePathChecks(path, files);

protections.Append(directoryPathProtections);

}

// Scan each file in directory separately

for (int i = 0; i < files.Count; i++)

{

// Get the current file

string file = files[i];

// Get the reportable file name

string reportableFileName = file;

if (reportableFileName.StartsWith(tempFilePath))

#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER

reportableFileName = reportableFileName[tempFilePathWithGuid.Length..];

#else

reportableFileName = reportableFileName.Substring(tempFilePathWithGuid.Length);

#endif

// Checkpoint

_fileProgress?.Report(new ProtectionProgress(reportableFileName, depth, i / (float)files.Count, "Checking file" + (file != reportableFileName ? " from archive" : string.Empty)));

// Scan for path-detectable protections

if (_scanPaths)

{

var filePathProtections = HandlePathChecks(file, files: null);

if (filePathProtections is not null && filePathProtections.Count > 0)

protections.Append(filePathProtections);

}

// Scan for content-detectable protections

var fileProtections = GetInternalProtections(file, depth);

if (fileProtections is not null && fileProtections.Count > 0)

protections.Append(fileProtections);

// Checkpoint

protections.TryGetValue(file, out var fullProtectionList);

#if NET20 || NET35

var fullProtection = fullProtectionList is not null && fullProtectionList.Count > 0

#else

var fullProtection = fullProtectionList is not null && !fullProtectionList.IsEmpty

#endif

? string.Join(", ", [.. fullProtectionList])

: null;

_fileProgress?.Report(new ProtectionProgress(reportableFileName, depth, (i + 1) / (float)files.Count, fullProtection ?? string.Empty));

}

}

// Scan a single file by itself

else if (File.Exists(path))

{

// Get the reportable file name

string reportableFileName = path;

if (reportableFileName.StartsWith(tempFilePath))

#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER

reportableFileName = reportableFileName[tempFilePathWithGuid.Length..];

#else

reportableFileName = reportableFileName.Substring(tempFilePathWithGuid.Length);

#endif

// Checkpoint

_fileProgress?.Report(new ProtectionProgress(reportableFileName, depth, 0, "Checking file" + (path != reportableFileName ? " from archive" : string.Empty)));

// Scan for path-detectable protections

if (_scanPaths)

{

var filePathProtections = HandlePathChecks(path, files: null);

if (filePathProtections is not null && filePathProtections.Count > 0)

protections.Append(filePathProtections);

}

// Scan for content-detectable protections

var fileProtections = GetInternalProtections(path, depth);

if (fileProtections is not null && fileProtections.Count > 0)

protections.Append(fileProtections);

// Checkpoint

protections.TryGetValue(path, out var fullProtectionList);

#if NET20 || NET35

var fullProtection = fullProtectionList is not null && fullProtectionList.Count > 0

#else

var fullProtection = fullProtectionList is not null && !fullProtectionList.IsEmpty

#endif

? string.Join(", ", [.. fullProtectionList])

: null;

_fileProgress?.Report(new ProtectionProgress(reportableFileName, depth, 1, fullProtection ?? string.Empty));

}

// Invalid path

else

{

if (_includeDebug) Console.Error.WriteLine($"{path} is not a directory or file, skipping...");

//throw new FileNotFoundException($"{path} is not a directory or file, skipping...");

}

}

// Clear out any empty keys

protections.ClearEmptyKeys();

// If we're in debug, output the elasped time to console

if (_includeDebug)

Console.WriteLine($"Time elapsed: {DateTime.UtcNow.Subtract(startTime)}");

return protections;

}

/// <summary>

/// Get the content-detectable protections associated with a single path

/// </summary>

/// <param name="file">Path to the file to scan</param>

/// <param name="depth">Depth of the current scanner pertaining to extracted data</param>

/// <returns>Dictionary of list of strings representing the found protections</returns>

private ProtectionDictionary GetInternalProtections(string file, int depth)

{

// Quick sanity check before continuing

if (!File.Exists(file))

{

if (_includeDebug) Console.WriteLine($"{file} does not exist, skipping...");

return [];

}

// Open the file and begin scanning

try

{

using FileStream fs = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

return GetInternalProtections(fs.Name, fs, depth);

}

catch (DirectoryNotFoundException ex)

{

if (_includeDebug) Console.WriteLine(ex);

return [];

}

catch (FileNotFoundException ex)

{

if (_includeDebug) Console.WriteLine(ex);

return [];

}

catch (UnauthorizedAccessException ex)

{

if (_includeDebug) Console.WriteLine(ex);

var protections = new ProtectionDictionary();

protections.Append(file, _includeDebug ? ex.ToString() : "[Access issue when opening file, please check permissions and try again]");

return protections;

}

catch (Exception ex)

{

if (_includeDebug) Console.WriteLine(ex);

var protections = new ProtectionDictionary();

protections.Append(file, _includeDebug ? ex.ToString() : "[Exception opening file, please try again]");

return protections;

}

}

/// <summary>

/// Get the content-detectable protections associated with a single path

/// </summary>

/// <param name="fileName">Name of the source file of the stream, for tracking</param>

/// <param name="stream">Stream to scan the contents of</param>

/// <param name="depth">Depth of the current scanner pertaining to extracted data</param>

/// <returns>Dictionary of list of strings representing the found protections</returns>

private ProtectionDictionary GetInternalProtections(string fileName, Stream stream, int depth)

{

// Quick sanity check before continuing

if (!stream.CanRead)

{

if (_includeDebug) Console.WriteLine($"{fileName} does not have a readable stream, skipping...");

return [];

}

// Get the extension for certain checks

string extension = Path.GetExtension(fileName).ToLower().TrimStart('.');

// Get the first 16 bytes for matching

byte[] magic;

try

{

int bytesToRead = (int)Math.Min(16, stream.Length);

magic = stream.ReadBytes(bytesToRead);

stream.Seek(0, SeekOrigin.Begin);

}

catch (Exception ex)

{

if (_includeDebug) Console.Error.WriteLine(ex);

return [];

}

// Get the file type either from magic number or extension

WrapperType fileType = WrapperFactory.GetFileType(magic, extension);

if (fileType == WrapperType.UNKNOWN)

{

if (_includeDebug) Console.WriteLine($"{fileName} not a scannable file type, skipping...");

return [];

}

// Get the wrapper, if possible

var wrapper = WrapperFactory.CreateWrapper(fileType, stream);

// Initialize the protections found

var protections = new ProtectionDictionary();

#region Non-Archive File Types

// Try to scan file contents

var detectable = CreateDetectable(fileType, wrapper);

if (_scanContents && detectable is not null)

{

try

{

var subProtection = detectable.Detect(stream, fileName, _includeDebug);

protections.Append(fileName, subProtection);

}

catch (Exception ex)

{

if (_includeDebug) Console.WriteLine(ex);

protections.Append(fileName, _includeDebug ? ex.ToString() : "[Exception opening file, please try again]");

}

}

#endregion

#region Archive File Types

// If we're scanning archives

if (_scanArchives && wrapper is IExtractable extractable)

{

// If the extractable file itself fails

try

{

// Extract and get the output path

string tempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

Directory.CreateDirectory(tempPath);

_ = extractable.Extract(tempPath, _includeDebug);

// Check if any files extracted

if (IOExtensions.SafeGetFileSystemEntries(tempPath).Length > 0)

{

// Scan the output path

var subProtections = GetProtectionsImpl(tempPath, depth + 1);

// Prepare the returned values

subProtections.StripFromKeys(tempPath);

subProtections.PrependToKeys(fileName);

// Append the values

protections.Append(subProtections);

}

// If temp directory cleanup fails

try

{

if (Directory.Exists(tempPath))

Directory.Delete(tempPath, true);

}

catch (Exception ex)

{

if (_includeDebug) Console.Error.WriteLine(ex);

}

}

catch (Exception ex)

{

if (_includeDebug) Console.Error.WriteLine(ex);

}

}

#endregion

// Clear out any empty keys

protections.ClearEmptyKeys();

return protections;

}

#endregion

#region Path Handling

/// <summary>

/// Handle a single path based on all path check implementations

/// </summary>

/// <param name="path">Path of the file or directory to check</param>

/// <param name="scanner">Scanner object to use for options and scanning</param>

/// <returns>Set of protections in file, null on error</returns>

private static ProtectionDictionary HandlePathChecks(string path, List<string>? files)

{

// Create the output dictionary

var protections = new ProtectionDictionary();

// Preprocess the list of files

files = files?

.ConvertAll(f => f.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));

// Iterate through all checks

StaticChecks.PathCheckClasses.IterateWithAction(checkClass =>

{

var subProtections = PerformPathCheck(checkClass, path, files);

protections.Append(path, subProtections);

});

return protections;

}

/// <summary>

/// Handle files based on an IPathCheck implementation

/// </summary>

/// <param name="impl">IPathCheck class representing the file type</param>

/// <param name="path">Path of the file or directory to check</param>

/// <returns>Set of protections in path, empty on error</returns>

private static List<string> PerformPathCheck(IPathCheck impl, string? path, List<string>? files)

{

// If we have an invalid path

if (string.IsNullOrEmpty(path))

return [];

// Setup the list

var protections = new List<string>();

// If we have a file path

if (File.Exists(path))

{

var protection = impl.CheckFilePath(path!);

if (protection is not null)

protections.Add(protection);

}

// If we have a directory path

if (Directory.Exists(path) && files is not null && files.Count > 0)

{

var subProtections = impl.CheckDirectoryPath(path!, files);

if (subProtections is not null)

protections.AddRange(subProtections);

}

return protections;

}

#endregion

#region Helpers

/// <summary>

/// Create an instance of a detectable based on file type

/// </summary>

private static IDetectable? CreateDetectable(WrapperType fileType, IWrapper? wrapper)

{

// Use the wrapper before the type

return wrapper switch

{

AACSMediaKeyBlock obj => new FileType.AACSMediaKeyBlock(obj),

BDPlusSVM obj => new FileType.BDPlusSVM(obj),

GCF obj => new FileType.GCF(obj),

ISO9660 obj => new FileType.ISO9660(obj),

LDSCRYPT obj => new FileType.LDSCRYPT(obj),

LinearExecutable obj => new FileType.LinearExecutable(obj),

MSDOS obj => new FileType.MSDOS(obj),

NewExecutable obj => new FileType.NewExecutable(obj),

PlayJAudioFile obj => new FileType.PLJ(obj),

PortableExecutable obj => new FileType.PortableExecutable(obj),

RealArcadeInstaller obj => new FileType.RealArcadeInstaller(obj),

RealArcadeMezzanine obj => new FileType.RealArcadeMezzanine(obj),

SFFS obj => new FileType.SFFS(obj),

// Fall back on the file type for types not implemented in Serialization

#pragma warning disable IDE0072

_ => fileType switch

{

WrapperType.Textfile => new FileType.Textfile(),

_ => null,

},

#pragma warning restore IDE0072

};

}

#endregion

}