Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2024-38077-MadLicense-exploit — Framework d'exploitation modulaire pour CVE-2024-38077 (débordement de tas RDL Windows) avec contournement d'ASLR, préparation du tas, génération de chaînes ROP et charges utiles d'injection DLL pour l'exécution de code à distance sans authentification préalable. | Kitploit
Outils/GitHubGitHub/ermensonx/cve-2024-38077-madlicense-exploit
Frameworks d'ExploitationAnalyse des VulnérabilitésExploitationRétro-ingénierieShellcodeTests d'IntrusionApprentissage et ÉducationDéveloppement de Charges UtilesExploitation de Binaires
GitHubermensonx/cve-2024-38077-madlicense-exploit

CVE-2024-38077-MadLicense-exploit

Framework d'exploitation modulaire pour CVE-2024-38077 (débordement de tas RDL Windows) avec contournement d'ASLR, préparation du tas, génération de chaînes ROP et charges utiles d'injection DLL pour l'exécution de code à distance sans authentification préalable.

Voir le dépôt
162il y a 11 moisPas encore vérifié
Partager

CVE-2024-38077 MadLicense - Framework d'Exploitation Complet

📚 Documentation Technique pour Présentation

Ce document explique chaque composant du framework, pourquoi il existe, et comment fonctionne l'exploitation du heap buffer overflow sur Windows moderne.


🎯 Qu'est-ce que CVE-2024-38077 ?

La Vulnérabilité

Le service Windows Remote Desktop Licensing (lserver.exe) contient un heap buffer overflow dans la fonction CDataCoding::DecodeData.

┌─────────────────────────────────────────────────────────────┐
│  VULNERABILIDADE: Cálculo incorreto de tamanho             │
├─────────────────────────────────────────────────────────────┤
│  1. Cliente envia dados Base64 de tamanho N                │
│  2. Servidor calcula: buffer_size = (N / 4) * 3            │
│  3. Servidor aloca buffer de 'buffer_size' bytes           │
│  4. Decode Base64 REALMENTE escreve: ceil(N * 3/4) bytes   │
│  5. Se N não é múltiplo de 4: OVERFLOW!                    │
└─────────────────────────────────────────────────────────────┘

Exemple concret :

  • Entrée : 4001 octets
  • Calcul serveur : (4001 / 4) * 3 = 1000 * 3 = 3000 octets alloués
  • Décodage réel : ceil(4001 * 0.75) = 3001 octets écrits
  • Overflow : 1 octet (mais contrôlable pour en avoir plus)

Pourquoi Est-Ce Critique ?

  1. Pre-Auth : Aucune information d'identification requise
  2. Distant : Via réseau, port 135 (RPC)
  3. SYSTEM : Le service s'exécute en tant que NT AUTHORITY\SYSTEM
  4. Courant : Windows Server 2000-2025 affectés

🏗️ Architecture du Framework

Vue d'Ensemble des Modules

┌─────────────────────────────────────────────────────────────────┐
│                      EXPLOIT CHAIN                              │
├──────────┬──────────┬──────────┬──────────┬──────────┬─────────┤
│  LEAK    │  MODEL   │  WRITE   │  GROOM   │ TRIGGER  │ EXECUTE │
│ (ASLR)   │ (Target) │ (Where)  │ (Heap)   │ (Use)    │ (RCE)   │
├──────────┼──────────┼──────────┼──────────┼──────────┼─────────┤
│ leak.py  │target_   │write_    │heap_     │trigger   │code_    │
│          │model.py  │primitive │controller│.py       │reuse.py │
│          │          │.py       │.py       │          │         │
└──────────┴──────────┴──────────┴──────────┴──────────┴─────────┘
          ↓                                              ↓
    ┌───────────┐                              ┌──────────────┐
    │ execution │                              │   payload    │
    │   .py     │                              │     .py      │
    └───────────┘                              └──────────────┘
          ↓                                              ↓
    ┌───────────────────────────────────────────────────────────┐
    │                    mitigations.py                         │
    │              (DEP, ASLR, CFG awareness)                   │
    └───────────────────────────────────────────────────────────┘
                              ↓
    ┌───────────────────────────────────────────────────────────┐
    │                      exploit.py                           │
    │                   (Orchestrator)                          │
    └───────────────────────────────────────────────────────────┘

📦 Module 1 : primitives.py - Fondation

Qu'est-ce que c'est ?

Utilitaires de bas niveau pour la manipulation de la mémoire.

Pourquoi Existe-t-Il ?

Les exploits ont besoin de :

  • Convertir entre types (int ↔ bytes)
  • Générer des motifs pour l'analyse de crash
  • Aligner correctement les données

Fonctions Principales

# Pack/Unpack - Converter inteiros para bytes e vice-versa
p64(0xDEADBEEF)      # → b'\xef\xbe\xad\xde\x00\x00\x00\x00'
p32(0x41414141)      # → b'AAAA'
u64(b'\x41\x42...')  # → 0x... (int)

# Padrão Cíclico - Para identificar offset de crash
cyclic(100)          # Gera sequência De Bruijn
cyclic_find(pattern, value)  # Encontra offset do valor

# Alinhamento - Memória precisa estar alinhada
align(0x1003, 0x10)  # → 0x1010 (alinha para 16 bytes)

Pourquoi C'Est Important ?

Problème réel : Vous provoquez un crash et le RIP contient 0x61616171.

  • Sans cyclic : « Quelque part dans mon buffer... »
  • Avec cyclic : cyclic_find(pattern, 0x61616171) → offset exact !

📦 Module 2 : leak.py - Bypass d'ASLR

Qu'est-ce que l'ASLR ?

Address Space Layout Randomization : À chaque démarrage/exécution, les adresses changent.

Boot 1:  ntdll.dll @ 0x7FFA12340000
Boot 2:  ntdll.dll @ 0x7FFB98760000
Boot 3:  ntdll.dll @ 0x7FFC55550000

Pourquoi Avons-Nous Besoin d'un Leak ?

Sans savoir où se trouve la mémoire :

  • Nous ne savons pas où placer le payload
  • Nous ne connaissons pas l'adresse des gadgets ROP
  • Toute tentative = crash aléatoire

Structure du Module

class LeakInfo:
    """Container para endereços vazados"""
    heap_base: int         # Base do heap
    ntdll_base: int        # Base do ntdll.dll
    kernel32_base: int     # Base do kernel32.dll
    # ...

class LeakProvider:
    """Orquestrador de fontes de leak"""
    sources: List[LeakSource]
    
    def obtain() -> LeakInfo:
        # Tenta cada fonte até conseguir

Sources de Leak Implémentées

SourceComment Ça FonctionneQuand l'Utiliser
ManualLeakSourceL'utilisateur fournit les adressesLab/Debug avec accès à la cible
ResponseLeakSourceExtrait des réponses RPCSi le service fuit des pointeurs
TimingLeakSourceSide-channel temporelThéorique, très difficile

Pourquoi une Entrée Manuelle ?

Lors de démonstrations/labs, vous pouvez :

  1. Attacher un debugger à la cible
  2. Voir la base des modules
  3. Fournir via --ntdll-base 0x7ffa...

Cela simule un leak réel, permettant de tester le reste de la chaîne.


📦 Module 3 : target_model.py - Mappage de la Cible

Qu'est-ce que c'est ?

Modélisation des structures de données vulnérables et adjacentes.

Pourquoi Existe-t-Il ?

Overflow ≠ Exploitation. Nous devons savoir :

  • Qu'est-ce que nous écrasons ?
  • Quelle est la taille de l'objet ?
  • Quel champ est utile à corrompre ?

Composants

class VulnerableBuffer:
    """O buffer que vai sofrer overflow"""
    allocation_size: int   # Quanto foi alocado
    write_size: int        # Quanto será escrito
    overflow_amount: int   # Diferença = overflow
    
    def calculate_overflow(input_size):
        # Simula o bug de cálculo
        alloc = (input_size // 4) * 3
        actual = ((input_size + 3) // 4) * 3
        return alloc, actual, actual - alloc

class AdjacentObject:
    """Objeto que será corrompido (adjacente no heap)"""
    fields: List[StructField]
    has_vtable: bool       # Tem tabela virtual?
    has_function_ptr: bool # Tem ponteiro de função?

Exemple de Structure Cible

# Objeto hipotético baseado em análise reversa
license_req = AdjacentObject(
    name="CLicenseRequest",
    typical_size=0x100,
    has_vtable=True
)

# Campos mapeados
license_req.add_field("vtable",   0x00, 8, VTABLE,   is_target=True)
license_req.add_field("refcount", 0x08, 4, REFCOUNT)
license_req.add_field("callback", 0x10, 8, CALLBACK, is_target=True)

Pourquoi is_target=True ?

Marque les champs utiles pour l'exploitation :

  • vtable : Si nous l'écrasons, nous contrôlons les appels de méthode
  • callback : Si nous l'écrasons, nous contrôlons quand le callback est appelé

📦 Module 4 : write_primitive.py - Écriture Contrôlée

Le Problème

L'overflow écrit des données séquentielles. Mais nous avons besoin de :

  • Écrire une valeur spécifique (adresse de notre ROP)
  • À un offset spécifique (où se trouve le pointeur vtable)

La Solution

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    696
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    499
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    396
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    340
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    258
  • 6

    antifox

    antifox-ai/antifox

    Plateforme de test d'intrusion autonome multi-agents par IA qui exécute la reconnaissance, la découverte de la surface d'attaque, la validation de l'exploitation et la livraison de rapports étayés par des preuves.

    257

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →