fuzz_common.c File Reference

#include "fuzz_common.h"
#include "lwip/altcp_tcp.h"
#include "lwip/dns.h"
#include "lwip/init.h"
#include "lwip/netif.h"
#include "lwip/sys.h"
#include "lwip/timeouts.h"
#include "lwip/udp.h"
#include "netif/etharp.h"
#include "lwip/apps/httpd.h"
#include "lwip/apps/snmp.h"
#include "lwip/apps/lwiperf.h"
#include "lwip/apps/mdns.h"
#include <string.h>
#include <stdio.h>

Include dependency graph for fuzz_common.c:

Go to the source code of this file.

Macros
#define	FUZZ_DEBUG   LWIP_DBG_OFF
#define	FUZZ_DUMP_PCAP   0
#define	pcap_dump_rx_packet(p)
#define	pcap_dump_tx_packet(p)
#define	pcap_dump_init()
#define	pcap_dump_stop()

Functions
static err_t	lwip_tx_func (struct netif *netif, struct pbuf *p)
static err_t	testif_init (struct netif *netif)
static void	input_pkt (struct netif *netif, const u8_t *data, size_t len)
static void	input_pkts (enum lwip_fuzz_type type, struct netif *netif, const u8_t *data, size_t len)
int	lwip_fuzztest (int argc, char **argv, enum lwip_fuzz_type type, u32_t test_apps)

Variables
static u8_t	pktbuf [200000]
static const u8_t *	remfuzz_ptr
static size_t	remfuzz_len

Macro Definition Documentation

FUZZ_DEBUG

#define FUZZ_DEBUG   LWIP_DBG_OFF

Definition at line 62 of file fuzz_common.c.

FUZZ_DUMP_PCAP

#define FUZZ_DUMP_PCAP   0

Set this to 1 and define FUZZ_DUMP_PCAP_FILE to dump tx and rx packets into a pcap file. At the same time, packet info is written via LWIP_DEBUGF so packets can be matched to other events for debugging them.

Definition at line 75 of file fuzz_common.c.

pcap_dump_init

#define pcap_dump_init

(

)

Definition at line 151 of file fuzz_common.c.

pcap_dump_rx_packet

#define pcap_dump_rx_packet

(

p

)

Definition at line 149 of file fuzz_common.c.

pcap_dump_stop

#define pcap_dump_stop

(

)

Definition at line 152 of file fuzz_common.c.

pcap_dump_tx_packet

#define pcap_dump_tx_packet

(

p

)

Definition at line 150 of file fuzz_common.c.

Function Documentation

input_pkt()

static void input_pkt ( struct netif *  netif, const u8_t *  data, size_t  len  )

static

Definition at line 190 of file fuzz_common.c.

{
  struct pbuf *p, *q;
  err_t err;
 
  if (len > 0xFFFF) {
    printf("pkt too big (%#zX bytes)\n", len);
    return;
  }
 
  p = pbuf_alloc(PBUF_RAW, (u16_t)len, PBUF_POOL);
  LWIP_ASSERT("alloc failed", p);
  for(q = p; q != NULL; q = q->next) {
    MEMCPY(q->payload, data, q->len);
    data += q->len;
  }
  remfuzz_ptr += len;
  remfuzz_len -= len;
  pcap_dump_rx_packet(p);
  err = netif->input(p, netif);
  if (err != ERR_OK) {
    pbuf_free(p);
  }
}

Referenced by input_pkts().

input_pkts()

static void input_pkts ( enum lwip_fuzz_type  type, struct netif *  netif, const u8_t *  data, size_t  len  )

static

Definition at line 215 of file fuzz_common.c.

{
  remfuzz_ptr = data;
  remfuzz_len = len;
 
  if (type == LWIP_FUZZ_SINGLE) {
    input_pkt(netif, data, len);
  } else {
    const u16_t max_packet_size = 1514;
    const size_t minlen = sizeof(u16_t) + (type == LWIP_FUZZ_MULTIPACKET_TIME ? sizeof(u32_t) : 0);
 
    while (remfuzz_len > minlen) {
      u16_t frame_len;
#ifdef LWIP_FUZZ_SYS_NOW
      u32_t external_delay = 0;
#endif
      if (type == LWIP_FUZZ_MULTIPACKET_TIME) {
#ifdef LWIP_FUZZ_SYS_NOW
        /* Extract external delay time from fuzz pool */
        memcpy(&external_delay, remfuzz_ptr, sizeof(u32_t));
        external_delay = ntohl(external_delay);
#endif
        remfuzz_ptr += sizeof(u32_t);
        remfuzz_len -= sizeof(u32_t);
      }
      memcpy(&frame_len, remfuzz_ptr, sizeof(u16_t));
      remfuzz_ptr += sizeof(u16_t);
      remfuzz_len -= sizeof(u16_t);
      frame_len = ntohs(frame_len) & 0x7FF;
      frame_len = LWIP_MIN(frame_len, max_packet_size);
      if (frame_len > remfuzz_len) {
        frame_len = (u16_t)remfuzz_len;
      }
      if (frame_len != 0) {
        if (type == LWIP_FUZZ_MULTIPACKET_TIME) {
#ifdef LWIP_FUZZ_SYS_NOW
          /* Update total external delay time, and check timeouts */
          sys_now_offset += external_delay;
          LWIP_DEBUGF(FUZZ_DEBUG, ("fuzz: sys_now_offset += %u -> %u\n", external_delay, sys_now_offset));
#endif
          sys_check_timeouts();
        }
        input_pkt(netif, remfuzz_ptr, frame_len);
        /* Check timeouts again */
        sys_check_timeouts();
      }
    }
  }
}

Referenced by lwip_fuzztest().

lwip_fuzztest()

int lwip_fuzztest	(	int	argc,
		char **	argv,
		enum lwip_fuzz_type	type,
		u32_t	test_apps
	)

Definition at line 576 of file fuzz_common.c.

{
  struct netif net_test;
  ip4_addr_t addr;
  ip4_addr_t netmask;
  ip4_addr_t gw;
  size_t len;
  err_t err;
  ip_addr_t remote_addr;      /* a IPv4 addr of the destination */
  struct eth_addr remote_mac = ETH_ADDR(0x28, 0x00, 0x00, 0x22, 0x2b, 0x38); /* a MAC addr of the destination */
 
  pcap_dump_init();
  lwip_init();
 
  IP4_ADDR(&addr, 172, 30, 115, 84);
  IP4_ADDR(&netmask, 255, 255, 255, 0);
  IP4_ADDR(&gw, 172, 30, 115, 1);
 
  netif_add(&net_test, &addr, &netmask, &gw, &net_test, testif_init, ethernet_input);
  netif_set_up(&net_test);
  netif_set_link_up(&net_test);
 
  if (test_apps & LWIP_FUZZ_STATICARP) {
    /* Add the ARP entry */
    IP_ADDR4(&remote_addr, 172, 30, 115, 37);
    etharp_add_static_entry(&(remote_addr.u_addr.ip4), &remote_mac);
  }
 
#if LWIP_IPV6
  nd6_tmr(); /* tick nd to join multicast groups */
#endif
  dns_setserver(0, &net_test.gw);
 
  if (test_apps & LWIP_FUZZ_DEFAULT) {
    /* initialize apps */
    httpd_init();
    lwiperf_start_tcp_server_default(NULL, NULL);
    mdns_resp_init();
    mdns_resp_add_netif(&net_test, "hostname");
    snmp_init();
  }
  if (test_apps & LWIP_FUZZ_TCP_CLIENT) {
    tcp_client_pcb = altcp_tcp_new_ip_type(IPADDR_TYPE_ANY);
    LWIP_ASSERT("Error: altcp_new() failed", tcp_client_pcb != NULL);
    tcp_remote_port = 80;
    err = altcp_connect(tcp_client_pcb, &remote_addr, tcp_remote_port, tcp_client_connected);
    LWIP_ASSERT("Error: altcp_connect() failed", err == ERR_OK);
    altcp_recv(tcp_client_pcb, tcp_client_recv);
    altcp_err(tcp_client_pcb, tcp_client_err);
    altcp_poll(tcp_client_pcb, tcp_client_poll, 10);
    altcp_sent(tcp_client_pcb, tcp_client_sent);
  }
  if (test_apps & LWIP_FUZZ_TCP_SERVER) {
    tcp_server_pcb = altcp_tcp_new_ip_type(IPADDR_TYPE_ANY);
    LWIP_ASSERT("Error: altcp_new() failed", tcp_server_pcb != NULL);
    altcp_setprio(tcp_server_pcb, TCP_PRIO_MIN);
    tcp_local_port = 80;
    err = altcp_bind(tcp_server_pcb, IP_ANY_TYPE, tcp_local_port);
    LWIP_ASSERT("Error: altcp_bind() failed", err == ERR_OK);
    tcp_server_pcb = altcp_listen(tcp_server_pcb);
    LWIP_ASSERT("Error: altcp_listen() failed", err == ERR_OK);
    altcp_accept(tcp_server_pcb, tcp_server_accept);
  }
  if (test_apps & LWIP_FUZZ_UDP_CLIENT) {
    udp_client_pcb = udp_new();
    udp_new_ip_type(IPADDR_TYPE_ANY);
    udp_recv(udp_client_pcb, udp_client_recv, NULL);
    udp_remote_port = 161;
    udp_connect(udp_client_pcb, &remote_addr, udp_remote_port);
  }
  if (test_apps & LWIP_FUZZ_UDP_SERVER) {
    udp_server_pcb = udp_new();
    udp_new_ip_type(IPADDR_TYPE_ANY);
    udp_local_port = 161;
    udp_bind(udp_server_pcb, IP_ANY_TYPE, udp_local_port);
    udp_recv(udp_server_pcb, udp_server_recv, NULL);
  }
 
  if(argc > 1) {
    FILE* f;
    const char* filename;
    printf("reading input from file... ");
    fflush(stdout);
    filename = argv[1];
    LWIP_ASSERT("invalid filename", filename != NULL);
    f = fopen(filename, "rb");
    LWIP_ASSERT("open failed", f != NULL);
    len = fread(pktbuf, 1, sizeof(pktbuf), f);
    fclose(f);
    printf("testing file: \"%s\"...\r\n", filename);
  } else {
    len = fread(pktbuf, 1, sizeof(pktbuf), stdin);
  }
  input_pkts(type, &net_test, pktbuf, len);
 
  pcap_dump_stop();
  return 0;
}

Referenced by main().

lwip_tx_func()

static err_t lwip_tx_func ( struct netif *  netif, struct pbuf *  p  )

static

Definition at line 156 of file fuzz_common.c.

{
  pcap_dump_tx_packet(p);
  LWIP_UNUSED_ARG(netif);
  LWIP_UNUSED_ARG(p);
  return ERR_OK;
}

Referenced by testif_init().

testif_init()

static err_t testif_init ( struct netif *  netif )

static

Definition at line 164 of file fuzz_common.c.

{
  netif->name[0] = 'f';
  netif->name[1] = 'z';
  netif->output = etharp_output;
  netif->linkoutput = lwip_tx_func;
  netif->mtu = 1500;
  netif->hwaddr_len = 6;
  netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;
 
  netif->hwaddr[0] = 0x00;
  netif->hwaddr[1] = 0x23;
  netif->hwaddr[2] = 0xC1;
  netif->hwaddr[3] = 0xDE;
  netif->hwaddr[4] = 0xD0;
  netif->hwaddr[5] = 0x0D;
 
#if LWIP_IPV6
  netif->output_ip6 = ethip6_output;
  netif_create_ip6_linklocal_address(netif, 1);
  netif->flags |= NETIF_FLAG_MLD6;
#endif
 
  return ERR_OK;
}

Referenced by lwip_fuzztest().

Variable Documentation

pktbuf

u8_t pktbuf[200000]

static

Definition at line 57 of file fuzz_common.c.

Referenced by lwip_fuzztest(), and test_ip_pktinfo().

remfuzz_len

size_t remfuzz_len

static

Definition at line 59 of file fuzz_common.c.

Referenced by input_pkt(), and input_pkts().

remfuzz_ptr

const u8_t* remfuzz_ptr

static

Definition at line 58 of file fuzz_common.c.

Referenced by input_pkt(), and input_pkts().