Cleanup

Author: mnadareski

BinaryObjectScanner/Data/StaticChecks.cs

@@ -23,7 +23,7 @@ public static IContentCheck[] ContentCheckClasses
         }
 
         /// <summary>
-        /// Cache for all IISOCheck<ISO> types
+        /// Cache for all IDiskImageCheck<ISO9660> types
         /// </summary>
         public static IDiskImageCheck<ISO9660>[] ISO9660CheckClasses
         {
@@ -33,7 +33,7 @@ public static IDiskImageCheck<ISO9660>[] ISO9660CheckClasses
                 return iso9660CheckClasses;
             }
         }
-        
+
         /// <summary>
         /// Cache for all IExecutableCheck<LinearExecutable> types
         /// </summary>
@@ -103,12 +103,11 @@ public static IExecutableCheck<PortableExecutable>[] PortableExecutableCheckClas
         /// </summary>
         private static IContentCheck[]? contentCheckClasses;
 
-        
         /// <summary>
         /// Cache for all IISOCheck<ISO9660> types
         /// </summary>
         private static IDiskImageCheck<ISO9660>[]? iso9660CheckClasses;
-        
+
         /// <summary>
         /// Cache for all IExecutableCheck<LinearExecutable> types
         /// </summary>
@@ -169,7 +168,7 @@ private static T[] InitCheckClasses<T>(Assembly assembly)
             if (assemblyTypes.Length == 0)
                 return [];
 
-            // Loop through all types 
+            // Loop through all types
             List<T> classTypes = [];
             foreach (Type? type in assemblyTypes)
             {

BinaryObjectScanner/FileType/DiskImage.cs

@@ -1,6 +1,4 @@
-using System;
 using System.Collections.Generic;
-using System.IO;
 using BinaryObjectScanner.Data;
 using BinaryObjectScanner.Interfaces;
 using SabreTools.IO.Extensions;
@@ -20,13 +18,13 @@ public DiskImage(T wrapper) : base(wrapper) { }
         #region Check Runners
 
         /// <summary>
-        /// Handle a single file based on all ISO check implementations
+        /// Handle a single file based on all disk image check implementations
         /// </summary>
-        /// <param name="file">Name of the source file of the ISO, for tracking</param>
+        /// <param name="file">Name of the source file of the disk image, for tracking</param>
         /// <param name="checks">Set of checks to use</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
         /// <returns>Set of protections in file, empty on error</returns>
-        protected IDictionary<U, string> RunISOChecks<U>(string file, U[] checks, bool includeDebug)
+        protected IDictionary<U, string> RunDiskImageChecks<U>(string file, U[] checks, bool includeDebug)
             where U : IDiskImageCheck<T>
         {
             // Create the output dictionary

BinaryObjectScanner/FileType/ISO9660.cs

@@ -25,7 +25,7 @@ public ISO9660(SabreTools.Serialization.Wrappers.ISO9660 wrapper) : base(wrapper
 
             // Standard checks
             var subProtections
-                = RunISOChecks(file, StaticChecks.ISO9660CheckClasses, includeDebug);
+                = RunDiskImageChecks(file, StaticChecks.ISO9660CheckClasses, includeDebug);
             protections.Append(file, subProtections.Values);
 
             // If there are no protections
@@ -43,51 +43,51 @@ var subProtections
         }
 
         /// <summary>
-        /// Checks whether the sequence of bytes is pure data (as in, not empty, not text, just high-entropy data)
+        /// Checks whether the sequence of bytes is pure data (as in, not empty,
+        /// not text, just high-entropy data)
         /// </summary>
         public static bool IsPureData(byte[] bytes)
         {
             // Check if there are three 0x00s in a row. Two seems like pushing it
-            byte[] containedZeroes = {0x00, 0x00, 0x00};
             int index = 0;
-            for (int i = 0; i < bytes.Length; ++i) 
+            for (int i = 0; i < bytes.Length; ++i)
             {
-                if (bytes[i] == containedZeroes[index])
+                if (bytes[i] == 0x00)
                 {
-                    if (++index >= containedZeroes.Length)
-                        return false; 
+                    if (++index >= 3)
+                        return false;
                 }
                 else
                 {
-                    index = 0;   
+                    index = 0;
                 }
             }
-            
+
             // Checks if there are strings in the data
             // TODO: is this too dangerous, or too faulty?
             // Currently-found worst cases:
             // "Y:1BY:1BC" in Redump ID 23339
             var strings = bytes.ReadStringsWithEncoding(charLimit: 7, Encoding.ASCII);
-            Regex rgx = new Regex("[^a-zA-Z0-9 -'!,.]");
+            var rgx = new Regex("[^a-zA-Z0-9 -'!,.]");
             foreach (string str in strings)
             {
                 if (rgx.Replace(str, "").Length > 7)
                     return false;
             }
-            
+
             return true;
         }
-        
-        // TODO: can these 2 "noteworthy" functions be cached?
+
         /// <summary>
         /// Checks whether the Application Use data is "noteworthy" enough to be worth checking for protection.
         /// </summary>
+        /// TODO: can these 2 "noteworthy" functions be cached?
         public static bool NoteworthyApplicationUse(PrimaryVolumeDescriptor pvd)
         {
             var applicationUse = pvd.ApplicationUse;
             if (Array.TrueForAll(applicationUse, b => b == 0x00))
                 return false;
-            
+
             int offset = 0;
             string? potentialAppUseString = applicationUse.ReadNullTerminatedAnsiString(ref offset);
             if (potentialAppUseString != null && potentialAppUseString.Length > 0) // Some image authoring programs add a starting string to AU data
@@ -100,20 +100,21 @@ public static bool NoteworthyApplicationUse(PrimaryVolumeDescriptor pvd)
                     return false;
                 else if (Array.TrueForAll(Encoding.ASCII.GetBytes(potentialAppUseString), b => b == 0x20))
                     return false;
+
                 // TODO: Unhandled "norb" mastering that puts stuff everywhere, inconsistently. See RID 103641
                 // More things will have to go here as more disc authoring softwares are found that do this.
                 // Redump ID 24478 has a bunch of 0x20 with norb in the middle, some discs have 0x20 that ends in a "/"
                 // character. If these are found to be causing issues they can be added.
             }
-            
+
             offset = 141;
             potentialAppUseString = applicationUse.ReadNullTerminatedAnsiString(ref offset);
-            if (potentialAppUseString == "CD-XA001") 
-                    return false;
-            
+            if (potentialAppUseString == "CD-XA001")
+                return false;
+
             return true;
         }
-        
+
         /// <summary>
         /// Checks whether the Reserved 653 Bytes are "noteworthy" enough to be worth checking for protection.
         /// </summary>
@@ -123,8 +124,9 @@ public static bool NoteworthyReserved653Bytes(PrimaryVolumeDescriptor pvd)
             var noteworthyReserved653Bytes = true;
             if (Array.TrueForAll(reserved653Bytes, b => b == 0x00))
                 noteworthyReserved653Bytes = false;
+
             // Unsure if more will be needed
             return noteworthyReserved653Bytes;
         }
     }
-}
+}

BinaryObjectScanner/Interfaces/IDiskImageCheck.cs

@@ -11,9 +11,9 @@ public interface IDiskImageCheck<T> where T : WrapperBase
         /// Check a path for protections based on file contents
         /// </summary>
         /// <param name="file">File to check for protection indicators</param>
-        /// <param name="diskImage"></param>
+        /// <param name="diskImage">Disk image representing the read-in file</param>
         /// <param name="includeDebug">True to include debug data, false otherwise</param>
         /// <returns>String containing any protections found in the file</returns>
         string? CheckDiskImage(string file, T diskImage, bool includeDebug);
     }
-}
+}

BinaryObjectScanner/Protection/AlphaROM.cs

@@ -10,7 +10,7 @@ namespace BinaryObjectScanner.Protection
     /// <summary>
     /// Alpha-ROM is a form of copy protection created by SETTEC. It is known to make use of twin sectors as well as region locking.
     /// Later forms of Alpha-ROM appear to be digital only, and it's currently unsure what forms of protection the digital only version includes, except that it does make use of region locking.
-    /// It seems that Alpha-ROM was used in Visual Novels using certain game engines, most notably RealLive and Siglus (https://forums.fuwanovel.net/topic/20927-cannot-crack-siglus-engine-with-alpharom/). 
+    /// It seems that Alpha-ROM was used in Visual Novels using certain game engines, most notably RealLive and Siglus (https://forums.fuwanovel.net/topic/20927-cannot-crack-siglus-engine-with-alpharom/).
     /// Not every Siglus engine game uses Alpha-ROM (Source: https://sample9.dmm.co.jp/digital/pcgame/vsat_0263/vsat_0263t.zip {Official trial mirror}).
     /// Not every RealLive engine game uses Alpha-ROM (Source: IA item "Kanon_Standard_Edition_Japan").
     /// Alpha-ROM also seems to have made use of something called "Alpha-DPS" for non-executable data files (http://www.gonsuke.co.jp/protect.html).
@@ -43,12 +43,57 @@ namespace BinaryObjectScanner.Protection
     //      - SETTEC0000SETTEC1111
     //      - SOFTWARE\SETTEC
     // TODO: Are there version numbers?
-    public class AlphaROM : IExecutableCheck<PortableExecutable>, IDiskImageCheck<ISO9660>
+    public class AlphaROM : IDiskImageCheck<ISO9660>, IExecutableCheck<PortableExecutable>
     {
+        /// <inheritdoc/>
+        public string? CheckDiskImage(string file, ISO9660 diskImage, bool includeDebug)
+        {
+            // Checks can be made even easier once UDF support exists, as most (although not all, some early discs like
+            // redump ID 124111 have no UDF partition) discs have "Settec" slathered over every field UDF lets them.
+
+            if (diskImage.VolumeDescriptorSet.Length == 0)
+                return null;
+            if (diskImage.VolumeDescriptorSet[0] is not PrimaryVolumeDescriptor pvd)
+                return null;
+
+            // Alpharom disc check #1: disc has varying (but observed to at least always be larger than 14) length
+            // string made up of numbers and capital letters.
+            // TODO: triple-check that length is never below 14
+            int offset = 0;
+            var applicationIdentifierString = pvd.ApplicationIdentifier.ReadNullTerminatedAnsiString(ref offset)?.Trim();
+            if (applicationIdentifierString == null || applicationIdentifierString.Length < 14)
+                return null;
+
+            if (!Regex.IsMatch(applicationIdentifierString, "^[A-Z0-9]*$"))
+                return null;
+
+            // Alpharom disc check #2: disc has publisher identifier filled with varying amount of data (26-50 bytes
+            // have been observed) followed by spaces. There's a decent chance this is just a Japanese text string, but
+            // UTF, Shift-JIS, and EUC-JP all fail to display anything but garbage.
+
+            var publisherIdentifier = pvd.PublisherIdentifier;
+            int firstSpace = Array.FindIndex(publisherIdentifier, b => b == 0x20);
+            if (firstSpace <= 10 || firstSpace >= 120)
+                return null;
+
+            var publisherData = new byte[firstSpace];
+            var publisherSpaces = new byte[publisherData.Length - firstSpace];
+            Array.Copy(publisherIdentifier, 0, publisherData, 0, firstSpace);
+            Array.Copy(publisherIdentifier, firstSpace, publisherSpaces, 0, publisherData.Length - firstSpace);
+
+            if (!Array.TrueForAll(publisherSpaces, b => b == 0x20))
+                return null;
+
+            if (!FileType.ISO9660.IsPureData(publisherData))
+                return null;
+
+            return "AlphaROM";
+        }
+
         /// <inheritdoc/>
         public string? CheckExecutable(string file, PortableExecutable exe, bool includeDebug)
         {
-            // TODO: Add support for detecting Alpha-ROM found in older games made with the RealLive engine. 
+            // TODO: Add support for detecting Alpha-ROM found in older games made with the RealLive engine.
             // TODO: Add version detection for Alpha-ROM.
 
             // Get the .data/DATA section strings, if they exist
@@ -88,51 +133,5 @@ public class AlphaROM : IExecutableCheck<PortableExecutable>, IDiskImageCheck<IS
 
             return null;
         }
-
-         /// <inheritdoc/>
-        public string? CheckDiskImage(string file, ISO9660 diskImage, bool includeDebug)
-        {
-            // Checks can be made even easier once UDF support exists, as most (although not all, some early discs like
-            // redump ID 124111 have no UDF partition) discs have "Settec" slathered over every field UDF lets them.
-
-            if (diskImage.VolumeDescriptorSet.Length == 0)
-                return null;
-            
-            if (diskImage.VolumeDescriptorSet[0] is not PrimaryVolumeDescriptor pvd)
-                return null;
-            
-            // Alpharom disc check #1: disc has varying (but observed to at least always be larger than 14) length 
-            // string made up of numbers and capital letters.
-            // TODO: triple-check that length is never below 14
-            int offset = 0;
-            var applicationIdentifierString = pvd.ApplicationIdentifier.ReadNullTerminatedAnsiString(ref offset)?.Trim();
-            if (applicationIdentifierString == null || applicationIdentifierString.Length < 14)
-                return null;
-
-            if (!Regex.IsMatch(applicationIdentifierString, "^[A-Z0-9]*$"))
-                return null;
-            
-            // Alpharom disc check #2: disc has publisher identifier filled with varying amount of data (26-50 bytes
-            // have been observed) followed by spaces. There's a decent chance this is just a Japanese text string, but
-            // UTF, Shift-JIS, and EUC-JP all fail to display anything but garbage.
-            
-            var publisherIdentifier = pvd.PublisherIdentifier;
-            int firstSpace = Array.FindIndex(publisherIdentifier, b => b == 0x20);
-            if (firstSpace <= 10 || firstSpace >= 120)
-                return null;
-            
-            var publisherData = new byte[firstSpace];
-            var publisherSpaces = new byte[publisherData.Length - firstSpace];
-            Array.Copy(publisherIdentifier, 0, publisherData, 0, firstSpace);
-            Array.Copy(publisherIdentifier, firstSpace, publisherSpaces, 0, publisherData.Length - firstSpace);
-            
-            if (!Array.TrueForAll(publisherSpaces, b => b == 0x20))
-                return null;
-            
-            if (!FileType.ISO9660.IsPureData(publisherData))
-                return null;
-            
-            return "AlphaROM";
-        }
     }
 }