English

A5/1 — Chiffrement GSM

A5/1 est l’algorithme de chiffrement à flot utilisé dans le GSM pour assurer la confidentialité des communications radio entre le mobile et la station de base (BTS).

Principe de fonctionnement

  • Chiffrement à flot avec un état interne de 64 bits (3 registres à décalage LFSR)

  • Initialisé avec la clé Kc (calculée à partir de la Ki de la SIM via l’algorithme A3/A8 et l’IMSI de l’abonné)

  • Le chiffrement s’applique en temps réel, bit par bit, sur la voix ou les données

Vulnérabilités

  • Conception ancienne (années 1980/1990)

  • Plusieurs attaques connues :

    • Tables arc-en-ciel (time-memory tradeoff, ex : Kraken/projet A5/1)

    • Attaques sur les faiblesses des LFSR et synchronisation des registres

    • Récupération de Kc si suffisamment de keystream est capturé

Outils open source

  • Kraken

  • gr-gsm + Airprobe

  • OsmocomBB : possible d’injecter ou d’extraire des keystreams pour attaques bruteforce

Détection & tests

  • Si la cellule envoie un « Ciphering Indicator », certains téléphones préviennent quand le chiffrement est désactivé

  • La plupart des réseaux modernes désactivent l’A5/1, passent en A5/3 ou désactivent complètement le chiffrement

Pour aller plus loin

Note légale :
Toute attaque ou rétro-ingénierie d’A5/1 est réservée à la recherche, au pentesting autorisé, ou à la démonstration légale.
L’interception non autorisée est illégale dans la plupart des pays.

  • Kraken : outil de déchiffrement bruteforce A5/1 (GSM) via tables arc-en-ciel (rainbow tables).

  • behemoth.py : script Python (non officiel, communautaire) pour automatiser et paralléliser l’attaque Kraken, notamment sur de grandes infrastructures (ex : cluster, GPU, ou tâches batch).

Kraken — Rainbow Tables pour A5/1

Kraken est un outil open-source qui permet de casser le chiffrement A5/1 utilisé dans le GSM (2G) en utilisant la technique des tables arc-en-ciel (“rainbow tables”).

  • But : Trouver la clé Kc à partir d’un extrait connu de flux chiffré (“known plaintext”).

  • Principe :

    1. On enregistre des bursts A5/1 (ex : via OsmocomBB ou Airprobe).

    2. Si l’on connaît une partie du message clair correspondant, on extrait le keystream chiffré.

    3. On lance Kraken : il compare ce keystream avec ses tables (des téraoctets de pré-calcul), et peut retrouver la clé en quelques secondes/minutes… si le keystream se trouve dans les tables.

    4. Avec la clé Kc, on peut déchiffrer tous les échanges chiffrés de la session GSM (voix, SMS, etc).

  • Limites :

    • Il faut un keystream de bonne qualité (souvent 64 bits sans erreurs).

    • Les tables ne couvrent pas tout l’espace (proba de réussite ~22–24% par table, jusqu’à ~50–60% avec plusieurs tables).

    • Sensible à la moindre erreur de réception radio.

Kraken fonctionne généralement en ligne de commande avec un fichier binaire de keystream (ex : .kc), et pointe vers un dossier de tables rainbow (fichiers .bin de plusieurs Go à To).

behemoth.py — Orchestrateur Python pour Kraken

behemoth.py est un wrapper Python pour faciliter, automatiser et paralléliser l’utilisation de Kraken sur de grandes quantités de keystream, de tables, ou sur des architectures multi-core/GPU/cluster.

  • Fonctions typiques :

    • Diviser le keystream en blocs, lancer plusieurs instances Kraken en parallèle.

    • Gérer la distribution de tâches sur plusieurs machines ou cœurs.

    • Faire de la “batch processing” (attaque automatisée sur beaucoup de captures, ou avec de multiples tables).

    • Logger, relancer, gérer les timeouts, agréger les résultats.

    • Support d’infrastructures type cluster/Cloud (ex : orchestrer du Kraken sur 8–16 machines ou plus).

  • Avantage :

    • Tu gagnes en vitesse (attaque massive, multi-thread, scalable).

    • Tu peux “industrialiser” le process (pipeline, logs, monitoring).

Remarque : behemoth.py n’est pas un projet “officiel” de Kraken, mais une surcouche communautaire, souvent adaptée à l’infrastructure ou au workflow de chaque équipe de recherche ou CTF.

Résumé — Usage terrain

  • Kraken = brute-force A5/1 sur 2G, avec rainbow tables (~8 To pour full coverage), single machine.

  • behemoth.py = pipeline Python qui orchestre de nombreux Kraken en //, sur batch de captures ou cluster, pour industrialiser la récupération de clés Kc.

Liens utiles

  1. Préparer le système

  2. Installer Kraken

  3. Télécharger/installer les rainbow tables

  4. Installer behemoth.py

  5. Exemple d’utilisation (simple + batch/cluster)

Tuto Kraken + behemoth.py (Ubuntu 22.04/24.04)

1. Préparer le système

sudo apt update
sudo apt install -y git build-essential cmake python3 python3-pip \
    libgmp-dev

2. Installer Kraken

a) Récupérer le repo

git clone https://github.com/JPaulMora/kraken.git
cd kraken

b) Compiler

make

Tu obtiens l’exécutable kraken dans le dossier.

3. Installer ou télécharger les Rainbow Tables

  • Attention : Les tables font plusieurs To (ex : tables sur le forum SRLabs).

  • Décompresse tout dans un dossier, exemple : /mnt/kraken_tables/

4. Installer behemoth.py

a) Télécharger le script

cd ~
git clone https://github.com/JPaulMora/behemoth.git
cd behemoth
pip3 install -r requirements.txt  # (si besoin)

b) Vérifie la config

  • Le script fonctionne avec Python 3.

  • Adapte les chemins vers :

    • L’exécutable kraken

    • Le dossier des tables

    • Tes fichiers kc (keystream à casser)

5. Utiliser Kraken (manuel et avec behemoth.py)

A. Utilisation simple de Kraken

  1. Tu dois avoir extrait un keystream (“.kc”) à partir d’une attaque A5/1 (via OsmocomBB/airprobe, etc).

    • Par ex: my_capture.kc contient 64 bits extraits sans erreur.

  2. Lancer Kraken

    ./kraken my_capture.kc /mnt/kraken_tables/

    • Il affiche la clé trouvée (ou rien si miss).

B. Utiliser behemoth.py pour des batchs (mode pipeline/parallèle)

Exemple minimal :

python3 behemoth.py -k /chemin/kraken -t /mnt/kraken_tables/ -i dossier_kc/ -j 8

  • -k : chemin vers exécutable kraken

  • -t : dossier rainbow tables

  • -i : dossier contenant plusieurs .kc (batch)

  • -j : nombre de jobs/threads (ex : 8 = 8 CPU en //)

  • Résultat : toutes les clés Kc trouvées sont loguées/fichiers.

Pour cluster/machines multiples

  • Il existe des modes --slave/--master pour dispatcher sur plusieurs nodes (voir README du repo).

6. Schéma résumé

(signal GSM) → extraction keystream (.kc) → Kraken (ou behemoth.py)
                                       ↳ tables rainbow
                                       ↳ clé Kc

Notes / Bonnes pratiques

  • La qualité du keystream est CRUCIALE (aucune erreur de bit !)

  • Plus tu as de tables, plus tu as de chances (sinon succès partiel).

  • behemoth.py = batch/cluster, Kraken = solo.

  • Sur SSD/NVMe = +rapide.

##Liens utiles

Installation Deka (cracker Kraken OpenCL)

1. Prérequis

  • OS : Debian Jessie à Bookworm, ou Ubuntu

  • GPU : AMD recommandé (Nvidia possible mais demande plus de patchs)

  • Python 3 (certains scripts nécessitent aussi 2.7)

  • PyOpenCL

  • Disque : ≥2 To libres pour les tables (SSD/NVMe conseillé)

  • Paquets :

sudo apt update
sudo apt install git build-essential python3-pip python3-dev ocl-icd-libopencl1 opencl-headers clinfo
pip3 install pyopencl

2. Cloner le code

Fork recommandé (patché pour systèmes récents) :

git clone https://github.com/0x7678/typhon-vx.git
cd typhon-vx/kraken

(Pour comparer avec les originaux, pas obligatoire) :

git clone http://jenda.hrach.eu/p/deka
git clone git://git.srlabs.de/kraken

3. Télécharger les tables Rainbow

Stocke les tables sur un disque dédié, idéalement en ext4/xfs, ou écris-les directement sur un device bloc pour les meilleures perfs.

4. Installer les tables

Option 1 – Mode fichier (le plus simple, moins performant) :

./TableConvert di /mnt/tables/gsm/100.dlt 100.ins:0 100.idx

  • /mnt/tables/gsm/100.dlt : fichier table source

  • 100.ins:0 : fichier destination (avec offset)

  • 100.idx : fichier index destination

Option 2 – Direct sur device bloc (meilleures performances) :

  • Utilise install.py pour écrire les tables directement sur un device brut (triple-vérifie le chemin du device !)

5. Configurer Deka

Édite delta_config.h :

  • Indique les bons chemins pour les tables, fichiers d’index et offsets (issus de ton tables.conf généré)

  • ASTUCE : utilise /dev/disk/by-uuid/ ou des chemins absolus — jamais /dev/sdX car l’ordre des devices peut changer au reboot !

#define TABLE_DEV "/dev/disk/by-uuid/XXXX-YYYY"
#define TABLE_IDX "/mnt/tables/gsm/100.idx"
#define TABLE_OFF 0

6. Générer le kernel OpenCL

  • AMD : utiliser genkernel32.sh (recommandé)

  • Nvidia : il faudra peut-être patcher “unsigned long long” → “ulong”

  • 32 ou 64 bits : génère un slice.c spécifique (ajuster aussi vankusconf.h/vankusconf.py si passage en 64 bits)

./genkernel32.sh > slice.c
# ou
./genkernel64.sh > slice.c

Si tu obtiens une erreur “unsigned long long”, remplace dans le code par :

ulong one = 1;
mask |= one << i;
ulong all = 0xFFFFFFFFFFFFFFFF;
if(diff != all) { ... }

7. Tuning kernel (vankusconf.py/.h)

  • Kernels concurrents : (nombre de cores GPU - 1) × petit entier. Exemple : 4095 pour 2048 cores GPU.

  • QSIZE : Environ 2× le nombre de fragments traités en parallèle.

8. Lancer Deka / Kraken

Démarrage manuel (conseillé pour debug/début) :

python3 paplon.py
python3 oclvankus.py   # (une fois par device OpenCL ; demande le numéro)
python3 delta_client.py

Automatique (prod) :

./init.sh

PYOPENCL_CTX : Pour éviter la question du device :

export PYOPENCL_CTX="0:0"

9. Connexion & test de crack

Connexion au serveur Deka (paplon) :

telnet localhost 1578

Test avec un burst A5/1 connu :

crack 00111000...   # (colle un burst connu)
# Output attendu :
# Found 44D85D82BAF275B4 @ 2 #0 (table:412)

10. Monitoring & tuning perfs

Dans telnet, tape stats pour vérifier la taille des files d’attente.

  • Si goulot = stockage : passe en SSD/NVMe, device direct, ou async IO.

  • Si goulot = calcul : tune kernel (loop unrolling, itérations, kernels concurrents, etc.)

Récapitulatif express

# 1. Dépendances
sudo apt install git build-essential python3-pip ocl-icd-libopencl1 opencl-headers clinfo
pip3 install pyopencl

# 2. Cloner le code
git clone https://github.com/0x7678/typhon-vx.git
cd typhon-vx/kraken

# 3. Télécharger les tables (~1,7To)

# 4. Installer les tables (TableConvert ou install.py)

# 5. Éditer delta_config.h (chemins absolus/UUID)

# 6. Générer kernel : ./genkernel32.sh > slice.c

# 7. Lancer : paplon.py, oclvankus.py, delta_client.py

# 8. Connexion : telnet localhost 1578, commande "crack"

# 9. Tune (stats, kernel, stockage)

Notes & Astuces

  • Évite de lancer en root sauf nécessité (accès device brut)

  • Scripts et kernels adaptables à volonté (fragments, tuning, debug)

  • Pour le support ou l’optimisation, voir Issues Github, forums SRLabs, brmlab, Discords GSM