Forward with incomplete virtual class

daemon/include/Sniffer.h → daemon/include/CovertChannel.h

@@ -12,7 +12,7 @@
  * forward the packets to an analyzer or modifyer so we can hide data in the
  * traffic.
  */
-class Sniffer {
+class CovertChannel {
 public:
 	/**
 	 * Creates a Sniffer.
@@ -21,14 +21,14 @@ public:
 	 *
 	 * @param interface name of the interface for sniffing
 	 */
-	Sniffer(const std::string &interfaceName);
+	CovertChannel(const std::string &innerInterface, const std::string &outerInterface);
 
 	/**
 	 * Destroys the Sniffer.
 	 *
 	 * Destructor of the Sniffer.
 	 */
-	~Sniffer();
+	virtual ~CovertChannel();
 
 	/**
 	 * Start sniffing on the interface.
@@ -48,7 +48,7 @@ public:
 	 */
 	void setFilter(const std::string &filterString);
 
-private:
+protected:
 	/**
 	 * Handler for sniffed packets.
 	 *
@@ -59,12 +59,23 @@ private:
 	 *
 	 * @return false = stop loop | true = continue loop
 	 */
-	bool handle(Tins::PDU &pdu);
+	// bool handle(Tins::PDU &pdu);
+
+	bool handleForwardToInner(Tins::PDU &pdu);
+	bool handleForwardToOuter(Tins::PDU &pdu);
+	virtual bool handleRedirectToInner(Tins::PDU &pdu) = 0;
+	virtual bool handleRedirectToOuter(Tins::PDU &pdu) = 0;
+
+	void startInnerSniffing();
+	void startOuterSniffing();
 
 	/**
 	 * Tins sniffer object.
 	 */
-	Tins::Sniffer *sniffer;
+	Tins::Sniffer *innerSniffer;
+	Tins::Sniffer *outerSniffer;
+	Tins::PacketSender innerSender;
+	Tins::PacketSender outerSender;
 };
 
 #endif

daemon/src/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 2.8)
 
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
-add_executable(ccats src/main.cpp src/Sniffer.cpp src/Server.cpp src/base64.cpp src/JsonCommander.cpp src/FileManager.cpp src/UserManager.cpp src/Config.cpp)
+add_executable(ccats src/main.cpp src/CovertChannel.cpp src/Server.cpp src/base64.cpp src/JsonCommander.cpp src/FileManager.cpp src/UserManager.cpp src/Config.cpp)
 
 # dependencies used by server only
 find_package(libtins 4.2 REQUIRED)

daemon/src/CovertChannel.cpp

@@ -0,0 +1,52 @@
+#include "../include/CovertChannel.h"
+#include <cstdlib>
+#include <iostream>
+#include <thread>
+
+CovertChannel::CovertChannel(const std::string &innerInterface, const std::string &outerInterface) : 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 {
+		innerSniffer = new Tins::Sniffer(innerInterface, config);
+		outerSniffer = new Tins::Sniffer(outerInterface, config);
+	} 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() {
+	innerSniffer->stop_sniff();
+	outerSniffer->stop_sniff();
+	delete (innerSniffer);
+	delete (outerSniffer);
+}
+
+void CovertChannel::startSniffing() {
+	std::thread innerSnifferThread(&CovertChannel::startInnerSniffing, this);
+	std::thread outerSnifferThread(&CovertChannel::startOuterSniffing, this);
+	innerSnifferThread.detach();
+	outerSnifferThread.detach();
+}
+
+void CovertChannel::startInnerSniffing() { innerSniffer->sniff_loop(make_sniffer_handler(this, &CovertChannel::handleForwardToOuter)); }
+
+void CovertChannel::startOuterSniffing() { outerSniffer->sniff_loop(make_sniffer_handler(this, &CovertChannel::handleForwardToInner)); }
+
+void CovertChannel::setFilter(const std::string &filterString) { innerSniffer->set_filter(filterString); }
+
+bool CovertChannel::handleForwardToInner(Tins::PDU &pdu) {
+	innerSender.send(pdu);
+
+	return true;
+}
+
+bool CovertChannel::handleForwardToOuter(Tins::PDU &pdu) {
+	outerSender.send(pdu);
+
+	return true;
+}

daemon/src/Sniffer.cpp

@@ -1,33 +0,0 @@
-#include "../include/Sniffer.h"
-#include <cstdlib>
-#include <iostream>
-
-Sniffer::Sniffer(const std::string &interfaceName) {
-	Tins::SnifferConfiguration config;
-	config.set_promisc_mode(true);
-
-	try {
-		sniffer = new Tins::Sniffer(interfaceName, config);
-	} catch (const Tins::pcap_error &e) {
-		std::cerr << "An error accured setting up the sniffer: " << e.what() << std::endl;
-		std::exit(EXIT_FAILURE);
-	}
-}
-
-Sniffer::~Sniffer() {
-	sniffer->stop_sniff();
-	delete (sniffer);
-}
-
-void Sniffer::startSniffing() { sniffer->sniff_loop(make_sniffer_handler(this, &Sniffer::handle)); }
-
-void Sniffer::setFilter(const std::string &filterString) { sniffer->set_filter(filterString); }
-
-bool Sniffer::handle(Tins::PDU &pdu) {
-	// TODO implement handler for sniffed traffic
-
-	std::cout << "packet sniffed" << std::endl;
-
-	return false; // will stop sniffing after the first packet because this
-	              // handler returns false
-}

daemon/src/main.cpp

@@ -2,8 +2,8 @@
 #include <thread>
 
 #include "../include/Config.h"
+#include "../include/CovertChannel.h"
 #include "../include/Server.h"
-#include "../include/Sniffer.h"
 #include "../include/UserManager.h"
 
 using namespace std;
@@ -15,14 +15,15 @@ int main(int argc, char *argv[]) {
 		exit(EXIT_FAILURE);
 	}
 
-	const string interface = Config::getValue("interface");
+	const string innerInterface = Config::getValue("innerInterface");
+	const string outerInterface = Config::getValue("outerInterface");
 
 	// check if userStorage is add specified location
 	// if not create one
 	UserManager::init(Config::getValue("userdatabase"));
 
-	Sniffer *sniffer = new Sniffer(interface);
-	thread snifferThread(&Sniffer::startSniffing, sniffer);
+	CovertChannel covertchannel(innerInterface, outerInterface);
+	covertchannel.startSniffing();
 
 	try {
 		io_service io_service;
@@ -32,7 +33,5 @@ int main(int argc, char *argv[]) {
 		cerr << e.what() << endl;
 	}
 
-	snifferThread.join();
-	delete (sniffer);
 	return 0;
 }