[Source] Projeto Honeypot.

[_Dr4k0_]

Code Select Expand

#include <stdio.h> // Biblioteca padrao de I.O de C
#include <stdlib.h> // Algumas funcões
#include <conio.h> // getch();
#include <windows.h> // Funções da api e sockets

/*
*****************************************************
*                    PROJETO HONEYPOT               *
*                 DESENVOLVIDO POR DEFCON           *
*             contato: defcon_four@hotmail.com      *
*            Forum recomendado: www.hackmode.com.br *
*****************************************************
*/

DWORD WINAPI FTP( LPVOID lpParam ) // Thread para emular o server FTP
{
      char msg[5000]; // Msg que alertara o adm e escrevera no log
      char com1[256], com2[256], com3[256], com4[256], com5[256]; // char's para guardarem os comandos executados,
      // que serao 5 ao todo
     
      char logado[]={"\n220---------- Welcome to Pure-FTPd [TLS] ----------" // Msg que dara um toque mais real
                    "\n220-You are user number 1 of 50 allowed."             // ao servidor FTP
                    "\n220-Local time is now 13:02.Server port: 21."          // basiei-me no Pure-FTPd
                    "\n220-IPv6 connections are also welcome on this server." // do qual nao lembro a versao
                    "\n220 You will be disconnected after 15 minutes of inactivy."};

      char bash[]="\n[root@anonymous root]# ";  // Uma shell pro cara ;)
      char not_found[]="\nComando desconhecido.\n"; // Por acaso todos os comandos nao serao reconhecidos =|
     
      SOCKET sock1, sock2;// declara dois sockets
     
      int SizeOfSocket=sizeof(struct sockaddr); // defini o tamanho da estrutura para o socket que ira receber

      label1: // label, isso é pouco usado, mas coloquei para que o server ficasse rodando o tempo todo
     
      sock1=socket(AF_INET,SOCK_STREAM,0); // configura o socket sock1
     
      struct sockaddr_in local, remote; // Declara duas estruturas LOCAL E REMOTA
      local.sin_port=htons(21); // configura porta como 21 -> ftp
      local.sin_addr.s_addr=INADDR_ANY; // recebe conexao de QUALQUER IP
      local.sin_family=AF_INET; // configura familia do socket como AF_INET
     
      struct servent* servico; // strutura SERVENT, da qual sera pega o nome do servico
      servico=getservbyport(htons(21),"tcp"); // pega o servico pela porta 21-> ftp tcp duhh =D
     
      bind(sock1,(struct sockaddr*)&local,sizeof(local));// 'binda' o sock sock1 com as informacoes da estrutura local
     
      listen(sock1,1); // coloca socke1 em escuta
     
      sock2=accept(sock1,(struct sockaddr*)&remote,&SizeOfSocket); // configura sock2 para receber conexao em sock1
     
      if(sock2<0) // se sock2 for menor que 0..
      { printf("\nImpossivel conectar\n"); } // imprime frase
      else// senao
      {
                 ZeroMemory(&com1,sizeof(com1));// zera com1
                 ZeroMemory(&com2,sizeof(com2));// zera com2
                 ZeroMemory(&com3,sizeof(com3));// zera com3
                 ZeroMemory(&com4,sizeof(com4));// zera com4
                 ZeroMemory(&com5,sizeof(com5));// zera com5
                 
                 /*
                 ===============================================================
                 O comando ZeroMemory geralmente não é usado para isto, foi
                 quase uma gambiarra =P mais funcionou
                 Obs: para que quando houvesse uma outra conexao, nao restassem
                 caracteres no buffer para serem impressos juntos ;)
                 ===============================================================
                 */
                 
                 
                 send(sock2,logado,sizeof(logado),0);// envia LOGADO
                 
                 send(sock2,bash,sizeof(bash),0);// envia BASH
                 recv(sock2,com1,sizeof(com1),0);// recebe comando 1
                 send(sock2,not_found,sizeof(not_found),0); // envia comando not found
                 
                 send(sock2,bash,sizeof(bash),0); // envia bash
                 recv(sock2,com2,sizeof(com2),0);// receve comando 2

                 
                 send(sock2,bash,sizeof(bash),0);// envia bash
                 recv(sock2,com3,sizeof(com3),0);// recebe comando 4

                 
                 send(sock2,bash,sizeof(bash),0);// envia bash
                 recv(sock2,com4,sizeof(com4),0);// recebe comando 4

                 
                 send(sock2,bash,sizeof(bash),0);// envia bash
                 recv(sock2,com5,sizeof(com5),0);// recebe comando 5
                 send(sock2,not_found,sizeof(not_found),0); // envia comando not found
                 
                 ZeroMemory(&msg,sizeof(msg)); // zera msg
                 sprintf(msg,"\n\nConexao logada:\t\t\t\t\nIp do atacante: %s\nPorta atacada: %d\nPorta do atacante: %d\nServico: %s\n\nComandos executados:\n[ bash ]# %s\n[ bash ]# %s\n[ bash ]# %s\n[ bash ]# %s\n[ bash]# %s",inet_ntoa(remote.sin_addr),ntohs(local.sin_port),ntohs(remote.sin_port),servico->s_name,com1,com2,com3,com4,com5);
                 /*
                 ===============================================================
                 Essa gingantesca linha ai em cima, não tem nada de monstruosa,
                 ela coloca em msg a seguinte msg:
                     
                     Conexao logada:
                     Ip do atacante: (ip do cara)
                     Porta atacada: (a porta do ftp 21)
                     Porta do atacante: ( de qual porta se originou o ataque)
                     Servido: FTP
                     
                     (
                     .
                     . Aqui os 5 comandos executados por ele
                     .
                     )
                 */
                     
                 closesocket(sock1); // fecha socket e conexao junto
                 closesocket(sock2); // fecha socket
                 
                 MessageBox(0,msg,"Honeypot Alert!!",MB_OK|MB_ICONWARNING); // da um alerta ao adm
                 
                 FILE *fp=fopen("Alerta_FTP.txt","ar+");// abre um arquivo chamado Alerta_FTP.txt
                 fprintf(fp,msg);// escreve a msg nele
                 fclose(fp);// e fecha
                 
                 goto label1;// volta para label1 para fazer tudo de novo
      }
      printf("\nServidor FTP finalizado =|\n"); // Se sair da estrutura finaliza o servidor
}; // Fim da thread FTP

DWORD WINAPI TELNET ( LPVOID lpParam )// thread TELNET
{
      char log1[256]; // char para receber login
      char senha1[256];  // char para receber senha
      char msg1[2000]; // para a msg do adm
     
      char logon_telnet[]="\nConectiva Linux 8"                  // Isto é só para dar um pouquinho mais de realismo
                          "\nKernel 2.6.5-63077cl (i686)\n";     // A versao 8 do conectiva, uma versao bem bugada,
                                                                 // mas o kernel atualizado
     
      char logim_telnet[]="\nLogim: "; // envia msg para receber logim
      char error_logim[]="\nUsuario invalido\nTente novamente mais tarde\n\n"; // envia Msg de error de login
      char senha_telnet[]="\nPassword: "; // envia msg para receber senha
     
      SOCKET telnet1, telnet2; // declara dois sockets, telnet1 e telnet2
      int SizeOFTelnet=sizeof(struct sockaddr); // integer para declarar tamanho da estrutura que ira receber conexao

      label2: // label 2
      struct servent* telnet; // estrutura servent para pegar servico da porta 23
      telnet=getservbyport(htons(23),"tcp"); // pega servico da porta 23
     
      telnet1=socket(AF_INET,SOCK_STREAM,0); // configura socket telnet1
     
      struct sockaddr_in tel_local, tel_remote; // declara duas estruturas sockaddr_in
      tel_local.sin_port=htons(23);// configura porta
      tel_local.sin_addr.s_addr=INADDR_ANY;// recebe conexao de qualquer ip
      tel_local.sin_family=AF_INET;// seta familia do socket como AF_INET
     
      bind(telnet1,(struct sockaddr*)&tel_local,sizeof(tel_local));//binda socket telnet1 com info de estrutura tel_local
     
      listen(telnet1,1);// coloca socket telnet1 em escuta
     
      telnet2=accept(telnet1,(struct sockaddr*)&tel_remote,&SizeOFTelnet);// configura socket telnet2 para receber conexao em telnet1
     
      if(telnet2<0)// se for menor que 0 entao...
      {
                   printf("\nImpossivel de conectar\n");//imprime frase
      }
      else// senao..
      {
                   ZeroMemory(&log1,sizeof(log1)); //zera log1
                   
                   ZeroMemory(&senha1,sizeof(senha1));// zera senha1

                   ZeroMemory(&msg1,sizeof(msg1));//zera msg1

                   
                   send(telnet2,logon_telnet,sizeof(logon_telnet),0);//envia logon_telnet
                   
                   send(telnet2,logim_telnet,sizeof(logim_telnet),0);// envia logim_telnet
                   recv(telnet2,log1,sizeof(log1),0);//recebe login para log1
                   send(telnet2,senha_telnet,sizeof(senha_telnet),0);//envia msg para receber senha
                   recv(telnet2,senha1,sizeof(senha1),0);// recebe senha
                   send(telnet2,error_logim,sizeof(error_logim),0);// envia msg de erro de login
                   
                   closesocket(telnet1);// fecha socket telnet1
                   closesocket(telnet2);// fecha socket telnet2
                   
                   sprintf(msg1,"\n\n->Conexao logada:\t\t\t\t\n\nIp do atacante: %s\nPorta atacada: %d\nPorta do atacante: %d\nServico: %s\n\nLogim usado: %s\nSenha usada: %s",inet_ntoa(tel_remote.sin_addr),ntohs(tel_local.sin_port),ntohs(tel_remote.sin_port),telnet->s_name,log1,senha1);
                   /*
                   ==> A linha acima faz o mesmo daquela explicada lá em cima ^^
                   */
                   MessageBox(0,msg1,"Honeypot Alert",MB_OK|MB_ICONWARNING); // envia msg para o admin
                   FILE *fp_tel=fopen("Alerta_TELNET.txt","ar+");// abre arquivo Alerta_TELNET.txt
                   fprintf(fp_tel,msg1);// escreve msg no arquivo
                   fclose(fp_tel);// fecha arquivo
                   
                   goto label2; // votla para label2
      }
     
      printf("\nServidor Telnet finalizado =|\n"); // se sair da estrutura da essa msg
};

DWORD WINAPI WEB(LPVOID lParam)//  thread WEb
{
      char com_web[256], msgweb[2048];// daus chars
     
     
      char shell[]="\n[user@localhost /srv/www/default/html]# "; // á suposta shell =D
     
      char com_no[]="\nComando invalido\n";// msg de comando invalido
     
      char perm[]="\n------------------- Bem vindo ao Apache -------------" // msg do servidor r
                  "\n- Este servidor foi modificado de acordo com as     -" // as permissoes
                  "\n- necessidades do administrador, por motivos de     -" // do servidor
                  "\n- seguranca voce só possue permissao para:          -" // setadas pelo
                  "\n- Fazer download e upload neste servidor.           -" // administrador
                  "\n- Obrigado pela colaboracao.                        -" // =D
                  "\n-----------------------------------------------------";
                 
      SOCKET l_web, re_web; // declara dois sockets
     
      labelweb: // declara labelweb
     
      l_web=socket(AF_INET,SOCK_STREAM,0);// configura socket l_web
      struct servent* serv_web;// estrutura servent
      serv_web=getservbyport(htons(80),"tcp"); // pega servico da porta 80
     
      struct sockaddr_in local_web, remote_web;//duas estruturas sockaddr_in
      local_web.sin_port=htons(80);//configura porta
      local_web.sin_addr.s_addr=INADDR_ANY;//recebe conexao de qualquer IP
      local_web.sin_family=AF_INET;// seta familia do socket como AF_INET
     
      bind(l_web,(struct sockaddr*)&local_web,sizeof(local_web)); // binda socket l_web com info de estrutura local_web
     
      listen(l_web,1);// coloca socket l_web em escuta
     
      int SizeWeb=sizeof(struct sockaddr); // tamanho da estrutura
      re_web=accept(l_web,(struct sockaddr*)&remote_web,&SizeWeb);// configura socket re_web para receber conexao em socket l_web
      if(re_web<0) // se for menor que 0...
      {
                  printf("\nImpossivel receber conexao");// mostra msg
      }
      else  // senao..
      {

                  ZeroMemory(&com_web,sizeof(com_web)); // zera com_web
                 
                  send(re_web,perm,sizeof(perm),0); // envia perm[]
                  send(re_web,shell,sizeof(shell),0); // envia 'shell'
                  recv(re_web,com_web,sizeof(com_web),0); // recebe comando
                  send(re_web,com_no,sizeof(com_no),0);// envia comando not found
                 
                  closesocket(re_web); // fecha socket re_web
                  closesocket(l_web); // fecha socket l_web
                 
                  sprintf(msgweb,"\n\n->Conexao logada:\t\t\t\t\n\nIp do atacante: %s\nPorta atacada: %d\nPorta do atacante: %d\nServico: %s\nComando usado: %s",inet_ntoa(remote_web.sin_addr),ntohs(local_web.sin_port),ntohs(remote_web.sin_port),serv_web->s_name,com_web);
                  /*
                  ==> MESMA COISA EXPLICADO NAS ACIMAS, pode haver algo de diferente mais é QUASE iguais
                  */
                 
                  FILE *fpweb=fopen("Alerta_web.txt","ar+"); // abre arquivo
                  fprintf(fpweb,msgweb);//escreve no arquivo
                  fclose(fpweb);//fecha arquivo
                 
                  MessageBox(0,msgweb,"Alerta Honeypot!!",MB_OK|MB_ICONWARNING);// da msg para o adm
                  goto labelweb; // volta para label
      }
     
};

DWORD WINAPI DNS_DOMAIN(LPVOID lParam) // thread do server DNS
{
      char mand[]="------------------------------------------------"     // MSG
                  "\n-              Servidor DNS                    -"   // E
                  "\n- Servidor privado, consultas à intranet local -"   // BLA BLA BLA
                  "\n----------------------------------------------"     // cansei =P
                  "\n\n\n";

      char msg[]="\nDesculpe, voce não possue autorização para consultas a" // MAIS
                 "\neste servidor, seu ip deve estar cadastrado em nosso  " // MSG =D
                 "\nBanco de Dados\n";
                 
       char msg_dns[2048];// msg do adm
       
       int SizeDns=sizeof(struct sockaddr);// tamanho da estrutura
     
     SOCKET d_sock, ns_sock;// declara dois sockets d_sock e ns_sock
     
     dnslabel:// dnslabel LABEL
     
     d_sock=socket(AF_INET,SOCK_STREAM,0);// configura socket
     
     struct servent* serv_dns;//estrutura servent
     serv_dns=getservbyport(htons(53),"tcp"); // pega servido da porta 53
     
     struct sockaddr_in dns_local, dns_remote; // duas estruturas sockaddr_in
     dns_local.sin_addr.s_addr=INADDR_ANY;// recebe conexao de qualquer ip
     dns_local.sin_port=htons(53);// configura porta 53
     dns_local.sin_family=AF_INET;// familia do socket AF_INET
     
     bind(d_sock,(struct sockaddr*)&dns_local,sizeof(dns_local)); // binda o socket com info da estrutura dns_local
     
     listen(d_sock,1);// coloca socket d_sock em escuta
     
     ns_sock=accept(d_sock,(struct sockaddr*)&dns_remote,&SizeDns);// configura para receber conexao em d_sock
     
     if(ns_sock<0)// se for menor que 0
     {
                  printf("\nImpossivel conectar( Dns ).");// imprime msg
     }
     else// senao
     {
                  send(ns_sock,mand,sizeof(mand),0);// envia mand
                  send(ns_sock,msg,sizeof(msg),0);//envia msg
                 
                  Sleep(800);// espera 800 mlseconds
                 
                  closesocket(d_sock); // fecha socket d_sock
                  closesocket(ns_sock);// fecha socket ns_sock
                 
                  sprintf(msg_dns,"\n\n->Conexao logada:\t\t\t\t\nIp do atacante: %s\nPorta atacada: %d\nPorta do atacante: %d\nServico: %s",inet_ntoa(dns_remote.sin_addr),ntohs(dns_local.sin_port),ntohs(dns_remote.sin_port),serv_dns->s_name);         
                  /*
                  ==> To cansando hein =D
                  */                 
                 
                  FILE *dnsfp=fopen("Alerta_dns.txt","ar+");//abre arquivo
                  fprintf(dnsfp,msg_dns);//escreve em arquivo
                  fclose(dnsfp);// fecha arquivo
                 
                  MessageBox(0,msg_dns,"Alert Honeypot",MB_OK|MB_ICONWARNING);// msg para adm
                  goto dnslabel;// volta para dnslabel
     }
};

DWORD WINAPI SSH(LPVOID lParam) // Thread do server SSH
{
     char log[2048]; // log lol =D
     
     char cript[]="\nThe authenticity of host can't br established.\n"
                  "\nRSa key fingerprint is ad:a1:76:c1:b1:70:b4:bf:0a:41:77:e1:e3:3b:ce:6f."
                  "\nAre you sure want to continue connecting now."; // msg duhh ^^


     char mand_login[]="\nLogin: "; // manda msg para receber login
     char logon[256];// recebe user do login
     
     char mand_senha[]="\nSenha: "; // manda msg para receber senha
     char senha[256];// recebe senha
     
     char root[]="\nPermission denied, please try again.\n"; // Permissao negada e bla bla bla
     
     int SizeOfSSH=sizeof(struct sockaddr); // tamanho da estrutura
     
     SOCKET ssh1, ssh2; // declara socket
     
     sshlabel: // declara label
     
     ssh1=socket(AF_INET,SOCK_STREAM,0);//configura socket ssh1

     struct sockaddr_in ssh_local, ssh_remoto;// declara duas estruturas sockaddr_in
     ssh_local.sin_addr.s_addr=INADDR_ANY;// recebe conexao de qualquer ip
     ssh_local.sin_port=htons(22);// porta 22
     ssh_local.sin_family=AF_INET;// configura familia do socket
     
     bind(ssh1,(struct sockaddr*)&ssh_local,sizeof(ssh_local)); // binda socket com as info da estrutura ssh_local
     
     listen(ssh1,1);//coloca socket
     
     ssh2=accept(ssh1,(struct sockaddr*)&ssh_remoto,&SizeOfSSH);
     // configura socket2 para receber conexao em socket 1
     
     if(ssh2<0)//se menor que 0
     {
               printf("\nImpossivel conectar");// dá a msg
     }
     else
     {

               ZeroMemory(&log,sizeof(log));// zera log
               ZeroMemory(&logon,sizeof(logon));//zera logon
               ZeroMemory(&senha,sizeof(senha));//zera senha
               
               
               send(ssh2,cript,sizeof(cript),0);// manda cript
               send(ssh2,mand_login,sizeof(mand_login),0);// manda mand_login
               recv(ssh2,logon,sizeof(logon),0);//recebe login
               send(ssh2,mand_senha,sizeof(mand_senha),0);//manda mand_senha
               recv(ssh2,senha,sizeof(senha),0);//recebe senha
               
               send(ssh2,root,sizeof(root),0);//manda error
               
               closesocket(ssh1);// fecha socket ssh1
               closesocket(ssh2);// fecha socket ssh2
               
               sprintf(log,"Ip: %s\nPorta atacada: %d\nPorta do atacante: %d\nServico: Ssh\nLogim usado: %s\nSenha usasda: %s",inet_ntoa(ssh_remoto.sin_addr),ntohs(ssh_local.sin_port),ntohs(ssh_remoto.sin_port),logon,senha);
               /*
               ==> eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee denovo =D
               */
               
               FILE *fp=fopen("Alert_SSH.txt","ar+");// cria arquivo
               fprintf(fp,log);// escreve arquivo
               fclose(fp);// fecha arquivo
               
               MessageBox(0,log,"Honeypot Alert!!",MB_OK|MB_ICONWARNING);// msg pro adm
               goto sshlabel;// volta pra sshlabel
     }
         
};//Fim de thread do server SSH

main() // main, funcao principal duhp
{
      WSADATA wData; // declara var WSADATA wData
      WSAStartup(MAKEWORD(2,2),&wData); // carrega dll v2.2
     
      HANDLE hThread[5];// 5 handles
      DWORD dwThreadId[5];// 5 dwords
     
      SetConsoleTitle("Defcon HoneyPot v 0.01");// seta titulo da janela
     
      hThread[1]=CreateThread(NULL,0,FTP,NULL,0x08000000,&dwThreadId[1]);//cria thread 1 do FTP
      hThread[2]=CreateThread(NULL,0,TELNET,NULL,0x08000000,&dwThreadId[2]); // cria thread 2 do TELNET
      hThread[3]=CreateThread(NULL,0,WEB,NULL,0x08000000,&dwThreadId[3]);// cria thread 3 do WEB
      hThread[4]=CreateThread(NULL,0,DNS_DOMAIN,NULL,0x08000000,&dwThreadId[4]); // cria thread 4 do DNS
      hThread[5]=CreateThread(NULL,0,SSH,NULL,0x0800000,&dwThreadId[5]);// cria threa 5 do SSH
     
      OpenThread(0x0010000L | 0x0001,TRUE,dwThreadId[1]); //
      OpenThread(0x0010000L | 0x0001,TRUE,dwThreadId[2]); //  Abre Threads como
      OpenThread(0x0010000L | 0x0001,TRUE,dwThreadId[3]); //  0x00100000L -> Sincronizar
      OpenThread(0x0010000L | 0x0001,TRUE,dwThreadId[4]); //  0x0001 -> Termina-lo
      OpenThread(0x0010000L | 0x0001,TRUE,dwThreadId[5]); //
     
     
      printf("\nVoce deseja deixar esta janela aberta( 1 ) ou fechala( 2 )?");
      int opc;
      printf("\nOpc: ");
      scanf("%d",&opc);
     
      /*
      Essa parte acima é só para pegar a opc relacionada a janela
      */
     
      if(opc==1)// se for opc 1 deixa janela aberta e se for pressionada qq tecla sai do honeypot
      {
               
                printf("\nPara Finalizar o programa basta apertar qualquer tecla.");
                getch();
      }
      else // senao minimiza e deixa em um loop infinito para nao sair do honeypot
      {
                HWND janela;
                janela=FindWindow(NULL,"HoneyPot v 0.01");
                ShowWindow(janela,SW_HIDE);
                while(1){ Sleep(50000); }   
      }
     
      TerminateThread(hThread[1],0); //
      TerminateThread(hThread[2],0); //
      TerminateThread(hThread[3],0); // TERMINA THREADS
      TerminateThread(hThread[4],0); //
      TerminateThread(hThread[5],0); //
     
      CloseHandle(hThread[1]); //
      CloseHandle(hThread[2]); //
      CloseHandle(hThread[3]); // FECHA HANDLES hThraed[1-5]
      CloseHandle(hThread[4]); //
      CloseHandle(hThread[5]); //
     
      return 0; // volta ao sistema
}
// FIM DO código
Segue algumas screen's:



Acimas pode-se ver que tem opcoes de deixa-lo aberto em uma janela ou deixalo em HIDE.



Aqui da para ver um exemplo das mensagens enviadas ao administrador quando esta ocorrendo algo nos "servidores".

Autor:Defcon

Acho que é um code bem legal que para pessoas mais experiente um pouco pode ajudar muito nos estudos!!

[vuln]

Apenas lembrando amigo, que de acordo com o Regimento Interno do Fórum, é proibido propaganda (SPAM); o que foi notado no cabeçalho de seu post. (HackMode.com.br). E para os usuários que não sabem o que é I.O, onde ele se referiu a biblioteca stdio.h, irei responder logo completando o nome da biblioteca:
Standard Input-Output.

Apenas algo para acrescentar a cabeça de vocês xD

abraços