dncil

dncil è una libreria di disassemblaggio del Common Intermediate Language (CIL) scritta in Python che supporta l'analisi dell'header, delle istruzioni e dei gestori di eccezioni dei metodi gestiti .NET. I dati analizzati vengono esposti tramite un'API orientata agli oggetti per aiutarti a sviluppare rapidamente strumenti di analisi CIL usando dncil.

Perché Python? Le librerie esistenti che supportano il disassemblaggio CIL, come dnLib, sono scritte in C#. Per sfruttare questi strumenti, devi creare applicazioni C#, il che richiede esperienza di sviluppo in C#. Usando dncil, un'alternativa in puro Python:

1. Non hai bisogno di esperienza con C# per analizzare CIL a livello di programmazione.
2. Puoi sviluppare e testare rapidamente i tuoi strumenti di analisi CIL.
3. Puoi integrare facilmente i tuoi strumenti di analisi CIL con progetti Python esistenti.

Esempio

Lo script di esempio print_cil_from_dn_file.py usa dncil insieme alla libreria di analisi .NET dnfile per disassemblare i metodi gestiti trovati in un eseguibile .NET. Vediamo cosa può fare.

Per prima cosa, compiliamo il seguente codice sorgente C#:

using System;	

public class HelloWorld
{
    public static void Main(string[] args)
    {
        Console.WriteLine ("Hello World!");
    }
}

La compilazione produce un eseguibile PE contenente metadati .NET che informano il Common Language Runtime (CLR) su come eseguire il nostro codice. Usiamo dnfile per analizzare questi metadati, ottenendo così l'offset del nostro metodo gestito Main. Poi usiamo dncil per disassemblare e visualizzare le istruzioni CIL memorizzate in questa posizione.

Vediamo quanto sopra in azione:

$ python scripts/print_cil_from_dn_file.py hello-world.exe 

Method: Main
0000    00                  nop            
0001    72 01 00 00 70      ldstr          "Hello World!"
0006    28 04 00 00 0a      call           System.Console::WriteLine
000B    00                  nop            
000C    2a                  ret            

Il nostro metodo Main è rappresentato dalla classe CilMethodBody. Questa classe contiene dati che includono l'header, le istruzioni CIL e i gestori di eccezioni di un determinato metodo gestito. Espone inoltre varie funzioni di supporto:

>  main_method_body.flags
SmallFormat  :  false
TinyFormat   :  false
FatFormat    :  false
TinyFormat1  :  true
MoreSects    :  false
InitLocals   :  false
CompressedIL :  false
>  main_method_body.size
14
>  hexdump.hexdump(main_method_body.get_bytes())
00000000: 36 00 72 01 00 00 70 28  04 00 00 0A 00 2A        6.r...p(.....*
>  hexdump.hexdump(main_method_body.get_header_bytes())
00000000: 36                                                6
>  hexdump.hexdump(main_method_body.get_instruction_bytes())
00000000: 00 72 01 00 00 70 28 04  00 00 0A 00 2A           .r...p(.....*

Ogni istruzione CIL trovata nel nostro metodo gestito Main è rappresentata dalla classe Instruction. Questa classe contiene dati che includono l'offset, il mnemonico, l'opcode e l'operando di una determinata istruzione CIL. Espone inoltre varie funzioni di supporto:

>  len(main_method_body.instructions)
5
>  insn = main_method_body.instructions[1]
>  insn.offset
1
>  insn.mnemonic
'ldstr'
>  insn.operand
token(0x70000001)
>  insn.is_ldstr()
True
>  insn.size
5
>  hexdump.hexdump(insn.get_bytes())
00000000: 72 01 00 00 70                                    r...p
>  hexdump.hexdump(insn.get_opcode_bytes())
00000000: 72                                                r
>  hexdump.hexdump(insn.get_operand_bytes())
00000000: 01 00 00 70                                       ...p

Installazione

Per installare dncil usa pip per recuperare il modulo dncil:

$ pip install dncil

Per eseguire gli script di esempio, assicurati di installare dnfile. In alternativa, installa dncil con le dipendenze di sviluppo come descritto nella sezione Development di seguito.

Vedi print_cil_from_bytes.py per un rapido esempio di utilizzo di dncil per stampare le istruzioni CIL trovate in un flusso di byte contenente un metodo gestito .NET.

Sviluppo

Se desideri esaminare e modificare il codice sorgente di dncil, dovrai scaricarlo da GitHub e installarlo localmente.

Usa il seguente comando per installare dncil localmente con le dipendenze di sviluppo:

$ pip install /local/path/to/src[dev]

Avrai bisogno delle dipendenze di sviluppo di dncil per eseguire test e linting come descritto di seguito.

Test

Usa il seguente comando per eseguire i test:

$ pytest /local/path/to/src/tests

Linting

Usa i seguenti comandi per identificare errori di formattazione:

$ black -l 120 -c /local/path/to/src
$ isort --profile black --length-sort --line-width 120 -c /local/path/to/src
$ mypy --config-file /local/path/to/src/.github/mypy/mypy.ini /local/path/to/src/dncil/ /local/path/to/src/scripts/ /local/path/to/src/tests/

Crediti

dncil è basato sul codice di analisi CIL trovato in dnLib.