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` से मेल खाता है):

* हेडर प्लेसहोल्डर के बाद, DLL और फ़ंक्शन नाम UTF‑8 बाइट्स के रूप में लिखे जाते हैं।
* प्रत्येक बिल्ड के लिए, मिलान किया गया सिंबल नाम UTF‑8 स्ट्रिंग (बिना टर्मिनेटर) के रूप में लिखा जाता है। ये एक सरल स्ट्रिंग पूल बनाते हैं।
* लेखक फिर 4 बाइट्स पर संरेखित करता है और फिक्स्ड-साइज़ एंट्रीज़ तालिका लिखता है।
* प्रत्येक एंट्री में इस स्ट्रिंग पूल की ओर इशारा करने वाले ऑफ़सेट (`matched_off`, `matched_len`) होते हैं।

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

typedef struct {
    char     magic[4];   // "WOF\0" (WOFF_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 entry_cnt;  // Number of offset entries
    uint32_t entries_off;// Offset to entries table
} woff_header_t; // 36 bytes

Offset Entry (32 bytes)

प्रत्येक प्रविष्टि किसी Windows बिल्ड को उस बिल्ड में फ़ंक्शन के स्थान से मैप करती है।```c // Packed as: "<IIQQII" (little-endian)

typedef struct { uint32_t major; // Windows major version (e.g., 19041) uint32_t minor; // Windows minor version (e.g., 1234) uint64_t rva; // Relative Virtual Address in the DLL uint64_t file_offset; // Raw file offset in the DLL on disk uint32_t matched_off; // Offset to matched symbol name string uint32_t matched_len; // Length of matched symbol name } woff_entry_t; // 32 bytes

##### उपयोग नोट्स

* **RVA** वह मेमोरी ऑफ़सेट है जब DLL अपने पसंदीदा आधार पर लोड होता है।
* **फ़ाइल ऑफ़सेट** डिस्क पर PE फ़ाइल में कच्ची स्थिति है।
* **मिलान किया गया प्रतीक** अनुरोधित फ़ंक्शन से भिन्न हो सकता है (जैसे, अग्रेषित एक्सपोर्ट)।
  स्ट्रिंग को स्ट्रिंग पूल में एक बार संग्रहीत किया जाता है; `matched_off`/`matched_len` उसे संदर्भित करते हैं।
* प्रविष्टियाँ कुशल लुकअप के लिए **बिल्ड संस्करण** (`major`, फिर `minor`) के अनुसार क्रमबद्ध हैं।

---

#### आर्किटेक्चर कोड

दोनों बाइनरी प्रारूप समान आर्किटेक्चर एन्कोडिंग का उपयोग करते हैं (`ARCH_CODE_MAP` के माध्यम से):

| कोड | आर्किटेक्चर | विवरण                  |
| ---- | ------------ | ---------------------------- |
| 1    | x64          | 64-बिट AMD64/Intel64         |
| 2    | ARM64        | 64-बिट ARM (AArch64)         |
| 3    | WoW64        | 64-बिट Windows पर 32-बिट x86 |

अज्ञात आर्किटेक्चर स्ट्रिंग्स आंतरिक रूप से `1` (x64) पर डिफ़ॉल्ट होती हैं; CLI मानों को समर्थित सेट तक सीमित करता है।

---

### 3. **C हेडर प्रारूप**

संकलन के लिए तैयार C हेडर, जिनमें टाइप-सुरक्षित संरचनाएँ और डेटा सरणियाँ होती हैं।

`pe-signgen` दो *प्रकार* के C हेडर उत्पन्न कर सकता है:

* **WSIG हेडर** – सिग्नेचर और मास्क डेटा के लिए (`write_wsig_header` से)।
* **WOFF हेडर** – सीधे RVA/फ़ाइल-ऑफ़सेट तालिकाओं के लिए (`write_woff_header` से)।

`--output-format cheader` विकल्प C हेडर चुनता है; इसे `--offsets` के साथ संयोजित करने पर WSIG और WOFF वेरिएंट्स के बीच स्विच होता है।

#### WSIG C हेडर```bash
pe-signgen --signature ntdll!RtlpInitializeThreadActivationContextStack \
  -o rtlp_init_actx.h --output-format cheader

जनरेटेड हेडर संरचना (सरलीकृत, write_wsig_header से मेल खाती है):```c /* Auto-generated WSIG header for ntdll ! RtlpInitializeThreadActivationContextStack ! x64. */ #ifndef WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_H #define WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_H

#include <stdint.h> #include <stddef.h>

#define WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_DLL_NAME "ntdll" #define WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_FUNCTION_NAME "RtlpInitializeThreadActivationContextStack" #define WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_ARCH "x64"

/* Per-version build identifier. */ typedef struct { uint32_t major; uint32_t minor; } WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_version_t;

/* Signature group entry. */ typedef struct { const uint8_t *pattern; const uint8_t *mask; uint32_t length; uint32_t build_count; const WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_version_t *versions; } WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group_t;

/* One pattern/mask/versions triple per group. / static const uint8_t WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_pattern[] = { / ... / }; static const uint8_t WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_mask[] = { / ... / }; static const WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_version_t WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_versions[] = { { 10240u, 16384u }, / 10240.16384 / / ... */ };

static const WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group_t WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_GROUPS[] = { { WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_pattern, WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_mask, (uint32_t)(sizeof(WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_pattern) / sizeof(WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_pattern[0])), (uint32_t)(sizeof(WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_versions) / sizeof(WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_versions[0])), WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group0_versions }, /* group 0 (RtlpInitializeThreadActivationContextStack) / / ... */ };

static const size_t WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_GROUP_COUNT = sizeof(WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_GROUPS) / sizeof(WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_GROUPS[0]);

#endif /* WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_H */

**एकीकरण उदाहरण (उत्पन्न प्रकारों से मेल खाने के लिए सही किया गया):**```c
#include "rtlp_init_actx.h"

static inline int match_byte(uint8_t want, uint8_t got,
                             const uint8_t *mbits, uint32_t i) {
    uint8_t bit = (mbits[i >> 3] >> (i & 7)) & 1u;
    return bit ? (want == got) : 1;
}

static const uint8_t *
find_signature(const uint8_t *base, size_t size,
               const uint8_t *pattern,
               const uint8_t *mbits,
               uint32_t sig_len) {
    if (!base || !pattern || !mbits || sig_len == 0)
        return NULL;
    if (size < sig_len)
        return NULL;

    // Find first non-wildcard byte as anchor
    uint32_t anchor = sig_len;
    for (uint32_t i = 0; i < sig_len; ++i) {
        if ((mbits[i >> 3] >> (i & 7)) & 1u) {
            anchor = i;
            break;
        }
    }
    if (anchor == sig_len)
        return base; // all wildcards

    const uint8_t anchor_val = pattern[anchor];
    const size_t last_pos = size - (size_t)sig_len;

    for (size_t pos = 0; pos <= last_pos; ++pos) {
        if (base[pos + anchor] != anchor_val)
            continue;

        uint32_t i = 0;
        for (; i < sig_len; ++i) {
            if (!match_byte(pattern[i], base[pos + i], mbits, i))
                break;
        }
        if (i == sig_len)
            return base + pos;
    }
    return NULL;
}

static void
fetch_signature(uint32_t major, uint32_t minor,
                const WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group_t *groups,
                size_t group_len,
                const uint8_t **signature_dest,
                const uint8_t **mask_dest,
                uint32_t *signature_len_dest) {
    *signature_dest = NULL;
    *mask_dest = NULL;
    *signature_len_dest = 0;

    const WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group_t *closest = NULL;
    uint32_t best_distance = 0xFFFFFFFFu;

    for (size_t gi = 0; gi < group_len; ++gi) {
        const WSIG_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_group_t *g = &groups[gi];
        for (uint32_t vi = 0; vi < g->build_count; ++vi) {
            uint32_t m = g->versions[vi].major;
            uint32_t n = g->versions[vi].minor;

            uint32_t distance = (m > major ? m - major : major - m) * 10000u +
                                (n > minor ? n - minor : minor - n);

            if (distance < best_distance) {
                best_distance = distance;
                closest = g;
            }

            if (m == major && n == minor) {
                *signature_dest = g->pattern;
                *mask_dest = g->mask;
                *signature_len_dest = g->length;
                return;
            }
        }
    }

    if (closest) {
        *signature_dest = closest->pattern;
        *mask_dest = closest->mask;
        *signature_len_dest = closest->length;
    }
}

फिर आप इसे अपने स्वयं के लोडर-विशिष्ट कोड में जोड़ सकते हैं (जैसे GetModuleHandleA का उपयोग करके, PE सेक्शनों को ट्रैवर्स करना, आदि)। हैडर जानबूझकर केवल डेटा प्रदान करता है; सहायक फ़ंक्शन उपभोक्ता पर निर्भर हैं।

WOFF C हैडर

केवल ऑफ़सेट-केवल उपयोग मामलों के लिए, write_woff_header एक छोटा हैडर उत्पन्न करता है जो (major, minor, rva, file_offset) प्रविष्टियों की एक क्रमबद्ध तालिका का वर्णन करता है।

लेआउट (write_woff_header से मेल खाता है):```c /* Auto-generated WOFF header for ntdll ! RtlpInitializeThreadActivationContextStack ! x64. */ #ifndef WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_H #define WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_H

#include <stdint.h> #include <stddef.h>

#define WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_DLL_NAME "ntdll" #define WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_FUNCTION_NAME "RtlpInitializeThreadActivationContextStack" #define WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_ARCH "x64"

/* Per-build offset entry. */ typedef struct { uint32_t major; uint32_t minor; uint64_t rva; uint64_t file_offset; } WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_entry_t;

static const WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_entry_t WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_ENTRIES[] = { { 10240u, 16384u, 0x5B195ULL, 0x5A595ULL }, /* 10240.16384 (RtlpInitializeThreadActivationContextStack) / / ... (sorted by major, then minor) ... */ };

static const size_t WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_ENTRY_COUNT = sizeof(WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_ENTRIES) / sizeof(WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_ENTRIES[0]);

#endif /* WOFF_NTDLL_RTLPINITIALIZETHREADACTIVATIONCONTEXTSTACK_X64_H */

यह तब उपयोगी होता है जब आप ऑफसेट पर ही भरोसा करते हैं और पैटर्न-मिलान की आवश्यकता नहीं होती है।

---

## स्थापना

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

* Python 3.8+
* Git
* इंटरनेट कनेक्शन (पहली बार चलाने पर)
* पूर्ण कैश के लिए ~10GB डिस्क स्थान

### Pip से इंस्टॉल करें```bash
pip install pe-signgen

स्रोत से इंस्टॉल करें```bash

git clone https://github.com/forentfraps/pe-signgen.git cd pe-signgen pip install -r requirements.txt pip install -e .

---

## त्वरित आरंभ

### हस्ताक्षर उत्पन्न करें```bash
pe-signgen --signature ntdll!LdrLoadDll

ऑफ़सेट उत्पन्न करें```bash

pe-signgen --signature kernel32!CreateFileW --offsets

### JSON के रूप में सहेजें```bash
pe-signgen --signature ntdll!NtCreateFile -o out.json --output-format json

कमांड-लाइन विकल्प

मूल सिंटैक्स```bash

pe-signgen --signature DLL!FUNCTION [OPTIONS]

### आर्किटेक्चर```bash
--arch x64   # default
--arch arm64
--arch wow64

संस्करण फ़िल्टरिंग```bash

--os-version win10 # Only Windows 10 --os-version win11 # Only Windows 11 --min-version 10.0 # Minimum version --max-version 11.0 # Maximum version

### हस्ताक्षर लंबाई नियंत्रण```bash
--min-length 32          # Minimum signature length
--max-length 64          # Maximum signature length

आउटपुट विकल्प```bash

-o, --output PATH # Output file path --output-format FORMAT # json | binary | cheader --offsets # Generate offsets instead of signatures

### प्रदर्शन```bash
--workers 16             # Parallel workers (default: CPU count)
--no-cache               # Disable caching
--no-git-update          # Skip Winbindex updates

वाचालता```bash

--verbose # Detailed output --quiet # Minimal output --no-progress # Disable progress bars

## कैशिंग

### कैश लेआउट```text
~/.cache/pe-signgen/
│
├── dlls/           # Downloaded DLLs
├── pdbs/           # Downloaded PDBs
├── signatures/     # Generated signatures
└── winbindex_data/ # Winbindex metadata

कैश नियंत्रण```bash

Disable cache for fresh generation

pe-signgen --signature ntdll!NtCreateFile --no-cache

Clear cache

rm -rf ~/.cache/pe-signgen

Custom cache location

export PE_SIGNGEN_CACHE=/custom/path pe-signgen --signature ntdll!NtCreateFile

---

## प्रदर्शन

**उदाहरण प्रदर्शन (12-कोर CPU, 100 Mbps):**

| ऑपरेशन                         | समय        |
| --------------------------------- | ----------- |
| पहला रन (कोई कैश नहीं)              | 5–10 min    |
| कैश्ड रन                        | < 1 sec     |
| प्रति-बिल्ड विश्लेषण                | 0.1–0.5 sec |
| पूर्ण रन (1000 बिल्ड, 8 वर्कर्स) | 2–4 min     |

**संसाधन आवश्यकताएँ:**

* **डिस्क:** पूर्ण DLL/PDB कैश के लिए ~10 GB
* **मेमोरी:** ~500 MB पीक उपयोग
* **नेटवर्क:** पहले रन पर कई GB

---

## ज्ञात सीमाएँ

* **Windows संस्करण कवरेज:** केवल Windows **10 और 11** (Winbindex सीमा)
* **बिल्ड उपलब्धता:** हर Win10/11 बिल्ड Winbindex में मौजूद नहीं है

---

## विकास```bash
git clone https://github.com/forentfraps/pe-signgen.git
cd pe-signgen
pip install -e ".[dev]"

# Code formatting
black pe_signgen/

# Type checking
mypy pe_signgen/

लाइसेंस

MIT लाइसेंस – देखें LICENSE।

श्रेय

Winbindex – Windows बिल्ड मेटाडेटा @m417z द्वारा
pefile – PE पार्सिंग लाइब्रेरी
winpdb-rs – PDB पार्सिंग Python बाइंडिंग्स

आंतरिक Windows APIs के लिए मजबूत, स्वचालित सिग्नेचर जनरेशन की आवश्यकता से प्रेरित।

योगदान

योगदान का स्वागत है! कृपया:

रिपॉजिटरी को फोर्क करें
एक फीचर ब्रांच बनाएं
नई कार्यक्षमता के लिए परीक्षण जोड़ें
पुल रिक्वेस्ट सबमिट करें

सहायता

मुद्दे: GitHub Issues
चर्चाएं: GitHub Discussions

pe-signgen

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

pe-signgen

अवलोकन

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

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

1. JSON प्रारूप

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

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

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

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

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

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

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

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

Offset Entry (32 bytes)

WOFF C हैडर

स्रोत से इंस्टॉल करें```bash

ऑफ़सेट उत्पन्न करें```bash

कमांड-लाइन विकल्प

मूल सिंटैक्स```bash

संस्करण फ़िल्टरिंग```bash

आउटपुट विकल्प```bash

वाचालता```bash

कैश नियंत्रण```bash

Disable cache for fresh generation

Clear cache

Custom cache location

लाइसेंस

श्रेय

योगदान

सहायता