3.1 Nozioni base del Linguaggio Assembly

Spesso i virus sono scritti in un linguaggio molto vicino a quello "naturale" del computer, l'Assembly appunto. I listati scritti in questo linguaggio sono caratterizzati dall'estensione ASM (a volte A86). Il programmatore Assembly deve conoscere necessariamente l'aritmetica binaria e quella esadecimale. Se il nostro sistema di numerazione decimale prevede l'uso di dieci simboli, quello binario ne prevede due e quello esadecimale (abbreviato con "hex") ne usa 16 (0-1-2-3-4-5-6-7-8-9-A-B-C-D-E-F). Il fattore di conversione è un puro calcolo matematico. Ovviamente il sistema esadecimale offre il vantaggio di occupare meno spazio. In Assembly è possibile gestire tutti e tre i sistemi di numerazione. Quello di 'default' è il sistema decimale, ma è possibile scrivere numeri negli altri formati aggiungendo "B" oppure "H" alla fine del numero.

Esempio: 10011010010B       4D2H

E' bene precisare che i numeri esadecimali non possono iniziare con una lettera, cioè A55H non è ammesso, 0A55H si.

3.2 I Registri

Gli elementi chiave dell'Assembly sono i registri, cioè le celle di memoria che possono memorizzare determinati valori. La dimensione dei registri dipende dal processore e dalla compilazione usata. Iniziamo con i registri a 16 bit (2 byte equivalgono a 1 word).        

Registri a 16 bit                                                            

I primi 4 registri sono ulteriormente suddivisi in registri a 8 bit, che indicano rispettivamente la parte alta e la parte bassa del registro. Vediamo come i registri sono classificati:

• AX      Accumulatore             (diviso in AH e AL)
• BX      Puntatore memoria     (diviso in BH e BL)
• CX      Contatore di cicli        (diviso in CH e CL)
• DX      Dati                           (diviso in DH e DL)
• SI       Sorgente dati
• DI       Destinazione dati

Ci sono poi i registri di segmento, che indicano delle porzioni di memoria RAM di 64K:

• CS     Code Segment          (segmento codice in esecuzione)
• DS     Data Segment           (segmento zona dati)
• ES     Extra Segment          (segmento aggiuntivo)
• SS     Stack Segment         (segmento stack)
• BP     Base Pointer             (punta al top dello stack)
• SP     Stack Pointer            (punta alla base dello stack)
• IP       Instruction Pointer     (punta all'istruzione corrente)

I registri che possono indirizzare la memoria, cioè riferirsi a dei dati contenuti in un certo punto di questa, sono solo BX, SI e DI. Nei processori 386 e superiori esistono i registri a 32 bit che richiedono debugger particolari per il loro controllo.

Registri a 32 bit

Per visualizzare il contenuto dei registri sotto MS-DOS si può usare il comando "DEBUG" che restituisce inoltre l'istruzione da eseguire, con il relativo codice esadecimale.

Esistono poi alcuni "tester" chiamati Flag. Essi sono degli switch che possono valere 0 o 1 e scattano in particolari condizioni:

• CF      Carry Flag       Flag di riporto, indica un riporto nelle somme e nelle 
•                                 sottrazioni.
• PF      Parity Flag      Bit di parità, viene usato nei processi di comunicazione.
• ZF      Zero Flag         Se è settato indica che il risultato di una operazione è 
•                                 zero.
• SF      Sign Flag        Flag di segno, indica se considerare il numero in assoluto 
•                                 o col segno.
• TF      Trap Flag         Usato dal debugger per controllare l'esecuzione passo 
•                                 dopo passo.
• DF      Direction         Indica il verso in cui bisogna lavorare con le stringhe (1 in 
•                                 avanti, 0 indietro).

3.3 Istruzioni di base                                    

Segue ora una descrizione delle più comuni e usate istruzioni del linguaggio.

ADD

Addizione tra due registri, tra un numero e un registro, tra un'area di memoria e un registro, tra un'area di memoria e un numero. Esempi:

• 053412      ADD     AX, 1234    aggiunge in AX il valore 1234H
• 01D0         ADD     AX, DX       aggiunge in AX il valore di DX
• 00F4         ADD     AH, DH      aggiunge in AH il valore di DH
• 00DC        ADD     AH, BL       aggiunge in AH il valore di BL
• 0307         ADD     AX, [BX]      aggiunge in AX il valore WORD puntato 
•                                              dall'indirizzo di BX
• 0207         ADD     AL, [BX]      aggiunge in AX il valore BYTE puntato all'indirizzo 
•                                               di BX
• 80C199     ADD     CL, 99         aggiunge in CL il valore 99H

E' possibile operare solo con registri della stessa dimensione o con registri e valori dello stesso formato. Ad esempio un'addizione del numero 1234 (16 bit) al registro AL (8 bit) risulta errata. Inoltre in caso di ambiguità bisogna specificare se il dato da manipolare è di tipo WORD (16 bit) o di tipo BYTE (8 bit), usando l'istruzione "PTR":

• 800711         ADD       BYTE PTR  [BX], 11
• 81073412      ADD      WORD PTR  [BX], 1234

Se il risultato eccede per il registro, il flag di riporto verrà settato su ON.

SUB

Funzione inversa di ADD, effettua la sottrazione tra numeri, registri o valori. Stesso funzionamento di ADD.

INC / DEC

Nel caso di addizione o sottrazione di 1 (incremento e decremento), si possono usare queste due istruzioni, molto più veloci e ridotte in termini di spazio:

• 050100       ADD      AX, 0001              40        INC       AX
• 83EB01      SUB      BX, +01                4B       DEC      BX

Non si possono usare direttamente sui registri di segmento.

MOV

Muove un valore dentro a un registro, o un registro dentro un altro registro, un valore dentro un'area di memoria o un registro dentro un'area di memoria.

• B83412         MOV       AX, 1234                         carica in AX il valore 1234H
• 89FE             MOV      SI, DI                              carica in SI il valore di DI
• C7073412      MOV      WORD PTR [BX], 1234     carica nella zona puntata da   
•                                                                         [BX]  1234H
• 8907              MOV     [BX], AX                           carica nella zona puntata da    
•                                                                          [BX]  AX

Usando questa istruzione è possibile accedere ai registri di segmento e modificarli:

• 8CDA           MOV      DX, DS        carica in DX il valore di DS
• 81C20001      ADD      DX, 0100     aggiunge 100H a DX
• 8EC2            MOV     ES, DX         carica in ES il valore di DX

Non sono ammesse manipolazioni sui registri CS e IP.

PUSH / POP

Permettono di salvare un registro o il valore puntato da un registro nello stack per poi ripristinarlo:

• B80001      MOV        AX, 0100
• 50              PUSH      AX
• 050001       ADD        AX, 0100
• 58              POP        AX

E' anche possibile manipolare i registri di segmento, come abbiamo visto prima con l'istruzione "MOV":

• 1E                PUSH      DS
• 5A                POP        DX
• 81C20001      ADD        DX, 0100
• 52                 PUSH      DX
• 1F                 POP        DS

NOP

E' un'istruzione progettata per non eseguire nessuna operazione. E' usata per le ottimizzazioni di codice, cioè per sincronizzare le esecuzioni e i trasferimenti dei dati. Il suo codice esadecimale è 90H.

CMP

Istruzione di confronto, serve per confrontare tra di loro due registri, delle posizioni di memoria:

• 39D8            CMP      AX, BX                             confronto tra registri 16-bit
• 38D8            CMP      AL, BL                             confronto tra registri 8-bit
• 39FE            CMP      SI, DI                               confronto tra registri 16-bit
• 3904             CMP      [SI], AX                            confronto tra valore puntato 
•                                                                         e registro
• 3B0F            CMP      CX, [BX]                           confronto tra registro e valore  
•                                                                         puntato
• 3D3412         CMP      AX, 1234                          confronto tra registro e valore  
•                                                                         diretto 16-bit
• 80FC12         CMP      AH, 12                             confronto tra registro e valore 
•                                                                         diretto 8-bit
• 803C12         CMP      BYTE PTR [SI], 12            confronto tra val. puntato e     
•                                                                         val. diretto a 8-bit
• 813D3412      CMP      WORD PTR [DI], 1234      confronto tra val. puntato e     
•                                                                         val. diretto a16-bit

Non si possono confrontare tra di loro due valori diretti o due valori puntati contemporaneamente. Occorre caricare uno di essi prima in un registro e poi eseguire il confronto su quel registro.

JMP

Salta a un indirizzo. Si può usare in diversi formati:

• E9FD03             JMP      0500              salta all'indirizzo 500H
• EA78563412      JMP      1234:5678      salta all'indirizzo 5678H del segmento di 
•                                                           memoria 1234H
• FFE3                 JMP      BX                 salta al valore di BX
• FF27                 JMP      [BX]               salta al valore puntato dal registro BX

JNZ / JZ

Salti condizionati. Eseguono il salto se una data condizione è vera. In questo caso la condizione è data dallo zero flag; esistono però altri tipi di salti:

• JNC / JC      salta se non c'è / se c'è riporto                    (Jump if Not Carry)
• JNA / JA      salta se non è superiore / se è superiore      (Jump if Not Above)
• JNB / JB      salta se non è inferiore / se è inferiore          (Jump if Not Below)
• JCXZ            salta se il registro CX è zero                       (Jump if CX is Zero)

Di solito i salti condizionati seguono un'istruzione "CMP" o una "OR". I salti condizionati hanno un limite (range) per cui non si possono fare salti dall'indirizzo corrente ad uno che superi i 181H (385D) byte.