examples: Move in RIOT/applications

examples/sniffer/Makefile

@@ -0,0 +1,23 @@
+# Set the name of your application:
+APPLICATION = sniffer
+
+# If no BOARD is found in the environment, use this default:
+BOARD ?= native
+
+# This has to be the absolute path to the RIOT base directory:
+RIOTBASE ?= $(CURDIR)/../..
+
+# Define modules that are used
+USEMODULE += fmt
+USEMODULE += gnrc
+USEMODULE += netdev_default
+USEMODULE += auto_init_gnrc_netif
+USEMODULE += shell
+USEMODULE += shell_commands
+USEMODULE += ps
+USEMODULE += ztimer64_usec
+
+# Change this to 0 show compiler invocation lines by default:
+QUIET ?= 1
+
+include $(RIOTBASE)/Makefile.include

examples/sniffer/Makefile.ci

@@ -0,0 +1,25 @@
+BOARD_INSUFFICIENT_MEMORY := \
+    arduino-duemilanove \
+    arduino-leonardo \
+    arduino-mega2560 \
+    arduino-nano \
+    arduino-uno \
+    atmega328p-xplained-mini \
+    atmega328p \
+    bluepill-stm32f030c8 \
+    i-nucleo-lrwan1 \
+    nucleo-f030r8 \
+    nucleo-f031k6 \
+    nucleo-f042k6 \
+    nucleo-l011k4 \
+    nucleo-l031k6 \
+    nucleo-l053r8 \
+    samd10-xmini \
+    slstk3400a \
+    stk3200 \
+    stm32f030f4-demo \
+    stm32f0discovery \
+    stm32g0316-disco \
+    stm32l0538-disco \
+    waspmote-pro \
+    #

examples/sniffer/README.md

@@ -0,0 +1,22 @@
+About
+=====
+
+This application is built to run together with the script `./tools/sniffer.py`
+as a sniffer for (wireless) data traffic. This application works with any board
+with any network device that supports the gnrc network stack (or precisely the
+gnrc parts up to the link-layer). Further the network device (and its driver)
+needs to support promiscuous and raw mode for usable output. Finally the board
+needs to include auto-initialization code for the targeted network device.
+
+
+Usage
+=====
+
+Compile and flash this application to the board of your choice. You can check
+if everything on the RIOT side works by connecting to the board via UART and by
+checking with `ifconfig` if a network device is available. Also note the
+interface number for the following commands. Then you can check with
+`ifconfig <iface> promisc` if promiscuous mode is supported and with
+`ifconfig <iface> raw` if raw mode is supported by the driver/network device.
+
+For further information on setting up the host part, see `./tools/README.md`.

examples/sniffer/main.c

@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2015-18 Freie Universität Berlin
+ *
+ * This file is subject to the terms and conditions of the GNU Lesser
+ * General Public License v2.1. See the file LICENSE in the top level
+ * directory for more details.
+ */
+
+/**
+ * @defgroup    app_sniffer
+ * @brief       Sniffer application based on the new network stack
+ * @{
+ *
+ * @file
+ * @brief       Sniffer application for RIOT
+ *
+ * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
+ * @author      Martine Lenders <m.lenders@fu-berlin.de>
+ *
+ * @}
+ */
+
+#include <stdio.h>
+
+#include "fmt.h"
+#include "thread.h"
+#include "shell.h"
+#include "net/gnrc.h"
+#include "ztimer64.h"
+
+/**
+ * @brief   Buffer size used by the shell
+ */
+#define SHELL_BUFSIZE           (64U)
+
+/**
+ * @brief   Priority of the RAW dump thread
+ */
+#define RAWDUMP_PRIO            (THREAD_PRIORITY_MAIN - 1)
+
+/**
+ * @brief   Message queue size of the RAW dump thread
+ */
+#define RAWDUMP_MSG_Q_SIZE      (32U)
+
+/**
+ * @brief   Stack for the raw dump thread
+ */
+static char rawdmp_stack[THREAD_STACKSIZE_SMALL];
+
+/**
+ * @brief   Make a raw dump of the given packet contents
+ */
+void dump_pkt(gnrc_pktsnip_t *pkt)
+{
+    gnrc_pktsnip_t *snip = pkt;
+    uint8_t lqi = 0;
+    if (pkt->next) {
+        if (pkt->next->type == GNRC_NETTYPE_NETIF) {
+            gnrc_netif_hdr_t *netif_hdr = pkt->next->data;
+            lqi = netif_hdr->lqi;
+            pkt = gnrc_pktbuf_remove_snip(pkt, pkt->next);
+        }
+    }
+    uint64_t now_us = ztimer64_now(ZTIMER64_USEC);
+
+    print_str("rftest-rx --- len ");
+    print_u32_hex((uint32_t)gnrc_pkt_len(pkt));
+    print_str(" lqi ");
+    print_byte_hex(lqi);
+    print_str(" rx_time ");
+    print_u64_hex(now_us);
+    print_str("\n");
+    while (snip) {
+        for (size_t i = 0; i < snip->size; i++) {
+            print_byte_hex(((uint8_t *)(snip->data))[i]);
+            print_str(" ");
+        }
+        snip = snip->next;
+    }
+    print_str("\n\n");
+
+    gnrc_pktbuf_release(pkt);
+}
+
+/**
+ * @brief   Event loop of the RAW dump thread
+ *
+ * @param[in] arg   unused parameter
+ */
+void *rawdump(void *arg)
+{
+    msg_t msg_q[RAWDUMP_MSG_Q_SIZE];
+
+    (void)arg;
+    msg_init_queue(msg_q, RAWDUMP_MSG_Q_SIZE);
+    while (1) {
+        msg_t msg;
+
+        msg_receive(&msg);
+        switch (msg.type) {
+            case GNRC_NETAPI_MSG_TYPE_RCV:
+                dump_pkt((gnrc_pktsnip_t *)msg.content.ptr);
+                break;
+            default:
+                /* do nothing */
+                break;
+        }
+    }
+
+    /* never reached */
+    return NULL;
+}
+
+/**
+ * @brief   Maybe you are a golfer?!
+ */
+int main(void)
+{
+    gnrc_netreg_entry_t dump;
+
+    puts("RIOT sniffer application");
+
+    /* start and register rawdump thread */
+    puts("Run the rawdump thread and register it");
+    dump.target.pid = thread_create(rawdmp_stack, sizeof(rawdmp_stack), RAWDUMP_PRIO,
+                                    THREAD_CREATE_STACKTEST, rawdump, NULL, "rawdump");
+    dump.demux_ctx = GNRC_NETREG_DEMUX_CTX_ALL;
+    gnrc_netreg_register(GNRC_NETTYPE_UNDEF, &dump);
+
+    /* start the shell */
+    puts("All ok, starting the shell now");
+    char line_buf[SHELL_DEFAULT_BUFSIZE];
+    shell_run(NULL, line_buf, SHELL_DEFAULT_BUFSIZE);
+
+    return 0;
+}

examples/sniffer/tools/README.md

@@ -0,0 +1,114 @@
+# RIOT Sniffer Application
+
+
+## About
+
+This sniffer script can be used to monitor and capture network traffic using
+a RIOT based node. It is primarily designed for sniffing wireless data traffic,
+but can also well be used for wired network traffic, as long as used network
+devices support promiscuous mode and output of raw data.
+
+The python script `sniffer.py` requires a RIOT node running the sniffer app, its
+source code is located in this repository (see main folder). This node outputs
+received network traffic via a serial port or a network socket in the common
+Wireshark/libpcap (pcap) format. This output is then parsed by the `sniffer.py`
+script included in this folder run on a host computer.
+
+The `sniffer.py` script is a modified version of [malvira's script](https://github.com/malvira/libmc1322x/blob/master/tools/rftestrx2pcap.py)
+for the Redbee Ecotag (https://github.com/malvira/libmc1322x/wiki/wireshark).
+
+## Dependencies
+
+The `sniffer.py` script is written in Python and needs [pyserial](https://pypi.python.org/pypi/pyserial).
+
+Installing the dependencies:
+
+
+#### Debuntu
+    apt-get install python-serial
+
+#### PIP
+    pip install pyserial
+
+
+## Usage
+
+General usage:
+
+1.  Flash an applicable RIOT node with the sniffer application (insert path to
+    RIOT source and board name), as follows:
+```
+$ git clone https://github.com/RIOT-OS/applications/
+$ cd applications/sniffer
+$ BOARD=<name> make clean all flash
+```
+
+2.  Run the `sniffer.py` script (change to subfolder `tools/`) as follows :
+    For serial port:
+```
+$ ./sniffer.py [-b baudrate] <tty> <channel> [outfile]
+```
+For network socket:
+```
+$ ./sniffer.py <host>:<port> <channel> [outfile]
+```
+
+You should see output like below:
+```
+ifconfig 3 set chan 26
+ifconfig 3 raw
+ifconfig 3 promisc
+RX: 0
+```
+
+For detailed information on the parameters use the scripts on-line help:
+
+```
+./sniffer.py -h
+```
+
+### Examples
+
+The following examples are made when using the sniffer application together with
+an `iotlab-m3` node that is connected to `/dev/ttyUSB1`(or COM1) (`serial` connection type)
+and runs per default with a baudrate of 500000. For the `socket` connection type port 20000
+is used.
+
+#### Linux (serial)
+
+Dump packets to a file:
+```
+$ ./sniffer.py -b 500000 /dev/ttyUSB1 17 foo.pcap
+```
+
+This .pcap can then be opened in Wireshark.
+
+Alternatively for live captures, you can pipe directly into Wireshark with:
+```
+$ ./sniffer.py -b 500000 /dev/ttyUSB1 17 | wireshark -k -i -
+```
+
+#### Windows (serial)
+
+For windows you can use the optional third argument to output to a
+.pcap:
+
+```
+$ ./sniffer.py -b 500000 COM1 17 foo.pcap
+```
+
+#### IoT-Lab Testbed (socket)
+
+Start an experiment either via the website provided by the IoT-Lab testbed or
+by using the RIOT specific iotlab Makefile with 3 neighboring `iotlab-m3` nodes,
+where one of them runs the sniffer application and the others run the `gnrc_networking` application.
+
+Now you can bind the sniffer node to localhost:
+ssh -L 20000:_node-id_:20000 _user_@_site_.iot-lab.info
+
+Then you can dump or observe the traffic generated by the other nodes running the `gnrc_networking`
+application via one of the following commands:
+```
+$ ./sniffer.py localhost:20000 26 foo.pcap
+$ ./sniffer.py localhost:20000 26 | wireshark -k -i -
+```