nfstream
v6.5.3
NFStream est un framework Python multiplateforme fournissant des structures de données rapides, flexibles et expressives conçues pour rendre l'utilisation des données réseau en ligne ou hors ligne facile et intuitive. Il vise à être l’élément fondamental de haut niveau de Python pour effectuer une analyse pratique des données de flux réseau dans le monde réel . De plus, il a pour objectif plus large de devenir un cadre unificateur d’analyse de données de réseau pour les chercheurs, assurant la reproductibilité des données entre les expériences.
| Carnet en direct | |
| Site Web du projet | |
| Canal de discussion | |
| Dernière version | |
| Versions prises en charge | |
| Licence de projet | |
| Intégration continue | |
| Qualité du code |
Principales caractéristiques
Comment l'obtenir ?
Comment l'utiliser ?
Entraîner le modèle
Streamer alimenté par ML sur le trafic en direct
Identification cryptée des applications et extraction des métadonnées
Visibilité du système
Extraction de caractéristiques du flux statistique post-mortem
Extraction précoce des caractéristiques du flux statistique
Interface d'exportation de Pandas
Interface d'exportation CSV
Extension de NFStream
Formation et déploiement de modèles de Machine Learning
Construire à partir de sources
Contribuer
Éthique
Crédits
Citation
Auteurs
Organisations de soutien
Publications utilisant NFStream
Licence
Performances : NFStream est conçu pour être rapide : AF_PACKET_V3/FANOUT sur Linux, multitraitement, moteur de calcul natif basé sur CFFI et prise en charge complète de PyPy .
Visibilité chiffrée de couche 7 : l'inspection approfondie des paquets NFStream est basée sur nDPI . Il permet à NFStream d'effectuer une identification fiable des applications cryptées et une prise d'empreintes digitales des métadonnées (par exemple TLS, SSH, DHCP, HTTP).
Visibilité du système : NFStream sonde le noyau du système surveillé pour obtenir des informations sur les sockets Internet ouverts et collecte une vérité terrain garantie (nom du processus, PID, etc.) au niveau de l'application.
Extraction de caractéristiques statistiques : NFStream fournit l'état de l'art en matière d'extraction de caractéristiques statistiques basée sur les flux. Il comprend des caractéristiques statistiques post-mortem (par exemple, minimum, moyenne, écart type et maximum de la taille des paquets et du temps entre les arrivées) et des caractéristiques de flux précoces (par exemple, la séquence des n premiers paquets, les temps entre les arrivées et les directions).
Flexibilité : NFStream est facilement extensible à l'aide de NFPlugins . Il permet la création d’une nouvelle fonctionnalité de flux en quelques lignes de Python.
Orienté Machine Learning : NFStream vise à rendre les approches de Machine Learning pour la gestion du trafic réseau reproductibles et déployables. En utilisant NFStream comme cadre commun, les chercheurs garantissent que les modèles sont formés en utilisant la même logique de calcul de fonctionnalités, ce qui permet une comparaison équitable. De plus, les modèles entraînés peuvent être déployés et évalués sur des réseaux en direct à l'aide de NFPlugins .
Les installateurs binaires pour la dernière version publiée sont disponibles sur Pypi.
pip installer nfstream
Notes Windows : NFStream n'inclut pas les pilotes de capture sous Windows (restrictions de licence). Il est nécessaire d'installer les pilotes Npcap avant d'installer NFStream. Si Wireshark est déjà installé sur Windows, les pilotes Npcap sont déjà installés et vous n'avez pas besoin d'effectuer d'action supplémentaire.
Vous gérez un gros fichier pcap et souhaitez le regrouper en flux réseau étiquetés ? NFStream facilite ce chemin en quelques lignes :
from nfstream import NFStreamer# Nous affichons tous les paramètres du streamer avec leurs valeurs par défaut.# Voir la documentation pour des informations détaillées sur chaque paramètre.# https://www.nfstream.org/docs/api#nfstreamermy_streamer = NFStreamer(source="facebook.pcap ", # ou interface réseau en direct decode_tunnels=True, bpf_filter=None, promiscuous_mode=True, snapshot_length=1536, ralenti_timeout=120, active_timeout=1800, comptabilité_mode=0, udps=Aucun, n_dissections=20, static_analysis=False, splt_analysis=0, n_meters=0, max_nflows=0, performance_report=0, system_visibility_mode=0, system_visibility_poll_ms=100)
pour le flux dans my_streamer:print(flow) # imprimez-le.# Voir la documentation pour la description détaillée de chaque fonctionnalité.# https://www.nfstream.org/docs/api#nflowNFlow(id=0, expiration_id=0, src_ip='192.168.43.18', src_mac='30:52:cb :6c:9c:1b', src_oui='30:52:cb', src_port=52066, dst_ip='66.220.156.68', dst_mac='98:0c:82:d3:3c:7c', dst_oui='98:0c:82', dst_port=443, protocole=6, ip_version=4, vlan_id=0, tunnel_id=0, bidirectionnel_first_seen_ms=1472393122365, bidirectionnel_last_seen_ms=1472393123665, bidirectionnel_duration_ms=1300, bidirectionnel_packets=19, bidirectionnel_bytes=5745, src2dst_first_seen_ms=1472393122365, src2dst_last_seen_ms=1472393123408, src2dst_duration_ms=1043, src2dst_packets=9, src2dst_bytes=1345, dst2src_first_seen_ms=1472393122668, dst2src_last_seen_ms=1472393123665, dst2src_duration_ms=997, dst2src_packets=10, dst2src_bytes=4400, application_name='TLS.Facebook', application_category_name='SocialNetwork', application_is_guessed=0, application_confidence=4, request_server_name='facebook.com', client_fingerprint='bfcc1a3891601edb4f137ab7ab25b840', server_fingerprint='2d1eb5817ece335c24904f516ad5da12', user_agent='', content_type='')
NFStream sonde le noyau du système surveillé pour obtenir des informations sur les sockets Internet ouverts et collecte une vérité terrain garantie (nom du processus, PID, etc.) au niveau de l'application.
from nfstream import NFStreamermy_streamer = NFStreamer(source="Intel(R) Wi-Fi 6 AX200 160MHz", # Mode de capture en direct. # Désactivez la dissection L7 à des fins de lisibilité uniquement. n_dissections=0, system_visibility_poll_ms=100, system_visibility_mode=1)
pour le flux dans my_streamer:print(flow) # imprimez-le.# Voir la documentation pour la description détaillée de chaque fonctionnalité.# https://www.nfstream.org/docs/api#nflowNFlow(id=0, expiration_id=0, src_ip='192.168.43.18', src_mac='30:52:cb :6c:9c:1b', src_oui='30:52:cb', src_port=59339, dst_ip='184.73.244.37', dst_mac='98:0c:82:d3:3c:7c', dst_oui='98:0c:82', dst_port=443, protocole=6, ip_version=4, vlan_id=0, tunnel_id=0, bidirectionnel_first_seen_ms=1638966705265, bidirectionnel_last_seen_ms=1638966706999, bidirectionnel_duration_ms=1734, bidirectionnel_packets=98, bidirectionnel_bytes=424464, src2dst_first_seen_ms=1638966705265, src2dst_last_seen_ms=1638966706999, src2dst_duration_ms=1734, src2dst_packets=22, src2dst_bytes=2478, dst2src_first_seen_ms=1638966705345, dst2src_last_seen_ms=1638966706999, dst2src_duration_ms=1654, dst2src_packets=76, dst2src_bytes=421986, # Processus qui a généré ce flux signalé system_process_pid=14596, system_process_name='FortniteClient-Win64-Shipping.exe')
NFStream effectue 48 extractions de caractéristiques statistiques de flux post-mortem, qui comprennent une analyse détaillée des indicateurs TCP, le minimum, la moyenne, le maximum et l'écart type de la taille des paquets et du temps entre les arrivées dans chaque direction.
from nfstream import NFStreamermy_streamer = NFStreamer(source="facebook.pcap", # Désactivez la dissection L7 pour des raisons de lisibilité. n_dissections=0,
static_analysis=True)pour le flux dans my_streamer:print(flow)# Voir la documentation pour la description détaillée de chaque fonctionnalité.# https://www.nfstream.org/docs/api#nflowNFlow(id=0, expiration_id=0, src_ip='192.168.43.18', src_mac='30:52:cb :6c:9c:1b', src_oui='30:52:cb', src_port=52066, dst_ip='66.220.156.68', dst_mac='98:0c:82:d3:3c:7c', dst_oui='98:0c:82', dst_port=443, protocole=6, ip_version=4, vlan_id=0, tunnel_id=0, bidirectionnel_first_seen_ms=1472393122365, bidirectionnel_last_seen_ms=1472393123665, bidirectionnel_duration_ms=1300, bidirectionnel_packets=19, bidirectionnel_bytes=5745, src2dst_first_seen_ms=1472393122365, src2dst_last_seen_ms=1472393123408, src2dst_duration_ms=1043, src2dst_packets=9, src2dst_bytes=1345, dst2src_first_seen_ms=1472393122668, dst2src_last_seen_ms=1472393123665, dst2src_duration_ms=997, dst2src_packets=10, dst2src_bytes=4400, bidirectionnel_min_ps=66, bidirectionnel_mean_ps=302.36842105263156, bidirectionnel_stddev_ps=425,53315715259754, bidirectionnel_max_ps=1454, src2dst_min_ps=66, src2dst_mean_ps=149,44444444444446, src2dst_stddev_ps=132,20354676701294, src2dst_max_ps=449, dst2src_min_ps=66, dst2src_mean_ps=440.0, dst2src_stddev_ps=549.7164925870628, dst2src_max_ps=1454, bidirectionnel_min_piat_ms=0, bidirectionnel_mean_piat_ms=72,22222222222223, bidirectionnel_stddev_piat_ms=137,34994188549086, bidirectionnel_max_piat_ms=398, src2dst_min_piat_ms=0, src2dst_mean_piat_ms=130,375, src2dst_stddev_piat_ms=179,72036811192467, src2dst_max_piat_ms=415, dst2src_min_piat_ms=0, dst2src_mean_piat_ms=110,77777777777777, dst2src_stddev_piat_ms=169.51458475436397, dst2src_max_piat_ms=409, bidirectionnel_syn_packets=2, bidirectionnel_cwr_packets=0, bidirectionnel_ece_packets=0, bidirectionnel_urg_packets=0, bidirectionnel_ack_packets=18, bidirectionnel_psh_packets=9, bidirectionnel_rst_packets=0, bidirectionnel_fin_packets=0, src2dst_syn_packets=1, src2dst_cwr_packets=0, src2dst_ece_packets=0, src2dst_urg_packets=0, src2dst_ack_packets=8, src2dst_psh_packets=4, src2dst_rst_packets=0, src2dst_fin_packets=0, dst2src_syn_packets=1, dst2src_cwr_packets=0, dst2src_ece_packets=0, dst2src_urg_packets=0, dst2src_ack_packets=10, dst2src_psh_packets=5, dst2src_rst_packets=0, dst2src_fin_packets=0)
NFStream effectue une extraction précoce (jusqu'à 255 paquets) des caractéristiques statistiques de flux (appelée analyse SPLT dans la littérature). Il est résumé sous la forme d’une séquence des directions, tailles et temps entre les arrivées de ces paquets.
from nfstream import NFStreamermy_streamer = NFStreamer(source="facebook.pcap", # Nous désactivons la dissection l7 pour des raisons de lisibilité. n_dissections=0, splt_analysis=10)pour le flux dans my_streamer:print(flow)
# Voir la documentation pour la description détaillée de chaque fonctionnalité.# https://www.nfstream.org/docs/api#nflowNFlow(id=0, expiration_id=0, src_ip='192.168.43.18', src_mac='30:52:cb :6c:9c:1b', src_oui='30:52:cb', src_port=52066, dst_ip='66.220.156.68', dst_mac='98:0c:82:d3:3c:7c', dst_oui='98:0c:82', dst_port=443, protocole=6, ip_version=4, vlan_id=0, tunnel_id=0, bidirectionnel_first_seen_ms=1472393122365, bidirectionnel_last_seen_ms=1472393123665, bidirectionnel_duration_ms=1300, bidirectionnel_packets=19, bidirectionnel_bytes=5745, src2dst_first_seen_ms=1472393122365, src2dst_last_seen_ms=1472393123408, src2dst_duration_ms=1043, src2dst_packets=9, src2dst_bytes=1345, dst2src_first_seen_ms=1472393122668, dst2src_last_seen_ms=1472393123665, dst2src_duration_ms=997, dst2src_packets=10, dst2src_bytes=4400, # La séquence des 10 premiers paquets, leur taille et leur heure d'arrivée. splt_direction=[0, 1, 0, 0, 1, 1, 0, 1, 0, 1], splt_ps=[74, 74, 66, 262, 66, 1454, 66, 1454, 66, 463], splt_piat_ms= [0, 303, 0, 0, 313, 0, 0, 0, 0, 1])
NFStream prend nativement en charge Pandas comme interface d'exportation.
# Voir la documentation pour plus de détails.# https://www.nfstream.org/docs/api#pandas-dataframe-conversionfrom nfstream import NFStreamermy_dataframe = NFStreamer(source='teams.pcap').to_pandas()[["src_ip" ,"port_src", "dst_ip", "dst_port", "protocole", "paquets_bidirectionnels", "octets_bidirectionnels", "nom_application"]]my_dataframe.head(5)
NFStream prend nativement en charge le format de fichier CSV comme interface d'exportation.
# Voir la documentation pour plus de détails.# https://www.nfstream.org/docs/api#csv-file-conversionflows_count = NFStreamer(source='facebook.pcap').to_csv(path=None,columns_to_anonymize=(), flow_per_file=0,rotate_files=0)
Vous n'avez pas trouvé de fonctionnalité de flux spécifique ? ajoutez un plugin à NFStream en quelques lignes :
from nfstream import NFPluginclass MyCustomPktSizeFeature(NFPlugin):def on_init(self, packet, flow):# création de flux avec le premier paquetif packet.raw_size == self.custom_size:flow.udps.packet_with_custom_size = 1else:flow.udps.packet_with_custom_size = 0
def on_update(self, packet, flow):# mise à jour du flux avec chaque paquet appartenant au flux si packet.raw_size == self.custom_size:flow.udps.packet_with_custom_size += 1extended_streamer = NFStreamer(source='facebook.pcap',
udps=MyCustomPktSizeFeature(custom_size=555))pour le flux dans extend_streamer :# consultez votre métrique créée dynamiquement dans les flux générésprint(flow.udps.packet_with_custom_size)L'exemple simpliste suivant montre comment former et déployer une approche d'apprentissage automatique pour la catégorisation des flux de trafic. Nous souhaitons exécuter une classification des flux de catégories de réseaux sociaux basée sur les paquets_bidirectionnels et les octets_bidirectionnels comme fonctionnalités d'entrée. Par souci de concision, nous décidons de prédire uniquement au stade de l’expiration du flux.
à partir de nfstream import NFPlugin, NFStreamerimport numpyfrom sklearn.ensemble import RandomForestClassifierdf = NFStreamer(source="training_traffic.pcap").to_pandas()X = df[["bidirectionnel_packets", "bidirectionnel_bytes"]]y = df["application_category_name"]. apply (lambda x : 1 si 'SocialNetwork' dans x sinon 0)modèle = RandomForestClassifier()model.fit(X, y)
class ModelPrediction(NFPlugin):def on_init(self, packet, flow):flow.udps.model_prediction = 0def on_expire(self, flow):# Vous pouvez faire de même dans le point d'entrée on_update et forcer l'expiration avec un identifiant personnalisé. to_predict = numpy.array([flow.bidirectionnel_packets, flow.bidirectionnel_bytes]).reshape((1,-1))flow.udps.model_prediction = self.my_model.predict(to_predict)ml_streamer = NFStreamer(source="eth0", udps=ModelPrediction(my_model=model))pour le flux dans ml_streamer:print(flow.udps.model_prediction)
Plus d'exemples et de détails NFPlugin sont fournis dans la documentation officielle . Vous pouvez également tester NFStream sans installation à l'aide de notre carnet de démonstration en direct .
Pour construire NFStream à partir des sources, veuillez lire le guide d'installation fourni dans la documentation officielle.
Veuillez lire Contribuer pour plus de détails sur notre code de conduite et le processus de soumission de demandes de tirage.
NFStream est destiné à la recherche de données réseau et à l'investigation. Les chercheurs et les scientifiques des données réseau peuvent utiliser ce cadre pour créer des ensembles de données fiables et former et évaluer des modèles d'apprentissage automatique appliqués au réseau. Comme tout outil de surveillance de paquets, NFStream pourrait être utilisé à mauvais escient. Ne l'exécutez pas sur un réseau que vous ne possédez pas ou que vous n'administrez pas .
L'article NFStream est publié dans Computer Networks (COMNET) . Si vous utilisez NFStream dans une publication scientifique, nous apprécierions les citations de l'article suivant :
@article{AOUINI2022108719,
title = {NFStream : un cadre d'analyse de données réseau flexible},
auteur = {Aouini, Zied et Pekar, Adrian},
est ce que je = {10.1016/j.comnet.2021.108719},
issn = {1389-1286},
journal = {Réseaux informatiques},
pages = {108719},
année = {2022},
éditeur = {Elsevier},
volume = {204},
URL = {https://www.sciencedirect.com/science/article/pii/S1389128621005739}
}Les personnes suivantes ont contribué à NFStream :
Zied Aouini : Créateur et développeur principal.
Adrian Pekar : Génération et stockage de jeux de données.
Romain Picard : Implémentation des plugins MDNS et DHCP.
Radion Bikmukhamedov : Premiers travaux sur l'analyse SPLT NFPlugin.
Les organisations suivantes ont pris en charge NFStream :
SoftAtHome : Supporteur du développement NFStream.
Université technique de Košice : Matériel et infrastructure pour la génération et le stockage d'ensembles de données.
ntop : Support technique de l'intégration nDPI .
Le Projet Nmap : Support technique de l'intégration Npcap (installateur OEM NPCAP sur Windows CI).
Google OSS Fuzz : Prise en charge continue des tests de fuzzing du projet NFStream.
Une architecture hiérarchique et une stratégie probabiliste pour la détection collaborative des intrusions
Cadre open source pour la classification de l'Internet crypté et du trafic malveillant
ConFlow : un flux réseau contrasté améliorant l'apprentissage déséquilibré en classe dans la détection des intrusions réseau
Apprentissage continu pour la détection des intrusions réseau basée sur les anomalies
Un système auto-sécurisé basé sur un réseau défini par logiciel
Auto-encodeurs variationnels robustes et flux de normalisation pour la détection d'anomalies de réseau non supervisée
RADON : auto-encodeur robuste pour la détection d'anomalies non supervisée
Une approche générique d'apprentissage automatique pour l'identification des appareils IoT
Classement des périphériques réseau pour la priorisation des alarmes : étude de cas sur la détection d'intrusion
Détection des logiciels malveillants basée sur les flux réseau à l'aide d'une approche combinée d'exploration et d'apprentissage profond
Détection des intrusions réseau basée sur une intelligence artificielle distribuée et fiable
Cadre de transformateur génératif pour la génération et la classification du trafic réseau
Générateurs et classificateurs de trafic réseau multiclasses basés sur des réseaux de neurones
Utilisation de la sélection de fonctionnalités intégrées et de CNN pour la classification sur CCD-INID-V1, un nouvel ensemble de données IoT
Une approche basée sur la mise en réseau définie par les connaissances pour identifier les flux de streaming vidéo dans les réseaux 5G
Découverte de connaissances : peut-elle apporter un nouvel éclairage sur la définition du seuil de détection des gros frappeurs ?
Collecte et analyse du trafic des nœuds de sortie Tor
Analyse et collecte de données à partir du réseau IP
Ce projet est sous licence LGPLv3 - voir le fichier de licence pour plus de détails
