Python pour la Sécurité : Configuration Avancée et Gestion des Erreurs

Installation des Dépendances

Installez Python et les bibliothèques nécessaires pour manipuler les configurations réseau et intercepter les erreurs.

sudo apt-get install python3 python3-pip

pip3 install netifaces python-iptables

Ces commandes installent Python et les paquets nécessaires pour interagir avec les interfaces réseau et les iptables de manière sécurisée.

Script Python pour Configurer iptables

Créons un script pour configurer iptables, en y intégrant des pratiques de gestion des erreurs pour améliorer la robustesse.

import iptc

def add_firewall_rule(chain, src, dst, protocol, target='DROP'):
    try:
        rule = iptc.Rule()
        rule.src = src
        rule.dst = dst
        rule.protocol = protocol
        rule.target = iptc.Target(rule, target)
        chain = iptc.Chain(iptc.Table(iptc.Table.FILTER), chain)
        chain.insert_rule(rule)
        print(f"Rule added to {chain} with target {target}.")
    except Exception as e:
        print(f"Failed to add rule: {e}")

if __name__ == "__main__":
    add_firewall_rule('INPUT', '0.0.0.0/0', '192.168.1.1', 'tcp')
            

Cette section du script ajoute une règle de filtrage dans iptables pour bloquer tout trafic TCP entrant non sollicité, avec gestion des erreurs pour garantir l'exécution sans faille.

Randomisation d'Adresses IP et MAC

Intégrons la randomisation des adresses IP et MAC avec une gestion des erreurs pour renforcer l'anonymat et la sécurité.

import netifaces as ni
import random, subprocess

def randomize_mac(interface):
    try:
        new_mac = [random.randint(0x00, 0x7f) for _ in range(6)]
        formatted_mac = ':'.join(f'{x:02x}' for x in new_mac)
        subprocess.call(['ifconfig', interface, 'down'])
        subprocess.call(['ifconfig', interface, 'hw', 'ether', formatted_mac])
        subprocess.call(['ifconfig', interface, 'up'])
        print(f"New MAC address set: {formatted_mac}")
    except Exception as e:
        print(f"Failed to change MAC address: {e}")

def randomize_ip(interface):
    try:
        new_ip = f"192.168.1.{random.randint(2, 254)}"
        ni.ifaddresses(interface)[ni.AF_INET][0]['addr'] = new_ip
        print(f"New IP address set: {new_ip}")
    except Exception as e:
        print(f"Failed to change IP address: {e}")

if __name__ == "__main__":
    randomize_mac('eth0')
    randomize_ip('eth0')
            

Ce segment modifie aléatoirement les adresses MAC et IP, avec des vérifications pour s'assurer que les commandes s'exécutent correctement et que les erreurs sont gérées efficacement.

Explications du Script pour Configurer iptables

Décortiquons chaque ligne du script iptables pour comprendre son fonctionnement :

• import iptc: Importe la bibliothèque Python qui permet de manipuler les iptables sous Linux.
• def add_firewall_rule(chain, src, dst, protocol, target='DROP'):: Définit une fonction pour ajouter des règles de pare-feu. Les paramètres incluent la chaîne (par exemple, INPUT), l'adresse source, l'adresse de destination, le protocole, et l'action (par défaut à 'DROP').
• rule = iptc.Rule(): Crée une nouvelle règle.
• rule.src = src: Définit l'adresse source de la règle.
• rule.dst = dst: Définit l'adresse de destination de la règle.
• rule.protocol = protocol: Définit le protocole de la règle (par exemple, TCP).
• rule.target = iptc.Target(rule, target): Définit l'action de la règle (par exemple, DROP).
• chain = iptc.Chain(iptc.Table(iptc.Table.FILTER), chain): Accède à la chaîne spécifiée dans la table de filtrage des iptables.
• chain.insert_rule(rule): Insère la règle dans la chaîne.
• print(f"Rule added to {chain} with target {target}."): Affiche un message confirmant l'ajout de la règle.
• Gestion des erreurs avec try et except: Encadre le bloc de code qui peut générer une exception pour une gestion d'erreur robuste.

Explications du Script pour la Randomisation d'Adresses IP et MAC

Examinons chaque ligne du script de randomisation pour saisir les détails techniques :

• import netifaces as ni: Importe la bibliothèque netifaces pour interagir avec les configurations réseau.
• import random, subprocess: Importe les bibliothèques nécessaires pour générer des nombres aléatoires et exécuter des commandes système.
• def randomize_mac(interface):: Définit une fonction pour changer l'adresse MAC d'une interface.
• new_mac = [random.randint(0x00, 0x7f) for _ in range(6)]: Génère une nouvelle adresse MAC de manière aléatoire.
• formatted_mac = ':'.join(f'{x:02x}' for x in new_mac): Formate l'adresse MAC dans le format standard.
• Commandes subprocess.call(): Utilisées pour éteindre l'interface, changer l'adresse MAC, et la rallumer.
• def randomize_ip(interface):: Définit une fonction pour changer l'adresse IP de manière aléatoire.
• new_ip = f"192.168.1.{random.randint(2, 254)}": Génère une nouvelle adresse IP dans le sous-réseau spécifié.
• ni.ifaddresses(interface)[ni.AF_INET][0]['addr'] = new_ip: Applique la nouvelle adresse IP à l'interface.
• Gestion des erreurs pour capturer et afficher les exceptions qui pourraient survenir pendant l'exécution des commandes.