Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

[SOLUCIONADO] Ayuda con analisis, ideas u otras formas de escaneo para red local

  • 1 Respuestas
  • 1633 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado proxy_lainux

  • *
  • Underc0der
  • Mensajes: 121
  • Actividad:
    0%
  • Reputación 0
  • belial grimoire
    • Ver Perfil
« en: Enero 25, 2014, 02:29:53 pm »
hola

Estoy intentando hacer un codigo para analizar redes locales basandome en el codigo "arptool" de Cristiano Lincoln Mattos, ya logre entender parte del codigo despues de estar  buscando en google algunas estructuras y funciones, y tambien ya logre hacer funcionar un codigo hecho por mi pero solo logro saber la ip, netmask y Mac address de mi computadora

viendo mas su codigo el manda peticiones arp para sacar la informacion de las demas computadoras conectadas como la ip, netmask y mac address... algo parecido a lo que hace nmap con el comando -sP que te dice que computadoras estan activas

pero aqui es donde tengo el problema...  recuerdo que hace un tiempo cuando encontre por primera ves arptool, lo compile y funcionaba bien, a veces tenia sus pequeños fallos pero me daba la informacion de las ip locales

ahora lo volvi a encontrar, lo compile pero ya no me muestra las demas ip's mas que la mia, asi que ya no se si todavia funcione

me gustaria saber si alguien de aqui me podria dar ideas para lograr scanear las redes locales y encontrar la misma infomacion  "ip, netmask y mac address", o si podrian ayudarme a analizar el codigo y que me puedan decir porque ya no funciona bien el codigo ó que me puedan explicar algunas funciones que no logre entender, seria de bastante ayuda

ya entendi la mayoria pero hay parte del codigo que ya no logre entender, por ejemplo, la funcion str_to_hwaddr, la funcion hexstr_to_int y ya casi le entiendo a la funcion add_to_list que sera casi lo ultimo, porque la funcion show_list es solo para mandar a la consola la informacion guardada en las estructuras y sendarp  es la funcion send y recv para mandar los paquetes y lo demas ya lo tengo entendido bien.

espero me puedan ayudar, dejo el codigo

Código: C
  1. /*
  2.  *      ARPTool v0.1, (c) Cristiano Lincoln Mattos, 1999 - <lincoln@hotlink.com.br>
  3.  *
  4.  *      - Compiled and tested on Linux 2.0.33, 2.0.35, 2.0.36, libc5 & glibc.  
  5.  *        Will port to Solaris 2.5.1 as soon as i have time.
  6.  *      - For usage, run it without arguments.
  7.  *      - If you dont know what this is for, or what you can do with it,
  8.  *        read yuri volobuev's excellent bugtraq post about ARP spoofing
  9.  *        (available from the bugtraq archives).
  10.  *      - The netmap results depend on the network latency.. try adjusting the
  11.  *        usleep() delay, if you think it's too small/big.
  12.  *      - The latest version will be always at
  13.  *              http://www.hotlink.com.br/users/lincoln/arptool
  14.  *      - Some code borrowed from neped (apostols.org), thanks.
  15.  *      
  16.  *      #include <stddisclaimer.h>
  17.  *
  18.  *      CHANGELOG:
  19.  *         09/12/98 - General code cleanup.
  20.  *         07/12/98 - Removed the option for hiding in the process list, and
  21.  *                    double mode: didn't work as expected, stupid oversight.
  22.  *         29/12/98 - Better display of MAC's with more than one IP (proxy
  23.  *                    arp or virtual interfaces).
  24.  *         28/12/98 - Added check for arp reply being to source ip (netmap).
  25.  */
  26.  
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <sys/socket.h>
  31. #include <arpa/inet.h>
  32. #include <netinet/in.h>
  33. #include <linux/if.h>
  34. #include <linux/sockios.h>
  35. #include <linux/if_ether.h>
  36. #include <unistd.h>
  37. #include <fcntl.h>
  38.  
  39. #define ARP_ETHER       1
  40. #define ARP_REQUEST     1
  41. #define ARP_REPLY       2
  42.  
  43. /* Structures */
  44. struct pkt_struct {
  45.         unsigned char eth_dst[6];
  46.         unsigned char eth_src[6];
  47.         unsigned short eth_proto;
  48.         unsigned short int arp_hw_type;
  49.         unsigned short int arp_proto;
  50.         unsigned char arp_hw_len;
  51.         unsigned char arp_proto_len;                    // proto is IP.
  52.         unsigned short arp_oper;
  53.         unsigned char arp_hw_src[6];
  54.         unsigned char arp_ip_src[4];
  55.         unsigned char arp_hw_dst[6];
  56.         unsigned char arp_ip_dst[4];
  57. };
  58.  
  59. struct spoof_struct {
  60.         unsigned char hw_src[6];
  61.         unsigned char hw_dst[6];
  62.         unsigned long int ip_src;
  63.         unsigned long int ip_dst;
  64.         unsigned short op;
  65. };
  66.  
  67. /* List structures */
  68. struct iplist_struct {
  69.         unsigned long int ip;
  70.         struct iplist_struct * next;
  71. };
  72.  
  73. struct list_struct {
  74.         unsigned char hw[ETH_ALEN];
  75.         struct iplist_struct * iplist;
  76.         struct iplist_struct * lastip;
  77.         struct list_struct * next;
  78. } * head = NULL, * tail = NULL;
  79.  
  80. /* Functions */
  81. char * hwaddr_to_str (unsigned char * str);
  82. unsigned char * str_to_hwaddr (char * str);
  83. unsigned int hexstr_to_int (char *cptr);
  84. void netmap (int fd, unsigned long int start_ip);
  85. void usage (char * av, int mode);
  86. void add_to_list (unsigned long int ip, unsigned char * hw);
  87. void show_list ();
  88.  
  89. /* Global variables */
  90. unsigned long netmask, broadcast;                       /* struct in_addr */
  91. unsigned char hwaddr[ETH_ALEN];
  92. struct sockaddr sock;
  93. int verbose = 0;
  94.  
  95. void sendarp (int fd, unsigned char * h_source, unsigned char * h_dest, \
  96.                       unsigned char * arp_src, unsigned char * arp_dst, \
  97.                       unsigned long int ip_source, unsigned long int ip_dest, unsigned char op) {
  98.         struct pkt_struct pkt;
  99.  
  100.         // Ethernet header.
  101.         memcpy(&pkt.eth_dst,h_dest,ETH_ALEN);
  102.         memcpy(&pkt.eth_src,h_source,ETH_ALEN);
  103.         pkt.eth_proto = htons(ETH_P_ARP);
  104.         // ARP header.
  105.         pkt.arp_hw_type = htons(ARP_ETHER);
  106.         pkt.arp_proto = htons(ETH_P_IP);
  107.         pkt.arp_hw_len = ETH_ALEN;
  108.         pkt.arp_proto_len = 4;
  109.         pkt.arp_oper = htons(op);
  110.  
  111.         if (arp_src==0) bzero(&pkt.arp_hw_src,ETH_ALEN);
  112.                 else memcpy(&pkt.arp_hw_src,arp_src,ETH_ALEN);
  113.         if (arp_dst==0) bzero(&pkt.arp_hw_dst,ETH_ALEN);
  114.                 else memcpy(&pkt.arp_hw_dst,arp_dst,ETH_ALEN);
  115.  
  116.         memcpy(&pkt.arp_ip_src,&ip_source,4);
  117.         memcpy(&pkt.arp_ip_dst,&ip_dest,4);
  118.  
  119.         if ( (sendto(fd,&pkt,sizeof(pkt),0,&sock,sizeof(sock))) < 0) perror("Error sending ARP");
  120.  
  121.        
  122.  
  123. }
  124.  
  125. void netmap (int fd, unsigned long int start_ip) {
  126.         unsigned long int ip, ip_s;
  127.         struct pkt_struct * pkt;
  128.         int i;
  129.  
  130.         ip_s = start_ip;
  131.         ip = ip_s & netmask;
  132.  
  133.         i = fcntl(fd,F_GETFL);
  134.         if ((fcntl(fd,F_SETFL, i | O_NONBLOCK))<0) {
  135.                 perror("FCNTL"); exit (1);
  136.         }
  137.  
  138.         pkt = (struct pkt_struct *) malloc(sizeof(struct pkt_struct));
  139.         bzero(pkt,sizeof(struct pkt_struct));
  140.  
  141.         printf(" - Mapping network... \n");
  142.         while (ip < broadcast) {
  143.                 unsigned long int iptmp;
  144.                 unsigned char hwa[ETH_ALEN];
  145.                 ip = ntohl(ip);
  146.                 ip = htonl(++ip);
  147.  
  148.                 sendarp(fd,hwaddr,str_to_hwaddr("FF:FF:FF:FF:FF:FF"),hwaddr,0,ip_s,ip,ARP_REQUEST);
  149.                 usleep(1000);
  150.  
  151.                 i = sizeof(sock);
  152.                 bzero(pkt,sizeof(struct pkt_struct));
  153.                 if ((recvfrom(fd,pkt,sizeof(struct pkt_struct),0,&sock,&i)) < 0) continue;
  154.  
  155.                 memcpy(&iptmp,pkt->arp_ip_dst,4);
  156.                 if ((iptmp!=ip_s) || (ntohs(pkt->arp_oper)!=ARP_REPLY)) continue;              
  157.                 memcpy(&iptmp,pkt->arp_ip_src,4);
  158.                 add_to_list(iptmp,pkt->eth_src);
  159.         }
  160.         show_list();
  161.         free (pkt);
  162. }
  163.        
  164.  
  165. void main (int argc, char ** argv) {
  166.         struct ifreq ifr;
  167.         struct sockaddr_in sin;
  168.         struct spoof_struct sp;
  169.         unsigned long int ip;
  170.         int fd, ret;
  171.         int i = 0, map = 0, spoof = 0, interval = 0;
  172.         char * dev;
  173.  
  174.         // Parsing the arguments.
  175.         if (argc < 2) { usage(argv[0],0); exit(1); }
  176.        
  177.         usage(argv[0],1);
  178.         dev = (char *) malloc(6); strncpy(dev,"wlan0",5);
  179.         while ((i = getopt(argc, argv, "dc:vmi:s:")) != EOF) {
  180.                 switch (i) {
  181.                         case 'm': map = 1; continue;
  182.                         case 'v': verbose = 1; continue;
  183.                         case 'i': dev = optarg; continue;
  184.                         case 'c': interval = atoi(optarg); continue;
  185.                         case 's': spoof = optind-1; continue;
  186.                         case '?': exit(1);
  187.                         default: usage(argv[0],0); exit;
  188.                 }
  189.         }
  190.         if ((map) && (spoof)) {
  191.                 printf(" Error: cannot run in map mode (-m) and spoof mode (-s) simultaneously.\n");
  192.                 exit(1);
  193.         }
  194.         if ((!map) && (!spoof)) {
  195.                 printf(" Error: map mode (-m) or spoof mode (-s) must be specified.\n");
  196.                 exit(1);
  197.         }
  198.         if (spoof) {
  199.                 unsigned long int ips;
  200.                 int origspoof = spoof;
  201.  
  202.                 spoof = optind;
  203.                 if ((!argv[origspoof]) || (!argv[spoof]) || (!argv[spoof+1]) || (!argv[spoof+2]) || (!argv[spoof+3])) {
  204.                         printf(" Error: spoof (-s) requires five arguments: \n");
  205.                         exit(1);
  206.                 }
  207.  
  208.                 ips = atoi(argv[spoof+3]);
  209.                 if ( (ips!=1) && (ips!=2) ) {
  210.                         printf(" Erro: wrong arp operation.  Must be 1 for request or 2 for reply. \n");
  211.                         exit(1);
  212.                 }
  213.                 memcpy(&sp.hw_src,str_to_hwaddr(argv[origspoof]),ETH_ALEN);
  214.                 memcpy(&sp.hw_dst,str_to_hwaddr(argv[spoof++]),ETH_ALEN);              
  215.                 ips= inet_addr(argv[spoof++]);
  216.                 memcpy(&sp.ip_src,&ips,4);
  217.                 ips = inet_addr(argv[spoof++]);
  218.                 memcpy(&sp.ip_dst,&ips,4);
  219.                 ips = atoi(argv[spoof]);
  220.                 memcpy(&sp.op,&ips,1);
  221.         }
  222.  
  223.  
  224.         // Setting up the sockets, interface, and getting data.
  225.         strcpy(sock.sa_data,dev);
  226.         sock.sa_family = AF_INET;
  227.         fd = socket(AF_INET, SOCK_PACKET, htons(ETH_P_ARP));
  228.         if (fd==-1) {
  229.                 perror("Socket: "); exit (1);
  230.         }
  231.  
  232.         // HW Addr.
  233.         strcpy(ifr.ifr_name,dev);
  234.         ret = ioctl(fd,SIOCGIFHWADDR,&ifr);
  235.         if (ret==-1) {
  236.                 perror("Error getting HW Address"); exit (1);
  237.         }
  238.         memcpy(hwaddr,ifr.ifr_hwaddr.sa_data,ETH_ALEN);
  239.  
  240.         // IP.
  241.         ret = ioctl(fd,SIOCGIFADDR,&ifr);
  242.         if (ret==-1) {
  243.                 perror("Error getting IP Address"); exit (1);
  244.         }
  245.         memcpy(&sin,&ifr.ifr_addr,sizeof(struct sockaddr_in));
  246.         ip = sin.sin_addr.s_addr;
  247.  
  248.         // Netmask.
  249.         ret = ioctl(fd,SIOCGIFNETMASK,&ifr);
  250.         if (ret==-1) {
  251.                 perror("Error getting netmask"); exit (1);
  252.         }
  253.         memcpy(&sin,&ifr.ifr_netmask,sizeof(struct sockaddr_in));
  254.         netmask = sin.sin_addr.s_addr;
  255. //      netmask = 16777215;             // 24 bit Netmask
  256.  
  257.         // Broadcast.
  258.         ret = ioctl(fd,SIOCGIFBRDADDR,&ifr);
  259.         if (ret==-1) {
  260.                 perror("Error getting broadcast"); exit (1);
  261.         }
  262.         memcpy(&sin,&ifr.ifr_broadaddr,sizeof(struct sockaddr_in));
  263.         broadcast = sin.sin_addr.s_addr;
  264.  
  265.  printf("- Hardware Address: %s\n", hwaddr_to_str(hwaddr));
  266.     printf("- Interface IP: %s (%s)\n", inet_ntoa(*(struct in_addr*)&ip), dev);
  267.         printf("- Netmask: %s\n", inet_ntoa(*(struct in_addr*)&netmask));
  268.         printf("- Brodcast: %s\n\n", inet_ntoa(*(struct in_addr*)&broadcast));
  269.  
  270.         while (1) {
  271.                 if (map) netmap (fd,ip);
  272.                 if (spoof) {
  273.                         sendarp(fd,sp.hw_src,sp.hw_dst,sp.hw_src,sp.hw_dst,sp.ip_src,sp.ip_dst,sp.op);
  274.                 }
  275.                 if (interval) sleep(interval);
  276.                         else break;
  277.         }
  278. }
  279.  
  280.  
  281. char * hwaddr_to_str (unsigned char * str) {
  282.         static char tmp[20];
  283.         sprintf(tmp,"%02X:%02X:%02X:%02X:%02X:%02X",str[0],str[1],str[2],str[3],str[4],str[5]);
  284.         return tmp;
  285. }
  286.  
  287. unsigned int hexstr_to_int(char *cptr) {
  288.       unsigned int i, j = 0;
  289.        
  290.       while (cptr && *cptr && isxdigit(*cptr)) {
  291.             i = *cptr++ - '0';
  292.             if (9 < i) i -= 7;
  293.             j <<= 4;
  294.             j |= (i & 0x0f);
  295.       }
  296.       return(j);
  297. }      
  298.  
  299. unsigned char * str_to_hwaddr (char * str) {
  300.         unsigned char tmp[2], strbuf[17], t[2];
  301.         static unsigned char * buf, * tt;
  302.         int e, i;
  303.  
  304.         buf = (unsigned char *) malloc(6);
  305.         bzero(t,2); bzero(tmp,2); bzero(strbuf,17); bzero(buf,6);
  306.         strncpy(strbuf,str,17); strbuf[17]='\0';
  307.         tt = buf;
  308.        
  309.         e = 0;
  310.         for (i=0; i < strlen(strbuf); i++) {
  311.                 if ((strbuf[i]==':') && (e==0)) continue;
  312.                 tmp[e] = strbuf[i]; e++;
  313.                 if (e==2) {
  314.                         unsigned int a;
  315.                         a = hexstr_to_int(tmp);
  316.                         memcpy(tt,&a,1); tt++;
  317.                         bzero(tmp,2); e = 0;
  318.                 }
  319.         }
  320.         return buf;
  321. }
  322.  
  323. void usage (char * av, int mode) {
  324.         printf(" ARPTool v0.1, (c) Cristiano Lincoln Mattos, 1999.  <lincoln@hotlink.com.br> \n");
  325.         if (!mode) {
  326.                 printf(" Sintax: %s [-i interface] [-m] [-c] [-s hwsrc hwdest ipsrc ipdst op]\n",av);
  327.                 printf("         -i interface: use this interface.  If ommited, default to eth0\n");
  328.                 printf("         -m: network map mode.  Will identify all hosts on the same \n                  cable segment. \n");
  329.                 printf("         -s src_hwaddress dst_hwaddress src_ipaddress dst_ipaddress operation:\n");
  330.                 printf("            send arbitrary ARP packets.  The hardware address must be \n                specified in the usual form, i.e. 00:00:FD:FF:1E:C1.\n                  Operation is 1 for ARP request, 2 for ARP reply. \n");
  331.                 printf("         -c interval: continuous mode.  Will keep sending the specified \n              packets every interval seconds (requires -s or -m).\n");
  332.                 exit(1);
  333.         }
  334. }      
  335.  
  336.  
  337. void show_list () {
  338.         struct list_struct * tmp, * tmp2;
  339.         tmp = head;
  340.         while (tmp!=NULL) {
  341.                 struct iplist_struct * iptmp;
  342.                 iptmp = tmp->iplist;
  343.                 printf(" -- HW Address: %s",hwaddr_to_str(tmp->hw));
  344.                 if (iptmp->next) printf(" - Several IP's: probably router with proxy arp, or virtual interfaces.\n");
  345.                 while (iptmp!=NULL) {
  346.                         printf("            IP: %s\n",inet_ntoa(*(struct in_addr*)&iptmp->ip));
  347.                         iptmp = iptmp->next;
  348.                 }
  349.                 free(iptmp); tmp2 = tmp->next;
  350.                 free(tmp); tmp = tmp2;
  351.         }
  352.         return;
  353. }
  354.              
  355.  
  356. void add_to_list (unsigned long int ip, unsigned char * hw) {
  357.         struct list_struct * tmp;
  358.         struct iplist_struct * iptmp;
  359.         tmp = head;
  360.         while (tmp) {
  361.                 if ((hw[0]==tmp->hw[0]) && (hw[1]==tmp->hw[1]) && (hw[2]==tmp->hw[2]) && (hw[3]==tmp->hw[3]) &&\
  362.                         (hw[4]==tmp->hw[4]) && (hw[5]==tmp->hw[5])) break;
  363.                 tmp = tmp->next;
  364.         }
  365.         if (!tmp) {                     // If it's the first HW entry, or did not find HW in list, create
  366.                 if ((tmp = (struct list_struct *) malloc(sizeof(struct list_struct))) == NULL) {
  367.                         printf("\n malloc error. \n"); exit (1);
  368.                 }
  369.                 if ((iptmp = (struct iplist_struct *) malloc(sizeof(struct iplist_struct))) == NULL) {
  370.                         printf("\n malloc error. \n"); exit (1);
  371.                 }
  372.                 iptmp->ip = ip;
  373.                 iptmp->next = NULL;
  374.                 tmp->iplist = iptmp;            
  375.                 tmp->lastip = iptmp;
  376.                 tmp->next = NULL;
  377.                 memcpy(tmp->hw,hw,ETH_ALEN);
  378.                 if (tail) {
  379.                         tail->next = tmp;
  380.                         tail = tmp;
  381.                 }
  382.         } else {                        // Found the HW entry in the list, just add the IP.
  383.                 if ((iptmp = (struct iplist_struct *) malloc(sizeof(struct iplist_struct))) == NULL) {
  384.                         printf("\n malloc error. \n"); exit (1);
  385.                 }
  386.                 iptmp->ip = ip;
  387.                 iptmp->next = NULL;
  388.                 tmp->lastip->next = iptmp;
  389.                 tmp->lastip = iptmp;
  390.         }
  391.         if (!head) head = tail = tmp;
  392. }

« Última modificación: Agosto 18, 2014, 08:11:41 pm por Expermicid »

Desconectado k133

  • *
  • Underc0der
  • Mensajes: 48
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #1 en: Febrero 22, 2014, 03:29:36 pm »
Yo también me quede en esta parte. Hace ya tiempo que no programo en c pero el último proyecto que quería hacer era relacionado con el manejo de interfaces y enviar paquetes. Pero no conseguí entender del todo bien las estructuras que usa el kernel.

El documento que yo "intente" entender fue:
http://www.xml.com/ldd/chapter/book/ch14.html

Se agradece si alguien ayuda.

 

¿Te gustó el post? COMPARTILO!



[SOLUCIONADO] ¿Kali Linux o Kali Linux Ligth ?

Iniciado por worq

Respuestas: 2
Vistas: 12056
Último mensaje Noviembre 21, 2017, 12:28:54 pm
por Codig0Bit
Crear un archivo .vbs para ejecutar un archivo .bat en invisible

Iniciado por NMS

Respuestas: 2
Vistas: 6066
Último mensaje Marzo 13, 2017, 10:37:57 pm
por sadfud
Cómo uso la "/" para hacer un select en una tabla

Iniciado por tetano32

Respuestas: 3
Vistas: 1310
Último mensaje Diciembre 20, 2017, 04:41:12 pm
por tetano32
allegro 5,opngl,sdk para fan game modo storyboard game

Iniciado por Mr.Tru

Respuestas: 2
Vistas: 679
Último mensaje Mayo 23, 2018, 01:19:20 pm
por Mr.Tru
Parámetros para un script que permita saltar a root con "su"

Iniciado por DUDA

Respuestas: 5
Vistas: 1902
Último mensaje Marzo 28, 2017, 08:23:12 pm
por seth