通过以太网转发RREQ收到的消息[OMNET ++和INET]

时间：2015-03-16 15:11:00

标签： omnet++ inet

我在尝试通过其以太网接口转发RREQ数据包（通过MANET模拟网络接收）时遇到了麻烦。 我正在寻找的方法是将所述数据包（从无线接口接收）发送到通过以太网直接连接的另一台主机。

假设我从主机A的无线接口收到一个数据包，主机A也有一个直接连接到主机B的以太网接口，我想通过以太网接口转发该数据包，以便主机B收到这个通过它的以太网接口发送数据包。

我不知道要使用什么功能。

我正在处理的项目很重要，所以如果需要，我会尽快提供代码，以便回答我的问题。

编辑：

因此，最终目标是在MANET网络中实施虫洞攻击。 基本来说，虫洞攻击涉及两个攻击者（ATTACKER_A和ATTACKER_B），这两个攻击者通过高速连接（即以太网）直接相互连接。 一旦ATTACKER_A的邻域发送RREQ，并且ATTACKER_A接收到它，它将通过以太网将RREQ转发到ATTACKER_B，而不是简单地在网络中广播它。 当ATTACKER_B收到RREQ时，它会将RREQ通过无线方式转发到它的邻居，充当AODV manet网络中的正常节点。

结果是ATTACKER_A的邻居被欺骗认为主机thar在ATTACKER_B附近是它自己的邻居的一部分，因此在网络的两个远端部分之间创建了一个虫洞。

真的，理论并不复杂。

所以，这是网络架构 wormhole schema

这是SimpleWormhole.ned 

package nesg.netattacks.simulations.SimpleAttackScenarios.SimpleWormholeAttackScenario;

import inet.networklayer.autorouting.ipv4.IPv4NetworkConfigurator;
import inet.world.radio.ChannelControl;

import ned.DatarateChannel;

import nesg.netattacks.nodes.NA_AttackerAdhocHost;
import nesg.netattacks.nodes.NA_AdhocHost;

network SimpleWormhole
{
    @display("bgb=600,477,grey75");
    int test_ivo;

    types:
        channel ethline extends DatarateChannel
        {
            delay = 50ns;
            datarate = 100Mbps;
        }

    submodules:
        nodeA: NA_AdhocHost {
            @display("p=79,310");
        }
        nodeB: NA_AdhocHost {
            @display("p=240,366");
        }
        nodeC: NA_AdhocHost {
            @display("p=380,120");
        }
        nodeD: NA_AdhocHost {
            @display("p=518,159");
        }
        nodeE: NA_AdhocHost {
            @display("p=240,186");
        }
        nodeF: NA_AdhocHost {
            @display("p=380,286");
        } 
        attackerA: NA_AttackerAdhocHost {
            @display("p=165,310");
        }

        attackerB: NA_AttackerAdhocHost {
            @display("p=450,159");
        }
        configurator: IPv4NetworkConfigurator {
            @display("p=80,20");
        }
        channelControl: ChannelControl {
            @display("p=80,70;i=misc/sun");
        }

    connections:
        attackerA.ethg++ <--> eth_ivo: ethline <--> attackerB.ethg++;
}

NA_ATTACKERADHOCHOST是一个连续从其他ned文件继承的ned文件，回顾继承链，我发现第一个ned文件是NA_NODEBASE，其中包含一些与以太网门相关的部分

NA_NODEBASE.n​​ed 

package nesg.netattacks.nodes;

import inet.util.PcapRecorder;
import inet.networklayer.ipv4.RoutingTable;
import inet.networklayer.common.InterfaceTable;
import inet.mobility.IMobility;
import inet.linklayer.IWirelessNic;
import inet.linklayer.IWiredNic;
import inet.linklayer.IExternalNic;
import inet.base.NotificationBoard;
import inet.nodes.inet.NetworkLayer;

import nesg.netattacks.hackedmodules.networklayer.NA_NetworkLayer;

module NA_NodeBase
{
    parameters:
        @display("bgb=611,448");
        @node;
        @labels(node,ethernet-node,wireless-node);
        int numExtInterfaces = default(0);
        int numRadios = default(0);               // the number of radios in the router. by default no wireless
        int numPcapRecorders = default(0); // no of PcapRecorders.
        string mobilityType = default("StationaryMobility");
        string routingFile = default("");
        bool IPForward = default(true);
    gates:
        input radioIn[numRadios] @directIn;
        inout pppg[] @labels(PPPFrame-conn);
        inout ethg[] @labels(EtherFrame-conn);
    submodules:
        notificationBoard: NotificationBoard {
            parameters:
                @display("p=53,194");
        }

        // optional mobility module. Required only if wireless cards are present
        mobility: <mobilityType> like IMobility if mobilityType != "" && numRadios > 0 {
            parameters:
                @display("p=53,121");
        }

        //# Hacked module replacing the normal NetworkLayer INET module for attack purposes.
        networkLayer: NA_NetworkLayer {
            parameters:
                @display("p=329,287;q=queue");
        }

        routingTable: RoutingTable {
            parameters:
                @display("p=53,287");
                IPForward = IPForward;
                routingFile = routingFile;
        }

        // linklayer
        interfaceTable: InterfaceTable {
            parameters:
                @display("p=53,386");
        }

        pcapRecorder[numPcapRecorders]: PcapRecorder {
            @display("p=159,259");
        }

        wlan[numRadios]: <default("Ieee80211Nic")> like IWirelessNic {
            parameters:
                @display("p=159,386;q=queue");
        }
        eth[sizeof(ethg)]: <default("EthernetInterface")> like IWiredNic {
            parameters:
                @display("p=282,386,row,90;q=txQueue");
        }
        ppp[sizeof(pppg)]: <default("PPPInterface")> like IWiredNic {
            parameters:
                @display("p=407,386,row,90;q=txQueue");
        }
        ext[numExtInterfaces]: <default("ExtInterface")> like IExternalNic {
            parameters:
                @display("p=547,386,row,90;q=txQueue;i=block/ifcard");
        }

    connections allowunconnected:
        // connections to network outside
        for i=0..sizeof(radioIn)-1 {
            radioIn[i] --> wlan[i].radioIn;
            wlan[i].upperLayerOut --> networkLayer.ifIn++;
            wlan[i].upperLayerIn <-- networkLayer.ifOut++;
        }

        for i=0..sizeof(ethg)-1 {
            ethg[i] <--> eth[i].phys;
            eth[i].upperLayerOut --> networkLayer.ifIn++;
            eth[i].upperLayerIn <-- networkLayer.ifOut++;
        }

        for i=0..sizeof(pppg)-1 {
            pppg[i] <--> ppp[i].phys;
            ppp[i].upperLayerOut --> networkLayer.ifIn++;
            ppp[i].upperLayerIn <-- networkLayer.ifOut++;
        }

        for i=0..numExtInterfaces-1 {
            ext[i].upperLayerOut --> networkLayer.ifIn++;
            ext[i].upperLayerIn <-- networkLayer.ifOut++;
        }
}

最后，攻击者使用AODV协议的实现，这是我需要编辑的代码才能使其工作。代码来自INET框架。

我搜索了所有的aodv代码，以便找到我需要编辑的贵重物品函数，以便实现虫洞行为，结果发现我可能需要修改此函数的一部分

NA_AODV_rreq.cc 

void NS_CLASS rreq_process(RREQ * rreq, int rreqlen, struct in_addr ip_src,
                           struct in_addr ip_dst, int ip_ttl,
                           unsigned int ifindex)
{

    -- some code here -- 

    // BEGIN NA_WORMHOLE
    // if wormhole is active print it
    if (wormholeAttackIsActive) {
        LOG << "\n sending rreq forward to other attacker \n";
        //send(rreq, "ethg$o");
        if (!ev.isDisabled())
                ev.printf("ip_src=%s rreq_orig=%s rreq_dest=%s\n",ip_to_str(ip_src),
                          ip_to_str(rreq_orig), ip_to_str(rreq_dest));
        LOG << "\n\nsent\n\n";
        LOG << ip_ttl;
        //return;
    }
    // END NA_WORMHOLE

正如您所看到的，真正的问题是所有代码都在AODV源文件中，并且导致高模块性，我很难找到正确的方法来实现它。 此外，缺乏文件记录根本没有帮助。

1 个答案:

答案 0 :(得分：1)

send()功能用于发送消息。您可以从OMNeT++'s manual page了解有关它的更多信息。

要使用send()功能，至少需要两个参数。

  1. 您要发送的邮件。
  2. 您要通过其发送的接口名称。

    3. 在您的情况下，消息是RREQ数据包，接口是主机A的以太网接口。由于您手头有RREQ数据包，您只需要确定以太网接口名称。为此，您需要检查您正在模拟的网络的.ned文件。

    .ned文件将包含以下格式的声明。

    network Network_Name
{
    parameters:
        ...
    submodules:
        ...
    connections:
        ...
}

    这只是一个例子。但是，根据您的模拟模型，.ned文件可能包含更复杂的声明。但是你应该关注connections:下声明的内容。

    通常在connections:下，您会找到一些声明，例如。

    Host_A.portX <--> Host_B.portY;

    此处portX是您要查找的接口名称。同样，这是一个简单的例子，connections:下的声明可能包含更多。因此，如果您无法自行了解，则需要在此处上传您网络connections:文件的.ned部分。

    完成后，您可以像这样使用send()。

    send(RREQ, "portX")

    请确保在主机A的portX文件中将inout声明为out或.ned门。否则send()将无效。如果在portX中将inout声明为portX$o门使用send()，则指定send()使用portX的输出接口。

相关问题
最新问题