██╗     ██╗████████╗██╗  ██╗██╗██╗   ██╗███╗   ███╗
██║     ██║╚══██╔══╝██║  ██║██║██║   ██║████╗ ████║
██║     ██║   ██║   ███████║██║██║   ██║██╔████╔██║
██║     ██║   ██║   ██╔══██║██║██║   ██║██║╚██╔╝██║
███████╗██║   ██║   ██║  ██║██║╚██████╔╝██║ ╚═╝ ██║
╚══════╝╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝ ╚═════╝ ╚═╝     ╚═╝

यूज़र-मोड क्लाइंट के साथ Windows कर्नेल-मोड ड्राइवर फ्रेमवर्क

[!IMPORTANT]

पूरा प्रोजेक्ट प्राप्त करें

सॉल्यूशन फ़ाइलें Discord सर्वर के माध्यम से उपलब्ध हैं।

पूरा सोर्स कोड खरीदने में रुचि है? मुझसे Telegram या Discord पर संपर्क करें: @tonythimself।

अवलोकन

Lithium एक Windows कर्नेल-मोड ड्राइवर (lithium-kernel) है जिसके साथ एक यूज़र-मोड क्लाइंट (lithium-usermode) जुड़ा है। यह एक कस्टम IOCTL इंटरफ़ेस के माध्यम से संचार करता है और लो-लेवल मेमोरी मैनिपुलेशन, पेज टेबल वॉकिंग, और इनपुट डिवाइस कंट्रोल प्रिमिटिव्स प्रदान करता है।

विशेषताएँ

विशेषता	विवरण
फ़िज़िकल मेमोरी R/W	`MmCopyMemory` के माध्यम से सीधे फ़िज़िकल एड्रेस पढ़ें/लिखें
वर्चुअल मेमोरी R/W	`MmCopyVirtualMemory` के माध्यम से क्रॉस-प्रोसेस वर्चुअल मेमोरी एक्सेस
DTB रिज़ॉल्यूशन	PFN डेटाबेस एन्यूमरेशन के माध्यम से डायरेक्टरी टेबल बेस निष्कर्षण
पेज टेबल वॉकिंग	PML4/PDPT/PD/PT लेयर कैशिंग के साथ लीनियर एड्रेस ट्रांसलेशन
पैटर्न स्कैनिंग	प्रोसेस मेमोरी में IDA-शैली सिग्नेचर स्कैनिंग
मेमोरी एलोकेशन	टारगेट प्रोसेस कॉन्टेक्स्ट में `ZwAllocateVirtualMemory`
मेमोरी प्रोटेक्शन	टारगेट प्रोसेस कॉन्टेक्स्ट में `ZwProtectVirtualMemory`
माउस एमुलेशन	MouClass सर्विस कॉलबैक हुक के माध्यम से कर्नेल-लेवल माउस इनपुट
थ्रेड हाइडिंग	ETHREAD फ़ील्ड स्पूफ़िंग (स्टार्ट एड्रेस, CID, क्रिएट टाइम, आदि)
NMI कॉलबैक डिसेबल	डीबगर एवेज़न के लिए NMI कॉलबैक सप्रेशन
पूल क्लीनिंग	कर्नेल पूल ट्रैकर से बिग पूल टेबल एंट्री हटाना

प्रोजेक्ट संरचना

lithium/
├── lithium-kernel/              # Kernel-mode driver (KMDF)
│   ├── entry.cpp                # DriverEntry entry point
│   ├── core/
│   │   ├── dispatch/            # IOCTL dispatch and request routing
│   │   ├── requests/
│   │   │   ├── directory-table-base/  # DTB resolution & page table walk
│   │   │   ├── image-base/           # Process module base retrieval
│   │   │   ├── mouse/                # Mouse input emulation via MouClass
│   │   │   ├── read-write/           # Physical and virtual memory R/W
│   │   │   └── virtual-memory/       # Allocate, protect, query, pattern scan
│   │   └── utilities/
│   │       ├── kernel/          # Module enumeration, NMI, thread ops
│   │       └── ...              # Pool cleaner, CRT shim
│   └── dependencies/
│       ├── additional/
│       │   ├── crt/             # Minimal CRT implementation
│       │   ├── security/        # skCrypter string encryption, oxorany
│       │   └── structures/      # Shared invoke data structures
│       └── includes.hpp         # Master include header
│
└── lithium-usermode/            # User-mode client
    ├── entry.cpp                # Client entry point
    ├── core/
    │   └── driver/              # IOCTL communication layer
    └── dependencies/
        ├── additional/
        │   └── structs.hpp      # Page table entry unions & helpers
        └── includes.hpp

IOCTL इंटरफ़ेस

संचार एक मौजूदा ड्राइवर (ProcObsrvesx.sys) के IOCTL डिस्पैच रूटीन को हुक करके स्थापित किया जाता है। लोड के समय, कर्नेल मॉड्यूल टारगेट ड्राइवर का पता लगाता है, उसके IRP डिस्पैच हैंडलर को स्कैन करता है, और उसे lithium के अपने hooked_ioctl के लिए एक ट्रैम्पोलिन से ओवरराइट करता है। यूज़र-मोड क्लाइंट \\.\ProcObsrvesx खोलता है और सभी IOCTLs हुक के माध्यम से पारदर्शी रूप से रीडायरेक्ट हो जाते हैं।

कोड	इनपुट स्ट्रक्चर	क्रिया
`invoke_base`	`base_invoke { pid, handle }`	प्रोसेस इमेज बेस प्राप्त करें
`invoke_dtb`	`dtb_invoke { pid, dtb }`	डायरेक्टरी टेबल बेस रिज़ॉल्व करें
`invoke_read`	`read_invoke { pid, directory_table, address, buffer, size }`	फ़िज़िकल मेमोरी पढ़ें
`invoke_write`	`write_invoke { pid, directory_table, address, buffer, size }`	फ़िज़िकल मेमोरी लिखें
`invoke_read_virtual`	`read_virtual_invoke { pid, address, buffer, size }`	वर्चुअल मेमोरी पढ़ें
`invoke_write_virtual`	`write_virtual_invoke { pid, address, buffer, size }`	वर्चुअल मेमोरी लिखें
`invoke_allocate`	`allocate_invoke { pid, type, protection, address, size }`	वर्चुअल मेमोरी एलोकेट करें
`invoke_protect`	`protect_invoke { pid, protection, address, size }`	मेमोरी प्रोटेक्शन बदलें
`invoke_virtual_query`	`query_virtual_invoke { pid, address, mbi }`	वर्चुअल मेमोरी जानकारी क्वेरी करें
`invoke_pattern_scan`	`pattern_invoke { pid, signature, address, pattern_address }`	मेमोरी पैटर्न स्कैन करें
`invoke_move_mouse`	`mouse_invoke { x, y, flags, button_flags }`	माउस इनपुट एमुलेट करें

आंतरिक कार्यप्रणाली

DTB रिज़ॉल्यूशन

ड्राइवर MmGetPhysicalMemoryRanges द्वारा लौटाए गए फ़िज़िकल मेमोरी रेंजों पर इटरेट करता है, सेल्फ-रेफ़रेंसिंग PML4 एंट्री का पता लगाने के लिए PFN डेटाबेस को वॉक करता है, और किसी दिए गए प्रोसेस के लिए सही डायरेक्टरी टेबल बेस की पुष्टि करने के लिए प्रत्येक पेज टेबल लेयर को वैलिडेट करता है।

पेज टेबल वॉकिंग

लीनियर-टू-फ़िज़िकल ट्रांसलेशन चार-लेवल x64 पेज टेबल पदानुक्रम (PML4 → PDPT → PD → PT) को प्रति-लेवल कैशिंग के साथ ट्रैवर्स करता है। लार्ज पेज (2MB / 1GB) सपोर्ट बेस्ट-एफ़र्ट आधार पर शामिल है।

माउस एमुलेशन

ड्राइवर MouClass और MouHID ड्राइवर ऑब्जेक्ट्स का पता लगाता है, HID डिवाइस एक्सटेंशन से MouseClassServiceCallback को रिज़ॉल्व करता है, और सीधे कॉलबैक चेन में MOUSE_INPUT_DATA पैकेट इंजेक्ट करता है।

थ्रेड हाइडिंग

मुख्य ETHREAD फ़ील्ड्स — क्रिएट टाइम, स्टार्ट एड्रेस, Win32 स्टार्ट एड्रेस, कर्नेल स्टैक, CID, और एग्ज़िट स्टेटस — को सेव किया जाता है और बेनाइन या नल वैल्यूज़ से बदल दिया जाता है। टियरडाउन पर, थ्रेड टर्मिनेशन से पहले मूल वैल्यूज़ बहाल कर दी जाती हैं।

आवश्यकताएँ

Windows 10/11 x64
Windows Driver Kit (WDK) 10.0.26100.0 के साथ Visual Studio 2022 या बाद का संस्करण
एक कर्नेल ड्राइवर लोडिंग विधि (टेस्ट साइनिंग, कर्नेल मैपर, आदि)

बिल्ड

Visual Studio में lithium.sln खोलें
कॉन्फ़िगरेशन को Release / x64 पर सेट करें
lithium-kernel बिल्ड करें → lithium-kernel.sys
lithium-usermode बिल्ड करें → lithium-usermode.exe

या MSBuild के माध्यम से:

msbuild lithium.sln /p:Configuration=Release /p:Platform=x64

उपयोग

#include <core/driver/driver.hpp>

g_driver->initialize_handle();
DWORD pid = g_driver->get_process_id(L"target.exe");
g_driver->attach(pid);

g_driver->image_base = g_driver->get_image_base(0);
g_driver->dtb = g_driver->resolve_directory_table_base();

auto value = g_driver->read<uintptr_t>(g_driver->image_base + 0xOFFSET);
g_driver->mouse_event(-10, -10, 0, 0);

निर्भरताएँ

skCrypter — कंपाइल-टाइम स्ट्रिंग एन्क्रिप्शन
oxorany — कंपाइल-टाइम कॉन्स्टेंट ऑबफ़स्केशन

अस्वीकरण

यह प्रोजेक्ट केवल शैक्षिक और शोध उद्देश्यों के लिए है।
इसका उपयोग केवल उन सिस्टम्स पर करें जिनके आप मालिक हैं या जिनका परीक्षण करने की आपके पास स्पष्ट अनुमति है।
इस सॉफ़्टवेयर के किसी भी दुरुपयोग या क्षति के लिए लेखक ज़िम्मेदार नहीं हैं।

_{शोध के लिए निर्मित · प्रोडक्शन के लिए नहीं}

lithium-kernel

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

पूरा प्रोजेक्ट प्राप्त करें