/// <summary>
/// Returns true if the PE file meets all of the pre-conditions to be Open Source Signed.
/// Returns false and logs msbuild errors otherwise.
/// </summary>
private bool Validate(PEReader peReader)
{
if (!peReader.HasMetadata)
{
LogError("PE file is not a managed module.");
return(false);
}
var mdReader = peReader.GetMetadataReader();
if (!mdReader.IsAssembly)
{
LogError("PE file is not an assembly.");
return(false);
}
CorHeader header = peReader.PEHeaders.CorHeader;
if ((header.Flags & CorFlags.StrongNameSigned) == CorFlags.StrongNameSigned)
{
LogError("PE file is already strong-name signed.");
return(false);
}
if ((header.StrongNameSignatureDirectory.Size <= 0) || mdReader.GetAssemblyDefinition().PublicKey.IsNil)
{
LogError("PE file is not a delay-signed assembly.");
return(false);
}
return(true);
}
public unsafe static MetadataScope Load(PEImage pe, out CorHeader corHeader)
{
var dd = pe.Directories[DataDirectories.CLIHeader];
if (dd.IsNull)
{
throw new BadImageFormatException(string.Format(SR.MetadataImageNotValid, pe.Location));
}
var metadata = new MetadataScope();
using (var accessor = pe.OpenImageToSectionData(dd.RVA))
{
fixed(byte *pBuff = accessor.ReadBytes(sizeof(CorHeader)))
{
corHeader = *(CorHeader *)pBuff;
}
if (corHeader.Cb != MetadataConstants.CorHeaderSignature)
{
throw new BadImageFormatException(string.Format(SR.MetadataImageNotValid, pe.Location));
}
accessor.Position = pe.ResolvePositionToSectionData(corHeader.Metadata.RVA);
metadata.Read(accessor);
}
return(metadata);
}
FileType InferType(string fileRelativePath, Stream file)
{
if (fileRelativePath.Equals(DepsJson))
{
return(FileType.DepsJson);
}
if (fileRelativePath.Equals(RuntimeConfigJson))
{
return(FileType.RuntimeConfigJson);
}
try
{
PEReader peReader = new PEReader(file);
CorHeader corHeader = peReader.PEHeaders.CorHeader;
if ((corHeader != null) && ((corHeader.Flags & CorFlags.ILOnly) != 0))
{
return(FileType.Assembly);
}
}
catch (BadImageFormatException)
{
}
return(FileType.Extract);
}
internal MethodInfo ComputeEntryPoint(bool fileRefEntryPointAllowed)
{
PEHeaders peHeaders = PEReader.PEHeaders;
CorHeader corHeader = peHeaders.CorHeader;
if ((corHeader.Flags & CorFlags.NativeEntryPoint) != 0)
{
return(null);
}
int entryPointToken = corHeader.EntryPointTokenOrRelativeVirtualAddress;
Handle handle = entryPointToken.ToHandle();
if (handle.IsNil)
{
return(null);
}
HandleKind kind = handle.Kind;
switch (kind)
{
case HandleKind.MethodDefinition:
{
MethodDefinitionHandle mdh = (MethodDefinitionHandle)handle;
return(mdh.ResolveMethod <MethodInfo>(this, default));
}
case HandleKind.AssemblyFile:
{
if (!fileRefEntryPointAllowed)
{
throw new BadImageFormatException();
}
MetadataReader reader = Reader;
string moduleName = ((AssemblyFileHandle)handle).GetAssemblyFile(reader).Name.GetString(reader);
EcmaModule roModule = (EcmaModule)(Assembly.GetModule(moduleName));
return(roModule.ComputeEntryPoint(fileRefEntryPointAllowed: false));
}
default:
throw new BadImageFormatException();
}
}
/// <summary>
/// Returns true if the PE file meets all of the pre-conditions to be Open Source Signed.
/// Returns false and logs msbuild errors otherwise.
/// </summary>
private static bool IsPublicSigned(PEReader peReader)
{
if (!peReader.HasMetadata)
{
return(false);
}
var mdReader = peReader.GetMetadataReader();
if (!mdReader.IsAssembly)
{
return(false);
}
CorHeader header = peReader.PEHeaders.CorHeader;
return((header.Flags & CorFlags.StrongNameSigned) == CorFlags.StrongNameSigned);
}
/// <summary>
/// Returns true if the PE file meets all of the pre-conditions to be Open Source Signed.
/// Returns false and logs msbuild errors otherwise.
/// </summary>
private static bool Validate(PEReader peReader, MetadataReader mdReader, bool unSign)
{
CorHeader header = peReader.PEHeaders.CorHeader;
var expectedStrongNameFlag = unSign ? CorFlags.StrongNameSigned : 0;
var actualStrongNameFlag = header.Flags & CorFlags.StrongNameSigned;
if (expectedStrongNameFlag != actualStrongNameFlag)
{
Console.Error.WriteLine($"PE file is {(unSign ? "not" : "already")} strong-name signed.");
return(false);
}
if ((header.StrongNameSignatureDirectory.Size <= 0) || mdReader.GetAssemblyDefinition().PublicKey.IsNil)
{
Console.Error.WriteLine("PE file is not a delay-signed assembly.");
return(false);
}
return(true);
}
private bool IsAssembly(string path, out bool isPE)
{
isPE = false;
using (FileStream file = File.OpenRead(path))
{
try
{
PEReader peReader = new PEReader(file);
CorHeader corHeader = peReader.PEHeaders.CorHeader;
isPE = true; // If peReader.PEHeaders doesn't throw, it is a valid PEImage
return(corHeader != null);
}
catch (BadImageFormatException)
{
}
}
return(false);
}
public static MemoryMappedMetadata Load(PEImage pe, out CorHeader corHeader)
{
var dd = pe.Directories[DataDirectories.CLIHeader];
if (dd.IsNull)
{
throw new BadImageFormatException(string.Format(SR.MetadataImageNotValid, pe.Location));
}
MemoryMappedMetadata metadata;
using (var accessor = pe.OpenImageToSectionData(dd.RVA))
{
corHeader = CorHeader.Read(accessor, pe.Location);
if (corHeader.Metadata.IsNull)
{
throw new BadImageFormatException(string.Format(SR.MetadataImageNotValid, pe.Location));
}
long position = pe.ResolvePositionToSectionData(corHeader.Metadata.RVA);
metadata = new MemoryMappedMetadata(accessor.Map(position, corHeader.Metadata.Size));
}
return metadata;
}
private static void WriteCorHeader(Stream peStream, CorHeader corHeader)
{
var writer = new BlobBuilder(CorHeaderSize);
writer.WriteUInt32(CorHeaderSize);
writer.WriteUInt16(corHeader.MajorRuntimeVersion);
writer.WriteUInt16(corHeader.MinorRuntimeVersion);
writer.WriteUInt32((uint)corHeader.MetadataDirectory.RelativeVirtualAddress);
writer.WriteUInt32((uint)corHeader.MetadataDirectory.Size);
writer.WriteUInt32((uint)corHeader.Flags);
writer.WriteUInt32((uint)corHeader.EntryPointTokenOrRelativeVirtualAddress);
writer.WriteUInt32((uint)(corHeader.ResourcesDirectory.Size == 0 ? 0 : corHeader.ResourcesDirectory.RelativeVirtualAddress)); // 28
writer.WriteUInt32((uint)corHeader.ResourcesDirectory.Size);
writer.WriteUInt32((uint)(corHeader.StrongNameSignatureDirectory.Size == 0 ? 0 : corHeader.StrongNameSignatureDirectory.RelativeVirtualAddress)); // 36
writer.WriteUInt32((uint)corHeader.StrongNameSignatureDirectory.Size);
writer.WriteUInt32((uint)corHeader.CodeManagerTableDirectory.RelativeVirtualAddress);
writer.WriteUInt32((uint)corHeader.CodeManagerTableDirectory.Size);
writer.WriteUInt32((uint)corHeader.VtableFixupsDirectory.RelativeVirtualAddress);
writer.WriteUInt32((uint)corHeader.VtableFixupsDirectory.Size);
writer.WriteUInt32((uint)corHeader.ExportAddressTableJumpsDirectory.RelativeVirtualAddress);
writer.WriteUInt32((uint)corHeader.ExportAddressTableJumpsDirectory.Size);
writer.WriteUInt64(0);
Debug.Assert(writer.Count == CorHeaderSize);
Debug.Assert(writer.Count % 4 == 0);
writer.WriteContentTo(peStream);
}
private string GetProcessorArchitecture()
{
string processorArchitecture = "unknown";
if (_peReader.PEHeaders == null ||
_peReader.PEHeaders.CoffHeader == null)
{
return(processorArchitecture);
}
Machine machine = _peReader.PEHeaders.CoffHeader.Machine;
CorHeader corHeader = _peReader.PEHeaders.CorHeader;
if (corHeader != null)
{
CorFlags corFlags = corHeader.Flags;
if ((corFlags & CorFlags.ILLibrary) != 0)
{
processorArchitecture = "msil";
}
else
{
switch (machine)
{
case Machine.I386:
// "x86" only if corflags "requires" but not "prefers" x86
if ((corFlags & CorFlags.Requires32Bit) != 0 &&
(corFlags & CorFlags.Prefers32Bit) == 0)
{
processorArchitecture = "x86";
}
else
{
processorArchitecture = "msil";
}
break;
case Machine.IA64:
processorArchitecture = "ia64";
break;
case Machine.Amd64:
processorArchitecture = "amd64";
break;
case Machine.Arm:
processorArchitecture = "arm";
break;
case Machine.Arm64:
processorArchitecture = "arm64";
break;
default:
break;
}
}
}
return(processorArchitecture);
}
private CorHeader CreateCorHeader(MetadataSizes metadataSizes, int entryPointToken)
{
CorHeader corHeader = new CorHeader();
corHeader.CodeManagerTable.RelativeVirtualAddress = 0;
corHeader.CodeManagerTable.Size = 0;
corHeader.EntryPointToken = (uint)entryPointToken;
corHeader.ExportAddressTableJumps.RelativeVirtualAddress = 0;
corHeader.ExportAddressTableJumps.Size = 0;
corHeader.Flags = this.GetCorHeaderFlags();
corHeader.MajorRuntimeVersion = 2;
corHeader.MetadataDirectory.RelativeVirtualAddress = _textSection.RelativeVirtualAddress + (uint)ComputeOffsetToMetadata(metadataSizes.ILStreamSize);
corHeader.MetadataDirectory.Size = (uint)metadataSizes.MetadataSize;
corHeader.MinorRuntimeVersion = 5;
corHeader.Resources.RelativeVirtualAddress = corHeader.MetadataDirectory.RelativeVirtualAddress + corHeader.MetadataDirectory.Size;
corHeader.Resources.Size = (uint)metadataSizes.ResourceDataSize;
corHeader.StrongNameSignature.RelativeVirtualAddress = corHeader.Resources.RelativeVirtualAddress + corHeader.Resources.Size;
corHeader.StrongNameSignature.Size = (uint)ComputeStrongNameSignatureSize();
corHeader.VTableFixups.RelativeVirtualAddress = 0;
corHeader.VTableFixups.Size = 0;
return corHeader;
}
private static void WriteCorHeader(Stream peStream, CorHeader corHeader)
{
var writer = new BlobWriter(72);
writer.WriteUint(72); // Number of bytes in this header 4
writer.WriteUshort(corHeader.MajorRuntimeVersion); // 6
writer.WriteUshort(corHeader.MinorRuntimeVersion); // 8
writer.WriteUint(corHeader.MetadataDirectory.RelativeVirtualAddress); // 12
writer.WriteUint(corHeader.MetadataDirectory.Size); // 16
writer.WriteUint((uint)corHeader.Flags); // 20
writer.WriteUint(corHeader.EntryPointToken); // 24
writer.WriteUint(corHeader.Resources.Size == 0 ? 0u : corHeader.Resources.RelativeVirtualAddress); // 28
writer.WriteUint(corHeader.Resources.Size); // 32
writer.WriteUint(corHeader.StrongNameSignature.Size == 0 ? 0u : corHeader.StrongNameSignature.RelativeVirtualAddress); // 36
writer.WriteUint(corHeader.StrongNameSignature.Size); // 40
writer.WriteUint(corHeader.CodeManagerTable.RelativeVirtualAddress); // 44
writer.WriteUint(corHeader.CodeManagerTable.Size); // 48
writer.WriteUint(corHeader.VTableFixups.RelativeVirtualAddress); // 52
writer.WriteUint(corHeader.VTableFixups.Size); // 56
writer.WriteUint(corHeader.ExportAddressTableJumps.RelativeVirtualAddress); // 60
writer.WriteUint(corHeader.ExportAddressTableJumps.Size); // 64
writer.WriteUlong(0); // 72
writer.WriteTo(peStream);
}
private void WriteTextSection(
Stream peStream,
CorHeader corHeader,
BlobWriter metadataWriter,
BlobWriter ilStream,
BlobWriter mappedFieldDataWriter,
BlobWriter managedResourceWriter,
MetadataSizes metadataSizes,
ContentId pdbContentId,
out long metadataPosition)
{
peStream.Position = _textSection.PointerToRawData;
if (_emitRuntimeStartupStub)
{
this.WriteImportAddressTable(peStream);
}
WriteCorHeader(peStream, corHeader);
WriteIL(peStream, ilStream);
metadataPosition = peStream.Position;
WriteMetadata(peStream, metadataWriter);
WriteManagedResources(peStream, managedResourceWriter);
WriteSpaceForHash(peStream, (int)corHeader.StrongNameSignature.Size);
WriteDebugTable(peStream, pdbContentId, metadataSizes);
if (_emitRuntimeStartupStub)
{
WriteImportTable(peStream);
WriteNameTable(peStream);
WriteRuntimeStartupStub(peStream);
}
WriteMappedFieldData(peStream, mappedFieldDataWriter);
}
private void WriteTextSection(
Stream peStream,
CorHeader corHeader,
MemoryStream metadataStream,
MemoryStream ilStream,
MemoryStream mappedFieldDataStream,
MemoryStream managedResourceStream,
out long startOfMetadata,
out long positionOfTimestamp)
{
peStream.Position = _textSection.PointerToRawData;
if (_emitRuntimeStartupStub)
{
this.WriteImportAddressTable(peStream);
}
WriteCorHeader(peStream, corHeader);
WriteIL(peStream, ilStream);
startOfMetadata = peStream.Position;
WriteMetadata(peStream, metadataStream);
this.WriteManagedResources(peStream, managedResourceStream);
WriteSpaceForHash(peStream, (int)corHeader.StrongNameSignature.Size);
this.WriteDebugTable(peStream, out positionOfTimestamp);
if (_emitRuntimeStartupStub)
{
this.WriteImportTable(peStream);
this.WriteNameTable(peStream);
this.WriteRuntimeStartupStub(peStream);
}
WriteMappedFieldData(peStream, mappedFieldDataStream);
}
