Criando um vírus

Vírus são horríveis criações que foram escritas para se multiplicarem e destruírem os sistemas de idiotas incautos. Isso elimina dos sistemas todos os simplesões que não acham um problema quando um arquivo de 100 bytes transforma-se em um de 1000 bytes. Bah, esses imbecis não deveriam existir, sendo assim, é nosso trabalho sagrado varrer os discos rígidos deles da face da terra. É apenas uma questão de sobrevivência do mais forte.

Depois de escrever muitos vírus, eu fiquei sabendo que os criadores de virus geralmente aprendem a criar virus atraves dos seus próprios vírus ou ao examinar o codigo dessassemblado de outros vírus. Existe uma falta incrível de informação no assunto. Mesmo livros publicados por grandes nomes tal como Burger, não mostram como são criados os vírus. Esse guia irá mostrar a você como criar um vírus e também irá dar a você um monte de códigos fontes para incluir em seu próprio vírus.

Criar vírus não é tão difícl como você deve estar imaginando. Para escrever um vírus efetivo, entretanto, você *deve* conhecer a linguagem assembly. Pequeno, código compacto são marcas registradas da linguagem assembly e essas são características desejáveis dos vírus. Entretanto, *não* é necessário escrever em puro assembler. Também pode ser usado, uma vez que ele permite quase controle total no sistema enquanto gera código relativamente compacto (se você ficar longe das bibliotecas de funções). Entretanto, você deverá acessar as interrupções, assim conhecimento em assembly continua necessário. Entretanto, ficar no assembly puro é melhor, uma vez que muitas operações são mais facilmente codificadas em assembly. Se você não conhece assembly, eu recomendo pegar uma cópia da Bíblia Microsoft de Macro Assembler (Nabajyoti Barkakati, ISBN #: 0-672-22659-6). É um livro simples de seguir cobrindo o assembly com muitos detalhes. Também pegar uma cópia de Undocumented DOS (Schulman, et al, ISBN #0-201-57064-5), também seria muito útil.

A questão de qual compilador usar também é difícil. Eu sugiro usar o Borland Turbo Assembler e/ou Borland C++. Eu não tenho uma cópia do Zortech C, mas eu acho que ele é uma boa escolha. Fique longe dos compiladores Microsoft, uma vez que eles não são tão flexíveis nem eficientes como aqueles dos outros fabricantes.

Um pouco mais de itens rondam a lista de ferramentas que ajudam na construção de vírus. As últimas versões do Norton Utilities são uns dos programas mais poderosos disponíveis, e são imensamente necessários. TENHO CERTEZA QUE VOCÊ TENHA UMA CÓPIA! Você pode encontrar isso em qualquer BBS decente. O Norton é usado em cada passo do processo, da escrita até o teste. Bons helps sobre debugger. Utilitários de controle de memória tais como MAPMEM, PMAP, e MARK/RELEASE, são utilitários sem valor, especialmente quando criando vírus TSR. Sourcer, o dissassemblador comentado, é útil para examinar o código de outros vírus (esse é um bom lugar para pegar idéias/técnicas para seu vírus).

Agora que você tem suas ferramentas, você está pronto para criar um trabalho de arte criado para esmagar os sistemas dos cretinos. Existem três tipos de vírus:

1) Vírus pequenos (abaixo dos 500 bytes) que são feitos para serem indetectáveis devido ao seu pequeno tamanho. TINY é um desses vírus. Eles são geralmente muito simples devido ao fato que seu tamanho é muito limitado.

2) Vírus Grandes (acima dos 1,500 bytes) que são feitos para ser indetectáveis devido ao fato que eles cobrem seu rastro muito bem (todo aquele código SERVE para algo!). O melhor exempho desse é o vírus Whale, que é talvez o melhor vírus 'Stealth' atualmente.

3) Outros vírus que não são feitos para serem escondidos totalmente (os escritores não ligam para isso). Os vírus comuns são como esses. Todos os vírus que sobreescrevem estão nessa categoria.

Você deve decidir que tipo de vírus você irá escrever. Eu irei tratar mais do segundo tipo (Vírus Stealth). Entretanto, muitas das técnicas descritas podem ser facilmente aplicadas para o primeiro tipo (vírus pequenos). Entretanto, os vírus pequenos geralmente não tem muitas das "qualidades" dos vírus maiores, tais como diretórios transversal. O terceiro tipo é mais um tipo de replicação de caválo de tróia, e irá garantir uma rápida (muito, muito rápida!) discussão mais tarde.

Um vírus pode ser dividido em três partes: a replicação, a camuflagem, e a bomba. A parte replicadora controla a multiplicação do vírus para outros arquivos, a camuflagem evita o vírus de ser encontrado, e a bomba apenas executa quando a condição de ativação do vírus (entenda sobre isso mais tarde) são satisfeitas.

Replicação

O trabalho para a replicação é o de multiplicar o vírus através do sistema do cara que pegou o vírus. Como fazer isso sem destruir os arquivos que ele infecta? A forma mais fácil de fazer esse tipo de replicação é através da infecção de arquivos COM. Ele primeiro salva os primeiros bytes do arquivos infectado. Depois ele copia uma pequena parte de seu código para o início do arquivo, e o resto para o fim.

+----------------+ +------------+
| P1 | P2 | | V1 | V2 |
+----------------+ +------------+
Arquivo normal. O código do vírus

No diagrama, P1 é a parte 1 do arquivo, P2 é a parte 2 do arquivo, e V1 e V2 são as partes 1 e 2 do vírus. Note que o tamanho de P1 deve ser o mesmo do que o tamanho de V1, mas o tamanho de P2 não deve ser necessariamente o mesmo de V2. O primeiro vírus salva P1 e copia ele para: 1) O fim do arquivo ou 2) dentro do código do vírus. Vamos assumir que ele copia o código para o fim do arquivo. Esse arquivo agora está assim:

+---------------------+
| P1 | P2 | P1 |
+---------------------+

Então, o vírus copia a primeira parte de si próprio para o início do arquivo.

+---------------------+
| V1 | P2 | P1 |
+---------------------+

Finalmente, o vírus copia a segunda parte de si próprio para o fim do arquivo. A cópia final, o arquivo infectado fica parecendo assim:

+-----------------------------+
| V1 | P2 | P1 | V2 |
+-----------------------------+

A questão é: Que diabos fazem V1 e V2? V1 transfere o controle do programa para V2. O código para fazer isso é simples:

JMP FAR PTR Duh ; Takes four bytes
Duh DW V2_Start ; Takes two bytes

Duh é um far pointer (Segmento:Offset) apontando para a primeira instrução de V2. Note que o valor de Duh deve ser modificado para refletir o tamanho do arquivo que está infectado. Por exemplo, se o tamanho original do programa é 79 bytes, Duh pode ser modificado assim a instrução em CS:[155h] é executada. O valor de Duh é obtido ao acrescentar o tamanho de V1, o tamanho original do arquivo infectado, e 256 (para contar para o PSP). Nesse caso, V1=6 e P1 + P2 = 79, assim 6 + 79 + 256 = 341 decimal (155 hex).

Um método alternado, muito mais difícil de entender segue-se:

DB 1101001b ; Código para o JMP (deslocamento de 2 bytes)
Duh DW V2_Start - OFFSET Duh ; deslocamento de 2 bytes

Isso insere o offset jump diretamente no código seguido da instrução jump. Você também pode
trocar a segunda linha com:

DW V2_Start - $

que faz a mesma tarefa.

V2 contém o resto do código,e é o código que faz todo o resto. A última parte de V2 copia P1 sobre V1 (na memória, não no disco) e então transfere o controle para o início do arquivo (na memória). O programa original então roda feliz como se nada tivesse acontecido. O código para fazer é muito simples.

MOV SI, V2_START ; V2_START é um rótulo marcando onde V2 inicia
SUB SI, V1_LENGTH ; Volta atrás para onde P1 está armazenado
MOV DI, 0100h ; Todos os arquivos COM são carregados @ CS:[100h] na memória
MOV CX, V1_LENGTH ; Move CX bytes
REP MOVSB ; DS:[SI] -> ES:[DI]

MOV DI, 0100h
JMP DI

Esse código assume que P1 está localizado logo após V2, como aqui:

P1_Stored_Here:
.
.
.
V2_Start:

Isso também assume ES igual a CS. Se essas instruções são falsas, mude o código de acordo.
Aqui vai um exemplo:

PUSH CS ; armazena CS
POP ES ; e move isso para ES
; Note MOV ES, CS não é uma instrução válida
MOV SI, P1_START ; Move de onde P1 está armazenado
MOV DI, 0100h ; para CS:[100h]
MOV CX, V1_LENGTH
REP MOVSB

MOV DI, 0100h
JMP DI

Esse código primeiro move CS para ES e então seta o pointer fonte de MOVSB para onde P1 está localizado. Lembre-se que isso tudo está pegando lugar na memória, assim você precisa o OFFSET de P1, não apenas a localização física do arquivo. O offset de P1 é 100h maior do que a localização física do arquivo, uma vez que arquivos COM são carregados a partir de CS:[100h].

Assim aqui está um sumário das partes do vírus e localização dos rótulos:

V1_Start:
JMP FAR PTR Duh
Duh DW V2_Start
V1_End:

P2_Start:
P2_End:

P1_Start:
; Primeira parte do programa armazenado aqui para uso futuro
P1_End:

V2_Start:
; Programa Real
V2_End:

V1_Length EQU V1_End - V1_Start

Alternativamente, você pode armazenar P1 em V2 como segue:

V2_Start:

P1_Start:
P1_End:

V2_End:

É isso esquema para infectar um arquivo COM sem destruir ele! Simples, não? Arquivos EXE, entretanto, são um pouco mais difíceis de infectar sem deixar eles inexecutáveis - Eu irei cobrir esse tópico em um arquivo mais tarde.

Agora nós iremos voltar nossa atenção para a porção replicadora do vírus.
Os passos são mostrados abaixo:

1) Encontrar um arquivo para infectar
2) Checar se ele já está infectado
3) Se sim, voltar para 1
4) Infectar ele
5) Se já infectou arquivos que chegam então sai.
6) Senão, volta para 1

Encontrar um arquivo para infectar é uma forma simples de escrever um procedimento de diretórios transversais e pode-se instruir chamadas FINDFIRST e FINDNEXT para encontrar arquivos possíveis para infectar. Uma vez que você encontra um arquivo, abra ele e leia os primeiros poucos bytes. Se eles são os mesmos que os primeiros bytes V1, então o arquivo já está infectado. Se o bytes de V1 não são exclusivos de seu vírus então mude ele assim eles serão. É *extremamente* importante que seu vírus não reinfecte os mesmos arquivos, uma vez que foi dessa forma que o Jerusalem foi detectado pela primeira vez. Se o arquivos não estava infectado, então infecte-o!
Infecção deverá ter os seguintes passos:

1) Mudar os atributos do arquivo para nada.
2) Salvar a data/hora do arquivo.
3) Fechar o arquivo.
4) Abra ele de novo em modo de leitura/gravação.
5) Salve P1 e acrescente ele no fim do arquivo.
6) Copie V1 para o início, mas modifique o offset para onde ele JMPs (pula) assim ele
transfere o controle corretamente.
7) Anexar V2 no fim do arquivo.
8) Restaure atributos do arquivo e a data/hora.

Você pode manter um contador de número de arquivos infectados durante essa rodada. Se o número excede, digamos 3, então pare. É melhor infectar aos pouco do que se deixar descobrir ao tentar infectar todo o drive de uma vez só.

Você deve cobrir todos os seus rastros quando você infecta um arquivo. Salve os atributos do arquivo originais mais a data e hora e restaure eles quando você terminar. ISSO É MUITO IMPORTANTE! Isso pega 50 a 75 bytes de código, provavelmente menos, para fazer essas poucas coisas que fazem maravilhas na hora de esconder seu programa.

Eu irei incluir o código para a função de diretório transversal, assim como outras partes do replicador na próxima edição do meu Guia de Vírus.

Camuflando

Essa é a parte que camufla o programa para não ser encontrado pelo usuário de todo dia e pelos anti-vírus.
As forma mais simples de camuflagem é a encriptação.
O código para uma encriptação simples em XOR segue:

encrypt_val db ?

decrypt:
encrypt:
mov ah, encrypt_val

mov cx, part_to_encrypt_end - part_to_encrypt_start
mov si, part_to_encrypt_start
mov di, si

xor_loop:
lodsb ; DS:[SI] -> AL
xor al, ah
stosb ; AL -> ES:[DI]
loop xor_loop
ret

Note que os procedimentos de encriptação e desencriptação são as mesmas. Isso é devido a natureza louca do XOR. Você pode chamar (CALL) esses procedimentos de qualquer lugar no programa mas tenha certeza que não chame ele de um lugar de dentro da área a ser encryptada, pois o programa irá dar erros. Quando escrever o vírus, mude o valor de encriptação para 0. part_to_encrypt_start e part_to_encrypt_end indicam a parte que você deseja encriptar. Use uma chama decrypt no início de V2 para desencriptar o arquivo assim seu programa pode rodar. Quando Infectar um arquivo, primeiro mude o encrypt_val, depois chame encrypt, depois escreva V2 para o fim do arquivo, e chame decrypt. TENHA CERTEZA QUE ESSA PARTE NÃO ESTEJA NA ÁREA QUE VAI SER ENCRIPTADA!!!

Aqui está como V2 irá parecer com a camuflagem:

V2_Start:

Concealer_Start:
.
.
.
Concealer_End:

Replicator_Start:
.
.
.
Replicator_End:

Part_To_Encrypt_Start:
.
.
.
Part_To_Encrypt_End:
V2_End:

Alternativamente, você pode mover partes do código não-encriptado entre Part_To_Encrypt_End e V2_End.

O valor da encriptação é somente aparente. Encriptação torna a tarefa dos anti-vírus difícil para encontrar seu vírus. Ele também esconde algumas cadeias de textos localizadas em seu programa. Esta é a forma mais fácil e curta de esconder seu vírus.

Encriptação é apenas uma forma de camuflar o vírus. Há vírus que alteram as interrupções do DOS e altera a saída de dados do DIR, assim os tamanhos do arquivo aparecem normais. Outra forma de camuflar (Para vírus TSR) é alterar o DOS assim utilitários de memória não detectam o vírus. Carregar o vírus em certas partes da memória permitem que eles sobrevivam a um reboot. Existem muitas técnicas de camuflagem do vírus, limitadas apenas pela imaginação do escritor.

A bomba

Bom, agora que toda a parte chata está feita. A coisa indecente está contida aqui. A parte do vírus que faz todas as deleções/slowdown/etc que deixam os vírus tão incomodáveis. De alguma condições de ativação para o vírus. Isso pode ser qualquer coisa, indo da data de seu aniversário até quando o vírus infectou 100 arquivos. Quando essas condições se concretizam, então o seu vírus executa a bomba. Alguma sugestões de bombas possíveis:

1) Deixar o sistema mais lento - facilmente feito ao capturar uma interrupção e causar um delay quando ela ativa.
2) Deleção de arquivos - Deletar todos os arquivos ZIP do drive.
3) Mostrar messagens - Mostrar uma messagem legal tipo dissendo algo de mesmo efeito de: "Você está fodido"
4) Apagar/Trocar as tabelas de partição/Setor de Boot/FAT do disco rígido - isso é muito mal, e muitos idiotas não conseguem arrumar isso.

Esse é, com certeza, a parte engraçada de escrever um vírus, então seja original!

Problemas com o Offset

Existe um problema no cálculo de offsets. Depois de você infectar um arquivos, os locais das variáveis mudam. Você TEM que contar isso. Todos offsets relativos podem ficam o mesmo, mas você tem que acrescentar o tamanho do arquivo para os offsets absolutos ou seu programa não vaifuncionar. Essa é a parte mais complicada ao escrever o vírus e levar isso em conta irá aumentar grandemente o tamanho do vírus. ISSO É MUITO IMPORTANTE E VOCÊ DEVE ESTAR ENTENDENDO ISSO ANTES DE TENTAR ESCREVER UM QUE NÃO SOBREESCREVE OS PROGRAMAS! Se você não o fizer, você vai se fuder e o seu vírus NÃO VAI TRABALHAR! Uma parte inteira desse guia vai ser devotado para esse problema.

Testando

Testar o vírus é uma parte perigosa mas essential no processo de criação de vírus. É para se ter certeza que pessoas *irão* ser prejudicadas pelo vírus. Teste-o em todas as condições e tenha certeza que ele ativa-se dentro das condições. Isso pode ser me melhor feito se você ou algum amigo tiver um segundo computador para testas o vírus, mas, é claro, esse não é o nosso caso. Assim, é ESSENCIAL que você mantenha cópias de segurança de seus arquivos, partição, boot record, e FAT. Norton é ótimo em fazer isso. Nao esqueça esse aviso porque você SERÁ atingido pelo seu próprio vírus. Quando eu fiz me primeiro vírus, meu sistema foi abaixo por dois dias porque eu não tinha boas cópias de segurança. Com sorte, o vírus não era muito destrutivo. Eu encontrei no RamDrive uma ótima forma de testar os vírus, uma vez que os danos não são permanente. RamDrive também é ótimo para testar Cávalos de Tróia, mas esse é um tópico para outro arquivo...

Distribuindo

Essa é outra parte interessante da escrita de vírus. Isso envolve enviar seu programa brilhantemente feito através das linha de telefone para a sua BBS local. O que você deve fazer é infectar um arquivo que faz algo interessante (pegue algum utilitário útil de outra BBS), infecte ele e dê um upload nele para o local onde ele será copiado por usuários de todo lugar. A melhor coisa que seu vírus tem é que ele não é detectado por anti-vírus idiotas como o da McAffee, uma vez que ele é novo! E é claro, tenha certeza que você está usando uma conta falsa (duh). Melhor ainda, crie uma conta false com o nome/número de telefone de alguém que você não goste e upload o arquivo infectado com o nome dele. Você pode ligar de volta de tempos em tempos e usar uma porta como a ZDoor para checar a multiplicação do seu vírus. Quantos mais copiaram seu vírus, mais compartilharam a experiência do seu vírus!

Eu prometi uma breve seção em vírus que sobreescrevem programas, assim, aqui esta ela...

Tudo o que esse vírus faz é espalhar-se pelo sistema. Eles deixam os arquivos infectados inutilizados, assim eles são facilmente detectados. É muito simples fazer um:

+-------------+ +-----+ +-------------+
| Programa | + |Vírus | = |Vírus|ama |
+-------------+ +-----+ +-------------+

Esses vírus são pequenos, mas muito fáceis de serem detectados. Isso é o suficiente saber!

hackers