public unsafe void GetReader_Offset()
{
var array = ImmutableArray.Create(new byte[] { 0, 1, 2, 3, 4 });
var provider = new ByteArrayMemoryProvider(array);
var block = provider.GetMemoryBlock();
var peBlock = new PEMemoryBlock(block, offset: 1);
var reader1 = peBlock.GetReader();
Assert.Equal(4, reader1.Length);
AssertEx.Equal(new byte[] { 1, 2, 3 }, reader1.ReadBytes(3));
AssertEx.Equal(new byte[] { 4 }, reader1.ReadBytes(1));
var reader2 = peBlock.GetReader(1, 2);
Assert.Equal(2, reader2.Length);
AssertEx.Equal(new byte[] { 2, 3 }, reader2.ReadBytes(2));
var reader3 = peBlock.GetReader(4, 0);
Assert.Equal(0, reader3.Length);
AssertEx.Equal(new byte[] { }, reader3.ReadBytes(0));
Assert.Throws <ArgumentOutOfRangeException>(() => peBlock.GetReader(0, 5));
Assert.Throws <ArgumentOutOfRangeException>(() => peBlock.GetReader(4, 1));
Assert.Throws <ArgumentOutOfRangeException>(() => peBlock.GetReader(5, 0));
}
public void CodeView_Errors()
{
var bytes = ImmutableArray.Create(new byte[]
{
(byte)'R', (byte)'S', (byte)'D', (byte)'S', // signature
0x6E, 0xE6, 0x88, 0x3C, 0xB9, 0xE0, 0x08, 0x45, 0x92, 0x90, 0x11, 0xE0, 0xDB, 0x51, 0xA1, 0xC5, // GUID
0x01, 0x00, 0x00, 0x00, // age
(byte)'x', 0x00, // path
});
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, 1))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeCodeViewDebugDirectoryData(block));
}
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, 4))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeCodeViewDebugDirectoryData(block));
}
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length - 3))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeCodeViewDebugDirectoryData(block));
}
}
public unsafe void ByteArray()
{
var array = ImmutableArray.Create(new byte[] { 1, 2, 3, 4 });
using (var provider = new ByteArrayMemoryProvider(array))
{
using (var block = provider.GetMemoryBlock())
{
Assert.Equal(4, block.Size);
AssertEx.Equal(provider.Pointer, block.Pointer);
AssertEx.Equal(new byte[] { }, block.GetContentUnchecked(0, 0));
AssertEx.Equal(new byte[] { 3, 4 }, block.GetContentUnchecked(2, 2));
AssertEx.Equal(new byte[] { 1, 2, 3 }, block.GetContentUnchecked(0, 3));
}
using (var block = provider.GetMemoryBlock(1, 2))
{
AssertEx.Equal(provider.Pointer + 1, block.Pointer);
Assert.Equal(2, block.Size);
AssertEx.Equal(new byte[] { 2, 3 }, block.GetContentUnchecked(0, 2));
AssertEx.Equal(new byte[] { 3 }, block.GetContentUnchecked(1, 1));
AssertEx.Equal(new byte[] { }, block.GetContentUnchecked(2, 0));
}
}
}
public void CodeView_PathPadding()
{
var bytes = ImmutableArray.Create(new byte[]
{
(byte)'R', (byte)'S', (byte)'D', (byte)'S', // signature
0x6E, 0xE6, 0x88, 0x3C, 0xB9, 0xE0, 0x08, 0x45, 0x92, 0x90, 0x11, 0xE0, 0xDB, 0x51, 0xA1, 0xC5, // GUID
0x01, 0x00, 0x00, 0x00, // age
(byte)'x', 0x00, 0x20, 0xff, // path
});
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length))
{
Assert.Equal("x", PEReader.DecodeCodeViewDebugDirectoryData(block).Path);
}
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length - 1))
{
Assert.Equal("x", PEReader.DecodeCodeViewDebugDirectoryData(block).Path);
}
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length - 2))
{
Assert.Equal("x", PEReader.DecodeCodeViewDebugDirectoryData(block).Path);
}
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length - 3))
{
Assert.Equal("x", PEReader.DecodeCodeViewDebugDirectoryData(block).Path);
}
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length - 4))
{
Assert.Equal("", PEReader.DecodeCodeViewDebugDirectoryData(block).Path);
}
}
public void PdbChecksum_Errors(byte[] blob)
{
var bytes = ImmutableArray.Create(blob);
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodePdbChecksumDebugDirectoryData(block));
}
}
public void EmbeddedPortablePdb()
{
var b = new DebugDirectoryBuilder();
var pdb = new BlobBuilder();
pdb.WriteInt64(0x1122334455667788);
b.AddEmbeddedPortablePdbEntry(pdb, portablePdbVersion: 0x0100);
var blob = new BlobBuilder();
b.Serialize(blob, new SectionLocation(0, 0), sectionOffset: 0);
var bytes = blob.ToImmutableArray();
AssertEx.Equal(new byte[]
{
0x00, 0x00, 0x00, 0x00, // Characteristics
0x00, 0x00, 0x00, 0x00, // Stamp
0x00, 0x01, 0x00, 0x01, // Version
0x11, 0x00, 0x00, 0x00, // Type
0x12, 0x00, 0x00, 0x00, // SizeOfData
0x1C, 0x00, 0x00, 0x00, // AddressOfRawData
0x1C, 0x00, 0x00, 0x00, // PointerToRawData
0x4D, 0x50, 0x44, 0x42, // signature
0x08, 0x00, 0x00, 0x00, // uncompressed size
0xEB, 0x28, 0x4F, 0x0B, 0x75, 0x31, 0x56, 0x12, 0x04, 0x00 // compressed data
}, bytes);
using (var pinned = new PinnedBlob(bytes))
{
var actual = PEReader.ReadDebugDirectoryEntries(pinned.CreateReader(0, DebugDirectoryEntry.Size));
Assert.Equal(1, actual.Length);
Assert.Equal(0u, actual[0].Stamp);
Assert.Equal(0x0100, actual[0].MajorVersion);
Assert.Equal(0x0100, actual[0].MinorVersion);
Assert.Equal(DebugDirectoryEntryType.EmbeddedPortablePdb, actual[0].Type);
Assert.False(actual[0].IsPortableCodeView);
Assert.Equal(0x00000012, actual[0].DataSize);
Assert.Equal(0x0000001c, actual[0].DataRelativeVirtualAddress);
Assert.Equal(0x0000001c, actual[0].DataPointer);
var provider = new ByteArrayMemoryProvider(bytes);
using (var block = provider.GetMemoryBlock(actual[0].DataPointer, actual[0].DataSize))
{
var decoded = PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block);
AssertEx.Equal(new byte[] { 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 }, decoded);
}
}
}
public void PdbChecksum()
{
var bytes = ImmutableArray.Create(new byte[]
{
(byte)'A', (byte)'L', (byte)'G', 0, // AlgorithmName
0x01, 0x02, 0x03, 0x04, 0x05 // checksum
});
using (var block = new ByteArrayMemoryProvider(bytes).GetMemoryBlock(0, bytes.Length))
{
var data = PEReader.DecodePdbChecksumDebugDirectoryData(block);
Assert.Equal("ALG", data.AlgorithmName);
AssertEx.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05 }, data.Checksum);
}
}
public unsafe void GetContent_Offset()
{
var array = ImmutableArray.Create(new byte[] { 0, 1, 2, 3, 4 });
var provider = new ByteArrayMemoryProvider(array);
var block = provider.GetMemoryBlock();
var peBlock = new PEMemoryBlock(block, offset: 1);
AssertEx.Equal(new byte[] { 1, 2, 3, 4 }, peBlock.GetContent());
AssertEx.Equal(new byte[] { 2, 3 }, peBlock.GetContent(1, 2));
AssertEx.Equal(new byte[] { }, peBlock.GetContent(4, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => peBlock.GetContent(0, 5));
Assert.Throws <ArgumentOutOfRangeException>(() => peBlock.GetContent(4, 1));
Assert.Throws <ArgumentOutOfRangeException>(() => peBlock.GetContent(5, 0));
}
public unsafe void ByteArray()
{
var array = ImmutableArray.Create(new byte[] { 1, 2, 3 });
using (var provider = new ByteArrayMemoryProvider(array))
{
using (var block = provider.GetMemoryBlock())
{
Assert.Equal(3, block.Size);
AssertEx.Equal(provider.Pointer, block.Pointer);
Assert.Equal(array, block.GetContent());
}
using (var block = provider.GetMemoryBlock(1, 2))
{
AssertEx.Equal(provider.Pointer + 1, block.Pointer);
Assert.Equal(2, block.Size);
Assert.Equal(new byte[] { 2, 3 }, block.GetContent());
}
}
}
public void EmbeddedPortablePdb_Errors()
{
var bytes1 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x42, // signature
0xFF, 0xFF, 0xFF, 0xFF, // uncompressed size
0xEB, 0x28, 0x4F, 0x0B, 0x75, 0x31, 0x56, 0x12, 0x04, 0x00 // compressed data
});
using (var block = new ByteArrayMemoryProvider(bytes1).GetMemoryBlock(0, bytes1.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes2 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x42, // signature
0x09, 0x00, 0x00, 0x00, // uncompressed size
0xEB, 0x28, 0x4F, 0x0B, 0x75, 0x31, 0x56, 0x12, 0x04, 0x00 // compressed data
});
using (var block = new ByteArrayMemoryProvider(bytes2).GetMemoryBlock(0, bytes2.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes3 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x42, // signature
0x00, 0x00, 0x00, 0x00, // uncompressed size
0xEB, 0x28, 0x4F, 0x0B, 0x75, 0x31, 0x56, 0x12, 0x04, 0x00 // compressed data
});
using (var block = new ByteArrayMemoryProvider(bytes3).GetMemoryBlock(0, bytes3.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes4 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x42, // signature
0xff, 0xff, 0xff, 0x7f, // uncompressed size
0xEB, 0x28, 0x4F, 0x0B, 0x75, 0x31, 0x56, 0x12, 0x04, 0x00 // compressed data
});
using (var block = new ByteArrayMemoryProvider(bytes4).GetMemoryBlock(0, bytes4.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes5 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x42, // signature
0x08, 0x00, 0x00, 0x00, // uncompressed size
0xEF, 0xFF, 0x4F, 0xFF, 0x75, 0x31, 0x56, 0x12, 0x04, 0x00 // compressed data
});
using (var block = new ByteArrayMemoryProvider(bytes4).GetMemoryBlock(0, bytes4.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes6 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x43, // signature
0x08, 0x00, 0x00, 0x00, // uncompressed size
0xEB, 0x28, 0x4F, 0x0B, 0x75, 0x31, 0x56, 0x12, 0x04, 0x00 // compressed data
});
using (var block = new ByteArrayMemoryProvider(bytes6).GetMemoryBlock(0, bytes6.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes7 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x43, // signature
0x08, 0x00, 0x00,
});
using (var block = new ByteArrayMemoryProvider(bytes7).GetMemoryBlock(0, bytes7.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes8 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x43, // signature
0x08, 0x00, 0x00,
});
using (var block = new ByteArrayMemoryProvider(bytes8).GetMemoryBlock(0, bytes8.Length))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
var bytes9 = ImmutableArray.Create(new byte[]
{
0x4D, 0x50, 0x44, 0x43, // signature
0x08, 0x00, 0x00, 0x00
});
using (var block = new ByteArrayMemoryProvider(bytes9).GetMemoryBlock(0, 1))
{
Assert.Throws <BadImageFormatException>(() => PEReader.DecodeEmbeddedPortablePdbDebugDirectoryData(block));
}
}
