Tutorial Cap01 - INTRODUZIONE - Giobe®2000 - Assembler - Assembly - debugger DEBUG istruzioni 8086 80x86 processore

Sezione

Indirizzi Base Registri Interni
Area Comunicazione BIOS Funzioni BIOS Funzioni DOS
Prefazione Capitolo 1 Capitolo 2 Schede
Libreria ASM Libreria MAC Palestra Progetti ASM
Info Download INDICE

Capitolo 1

Home » Programma il Computer » Tutorial Assembly

Il Processore e il Debugger

INTRODUZIONE [1 di 60]

Aggiornato 24 settembre 2003 e 17 febbraio 2005

Comando U - Disassembla il codice di un file eseguibile

	Ecco la vera bomba! ... il comando U (UNASSEMBLE, disassembla): di solito ha senso solo dopo aver specificato il nome (con il comando N) e caricato in memoria (con il comando L) un file eseguibile, magari dopo aver pulito la memoria chiamata ad ospitarlo (con il comando F); se viene dato senza parametri inizia a tradurre il bytes presenti in memoria a partire dall'indirizzo CS:0100H; il segmento di default è ovviamente quello di codice, CS.
	E' facile capire la potenza di questo comando: con esso si possono analizzare le istruzioni di qualunque file eseguibile, in primis quelli da noi prodotti, in fase di messa a punto o di ricerca delle rogne...
	Ma soprattutto (?!) quelli prodotti da altri (per esempio dal tuo ben amato autore preferito...); l'ipocrisia è la peggiore delle essenze umane; i sepolcri imbiancati sono lo sfoggio della peggiore architettura...
	Naturalmente la "traduzione" in chiaro di un sorgente non è priva di intoppi e malizie: è il prezzo che bisogna pagare all'esperienza e al colpo d'occhio.

Il comando U prova comunque a tradurre in assembly i bytes che trova; se per qualche ragione il programma contiene tabelle o dati o messaggi (cosa estremamente probabile..) il risultato sarà del tutto illogico, cioè verranno mostrate sequenze di istruzioni assurde e scorrelate. Bisogna quindi saper localizzare le aree dati di un programma, escludendole dall'indagine con U a beneficio di quella con il comando D.

L'esempio mostra la sequenza di comandi adatti all'analisi del programma prova.com, usato nel capitolo 2 per esercitarci nella sua creazione; nella parte destra è riproposto il codice sorgente (prova.asm) mentre a sinistra si può osservare come viene interpretato dal comando U:

Se fai click sull'icona a sinistra si apre l'Ambiente Assembly e puoi provare DEBUG on-line.
Scegli il pulsante di opzione "Aprire il file" o "Esegui l'applicazione" e conferma con OK.
NB: alcuni gestori di protezione (per esempio SP2 di WinXP) non ti consentono questa operazione:
in questo caso scrivi c:\arch-lab\bin\sys\assembler.pif direttamente nel campo indirizzo del Browser

-f 100 1000 00
-n prova.com
-l
-u
11A0:0100 B400 MOV AH,00
11A0:0102 B003 MOV AL,03
11A0:0104 CD10 INT 10
11A0:0106 B400 MOV AH,00
11A0:0108 CD16 INT 16
11A0:010A B44C MOV AH,4C
11A0:010C CD21 INT 21
11A0:010E 0000 ADD [BX+SI],AL

_prog   SEGMENT BYTE PUBLIC 'CODE'
        ASSUME CS:_prog,DS:_prog
        ORG    0100H
INIZIO: MOV AH,00H ;Pulisci lo schermo
        MOV  AL,03H ;(ClearScreen)
        INT  10H    ;
        MOV  AH,00H;Aspetta la pressione
        INT  16H    ;di un tasto
        MOV  AH,4CH ;Torna al dos
        INT  21H    ;
_prog   ENDS
        END INIZIO

Osserviamo con calma il frutto di Unassemble:

la pressione di U (ed ogni altra successiva) ha coinvolto almeno 16 bytes di memoria.

l'indirizzo della locazione di partenza è CS:0100 (perchè è la prima volta) ma in generale è sempre dato dal valore corrente di CS:IP.

i bytes di ciascuna riga visualizzata appartengono ad una ben precisa istruzione, ad insindacabile giudizio del debugger.

per ogni riga mostrata sono resi disponibili:

	l'indirizzo logico (CS:IP corrente) del primo dei bytes coinvolti.
	la sequenza dei bytes associati all'istruzione riconosciuta; di essi il primo è certamente un codice operativo.
	dopo i bytes che codificano l'istruzione viene mostrata la loro interpretazione mnemonica:

Non dimenticare: in ambiente Debug i numeri mostrati sono sempre esadecimali anche se non sono dotati della H finale!

in ogni caso il processo continua per tutti i bytes coinvolti, anche per quelli che non appartengono più al programma caricato in memoria; ne da dimostrazione l'ultima riga di disassemblato, nella quale i 2 bytes a 00H sono comunque ritenuti istruzione dal comando U (un'istruzione del tutto improbabile e illogica, almeno nel contesto precedente, ADD [BX+SI],AL).

Ogni volta che si preme U il video si riempie con le istruzioni corrispondenti ai successivi 16 bytes.

	Se desideri rivedere la traduzione di bytes passati in precedenza è necessario usare il comando U con la specifica dell'indirizzo (offset) desiderato, per esempio U 100, per tornare a rivedere tutto!
	In certi casi (in particolare se si riesce a ridirigere la videata verso un file....) è conveniente passare 2 parametri, l'indirizzo iniziale e il numero (espresso con una L seguita dal numero esadecimale) delle istruzioni da dissassemblare; per esempio, conoscendo la lunghezza del programma è possibile evitare così la visualizzazione dell'istruzione fasulla:

-u 100 L7
11A0:0100 B400 MOV AH,00
11A0:0102 B003 MOV AL,03
11A0:0104 CD10 INT 10
11A0:0106 B400 MOV AH,00
11A0:0108 CD16 INT 16
11A0:010A B44C MOV AH,4C
11A0:010C CD21 INT 21

Naturalmente se si punta l'indirizzo di un bytes operando (cosa probabile, quando si effettua un'analisi al buio...) il risultati sono imprevedibili, ma prima o poi il vero programma viene agganciato; l'esperienza aiuta a trovare il vero indirizzo iniziale; vediamo il significato di questa osservazione con l'analisi del programma precedente, puntato male:

-u 101
11A0:0101 00B003CD ADD [BX+SI+CD03],DH
11A0:0105 10B400CD ADC [SI+CD00],DH
11A0:0109 16       PUSH SS
11A0:010A B44C     MOV AH,4C
11A0:010C CD21     INT 21
11A0:010E 0000     ADD [BX+SI],AL
11A0:0110 0000     ADD [BX+SI],AL
11A0:0112 0000     ADD [BX+SI],AL

Ci vuole un bel po' per individuare le istruzioni vere (quelle a 010A e 010C) ma l'assurdità delle prime 3 istruzioni ci ha chiaramente messo sull'avviso che qualcosa è andato storto! Il buon comando U ci ha comunque provato.

	Capitolo 1			INTRODUZIONE
	1 di 60

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

CAP. 1 »

1. Processore 80x86 2. Istruzioni 80x86 3. Debug 4. La Grande Libreria

TUTORIAL »

^Home

Pascal|Manuali|Tabelle|Schede
Tutorial Assembly|Palestra Assembler

Aggiungi Giobe®2000 ai preferiti

Motore
Ricerca

Rendi Giobe®2000 pagina di Default