static void Main(string[] args) { if (args == null || args.Length == 0) { Console.WriteLine("usage: PeToPe [path]fileName.ext [noStack]"); return; } bool noStack = args.Length == 2; using (var host = new PeReader.DefaultHost()) { //Read the Metadata Model from the PE file var 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; } //Get a PDB reader if there is a PDB file. PdbReader /*?*/ pdbReader = null; string pdbFile = Path.ChangeExtension(module.Location, "pdb"); if (File.Exists(pdbFile)) { Stream pdbStream = File.OpenRead(pdbFile); pdbReader = new PdbReader(pdbStream, host); } using (pdbReader) { //Construct a Code Model from the Metadata model via decompilation var options = DecompilerOptions.None; if (noStack) { options |= DecompilerOptions.Unstack; } var decompiledModule = Decompiler.GetCodeModelFromMetadataModel(host, module, pdbReader, options); ISourceLocationProvider sourceLocationProvider = pdbReader; //The decompiler preserves the Locations from the IOperation values, so the PdbReader still works. //Recompiling the CodeModel to IL might change the IL offsets, so a new provider is needed. ILocalScopeProvider localScopeProvider = new Decompiler.LocalScopeProvider(pdbReader); //Get a mutable copy of the Code Model. The ISourceLocationProvider is needed to provide copied source method bodies with the //ability to find out where to mark sequence points when compiling themselves back into IL. //(ISourceMethodBody does not know about the Source Model, so this information must be provided explicitly.) var copier = new CodeDeepCopier(host, sourceLocationProvider); var mutableModule = copier.Copy(decompiledModule); //Traverse the mutable copy. In a real application the traversal will collect information to be used during rewriting. var traverser = new CodeTraverser() { PreorderVisitor = new CodeVisitor() }; traverser.Traverse(mutableModule); //Rewrite the mutable Code Model. In a real application CodeRewriter would be a subclass that actually does something. //(This is why decompiled source method bodies must recompile themselves, rather than just use the IL from which they were decompiled.) var rewriter = new CodeRewriter(host); var rewrittenModule = rewriter.Rewrite(mutableModule); //Write out the Code Model by traversing it as the Metadata Model that it also is. using (var peStream = File.Create(rewrittenModule.Location + ".pe")) { if (pdbReader == null) { PeWriter.WritePeToStream(rewrittenModule, host, peStream); } else { using (var pdbWriter = new PdbWriter(rewrittenModule.Location + ".pdb", pdbReader)) { PeWriter.WritePeToStream(rewrittenModule, host, peStream, sourceLocationProvider, localScopeProvider, pdbWriter); } } } } } }
static int Main(string[] args) { if (args == null || args.Length == 0) { Console.WriteLine("usage: HelloContracts [path]fileName.Contracts.dll [-libpaths ...]* [-p [-i] | -inject]"); return(1); } #region Parse options var options = new Options(); options.Parse(args); if (options.HelpRequested) { options.PrintOptions(""); return(1); } if (options.HasErrors) { options.PrintErrorsAndExit(Console.Out); } #endregion var fileName = String.IsNullOrEmpty(options.assembly) ? options.GeneralArguments[0] : options.assembly; if (options.printContracts) { #region Collect and write contracts using (var host = new CodeContractAwareHostEnvironment(options.libpaths)) { IModule module = host.LoadUnitFrom(fileName) as IModule; if (module == null || module is Dummy) { Console.WriteLine("'{0}' is not a PE file containing a CLR module or assembly.", fileName); Environment.Exit(1); } var t = new Traverser(host, options.inherited); t.Traverse(module); } #endregion return(0); } else { using (var host = new CodeContractAwareHostEnvironment(options.libpaths, true, true)) { // Read the Metadata Model from the PE file var module = host.LoadUnitFrom(fileName) as IModule; if (module == null || module is Dummy) { Console.WriteLine(fileName + " is not a PE file containing a CLR module or assembly."); return(1); } // Get a PDB reader if there is a PDB file. 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) { ISourceLocationProvider sourceLocationProvider = pdbReader; // Construct a Code Model from the Metadata model via decompilation var mutableModule = Decompiler.GetCodeModelFromMetadataModel(host, module, pdbReader, DecompilerOptions.AnonymousDelegates | DecompilerOptions.Loops); ILocalScopeProvider localScopeProvider = new Decompiler.LocalScopeProvider(pdbReader); // Extract contracts (side effect: removes them from the method bodies) var contractProvider = Microsoft.Cci.MutableContracts.ContractHelper.ExtractContracts(host, mutableModule, pdbReader, localScopeProvider); // Inject non-null postconditions if (options.inject) { new NonNullInjector(host, contractProvider).Traverse(mutableModule); } // Put the contracts back in as method calls at the beginning of each method Microsoft.Cci.MutableContracts.ContractHelper.InjectContractCalls(host, mutableModule, contractProvider, sourceLocationProvider); // Write out the resulting module. Each method's corresponding IL is produced // lazily using CodeModelToILConverter via the delegate that the mutator stored in the method bodies. using (var peStream = File.Create(mutableModule.Location + ".pe")) { if (pdbReader == null) { PeWriter.WritePeToStream(mutableModule, host, peStream); } else { using (var pdbWriter = new PdbWriter(mutableModule.Location + ".pdb", sourceLocationProvider)) { PeWriter.WritePeToStream(mutableModule, host, peStream, sourceLocationProvider, localScopeProvider, pdbWriter); } } } } } return(0); } }
static void Main(string[] args) { if (args == null || args.Length == 0) { Console.WriteLine("usage: PeToPe [path]fileName.ext [decompile] [noStack]"); return; } bool decompile = args.Length >= 2; bool noStack = args.Length >= 3; using (var host = new HostEnvironment()) { //Read the Metadata Model from the PE file var 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; } //Get a PDB reader if there is a PDB file. PdbReader /*?*/ pdbReader = null; string pdbFile = module.DebugInformationLocation; if (string.IsNullOrEmpty(pdbFile) || !File.Exists(pdbFile)) { pdbFile = Path.ChangeExtension(module.Location, "pdb"); } if (File.Exists(pdbFile)) { using (var pdbStream = File.OpenRead(pdbFile)) { pdbReader = new PdbReader(pdbStream, host); } } using (pdbReader) { ISourceLocationProvider sourceLocationProvider = pdbReader; ILocalScopeProvider localScopeProvider = pdbReader; if (decompile) { //Construct a Code Model from the Metadata model via decompilation var options = DecompilerOptions.AnonymousDelegates | DecompilerOptions.Iterators | DecompilerOptions.Loops; if (noStack) { options |= DecompilerOptions.Unstack; } module = Decompiler.GetCodeModelFromMetadataModel(host, module, pdbReader, options); if (pdbReader != null) { localScopeProvider = new Decompiler.LocalScopeProvider(pdbReader); } } MetadataRewriter rewriter; MetadataDeepCopier copier; if (decompile) { copier = new CodeDeepCopier(host, pdbReader, pdbReader); rewriter = new CodeRewriter(host); } else { copier = new MetadataDeepCopier(host); rewriter = new MetadataRewriter(host); } var mutableModule = copier.Copy(module); module = rewriter.Rewrite(mutableModule); //var validator = new MetadataValidator(host); //List<Microsoft.Cci.ErrorEventArgs> errorEvents = new List<Microsoft.Cci.ErrorEventArgs>(); //host.Errors += (object sender, Microsoft.Cci.ErrorEventArgs e) => errorEvents.Add(e); //var assem = module as IAssembly; //validator.Validate(assem); //if (errorEvents.Count != 0) //{ // foreach (var e in errorEvents) // { // foreach (var err in e.Errors) // { // Console.WriteLine(err.Message); // } // } //} #if DEBUG var newRoot = Path.GetFileNameWithoutExtension(module.Location) + "1"; var newName = newRoot + Path.GetExtension(module.Location); using (Stream peStream = File.Create(newName)) { if (pdbReader == null) { PeWriter.WritePeToStream(module, host, peStream); } else { using (var pdbWriter = new PdbWriter(newRoot + ".pdb", pdbReader, emitTokenSourceInfo: true)) { PeWriter.WritePeToStream(module, host, peStream, sourceLocationProvider, localScopeProvider, pdbWriter); } } } #else using (Stream peStream = File.Create(module.Location)) { if (pdbReader == null) { PeWriter.WritePeToStream(module, host, peStream); } else { using (var pdbWriter = new PdbWriter(pdbFile, pdbReader, emitTokenSourceInfo: true)) { PeWriter.WritePeToStream(module, host, peStream, sourceLocationProvider, localScopeProvider, pdbWriter); } } } #endif } } }