How to implement hello flood attack in OMNeT++
To implement the Hello flood attack is a kind of denial-of-service attack that aims wireless sensor networks (WSNs), especially those using protocols that rely on broadcasting “hello” packets for neighbour discovery. In this, a malicious node forwards a great number of “hello” packets to its neighbours, causing them to excess resources on processing these packets and possibly disrupting the network.
Given below is a process helps how to implement a Hello flood attack in OMNeT++ using the INET framework:
Step-by-Step Implementations:
- Set up OMNeT++ and INET Framework
- Make sure that OMNeT++ and the INET framework are installed and correctly configured. The INET framework delivers necessary modules for mimicking network protocols, which we can use to simulate a wireless sensor network (WSN) and the Hello flood attack.
- Define the Network Topology
- Build a network topology in a .ned file that contains legitimate sensor nodes and an attacker node. The attacker node will perform the Hello flood attack and the sensor nodes will communicate with each other.
Example:
network HelloFloodAttackNetwork
{
submodules:
sensor1: StandardHost;
sensor2: StandardHost;
sensor3: StandardHost;
attacker: StandardHost;
coordinator: Router; // Central node or coordinator
connections:
sensor1.ethg++ <–> Ieee802154NarrowbandInterface <–> coordinator.ethg++;
sensor2.ethg++ <–> Ieee802154NarrowbandInterface <–> coordinator.ethg++;
sensor3.ethg++ <–> Ieee802154NarrowbandInterface <–> coordinator.ethg++;
attacker.ethg++ <–> Ieee802154NarrowbandInterface <–> coordinator.ethg++;
}
- The sensor1, sensor2, and sensor3 nodes denote legitimate wireless sensor nodes. The attacker node will flood the network includes the hello packets.
- Create or Configure a Hello Flood Attack Module
- The attacker node would be configured to send a huge number of “hello” packets to its neighbours. It can be finish using a custom application or by modifying an existing one to send out these packets at a high frequency.
Option A: Using a Custom Application Module
- We can make a custom C++ module that generates and sends hello packets endlessly or at a high rate.
Example C++ code for a custom Hello flood attack module:
class HelloFloodAttack : public cSimpleModule
{
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
void sendHelloPacket();
};
void HelloFloodAttack::initialize()
{
// Schedule the first hello packet send event
scheduleAt(simTime() + par(“startTime”), new cMessage(“sendHello”));
}
void HelloFloodAttack::handleMessage(cMessage *msg)
{
if (msg->isSelfMessage()) {
sendHelloPacket();
scheduleAt(simTime() + par(“interval”), msg); // Schedule the next hello packet
} else {
delete msg;
}
}
void HelloFloodAttack::sendHelloPacket()
{
auto helloPacket = new cPacket(“HelloPacket”);
helloPacket->setByteLength(par(“packetSize”));
// Set packet parameters (e.g., source address, etc.)
send(helloPacket, “out”); // Send the hello packet to all neighbors
}
Define_Module(HelloFloodAttack);
- This module lists the sending of hello packets at regular breaks, efficiently flooding the network.
- Configure the Attacker Node
- In the .ini file, configure the attacker node to use the custom Hello flood attack module.
Example configuration in omnetpp.ini:
*.attacker.numApps = 1
*.attacker.app[0].typename = “HelloFloodAttack”
*.attacker.app[0].startTime = 2s
*.attacker.app[0].interval = 0.01s # High frequency to simulate the flood
*.attacker.app[0].packetSize = 64B # Size of the hello packet
- startTime determines when the Hello flood attack starts.
- interval sets the frequency at which hello packets are sent, simulating the flood.
- packetSize defines the size of each hello packet.
- Configure the Sensor Nodes
- The sensor nodes would be configured to normally answer to hello packets by updating their neighbour tables or executing other network management tasks.
Example:
*.sensor1.numApps = 1
*.sensor1.app[0].typename = “Ieee802154App” // Assuming the sensor nodes use IEEE 802.15.4
*.sensor2.numApps = 1
*.sensor2.app[0].typename = “Ieee802154App”
*.sensor3.numApps = 1
*.sensor3.app[0].typename = “Ieee802154App”
- The sensor nodes will process hello packets as part of their normal operation, making them susceptible to the Hello flood attack.
- Run the Simulation
- Compile and run the OMNeT++ simulation. The attacker node will start flooding the network with hello packets, on processing these packets the sensor nodes to waste resources.
- Analyse the Results
- Impact of the Hello flood attack on the network by using OMNeT++’s tools to monitor. Focus on metrics like energy consumption, packet loss, network throughput, and communication delays.
- Monitor how the sensor nodes handle the flood of hello packets, involving any potential failures or disruptions in normal network operations.
- Enhancements and Variations
- Different Flooding Rates: Testing with various intervals among hello packets to study how changing flood intensities affect the network.
- Defensive Mechanisms: Execute defence strategies like rate limiting, packet filtering, or neighbour authentication to counteract the Hello flood attack.
- Multiple Attackers: Mimic a scenario with numerous attacker nodes to learn the effects of a distributed Hello flood attack.
Example Files
The following files as part of the simulation:
- HelloFloodAttackNetwork.ned: Describes the network topology.
- omnetpp.ini: Encompasses configuration settings for the Hello flood attack.
- HelloFloodAttack.cc: Custom C++ code for the Hello flood attack module.
In this paper, we are provided details about hello packets, network topology, hello flood attack module and the impact is helps to execute Hello Flood Attack in OMNeT using INET framework. Send us a message if you need help with comparing different options and ideas for your project in this area. You can also get support for implementing and simulating a hello flood attack using the OMNeT++ tool from the developers at omnet-manual.com.