Ejemplo n.º 1
0
 internal void Write(PeWriter wtr, ref uint datPtr)
 {
     for (int i = 0; i < 8; i++)
     {
         if (i < n.Length)
         {
             wtr.Write((byte)n[i]);
         }
         else
         {
             wtr.Write((byte)0);
         }
     }
     wtr.Write((uint)vSize);
     wtr.Write((uint)vPtr);
     wtr.Write((uint)dat.Length);
     wtr.Write((uint)datPtr);
     wtr.Write((uint)relocPtr);
     wtr.Write((uint)lnPtr);
     wtr.Write((ushort)relocNo);
     wtr.Write((ushort)lnNo);
     wtr.Write((uint)c);
     wtr.SaveLocation();
     wtr.SetPosition(datPtr);
     wtr.Write(dat);
     wtr.LoadLocation();
     datPtr += (uint)dat.Length;
 }
Ejemplo n.º 2
0
        private static void TranslateToExe(SpecSharpOptions commandLineOptions)
        //^ requires commandLineOptions.FileNames.Count > 0;
        {
            HostEnvironment hostEnvironment = new HostEnvironment();

            hostEnvironment.Errors         += hostEnvironment.HandleErrors;
            hostEnvironment.displayFileName = true;
            List <IAssemblyReference>      assemblyReferences = GetAssemblyReferences(commandLineOptions, hostEnvironment);
            List <IModuleReference>        moduleReferences   = new List <IModuleReference>();
            List <SpecSharpSourceDocument> programSources     = new List <SpecSharpSourceDocument>(1);
            IName                      name   = hostEnvironment.NameTable.GetNameFor(Path.GetFileNameWithoutExtension(commandLineOptions.FileNames[0]));
            SpecSharpAssembly          assem  = new SpecSharpAssembly(name, Path.GetFullPath(name.Value), hostEnvironment, commandLineOptions, assemblyReferences, moduleReferences, programSources);
            SpecSharpCompilationHelper helper = new SpecSharpCompilationHelper(assem.Compilation);

            foreach (string fileName in commandLineOptions.FileNames)
            {
                name = hostEnvironment.NameTable.GetNameFor(fileName);
                StreamReader instream = File.OpenText(fileName);
                programSources.Add(new SpecSharpSourceDocument(helper, name, Path.GetFullPath(fileName), instream));
            }

            if (assem.Compilation.HasErrors)
            {
                return;
            }
            var sourceLocationProvider = assem.Compilation.SourceLocationProvider;
            var localScopeProvider     = assem.Compilation.LocalScopeProvider;

            using (var pdbWriter = new PdbWriter(Path.ChangeExtension(assem.Location, "pdb"), sourceLocationProvider)) {
                PeWriter.WritePeToStream(assem, hostEnvironment, File.Create(Path.ChangeExtension(assem.Location, "exe")), sourceLocationProvider, localScopeProvider, pdbWriter);
            }
        }
Ejemplo n.º 3
0
 public void Write(PeWriter wtr)
 {
     wtr.SetPosition(StandardFieldsOffset);
     sf.Write(wtr);
     wsf.Write(wtr);
     dd.Write(wtr);
 }
Ejemplo n.º 4
0
    void AssertWriteToPeFile(PeVerifyResult expectedResult, IAssembly assembly, string pdbPath)
    {
        var validator = new MetadataValidator(this.host);
        List <Microsoft.Cci.ErrorEventArgs> errorEvents = new List <Microsoft.Cci.ErrorEventArgs>();

        this.host.Errors += (object sender, Microsoft.Cci.ErrorEventArgs e) => errorEvents.Add(e);
        validator.Validate(assembly);
        Debug.Assert(errorEvents.Count == 0);
        using (var rewrittenFile = File.Create(assembly.Location)) {
            if (pdbPath != null)
            {
                using (var f = File.OpenRead(pdbPath)) {
                    using (var pdbReader = new PdbReader(f, host)) {
                        using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), pdbReader)) {
                            PeWriter.WritePeToStream(assembly, host, rewrittenFile, pdbReader, pdbReader, pdbWriter);
                        }
                    }
                }
            }
            else
            {
                using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), null)) {
                    PeWriter.WritePeToStream(assembly, host, rewrittenFile, null, null, pdbWriter);
                }
            }
        }

        Assert.True(File.Exists(assembly.Location));
        PeVerify.Assert(expectedResult, PeVerify.VerifyAssembly(assembly.Location, true));
    }
Ejemplo n.º 5
0
        public void Write(PeWriter wtr)
        {
            wtr.SetPosition(SectionHeadersOffset);
            uint datPtr = SectionHeadersOffset + 40 * (uint)this.Count;

            if (file.Type == PeFileType.Image)
            {
                uint align = file.OptionalHeader.WindowsSpecificFields.FileAlignment;
                if (datPtr < align)
                {
                    datPtr = align;
                }
                else
                {
                    uint newPtr = align;
                    while (datPtr > align)
                    {
                        newPtr += align; datPtr -= align;
                    }
                    datPtr = newPtr;
                }
            }
            for (int i = 0; i < file.PEHeader.NumberOfSections; i++)
            {
                Items[i].Write(wtr, ref datPtr);
            }
        }
Ejemplo n.º 6
0
        private static void OutputFacadeToFile(string facadePath, HostEnvironment seedHost, Assembly facade, IAssembly contract, string pdbLocation = null)
        {
            // Use the filename (including extension .dll/.winmd) so people can have some control over the output facade file name.
            string facadeFileName   = Path.GetFileName(contract.Location);
            string facadeOutputPath = Path.Combine(facadePath, facadeFileName);

            using (Stream peOutStream = File.Create(facadeOutputPath))
            {
                if (pdbLocation != null)
                {
                    if (File.Exists(pdbLocation))
                    {
                        string pdbOutputPath = Path.Combine(facadePath, contract.Name + ".pdb");
                        using (Stream pdbReadStream = File.OpenRead(pdbLocation))
                            using (PdbReader pdbReader = new PdbReader(pdbReadStream, seedHost))
                                using (PdbWriter pdbWriter = new PdbWriter(pdbOutputPath, pdbReader))
                                {
                                    PeWriter.WritePeToStream(facade, seedHost, peOutStream, pdbReader, pdbReader, pdbWriter);
                                }
                    }
                    else
                    {
                        throw new FacadeGenerationException("Couldn't find the pdb at the given location: " + pdbLocation);
                    }
                }
                else
                {
                    PeWriter.WritePeToStream(facade, seedHost, peOutStream);
                }
            }
        }
Ejemplo n.º 7
0
        static void Main(string[] args)
        {
            using (var host = new HelloHost()) {
                var nameTable    = host.NameTable;
                var coreAssembly = host.LoadAssembly(host.CoreAssemblySymbolicIdentity);

                var aname   = nameTable.GetNameFor("hello");
                var mname   = nameTable.GetNameFor("hello.exe");
                var arefs   = IteratorHelper.GetSingletonEnumerable <IAssemblyReference>(coreAssembly);
                var source  = new HelloSourceDocument(aname);
                var sources = IteratorHelper.GetSingletonEnumerable <HelloSourceDocument>(source);

                var helloAssembly          = new HelloAssembly(aname, host, mname, arefs, sources);
                var sourceLocationProvider = helloAssembly.Compilation.SourceLocationProvider;
                var localScopeProvider     = helloAssembly.Compilation.LocalScopeProvider;

                using (var sourceFile = File.CreateText("hello.cs")) {
                    sourceFile.WriteLine("hello");
                }
                using (var peStream = File.Create("hello.exe")) {
                    using (var pdbWriter = new PdbWriter("hello.pdb", sourceLocationProvider)) {
                        PeWriter.WritePeToStream(helloAssembly, host, peStream, helloAssembly.Compilation.SourceLocationProvider, helloAssembly.Compilation.LocalScopeProvider, pdbWriter);
                    }
                }
            }
        }
        static void Main(string[] argv)
        {
            if (argv == null || argv.Length < 1)
            {
                Console.WriteLine("Usage: Main <assemblys> [<outputPath>]");
            }

            using (var host = new PeReader.DefaultHost()) {
                var module = host.LoadUnitFrom(argv[0]) as IModule;
                if (module == null || module == Dummy.Module || module == Dummy.Assembly)
                {
                    throw new Exception(argv[0] + " is not a PE file containing a CLR assembly, or an error occurred when loading it.");
                }

                PdbReader pdbReader = null;
                string    pdbFile   = Path.ChangeExtension(module.Location, "pdb");
                if (File.Exists(pdbFile))
                {
                    using (var pdbStream = File.OpenRead(pdbFile)) {
                        pdbReader = new PdbReader(pdbStream, host);
                    }
                }
                else
                {
                    Console.WriteLine("Could not load the PDB file for '" + module.Name.Value + "' . Proceeding anyway.");
                }

                using (pdbReader) {
                    var copy = new MetadataDeepCopier(host).Copy(module);
                    var shadowFieldsAddedAssembly           = new ShadowFieldRewriter(host).Rewrite(copy);
                    var shadowFieldsAndMethodsAddedAssembly = new ShadowMethodRewriter(host).Rewrite(shadowFieldsAddedAssembly);
                    var rewrittenAssembly = new FinalizeMethodRewriter(host).Rewrite(shadowFieldsAndMethodsAddedAssembly);

                    var main = rewrittenAssembly.EntryPoint.ResolvedMethod;
                    if (main != Dummy.Method)
                    {
                        var body = main.Body as MethodBody;
                        if (body != null)
                        {
                            new AddGCWaitForFinalization(host, body).Rewrite();
                        }
                    }

                    var validator = new MetadataValidator(host);
                    validator.Validate(rewrittenAssembly as IAssembly);

                    string outputPath     = rewrittenAssembly.Location + ".meta";
                    var    outputFileName = Path.GetFileNameWithoutExtension(outputPath);

                    // Need to not pass in a local scope provider until such time as we have one that will use the mutator
                    // to remap things (like the type of a scope constant) from the original assembly to the mutated one.
                    using (var peStream = File.Create(outputPath)) {
                        using (var pdbWriter = new PdbWriter(outputFileName + ".pdb", pdbReader)) {
                            PeWriter.WritePeToStream(rewrittenAssembly, host, peStream, pdbReader, null, pdbWriter);
                        }
                    }
                }
            }
        }
Ejemplo n.º 9
0
 public override void Write(PeWriter wtr)
 {
     wtr.BaseStream.Position = 0;
     wtr.Write((ushort)m);
     wtr.Write(hc);
     wtr.Write((uint)o);
     wtr.Write(ds);
 }
Ejemplo n.º 10
0
        private static void OutputFacadeToFile(string facadePath, HostEnvironment seedHost, Assembly facade, IAssembly contract, string pdbLocation = null)
        {
            bool   needsConversion    = false;
            string pdbOutputPath      = Path.Combine(facadePath, contract.Name + ".pdb");
            string finalPdbOutputPath = pdbOutputPath;

            // Use the filename (including extension .dll/.winmd) so people can have some control over the output facade file name.
            string facadeFileName   = Path.GetFileName(contract.Location);
            string facadeOutputPath = Path.Combine(facadePath, facadeFileName);

            using (Stream peOutStream = File.Create(facadeOutputPath))
            {
                if (pdbLocation != null)
                {
                    if (File.Exists(pdbLocation))
                    {
                        // Convert from portable to windows PDBs if necessary.  If we convert
                        // set the pdbOutput path to a *.windows.pdb file so we can convert it back
                        // to 'finalPdbOutputPath'.
                        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                        {
                            needsConversion = ConvertFromPortableIfNecessary(facade.Location, ref pdbLocation);
                        }
                        if (needsConversion)
                        {
                            // We want to keep the same file name for the PDB because it is used as a key when looking it up on a symbol server
                            string pdbOutputPathPdbDir = Path.Combine(Path.GetDirectoryName(pdbOutputPath), "WindowsPdb");
                            Directory.CreateDirectory(pdbOutputPathPdbDir);
                            pdbOutputPath = Path.Combine(pdbOutputPathPdbDir, Path.GetFileName(pdbOutputPath));
                        }

                        // do the main GenFacades logic (which today only works with windows PDBs).
                        using (Stream pdbReadStream = File.OpenRead(pdbLocation))
                            using (PdbReader pdbReader = new PdbReader(pdbReadStream, seedHost))
                                using (PdbWriter pdbWriter = new PdbWriter(pdbOutputPath, pdbReader))
                                {
                                    PeWriter.WritePeToStream(facade, seedHost, peOutStream, pdbReader, pdbReader, pdbWriter);
                                }
                    }
                    else
                    {
                        throw new FacadeGenerationException("Couldn't find the pdb at the given location: " + pdbLocation);
                    }
                }
                else
                {
                    PeWriter.WritePeToStream(facade, seedHost, peOutStream);
                }
            }

            // If we started with Portable PDBs we need to convert the output to portable again.
            // We have to do this after facadeOutputPath is closed for writing.
            if (needsConversion)
            {
                Trace.TraceInformation("Converting PDB generated by GenFacades " + pdbOutputPath + " to portable format " + finalPdbOutputPath);
                ConvertFromWindowsPdb(facadeOutputPath, pdbOutputPath, finalPdbOutputPath);
            }
        }
Ejemplo n.º 11
0
 public void Write(PeWriter wtr)
 {
     wtr.SetPosition(hdr.DataDirectoriesOffset);
     for (int i = 0; i < 16; i++)
     {
         wtr.Write(Items[i].Address);
         wtr.Write(Items[i].Size);
     }
 }
Ejemplo n.º 12
0
        static int Main(string[] args)
        {
            if (args == null || args.Length < 1)
            {
                Console.WriteLine("Usage: ILMutator <assembly> [<outputPath>]");
                return(1);
            }

            using (var host = new PeReader.DefaultHost()) {
                IModule /*?*/ module = host.LoadUnitFrom(args[0]) as IModule;
                if (module == null || module is Dummy)
                {
                    Console.WriteLine(args[0] + " is not a PE file containing a CLR assembly, or an error occurred when loading it.");
                    return(1);
                }
                module = new MetadataDeepCopier(host).Copy(module);

                PdbReader /*?*/ pdbReader = null;
                string          pdbFile   = Path.ChangeExtension(module.Location, "pdb");
                if (File.Exists(pdbFile))
                {
                    using (var pdbStream = File.OpenRead(pdbFile)) {
                        pdbReader = new PdbReader(pdbStream, host);
                    }
                }
                else
                {
                    Console.WriteLine("Could not load the PDB file for '" + module.Name.Value + "' . Proceeding anyway.");
                }
                using (pdbReader) {
                    var       localScopeProvider = pdbReader == null ? null : new ILGenerator.LocalScopeProvider(pdbReader);
                    ILMutator mutator            = new ILMutator(host, pdbReader);
                    module = mutator.Rewrite(module);

                    string newName;
                    if (args.Length == 2)
                    {
                        newName = args[1];
                    }
                    else
                    {
                        var loc      = module.Location;
                        var path     = Path.GetDirectoryName(loc) ?? "";
                        var fileName = Path.GetFileNameWithoutExtension(loc);
                        var ext      = Path.GetExtension(loc);
                        newName = Path.Combine(path, fileName + "1" + ext);
                    }

                    using (var peStream = File.Create(newName)) {
                        using (var pdbWriter = new PdbWriter(Path.ChangeExtension(newName, ".pdb"), pdbReader)) {
                            PeWriter.WritePeToStream(module, host, peStream, pdbReader, localScopeProvider, pdbWriter);
                        }
                    }
                }
                return(0); // success
            }
        }
Ejemplo n.º 13
0
 void AssertWriteToPeFile(PeVerifyResult expectedResult, IAssembly assembly, PdbReader pdbReader)
 {
     using (var rewrittenFile = File.Create(assembly.Location)) {
         using (var pdbWriter = new PdbWriter(Path.GetFullPath(assembly.Location + ".pdb"), pdbReader)) {
             PeWriter.WritePeToStream(assembly, host, rewrittenFile, pdbReader, pdbReader, pdbWriter);
         }
     }
     Assert.True(File.Exists(assembly.Location));
     PeVerify.Assert(expectedResult, PeVerify.VerifyAssembly(assembly.Location, true));
 }
Ejemplo n.º 14
0
        public override string Run(string tempFolder)
        {
            var assembly   = Generate();
            var fileName   = assembly.Kind == ModuleKind.DynamicallyLinkedLibrary ? DllName : ExeName;
            var resultPath = Path.Combine(tempFolder, fileName);

            using (var fs = File.Create(resultPath))
                PeWriter.WritePeToStream(assembly, Host, fs);
            return(resultPath);
        }
Ejemplo n.º 15
0
 public void Save(PeWriter wtr, uint adr)
 {
     wtr.SetPosition(adr);
     foreach (CertificateEntry i in items)
     {
         wtr.Write((uint)i.CertificateData.Length + 8);
         wtr.Write((ushort)i.Revision);
         wtr.Write((ushort)i.CertificateType);
         wtr.Write(i.CertificateData);
     }
 }
Ejemplo n.º 16
0
    void AssertWriteToPeFile(PeVerifyResult expectedResult, IAssembly assembly)
    {
        using (FileStream rewrittenFile = File.Create(assembly.Location)) {
            using (this.pdbReader) {
                PeWriter.WritePeToStream(assembly, this.host, rewrittenFile, this.pdbReader, this.pdbReader, this.pdbWriter);
            }
        }

        Assert.True(File.Exists(assembly.Location));
        PeVerify.Assert(expectedResult, PeVerify.VerifyAssembly(assembly.Location));
    }
Ejemplo n.º 17
0
 public override void Write(PeWriter wtr)
 {
     wtr.SetPosition(PEHeaderOffset);
     wtr.Write((ushort)m);
     wtr.Write((ushort)noSect);
     wtr.WriteStamp(stamp);
     wtr.Write((uint)ptrSym);
     wtr.Write((uint)noSym);
     wtr.Write((ushort)sOh);
     wtr.Write((ushort)c);
 }
Ejemplo n.º 18
0
        internal static void EmitCorLibWithAssemblyReferences(
            Compilation comp,
            string pdbPath,
            Func <CommonPEModuleBuilder, EmitOptions, CommonPEModuleBuilder> getModuleBuilder,
            out ImmutableArray <byte> peBytes,
            out ImmutableArray <byte> pdbBytes)
        {
            var diagnostics   = DiagnosticBag.GetInstance();
            var emitOptions   = EmitOptions.Default.WithRuntimeMetadataVersion("0.0.0.0").WithDebugInformationFormat(DebugInformationFormat.PortablePdb);
            var moduleBuilder = comp.CheckOptionsAndCreateModuleBuilder(
                diagnostics,
                null,
                emitOptions,
                null,
                null,
                null,
                null,
                default(CancellationToken));

            // Wrap the module builder in a module builder that
            // reports the "System.Object" type as having no base type.
            moduleBuilder = getModuleBuilder(moduleBuilder, emitOptions);
            bool result = comp.Compile(
                moduleBuilder,
                emittingPdb: pdbPath != null,
                diagnostics: diagnostics,
                filterOpt: null,
                cancellationToken: default(CancellationToken));

            using (var peStream = new MemoryStream())
            {
                using (var pdbStream = new MemoryStream())
                {
                    PeWriter.WritePeToStream(
                        new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true),
                        comp.MessageProvider,
                        () => peStream,
                        () => pdbStream,
                        null, null,
                        metadataOnly: true,
                        isDeterministic: false,
                        emitTestCoverageData: false,
                        privateKeyOpt: null,
                        cancellationToken: default(CancellationToken));

                    peBytes  = peStream.ToImmutable();
                    pdbBytes = pdbStream.ToImmutable();
                }
            }

            diagnostics.Verify();
            diagnostics.Free();
        }
Ejemplo n.º 19
0
 public override void Write(PeWriter wtr)
 {
     wtr.SetPosition(hdr.WindowsSpecificFieldsOffset);
     if (hdr.Type == ExecutableType.PE32Plus)
     {
         wtr.Write((ulong)imgBas);
         wtr.Write((uint)sectA);
         wtr.Write((uint)fA);
         wtr.Write((ushort)maOs);
         wtr.Write((ushort)miOs);
         wtr.Write((ushort)maImg);
         wtr.Write((ushort)miImg);
         wtr.Write((ushort)maSs);
         wtr.Write((ushort)miSs);
         wtr.Write((uint)winVer);
         wtr.Write((uint)sImg);
         wtr.Write((uint)sHdr);
         wtr.Write((uint)cs);
         wtr.Write((ushort)Ss);
         wtr.Write((ushort)dll);
         wtr.Write((ulong)sSr);
         wtr.Write((ulong)sSc);
         wtr.Write((ulong)sHr);
         wtr.Write((ulong)sHc);
         wtr.Write((uint)ldrF);
         wtr.Write((uint)noDd);
     }
     else
     {
         wtr.Write((uint)imgBas);
         wtr.Write((uint)sectA);
         wtr.Write((uint)fA);
         wtr.Write((ushort)maOs);
         wtr.Write((ushort)miOs);
         wtr.Write((ushort)maImg);
         wtr.Write((ushort)miImg);
         wtr.Write((ushort)maSs);
         wtr.Write((ushort)miSs);
         wtr.Write((uint)winVer);
         wtr.Write((uint)sImg);
         wtr.Write((uint)sHdr);
         wtr.Write((uint)cs);
         wtr.Write((ushort)Ss);
         wtr.Write((ushort)dll);
         wtr.Write((uint)sSr);
         wtr.Write((uint)sSc);
         wtr.Write((uint)sHr);
         wtr.Write((uint)sHc);
         wtr.Write((uint)ldrF);
         wtr.Write((uint)noDd);
     }
 }
Ejemplo n.º 20
0
        private static int RunTest(HostEnvironment hostEnvironment, string suiteName, string test, StringBuilder actualOutput, List <string> compilerParameters, List <string> testCaseParameters)
        {
            hostEnvironment.hasError = false;
            IName                     name               = hostEnvironment.NameTable.GetNameFor(suiteName);
            SpecSharpOptions          options            = new SpecSharpOptions(); //TODO: extract from params
            List <IAssemblyReference> assemblyReferences = new List <IAssemblyReference>();
            List <IModuleReference>   moduleReferences   = new List <IModuleReference>();

            assemblyReferences.Add(hostEnvironment.LoadAssembly(hostEnvironment.CoreAssemblySymbolicIdentity));
            IUnit unit;
            SpecSharpAssembly /*?*/    assem = null;
            SpecSharpCompilationHelper helper;

            if (hostEnvironment.previousDocument != null && compilerParameters.Contains("/incremental"))
            {
                unit   = hostEnvironment.GetIncrementalUnit(test);
                helper = (SpecSharpCompilationHelper)hostEnvironment.previousDocument.SpecSharpCompilationPart.Helper;
            }
            else
            {
                List <SpecSharpSourceDocument> programSources = new List <SpecSharpSourceDocument>(1);
                assem  = new SpecSharpAssembly(name, "", hostEnvironment, options, assemblyReferences, moduleReferences, programSources);
                helper = new SpecSharpCompilationHelper(assem.Compilation);
                programSources.Add(hostEnvironment.previousDocument = new SpecSharpSourceDocument(helper, name, "", test));
                unit = assem;
            }
            if (assem != null && assem.Compilation.HasErrors)
            {
                return(0);
            }
            if (assem != null && assem.EntryPoint.ResolvedMethod != Dummy.Method)
            {
                var memStream = new MemoryStream();
                PeWriter.WritePeToStream(assem, hostEnvironment, memStream);
                if (hostEnvironment.hasError)
                {
                    return(0);
                }
                var runtimeAssembly = System.Reflection.Assembly.Load(memStream.ToArray());
                var result          = runtimeAssembly.EntryPoint.Invoke(null, null);
                if (result is int)
                {
                    return((int)result);
                }
                return(0);
            }

            BaseCodeTraverser traverser = new BaseCodeTraverser();

            unit.Dispatch(traverser);
            return(0);
        }
Ejemplo n.º 21
0
        static void Main(string[] args)
        {
            if (args == null || args.Length == 0)
            {
                Console.WriteLine("usage: EdgeProfiler [path]fileName.ext");
                return;
            }
            using (var host = new PeReader.DefaultHost()) {
                IModule /*?*/ module = host.LoadUnitFrom(args[0]) as IModule;
                if (module == null || module is Dummy)
                {
                    Console.WriteLine(args[0] + " is not a PE file containing a CLR module or assembly.");
                    return;
                }

                var coreIdentity = host.CoreAssemblySymbolicIdentity; //force host to let args[0] determine the target platform
                var profiler     = (IAssembly)host.LoadUnitFrom(typeof(Program).Assembly.Location);
                var logger       = (INamespaceTypeDefinition)UnitHelper.FindType(host.NameTable, profiler, "Logger");

                PdbReader /*?*/ pdbReader = null;
                string          pdbFile   = Path.ChangeExtension(module.Location, "pdb");
                if (File.Exists(pdbFile))
                {
                    using (var pdbStream = File.OpenRead(pdbFile)) {
                        pdbReader = new PdbReader(pdbStream, host);
                    }
                }

                using (pdbReader) {
                    var instrumentedModule = Instrumenter.GetInstrumented(host, module, pdbReader, logger);
                    var newRoot            = Path.GetFileNameWithoutExtension(module.Location) + ".instrumented";
                    var newName            = newRoot + Path.GetExtension(module.Location);
                    using (var peStream = File.Create(newName)) {
                        if (pdbReader == null)
                        {
                            PeWriter.WritePeToStream(instrumentedModule, host, peStream);
                        }
                        else
                        {
                            var localScopeProvider = new ILGenerator.LocalScopeProvider(pdbReader);
                            using (var pdbWriter = new PdbWriter(newRoot + ".pdb", pdbReader)) {
                                PeWriter.WritePeToStream(instrumentedModule, host, peStream, pdbReader, localScopeProvider, pdbWriter);
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 22
0
        public void WriteToStream(IModuleInfo moduleInfo, FileStream stream, string filePath)
        {
            var module = (ModuleInfo)moduleInfo;

            if (module.PdbReader == null)
            {
                PeWriter.WritePeToStream(module.Module, _host, stream);
            }
            else
            {
                using (var pdbWriter = new PdbWriter(Path.ChangeExtension(filePath, "pdb"), module.PdbReader)) {
                    PeWriter.WritePeToStream(module.Module, _host, stream, module.PdbReader,
                                             module.PdbReader, pdbWriter);
                }
            }
        }
Ejemplo n.º 23
0
 public override void Write(PeWriter wtr)
 {
     wtr.SetPosition(hdr.StandardFieldsOffset);
     wtr.Write((ushort)hdr.t);
     wtr.Write(maL);
     wtr.Write(miL);
     wtr.Write(sC);
     wtr.Write(sI);
     wtr.Write(sU);
     wtr.Write(entry);
     wtr.Write(bc);
     if (Magic != ExecutableType.PE32Plus)
     {
         wtr.Write(bd);
     }
 }
Ejemplo n.º 24
0
        static void Main(string[] args)
        {
            if (args == null || args.Length != 2)
            {
                Console.WriteLine("usage: asmmeta <input> <output>");
                return;
            }
            HostEnvironment host   = new HostEnvironment();
            IModule /*?*/   module = host.LoadUnitFrom(args[0]) as IModule;

            if (module == null || module == Dummy.Module || module == Dummy.Assembly)
            {
                Console.WriteLine(args[0] + " is not a PE file containing a CLR module or assembly.");
                return;
            }

            string outputFile    = args[1];
            string outputPDBFile = Path.ChangeExtension(args[1], "pdb");

            PdbReader /*?*/ pdbReader = null;
            PdbWriter /*?*/ pdbWriter = null;
            string          pdbFile   = Path.ChangeExtension(module.Location, "pdb");

            if (File.Exists(pdbFile))
            {
                Stream pdbStream = File.OpenRead(pdbFile);
                pdbReader = new PdbReader(pdbStream, host);
                pdbWriter = new PdbWriter(Path.GetFullPath(outputPDBFile), pdbReader);
            }

            MetadataMutator mutator  = new MetadataMutator(host);
            IAssembly /*?*/ assembly = module as IAssembly;

            if (assembly != null)
            {
                var mutable = mutator.GetMutableCopy(assembly);
                mutable.Name = host.NameTable.GetNameFor(Path.GetFileNameWithoutExtension(args[1]));
                module       = mutator.Visit(mutable);
            }
            else
            {
                var mutable = mutator.GetMutableCopy(module);
                mutable.Name = host.NameTable.GetNameFor(Path.GetFileNameWithoutExtension(args[1]));
                module       = mutator.Visit(mutable);
            }
            PeWriter.WritePeToStream(module, host, File.Create(Path.GetFullPath(outputFile)), pdbReader, pdbReader, pdbWriter);
        }
Ejemplo n.º 25
0
        public void Save(string fileName)
        {
            var pdbName = Path.ChangeExtension(fileName, "pdb");

            using (var peStream = File.Create(fileName))
            {
                if (this.PdbReader == null)
                {
                    PeWriter.WritePeToStream(this.Module, this.Host, peStream);
                }
                else
                {
                    using (var pdbWriter = new PdbWriter(pdbName, this.PdbReader))
                        PeWriter.WritePeToStream(this.Module, this.Host, peStream, this.PdbReader, this.PdbReader, pdbWriter);
                }
            }
        }
Ejemplo n.º 26
0
        private static void RewriteBinary(
            Assembly copy,
            AssemblyReport assemblyReport,
            MetadataReaderHost host,
            string outputPath,
            MethodRemoval methodRemoval,
            StubMethodBodyEmitter stubEmitter)
        {
            /* This is an attempt to decouple the MethodRemoval commandline options
             * from the tree shaker, but it doesn't really seem to be working.
             * Might be better to just pass the method removal directly to
             * the rewriter.
             */

            bool removeMethods  = (methodRemoval == MethodRemoval.Remove);
            bool fullDebugStubs = (methodRemoval == MethodRemoval.Debug);
            bool dryRun         = (methodRemoval == MethodRemoval.None);

            PdbReader /*?*/ pdbReader = null;
            string          pdbFile   = Path.ChangeExtension(copy.Location, "pdb");

            if (File.Exists(pdbFile))
            {
                using (var pdbStream = File.OpenRead(pdbFile)) {
                    pdbReader = new PdbReader(pdbStream, host);
                }
            }
            else
            {
                Console.WriteLine("Could not load the PDB file for '" + copy.Name.Value + "' . Proceeding anyway.");
            }

            using (pdbReader) {
                var localScopeProvider = pdbReader == null ? null : new ILGenerator.LocalScopeProvider(pdbReader);
                var pdbPath            = Path.ChangeExtension(outputPath, ".pdb");
                var outputFileName     = Path.GetFileNameWithoutExtension(outputPath);
                using (var peStream = File.Create(outputPath)) {
                    using (var pdbWriter = new PdbWriter(pdbPath, pdbReader)) {
                        var       rewriter      = new TreeShakingRewriter(host, assemblyReport, dryRun, removeMethods, fullDebugStubs, stubEmitter);
                        IAssembly rewrittenCopy = rewriter.Rewrite(copy);

                        PeWriter.WritePeToStream(rewrittenCopy, host, peStream, pdbReader, localScopeProvider, pdbWriter);
                    }
                }
            }
        }
Ejemplo n.º 27
0
        public void Save(CciAssembly assembly, string path)
        {
            Contract.Requires(assembly != null);
            Contract.Requires(!string.IsNullOrEmpty(path));

            var sourceLocationProvider = GetPdbReader(assembly.Module);

            lock (turnstile)
            {
                ContractHelper.InjectContractCalls(host, assembly.Module, assembly.ContractProvider, sourceLocationProvider);
            }
            using (var peStream = File.Create(path))
            {
                lock (turnstile)
                {
                    PeWriter.WritePeToStream(assembly.Module, host, peStream);
                }
            }
        }
Ejemplo n.º 28
0
        public static void Main(string[] args)
        {
            if (args.Length != 2)
            {
                Console.WriteLine("Usage: PInvokeCompiler Input.dll Output.dll");
                return;
            }

            var inputFile  = args[0];
            var outputFile = args[1];

            using (var host = new PeReader.DefaultHost())
            {
                var unit     = host.LoadUnitFrom(inputFile);
                var assembly = unit as IAssembly;

                if (assembly == null)
                {
                    Console.WriteLine("Error: Input file not loadable as assembly");
                    return;
                }

                Assembly mutable = new MetadataDeepCopier(host).Copy(assembly);

                var interopHelperReference = new InteropHelperReferences(host, mutable);

                var pinvokeMethodMetadataTraverser = new PInvokeMethodMetadataTraverser(interopHelperReference.PInvokeHelpers);
                pinvokeMethodMetadataTraverser.TraverseChildren(mutable);

                var methodTransformationMetadataRewriter = new MethodTransformationMetadataRewriter(interopHelperReference.LoadLibrary, interopHelperReference.GetProcAddress, interopHelperReference.IsLibraryInitialized, host, pinvokeMethodMetadataTraverser);
                methodTransformationMetadataRewriter.RewriteChildren(mutable);

                var pinvokeMethodMetadataRewriter = new PInvokeMethodMetadataRewriter(interopHelperReference, host, methodTransformationMetadataRewriter);
                pinvokeMethodMetadataRewriter.RewriteChildren(mutable);

                using (var stream = File.Create(outputFile))
                {
                    PeWriter.WritePeToStream(mutable, host, stream);
                }
            }
        }
Ejemplo n.º 29
0
        public MemoryStream WriteToStream(IModuleInfo moduleInfo)
        {
            var module = (ModuleInfo)moduleInfo;

            _log.Info("CommonCompilerInfra.WriteToFile:" + module.Name);
            MemoryStream stream = new MemoryStream();

            if (module.PdbReader == null)
            {
                PeWriter.WritePeToStream(module.Module, _host, stream);
            }
            else
            {
                throw new NotImplementedException();
                //                using (var pdbWriter = new PdbWriter(Path.ChangeExtension(filePath, "pdb"), module.PdbReader))
                //                {
                //                    PeWriter.WritePeToStream(module.Module, _host, stream, module.SourceLocationProvider,
                //                        module.LocalScopeProvider, pdbWriter);
                //                }
            }
            stream.Position = 0;

            return(stream);
        }
Ejemplo n.º 30
0
        /// <summary>
        /// Validates that the given stream is marked as signed, the signature matches
        /// the public key, and the header checksum is correct.
        /// </summary>
        public static bool IsStreamFullSigned(Stream moduleContents)
        {
            var savedPosition = moduleContents.Position;

            try
            {
                moduleContents.Position = 0;

                var peHeaders = new PEHeaders(moduleContents);

                moduleContents.Position = 0;

                using (var metadata = ModuleMetadata.CreateFromStream(moduleContents, leaveOpen: true))
                {
                    var metadataReader = metadata.MetadataReader;
                    var peReader       = metadata.Module.PEReaderOpt;
                    var flags          = peHeaders.CorHeader.Flags;

                    if (CorFlags.StrongNameSigned != (flags & CorFlags.StrongNameSigned))
                    {
                        return(false);
                    }

                    var snDirectory = peReader.PEHeaders.CorHeader.StrongNameSignatureDirectory;
                    if (!peHeaders.TryGetDirectoryOffset(snDirectory, out int snOffset))
                    {
                        return(false);
                    }

                    moduleContents.Position = 0;
                    int peSize;
                    try
                    {
                        peSize = checked ((int)moduleContents.Length);
                    }
                    catch
                    {
                        return(false);
                    }

                    var peImage = new BlobBuilder(peSize);
                    if (peSize != peImage.TryWriteBytes(moduleContents, peSize))
                    {
                        return(false);
                    }

                    byte[] buffer = GetBlobBuffer(peImage.GetBlobs().Single());

                    uint expectedChecksum = peHeaders.PEHeader.CheckSum;
                    Blob checksumBlob     = MakeBlob(buffer, peHeaders.PEHeaderStartOffset + ChecksumOffset, sizeof(uint));

                    if (expectedChecksum != PeWriter.CalculateChecksum(peImage, checksumBlob))
                    {
                        return(false);
                    }

                    int    snSize = snDirectory.Size;
                    byte[] hash   = ComputeSigningHash(peImage, peHeaders, checksumBlob, snOffset, snSize);

                    ImmutableArray <byte> publicKeyBlob = metadataReader.GetBlobContent(metadataReader.GetAssemblyDefinition().PublicKey);
                    // RSA parameters start after the public key offset
                    byte[] publicKeyParams = new byte[publicKeyBlob.Length - CryptoBlobParser.s_publicKeyHeaderSize];
                    publicKeyBlob.CopyTo(CryptoBlobParser.s_publicKeyHeaderSize, publicKeyParams, 0, publicKeyParams.Length);
                    var snKey = publicKeyParams.ToRSAParameters(includePrivateParameters: false);

                    using (var rsa = RSA.Create())
                    {
                        rsa.ImportParameters(snKey);
                        var reversedSignature = peReader.GetSectionData(snDirectory.RelativeVirtualAddress).GetContent(0, snSize).ToArray();

                        // Unknown why the signature is reversed, but this matches the behavior of the CLR
                        // signing implementation.
                        Array.Reverse(reversedSignature);

                        if (!rsa.VerifyHash(hash, reversedSignature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1))
                        {
                            return(false);
                        }
                    }

                    return(true);
                }
            }
            finally
            {
                moduleContents.Position = savedPosition;
            }
        }