How to Implement Fragmentation Attack in NS2

 

To implement a fragmentation attack is a kind of network attack in which an attacker forwards the fragmented packets to a target, and frequently with the aim of bypassing security mechanisms like firewalls or intrusion detection systems or causing a denial of service (DoS). In NS2 that is Network Simulator 2, but it does not deliver the built-in support for directly mimicking fragmentation at the packet level (as seen in real-world attacks such as IP fragmentation), we can model a fragmentation-like attack by transfer smaller, incomplete packets and simulating the performance of fragmented traffic. Given below is a procedure on how we can theoretically simulate a fragmentation attack in NS2 by simulating fragmented packets from an attacker node.

Conceptual Steps for Implementing a Fragmentation Attack in NS2:

  1. Set Up the Network Topology:
    • State that the topology including the legitimate nodes and an attacker node.
    • These legitimate nodes will communicate typically. However the attacker node will send fragmented (or small) packets created to interrupt or bypass the network.
  2. Fragmented Packets Simulation:
    • To replicate the fragmented packets by sending smaller-than-usual packets from the attacker node, with changing the payload sizes, and intervals.
    • Those packets will be treated as fragmented packets by the receiver, mimicking how an attacker could utilise the fragmentation.
  3. Monitor the Network Behaviour:
    • Calculate how the fragmented traffic effects the target node’s performance. Then we can observe the parameters such as packet loss, increased processing overhead, or network delays.

Tcl Script for Simulating a Fragmentation Attack in NS2:

# Create a new simulator

set ns [new Simulator]

# Open trace and nam files for output

set tracefile [open out.tr w]

$ns trace-all $tracefile

# Define network nodes

set n0 [$ns node]  ;# Legitimate node (Sender)

set n1 [$ns node]  ;# Legitimate node (Receiver)

set n2 [$ns node]  ;# Malicious node (Attacker)

# Create duplex links between nodes

$ns duplex-link $n0 $n1 1Mb 10ms DropTail

$ns duplex-link $n2 $n1 1Mb 10ms DropTail  ;# Malicious node linked to the receiver

# Define TCP agents for legitimate communication between n0 and n1

set tcp0 [new Agent/TCP]

set sink0 [new Agent/TCPSink]

$ns attach-agent $n0 $tcp0

$ns attach-agent $n1 $sink0

$ns connect $tcp0 $sink0

# Create an FTP traffic source to simulate normal communication

set ftp0 [new Application/FTP]

$ftp0 attach-agent $tcp0

$ns at 1.0 “$ftp0 start”

# Malicious node behavior: Simulate fragmentation attack by sending small packets

proc fragmentation_attack {attacker victim} {

global ns

set udp [new Agent/UDP]

$ns attach-agent $attacker $udp

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp

$cbr set packetSize_ 64   ;# Simulating small fragmented packets

$cbr set interval_ 0.002  ;# High rate to simulate fragmentation attack

$ns at 2.0 “$cbr start”

puts “Fragmentation attack: Malicious node is sending small fragmented packets.”

}

# Start the fragmentation attack at the malicious node

$ns at 2.0 “fragmentation_attack $n2 $n1”

# End the simulation after 10 seconds

$ns at 10.0 “finish”

proc finish {} {

global ns tracefile

$ns flush-trace

close $tracefile

exit 0

}

# Run the simulation

$ns run

Explanation of the Script:

  1. Nodes:
    • n0: Legitimate sender node.
    • n1: Legitimate receiver node.
    • n2: Malicious attacker node that simulates sending the fragmented packets to n1.
  2. Legitimate Traffic:
    • A TCP connection is ascertained among the nodes n0 (sender) and n1 (receiver), including the FTP used to make legitimate traffic.
  3. Fragmentation Attack Simulation:
    • The malicious node n2 sends small packets that simulating fragmented packets to the receiver (n1).
    • Those packets have a tiny payload size (64 bytes), and it sent at a high rate (interval of 0.002 seconds), mimicking how an attacker could flood a network with the fragmented packets.
  4. Traffic Analysis:
    • The trace file (out.tr) will take the small, frequent packets sent from the attacker node to the receiver, mimicking the fragmented traffic.
    • Then we can estimate the impact of this fragmented traffic on the legitimate communication among the nodes n0 and n1.

Post-Simulation Analysis:

  1. Trace File Analysis:
    • Here, open the trace file and inspect how the fragmented packets from the malicious node (n2) affect the legitimate traffic. Observe for delays, packet drops, or any other impact on the communication among the nodes n0 and n1.
  2. Network Animator (NAM) Visualization:
    • We can use the NAM (Network Animator) to envision the attack. From the malicious node to the legitimate receiver, we should monitor small packets being sent often. Observe how these fragmented packets affect the normal traffic between the legitimate nodes.
  3. Impact on the Receiver Node:
    • This packets may cause extra overhead for the receiver as it processes a large number of small packets, possibly leading to the delays or packet loss.

Example of Fragmented Packet Simulation in NAM:

In NAM, we will be capable to observe the small, frequent packets sent by the malicious node to the receiver. It replicate the network performance under this attack in which the the malicious node is sending a flood of fragmented packets.

Enhancing the Simulation:

  1. Multiple Attackers:
    • We can launch more malicious nodes to replicate the distributed fragmentation attack in which several attackers send fragmented packets to overcome the target node.
  2. Legitimate Traffic with Fragmentation:
    • We can mimic the use of fragmentation in legitimate traffic by sending smaller packets from the nodes n0 to n1, together with the malicious fragmented packets from the attacker node.
  3. Different Fragmentation Patterns:
    • We can alter the packet size and interval among the packets to replicate various kinds of fragmentation attacks, with both high-rate and low-rate attacks.
  4. TCP-Based Fragmentation:
    • We can also change the script to mimic the TCP-based fragmentation attacks in which the attacker sends fragmented TCP segments to the target node.

In this manual, we executed the stepwise procedure to theoretically simulate a fragmentation attack in NS2 simulation. If required, we will offer more essential details of this topic.

To get your Fragmentation Attack in NS2 you can approach ns2project.com. Get best simulation assistance from us.