From 79b43e8e72866f450dee8b59510cb5767b1491ec Mon Sep 17 00:00:00 2001
From: Vitek Karas <10670590+vitek-karas@users.noreply.github.com>
Date: Thu, 20 Jan 2022 00:58:10 +0100
Subject: [PATCH] Fix deterministic MVID and add PdbChecksum (#810)

* Fix deterministic MVID and add PdbChecksum (#31)

* Fix how pdb path is calculated in the tests

* Fix portable PDB stamp in CodeView header (#32)

* Introduce ISymbolWriter.Write

This mostly cleans up the code to make it easier to understand. `ISymbolWriter.GetDebugHeader` no longer actually writes the symbols, there's a new `Write` method for just that.

The assembly writer calls `Write` first and then the image writer calls `GetDebugHeader` when it's needed.

This is partially taken from https://github.com/jbevain/cecil/pull/617.
---
 Mono.Cecil.Cil/PortablePdb.cs                 | 189 +++++++---
 Mono.Cecil.Cil/Symbols.cs                     |   7 +
 Mono.Cecil.PE/ImageReader.cs                  |   5 +-
 Mono.Cecil.PE/ImageWriter.cs                  |  12 +-
 Mono.Cecil/AssemblyWriter.cs                  |  46 +--
 Mono.Security.Cryptography/CryptoService.cs   |   2 +-
 Test/Mono.Cecil.Tests/ImageReadTests.cs       |  18 +-
 Test/Mono.Cecil.Tests/PortablePdbTests.cs     | 330 +++++++++++++++++-
 .../assemblies/EmbeddedPdbChecksumLib.dll     | Bin 0 -> 9728 bytes
 Test/Resources/assemblies/PdbChecksumLib.dll  | Bin 0 -> 4096 bytes
 Test/Resources/assemblies/PdbChecksumLib.pdb  | Bin 0 -> 9576 bytes
 symbols/mdb/Mono.Cecil.Mdb/MdbWriter.cs       |   6 +
 symbols/pdb/Mono.Cecil.Pdb/NativePdbWriter.cs |  17 +-
 13 files changed, 542 insertions(+), 90 deletions(-)
 create mode 100644 Test/Resources/assemblies/EmbeddedPdbChecksumLib.dll
 create mode 100644 Test/Resources/assemblies/PdbChecksumLib.dll
 create mode 100644 Test/Resources/assemblies/PdbChecksumLib.pdb

diff --git a/Mono.Cecil.Cil/PortablePdb.cs b/Mono.Cecil.Cil/PortablePdb.cs
index aff6b2937..6664bee32 100644
--- a/Mono.Cecil.Cil/PortablePdb.cs
+++ b/Mono.Cecil.Cil/PortablePdb.cs
@@ -12,7 +12,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
-
+using System.Security.Cryptography;
 using Mono.Cecil.Metadata;
 using Mono.Cecil.PE;
 
@@ -39,7 +39,7 @@ public ISymbolReader GetSymbolReader (ModuleDefinition module, Stream symbolStre
 
 		ISymbolReader GetSymbolReader (ModuleDefinition module, Disposable<Stream> symbolStream, string fileName)
 		{
-			return new PortablePdbReader (ImageReader.ReadPortablePdb (symbolStream, fileName), module);
+			return new PortablePdbReader (ImageReader.ReadPortablePdb (symbolStream, fileName, out _), module);
 		}
 	}
 
@@ -234,8 +234,8 @@ public ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fileName)
 			Mixin.CheckModule (module);
 			Mixin.CheckFileName (fileName);
 
-			var file = File.OpenWrite (Mixin.GetPdbFileName (fileName));
-			return GetSymbolWriter (module, Disposable.Owned (file as Stream));
+			var file = File.Open (Mixin.GetPdbFileName (fileName), FileMode.OpenOrCreate, FileAccess.ReadWrite);
+			return GetSymbolWriter (module, Disposable.Owned (file as Stream), Disposable.NotOwned ((Stream)null));
 		}
 
 		public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStream)
@@ -243,15 +243,18 @@ public ISymbolWriter GetSymbolWriter (ModuleDefinition module, Stream symbolStre
 			Mixin.CheckModule (module);
 			Mixin.CheckStream (symbolStream);
 
-			return GetSymbolWriter (module, Disposable.NotOwned (symbolStream));
+			// In order to compute the PDB checksum, the stream we're writing to needs to be able to
+			// seek and read as well. We can't assume this about a stream provided by the user.
+			// So in this case, create a memory stream to cache the PDB.
+			return GetSymbolWriter (module, Disposable.Owned (new MemoryStream() as Stream), Disposable.NotOwned (symbolStream));
 		}
 
-		ISymbolWriter GetSymbolWriter (ModuleDefinition module, Disposable<Stream> stream)
+		ISymbolWriter GetSymbolWriter (ModuleDefinition module, Disposable<Stream> stream, Disposable<Stream> final_stream)
 		{
 			var metadata = new MetadataBuilder (module, this);
 			var writer = ImageWriter.CreateDebugWriter (module, metadata, stream);
 
-			return new PortablePdbWriter (metadata, module, writer);
+			return new PortablePdbWriter (metadata, module, writer, final_stream);
 		}
 	}
 
@@ -260,9 +263,14 @@ public sealed class PortablePdbWriter : ISymbolWriter {
 		readonly MetadataBuilder pdb_metadata;
 		readonly ModuleDefinition module;
 		readonly ImageWriter writer;
+		readonly Disposable<Stream> final_stream;
 
 		MetadataBuilder module_metadata;
 
+		internal byte [] pdb_checksum;
+		internal Guid pdb_id_guid;
+		internal uint pdb_id_stamp;
+
 		bool IsEmbedded { get { return writer == null; } }
 
 		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module)
@@ -278,10 +286,11 @@ internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition modul
 			pdb_metadata.AddCustomDebugInformations (module);
 		}
 
-		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer)
+		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer, Disposable<Stream> final_stream)
 			: this (pdb_metadata, module)
 		{
 			this.writer = writer;
+			this.final_stream = final_stream;
 		}
 
 		public ISymbolReaderProvider GetReaderProvider ()
@@ -289,45 +298,88 @@ public ISymbolReaderProvider GetReaderProvider ()
 			return new PortablePdbReaderProvider ();
 		}
 
+		public void Write (MethodDebugInformation info)
+		{
+			CheckMethodDebugInformationTable ();
+
+			pdb_metadata.AddMethodDebugInformation (info);
+		}
+
+		public void Write ()
+		{
+			if (IsEmbedded)
+				return;
+
+			WritePdbFile ();
+
+			if (final_stream.value != null) {
+				writer.BaseStream.Seek (0, SeekOrigin.Begin);
+				var buffer = new byte [8192];
+				CryptoService.CopyStreamChunk (writer.BaseStream, final_stream.value, buffer, (int)writer.BaseStream.Length);
+			}
+		}
+
 		public ImageDebugHeader GetDebugHeader ()
 		{
 			if (IsEmbedded)
 				return new ImageDebugHeader ();
 
-			var directory = new ImageDebugDirectory () {
-				MajorVersion = 256,
-				MinorVersion = 20557,
-				Type = ImageDebugType.CodeView,
-				TimeDateStamp = (int) module.timestamp,
-			};
-
-			var buffer = new ByteBuffer ();
-			// RSDS
-			buffer.WriteUInt32 (0x53445352);
-			// Module ID
-			buffer.WriteBytes (module.Mvid.ToByteArray ());
-			// PDB Age
-			buffer.WriteUInt32 (1);
-			// PDB Path
-			var fileName = writer.BaseStream.GetFileName ();
-			if (string.IsNullOrEmpty (fileName)) {
-				fileName = module.Assembly.Name.Name + ".pdb";
+			ImageDebugHeaderEntry codeViewEntry;
+			{
+				var codeViewDirectory = new ImageDebugDirectory () {
+					MajorVersion = 256,
+					MinorVersion = 20557,
+					Type = ImageDebugType.CodeView,
+					TimeDateStamp = (int)pdb_id_stamp,
+				};
+
+				var buffer = new ByteBuffer ();
+				// RSDS
+				buffer.WriteUInt32 (0x53445352);
+				// Module ID
+				buffer.WriteBytes (pdb_id_guid.ToByteArray ());
+				// PDB Age
+				buffer.WriteUInt32 (1);
+				// PDB Path
+				var fileName = writer.BaseStream.GetFileName ();
+				if (string.IsNullOrEmpty (fileName)) {
+					fileName = module.Assembly.Name.Name + ".pdb";
+				}
+				buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes (fileName));
+				buffer.WriteByte (0);
+
+				var data = new byte [buffer.length];
+				Buffer.BlockCopy (buffer.buffer, 0, data, 0, buffer.length);
+				codeViewDirectory.SizeOfData = data.Length;
+
+				codeViewEntry = new ImageDebugHeaderEntry (codeViewDirectory, data);
 			}
-			buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes (fileName));
-			buffer.WriteByte (0);
 
-			var data = new byte [buffer.length];
-			Buffer.BlockCopy (buffer.buffer, 0, data, 0, buffer.length);
-			directory.SizeOfData = data.Length;
+			ImageDebugHeaderEntry pdbChecksumEntry;
+			{
+				var pdbChecksumDirectory = new ImageDebugDirectory () {
+					MajorVersion = 1,
+					MinorVersion = 0,
+					Type = ImageDebugType.PdbChecksum,
+					TimeDateStamp = 0
+				};
 
-			return new ImageDebugHeader (new ImageDebugHeaderEntry (directory, data));
-		}
+				var buffer = new ByteBuffer ();
+				// SHA256 - Algorithm name
+				buffer.WriteBytes (System.Text.Encoding.UTF8.GetBytes ("SHA256"));
+				buffer.WriteByte (0);
 
-		public void Write (MethodDebugInformation info)
-		{
-			CheckMethodDebugInformationTable ();
+				// Checksum - 32 bytes
+				buffer.WriteBytes (pdb_checksum);
 
-			pdb_metadata.AddMethodDebugInformation (info);
+				var data = new byte [buffer.length];
+				Buffer.BlockCopy (buffer.buffer, 0, data, 0, buffer.length);
+				pdbChecksumDirectory.SizeOfData = data.Length;
+
+				pdbChecksumEntry = new ImageDebugHeaderEntry (pdbChecksumDirectory, data);
+			}
+
+			return new ImageDebugHeader (new ImageDebugHeaderEntry [] { codeViewEntry, pdbChecksumEntry });
 		}
 
 		void CheckMethodDebugInformationTable ()
@@ -343,10 +395,8 @@ void CheckMethodDebugInformationTable ()
 
 		public void Dispose ()
 		{
-			if (IsEmbedded)
-				return;
-
-			WritePdbFile ();
+			writer.stream.Dispose ();
+			final_stream.Dispose ();
 		}
 
 		void WritePdbFile ()
@@ -360,15 +410,18 @@ void WritePdbFile ()
 			writer.WriteMetadata ();
 
 			writer.Flush ();
-			writer.stream.Dispose ();
+
+			ComputeChecksumAndPdbId ();
+
+			WritePdbId ();
 		}
 
 		void WritePdbHeap ()
 		{
 			var pdb_heap = pdb_metadata.pdb_heap;
 
-			pdb_heap.WriteBytes (module.Mvid.ToByteArray ());
-			pdb_heap.WriteUInt32 (module_metadata.timestamp);
+			// PDB ID ( GUID + TimeStamp ) are left zeroed out for now. Will be filled at the end with a hash.
+			pdb_heap.WriteBytes (20);
 
 			pdb_heap.WriteUInt32 (module_metadata.entry_point.ToUInt32 ());
 
@@ -399,6 +452,32 @@ void WriteTableHeap ()
 			pdb_metadata.table_heap.ComputeTableInformations ();
 			pdb_metadata.table_heap.WriteTableHeap ();
 		}
+
+		void ComputeChecksumAndPdbId ()
+		{
+			var buffer = new byte [8192];
+
+			// Compute the has of the entire file - PDB ID is zeroes still
+			writer.BaseStream.Seek (0, SeekOrigin.Begin);
+			var sha256 = SHA256.Create ();
+			using (var crypto_stream = new CryptoStream (Stream.Null, sha256, CryptoStreamMode.Write)) {
+				CryptoService.CopyStreamChunk (writer.BaseStream, crypto_stream, buffer, (int)writer.BaseStream.Length);
+			}
+
+			pdb_checksum = sha256.Hash;
+
+			var hashBytes = new ByteBuffer (pdb_checksum);
+			pdb_id_guid = new Guid (hashBytes.ReadBytes (16));
+			pdb_id_stamp = hashBytes.ReadUInt32 ();
+		}
+
+		void WritePdbId ()
+		{
+			// PDB ID is the first 20 bytes of the PdbHeap
+			writer.MoveToRVA (TextSegment.PdbHeap);
+			writer.WriteBytes (pdb_id_guid.ToByteArray ());
+			writer.WriteUInt32 (pdb_id_stamp);
+		}
 	}
 
 	public sealed class EmbeddedPortablePdbWriterProvider : ISymbolWriterProvider {
@@ -435,9 +514,14 @@ public ISymbolReaderProvider GetReaderProvider ()
 			return new EmbeddedPortablePdbReaderProvider ();
 		}
 
+		public void Write (MethodDebugInformation info)
+		{
+			writer.Write (info);
+		}
+
 		public ImageDebugHeader GetDebugHeader ()
 		{
-			writer.Dispose ();
+			ImageDebugHeader pdbDebugHeader = writer.GetDebugHeader ();
 
 			var directory = new ImageDebugDirectory {
 				Type = ImageDebugType.EmbeddedPortablePdb,
@@ -462,19 +546,22 @@ public ImageDebugHeader GetDebugHeader ()
 
 			directory.SizeOfData = (int) data.Length;
 
-			return new ImageDebugHeader (new [] {
-				writer.GetDebugHeader ().Entries [0],
-				new ImageDebugHeaderEntry (directory, data.ToArray ())
-			});
+			var debugHeaderEntries = new ImageDebugHeaderEntry [pdbDebugHeader.Entries.Length + 1];
+			for (int i = 0; i < pdbDebugHeader.Entries.Length; i++)
+				debugHeaderEntries [i] = pdbDebugHeader.Entries [i];
+			debugHeaderEntries [debugHeaderEntries.Length - 1] = new ImageDebugHeaderEntry (directory, data.ToArray ());
+
+			return new ImageDebugHeader (debugHeaderEntries);
 		}
 
-		public void Write (MethodDebugInformation info)
+		public void Write ()
 		{
-			writer.Write (info);
+			writer.Write ();
 		}
 
 		public void Dispose ()
 		{
+			writer.Dispose ();
 		}
 	}
 
diff --git a/Mono.Cecil.Cil/Symbols.cs b/Mono.Cecil.Cil/Symbols.cs
index 5e92b67fa..744e7a82b 100644
--- a/Mono.Cecil.Cil/Symbols.cs
+++ b/Mono.Cecil.Cil/Symbols.cs
@@ -39,6 +39,7 @@ public enum ImageDebugType {
 		CodeView = 2,
 		Deterministic = 16,
 		EmbeddedPortablePdb = 17,
+		PdbChecksum = 19,
 	}
 
 	public sealed class ImageDebugHeader {
@@ -1114,6 +1115,7 @@ public interface ISymbolWriter : IDisposable {
 		ISymbolReaderProvider GetReaderProvider ();
 		ImageDebugHeader GetDebugHeader ();
 		void Write (MethodDebugInformation info);
+		void Write ();
 	}
 
 	public interface ISymbolWriterProvider {
@@ -1174,6 +1176,11 @@ public static ImageDebugHeaderEntry GetEmbeddedPortablePdbEntry (this ImageDebug
 			return GetEntry (header, ImageDebugType.EmbeddedPortablePdb);
 		}
 
+		public static ImageDebugHeaderEntry GetPdbChecksumEntry (this ImageDebugHeader header)
+		{
+			return GetEntry (header, ImageDebugType.PdbChecksum);
+		}
+
 		private static ImageDebugHeaderEntry GetEntry (this ImageDebugHeader header, ImageDebugType type)
 		{
 			if (!header.HasEntries)
diff --git a/Mono.Cecil.PE/ImageReader.cs b/Mono.Cecil.PE/ImageReader.cs
index 535812924..a34e64d36 100644
--- a/Mono.Cecil.PE/ImageReader.cs
+++ b/Mono.Cecil.PE/ImageReader.cs
@@ -27,6 +27,7 @@ sealed class ImageReader : BinaryStreamReader {
 		DataDirectory metadata;
 
 		uint table_heap_offset;
+		uint pdb_heap_offset;
 
 		public ImageReader (Disposable<Stream> stream, string file_name)
 			: base (stream.value)
@@ -400,6 +401,7 @@ void ReadMetadataStream (Section section)
 				break;
 			case "#Pdb":
 				image.PdbHeap = new PdbHeap (data);
+				pdb_heap_offset = offset;
 				break;
 			}
 		}
@@ -768,7 +770,7 @@ public static Image ReadImage (Disposable<Stream> stream, string file_name)
 			}
 		}
 
-		public static Image ReadPortablePdb (Disposable<Stream> stream, string file_name)
+		public static Image ReadPortablePdb (Disposable<Stream> stream, string file_name, out uint pdb_heap_offset)
 		{
 			try {
 				var reader = new ImageReader (stream, file_name);
@@ -785,6 +787,7 @@ public static Image ReadPortablePdb (Disposable<Stream> stream, string file_name
 
 				reader.metadata = new DataDirectory (0, length);
 				reader.ReadMetadata ();
+				pdb_heap_offset = reader.pdb_heap_offset;
 				return reader.image;
 			} catch (EndOfStreamException e) {
 				throw new BadImageFormatException (stream.value.GetFileName (), e);
diff --git a/Mono.Cecil.PE/ImageWriter.cs b/Mono.Cecil.PE/ImageWriter.cs
index d6fb36335..c2eb97a17 100644
--- a/Mono.Cecil.PE/ImageWriter.cs
+++ b/Mono.Cecil.PE/ImageWriter.cs
@@ -48,6 +48,8 @@ sealed class ImageWriter : BinaryStreamWriter {
 
 		ushort sections;
 
+		internal long debug_header_entries_position;
+
 		ImageWriter (ModuleDefinition module, string runtime_version, MetadataBuilder metadata, Disposable<Stream> stream, bool metadataOnly = false)
 			: base (stream.value)
 		{
@@ -64,7 +66,7 @@ sealed class ImageWriter : BinaryStreamWriter {
 			this.GetDebugHeader ();
 			this.GetWin32Resources ();
 			this.BuildTextMap ();
-			this.sections = (ushort) (has_reloc ? 2 : 1); // text + reloc?
+			this.sections = (ushort)(has_reloc ? 2 : 1); // text + reloc?
 		}
 
 		void GetDebugHeader ()
@@ -98,7 +100,7 @@ void GetWin32Resources ()
 
 		public static ImageWriter CreateWriter (ModuleDefinition module, MetadataBuilder metadata, Disposable<Stream> stream)
 		{
-			var writer = new ImageWriter (module, module.runtime_version, metadata, stream);
+			var writer = new ImageWriter (module, module.runtime_version, metadata, stream, metadataOnly: false);
 			writer.BuildSections ();
 			return writer;
 		}
@@ -379,7 +381,7 @@ void MoveToRVA (Section section, RVA rva)
 			BaseStream.Seek (GetRVAFileOffset (section, rva), SeekOrigin.Begin);
 		}
 
-		void MoveToRVA (TextSegment segment)
+		internal void MoveToRVA (TextSegment segment)
 		{
 			MoveToRVA (text, text_map.GetRVA (segment));
 		}
@@ -600,7 +602,9 @@ void WriteDebugDirectory ()
 
 				data_start += entry.Data.Length;
 			}
-			
+
+			debug_header_entries_position = BaseStream.Position;
+
 			for (var i = 0; i < debug_header.Entries.Length; i++) {
 				var entry = debug_header.Entries [i];
 				WriteBytes (entry.Data);
diff --git a/Mono.Cecil/AssemblyWriter.cs b/Mono.Cecil/AssemblyWriter.cs
index 65151517f..25076ff32 100644
--- a/Mono.Cecil/AssemblyWriter.cs
+++ b/Mono.Cecil/AssemblyWriter.cs
@@ -118,13 +118,16 @@ static void Write (ModuleDefinition module, Disposable<Stream> stream, WriterPar
 					metadata.SetSymbolWriter (symbol_writer);
 					BuildMetadata (module, metadata);
 
-					if (parameters.DeterministicMvid)
-						metadata.ComputeDeterministicMvid ();
+					if (symbol_writer != null)
+						symbol_writer.Write ();
 
 					var writer = ImageWriter.CreateWriter (module, metadata, stream);
 					stream.value.SetLength (0);
 					writer.WriteImage ();
 
+					if (parameters.DeterministicMvid)
+						ComputeDeterministicMvid (writer, module);
+
 					if (parameters.HasStrongNameKey)
 						CryptoService.StrongName (stream.value, writer, parameters);
 				}
@@ -156,6 +159,26 @@ static ISymbolWriter GetSymbolWriter (ModuleDefinition module, string fq_name, I
 
 			return symbol_writer_provider.GetSymbolWriter (module, fq_name);
 		}
+
+		static void ComputeDeterministicMvid (ImageWriter writer, ModuleDefinition module)
+		{
+			long previousPosition = writer.BaseStream.Position;
+			writer.BaseStream.Seek(0, SeekOrigin.Begin);
+
+			// The hash should be computed with the MVID set to all zeroes
+			// which it is - we explicitly write all zeroes GUID into the heap
+			// as the MVID.
+			// Same goes for strong name signature, which also already in the image but all zeroes right now.
+			Guid guid = CryptoService.ComputeGuid (CryptoService.ComputeHash (writer.BaseStream));
+
+			// The MVID GUID is always the first GUID in the GUID heap
+			writer.MoveToRVA (TextSegment.GuidHeap);
+			writer.WriteBytes (guid.ToByteArray ());
+			writer.Flush ();
+			module.Mvid = guid;
+
+			writer.BaseStream.Seek(previousPosition, SeekOrigin.Begin);
+		}
 	}
 
 	abstract class MetadataTable {
@@ -2649,25 +2672,6 @@ void AddSequencePoints (MethodDebugInformation info)
 
 			method_debug_information_table.rows [rid - 1].Col2 = GetBlobIndex (signature);
 		}
-
-		public void ComputeDeterministicMvid ()
-		{
-			var guid = CryptoService.ComputeGuid (CryptoService.ComputeHash (
-				data,
-				resources,
-				string_heap,
-				user_string_heap,
-				blob_heap,
-				table_heap,
-				code));
-
-			var position = guid_heap.position;
-			guid_heap.position = 0;
-			guid_heap.WriteBytes (guid.ToByteArray ());
-			guid_heap.position = position;
-
-			module.Mvid = guid;
-		}
 	}
 
 	sealed class SignatureWriter : ByteBuffer {
diff --git a/Mono.Security.Cryptography/CryptoService.cs b/Mono.Security.Cryptography/CryptoService.cs
index dd9613fe0..3877debfa 100644
--- a/Mono.Security.Cryptography/CryptoService.cs
+++ b/Mono.Security.Cryptography/CryptoService.cs
@@ -109,7 +109,7 @@ static byte [] HashStream (Stream stream, ImageWriter writer, out int strong_nam
 			return sha1.Hash;
 		}
 
-		static void CopyStreamChunk (Stream stream, Stream dest_stream, byte [] buffer, int length)
+		public static void CopyStreamChunk (Stream stream, Stream dest_stream, byte [] buffer, int length)
 		{
 			while (length > 0) {
 				int read = stream.Read (buffer, 0, System.Math.Min (buffer.Length, length));
diff --git a/Test/Mono.Cecil.Tests/ImageReadTests.cs b/Test/Mono.Cecil.Tests/ImageReadTests.cs
index ef6ab06ff..f663b60ca 100644
--- a/Test/Mono.Cecil.Tests/ImageReadTests.cs
+++ b/Test/Mono.Cecil.Tests/ImageReadTests.cs
@@ -237,9 +237,16 @@ public void ExternalPdbDeterministicAssembly ()
 
 				var header = module.GetDebugHeader ();
 
-				Assert.AreEqual (2, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Length >= 2);
 				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.CodeView));
 				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
+
+				// If read directly from a file the PdbChecksum may not be persent (in this test case it isn't)
+				// but when written through Cecil it will always be there.
+				if (header.Entries.Length > 2) {
+					Assert.AreEqual (3, header.Entries.Length);
+					Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.PdbChecksum));
+				}
 			}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
 		}
 
@@ -251,10 +258,17 @@ public void EmbeddedPdbDeterministicAssembly ()
 
 				var header = module.GetDebugHeader ();
 
-				Assert.AreEqual (3, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Length >= 3);
 				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.CodeView));
 				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.Deterministic));
 				Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.EmbeddedPortablePdb));
+
+				// If read directly from a file the PdbChecksum may not be persent (in this test case it isn't)
+				// but when written through Cecil it will always be there.
+				if (header.Entries.Length > 3) {
+					Assert.AreEqual (4, header.Entries.Length);
+					Assert.IsTrue (header.Entries.Any (e => e.Directory.Type == ImageDebugType.PdbChecksum));
+				}
 			}, symbolReaderProvider: typeof (EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof (EmbeddedPortablePdbWriterProvider));
 		}
 	}
diff --git a/Test/Mono.Cecil.Tests/PortablePdbTests.cs b/Test/Mono.Cecil.Tests/PortablePdbTests.cs
index d9786cb37..bd524fd14 100644
--- a/Test/Mono.Cecil.Tests/PortablePdbTests.cs
+++ b/Test/Mono.Cecil.Tests/PortablePdbTests.cs
@@ -1,6 +1,8 @@
 using System;
 using System.IO;
+using System.IO.Compression;
 using System.Linq;
+using System.Security.Cryptography;
 using System.Text;
 using NUnit.Framework;
 
@@ -357,15 +359,23 @@ public void EmbeddedCompressedPortablePdb ()
 				var header = module.GetDebugHeader ();
 
 				Assert.IsNotNull (header);
-				Assert.AreEqual (2, header.Entries.Length);
+				Assert.IsTrue (header.Entries.Length >= 2);
 
-				var cv = header.Entries [0];
+				int i = 0;
+				var cv = header.Entries [i++];
 				Assert.AreEqual (ImageDebugType.CodeView, cv.Directory.Type);
 
-				var eppdb = header.Entries [1];
+				if (header.Entries.Length > 2) {
+					Assert.AreEqual (3, header.Entries.Length);
+					var pdbChecksum = header.Entries [i++];
+					Assert.AreEqual (ImageDebugType.PdbChecksum, pdbChecksum.Directory.Type);
+				}
+
+				var eppdb = header.Entries [i++];
 				Assert.AreEqual (ImageDebugType.EmbeddedPortablePdb, eppdb.Directory.Type);
 				Assert.AreEqual (0x0100, eppdb.Directory.MajorVersion);
 				Assert.AreEqual (0x0100, eppdb.Directory.MinorVersion);
+
 			}, symbolReaderProvider: typeof (EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof (EmbeddedPortablePdbWriterProvider));
 		}
 
@@ -400,7 +410,7 @@ void TestPortablePdbModule (Action<ModuleDefinition> test)
 		{
 			TestModule ("PdbTarget.exe", test, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
 			TestModule ("EmbeddedPdbTarget.exe", test, verify: !Platform.OnMono);
-			TestModule ("EmbeddedCompressedPdbTarget.exe", test, symbolReaderProvider: typeof(EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof(EmbeddedPortablePdbWriterProvider));
+			TestModule ("EmbeddedCompressedPdbTarget.exe", test, symbolReaderProvider: typeof(EmbeddedPortablePdbReaderProvider), symbolWriterProvider: typeof (EmbeddedPortablePdbWriterProvider));
 		}
 
 		[Test]
@@ -604,7 +614,7 @@ static EmbeddedSourceDebugInformation GetSourceDebugInfo (Document document)
 		}
 
 		[Test]
-		public void PortablePdbLineInfo  ()
+		public void PortablePdbLineInfo()
 		{
 			TestModule ("line.exe", module => {
 				var type = module.GetType ("Tests");
@@ -698,6 +708,11 @@ public void Write (MethodDebugInformation info)
 				symbol_writer.Write (info);
 			}
 
+			public void Write ()
+			{
+				symbol_writer.Write ();
+			}
+
 			public void Dispose ()
 			{
 				symbol_writer.Dispose ();
@@ -809,5 +824,310 @@ public void ClearSequencePoints ()
 				}
 			});
 		}
+
+		[Test]
+		public void DoubleWriteAndReadWithDeterministicMvidAndVariousChanges ()
+		{
+			Guid mvidIn, mvidARM64Out, mvidX64Out;
+
+			const string resource = "mylib.dll";
+			{
+				string destination = Path.GetTempFileName ();
+
+				using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+					mvidIn = module.Mvid;
+					module.Architecture = TargetArchitecture.ARM64; // Can't use I386 as it writes different import table size -> differnt MVID
+					module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+				}
+
+				using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+					mvidARM64Out = module.Mvid;
+				}
+
+				Assert.AreNotEqual (mvidIn, mvidARM64Out);
+			}
+
+			{
+				string destination = Path.GetTempFileName ();
+
+				using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+					Assert.AreEqual (mvidIn, module.Mvid);
+					module.Architecture = TargetArchitecture.AMD64;
+					module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+				}
+
+				using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+					mvidX64Out = module.Mvid;
+				}
+
+				Assert.AreNotEqual (mvidARM64Out, mvidX64Out);
+			}
+
+			{
+				string destination = Path.GetTempFileName ();
+
+				using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+					Assert.AreEqual (mvidIn, module.Mvid);
+					module.Architecture = TargetArchitecture.AMD64;
+					module.timestamp = 42;
+					module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+				}
+
+				Guid mvidDifferentTimeStamp;
+				using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+					mvidDifferentTimeStamp = module.Mvid;
+				}
+
+				Assert.AreNotEqual (mvidX64Out, mvidDifferentTimeStamp);
+			}
+		}
+
+		[Test]
+		public void ReadPortablePdbChecksum ()
+		{
+			const string resource = "PdbChecksumLib.dll";
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				GetPdbChecksumData (module.GetDebugHeader (), out string algorithmName, out byte [] checksum);
+				Assert.AreEqual ("SHA256", algorithmName);
+				GetCodeViewPdbId (module, out byte[] pdbId);
+
+				string pdbPath = Mixin.GetPdbFileName (module.FileName);
+				CalculatePdbChecksumAndId (pdbPath, out byte [] expectedChecksum, out byte [] expectedPdbId);
+
+				CollectionAssert.AreEqual (expectedChecksum, checksum);
+				CollectionAssert.AreEqual (expectedPdbId, pdbId);
+			}
+		}
+
+		[Test]
+		public void ReadEmbeddedPortablePdbChecksum ()
+		{
+			const string resource = "EmbeddedPdbChecksumLib.dll";
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				var debugHeader = module.GetDebugHeader ();
+				GetPdbChecksumData (debugHeader, out string algorithmName, out byte [] checksum);
+				Assert.AreEqual ("SHA256", algorithmName);
+				GetCodeViewPdbId (module, out byte [] pdbId);
+
+				GetEmbeddedPdb (debugHeader, out byte [] embeddedPdb);
+				CalculatePdbChecksumAndId (embeddedPdb, out byte [] expectedChecksum, out byte [] expectedPdbId);
+
+				CollectionAssert.AreEqual (expectedChecksum, checksum);
+				CollectionAssert.AreEqual (expectedPdbId, pdbId);
+			}
+		}
+
+		[Test]
+		public void WritePortablePdbChecksum ()
+		{
+			const string resource = "PdbChecksumLib.dll";
+			string destination = Path.GetTempFileName ();
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+			}
+
+			using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+				GetPdbChecksumData (module.GetDebugHeader (), out string algorithmName, out byte [] checksum);
+				Assert.AreEqual ("SHA256", algorithmName);
+				GetCodeViewPdbId (module, out byte [] pdbId);
+
+				string pdbPath = Mixin.GetPdbFileName (module.FileName);
+				CalculatePdbChecksumAndId (pdbPath, out byte [] expectedChecksum, out byte [] expectedPdbId);
+
+				CollectionAssert.AreEqual (expectedChecksum, checksum);
+				CollectionAssert.AreEqual (expectedPdbId, pdbId);
+			}
+		}
+
+		[Test]
+		public void WritePortablePdbToWriteOnlyStream ()
+		{
+			const string resource = "PdbChecksumLib.dll";
+			string destination = Path.GetTempFileName ();
+
+			// Note that the module stream already requires read access even on writing to be able to compute strong name
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true }))
+			using (var pdbStream = new FileStream (destination + ".pdb", FileMode.Create, FileAccess.Write)) {
+				module.Write (destination, new WriterParameters {
+					DeterministicMvid = true,
+					WriteSymbols = true,
+					SymbolWriterProvider = new PortablePdbWriterProvider (),
+					SymbolStream = pdbStream
+				});
+			}
+		}
+
+		[Test]
+		public void DoubleWritePortablePdbDeterministicPdbId ()
+		{
+			const string resource = "PdbChecksumLib.dll";
+			string destination = Path.GetTempFileName ();
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+			}
+
+			byte [] pdbIdOne;
+			using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+				string pdbPath = Mixin.GetPdbFileName (module.FileName);
+				CalculatePdbChecksumAndId (pdbPath, out byte [] expectedChecksum, out pdbIdOne);
+			}
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+			}
+
+			byte [] pdbIdTwo;
+			using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+				string pdbPath = Mixin.GetPdbFileName (module.FileName);
+				CalculatePdbChecksumAndId (pdbPath, out byte [] expectedChecksum, out pdbIdTwo);
+			}
+
+			CollectionAssert.AreEqual (pdbIdOne, pdbIdTwo);
+		}
+
+		[Test]
+		public void WriteEmbeddedPortablePdbChecksum ()
+		{
+			const string resource = "EmbeddedPdbChecksumLib.dll";
+			string destination = Path.GetTempFileName ();
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+			}
+
+			using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+				var debugHeader = module.GetDebugHeader ();
+				GetPdbChecksumData (debugHeader, out string algorithmName, out byte [] checksum);
+				Assert.AreEqual ("SHA256", algorithmName);
+				GetCodeViewPdbId (module, out byte [] pdbId);
+
+				GetEmbeddedPdb (debugHeader, out byte [] embeddedPdb);
+				CalculatePdbChecksumAndId (embeddedPdb, out byte [] expectedChecksum, out byte [] expectedPdbId);
+
+				CollectionAssert.AreEqual (expectedChecksum, checksum);
+				CollectionAssert.AreEqual (expectedPdbId, pdbId);
+			}
+		}
+
+		[Test]
+		public void DoubleWriteEmbeddedPortablePdbChecksum ()
+		{
+			const string resource = "EmbeddedPdbChecksumLib.dll";
+			string destination = Path.GetTempFileName ();
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+			}
+
+			byte [] pdbIdOne;
+			using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+				var debugHeader = module.GetDebugHeader ();
+				GetEmbeddedPdb (debugHeader, out byte [] embeddedPdb);
+				CalculatePdbChecksumAndId (embeddedPdb, out byte [] expectedChecksum, out pdbIdOne);
+			}
+
+			using (var module = GetResourceModule (resource, new ReaderParameters { ReadSymbols = true })) {
+				module.Write (destination, new WriterParameters { DeterministicMvid = true, WriteSymbols = true });
+			}
+
+			byte [] pdbIdTwo;
+			using (var module = ModuleDefinition.ReadModule (destination, new ReaderParameters { ReadSymbols = true })) {
+				var debugHeader = module.GetDebugHeader ();
+				GetEmbeddedPdb (debugHeader, out byte [] embeddedPdb);
+				CalculatePdbChecksumAndId (embeddedPdb, out byte [] expectedChecksum, out pdbIdTwo);
+			}
+
+			CollectionAssert.AreEqual (pdbIdOne, pdbIdTwo);
+		}
+
+		private void GetEmbeddedPdb (ImageDebugHeader debugHeader, out byte [] embeddedPdb)
+		{
+			var entry = Mixin.GetEmbeddedPortablePdbEntry (debugHeader);
+			Assert.IsNotNull (entry);
+
+			var compressed_stream = new MemoryStream (entry.Data);
+			var reader = new BinaryStreamReader (compressed_stream);
+			Assert.AreEqual (0x4244504D, reader.ReadInt32 ());
+			var length = reader.ReadInt32 ();
+			var decompressed_stream = new MemoryStream (length);
+
+			using (var deflate = new DeflateStream (compressed_stream, CompressionMode.Decompress, leaveOpen: true))
+				deflate.CopyTo (decompressed_stream);
+
+			embeddedPdb = decompressed_stream.ToArray ();
+		}
+
+		private void GetPdbChecksumData (ImageDebugHeader debugHeader, out string algorithmName, out byte [] checksum)
+		{
+			var entry = Mixin.GetPdbChecksumEntry (debugHeader);
+			Assert.IsNotNull (entry);
+
+			var length = Array.IndexOf (entry.Data, (byte)0, 0);
+			var bytes = new byte [length];
+			Buffer.BlockCopy (entry.Data, 0, bytes, 0, length);
+			algorithmName = Encoding.UTF8.GetString (bytes);
+			int checksumSize = 0;
+			switch (algorithmName) {
+			case "SHA256": checksumSize = 32; break;
+			case "SHA384": checksumSize = 48; break;
+			case "SHA512": checksumSize = 64; break;
+			}
+			checksum = new byte [checksumSize];
+			Buffer.BlockCopy (entry.Data, length + 1, checksum, 0, checksumSize);
+		}
+
+		private void CalculatePdbChecksumAndId (string filePath, out byte [] pdbChecksum, out byte [] pdbId)
+		{
+			using (var fs = File.OpenRead (filePath))
+				CalculatePdbChecksumAndId (fs, out pdbChecksum, out pdbId);
+		}
+
+		private void CalculatePdbChecksumAndId (byte [] data, out byte [] pdbChecksum, out byte [] pdbId)
+		{
+			using (var pdb = new MemoryStream (data))
+				CalculatePdbChecksumAndId (pdb, out pdbChecksum, out pdbId);
+		}
+
+		private void CalculatePdbChecksumAndId (Stream pdbStream, out byte [] pdbChecksum, out byte [] pdbId)
+		{
+			// Get the offset of the PDB heap (this requires parsing several headers
+			// so it's easier to use the ImageReader directly for this)
+			Image image = ImageReader.ReadPortablePdb (new Disposable<Stream> (pdbStream, false), "test.pdb", out uint pdbHeapOffset);
+			pdbId = new byte [20];
+			Array.Copy (image.PdbHeap.data, 0, pdbId, 0, 20);
+
+			pdbStream.Seek (0, SeekOrigin.Begin);
+			byte [] rawBytes = pdbStream.ReadAll ();
+
+			var bytes = new byte [rawBytes.Length];
+
+			Array.Copy (rawBytes, 0, bytes, 0, pdbHeapOffset);
+
+			// Zero out the PDB ID (20 bytes)
+			for (int i = 0; i < 20; bytes [i + pdbHeapOffset] = 0, i++) ;
+
+			Array.Copy (rawBytes, pdbHeapOffset + 20, bytes, pdbHeapOffset + 20, rawBytes.Length - pdbHeapOffset - 20);
+
+			var sha256 = SHA256.Create ();
+			pdbChecksum = sha256.ComputeHash (bytes);
+		}
+
+		static void GetCodeViewPdbId (ModuleDefinition module, out byte[] pdbId)
+		{
+			var header = module.GetDebugHeader ();
+			var cv = Mixin.GetCodeViewEntry (header);
+			Assert.IsNotNull (cv);
+
+			CollectionAssert.AreEqual (new byte [] { 0x52, 0x53, 0x44, 0x53 }, cv.Data.Take (4));
+
+			ByteBuffer buffer = new ByteBuffer (20);
+			buffer.WriteBytes (cv.Data.Skip (4).Take (16).ToArray ());
+			buffer.WriteInt32 (cv.Directory.TimeDateStamp);
+			pdbId = buffer.buffer;
+		}
 	}
 }
diff --git a/Test/Resources/assemblies/EmbeddedPdbChecksumLib.dll b/Test/Resources/assemblies/EmbeddedPdbChecksumLib.dll
new file mode 100644
index 0000000000000000000000000000000000000000..2de939b9b18609590abed1bde5bdfb272b91ed96
GIT binary patch
literal 9728
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
X|1TpDF#h)uC-J|p`EUCFt^)r9McxBc

literal 0
HcmV?d00001

diff --git a/Test/Resources/assemblies/PdbChecksumLib.dll b/Test/Resources/assemblies/PdbChecksumLib.dll
new file mode 100644
index 0000000000000000000000000000000000000000..9c28db70494fe0ff2996c8437aa391e4c3cf01e8
GIT binary patch
literal 4096
zcmeHKU2GIp6h60qlmbf|kkpvqU_mOFp`}2e^0V!33&sA~T`G_!?d<k;J9c(vGcyZp
zVze(vA~8Xq)CYYr#s`BWDiWfJ37YsIz9>HV;LnrML|=R{M*Pm5neI=u8siI*v%Tk@
zzd83i=g!=jj-0+k^+eQwar-vWHOx$L#aCvFaL4Yy9;0_w-`sLd4By<6o;N+M;5s?i
z$ZJ`{wjE!~NX;$UnrUmvv6Pl~W~IJvUCY)m_4okMu&Af!zUlcrTJ39kKwBfah?-$(
z3aoVxV%9L?7(}f~t_yIpf$=L^1c#leo@UN-DF2n`P-PS7@;0I|7UD!Fxe>KAL$nsQ
zF90}Q>sv|J0{Br#GxTGTf?4<FIUjQ~*Qc?75#olVNF$ojUC+%zQ`q7VxX>1i3W@{0
z?n=u+AY-K&49*q9sGvAee}$^VZ&5!JW2>V^I;jyoi8TZp{{?NX>s$kXJNi?{`$d?A
zF`e0?cj-M{J>3U5X(L(SGgzeKDWXp?f5mdjcTGFzal{+g3of<eM2g;o%v;!T^u$mS
z^ZU?0WWC>VGMJfAt~k1pXf-RpiXPe&)WB<VE4Us2Q>|l}2hp?$<|evDuZbqwE|~A4
z=f!&Z2(BhNO#`sRL<#&VG4~X|r1&q2Clvo&xGEWMB<JT}D@Gf2D|uXF`!nqqkwXCI
zMXcQh-bD9;x6ni2t%zlQK=D4shZKKI@l%Q$;7z2Xp3UGJXgm0QGzi{-ds(NQbRN8i
zUIKrFUI$Om+u)BXdkVZ^G3o#yDQW|63}v3~A+4+>EW`7<>EMVnTeRe18lTN1=4E!l
zE9QsI45dn*FZ23D(e}-}q@>Igb2%ep$vz(&nko8{`aDnOGgc{W`jzIi;pU`2h|@xz
zb=-yJ@q?x%C#CC|j=kJDWY0Nn-tgfxtiOy(IQE>GE4nJKoFw7o3#O%v6VfuyDakAQ
zBgEq_iq87W9h|_hOJzq`zq0#g#<Wbo!du-WJ%o$fy{4P`tYw8AU23eHvt*XbBt7dp
zZe&lIM$UFT-^_ZEDa4=$)k!xc-7{uZdf}#EIqV_SvCI?581C@**I)75KS>{bZ}*Ll
z5B<=apaxBd=6a1pBZRg#R%6Xqj!Zw@cB`egS*Wv$Xfxm8>AFpiyGCKuu?Nm&Wr0Da
z=UwNlClJRE9?@Pw?fU3II^npouTXe6Ed9`#y?PfC#5OMNf70{{mQfnT?LZp@#cJ*|
zS}SN3HcJ|w#7PIG8;1&hc&r6ADkUt5#O@bvkQf<f2-6syIOjT7Mc&}<-vD(x#s&B;
zRQNbby)sw`X(E+Oz4+?!Q*vkP@waAsFF&jQc#t3W!QQE%;bGHWknWT#@#>qZ20i6u
zo|p<TPubE(%{38vVHS_jvA*4V_ffdQ4kuaxRjl2z%Xv9H^4+_QS3mm_NF(~0Wi8UG
z=jc=qtkdXx(y~Sj)26(a#WqNFmj&M2+mNNU-0F09wf{*6_>D!>PPABEaPTI_bGFRR
zas2IYGEVec@Vv7L@*eO>O5y37qyd_MG=#U)DD)xl!QiWlK4|y}-+lZf@n8z(BY~p6
z0V>ieD}MtBWHrb|9uwaZ5;<*}BS-nSs;koQ8nAls8{{L-ffmq}hAAW!z~m#!ggy5s
znf9xgE{cA8C<B@3Fs;Y63FOODL9J0jMFupf(vQ<DA`>(ZJxdEfP=s$7>tvLFP+cD(
zPa?`g9OEcd;rzQiT{wuv67EUlagnK9XE)yYT}uOJ6}}aO>XffyZD6)4kgv3!j+!j|
zm^yK=3)CagHO|1DC{RgNkVDn{UePc{)p}#0ox9A@QQfQs9s8&227Mn#J_l%u=$T)E
zo@k{!fP-G}msj=mwOuRsjA*~=Zy$Q<q1HTh&q9?N?!4+wm#^V|-(jQ$|1&h~yTfqb
Jh5Mg$;19-|`dt73

literal 0
HcmV?d00001

diff --git a/Test/Resources/assemblies/PdbChecksumLib.pdb b/Test/Resources/assemblies/PdbChecksumLib.pdb
new file mode 100644
index 0000000000000000000000000000000000000000..81975e75a03a07faf335090a384481a5ca9fa7b2
GIT binary patch
literal 9576
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

literal 0
HcmV?d00001

diff --git a/symbols/mdb/Mono.Cecil.Mdb/MdbWriter.cs b/symbols/mdb/Mono.Cecil.Mdb/MdbWriter.cs
index 9b565187d..4d4ce933b 100644
--- a/symbols/mdb/Mono.Cecil.Mdb/MdbWriter.cs
+++ b/symbols/mdb/Mono.Cecil.Mdb/MdbWriter.cs
@@ -167,6 +167,12 @@ public ImageDebugHeader GetDebugHeader ()
 			return new ImageDebugHeader ();
 		}
 
+		public void Write ()
+		{
+			// Can't write it here since we need the final module MVID - which is only computed
+			// after the entire image of the assembly is written (since it's computed from the hash of that)
+		}
+
 		public void Dispose ()
 		{
 			writer.WriteSymbolFile (module.Mvid);
diff --git a/symbols/pdb/Mono.Cecil.Pdb/NativePdbWriter.cs b/symbols/pdb/Mono.Cecil.Pdb/NativePdbWriter.cs
index 01b6c7a51..7bb9c6f15 100644
--- a/symbols/pdb/Mono.Cecil.Pdb/NativePdbWriter.cs
+++ b/symbols/pdb/Mono.Cecil.Pdb/NativePdbWriter.cs
@@ -28,6 +28,9 @@ public class NativePdbWriter : ISymbolWriter {
 		readonly Dictionary<string, SymDocumentWriter> documents;
 		readonly Dictionary<ImportDebugInformation, MetadataToken> import_info_to_parent;
 
+		ImageDebugDirectory debug_directory;
+		byte [] debug_info;
+
 		internal NativePdbWriter (ModuleDefinition module, SymWriter writer)
 		{
 			this.module = module;
@@ -44,10 +47,7 @@ public ISymbolReaderProvider GetReaderProvider ()
 
 		public ImageDebugHeader GetDebugHeader ()
 		{
-			ImageDebugDirectory directory;
-			var data = writer.GetDebugInfo (out directory);
-			directory.TimeDateStamp = (int) module.timestamp;
-			return new ImageDebugHeader (new ImageDebugHeaderEntry (directory, data));
+			return new ImageDebugHeader (new ImageDebugHeaderEntry (debug_directory, debug_info));
 		}
 
 		public void Write (MethodDebugInformation info)
@@ -253,14 +253,21 @@ SymDocumentWriter GetDocument (Document document)
 			return doc_writer;
 		}
 
-		public void Dispose ()
+		public void Write ()
 		{
 			var entry_point = module.EntryPoint;
 			if (entry_point != null)
 				writer.SetUserEntryPoint (entry_point.MetadataToken.ToInt32 ());
 
+			debug_info = writer.GetDebugInfo (out debug_directory);
+			debug_directory.TimeDateStamp = (int)module.timestamp;
+
 			writer.Close ();
 		}
+
+		public void Dispose ()
+		{
+		}
 	}
 
 	enum CustomMetadataType : byte {