Hackwarium

Les courbes elliptiques en cybersécurité et pentesting

Publié le 17 février 2025 par mzr

Introduction

Les courbes elliptiques sont devenues incontournables en cryptographie moderne, offrant un compromis idéal entre sécurité et performance. Leur capacité à fournir un haut niveau de sécurité avec des clés de petite taille en fait un outil privilégié en cybersécurité et lors d'analyses de pentesting.

Fondamentaux mathématiques

Une courbe elliptique sur le corps des réels est généralement définie par l'équation de Weierstrass :

$$ y^2 = x^3 + ax + b $$

Pour éviter les singularités, le discriminant doit être non nul :

$$ \Delta = 4a^3 + 27b^2 \neq 0 $$

L'ensemble des points sur la courbe, avec un point à l'infini, forme un groupe abélien dont la loi d'addition est essentielle en cryptographie.

Loi d'addition des points

Pour deux points distincts \(P = (x_1, y_1)\) et \(Q = (x_2, y_2)\) sur la courbe, la pente \(m\) se calcule par :

$$ m = \frac{y_2 - y_1}{x_2 - x_1} $$

Les coordonnées du point \(R = P + Q = (x_3, y_3)\) résultent de :

$$ x_3 = m^2 - x_1 - x_2 $$

$$ y_3 = m(x_1 - x_3) - y_1 $$

Pour le doublement d'un point \(P\) (c'est-à-dire \(P = Q\)), la pente se calcule ainsi :

$$ m = \frac{3x_1^2 + a}{2y_1} $$

Représentation graphique

La représentation graphique d'une courbe elliptique aide à visualiser sa structure. Par exemple, la courbe :

$$ y^2 = x^3 + ax + b $$

peut être représentée graphiquement comme ci-dessous :

Graphique d'une courbe elliptique
Représentation de la courbe \( y^2 = x^3 - x + 1 \)

Utilisation en cybersécurité

La cryptographie à courbes elliptiques (ECC) offre plusieurs avantages :

  • Clés de petite taille : Une clé ECC de 256 bits offre une sécurité équivalente à une clé RSA de 3072 bits.
  • Efficacité : Les opérations ECC requièrent moins de ressources, idéal pour des environnements contraints.
  • Sécurité robuste : Le problème du logarithme discret sur les courbes elliptiques (ECDLP) est difficile à résoudre.

Implications en pentesting

Pour les professionnels du pentesting, l'analyse des implémentations ECC est cruciale afin de détecter d'éventuelles vulnérabilités. Voici quelques points à vérifier :

  1. Validation des paramètres : S'assurer que \(a\) et \(b\) respectent les standards et que le discriminant est bien vérifié.
  2. Contrôle des points : Vérifier que les points reçus lors des échanges appartiennent bien à la courbe pour éviter des attaques par "invalid curve".
  3. Génération aléatoire : Une mauvaise implémentation peut compromettre la sécurité des clés privées.

Exemple de code d'audit en Python


def is_on_curve(x, y, a, b):
    # Vérifie si y² = x³ + ax + b
    return y**2 == x**3 + a*x + b

# Exemple pour la courbe: y² = x³ - x + 1
a = -1
b = 1
x, y = 2, 3

if is_on_curve(x, y, a, b):
    print("Le point est sur la courbe")
else:
    print("Le point n'est pas sur la courbe")
          

Approfondissements et recherches avancées

La robustesse de l'ECC repose sur la difficulté du problème du logarithme discret sur courbes elliptiques (ECDLP). Pour un point \(P\) et un entier \(k\), le calcul du point \(Q = kP\) est rapide, mais retrouver \(k\) à partir de \(P\) et \(Q\) reste un problème complexe :

Q = kP

Utilisation de l'assembleur dans le hacking

Publié le 19 février 2025 par mzr

Utilisation de l'assembleur dans le hacking : Une exploration détaillée

L'assembleur est l'un des outils les plus puissants pour comprendre et manipuler les opérations logicielles au niveau bas. Les hackers utilisent l'assembleur pour décomposer et exploiter des vulnérabilités au niveau matériel et système d'exploitation. Dans cet article, nous allons explorer comment l'assembleur est utilisé dans le hacking, son importance dans l'ingénierie inverse, et comment il peut aider à exploiter des vulnérabilités dans les systèmes modernes.

Qu'est-ce que l'assembleur et pourquoi est-il important dans le hacking ?

L'assembleur est un langage de programmation bas niveau qui est étroitement lié au code machine. Il offre une abstraction des instructions binaires qu'un processeur peut exécuter. Les hackers utilisent l'assembleur parce qu'il leur permet de manipuler les programmes à un niveau granulaire, ce qui est crucial pour l'ingénierie inverse et l'exploitation des vulnérabilités.

L'assembleur est particulièrement utile dans le contexte du hacking car il permet d'accéder aux instructions brutes d'un programme. En comprenant l'assembleur, les hackers peuvent manipuler le comportement des programmes de manière que les langages de niveau supérieur ne peuvent pas facilement réaliser.

L'assembleur et l'ingénierie inverse

L'une des applications les plus courantes de l'assembleur dans le hacking est l'ingénierie inverse. Les hackers utilisent l'assembleur pour analyser des exécutables, comprendre leur fonctionnement interne et identifier des vulnérabilités ou des portes dérobées.

Les programmes compilés en code machine sont difficiles à analyser sans revenir à une représentation lisible. Grâce à l'assembleur, un hacker peut examiner le code binaire à un niveau plus compréhensible, détectant ainsi des failles telles que les débordements de tampon, les injections de code, ou d'autres vulnérabilités.

Exploitation des vulnérabilités avec l'assembleur

Une fois que l'assembleur est utilisé pour identifier une vulnérabilité, les hackers peuvent l'exploiter. Par exemple, lors d'une attaque de type "buffer overflow", l'assembleur peut être utilisé pour écrire un shellcode — un petit morceau de code malveillant qui peut être injecté dans un programme pour prendre le contrôle du système.

Les hackers utilisent souvent l'assembleur pour modifier le flux d'exécution d'un programme, altérer des variables ou manipuler des registres afin d'atteindre leurs objectifs malveillants. Cela peut aller de l'exécution d'un code arbitraire à l'escalade de privilèges sur un système vulnérable.

Exemples d'utilisation de l'assembleur dans le hacking

Voici quelques exemples où l'assembleur a été utilisé dans des attaques réelles :

  • Exploitation de vulnérabilités de type "Return Oriented Programming" (ROP) : Les hackers peuvent utiliser l'assembleur pour manipuler des segments de code déjà présents dans un programme, en réutilisant des "gadgets" existants pour contourner les protections comme la randomisation de l'espace d'adressage (ASLR).
  • Création de shellcodes : L'assembleur est essentiel pour la création de shellcodes, qui sont des codes malveillants utilisés dans les attaques de débordement de tampon pour exécuter des commandes arbitraires sur une machine vulnérable.
  • Injections de code dans des processus en cours d'exécution : En analysant le code binaire d'une application, un hacker peut injecter son propre code dans un processus en cours d'exécution, ce qui permet d'exécuter des actions non autorisées sans que le système ne le détecte facilement.

Outils utilisés pour travailler avec l'assembleur dans le hacking

Les hackers utilisent plusieurs outils pour travailler avec l'assembleur. Parmi les plus populaires, on trouve :

  • GDB (GNU Debugger) : Un débogueur utilisé pour examiner le code machine, modifier l'exécution d'un programme et comprendre le comportement du programme au niveau binaire.
  • OllyDbg : Un débogueur pour les programmes Windows, qui permet aux hackers d'analyser le code binaire à un niveau plus accessible et de manipuler l'exécution de manière dynamique.
  • IDA Pro : Un désassembleur interactif utilisé pour convertir le code machine en code assembleur lisible. Il est couramment utilisé dans l'ingénierie inverse et l'analyse de logiciels malveillants.

Programme simple assembleur

Voici un tutoriel simple pour vous familiariser avec l'assembleur. Nous allons créer un programme simple qui affiche du texte dans la sortie standard, en utilisant l'assembleur NASM.

1. Installer NASM

Installez NASM avec la commande suivante :

sudo apt install nasm

2. Créer un fichier source

Créez un fichier source hello.asm contenant le code suivant :

section .data
    hello db 'Hello, world!',0

section .text
    global _start

_start:
    ; écriture du message à l'écran
    mov eax, 4         ; code système pour 'write'
    mov ebx, 1         ; fichier de sortie (1 = STDOUT)
    mov ecx, hello     ; message à afficher
    mov edx, 13        ; longueur du message
    int 0x80           ; appel système

    ; quitter le programme
    mov eax, 1         ; code système pour 'exit'
    xor ebx, ebx       ; code de sortie (0)
    int 0x80           ; appel système
            

3. Assembler et lier le programme

Utilisez NASM pour assembler le fichier source en un fichier binaire :

nasm -f elf32 hello.asm

Ensuite, liez-le avec ld :

ld -m elf_i386 -s -o hello hello.o

4. Exécuter le programme

Maintenant, exécutez votre programme avec :

./hello

Vous devriez voir "Hello, world!" s'afficher à l'écran.