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)