pjbgf / dotnet-ildasm Goto Github PK

View Code? Open in Web Editor NEW

60.0 5.0 14.0 191 KB

Light-weight cross platform IL disassembler tool built in C#.

License: MIT License

C# 98.30% Batchfile 1.07% Shell 0.63%

dotnet-ildasm ildasm cil il-disassembler dotnet-cli msil disassembler dotnet-core

dotnet-ildasm's Introduction

Dot Net IL Disassembler

Description

The dotnet ildasm provides a command-line IL dissassembler. Simply send the assembly path as a parameter and as a result you will get the IL contents of that assembly.

Setup

The project was created as a global CLI tool, therefore you can install with a single command:

dotnet tool install -g dotnet-ildasm

Note that for the command above to work, you need .NET Core SDK 2.1.300 or above installed in your machine.

Syntax

dotnet ildasm <ASSEMBLY_PATH>
dotnet ildasm <ASSEMBLY_PATH> <-o|--output>
dotnet ildasm <ASSEMBLY_PATH> <-i|--item>
dotnet ildasm <-h|--help>

Options

-i
Filter results by method and/or classes to be disassembled.

-o
Define the output file to be created with the assembly's IL.

Examples

Output IL to the command line:

dotnet ildasm myassembly.dll

Filter results by method and/or classes to be disassembled, showing the result in the command line:

dotnet ildasm myassembly.dll -i ClassName
dotnet ildasm myassembly.dll -i ::MethodName
dotnet ildasm myassembly.dll -i ClassName::MethodName

Define the file to be created with the output:

dotnet ildasm myassembly.dll -o disassembledAssembly.il

dotnet-ildasm's People

Stargazers

Watchers

Forkers

trazarw clouda2z-code kstanoev wilvk jaywalia lance2088 digitalarche ihaiucom gurupia johnsonxd4 lextudio maybelaterornot

dotnet-ildasm's Issues

IL Code needs to be indented

Current IL

.class private auto ansi beforefieldinit ConsoleApp1.Program extends System.Object{

.method private hidebysig System.Void ConsoleApp1.Program::Main(System.String[]) cil managed
{
.entrypoint
// Code size 13
.maxstack 8
IL_0000: nop
IL_0001: ldstr "Hello World!"
IL_0006: call System.Void System.Console::WriteLine(System.String)
IL_000b: nop
IL_000c: ret
}// End of method System.Void ConsoleApp1.Program::Main(System.String[])

.method public hidebysig specialname rtspecialname instance System.Void ConsoleApp1.Program::.ctor() cil managed
{
// Code size 8
.maxstack 8
IL_0000: ldarg.0
IL_0001: call System.Void System.Object::.ctor()
IL_0006: nop
IL_0007: ret
}// End of method System.Void ConsoleApp1.Program::.ctor()

} // End of class ConsoleApp1.Program

Expected IL

.class private auto ansi beforefieldinit ConsoleApp1.Program extends System.Object{

	.method private hidebysig System.Void ConsoleApp1.Program::Main(System.String[]) cil managed
	{
		.entrypoint
		// Code size 13
		.maxstack 8
		IL_0000: nop
		IL_0001: ldstr "Hello World!"
		IL_0006: call System.Void System.Console::WriteLine(System.String)
		IL_000b: nop
		IL_000c: ret
	}// End of method System.Void ConsoleApp1.Program::Main(System.String[])

	.method public hidebysig specialname rtspecialname instance System.Void ConsoleApp1.Program::.ctor() cil managed
	{
		// Code size 8
		.maxstack 8
		IL_0000: ldarg.0
		IL_0001: call System.Void System.Object::.ctor()
		IL_0006: nop
		IL_0007: ret
	}// End of method System.Void ConsoleApp1.Program::.ctor()

} // End of class ConsoleApp1.Program

Consider using Microsoft.NETCore.ILDAsm instead of Mono.Cecil

for .NET core specific projects.
It may be hard to set up because of the runtime graph and native code evolved, but it would align more closely to the concept of making a dotnet ildasm tool for the .NET Core tooling. This package is produced from https://github.com/dotnet/coreclr/tree/master/src/ildasm

Add support to Try Catchs

Add support to fields.

Currently class fields are not exported onto IL.

Add reassembling of test .IL files as part of CI Cross Checks

ILDASM - Wrong exit code

I'm using ILDASM to inspect all files in a folder (project build output), and in somes cases i have configuration/text files. In those edge cases i caught a bug, although i received an exit code 0 the process output was "Image is either too small or contains an invalid byte offset or count.\n". According to the process output i was expecting to receive an exit 1.

I'm migrating to this version of ILDASM (before i was using https://docs.microsoft.com/en-us/dotnet/framework/tools/ildasm-exe-il-disassembler) because i couldn't run in Docker container with mono.

I even open an issue on the wrong project site (https://github.com/dotnet/coreclr/issues/18885#issuecomment-404794040), but then i realized this version of ILDASM was manged in a distinct project.

Command example:

dotnet ildasm CannotDisassemble & echo %errorlevel%

Output:

Image is either too small or contains an invalid byte offset or count.
0

CannotDisassemble.zip

Create switch to add annotations to IL

It would be handy a switch (‘-a’ | ‘-annotate’) that would add commands explaining the IL instructions using comments.

Reassembling PEs using MS ILasm generates error.

Sign the generated nuget packages

Use the signing packages feature before publish versions into Nuget.org.

https://docs.microsoft.com/en-us/nuget/reference/signed-packages-reference

Locals not being initialised

Stop generating version from feature branches

Currently any commit to a feature branch is generating a new nuget package.

A better approach would be to push such packages into a MyGet feed.

Implement some of MS ILDasm Features

Implement keys features from MS IL Dasm:

/source Shows original source lines as comments.
/raweh Shows exception handling clauses in raw form.
/pubonly Disassembles only public types and members.

Also support same syntax, using slashes instead of hyphens.

More information at ILDasm documentation

Create regression testing for all permutations of Class and Method Signatures

Support Execution for .Net 4.5 in Linux

This should be working already, needs to be asserted as part of the CI pipeline.

Wrong IL generated for storing value in a local variable.

Source code

class Program
{
    static void Main(string[] args)
    {
        int add = Add(20, 10);
        int sub = Subtract(20, 10);
        int multiply = Multiply(20, 10);
        int divide = Divide(20, 10);
        // Issue here
        int modulo = Modulo(20, 10);
    }

    static int Add(int i, int j) => i + j;

    static int Subtract(int i, int j) => i - j;

    static int Multiply(int i, int j) => i * j;

    static int Divide(int i, int j) => i / j;

    static int Modulo(int i, int j) => i % j;
}

Steps to reproduce

Compile the above source code into a DLL.
Run dotnet ildasm on the DLL.

Expected IL

IL_0032: stloc.s V_4

Actual IL

IL_0032: stloc.s class V_4

Error
When running ILAsm : MSIL.il(60) : error : syntax error at token 'class' in: IL_0032: stloc.s class V_4
Works well with traditional ILDAsm.

Package application as dotnet CLI tool

Exported Types needs to be translated from .Net Types to IL Types

Current IL

.method private hidebysig System.Void ConsoleApp1.Program::Main(System.String[]) cil managed
{
.entrypoint
// Code size 13
.maxstack 8
IL_0000: nop
IL_0001: ldstr "Hello World!"
IL_0006: call System.Void System.Console::WriteLine(System.String)
IL_000b: nop
IL_000c: ret
}

Expected IL

.method private hidebysig void ConsoleApp1.Program::Main(string[]) cil managed
{
.entrypoint
// Code size 13
.maxstack 8
IL_0000: nop
IL_0001: ldstr "Hello World!"
IL_0006: call void System.Console::WriteLine(string)
IL_000b: nop
IL_000c: ret
}

Failed to disassemble .Net Framework App

I was executing some tests with ildasm and found an issue. I tried to desassemble a WPF executable (.Net Framework 4.6.2) and it failed due to:

Failed to resolve assembly: 'PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'

Then i copied from .NetFramework folder the missinf dll to the output folder of the project and executed again the ildasm, and this time it worked.

Is there any workaround to fix this issue, as ildasm should resolve .NetFramework dlls, as it does for .NetStandard references.

If i use the ildasm version that comes with Microsoft SDK's it workes correctly (for instance Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.7.1 Tools).

Sample.zip

Support lookup for nuget packages

Create a switch to allow automatic download of nuget packages.

Need to consider a specific syntax to support package name and version, potentially:

dotnet ildasm packagename/0.1.0 --nuget

dotnet ildasm packagename --nuget -v 0.1.0

Create --force switch to force files to be overwritten

How to use it on .net core 2.0?

Is there a way to use ildasm in .net core 2.0?
Any information would be helpful.

Consolidate Build and Release Pipelines

Consolidate all builds using a single platform - potentially GitHub Actions.

Context
Currently AppVeyor is being used for windows builds and CircleCI for linux.
Each platform tests for platform-compatibility, but also add the following activities:

Windows pipeline: applies git semver and releases the nuget package.
Linux: generate code coverage report and submit to codecov.

Add support to params key word

C# Code

public void PublicVoidMethodParams(params string [] parameters)
{
}

Current IL
.method public hidebysig instance void PublicVoidMethodParams(array parameters) cil managed

Expected IL
.method public hidebysig instance void PublicVoidMethodParams(string[] parameters) cil managed

Nested classes do not seem to be supported

While trying to disassemble some assemblies with nested classes, they're not disassembled. ildasm from the .NET framework, and the disassembler from sharplab are able to correctly disassemble the code generated by this C# program:

using System;

namespace Foo {
	class Bar {
		public class FooBar {
			public string SomeMethod() { return "aaaaa"; }
		}

		public FooBar MakeFooBar() {
			return new FooBar();
		}
	}

	class Test {
		public static void Main() {
			var bar = new Bar();
			var fooBar = bar.MakeFooBar();

			Console.WriteLine(fooBar.SomeMethod());
		}
	}
}

In this example, dotnet-ildasm generates calls to FooBar.SomeMethod(), but its definition is nowhere to be found.

Use same command line framework that dotnet cli

Using the same command line framework as the dotnet cli tools would make consistent the look and feel of ‘dotnet ildasm’ when compared to the other tools.

Support Execution for .Net 4.5 on Windows

This should be working already, needs to be asserted as part of the CI pipeline.

netcoreapp5.0 not supported, 3.0 is "out of support"

Attempting to use the current latest release on .NET Core 5.0 gives:

[gitlab@f1b1b25c46f1 test]$ dotnet tool install --tool-path /tmp/ dotnet-ildasm
You can invoke the tool using the following command: dotnet-ildasm
Tool 'dotnet-ildasm' (version '0.12.2') was successfully installed.
[gitlab@f1b1b25c46f1 test]$ /tmp/dotnet-ildasm
It was not possible to find any compatible framework version
The framework 'Microsoft.NETCore.App', version '3.0.0' was not found.
  - The following frameworks were found:
      5.0.0 at [/usr/share/dotnet/shared/Microsoft.NETCore.App]

You can resolve the problem by installing the specified framework and/or SDK.

The specified framework can be found at:
  - https://aka.ms/dotnet-core-applaunch?framework=Microsoft.NETCore.App&framework_version=3.0.0&arch=x64&rid=centos.7-x64

Taking a look at build.sh, it appears to be building for each version from 2.0 -> 3.0.

Structs are not supported

C# Code

struct Abc
{
}

Current IL

.class private sequential ansi beforefieldinit ConsoleApp1.Abc extends System.ValueType
{
} // End of class ConsoleApp1.Abc

Expected IL

.class private sequential ansi sealed beforefieldinit ConsoleApp1.Abc extends [System.Runtime]System.ValueType
{
  .pack 0
  .size 1
} // end of class ConsoleApp1.Abc

Enable "Require signed commits"

Add Snyk monitor to Pipeline

IL Generated has inconsistent Indentation

The generated IL has inconsistent indentation in the following scenarios:

Catch Statements
Expected

    IL_0009: nop
    IL_000a: leave.s       IL_0017
  }
  catch [netstandard]System.Exception
  {
    IL_000c: stloc.0
    IL_000d: nop

Actual

    IL_0009: nop
    IL_000a: leave.s       IL_0017
  }
catch [netstandard]System.Exception
  {
    IL_000c: stloc.0
    IL_000d: nop

Closing Brackets
Expected

.class public ... extends [netstandard]System.Object
{
  .method public hidebysig ...() cil managed
  {
  }
  .method public ...() cil managed
  {
  }
}

Actual

.class public ... extends [netstandard]System.Object
{
  .method public hidebysig ...() cil managed
  {
}
  .method public ...() cil managed
  {
}
}

Breakline between Methods and Classes
Expected

.class public ... extends [netstandard]System.Object
{
  .method public hidebysig ...() cil managed
  {
  }

  .method public ...() cil managed
  {
  }
}

.class private ... extends [netstandard]System.Object
{

Actual

.class public ... extends [netstandard]System.Object
{
  .method public hidebysig ...() cil managed
  {
  }
  .method public ...() cil managed
  {
  }
}
.class private ... extends [netstandard]System.Object
{

Implement -item switch for filtering disassembled types

Disassembles specific items depending upon the argument supplied:

Disassembles the specified class.
Disassembles the specified memberof the class.

Syntax proposed:
-item=class[::member]

Custom attributes not extracted for all targets

Currently, custom attributes are only extracted for assemblies and types, but not other targets like type members (properties, methods, etc.).

Invalid IL for Properties

Current IL
IL_0001: ldfld string dotnet_ildasm.Sample.Classes.PublicClass::<Property1>k__BackingField
Expected IL
IL_0001: ldfld string dotnet_ildasm.Sample.Classes.PublicClass::'<Property1>k__BackingField'

Support Execution for .Net Core on Windows

This should be working already, needs to be asserted as part of the CI pipeline.

Add Check whether target assembly exists

Wrong IL generated for Local init

Source code:

public void UsingTryCatch(int parameter)
{
      try
      {
           Console.WriteLine(parameter);
      }
      catch (Exception e)
      {
          Console.WriteLine(e);
          throw;
      }
}

Expected IL

.locals init (class [System.Runtime]System.Exception V_0)

Actual IL

.locals init([System.Runtime]System.Exception V_0)

Filter printing classes not contained within expression.

When filtering by Class name and Method name, classes that does not match the criteria will also be printed.

Support Execution .Net Core 1.0 in Linux

This should be working already, needs to be asserted as part of the CI pipeline.

Add performance benchmarking

https://github.com/dotnet/BenchmarkDotNet

dotnet-ildasm throws error as "It was not possible to find any compatible framework version The specified framework 'Microsoft.NETCore.App', version '2.2.0' was not found. - The following frameworks were found: 3.0.0 at [/usr/share/dotnet/shared/Microsoft.NETCore.App]" since we upgraded dotnet version to 2.2xx to 3.0

Since we updated our dotnet version from 2.2.xxx to 3.0.0 we are facing below error while running ./dotnet-ildasm "$dll" command.

It was not possible to find any compatible framework version
The specified framework 'Microsoft.NETCore.App', version '2.2.0' was not found.
  - The following frameworks were found:
      3.0.0 at [/usr/share/dotnet/shared/Microsoft.NETCore.App]

Feels like this command fails with new dotnet version.

Any help with this issue would be appreciated. :)

Extract the public key token actual value from referenced assemblies

Current IL

.assembly extern System.Runtime
{
// .publickeytoken 10110000 111111 1011111 1111111 10001 11010101 1010 111010 // Needs proper formatting
.ver 4:2:0:0
}

Expected IL

.assembly extern System.Runtime
{
  .publickeytoken = (B0 3F 5F 7F 11 D5 0A 3A)
  .ver 4:2:0:0
}

External Types should always be preceded by their assembly names

Current IL

.custom instance System.Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(System.Int32)

Please notice that the example above is with custom attributes, however this specific issue regards all types. Also, the current IL have other problems that are logged in their own separated issues ( #2 , #3 and #4 )

Expected IL

.custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 )

Extract Cecil Extension Methods onto its own project

The extension methods used to generate IL based on Mono.Cecil should be extracted as a separate package.

Extract custom attribute values

Current IL

.custom instance System.Void System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(System.Int32)
.custom instance System.Void System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor()
.custom instance System.Void System.Runtime.Versioning.TargetFrameworkAttribute::.ctor(System.String)
.custom instance System.Void System.Reflection.AssemblyCompanyAttribute::.ctor(System.String)
.custom instance System.Void System.Reflection.AssemblyConfigurationAttribute::.ctor(System.String)
.custom instance System.Void System.Reflection.AssemblyDescriptionAttribute::.ctor(System.String)
.custom instance System.Void System.Reflection.AssemblyFileVersionAttribute::.ctor(System.String)
.custom instance System.Void System.Reflection.AssemblyInformationalVersionAttribute::.ctor(System.String)
.custom instance System.Void System.Reflection.AssemblyProductAttribute::.ctor(System.String)
.custom instance System.Void System.Reflection.AssemblyTitleAttribute::.ctor(System.String)

Expected IL

  .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 ) 
  .custom instance void [System.Runtime]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78   // ....T..WrapNonEx
                                                                                                                   63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 )       // ceptionThrows.

  .custom instance void [System.Runtime]System.Runtime.Versioning.TargetFrameworkAttribute::.ctor(string) = ( 01 00 18 2E 4E 45 54 43 6F 72 65 41 70 70 2C 56   // ....NETCoreApp,V
                                                                                                              65 72 73 69 6F 6E 3D 76 32 2E 30 01 00 54 0E 14   // ersion=v2.0..T..
                                                                                                              46 72 61 6D 65 77 6F 72 6B 44 69 73 70 6C 61 79   // FrameworkDisplay
                                                                                                              4E 61 6D 65 00 )                                  // Name.
  .custom instance void [System.Runtime]System.Reflection.AssemblyCompanyAttribute::.ctor(string) = ( 01 00 0B 43 6F 6E 73 6F 6C 65 41 70 70 31 00 00 ) // ...ConsoleApp1..
  .custom instance void [System.Runtime]System.Reflection.AssemblyConfigurationAttribute::.ctor(string) = ( 01 00 05 44 65 62 75 67 00 00 )                   // ...Debug..
  .custom instance void [System.Runtime]System.Reflection.AssemblyDescriptionAttribute::.ctor(string) = ( 01 00 13 50 61 63 6B 61 67 65 20 44 65 73 63 72   // ...Package Descr
                                                                                                          69 70 74 69 6F 6E 00 00 )                         // iption..
  .custom instance void [System.Runtime]System.Reflection.AssemblyFileVersionAttribute::.ctor(string) = ( 01 00 07 31 2E 30 2E 30 2E 30 00 00 )             // ...1.0.0.0..
  .custom instance void [System.Runtime]System.Reflection.AssemblyInformationalVersionAttribute::.ctor(string) = ( 01 00 05 31 2E 30 2E 30 00 00 )                   // ...1.0.0..
  .custom instance void [System.Runtime]System.Reflection.AssemblyProductAttribute::.ctor(string) = ( 01 00 0B 43 6F 6E 73 6F 6C 65 41 70 70 31 00 00 ) // ...ConsoleApp1..
  .custom instance void [System.Runtime]System.Reflection.AssemblyTitleAttribute::.ctor(string) = ( 01 00 0B 43 6F 6E 73 6F 6C 65 41 70 70 31 00 00 ) // ...ConsoleApp1..

Extract Assembly Directives

The following assembly directives are not being extracted from the assembly:

pjbgf / dotnet-ildasm Goto Github PK

dotnet-ildasm's Introduction

Dot Net IL Disassembler

Description

Setup

Syntax

Options

Examples

dotnet-ildasm's People

Stargazers

Watchers

Forkers

dotnet-ildasm's Issues

Recommend Projects

Recommend Topics

Recommend Org