Exemplo n.º 1
0
    def test_it_should_not_return_traffic_to_the_previous_hop(self):
        l = Link('A')
        i = Interface(link=l)

        l.accept("This is a packet.", previous_hop=i)

        self.assertEqual(0, len(i.received()))
Exemplo n.º 2
0
    def test_it_should_not_respond_to_an_arp_reply_address(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ll_addr0="00:b0:d0:86:bb:f7", ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")])

        l.accept(ARP(hwsrc="00:01:02:03:04:05", psrc="192.0.43.100", pdst="192.0.43.200", op=0x002))

        self.assertEqual(1, len(l.forwarded()))
Exemplo n.º 3
0
    def test_it_should_send_traffic_on_if0(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")])

        n.send("This is a packet.")

        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual("This is a packet.", l.forwarded()[0])
Exemplo n.º 4
0
    def test_it_should_not_get_received_packets_for_another_ip(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ips0=[IPAddress.identify("2001:db8::1"), IPAddress.identify("fe80::1")])

        l.accept(IPv6(src="2001:db8::2", dst="2001:db8::3")/ICMPv6EchoRequest())
        l.accept(IPv6(src="2001:db8::3", dst="2001:db8::2")/ICMPv6EchoReply())

        self.assertEqual(0, len(n.received()))
Exemplo n.º 5
0
    def test_it_should_not_respond_to_a_neighbourhood_solicitation_for_a_multicast_group_in_the_ips(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ll_addr0="00:b0:d0:86:bb:f7", ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")])

        l.accept(IPv6(src="fe80:500:88:200::20", dst="fe80:500:88:200::10")/ICMPv6ND_NS(tgt="ff02::1"))

        self.assertEqual(1, len(l.forwarded()))
        self.assertTrue(l.forwarded()[0].haslayer(ICMPv6ND_NS))
Exemplo n.º 6
0
    def test_it_should_send_packets_to_a_link(self):
        l = Link('A')
        i = Interface(link=l)

        i.send("This is a packet.")

        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual("This is a packet.", l.forwarded()[0])
Exemplo n.º 7
0
    def test_it_should_get_received_packets_filtered_by_lambda(self):
        l = Link('A')
        i = Interface(link=l)

        l.accept(IPv6(src="2001:db8::2", dst="2001:db8::1")/ICMPv6EchoRequest())
        l.accept(IP(src="192.168.0.1", dst="192.168.0.2")/ICMP())
        
        self.assertEqual(1, len(i.received(lbda=lambda p: p.haslayer(IPv6))))
Exemplo n.º 8
0
    def test_it_should_accept_traffic_from_an_interface(self):
        l = Link('A')
        i = Interface(link=l)

        l.accept("This is a packet.", previous_hop=i)

        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual("This is a packet.", l.forwarded()[0])
Exemplo n.º 9
0
    def test_it_should_receive_traffic_from_if0(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")])

        l.accept(IPv6(src="2001:500:88:200::90", dst="2001:500:88:200::10"))

        self.assertEqual(1, len(n.received()))
        self.assertTrue(n.received()[0].haslayer(IPv6))
Exemplo n.º 10
0
    def test_it_should_forward_traffic_to_an_interface(self):
        l = Link('A')
        i = Interface(link=l)
        j = Interface(link=l)

        l.accept("This is a packet.", previous_hop=i)
        
        self.assertEqual(1, len(j.received()))
        self.assertEqual("This is a packet.", j.received()[0])
Exemplo n.º 11
0
    def test_it_should_get_received_packets_filtered_by_sequence(self):
        l = Link('A')
        i = Interface(link=l)

        l.accept(IPv6(src="2001:db8::2", dst="2001:db8::1")/ICMPv6EchoRequest(seq=2))
        l.accept(IPv6(src="2001:db8::1", dst="2001:db8::2")/ICMPv6EchoReply(seq=2))
        
        self.assertEqual(2, len(i.received(seq=2)))
        self.assertEqual(0, len(i.received(seq=1)))
Exemplo n.º 12
0
    def test_it_should_get_received_packets_filtered_by_type(self):
        l = Link('A')
        i = Interface(link=l)

        l.accept(IPv6(src="2001:db8::2", dst="2001:db8::1")/ICMPv6EchoRequest())
        l.accept(IPv6(src="2001:db8::1", dst="2001:db8::2")/ICMPv6EchoReply())

        self.assertEqual(1, len(i.received(type=ICMPv6EchoRequest)))
        self.assertTrue(i.received(type=ICMPv6EchoRequest)[0].haslayer(ICMPv6EchoRequest))
Exemplo n.º 13
0
    def test_it_should_strip_layer_2_frames_from_packets_on_receive(self):
        l = Link('A')
        i = Interface(link=l)

        l.accept(Ether()/IPv6())
        
        self.assertEqual(1, len(i.received()))
        self.assertFalse(i.received()[0].haslayer('Ether'))
        self.assertTrue(i.received()[0].haslayer('IPv6'))
Exemplo n.º 14
0
    def test_it_should_get_received_packets_for_its_own_link_local(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ips0=[IPAddress.identify("2001:db8::1"), IPAddress.identify("fe80::1")])

        l.accept(IPv6(src="fe80::2", dst="fe80::1")/ICMPv6EchoRequest())
        l.accept(IPv6(src="fe80::1", dst="fe80::2")/ICMPv6EchoReply())

        self.assertEqual(1, len(n.received()))
        self.assertTrue(n.received()[0].haslayer(ICMPv6EchoRequest))
Exemplo n.º 15
0
    def test_it_should_not_forward_router_solicitations(self):
        l = Link('A')
        m = Link('B')
        r = TestRouter('TNN',   link0=l, ll_addr0="00:b0:d0:86:bb:f7", ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")],
                                link1=m, ll_addr1="00:b0:d0:86:bb:f8", ips1=[IPAddress.identify("2001:600:88:200::10"), IPAddress.identify("2001:600:88:200::11"), IPAddress.identify("fe80:600:88:200::10"), IPAddress.identify("192.1.43.10")])

        l.accept(IPv6(src="fe80:500:88:200::20", dst="ff02::2")/ICMPv6ND_RS())
        
        self.assertFalse(any(map(lambda p: p.haslayer(ICMPv6ND_RS), m.forwarded())))
Exemplo n.º 16
0
    def test_it_should_not_forward_neighbour_advertisements(self):
        l = Link('A')
        m = Link('B')
        r = TestRouter('TNN',   link0=l, ll_addr0="00:b0:d0:86:bb:f7", ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")],
                                link1=m, ll_addr1="00:b0:d0:86:bb:f8", ips1=[IPAddress.identify("2001:600:88:200::10"), IPAddress.identify("2001:600:88:200::11"), IPAddress.identify("fe80:600:88:200::10"), IPAddress.identify("192.1.43.10")])

        l.accept(IPv6(src="fe80:500:88:200::20", dst="ff02::2")/ICMPv6ND_NA())

        self.assertEqual(0, len(m.forwarded()))
Exemplo n.º 17
0
    def test_it_should_encapsulate_packets_with_layer_2_frames_on_send(self):
        l = Link('A')
        i = Interface(link=l)

        i.send(IPv6())
        
        self.assertEqual(1, len(l.forwarded()))
        self.assertTrue(l.forwarded()[0].haslayer(Ether))
        self.assertTrue(l.forwarded()[0].haslayer(IPv6))
Exemplo n.º 18
0
    def test_it_should_get_received_packets_for_its_own_v4_address(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ips0=[IPAddress.identify("2001:db8::1"), IPAddress.identify("fe80::1"), IPAddress.identify("10.0.0.1")])

        l.accept(IP(src="10.0.0.2", dst="10.0.0.1")/ICMP())
        l.accept(IP(src="10.0.0.1", dst="10.0.0.2")/ICMP())

        self.assertEqual(1, len(n.received()))
        self.assertTrue(n.received()[0].haslayer(ICMP))
Exemplo n.º 19
0
    def test_it_should_forward_packets_from_the_link_to_phy(self):
        l = Link('A')
        i = MockInterface('if0', '00:b0:d0:86:bb:f7')
        k = TargetInterface(link_addr="00:b0:d0:bb:cc:ff")
        t = Tap(l, i, k)

        l.accept("This is a packet.")

        self.assertEqual(1, len(i.sent))
        self.assertEqual("This is a packet.", i.sent[0])
Exemplo n.º 20
0
    def test_it_should_forward_packets_from_phy_to_the_link(self):
        l = Link('A')
        i = MockInterface('if0', '00:b0:d0:86:bb:f7')
        k = TargetInterface(link_addr="00:b0:d0:bb:cc:ff")
        t = Tap(l, i, k)

        i.accept(["This is a packet."])

        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual("This is a packet.", l.forwarded()[0])
Exemplo n.º 21
0
    def test_it_should_set_the_source_and_destination_mac_addresses_to_defaults_for_ethernet_link_layer(self):
        l = Link('A')
        i = Interface(link=l)

        i.send(IPv6())

        self.assertEqual(1, len(l.forwarded()))
        self.assertTrue(l.forwarded()[0].haslayer(Ether))
        self.assertEqual("00:00:00:00:00:00", l.forwarded()[0].getlayer(Ether).src)
        self.assertEqual("ff:ff:ff:ff:ff:ff", l.forwarded()[0].getlayer(Ether).dst)
Exemplo n.º 22
0
    def test_it_should_forward_traffic_accept_a_real_interface_through_a_tap(self):
        l = Link('A')
        i = Interface(link=l)
        j = MockInterface('if0', '00:b0:d0:86:bb:f7')
        k = TargetInterface(link_addr="00:b0:d0:bb:cc:ff")
        t = Tap(l, j, k)

        l.accept("This is a packet.", previous_hop=i)
        
        self.assertEqual(1, len(j.sent))
        self.assertEqual("This is a packet.", j.sent[0])
Exemplo n.º 23
0
    def test_it_should_receive_traffic_from_if1(self):
        l = Link('A')
        m = Link('B')
        r = TestRouter('TNN',   link0=l, ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")],
                                link1=m, ips1=[IPAddress.identify("2001:600:88:200::10"), IPAddress.identify("2001:600:88:200::11"), IPAddress.identify("fe80:600:88:200::10"), IPAddress.identify("192.1.43.10")])

        m.accept(IPv6(src="2001:600:88:200::90", dst="2001:600:88:200::10"))

        self.assertEqual(0, len(r.received()))
        self.assertEqual(1, len(r.received(1)))
        self.assertTrue(r.received(1)[0].haslayer(IPv6))
Exemplo n.º 24
0
    def test_it_should_send_traffic_on_if1(self):
        l = Link('A')
        m = Link('B')
        r = TestRouter('TNN',   link0=l, ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")],
                                link1=m, ips1=[IPAddress.identify("2001:600:88:200::10"), IPAddress.identify("2001:600:88:200::11"), IPAddress.identify("fe80:600:88:200::10"), IPAddress.identify("192.1.43.10")])

        r.send("This is a packet.", iface=1)

        self.assertEqual(0, len(l.forwarded()))
        self.assertEqual(1, len(m.forwarded()))
        self.assertEqual("This is a packet.", m.forwarded()[0])
Exemplo n.º 25
0
    def test_it_should_forward_traffic_to_a_real_interface_through_a_tap(self):
        l = Link('A')
        i = Interface(link=l)
        j = MockInterface('if0', '00:b0:d0:86:bb:f7')
        k = TargetInterface(link_addr="00:b0:d0:bb:cc:ff")
        t = Tap(l, j, k)

        j.accept(["This is a packet."])
        
        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual("This is a packet.", l.forwarded()[0])
Exemplo n.º 26
0
    def test_it_should_respond_to_arp_for_its_ipv4_address(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ll_addr0="00:b0:d0:86:bb:f7", ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")])

        l.accept(ARP(hwsrc="00:01:02:03:04:05", psrc="192.0.43.100", pdst="192.0.43.10"))

        self.assertEqual(2, len(l.forwarded()))
        self.assertTrue(l.forwarded()[1].haslayer(ARP))
        self.assertEqual(0x0002, l.forwarded()[1].getlayer(ARP).op)
        self.assertEqual("192.0.43.10", l.forwarded()[1].getlayer(ARP).psrc)
        self.assertEqual("00:b0:d0:86:bb:f7", l.forwarded()[1].getlayer(ARP).hwsrc)
        self.assertEqual("192.0.43.100", l.forwarded()[1].getlayer(ARP).pdst)
        self.assertEqual("00:01:02:03:04:05", l.forwarded()[1].getlayer(ARP).hwdst)
Exemplo n.º 27
0
    def test_it_should_respond_to_a_neighbourhood_solicitation_for_its_link_local_ip(self):
        l = Link('A')
        n = TestNode('TNN',     link0=l, ll_addr0="00:b0:d0:86:bb:f7", ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")])

        l.accept(IPv6(src="fe80:500:88:200::20", dst="fe80:500:88:200::10")/ICMPv6ND_NS(tgt="fe80:500:88:200::10"))

        self.assertEqual(2, len(l.forwarded()))
        self.assertTrue(l.forwarded()[0].haslayer(ICMPv6ND_NS))
        self.assertTrue(l.forwarded()[1].haslayer(ICMPv6ND_NA))
        self.assertEqual("fe80:500:88:200::10", l.forwarded()[1].getlayer(IPv6).src)
        self.assertEqual("fe80:500:88:200::20", l.forwarded()[1].getlayer(IPv6).dst)
        self.assertEqual("fe80:500:88:200::10", l.forwarded()[1].getlayer(ICMPv6ND_NA).tgt)

        self.assertTrue(l.forwarded()[1].haslayer(ICMPv6NDOptDstLLAddr))
        self.assertEqual("00:b0:d0:86:bb:f7", l.forwarded()[1].getlayer(ICMPv6NDOptDstLLAddr).lladdr)
Exemplo n.º 28
0
    def test_it_should_decrement_the_ttl_when_forwarding_ipv4_packets(self):
        l = Link('A')
        m = Link('B')
        r = TestRouter('TNN',   link0=l, ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")],
                                link1=m, ips1=[IPAddress.identify("2001:600:88:200::10"), IPAddress.identify("2001:600:88:200::11"), IPAddress.identify("fe80:600:88:200::10"), IPAddress.identify("192.1.43.10")],
                                forwards_to_0=[Network("192.0.43.0/24")],
                                forwards_to_1=[Network("192.1.43.0/24")])
        p = IP(dst="192.1.43.10")

        self.assertEqual(64, p.ttl)

        l.accept(p)

        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual(1, len(m.forwarded()))
        self.assertTrue(m.forwarded()[0].haslayer(IP))
        self.assertEqual(63, m.forwarded()[0].ttl)
Exemplo n.º 29
0
    def test_it_should_not_forward_global_traffic_addressed_to_the_interface(self):
        l = Link('A')
        m = Link('B')
        r = TestRouter('TNN',   link0=l, ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")],
                                link1=m, ips1=[IPAddress.identify("2001:600:88:200::10"), IPAddress.identify("2001:600:88:200::11"), IPAddress.identify("fe80:600:88:200::10"), IPAddress.identify("192.1.43.10")])

        l.accept(IPv6(dst="2001:500:88:200::10"))

        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual(0, len(m.forwarded()))
Exemplo n.º 30
0
    def test_it_should_not_forward_link_local_traffic(self):
        l = Link('A')
        m = Link('B')
        r = TestRouter('TNN',   link0=l, ips0=[IPAddress.identify("2001:500:88:200::10"), IPAddress.identify("2001:500:88:200::11"), IPAddress.identify("fe80:500:88:200::10"), IPAddress.identify("192.0.43.10")],
                                link1=m, ips1=[IPAddress.identify("2001:600:88:200::10"), IPAddress.identify("2001:600:88:200::11"), IPAddress.identify("fe80:600:88:200::10"), IPAddress.identify("192.1.43.10")],
                                forwards_to_0=[Network("2001:0500:0088:0200:0000:0000:0000:0000/64")],
                                forwards_to_1=[Network("2001:0600:0088:0200:0000:0000:0000:0000/64")])

        l.accept(IPv6(dst="fe80:600:88:200::10"))

        self.assertEqual(1, len(l.forwarded()))
        self.assertEqual(0, len(m.forwarded()))