SHGenOB : Générateur de shellcode à partir de code C PIC

Introduction

SHGenOB est un outil basé sur Python conçu pour générer du shellcode à partir de code indépendant de la position (PIC) écrit en C. Il automatise le processus de compilation du code C, l'extraction de la section .text et, éventuellement, le chiffrement du shellcode résultant à l'aide d'un chiffrement XOR.

Ce projet est entièrement basé sur ce document de hasherezade.

Code indépendant de la position (PIC)

Note importante pour les utilisateurs de SHGenOB : Pour que cet outil de génération de shellcode fonctionne correctement, le code C du fichier d'entrée doit être écrit en tant que code indépendant de la position (PIC). L'outil suppose que le code fourni respecte les principes et caractéristiques du PIC décrits ci-dessous.

Le code indépendant de la position (PIC) est un type de code machine qui peut être exécuté indépendamment de son adresse mémoire absolue. Cette caractéristique rend le PIC particulièrement utile pour créer du shellcode, des bibliothèques partagées et certains types de logiciels malveillants. Les principales caractéristiques du PIC sont les suivantes :

• Indépendance d'adresse : Le PIC peut s'exécuter correctement quel que soit l'endroit où il est chargé en mémoire.
• Aucune référence mémoire fixe : Il évite d'utiliser des adresses absolues, s'appuyant plutôt sur l'adressage relatif ou d'autres techniques pour référencer les emplacements mémoire.
• Autonome : Le PIC inclut généralement toutes les données nécessaires dans le code lui-même, réduisant ainsi les dépendances externes.
• Chaînes sur la pile : Déclarer des chaînes comme des tableaux de caractères force le compilateur à les placer sur la pile et non dans la section .data ou .pdata du fichier PE.
• Sans relocation : Il ne nécessite pas que le chargeur effectue des relocations, ce qui accélère son chargement et son exécution.
• Taille réduite : Le PIC donne souvent des binaires plus petits que le code dépendant de la position.
• Adressage relatif aux registres : Il utilise fréquemment l'adressage relatif aux registres pour accéder aux données et effectuer des sauts.
• Utilisation d'offsets : Au lieu d'adresses absolues, le PIC utilise des offsets à partir du pointeur d'instruction courant.
• Techniques spécifiques à la plateforme : Différentes architectures de CPU peuvent nécessiter différentes techniques pour atteindre l'indépendance de position.

Le PIC est essentiel dans les scénarios où l'adresse de chargement exacte du code n'est pas connue à l'avance, ce qui en fait un concept crucial dans le développement de shellcode et dans certains domaines de la programmation système. Lorsque vous utilisez SHGenOB, assurez-vous que votre code C d'entrée suit ces principes PIC afin de générer un shellcode efficace et fiable.

Fonctionnalités

• Compile le code C PIC à l'aide des outils Microsoft Visual Studio
• Extrait la section .text de l'exécutable compilé
• Chiffre éventuellement le shellcode à l'aide d'un chiffrement XOR
• Insère le shellcode généré dans un modèle de chargeur (loader)
• Compile et teste le chargeur avec le shellcode généré
• Prend en charge le mode débogage pour l'inspection des fichiers intermédiaires
• Nettoie les fichiers intermédiaires après une exécution réussie

Prérequis

• Système d'exploitation Windows
• Python 3.6 ou version ultérieure
• Microsoft Visual Studio 2022 Community Edition (ou version compatible)
• Les paquets Python suivants :
  • pefile
  • argparse
• Un compilateur C (cl.exe) et un assembleur (ml64.exe) de Visual Studio
• Le fichier vcvars64.bat de Visual Studio (pour configurer l'environnement de compilation)

Installation

1. Installez Python 3.6 ou une version ultérieure depuis python.org
2. Installez Microsoft Visual Studio 2022 Community Edition
3. Installez les paquets Python requis :

pip install pefile argparse

4. Clonez ou téléchargez ce dépôt sur votre machine locale

Utilisation

Exécutez le script à partir de la ligne de commande avec la syntaxe suivante :

python shgenob.py --code-file <chemin_vers_fichier_c> [--masm-file <chemin_vers_fichier_masm>] [--debug] [--xor-key <clé>]

Arguments :

• --code-file ou -cf : (Obligatoire) Chemin vers le fichier main.c contenant le code PIC
• --masm-file ou -mf : (Facultatif) Chemin vers un fichier .masm externe pour inclure une logique assembleur supplémentaire dans le shellcode
• --debug ou -d : (Facultatif) Active le mode débogage (ignore le nettoyage des fichiers intermédiaires)
• --xor-key ou -xk : (Facultatif) Clé XOR pour chiffrer le shellcode (format : AA,BB,CC)

Exemples :

# Utilisation de base
python shgenob.py --code-file main.c

# Avec un fichier MASM externe
python shgenob.py --code-file main.c --masm-file custom_logic.masm

# Avec toutes les options
python shgenob.py --code-file main.c --masm-file custom_logic.masm --debug --xor-key AA,BB,CC

Descriptions des fonctions

1. save_to_file(content, filename) : Enregistre le contenu donné dans un fichier du répertoire courant
2. cleanup() : Supprime les fichiers intermédiaires (.asm, .exe, .obj, .lnk) du répertoire courant
3. xor_encrypt(shellcode, key) : Chiffre le shellcode à l'aide d'un XOR avec la clé fournie
4. insert_shellcode_into_loader(formatted_shellcode, loader_file) : Insère le shellcode dans le modèle de chargeur
5. extract_text_section(file_path, key) : Extrait la section .text d'un fichier PE et la chiffre éventuellement
6. find_file(root_dir, file_name) : Recherche un fichier dans le répertoire donné et ses sous-répertoires
7. run_command_with_vcvars(command, vcvars_path) : Exécute une commande avec les variables d'environnement Visual Studio définies
8. compile_cpp_file(cpp_file, vcvars_path, output_exe) : Compile un fichier C++ à l'aide du compilateur Visual Studio
9. modify_asm_file(asm_file) : Modifie le fichier assembleur généré pour la compatibilité du shellcode
10. main(cpp_file, args) : Fonction principale qui orchestre le processus de génération du shellcode

Flux de travail

1. Analyser les arguments de la ligne de commande
2. Localiser les outils Visual Studio (vcvars64.bat, cl.exe, ml64.exe)
3. Compiler le fichier C d'entrée en assembleur
4. Modifier le fichier assembleur généré
5. Assembler le fichier assembleur modifié
6. Extraire la section .text de l'exécutable résultant
7. Chiffrer éventuellement le shellcode extrait
8. Enregistrer le shellcode dans un fichier
9. Insérer le shellcode dans un modèle de chargeur
10. Compiler le chargeur
11. Tester le chargeur avec le shellcode généré
12. Nettoyer les fichiers intermédiaires (sauf en mode débogage)

Débogage

Utilisez l'indicateur --debug pour ignorer le processus de nettoyage et inspecter les fichiers intermédiaires. Cela est utile pour résoudre les problèmes et comprendre le processus de génération du shellcode.

Considérations de sécurité

• Cet outil est destiné uniquement à des fins éducatives et de tests autorisés
• Le shellcode généré peut être signalé par les logiciels antivirus
• Utilisez le chiffrement (clé XOR) pour obscurcir le shellcode, mais notez qu'il s'agit d'une forme d'obscurcissement de base
• Assurez-vous d'avoir l'autorisation d'utiliser cet outil sur les systèmes cibles

Limites

• Ne prend actuellement en charge que Windows et la chaîne d'outils Microsoft Visual Studio
• Gestion limitée des erreurs pour certains cas particuliers
• Le chiffrement XOR est une forme d'obscurcissement de base et peut ne pas suffire pour tous les cas d'utilisation

Contribution

Les contributions visant à améliorer SHGenOB sont les bienvenues. Veuillez suivre ces étapes :

1. Forkez le dépôt
2. Créez une nouvelle branche pour votre fonctionnalité
3. Commitez vos modifications
4. Poussez vers la branche
5. Créez une nouvelle pull request