Add support for Blake3 chunk hashes

Author: xPaw

ValvePak/ValvePak.Test/Files/fall_2025_rewardfx.vpk

@@ -488,6 +488,30 @@ public void ThrowsDueToMissingPakFile()
 			Assert.Throws<FileNotFoundException>(() => package.VerifyChunkHashes());
 		}
 
+		[Test]
+		public void TestVerifyChunkHashes()
+		{
+			var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Files", "fall_2025_rewardfx.vpk");
+
+			using var package = new Package();
+			package.Read(path);
+
+			Assert.DoesNotThrow(package.VerifyHashes);
+			Assert.DoesNotThrow(() => package.VerifyChunkHashes(null));
+		}
+
+		[Test]
+		public void TestVerifyChunkHashesBlake3()
+		{
+			var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Files", "monster_hunter_dashboard_balek3_chunk_hash.vpk");
+
+			using var package = new Package();
+			package.Read(path);
+
+			Assert.DoesNotThrow(package.VerifyHashes);
+			Assert.DoesNotThrow(() => package.VerifyChunkHashes(null));
+		}
+
 		private static void TestVPKExtraction(string path)
 		{
 			using var package = new Package();

ValvePak/ValvePak.Test/Files/monster_hunter_dashboard_balek3_chunk_hash.vpk

@@ -1,14 +1,19 @@
 namespace SteamDatabase.ValvePak
 {
 	/// <summary>
-	/// Represents an entry in the VPK archive MD5 section, containing checksum information for a chunk of archive data.
+	/// Represents an entry in the VPK archive hashes section, containing checksum information for a chunk of archive data.
 	/// </summary>
-	public class ArchiveMD5SectionEntry
+	public class ChunkHashFraction
 	{
 		/// <summary>
 		/// Gets or sets the archive index.
 		/// </summary>
-		public required uint ArchiveIndex { get; set; }
+		public required ushort ArchiveIndex { get; set; }
+
+		/// <summary>
+		/// Gets or sets the hash algorithm type used for this entry.
+		/// </summary>
+		public required EHashType HashType { get; set; }
 
 		/// <summary>
 		/// Gets or sets the offset in the package.

ValvePak/ValvePak.Test/PackageTest.cs

@@ -0,0 +1,20 @@
+namespace SteamDatabase.ValvePak
+{
+	/// <summary>
+	/// Represents the hash algorithm type used in VPK archive MD5 section entries.
+	/// </summary>
+#pragma warning disable CA1028 // Enum Storage should be Int32
+	public enum EHashType : ushort
+#pragma warning restore CA1028
+	{
+		/// <summary>
+		/// MD5 hash algorithm.
+		/// </summary>
+		MD5 = 0,
+
+		/// <summary>
+		/// Blake3 hash algorithm.
+		/// </summary>
+		Blake3 = 1,
+	}
+}

…vePak/ValvePak/ArchiveMD5SectionEntry.cs ValvePak/ValvePak/ChunkHashFraction.csValvePak/ValvePak/ArchiveMD5SectionEntry.cs renamed to ValvePak/ValvePak/ChunkHashFraction.cs ValvePak/ValvePak/ArchiveMD5SectionEntry.cs renamed to ValvePak/ValvePak/ChunkHashFraction.cs

@@ -109,10 +109,10 @@ public void ReadEntry(PackageEntry entry, out byte[] output, bool validateCrc =
 		/// <param name="validateCrc">If true, CRC32 will be calculated and verified for read data.</param>
 		public void ReadEntry(PackageEntry entry, byte[] output, bool validateCrc = true)
 		{
-            ArgumentNullException.ThrowIfNull(entry);
-            ArgumentNullException.ThrowIfNull(output);
+			ArgumentNullException.ThrowIfNull(entry);
+			ArgumentNullException.ThrowIfNull(output);
 
-            var totalLength = (int)entry.TotalLength;
+			var totalLength = (int)entry.TotalLength;
 
 			if (output.Length < totalLength)
 			{
@@ -145,7 +145,7 @@ public void ReadEntry(PackageEntry entry, byte[] output, bool validateCrc = true
 				}
 				finally
 				{
-                    if (entry.ArchiveIndex != 0x7FFF)
+					if (entry.ArchiveIndex != 0x7FFF)
 					{
 						fs.Dispose();
 					}
@@ -263,23 +263,32 @@ private void ReadArchiveMD5Section()
 
 			if (ArchiveMD5SectionSize == 0)
 			{
-				ArchiveMD5Entries = [];
+				AccessPackFileHashes = [];
 				return;
 			}
 
 			var entries = (int)(ArchiveMD5SectionSize / 28); // 28 is sizeof(VPK_MD5SectionEntry), which is int + int + int + 16 chars
 
-			ArchiveMD5Entries = new List<ArchiveMD5SectionEntry>(entries);
+			AccessPackFileHashes = new List<ChunkHashFraction>(entries);
 
 			for (var i = 0; i < entries; i++)
 			{
-				ArchiveMD5Entries.Add(new ArchiveMD5SectionEntry
+				var hashFraction = new ChunkHashFraction
 				{
-					ArchiveIndex = Reader.ReadUInt32(),
+					ArchiveIndex = Reader.ReadUInt16(),
+					HashType = (EHashType)Reader.ReadUInt16(),
 					Offset = Reader.ReadUInt32(),
 					Length = Reader.ReadUInt32(),
 					Checksum = Reader.ReadBytes(16)
-				});
+				};
+
+				if (hashFraction.ArchiveIndex == 0 && hashFraction.HashType == (EHashType)0x8000)
+				{
+					hashFraction.ArchiveIndex = 0x7FFF;
+					hashFraction.HashType = EHashType.MD5;
+				}
+
+				AccessPackFileHashes.Add(hashFraction);
 			}
 		}
 
@@ -355,10 +364,10 @@ private Stream GetFileStream(ushort archiveIndex)
 		/// <param name="entry">Package entry.</param>
 		/// <returns>Stream for a given package entry contents.</returns>
 		public Stream GetMemoryMappedStreamIfPossible(PackageEntry entry)
-        {
-            ArgumentNullException.ThrowIfNull(entry);
+		{
+			ArgumentNullException.ThrowIfNull(entry);
 
-            if (entry.Length <= 4096 || entry.SmallData.Length > 0)
+			if (entry.Length <= 4096 || entry.SmallData.Length > 0)
 			{
 				ReadEntry(entry, out var output, false);
 				return new MemoryStream(output);

ValvePak/ValvePak/EHashType.cs

@@ -55,7 +55,7 @@ public override long Position
 		private uint FileSizeBeforeWholeFileHash;
 
 		/// <summary>
-		/// Gets the size in bytes of the whole file before <see cref="ArchiveMD5Entries"/>.
+		/// Gets the size in bytes of the whole file before <see cref="AccessPackFileHashes"/>.
 		/// </summary>
 		private uint FileSizeBeforeArchiveMD5Entries;
 
@@ -105,60 +105,84 @@ public void VerifyHashes()
 		}
 
 		/// <summary>
-		/// Verify MD5 hashes of individual chunk files provided in the VPK.
+		/// Verify hashes of individual chunk files provided in the VPK.
 		/// </summary>
 		/// <param name="progressReporter">If provided, will report a string with the current verification progress.</param>
 		public void VerifyChunkHashes(IProgress<string>? progressReporter = null)
 		{
 			Stream? stream = null;
-			var lastArchiveIndex = uint.MaxValue;
+			var lastArchiveIndex = ushort.MaxValue;
 
 			// When created by Valve, entries are sorted, and are 1MB chunks
-			var allEntries = ArchiveMD5Entries
+			var allEntries = AccessPackFileHashes
 				.OrderBy(file => file.Offset)
 				.GroupBy(file => file.ArchiveIndex)
 				.OrderBy(x => x.Key)
 				.SelectMany(x => x);
 
+			Span<byte> hash = stackalloc byte[16];
+
 			try
 			{
 				foreach (var entry in allEntries)
 				{
-					if (entry.ArchiveIndex > short.MaxValue)
+					var hashTypeName = entry.HashType switch
 					{
-						throw new InvalidDataException("Unexpected archive index");
-					}
+						EHashType.Blake3 => "Blake3",
+						EHashType.MD5 => "MD5",
+						_ => string.Empty,
+					};
 
-					progressReporter?.Report($"Verifying MD5 hash at offset {entry.Offset} in archive {entry.ArchiveIndex}.");
+					progressReporter?.Report($"Verifying {hashTypeName} hash at offset {entry.Offset} in archive {entry.ArchiveIndex}.");
 
-					if (lastArchiveIndex != entry.ArchiveIndex)
+					if (stream == null || lastArchiveIndex != entry.ArchiveIndex)
 					{
 						if (lastArchiveIndex != 0x7FFF)
 						{
 							stream?.Close();
 						}
 
-						stream = GetFileStream((ushort)entry.ArchiveIndex);
+						stream = GetFileStream(entry.ArchiveIndex);
 						lastArchiveIndex = entry.ArchiveIndex;
 					}
 					else
 					{
-						Debug.Assert(stream != null); // what's actually happening here? did we miss assigning stream to Reader.BaseStream?
-
 						var offset = entry.ArchiveIndex == 0x7FFF ? HeaderSize + TreeSize : 0;
 						stream.Seek(offset, SeekOrigin.Begin);
 					}
 
 					using var subStream = new SubStream(stream, stream.Position + entry.Offset, entry.Length);
-					var hash = MD5.HashData(subStream);
+
+					switch (entry.HashType)
+					{
+						case EHashType.Blake3:
+							using (var hasher = Blake3.Hasher.New())
+							{
+								var buffer = new byte[8192]; // TODO: Fix this alloc
+								int bytesRead;
+								while ((bytesRead = subStream.Read(buffer, 0, buffer.Length)) > 0)
+								{
+									hasher.UpdateWithJoin(buffer.AsSpan(0, bytesRead));
+								}
+								hasher.Finalize(hash);
+							}
+							break;
+
+						case EHashType.MD5:
+							MD5.HashData(subStream, hash);
+							break;
+
+						default:
+							throw new InvalidDataException($"Unrecognized hash type: {entry.HashType} ({(ushort)entry.HashType})");
+					}
 
 					if (!hash.SequenceEqual(entry.Checksum))
 					{
-						throw new InvalidDataException($"Package checksum mismatch in archive {entry.ArchiveIndex} at {entry.Offset} ({BitConverter.ToString(hash)} != expected {BitConverter.ToString(entry.Checksum)})");
+						throw new InvalidDataException($"Package checksum mismatch ({hashTypeName}) in archive {entry.ArchiveIndex} at {entry.Offset} ({Convert.ToHexString(hash)} != expected {Convert.ToHexString(entry.Checksum)})");
 					}
 				}
 
-				progressReporter?.Report("Successfully verified archive MD5 hashes.");
+				progressReporter?.Report("Successfully verified archive hashes.");
 			}
 			finally
 			{

ValvePak/ValvePak/Package.Read.cs

@@ -106,7 +106,7 @@ public partial class Package : IDisposable
 		/// <summary>
 		/// Gets the archive MD5 checksum section entries. Also known as cache line hashes.
 		/// </summary>
-		public List<ArchiveMD5SectionEntry> ArchiveMD5Entries { get; private set; } = [];
+		public List<ChunkHashFraction> AccessPackFileHashes { get; private set; } = [];
 
 		private CaseInsensitivePackageEntryComparer? Comparer;
 

ValvePak/ValvePak/Package.Verify.cs

@@ -18,7 +18,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.IO.Hashing" Version="9.0.10" />
+    <PackageReference Include="Blake3" Version="2.0.0">
+        <NoWarn>CS8002</NoWarn>
+	</PackageReference>
+    <PackageReference Include="System.IO.Hashing" Version="9.0.11" />
   </ItemGroup>
 
   <ItemGroup>