How to Implement packet flooding attack in ns3

To implement a packet flooding attack in ns3, we have to set up a network topology where an attacker node sends a large volume of packets to a target node, overwhelming its resources. By using various protocols, this can be done. Here we will be using UDP flooding, because it is straightforward and effective for demonstration purposes.

Here is the detailed guide on implementing this.

Steps for implementation

1. Set up your ns3 :

• Make sure that ns3 is installed in the computer. If not, install it.

2. Create a new ns3 script :

• In the scratch directory of ns3, create a new script.

3. Include necessary libraries :

• In your script, include the necessary libraries.

4. Define network topology :

• For your network topology, create multiple legitimate nodes and one attacker node.

5. Implement the Packet flooding attack logic :

• To the victim node, use sockets to send a large volume of UDP packets from the attacker node.

6. Enable packet capturing :

• Enable pcap tracing to capture packets for analysis with Wireshark.

7. Run the Simulation :

• Define the simulation parameters and run it.

Example for implementing UDP flooding attack

Here is the example for the implementation of UDP flooding :

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

#include “ns3/ipv4-address.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“UdpFloodAttack”);

void SendUdpFlood (Ptr<Node> attackerNode, Ipv4Address victimAddress, uint16_t port, uint32_t packetSize, uint32_t numPackets, Time interval)

{

Ptr<Socket> socket = Socket::CreateSocket (attackerNode, TypeId::LookupByName (“ns3::UdpSocketFactory”));

InetSocketAddress remote = InetSocketAddress (victimAddress, port);

socket->Connect (remote);

Ptr<Packet> packet = Create<Packet> (packetSize);

for (uint32_t i = 0; i < numPackets; ++i)

{

socket->Send (packet);

Simulator::Schedule (interval, &SendUdpFlood, attackerNode, victimAddress, port, packetSize, numPackets, interval);

}

}

int main (int argc, char *argv[])

{

bool verbose = true;

uint32_t nAttackers = 1; // Number of attacker nodes

uint16_t port = 9; // Target port for the attack

uint32_t packetSize = 1024; // Size of UDP packet

uint32_t numPackets = 1000; // Number of packets to send

Time interval = Seconds (0.01); // Interval between packets

CommandLine cmd;

cmd.AddValue (“nAttackers”, “Number of attacker nodes”, nAttackers);

cmd.AddValue (“port”, “Target port for the attack”, port);

cmd.AddValue (“packetSize”, “Size of UDP packets”, packetSize);

cmd.AddValue (“numPackets”, “Number of UDP packets”, numPackets);

cmd.AddValue (“interval”, “Interval between UDP packets”, interval);

cmd.Parse (argc, argv);

if (verbose)

{

LogComponentEnable (“UdpFloodAttack”, LOG_LEVEL_INFO);

}

NodeContainer nodes;

nodes.Create (2 + nAttackers); // 1 victim node + n legitimate nodes + n attacker nodes

Ptr<Node> victim = nodes.Get (0);

NodeContainer attackers;

for (uint32_t i = 1; i <= nAttackers; ++i)

{

attackers.Add (nodes.Get (i));

}

NodeContainer legitimateNodes;

for (uint32_t i = nAttackers + 1; i < nodes.GetN (); ++i)

{

legitimateNodes.Add (nodes.Get (i));

}

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute (“DataRate”, StringValue (“5Mbps”));

pointToPoint.SetChannelAttribute (“Delay”, StringValue (“2ms”));

NetDeviceContainer devices;

for (uint32_t i = 0; i < nodes.GetN () – 1; ++i)

{

devices.Add (pointToPoint.Install (nodes.Get (i), nodes.Get (i + 1)));

}

InternetStackHelper stack;

stack.Install (nodes);

Ipv4AddressHelper address;

address.SetBase (“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfaces = address.Assign (devices);

// Install applications on legitimate nodes

UdpEchoServerHelper echoServer (port);

ApplicationContainer serverApps = echoServer.Install (victim);

serverApps.Start (Seconds (1.0));

serverApps.Stop (Seconds (10.0));

UdpEchoClientHelper echoClient (interfaces.GetAddress (0), port);

echoClient.SetAttribute (“MaxPackets”, UintegerValue (100));

echoClient.SetAttribute (“Interval”, TimeValue (Seconds (0.1)));

echoClient.SetAttribute (“PacketSize”, UintegerValue (packetSize));

ApplicationContainer clientApps = echoClient.Install (legitimateNodes);

clientApps.Start (Seconds (2.0));

clientApps.Stop (Seconds (10.0));

// Schedule UDP flood attack from each attacker node

for (uint32_t i = 0; i < attackers.GetN (); ++i)

{

Simulator::Schedule (Seconds (3.0), &SendUdpFlood, attackers.Get (i), interfaces.GetAddress (0), port, packetSize, numPackets, interval);

}

// Enable packet capture

pointToPoint.EnablePcapAll (“udp_flood_attack”);

Simulator::Run ();

Simulator::Destroy ();

return 0;

}

Explanation

1. Nodes and links :

Nodes are created for victim, legitimate communication and for attackers. Point-to-point links between nodes are configured.

2. Applications :

On one of the victim node, a UDP echo server is installed. and On legitimate nodes, a UDP echo server is installed to generate normal traffic.

3. UDP flood attack logic :

To create and send packets flood of UDP packets from the attacker node to the victim node,  SendUdpFlood is implemented. To start at a specific time in the simulation, we scheduled the UDP flood attack.

4. Packet Capture :

To capture the traffic for analysis with Wireshark, pcap tracing on all nodes is enabled.

5. Running the Simulation :

The simulation runs with attacker node sending flood of UDP packets to the victim node, and the traffic is captured in pcap files.

Overall, we had a guide on implementing packet flooding attack in ns3 by setting up a network topology where an attacker node sends a large volume of packets to a target node, overwhelming its resources. We provide more related coding and simulation support for you  on packet flooding attack.