pe-signgen

Windows PE फ़ंक्शंस के लिए क्रॉस-संस्करण बाइनरी सिग्नेचर और RVA ऑफसेट

---

अवलोकन

pe-signgen रिवर्स इंजीनियरों और सुरक्षा शोधकर्ताओं के लिए एक उपकरण है जो स्वचालित रूप से जनरेट करता है:

• अनएक्सपोर्टेड और एक्सपोर्टेड फ़ंक्शंस के लिए बाइनरी सिग्नेचर (वाइल्डकार्ड के साथ बाइट पैटर्न)
• बाइनरी में फ़ंक्शंस को सीधे लोकेट करने के लिए RVA और फ़ाइल ऑफसेट
• क्रॉस-बिल्ड सिग्नेचर जो कई विंडोज़ संस्करणों में काम करते हैं
• विभिन्न उपयोग मामलों के लिए अनुकूलित कई आउटपुट प्रारूप
• x64, ARM64, और WoW64 आर्किटेक्चर के लिए समर्थन

मुख्य विचार विंडोज़ 10/11 बिल्ड में अनएक्सपोर्टेड फ़ंक्शंस तक पहुंचने का एक व्यवस्थित, मजबूत तरीका प्रदान करना है। यह उपयोग करता है:

• विंडोज़ बिल्ड मेटाडेटा के लिए Winbindex
• PDB के लिए Microsoft के सार्वजनिक सिंबल सर्वर
• प्रतिलिपि योग्य, ऑफ़लाइन-अनुकूल वर्कफ़्लो के लिए स्थानीय कैशिंग

⚠️ विंडोज़ संस्करण समर्थन pe-signgen केवल Windows 10 और Windows 11 का समर्थन करता है। यह एक जानबूझकर किया गया डिज़ाइन निर्णय है: Winbindex पुराने संस्करणों के लिए पूर्ण डेटा प्रदान नहीं करता है।

---

उपयोग के मामले

• अनएक्सपोर्टेड विंडोज़ इंटरनल्स LdrpInitializeTls, RtlpInsertInvertedFunctionTableEntry जैसे फ़ंक्शंस के लिए सिग्नेचर जनरेट करें, आदि।

• गेम हैकिंग / एंटी-चीट अनुसंधान गेम अपडेट में बरकरार रहने वाले स्थिर सिग्नेचर जनरेट करें

• सुरक्षा अनुसंधान विंडोज़ बिल्ड में सुरक्षा-महत्वपूर्ण रूटीन लोकेट करें

• स्वचालन आंतरिक API के पूरे सेट के लिए स्क्रिप्ट योग्य सिग्नेचर और ऑफसेट जनरेशन

---

आउटपुट प्रारूप

pe-signgen विभिन्न उपयोग मामलों के लिए तीन अलग-अलग आउटपुट प्रारूप प्रदान करता है:

1. JSON प्रारूप

स्वचालन, स्क्रिप्टिंग और अन्य टूल के साथ एकीकरण के लिए संरचित डेटा।```bash pe-signgen --signature ntdll!NtCreateFile -o ntcreatefile.json --output-format json

**आउटपुट संरचना:**```json
{
  "dll_name": "ntdll",
  "function_name": "NtCreateFile",
  "architecture": "x64",
  "generated": "2024-12-11T15:30:00.123456",
  "total_builds": 1247,
  "unique_signatures": 3,
  "signature_groups": [
    {
      "matched_symbol": "NtCreateFile",
      "signature": "4C 8B DC 49 89 5B 08 49 89 6B 10 49 89 73 18 ...",
      "length": 48,
      "build_count": 845,
      "versions": [
        { "major": 10240, "minor": 16384, "build": "10240.16384" },
        { "major": 10586, "minor": 0, "build": "10586.0" }
      ]
    }
  ]
}

नोट्स:

• major और minor पहले . पर विभाजित करके बिल्ड स्ट्रिंग से प्राप्त किए जाते हैं। उदाहरण: "10240.16384" → major = 10240, minor = 16384।
• build आंतरिक रूप से उपयोग की जाने वाली मूल बिल्ड स्ट्रिंग कुंजी है।

---

2. बाइनरी प्रारूप (WSIG/WOFF)

कॉम्पैक्ट, रनटाइम-तैयार बाइनरी प्रारूप जो एम्बेडेड सिस्टम और कम-ओवरहेड स्कैनिंग के लिए अनुकूलित हैं।

ये write_wsig() और write_woff() में लागू किए गए ऑन-डिस्क लेआउट से मेल खाते हैं।

---

WSIG प्रारूप (Windows Signature)

मैजिक: WSO\0 (0x57 0x53 0x4F 0x00) वर्तमान संस्करण: 1 उद्देश्य: वाइल्डकार्ड मास्क और संबद्ध Windows बिल्ड संस्करणों के साथ बाइनरी हस्ताक्षर संग्रहीत करना।

फ़ाइल संरचना (अवधारणात्मक)```

┌─────────────────────────────────────┐ │ Header (36 bytes) │ ├─────────────────────────────────────┤ │ DLL Name (variable) │ ├─────────────────────────────────────┤ │ Function Name (variable) │ ├─────────────────────────────────────┤ │ Signature / Mask / Build blobs │ ← Arbitrary order, see notes ├─────────────────────────────────────┤ ← Aligned to 4 bytes │ Groups Table (24 × N bytes) │ └─────────────────────────────────────┘

**महत्वपूर्ण लेआउट नोट (`write_wsig` से मेल खाते हैं)**

* हेडर के बाद, DLL और फ़ंक्शन नाम UTF‑8 बाइट्स के रूप में लिखे जाते हैं।
* प्रत्येक सिग्नेचर समूह के लिए, पैटर्न बाइट्स और मास्क बाइट्स लिखे जाते हैं, उसके बाद उस समूह के लिए बिल्ड ऐरे लिखा जाता है।
* ये प्रति-समूह क्षेत्र प्रकार के आधार पर वैश्विक रूप से **नहीं** समूहित किए जाते हैं: पैटर्न, मास्क और बिल्ड ऐरे आपस में मिश्रित हो सकते हैं।
* बिल्डर प्रत्येक बिल्ड ऐरे से पहले और ग्रुप्स टेबल से पहले **4 बाइट्स** पर संरेखित करता है। इससे पैडिंग आ सकती है।
* उपभोक्ताओं को हेडर और ग्रुप एंट्री में दिए गए ऑफसेट का **हमेशा** पालन करना चाहिए; भौतिक सन्निहितता के लिए अवधारणात्मक आरेख पर **निर्भर न रहें**।

##### हेडर लेआउट (36 बाइट्स)```c
// Packed as: "<4sIIIIIIII" (little-endian)

typedef struct {
    char     magic[4];   // "WSO\0" (WSIG_MAGIC)
    uint32_t version;    // FORMAT_VERSION (currently 1)
    uint32_t arch;       // Architecture code (1=x64, 2=ARM64, 3=WoW64)
    uint32_t dll_off;    // Offset to DLL name string
    uint32_t dll_len;    // Length of DLL name in bytes
    uint32_t func_off;   // Offset to function name string
    uint32_t func_len;   // Length of function name in bytes
    uint32_t group_count;// Number of signature groups
    uint32_t groups_off; // Offset to groups table
} wsig_header_t; // 36 bytes

समूह प्रविष्टि (24 बाइट्स)

प्रत्येक सिग्नेचर समूह एक अद्वितीय पैटर्न का प्रतिनिधित्व करता है जो एक या अधिक Windows बिल्ड पर लागू होता है।```c // Packed as: "<IIIIII" (little-endian)

typedef struct { uint32_t sig_off; // Offset to signature pattern bytes uint32_t sig_len; // Length of signature pattern (in bytes) uint32_t mask_off; // Offset to wildcard mask bytes uint32_t mask_len; // Length of wildcard mask (≈ ceil(sig_len/8)) uint32_t builds_off; // Offset to build version array uint32_t build_cnt; // Number of builds using this signature } wsig_group_t; // 24 bytes

##### बिल्ड संस्करण प्रविष्टि (8 बाइट्स)

प्रत्येक बिल्ड प्रविष्टि एक विशिष्ट Windows संस्करण की पहचान करती है जो इस सिग्नेचर का उपयोग करता है।```c
typedef struct {
    uint32_t major; // e.g. 19041
    uint32_t minor; // e.g. 1234
} wsig_build_t; // 8 bytes

major और minor बिल्ड स्ट्रिंग को विभाजित करने से आते हैं ("A.B" → A, B). मूल बिल्ड स्ट्रिंग बाइनरी फॉर्मेट में संग्रहीत नहीं होती; यदि आपको इसकी आवश्यकता हो, तो इसे बाहरी रूप से रखें (यह JSON आउटपुट में मौजूद होती है)।

वाइल्डकार्ड मास्क प्रारूप

मास्क एक बिटमास्क है जहाँ प्रत्येक बिट सिग्नेचर पैटर्न में एक बाइट के अनुरूप होता है:

• Bit = 1: बाइट का सटीक मिलान होना चाहिए (निश्चित बाइट)
• Bit = 0: बाइट वाइल्डकार्ड है (मिलान के दौरान इस बाइट को अनदेखा करें)

उदाहरण:``` Signature: 4C 8B DC 49 89 ?? 08 49 Mask bits: 1 1 1 1 1 0 1 1 (MSB first within each byte) Mask byte: 0xBF (binary: 10111111)

मास्क बाइट्स को प्रत्येक बाइट के भीतर **लिटिल-एंडियन बिट ऑर्डर** में संग्रहीत और व्याख्यायित किया जाता है (ठीक वैसे ही जैसे C हेल्पर्स और `parse_signature` में उपयोग किया गया है):```c
uint8_t bit = (mask_bytes[byte_index >> 3] >> (byte_index & 7)) & 1u;

स्ट्रिंग संग्रहण

• DLL और फ़ंक्शन नाम UTF‑8 के रूप में, बिना null टर्मिनेटर के संग्रहीत किए जाते हैं।
• लंबाई निर्धारित करने के लिए *_len का उपयोग करें; उससे आगे न पढ़ें।
• स्ट्रिंग्स के लिए स्वयं कोई संरेखण आवश्यकताएँ नहीं हैं।
• अतिरिक्त डेटा क्षेत्र (build arrays और groups table) 4‑बाइट सीमाओं पर संरेखित होते हैं; किसी भी padding को अपारदर्शी मानें।

---

WOFF प्रारूप (Windows Offset)

जादुई मान: WOF\0 (0x57 0x4F 0x46 0x00) वर्तमान संस्करण: 1 उद्देश्य: Windows बिल्ड्स में फ़ंक्शनों के लिए सीधे RVA और फ़ाइल ऑफ़सेट संग्रहीत करना

फ़ाइल संरचना```

┌─────────────────────────────────────┐ │ Header (36 bytes) │ ├─────────────────────────────────────┤ │ DLL Name (variable) │ ├─────────────────────────────────────┤ │ Function Name (variable) │ ├─────────────────────────────────────┤ │ Matched Symbol Names (variable) │ ← One UTF‑8 string per entry ├─────────────────────────────────────┤ ← Aligned to 4 bytes │ Entries Table (32 × N bytes) │ └─────────────────────────────────────┘

लेआउट विवरण (`write_woff` से मेल खाता है):