Romain/Analyse_Reseaux
1
0
Fork 0
forked from JulieChv/Analyse_Reseaux
Code Pull Requests Activity

ajout de doc

Browse Source
This commit is contained in:
Chevallier
2026-05-26 15:10:05 +02:00
parent f79e6e69c4
commit d6ecf14737
12 changed files with 1830 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
CREATE_FIREWALL_PARSING.md Normal file
View File

@@ -0,0 +1,222 @@
# Guide de Développement : Créer son propre Parseur Firewall
Ce guide explique comment étendre l'outil d'analyse réseau en ajoutant un nouveau parseur pour un modèle de firewall non supporté nativement (ex: CheckPoint, Fortinet, etc.).
> **Note :** Tout au long de ce guide, remplacez **`MODELE`** (en majuscule ou minuscule) par le nom de la marque ou du modèle du firewall ciblé.
---
## Étape 1 : Création du script de parsing
Dans le dossier `Parseurs_config_Firewall/src/scripts/` (ou `script/` selon votre arborescence), créez un nouveau fichier Python nommé **`json_MODELE.py`**.
*Il est fortement recommandé de s'inspirer des parseurs existants comme `json_Forcepoint.py`, `json_Stormshield.py` ou `json_PaloAlto.py`.*
Voici le squelette de code à utiliser (exemple basé sur des logs au format XML) :
```python
#!/usr/bin/env python3
"""
Parser pour configuration MODELE XML vers un format json normalisé OpenConfig YANG
Extrait les groupes d'objets, objets, groupes de services, services, routes, interfaces et règles
"""
import xml.etree.ElementTree as ET
import json
from scripts.export_modele import ParserMixin
from scripts.objets.data import AddressObject, AddressGroup, ServiceObject, ServiceGroup, Interface, SecurityRule, StaticRoute, VirtualRouter
from pathlib import Path
class ModeleParser(ParserMixin):
"""Parser pour fichier Modele"""
def __init__(self, xml_file_path: str):
"""Initialise le parser avec le chemin du fichier"""
self.xml_file = xml_file_path
self.tree = None
self.root = None
self.config = {
'address_objects': [],
'address_groups': [],
'service_objects': [],
'service_groups': [],
'interfaces': [],
'virtual_routers': [],
'static_routes': [],
'security_rules': []
}
def load_xml(self):
"""Charge le fichier XML"""
try:
self.tree = ET.parse(self.xml_file)
self.root = self.tree.getroot()
print(f"✓ Fichier XML chargé: {self.xml_file}")
except ET.ParseError as e:
print(f"✗ Erreur de parsing XML: {e}")
raise
except FileNotFoundError:
print(f"✗ Fichier non trouvé: {self.xml_file}")
raise
def _parse_address_objects(self):
"""Parse les objets adresse"""
address_objects = []
# TODO: Parcourir le XML et instancier des objets AddressObject
self.config['address_objects'] = address_objects
print(f"✓ Trouvé {len(address_objects)} objets adresse")
def _parse_address_groups(self):
"""Parse les groupes d'adresses"""
address_groups = []
# TODO: Parcourir le XML et instancier des objets AddressGroup
self.config['address_groups'] = address_groups
print(f"✓ Trouvé {len(address_groups)} groupes d'adresses")
def _parse_service_objects(self):
"""Parse les objets service"""
service_objects = []
# TODO: Parcourir le XML et instancier des objets ServiceObject
self.config['service_objects'] = service_objects
print(f"✓ Trouvé {len(service_objects)} objets service")
def _parse_service_groups(self):
"""Parse les groupes de services"""
service_groups = []
# TODO: Parcourir le XML et instancier des objets ServiceGroup
self.config['service_groups'] = service_groups
print(f"✓ Trouvé {len(service_groups)} groupes de services")
def _parse_interfaces(self):
"""Parse les interfaces réseau"""
interfaces = []
# TODO: Parcourir le XML et instancier des objets Interface
self.config['interfaces'] = interfaces
print(f"✓ Trouvé {len(interfaces)} interfaces")
def _parse_virtual_routers(self):
"""Parse les virtual-routers et leurs routes statiques"""
virtual_routers = []
# TODO: Parcourir le XML, instancier des VirtualRouter et injecter les StaticRoute
self.config['virtual_routers'] = virtual_routers
print(f"✓ Trouvé {len(virtual_routers)} virtual-routers")
def _parse_security_rules(self):
"""Parse les règles de sécurité"""
security_rules = []
# TODO: Parcourir le XML et instancier des objets SecurityRule
self.config['security_rules'] = security_rules
print(f"✓ Trouvé {len(security_rules)} règles de sécurité")
def parse_all(self):
"""Parse tous les éléments de configuration"""
print("Début du parsing de la configuration MODELE...")
self.load_xml()
self._parse_address_objects()
self._parse_address_groups()
self._parse_service_objects()
self._parse_service_groups()
self._parse_interfaces()
self._parse_virtual_routers()
self._parse_security_rules()
print("✓ Parsing terminé avec succès!")
def export_to_json(self, output_file: str):
"""Exporte la configuration au format JSON OpenConfig"""
fw_name = ""
deviceconfig = self.root.find(".//deviceconfig/system/hostname")
if deviceconfig is not None and deviceconfig.text:
fw_name = deviceconfig.text.strip()
openconfig_data = self.to_openconfig_yang("MODELE", [fw_name])
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(openconfig_data, f, indent=2, ensure_ascii=False)
print(f"✓ Configuration exportée vers: {output_file}")
def generate_json_modele(input_file: str, output_file: str):
"""Génère le fichier JSON OpenConfig à partir du fichier XML MODELE"""
xml_file = Path(input_file)
if not xml_file.exists():
print(f"✗ Erreur: Le fichier '{xml_file}' n'existe pas")
return
try:
parser = ModeleParser(str(xml_file))
parser.parse_all()
parser.print_summary()
parser.export_to_json(output_file)
print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file}")
except Exception as e:
print(f"✗ Erreur: {e}")
return
if __name__ == "__main__":
import sys
if len(sys.argv) != 2:
print("Usage: python json_MODELE.py <fichier_config.xml>")
sys.exit(1)
xml_file = sys.argv[1]
if not Path(xml_file).exists():
print(f"✗ Erreur: Le fichier '{xml_file}' n'existe pas")
sys.exit(1)
try:
parser = ModeleParser(xml_file)
parser.parse_all()
parser.print_summary()
output_file = 'output_Modele.json'
parser.export_to_json(output_file)
print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file}")
except Exception as e:
print(f"✗ Erreur: {e}")
sys.exit(1)
```
## Étape 2 : Intégration dans le moteur principal (`main.py`)
Pour que le script global prenne en charge le nouveau modèle, ouvrez le fichier `Parseurs_config_Firewall/src/main.py` :
1. Importez votre nouvelle fonction en haut du fichier :
```python
from scripts.json_MODELE import generate_json_modele
```
2. Ajoutez la condition correspondante dans le bloc de sélection du type de firewall :
```python
elif firewall_type == "modele":
generate_json_modele(input_data, output_file_json)
```
3. Mettez à jour les instructions textuelles d'usage affichées dans la console si le paramètre saisi est incorrect afin d'inclure `"modele"` dans la liste des choix valides.
## Étape 3 : Adaptation de l'Interface Graphique (GUI)
Afin que le nouveau modèle apparaisse dans l'interface graphique unifiée :
1. Ouvrez le fichier de gestion de la GUI (`gui_firewall.py` racine ou script GUI dédié).
2. Repérez le composant de sélection (Menu déroulant / ComboBox ou liste de boutons radio) listant les firewalls.
3. Ajoutez **`MODELE`** à la liste des choix graphiques.
> **Important :** faire attention si le script prend en compte un dossier ou un fichier.

424
CREATE_SWITCH_PARSING.md Normal file
View File

@@ -0,0 +1,424 @@
# Guide de Développement : Créer son propre Parseur Switch
Ce guide explique comment étendre l'outil d'analyse réseau en ajoutant un nouveau parseur pour un modèle de switch non supporté nativement (ex: Cisco Meraki, Nexus, etc.).
> **Note :** Tout au long de ce guide, remplacez **`MODELE`** (en majuscule ou minuscule) par le nom de la marque ou du modèle du switch ciblé.
---
## Étape 1 : Création du script de parsing
Dans le dossier `Parseurs_logs_Switch/src/scripts/` (ou `script/` selon votre arborescence), créez un nouveau fichier Python nommé **`json_MODELE.py`**.
*Il est fortement recommandé de s'inspirer des parseurs existants comme `json_hpe.py`.*
Voici le squelette de code à utiliser (exemple basé sur des logs au format XML) :
```python
#!/usr/bin/env python3
"""
Parser pour configuration switch MODELE vers un format json normalisé OpenConfig YANG
Extrait les différentes sections de logs et les convertit en objets Python, puis exporte le tout au format JSON OpenConfig.
"""
import json
import re
from scripts.export_modele import ParserMixin
from scripts.objets.data import MacAddress, Arp, Route, FIB, SlotInfo, VersionInfo, ComponentInfo, SlotManuInfo, ManuInfo, Power, SlotFanInfo, Fan, Sensor, EnvironmentInfo, SlotEnvInfo, SlotBootInfo, IrfMember, IrfLink, IrfTopology, IrfConfiguration, CpuUsage, CpuProcessInfo, ProcessInfo, Memory, TransceiverDiag, Transceiver, TransceiverInterface, Log, Multicast, Qos, Aaa, StpGlobal, StpInfo, StpPort, InterfaceCounter, NetworkInterface, LinkAggregation, ConfigVlan, ConfigIrfPort, ConfigInterface, ConfigAcl, ConfigUser, ConfigSnmp, DeviceConfiguration
from pathlib import Path
class ModeleParser(ParserMixin):
"""Parser pour fichier XML MODELE"""
def __init__(self, file_path: str):
"""Initialise le parser avec le chemin du fichier de logs MODELE"""
self.file = file_path
self.root = None
self.raw_data = None
self.config = None
self.config = {
'mac_addresses': [],
'arp_table': [],
'routing_table': [],
'fib_table': [],
'version': {},
'manuinfo': {},
'power': [],
'fans': [],
'environment': [],
'boot_loader': [],
'irf': [],
'irf_topology': [],
'irf_configuration': [],
'cpu_process': {},
'process': {},
'memory': [],
'transceiver': [],
'transceiver_interface': [],
'logbuffer': [],
'multicast': [],
'qos': [],
'aaa': [],
'stp': {},
'interfaces': [],
'link_aggregation': [],
'current_configuration': {},
'saved_configuration': {}
}
self.master = None
def load_file(self):
"""Charge le fichier texte brut avec gestion d'encodage"""
encodings_to_try = ['utf-8', 'latin-1', 'cp1252']
for encoding in encodings_to_try:
try:
with open(self.file, 'r', encoding=encoding) as f:
self.raw_data = f.readlines()
print(f"✓ Fichier chargé ({encoding}): {self.file}")
return
except UnicodeDecodeError:
continue
raise ValueError("Impossible de décoder le fichier avec les encodages standards")
def _parse_mac_address(self):
"""Parse display mac-address"""
mac_addresses = []
# TODO: Parcourir les logs et instancier des objets Mac Address
self.config['mac_addresses'] = mac_addresses
def _parse_arp_table(self):
"""Parse display arp all"""
arp_table = []
# TODO: Parcourir les logs et instancier des objets ARP
self.config['arp_table'] = arp_table
def _parse_routing_table(self):
"""Parse display ip routing-table"""
routes = []
# TODO: Parcourir les logs et instancier des objets Routing table
self.config['routing_table'] = routes
def _parse_fib_table(self):
"""Parse display fib"""
fib_entries = []
# TODO: Parcourir les logs et instancier des objets FIB
self.config['fib_table'] = fib_entries
def _parse_version(self):
"""Parse display version"""
version_info = VersionInfo()
# TODO: Parcourir les logs et instancier des objets Version
self.config["version"] = version_info
def _parse_device_manuinfo(self):
"""Parse display device manuinfo"""
manuinfo = ManuInfo()
# TODO: Parcourir les logs et instancier des objets ManuInfo
self.config["manuinfo"] = manuinfo
def _parse_power(self):
"""Parse display power"""
power_data = []
# TODO: Parcourir les logs et instancier des objets Power
self.config["power"] = power_data
def _parse_fan(self):
"""Parse display fan"""
fan_data = []
# TODO: Parcourir les logs et instancier des objets Fan
self.config["fans"] = fan_data
def _parse_environment(self):
"""Parse display environment"""
env_data = EnvironmentInfo()
# TODO: Parcourir les logs et instancier des objets Environment
self.config["environment"] = env_data
def _bootloader_information(self):
"""Parse boot-loader information"""
boot_data = []
# TODO: Parcourir les logs et instancier des objets Boot loader
self.config["boot_loader"] = boot_data
def _parse_irf(self):
"""Parse display irf"""
irf_data = []
# TODO: Parcourir les logs et instancier des objets IRF
self.config["irf"] = irf_data
def _parse_irf_topology(self):
"""Parse display irf topology"""
topo = []
# TODO: Parcourir les logs et instancier des objets IRF Topology
self.config["irf_topology"] = topo
def _parse_irf_configuration(self):
"""Parse display irf configuration"""
config = []
# TODO: Parcourir les logs et instancier des objets IRF Configuration
self.config["irf_configuration"] = config
def _parse_cpu_process(self):
"""Parse display process cpu slot [master]"""
cpu_data = CpuProcessInfo(slot=self.master)
# TODO: Parcourir les logs et instancier des objets CPU Process
self.config["cpu_process"] = cpu_data
def _parse_process(self):
"""Parse display process slot [master]"""
process_data = ProcessInfo(slot=self.master)
# TODO: Parcourir les logs et instancier des objets Process
self.config["process"] = process_data
def _parse_memory(self):
"""Parse display memory"""
memory_data = []
# TODO: Parcourir les logs et instancier des objets Memory
self.config["memory"] = memory_data
def _parse_transceiver_diagnosis(self):
"""Parse display transceiver diagnosis interface"""
data = []
# TODO: Parcourir les logs et instancier des objets Transceiver diagnosis
self.config["transceiver"] = data
def _parse_transceiver_interface(self):
"""Parse display transceiver interface"""
data = []
# TODO: Parcourir les logs et instancier des objets Transceiver interface
self.config["transceiver_interface"] = data
def _parse_logbuffer(self):
"""Parse display logbuffer"""
raw_table = []
# TODO: Parcourir les logs et instancier des objets Log
self.config["logbuffer"] = {
"raw_table": raw_table
}
def _parse_multicast(self):
"""Parse display multicast forwarding-table"""
multicast = []
# TODO: Parcourir les logs et instancier des objets Multicast
self.config["multicast"] = multicast
def _parse_qos(self):
"""Parse qos policy user-defined"""
qos = []
# TODO: Parcourir les logs et instancier des objets QOS
self.config["qos"] = qos
def _parse_aaa(self):
"""Parse dot1x"""
aaa = []
# TODO: Parcourir les logs et instancier des objets AAA
self.config["aaa"] = aaa
def _parse_stp(self):
"""Parse display stp"""
stp = StpInfo()
# TODO: Parcourir les logs et instancier des objets STP
self.config["stp"] = stp
def _parse_interface(self):
"""Parse display interface"""
INTERFACE_NAME_RE = re.compile(
r'^('
r'Bridge-Aggregation\d+'
r'|HundredGigE[\d/]+'
r'|Ten-GigabitEthernet[\d/]+'
r'|GigabitEthernet[\d/]+'
r'|M-GigabitEthernet[\d/]+'
r'|FortyGigE[\d/]+'
r'|XGE[\d/]+'
r'|Vlan-interface\d+'
r'|LoopBack\d+'
r'|InLoopBack\d+'
r'|NULL\d+'
r'|Register-Tunnel\d+'
r'|Tunnel\d+'
r')$',
re.IGNORECASE
)
interfaces = []
# TODO: Parcourir les logs et instancier des objets Interface
self.config["interfaces"] = interfaces
def _parse_link_aggregation(self):
"""Parse display link-aggregation verbose"""
aggs = []
# TODO: Parcourir les logs et instancier des objets Link Aggregation
self.config["link_aggregation"] = aggs
def _parse_current_configuration(self):
"""Parse display current-configuration"""
self.config["current_configuration"] = self._parse_configuration_section(
"display current-configuration"
)
def _parse_saved_configuration(self):
"""Parse display saved-configuration"""
self.config["saved_configuration"] = self._parse_configuration_section(
"display saved-configuration"
)
def _parse_configuration_section(self, section_marker: str) -> DeviceConfiguration:
"""Parse une section de configuration (current ou saved)"""
config = DeviceConfiguration()
# TODO: Parcourir les logs et instancier des objets Configuration
return config
def parse_all(self):
"""Parse tous les éléments de configuration"""
print("Début du parsing de la configuration MODELE...")
self.load_file()
self._parse_mac_address()
self._parse_arp_table()
self._parse_routing_table()
self._parse_fib_table()
self._parse_version()
self._parse_device_manuinfo()
self._parse_power()
self._parse_fan()
self._parse_environment()
self._bootloader_information()
self._parse_irf()
self._parse_irf_topology()
self._parse_irf_configuration()
self._parse_cpu_process()
self._parse_process()
self._parse_memory()
self._parse_transceiver_diagnosis()
self._parse_transceiver_interface()
self._parse_logbuffer()
self._parse_multicast() # Pas implémenté
self._parse_qos() # Pas implémenté
self._parse_aaa() # Pas implémenté
self._parse_stp()
self._parse_interface()
self._parse_link_aggregation()
self._parse_current_configuration()
self._parse_saved_configuration()
# display poe interface (a voir si existe dans d'autres logs)
print("✓ Parsing terminé avec succès!")
def export_to_json(self, output_file1: str, output_file2: str):
"""Exporte la configuration au format JSON OpenConfig"""
fw_name = self.config['current_configuration'].hostname
openconfig_data_c = self.to_openconfig_yang("modele", fw_name, "current_configuration")
openconfig_data_s = self.to_openconfig_yang("modele", fw_name, "saved_configuration")
with open(output_file1, "w", encoding="utf-8") as f:
json.dump(openconfig_data_c, f, indent=2, ensure_ascii=False)
with open(output_file2, "w", encoding="utf-8") as f:
json.dump(openconfig_data_s, f, indent=2, ensure_ascii=False)
print(f"✓ Configuration exportée vers: {output_file1} {output_file2}")
def generate_json_modele(input_file: str, output_file1: str, output_file2: str):
"""Génère le fichier JSON OpenConfig à partir du fichier XML MODELE"""
file = Path(input_file)
if not file.exists():
print(f"✗ Erreur: Le fichier '{file}' n'existe pas")
return
try:
parser = ModeleParser(str(file))
parser.parse_all()
parser.print_summary()
parser.export_to_json(output_file1, output_file2)
print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file1} {output_file2}")
except Exception as e:
print(f"✗ Erreur: {e}")
return
```
## Étape 2 : Intégration dans le moteur principal (`main.py`)
Pour que le script global prenne en charge le nouveau modèle, ouvrez le fichier `Parseurs_logs_Switch/src/main.py` :
1. Importez votre nouvelle fonction en haut du fichier :
```python
import scripts.json_modele as json_modele
```
2. Ajoutez la condition correspondante dans le bloc de sélection du type de firewall :
```python
elif switch_type == "modele":
json_modele.generate_json_modele(input_data, output_file1_json, output_file2_json)
```
3. Mettez à jour les instructions textuelles d'usage affichées dans la console si le paramètre saisi est incorrect afin d'inclure `"modele"` dans la liste des choix valides.
## Étape 3 : Adaptation de l'Interface Graphique (GUI)
Afin que le nouveau modèle apparaisse dans l'interface graphique unifiée :
1. Ouvrez le fichier de gestion de la GUI (`gui_switch.py` racine ou script GUI dédié).
2. Repérez le composant de sélection (Menu déroulant / ComboBox ou liste de boutons radio) listant les switches.
3. Ajoutez **`MODELE`** à la liste des choix graphiques.
> **Important :** faire attention si le script prend en compte un dossier ou un fichier.

204
Parseurs_config_Firewall/MODELE.md Normal file
View File

@@ -0,0 +1,204 @@
```json
{
"firewall-device": {
"type": "", //palo-alto, forcepoint, stormshield
"name": [
"NOM_Switch"
]
},
"openconfig-interfaces:interfaces": {
"interface": [
{
"name": "INTERFACE NAME",
"config": {
"name": "INTERFACE NAME",
"type": "", //iana-if-type:ieee8023adLag, iana-if-type:ethernetCsmacd, ...
"enabled": true,
"description": "DESCRIPTION"
},
"subinterfaces": {
"subinterface": [
{
"index": 0,
"config": {
"index": 0,
"enabled": true
},
"oc-ip:ipv4": {
"oc-ip:addresses": {
"oc-ip:address": [
{
"oc-ip:ip": "IP",
"oc-ip:config": {
"oc-ip:ip": "IP",
"oc-ip:prefix-length": "MASQUE"
}
}
]
}
}
}
]
}
}
]
},
"openconfig-network-instance:network-instances": {
"network-instance": [
{
"name": "NOM",
"config": {
"name": "NOM",
"type": "TYPE"
},
"interfaces": {
"interface": [
{
"id": "" // INTERFACE
}
]
},
"protocols": { //routing table
"protocol": [
{
"identifier": "STATIC",
"name": "STATIC",
"static-routes": {
"static": [
{
"prefix": "CIDR",
"next-hops": {
"next-hop": [
{
"index": "", //NAME
"config": {
"index": "", //NAME
"next-hop": "", //NEXT VR ou NEXT HOP IP
"metric": 10,
"oc-loc-rt-netinst:next-network-instance": "", //NEXT VR si NEXT VR
"oc-loc-rt-netinst:nh-network-instance": "" // NEXT HOP IP si NEXT HOP IP
},
"interface-ref": {
"config": {
"interface": "" // INTERFACE
}
}
}
]
}
}
]
}
}
]
}
}
]
},
"openconfig-acl:acl": {
"acl-sets": {
"acl-set": [
{
"name": "NOM",
"type": "openconfig-acl:ACL_IPV4",
"config": {
"name": "NOM",
"type": "openconfig-acl:ACL_IPV4",
"description": "DESCRIPTION"
},
"state": {
"description": true
},
"acl-entries": {
"acl-entry": [
{
"sequence-id": 1,
"config": {
"sequence-id": 1,
"description": [ //application
"ping",
]
},
"state": {
"sequence-id": 1,
"description": "" //Format "Misc: liste des tag member"
},
"ipv4": {
"config": {
"source-address": "any",
"destination-address": "any"
}
},
"transport": {
"config": {
"source-port": "any",
"destination-port": "" //service member
}
},
"actions": {
"config": {
"forwarding-action": "", //openconfig-acl:ACCEPT, openconfig-acl:ACCEPT_DISABLED, openconfig-acl:DROP, openconfig-acl:NAT
"log-action": ""
}
}
}
]
}
}
]
}
},
"custom-firewall-objects:firewall-objects": {
"address": [
{
"name": "ADDRESS NAME",
"config": {
"name": "ADDRESS NAME",
"ip_netmask": "IP ou CIDR",
"description": "DESCRIPTION",
"misc": [] //tag member
}
}
],
"address-group": [
{
"name": "ADDRESS GROUP NAME",
"config": {
"name": "GROUP NAME",
"members": [
"ADDRESS NAME"
],
"description": "DESCRIPTION",
"misc": [] //tag member
}
}
],
"service": [
{
"name": "SERVICE NAME",
"config": {
"name": "SERVICE NAME",
"protocol": "", //udp, tcp, ...
"port": "",
"source_port": "1",
"description": "DESCRIPTION",
"misc": [] //tag member
}
}
],
"service-group": [
{
"name": "SERVICE GROUP NAME",
"config": {
"name": "SERVICE GROUP NAME",
"members": [
"SERVICE NAME"
],
"description": "DESCRIPTION",
"misc": [] //tag member
}
}
]
}
}
```

4
Parseurs_config_Firewall/README.md
View File

@@ -4,8 +4,8 @@
Cet outil permet de **parser les configurations de différents types de firewalls** (Palo Alto, Stormshield, Forcepoint) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.
Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
- Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
- Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
## Fonctionnalités principales

781
Parseurs_logs_Switch/MODELE.md Normal file
View File

@@ -0,0 +1,781 @@
```json
{
"switch-device": {
"type": "hpe",
"name": "NOM_Switch"
},
"openconfig-system:system": {
"state": [
{
"hostname": "NOM_Switch",
"login-banner": [
"Message de",
"Connexion"
],
"motd-banner": [
"Message de",
"Connexion"
],
"current-datetime": "",
"up-time": "1 weeks, 1 days, 1 hours, 1 minutes",
"software-version": "Version 1 Release 1"
}
],
"aaa": {
"authentication": {
"users": {
"user": [
{
"username": "user",
"config": {
"username": "user",
"password-hashed": "hash",
"role": "role",
"openconfig-system-ext:allowed-services": [
"http"
]
}
}
]
}
}
},
"processes": {
"process": [
{
"pid": 1, // int de l'id du master
"state": {
"pid": 1, // int de l'id du master
"args": [
"cpu process master",
"liste des éléments",
"process master",
"liste des éléments"
]
}
}
]
},
"messages": {
"state": {
"message": [
{
"msg": "log" //string de tous les logs
}
]
}
},
"ssh-server": {
"enabled": true,
"config": {
"enabled": true,
"openconfig-system-ext:access-permissible": "1"
}
},
"cpus": {
"cpu": [
{
"index": 1, // int de l'id du master
"state": {
"index": 1, // int de l'id du master
"instant": 0, // % CPU utilization in 5 secs
"min": 0, // % CPU utilization in 1 min
"max": 0 // % CPU utilization in 5 mins
}
}
]
},
"ntp": {
"config": {
"enabled": true,
"ntp-source-address": "interface name"
},
"servers": {
"server": [
{
"address": "ip",
"config": {
"address": "ip",
"prefer": true
}
}
]
},
"peers": {
"peer": [
{
"address": "ip",
"config": {
"address": "ip",
"prefer": true
}
}
]
}
}
},
"openconfig-lldp:lldp": {
"config": {
"enabled": true
}
},
"openconfig-relay-agent:relay-agent": {
"dhcp": {
"config": {
"enable-relay-agent": true
}
}
},
"ietf-snmp:snmp": {
"ietf-snmp:snmp": {
"engine": {
"version": {
"v1": true,
"v2c": true,
"v3": true
},
"engine-id": "id"
},
"community": [
{
"index": 0,
"text-name": "mail@contact",
"context": "Contact: NOM Location: NOM" // Format Contact: NOM Location: NOM
}
],
"usm": {
"local": {
"user": [
{
"name": "NOM UTILISATEUR",
"auth": {
"md5": {
"key": "" //REDACTED si authentication mode
}
},
"priv": {
"aes": {
"key": "" //REDACTED si privacy mode
}
}
}
]
}
},
"vacm": {
"group": [
{
"name": "NOM GROUPE",
"access": [
{
"security-model": "", //V1, v2, v3
"notify-view": "",
"source-context": "", //id acl
"read-view": "All",
"write-view": "All",
"notify-view": "All"
}
]
}
],
"view": [ //mib view
{
"name": "All",
"include": [
"iso"
],
"exclude": []
}
]
},
"target": [ // target host
{
"name": "NOM TARGET",
"udp": {
"ip": "ip"
},
"target-params": "NOM PARAM"
}
],
"target-params": [ // target param
{
"name": "NOM PARAM",
"usm": {
"user-name": "NOM TARGET",
"security-level": "auth-priv"
}
}
]
}
},
"openconfig-interfaces:interfaces": {
"interface": [
{
"name": "NOM INTERFACE",
"config": {
"name": "NOM INTERFACE",
"type": "" // iana-if-type:ieee8023adLag si Bridge-Aggregation sinon null
},
"state": {
"name": "NOM INTERFACE",
"admin-status": "", //UP ou DOWN
"oper-status": "", // UP ou DOWN ou null
"description": "", // Format "Jumbo: True/False;Description: ...;Media: ...;Hardware: type de lien;Raw: config de l'interface dans current-configuration;Counters Cleared: date;
"mtu": null,
"counters": {
"in-octets": null,
"in-pkts": null,
"in-unicast-pkts": null,
"in-broadcast-pkts": null,
"in-multicast-pkts": null,
"in-pauses-pkts": null,
"in-drops": null,
"in-errors": null,
"out-octets": null,
"out-pkts": null,
"out-unicast-pkts": null,
"out-broadcast-pkts": null,
"out-multicast-pkts": null,
"out-pauses-pkts": null,
"out-drops": null,
"out-errors": [
{
"type": "output errors",
"count": 0
},
{
"type": "underruns",
"count": 0
},
{
"type": "buffer failures",
"count": 0
},
{
"type": "aborts",
"count": 0
},
{
"type": "deferred",
"count": 0
},
{
"type": "collisions",
"count": 0
},
{
"type": "late collisions",
"count": 0
},
{
"type": "lost carrier",
"count": 0
},
{
"type": "no carrier",
"count": 0
}
]
},
"openconfig-if-aggregate-ext:load-sharing-type": "Shar"
},
"ethernet": {
"name": "Bridge-Aggregation1",
"state": {
"enable-flow-control": null,
"duplex-mode": "unknown-duplex",
"port-speed": null
},
"switched-vlan": {
"state": {
"interface-mode": "", //ACCESS ou TRUNK
"native-vlan": 1, // PVID
"access-vlan": 1, // si ACCESS: PVID
"trunk-vlans": [ // si TRUNK
"vlan_passing",
1,
"vlan_permitted",
1
]
}
}
},
"subinterfaces": {
"subinterface": [
{
"index": 0, //toujours 0
"config": {
"index": 0 //toujours 0
},
"state": {
"index": 0 //toujours 0
},
"oc-ip:ipv4": {
"oc-ip:neighbors": { // table arp
"oc-ip:neighbor": [
{
"ip": "IP",
"config": {
"ip": "IP",
"link-layer-address": "MAC"
},
"state": {
"ip": "IP",
"link-layer-address": "MAC",
"origin": "DYNAMIC",
"openconfig-if-ip-ext:aging": "",
"openconfig-if-ip-ext:vlan": ""
}
}
]
},
"addresses": { // Internet address
"address": [
{
"ip": "IP",
"state": {
"ip": "IP",
"prefix-length": 255 // Masque
}
}
]
}
}
}
]
},
"openconfig-if-aggregate:aggregation": {
"state": {
"lag-type": "Static", //Static ou Dynamic
"member": [
"Local",
"texte",
"Remote",
"texte"
]
}
}
}
]
},
"openconfig-network-instance:network-instances": {
"network-instance": [
{
"name": "default",
"fdb": {
"mac-table": { // table mac
"entries": {
"entry": [
{
"mac-address": "MAC",
"vlan": "1",
"config": {
"mac-address": "MAC",
"vlan": "1"
},
"state": {
"mac-address": "MAC",
"vlan": "1",
"age": "Y", //aging
"entry-type": "Learned" // State
},
"interface": {
"interface-ref": {
"config": {
"interface": "NOM INTERFACE"
}
}
}
}
]
}
}
},
"protocols": { //table de routage
"protocol": [
{
"identifier": "", // oc-pol-types:RIP, oc-pol-types:DIRECT, oc-pol-types:STATIC, oc-pol-types:IPV4
"name": "", //RIP, DIRECT, STATIC, IPV4
"static-routes": {
"static": [
{
"prefix": "CIDR",
"config": {
"prefix": "CIDR"
},
"next-hops": {
"next-hop": [
{
"index": 0,
"config": {
"next-hop": "IP",
"metric": 0,
"preference": 0
},
"interface-ref": {
"config": {
"interface": "INTERFACE"
}
}
}
]
}
}
]
}
}
]
},
"tables": { //table FIB
"table": [
{
"protocol": "oc-pol-types:IPV4",
"address-family": "oc-types:IPV4",
"ipv4": {
"routes": {
"route": [
{
"prefix": "CIDR",
"state": {
"prefix": "CIDR",
"active": true,
"_custom_flags": "" //FLAG
},
"next-hops": {
"next-hop": [
{
"index": 0,
"state": {
"next-hop": "IP",
"pushed-mpls-label-stack": []
},
"interface-ref": {
"state": {
"interface": "INTERFACE"
}
}
}
]
}
}
]
}
}
}
]
}
}
]
},
"openconfig-vlan:vlans": {
"vlan": [
{
"vlan-id": 1,
"config": {
"vlan-id": 1,
"name": "" //NAME
},
"state": {
"name": "" //DESCRIPTION
}
}
]
},
"openconfig-acl:acl": {
"acl-sets": {
"acl-set": [
{
"name": "1", //numéro ACL
"type": "", //basic ou advanced
"config": {
"name": "1", //numéro ACL
"type": "", //basic ou advanced
"description": ""
},
"acl-entries": {
"acl-entry": [
{
"sequence-id": 1,
"config": {
"sequence-id": 1,
"forwarding-action": "" //ACCEPT ou DROP
},
"ipv4": {
"config": {
"protocol": "", //IP_TCP, UP_UDP, IP_PIM
"source-address": "IP",
"source-address-prefix-set": "MASQUE",
"destination-address": "IP",
"destination-address-prefix-set": "MASQUE"
}
}
}
]
}
}
]
}
},
"openconfig-platform:components": {
"component": [
{
"name": "CHASSIS",
"config": {
"name": "CHASSIS"
},
"state": {
"name": "CHASSIS",
"type": "oc-platform-types:CHASSIS",
"model-name": ""
}
},
{
"name": "OS",
"config": {
"name": "OS"
},
"state": {
"name": "OS",
"type": "oc-platform-types:OPERATING_SYSTEM",
"description": "", //Format "Boot-image: ..."
"software-version": "Version 1 Release 1"
}
},
{
"name": "Switch 1",
"config": {
"name": "Switch 1"
},
"state": {
"name": "Switch 1",
"type": "oc-platform-types:LINECARD",
"id": 1,
"description": "", //Format "Patch version: ..."
"hardware-version": "", // release version
"software-version": "", //Format "CURRENT: ... | MAIN: ... | BACKUP: ..."
"model-name": "", //board type
"last-reboot-reason": "",
"redundant-role": "", //Standby ou Master
"memory": {
"available": 1,
"utilized": 1
}
},
"properties": {
"property": [
{
"name": "irf-priority",
"state": {
"name": "irf-priority",
"value": "1" //priority
}
},
{
"name": "irf-link-1",
"state": {
"name": "irf-link-1",
"value": "Neighbor: 2 | State: UP"
}
},
{
"name": "irf-link-2",
"state": {
"name": "irf-link-2",
"value": "Neighbor: 3 | State: UP"
}
},
{
"name": "irf-config-port1",
"state": {
"name": "irf-config-port1",
"value": "Ten-GigabitEthernet1/0/1, Ten-GigabitEthernet1/0/2"
}
},
{
"name": "irf-config-port2",
"state": {
"name": "irf-config-port2",
"value": "Ten-GigabitEthernet1/0/3, Ten-GigabitEthernet1/0/4"
}
}
]
}
},
{
"name": "CPU 1",
"config": {
"name": "CPU 1"
},
"state": {
"name": "CPU 1",
"type": "oc-platform-types:LINECARD",
"description": "", //DEVICE NAME
"mfg-name": "", // VENDOR NAME
"mfg-date": "", // MANUFACTURING DATE
"serial-no": "", //SN
"part-no": "", //PRODUCT NUMBER
"base-mac-address": "MAC"
}
},
{
"name": "FAN 1",
"config": {
"name": "FAN 1"
},
"state": {
"name": "FAN 1",
"type": "oc-platform-types:FAN",
"description": "", //DEVICE NAME
"mfg-name": "", // VENDOR NAME
"mfg-date": "", // MANUFACTURING DATE
"serial-no": "", //SN
"parent": "CPU 1",
"oper-status": "" //STATE
},
"openconfig-platform-fan:fan": {
"state": {
"oc-fan:airflow-direction": "",
"oc-fan:prefer-airflow-direction": ""
}
}
},
{
"name": "POWER 1",
"config": {
"name": "POWER 1"
},
"state": {
"name": "POWER 1",
"type": "oc-platform-types:POWER_SUPPLY",
"description": "", //DEVICE NAME
"mfg-name": "", // VENDOR NAME
"mfg-date": "", // MANUFACTURING DATE
"serial-no": "", //SN
"parent": "CPU 1",
"oper-status": "" //STATE
},
"openconfig-platform-psu:power-supply": {
"state": {
"oc-platform-psu:mode": ""
}
}
},
{
"name": "hotspot 1",
"config": {
"name": "hotspot 1"
},
"state": {
"name": "hotspot 1",
"type": "oc-platform-types:SENSOR",
"parent": 1, //SLOT
"temperature": {
"instant": "1"
}
}
},
{ //transceiver diagnostic et interface
"name": "INTERFACE NAME",
"config": {
"name": "INTERFACE NAME"
},
"state": {
"name": "INTERFACE NAME",
"type": "oc-platform-types:TRANSCEIVER",
"present": "", //PRESENT ou null
"form-factor": "", //TRANSCEIVER TYPE
"connector-type": "",
"vendor": "",
"part-no": "", //PRODUCT NUMBER/ORDERING NAME
"temperature": {
"instant": 1
}
},
"properties": {
"property": [
{
"name": "wavelength",
"state": {
"name": "wavelength",
"value": "1"
}
}
]
},
"oc-transceiver:transceiver": {
"state": {
"supply-voltage": {
"instant": 1 //VOLTAGE
},
"output-power": {
"instant": 1 //TX
},
"input-power": {
"instant": 1 //RX
},
"laser-bias-current": {
"instant": 1 //BIAS
}
}
}
}
]
},
"openconfig-spanning-tree:stp": {
"global": {
"state": {
"enabled-protocol": [
"oc-stp-types:RSTP"
],
"bpdu-guard": false
}
},
"interfaces": {
"interface": [
{
"name": "INTERFACE NAME",
"state": {
"hello-time": "",
"name": "INTERFACE NAME",
"edge-port": "",
"bpdu-mst": "",
"rapid-transition": "", //True ou False
"num-vlans": 1
}
}
]
},
"rstp": {
"state": {
"hello-time": "",
"bridge-priority": "0",
"bridge-address": "MAC",
"designated-root-address": "MAC",
"root-port": "0",
"topology-changes": 1,
"last-topology-change": "DATE"
},
"interfaces": {
"interface": [
{
"name": "INTERFACE NAME",
"state": {
"name": "INTERFACE NAME",
"port-num": 1,
"protocol": "", //Enabled ou Disabled
"role": "",
"port-state": "", //UP ou DOWN
"counters": {
"state": {
"bpdu-sent": 1,
"bpdu-received": 1
}
}
}
}
]
}
}
}
}
```

8
Parseurs_logs_Switch/README.md
View File

@@ -4,10 +4,10 @@
Cet outil permet de **récupérer les données des logs de différents types de switches** (HPE uniquement actuellement) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.
Il fournit également la possibilité de générer une **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
Il fournit également la possibilité de générer une **rapport des interfaces format Excel** pour visualiser la liste des counters pour chaque interface.
Il fournit également la possibilité de générer une **rapport des stack format Excel** pour visualiser les stack de chaque switch.
Il founit également la possibilité de générer une **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
- Il fournit également la possibilité de générer un **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
- Il fournit également la possibilité de générer un **rapport des interfaces format Excel** pour visualiser la liste des counters pour chaque interface.
- Il fournit également la possibilité de générer un **rapport des stack format Excel** pour visualiser les stack de chaque switch.
- Il founit également la possibilité de générer un **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
## Fonctionnalités principales

127
Parseurs_logs_Switch/src/main.py Normal file
View File

@@ -0,0 +1,127 @@
import sys
import os
import time
import scripts.json_hpe as json_hpe
from pathlib import Path
from scripts.export_schema_infra import main as schema_infra
from scripts.export_rapport_uplink import main as rapport_uplink
from scripts.export_rapport_stack import main as rapport_stack
from scripts.export_rapport_interfaces import main as rapport_interfaces
sys.path.append(os.path.dirname(__file__))
def verify_if_file_exists(name):
base, ext = os.path.splitext(name)
counter = 1
new_name = name
while os.path.exists(new_name):
new_name = f"{base}_{counter}{ext}"
counter += 1
return new_name
def main():
"""Fonction principale du programme d'analyse de switches"""
if len(sys.argv) < 3:
print("Usage: python3 src/main.py <switch_type>[hpe|...] <input_file> [-o <output_file>] [-u] [-d] [-s] [-i]")
print("Options:")
print(" <switch_type> Type of switch to process (hpe)")
print(" -o <output_file> Specify output JSON file name (optional)")
print(" -d Generate infrastructure schema (optional)")
print(" -u Generate uplink report (optional)")
print(" -s Generate stack report (optional)")
print(" -i Generate interface report (optional)")
sys.exit(1)
switch_type = sys.argv[1].lower()
input_data = sys.argv[2]
input_path = "src/input/"
output_path = "src/output/"
os.makedirs(output_path, exist_ok=True)
if "-o" in sys.argv:
o_index = sys.argv.index("-o")
if o_index + 1 < len(sys.argv):
output_file1_json = f"{output_path}{switch_type}_saved_{sys.argv[o_index + 1]}.json"
output_file2_json = f"{output_path}{switch_type}_current_{sys.argv[o_index + 1]}.json"
else:
print("Erreur: nom de fichier de sortie manquant après '-o'.")
sys.exit(1)
else:
timestamp = time.strftime("%Y%m%d")
output_file1_json = f"{output_path}{switch_type}_current_{timestamp}.json"
output_file2_json = f"{output_path}{switch_type}_saved_{timestamp}.json"
output_file1_json = verify_if_file_exists(output_file1_json)
output_file2_json = verify_if_file_exists(output_file2_json)
if switch_type == "hpe":
json_hpe.generate_json_hpe(input_data, output_file1_json, output_file2_json)
else:
print("Erreur: type de switch inconnu. Utilisez 'hpe'.")
sys.exit(1)
if "-d" in sys.argv:
print(f"\nGénération du schéma d'infrastructure...")
if "-o" in sys.argv:
o_index = sys.argv.index("-o")
if o_index + 1 < len(sys.argv):
output_file_html = os.path.join(f"{output_path}schema_infra_{switch_type}_{sys.argv[o_index + 1]}.html")
else:
print("Erreur: nom de fichier de sortie manquant après '-o'.")
sys.exit(1)
else:
timestamp = time.strftime("%Y%m%d")
output_file_html = f"{output_path}schema_infra_{switch_type}_{timestamp}.html"
output_file_html = verify_if_file_exists(output_file_html)
html_file = schema_infra(output_path, output_file_html)
print(f"✓ Processus terminé. Fichiers générés:\n - JSON: {output_file1_json} & {output_file2_json}\n - HTML: {html_file}")
if "-u" in sys.argv:
print(f"\nGénération du rapport d'uplink...")
if "-o" in sys.argv:
o_index = sys.argv.index("-o")
if o_index + 1 < len(sys.argv):
output_file_excel = os.path.join(f"{output_path}rapport_uplink_{switch_type}_{sys.argv[o_index + 1]}.xlsx")
else:
print("Erreur: nom de fichier de sortie manquant après '-o'.")
sys.exit(1)
else:
timestamp = time.strftime("%Y%m%d")
output_file_excel = f"{output_path}rapport_uplink_{switch_type}_{timestamp}.xlsx"
output_file_excel = verify_if_file_exists(output_file_excel)
excel_file = rapport_uplink(output_path, output_file_excel)
print(f"✓ Processus terminé. Fichiers générés:\n - JSON: {output_file1_json} & {output_file2_json}\n - Excel: {excel_file}")
if "-s" in sys.argv:
print(f"\nGénération du rapport de stack...")
if "-o" in sys.argv:
o_index = sys.argv.index("-o")
if o_index + 1 < len(sys.argv):
output_file_excel = os.path.join(f"{output_path}rapport_stack_{switch_type}_{sys.argv[o_index + 1]}.xlsx")
else:
print("Erreur: nom de fichier de sortie manquant après '-o'.")
sys.exit(1)
else:
timestamp = time.strftime("%Y%m%d")
output_file_excel = f"{output_path}rapport_stack_{switch_type}_{timestamp}.xlsx"
output_file_excel = verify_if_file_exists(output_file_excel)
excel_file = rapport_stack(output_path, output_file_excel)
print(f"✓ Processus terminé. Fichiers générés:\n - JSON: {output_file1_json} & {output_file2_json}\n - Excel: {excel_file}")
if "-i" in sys.argv:
print(f"\nGénération du rapport d'interfaces...")
if "-o" in sys.argv:
o_index = sys.argv.index("-o")
if o_index + 1 < len(sys.argv):
output_file_excel = os.path.join(f"{output_path}rapport_interfaces_{switch_type}_{sys.argv[o_index + 1]}.xlsx")
else:
print("Erreur: nom de fichier de sortie manquant après '-o'.")
sys.exit(1)
else:
timestamp = time.strftime("%Y%m%d")
output_file_excel = f"{output_path}rapport_interfaces_{switch_type}_{timestamp}.xlsx"
output_file_excel = verify_if_file_exists(output_file_excel)
excel_file = rapport_interfaces(output_path, output_file_excel)
print(f"✓ Processus terminé. Fichiers générés:\n - JSON: {output_file1_json} & {output_file2_json}\n - Excel: {excel_file}")
if __name__ == "__main__":
main()

2
Parseurs_logs_Switch/src/scripts/export_modele.py
View File

@@ -181,7 +181,7 @@ class ParserMixin:
"software-version": f"Version {self.config['version'].version if self.config['version'].version else None} Release {self.config['version'].release if self.config['version'].release else None}"
})
# Conversion current configuration/saved configuration TODO
# Conversion current configuration/saved configuration
# Users
if self.config[config_type].local_users:
oc_users = []

35
Parseurs_logs_Switch/src/scripts/json_hpe.py
View File

@@ -1,7 +1,7 @@
#!/usr/bin/env python3
"""
Parser pour configuration switch HPE vers un format json normalisé OpenConfig YANG
Extrait les différentes sections de la configuration HPE et les convertit en objets Python, puis exporte le tout au format JSON OpenConfig.
Extrait les différentes sections de logs et les convertit en objets Python, puis exporte le tout au format JSON OpenConfig.
"""
import json
@@ -14,7 +14,7 @@ class HpeParser(ParserMixin):
"""Parser pour fichier XML HPE"""
def __init__(self, file_path: str):
"""Initialise le parser avec le chemin du fichier de configuration HPE"""
"""Initialise le parser avec le chemin du fichier de logs HPE"""
self.file = file_path
self.root = None
self.raw_data = None
@@ -1505,33 +1505,4 @@ def generate_json_hpe(input_file: str, output_file1: str, output_file2: str):
except Exception as e:
print(f"✗ Erreur: {e}")
return
# if __name__ == "__main__":
# import sys
# if len(sys.argv) != 2:
# print("Usage: python json_hpe.py <fichier_config>")
# print("Exemple: python json_hpe.py config_hpe")
# sys.exit(1)
# file = sys.argv[1]
# if not Path(file).exists():
# print(f"✗ Erreur: Le fichier '{file}' n'existe pas")
# sys.exit(1)
# try:
# parser = HpeParser(file)
# parser.parse_all()
# parser.print_summary()
# input_path = Path(file)
# output_file = 'output_Hpe.json'
# parser.export_to_json(output_file)
# print(f"\n✓ Conversion terminée! Vérifiez le fichier: {output_file}")
# except Exception as e:
# print(f"✗ Erreur: {e}")
# sys.exit(1)
return

55
README.md Normal file
View File

@@ -0,0 +1,55 @@
# Analyse Réseau
## Description
Cet outil centralisé permet de récupérer et d'analyser les données de configuration et de logs issues de différents équipements réseau (Firewalls et Switches). Il convertit ces informations brutes en un format JSON normalisé basé sur les modèles OpenConfig (YANG) et génère divers rapports d'infrastructure au format Excel ainsi que des schémas visuels.
L'application dispose d'une interface graphique (GUI) qui automatise la gestion de l'environnement virtuel et l'installation des dépendances pour faciliter son utilisation.
## Fonctionnalités par module
- Module Firewall
```bash
Équipements supportés : Palo Alto, Stormshield, Forcepoint.
Données extraites : Fichiers et dossiers de configurations d'origine.
Rapports générés :
- Matrice de flux (Excel) pour visualiser les communications et les règles de trafic.
- Matrice de routage (Excel) pour cartographier les routes statiques.
```
- Module Switch
```bash
Équipements supportés : HPE (Comware / ProCurve).
Données extraites : Fichiers de logs (outputs de commandes de diagnostic).
Rapports générés :
- Rapport des liens inter-switches (Excel).
- Rapport des interfaces et de leurs compteurs (Excel).
- Rapport d'état des stacks (Excel).
- Schéma global de l'infrastructure réseau (génération visuelle des interconnexions).
```
## Avertissements (Pré-requis)
Avant de lancer l'application, vous devez impérativement créer manuellement les dossiers input/ s'ils n'existent pas encore, et y déposer vos fichiers selon l'architecture suivante :
- Pour le **Firewall** : Créer le dossier et déposer les configurations dans /Parseurs_config_Firewall/src/input/
- Pour le **Switch** : Créer le dossier et déposer les fichiers de logs dans /Parseurs_logs_Switch/src/input/
Fichier de site : N'oubliez pas de renseigner ou modifier le fichier de données site.json pour correspondre à vos zone réseau situé dans le dossier /Parseurs_config_Firewall/src/data/.
## Utilisation & Interface Graphique
L'outil intègre une interface graphique. Lors de son premier lancement, le script se charge de créer automatiquement un environnement virtuel (venv) et d'y installer tous les paquets requis (requirements.txt).
Pour démarrer l'application, exécutez simplement la commande suivante à la racine du projet :
```bash
python3 ./main.py
```
## Gestion des Sorties (Output)
Une fois l'analyse terminée, l'ensemble des données extraites (JSON OpenConfig, matrices Excel, rapports et schémas d'infrastructure) sera automatiquement exporté dans les répertoires output/ de leurs sections respectives :
- Résultats Firewalls : /Parseurs_config_Firewall/src/output/
- Résultats Switches : /Parseurs_logs_Switch/src/output/

4
help_Firewall.md
View File

@@ -4,8 +4,8 @@
Cet outil permet de **récupérer les données des configurations de différents types de firewalls** (Palo Alto, Stormshield, Forcepoint) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.
Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
- Il fournit également la possibilité de générer une **matrice de flux au format Excel** pour visualiser les communications et règles de trafic dans l’infrastructure.
- Il founit également la possibilité de générer une **matrice de routage au format Excel** pour visualiser les routes statiques dans l’infrastructure.
## Utilisation

8
help_Switch.md
View File

@@ -4,14 +4,16 @@
Cet outil permet de **récupérer les données des logs de différents types de switches** (HPE uniquement actuellement) et de **convertir ces informations en un format JSON normalisé basé sur des modèles OpenConfig en YANG**.
Il fournit également la possibilité de générer une **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
Il founit également la possibilité de générer une **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
- Il fournit également la possibilité de générer un **rapport des liens inter-switches format Excel** pour visualiser les liens entre les switches existants.
- Il fournit également la possibilité de générer un **rapport des interfaces format Excel** pour visualiser la liste des counters pour chaque interface.
- Il fournit également la possibilité de générer un **rapport des stack format Excel** pour visualiser les stack de chaque switch.
- Il founit également la possibilité de générer un **schéma de l'infrastructure** pour visualiser les liens entres les switches dans l'infrastructure.
## Utilisation
### Pré-requis
- Mettre le/les fichier(s) et/ou dossier(s) de configurations dans le dossier `/Parseurs_logs_Switch/src/input/`
- Mettre le/les fichier(s) de logs dans le dossier `/Parseurs_logs_Switch/src/input/`
```bash
python3 ./main.py