Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
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é.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
rust_syscalls — Appels système directs et indirects via un stub unique avec résolution des SSN à l'exécution pour Windows. | Kitploit
Outils/GitHubGitHub/janoglezcampos/rust_syscalls
Évasion IDS/IPSPost-ExploitationRed TeamingDéveloppement de Charges Utiles
GitHubjanoglezcampos/rust_syscalls

rust_syscalls

Appels système directs et indirects via un stub unique avec résolution des SSN à l'exécution pour Windows.

Voir le dépôt
240334il y a 3 ansVérifié par Kitploit

Populaires

Voir tout →

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

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

RUST_SYSCALLS

Stub unique pour appels système directs et indirects avec résolution dynamique des SSN pour Windows.


Fonctionnalités :

  • Une seule ligne pour tous vos appels système
  • Hachage des noms de fonctions au moment de la compilation
  • Appels système directs ou indirects
  • Support natif x86_64, WOW64 et x86
  • Conçu pour permettre l'implémentation de méthodes personnalisées de récupération des SSN (consultez la fin de ce readme pour plus d'informations)

Comment l'utiliser :

  1. Ajoutez le dépôt git / le chemin local de la bibliothèque à vos dépendances :

    rust_syscalls = {git = "https://github.com/janoglezcampos/rust_syscalls"}

    ou

    rust_syscalls = {path = <chemin vers le dossier de la bibliothèque>}

  2. Choisissez la méthode directe ou indirecte en définissant _DIRECT_ ou _INDIRECT_ comme fonctionnalité :

rust_syscalls = {path = <chemin vers le dossier de la bibliothèque>}, features = ["_INDIRECT_"]}

  • Importez

    use rust_syscalls::syscall;

  • Appel système :

    NTSTATUS status = syscall!("NtClose", handle);


  • Exemple :

    root@kitploit:~
        #![allow(non_snake_case)]
        use ntapi::ntapi_base::CLIENT_ID;
        use rust_syscalls::syscall;
    
        use winapi::shared::ntdef::{OBJECT_ATTRIBUTES, HANDLE, NULL, NTSTATUS, PVOID};
        use winapi::um::winnt::{PROCESS_VM_WRITE, PROCESS_VM_READ, MEMORY_BASIC_INFORMATION};
        use std::mem::size_of;
        
        fn main(){
            let pid             : u64      = 3268; //Process PID
            let currentProcess  : HANDLE = -1isize as _;
            let mem_info_len    : usize = size_of::<MEMORY_BASIC_INFORMATION>() as _;
    
            let mut handle      : HANDLE   = NULL;
            let mut status      : NTSTATUS;
        
            let mem_info: MEMORY_BASIC_INFORMATION = MEMORY_BASIC_INFORMATION {
                BaseAddress: NULL,
                AllocationBase: NULL,
                AllocationProtect: 0,
                RegionSize: 0,
                State: 0,
                Protect: 0,
                Type: 0,
            };
    
            let oa : OBJECT_ATTRIBUTES = OBJECT_ATTRIBUTES {
                Length: size_of::<OBJECT_ATTRIBUTES>() as _,
                RootDirectory: NULL,
                ObjectName: NULL as _,
                Attributes: 0,
                SecurityDescriptor: NULL,
                SecurityQualityOfService: NULL
            };
    
            let cid : CLIENT_ID = CLIENT_ID {
                UniqueProcess: pid as _,
                UniqueThread: 0 as _
            };
    
            unsafe {
                status = syscall!("NtOpenProcess", &mut handle, PROCESS_VM_WRITE | PROCESS_VM_READ, &oa, &cid);
            }
            
            println!("\n\t[-] NtOpenProcess status: {:#02X}", status);
    
            if status != 0 {
                return;
            }
    
            unsafe {
                status = syscall!("NtQueryVirtualMemory", currentProcess, &pid, 0, &mem_info, mem_info_len, NULL as PVOID);
            }
            
            println!("\n\t[-] NtQueryVirtualMemory status: {:#02X}", status);
            
            if status != 0 {
                return;
            }
    
            println!("\n\t[-] Protect value: {:#02X}\n\t", mem_info.Protect);
    
            unsafe {
                status = syscall!("NtClose", handle);
            }
            
            println!("\t[-] NtClose       status: {:#02X}", status);
        }
    

    Implémentation de nouvelles méthodes de résolution dynamique des SSN et des adresses d'appels système :

    Tout le code nécessaire à la récupération des SSN et des adresses est inclus dans le fichier src\syscall_resolve.rs.

    Il existe une fonction centrale utilisée pour récupérer les valeurs, appelée get_ssn, avec 4 implémentations, où l'argument reçu est le résultat de l'appel à crate::obf!(\<nom de votre fonction\>), et les valeurs de retour sont le ssn (u16), et, dans le cas d'un appel système indirect, l'adresse de l'instruction syscall/sysenter que vous souhaitez utiliser.

    • x86_64 direct :

      fn get_ssn(hash: u32) -> (u16);

    • x86_64 indirect :

      fn get_ssn(hash: u32) -> (u16, u64);

    • x86 direct :

      fn get_ssn(hash: u32) -> (u16);

    • x86 indirect :

      fn get_ssn(hash: u32) -> (u16, u32);

    Réimplémentez simplement ces fonctions avec la méthode de récupération de votre choix.


    Merci à SysWhispers3 d'avoir été un pilier solide lors du développement de cette bibliothèque

    Télécharger l’outil