ec_inet_bsd.c

Ettercap最初设计为交换网上的sniffer

      ERROR_MSG("ioctl(BIOCPROMISC)");

   return 0;
}



void Inet_Restore_ifr(void)
{

   // this function is not needed !!
   // when a bpf is closed, the interface is restored

}



void Inet_DisableForwarding(void)
{

   int mib[4];      // for sysctl()
   int val = 0;     // for sysctl()   disable
   size_t len;

   mib[0] = CTL_NET;
   mib[1] = PF_INET;
   mib[2] = IPPROTO_IP;
   mib[3] = IPCTL_FORWARDING;

   len = sizeof(IpForward_status);

   if( (sysctl(mib, 4, &IpForward_status, &len, &val, sizeof(val))) == -1)
    ERROR_MSG("sysctl() | net.inet.ip.forwarding");

   DEBUG_MSG("Inet_DisableForwarding | net.inet.ip.forwarding = %d  old_value = %d\n", val, IpForward_status);

   atexit(Inet_RestoreForwarding);

}



void Inet_RestoreForwarding(void)
{

   int mib[4];      // for sysctl()

   mib[0] = CTL_NET;
   mib[1] = PF_INET;
   mib[2] = IPPROTO_IP;
   mib[3] = IPCTL_FORWARDING;

   if (strcmp(ECThread_getname(pthread_self()), PROGRAM)) return;

   if( (sysctl(mib, 4, NULL, NULL, &IpForward_status, sizeof(IpForward_status))) == -1)
      ERROR_MSG("sysctl()");

   DEBUG_MSG("Inet_RestoreForwarding | net.inet.ip.forwarding = %d\n", IpForward_status);

}


char *Inet_MacFromIP(unsigned long ip)
{
   int mib[6];
   size_t len;
   char *buf, *next, *end;
   struct rt_msghdr *rtm;
   struct sockaddr_inarp *sin;
   struct sockaddr_dl *sdl;
   static char ETH_BROADCAST[6] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};

   DEBUG_MSG("Inet_MacFromIP");

   mib[0] = CTL_NET;
   mib[1] = AF_ROUTE;
   mib[2] = 0;
   mib[3] = AF_INET;
   mib[4] = NET_RT_FLAGS;
   mib[5] = RTF_LLINFO;

   if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0)
      ERROR_MSG("sysctl()");

   if ((buf = (char *)malloc(len)) == NULL)
      ERROR_MSG("malloc()");

   if (sysctl(mib, 6, buf, &len, NULL, 0) < 0)
   {
      free(buf);
      ERROR_MSG("sysctl()");
   }
   end = buf + len;

   for (next = buf ; next < end ; next += rtm->rtm_msglen)
   {
      rtm = (struct rt_msghdr *)next;
      sin = (struct sockaddr_inarp *)(rtm + 1);
      sdl = (struct sockaddr_dl *)(sin + 1);

      if (sin->sin_addr.s_addr == ip && sdl->sdl_alen)
      {
         free(buf);
         return LLADDR(sdl);
      }
      else     // not in cache... try to find it...
      {
      	struct recv_packet recvpck;
         char MyMAC[6];
         u_long MyIP;
         int MTU, sock;
         TIME_DECLARE;

         DEBUG_MSG("Inet_MacFromIP -- try to find it");

         sock = Inet_OpenRawSock(Options.netiface);

         Inet_GetIfaceInfo(Options.netiface, &MTU, MyMAC, &MyIP, NULL);

         if (ip == MyIP)
         {
            DEBUG_MSG("Inet_MacFromIP -- try to find me... ;)");
            memcpy(LLADDR(sdl), MyMAC, ETHER_ADDR_LEN);
            Inet_CloseRawSock(sock);
            return (char *) LLADDR(sdl);
         }

      	recvpck.buf = Inet_Forge_packet( MTU + ALIGN_ETH_TO_WORD );
      	recvpck.aligned = recvpck.buf + ALIGN_ETH_TO_WORD;

         Inet_Forge_ethernet( recvpck.aligned, MyMAC, ETH_BROADCAST, ETH_P_ARP );

         Inet_Forge_arp( recvpck.aligned + ETH_HEADER, ARPOP_REQUEST,
                         MyMAC, MyIP,
                         ARP_BROADCAST, ip );

         Inet_SendRawPacket(sock, buf, ETH_HEADER + ARP_HEADER);

			memset(recvpck.aligned, 0, MTU);

         fcntl(sock, F_SETFL, O_NONBLOCK);
         TIME_START;

         do
         {
            int len;
            short pkttype;
            ETH_header *ethpkt;
            ARP_header *arppkt;

            len = Inet_GetRawPacket(sock, recvpck.aligned, MTU, &pkttype);

            ethpkt = (ETH_header *)recvpck.aligned;
            arppkt = (ARP_header *)(recvpck.aligned + ETH_HEADER);

            TIME_FINISH;

            if (len > 0 && pkttype == PACKET_HOST && ethpkt->type == htons(ETH_P_ARP) && arppkt->opcode == htons(ARPOP_REPLY))
            {
               if ( *(unsigned long *)arppkt->source_ip == ip )
               {
                  memcpy(LLADDR(sdl), &arppkt->source_add, ETHER_ADDR_LEN);
                  free(buf);
                  Inet_Forge_packet_destroy( recvpck.buf );
                  Inet_CloseRawSock(sock);
                  return (char *) LLADDR(sdl);
               }
            }
         } while ( TIME_ELAPSED < 0.5 );
         Inet_Forge_packet_destroy( recvpck.buf );
         Inet_CloseRawSock(sock);
      }
   }
   free(buf);

   return ETH_BROADCAST;  // workaround for non local ip

}


#ifdef PERMIT_HTTPS


// ARP ENTRY MANAGEMENT ---------------------------  ripped form arp.c  ----------------


#define ROUNDUP(a)   ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))

static int pid;
static int s = -1;

struct   sockaddr_in so_mask = {8, 0, 0, { 0xffffffff}};
struct   sockaddr_inarp blank_sin = {sizeof(blank_sin), AF_INET }, sin_m;
struct   sockaddr_dl blank_sdl = {sizeof(blank_sdl), AF_LINK }, sdl_m;
struct   {
   struct   rt_msghdr m_rtm;
   char  m_space[512];
}  m_rtmsg;

u_long SavedIP;
u_char SavedMAC[6];

// protos...

int rtmsg_arp(int cmd);


//==================================

int rtmsg_arp(int cmd)
{
   static int seq;
   int rlen;
   register struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
   register char *cp = m_rtmsg.m_space;
   register int l;

   errno = 0;
   if (cmd == RTM_DELETE)
      goto doit;
   bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
   rtm->rtm_flags = 0;
   rtm->rtm_version = RTM_VERSION;

   switch (cmd) {
      case RTM_ADD:
         rtm->rtm_addrs |= RTA_GATEWAY;
         rtm->rtm_rmx.rmx_expire = 0;
         rtm->rtm_inits = RTV_EXPIRE;
         rtm->rtm_flags |= (RTF_HOST | RTF_STATIC);
         sin_m.sin_other = 0;
      case RTM_GET:
         rtm->rtm_addrs |= RTA_DST;
   }
#define NEXTADDR(w, s) \
   if (rtm->rtm_addrs & (w)) { \
      bcopy((char *)&s, cp, sizeof(s)); cp += ROUNDUP(sizeof(s));}

   NEXTADDR(RTA_DST, sin_m);
   NEXTADDR(RTA_GATEWAY, sdl_m);
   NEXTADDR(RTA_NETMASK, so_mask);

#undef NEXTADDR

   rtm->rtm_msglen = cp - (char *)&m_rtmsg;
doit:
   l = rtm->rtm_msglen;
   rtm->rtm_seq = ++seq;
   rtm->rtm_type = cmd;

   if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
      if (errno != ESRCH || cmd != RTM_DELETE)
         ERROR_MSG("writing on PF_ROUTE socket");
   }
   do {
      l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
   } while (l > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
   if (l < 0)
      ERROR_MSG("reading on PF_ROUTE socket");

   return (0);
}



void Inet_UnSetARPEntry(void)
{
   register struct sockaddr_inarp *sin = &sin_m;
   register struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
   struct sockaddr_dl *sdl;

   DEBUG_MSG("Inet_UnSetARPEntry");

   s = socket(PF_ROUTE, SOCK_RAW, 0);
   if (s < 0)
      ERROR_MSG("socket(PF_ROUTE)");

   sin_m = blank_sin;
   sin->sin_addr.s_addr = SavedIP;

   rtmsg_arp(RTM_GET);

   sin = (struct sockaddr_inarp *)(rtm + 1);
   sdl = (struct sockaddr_dl *)(ROUNDUP(sin->sin_len) + (char *)sin);

   rtmsg_arp(RTM_DELETE);

   close(s);
}



int Inet_SetARPEntry(unsigned long IP, char MAC[6])
{
   register struct sockaddr_inarp *sin = &sin_m;
   register struct sockaddr_dl *sdl;
   register struct rt_msghdr *rtm = &(m_rtmsg.m_rtm);
   u_char *ea;
   int ret;

   DEBUG_MSG("Inet_SetARPEntry");

   pid = getpid();

   s = socket(PF_ROUTE, SOCK_RAW, 0);
   if (s < 0)
      ERROR_MSG("socket(PF_ROUTE)");

   sdl_m = blank_sdl;
   sin_m = blank_sin;
   sin->sin_addr.s_addr = Inet_Fake_Host();

   ea = (u_char *)LLADDR(&sdl_m);
   memcpy(ea, MAC, 6);
   sdl_m.sdl_alen = 6;

   rtmsg_arp(RTM_GET);

   sin = (struct sockaddr_inarp *)(rtm + 1);
   sdl = (struct sockaddr_dl *)(ROUNDUP(sin->sin_len) + (char *)sin);

   sdl_m.sdl_type = sdl->sdl_type;
   sdl_m.sdl_index = sdl->sdl_index;

   SavedIP = Inet_Fake_Host();
   memcpy(SavedMAC, MAC, 6);

   atexit(Inet_UnSetARPEntry);

   ret = rtmsg_arp(RTM_ADD);

   close(s);

   return ret;

}



// ROUTE MANAGEMENT ---------------------------  ripped form route.c ----------------

int forcenet, forcehost, rtm_addrs, af, aflen = sizeof (struct sockaddr_in);
struct   rt_metrics rt_metrics;
u_long  rtm_inits;

union sockunion {
   struct   sockaddr sa;
   struct   sockaddr_in sin;
   struct   sockaddr_dl sdl;
} so_dst, so_gate, so_mask_r, so_genmask, so_ifa, so_ifp;

typedef union sockunion *sup;

// protos.....

int rtmsg_route(int cmd, int flags);
void inet_makenetandmask(u_long net, struct sockaddr_in *sin, u_long bits);
int getaddr(int which, char *s, struct hostent **hpp);
void mask_addr(void);
int rtmsg_route(int cmd, int flags);

//====================

void inet_makenetandmask(u_long net, struct sockaddr_in *sin, u_long bits)
{
   u_long addr, mask = 0;
   register char *cp;

   rtm_addrs |= RTA_NETMASK;
   if (bits) {
      addr = net;
      mask = 0xffffffff << (32 - bits);
   } else if (net == 0)
      mask = addr = 0;
   else if (net < 128) {
      addr = net << IN_CLASSA_NSHIFT;
      mask = IN_CLASSA_NET;
   } else if (net < 65536) {
      addr = net << IN_CLASSB_NSHIFT;
      mask = IN_CLASSB_NET;
   } else if (net < 16777216L) {
      addr = net << IN_CLASSC_NSHIFT;
      mask = IN_CLASSC_NET;
   } else {
      addr = net;
      if ((addr & IN_CLASSA_HOST) == 0)
         mask =  IN_CLASSA_NET;
      else if ((addr & IN_CLASSB_HOST) == 0)
         mask =  IN_CLASSB_NET;
      else if ((addr & IN_CLASSC_HOST) == 0)
         mask =  IN_CLASSC_NET;
      else
         mask = -1;
   }
   sin->sin_addr.s_addr = htonl(addr);
   sin = &so_mask_r.sin;
   sin->sin_addr.s_addr = htonl(mask);
   sin->sin_len = 0;
   sin->sin_family = 0;
   cp = (char *)(&sin->sin_addr + 1);
   while (*--cp == 0 && cp > (char *)sin)
      ;
   sin->sin_len = 1 + cp - (char *)sin;
}



int getaddr(int which, char *s, struct hostent **hpp)
{
   sup su;
   struct hostent *hp;
   struct netent *np;
   u_long val;
   int afamily;  /* local copy of af so we can change it */

   memset(&su, 0, sizeof(sup));

   if (af == 0) {
      af = AF_INET;
      aflen = sizeof(struct sockaddr_in);
   }
   afamily = af;
   rtm_addrs |= which;
   switch (which) {
   case RTA_DST:
      su = &so_dst;
      break;
   case RTA_GATEWAY:
      su = &so_gate;
      break;
   case RTA_NETMASK:
      su = &so_mask_r;
      break;
   }

   su->sa.sa_len = aflen;
   su->sa.sa_family = afamily; /* cases that don't want it have left already */

   if (hpp == NULL)
      hpp = &hp;
   *hpp = NULL;

   if ((which != RTA_DST || forcenet == 0) && (val = inet_addr(s)) != INADDR_NONE) {
      su->sin.sin_addr.s_addr = val;
      if (which != RTA_DST || inet_lnaof(su->sin.sin_addr) != INADDR_ANY)
         return (1);
      else {
         val = ntohl(val);
         goto netdone;
      }
   }

   if (which == RTA_DST && forcehost == 0 && ((val = inet_network(s)) != INADDR_NONE ||
       ((np = getnetbyname(s)) != NULL && (val = np->n_net) != 0))) {
netdone:
      inet_makenetandmask(val, &su->sin, 0);
      return (0);
   }

   hp = gethostbyname(s);
   if (hp) {
      *hpp = hp;
      su->sin.sin_family = hp->h_addrtype;
      bcopy(hp->h_addr, (char *)&su->sin.sin_addr,
          MIN(hp->h_length, sizeof(su->sin.sin_addr)));
      return (1);
   }
   Error_msg("ec_inet_BSD:%d  bad address %s | ERRNO : %d | %s", __LINE__, s, errno, strerror(errno));
   return 0;
}

void mask_addr()
{
   int olen = so_mask_r.sa.sa_len;
   register char *cp1 = olen + (char *)&so_mask_r, *cp2;

   for (so_mask_r.sa.sa_len = 0; cp1 > (char *)&so_mask_r; )
      if (*--cp1 != 0) {
         so_mask_r.sa.sa_len = 1 + cp1 - (char *)&so_mask_r;
         break;
      }
   if ((rtm_addrs & RTA_DST) == 0)
      return;

   switch (so_dst.sa.sa_family) {
   case AF_INET:
   case AF_APPLETALK:
   case 0:
      return;
   }
   cp1 = so_mask_r.sa.sa_len + 1 + (char *)&so_dst;
   cp2 = so_dst.sa.sa_len + 1 + (char *)&so_dst;
   while (cp2 > cp1)
      *--cp2 = 0;
   cp2 = so_mask_r.sa.sa_len + 1 + (char *)&so_mask_r;
   while (cp1 > so_dst.sa.sa_data)
      *--cp1 &= *--cp2;
}


int rtmsg_route(int cmd, int flags)
{
   static int seq;
   int rlen;
   register char *cp = m_rtmsg.m_space;
   register int l;

#define NEXTADDR(w, u) \
   if (rtm_addrs & (w)) {\
       l = ROUNDUP(u.sa.sa_len); bcopy((char *)&(u), cp, l); cp += l;\
   }

   errno = 0;
   bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
   if (cmd == 'a')
      cmd = RTM_ADD;
   else
      cmd = RTM_DELETE;

#define rtm m_rtmsg.m_rtm
   rtm.rtm_type = cmd;
   rtm.rtm_flags = flags;
   rtm.rtm_version = RTM_VERSION;
   rtm.rtm_seq = ++seq;
   rtm.rtm_addrs = rtm_addrs;
   rtm.rtm_rmx = rt_metrics;
   rtm.rtm_inits = rtm_inits;

   if (rtm_addrs & RTA_NETMASK)
      mask_addr();
   NEXTADDR(RTA_DST, so_dst);
   NEXTADDR(RTA_GATEWAY, so_gate);
   NEXTADDR(RTA_NETMASK, so_mask_r);
   NEXTADDR(RTA_GENMASK, so_genmask);
   NEXTADDR(RTA_IFP, so_ifp);
   NEXTADDR(RTA_IFA, so_ifa);
   rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
   if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0)
      ERROR_MSG("writing to routing socket");

#undef rtm
#undef NEXTADDR
   return (0);
}



void Inet_UnsetRoute(void)
{
   int flags = RTF_STATIC;
   struct hostent *hp = 0;
   int IP;

   DEBUG_MSG("Inet_UnsetRoute");

   pid = getpid();

   s = socket(PF_ROUTE, SOCK_RAW, 0);
   if (s < 0)
      ERROR_MSG("socket(PF_ROUTE)");


   forcehost = 0;
   forcenet++;
   hp = 0;
   flags = RTF_STATIC;

   IP = Inet_Fake_Host();

   getaddr(RTA_DST, "1.0.0.0", &hp);
   getaddr(RTA_GATEWAY, int_ntoa(IP), &hp);
   getaddr(RTA_NETMASK, "255.0.0.0", 0);

   flags |= RTF_UP;
   flags |= RTF_GATEWAY;

   rtmsg_route('d', flags);

   forcenet = 0;

   close(s);
}



void Inet_SetRoute(void)
{
   int flags = RTF_STATIC;
   struct hostent *hp = 0;
   int IP;

   DEBUG_MSG("Inet_SetRoute NET");

   pid = getpid();

   s = socket(PF_ROUTE, SOCK_RAW, 0);
   if (s < 0)
      ERROR_MSG("socket(PF_ROUTE)");


   forcehost = 0;
   forcenet++;
   hp = 0;
   flags = RTF_STATIC;

   IP = Inet_Fake_Host();

   getaddr(RTA_DST, "1.0.0.0", &hp);
   getaddr(RTA_GATEWAY, int_ntoa(IP), &hp);
   getaddr(RTA_NETMASK, "255.0.0.0", 0);

   flags |= RTF_UP;
   flags |= RTF_GATEWAY;

   rtmsg_route('a', flags);

   forcenet = 0;

   close(s);
   atexit(Inet_UnsetRoute);
}

#endif

/* EOF */

// vim:ts=3:expandtab