BitCell

by **emi** » 01 May 2010, 21:39

Program facut in momentul in care invatam sa controlez Pascal si assembler, pe un sistem MS-DOS.
(functioneaza si sub Win XP, dar memoria afisata nu e cea reala)

MVIEW.PAS

Line number On/Off | Expand/Contract | Select all

{$A+,B-,D-,E-,F-,G-,I+,L-,N-,O-,P-,Q-,R-,S+,T-,V-,X-}
{$M $800,0,0 }
 
uses dos;
type
  dword=record l,h:word end;
 
var
  VideoSeg,P,I:WORD;
  str:string;
  again:boolean;
  firstMCB:boolean;
  urmMCB,CurrentIP,DataSeg:word;
  KbdIntVec:Procedure;
  sav_x,sav_y,scr_attr:byte;
  scr_full_mode:boolean;
  Active:boolean;
 
 
{$I   VIDEO.INC}
{$I   CUSOR.INC}
{$I     KEY.INC}
{$I    SCAN.INC}
{$I  Memory.INC}
 
 
procedure init;
begin
  FirstMCB:=true;
  str:='';
  P:=0;
  scr_full_mode:=false;
  clrscr;
  VideoSeg:=GetVideoSeg;
  scr_attr:=mem[VideoSeg:1];
  Active:=false;
  asm
    call @1
    @1:
    pop ax
    mov cx,4
    shr ax,cl
    mov bx,cs
    add ax,bx
    mov CurrentIP,ax
 
    mov dx,$1234            { Allready installed ? }
    int $09
    cmp dx,$4321
    jne @NotActive
    mov al,true
    mov Active,al
    @NotActive:
  end;
end;
 
procedure run;
var
  ExtKey,Key:byte;
  step:word;
BEGIN
  gotoxy(12,0);
  REPEAT
    WritePage;
    extendedkey(ExtKey,Key);
    again:=false;
    if scr_full_mode then begin
      case key of
      27:exit;
      0 :case extkey of
         80: p:=p+5;                           { DN }
         72: p:=p-5;                           { UP }
         73: p:=p-125;                         { PgUp }
         81: p:=p+125;                         { PgDn }
         end;
      32:scr_full_mode:=false;
      end;
    end else begin
    CASE Key OF
      27: EXIT;
      0 : CASE ExtKey OF
        80 : INC(P);                            { DN }
        72 : DEC(P);                            { UP }
        77 : right;
        75 : left;
        71 : P:=0;                              { HOME  }
        79 : P:=$FFE7;                          { End   }
        73 : P:=P-$19;                          { PgUp  }
        81 : P:=P+$19;                          { PgDn  }
        132: P:=P-$190;                         { ^PgUp }
        118: P:=P+$190;                         { ^PgDn }
        68 : if active then begin               { F10   }
               clrscr;
               setintvec($09,Addr(KbdIntVec));
               halt;
             end;
      END;
      48..57,65..70,97..102:
        if key<58 then P:=(key-48)*$1000
        else P:=((key and $DF)-55)*$1000;
      83,115: scan;                             { S     }
      71,103: begin again:=true; scan; end;     { G     }
      23    : writemsg;                         { ^W    }
      09    : tab;
      73,105: Interrupts;
      77,109: Mcb;
      84,116: DTA;
      32    : scr_full_mode:=true;
      36    : asm mov ax,sp; shr ax,1; shr ax,1; shr ax,1; shr ax,1;
                  mov bx,ss; add ax,bx; mov p,ax
              end;
      64    : P:=CurrentIP;
      35    : P:=DataSeg;
      END;
    end;
  UNTIL FALSE;
END;
 
procedure done;
begin
  clrscr;
  gotoxy(21,12);
  WriteLn('Memory View 1.7 (c) 93,98 by EmiSoft');
end;
 
{$F+}
procedure Activate; interrupt;
var flags:word;
begin
  asm
    pushf
    pop ax
    mov flags,ax
  end;
 
  inline ($9C); { PUSHF }
  KbdIntVec;
  asm
    mov dx,[BP+10]             { Self test }
    cmp dx,$1234
    jne @1
    mov dx,$4321
    mov [BP+10],dx
    @1:
  end;
  if Active then exit;
  if (flags and $30) <> 0 then exit;
 
  if (mem[0:$417] and $03) <> $03       { not (Left and Right Shift) ? }
  then exit;
 
  {init}
    Active:=true;
    asm
      mov ax,[BP+18]
      mov cx,4
      shr ax,cl
      add ax,[BP+20]
      mov CurrentIP,ax
      mov ax,[BP+4]
      mov DataSeg,ax
    end;
    sav_x:=wherex; sav_y:=wherey;
    MovScreen( ptr(VideoSeg+$0700,0), ptr(VideoSeg,0) );
 
    VideoSeg:=VideoSeg+$0600;
    scr_Fill($20,scr_attr);
    WritePage;
    VideoSeg:=VideoSeg-$0600;
 
    scr_RigthScroll(VideoSeg,VideoSeg+$0600);
  {end init}
 
  run;
  gotoxy(sav_x,sav_y);
  scr_LeftScroll(VideoSeg,VideoSeg+$0700);
  Active:=false;
end;
{$F-}
 
BEGIN
  init;
  if not Active and (paramstr(1)='tsr') then begin
    GetIntVec($9,@KbdIntVec);
    SetIntVec($9,Addr(Activate));
    Keep(0); { Terminate, stay resident }
  end;
  run;
  done;
END.

VIDEO.INC

Line number On/Off | Expand/Contract | Select all

function GetVideoMode:byte;assembler;
asm
  mov ah,$0f
  int $10
end;
 
function GetVideoSeg:word;
var
  mode: shortint;
begin
  asm
    mov ah,$0f
    int $10
    mov byte ptr mode,al
  end;
  case mode of
    1..6,8..9 : getvideoseg := $b800;
    -2,7,10   : getvideoseg := $b000;
  else getvideoseg := $a000;
  end;
end;
 
procedure clrscr;assembler;
asm
  mov ah,15
  int 10h
  mov ah,0
  int 10h
end;
 
procedure scr_write(x,y:byte; var s:string);assembler;
asm
  mov ax,VideoSeg
  mov es,ax
  xor ax,ax
  mov al,160
  mul y
  xor bx,bx
  mov bl,x
  shl bx,1
  add ax,bx
  mov di,ax
  cld
  push ds
  lds si,s
  xor ax,ax
  lodsb
  mov cx,ax
@1:
  movsb
  inc di
  loop @1
  pop ds
end;
 
procedure MovScreen(Dest,Source:pointer);assembler;
asm
  push ds
  mov cx,2000
  cld
  lds si,Source
  les di,Dest
  rep movsw
  pop ds
end;
 
procedure scr_Fill(fill,attr:byte);assembler;
asm
  mov cx,2000
  mov ax,VideoSeg
  mov es,ax
  xor di,di
  mov al,fill
  mov ah,attr
  cld
  rep stosw
end;
 
procedure scr_CopyCol(scr1,scr2,col1,col2:word);assembler;
asm
  { load segment of screen1 (destination) }
  mov ax,scr1
  mov es,ax
  { load offset }
  mov di,col1
  shl di,1
  { load segment of screen2 (source) }
  mov ax,scr2
  push ds
  mov ds,ax
  { load offset }
  mov si,col2
  shl si,1
  { go copy }
  mov cx,25
  cld
@1:
  movsw
  add si,160-2
  add di,160-2
  loop @1
  pop ds
end;
 
procedure scr_asmLeftScroll(scr:word);assembler;
asm
  push ds
  mov ax,scr
  mov ds,ax
  mov es,ax
  xor di,di
  mov si,2
  mov cx,25*80-1
  cld
  rep
  movsw
  pop ds
end;
 
procedure scr_asmRigthScroll(scr:word);assembler;
asm
  push ds
  mov ax,scr
  mov ds,ax
  mov es,ax
  mov di,25*160
  mov si,25*160-2
  mov cx,26*80-1
  std
  rep movsw
  pop ds
end;
 
procedure Delay(ms:word);
var x:longint;
begin
  { de fapt 55*ms milisecunde }
  x:=meml[0:$46c] + ms;
  repeat until (x <= meml[0:$46c]);
end;
 
procedure scr_LeftScroll(scr1,scr2:word);
var i,j:word;
begin
  for i:=0 to 80-1 do begin
    scr_asmLeftScroll(scr1);
    scr_CopyCol(scr1,scr2,79,i);
    {Delay(1);{}
  end;
end;
 
procedure scr_RigthScroll(scr1,scr2:word);
var i:word;
begin
  for i:=80-1 downto 0 do begin
    scr_asmRigthScroll(scr1);
    scr_CopyCol(scr1,scr2,0,i);
  end;
end;

CUSOR.INC

Line number On/Off | Expand/Contract | Select all

function wherex:byte;assembler;
asm
    push    ds
    xor ax,ax
    mov ds,ax
    mov si,462h
    lodsb
    mov si,450h
    shl ax,1
    add si,ax
    lodsb
    pop ds
end;
 
function wherey:byte;assembler;
asm
    push    ds
    xor ax,ax
    mov ds,ax
    mov si,462h
    lodsb
    mov si,450h
    shl ax,1
    inc ax
    add si,ax
    lodsb
    pop ds
end;
 
procedure gotoxy(x,y:byte);assembler;
asm
    push    ds
    xor ax,ax
    mov ds,ax
    mov bh,[462h]
    mov dl,[bp+6]
    mov dh,[bp+4]
    mov ah,2
    int 10h
    pop ds
end;

KEY.INC

Line number On/Off | Expand/Contract | Select all

procedure waitkey;assembler;
asm
  push ds
  xor ax,ax
  mov ds,ax
  mov al,[$041a]
  mov [$041c],al
  pop ds
  int $16
end;
 
function keypressed:boolean;assembler;
asm
  push ds
  xor ax,ax
  mov ds,ax
  mov al,[41ah]
  cmp al,[41ch]
  jz @0
  mov al,1
  jmp @1
@0:
  mov al,0
@1:
  pop ds
end;
 
function readkey:char;assembler;
asm
  mov ah,0
  int 16h
end;
 
procedure extendedkey(var e,k:byte);assembler;
asm
  mov ah,0
  int 16h
  les di,[bp+4]
  stosb
  les di,[bp+8]
  mov al,ah
  stosb
end;
 
procedure ZipSound(zip,final:word);assembler;
asm
    IN  AL,61h
    OR  AL,0003
    OUT 61h,AL
    MOV AL,0090h
    OUT 43h,AL
    MOV AX,0002
@1: OUT 42h,AL
    MOV CX,zip       {0210h}
    SUB CX,AX
@2: loop    @2
    ADD AL,02
    JNZ @1
    SUB AL,04
@3: OUT 42h,AL
    MOV CX,final     {0114h}
@4: loop    @4
    SUB AL,4
    JNZ @3
    IN  AL,61h
    AND AL,0FCh
    OUT 61h,AL
end;

SCAN.INC

Line number On/Off | Expand/Contract | Select all

function scan_str(segment:word; var str:string; var offs_match:word):boolean;assembler;
var
  lungime:byte;
  ofs_str:word;
  sav_si :word;
asm
  push ds
  les di,str
  mov al,es:[di]
  mov lungime,al
  xor dx,dx
  mov dl,al
  inc di
  mov ofs_str,di
  mov ax,segment
  mov ds,ax
  xor si,si
  cld
  mov cx,$FFF0
@restore:
  mov bl,es:[di]
  inc di
  dec dl
  xor bl,$55
  and bl,$DF
@continua:
  lodsb
  and al,$DF
  cmp al,bl
  jz @found
  loop @continua
@out:
  xor ax,ax
  jmp @end
@found:
  mov sav_si,si
  or dl,dl
  jz @match
  mov bl,es:[di]
  xor bl,$55
  and bl,$DF
  inc di
  dec dx
  lodsb
  and al,$DF
  cmp al,bl
  jz @found
  mov di,ofs_str
  mov si,sav_si
  xor dx,dx
  mov dl,lungime
  jmp @restore
@match:
  mov ax,si
  sub al,lungime
  sbb ah,0
  les di,offs_match
  stosw
@end:
  pop ds
end;
 
procedure XorStr(var str:string);assembler;
asm
  push ds
  lds si,str
  les di,str
  cld
  lodsb
  inc di
  xor cx,cx
  mov cl,al
@1:
  lodsb
  xor al,$55
  stosb
  loop @1
  pop ds
end;
 
procedure SecureReadStr(var str:string);
var
  count:byte;
  key:char;
begin
  for count:=0 to 255 do str[count]:=#0;
  count:=0;
  repeat
    key:=readkey;
    if key=#27 then begin str:=''; exit; end;
    if (key in [#32..#126]) and (count<20)
    then begin
      inc(count);
      str[0]:=char(count);
      str[count]:=key;
      write(key);
    end else if (key=#8) and (count>0) then begin
      dec(count);
      str[0]:=char(count);
      write(#8,'ů',#8);
    end else if key<>#13 then write(#7);
  until key=#13;
  XorStr(str);
end;
 
procedure add_dw_w(var x:dword; source:word);assembler;
asm
  mov ax,source
  les di,x
  add es:[di],ax
  jnc @exit
  inc word ptr es:[di+2]
@exit:
end;
 
procedure scan;
var x,y,z:byte;
    b:dword;
    ofs:word;
    s:string[22];
begin
  b.h:=0;
  x:=wherex; y:=wherey;
  b.l:=p+1;
  if not again then begin
    b.l:=p;                                  { incepe cu paragraful curent }
    scr_fill(176,scr_attr);
    s:='Enter a string:'; scr_write(28,10,s);
    s:='[ůůůůůůůůůůůůůůůůůůůů]'; scr_write(28,12,s);
 
    gotoxy(29,12);
    SecureReadStr(str);
  end;
  if str<>'' then begin
    scr_fill($20,scr_attr);
    s:='Searching...'; scr_write(33,12,s);
    while b.h=0 do begin
      if scan_str(b.l,str,ofs) then begin
        p := b.l + ofs div 16;
        x :=  64 + ofs mod 16;
        ZipSound($210,$114);
        gotoxy(x,0); exit;
      end;
      add_dw_w(b,$ff0);
    end;
    gotoxy(33,12); write('NOT FOUND ! '); waitkey;
  end;
  gotoxy(x,y);
end;

MEMORY.INC

Line number On/Off | Expand/Contract | Select all

procedure WritePara(source,dest:pointer);assembler;
asm
  cld
  push ds
  lds  si,source
  mov  dx,ds
  mov  bx,si
  les  di,dest
  mov  ax,es
  mov  al,'['
  stosb
  inc  di
  shl  bx,1
  shl  bx,1
  shl  bx,1
  shl  bx,1
  add  dx,bx
  mov  al,'0'
  stosb
  inc  di
  stosb
  inc  di
  stosb
  inc  di
  mov  al,dh
  call @store
  mov  al,dl
  call @store
  mov  al,'0'
  stosb
  inc  di
  mov  al,']'
  stosb
  inc  di
  mov  cx,$0010
@hexpara:
  mov  dx,cx
  mov  al,' '
  stosb
  inc  di
  shr  dx,1
  jc   @unspatiu
  shr  dx,1
  jc   @unspatiu
  stosb
  inc  di
@unspatiu:
  lodsb
  call @store
  loop @hexpara
  mov  al,' '
  stosb
  inc  di
  stosb
  inc  di
  sub  si,$10
  mov  cx,$0010
@asciipara:
  movsb
  inc  di
  loop @asciipara
  jmp  @return
@store:
  mov  ah,al
  shr  al,1
  shr  al,1
  shr  al,1
  shr  al,1
  call @qbit
  mov  al,ah
  and  al,$0f
@qbit:
  add  al,'0'
  cmp  al,'9'
  jbe  @cifra
  add  al,$07
@cifra:
  stosb
  inc  di
  ret
@return:
  pop ds
end;
 
procedure asmWriteFull(source:word);assembler;
asm
  mov ax,VideoSeg
  mov es,ax
  xor di,di
  push ds
  mov ax,source
  mov ds,ax
  xor si,si
  mov cx,80*25
  cld
@1:
  movsb
  inc di
  loop @1
  pop ds
end;
 
procedure WritePage;
var i:word;
begin
  if not scr_full_mode
  then begin
    for i:=0 to 24 do
    WritePara( Ptr(P+I,0), Ptr(VideoSeg,I*160) );
  end
  else asmWriteFull(P);
end;
 
procedure Mcb;
var x:word;
    id:char;
begin
  if (firstMCB) or (urmMCB=0) then begin
    firstMCB:=false;
    asm
      mov ah,$52
      int $21
      mov ax,es:[bx-2];
      mov x,ax
    end;
    P:=x;
    asm
      mov ax,x
      mov es,ax
      mov ax,es:[$0003]
      mov x,ax
    end;
    urmMCB:=P+x+1;
    exit;
  end;
  P:=urmMCB;
  x:=urmMCB;
  asm
    push ds
    mov ax,x
    mov ds,ax
    mov ax,[$0003]
    add x,ax
    mov al,[$0000]
    mov id,al
    pop ds
  end;
  urmMCB:=x+1;
  if upcase(id)='Z' then urmMCB:=0;
end;
 
procedure DTA;
var x:word;
begin
  asm
    mov ah,$2f
    int $21
    shr bx,1
    shr bx,1
    shr bx,1
    shr bx,1
    mov ax,es
    add ax,bx
    mov x,ax
  end;
  P:=x;
end;
 
procedure writeInt(x,y:byte;i:word);
const h:array[0..15] of char = '0123456789ABCDEF';
var v,w:word;
begin
  gotoxy(x,y);
  write('Int',h[i shr 4],h[i and $0f],' ');
  v:=memw[$0:i*4];
  w:=memw[$0:i*4+2];
  write(h[hi(w) shr 4],h[hi(w) and $0f],
        h[lo(w) shr 4],h[lo(w) and $0f],':',
        h[hi(v) shr 4],h[hi(v) and $0f],
        h[lo(v) shr 4],h[lo(v) and $0f]);
  writeln;
end;
 
procedure Interrupts;
var i:word;
    x,y:byte;
    p:word;
begin
  x:=0; y:=0;
  scr_Fill($20,scr_attr);
  gotoxy(0,0);
  write('Intreruperi suspecte:');
  for i:=0 to $90 do begin
    p:=memw[0:i*4+2];
    p:=p + memw[0:i*4] div 16;
    if (p>0) and ((p<$0052) or (p>$8000)) and (p<$C800)
    then begin
      inc(y);
      if y>22 then begin x:=x+17; y:=1; end;
      writeInt(x,y,i);
    end;
  end;
  gotoxy(70,0); write('Ram ',memw[0:$413],'K');
  gotoxy(0,23); write('Press any key to continue...'); waitkey;
  gotoxy(12,0);
end;
 
procedure left;
var x:byte;
begin
  x:=wherex;
  if x>12 then
  if x>64 then gotoxy(wherex-1,0)
  else begin
    if ((x+1) mod 13)=0
    then gotoxy(x-3,0)
    else if (((x+1) mod 13) mod 3)=0
         then gotoxy(x-2,0)
         else gotoxy(x-1,0)
  end;
end;
 
procedure right;
var x:byte;
begin
  x:=wherex;
  if x<79 then
  if x>63 then gotoxy(wherex+1,0)
  else begin
    if ((x-9) mod 13)=0
    then gotoxy(x+3,0)
    else if ((((x-9) mod 13)-1) mod 3)=0
     then gotoxy(x+2,0)
     else gotoxy(x+1,0)
  end;
end;
 
procedure tab;
var x:byte;
begin
  x:=wherex;
  if x<64 then begin
    x:=64+4*((x-12) div 13)+((x-12) mod 13) div 3;
  end else begin
    x:=12+((x-64) div 4)*13+((x-64) mod 4)*3;
  end;
  gotoxy(x,0);
end;
 
procedure writetoram(c:byte);
var x,d,i,j:byte; ofs:word;
begin
  x:=wherex;
  if x<64 then begin
    if ((c>=48) and (c<=57)) or
       ((c>=65) and (c<=70)) or
       ((c>=97) and (c<=102)) then begin
    if c<58 then i:=c-48 else i:=(c and $DF)-55;
    ofs:=4*((x-12) div 13)+((x-12) mod 13) div 3;
    d:=((x-12) mod 13) mod 3;
    j:=byte(ptr(p,ofs)^);
    if d=0
    then byte(ptr(p,ofs)^):=(j or $F0) and ((i shl 4) or $0F)
    else byte(ptr(p,ofs)^):=(j or $0F) and (i or $F0);
    if j<>byte(ptr(p,ofs)^) then
    if x=61 then begin
      inc(p); gotoxy(12,0);
    end else right;
  end
  end else begin
  byte(ptr(p,x-64)^):=c;
  if byte(ptr(p,x-64)^)=c then
  if x=79 then begin
    inc(p); gotoxy(64,0);
  end else right;
  end;
end;
 
procedure writemsg;
var x,y:byte;
    write_mode:boolean;
begin
  x:=wherex; y:=wherey;
  scr_Fill($20,scr_attr);
  gotoxy(30,12); write('I LIKE HACKING !'); WaitKey;
  gotoxy(x,y);
  write_mode:=true;
  repeat
    WritePage;
    extendedkey(x,y);
    case y OF
      27: write_mode:=false;
      09: tab;
      00: case x of
        80 : INC(P);       {DN}
        72 : DEC(P);       {UP}
        77 : right;
        75 : left;
        73 : P:=P-$19;     {PgUp}
        81 : P:=P+$19;     {PgDn}
        132: P:=P-$190;    {^PgUp}
        118: P:=P+$190;    {^PgDn}
      end;
      else writetoram(y);
    end;
  until not write_mode;
  x:=wherex; y:=wherey;
  scr_Fill($20,scr_attr);
  gotoxy(28,12); write('Back to read only mode'); waitkey;
  gotoxy(x,y);
end;
 
procedure MemoryMap;
begin
  scr_Fill($20,scr_attr);
 
  waitkey;
end;

MVIEW.DOC

Memory Viewer version 1.7
(c) by EmiSoft

Deplasare cusor: Left,Right,Tab

Deplasare la adesa:
Up, PgUp,Home,^PgUp - o linie, o pagina, adresa 0, mai repede in sus.
Down,PgDn,End, ^PgDn - o linie, o pagina, ultima adresa, mai repede.
0,1,..,9,A,B,..,F - deplasare la adresa x0000

SpaceBar = FULL Page

Esc = EXIT !

Special:
--------
I = Interrupts ( de obicei virusii se incarca la 9Fxx:xxxx )
S = Search string
G = Search aGain
^W = Write mode
M = Memory Control Block
T = Current Disk Transfer Address
$ = Current Stack Zone
# = DS
@ = CS:IP

Rezident:
---------
Comanda: MVIEW tsr

Activare = Shift LEFT + Shift RIGHT

VIRUS.DOC

Am scris acest program special pentru a detecta mai usor virusii din memorie.

Reguli important de retinut !
-----------------------------

1. Un virus se activeaza DOAR ATUNCI cind este EXECUTAT (cu mai mult sau mai
putina voie a dvs.!!!) adica:
- executie MBR infectat ( MBR contine cod executabil )
- BOOT infectat
- fisier infectat

2. Un virus nu poate fi activ in memorie decit daca are cel putin o
intrerupere redirectata spre el.

Intreruperile frecvent "mincate" sunt:
08 - IRQ0 = System Timer (se apeleaza automat la fiecare 55ms)
09 - IRQ1 = Keyboard (se apeleaza la fiecare actionare a vreunei taste)
13 - Disk (BIOS)
1C - User Timer Tick (la fiecare 55ms)
21 - DOS Functions
25 - Absolute Disk Read
26 - Absolute Disk Write

Bineinteles ca mai pot fi si altele.

In continuare voi folosi adresa fizica memoriei.
Este o adresa pe 20 de biti si se calculeaza astfel:

AdrFizica = Segment*16 + Offset.

Locul de incarcare al unui virus (Adresa fizica) :

00200..00400 Chiar in vectorii de inreruperi !!!
Exepmlu: Tiny178

9F000..A0000 Marea majoritate se copiaza aici.

A0000..C8000 Pot fi si aici, daca nu i-am intilnit nu inseamna ca nu exista.

Chestiuni picante
------------------
Dark Avenger
SCANEAZA BIOS-ul !!! (de la C8000 in colo) si gaseste adresa pentru int13.
Bineinteles ca are nevoie totusi de o intrerupere ca sa se activeze.
Foloseste int21

AI
Se copiaza tot la 9Fxxx dar pacaleste cautatorul neexperimentat
pentru ca redirecteaza intreruperile mai intii la
004F0..004FF zona BIOS pentru programe utilizator.

Cum se scapa de virusi
----------------------

Intotdeauna trebuie o discheta (CURATA) de salvare! Altfel ...
Care sa contina:
1. Sistemul de operare
2. FORMAT
3. SYS
4. FDISK
5. Un antivirus

Ce trebuie facut ?
------------------
1. Porniti sistemul de pe discheta.
Si NU executati nimic de pe hard!
2. FDISK /MBR - elimina virusii care se instaleaza in MBR
3. SYS c: - elimina virusii din BOOT
4. Lansati antivirusul sa caute executabile infectate.
5. Ultima solutie: FORMAT c: /s - distruge tot.

ATENTIE!
NU formatati hard-ul aiurea!
Doar cu FORMAT nu se elimina toti virusii.

Sursele si executabilul le gasiti in atasament.

P.S.: Acest program a fost publicat si pe alt site.

BitCell

MSDOS Memory Viewer: mview

MSDOS Memory Viewer: mview

Who is online