def createIpv6Pkt(self, ipproto=6, layer1=None, layer2=None):
e = ethernet()
e.dst = self.dmac
e.src = self.smac
e.type = 0x86dd
i = ipv6()
i.next_header = ipproto
i.src = self.src6
i.dst = self.dst6
e.data = i
i.data = layer1
layer1.data = layer2
if layer2 == None:
retChain = pcs.Chain([e, i, layer1]).packets[0]
else:
retChain = pcs.Chain([e, i, layer1, layer2]).packets[0]
return retChain
def createwritepacket(self, tcb, ip, tcp, from_, to):
ether = createethernet(self, tcb, from_, to)
tcp.checksum = tcp_cksum(tcp, ip)
ip.length = len(ip.bytes) + len(tcp.bytes)
ip.checksum = ip_cksum(ip)
packet = pcs.Chain([ether, ip, tcp])
tcb.output[from_].write(packet.bytes, len(packet.bytes))
def createIpv4Pkt(self, ipproto=6, layer1=None, layer2=None):
e = ethernet()
e.dst = self.dmac
e.src = self.smac
e.type = 0x0800
i = ipv4()
i.protocol = ipproto
i.id = 0
i.flags = 0
i.src = self.src
i.dst = self.dst
e.data = i
i.data = layer1
layer1.data = layer2
if layer2 == None:
retChain = pcs.Chain([e, i, layer1]).packets[0]
else:
retChain = pcs.Chain([e, i, layer1, layer2]).packets[0]
return retChain
def executeTrigger(self, pkt):
"""
Execute the trigger action the pkt which satisfies the trigger's
action conditions.
@param pkt:
The packet against which a trigger is actioned
@return:
A trigger Chain for transmission, None if action is internal
"""
retChain = None
# Action based on trigger type
if self.action == Trigger.Trigger.STOP:
# Test if pkt is really a HTTP packet
(p, i) = pkt.chain().find_first_of(pcs.packets.http.httpResponse)
if not p:
self.logger.debug("HTTP trigger.STOP:\n%s" % pkt.chain())
raise PcapReplayError(Trigger.ERR_PCAPR_TRIGGER_INVALID,
'executeTrigger : Invalid trigger/pkt ' +
'pair execution')
# Create a terminating response chain for xmit by the caller
ether = pkt
e = ethernet()
e.dst = ether.src
e.src = ether.dst
e.type = ether.type
ip = pkt.data
if type(ip) == pcs.packets.ipv4.ipv4:
i = ipv4()
i.tos = ip.tos
i.protocol = ip.protocol
i.id = 0
i.flags = 0
elif type(ip) == pcs.packets.ipv6.ipv6:
i = ipv6()
i.traffic_class = ip.traffic_class
i.next_header = ip.next_header
i.src = ip.dst
i.dst = ip.src
tcp = pkt.data.data
t = pcs.packets.tcp.tcp()
t.sport = tcp.dport
t.dport = tcp.sport
t.reset = 1
t.ack = 1
t.ack_number = tcp.ack_number
t.sequence = tcp.sequence
t.data = None
retChain = pcs.Chain([e, i, t])
retChain.fixup()
return retChain
def main():
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-i",
"--interface",
dest="interface",
default=None,
help="Network interface to send on.")
parser.add_option("-t",
"--target",
dest="ip_target",
default=None,
help="IPv4 target address to lookup.")
parser.add_option("-s",
"--ip_source",
dest="ip_source",
default=None,
help="IPv4 source address to use.")
parser.add_option("-d",
"--ether_destination",
dest="ether_destination",
default=None,
help="Ethernet destination address to use.")
parser.add_option("-e",
"--ether_source",
dest="ether_source",
default=None,
help="Ethernet source address to use.")
parser.add_option("-o",
"--source-port",
dest="source_port",
default=None,
help="Tcp source port.")
parser.add_option("-x",
"--destination-port",
dest="destination_port",
default=None,
help="Tcp destination port.")
(options, args) = parser.parse_args()
import random
ipid = random.randrange(1, (1 << 16) - 1)
tcpsport = random.randrange(50000, 60000) #int(options.source_port )
tcpsequence = random.randrange(1, (1 << 32) - 1)
output = pcs.PcapConnector(options.interface)
replyip = None
replytcp = None
reply = None
packet = None
# SYN
what = "SYN"
ip1 = ipv4.ipv4()
ip1.version = 4
ip1.hlen = 5
ip1.tos = 0
ip1.id = ++ipid
ip1.flags = 0
ip1.offset = 0
ip1.ttl = 64
ip1.protocol = pcs.IPPROTO_TCP
ip1.src = pcs.inet_atol(options.ip_source)
ip1.dst = pcs.inet_atol(options.ip_target)
tcp1 = tcp.tcp()
tcp1.sport = tcpsport
tcp1.dport = int(options.destination_port)
tcp1.sequence = tcpsequence
tcpsequence = tcpsequence + 1 # SYN consumes the sequence
tcp1.ack_number = 0
tcp1.offset = 5
tcp1.urgent = 0
tcp1.ack = 0
tcp1.push = 0
tcp1.reset = 0
tcp1.syn = 1
tcp1.fin = 0
tcp1.window = (1 << 16) - 1
tcp1.urg_point = 0
#tcp1.options
tcp1.checksum = tcp_cksum(tcp1, ip1)
ip1.length = len(ip1.bytes) + len(tcp1.bytes)
# important, only calcs the ip checksum after fill length field
ip1.checksum = ip_cksum(ip1)
ether1 = ethernet.ethernet()
ether1.src = ethernet.ether_atob(options.ether_source)
ether1.dst = ethernet.ether_atob(options.ether_destination)
ether1.type = 0x800
packet = pcs.Chain([ether1, ip1, tcp1])
print "\n%s---------------------------------" % what
print tcp1
print "---------------------------------"
out = output.write(packet.bytes, len(packet.bytes))
## SYN
# SYN+ACK
what = "SYN+ACK"
while 1:
reply = output.read()
packet = ethernet.ethernet(reply)
try:
replyip = packet.data
replytcp = replyip.data
if (ip1.src==replyip.dst and \
ip1.dst==replyip.src and \
tcp1.sport==replytcp.dport and \
tcp1.dport==replytcp.sport):
break
except: #it cannot be a tcp packet (without sport:)
pass
print "\n%s---------------------------------" % what
print packet.data.data
print "---------------------------------"
## SYN+ACK
# ACK 134,187
what = "ACK (SYN)"
ip3 = ipv4.ipv4()
ip3.version = 4
ip3.hlen = 5
ip3.tos = 0
ip3.id = ++ipid
ip3.flags = 0
ip3.offset = 0
ip3.ttl = 64
ip3.protocol = pcs.IPPROTO_TCP
ip3.src = pcs.inet_atol(options.ip_source)
ip3.dst = pcs.inet_atol(options.ip_target)
tcp3 = tcp.tcp()
tcp3.sport = tcpsport
tcp3.dport = int(options.destination_port)
tcp3.sequence = tcpsequence
##tcpsequence = tcpsequence + 1 # ACK DOES NOT consumes the sequence
tcp3.ack_number = replytcp.sequence + 1
tcp3.offset = 5
tcp3.urgent = 0
tcp3.ack = 1
tcp3.push = 0
tcp3.reset = 0
tcp3.syn = 0
tcp3.fin = 0
tcp3.window = (1 << 16) - 1
tcp3.urg_point = 0
#tcp3.options
tcp3.checksum = tcp_cksum(tcp3, ip3)
ip3.length = len(ip3.bytes) + len(tcp3.bytes)
# important, only calcs the ip checksum after fill length field
ip3.checksum = ip_cksum(ip3)
ether3 = ethernet.ethernet()
ether3.src = ethernet.ether_atob(options.ether_source)
ether3.dst = ethernet.ether_atob(options.ether_destination)
ether3.type = 0x800
packet = pcs.Chain([ether3, ip3, tcp3])
print "\n%s---------------------------------" % what
print tcp3
print "---------------------------------"
out = output.write(packet.bytes, len(packet.bytes))
## ACK
# FIN 188,241
what = "FIN"
ip4 = ipv4.ipv4()
ip4.version = 4
ip4.hlen = 5
ip4.tos = 0
ip4.id = ++ipid
ip4.flags = 0
ip4.offset = 0
ip4.ttl = 64
ip4.protocol = pcs.IPPROTO_TCP
ip4.src = pcs.inet_atol(options.ip_source)
ip4.dst = pcs.inet_atol(options.ip_target)
tcp4 = tcp.tcp()
tcp4.sport = tcpsport
tcp4.dport = int(options.destination_port)
tcp4.sequence = tcpsequence
tcpsequence = tcpsequence + 1 # FIN consumes the sequence
tcp4.ack_number = replytcp.sequence + 1
tcp4.offset = 5
tcp4.urgent = 0
tcp4.ack = 1
tcp4.push = 0
tcp4.reset = 0
tcp4.syn = 0
tcp4.fin = 1
tcp4.window = (1 << 16) - 1
tcp4.urg_point = 0
#tcp4.options
tcp4.checksum = tcp_cksum(tcp4, ip4)
ip4.length = len(ip4.bytes) + len(tcp4.bytes)
# important, only calcs the ip checksum after fill length field
ip4.checksum = ip_cksum(ip4)
ether4 = ethernet.ethernet()
ether4.src = ethernet.ether_atob(options.ether_source)
ether4.dst = ethernet.ether_atob(options.ether_destination)
ether4.type = 0x800
packet = pcs.Chain([ether4, ip4, tcp4])
print "\n%s---------------------------------" % what
print tcp4
print "---------------------------------"
out = output.write(packet.bytes, len(packet.bytes))
## FIN
# ACK (FIN)
what = "ACK (FIN)"
while 1:
reply = output.read()
packet = ethernet.ethernet(reply)
try:
replyip = packet.data
replytcp = replyip.data
if (ip1.src==replyip.dst and \
ip1.dst==replyip.src and \
tcp1.sport==replytcp.dport and \
tcp1.dport==replytcp.sport):
break
except: #it cannot be a tcp packet (without sport:)
pass
print "\n%s---------------------------------" % what
print packet.data.data
print "---------------------------------"
## ACK (FIN)
# FIN
what = "FIN"
while 1:
reply = output.read()
packet = ethernet.ethernet(reply)
try:
replyip = packet.data
replytcp = replyip.data
if (ip1.src==replyip.dst and \
ip1.dst==replyip.src and \
tcp1.sport==replytcp.dport and \
tcp1.dport==replytcp.sport):
break
except: #it cannot be a tcp packet (without sport:)
pass
print "\n%s---------------------------------" % what
print packet.data.data
print "---------------------------------"
## FIN
# ACK (FIN) 288,341
what = "ACK (FIN)"
ip7 = ipv4.ipv4()
ip7.version = 4
ip7.hlen = 5
ip7.tos = 0
ip7.id = ++ipid
ip7.flags = 0
ip7.offset = 0
ip7.ttl = 64
ip7.protocol = pcs.IPPROTO_TCP
ip7.src = pcs.inet_atol(options.ip_source)
ip7.dst = pcs.inet_atol(options.ip_target)
tcp7 = tcp.tcp()
tcp7.sport = tcpsport
tcp7.dport = int(options.destination_port)
tcp7.sequence = tcpsequence
##tcpsequence = tcpsequence + 1 # ACK DOES NOT consumes the sequence
tcp7.ack_number = replytcp.sequence + 1
tcp7.offset = 5
tcp7.urgent = 0
tcp7.ack = 1
tcp7.push = 0
tcp7.reset = 0
tcp7.syn = 0
tcp7.fin = 0
tcp7.window = (1 << 16) - 1
tcp7.urg_point = 0
#tcp7.options
tcp7.checksum = tcp_cksum(tcp7, ip7)
ip7.length = len(ip7.bytes) + len(tcp7.bytes)
# important, only calcs the ip checksum after fill length field
ip7.checksum = ip_cksum(ip7)
ether7 = ethernet.ethernet()
ether7.src = ethernet.ether_atob(options.ether_source)
ether7.dst = ethernet.ether_atob(options.ether_destination)
ether7.type = 0x800
packet = pcs.Chain([ether7, ip7, tcp7])
print "\n%s---------------------------------" % what
print tcp7
print "---------------------------------"
out = output.write(packet.bytes, len(packet.bytes))