version 0.0.1

include/Threads/AttackThread.hpp

@@ -0,0 +1,449 @@
+#pragma once
+
+#include <rte_ether.h>
+
+#include "PacketDissection/PacketContainerLean.hpp"
+#include "PacketDissection/PacketInfo.hpp"
+#include "PacketDissection/PacketInfoIpv4Tcp.hpp"
+#include "RandomNumberGenerator.hpp"
+#include "Threads/ForwardingThread.hpp"
+
+class AttackThread : public Thread {
+  private:
+    inline void run() {
+        std::cout << "\nRunning on lcore " << rte_lcore_id()
+                  << ". [Ctrl+C to quit]\n"
+                  << std::endl;
+
+        while (likely(_quit == false)) {
+            // have skip iterate field in config and skip for nb of packets
+            iterate();
+#ifdef SINGLE_ITERATION
+            _quit = false;
+#endif
+        }
+
+        _running = false;
+    }
+
+    PacketContainerLean* _pkt_container_to_dave;
+    PacketContainerLean* _pkt_container_to_alice;
+    RandomNumberGenerator _rng;
+    unsigned int _nb_worker_threads;
+
+    rte_ether_addr _bob_mac;
+    rte_ether_addr _src_mac;
+
+    uint32_t _bob_ip;
+    uint32_t _alice_ip;
+
+    uint8_t _tcp_flags;
+
+    enum AttackType { SYN_FLOOD, SYN_FIN_ACK, SYN_FIN, UDP_FLOOD, NO_ATTACK };
+    AttackType _attack_type;
+
+    rte_mbuf* _mbuf_origin;
+
+    uint64_t _cycles_old;
+    uint64_t _data_rate;
+    uint64_t _nb_attack_packets;
+    uint64_t _data_rate_per_cycle;
+    uint64_t _delta_cycles_mean;
+
+    uint64_t _total_nb_pkts_to_dave;
+    uint64_t _total_nb_pkts_from_dave;
+    uint64_t _total_nb_pkts_to_alice;
+    uint64_t _total_data_volume_to_alice;
+    uint64_t _total_nb_pkts_from_alice;
+    uint64_t _total_data_volume_from_alice;
+
+    int _iterations;
+    uint _call_send_pkts_every_nth_iteration;
+
+    // ============ not needed
+
+    uint16_t _nb_pkts_to_dave;
+    uint16_t _nb_pkts_to_alice;
+
+    PacketType _pkt_type;
+
+    uint64_t _cycles;
+    uint64_t _delta_cycles;
+    uint64_t _data_volume;
+
+    uint64_t _hz;
+    int _n;
+
+    /**
+     * This method is used in a loop so every parameter is created before
+     * the loop. These you pass to the function which initializes the
+     * variables.
+     *
+     * @param[in] pkt_size
+     * @param[in] cycles
+     * @param[in] delta_cycles
+     * @param[in] cycles_old
+     * @param[in] data_volume
+     * @param[in] data_rate_per_cycle
+     * @param[out] nb_attack_packets
+     */
+    inline void calculate_nb_attack_packets(int pkt_size) {
+
+        _cycles = rte_get_tsc_cycles();
+        _delta_cycles = _cycles - _cycles_old;
+
+        // data volume to send in bit
+        _data_volume = _delta_cycles * _data_rate_per_cycle;
+
+        _nb_attack_packets = int(_data_volume / (pkt_size * 8));
+
+        if (unlikely(_nb_attack_packets == 0)) {
+            _nb_attack_packets = 2;
+        }
+
+        if (unlikely(_nb_attack_packets >= NUM_MBUF_ARRS * BURST_SIZE - 1)) {
+            _nb_attack_packets = NUM_MBUF_ARRS * BURST_SIZE - 1;
+            LOG_INFO << "maximum reached" << LOG_END;
+        }
+
+        LOG_INFO << "Number of cycles: " << _delta_cycles << LOG_END;
+
+        LOG_INFO << "Duration of a period: " << (_delta_cycles / _hz)
+                 << LOG_END;
+
+        // set _cycles_old
+        _cycles_old = _cycles;
+    }
+
+    /**
+     * @brief
+     *
+     * @param byte1
+     * @param byte2
+     * @param byte3
+     * @param byte4
+     * @return uint32_t
+     */
+    inline uint32_t calculate_ipv4_address(uint8_t byte1, uint8_t byte2,
+                                           uint8_t byte3, uint8_t byte4) {
+        return byte1 * 2 ^ 24 + byte2 * 2 ^ 16 + byte3 * 2 ^ 8 + byte4;
+    }
+
+    /**
+     * @brief Create a bulk of attack packets, add them to the packets
+     * already in the PacketContainer.
+     */
+    inline void create_attack_packet_burst_tcp(uint32_t nb_pkts,
+                                               uint8_t tcp_flags) {
+
+        rte_mempool* mempool = _pkt_container_to_dave->get_mempool_lean();
+
+        rte_mbuf* m_copy;
+
+        for (int i = 0; i < nb_pkts; ++i) {
+            m_copy = rte_pktmbuf_copy(_mbuf_origin, mempool, 0, UINT32_MAX);
+
+            if (unlikely(m_copy == nullptr)) {
+                throw std::runtime_error("m_copy is null");
+            }
+
+            PacketInfoIpv4Tcp* pkt_info = static_cast<PacketInfoIpv4Tcp*>(
+                PacketInfoCreator::create_mini_pkt_info(m_copy, IPv4TCP));
+
+            pkt_info->set_src_ip(_rng.gen_rdm_32_bit());
+
+            // select one of the following two, which one suits you better
+            // pkt_info->recalculate_checksums();
+            pkt_info->prepare_offloading_checksums();
+
+            _pkt_container_to_dave->add_mbuf(m_copy);
+
+            delete pkt_info;
+            pkt_info = nullptr;
+        }
+    }
+
+    /**
+     * @brief Create a bulk of attack packets, add them to the packets
+     * already in the PacketContainer.
+     */
+    inline void create_attack_packet_burst_udp(uint32_t nb_pkts) {
+
+        rte_mempool* mempool = _pkt_container_to_dave->get_mempool_lean();
+
+        rte_mbuf* m_copy;
+
+        for (int i = 0; i < nb_pkts; ++i) {
+            m_copy = rte_pktmbuf_copy(_mbuf_origin, mempool, 0, UINT32_MAX);
+
+            if (unlikely(m_copy == nullptr)) {
+                throw std::runtime_error("m_copy is null");
+            }
+
+            PacketInfoIpv4Udp* pkt_info = static_cast<PacketInfoIpv4Udp*>(
+                PacketInfoCreator::create_mini_pkt_info(m_copy, IPv4UDP));
+
+            pkt_info->set_src_ip(_rng.gen_rdm_32_bit());
+
+            // select one of the following two, which one suits you better
+            // pkt_info->recalculate_checksums();
+            pkt_info->prepare_offloading_checksums(false);
+
+            _pkt_container_to_dave->add_mbuf(m_copy);
+
+            delete pkt_info;
+            pkt_info = nullptr;
+        }
+    }
+
+    inline void calculate_cycles() {
+        _cycles = rte_get_tsc_cycles();
+        _delta_cycles = _cycles - _cycles_old;
+
+        if (_n == 1) {
+            _delta_cycles_mean = _delta_cycles;
+        }
+
+        _delta_cycles_mean =
+            (_delta_cycles_mean + _delta_cycles / _n) * _n / (_n + 1);
+        ++_n;
+
+        LOG_INFO << "delta_cycles_mean: " << _delta_cycles_mean << LOG_END;
+
+        // LOG_INFO << "Duration of a period: " << (_delta_cycles / _hz) <<
+        // LOG_END;
+
+        _cycles_old = _cycles;
+    }
+
+  public:
+    bool _do_attack;
+
+    inline AttackThread(PacketContainerLean* pkt_container_to_dave,
+                        PacketContainerLean* pkt_container_to_alice,
+                        unsigned int nb_worker_threads)
+
+        : Thread(), _nb_worker_threads(nb_worker_threads), _iterations(0),
+          _call_send_pkts_every_nth_iteration(0),
+          _pkt_container_to_dave(pkt_container_to_dave),
+          _pkt_container_to_alice(pkt_container_to_alice), _nb_pkts_to_dave(0),
+          _nb_pkts_to_alice(0), _total_nb_pkts_to_dave(0), 
+          _total_nb_pkts_from_dave(0), _total_nb_pkts_to_alice(0), 
+          _total_data_volume_to_alice(0), _total_nb_pkts_from_alice(0), 
+          _total_data_volume_from_alice(0), _pkt_type(NONE), _cycles(0), 
+          _delta_cycles(0), _data_volume(0), _nb_attack_packets(0), 
+          _hz(rte_get_tsc_hz()), _delta_cycles_mean(0), _n(1), 
+          _bob_mac({.addr_bytes = {60, 253, 254, 163, 231, 48}}),
+          _src_mac({.addr_bytes = {60, 253, 254, 163, 231, 88}}),
+          _bob_ip(167772162), _alice_ip(167772161), _tcp_flags(0),
+          _mbuf_origin(nullptr), _do_attack(false) {
+
+        // ===== calculate stuff regarding clock calculation ===== //
+
+        /*
+        _data_rate =
+            int((std::stoi(Configurator::instance()->get_config_as_string(
+                     "attack_rate")) *
+                 1000000) /
+                _nb_worker_threads);
+
+        _data_rate_per_cycle = int(_data_rate / _hz);
+
+        // if data_rate < hz
+        if (_data_rate_per_cycle == 0) {
+            _data_rate_per_cycle = _data_rate;
+        }
+
+        _cycles_old = rte_get_tsc_cycles();
+        */
+
+        // ===== read and set attack type ===== //
+
+        std::string attack_type =
+            Configurator::instance()->get_config_as_string("attack_type");
+
+        if (attack_type == "none") {
+            _attack_type = NO_ATTACK;
+        } else if (attack_type == "syn_flood") {
+            _attack_type = SYN_FLOOD;
+            _tcp_flags = 0b00000010;
+        } else if (attack_type == "syn_fin") {
+            _attack_type = SYN_FIN;
+            _tcp_flags = 0b00000011;
+        } else if (attack_type == "syn_fin_ack") {
+            _attack_type = SYN_FIN_ACK;
+            _tcp_flags = 0b00010011;
+        } else if (attack_type == "udp_flood") {
+            _attack_type = UDP_FLOOD;
+        } else {
+            throw std::runtime_error(
+                "String attack_type in config_attacker.json "
+                "does not match any type");
+        }
+
+        LOG_INFO << "Attack type " << attack_type << " is set." << LOG_END;
+
+        // ===== set number of attack packets ===== //
+
+        _nb_attack_packets =
+            Configurator::instance()->get_config_as_unsigned_int(
+                "number_of_attack_packets_per_thread_per_send_call");
+
+        _call_send_pkts_every_nth_iteration =
+            Configurator::instance()->get_config_as_unsigned_int(
+                "call_send_pkts_every_nth_iteration");
+
+        LOG_INFO << "number_of_attack_packets_per_thread_per_send_call : "
+                 << _nb_attack_packets << LOG_END;
+
+        // ===== create origin attack packet ===== //
+
+        _mbuf_origin =
+            rte_pktmbuf_alloc(_pkt_container_to_dave->get_mempool_lean());
+
+        if (_attack_type == SYN_FLOOD || _attack_type == SYN_FIN ||
+            _attack_type == SYN_FIN_ACK) {
+
+            PacketInfo* pkt_info_plain =
+                PacketInfoCreator::create_pkt_info(_mbuf_origin, IPv4TCP);
+
+            PacketInfoIpv4Tcp* pkt_info_origin =
+                static_cast<PacketInfoIpv4Tcp*>(pkt_info_plain);
+
+            pkt_info_origin->fill_payloadless_tcp_packet(
+                _src_mac, _bob_mac, _rng.gen_rdm_32_bit(), _bob_ip,
+                _rng.gen_rdm_16_bit(), 80, 1, 1, _tcp_flags, 64);
+
+            pkt_info_origin->prepare_offloading_checksums();
+
+            delete pkt_info_origin;
+            pkt_info_origin = nullptr;
+
+        } else if (_attack_type == UDP_FLOOD) {
+
+            PacketInfo* pkt_info_plain =
+                PacketInfoCreator::create_pkt_info(_mbuf_origin, IPv4UDP);
+
+            PacketInfoIpv4Udp* pkt_info_origin =
+                static_cast<PacketInfoIpv4Udp*>(pkt_info_plain);
+
+            pkt_info_origin->fill_payloadless_udp_packet(
+                _src_mac, _bob_mac, _rng.gen_rdm_32_bit(), _bob_ip,
+                _rng.gen_rdm_16_bit(), 80);
+
+            pkt_info_origin->prepare_offloading_checksums(false);
+
+            delete pkt_info_origin;
+            pkt_info_origin = nullptr;
+        }
+
+        // ===== attack rate
+    }
+
+    inline ~AttackThread() { rte_pktmbuf_free(_mbuf_origin); }
+
+    inline static int s_run(void* thread_vptr) {
+        AttackThread* thread = static_cast<AttackThread*>(thread_vptr);
+        thread->run();
+
+        return 0;
+    }
+
+    inline void iterate() {
+
+        // ===== ALICE <--[MALLORY]-- DAVE/BOB ===== //
+
+        _pkt_container_to_alice->poll_mbufs(_nb_pkts_to_alice);
+        _total_nb_pkts_from_dave += _nb_pkts_to_alice;
+
+        // continue if no packets are received
+        if (likely(_nb_pkts_to_alice > 0)) {
+            // drop all packets that do not go to the mallory interface
+            for (int i = 0; i < _nb_pkts_to_alice; i++) {
+
+                rte_mbuf* mbuf = _pkt_container_to_alice->get_mbuf_at_index(i);
+
+                uint32_t ip4_addr =
+                    PacketInfoCreator::get_dst_ip_from_mbuf(mbuf);
+
+                if (likely(ip4_addr != 0 && ip4_addr != _alice_ip)) {
+                    _pkt_container_to_alice->drop_polled_mbuf(i);
+                } else {
+                    _total_data_volume_to_alice += rte_pktmbuf_pkt_len(mbuf);
+                }
+            }
+            _total_nb_pkts_to_alice += _pkt_container_to_alice->send_mbufs();
+        }
+
+        // ===== ALICE --[MALLORY]--> DAVE/BOB ===== //
+
+        _pkt_container_to_dave->poll_mbufs(_nb_pkts_to_dave);
+        _total_nb_pkts_from_alice += _nb_pkts_to_dave;
+        for (int i = 0; i < _nb_pkts_to_dave; ++i) {
+            _total_data_volume_from_alice += rte_pktmbuf_pkt_len(
+                _pkt_container_to_dave->get_mbuf_at_index(i));
+        }
+
+        if (unlikely(_iterations == _call_send_pkts_every_nth_iteration)) {
+            _iterations = 0;
+
+            // create attack packets
+            if (likely(_do_attack)) {
+                if (_attack_type == SYN_FLOOD || _attack_type == SYN_FIN ||
+                    _attack_type == SYN_FIN_ACK) {
+                    create_attack_packet_burst_tcp(_nb_attack_packets,
+                                                   _tcp_flags);
+                } else if (_attack_type == UDP_FLOOD) {
+                    create_attack_packet_burst_udp(_nb_attack_packets);
+                }
+            } else{
+                _total_nb_pkts_to_dave = 0;
+                _total_nb_pkts_from_dave = 0;
+                _total_nb_pkts_to_alice = 0;
+                _total_data_volume_to_alice = 0;
+                _total_nb_pkts_from_alice = 0;
+                _total_data_volume_from_alice = 0;
+            }
+        }
+
+        ++_iterations;
+
+        _total_nb_pkts_to_dave = _total_nb_pkts_to_dave +
+                             _pkt_container_to_dave->send_mbufs();
+
+        // calculate_cycles();
+    }
+
+    inline uint64_t get_total_nb_pkts_to_dave() { 
+        return _total_nb_pkts_to_dave; 
+    }
+
+    inline uint64_t get_total_nb_pkts_from_dave() {
+        return _total_nb_pkts_from_dave;
+    }
+
+    inline uint64_t get_total_nb_pkts_to_alice() {
+        return _total_nb_pkts_to_alice;
+    }
+
+    inline uint64_t get_total_data_volume_to_alice() {
+        return _total_data_volume_to_alice;
+    }
+
+    inline uint64_t get_total_nb_pkts_from_alice() {
+        return _total_nb_pkts_from_alice;
+    }
+
+    inline uint64_t get_total_data_volume_from_alice() {
+        return _total_data_volume_from_alice;
+    }
+
+    inline int get_atk_pkt_type() {
+        if ((_attack_type == SYN_FLOOD) || (_attack_type == SYN_FIN) ||
+            (_attack_type == SYN_FIN_ACK)) {
+
+            return 1;
+        }
+        return 0;
+    }
+};

include/Threads/DefenseThread.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "PacketDissection/PacketContainer.hpp"
+#include "Treatment/Treatment.hpp"
+
+#include "Threads/ForwardingThread.hpp"
+
+class DefenseThread : public Thread {
+  public:
+    DefenseThread(MbufContainerReceiving* mbuf_container_from_inside,
+                  MbufContainerReceiving* mbuf_container_from_outside,
+                  MbufContainerTransmitting* mbuf_container_to_inside,
+                  MbufContainerTransmitting* mbuf_container_to_outside);
+
+    ~DefenseThread() { delete _treatment; }
+
+    void start_treat() { _do_treat = true; }
+
+    void stop_treat() { _do_treat = false; }
+
+    bool _do_treat;
+
+    /**
+     * @brief Wrapper for the run-method
+     *
+     * Static method that calls the run method on a specific thread
+     * object. This is necessary since s_run is used to start a new thread with
+     * the dpdk function "rte_eal_remote_launch" which only takes specific types
+     * of funktions.
+     *
+     * @param thread_obj object of type thread the run method is to be called on
+     * @return int
+     */
+    static int s_run(void* thread_obj);
+
+  private:
+    Treatment* _treatment;
+
+    MbufContainerReceiving* _mbuf_container_from_outside;
+    MbufContainerReceiving* _mbuf_container_from_inside;
+    MbufContainerTransmitting* _mbuf_container_to_outside;
+    MbufContainerTransmitting* _mbuf_container_to_inside;
+
+    /**
+     * @brief Run thread
+     *
+     * "Main"-routine of a thread. It is executed until the application is quit
+     * or killed.
+     */
+    void run();
+};

include/Threads/ForwardingThread.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "PacketDissection/PacketContainer.hpp"
+#include "PacketDissection/PacketContainerLean.hpp"
+
+#include "Threads/Thread.hpp"
+
+class ForwardingThread : public Thread {
+  public:
+    /**
+     * @brief Construct a new Thread object
+     *
+     * @param pkt_container_to_inside PacketContainer of packets that come from
+     * the outside port and are to be forwarded to the inside port
+     * @param pkt_container_to_outside PacketContainer of packets that come from
+     * the inside port and are to be forwarded to the outside port
+     */
+    ForwardingThread(PacketContainer* pkt_container_to_inside,
+                     PacketContainer* pkt_container_to_outside)
+        : Thread(), _pkt_container_to_inside(pkt_container_to_inside),
+          _pkt_container_to_outside(pkt_container_to_outside) {}
+
+    ForwardingThread(PacketContainerLean* pkt_container_to_inside,
+                     PacketContainerLean* pkt_container_to_outside)
+        : Thread(), _pkt_container_to_inside_lean(pkt_container_to_inside),
+          _pkt_container_to_outside_lean(pkt_container_to_outside) {}
+
+  protected:
+    /**
+     * @brief in AttackThread: to dave
+     */
+    PacketContainer* _pkt_container_to_inside;
+    PacketContainerLean* _pkt_container_to_inside_lean;
+    // PacketContainerLean* _pkt_container_from_outside_lean;
+
+    /**
+     * @brief in AttackThread: to alice
+     */
+    PacketContainer* _pkt_container_to_outside;
+    PacketContainerLean* _pkt_container_to_outside_lean;
+};

include/Threads/StatisticsThread.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <rte_ring_core.h>
+#include <rte_ring_elem.h>
+
+#include <string>
+
+#include "Threads/Thread.hpp"
+
+struct Stats {
+    uint64_t attacks;
+    uint64_t bytes;
+    uint64_t dropped;
+    uint64_t packets;
+    uint64_t work_time;
+    uint64_t syn_level;
+
+    Stats* operator+=(const Stats* new_stats);
+};
+
+struct StatsMonitor {
+    double attacks_per_second;
+    double attacks_percent;
+    double bytes_per_second;
+    double dropped_per_second;
+    double dropped_percent;
+    double packets_per_second;
+    double proc_speed; // process speed
+    double total_time;
+};
+
+class StatisticsThread : public Thread {
+  public:
+    static int s_run(void* thread_vptr);
+
+    void enqueue_statistics(int& id, Stats* new_stats);
+    void update_statistics(Stats* new_stats);
+
+  private:
+    void run();
+    static rte_ring* _s_queue[16];
+    static Stats* _s_stats;
+};

include/Threads/Thread.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <stdint.h>
+
+class Thread {
+  public:
+    /**
+     * @brief Construct a new Thread object
+     */
+    inline Thread() : _quit(false), _running(true) {}
+
+    /**
+     * @brief quit the thread
+     */
+    inline void quit() { _quit = true; }
+
+    inline bool is_running() { return _running; }
+
+  protected:
+    bool _quit;
+    bool _running;
+    uint64_t _cycles_old;
+};