private static void WriteUTF16Z(ByteBuffer bb, string str) { foreach (char c in str) { bb.Write((short)c); } bb.Write((short)0); }
private void WriteEntry(ByteBuffer bb, ref int offset, Dictionary <string, int> strings, ref int stringTableOffset, ByteBuffer stringTable) { WriteNameOrOrdinal(bb, OrdinalOrName, strings, ref stringTableOffset, stringTable); if (Data == null) { bb.Write(0x80000000U | (uint)offset); } else { bb.Write(offset); } offset += 16 + entries.Count * 8; }
private static void WriteString(ByteBuffer bb, string name, string value) { value = value ?? " "; int pos = bb.Position; bb.Write((short)0); // wLength (placeholder) bb.Write((short)(value.Length + 1)); // wValueLength bb.Write((short)1); // wType WriteUTF16Z(bb, name); bb.Align(4); WriteUTF16Z(bb, value); bb.Align(4); int savedPos = bb.Position; bb.Position = pos; bb.Write((short)(savedPos - pos)); bb.Position = savedPos; }
internal void Write(MetadataWriter mw, uint rva) { foreach (int offset in linkOffsets) { bb.Position = offset; bb.Write(bb.GetInt32AtCurrentPosition() + (int)rva); } mw.Write(bb); }
private void WriteResourceDataEntries(ByteBuffer bb, List <int> linkOffsets, ref int offset) { foreach (ResourceDirectoryEntry entry in entries) { if (entry.Data != null) { linkOffsets.Add(bb.Position); bb.Write(offset); bb.Write(entry.Data.Length); bb.Write(0); // code page bb.Write(0); // reserved offset += (entry.Data.Length + 3) & ~3; } else { entry.WriteResourceDataEntries(bb, linkOffsets, ref offset); } } }
private void SetDataAndRvaImpl(byte[] data, ByteBuffer bb, int readonlyMarker) { attribs |= FieldAttributes.HasFieldRVA; FieldRVATable.Record rec = new FieldRVATable.Record(); bb.Align(8); rec.RVA = bb.Position + readonlyMarker; rec.Field = pseudoToken; typeBuilder.ModuleBuilder.FieldRVA.AddRecord(rec); bb.Write(data); }
private static void StrongName(Stream stream, StrongNameKeyPair keyPair, uint headerLength, uint textSectionFileOffset, uint strongNameSignatureFileOffset, uint strongNameSignatureLength) { SHA1Managed hash = new SHA1Managed(); using (CryptoStream cs = new CryptoStream(Stream.Null, hash, CryptoStreamMode.Write)) { stream.Seek(0, SeekOrigin.Begin); byte[] buf = new byte[8192]; HashChunk(stream, cs, buf, (int)headerLength); stream.Seek(textSectionFileOffset, SeekOrigin.Begin); HashChunk(stream, cs, buf, (int)(strongNameSignatureFileOffset - textSectionFileOffset)); stream.Seek(strongNameSignatureLength, SeekOrigin.Current); HashChunk(stream, cs, buf, (int)(stream.Length - (strongNameSignatureFileOffset + strongNameSignatureLength))); } using (RSA rsa = CryptoHack.CreateRSA(keyPair)) { RSAPKCS1SignatureFormatter sign = new RSAPKCS1SignatureFormatter(rsa); byte[] signature = sign.CreateSignature(hash); Array.Reverse(signature); if (signature.Length != strongNameSignatureLength) { throw new InvalidOperationException("Signature length mismatch"); } stream.Seek(strongNameSignatureFileOffset, SeekOrigin.Begin); stream.Write(signature, 0, signature.Length); } // compute the PE checksum stream.Seek(0, SeekOrigin.Begin); int count = (int)stream.Length / 4; BinaryReader br = new BinaryReader(stream); long sum = 0; for (int i = 0; i < count; i++) { sum += br.ReadUInt32(); int carry = (int)(sum >> 32); sum &= 0xFFFFFFFFU; sum += carry; } while ((sum >> 16) != 0) { sum = (sum & 0xFFFF) + (sum >> 16); } sum += stream.Length; // write the PE checksum, note that it is always at offset 0xD8 in the file ByteBuffer bb = new ByteBuffer(4); bb.Write((int)sum); stream.Seek(0xD8, SeekOrigin.Begin); bb.WriteTo(stream); }
private void Write(ByteBuffer bb, int writeDepth, int currentDepth, ref int offset, Dictionary <string, int> strings, ref int stringTableOffset, ByteBuffer stringTable) { if (currentDepth == writeDepth) { // directory header bb.Write(0); // Characteristics bb.Write(0); // Time/Date Stamp bb.Write(0); // Version (Major / Minor) bb.Write((ushort)namedEntries); bb.Write((ushort)(entries.Count - namedEntries)); } foreach (ResourceDirectoryEntry entry in entries) { if (currentDepth == writeDepth) { entry.WriteEntry(bb, ref offset, strings, ref stringTableOffset, stringTable); } else { entry.Write(bb, writeDepth, currentDepth + 1, ref offset, strings, ref stringTableOffset, stringTable); } } }
private static void WriteNameOrOrdinal(ByteBuffer bb, OrdinalOrName id, Dictionary <string, int> strings, ref int stringTableOffset, ByteBuffer stringTable) { if (id.Name == null) { bb.Write((int)id.Ordinal); } else { int stringOffset; if (!strings.TryGetValue(id.Name, out stringOffset)) { stringOffset = stringTableOffset; strings.Add(id.Name, stringOffset); stringTableOffset += id.Name.Length * 2 + 2; stringTable.Write((ushort)id.Name.Length); foreach (char c in id.Name) { stringTable.Write((short)c); } } bb.Write(0x80000000U | (uint)stringOffset); } }
private void WriteData(ByteBuffer bb) { foreach (ResourceDirectoryEntry entry in entries) { if (entry.Data != null) { bb.Write(entry.Data); bb.Align(4); } else { entry.WriteData(bb); } } }
private static void StrongName(Stream stream, StrongNameKeyPair keyPair, uint headerLength, uint textSectionFileOffset, uint strongNameSignatureFileOffset, uint strongNameSignatureLength) { byte[] hash; using (SHA1 sha1 = SHA1.Create()) { stream.Seek(0, SeekOrigin.Begin); Stream skipStream = new SkipStream(stream, strongNameSignatureFileOffset, strongNameSignatureLength); skipStream = new SkipStream(skipStream, headerLength, textSectionFileOffset - headerLength); hash = sha1.ComputeHash(skipStream); } using (RSACryptoServiceProvider rsa = keyPair.CreateRSA()) { byte[] signature = rsa.SignHash(hash, "1.3.14.3.2.26"); Array.Reverse(signature); if (signature.Length != strongNameSignatureLength) { throw new InvalidOperationException("Signature length mismatch"); } stream.Seek(strongNameSignatureFileOffset, SeekOrigin.Begin); stream.Write(signature, 0, signature.Length); } // compute the PE checksum stream.Seek(0, SeekOrigin.Begin); int count = (int)stream.Length / 4; BinaryReader br = new BinaryReader(stream); long sum = 0; for (int i = 0; i < count; i++) { sum += br.ReadUInt32(); int carry = (int)(sum >> 32); sum &= 0xFFFFFFFFU; sum += carry; } while ((sum >> 16) != 0) { sum = (sum & 0xFFFF) + (sum >> 16); } sum += stream.Length; // write the PE checksum, note that it is always at offset 0xD8 in the file ByteBuffer bb = new ByteBuffer(4); bb.Write((int)sum); stream.Seek(0xD8, SeekOrigin.Begin); bb.WriteTo(stream); }
internal void Write(ByteBuffer bb, List <int> linkOffsets) { if (entries.Count != 0) { int stringTableOffset = this.DirectoryLength; Dictionary <string, int> strings = new Dictionary <string, int>(); ByteBuffer stringTable = new ByteBuffer(16); int offset = 16 + entries.Count * 8; for (int pass = 0; pass < 3; pass++) { Write(bb, pass, 0, ref offset, strings, ref stringTableOffset, stringTable); } // the pecoff spec says that the string table is between the directory entries and the data entries, // but the windows linker puts them after the data entries, so we do too. stringTable.Align(4); offset += stringTable.Length; WriteResourceDataEntries(bb, linkOffsets, ref offset); bb.Write(stringTable); WriteData(bb); } }
private void WriteSigImpl(ModuleBuilder module, ByteBuffer bb, int parameterCount) { byte first; if ((callingConvention & CallingConventions.Any) == CallingConventions.VarArgs) { Debug.Assert(genericParamCount == 0); first = VARARG; } else if (genericParamCount > 0) { first = GENERIC; } else { first = DEFAULT; } if ((callingConvention & CallingConventions.HasThis) != 0) { first |= HASTHIS; } if ((callingConvention & CallingConventions.ExplicitThis) != 0) { first |= EXPLICITTHIS; } bb.Write(first); if (genericParamCount > 0) { bb.WriteCompressedInt(genericParamCount); } bb.WriteCompressedInt(parameterCount); // RetType if (modifiers != null && modifiers[0] != null) { WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, modifiers[0][0]); WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, modifiers[0][1]); } WriteType(module, bb, returnType); // Param for (int i = 0; i < parameterTypes.Length; i++) { if (modifiers != null && modifiers[i + 1] != null) { WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, modifiers[i + 1][0]); WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, modifiers[i + 1][1]); } WriteType(module, bb, parameterTypes[i]); } }
private static void WriteString(ByteBuffer bb, string str) { byte[] buf = Encoding.UTF8.GetBytes(str); bb.WriteCompressedUInt(buf.Length); bb.Write(buf); }
private static void WriteNameOrOrdinal(ByteBuffer bb, OrdinalOrName id, Dictionary<string, int> strings, ref int stringTableOffset, ByteBuffer stringTable) { if (id.Name == null) { bb.Write((int)id.Ordinal); } else { int stringOffset; if (!strings.TryGetValue(id.Name, out stringOffset)) { stringOffset = stringTableOffset; strings.Add(id.Name, stringOffset); stringTableOffset += id.Name.Length * 2 + 2; stringTable.Write((ushort)id.Name.Length); foreach (char c in id.Name) { stringTable.Write((short)c); } } bb.Write(0x80000000U | (uint)stringOffset); } }
private void Write(ByteBuffer bb, int writeDepth, int currentDepth, ref int offset, Dictionary<string, int> strings, ref int stringTableOffset, ByteBuffer stringTable) { if (currentDepth == writeDepth) { // directory header bb.Write(0); // Characteristics bb.Write(0); // Time/Date Stamp bb.Write(0); // Version (Major / Minor) bb.Write((ushort)namedEntries); bb.Write((ushort)(entries.Count - namedEntries)); } foreach (ResourceDirectoryEntry entry in entries) { if (currentDepth == writeDepth) { entry.WriteEntry(bb, ref offset, strings, ref stringTableOffset, stringTable); } else { entry.Write(bb, writeDepth, currentDepth + 1, ref offset, strings, ref stringTableOffset, stringTable); } } }
private void WriteResourceDataEntries(ByteBuffer bb, List<int> linkOffsets, ref int offset) { foreach (ResourceDirectoryEntry entry in entries) { if (entry.Data != null) { linkOffsets.Add(bb.Position); bb.Write(offset); bb.Write(entry.Data.Length); bb.Write(0); // code page bb.Write(0); // reserved offset += (entry.Data.Length + 3) & ~3; } else { entry.WriteResourceDataEntries(bb, linkOffsets, ref offset); } } }
internal BlobHeap() { buf.Write((byte)0); }
internal static void WriteMethodSpec(ModuleBuilder module, ByteBuffer bb, Type[] genArgs) { bb.Write(GENERICINST); bb.WriteCompressedUInt(genArgs.Length); foreach (Type arg in genArgs) { WriteType(module, bb, arg); } }
protected static void WriteType(ModuleBuilder module, ByteBuffer bb, Type type) { while (type.HasElementType) { if (type.__IsVector) { bb.Write(ELEMENT_TYPE_SZARRAY); } else if (type.IsArray) { int rank = type.GetArrayRank(); bb.Write(ELEMENT_TYPE_ARRAY); // LAMESPEC the Type production (23.2.12) doesn't include CustomMod* for arrays, but the verifier allows it and ildasm also supports it WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, type.__GetRequiredCustomModifiers()); WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, type.__GetOptionalCustomModifiers()); WriteType(module, bb, type.GetElementType()); bb.WriteCompressedInt(rank); // since a Type doesn't contain the lower/upper bounds // (they act like a custom modifier, so they are part of the signature, but not of the Type), // we set them to the C# compatible values and hope for the best bb.WriteCompressedInt(0); // boundsCount bb.WriteCompressedInt(rank); // loCount for (int i = 0; i < rank; i++) { bb.WriteCompressedInt(0); } return; } else if (type.IsByRef) { bb.Write(ELEMENT_TYPE_BYREF); } else if (type.IsPointer) { bb.Write(ELEMENT_TYPE_PTR); } WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, type.__GetRequiredCustomModifiers()); WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, type.__GetOptionalCustomModifiers()); type = type.GetElementType(); } Universe u = module.universe; if (type == u.System_Void) { bb.Write(ELEMENT_TYPE_VOID); } else if (type == u.System_Int32) { bb.Write(ELEMENT_TYPE_I4); } else if (type == u.System_Boolean) { bb.Write(ELEMENT_TYPE_BOOLEAN); } else if (type == u.System_String) { bb.Write(ELEMENT_TYPE_STRING); } else if (type == u.System_Char) { bb.Write(ELEMENT_TYPE_CHAR); } else if (type == u.System_SByte) { bb.Write(ELEMENT_TYPE_I1); } else if (type == u.System_Byte) { bb.Write(ELEMENT_TYPE_U1); } else if (type == u.System_Int16) { bb.Write(ELEMENT_TYPE_I2); } else if (type == u.System_UInt16) { bb.Write(ELEMENT_TYPE_U2); } else if (type == u.System_UInt32) { bb.Write(ELEMENT_TYPE_U4); } else if (type == u.System_Int64) { bb.Write(ELEMENT_TYPE_I8); } else if (type == u.System_UInt64) { bb.Write(ELEMENT_TYPE_U8); } else if (type == u.System_Single) { bb.Write(ELEMENT_TYPE_R4); } else if (type == u.System_Double) { bb.Write(ELEMENT_TYPE_R8); } else if (type == u.System_IntPtr) { bb.Write(ELEMENT_TYPE_I); } else if (type == u.System_UIntPtr) { bb.Write(ELEMENT_TYPE_U); } else if (type == u.System_TypedReference) { bb.Write(ELEMENT_TYPE_TYPEDBYREF); } else if (type == u.System_Object) { bb.Write(ELEMENT_TYPE_OBJECT); } else if (type.IsGenericParameter) { if (type is UnboundGenericMethodParameter || type.DeclaringMethod != null) { bb.Write(ELEMENT_TYPE_MVAR); } else { bb.Write(ELEMENT_TYPE_VAR); } bb.WriteCompressedInt(type.GenericParameterPosition); } else if (type.IsGenericType) { WriteGenericSignature(module, bb, type); } else { if (type.IsValueType) { bb.Write(ELEMENT_TYPE_VALUETYPE); } else { bb.Write(ELEMENT_TYPE_CLASS); } bb.WriteTypeDefOrRefEncoded(module.GetTypeToken(type).Token); } }
protected static void WriteCustomModifiers(ModuleBuilder module, ByteBuffer bb, byte mod, Type[] modifiers) { if (modifiers != null) { foreach (Type type in modifiers) { bb.Write(mod); bb.WriteTypeDefOrRefEncoded(module.GetTypeTokenForMemberRef(type)); } } }
// unmanaged calling convention internal static void WriteStandAloneMethodSig(ModuleBuilder module, ByteBuffer bb, CallingConvention callingConvention, Type returnType, Type[] parameterTypes) { switch (callingConvention) { case CallingConvention.Cdecl: bb.Write((byte)0x01); // C break; case CallingConvention.StdCall: case CallingConvention.Winapi: bb.Write((byte)0x02); // STDCALL break; case CallingConvention.ThisCall: bb.Write((byte)0x03); // THISCALL break; case CallingConvention.FastCall: bb.Write((byte)0x04); // FASTCALL break; default: throw new ArgumentOutOfRangeException("callingConvention"); } bb.WriteCompressedInt(parameterTypes.Length); WriteType(module, bb, returnType); foreach (Type t in parameterTypes) { WriteType(module, bb, t); } }
// managed calling convention internal static void WriteStandAloneMethodSig(ModuleBuilder module, ByteBuffer bb, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes) { byte flags = 0; if ((callingConvention & CallingConventions.HasThis) != 0) { flags |= HASTHIS; } if ((callingConvention & CallingConventions.ExplicitThis) != 0) { flags |= EXPLICITTHIS; } if ((callingConvention & CallingConventions.VarArgs) != 0) { flags |= VARARG; } bb.Write(flags); bb.WriteCompressedInt(parameterTypes.Length + optionalParameterTypes.Length); WriteType(module, bb, returnType); foreach (Type t in parameterTypes) { WriteType(module, bb, t); } if (optionalParameterTypes.Length > 0) { bb.Write(SENTINEL); foreach (Type t in optionalParameterTypes) { WriteType(module, bb, t); } } }
internal static void WriteLocalVarSig(ModuleBuilder module, ByteBuffer bb, IList<LocalBuilder> locals) { bb.Write(LOCAL_SIG); bb.WriteCompressedInt(locals.Count); foreach (LocalBuilder local in locals) { if (local.IsPinned) { bb.Write(ELEMENT_TYPE_PINNED); } WriteType(module, bb, local.LocalType); } }
internal static void WritePropertySig(ModuleBuilder module, ByteBuffer bb, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers) { byte flags = PROPERTY; if ((callingConvention & CallingConventions.HasThis) != 0) { flags |= HASTHIS; } if ((callingConvention & CallingConventions.ExplicitThis) != 0) { flags |= EXPLICITTHIS; } if ((callingConvention & CallingConventions.VarArgs) != 0) { flags |= VARARG; } bb.Write(flags); bb.WriteCompressedInt(parameterTypes == null ? 0 : parameterTypes.Length); WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, returnTypeRequiredCustomModifiers); WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, returnTypeOptionalCustomModifiers); WriteType(module, bb, returnType); if (parameterTypes != null) { for (int i = 0; i < parameterTypes.Length; i++) { if (parameterTypeRequiredCustomModifiers != null) { WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_REQD, parameterTypeRequiredCustomModifiers[i]); } if (parameterTypeOptionalCustomModifiers != null) { WriteCustomModifiers(module, bb, ELEMENT_TYPE_CMOD_OPT, parameterTypeOptionalCustomModifiers[i]); } WriteType(module, bb, parameterTypes[i]); } } }
internal void AddIcon(byte[] iconFile) { BinaryReader br = new BinaryReader(new MemoryStream(iconFile)); ushort idReserved = br.ReadUInt16(); ushort idType = br.ReadUInt16(); ushort idCount = br.ReadUInt16(); if (idReserved != 0 || idType != 1) { throw new ArgumentException("The supplied byte array is not a valid .ico file."); } ByteBuffer group = new ByteBuffer(6 + 14 * idCount); group.Write(idReserved); group.Write(idType); group.Write(idCount); for (int i = 0; i < idCount; i++) { byte bWidth = br.ReadByte(); byte bHeight = br.ReadByte(); byte bColorCount = br.ReadByte(); byte bReserved = br.ReadByte(); ushort wPlanes = br.ReadUInt16(); ushort wBitCount = br.ReadUInt16(); uint dwBytesInRes = br.ReadUInt32(); uint dwImageOffset = br.ReadUInt32(); // we start the icon IDs at 2 ushort id = (ushort)(2 + i); group.Write(bWidth); group.Write(bHeight); group.Write(bColorCount); group.Write(bReserved); group.Write(wPlanes); group.Write(wBitCount); group.Write(dwBytesInRes); group.Write(id); byte[] icon = new byte[dwBytesInRes]; Buffer.BlockCopy(iconFile, (int)dwImageOffset, icon, 0, icon.Length); root[new OrdinalOrName(RT_ICON)][new OrdinalOrName(id)][new OrdinalOrName(0)].Data = ByteBuffer.Wrap(icon); } root[new OrdinalOrName(RT_GROUP_ICON)][new OrdinalOrName(32512)][new OrdinalOrName(0)].Data = group; }
internal static void WriteStandAloneMethodSig(ModuleBuilder module, ByteBuffer bb, __StandAloneMethodSig sig) { if (sig.IsUnmanaged) { switch (sig.UnmanagedCallingConvention) { case CallingConvention.Cdecl: bb.Write((byte)0x01); // C break; case CallingConvention.StdCall: case CallingConvention.Winapi: bb.Write((byte)0x02); // STDCALL break; case CallingConvention.ThisCall: bb.Write((byte)0x03); // THISCALL break; case CallingConvention.FastCall: bb.Write((byte)0x04); // FASTCALL break; default: throw new ArgumentOutOfRangeException("callingConvention"); } } else { CallingConventions callingConvention = sig.CallingConvention; byte flags = 0; if ((callingConvention & CallingConventions.HasThis) != 0) { flags |= HASTHIS; } if ((callingConvention & CallingConventions.ExplicitThis) != 0) { flags |= EXPLICITTHIS; } if ((callingConvention & CallingConventions.VarArgs) != 0) { flags |= VARARG; } bb.Write(flags); } Type[] parameterTypes = sig.ParameterTypes; Type[] optionalParameterTypes = sig.OptionalParameterTypes; bb.WriteCompressedUInt(parameterTypes.Length + optionalParameterTypes.Length); WriteCustomModifiers(module, bb, sig.GetReturnTypeCustomModifiers()); WriteType(module, bb, sig.ReturnType); int index = 0; foreach (Type t in parameterTypes) { WriteCustomModifiers(module, bb, sig.GetParameterCustomModifiers(index++)); WriteType(module, bb, t); } // note that optional parameters are only allowed for managed signatures (but we don't enforce that) if (optionalParameterTypes.Length > 0) { bb.Write(SENTINEL); foreach (Type t in optionalParameterTypes) { WriteCustomModifiers(module, bb, sig.GetParameterCustomModifiers(index++)); WriteType(module, bb, t); } } }
private static void WriteUTF16Z(ByteBuffer bb, string str) { foreach (char c in str) { bb.Write((short)c); } bb.Write((short)0); }
internal static void WriteSignatureHelper(ModuleBuilder module, ByteBuffer bb, byte flags, ushort paramCount, List<Type> args) { bb.Write(flags); if (flags != FIELD) { bb.WriteCompressedUInt(paramCount); } foreach (Type type in args) { if (type == null) { bb.Write(ELEMENT_TYPE_VOID); } else if (type is MarkerType) { bb.Write(type.SigElementType); } else { WriteType(module, bb, type); } } }
private static void StrongName(FileStream fs, StrongNameKeyPair keyPair, uint headerLength, uint textSectionFileOffset, uint strongNameSignatureFileOffset, uint strongNameSignatureLength) { SHA1Managed hash = new SHA1Managed(); using (CryptoStream cs = new CryptoStream(Stream.Null, hash, CryptoStreamMode.Write)) { fs.Seek(0, SeekOrigin.Begin); byte[] buf = new byte[8192]; HashChunk(fs, cs, buf, (int)headerLength); fs.Seek(textSectionFileOffset, SeekOrigin.Begin); HashChunk(fs, cs, buf, (int)(strongNameSignatureFileOffset - textSectionFileOffset)); fs.Seek(strongNameSignatureLength, SeekOrigin.Current); HashChunk(fs, cs, buf, (int)(fs.Length - (strongNameSignatureFileOffset + strongNameSignatureLength))); } using (RSA rsa = CryptoHack.CreateRSA(keyPair)) { RSAPKCS1SignatureFormatter sign = new RSAPKCS1SignatureFormatter(rsa); sign.SetHashAlgorithm("SHA1"); byte[] signature = sign.CreateSignature(hash.Hash); Array.Reverse(signature); Debug.Assert(signature.Length == strongNameSignatureLength); fs.Seek(strongNameSignatureFileOffset, SeekOrigin.Begin); fs.Write(signature, 0, signature.Length); } // compute the PE checksum fs.Seek(0, SeekOrigin.Begin); int count = (int)fs.Length / 4; BinaryReader br = new BinaryReader(fs); long sum = 0; for (int i = 0; i < count; i++) { sum += br.ReadUInt32(); int carry = (int)(sum >> 32); sum &= 0xFFFFFFFFU; sum += carry; } while ((sum >> 16) != 0) { sum = (sum & 0xFFFF) + (sum >> 16); } sum += fs.Length; // write the PE checksum, note that it is always at offset 0xD8 in the file ByteBuffer bb = new ByteBuffer(4); bb.Write((int)sum); fs.Seek(0xD8, SeekOrigin.Begin); bb.WriteTo(fs); }
internal void Write(ByteBuffer bb, List<int> linkOffsets) { if (entries.Count != 0) { int stringTableOffset = this.DirectoryLength; Dictionary<string, int> strings = new Dictionary<string, int>(); ByteBuffer stringTable = new ByteBuffer(16); int offset = 16 + entries.Count * 8; for (int pass = 0; pass < 3; pass++) { Write(bb, pass, 0, ref offset, strings, ref stringTableOffset, stringTable); } // the pecoff spec says that the string table is between the directory entries and the data entries, // but the windows linker puts them after the data entries, so we do too. stringTable.Align(4); offset += stringTable.Length; WriteResourceDataEntries(bb, linkOffsets, ref offset); bb.Write(stringTable); WriteData(bb); } }
internal override void WriteSig(ModuleBuilder module, ByteBuffer bb) { byte flags = PROPERTY; if ((callingConvention & CallingConventions.HasThis) != 0) { flags |= HASTHIS; } if ((callingConvention & CallingConventions.ExplicitThis) != 0) { flags |= EXPLICITTHIS; } if ((callingConvention & CallingConventions.VarArgs) != 0) { flags |= VARARG; } bb.Write(flags); bb.WriteCompressedInt(parameterTypes == null ? 0 : parameterTypes.Length); WriteCustomModifiers(module, bb, customModifiers.GetReturnTypeCustomModifiers()); WriteType(module, bb, propertyType); if (parameterTypes != null) { for (int i = 0; i < parameterTypes.Length; i++) { WriteCustomModifiers(module, bb, customModifiers.GetParameterCustomModifiers(i)); WriteType(module, bb, parameterTypes[i]); } } }
private void WriteData(ByteBuffer bb) { foreach (ResourceDirectoryEntry entry in entries) { if (entry.Data != null) { bb.Write(entry.Data); bb.Align(4); } else { entry.WriteData(bb); } } }
internal void WriteMethodRefSig(ModuleBuilder module, ByteBuffer bb, Type[] optionalParameterTypes, CustomModifiers[] customModifiers) { WriteSigImpl(module, bb, parameterTypes.Length + optionalParameterTypes.Length); if (optionalParameterTypes.Length > 0) { bb.Write(SENTINEL); for (int i = 0; i < optionalParameterTypes.Length; i++) { WriteCustomModifiers(module, bb, Util.NullSafeElementAt(customModifiers, i)); WriteType(module, bb, optionalParameterTypes[i]); } } }
private void WriteEntry(ByteBuffer bb, ref int offset, Dictionary<string, int> strings, ref int stringTableOffset, ByteBuffer stringTable) { WriteNameOrOrdinal(bb, OrdinalOrName, strings, ref stringTableOffset, stringTable); if (Data == null) { bb.Write(0x80000000U | (uint)offset); } else { bb.Write(offset); } offset += 16 + entries.Count * 8; }
protected static void WriteType(ModuleBuilder module, ByteBuffer bb, Type type) { while (type.HasElementType) { byte sigElementType = type.SigElementType; bb.Write(sigElementType); if (sigElementType == ELEMENT_TYPE_ARRAY) { // LAMESPEC the Type production (23.2.12) doesn't include CustomMod* for arrays, but the verifier allows it and ildasm also supports it WriteCustomModifiers(module, bb, type.__GetCustomModifiers()); WriteType(module, bb, type.GetElementType()); bb.WriteCompressedUInt(type.GetArrayRank()); int[] sizes = type.__GetArraySizes(); bb.WriteCompressedUInt(sizes.Length); for (int i = 0; i < sizes.Length; i++) { bb.WriteCompressedUInt(sizes[i]); } int[] lobounds = type.__GetArrayLowerBounds(); bb.WriteCompressedUInt(lobounds.Length); for (int i = 0; i < lobounds.Length; i++) { bb.WriteCompressedInt(lobounds[i]); } return; } WriteCustomModifiers(module, bb, type.__GetCustomModifiers()); type = type.GetElementType(); } if (type.__IsBuiltIn) { bb.Write(type.SigElementType); } else if (type.IsGenericParameter) { bb.Write(type.SigElementType); bb.WriteCompressedUInt(type.GenericParameterPosition); } else if (!type.__IsMissing && type.IsGenericType) { WriteGenericSignature(module, bb, type); } else if (type.__IsFunctionPointer) { bb.Write(ELEMENT_TYPE_FNPTR); WriteStandAloneMethodSig(module, bb, type.__MethodSignature); } else { if (type.IsValueType) { bb.Write(ELEMENT_TYPE_VALUETYPE); } else { bb.Write(ELEMENT_TYPE_CLASS); } bb.WriteTypeDefOrRefEncoded(module.GetTypeToken(type).Token); } }
internal void AddIcon(byte[] iconFile) { BinaryReader br = new BinaryReader(new MemoryStream(iconFile)); ushort idReserved = br.ReadUInt16(); ushort idType = br.ReadUInt16(); ushort idCount = br.ReadUInt16(); if (idReserved != 0 || idType != 1) { throw new ArgumentException("The supplied byte array is not a valid .ico file."); } ByteBuffer group = new ByteBuffer(6 + 14 * idCount); group.Write(idReserved); group.Write(idType); group.Write(idCount); for (int i = 0; i < idCount; i++) { byte bWidth = br.ReadByte(); byte bHeight = br.ReadByte(); byte bColorCount = br.ReadByte(); byte bReserved = br.ReadByte(); ushort wPlanes = br.ReadUInt16(); ushort wBitCount = br.ReadUInt16(); uint dwBytesInRes = br.ReadUInt32(); uint dwImageOffset = br.ReadUInt32(); // we start the icon IDs at 2 ushort id = (ushort)(2 + i); group.Write(bWidth); group.Write(bHeight); group.Write(bColorCount); group.Write(bReserved); group.Write(wPlanes); group.Write(wBitCount); group.Write(dwBytesInRes); group.Write(id); byte[] icon = new byte[dwBytesInRes]; Buffer.BlockCopy(iconFile, (int)dwImageOffset, icon, 0, icon.Length); root[new OrdinalOrName(RT_ICON)][new OrdinalOrName(id)][new OrdinalOrName(0)].Data = ByteBuffer.Wrap(icon); } root[new OrdinalOrName(RT_GROUP_ICON)][new OrdinalOrName(32512)][new OrdinalOrName(0)].Data = group; }
private static void WriteGenericSignature(ModuleBuilder module, ByteBuffer bb, Type type) { Type[] typeArguments = type.GetGenericArguments(); CustomModifiers[] customModifiers = type.__GetGenericArgumentsCustomModifiers(); if (!type.IsGenericTypeDefinition) { type = type.GetGenericTypeDefinition(); } bb.Write(ELEMENT_TYPE_GENERICINST); if (type.IsValueType) { bb.Write(ELEMENT_TYPE_VALUETYPE); } else { bb.Write(ELEMENT_TYPE_CLASS); } bb.WriteTypeDefOrRefEncoded(module.GetTypeToken(type).Token); bb.WriteCompressedUInt(typeArguments.Length); for (int i = 0; i < typeArguments.Length; i++) { WriteCustomModifiers(module, bb, customModifiers[i]); WriteType(module, bb, typeArguments[i]); } }
internal void WriteMethodRefSig(ModuleBuilder module, ByteBuffer bb, Type[] optionalParameterTypes) { WriteSigImpl(module, bb, parameterTypes.Length + optionalParameterTypes.Length); if (optionalParameterTypes.Length > 0) { bb.Write(SENTINEL); foreach (Type type in optionalParameterTypes) { WriteType(module, bb, type); } } }
protected static void WriteCustomModifiers(ModuleBuilder module, ByteBuffer bb, CustomModifiers modifiers) { foreach (CustomModifiers.Entry entry in modifiers) { bb.Write(entry.IsRequired ? ELEMENT_TYPE_CMOD_REQD : ELEMENT_TYPE_CMOD_OPT); bb.WriteTypeDefOrRefEncoded(module.GetTypeTokenForMemberRef(entry.Type)); } }
private static void WriteString(ByteBuffer bb, string name, string value) { value = value ?? " "; int pos = bb.Position; bb.Write((short)0); // wLength (placeholder) bb.Write((short)(value.Length + 1));// wValueLength bb.Write((short)1); // wType WriteUTF16Z(bb, name); bb.Align(4); WriteUTF16Z(bb, value); bb.Align(4); int savedPos = bb.Position; bb.Position = pos; bb.Write((short)(savedPos - pos)); bb.Position = savedPos; }
private static void StrongName(Stream stream, StrongNameKeyPair keyPair, uint headerLength, uint textSectionFileOffset, uint strongNameSignatureFileOffset, uint strongNameSignatureLength) { SHA1Managed hash = new SHA1Managed(); using (CryptoStream cs = new CryptoStream(Stream.Null, hash, CryptoStreamMode.Write)) { stream.Seek(0, SeekOrigin.Begin); byte[] buf = new byte[8192]; HashChunk(stream, cs, buf, (int)headerLength); stream.Seek(textSectionFileOffset, SeekOrigin.Begin); HashChunk(stream, cs, buf, (int)(strongNameSignatureFileOffset - textSectionFileOffset)); stream.Seek(strongNameSignatureLength, SeekOrigin.Current); HashChunk(stream, cs, buf, (int)(stream.Length - (strongNameSignatureFileOffset + strongNameSignatureLength))); } using (RSA rsa = keyPair.CreateRSA()) { RSAPKCS1SignatureFormatter sign = new RSAPKCS1SignatureFormatter(rsa); byte[] signature = sign.CreateSignature(hash); Array.Reverse(signature); if (signature.Length != strongNameSignatureLength) { throw new InvalidOperationException("Signature length mismatch"); } stream.Seek(strongNameSignatureFileOffset, SeekOrigin.Begin); stream.Write(signature, 0, signature.Length); } // compute the PE checksum stream.Seek(0, SeekOrigin.Begin); int count = (int)stream.Length / 4; BinaryReader br = new BinaryReader(stream); long sum = 0; for (int i = 0; i < count; i++) { sum += br.ReadUInt32(); int carry = (int)(sum >> 32); sum &= 0xFFFFFFFFU; sum += carry; } while ((sum >> 16) != 0) { sum = (sum & 0xFFFF) + (sum >> 16); } sum += stream.Length; // write the PE checksum, note that it is always at offset 0xD8 in the file ByteBuffer bb = new ByteBuffer(4); bb.Write((int)sum); stream.Seek(0xD8, SeekOrigin.Begin); bb.WriteTo(stream); }
internal void Write(ByteBuffer bb) { if (fileVersion == null) { if (name.Version != null) { fileVersion = name.Version.ToString(); } else { fileVersion = "0.0.0.0"; } } int codepage = 1200; // Unicode codepage int lcid = 0x7f; if (name.CultureInfo != null) { lcid = name.CultureInfo.LCID; } if (culture != null) { lcid = new CultureInfo(culture).LCID; } Version filever = ParseVersionRobust(fileVersion); int fileVersionMajor = filever.Major; int fileVersionMinor = filever.Minor; int fileVersionBuild = filever.Build; int fileVersionRevision = filever.Revision; int productVersionMajor = fileVersionMajor; int productVersionMinor = fileVersionMinor; int productVersionBuild = fileVersionBuild; int productVersionRevision = fileVersionRevision; if (informationalVersion != null) { Version productver = ParseVersionRobust(informationalVersion); productVersionMajor = productver.Major; productVersionMinor = productver.Minor; productVersionBuild = productver.Build; productVersionRevision = productver.Revision; } ByteBuffer stringTable = new ByteBuffer(512); stringTable.Write((short)0); // wLength (placeholder) stringTable.Write((short)0); // wValueLength stringTable.Write((short)1); // wType WriteUTF16Z(stringTable, string.Format("{0:x4}{1:x4}", lcid, codepage)); stringTable.Align(4); WriteString(stringTable, "Comments", description); WriteString(stringTable, "CompanyName", company); WriteString(stringTable, "FileDescription", title); WriteString(stringTable, "FileVersion", fileVersion); WriteString(stringTable, "InternalName", name.Name); WriteString(stringTable, "LegalCopyright", copyright); WriteString(stringTable, "LegalTrademarks", trademark); WriteString(stringTable, "OriginalFilename", fileName); WriteString(stringTable, "ProductName", product); WriteString(stringTable, "ProductVersion", informationalVersion); stringTable.Position = 0; stringTable.Write((short)stringTable.Length); ByteBuffer stringFileInfo = new ByteBuffer(512); stringFileInfo.Write((short)0); // wLength (placeholder) stringFileInfo.Write((short)0); // wValueLength stringFileInfo.Write((short)1); // wType WriteUTF16Z(stringFileInfo, "StringFileInfo"); stringFileInfo.Align(4); stringFileInfo.Write(stringTable); stringFileInfo.Position = 0; stringFileInfo.Write((short)stringFileInfo.Length); byte[] preamble1 = new byte[] { // VS_VERSIONINFO (platform SDK) 0x34, 0x00, // wValueLength 0x00, 0x00, // wType 0x56, 0x00, 0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, // "VS_VERSION_INFO\0" 0x00, 0x00, // Padding1 (32 bit alignment) // VS_FIXEDFILEINFO starts 0xBD, 0x04, 0xEF, 0xFE, // dwSignature (0xFEEF04BD) 0x00, 0x00, 0x01, 0x00, // dwStrucVersion }; byte[] preamble2 = new byte[] { 0x3F, 0x00, 0x00, 0x00, // dwFileFlagsMask (??) 0x00, 0x00, 0x00, 0x00, // dwFileFlags (??) 0x04, 0x00, 0x00, 0x00, // dwFileOS 0x02, 0x00, 0x00, 0x00, // dwFileType 0x00, 0x00, 0x00, 0x00, // dwFileSubtype 0x00, 0x00, 0x00, 0x00, // dwFileDateMS 0x00, 0x00, 0x00, 0x00, // dwFileDateLS // Padding2 (32 bit alignment) // VarFileInfo 0x44, 0x00, // wLength 0x00, 0x00, // wValueLength 0x01, 0x00, // wType 0x56, 0x00, 0x61, 0x00, 0x72, 0x00, 0x46, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x00, 0x00, // "VarFileInfo\0" 0x00, 0x00, // Padding // Var 0x24, 0x00, // wLength 0x04, 0x00, // wValueLength 0x00, 0x00, // wType 0x54, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, // "Translation\0" 0x00, 0x00, // Padding (32 bit alignment) }; bb.Write((short)(2 + preamble1.Length + 8 + 8 + preamble2.Length + 4 + stringFileInfo.Length)); bb.Write(preamble1); bb.Write((short)fileVersionMinor); bb.Write((short)fileVersionMajor); bb.Write((short)fileVersionRevision); bb.Write((short)fileVersionBuild); bb.Write((short)productVersionMinor); bb.Write((short)productVersionMajor); bb.Write((short)productVersionRevision); bb.Write((short)productVersionBuild); bb.Write(preamble2); bb.Write((short)lcid); bb.Write((short)codepage); bb.Write(stringFileInfo); }
internal void Write(ByteBuffer bb) { if (fileVersion == null) { if (name.Version != null) { fileVersion = name.Version.ToString(); } else { fileVersion = "0.0.0.0"; } } int codepage = 1200; // Unicode codepage int lcid = 0x7f; try { if (name.CultureInfo != null) { lcid = name.CultureInfo.LCID; } } catch (ArgumentException) { // AssemblyName.CultureInfo throws an ArgumentException if AssemblyBuilder.__SetAssemblyCulture() was used to specify a non-existing culture } Version filever = ParseVersionRobust(fileVersion); int fileVersionMajor = filever.Major; int fileVersionMinor = filever.Minor; int fileVersionBuild = filever.Build; int fileVersionRevision = filever.Revision; int productVersionMajor = fileVersionMajor; int productVersionMinor = fileVersionMinor; int productVersionBuild = fileVersionBuild; int productVersionRevision = fileVersionRevision; if (informationalVersion != null) { Version productver = ParseVersionRobust(informationalVersion); productVersionMajor = productver.Major; productVersionMinor = productver.Minor; productVersionBuild = productver.Build; productVersionRevision = productver.Revision; } ByteBuffer stringTable = new ByteBuffer(512); stringTable.Write((short)0); // wLength (placeholder) stringTable.Write((short)0); // wValueLength stringTable.Write((short)1); // wType WriteUTF16Z(stringTable, string.Format("{0:x4}{1:x4}", lcid, codepage)); stringTable.Align(4); WriteString(stringTable, "Comments", description); WriteString(stringTable, "CompanyName", company); WriteString(stringTable, "FileDescription", title); WriteString(stringTable, "FileVersion", fileVersion); WriteString(stringTable, "InternalName", name.Name); WriteString(stringTable, "LegalCopyright", copyright); WriteString(stringTable, "LegalTrademarks", trademark); WriteString(stringTable, "OriginalFilename", fileName); WriteString(stringTable, "ProductName", product); WriteString(stringTable, "ProductVersion", informationalVersion); stringTable.Position = 0; stringTable.Write((short)stringTable.Length); ByteBuffer stringFileInfo = new ByteBuffer(512); stringFileInfo.Write((short)0); // wLength (placeholder) stringFileInfo.Write((short)0); // wValueLength stringFileInfo.Write((short)1); // wType WriteUTF16Z(stringFileInfo, "StringFileInfo"); stringFileInfo.Align(4); stringFileInfo.Write(stringTable); stringFileInfo.Position = 0; stringFileInfo.Write((short)stringFileInfo.Length); byte[] preamble1 = new byte[] { // VS_VERSIONINFO (platform SDK) 0x34, 0x00, // wValueLength 0x00, 0x00, // wType 0x56, 0x00, 0x53, 0x00, 0x5F, 0x00, 0x56, 0x00, 0x45, 0x00, 0x52, 0x00, 0x53, 0x00, 0x49, 0x00, 0x4F, 0x00, 0x4E, 0x00, 0x5F, 0x00, 0x49, 0x00, 0x4E, 0x00, 0x46, 0x00, 0x4F, 0x00, 0x00, 0x00, // "VS_VERSION_INFO\0" 0x00, 0x00, // Padding1 (32 bit alignment) // VS_FIXEDFILEINFO starts 0xBD, 0x04, 0xEF, 0xFE, // dwSignature (0xFEEF04BD) 0x00, 0x00, 0x01, 0x00, // dwStrucVersion }; byte[] preamble2 = new byte[] { 0x3F, 0x00, 0x00, 0x00, // dwFileFlagsMask (??) 0x00, 0x00, 0x00, 0x00, // dwFileFlags (??) 0x04, 0x00, 0x00, 0x00, // dwFileOS 0x02, 0x00, 0x00, 0x00, // dwFileType 0x00, 0x00, 0x00, 0x00, // dwFileSubtype 0x00, 0x00, 0x00, 0x00, // dwFileDateMS 0x00, 0x00, 0x00, 0x00, // dwFileDateLS // Padding2 (32 bit alignment) // VarFileInfo 0x44, 0x00, // wLength 0x00, 0x00, // wValueLength 0x01, 0x00, // wType 0x56, 0x00, 0x61, 0x00, 0x72, 0x00, 0x46, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x49, 0x00, 0x6E, 0x00, 0x66, 0x00, 0x6F, 0x00, 0x00, 0x00, // "VarFileInfo\0" 0x00, 0x00, // Padding // Var 0x24, 0x00, // wLength 0x04, 0x00, // wValueLength 0x00, 0x00, // wType 0x54, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x73, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, // "Translation\0" 0x00, 0x00, // Padding (32 bit alignment) }; bb.Write((short)(2 + preamble1.Length + 8 + 8 + preamble2.Length + 4 + stringFileInfo.Length)); bb.Write(preamble1); bb.Write((short)fileVersionMinor); bb.Write((short)fileVersionMajor); bb.Write((short)fileVersionRevision); bb.Write((short)fileVersionBuild); bb.Write((short)productVersionMinor); bb.Write((short)productVersionMajor); bb.Write((short)productVersionRevision); bb.Write((short)productVersionBuild); bb.Write(preamble2); bb.Write((short)lcid); bb.Write((short)codepage); bb.Write(stringFileInfo); }