How to Implement packet injection attack in ns3

Implementing a packet injection attack in ns3 involves setting up a network topology, configure traffic generating applications, and introduce a malicious node which injects packets into the network. Injection Attack in ns3 with detailed programming are granted by ns3simulation.com.

Here are the steps to implement packet injection attack in ns3.

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 nodes and one attacker node.

5. Implement the packet injection attack logic :

• To inject custom packets, use raw sockets 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 Packet injection attack

Here is the example for the implementation of Packet injection :

#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-header.h”

#include “ns3/udp-header.h”

#include “ns3/ipv4-raw-socket-factory.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“PacketInjectionAttack”);

void InjectPacket (Ptr<Node> attackerNode, Ipv4Address source, Ipv4Address destination, uint16_t port)

{

Ptr<Socket> socket = Socket::CreateSocket (attackerNode, Ipv4RawSocketFactory::GetTypeId ());

socket->SetAttribute (“Protocol”, UintegerValue (17)); // UDP protocol number

Ptr<Packet> packet = Create<Packet> (1024); // Create a packet of 1024 bytes

// Create and add UDP header

UdpHeader udpHeader;

udpHeader.SetSourcePort (9);

udpHeader.SetDestinationPort (port);

udpHeader.SetPayloadSize (1024 – 8); // UDP header size is 8 bytes

packet->AddHeader (udpHeader);

// Create and add IP header

Ipv4Header ipHeader;

ipHeader.SetSource (source);

ipHeader.SetDestination (destination);

ipHeader.SetProtocol (17); // UDP protocol number

ipHeader.SetPayloadSize (1024);

packet->AddHeader (ipHeader);

socket->Send (packet);

}

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

{

// Set up logging

LogComponentEnable (“PacketInjectionAttack”, LOG_LEVEL_INFO);

// Create nodes

NodeContainer nodes;

nodes.Create (3); // Two legitimate nodes and one attacker node

// Create point-to-point links

PointToPointHelper pointToPoint;

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

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

NetDeviceContainer devices;

devices = pointToPoint.Install (nodes.Get (0), nodes.Get (1));

devices.Add (pointToPoint.Install (nodes.Get (1), nodes.Get (2))); // Attacker connected to one of the nodes

// Install the internet stack

InternetStackHelper stack;

stack.Install (nodes);

// Assign IP addresses

Ipv4AddressHelper address;

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

Ipv4InterfaceContainer interfaces = address.Assign (devices);

// Install applications on legitimate nodes

uint16_t port = 9; // Discard port (RFC 863)

// Server application

UdpEchoServerHelper echoServer (port);

ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));

serverApps.Start (Seconds (1.0));

serverApps.Stop (Seconds (10.0));

// Client application

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

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

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

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

ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));

clientApps.Start (Seconds (2.0));

clientApps.Stop (Seconds (10.0));

// Enable packet capture

pointToPoint.EnablePcapAll (“packet_injection_attack”);

// Schedule packet injection

Simulator::Schedule (Seconds (3.0), &InjectPacket, nodes.Get (2), interfaces.GetAddress (0), interfaces.GetAddress (1), port);

// Run simulation

Simulator::Run ();

Simulator::Destroy ();

return 0;

}

Explanation

1. Nodes and links :

Three Nodes are created : two for legitimate nodes and one for attacker. Point-to-point links between nodes are configured.

2. Applications :

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

3. Packet injection attack logic :

To create and send a custom packet using raw sockets,  InjectPacket is implemented. To start at a specific time in the simulation, we scheduled the packet injection 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 injecting packets into the network, and the traffic is captured in pcap files.

Finally, we had successfully learned on implementing packet injection attack in ns3 by setting up a network topology, configure traffic generating applications, and introduce a malicious node that injects packets into the network.