CCats/daemon/src/CovertChannel/CovertChannel.cpp

#include "../../include/CovertChannel/CovertChannel.h"
#include <cstdlib>
#include <iostream>
#include <thread>

CovertChannel::CovertChannel(const std::string &innerInterface, const std::string &outerInterface, const std::string &innerForwardFilter,
                             const std::string &outerForwardFilter, const std::string &innerChannelFilter, const std::string &outerChannelFilter,
                             const std::string &outerPartnerFilter)
    : innerSender(innerInterface), outerSender(outerInterface) {
	Tins::SnifferConfiguration config;
	config.set_promisc_mode(true);
	config.set_immediate_mode(true);
	config.set_direction(PCAP_D_IN);
	config.set_snap_len(1500);

	try {
		innerForwardSniffer = new Tins::Sniffer(innerInterface, config);
		outerForwardSniffer = new Tins::Sniffer(outerInterface, config);
		innerChannelSniffer = new Tins::Sniffer(innerInterface, config);
		outerChannelSniffer = new Tins::Sniffer(outerInterface, config);
		outerPartnerSniffer = new Tins::Sniffer(outerInterface, config);

		setFilter(innerForwardFilter, outerForwardFilter, innerChannelFilter, outerChannelFilter, outerPartnerFilter);
	} catch (const Tins::pcap_error &e) {
		std::cerr << "An error accured setting up the sniffer: " << e.what() << std::endl;
		std::exit(EXIT_FAILURE);
	}
}

CovertChannel::~CovertChannel() {
	innerForwardSniffer->stop_sniff();
	outerForwardSniffer->stop_sniff();
	innerChannelSniffer->stop_sniff();
	outerChannelSniffer->stop_sniff();
	outerPartnerSniffer->stop_sniff();
	delete (innerForwardSniffer);
	delete (outerForwardSniffer);
	delete (innerChannelSniffer);
	delete (outerChannelSniffer);
	delete (outerPartnerSniffer);
}

void CovertChannel::setFilter(const std::string &innerForwardFilter, const std::string &outerForwardFilter, const std::string &innerChannelFilter,
                              const std::string &outerChannelFilter, const std::string &outerPartnerFilter) {
	innerForwardSniffer->set_filter(innerForwardFilter);
	outerForwardSniffer->set_filter(outerForwardFilter);
	innerChannelSniffer->set_filter(innerChannelFilter);
	outerChannelSniffer->set_filter(outerChannelFilter);
	outerPartnerSniffer->set_filter(outerPartnerFilter);
}

void CovertChannel::startSniffing() {
	std::thread innerForwardSnifferThread(&CovertChannel::startInnerForwardSniffing, this);
	std::thread outerForwardSnifferThread(&CovertChannel::startOuterForwardSniffing, this);
	std::thread innerChannelSnifferThread(&CovertChannel::startInnerChannelSniffing, this);
	std::thread outerChannelSnifferThread(&CovertChannel::startOuterChannelSniffing, this);
	std::thread outerPartnerSnifferThread(&CovertChannel::startOuterPartnerSniffing, this);

	innerForwardSnifferThread.detach();
	outerForwardSnifferThread.detach();
	innerChannelSnifferThread.detach();
	outerChannelSnifferThread.detach();
	outerPartnerSnifferThread.detach();
}

void CovertChannel::startInnerForwardSniffing() { innerForwardSniffer->sniff_loop(make_sniffer_handler(this, &CovertChannel::handleForwardFromInner)); }

void CovertChannel::startOuterForwardSniffing() { outerForwardSniffer->sniff_loop(make_sniffer_handler(this, &CovertChannel::handleForwardFromOuter)); }

void CovertChannel::startInnerChannelSniffing() { innerChannelSniffer->sniff_loop(make_sniffer_handler(this, &CovertChannel::handleChannelFromInner)); }

void CovertChannel::startOuterChannelSniffing() { outerChannelSniffer->sniff_loop(make_sniffer_handler(this, &CovertChannel::handleChannelFromOuter)); }

void CovertChannel::startOuterPartnerSniffing() { outerPartnerSniffer->sniff_loop(make_sniffer_handler(this, &CovertChannel::handlePartnerFromOuter)); }

bool CovertChannel::handleForwardFromOuter(Tins::PDU &pdu) {
	innerSender.send(pdu);

	return true;
}

bool CovertChannel::handleForwardFromInner(Tins::PDU &pdu) {
	outerSender.send(pdu);

	return true;
}