Bump IRDKit to v0.6.1

IRDKit/IRDKit.csproj

@@ -9,7 +9,7 @@
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
     <LangVersion>latest</LangVersion>
 	<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Version>0.5.0</Version>
+    <Version>0.6.1</Version>
     
     <!-- Package Properties -->
     <Authors>Deterous</Authors>

IRDKit/Program.cs

@@ -11,6 +11,7 @@ using System.IO.Hashing;
 using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
+using System.Xml.Linq;
 
 namespace IRDKit
 {
@@ -24,7 +25,7 @@ namespace IRDKit
         [Verb("create", HelpText = "Create an IRD from an ISO")]
         public class CreateOptions
         {
-            [Value(0, Required = true, HelpText = "Path to an ISO file, or directory of ISO files")]
+            [Value(0, Required = true, HelpText = "Path to ISO file(s), or directory of ISO files")]
             public IEnumerable<string> ISOPath { get; set; }
 
             [Option('o', "output", HelpText = "Path to the IRD file to be created (will overwrite)")]
@@ -55,7 +56,7 @@ namespace IRDKit
         [Verb("info", HelpText = "Print information from an IRD or ISO")]
         public class InfoOptions
         {
-            [Value(0, Required = true, HelpText = "Path to an IRD or ISO file, or directory of IRD and/or ISO files")]
+            [Value(0, Required = true, HelpText = "Path to IRD/ISO file(s), or directory of IRD/ISO files")]
             public IEnumerable<string> InPath { get; set; }
 
             [Option('o', "output", HelpText = "Path to the text or json file to be created (will overwrite)")]
@@ -84,6 +85,31 @@ namespace IRDKit
             public string OutPath { get; set; }
         }
 
+        /// <summary>
+        /// IRD rename command
+        /// </summary>
+        [Verb("rename", HelpText = "Rename one or more IRD files according to the redump PS3 DAT")]
+        public class RenameOptions
+        {
+            [Value(0, Required = true, HelpText = "Path to IRD file(s), or directory of IRD files")]
+            public IEnumerable<string> IRDPath { get; set; }
+
+            [Option('d', "datfile", Required = true, HelpText = "Path to the redump PS3 Datfile")]
+            public string DATPath { get; set; }
+
+            [Option('s', "serial", HelpText = "Appends disc serial to new IRD filename")]
+            public bool Serial { get; set; }
+
+            [Option('c', "crc", HelpText = "Appends ISO CRC to new IRD filename")]
+            public bool CRC { get; set; }
+
+            [Option('r', "recurse", HelpText = "Recurse through all subdirectories and rename all IRDs")]
+            public bool Recurse { get; set; }
+
+            [Option('v', "verbose", HelpText = "Print more information about the renaming")]
+            public bool Verbose { get; set; }
+        }
+
         #endregion
 
         #region Program
@@ -98,7 +124,7 @@ namespace IRDKit
             Console.OutputEncoding = Encoding.UTF8;
 
             // Parse arguments
-            var result = Parser.Default.ParseArguments<CreateOptions, InfoOptions, DiffOptions>(args).WithParsed(Run);
+            var result = Parser.Default.ParseArguments<CreateOptions, InfoOptions, DiffOptions, RenameOptions>(args).WithParsed(Run);
         }
 
         /// <summary>
@@ -173,7 +199,7 @@ namespace IRDKit
                             if (!File.Exists(isoPath))
                             {
                                 Console.Error.WriteLine($"ISO not found: {isoPath}");
-                                return;
+                                continue;
                             }
 
                             string irdPath;
@@ -330,6 +356,99 @@ namespace IRDKit
 
                     break;
 
+                // Process options from a 'rename' command
+                case RenameOptions opt:
+
+                    // Validate required parameters
+                    if (opt.IRDPath == null || !opt.IRDPath.Any())
+                    {
+                        Console.Error.WriteLine("Provide a valid IRD path to rename");
+                        return;
+                    }
+
+                    // Read DAT file
+                    XDocument datfile = DatParser(opt.DATPath);
+                    if (datfile == null)
+                    {
+                        Console.Error.WriteLine("Unable to parse DAT file");
+                        return;
+                    }
+
+                    foreach (string irdPath in opt.IRDPath)
+                    {
+                        // Validate IRD path
+                        if (string.IsNullOrEmpty(irdPath))
+                            continue;
+
+                        // If directory, search for all ISOs in current directory
+                        if (Directory.Exists(irdPath))
+                        {
+                            // If recurse option enabled, search recursively
+                            IEnumerable<string> irdFiles;
+                            if (opt.Recurse)
+                            {
+                                if (opt.Verbose && irdPath == ".")
+                                    Console.WriteLine($"Recursively renaming IRDs in current directory");
+                                else if (opt.Verbose)
+                                    Console.WriteLine($"Recursively renaming IRDs in {irdPath}");
+                                irdFiles = Directory.EnumerateFiles(irdPath, "*.ird", SearchOption.AllDirectories);
+                            }
+                            else
+                            {
+                                if (opt.Verbose && irdPath == ".")
+                                    Console.WriteLine($"Renaming IRDs in current directory");
+                                else if (opt.Verbose)
+                                    Console.WriteLine($"Renaming IRDs in {irdPath}");
+                                irdFiles = Directory.EnumerateFiles(irdPath, "*.ird", SearchOption.TopDirectoryOnly);
+                            }
+
+                            // Warn if no files are found
+                            if (!irdFiles.Any())
+                            {
+                                if (opt.Recurse)
+                                    Console.Error.WriteLine($"No IRDs found in {irdPath} (ensure .ird extension)");
+                                else
+                                    Console.Error.WriteLine($"No IRDs found in {irdPath} (ensure .ird extension, or try use -r)");
+                                continue;
+                            }
+
+                            // Rename all IRD files found
+                            foreach (string file in irdFiles.OrderBy(x => x))
+                            {
+                                try
+                                {
+                                    RenameIRD(file, datfile, serial: opt.Serial, crc: opt.CRC, verbose: opt.Verbose);
+                                }
+                                catch (Exception e)
+                                {
+                                    Console.Error.WriteLine(e);
+                                }
+                            }
+
+                        }
+                        else
+                        {
+                            // Check that given file exists
+                            if (!File.Exists(irdPath))
+                            {
+                                Console.Error.WriteLine($"IRD not found: {irdPath}");
+                                continue;
+                            }
+
+                            // Rename provided IRD path
+                            try
+                            {
+                                RenameIRD(irdPath, datfile, serial: opt.Serial, crc: opt.CRC, verbose: opt.Verbose);
+                            }
+                            catch (Exception e)
+                            {
+                                Console.Error.WriteLine(e);
+                            }
+                        }
+                    }
+
+                    break;
+
                 // Unknown command
                 default:
                     break;
@@ -704,16 +823,11 @@ namespace IRDKit
                         return irdPath;
                     }
                 }
-                catch (ArgumentException e)
+                catch (Exception e)
                 {
                     Console.Error.WriteLine(e.Message + ", failed to create IRD");
                     return null;
                 }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
-                    return null;
-                }
             }
 
             // Create new reproducible redump-style IRD with a given key file
@@ -740,16 +854,11 @@ namespace IRDKit
                         return irdPath;
                     }
                 }
-                catch (ArgumentException e)
+                catch (Exception e)
                 {
                     Console.Error.WriteLine(e.Message + ", failed to create IRD");
                     return null;
                 }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
-                    return null;
-                }
             }
 
             // Create new reproducible redump-style IRD with a given GetKey log
@@ -764,16 +873,11 @@ namespace IRDKit
                         ird1.Print();
                     return irdPath;
                 }
-                catch (ArgumentException e)
+                catch (Exception e)
                 {
                     Console.Error.WriteLine(e.Message + ", failed to create IRD");
                     return null;
                 }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
-                    return null;
-                }
             }
 
             // No key provided, try search for .key file
@@ -798,16 +902,11 @@ namespace IRDKit
                         return irdPath;
                     }
                 }
-                catch (ArgumentException e)
+                catch (Exception e)
                 {
                     Console.Error.WriteLine(e.Message + ", failed to create IRD");
                     return null;
                 }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
-                    return null;
-                }
             }
 
             // No key provided, try search for .getkey.log file
@@ -825,16 +924,11 @@ namespace IRDKit
                         ird1.Print();
                     return irdPath;
                 }
-                catch (ArgumentException e)
+                catch (Exception e)
                 {
                     Console.Error.WriteLine(e.Message + ", failed to create IRD");
                     return null;
                 }
-                catch (FileNotFoundException)
-                {
-                    Console.Error.WriteLine("File not found, failed to create IRD");
-                    return null;
-                }
             }
 
             // No key provided, try get key from redump.org
@@ -913,18 +1007,72 @@ namespace IRDKit
                     ird.Print();
                 return irdPath;
             }
-            catch (ArgumentException e)
+            catch (Exception e)
             {
                 Console.Error.WriteLine(e.Message + ", failed to create IRD");
                 return null;
             }
-            catch (FileNotFoundException)
+        }
+
+        public static XDocument DatParser(string datpath = null)
+        {
+            try
+            {
+                if (!File.Exists(datpath))
+                    return null;
+
+                return XDocument.Load(datpath);
+            }
+            catch
             {
-                Console.Error.WriteLine("File not found, failed to create IRD");
                 return null;
             }
         }
 
+        public static string GetDatFilename(IRD ird, XDocument datfile)
+        {
+            string crc32 = ird.UID.ToString("X8").ToLower();
+            XElement node = datfile.Root.Elements("game").Where(e => e.Element("rom").Attribute("crc").Value == crc32).FirstOrDefault() ?? throw new ArgumentException("Cannot find ISO in redump DAT");
+            return node.Attribute("name").Value;
+        }
+
+        public static void RenameIRD(string irdPath, XDocument datfile, bool serial = false, bool crc = false, bool verbose = false)
+        {
+            IRD ird = IRD.Read(irdPath);
+
+            if (ird.ExtraConfig != 0x0001)
+                throw new ArgumentException($"{irdPath} is not a redump-style IRD");
+
+            string filename = GetDatFilename(ird, datfile);
+            if (filename == null)
+                throw new ArgumentException($"Cannot determine DAT filename for {irdPath}");
+            if (serial)
+                filename += $" [{ird.TitleID[..4]}-{ird.TitleID[4..9]}]";
+            if (crc)
+                filename += $" [{ird.UID:X8}]";
+
+            // Rename irdPath to filename
+            string directory = Path.GetDirectoryName(Path.GetFullPath(filename));
+            string filepath;
+            if (!string.IsNullOrEmpty(directory))
+                filepath = Path.Combine(Path.GetDirectoryName(irdPath), filename + ".ird");
+            else
+                filepath = filename + ".ird";
+
+            // Rename IRD to new name
+            if (irdPath != filepath)
+            {
+                if (verbose)
+                    Console.WriteLine($"Renaming {Path.GetFileName(irdPath)} to {Path.GetFileName(filepath)}");
+                File.Move(irdPath, filepath);
+            }
+            else
+            {
+                if (verbose)
+                    Console.WriteLine($"Skipping {Path.GetFileName(irdPath)}, already named correctly");
+            }
+        }
+
         #endregion
 
         #region Helper Functions

LibIRD/IRD.cs

@@ -2,6 +2,7 @@
 using DiscUtils.Iso9660;
 using DiscUtils.Streams;
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
 using System.IO.Hashing;
@@ -300,6 +301,11 @@ namespace LibIRD
         /// </summary>
         private long[] RegionEnd { get; set; }
 
+        /// <summary>
+        /// File extents to hash
+        /// </summary>
+        private Range<long, long>[][] FileExtents { get; set; }
+
         #endregion
 
         #region Constructors
@@ -351,11 +357,9 @@ namespace LibIRD
 
         /// <summary>
         /// Default constructor for internal derived classes only: resulting object not in usable state
+        /// Assumes that internally derived class will set fields in its own constructor
         /// </summary>
-        private protected IRD()
+        private protected IRD() { }
-        {
-            // Assumes that internally derived class will set fields in its own constructor
-        }
 
         /// <summary>
         /// Constructor with given required fields
@@ -618,7 +622,7 @@ namespace LibIRD
         private protected void GenerateIRD(string isoPath, bool redump = false)
         {
             // Parse ISO file as a file stream
-            using FileStream fs = new FileStream(isoPath, FileMode.Open, FileAccess.Read) ?? throw new FileNotFoundException(isoPath);
+            using FileStream fs = new FileStream(isoPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan) ?? throw new FileNotFoundException(isoPath);
             // Validate ISO file stream
             if (!CDReader.Detect(fs))
                 throw new InvalidFileSystemException("Not a valid ISO file");
@@ -697,29 +701,40 @@ namespace LibIRD
             // Read and compress the ISO footer
             GetFooter(fs);
 
-            // Process all regions on ISO
+            // Get info region info from ISO
-            HashRegions(fs);
+            GetRegions(fs);
-
-            // TODO: Speed up program by hashing regions and files at the same time (read from filesystem only once)
 
             // Recursively count all files in ISO to allocate file arrays
             DiscDirectoryInfo rootDir = reader.GetDirectoryInfo("\\");
             FileCount = 0;
             CountFiles(rootDir);
-            FileKeys = new long[FileCount];
-            FileHashes = new byte[FileCount][];
 
-            // Determine file offsets and hashes
+            // Pre-allocate arrays and reset file count
+            FileKeys = new long[FileCount];
+            FileExtents = new Range<long, long>[FileCount][];
             uint fileCount = FileCount;
             FileCount = 0;
-            HashFiles(fs, reader, rootDir);
+
+            // Determine file offsets
+            GetFiles(fs, reader, rootDir);
+
+            // Resize arrays if non-contiguous files were detected
             if (FileCount != fileCount)
             {
                 long[] tempFileKeys = FileKeys;
                 Array.Resize(ref tempFileKeys, (int)FileCount);
                 FileKeys = tempFileKeys;
+                Range<long, long>[][] tempFileExtents = FileExtents;
+                Array.Resize(ref tempFileExtents, (int)FileCount);
+                FileExtents = tempFileExtents;
             }
-            Array.Sort(FileKeys, FileHashes);
+            // Sort files by offset
+            Array.Sort(FileKeys, FileExtents);
+
+            // Calculate CRC32 hash of ISO only if generating a redump IRD and the UID is not already set
+            RegionHashes = new byte[RegionCount][];
+            FileHashes = new byte[FileCount][];
+            HashISO(fs, redump && UID == 0x00000000);
         }
 
         #endregion
@@ -731,7 +746,7 @@ namespace LibIRD
         /// </summary>
         /// <remarks>PS3UPDAT.PUP update file version number</remarks>
         /// <param name="fs">ISO filestream</param>
-        /// <param name="reader"></param>
+        /// <param name="reader">CDReader</param>
         /// <exception cref="InvalidFileSystemException"></exception>
         private void GetSystemVersion(FileStream fs, CDReader reader)
         {
@@ -774,7 +789,7 @@ namespace LibIRD
         /// Retreives and stores the header
         /// </summary>
         /// <param name="fs">ISO filestream</param>
-        /// <param name="reader"></param>
+        /// <param name="reader">CDReader</param>
         /// <exception cref="InvalidFileSystemException"></exception>
         private void GetHeader(FileStream fs, CDReader reader)
         {
@@ -844,11 +859,11 @@ namespace LibIRD
         }
 
         /// <summary>
-        /// Determines and stores the hashes for each disc region
+        /// Retreives and stores the Region extents
         /// </summary>
-        /// <param name="fs"></param>
+        /// <param name="fs">ISO filestream</param>
         /// <exception cref="InvalidFileSystemException"></exception>
-        private void HashRegions(FileStream fs)
+        private void GetRegions(FileStream fs)
         {
             // Determine the number of unencryted regions
             fs.Seek(0, SeekOrigin.Begin);
@@ -859,7 +874,6 @@ namespace LibIRD
             RegionCount = (byte)(2 * ((uint)decRegionCount[3]) - 1);
             if (RegionCount <= 0)
                 throw new InvalidFileSystemException("No regions detected in ISO");
-            RegionHashes = new byte[RegionCount][];
             RegionStart = new long[RegionCount];
             RegionEnd = new long[RegionCount];
 
@@ -888,53 +902,15 @@ namespace LibIRD
             RegionStart[0] = FirstDataSector;
             // Remove footer from last region
             RegionEnd[^1] = (UpdateEnd / SectorSize) - 1;
-
-            // Determine MD5 hashes for each region
-            int bufSectors = 1024;
-            byte[] buf = new byte[bufSectors * SectorSize];
-            for (int i = 0; i < RegionCount; i++)
-            {
-                // Start reading data from first sector of region
-                fs.Seek(SectorSize * RegionStart[i], SeekOrigin.Begin);
-
-                // Compute MD5 hash for just the region portion of the ISO file
-                int numBytes;
-                using MD5 md5 = MD5.Create();
-                int regionSectors = (int)(RegionEnd[i] - RegionStart[i]) + 1;
-                for (int j = bufSectors; j <= regionSectors; j += bufSectors)
-                {
-                    // Read into buffer
-                    numBytes = fs.Read(buf, 0, buf.Length);
-                    // TODO: Process partial buffer if non-zero is returned
-                    if (numBytes < buf.Length)
-                        throw new InvalidFileSystemException("Disc region ended unexpectedly");
-
-                    // Process MD5 sum
-                    md5.TransformBlock(buf, 0, buf.Length, null, 0);
-                }
-
-                // Read any remaining sectors
-                int bufRemainder = (int)(SectorSize * (regionSectors % bufSectors));
-                if (bufRemainder != 0)
-                {
-                    numBytes = fs.Read(buf, 0, bufRemainder);
-                    // TODO: Process partial buffer if non-zero is returned
-                    if (numBytes < bufRemainder)
-                        throw new InvalidFileSystemException("Disc region ended unexpectedly");
-                }
-
-                // Compute and store MD5 hash of region
-                md5.TransformFinalBlock(buf, 0, bufRemainder);
-                RegionHashes[i] = md5.Hash;
-            }
         }
 
         /// <summary>
-        /// Determine and store hashes for all files and files within subdirectories recursively
+        /// Determine and store file extents for all files and files within subdirectories recursively
         /// </summary>
-        /// <param name="reader"></param>
+        /// <param name="fs">ISO filestream</param>
-        /// <param name="path"></param>
+        /// <param name="reader">CDReader</param>
-        private void HashFiles(FileStream fs, CDReader reader, DiscDirectoryInfo dir)
+        /// <param name="dir">Folder to search for files within</param>
+        private void GetFiles(FileStream fs, CDReader reader, DiscDirectoryInfo dir)
         {
             // Process all files in current directory
             foreach (DiscFileInfo fileInfo in dir.GetFiles())
@@ -942,25 +918,25 @@ namespace LibIRD
                 string filePath = fileInfo.FullName;
 
                 // Determine the extents of the file via clusters
-                Range<long, long>[] fileClusters = reader.PathToClusters(filePath);
+                Range<long, long>[] fileExtent = reader.PathToClusters(filePath);
 
                 // If invalid clusters were returned, we can't hash this file
-                if (fileClusters == null && fileClusters.Length == 0)
+                if (fileExtent == null && fileExtent.Length == 0)
                     throw new InvalidFileSystemException($"Unexpected file extents for {filePath}");
 
                 // Determine smallest file offset as first sector
-                long smallestOffset = fileClusters[0].Offset;
+                long smallestOffset = fileExtent[0].Offset;
                 bool nonContiguous = false;
-                for (int i = 1; i < fileClusters.Length; i++)
+                for (int i = 1; i < fileExtent.Length; i++)
                 {
-                    if (fileClusters[i] == null)
+                    if (fileExtent[i] == null)
                         throw new InvalidFileSystemException($"Unexpected file extents for {filePath}");
 
-                    if (fileClusters[i].Offset * SectorSize != fileClusters[i - 1].Offset * SectorSize + fileClusters[i - 1].Count)
+                    if (fileExtent[i].Offset * SectorSize != fileExtent[i - 1].Offset * SectorSize + fileExtent[i - 1].Count)
                         nonContiguous = true;
 
-                    if (fileClusters[i].Offset < smallestOffset)
+                    if (fileExtent[i].Offset < smallestOffset)
-                        smallestOffset = fileClusters[i].Offset;
+                        smallestOffset = fileExtent[i].Offset;
                 }
 
                 // If already encountered file offset, skip this file
@@ -969,74 +945,16 @@ namespace LibIRD
                 else if (nonContiguous)
                     Console.WriteLine($"Non-contiguous file found: {filePath}");
 
-                // Add file offset to keys
+                // Add file offset to keys and extents to extents
                 FileKeys[FileCount] = smallestOffset;
-
+                FileExtents[FileCount] = fileExtent;
-                // Determine whether file is in encrypted or decrypted region
-                bool encrypted = false;
-                for (int i = RegionCount - 1; i > 0; i--)
-                {
-                    if (RegionStart[i] <= smallestOffset)
-                    {
-                        encrypted = i % 2 == 1;
-                        break;
-                    }
-                }
-
-                // Read one sector at a time for small files
-                int bufSectors = (fileClusters[0].Count < 1024 * SectorSize) ? 1 : 1024;
-                byte[] buf = new byte[bufSectors * SectorSize];
-
-                // Hash each non-contiguous portion of the file
-                using MD5 md5 = MD5.Create();
-                for (int i = 0; i < fileClusters.Length; i++)
-                {
-                    // Start reading data from the beginning of the current extent
-                    fs.Seek(fileClusters[i].Offset * SectorSize, SeekOrigin.Begin);
-                    int numBytes;
-                    // Read file in buffers
-                    long fileSectors = fileClusters[i].Count / SectorSize;
-                    for (int j = 0; j <= fileSectors - bufSectors; j += bufSectors)
-                    {
-                        numBytes = fs.Read(buf, 0, buf.Length);
-                        // TODO: Process partial buffer if non-zero is returned
-                        if (numBytes != buf.Length)
-                            throw new InvalidFileSystemException("Disc region ended unexpectedly");
-
-                        // Decrypt buffer if necessary
-                        if (encrypted)
-                            DecryptSectors(ref buf, (int)fileClusters[i].Offset + j);
-
-                        // Hash sector
-                        md5.TransformBlock(buf, 0, buf.Length, null, 0);
-                    }
-                    // Read remaining partial buffer
-                    if ((fileClusters[i].Count % buf.Length) > 0)
-                    {
-                        numBytes = fs.Read(buf, 0, buf.Length);
-                        // TODO: Process partial buffer if non-zero is returned
-                        if (numBytes != buf.Length)
-                            throw new InvalidFileSystemException("Disc region ended unexpectedly");
-
-                        // Decrypt buffer if necessary
-                        if (encrypted)
-                            DecryptSectors(ref buf, (int)fileClusters[i].Offset + bufSectors * (int)(fileClusters[i].Count / buf.Length));
-
-                        // Hash partial buffer
-                        md5.TransformBlock(buf, 0, (int)(fileClusters[i].Count % buf.Length), null, 0);
-                    }
-                }
-
-                // Finalise and store MD5 hash
-                md5.TransformFinalBlock(buf, 0, 0);
-                FileHashes[FileCount] = md5.Hash;
                 FileCount++;
             }
 
             // Recursively process all subfolders of current directory
             foreach (DiscDirectoryInfo dirInfo in dir.GetDirectories())
             {
-                HashFiles(fs, reader, dirInfo);
+                GetFiles(fs, reader, dirInfo);
             }
         }
 
@@ -1044,15 +962,25 @@ namespace LibIRD
         /// Decrypts a given byte array of sector(s)
         /// </summary>
         /// <param name="buffer">Byte array to be decrypted</param>
-        /// <param name="offset">Number of bytes to decrypt</param>
+        /// <param name="sectorNumber">Sector number of first sector being decrypted</param>
+        /// <param name="offset">Number of sectors to skip</param>
+        /// <param name="count">Number of sectors to decrypt, beginning from offset</param>
         /// <exception cref="InvalidOperationException"></exception>
-        private protected void DecryptSectors(ref byte[] buffer, int sectorNumber)
+        private protected void DecryptSectors(ref byte[] buffer, int sectorNumber, int offset = 0, int? count = null)
         {
             ArgumentNullException.ThrowIfNull(buffer);
 
             if (buffer.Length == 0 || buffer.Length % SectorSize != 0)
                 throw new ArgumentException("Encrypted buffer must be multiple of SectorSize");
 
+            if (offset < 0 || offset >= buffer.Length / SectorSize)
+                throw new ArgumentException("Offset sector must be within buffer");
+
+            count ??= (int)(buffer.Length / SectorSize) - offset;
+
+            if (count < 0 || count > (buffer.Length / SectorSize) - offset)
+                throw new ArgumentException("Number of sectors must be within buffer");
+
             // Setup AES decryption
             using Aes aes = Aes.Create() ?? throw new InvalidOperationException("AES not available. Change your system settings");
             // Set AES settings
@@ -1060,8 +988,11 @@ namespace LibIRD
             aes.Padding = PaddingMode.None;
             aes.Mode = CipherMode.CBC;
 
+            // Convert offset and count to number of bytes
+            offset *= (int)SectorSize;
+            count *= (int)SectorSize;
             // Decrypt buffer one sector at a time
-            for (int i = 0; i < buffer.Length; i += (int)SectorSize)
+            for (int i = offset; i < offset + count; i += (int)SectorSize)
             {
                 // Determine AES Initial Value based on sector number
                 byte[] iv = new byte[16];
@@ -1097,6 +1028,200 @@ namespace LibIRD
                 CountFiles(dirInfo);
         }
 
+        /// <summary>
+        /// Calculate hashes for all region and file extents
+        /// </summary>
+        /// <param name="fs">ISO filestream</param>
+        /// <param name="redump">True if also calculating CRC32 of entire ISO</param>
+        private void HashISO(FileStream fs, bool redump)
+        {
+            // Initialise CRC32 ISO hasher, only used if making redump-style IRD
+            byte[] crc32;
+            Crc32 isoHasher = new();
+
+            // Initialise MD5 region hashes
+            List<int> regions = [];
+            MD5[] regionMD5 = new MD5[RegionCount];
+            for (int i = 0; i < RegionCount;  i++)
+            {
+                regions.Add(i);
+                regionMD5[i] = MD5.Create();
+            }
+
+            // Initialise MD5 file hashes
+            List<int> files = [];
+            MD5[] fileMD5 = new MD5[FileCount];
+            for (int i = 0; i < FileCount; i++)
+            {
+                files.Add(i);
+                fileMD5[i] = MD5.Create();
+            }
+
+            // Start hashing from beginning of ISO
+            long currentSector = 0;
+            fs.Seek(currentSector, SeekOrigin.Begin);
+
+            // Read from ISO, 1024 sectors at a time
+            int bufSectors = 1024;
+            byte[] buf = new byte[bufSectors * SectorSize];
+            while (true)
+            {
+                // Attempt to read a full buffer
+                bufSectors = 1024;
+                int numBytes = fs.Read(buf, 0, buf.Length);
+
+                // If end of ISO reached, stop reading
+                if (numBytes == 0)
+                {
+                    // If making redump-style IRD, save CRC32 hash to UID field
+                    if (redump)
+                    {
+                        crc32 = isoHasher.GetCurrentHash();
+                        UID = BitConverter.ToUInt32(crc32, 0);
+                    }
+                    return;
+                }
+
+                // Keep trying to read to fill buffer, remove once partial buffer hashing is supported
+                if (numBytes != buf.Length)
+                {
+                    while (numBytes % SectorSize != 0)
+                    {
+                        int newNumBytes = fs.Read(buf, numBytes, buf.Length - numBytes);
+                        numBytes += newNumBytes;
+
+                        // If end of ISO reached, trim buffer and hash
+                        if (newNumBytes == 0 && numBytes % SectorSize != 0)
+                        {
+                            //numBytes -= numBytes % (int)SectorSize;
+                            Console.Error.WriteLine("ERROR: ISO filestream ended early");
+                            break;
+                        }
+                    }
+                    // Only hash portion of buffer
+                    bufSectors = numBytes / (int)SectorSize;
+                    if (bufSectors == 0)
+                        Console.Error.WriteLine("ERROR: Trailing partial sector in ISO filestream");
+                    if (numBytes > buf.Length)
+                        throw new InvalidFileSystemException("ERROR: Read more bytes than buffer size???");
+                }
+
+                // Hash ISO
+                if (redump)
+                    isoHasher.Append(new ReadOnlySpan<byte>(buf, 0, numBytes));
+
+                // Hash regions
+                List<int> regionsEnded = [];
+                foreach (int i in regions)
+                {
+                    // Stop hashing regions if current region has not yet started (assumes regions are ordered)
+                    if (RegionStart[i] > currentSector + bufSectors)
+                        break;
+
+                    // Skip region if it has already ended
+                    //if (RegionEnd[i] < currentSector)
+                    //    continue;
+
+                    // Check if region has ended in this buffer [We know: Start is not in the future, Ending is not in the past]
+                    if (RegionEnd[i] < currentSector + bufSectors)
+                    {
+                        // Determine start byte, if region is entirely within the buffer
+                        int startByte = RegionStart[i] > currentSector ? (int)(SectorSize * (RegionStart[i] - currentSector)) : 0;
+                        // Determine end byte
+                        int endByte = (int)(SectorSize * (RegionEnd[i] - currentSector + 1));
+                        // Close region hash
+                        regionMD5[i].TransformFinalBlock(buf, startByte, endByte - startByte);
+                        RegionHashes[i] = regionMD5[i].Hash;
+                        regionMD5[i].Clear();
+                        regionsEnded.Add(i);
+                    }
+                    // Check if region has already begun
+                    else if (RegionStart[i] <= currentSector)
+                    {
+                        // Hash buffer
+                        regionMD5[i].TransformBlock(buf, 0, (int)SectorSize * bufSectors, null, 0);
+                    }
+                    // Region Start is in this buffer, ending is in the future
+                    else
+                    {
+                        // Hash partial buffer
+                        int regionStart = (int)(SectorSize * (RegionStart[i] - currentSector));
+                        regionMD5[i].TransformBlock(buf, regionStart, (int)SectorSize * bufSectors - regionStart, null, 0);
+                    }
+                }
+                if (regionsEnded.Count > 0)
+                    regions.RemoveAll(item => regionsEnded.Contains(item));
+
+                // Decrypt any encrypted sectors of buffer
+                for (int i = 1; i < RegionCount; i += 2)
+                {
+                    // If the current encrypted region is within the buffer
+                    if (RegionStart[i] < currentSector + bufSectors
+                        && RegionEnd[i] >= currentSector)
+                    {
+                        // First sector to decrypt from
+                        int encOffset = 0;
+
+                        // Don't decrypt initial sectors if the encrypted region starts within this buffer
+                        if (RegionStart[i] > currentSector)
+                            encOffset = (int)(RegionStart[i] - currentSector);
+
+                        // Number of sectors to decrypt
+                        int encCount = bufSectors - encOffset;
+
+                        // Don't decrypt last sectors if the encrypted region ends within this buffer
+                        if (RegionEnd[i] < currentSector + bufSectors)
+                            encCount -= (int)(currentSector + bufSectors - RegionEnd[i] + 1);
+
+                        // Decrypt encrypted sectors
+                        DecryptSectors(ref buf, (int)currentSector + encOffset, encOffset, encCount);
+                    }
+                }
+
+                // Hash files
+                List<int> filesEnded = [];
+                foreach (int i in files)
+                {
+                    // Stop hashing files if current file has not yet started (assumes FileKeys are sorted)
+                    if (FileKeys[i] > currentSector + bufSectors)
+                        break;
+
+                    // Hash each file extent for each file
+                    for (int j = 0; j < FileExtents[i].Length; j++)
+                    {
+                        // Skip hashing file extent if it has not yet started or already ended
+                        if (FileExtents[i][j].Offset > currentSector + bufSectors
+                            || SectorSize* FileExtents[i][j].Offset + FileExtents[i][j].Count < SectorSize * currentSector)
+                            continue;
+                        // Determine first file byte location in buffer
+                        int startByte = FileExtents[i][j].Offset > currentSector ? (int)(SectorSize * (FileExtents[i][j].Offset - currentSector)) : 0;
+                        // Determine last file byte location in buffer
+                        int endByte = (int)(FileExtents[i][j].Count - SectorSize * (currentSector - FileExtents[i][j].Offset));
+                        // Don't hash more than the buffer size
+                        endByte = endByte < bufSectors * (int)SectorSize ? endByte : bufSectors * (int)SectorSize;
+                        // Hash portion of buffer that file exists in
+                        fileMD5[i].TransformBlock(buf, startByte, endByte - startByte, null, 0);
+                    }
+
+                    // Check if current file has ended in this buffer (assumes last extent contains last byte)
+                    long lastByte = SectorSize * FileExtents[i][^1].Offset + FileExtents[i][^1].Count;
+                    if (lastByte < SectorSize * (currentSector + bufSectors)
+                        && lastByte > SectorSize * currentSector)
+                    {
+                        // Close file hash
+                        fileMD5[i].TransformFinalBlock(buf, 0, 0);
+                        FileHashes[i] = fileMD5[i].Hash;
+                        fileMD5[i].Clear();
+                        filesEnded.Add(i);
+                    }
+                }
+                if (filesEnded.Count > 0)
+                    files.RemoveAll(item => filesEnded.Contains(item));
+
+                currentSector += bufSectors;
+            }            
+        }
+
         #endregion
 
         #region IRD File
@@ -1164,7 +1289,12 @@ namespace LibIRD
 
                 // Hashes for each region
                 for (int i = 0; i < RegionCount; i++)
-                    bw.Write(RegionHashes[i], 0, 16);
+                {
+                    if (RegionHashes[i] == null)
+                        bw.Write(NullMD5);
+                    else
+                        bw.Write(RegionHashes[i], 0, 16);
+                }
 
                 // Number of files hashed
                 bw.Write(FileCount);

LibIRD/LibIRD.csproj

@@ -6,7 +6,7 @@
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
     <LangVersion>latest</LangVersion>
 	<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <Version>0.5.0</Version>
+    <Version>0.6.0</Version>
     <PackageOutputPath>../nupkg</PackageOutputPath>
     
     <!-- Package Properties -->

LibIRD/ReIRD.cs

@@ -59,11 +59,7 @@ namespace LibIRD
         /// </summary>
         /// <param name="isoPath">Path to the ISO</param>
         /// <param name="getKeyLog">Path to the GetKey log file</param>
-        public ReIRD(string isoPath, string getKeyLog) : base(isoPath, getKeyLog, true)
+        public ReIRD(string isoPath, string getKeyLog) : base(isoPath, getKeyLog, true) { }
-        {
-            // Generate Unique Identifier using ISO CRC32
-            UID = GenerateUID(isoPath);
-        }
 
         /// <summary>
         /// Constructor with optional additional region to generate a specific Disc ID
@@ -75,8 +71,8 @@ namespace LibIRD
         /// <param name="region">Disc Region</param>
         public ReIRD(string isoPath, byte[] key, long? layerbreak = null, uint? uid = null, Region region = Region.NONE) : base()
         {
-            // Generate Unique Identifier using ISO CRC32
+            // If the ISO CRC32 is provided, use it as the Unique ID
-            UID = uid == null ? GenerateUID(isoPath) : (uint)uid;
+            UID = uid == null ? 0x00000000 : (uint)uid;
 
             // Determine ISO file size
             long size = CalculateSize(isoPath);
@@ -135,7 +131,7 @@ namespace LibIRD
                 if (layerbreak >= 2 * BDLayerSize || layerbreak % SectorSize != 0)
                     throw new ArgumentException("Unexpected layerbreak value", nameof(size));
             }
-            else
+            else if (size > BDLayerSize)
             {
                 // If no layerbreak provided, ensure ISO is not BD-Video hybrid
                 using FileStream fs = new FileStream(isoPath, FileMode.Open, FileAccess.Read) ?? throw new FileNotFoundException(isoPath);