How to Implement quench attack in OMNeT++
To implement the quench attack in OMNeT++ has several steps basically we need to know the term quench attack, the quench attacks is refers to a kind of attacks where an attacker sends ICMP Source Quench messages to a target that deceptive it into decreasing its transmission rate or disturbing the communication and the ICMP Source Quench messages are designed to designate congestion in a network, asking the sender to slow down its packet transmission. Furthermore these characteristics is usually criticised in advanced networks and the quench attack is less common delay.
In OMNeT++, we need to emulate a quench attack by configuring an attacker node to send ICMP Source Quench messages to a victim, which would emulate the disturbance of communication or the reduction of transmission speed.
The below are the detailed procedures on how to implement the quench attack in OMNeT++ using the INET framework:
Step-by-Step Implementation:
- Set Up OMNeT++ and INET Framework
- Make sure that OMNeT++ and the INET framework are installed and properly configured. The INET framework delivers the essential modules for mimicking the network protocols, including ICMP.
- Define the Network Topology
- Generate a network topology in a .ned file that contains a client, server, router, and an attacker node. The attacker will send ICMP Source Quench messages to the client.
Example:
network QuenchAttackNetwork
{
submodules:
client: StandardHost;
server: StandardHost;
router: Router;
attacker: StandardHost;
connections:
client.ethg++ <–> Eth10G <–> router.ethg++;
attacker.ethg++ <–> Eth10G <–> router.ethg++;
router.ethg++ <–> Eth10G <–> server.ethg++;
}
- The attacker node will send ICMP Source Quench messages to the client to disrupt its communication with the server.
- Create a Custom Quench Attack Module
- To emulate the quench attack, generate a custom C++ module that creates and sends ICMP Source Quench messages.
Example C++ code for a custom quench attack module:
#include <omnetpp.h>
#include “inet/common/packet/Packet.h”
#include “inet/networklayer/icmpv4/IcmpHeader_m.h”
#include “inet/networklayer/contract/ipv4/Ipv4Header_m.h”
using namespace omnetpp;
using namespace inet;
class QuenchAttack : public cSimpleModule
{
protected:
virtual void initialize() override;
virtual void handleMessage(cMessage *msg) override;
void sendQuenchMessage();
};
void QuenchAttack::initialize()
{
// Schedule the first quench message to be sent
scheduleAt(simTime() + par(“startTime”), new cMessage(“sendQuenchMessage”));
}
void QuenchAttack::handleMessage(cMessage *msg)
{
if (msg->isSelfMessage()) {
sendQuenchMessage();
scheduleAt(simTime() + par(“interval”), msg); // Continuously send quench messages
} else {
delete msg;
}
}
void QuenchAttack::sendQuenchMessage()
{
auto packet = new Packet(“IcmpSourceQuench”);
// Create the ICMP Source Quench header
auto icmpHeader = makeShared<IcmpHeader>();
icmpHeader->setType(ICMP_SOURCE_QUENCH); // ICMP Type for Source Quench
icmpHeader->setCode(0);
packet->insertAtFront(icmpHeader);
// Add an IPv4 header for the original packet (to simulate that this is a response)
auto ipv4Header = makeShared<Ipv4Header>();
ipv4Header->setSourceAddress(Ipv4Address(“10.0.0.2”)); // Server IP
ipv4Header->setDestinationAddress(Ipv4Address(“10.0.0.1”)); // Client IP
ipv4Header->setProtocol(IP_PROT_ICMP);
packet->insertAtFront(ipv4Header);
// Send the ICMP Source Quench message to the client
send(packet, “out”);
}
Define_Module(QuenchAttack);
- This module emulates the creation and sending of ICMP Source Quench messages to the client.
- Configure the Attacker Node
- In your .ini file, configure the attacker node to use the quench attack module.
Example configuration in omnetpp.ini:
*.attacker.numApps = 1
*.attacker.app[0].typename = “QuenchAttack”
*.attacker.app[0].startTime = 1s
*.attacker.app[0].interval = 0.5s // Interval between sending quench messages
- startTime determines when the quench attack starts.
- interval sets how frequently ICMP Source Quench messages are sent.
- Configure the Client and Server Nodes
- The client and server nodes should be configured to interact normally. The client can be configured to slow down or disturb its communication upon receiving ICMP Source Quench messages.
Example for the client:
*.client.numApps = 1
*.client.app[0].typename = “UdpBasicApp”
*.client.app[0].destAddr = “server”
*.client.app[0].destPort = 5000
*.client.app[0].sendInterval = 1s
*.client.app[0].messageLength = 1024B
- The client sends UDP packets to the server at regular intervals.
Example for the server:
*.server.numApps = 1
*.server.app[0].typename = “UdpSink”
*.server.app[0].localPort = 5000
- The server listens for incoming UDP packets from the client.
- Run the Simulation
- Compile and run OMNeT++ simulation. The attacker node will begin sending ICMP Source Quench messages to the client, which should disrupt or minimize its communication rate with the server.
- Analyse the Results
- Use OMNeT++’s analysis tools to monitor the effect of the quench attack. Concentrate on how the client reacts to the ICMP Source Quench messages, whether it minimize its transmission rate, and the overall impact on communication among the client and server.
- Monitor whether the attack successfully disturbs communication and how the network responds to the attack.
- Enhancements and Variations
- Advanced Handling: Implement more sophisticated handling on the client side, like varying response based on the frequency or volume of quench messages received.
- Defensive Mechanisms: Execute network defenses, like rate limiting or ignoring deprecated ICMP Source Quench messages, to prevent the attack.
- Distributed Attack: To emulate multiple attackers sending quench messages to overwhelm the target.
Example Files
We need to generate the following files as part of simulation:
- QuenchAttackNetwork.ned: Describes the network topology.
- omnetpp.ini: Contains configuration settings for the quench attack simulation.
- QuenchAttack.cc: Custom C++ code for the quench attack module.
Here, we had understood how the quench attack will perform and emulate the network scenario using the OMNeT++. If you need more details regarding the quench attack we will provide that too.
The execution of quench attack simulations in OMNeT++ is conducted by omnet-manual.com. We offer superior simulation outcomes and provide comprehensive explanations tailored to your projects. Our team specializes in configuring an attacker node for your initiatives, so please share the details of your projects with us, and we will assist you further.