MSc Dissertation - Comparative Performance Analysis of AODV and DSDV Against Blackhole and Flooding Attacks in MANET Using NS-3

Use Network Simulator 3 to simulate the MANET with AODV and DSDV routing protocols under Blackhole and Flooding attacks to observe and analyse the impact caused by the attacks and determine the more effective protocol against them by using Packet Delivery Ratio, End-to-end Delay, and Throughput as the metrics.

GitHub

Screenshots

Project Description

Mobile Ad-hoc network (MANET) is an infrastructure-free network that can be configured by the devices within the system. MANET can operate in severe situations like natural disasters and oil drilling. However, MANET is vulnerable to various attacks, such as Blackhole and Flooding attacks, due to its limited computing resources, decentralisation, and dynamic topology. Therefore, realising the impact of the attacks on the network is critical to develop an effective countermeasure. This project uses Network Simulator 3 to simulate the MANET with AODV and DSDV routing protocols under Blackhole and Flooding attacks to observe and analyse the impact caused by the attacks and determine the more effective protocol against them by using Packet Delivery Ratio, End-to-end Delay, and Throughput as the metrics. The result shows that AODV is more competent than DSDV in most scenarios regarding Packet Delivery Ratio and Throughput. However, DSDV mainly performs better than AODV in End-to-end Delay.

Using

• C++
• Python
• Shell script – bash script
• Network Simulator 3
• Linux

Achievements

• Simulate MANET
• Implement Blackhole attack
• Implement Flooding attack
• Comparative analysis

Details

Aim

This dissertation aims to survey and compare the reactive and proactive routing protocols to determine which protocol is more resilient when the MANET is under attack. The research focuses on AODV, a reactive protocol, and DSDV, a proactive protocol, since they are the most common protocols used in MANETs. Blackhole and Flooding attacks have been selected for this study because they are two types of common attacks.

Objectives

• Objective 1: Conduct a Comprehensive literature review on Blackhole and Flooding attacks in MANET.
• Objective 2: Review and detail how reactive and proactive routing protocols operate, focusing on AODV and DSDV.
• Objective 3: Determine simulation parameters by reviewing real-world situations.
• Objective 4: Design and implement simulations on NS-3 (Network Simulator 3) to measure packet delivery ratio (PDR), end-to-end delay (E2E), and throughput.
• Objective 5: Create attack scenarios (Blackhole and Flooding) using C++ programming in NS-3.
• Objective 6: Analyse and explain simulation results of AODV and DSDV with and without the attacks
• Objective 7: Conduct a comparative analysis of the impact of Blackhole and Flooding attacks on AODV and DSDV.
• Objective 8: Summarise findings and provide recommendations for future research on MANET security.

Result

In conclusion, AODV is more reliable than DSDV against the Blackhole and Flooding attacks regarding PDR and throughput. While DSDV is more capable than AODV against the attacks in end-to-end delay but not in the 50-node area when the Blackhole attack exists. Therefore, AODV is generally more resilient than DSDV under the Blackhole and Flooding attack. This conclusion is similar to the work by M. N. B. Anwar’s ^[1], A. Singh et al. ^[2], and A. A. Chavan, D. S. Kurule, and P. U. Dere ^[3].

Code Showcase

C++ codes to set up the entire MANET simulation

Ipv4AddressHelper addressAdhoc;
addressAdhoc.SetBase("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer adhocInterfaces;
adhocInterfaces = addressAdhoc.Assign(adhocDevices);

OnOffHelper onoff1("ns3::UdpSocketFactory", Address());
onoff1.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1.0]"));
onoff1.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0.0]"));

for (int i = 0; i < nSinks; i++)
{
    Ptr<Socket> sink = SetupPacketReceive(adhocInterfaces.GetAddress(i), adhocNodes.Get(i));

    AddressValue remoteAddress(InetSocketAddress(adhocInterfaces.GetAddress(i), port));
    onoff1.SetAttribute("Remote", remoteAddress);

    Ptr<UniformRandomVariable> var = CreateObject<UniformRandomVariable>();
    ApplicationContainer temp = onoff1.Install(adhocNodes.Get(i + nSinks));
    temp.Start(Seconds(var->GetValue(100.0, 101.0)));
    temp.Stop(Seconds(TotalTime));
}

Bash Script to obtain multiple results automatically

#!/bin/bash

output_file="$HOME/Desktop/resultsFrom0to10.txt"
protocol_value=$1
malicious_node_value=$2
stream_index_value=$3

# Function to display the help message
display_help() {
    echo "Usage: ./script_name.sh [protocol_value] [malicious_node_value] [stream_index_value]"
    echo "Options:"
    echo "  protocol_value        Specify the protocol value"
    echo "  malicious_node_value  Specify the enable_malicious_node value"
    echo "  stream_index_value    Specify the streamIndex value"
    echo
}

# Check if the script is called with the help option
if [[ $1 == "--help" || $1 == "-h" ]]; then
    display_help
    exit 0
fi

# Check if the number of arguments is correct
if [[ $# -ne 3 ]]; then
    echo "Error: Incorrect number of arguments."
    display_help
    exit 1
fi

output_file="$HOME/Desktop/resultsFrom0to$stream_index_value-DSDV-50nodes-with-Blackhole.txt"


# Remove the output file if it already exists
rm -f "$output_file"

for ((index=0; index<=$stream_index_value; index++))
do
    ./ns3 run aodv-and-dsdv-compare -- --protocol=$protocol_value --enable_malicious_node=$malicious_node_value --streamIndex=$index >> "$output_file" 2>&1
done

Line chart drawer by Python

# Get the end-to-end delay from the txt file
def getE2EDelay(lines):
    # Store all total E2EDelay into a list
    e2eDelayList = []
    lineCount = 0  # Count E2EDelay lines
    for line in lines:
        if lineCount == 10:  # Stop when 10 nodes:
            break
        if "Average End to End Delay" in line:
            lineCount += 1

            # Find the index of the '=' character
            equals_index = line.index("=")

            # Extract the substring after the '=' character
            timeString = line[equals_index + 1 :]

            # Parse the number part
            match = re.search(r"([+-]?\d+\.\d+)e([+-]\d+)", timeString)
            num = float(match.group(1))
            exp = int(match.group(2))

            # Calculate value
            val = num * pow(10, exp)

            # Convert to seconds
            time_sec = val * 1e-9

            # Store the E2EDelay
            e2eDelayList.append(time_sec)

    return e2eDelayList # Return the average E2EDelay

# AODV vs DSDV without attack 100 topologies result comparison
def drawLineChart(aodvList, dsdvList, aodv30NodesList=None, dsdv30NodesList=None, aodv50NodesList=None, dsdv50NodesList=None):
    df = pd.DataFrame(
        {
            "AODV": aodvList,
            "DSDV": dsdvList,
            "AODV with Flooding": aodv30NodesList,
            "DSDV with Flooding": dsdv30NodesList,
            # "AODV 50 Nodes": aodv50NodesList,
            # "DSDV 50 Nodes": dsdv50NodesList,
        }
    )

    # Prepare the graph
    plt.figure(figsize=(15, 8))
    ax = sns.lineplot(data=df)
    ax.set(xlabel="Sample", ylabel="Throughput (kbps)")
    ax.set_title(title)
    ax.grid(True)

    # Show the graph
    plt.show()

C++ code for AODV blackhole attack

if (IsMalicious ||
    ((rreqHeader.GetUnknownSeqno() ||
      (int32_t(toDst.GetSeqNo()) - int32_t(rreqHeader.GetDstSeqno()) >= 0)) &&
      toDst.GetValidSeqNo()))
{
    if (IsMalicious || (!rreqHeader.GetDestinationOnly() && toDst.GetFlag() == VALID))
    {
        m_routingTable.LookupRoute(origin, toOrigin);
        /* Code for Blackhole attack */
        if (IsMalicious)
        {
            Ptr<NetDevice> dev =
                m_ipv4->GetNetDevice(m_ipv4->GetInterfaceForAddress(receiver));
            RoutingTableEntry falseToDst(
                dev,
                dst,
                true,
                rreqHeader.GetDstSeqno() + 100,
                m_ipv4->GetAddress(m_ipv4->GetInterfaceForAddress(receiver), 0),
                1,
                dst,
                m_activeRouteTimeout);
            SendReplyByIntermediateNode(falseToDst,
                                        toOrigin,
                                        rreqHeader.GetGratuitousRrep());
            return;
        }
        /* Code for Blackhole Attack Simulation ends here */
        SendReplyByIntermediateNode(toDst, toOrigin, rreqHeader.GetGratuitousRrep());
        return;
    }
    // More codes...
}

Reference

1. M. N. B. Anwar, “Performance analysis of aodv, olsr, dsdv routing protocols in manet under black hole attack,” in Proceedings of the international conference on computing advancements, pp. 1–5, 2020. ↩
2. A. Singh, G. Singh, and M. Singh, “Comparative study of olsr, dsdv, aodv, dsr and zrp routing protocols under blackhole attack in mobile ad hoc network,” in Intelligent Communication, Control and Devices: Proceedings of ICICCD 2017, pp. 443–453, Springer, 2018. ↩
3. A. Chavan, D. Kurule, and P. Dere, “Performance analysis of aodv and dsdv routing protocol in manet and modifications in aodv against black hole attack,” Procedia Computer Science, vol. 79, pp. 835–844, 2016. ↩