/* ** This file is a part of PassiveDNS. ** ** Copyright (C) 2010-2013, Edward Fjellskål ** ** This program is free software; you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation; either version 2 of the License, or ** (at your option) any later version. ** ** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with this program; if not, write to the Free Software ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ** */ /* I N C L U D E S **********************************************************/ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "passivedns.h" #include "dns.h" #ifdef HAVE_JSON #include #endif /* HAVE_JSON */ #ifdef HAVE_PFRING #include #endif /* HAVE_PFRING */ #ifndef CONFDIR #define CONFDIR "/etc/passivedns/" #endif /* G L O B A L S *** (or candidates for refactoring, as we say)***********/ globalconfig config; connection *bucket[BUCKET_SIZE]; static volatile sig_atomic_t signal_reopen_log_files = 0; /* I N T E R N A L P R O T O T Y P E S ***********************************/ static void usage(); static void show_version(); void check_vlan (packetinfo *pi); void prepare_null (packetinfo *pi); void prepare_raw (packetinfo *pi); void prepare_sll (packetinfo *pi); void prepare_eth (packetinfo *pi); void prepare_ip4 (packetinfo *pi); void prepare_ip4ip (packetinfo *pi); void prepare_ip6 (packetinfo *pi); void prepare_ip6ip (packetinfo *pi); void prepare_udp (packetinfo *pi); void prepare_tcp (packetinfo *pi); void parse_eth (packetinfo *pi); void parse_ip4 (packetinfo *pi); void parse_ip6 (packetinfo *pi); void parse_udp (packetinfo *pi); void parse_tcp (packetinfo *pi); const char *u_ntop_src(packetinfo *pi, char *dest); void set_pkt_end_ptr (packetinfo *pi); void check_interrupt(); void end_sessions(); void set_end_sessions(); void set_end_dns_records(); void cxt_init(); int connection_tracking(packetinfo *pi); connection *cxt_new(packetinfo *pi); void del_connection(connection *, connection **); void print_pdns_stats(); void free_config(); void reopen_log_files(); void game_over (); void got_packet(u_char *useless, const struct pcap_pkthdr *pheader, const u_char *packet); #ifdef HAVE_PFRING void pfring_got_packet(const struct pfring_pkthdr *pfheader, const u_char *packet, const u_char *useless); #endif /* HAVE_PFRING */ /* F U N C T I O N S ********************************************************/ #ifdef HAVE_PFRING void pfring_got_packet(const struct pfring_pkthdr *pfheader, const u_char *packet, const u_char *useless) { /* pcap_pkthdr and pfring_pkthdr are identical to each other*/ struct pcap_pkthdr *pheader = (struct pcap_pkthdr *)pfheader; /* Set timestamp if it's not set */ if (pheader->ts.tv_sec == 0) pheader->ts.tv_sec = time(NULL); /* pfring_loop orders the arguments differently than pcap_loop */ got_packet((u_char *)useless, (const struct pcap_pkthdr *)pheader, packet); } #endif /* HAVE_PFRING */ void got_packet(u_char *useless, const struct pcap_pkthdr *pheader, const u_char *packet) { config.p_s.got_packets++; packetinfo pstruct = {0}; packetinfo *pi = &pstruct; pi->packet = packet; pi->pheader = pheader; set_pkt_end_ptr (pi); memcpy( &config.tstamp, &pi->pheader->ts, sizeof( struct timeval ) ); /* Global */ if (signal_reopen_log_files) reopen_log_files(); if (config.intr_flag != 0) { check_interrupt(); } config.inpacket = 1; switch (config.linktype) { case DLT_NULL: prepare_null(pi); break; case DLT_RAW: prepare_raw(pi); break; #ifdef DLT_LINUX_SLL case DLT_LINUX_SLL: prepare_sll(pi); break; #endif default: prepare_eth(pi); check_vlan(pi); break; } switch (pi->eth_type) { case ETHERNET_TYPE_IP: prepare_ip4(pi); parse_ip4(pi); break; case ETHERNET_TYPE_IPV6: prepare_ip6(pi); parse_ip6(pi); break; default: config.p_s.otherl_recv++; //vlog(0x3, "[*] ETHERNET TYPE : %x\n",pi->eth_hdr->eth_ip_type); break; } config.inpacket = 0; } void prepare_null(packetinfo *pi) { pi->eth_hlen = LOOPBACK_HDR_LEN; if ((u_int32_t)*pi->packet == AF_INET) { pi->eth_type = ETHERNET_TYPE_IP; } else { pi->eth_type = ETHERNET_TYPE_IPV6; } } void prepare_raw(packetinfo *pi) { pi->eth_hlen = 0; if (IP_V((ip4_header *)pi->packet) == 4) pi->eth_type = ETHERNET_TYPE_IP; else pi->eth_type = ETHERNET_TYPE_IPV6; } void prepare_sll(packetinfo *pi) { pi->eth_hlen = SLL_HDR_LEN; if (IP_V((ip4_header *)(pi->packet + SLL_HDR_LEN)) == 4) pi->eth_type = ETHERNET_TYPE_IP; else pi->eth_type = ETHERNET_TYPE_IPV6; } void prepare_eth(packetinfo *pi) { if (pi->packet + ETHERNET_HEADER_LEN > pi->end_ptr) return; config.p_s.eth_recv++; pi->eth_hdr = (ether_header *) (pi->packet); pi->eth_type = ntohs(pi->eth_hdr->eth_ip_type); pi->eth_hlen = ETHERNET_HEADER_LEN; } void check_vlan(packetinfo *pi) { if (pi->eth_type == ETHERNET_TYPE_8021Q) { vlog(0x3, "[*] ETHERNET TYPE 8021Q\n"); config.p_s.vlan_recv++; pi->vlan = pi->eth_hdr->eth_8_vid; pi->eth_type = ntohs(pi->eth_hdr->eth_8_ip_type); pi->eth_hlen += 4; if ( pi->eth_type == ETHERNET_TYPE_8021Q ) { vlog(0x3, "[*] ETHERNET TYPE 8021Q in 8021Q\n"); pi->eth_type = ntohs(pi->eth_hdr->eth_82_ip_type); pi->eth_hlen += 4; pi->vlan = pi->eth_hdr->eth_82_vid; } } else if (pi->eth_type == (ETHERNET_TYPE_802Q1MT | ETHERNET_TYPE_802Q1MT2 | ETHERNET_TYPE_802Q1MT3 | ETHERNET_TYPE_8021AD)) { vlog(0x3, "[*] ETHERNET TYPE 802Q1MT\n"); pi->mvlan = pi->eth_hdr->eth_82_mvid; pi->eth_type = ntohs(pi->eth_hdr->eth_82_ip_type); pi->eth_hlen += 8; } } void prepare_ip4(packetinfo *pi) { config.p_s.ip4_recv++; pi->af = AF_INET; pi->ip4 = (ip4_header *) (pi->packet + pi->eth_hlen); pi->packet_bytes = (pi->ip4->ip_len - (IP_HL(pi->ip4) * 4)); } void parse_ip4(packetinfo *pi) { /* Paranoia */ if (((pi->packet + pi->eth_hlen) + (IP_HL(pi->ip4) * 4)) > pi->end_ptr) { dlog("[D] Refusing to parse IPv4 packet: IPv4-hdr passed end_ptr\n"); return; } switch (pi->ip4->ip_p) { case IP_PROTO_TCP: prepare_tcp(pi); parse_tcp(pi); break; case IP_PROTO_UDP: prepare_udp(pi); parse_udp(pi); break; case IP_PROTO_IP4: prepare_ip4ip(pi); break; case IP_PROTO_IP6: prepare_ip4ip(pi); break; default: break; } } void prepare_ip6ip(packetinfo *pi) { packetinfo pipi; memset(&pipi, 0, sizeof(packetinfo)); config.p_s.ip6ip_recv++; pipi.pheader = pi->pheader; pipi.packet = (pi->packet + pi->eth_hlen + IP6_HEADER_LEN); pipi.end_ptr = pi->end_ptr; if (pi->ip6->next == IP_PROTO_IP4) { prepare_ip4(&pipi); parse_ip4(&pipi); } else { prepare_ip6(&pipi); parse_ip6(&pipi); } } void prepare_ip4ip(packetinfo *pi) { packetinfo pipi; memset(&pipi, 0, sizeof(packetinfo)); config.p_s.ip4ip_recv++; pipi.pheader = pi->pheader; pipi.packet = (pi->packet + pi->eth_hlen + (IP_HL(pi->ip4) * 4)); pipi.end_ptr = pi->end_ptr; if (pi->ip4->ip_p == IP_PROTO_IP4) { prepare_ip4(&pipi); parse_ip4(&pipi); } else { prepare_ip6(&pipi); parse_ip6(&pipi); } } void prepare_ip6(packetinfo *pi) { config.p_s.ip6_recv++; pi->af = AF_INET6; pi->ip6 = (ip6_header *) (pi->packet + pi->eth_hlen); pi->packet_bytes = pi->ip6->len; } void parse_ip6(packetinfo *pi) { switch (pi->ip6->next) { case IP_PROTO_TCP: prepare_tcp(pi); parse_tcp(pi); break; case IP_PROTO_UDP: prepare_udp(pi); parse_udp(pi); break; case IP_PROTO_IP4: prepare_ip6ip(pi); break; case IP_PROTO_IP6: prepare_ip6ip(pi); break; default: break; } } void set_pkt_end_ptr(packetinfo *pi) { /* Paranoia! */ if (pi->pheader->len <= SNAPLENGTH) pi->end_ptr = (pi->packet + pi->pheader->len); else pi->end_ptr = (pi->packet + SNAPLENGTH); } void prepare_tcp(packetinfo *pi) { config.p_s.tcp_recv++; if (pi->af == AF_INET) { vlog(0x3, "[*] IPv4 PROTOCOL TYPE TCP:\n"); pi->tcph = (tcp_header *) (pi->packet + pi->eth_hlen + (IP_HL(pi->ip4) * 4)); pi->plen = (pi->pheader->caplen - (TCP_OFFSET(pi->tcph)) * 4 - (IP_HL(pi->ip4) * 4) - pi->eth_hlen); pi->payload = (pi->packet + pi->eth_hlen + (IP_HL(pi->ip4) * 4) + (TCP_OFFSET(pi->tcph) * 4)); } else if (pi->af == AF_INET6) { vlog(0x3, "[*] IPv6 PROTOCOL TYPE TCP:\n"); pi->tcph = (tcp_header *) (pi->packet + pi->eth_hlen + IP6_HEADER_LEN); pi->plen = (pi->pheader->caplen - (TCP_OFFSET(pi->tcph)) * 4 - IP6_HEADER_LEN - pi->eth_hlen); pi->payload = (pi->packet + pi->eth_hlen + IP6_HEADER_LEN + (TCP_OFFSET(pi->tcph)*4)); } pi->proto = IP_PROTO_TCP; pi->s_port = pi->tcph->src_port; pi->d_port = pi->tcph->dst_port; connection_tracking(pi); } void prepare_udp(packetinfo *pi) { config.p_s.udp_recv++; if (pi->af == AF_INET) { vlog(0x3, "[*] IPv4 PROTOCOL TYPE UDP:\n"); pi->udph = (udp_header *) (pi->packet + pi->eth_hlen + (IP_HL(pi->ip4) * 4)); pi->plen = pi->pheader->caplen - UDP_HEADER_LEN - (IP_HL(pi->ip4) * 4) - pi->eth_hlen; pi->payload = (pi->packet + pi->eth_hlen + (IP_HL(pi->ip4) * 4) + UDP_HEADER_LEN); } else if (pi->af == AF_INET6) { vlog(0x3, "[*] IPv6 PROTOCOL TYPE UDP:\n"); pi->udph = (udp_header *) (pi->packet + pi->eth_hlen + IP6_HEADER_LEN); pi->plen = pi->pheader->caplen - UDP_HEADER_LEN - IP6_HEADER_LEN - pi->eth_hlen; pi->payload = (pi->packet + pi->eth_hlen + IP6_HEADER_LEN + UDP_HEADER_LEN); } pi->proto = IP_PROTO_UDP; pi->s_port = pi->udph->src_port; pi->d_port = pi->udph->dst_port; connection_tracking(pi); } void parse_tcp(packetinfo *pi) { if (pi->plen <= 0) return; /* Reliable traffic comes from the servers (normally on port 53 or 5353) * and the client has sent at least one packet on that * connecton (Maybe asking for an aswer :) */ dlog("[D] Parsing TCP packet...\n"); dns_parser(pi); } void parse_udp(packetinfo *pi) { if (pi->plen <= 0) return; /* Reliable traffic comes from the servers (normally on port 53 or 5353) * and the client has sent at least one packet on that * connecton (Maybe asking for an aswer :) */ dlog("[D] Parsing UDP packet...\n"); dns_parser(pi); } int connection_tracking(packetinfo *pi) { struct in6_addr *ip_src; struct in6_addr *ip_dst; struct in6_addr ips; struct in6_addr ipd; uint16_t src_port = pi->s_port; uint16_t dst_port = pi->d_port; int af = pi->af; connection *cxt = NULL; connection *head = NULL; uint32_t hash; if(af == AF_INET6){ ip_src = &PI_IP6SRC(pi); ip_dst = &PI_IP6DST(pi); } else { #ifdef BSD_DERIVED ips.__u6_addr.__u6_addr32[0] = pi->ip4->ip_src; ipd.__u6_addr.__u6_addr32[0] = pi->ip4->ip_dst; #else ips.s6_addr32[0] = pi->ip4->ip_src; ipd.s6_addr32[0] = pi->ip4->ip_dst; #endif ip_src = &ips; ip_dst = &ipd; } /* Find the right connection bucket */ if (af == AF_INET) hash = CXT_HASH4(IP4ADDR(ip_src), IP4ADDR(ip_dst), src_port, dst_port, pi->proto); else if (af == AF_INET6) hash = CXT_HASH6(ip_src, ip_dst, src_port, dst_port, pi->proto); else { dlog("[D] Only CTX with AF_INET and AF_INET6 are supported: %d\n", af); return 0; } cxt = bucket[hash]; head = cxt; /* Search through the bucket */ while (cxt != NULL) { /* Two-way compare of given connection against connection table */ if (af == AF_INET) { if (CMP_CXT4(cxt, IP4ADDR(ip_src), src_port, IP4ADDR(ip_dst), dst_port)) { /* Client sends first packet (TCP/SYN - UDP?) hence this is a client */ dlog("[D] Found existing v4 client connection.\n"); return cxt_update_client(cxt, pi); } else if (CMP_CXT4(cxt, IP4ADDR(ip_dst), dst_port, IP4ADDR(ip_src), src_port)) { if (pi->sc == SC_SERVER) { /* This is a server */ dlog("[D] Found existing v4 server connection.\n"); return cxt_update_server(cxt, pi); } else { /* This is a client, where we saw a mid-stream DNS response first */ dlog("[D] Found existing unknown v4 server connection.\n"); return cxt_update_client(cxt, pi); } } } else if (af == AF_INET6) { if (CMP_CXT6(cxt, ip_src, src_port, ip_dst, dst_port)) { dlog("[D] Found existing v6 client connection.\n"); return cxt_update_client(cxt, pi); } else if (CMP_CXT6(cxt, ip_dst, dst_port, ip_src, src_port)) { dlog("[D] Found existing v6 client connection.\n"); return cxt_update_server(cxt, pi); } } cxt = cxt->next; } /* Bucket turned upside down didn't yield anything. New connection */ dlog("[D] New connection.\n"); cxt = cxt_new(pi); /* New connections are pushed on to the head of bucket[s_hash] */ cxt->next = head; if (head != NULL) /* Are we double linked? */ head->prev = cxt; bucket[hash] = cxt; pi->cxt = cxt; return cxt_update_unknown(cxt, pi); } /* Freshly smelling connection :d */ connection *cxt_new(packetinfo *pi) { struct in6_addr ips; struct in6_addr ipd; connection *cxt; config.cxtrackerid++; cxt = (connection *) calloc(1, sizeof(connection)); cxt->cxid = config.cxtrackerid; cxt->af = pi->af; if (pi->tcph) cxt->s_tcpFlags |= pi->tcph->t_flags; cxt->start_time = pi->pheader->ts.tv_sec; cxt->last_pkt_time = pi->pheader->ts.tv_sec; if (pi->af == AF_INET6){ cxt->s_ip = PI_IP6SRC(pi); cxt->d_ip = PI_IP6DST(pi); } else { #ifdef BSD_DERIVED ips.__u6_addr.__u6_addr32[0] = pi->ip4->ip_src; ipd.__u6_addr.__u6_addr32[0] = pi->ip4->ip_dst; #else ips.s6_addr32[0] = pi->ip4->ip_src; ipd.s6_addr32[0] = pi->ip4->ip_dst; #endif cxt->s_ip = ips; cxt->d_ip = ipd; } cxt->s_port = pi->s_port; cxt->d_port = pi->d_port; cxt->proto = pi->proto; cxt->check = 0x00; cxt->reversed = 0; config.curcxt++; return cxt; } int cxt_update_client(connection *cxt, packetinfo *pi) { cxt->last_pkt_time = pi->pheader->ts.tv_sec; if (pi->tcph) cxt->s_tcpFlags |= pi->tcph->t_flags; cxt->s_total_bytes += pi->packet_bytes; cxt->s_total_pkts += 1; pi->cxt = cxt; pi->sc = SC_CLIENT; if (cxt->s_total_bytes > MAX_BYTE_CHECK || cxt->s_total_pkts > MAX_PKT_CHECK) { return 0; /* Don't Check! */ } return SC_CLIENT; } int cxt_update_unknown(connection *cxt, packetinfo *pi) { cxt->last_pkt_time = pi->pheader->ts.tv_sec; if (pi->tcph) cxt->s_tcpFlags |= pi->tcph->t_flags; cxt->s_total_bytes += pi->packet_bytes; cxt->s_total_pkts += 1; pi->cxt = cxt; pi->sc = SC_UNKNOWN; if (cxt->s_total_bytes > MAX_BYTE_CHECK || cxt->s_total_pkts > MAX_PKT_CHECK) { return 0; /* Don't Check! */ } return SC_UNKNOWN; } int cxt_update_server(connection *cxt, packetinfo *pi) { cxt->last_pkt_time = pi->pheader->ts.tv_sec; if (pi->tcph) cxt->d_tcpFlags |= pi->tcph->t_flags; cxt->d_total_bytes += pi->packet_bytes; cxt->d_total_pkts += 1; pi->cxt = cxt; pi->sc = SC_SERVER; if (cxt->d_total_bytes > MAX_BYTE_CHECK || cxt->d_total_pkts > MAX_PKT_CHECK) return 0; /* Don't check! */ return SC_SERVER; } void end_all_sessions() { connection *cxt; int cxkey; config.llcxt = 0; for (cxkey = 0; cxkey < BUCKET_SIZE; cxkey++) { cxt = bucket[cxkey]; while (cxt != NULL) { config.llcxt++; if (cxt->prev) cxt->prev->next = cxt->next; if (cxt->next) cxt->next->prev = cxt->prev; connection *tmp = cxt; cxt = cxt->next; del_connection(tmp, &bucket[cxkey]); if (cxt == NULL) bucket[cxkey] = NULL; } } dlog("CXT in list before cleaning: %10u\n", config.llcxt); dlog("CXT in list after cleaning: %10u\n", config.curcxt); } void end_sessions() { connection *cxt; time_t check_time; check_time = config.tstamp.tv_sec; int ended, expired = 0; config.llcxt = 0; int iter; for (iter = 0; iter < BUCKET_SIZE; iter++) { cxt = bucket[iter]; while (cxt != NULL) { ended = 0; config.llcxt++; /* TCP */ if (cxt->proto == IP_PROTO_TCP) { /* FIN from both sides */ if (cxt->s_tcpFlags & TF_FIN && cxt->d_tcpFlags & TF_FIN && (check_time - cxt->last_pkt_time) > 5) ended = 1; /* RST from either side */ else if ((cxt->s_tcpFlags & TF_RST || cxt->d_tcpFlags & TF_RST) && (check_time - cxt->last_pkt_time) > 5) ended = 1; else if ((check_time - cxt->last_pkt_time) > TCP_TIMEOUT) expired = 1; } /* UDP */ else if (cxt->proto == IP_PROTO_UDP && (check_time - cxt->last_pkt_time) > UDP_TIMEOUT) expired = 1; /* ICMP */ else if (cxt->proto == IP_PROTO_ICMP || cxt->proto == IP6_PROTO_ICMP) { if ((check_time - cxt->last_pkt_time) > ICMP_TIMEOUT) expired = 1; } /* All other protocols */ else if ((check_time - cxt->last_pkt_time) > OTHER_TIMEOUT) expired = 1; if (ended == 1 || expired == 1) { /* Remove from the hash */ if (cxt->prev) cxt->prev->next = cxt->next; if (cxt->next) cxt->next->prev = cxt->prev; connection *tmp = cxt; connection *tmp_pre = cxt->prev; ended = expired = 0; cxt = cxt->next; del_connection(tmp, &bucket[iter]); if (cxt == NULL && tmp_pre == NULL) bucket[iter] = NULL; } else cxt = cxt->next; } } dlog("CXT in list before cleaning: %10u\n", config.llcxt); dlog("CXT in list after cleaning: %10u\n", config.curcxt); } void del_connection(connection * cxt, connection ** bucket_ptr) { connection *prev = cxt->prev; /* Older connections */ connection *next = cxt->next; /* Newer connections */ if (prev == NULL) { /* Beginning of list */ *bucket_ptr = next; /* Not only entry */ if (next) next->prev = NULL; } else if (next == NULL) { /* At end of list! */ prev->next = NULL; } else { /* A node */ prev->next = next; next->prev = prev; } /* Free and set to NULL */ free(cxt); cxt = NULL; config.curcxt--; } const char *u_ntop_src(packetinfo *pi, char *dest) { if (pi->af == AF_INET) { if (!inet_ntop(AF_INET, &pi->ip4->ip_src, dest, INET_ADDRSTRLEN + 1)) { perror("Something died in inet_ntop"); return NULL; } } else if (pi->af == AF_INET6) { if (!inet_ntop(AF_INET6, &pi->ip6->ip_src, dest, INET6_ADDRSTRLEN + 1)) { perror("Something died in inet_ntop"); return NULL; } } return dest; } void check_interrupt() { dlog("[D] In interrupt. Flag: %d\n",config.intr_flag); if (ISSET_INTERRUPT_END(config)) game_over(); else if (ISSET_INTERRUPT_SESSION(config)) set_end_sessions(); else if (ISSET_INTERRUPT_DNS(config)) set_end_dns_records(); else config.intr_flag = 0; } void sig_alarm_handler() { time_t now_t; now_t = config.tstamp.tv_sec; dlog("[D] Got SIG ALRM: %lu\n", now_t); /* Each time check for timed out sessions */ set_end_sessions(); /* Only check for timed-out dns records each 10 minutes */ if ((now_t - config.dnslastchk) >= 600) { set_end_dns_records(); } alarm(TIMEOUT); } void sig_hup_handler() { signal_reopen_log_files = 1; } void reopen_log_files() { if (config.output_log) { if (config.logfile_fd != NULL && config.logfile_fd != stdout) fclose(config.logfile_fd); config.logfile_fd = fopen(config.logfile, "a"); } if (config.output_log_nxd) { if (config.logfile_all) { /* Do nothing, since both logs use the same file */ } else { if (config.logfile_nxd_fd != NULL && config.logfile_nxd_fd != stdout) fclose(config.logfile_nxd_fd); config.logfile_nxd_fd = fopen(config.logfile_nxd, "a"); } } signal_reopen_log_files = 0; } void set_end_dns_records() { config.intr_flag |= INTERRUPT_DNS; if (config.inpacket == 0) { expire_dns_records(); config.dnslastchk = config.tstamp.tv_sec; config.intr_flag &= ~INTERRUPT_DNS; } } void set_end_sessions() { config.intr_flag |= INTERRUPT_SESSION; if (config.inpacket == 0) { end_sessions(); config.intr_flag &= ~INTERRUPT_SESSION; } } static int set_chroot(void) { char *absdir; /* Change to the directory */ if (chdir(config.chroot_dir) != 0) printf("set_chroot: Can not chdir to \"%s\": %s\n", config.chroot_dir,strerror(errno)); /* Always returns an absolute pathname */ absdir = getcwd(NULL, 0); /* Make the chroot call */ if (chroot(absdir) < 0) printf("Could not chroot to \"%s\": absolute: %s: %s\n", config.chroot_dir, absdir, strerror(errno)); if (chdir("/") < 0) printf("Could not chdir to \"/\" after chroot: %s\n", strerror(errno)); return 0; } int drop_privs(void) { struct group *gr; struct passwd *pw; char *endptr; int i; int do_setuid = 0; int do_setgid = 0; unsigned long groupid = 0; unsigned long userid = 0; if (config.group_name != NULL) { do_setgid = 1; if (!isdigit(config.group_name[0])) { gr = getgrnam(config.group_name); if (!gr) { if (config.chroot_dir) { elog("ERROR: you have chrooted and must set numeric group ID.\n"); exit(1); } else { elog("ERROR: couldn't get ID for group %s, group does not exist.", config.group_name); exit(1); } } groupid = gr->gr_gid; } else { groupid = strtoul(config.group_name, &endptr, 10); } } if (config.user_name != NULL) { do_setuid = 1; do_setgid = 1; if (isdigit(config.user_name[0]) == 0) { pw = getpwnam(config.user_name); if (pw != NULL) { userid = pw->pw_uid; } else { printf("[E] User %s not found!\n", config.user_name); } } else { userid = strtoul(config.user_name, &endptr, 10); pw = getpwuid(userid); } if (config.group_name == NULL && pw != NULL) groupid = pw->pw_gid; } if (do_setgid) { if ((i = setgid(groupid)) < 0) printf("Unable to set group ID: %s", strerror(i)); } endgrent(); endpwent(); if (do_setuid) { if (getuid() == 0 && initgroups(config.user_name, groupid) < 0) printf("Unable to init group names (%s/%lu)", config.user_name, groupid); if ((i = setuid(userid)) < 0) printf("Unable to set user ID: %s\n", strerror(i)); } return 0; } int is_valid_path(const char *path) { char dir[STDBUF]; struct stat st; if (path == NULL) return 0; memcpy(dir, path, strnlen(path, STDBUF)); dirname(dir); if (stat(dir, &st) != 0) return 0; if (!S_ISDIR(st.st_mode) || access(dir, W_OK) == -1) return 0; return 1; } int create_pid_file(const char *path) { char pid_buffer[12]; struct flock lock; int fd; if (!path) path = config.pidfile; if (!is_valid_path(path)) printf("PID path \"%s\" aint writable", path); if ((fd = open(path, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1) return ERROR; /* PID file locking */ lock.l_type = F_WRLCK; lock.l_start = 0; lock.l_whence = SEEK_SET; lock.l_len = 0; if (fcntl(fd, F_SETLK, &lock) == -1) { close(fd); return ERROR; } snprintf(pid_buffer, sizeof(pid_buffer), "%d\n", (int)getpid()); if (ftruncate(fd, 0) != 0) { close(fd); return ERROR; } if (write(fd, pid_buffer, strlen(pid_buffer)) != 0) { close(fd); return ERROR; } close(fd); return SUCCESS; } int daemonize() { pid_t pid; int fd; pid = fork(); if (pid > 0) exit(0); /* Parent */ if (pid < 0) return ERROR; setsid(); if ((fd = open("/dev/null", O_RDWR)) >= 0) { dup2(fd, 0); dup2(fd, 1); dup2(fd, 2); if (fd > 2) { close(fd); } } if (config.pidfile) return create_pid_file(config.pidfile); return SUCCESS; } void game_over() { if (config.inpacket == 0) { expire_all_dns_records(); print_pdns_stats(); if (config.handle != NULL) pcap_close(config.handle); config.handle = NULL; if (config.hostname != NULL) free(config.hostname); #ifdef HAVE_PFRING if (config.use_pfring && config.pfhandle != NULL) { pfring_breakloop(config.pfhandle); pfring_close(config.pfhandle); } #endif /* HAVE_PFRING */ end_all_sessions(); if (config.logfile_fd != NULL && config.logfile_fd != stdout) fclose(config.logfile_fd); if (config.logfile_nxd_fd != NULL && config.logfile_nxd_fd != stdout) fclose(config.logfile_nxd_fd); free_config(); olog("\n[*] passivedns ended.\n"); exit(0); } config.intr_flag |= INTERRUPT_END; } void free_config() { if (config.cfilter.bf_insns != NULL) free(config.cfilter.bf_insns); } void print_pdns_stats() { FILE *handle = stdout; if (config.use_stats_file) { handle = fopen(config.statsfile, "w"); if (handle == NULL) { olog("[!] Error opening stats file %s: %s\n", config.statsfile, strerror(errno)); return; } } flog(handle, "\n"); flog(handle, "-- Total DNS records allocated :%12u\n", config.p_s.dns_records); flog(handle, "-- Total DNS assets allocated :%12u\n", config.p_s.dns_assets); flog(handle, "-- Total DNS packets over IPv4/TCP :%12u\n", config.p_s.ip4_dns_tcp); flog(handle, "-- Total DNS packets over IPv6/TCP :%12u\n", config.p_s.ip6_dns_tcp); flog(handle, "-- Total DNS packets over TCP decoded :%12u\n", config.p_s.ip4_dec_tcp_ok + config.p_s.ip6_dec_tcp_ok); flog(handle, "-- Total DNS packets over TCP failed :%12u\n", config.p_s.ip4_dec_tcp_er + config.p_s.ip6_dec_tcp_er); flog(handle, "-- Total DNS packets over IPv4/UDP :%12u\n", config.p_s.ip4_dns_udp); flog(handle, "-- Total DNS packets over IPv6/UDP :%12u\n", config.p_s.ip6_dns_udp); flog(handle, "-- Total DNS packets over UDP decoded :%12u\n", config.p_s.ip4_dec_udp_ok + config.p_s.ip6_dec_udp_ok); flog(handle, "-- Total DNS packets over UDP failed :%12u\n", config.p_s.ip4_dec_udp_er + config.p_s.ip6_dec_udp_er); flog(handle, "-- Total packets received from libpcap :%12u\n", config.p_s.got_packets); flog(handle, "-- Total Ethernet packets received :%12u\n", config.p_s.eth_recv); flog(handle, "-- Total VLAN packets received :%12u\n", config.p_s.vlan_recv); if (config.use_stats_file) { fclose(handle); } } void usage() { olog("\n"); olog("USAGE:\n"); olog(" $ passivedns [options]\n\n"); olog(" OPTIONS:\n\n"); olog(" -i Network device (default: eth0).\n"); olog(" -r Read pcap .\n"); olog(" -H Choose hostname to print in record.\n"); #ifdef HAVE_PFRING olog(" -n Use PF_RING.\n"); olog(" -c Set PF_RING cluster_id.\n"); #endif /* HAVE_PFRING */ olog(" -l Logfile normal queries (default: /var/log/passivedns.log).\n"); olog(" -L Logfile for SRC Error queries (default: /var/log/passivedns.log).\n"); olog(" -y Log to syslog (uses local7 syslog facility).\n"); olog(" -Y Log NXDOMAIN to syslog.\n"); olog(" -d Delimiter between fields in log file (default: ||).\n"); #ifdef HAVE_JSON olog(" -j Use JSON as output in log file.\n"); olog(" -J Use JSON as output in NXDOMAIN log file.\n"); #endif /* HAVE_JSON */ olog(" -f Choose which fields to print (default: -f SMcsCQTAtn).\n"); olog(" -s Print stats on signal (SIGUSR1) to this file.\n"); olog(" -b 'BPF' Berkley Packet Filter (default: 'port 53').\n"); olog(" -p Name of pid file (default: /var/run/passivedns.pid).\n"); olog(" -S Soft memory limit in MB (default: 256).\n"); olog(" -C Seconds to cache DNS objects in memory (default: %u).\n", DNSCACHETIMEOUT); olog(" -P Seconds between printing duplicate DNS info (default %u).\n", DNSPRINTTIME); olog(" -X Manually set DNS RR Types to care about (default: -X 46CDNPRS).\n"); olog(" -N Set interface to non promisc. mode.\n"); olog(" -u User ID to drop privileges to.\n"); olog(" -g Group ID to drop privileges to.\n"); olog(" -T Directory to chroot into.\n"); olog(" -q Quiet mode (no output except errors).\n"); olog(" -D Run as daemon.\n"); olog(" -V Show version and exit.\n"); olog(" -h This help message.\n\n"); olog(" FIELDS:\n"); olog("\n"); olog(" H: YMD-HMS Stamp S: Timestamp(s) M: Timestamp(ms) c: Client IP \n"); olog(" s: Server IP C: Class Q: Query T: Type \n"); olog(" A: Answer t: TTL p: Protocol n: Count \n"); olog(" h: hostname L: QueryLength l: AnswerLength w: Client MAC \n"); olog(" W: Server MAC \n"); olog("\n"); olog(" FLAGS:\n"); olog("\n"); olog(" * For Record Types:\n"); olog(" 4:A 6:AAAA C:CNAME D:DNAME N:NAPTR O:SOA L:LOC F:SPF I:HINFO\n"); olog(" P:PTR R:RP S:SRV T:TXT M:MX n:NS d:DNSEC H:SSHFP\n"); olog(" L also enables GPOS\n"); #ifdef LDNS_RR_TYPE_NSEC3PARAM olog(" d enables DS, DNSKEY, NSEC, NSEC3, RRSIG\n"); #else olog(" d enables DS, DNSKEY, NSEC, NSEC3, NSEC3PARAM, RRSIG\n"); #endif /* LDNS_RR_TYPE_NSEC3PARAM */ olog("\n"); olog(" * For Server Return Code (SRC) Errors:\n"); olog(" f:FORMERR s:SERVFAIL x:NXDOMAIN o:NOTIMPL r:REFUSED\n"); olog(" y:YXDOMAIN e:YXRRSET t:NXRRSET a:NOTAUTH z:NOTZONE\n"); olog("\n"); } void show_version() { olog("\n"); olog("[*] PassiveDNS %s\n", VERSION); olog("[*] By Edward Bjarte Fjellskål \n"); olog("[*] Using %s\n", pcap_lib_version()); olog("[*] Using ldns version %s\n",ldns_version()); #ifdef HAVE_PFRING /* Print PF_RING version if PF_RING is used */ if (config.use_pfring) { char pfv[50]; u_int32_t pf_version; pfring_version(config.pfhandle, &pf_version); snprintf(pfv, 50, "%d.%d.%d", (pf_version & 0xFFFF0000) >> 16, (pf_version & 0x0000FF00) >> 8, pf_version & 0x000000FF); olog("[*] Using PF_RING version %s\n", pfv); } #endif /* HAVE_PFRING */ #ifdef HAVE_JSON if (config.use_json || config.use_json_nxd) { olog("[*] Using jansson version %s\n", JANSSON_VERSION); } #endif /* HAVE_JSON */ } extern int optind, opterr, optopt; // getopt() /* magic main */ int main(int argc, char *argv[]) { int ch = 0; // verbose_already = 0; int daemon = 0; memset(&config, 0, sizeof(globalconfig)); config.inpacket = config.intr_flag = 0; config.dnslastchk = 0; config.bpff = BPFF; config.logfile = "/var/log/passivedns.log"; config.logfile_nxd = "/var/log/passivedns.log"; config.statsfile = "/var/log/passivedns.stats"; config.pidfile = "/var/run/passivedns.pid"; config.promisc = 1; config.output_log = 0; config.output_log_nxd = 0; config.output_syslog = 0; config.output_syslog_nxd = 0; /* Default memory limit: 256 MB */ config.mem_limit_max = (256 * 1024 * 1024); config.dnsprinttime = DNSPRINTTIME; config.dnscachetimeout = DNSCACHETIMEOUT; config.dnsf = 0; config.log_delimiter = "||"; config.fieldsf = 0; config.fieldsf |= FIELD_TIMESTAMP_S; config.fieldsf |= FIELD_TIMESTAMP_MS; config.fieldsf |= FIELD_CLIENT; config.fieldsf |= FIELD_SERVER; config.fieldsf |= FIELD_CLASS; config.fieldsf |= FIELD_QUERY; config.fieldsf |= FIELD_TYPE; config.fieldsf |= FIELD_ANSWER; config.fieldsf |= FIELD_TTL; config.fieldsf |= FIELD_COUNT; config.dnsf |= DNS_CHK_A; config.dnsf |= DNS_CHK_AAAA; config.dnsf |= DNS_CHK_PTR; config.dnsf |= DNS_CHK_CNAME; config.dnsf |= DNS_CHK_DNAME; config.dnsf |= DNS_CHK_NAPTR; config.dnsf |= DNS_CHK_RP; config.dnsf |= DNS_CHK_SRV; #ifdef HAVE_PFRING config.cluster_id = 0; u_int32_t flags = 0; #endif /* HAVE_PFRING */ signal(SIGTERM, game_over); signal(SIGINT, game_over); signal(SIGQUIT, game_over); signal(SIGALRM, sig_alarm_handler); signal(SIGHUP, sig_hup_handler); signal(SIGUSR1, print_pdns_stats); signal(SIGUSR2, expire_all_dns_records); #define ARGS "i:H:r:qc:nyYNjJl:s:L:d:hb:Dp:C:P:S:f:X:u:g:T:V" while ((ch = getopt(argc, argv, ARGS)) != -1) switch (ch) { case 'i': config.dev = optarg; break; case 'H': config.hostname = strdup(optarg); break; case 'r': config.pcap_file = optarg; break; case 'q': config.cflags |= CONFIG_QUIET; break; case 'L': config.output_log_nxd = 1; config.logfile_nxd = optarg; break; case 'l': config.output_log = 1; config.logfile = optarg; break; case 'y': config.output_syslog = 1; break; case 'Y': config.output_syslog_nxd = 1; break; #ifdef HAVE_JSON case 'j': config.use_json = 1; break; case 'J': config.use_json_nxd = 1; break; #endif /* HAVE_JSON */ case 'd': config.log_delimiter = optarg; break; case 'b': config.bpff = optarg; break; case 'p': config.pidfile = optarg; break; case 'C': config.dnscachetimeout = strtol(optarg, NULL, 0); break; case 'P': config.dnsprinttime = strtol(optarg, NULL, 0); break; case 'S': config.mem_limit_max = (strtol(optarg, NULL, 0) * 1024 * 1024); break; case 's': config.use_stats_file = 1; config.statsfile = optarg; break; case 'f': parse_field_flags(optarg); break; case 'X': parse_dns_flags(optarg); break; case 'D': daemon = 1; break; case 'T': config.chroot_dir = optarg; config.chroot_flag = 1; break; case 'u': config.user_name = optarg; config.drop_privs_flag = 1; break; case 'g': config.group_name = optarg; config.drop_privs_flag = 1; break; case 'N': config.promisc = 0; break; #ifdef HAVE_PFRING case 'n': config.use_pfring = 1; break; case 'c': config.cluster_id = strtol(optarg, NULL, 0); break; #endif /* HAVE_PFRING */ case 'h': usage(); exit(0); break; case 'V': show_version(); olog("\n"); exit(0); break; case '?': elog("unrecognized argument: '%c'\n", optopt); break; default: elog("Did not recognize argument '%c'\n", ch); } /* Get hostname if not specified by commandline */ if (config.fieldsf & FIELD_HOSTNAME) { if (config.hostname == NULL) { config.hostname = malloc(HOST_NAME_MAX + 1); gethostname(config.hostname, HOST_NAME_MAX); } } /* Fall back to log file if syslog is not used */ if (config.output_syslog == 0) config.output_log = 1; if (config.output_syslog_nxd == 0) config.output_log_nxd = 1; /* Open log file */ if (config.output_log) { if (config.logfile[0] == '-' && config.logfile[1] == '\0') { config.logfile_fd = stdout; } else { config.logfile_fd = fopen(config.logfile, "a"); if (config.logfile_fd == NULL) { elog("[!] Error opening log file %s\n", config.logfile); exit(1); } } } /* Open NXDOMAIN log file */ if (config.output_log_nxd) { if (config.output_log && strcmp(config.logfile, config.logfile_nxd) == 0) { config.logfile_all = 1; } else if (config.logfile_nxd[0] == '-' && config.logfile_nxd[1] == '\0') { config.logfile_nxd_fd = stdout; } else { config.logfile_nxd_fd = fopen(config.logfile_nxd, "a"); if (config.logfile_nxd_fd == NULL) { elog("[!] Error opening NXDOMAIN log file %s\n", config.logfile_nxd); exit(1); } } } show_version(); #ifdef HAVE_PFRING if (config.use_pfring) { /* PF_RING does not have an option to read PCAP files */ if (config.pcap_file) { elog("[!] Reading PCAP files are not supported when using PF_RING\n"); exit(1); } if (config.dev == NULL) { elog("[!] Must specify capture NIC\n"); exit(1); } flags |= PF_RING_PROMISC; config.pfhandle = pfring_open(config.dev, SNAPLENGTH, flags); if (config.pfhandle == NULL) { elog("[!] Could not start PF_RING capture\n"); exit(1); } config.linktype = DLT_EN10MB; pfring_set_application_name(config.pfhandle, "passivedns"); if (config.cluster_id == 0) config.cluster_id = 99; /* Default cluster_id */ /* Don't add ring to cluster when using ZC or DNA */ if ((strncmp(config.dev, "zc", 2) != 0) && (strncmp(config.dev, "dna", 3)) != 0) { if ((pfring_set_cluster(config.pfhandle, config.cluster_id, cluster_per_flow)) != 0) { elog("[!] Could not set PF_RING cluster_id\n"); } } #ifdef HAVE_PFRING_BPF if (*config.bpff != '\0') { if ((pfring_set_bpf_filter(config.pfhandle, config.bpff)) != 0) { elog("[!] Unable to set bpf filter\n"); } } #endif /* HAVE_PFRING_BPF */ if ((pfring_enable_ring(config.pfhandle)) != 0) { elog("[!] Could not enable ring\n"); exit(1); } if (config.chroot_dir) { olog("[*] Chrooting to dir '%s'..\n", config.chroot_dir); if (set_chroot()) { elog("[!] failed to chroot\n"); exit(1); } } if (config.drop_privs_flag) { olog("[*] Dropping privs...\n"); drop_privs(); } if (daemon) { if (!is_valid_path(config.pidfile)) elog("[*] Unable to create pidfile '%s'\n", config.pidfile); openlog("passivedns", LOG_PID | LOG_CONS, LOG_DAEMON); olog("[*] Daemonizing...\n\n"); daemonize(); } alarm(TIMEOUT); olog("[*] Device: %s\n", config.dev); olog("[*] Sniffing...\n\n"); pfring_loop(config.pfhandle, pfring_got_packet, (u_char*)NULL, 1); game_over(); return 0; } #endif /* HAVE_PFRING */ if (config.pcap_file) { /* Read from PCAP file specified by '-r' switch. */ olog("[*] Reading from file %s\n\n", config.pcap_file); if (!(config.handle = pcap_open_offline(config.pcap_file, config.errbuf))) { elog("[*] Unable to open %s. (%s)", config.pcap_file, config.errbuf); } } else { /* Look up an available device if non specified */ if (config.dev == 0x0) { pcap_if_t *alldevs; if (0 != pcap_findalldevs(&alldevs, config.errbuf)) { elog("[*] Error pcap_findalldevs: %s \n", config.errbuf); exit(1); } config.dev = strdup(alldevs[0].name); pcap_freealldevs(alldevs); } olog("[*] Device: %s\n", config.dev); if ((config.handle = pcap_open_live(config.dev, SNAPLENGTH, config.promisc, 500, config.errbuf)) == NULL) { elog("[*] Error pcap_open_live: %s \n", config.errbuf); exit(1); } if (strlen(config.errbuf) > 0) { /* Fix to enable passivedns to run in an OpenVZ container */ if (strcmp(config.errbuf, "arptype 65535 not supported by libpcap - falling back to cooked socket") == 0) { olog("[*] %s \n", config.errbuf); } else { elog("[*] Error errbuf: %s \n", config.errbuf); exit(1); } } if (config.chroot_dir) { olog("[*] Chrooting to dir '%s'..\n", config.chroot_dir); if(set_chroot()){ elog("[!] failed to chroot\n"); exit(1); } } if (config.drop_privs_flag) { olog("[*] Dropping privs...\n"); drop_privs(); } if (daemon) { if (!is_valid_path(config.pidfile)) elog("[*] Unable to create pidfile '%s'\n", config.pidfile); openlog("passivedns", LOG_PID | LOG_CONS, LOG_DAEMON); olog("[*] Daemonizing...\n\n"); daemonize(); } } if (config.handle == NULL) { game_over(); return 1; } config.linktype = pcap_datalink(config.handle); /* Segfaults on empty pcap! */ if ((pcap_compile(config.handle, &config.cfilter, config.bpff, 1, config.net_mask)) == -1) { elog("[*] Error pcap_compile user_filter: %s\n", pcap_geterr(config.handle)); exit(1); } if (pcap_setfilter(config.handle, &config.cfilter)) { olog("[*] Unable to set pcap filter! %s", pcap_geterr(config.handle)); } alarm(TIMEOUT); if (!config.pcap_file) olog("[*] Sniffing...\n\n"); pcap_loop(config.handle, -1, got_packet, NULL); game_over(); return 0; }