Example #1
0
    def handle_arrival_msg(self):
        # TODO: impl protocol to handle arrived packet from network layer.
        # call self.msg_handler() to deliver to application layer.

        msg = self.network_layer.recv()

        if util.valid_ack(msg):
            sequence = util.get_sequence(msg)
            self.logger.info("Sender received ack%d", sequence)
            with self.sender_lock:
                self.sender_ack_base = sequence

        if util.valid_data(msg):
            sequence = util.get_sequence(msg)
            if sequence == GoBackN.receiver_expect_sequence:
                self.logger.info("Receiver received expected packet pkt%d",
                                 sequence)
                packet = util.make_ack_packet(config.MSG_TYPE_ACK, sequence)
                self.network_layer.send(packet)
                self.logger.info("Receiver send back ack%d", sequence)
                payload = util.get_payload(msg)
                self.msg_handler(payload)
                with GoBackN.gbn_lock:
                    GoBackN.receiver_expect_sequence = (
                        GoBackN.receiver_expect_sequence + 1) % util.HASH_SIZE
            else:
                self.logger.info("Receiver received unexpected packet pkt%d",
                                 sequence)
                if GoBackN.receiver_expect_sequence > 0:
                    packet = util.make_ack_packet(
                        config.MSG_TYPE_ACK,
                        GoBackN.receiver_expect_sequence - 1)
                    self.network_layer.send(packet)
                    self.logger.info("Recevier send back ack%d",
                                     GoBackN.receiver_expect_sequence - 1)
Example #2
0
def list_interface_by_host( hostip, userid, passwd):
	print hostip
	resp = requests.post( util.get_nxapi_endpoint( hostip), data=json.dumps( util.get_payload( "show interface brief")), headers=util.myheaders,auth=(userid,passwd)).json()
	outputs = resp['ins_api']['outputs']
	if not 'Success' in outputs['output']['msg']:
		return
	try:
		for row in outputs['output']['body']['TABLE_interface']['ROW_interface']:
			if row['state'] == 'up':
				print " - ", row['interface'], row['vlan'] if row.has_key('vlan') else '--', row['portmode'] if row.has_key('portmode') else ''

	except Exception as e:
		print e
def list_interface_by_host(hostip, userid, passwd):
    print hostip
    resp = requests.post(
        util.get_nxapi_endpoint(hostip),
        data=json.dumps(util.get_payload("show ip interface vrf all")),
        headers=util.myheaders,
        auth=(userid, passwd),
    ).json()
    outputs = resp["ins_api"]["outputs"]
    if not "Success" in outputs["output"]["msg"]:
        return
    pt = PrettyTable(["intf-name", "vrf-name", "link-state", "admin-stat", "prefix", "secondary"])
    pt.align["intf-name"] = "l"  # Left align city names
    pt.padding_width = 1  # One space between column edges and contents (default)
    try:
        if type(outputs["output"]["body"]["TABLE_intf"]) == dict:
            for row in outputs["output"]["body"]["TABLE_intf"]["ROW_intf"]:
                # print 'dict %r' %row
                if row["link-state"].upper() == "TRUE":
                    pt.add_row(
                        [
                            row["intf-name"],
                            row["vrf-name-out"],
                            "up",
                            "up" if row["admin-state"].upper() == "TRUE" else "down",
                            row["prefix"],
                            row["TABLE_secondary_address"]["ROW_secondary_address"]["prefix1"]
                            if row.has_key("TABLE_secondary_address")
                            else "-",
                        ]
                    )
        else:
            for idx, row in enumerate(outputs["output"]["body"]["TABLE_intf"]):
                # print 'list %r' %row
                # print row['ROW_intf']['link-state']
                if row["ROW_intf"]["link-state"] == "up":
                    pt.add_row(
                        [
                            row["ROW_intf"]["intf-name"],
                            outputs["output"]["body"]["TABLE_vrf"][idx]["ROW_vrf"]["vrf-name-out"],
                            "up",
                            row["ROW_intf"]["admin-state"],
                            row["ROW_intf"]["prefix"],
                            row["ROW_intf"]["TABLE_secondary_address"]["ROW_secondary_address"]["prefix1"]
                            if row["ROW_intf"].has_key("TABLE_secondary_address")
                            else "-",
                        ]
                    )
    except Exception as e:
        print e
    print pt
def list_vrf_interface_by_host( hostip, userid, passwd):
	print hostip
	vrf_map = {}
	resp = requests.post( util.get_nxapi_endpoint( hostip), data=json.dumps( util.get_payload( "show vrf interface")), headers=util.myheaders,auth=(userid,passwd)).json()
	outputs = resp['ins_api']['outputs']
	if not 'Success' in outputs['output']['msg']:
		return
	for row in outputs['output']['body']['TABLE_if']['ROW_if']:
		if vrf_map.has_key( row['vrf_name']):
			vrf_map[row['vrf_name']].add( row['if_name'])
		else:
			vrf_map[row['vrf_name']] = set()
			vrf_map[row['vrf_name']].add( row['if_name'])
	pt = PrettyTable(["vrf-name", "interface"])
	pt.align["vrf-name"] = "l" # Left align city names
	pt.padding_width = 1 # One space between column edges and contents (default)	
	for n in vrf_map.keys():
		pt.add_row( [ n, ",".join( vrf_map.get(n))])	
	print pt
Example #5
0
def find_payload_gadgets():
    """Finds and returns a set of gadgets that is used by the given exploit."""

    # load the exploits gadgets
    payload = util.get_payload(inp.get_input_file_path())
    exp_gadgets = set()

    for addr in payload:
        gadgets = find_gadgets(addr, addr + 64)
        for gad in gadgets:
            for iaddr, ins in gad._instrs:
                if iaddr == addr:
                    i = gad._instrs.index((iaddr, ins))
                    exp_gadgets.add(Gadget(addr, gad._instrs[-1][0], gad._instrs[i:]))

    print "found", len(exp_gadgets), "gadgets for", len(payload), "addresses"

    if len(exp_gadgets) != len(payload):
        print "missing:", list(set(payload) - set(g.get_start_ea() for g in exp_gadgets))

    return set((g.dump_simple(extra=True) for g in exp_gadgets))
def get_neighbors( hostip, userid, passwd):
	myentries = []
	resp = requests.post( util.get_nxapi_endpoint( hostip), data=json.dumps( util.get_payload('show cdp neighbors')), headers=util.myheaders,auth=(userid,passwd)).json()
	#print resp
	success = resp['ins_api']['outputs']['output']['msg']
	if success == 'Success' :
		entries = resp['ins_api']['outputs']['output']['body']['TABLE_cdp_neighbor_brief_info']['ROW_cdp_neighbor_brief_info']
		if type(entries) == list:
			for entry in entries:
				e = {}
				e['device_id'] = entry['device_id']
				e['intf_id'] = entry['intf_id']
				e['port_id'] = entry['port_id']
				myentries.append( e)
			return myentries
		elif type(entries) == dict:
			e = {}
			e['device_id'] = entries['device_id']
			e['intf_id'] = entries['intf_id']
			e['port_id'] = entries['port_id']
			myentries.append( e)
		return myentries
Example #7
0
    def handle_arrival_msg(self):
        msg = self.network_layer.recv()
        # TODO: impl protocol to handle arrived packet from network layer.
        # call self.msg_handler() to deliver to application layer.
        if util.valid_ack(msg):
            with StopAndWait.ss_lock:
                StopAndWait.sender_ack_sequence = util.get_sequence(msg)

        if util.valid_data(msg):
            sequence = util.get_sequence(msg)
            packet = util.make_ack_packet(config.MSG_TYPE_ACK, sequence)
            self.network_layer.send(packet)
            if StopAndWait.receiver_sequence != sequence:
                self.logger.info('Receiver received new packet: pkt%d',
                                 sequence)
                with StopAndWait.ss_lock:
                    StopAndWait.receiver_sequence = sequence
                payload = util.get_payload(msg)
                self.msg_handler(payload)
            else:
                self.logger.info(
                    'Receiver received duplicate packet: pkt%d, ignored',
                    sequence)