zig-pe

एक प्रतिबिंबित PE लोडर जो Zig में लिखा गया है। यह देशी और .NET PE फ़ाइलों को सीधे मेमोरी से लोड और निष्पादित करता है।

विशेषताएँ

PE लोडिंग पाइपलाइन

• DOS और NT हेडर पार्स करें (PE32 और PE32+ रनटाइम पर)
• सेक्शन को आवंटित मेमोरी में मैप करें
• इम्पोर्ट हल करें (नाम और ऑर्डिनल, PE32 4-बाइट / PE32+ 8-बाइट थंक)
• बेस रिलोकेशन लागू करें (HIGHLOW, DIR64, ARM_MOV32, THUMB_MOV32)
• विलंबित इम्पोर्ट हल करें (DataDirectory[13], आधुनिक RVA प्रारूप)
• अपवाद हैंडलर पंजीकृत करें (RtlAddFunctionTable, केवल x64/ARM64)
• प्रति-सेक्शन मेमोरी सुरक्षा सेट करें
• TLS कॉलबैक लागू करें (DLL_PROCESS_ATTACH)
• CreateThread के माध्यम से एंट्री पॉइंट निष्पादित करें
• सफाई करें (अपवाद तालिकाएँ पंजीकरण रद्द करें, मेमोरी मुक्त करें)

उन्नत सुरक्षा सुविधाएँ

• सुरक्षा कुकी आरंभीकरण (__security_cookie /GS बफर सुरक्षा के लिए)
• CFG (कंट्रोल फ़्लो गार्ड) - SetProcessValidCallTargets के माध्यम से मान्य कॉल लक्ष्य पंजीकृत करता है
• SxS / एक्टिवेशन कॉन्टेक्स्ट - GUI अनुप्रयोगों के लिए एम्बेडेड मैनिफेस्ट सक्रिय करता है
• बाउंड इम्पोर्ट डायरेक्ट्री अमान्यकरण

एक्सपोर्ट तालिका समाधान

लोडेड PE इमेज से एक्सपोर्ट हल करने के लिए उपयोगिता फ़ंक्शन:

• getExportByName(base, ntheaders, name) — नाम से हल करें
• getExportByOrdinal(base, ntheaders, ordinal) — ऑर्डिनल से हल करें

फ़ॉरवर्डेड एक्सपोर्ट को स्वचालित रूप से लक्ष्य DLL लोड करके संभालता है (जैसे, "NTDLL.RtlAllocateHeap" ntdll.dll में वास्तविक फ़ंक्शन पर हल होता है)।

API सेट समाधान

PEB ApiSetMap का उपयोग करके Windows API सेट (api-ms-win-*, ext-ms-win-*) को स्वचालित रूप से उनके वास्तविक होस्ट DLL में हल करता है। यह वर्चुअल API सेट DLL से इम्पोर्ट करने वाले PE को लोड करने में सक्षम बनाता है।

उपयोगिता फ़ंक्शन

• utils.detect_platform(buffer) — पता लगाएं कि PE 32-बिट है या 64-बिट
• utils.is_dotnet_assembly(ntheaders) — जाँचें कि PE एक .NET असेंबली है या नहीं
• utils.getDotNetVersion(buffer) — मेटाडेटा से .NET रनटाइम संस्करण स्ट्रिंग निकालें
• utils.rvaToFileOffset(buffer, rva) — RVA को रॉ फ़ाइल ऑफ़सेट में बदलें

संगतता

• देशी संकलित बाइनरी निष्पादन (x86, x86_64, ARM, ARM64)
• CLR होस्टिंग के माध्यम से .NET संकलित बाइनरी निष्पादन
• देशी और .NET दोनों निष्पादन योग्यों के लिए कमांड-लाइन आर्गुमेंट पास करना
• आर्किटेक्चर सत्यापन (PE की बिटनेस होस्ट प्रक्रिया से मेल खानी चाहिए)

समर्थित मशीन प्रकार

पूर्वापेक्षाएँ

• Zig कंपाइलर (नवीनतम संस्करण अनुशंसित)
• Windows OS (परियोजना Windows-विशिष्ट API का उपयोग करती है)

परियोजना का निर्माण

1. रिपॉजिटरी क्लोन करें:

   root@kitploit:~

   git clone https://github.com/Thoxy67/zig-pe.git
   cd zig-pe
   

2. परियोजना बनाएँ:

   root@kitploit:~

   zig build
   

निर्माण विकल्प

zig build -Ddotnet=false  # .NET समर्थन अक्षम करें (डिफ़ॉल्ट रूप से सक्षम)

निर्माण लक्ष्य

zig build                 # सभी लक्ष्य बनाएँ
zig build run-putty64     # 64-बिट देशी PE उदाहरण चलाएँ
zig build run-putty32     # 32-बिट देशी PE उदाहरण चलाएँ
zig build run-dotnet      # .NET असेंबली उदाहरण चलाएँ
zig build test            # यूनिट परीक्षण चलाएँ

उपयोग

बुनियादी उपयोग (एम्बेडेड PE)

const pe = @import("pe");

pub fn main() !void {
    // एक एम्बेडेड PE फ़ाइल लोड और निष्पादित करें
    try pe.RunPE.init(@embedFile("bin/app.exe")).run();
}

कमांड-लाइन आर्गुमेंट के साथ

const pe = @import("pe");

pub fn main() !void {
    var loader = pe.RunPE.init(@embedFile("bin/app.exe"));
    try loader.runWithArgs(&.{ "arg1", "arg2", "arg3" });
}

फ़ाइल से लोड करना

const std = @import("std");
const pe = @import("pe");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const file_content = try std.fs.cwd().readFileAlloc(
        allocator,
        "path/to/executable.exe",
        std.math.maxInt(usize),
    );
    defer allocator.free(file_content);

    try pe.RunPE.init(file_content).run();
}

लोडेड PE से एक्सपोर्ट हल करना

const pe = @import("pe");

// DLL को मेमोरी में लोड करने के बाद...
const base: [*]const u8 = @ptrCast(loaded_base);
const ntheaders = // ... NT हेडर प्राप्त करें

// नाम से हल करें
if (pe.getExportByName(base, ntheaders, "ExportedFunction")) |func_ptr| {
    const func: *const fn () void = @ptrCast(@alignCast(func_ptr));
    func();
}

// ऑर्डिनल से हल करें
if (pe.getExportByOrdinal(base, ntheaders, 42)) |func_ptr| {
    // फ़ंक्शन पॉइंटर का उपयोग करें
}

आर्गुमेंट पासिंग कैसे काम करती है

• देशी PE: आर्गुमेंट PEB CommandLine को पैच करके पास किए जाते हैं, जिससे GetCommandLineW() दिए गए आर्गुमेंट लौटाता है
• .NET असेंबली: आर्गुमेंट सीधे CLR आह्वान के माध्यम से Main(string[] args) को पास किए जाते हैं

सुरक्षा संबंधी विचार

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

योगदान

zig-pe में योगदान का स्वागत है! कृपया पुल अनुरोध प्रस्तुत करने, मुद्दे बनाने या जानकारी फैलाने में संकोच न करें।

1. परियोजना को फोर्क करें
2. अपनी सुविधा शाखा बनाएँ (git checkout -b feature/अद्भुतसुविधा)
3. अपने परिवर्तन कमिट करें (git commit -m 'कुछ अद्भुतसुविधा जोड़ें')
4. शाखा पर पुश करें (git push origin feature/अद्भुतसुविधा)
5. पुल अनुरोध खोलें

लाइसेंस

यह परियोजना MIT लाइसेंस के तहत लाइसेंस प्राप्त है - विवरण के लिए LICENSE फ़ाइल देखें।

स्वीकृतियाँ

• Zig प्रोग्रामिंग भाषा समुदाय
• PE फ़ाइल प्रारूप दस्तावेज़ीकरण में योगदानकर्ता

अस्वीकरण

यह परियोजना केवल शैक्षिक उद्देश्यों के लिए है। किसी भी PE फ़ाइल को लोड और निष्पादित करने से पहले सुनिश्चित करें कि आपके पास आवश्यक अधिकार और अनुमतियाँ हैं।