pe-signgen

Binäre Signaturen und RVA-Offsets für Windows-PE-Funktionen über verschiedene Versionen hinweg

Übersicht

pe-signgen ist ein Werkzeug für Reverse Engineers und Sicherheitsforscher, das automatisch generiert:

Binäre Signaturen (Byte-Muster mit Platzhaltern) für nicht exportierte und exportierte Funktionen
RVA- und Datei-Offsets zum direkten Auffinden von Funktionen in Binärdateien
Build-übergreifende Signaturen, die über viele Windows-Versionen hinweg funktionieren
Mehrere Ausgabeformate, optimiert für verschiedene Anwendungsfälle
Unterstützung für x64-, ARM64- und WoW64-Architekturen

Die Kernidee besteht darin, einen systematischen, robusten Weg zum Zugriff auf nicht exportierte Funktionen über Windows 10/11-Builds hinweg zu bieten. Es nutzt:

Winbindex für Windows-Build-Metadaten
Microsofts öffentliche Symbolserver für PDBs
Lokales Caching für reproduzierbare, offline-freundliche Arbeitsabläufe

⚠️ Windows-Versionsunterstützung pe-signgen unterstützt nur Windows 10 und Windows 11. Dies ist eine bewusste Designentscheidung: Winbindex bietet keine vollständigen Daten für ältere Versionen.

Anwendungsfälle

Nicht exportierte Windows-Interna Signaturen für Funktionen wie LdrpInitializeTls, RtlpInsertInvertedFunctionTableEntry, usw. generieren.
Game-Hacking / Anti-Cheat-Forschung Stabile Signaturen generieren, die Spielupdates überstehen
Sicherheitsforschung Sicherheitskritische Routinen über Windows-Builds hinweg lokalisieren
Automatisierung Skriptfähige Signatur- und Offset-Generierung für ganze Sätze interner APIs

Ausgabeformate

pe-signgen bietet drei verschiedene Ausgabeformate für unterschiedliche Anwendungsfälle:

1. JSON-Format

Strukturierte Daten für Automatisierung, Skripterstellung und Integration mit anderen Werkzeugen.```bash pe-signgen --signature ntdll!NtCreateFile -o ntcreatefile.json --output-format json

**Ausgabestruktur:**```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" }
      ]
    }
  ]
}

Notes:

major und minor werden aus dem Build-String abgeleitet, indem am ersten . geteilt wird. Beispiel: "10240.16384" → major = 10240, minor = 16384.
build ist der originale Build-String-Schlüssel, der intern verwendet wird.

2. Binärformat (WSIG/WOFF)

Kompakte, laufzeitbereite Binärformate, optimiert für eingebettete Systeme und Scans mit geringem Overhead.

Diese entsprechen dem On-Disk-Layout, das in write_wsig() und write_woff() implementiert ist.

WSIG-Format (Windows-Signatur)

Magie: WSO\0 (0x57 0x53 0x4F 0x00) Aktuelle Version: 1 Zweck: Speicherung von Binärsignaturen mit Wildcard-Masken und zugehörigen Windows-Build-Versionen

Dateistruktur (konzeptionell)```

┌─────────────────────────────────────┐ │ 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) │ └─────────────────────────────────────┘

**Wichtige Layout-Anmerkungen (entspricht `write_wsig`)**

* Nach dem Header werden die DLL- und Funktionsnamen als UTF‑8-Bytes geschrieben.
* Für jede Signaturgruppe werden die Pattern-Bytes und Mask-Bytes geschrieben, gefolgt vom Build-Array für diese Gruppe.
* Diese gruppenspezifischen Bereiche sind **nicht** global nach Typ gruppiert: Patterns, Masken und Build-Arrays können gemischt sein.
* Der Builder richtet sich vor jedem Build-Array und vor der Gruppentabelle auf **4 Bytes** aus. Dies kann Padding einführen.
* Konsumenten müssen **immer** den Offsets im Header und den Gruppeneinträgen folgen; verlassen Sie sich **nicht** auf das konzeptionelle Diagramm für die physische Kontiguität.

##### Header-Layout (36 Bytes)```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

Group Entry (24 bytes)

Jede Signaturgruppe repräsentiert ein eindeutiges Muster, das auf eine oder mehrere Windows-Builds zutrifft.```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

##### Build Version Entry (8 bytes)

Jeder Build-Eintrag identifiziert eine bestimmte Windows-Version, die diese Signatur verwendet.```c
typedef struct {
    uint32_t major; // e.g. 19041
    uint32_t minor; // e.g. 1234
} wsig_build_t; // 8 bytes

major und minor stammen aus der Aufteilung des Build-Strings ("A.B" → A, B). Der ursprüngliche Build-String wird nicht im Binärformat gespeichert; wenn Sie ihn benötigen, behalten Sie ihn extern (er ist in der JSON-Ausgabe vorhanden).

Wildcard-Maskenformat

Die Maske ist eine Bitmaske, wobei jedes Bit einem Byte im Signaturmuster entspricht:

Bit = 1: Byte muss exakt übereinstimmen (festes Byte)
Bit = 0: Byte ist wildcarded (dieses Byte wird beim Matching ignoriert)

Beispiel:``` 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)

Masken-Bytes werden in **Little-Endian-Bit-Reihenfolge** innerhalb jedes Bytes gespeichert und interpretiert (genau wie in den C-Helfern und `parse_signature` verwendet):```c
uint8_t bit = (mask_bytes[byte_index >> 3] >> (byte_index & 7)) & 1u;

Zeichenkettenspeicher

DLL- und Funktionsnamen werden als UTF‑8 gespeichert, ohne Nullterminatoren.
Verwenden Sie *_len, um die Länge zu bestimmen; lesen Sie nicht darüber hinaus.
Es gibt keine Ausrichtungsanforderungen für die Zeichenketten selbst.
Zusätzliche Datenbereiche (Build-Arrays und die Gruppen-Tabelle) sind an 4‑Byte-Grenzen ausgerichtet; behandeln Sie jegliches Padding als undurchsichtig.

WOFF-Format (Windows Offset)

Magic: WOF\0 (0x57 0x4F 0x46 0x00) Aktuelle Version: 1 Zweck: Speichert direkte RVA- und Datei-Offsets für Funktionen über Windows-Builds hinweg

Dateistruktur```

┌─────────────────────────────────────┐ │ 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) │ └─────────────────────────────────────┘

Layout-Details (entspricht `write_woff`):

* Nach dem Header-Platzhalter werden die DLL- und Funktionsnamen als UTF‑8-Bytes geschrieben.
* Für jeden Build wird der passende Symbolname als UTF‑8-String (ohne Terminator) geschrieben. Diese bilden einen einfachen String-Pool.
* Der Writer richtet dann auf 4 Bytes aus und schreibt die Tabelle mit Einträgen fester Größe.
* Jeder Eintrag enthält Offsets (`matched_off`, `matched_len`), die auf diesen String-Pool verweisen.

##### Header-Layout (36 Bytes)```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-Eintrag (32 Bytes)

Jeder Eintrag ordnet einem Windows-Build den Ort der Funktion in diesem Build zu.```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

##### Verwendungshinweise

* **RVA** ist der Speicherversatz, wenn die DLL an ihrer bevorzugten Basis geladen ist.
* **File offset** ist die rohe Position in der PE-Datei auf der Festplatte.
* **Matched symbol** kann von der angeforderten Funktion abweichen (z. B. weitergeleitete Exporte).
  Der String wird einmal im String-Pool gespeichert; `matched_off`/`matched_len` verweisen darauf.
* Einträge sind **nach Build-Version** sortiert (`major`, dann `minor`) für effiziente Suche.

---

#### Architekturcodes

Beide Binärformate verwenden die gleiche Architekturcodierung (über `ARCH_CODE_MAP`):

| Code | Architecture | Beschreibung                     |
| ---- | ------------ | -------------------------------- |
| 1    | x64          | 64-Bit AMD64/Intel64             |
| 2    | ARM64        | 64-Bit ARM (AArch64)             |
| 3    | WoW64        | 32-Bit x86 auf 64-Bit Windows    |

Unbekannte Architekturzeichenfolgen werden intern auf `1` (x64) standardmäßig gesetzt; die CLI schränkt Werte auf den unterstützten Satz ein.

---

### 3. **C-Header-Format**

Kompilierbereite C-Header mit typsicheren Strukturen und Datenfeldern.

`pe-signgen` kann zwei *Arten* von C-Headern ausgeben:

* **WSIG-Header** – für Signatur- und Maskendaten (von `write_wsig_header`).
* **WOFF-Header** – für direkte RVA/Dateiversetztabellen (von `write_woff_header`).

Die Option `--output-format cheader` wählt C-Header aus; die Kombination mit `--offsets` wechselt zwischen WSIG- und WOFF-Varianten.

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

Generierte Header-Struktur (vereinfacht, entspricht 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 */

**Integrationsbeispiel (korrigiert, um den generierten Typen zu entsprechen):**```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;
    }
}

Sie können dies dann in Ihren eigenen loader-spezifischen Code einbinden (z. B. mit GetModuleHandleA, Durchlaufen von PE-Abschnitten usw.). Der Header stellt absichtlich nur Daten bereit; Hilfsfunktionen bleiben dem Verbraucher überlassen.

WOFF C Header

Für reine Offset-Anwendungsfälle gibt write_woff_header einen kleinen Header aus, der eine sortierte Tabelle von (major, minor, rva, file_offset)-Einträgen beschreibt.

Layout (entspricht 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 */

Dies ist nützlich, wenn Sie den Offsets selbst vertrauen und kein Pattern-Matching benötigen.

---

## Installation

### Voraussetzungen

* Python 3.8+
* Git
* Internetverbindung (erster Durchlauf)
* ~10 GB Festplattenspeicher für vollständigen Cache

### Installation über Pip```bash
pip install pe-signgen

Installation aus dem Quellcode```bash

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

---

## Schnellstart

### Eine Signatur generieren```bash
pe-signgen --signature ntdll!LdrLoadDll

Offsets generieren```bash

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

### Als JSON speichern```bash
pe-signgen --signature ntdll!NtCreateFile -o out.json --output-format json

Befehlszeilenoptionen

Grundlegende Syntax```bash

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

### Architektur```bash
--arch x64   # default
--arch arm64
--arch wow64

Version Filterung```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

### Signaturlängensteuerung```bash
--min-length 32          # Minimum signature length
--max-length 64          # Maximum signature length

Ausgabeoptionen```bash

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

### Leistung```bash
--workers 16             # Parallel workers (default: CPU count)
--no-cache               # Disable caching
--no-git-update          # Skip Winbindex updates

Ausführlichkeit```bash

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

---

## Caching

### Cache-Layout```text
~/.cache/pe-signgen/
│
├── dlls/           # Downloaded DLLs
├── pdbs/           # Downloaded PDBs
├── signatures/     # Generated signatures
└── winbindex_data/ # Winbindex metadata

Cache-Steuerung```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

## Leistung

**Beispielhafte Leistung (12-Kern-CPU, 100 Mbit/s):**

| Vorgang                          | Zeit        |
| --------------------------------- | ----------- |
| Erster Durchlauf (kein Cache)     | 5–10 Min    |
| Zwischengespeicherter Durchlauf   | < 1 Sek     |
| Analyse pro Build                 | 0,1–0,5 Sek |
| Vollständiger Durchlauf (1000 Builds, 8 Worker) | 2–4 Min     |

**Ressourcenanforderungen:**

* **Festplatte:** ~10 GB für vollständigen DLL/PDB-Cache
* **Arbeitsspeicher:** ~500 MB Spitzenverbrauch
* **Netzwerk:** Mehrere GB beim ersten Durchlauf

---

## Bekannte Einschränkungen

* **Windows-Versionsabdeckung:** Nur Windows **10 und 11** (Winbindex-Einschränkung)
* **Build-Verfügbarkeit:** Nicht jeder Win10/11-Build ist in Winbindex vorhanden

---

## Entwicklung```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/

Lizenz

MIT-Lizenz – siehe LICENSE.

Danksagungen

Winbindex – Windows-Build-Metadaten von @m417z
pefile – PE-Parsing-Bibliothek
winpdb-rs – PDB-Parsing-Python-Bindungen

Inspiriert durch die Notwendigkeit einer robusten, automatisierten Signaturerzeugung für interne Windows-APIs.

Mitwirken

Beiträge sind willkommen! Bitte:

Forken Sie das Repository
Erstellen Sie einen Feature-Branch
Fügen Sie Tests für neue Funktionen hinzu
Reichen Sie einen Pull-Request ein

Unterstützung

Probleme: GitHub Issues
Diskussionen: GitHub Discussions

pe-signgen

Beliebteste

pe-signgen

Übersicht

Anwendungsfälle

Ausgabeformate

1. JSON-Format

2. Binärformat (WSIG/WOFF)

WSIG-Format (Windows-Signatur)

Dateistruktur (konzeptionell)```

Group Entry (24 bytes)

Wildcard-Maskenformat

Zeichenkettenspeicher

WOFF-Format (Windows Offset)

Dateistruktur```

Offset-Eintrag (32 Bytes)

WOFF C Header

Installation aus dem Quellcode```bash

Offsets generieren```bash

Befehlszeilenoptionen

Grundlegende Syntax```bash

Version Filterung```bash

Ausgabeoptionen```bash

Ausführlichkeit```bash

Cache-Steuerung```bash

Disable cache for fresh generation

Clear cache

Custom cache location

Lizenz

Danksagungen

Mitwirken

Unterstützung