rustdllproxy

Installation

cargo install rustdllproxy

Compatibilité

Cette crate ne prend actuellement en charge que le format PE DLL standard.

Limitations actuelles

• Lors du hooking de fonctions avec du code personnalisé, la signature de la fonction doit être connue
  • Cela peut être trouvé à l'aide de désassembleurs et d'outils de rétro-ingénierie comme Ghidra

Commandes

Rustdllproxy est fourni avec deux sous-commandes :

rustdllproxy --help        # aide générale
rustdllproxy new --help    # options de génération
rustdllproxy build --help  # options de compilation

Créer une nouvelle crate

Note rapide sur la stratégie

Avant de générer votre crate, décidez comment vous souhaitez que votre proxy fonctionne. Un motif typique est le détournement de l'ordre de recherche (search order hijacking), où vous commencez par renommer votre DLL cible en quelque chose comme target_.dll, puis utilisez le proxy compilé en tant que target.dll. Cela crée un flux ressemblant à binary -> target.dll -> target_.dll

Plusieurs approches sont possibles selon votre cas d'utilisation. Toutefois, si vous devez renommer la DLL sous-jacente proxyfiée, mettez à jour le fichier .def généré en conséquence.

rustdllproxy new -p path/to/target_.dll -n my_proxy

Astuce : rustdllproxy est construit comme une CLI avec clap. Exécutez rustdllproxy --help pour voir toutes les options et drapeaux.

Écriture de hooks

La bibliothèque de macros prend en charge 3 principaux types de hook : prehook, posthook et fullhook.

Étapes d'implémentation d'un hook

1. Remplacez la directive #[no_mangle] par la macro de hook (laissez le commentaire final //<dllname>.dll en place)

   root@kitploit:~

   #[prehook("dllbeingproxied.dll", "function_name")] //dllbeingproxied.dll
   

2. Renseignez la signature de la fonction (déclarez les entrées comme mut pour les modifier)

3. Compilez avec rustdllproxy build.

Types de hooks

prehook

Exécute du code avant la fonction d'origine. Permet d'ajouter des fonctionnalités ou de modifier les variables d'entrée.

#[prehook("target.dll", "my_function")] //target.dll
fn my_function(mut param1: i32, mut param2: &str) {
    // Your code here - executes before original function
    param1 *= 2;  // Modify parameters if needed
}

posthook

Exécute du code après la fonction d'origine. Visualisez et modifiez la valeur de retour à l'aide de la variable magique ret.

#[posthook("target.dll", "calculate")] //target.dll
fn calculate(input: i32) -> i32 {
    // Original function executes first
    // Then your code runs with access to 'ret'
    ret = ret * 2;  // Modify return value
}

Remarque : La variable ret est automatiquement définie comme mutable. Vous n'avez pas besoin d'y faire référence si ce n'est pas nécessaire.

fullhook

Fournit un contrôle complet sur l'exécution de la fonction. Gérez manuellement la valeur de retour et l'appel de la fonction.

#[fullhook("target.dll", "do_multi_add")] //target.dll
fn do_multi_add(mut a: i32, mut b: i32, mut c: i32) -> i32 {
    // Pre-processing
    a += 10;
    b += 20;

    // Call original function with magic func()
    let mut return_value: i32 = func(a, b, c);

    // Post-processing
    return_value *= 2;

    // Must explicitly return the value
    return_value
}

Compilation de la crate

Exécutez à partir du répertoire de la crate proxy (ou passez-le comme premier argument) :

rustdllproxy build [PATH] [--profile <name>] [--no-build] [-- <extra cargo args>]

Mises en garde

• Le fichier .def est entièrement régénéré à chaque compilation ; les modifications manuelles seront écrasées. Si vous devez apporter des modifications manuelles par rapport à la façon dont rustdllproxy compile, cargo peut être utilisé pour y parvenir.
• Le système de compilation s'appuie sur les commentaires générés, les exports .def et les noms de hooks pour récupérer le nom de la DLL sous-jacente avant la compilation. S'il n'y a pas assez d'informations, une erreur sera levée pour expliquer comment cela peut être résolu.

Exemple de flux de travail

Supposons que vous souhaitiez modifier office.dll utilisée dans un logiciel bureautique via le détournement de l'ordre de recherche de DLL :

Étape 1 : Préparer la DLL d'origine

# Rename the original DLL
mv office.dll office_.dll

Étape 2 : Générer la crate proxy

rustdllproxy new -p office_.dll -n office_proxy

Étape 3 : Implémenter les hooks

#[prehook("office_.dll", "open_window")] //office_.dll
fn open_window() {
    // Your custom code here...
    println!("Window is about to open!");
}

Étape 4 : Compiler et déployer

cd office_proxy
rustdllproxy build

Les fichiers de compilation se trouvent dans /target

Considérations sur le regroupement de DLL

Il est possible de proxifier plusieurs DLL cibles avec une seule crate. Cette fonctionnalité est rarement utilisée et comporte quelques mises en garde importantes.

Lors du regroupement de plusieurs DLL :

• Les ordinaux de fonctions peuvent changer en raison de l'ordre des exports
• Cela est rarement problématique car les logiciels modernes utilisent des noms d'exportation pour la compatibilité
• Utile principalement pour l'analyse et le développement d'applications personnalisées

Journal des modifications

Les notes de version se trouvent dans CHANGELOG.md.

Contribuer

Les contributions sont les bienvenues ! N'hésitez pas à soumettre des issues et des pull requests.