def __init__(self,
next_hop=None,
delay=None,
bandwidth=None,
mtu=None,
hop_count=None,
reliability=None,
load=None,
prefix=None,
dest=None):
eigrp_tlv.__init__(self, eigrp_tlv.EIGRP_TYPE_INTERNAL_ROUTE)
if next_hop:
self.next_hop = dumbnet.ip_aton(next_hop)
else:
self.next_hop = next_hop
self.delay = delay
self.bandwidth = bandwidth
self.mtu = mtu
self.hop_count = hop_count
self.reliability = reliability
self.load = load
self.prefix = prefix
if dest:
self.dest = dumbnet.ip_aton(dest)
else:
self.dest = dest
def run(self):
self.parent.log("RIP: Thread started")
timer = 15
while self.running:
if timer == 15:
timer = 0
rlist = []
for ip in self.parent.routes:
(iter, mask, nh, metrik) = self.parent.routes[ip]
rlist.append(rip_entry(rip_entry.AF_INET, 0, dumbnet.ip_aton(ip), dumbnet.ip_aton(mask), dumbnet.ip_aton(nh), int(metrik)))
msg = rip_message(rip_message.COMMAND_RESPONSE, rlist)
data = msg.render()
for dst in self.parent.hosts:
udp_hdr = dpkt.udp.UDP( sport=RIP_PORT,
dport=RIP_PORT,
data=data
)
udp_hdr.ulen += len(udp_hdr.data)
ip_hdr = dpkt.ip.IP( ttl=2,
p=dpkt.ip.IP_PROTO_UDP,
src=self.parent.ip,
dst=dumbnet.ip_aton(RIP_MULTICAST_ADDRESS),
data=str(udp_hdr)
)
ip_hdr.len += len(ip_hdr.data)
eth_hdr = dpkt.ethernet.Ethernet( dst=dumbnet.eth_aton(RIP_MULTICAST_MAC),
src=self.parent.mac,
type=dpkt.ethernet.ETH_TYPE_IP,
data=str(ip_hdr)
)
self.parent.dumbnet.send(str(eth_hdr))
timer = timer + 1
time.sleep(1)
self.parent.log("RIP: Thread terminated")
def run(self):
self.parent.log("WLCCP: Election Thread started")
header = wlccp_header(0xc1, 0x0, 0x8003, 0x41, 0x0, 0x2800, 0x0, dumbnet.eth_aton("00:00:00:00:00:00"), 0x2, dumbnet.eth_aton(self.mac))
h_data = header.render("%s\x00\x01\x00\x00\xff\x00%s\x00\x00\x00\x00\x00\x02\x00\x00\x00\x05%s%s%s%s%s%s%s%s"
% ( dumbnet.eth_aton(self.mac),
dumbnet.eth_aton(self.mac),
self.BLOB1,
dumbnet.eth_aton(self.mac),
dumbnet.ip_aton(self.ip),
self.BLOB2,
dumbnet.ip_aton(self.ip),
self.BLOB3,
self.BLOB4,
self.BLOB5
) )
data = dumbnet.eth_pack_hdr(dumbnet.eth_aton(self.WLCCP_DST_MAC), dumbnet.eth_aton(self.mac), socket.htons(self.WLCCP_ETH_TYPE)) + h_data
while self.running:
if self.parent.dumbnet:
self.parent.dumbnet.send(data)
for x in xrange(self.delay):
if not self.running:
break
time.sleep(1)
self.parent.log("WLCCP: Election Thread terminated")
def update_devices(self):
self.devices = {}
devs = pcap.findalldevs()
for (name, descr, addr, flags) in devs:
try:
test = dumbnet.eth(name)
mac = test.get()
self.devices[name] = {
'mac': mac,
'ip4': [],
'ip6': [],
'descr': descr,
'flags': flags
}
except:
pass
else:
if len(addr) > 1:
for (ip, mask, net, gw) in addr:
try:
dumbnet.ip_aton(ip)
addr_dict = {}
addr_dict['ip'] = ip
addr_dict['mask'] = mask
addr_dict['net'] = net
addr_dict['gw'] = gw
self.devices[name]['ip4'].append(addr_dict)
except:
pass
try:
dumbnet.ip6_aton(ip)
addr_dict = {}
addr_dict['ip'] = ip
if PLATFORM == "Windows" and mask is None:
addr_dict['mask'] = "ffff:ffff:ffff:ffff::"
else:
addr_dict['mask'] = mask
addr_dict['net'] = net
addr_dict['gw'] = gw
if ip.startswith("fe80:"):
addr_dict['linklocal'] = True
else:
addr_dict['linklocal'] = False
self.devices[name]['ip6'].append(addr_dict)
except:
pass
else:
#????
pass
def run(self):
self.parent.log("VRRP-3: Thread started")
while self.running:
for i in self.parent.peers:
(iter, pkg, state, arp) = self.parent.peers[i]
if state:
src_mac = dumbnet.eth_aton("00:00:5e:00:01:%02x" %
(pkg.id))
vrrp = vrrp_packet(pkg.id, 255, pkg.auth_type,
pkg.auth_data, 1, pkg.ips)
data = vrrp.render()
ip_hdr = dpkt.ip.IP(
ttl=255,
p=dpkt.ip.IP_PROTO_VRRP,
src=self.parent.ip,
dst=dumbnet.ip_aton(VRRP3_MULTICAST_ADDRESS),
data=data)
ip_hdr.len += len(ip_hdr.data)
ip_hdr.data = vrrp.build_checksum(ip_hdr.data, ip_hdr)
eth_hdr = dpkt.ethernet.Ethernet(
dst=dumbnet.eth_aton(VRRP3_MULTICAST_MAC),
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_IP,
data=str(ip_hdr))
self.parent.dumbnet.send(str(eth_hdr))
if arp:
brdc_mac = dumbnet.eth_aton("ff:ff:ff:ff:ff:ff")
stp_uplf_mac = dumbnet.eth_aton("01:00:0c:cd:cd:cd")
src_mac = self.parent.mac
for j in pkg.ips:
arp_hdr = dpkt.arp.ARP(hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=j,
tha=brdc_mac,
tpa=j)
eth_hdr = dpkt.ethernet.Ethernet(
dst=brdc_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr))
self.parent.dumbnet.send(str(eth_hdr))
arp_hdr = dpkt.arp.ARP(hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=j,
tha=stp_uplf_mac,
tpa=j)
eth_hdr = dpkt.ethernet.Ethernet(
dst=stp_uplf_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr))
self.parent.dumbnet.send(str(eth_hdr))
self.parent.peers[i] = (iter, pkg, state, arp - 1)
time.sleep(1)
self.parent.log("VRRP-3: Thread terminated")
def on_spoof_togglebutton_toggled(self, btn):
if btn.get_property("active"):
self.spoof = dumbnet.ip_aton(self.spoof_entry.get_text())
self.spoof_entry.set_property("sensitive", False)
else:
self.spoof_entry.set_property("sensitive", True)
self.spoof = False
def input_udp(self, eth, ip, udp, timestamp):
if ip.dst == dumbnet.ip_aton(RIP_MULTICAST_ADDRESS) and ip.src != self.ip:
if ip.src not in self.hosts:
src = dumbnet.ip_ntoa(ip.src)
iter = self.host_treestore.append(None, [src])
self.log("RIP: Got new host %s" % (src))
self.hosts[ip.src] = (iter, src)
msg = rip_message()
msg.parse(udp.data)
for i in msg.entries:
nh = dumbnet.ip_ntoa(i.nh)
if nh == "0.0.0.0":
nh = src
self.host_treestore.append(iter, ["%s/%s via %s metric %d" % (dumbnet.ip_ntoa(i.addr), dumbnet.ip_ntoa(i.mask), nh, i.metric)])
else:
(iter, src) = self.hosts[ip.src]
msg = rip_message(None, [])
msg.parse(udp.data)
path = self.host_treestore.get_path(iter)
expanded = self.host_treeview.row_expanded(path)
child = self.host_treestore.iter_children(iter)
while child:
self.host_treestore.remove(child)
child = self.host_treestore.iter_children(iter)
for i in msg.entries:
nh = dumbnet.ip_ntoa(i.nh)
if nh == "0.0.0.0":
nh = src
self.host_treestore.append(iter, ["%s/%s via %s metric %d" % (dumbnet.ip_ntoa(i.addr), dumbnet.ip_ntoa(i.mask), nh, i.metric)])
if expanded:
self.host_treeview.expand_row(path, False)
def hello(self):
timer = DEFAULT_HOLD_TIME
while self.running:
if timer == DEFAULT_HOLD_TIME:
timer = 0
params = eigrp_param(1, 0, 1, 0, 0, 15)
version = eigrp_version(self.parent.ios_ver,
self.parent.eigrp_ver) #(0xc02, 0x300)
args = [params, version]
if self.auth:
args.insert(0, self.auth)
msg = eigrp_packet(eigrp_packet.EIGRP_OPTCODE_HELLO, 0, 0, 0,
self.as_num, args)
data = msg.render()
if not self.parent.spoof:
self.send_multicast(data)
else:
ip_hdr = dpkt.ip.IP(
ttl=2,
p=dpkt.ip.IP_PROTO_EIGRP,
src=self.parent.spoof,
dst=dumbnet.ip_aton(EIGRP_MULTICAST_ADDRESS),
data=data)
ip_hdr.len += len(ip_hdr.data)
eth_hdr = dpkt.ethernet.Ethernet(
dst=dumbnet.eth_aton(EIGRP_MULTICAST_MAC),
src=self.parent.mac,
type=dpkt.ethernet.ETH_TYPE_IP,
data=str(ip_hdr))
self.parent.dumbnet.send(str(eth_hdr))
timer += 1
time.sleep(1)
def input_ip(self, eth, ip, timestamp):
if ip.dst == dumbnet.ip_aton("224.0.0.10"):
if ip.src != self.address and ip.src != self.spoof:
self.disp_multicast(str(ip.data), eth.src, ip.src)
if self.listen_for_auth and ip.src == self.address:
self.disp_auth(str(ip.data))
elif ip.dst == self.address or ip.dst == self.spoof:
self.disp_unicast(str(ip.data), eth.src, ip.src)
def on_release_button_clicked(self, btn):
select = self.treeview.get_selection()
(model, paths) = select.get_selected_rows()
for i in paths:
iter = model.get_iter(i)
peer = dumbnet.ip_aton(model.get_value(iter, self.STORE_SRC_ROW))
self.peers[peer]["state"] = False
model.set_value(iter, self.STORE_STATE_ROW, "Released")
def __init__(self, config): #interface, tunip, tun_mask, tun_decoy_dest):
self.config = config
self.log = logging.getLogger('cb.tcphijack.dr2dp_dp_tun')
self.tun = cb.util.twistedtun.TwistedTUN(
lambda x: self.handle_read(x),
interface=self.config['test']['tun_interface'],
ip=self.config['test']['tun_ip'],
netmask=self.config['test']['tun_netmask'])
self.decoy_dest = ip_aton(self.config['test']['decoy_dest'])
self.decoy_tun_dest = ip_aton(self.config['test']['decoy_tun_dest'])
self.tun_ip = ip_aton(self.config['test']['tun_ip'])
self.raw = socket.socket(socket.AF_INET, socket.SOCK_RAW,
socket.IPPROTO_TCP)
self.raw.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
self.flows = {}
def on_release_button_clicked(self, btn):
select = self.treeview.get_selection()
(model, paths) = select.get_selected_rows()
for i in paths:
iter = model.get_iter(i)
peer = dumbnet.ip_aton(model.get_value(iter, self.LIST_SRC_ROW))
(iter, pkg, run, arp) = self.peers[peer]
self.peers[peer] = (iter, pkg, False, arp)
model.set_value(iter, self.LIST_STATE_ROW, "Released")
def on_update_button_clicked(self, data):
page = self.notebook.get_current_page()
if page == 0:
msg = eigrp_packet(
eigrp_packet.EIGRP_OPTCODE_UPDATE,
eigrp_packet.EIGRP_FLAGS_COND_RECV, 0, 0,
int(self.as_spinbutton.get_value()), [
eigrp_internal_route(
self.next_hop_entry.get_text(),
int(self.delay_spinbutton.get_value()),
int(self.bandwidth_spinbutton.get_value()),
int(self.mtu_spinbutton.get_value()),
int(self.hop_count_spinbutton.get_value()),
int(self.reliability_spinbutton.get_value()),
int(self.load_spinbutton.get_value()),
int(self.prefix_spinbutton.get_value()),
self.destination_entry.get_text())
])
elif page == 1:
msg = eigrp_packet(
eigrp_packet.EIGRP_OPTCODE_UPDATE,
eigrp_packet.EIGRP_FLAGS_COND_RECV, 0, 0,
int(self.as_spinbutton.get_value()), [
eigrp_external_route(
self.next_hop_entry1.get_text(),
self.orig_router_entry.get_text(),
int(self.orig_as_spinbutton.get_value()), 0,
int(self.external_metric_spinbutton.get_value()),
int(self.external_id_spinbutton.get_value()), 0,
int(self.delay_spinbutton1.get_value()),
int(self.bandwidth_spinbutton1.get_value()),
int(self.mtu_spinbutton1.get_value()),
int(self.hop_count_spinbutton1.get_value()),
int(self.reliability_spinbutton1.get_value()),
int(self.load_spinbutton1.get_value()),
int(self.prefix_spinbutton1.get_value()),
self.destination_entry1.get_text())
])
elif page == 2:
buffer = self.update_textview.get_buffer()
text = buffer.get_text(buffer.get_start_iter(),
buffer.get_end_iter())
if text == "":
return
exec("msg = " + text)
select = self.treeview.get_selection()
(model, paths) = select.get_selected_rows()
for i in paths:
parent = model.iter_parent(model.get_iter(i))
if not parent:
parent = model.get_iter(i)
host = model.get_value(parent, self.TREE_HOST_ROW)
self.log("EIGRP: Sending update to %s" % (host))
peer = dumbnet.ip_aton(host)
self.peers[peer].update(msg)
def on_del_button_clicked(self, data):
select = self.treeview.get_selection()
(model, paths) = select.get_selected_rows()
for i in paths:
parent = model.iter_parent(model.get_iter(i))
if not parent:
parent = model.get_iter(i)
host = model.get_value(parent, self.TREE_HOST_ROW)
peer = dumbnet.ip_aton(host)
self.peers[peer].quit()
def __init__(self,
next_hop=None,
originating_router=None,
originating_as=None,
arbitrary_tag=None,
external_metric=None,
external_proto=None,
flags=None,
delay=None,
bandwidth=None,
mtu=None,
hop_count=None,
reliability=None,
load=None,
prefix=None,
dest=None):
eigrp_tlv.__init__(self, eigrp_tlv.EIGRP_TYPE_EXTERNAL_ROUTE)
if next_hop:
self.next_hop = dumbnet.ip_aton(next_hop)
else:
self.next_hop = next_hop
if originating_router:
self.originating_router = dumbnet.ip_aton(originating_router)
else:
self.originating_router = originating_router
self.originating_as = originating_as
self.arbitrary_tag = arbitrary_tag
self.external_metric = external_metric
self.external_proto = external_proto
self.flags = flags
self.delay = delay
self.bandwidth = bandwidth
self.mtu = mtu
self.hop_count = hop_count
self.reliability = reliability
self.load = load
self.prefix = prefix
if dest:
self.dest = dumbnet.ip_aton(dest)
else:
self.dest = dest
def send_multicast(self, data):
ip_hdr = dpkt.ip.IP(ttl=2,
p=dpkt.ip.IP_PROTO_EIGRP,
src=self.parent.address,
dst=dumbnet.ip_aton(EIGRP_MULTICAST_ADDRESS),
data=data)
ip_hdr.len += len(ip_hdr.data)
eth_hdr = dpkt.ethernet.Ethernet(
dst=dumbnet.eth_aton(EIGRP_MULTICAST_MAC),
src=self.parent.mac,
type=dpkt.ethernet.ETH_TYPE_IP,
data=str(ip_hdr))
self.parent.dumbnet.send(str(eth_hdr))
def on_get_button_clicked(self, btn):
select = self.treeview.get_selection()
(model, paths) = select.get_selected_rows()
for i in paths:
iter = model.get_iter(i)
peer = dumbnet.ip_aton(model.get_value(iter, self.STORE_SRC_ROW))
if self.arp_checkbutton.get_active():
arp = 3
else:
arp = 0
self.peers[peer]["state"] = True
self.peers[peer]["arp"] = arp
model.set_value(iter, self.STORE_STATE_ROW, "Taken")
if not self.thread.is_alive():
self.thread.start()
def on_get_button_clicked(self, btn):
select = self.treeview.get_selection()
(model, paths) = select.get_selected_rows()
for i in paths:
iter = model.get_iter(i)
peer = dumbnet.ip_aton(model.get_value(iter, self.LIST_SRC_ROW))
(iter, pkg, run, arp) = self.peers[peer]
if self.arp_checkbutton.get_active():
arp = 3
else:
arp = 0
self.peers[peer] = (iter, pkg, True, arp)
model.set_value(iter, self.LIST_STATE_ROW, "Taken")
if not self.thread.is_alive():
self.thread.start()
def on_goodbye_button_clicked(self, data):
select = self.treeview.get_selection()
(model, paths) = select.get_selected_rows()
if len(paths) == 1:
parent = model.iter_parent(model.get_iter(paths[0]))
if not parent:
parent = model.get_iter(paths[0])
host = model.get_value(parent, self.TREE_HOST_ROW)
peer = dumbnet.ip_aton(host)
self.peers[peer].msg = None
self.goodbye_thread = eigrp_goodbye(self, peer,
self.peers[peer].as_num)
self.goodbye_label.set_label("Sending Goodbye Messages to %s..." %
(host))
self.goodbye_window.show_all()
self.goodbye_thread.start()
self.log("EIGRP: Goodbye thread started for %s" % (host))
def tun0rd(pkt):
print "tun0 got: %s" % dpkt_to_str(pkt)
# client -> server
if pkt.dst == ip_aton('10.0.1.42'):
pkt.src = ip_aton('10.0.1.84')
pkt.dst = ip_aton('10.0.1.1')
# server -> client
elif pkt.dst == ip_aton('10.0.1.84'):
pkt.src = ip_aton('10.0.1.42')
pkt.dst = ip_aton('10.0.1.1')
pkt.data.sum = 0
pkt.sum = 0
print "writing to tun0: %s" % dpkt_to_str(pkt)
os.write(tun0.fd, str(pkt))
def on_add_button_clicked(self, data):
dialog = gtk.MessageDialog(
self.parent.window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_QUESTION, gtk.BUTTONS_OK_CANCEL,
"Enter IP Address to add:")
entry = gtk.Entry(0)
dialog.vbox.pack_start(entry)
entry.show()
ret = dialog.run()
dialog.destroy()
if ret == gtk.RESPONSE_OK:
try:
peer = entry.get_text()
arp = dumbnet.arp()
mac = arp.get(dumbnet.addr(peer))
if not mac:
raise Exception("Unable to get mac address")
self.add_peer(mac.data, dumbnet.ip_aton(peer),
int(self.as_spinbutton.get_value()))
except Exception, e:
self.log("EIGRP: Cant add peer %s: %s" % (peer, e))
def run(self):
self.parent.log("GLBP: Thread started")
while self.running:
for i in self.parent.peers:
(iter, pkg, hello, req_resp, auth, state,
arp) = self.parent.peers[i]
if state:
glbp = glbp_packet(pkg.group, self.parent.mac)
glbp_hello = glbp_tlv_hello(glbp_tlv_hello.STATE_ACTIVE,
255, hello.hello_int,
hello.hold_int, hello.redirect,
hello.timeout, hello.addr_type,
hello.addr_len, hello.addr)
reqs = ""
for req in req_resp:
req.prio = 255
req.weight = 255
reqs += req.render()
if not auth is None:
if auth.auth_type == glbp_tlv_auth.TYPE_PLAIN:
data = glbp.render() + auth.render(
) + glbp_hello.render() + reqs
elif auth.auth_type == glbp_tlv_auth.TYPE_MD5_STRING:
nonce = "\x00\x01\x02\x03\x04\x05\x06\x07"
data = glbp_tlv_nonce().render(
nonce) + glbp_hello.render() + reqs
import hashlib
m = hashlib.md5()
m.update(data)
auth.secret = m.digest()
data = glbp.render() + auth.render() + data
else:
data = glbp.render() + glbp_hello.render() + reqs
udp_hdr = dpkt.udp.UDP(sport=GLBP_PORT,
dport=GLBP_PORT,
data=data)
udp_hdr.ulen += len(udp_hdr.data)
ip_hdr = dpkt.ip.IP(
ttl=255,
p=dpkt.ip.IP_PROTO_UDP,
src=self.parent.ip,
dst=dumbnet.ip_aton(GLBP_MULTICAST_ADDRESS),
data=str(udp_hdr))
ip_hdr.len += len(ip_hdr.data)
eth_hdr = dpkt.ethernet.Ethernet(
dst=dumbnet.eth_aton(GLBP_MULTICAST_MAC),
src=self.parent.mac,
type=dpkt.ethernet.ETH_TYPE_IP,
data=str(ip_hdr))
self.parent.dumbnet.send(str(eth_hdr))
if arp:
if arp < 4:
src_mac = self.parent.mac
brdc_mac = dumbnet.eth_aton("ff:ff:ff:ff:ff:ff")
stp_uplf_mac = dumbnet.eth_aton(
"01:00:0c:cd:cd:cd")
ip = hello.addr #struct.pack("!I", hello.addr)
arp_hdr = dpkt.arp.ARP(hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=ip,
tha=brdc_mac,
tpa=ip)
eth_hdr = dpkt.ethernet.Ethernet(
dst=brdc_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr))
self.parent.dumbnet.send(str(eth_hdr))
arp_hdr = dpkt.arp.ARP(hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=ip,
tha=stp_uplf_mac,
tpa=ip)
eth_hdr = dpkt.ethernet.Ethernet(
dst=stp_uplf_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr))
self.parent.dumbnet.send(str(eth_hdr))
self.parent.peers[i] = (iter, pkg, hello, req_resp,
auth, state, arp - 1)
time.sleep(1)
self.parent.log("GLBP: Thread terminated")
def run(self):
self.parent.log("HSRP2: Thread started")
while self.running:
for i in self.parent.peers:
(iter, pkg, state, arp) = self.parent.peers[i]
if state:
hsrp2_group_state = hsrp2_group_state_tlv( hsrp2_group_state_tlv.OP_CODE_HELLO,
hsrp2_group_state_tlv.STATE_ACTIVE,
pkg["hsrp2_group_state_tlv"].ip_ver,
pkg["hsrp2_group_state_tlv"].group,
self.parent.mac,
255,
pkg["hsrp2_group_state_tlv"].hello_time,
pkg["hsrp2_group_state_tlv"].hold_time,
pkg["hsrp2_group_state_tlv"].ip
)
data = hsrp2_group_state.render()
if "hsrp2_text_auth_tlv" in pkg:
hsrp2_text_auth = hsrp2_text_auth_tlv(pkg["hsrp2_text_auth_tlv"].auth_data)
data += hsrp2_text_auth.render()
elif "hsrp2_md5_auth_tlv" in pkg:
if pkg["hsrp2_group_state_tlv"].ip_ver == 4:
ip = self.parent.ip
else:
ip = self.parent.ip6_ll[0] + self.parent.ip6_ll[-3:]
auth = hsrp2_md5_auth_tlv(pkg["hsrp2_md5_auth_tlv"].algo, pkg["hsrp2_md5_auth_tlv"].flags, ip, pkg["hsrp2_md5_auth_tlv"].keyid, "\x00" * 16)
if self.parent.ui == 'gtk':
secret = self.parent.auth_entry.get_text()
elif self.parent.ui == 'urw':
secret = self.parent.auth_edit.get_edit_text()
key_length = struct.pack("<Q", (len(secret) << 3))
key_fill = secret + '\x80' + '\x00' * (55 - len(secret)) + key_length
salt = data + auth.render()
m = hashlib.md5()
m.update(key_fill)
m.update(salt)
m.update(secret)
auth.csum = m.digest()
data += auth.render()
pass
if pkg["hsrp2_group_state_tlv"].ip_ver == 4:
udp_hdr = dpkt.udp.UDP( sport=HSRP2_PORT,
dport=HSRP2_PORT,
data=data
)
udp_hdr.ulen += len(udp_hdr.data)
ip_hdr = dpkt.ip.IP( ttl=1,
p=dpkt.ip.IP_PROTO_UDP,
src=self.parent.ip,
dst=dumbnet.ip_aton(HSRP2_MULTICAST_ADDRESS),
data=str(udp_hdr)
)
ip_hdr.len += len(ip_hdr.data)
ipt = dpkt.ethernet.ETH_TYPE_IP
else:
udp_hdr = dpkt.udp.UDP( sport=HSRP2_PORT6,
dport=HSRP2_PORT6,
data=data
)
udp_hdr.ulen += len(udp_hdr.data)
ip_hdr = dpkt.ip6.IP6( hlim=255,
nxt=dpkt.ip.IP_PROTO_UDP,
src=self.parent.ip6_ll,
dst=dumbnet.ip6_aton(HSRP2_MULTICAST6_ADDRESS),
data=udp_hdr,
plen = len(str(udp_hdr))
)
ip_hdr.extension_hdrs = { 0 : None,
43 : None,
44 : None,
51 : None,
50 : None,
60 : None
}
ipt = dpkt.ethernet.ETH_TYPE_IP6
eth_hdr = dpkt.ethernet.Ethernet( dst=dumbnet.eth_aton(HSRP2_MULTICAST_MAC),
src=self.parent.mac,
type=ipt,
data=str(ip_hdr)
)
self.parent.dumbnet.send(str(eth_hdr))
if arp:
src_mac = dumbnet.eth_aton("00:00:0c:9f:f0:%02x" % (pkg["hsrp2_group_state_tlv"].group))
brdc_mac = dumbnet.eth_aton("ff:ff:ff:ff:ff:ff")
stp_uplf_mac = dumbnet.eth_aton("01:00:0c:cd:cd:cd")
ip = pkg["hsrp2_group_state_tlv"].ip
arp_hdr = dpkt.arp.ARP( hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=ip,
tha=brdc_mac,
tpa=ip
)
eth_hdr = dpkt.ethernet.Ethernet( dst=brdc_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr)
)
self.parent.dumbnet.send(str(eth_hdr))
arp_hdr = dpkt.arp.ARP( hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=ip,
tha=stp_uplf_mac,
tpa=ip
)
eth_hdr = dpkt.ethernet.Ethernet( dst=stp_uplf_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr)
)
self.parent.dumbnet.send(str(eth_hdr))
self.parent.peers[i] = (iter, pkg, state, arp - 1)
time.sleep(1)
self.parent.log("HSRP2: Thread terminated")
def __init__(self, addr, len=4):
self.addr = dumbnet.ip_aton(addr)
self.len = len
def run(self):
self.parent.log("HSRP: Thread started")
while self.running:
for i in self.parent.peers:
if self.parent.peers[i]["state"]:
pkg = self.parent.peers[i]["pkg"]
auth = self.parent.peers[i]["auth"]
if not auth is None:
hsrp = hsrp_packet(hsrp_packet.OP_HELLO,
hsrp_packet.STATE_ACTIVE, pkg.hello,
pkg.hold, 255, pkg.group,
"\x00" * 8, pkg.ip)
auth = hsrp_auth_tlv(auth.algo, auth.flags,
self.parent.ip, auth.keyid,
"\x00" * 16)
if self.parent.ui == 'gtk':
secret = self.parent.auth_entry.get_text()
elif self.parent.ui == 'urw':
secret = self.parent.auth_edit.get_edit_text()
key_length = struct.pack("<Q", (len(secret) << 3))
key_fill = secret + '\x80' + '\x00' * (
55 - len(secret)) + key_length
salt = hsrp.render() + auth.render()
m = hashlib.md5()
m.update(key_fill)
m.update(salt)
m.update(secret)
auth.csum = m.digest()
data = hsrp.render() + auth.render()
else:
hsrp = hsrp_packet(hsrp_packet.OP_HELLO,
hsrp_packet.STATE_ACTIVE, pkg.hello,
pkg.hold, 255, pkg.group,
pkg.auth_data, pkg.ip)
data = hsrp.render()
udp_hdr = dpkt.udp.UDP(sport=HSRP_PORT,
dport=HSRP_PORT,
data=data)
udp_hdr.ulen += len(udp_hdr.data)
ip_hdr = dpkt.ip.IP(
ttl=1,
p=dpkt.ip.IP_PROTO_UDP,
src=self.parent.ip,
dst=dumbnet.ip_aton(HSRP_MULTICAST_ADDRESS),
data=str(udp_hdr))
ip_hdr.len += len(ip_hdr.data)
eth_hdr = dpkt.ethernet.Ethernet(
dst=dumbnet.eth_aton(HSRP_MULTICAST_MAC),
src=self.parent.mac,
type=dpkt.ethernet.ETH_TYPE_IP,
data=str(ip_hdr))
self.parent.dumbnet.send(str(eth_hdr))
if self.parent.peers[i]["arp"]:
src_mac = dumbnet.eth_aton("00:00:0c:07:ac:%02x" %
(pkg.group))
brdc_mac = dumbnet.eth_aton("ff:ff:ff:ff:ff:ff")
stp_uplf_mac = dumbnet.eth_aton("01:00:0c:cd:cd:cd")
ip = struct.pack("!I", pkg.ip)
arp_hdr = dpkt.arp.ARP(hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=ip,
tha=brdc_mac,
tpa=ip)
eth_hdr = dpkt.ethernet.Ethernet(
dst=brdc_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr))
self.parent.dumbnet.send(str(eth_hdr))
arp_hdr = dpkt.arp.ARP(hrd=dpkt.arp.ARP_HRD_ETH,
pro=dpkt.arp.ARP_PRO_IP,
op=dpkt.arp.ARP_OP_REPLY,
sha=src_mac,
spa=ip,
tha=stp_uplf_mac,
tpa=ip)
eth_hdr = dpkt.ethernet.Ethernet(
dst=stp_uplf_mac,
src=src_mac,
type=dpkt.ethernet.ETH_TYPE_ARP,
data=str(arp_hdr))
self.parent.dumbnet.send(str(eth_hdr))
self.parent.peers[i][
"arp"] = self.parent.peers[i]["arp"] - 1
time.sleep(1)
self.parent.log("HSRP: Thread terminated")
def set_ip(self, ip, mask):
self.address = dumbnet.ip_aton(ip)
self.mask = dumbnet.ip_aton(mask)
def set_ip(self, ip, mask):
self.ip = dumbnet.ip_aton(ip)
