J'ai besoin de coraller un paquet sphéry . La plupart du temps, cela fonctionne, mais parfois le pickleur se plaint d'un objet de fonction. En règle générale: des paquets arp cornichons bien. Certains paquets UDP sont problématiques.
6 Réponses :
(c'est plus pour référence, donc aucun votes attendu)
La liste d'horlogerie Scapy.ml@secdev.org est bien surveillée et tend à être très réactive. Si vous n'obtenez pas de réponses ici, essayez-y également.
Oh c'est là que la communication continue? Le problème du problème semble assez inactif. Au moins un de mes bugs y est resté pendant une demi-année sans réponse.
À titre de note latérale, 500 paquets par seconde pourraient également être plus que des poignées d'arrachement. Il est conçu pour la flexibilité et non la vitesse :) Demandez sur la liste. Je ne l'utilise pas vraiment beaucoup, alors je ne suis pas d'expert.
En fait, je peux confirmer que Scapy gère 500 paquets par seconde très bien. Accordé que j'utilise plus d'un fil et (après cette question) plus d'un processus.
Si par cornichon, vous voulez dire génériquement Serialize, vous pouvez toujours utiliser les méthodes d'importation / exportation PCAP: RDPCAP et WRPCAP .
pkts = rdpcap('FOO.pcap')
1) Je parle de 500 paquets par seconde.
2) Cette méthode perd en fait des données. Par exemple, l'horodatage est arrondi. Ce n'est pas nécessairement un problème, mais doit être pris en compte.
Est-ce que Scapy peut-il pousser même 500 paquets par seconde? J'ai trouvé que lors de l'envoi de paquets, il est beaucoup moins que cela. Vous pouvez toujours exécuter un TCPDump dans un autre terminal.
Scapy peut. Voir le commentaire sur une autre réponse.
Vous pouvez transmettre une référence à un fichier dans la file d'attente. Les chaînes sont pickables.
Désolé, la création d'un fichier pour chaque paquet est une mauvaise blague en termes de performance. Si je ne me soucierais pas des performances, je pourrais utiliser filetage au lieu de multiprocession et n'aurait pas à corner du tout.
Vous pouvez monkeyychatch the de la classe code> classe et injecter __ getState __ code> et __ setState __ code> méthodes convertissant la fonction dans l'objet de et vers une représentation piquante. Voir ici pour plus de détails. def packet_getstate(self):
# todo
def packet_setstate(self, state):
# todo
from scapy.packet import Packet
Packet.__getstate__ = packet_getstate
Packet.__setstate__ = packet_setstate
C'est une sorte d'évidence pour moi. La partie non évidente est la partie TOODO.
Inspection de manière interactive un objet de paquet qui échoue en décapage ( pprint.pprint (paquet .__ dict __) ) montrerait facilement ce que la fonction est, si c'est une Lambda, une fonction ou une instance méthode. Sachez-vous déjà quel genre de fonction est?
La traçabilité complète est trop longue pour un commentaire, mais vous pouvez facilement vous reproduire vous-même. La dernière ligne est la suivante: pickle.picklingError: ne peut pas corner
Ma solution (comme inspiré de la liste de diffusion Scapy) est la suivante:
class PicklablePacket:
"""A container for scapy packets that can be pickled (in contrast
to scapy packets themselves)."""
def __init__(self, pkt):
self.contents = bytes(pkt)
self.time = pkt.time
def __call__(self):
"""Get the original scapy packet."""
pkt = scapy.Ether(self.contents)
pkt.time = self.time
return pkt
Merci d'avoir posté de retour. Bien que je n'ai pas besoin de votre solution exacte, cela m'a aidé à trouver le mien.
tel que inspiré de ce Question On peut utiliser le DILL bibliothèque (ou d'autres comme SPICKLE, etc. - voir Pickle de recherche PYPI ) Pour enregistrer des paquets Scédy. Par exemple. Installez Dill en utilisant sudo easy_install Dill code> ou Sudo PIP Installation Dill code>. Voici un scénario d'utilisation de base: wrpcap("packets_array.pcap",packets_array)
Pour que la classe Picklabepacket fonctionne avec Scapy 3.0.0 Vous pouvez utiliser cette définition de classe:
class PicklablePacket:
"""A container for scapy packets that can be pickled (in contrast
to scapy packets themselves).
This works for python 3.5.1 and scapy 3.0.0 """
def __init__(self, pkt):
self.__contents = pkt.__bytes__()
self.__time = pkt.time
def __call__(self):
"""Get the original scapy packet."""
pkt = scapy.all.Ether(self.__contents)
pkt.time = self.__time
return pkt
L'arrière-plan est l'utilisation conjointement avec le module
multiprocessionnaire . Il faut que des objets soient pickables si vous souhaitez les transférer via une queue .Quelqu'un pourrait-il répondre à cette question afin que je puisse accorder la prime?