def utest():
p = scapy.Ether() / scapy.IP() / scapy.TCP()
m = Mask(p)
assert (m.pkt_match(p))
p1 = scapy.Ether() / scapy.IP() / scapy.TCP(sport=97)
assert (not m.pkt_match(p1))
m.set_do_not_care_scapy(scapy.TCP, "sport")
assert (not m.pkt_match(p1))
m.set_do_not_care_scapy(scapy.TCP, "chksum")
assert (m.pkt_match(p1))
def utest():
p = scapy.Ether() / scapy.IP() / scapy.TCP()
m = Mask(p)
assert(m.pkt_match(p))
p1 = scapy.Ether() / scapy.IP() / scapy.TCP(sport=97)
assert(not m.pkt_match(p1))
m.set_do_not_care_scapy(scapy.TCP, "sport")
assert(not m.pkt_match(p1))
m.set_do_not_care_scapy(scapy.TCP, "chksum")
assert(m.pkt_match(p1))
exp_pkt = "\x01\x02\x03\x04\x05\x06"
pkt = "\x01\x00\x00\x04\x05\x06\x07\x08"
m1 = Mask(exp_pkt, ignore_extra_bytes=True)
m1.set_do_not_care(8, 16)
assert(m1.pkt_match(pkt))
def test_unknown_ethertype(self):
import loxi.of12 as ofp
self.maxDiff = None
pkt = scapy.Ether(dst='00:01:02:03:04:05', src='00:06:07:08:09:0a', type=0x0801)/ \
('\x11' * 20)
expected = [
ofp.oxm.eth_dst([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]),
ofp.oxm.eth_src([0x00, 0x06, 0x07, 0x08, 0x09, 0x0a]),
ofp.oxm.eth_type(0x0801),
ofp.oxm.vlan_vid(ofp.OFP_VLAN_NONE),
]
result = parse.packet_to_flow_match_v3(pkt).oxm_list
self.assertEquals([x.show() for x in expected],
[x.show() for x in result])
def test_arp(self):
import loxi.of12 as ofp
self.maxDiff = None
pkt = scapy.Ether(dst='00:01:02:03:04:05', src='00:06:07:08:09:0a')/ \
scapy.ARP(hwsrc='00:01:02:03:04:05', hwdst='00:06:07:08:09:0a', \
psrc='192.168.0.1', pdst='192.168.0.2', op=1)
expected = [
ofp.oxm.eth_dst([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]),
ofp.oxm.eth_src([0x00, 0x06, 0x07, 0x08, 0x09, 0x0a]),
ofp.oxm.eth_type(0x0806),
ofp.oxm.vlan_vid(ofp.OFP_VLAN_NONE),
ofp.oxm.arp_op(1),
ofp.oxm.arp_spa(0xc0a80001),
ofp.oxm.arp_tpa(0xc0a80002),
ofp.oxm.arp_sha([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]),
ofp.oxm.arp_tha([0x00, 0x06, 0x07, 0x08, 0x09, 0x0a]),
]
result = parse.packet_to_flow_match_v3(pkt).oxm_list
self.assertEquals([x.show() for x in expected],
[x.show() for x in result])
def test_tcp(self):
import loxi.of12 as ofp
self.maxDiff = None
pkt = scapy.Ether(dst='00:01:02:03:04:05', src='00:06:07:08:09:0a')/ \
scapy.IP(src='192.168.0.1', dst='192.168.0.2', tos=2 | (32 << 2), ttl=64)/ \
scapy.TCP(sport=1234, dport=80)
expected = [
ofp.oxm.eth_dst([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]),
ofp.oxm.eth_src([0x00, 0x06, 0x07, 0x08, 0x09, 0x0a]),
ofp.oxm.eth_type(0x0800),
ofp.oxm.vlan_vid(ofp.OFP_VLAN_NONE),
ofp.oxm.ip_proto(6),
ofp.oxm.ip_dscp(32),
ofp.oxm.ip_ecn(2),
ofp.oxm.ipv4_src(0xc0a80001),
ofp.oxm.ipv4_dst(0xc0a80002),
ofp.oxm.tcp_src(1234),
ofp.oxm.tcp_dst(80)
]
result = parse.packet_to_flow_match_v3(pkt).oxm_list
self.assertEquals([x.show() for x in expected],
[x.show() for x in result])
def test_tcpv6(self):
import loxi.of12 as ofp
self.maxDiff = None
pkt = scapy.Ether(dst='00:01:02:03:04:05', src='00:06:07:08:09:0a')/ \
scapy.IPv6(src="::1", dst="::2", nh=6, tc=2 | (32 << 2), fl=7)/ \
scapy.TCP(sport=1234, dport=80)
expected = [
ofp.oxm.eth_dst([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]),
ofp.oxm.eth_src([0x00, 0x06, 0x07, 0x08, 0x09, 0x0a]),
ofp.oxm.eth_type(0x86dd),
ofp.oxm.vlan_vid(ofp.OFP_VLAN_NONE),
ofp.oxm.ip_proto(6),
ofp.oxm.ip_dscp(32),
ofp.oxm.ip_ecn(2),
ofp.oxm.ipv6_src("\x00" * 15 + "\x01"),
ofp.oxm.ipv6_dst("\x00" * 15 + "\x02"),
ofp.oxm.ipv6_flabel(7),
ofp.oxm.tcp_src(1234),
ofp.oxm.tcp_dst(80)
]
result = parse.packet_to_flow_match_v3(pkt).oxm_list
self.assertEquals([x.show() for x in expected],
[x.show() for x in result])
def packet_to_flow_match_oxm(packet, ofp):
def parse_ether_layer(layer, match):
assert(type(layer) == scapy.Ether)
match.oxm_list.append(ofp.oxm.eth_dst(parse_mac(layer.dst)))
match.oxm_list.append(ofp.oxm.eth_src(parse_mac(layer.src)))
if type(layer.payload) == scapy.Dot1Q:
layer = layer.payload
match.oxm_list.append(ofp.oxm.eth_type(layer.type))
match.oxm_list.append(ofp.oxm.vlan_vid(ofp.OFPVID_PRESENT|layer.vlan))
match.oxm_list.append(ofp.oxm.vlan_pcp(layer.prio))
else:
match.oxm_list.append(ofp.oxm.eth_type(layer.type))
match.oxm_list.append(ofp.oxm.vlan_vid(ofp.OFP_VLAN_NONE))
if type(layer.payload) == scapy.IP:
parse_ipv4_layer(layer.payload, match)
elif type(layer.payload) == scapy.IPv6:
parse_ipv6_layer(layer.payload, match)
elif type(layer.payload) == scapy.ARP:
parse_arp_layer(layer.payload, match)
# TODO MPLS
def parse_ipv4_layer(layer, match):
assert(type(layer) == scapy.IP)
match.oxm_list.append(ofp.oxm.ip_proto(layer.proto))
match.oxm_list.append(ofp.oxm.ip_dscp(layer.tos >> 2))
match.oxm_list.append(ofp.oxm.ip_ecn(layer.tos & 3))
match.oxm_list.append(ofp.oxm.ipv4_src(parse_ip(layer.src)))
match.oxm_list.append(ofp.oxm.ipv4_dst(parse_ip(layer.dst)))
if type(layer.payload) == scapy.TCP:
parse_tcp_layer(layer.payload, match)
elif type(layer.payload) == scapy.UDP:
parse_udp_layer(layer.payload, match)
elif type(layer.payload) == scapy.ICMP:
parse_icmpv4_layer(layer.payload, match)
# TODO SCTP
def parse_tcp_layer(layer, match):
assert(type(layer) == scapy.TCP)
match.oxm_list.append(ofp.oxm.tcp_src(layer.sport))
match.oxm_list.append(ofp.oxm.tcp_dst(layer.dport))
def parse_udp_layer(layer, match):
assert(type(layer) == scapy.UDP)
match.oxm_list.append(ofp.oxm.udp_src(layer.sport))
match.oxm_list.append(ofp.oxm.udp_dst(layer.dport))
def parse_icmpv4_layer(layer, match):
assert(type(layer) == scapy.ICMP)
match.oxm_list.append(ofp.oxm.icmpv4_type(layer.type))
match.oxm_list.append(ofp.oxm.icmpv4_code(layer.code))
def parse_arp_layer(layer, match):
assert(type(layer) == scapy.ARP)
match.oxm_list.append(ofp.oxm.arp_op(layer.op))
match.oxm_list.append(ofp.oxm.arp_spa(parse_ip(layer.psrc)))
match.oxm_list.append(ofp.oxm.arp_tpa(parse_ip(layer.pdst)))
match.oxm_list.append(ofp.oxm.arp_sha(parse_mac(layer.hwsrc)))
match.oxm_list.append(ofp.oxm.arp_tha(parse_mac(layer.hwdst)))
def parse_ipv6_layer(layer, match):
assert(type(layer) == scapy.IPv6)
# TODO handle chained headers
match.oxm_list.append(ofp.oxm.ip_proto(layer.nh))
match.oxm_list.append(ofp.oxm.ip_dscp(layer.tc >> 2))
match.oxm_list.append(ofp.oxm.ip_ecn(layer.tc & 3))
match.oxm_list.append(ofp.oxm.ipv6_src(parse_ipv6(layer.src)))
match.oxm_list.append(ofp.oxm.ipv6_dst(parse_ipv6(layer.dst)))
match.oxm_list.append(ofp.oxm.ipv6_flabel(layer.fl))
if type(layer.payload) == scapy.TCP:
parse_tcp_layer(layer.payload, match)
elif type(layer.payload) == scapy.UDP:
parse_udp_layer(layer.payload, match)
elif layer.nh == 0x3a:
parse_icmpv6_layer(layer.payload, match)
# TODO ND
# TODO SCTP
def parse_icmpv6_layer(layer, match):
match.oxm_list.append(ofp.oxm.icmpv6_type(layer.type))
match.oxm_list.append(ofp.oxm.icmpv6_code(layer.code))
if type(packet) == type(""):
ether = scapy.Ether(packet)
else:
ether = packet
match = ofp.match()
parse_ether_layer(packet, match)
return match
def packet_to_flow_match_v1(packet):
"""
OpenFlow 1.0 implementation of packet_to_flow_match
"""
import loxi.of10 as ofp
if type(packet) == type(""):
ether = scapy.Ether(packet)
else:
ether = packet
# For now, assume ether IP packet and ignore wildcards
try:
(dot1q, ip, tcp, udp, icmp, arp) = packet_type_classify(ether)
except:
raise ValueError("could not classify packet")
match = ofp.match()
match.wildcards = ofp.OFPFW_ALL
#@todo Check if packet is other than L2 format
match.eth_dst = parse_mac(ether.dst)
match.wildcards &= ~ofp.OFPFW_DL_DST
match.eth_src = parse_mac(ether.src)
match.wildcards &= ~ofp.OFPFW_DL_SRC
match.eth_type = ether.type
match.wildcards &= ~ofp.OFPFW_DL_TYPE
if dot1q:
match.vlan_vid = dot1q.vlan
match.vlan_pcp = dot1q.prio
match.eth_type = dot1q.type
else:
match.vlan_vid = ofp.OFP_VLAN_NONE
match.vlan_pcp = 0
match.wildcards &= ~ofp.OFPFW_DL_VLAN
match.wildcards &= ~ofp.OFPFW_DL_VLAN_PCP
if ip:
match.ipv4_src = parse_ip(ip.src)
match.wildcards &= ~ofp.OFPFW_NW_SRC_MASK
match.ipv4_dst = parse_ip(ip.dst)
match.wildcards &= ~ofp.OFPFW_NW_DST_MASK
match.ip_dscp = ip.tos
match.wildcards &= ~ofp.OFPFW_NW_TOS
if tcp:
match.ip_proto = 6
match.wildcards &= ~ofp.OFPFW_NW_PROTO
elif not tcp and udp:
tcp = udp
match.ip_proto = 17
match.wildcards &= ~ofp.OFPFW_NW_PROTO
if tcp:
match.tcp_src = tcp.sport
match.wildcards &= ~ofp.OFPFW_TP_SRC
match.tcp_dst = tcp.dport
match.wildcards &= ~ofp.OFPFW_TP_DST
if icmp:
match.ip_proto = 1
match.tcp_src = icmp.type
match.tcp_dst = icmp.code
match.wildcards &= ~ofp.OFPFW_NW_PROTO
if arp:
match.ip_proto = arp.op
match.wildcards &= ~ofp.OFPFW_NW_PROTO
match.ipv4_src = parse_ip(arp.psrc)
match.wildcards &= ~ofp.OFPFW_NW_SRC_MASK
match.ipv4_dst = parse_ip(arp.pdst)
match.wildcards &= ~ofp.OFPFW_NW_DST_MASK
return match