Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
rust_syscalls — रनटाइम SSN रिज़ॉल्विंग के साथ विंडोज़ के लिए एकल स्टब प्रत्यक्ष और अप्रत्यक्ष सिस्कॉलिंग। | Kitploit
उपकरण/GitHubGitHub/janoglezcampos/rust_syscalls
आईडीएस/आईपीएस से बचनापोस्ट-शोषणरेड टीमिंगपेलोड डेवलपमेंट
GitHubjanoglezcampos/rust_syscalls

rust_syscalls

रनटाइम SSN रिज़ॉल्विंग के साथ विंडोज़ के लिए एकल स्टब प्रत्यक्ष और अप्रत्यक्ष सिस्कॉलिंग।

रिपॉजिटरी देखें
240333 साल पहलेKitploit द्वारा समीक्षित

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

RUST_SYSCALLS

विंडोज़ के लिए रनटाइम SSN रिज़ॉल्विंग के साथ सिंगल स्टब डायरेक्ट और इनडायरेक्ट syscalling।


Features:

  • आपके सभी syscalls के लिए एक ही पंक्ति
  • संकलन समय पर फ़ंक्शन नाम हैशिंग
  • डायरेक्ट या इनडायरेक्ट syscalls
  • x86_64, WOW64 और x86 मूल समर्थन
  • कस्टम SSN फ़ेचिंग विधियों के कार्यान्वयन की अनुमति देने के लिए डिज़ाइन किया गया (अधिक जानकारी के लिए इस readme के अंत में देखें)

उपयोग कैसे करें:

  1. लाइब्रेरी की git रिपॉजिटरी / लोकल पथ को अपनी dependencies में जोड़ें:

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

    या

    rust_syscalls = {path = <path to library folder>}

  2. एक feature के रूप में _DIRECT_ या _INDIRECT_ सेट करके डायरेक्ट या इनडायरेक्ट विधि चुनें:

    rust_syscalls = {path = <path to library folder>}, features = ["_INDIRECT_"]}

  3. इम्पोर्ट करें

    use rust_syscalls::syscall;

  4. Syscall:

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


उदाहरण:

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);
    }

नए SSN और syscall एड्रेस रनटाइम रिज़ॉल्विंग विधियों को लागू करना:

SSN और एड्रेस फ़ेचिंग के लिए आवश्यक सभी कोड src\syscall_resolve.rs फ़ाइल में शामिल हैं।

मान पुनर्प्राप्त करने के लिए उपयोग किया जाने वाला एक मुख्य फ़ंक्शन है जिसे get_ssn कहा जाता है, जिसमें 4 कार्यान्वयन हैं, जहाँ प्राप्त तर्क crate::obf!(\<your function name\>) को कॉल करने का परिणाम है, और वापसी मान ssn (u16) हैं, और, इनडायरेक्ट syscalling के मामले में, syscall/sysenter निर्देश का पता जिसे आप उपयोग करना चाहते हैं।

  • x86_64 डायरेक्ट:

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

  • x86_64 इनडायरेक्ट:

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

  • x86 डायरेक्ट:

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

  • x86 इनडायरेक्ट:

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

बस इन फ़ंक्शनों को अपनी इच्छित फ़ेचिंग विधि के साथ पुनः लागू करें।


SysWhispers3 का धन्यवाद, इस लाइब्रेरी के विकास में एक मजबूत स्तंभ होने के लिए

टूल डाउनलोड करें