Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
intel-me-research — Sprich direkt mit deiner Intel Management Engine — Python-Tool ohne Abhängigkeiten. Findet Speicherlecks, Partitionsmanifest, Live-MKHI-Sondierung. Erster öffentlicher HECI Spy. | Kitploit
Tools/GitHubGitHub/jatinkapilaq1/intel-me-research
Embedded-System-SicherheitSchwachstellenanalyseReverse EngineeringInformationsbeschaffungHardware-SicherheitBinäranalyseFirmware-Analyse
GitHubjatinkapilaq1/intel-me-research

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

intel-me-research

Sprich direkt mit deiner Intel Management Engine — Python-Tool ohne Abhängigkeiten. Findet Speicherlecks, Partitionsmanifest, Live-MKHI-Sondierung. Erster öffentlicher HECI Spy.

Repository anzeigen
1329vor 1 MonatNoch nicht geprüft

Reverse Engineering der Intel-ME-Firmware — Live-Analyse von CSME 16.x

„In deinem Computer steckt ein geheimer zweiter Computer. Wir haben ihn gefunden, kartiert und dokumentiert, was sich dort versteckt."

🔥 PROBIER ES SELBST AUS — HECI SPY 🔥

Ein Python-Skript. Null Abhängigkeiten. Sprich direkt mit deiner Intel Management Engine.

root@kitploit:~
python scripts/heci_spy.py
# Requirements: Windows, Python 3.6+, Run as Administrator

Was es tut:

  • Erkennt dein Intel-HECI/MEI-Gerät automatisch
  • Stellt über das MKHI-Protokoll eine Verbindung zur ME her
  • Fragt Firmware-Version, Partitions-Manifest und versteckte Werte ab
  • Findet das Speicherleck — GEN.1B liefert bei jedem Lauf einen anderen Wert
  • Speichert einen teilbaren Bericht mit vollständigem Roh-Hex-Log

Gerade auf einem Lenovo IdeaPad Gaming 3 (i7-12650H, CSME 16.0.15.1735) ausgeführt:

root@kitploit:~
MKHI v3.1 | FW 16.0.1735.15 | 8 partitions found | GEN.1B: 0x00C344CA (changes each run!)

Wir haben bestätigt: 7/12 MKHI-Befehle antworten. Die ME ist aktiv, kommuniziert und leakt Speicher.

▶️ 35-Sekunden-Demo ansehen — (Rechtsklick > Speichern unter, oder bei YouTube hochladen für die Inline-Wiedergabe)

📊 Die vollständige 21-Folien-Präsentation ansehen


🏆 WELTPREMIERE

Dies ist die erste öffentliche Offenlegung der vollständigen internen Struktur der Intel-CSME-16.x-Firmware (Alder Lake), dekodiert aus Live-Hardware.

Niemand hat jemals veröffentlicht:

  1. Die vollständige IFWI-Dateisystemkarte — 80 interne Pfade von CSME 16.x
  2. Die exakte Hardware-Konfiguration — JSON-Konfigurationsblöcke, die die Laptop-Verdrahtung zeigen
  3. Die vollständige X.509-Zertifikatsvertrauenskette — 13 dekodierte Zertifikate
  4. Der ROM-Bypass-Boot-Mechanismus — wie die ME vor deinem BIOS bootet
  5. Die ME-Fähigkeitskarte — 11 Zugriffsdomänen aus Firmware-Beweisen
  6. 28 Sicherheitsstrukturen, aus der Live-Firmware kartiert
  7. ~2,9 MB lesbare Firmware von einem Live-System mit Intel CSME 16.x

Alles von einem Lenovo IdeaPad Gaming 3 mit Intel Core i7-12650H (12. Generation Alder Lake).

TL;DR

Die Intel Management Engine (ME) ist ein verborgener Mikrocontroller, der in jede moderne Intel-CPU eingebaut ist. Sie läuft mit einem eigenen Betriebssystem, hat einen eigenen Prozessor (Synopsys ARC EM) und arbeitet 24/7 — selbst wenn dein PC vollständig heruntergefahren ist. Die meisten Menschen wissen, dass sie existiert. Fast niemand hat einen Blick hineingeworfen.

Dieses Projekt schon.

Wir haben erfolgreich:

  • heci_spy.py entwickelt — das erste öffentliche Tool ohne Abhängigkeiten, das live über HECI/MKHI mit der Intel ME spricht
  • Ein Speicherleck gefunden — GEN.1B liefert bei jedem Lauf andere Werte (Adresszeiger-Leck)
  • Die Live-Firmware direkt von der Intel-ME-Hardware ausgelesen (4,8 MB)
  • Alle 29 internen Module und ihren Zweck identifiziert
  • Die Architektur des geheimen ARC-Prozessors anhand von Roh-Firmware-Strings bestätigt
  • Das vollständige 80-Pfade-IFWI-Dateisystem von CSME 16.x kartiert
  • 8 JSON-Hardware-Konfigurationsblöcke dekodiert, die die exakte Laptop-Verdrahtung zeigen
  • 13 X.509-Zertifikate extrahiert und dekodiert, die die Vertrauenskette bilden
  • Den ROM-Bypass-Boot-Mechanismus dokumentiert — die ME läuft vor deinem BIOS
  • Die Datentabelle der OverClocking-Engine in der ME-Firmware gefunden
  • 28 von 35 Sicherheitsstrukturen in der Firmware kartiert
  • 8/8 permanente, irreversible Sicherheitssperren dokumentiert
  • MEAnalyzer gepatcht, um CSME 16.x zu unterstützen (war zuvor defekt)

🗺️ WELTPREMIERE: Vollständige interne Firmware-Karte

root@kitploit:~
IfwiRoot/ (THE ENTIRE FIRMWARE)
├── BiosRegion (Your BIOS — 24MB)
├── DescriptorRegion (Flash layout)
│   ├── FDBAR/ (Flash Database)
│   │   ├── FLASH_VALID_SIGNATURE
│   │   ├── FLMAP0-4 (Component maps)
│   │   └── EcRegionPointer ← EC firmware pointer
│   ├── PchStraps (PCH hardware config)
│   │   ├── PCH_Strap_DMI_OPDMI_TLS: "4 GT/s"
│   │   ├── PCH_Strap_DMI_OPD_LVO: "0.95 Volts"
│   │   └── PCH_Strap_FIA_LOSL0-3: USB3/PCIe config
│   ├── MipDesc/ (Management Engine descriptors)
│   │   ├── PmcStraps (PMC config — Type-C ports)
│   │   └── DbCStraps (Debug Capability)
│   ├── MasterAccessPermissions ← SECURITY LOCKS
│   ├── OEM (Lenovo OEM data)
│   └── VsccTable (SPI flash component table)
│
├── CseRegion (THE INTEL ME — 4.8MB)
│   ├── RomBypass ← HIDDEN BOOT MECHANISM
│   ├── RomBypassVector (Jump table)
│   ├── BPDT1/ (Boot Partition Table 1)
│   │   ├── FTPR (Fault Tolerant Recovery — 2.2MB)
│   │   ├── RBE (ROM Bypass Engine)
│   │   ├── PMC (Power Management)
│   │   ├── IOM (Intel Orchestrator Manager)
│   │   ├── NPHY (Network PHY firmware)
│   │   ├── IDLM (Dynamic Link Manager)
│   │   ├── TBTP (Thunderbolt — 40KB readable)
│   │   ├── OEM_KM (OEM Key Manifest — Lenovo's keys)
│   │   └── PCHC (PCH Configuration)
│   ├── BPDT3/
│   │   ├── NFTP (Non-Fault Tolerant — 436KB readable)
│   │   ├── ISHC (Integrated Sensor Hub — 88KB)
│   │   ├── IUNIT (Intel Unit firmware)
│   │   └── GBST (Performance Boost)
│   └── DATA_PARTITION/
│       ├── FLOG (Flash Log)
│       ├── ELOG (Event Log)
│       ├── EFS (Encrypted File System)
│       ├── FITC/ (Flash Image Tool Config)
│       │   ├── HmrfpoNvar (HMRFPO config)
│       │   ├── ConfigRulesNvar (Configuration rules)
│       │   ├── PavpHdcpNvar (DRM/ HDCP config)
│       │   ├── ChipsetInit (Chipset initialization)
│       │   ├── EomNvar (End-of-Manufacturing config)
│       │   ├── TbtConfigDataNvar (Thunderbolt config)
│       │   └── CameraGpioNvar (Camera GPIO config)
│       ├── HVMP (Hypervisor Management Policy)
│       ├── IVBP (Intel Verified Boot Policy)
│       ├── IMDP (Intel Management Data Path)
│       └── UTOK (Unit Token — device authentication)
│
├── EcRegion (Embedded Controller firmware)
├── GbeRegion (Gigabit Ethernet MAC)
└── SigningContainer (Intel signing blob)

🗺️ WELTPREMIERE: Dekodierte Hardware-Konfiguration

root@kitploit:~
// Platform Identification (at ME+0x29C134)
{
    "StrapsProject": "adp_p_straps.xml",
    "HarnessProject": "ADP-P PCH (w/ADL-P / M CPU) RDL v1.0.2.5",
    "HarnessLabel": "v1.30 ADP-P (Harness #50)",
    "SelectedRvp": "ADL-P DDR4 (ADL-P + ADP-P)"
}

// PCH Strap Configuration (at ME+0x29C523)
{
    "PCH_Strap_DMI_OPDMI_TLS": "4 GT/s",
    "PCH_Strap_DMI_OPD_LVO": "0.95 Volts",
    "PCH_Strap_FIA_LOSL0": "USB3",
    "PCH_Strap_FIA_LOSL1": "USB3",
    "PCH_Strap_FIA_LOSL2": "PCIe",
    "PCH_Strap_FIA_LOSL3": "PCIe"
}

// PMC Type-C Port Configuration (at ME+0x29C753)
{
    "PD0_Type_C_Port_Enabled": "Yes",
    "PD0_USB2_Port": "USB2 Port 2",
    "PD1_Type_C_Port_Enabled": "No",
    "PD2_Type_C_Port_Enabled": "No",
    "PD3_Type_C_Port_Enabled": "No"
}

// BootGuard Profile (at ME+0x29D38F)
{ "BtGuardProfileConfig": 3 }

🏆 WELTPREMIERE: Zertifikats-Vertrauenskette

root@kitploit:~
Intel On-Die Root CA (ODCA CA2)
  │ https://tsci.intel.com/.../ODCA_CA2_CSME_Indirect.crl
  └── signs
CSME ADL ROM CA0 (Root of Trust — CPU fuses)
  │ Serial: 0x01 | SHA-256: 86474ecc2fc0c74b
  │ BURNED INTO HARDWARE — CANNOT be changed
  ├── signs
  │   CSME ADL SVN01 Kernel CA0 (Core ME OS)
  │   └── signs CSME ADL PAVP 01SVN0 (DRM)
  │       └── signs PAVP SGX CP0 + Playready
  └── signs
      CSME ADL PTT 01SVN0 (Platform Trust)
      └── signs 3 PTT signing certificates

Zielsystem

Was ist Intel ME?

Intel ME (auch Intel Management Engine oder CSME genannt) ist ein autonomes Subsystem, das in den Platform Controller Hub (PCH) eingebettet ist. Sie ist seit 2008 in jedem Intel-Consumer-Chipsatz vorhanden.

root@kitploit:~
 +-------------------------------------------------------+
 |                    YOUR COMPUTER                       |
 |                                                       |
 |  +-----------+    +-----------+    +---------------+  |
 |  |           |    |           |    |               |  |
 |  |  Windows  |    |   Linux   |    |  Intel ME     |  |
 |  |  (your OS)|    | (maybe)   |    |  (secret OS)  |  |
 |  |           |    |           |    |               |  |
 |  +-----------+    +-----------+    +---------------+  |
 |       |                |                |             |
 |       +------- CPU ---+------- PCH ----+             |
 |                                                       |
 |  You control this          You NEVER see this        |
 +-------------------------------------------------------+

Was die ME tun kann (und du kannst es nicht verhindern)

  • Deinen RAM lesen — voller Zugriff auf den gesamten Speicher, sogar wenn der PC „aus" ist
  • Auf dein Netzwerk zugreifen — hat einen eigenen TCP/IP-Stack und eine eigene Netzwerkverbindung
  • Deinen Bildschirm sehen — kann die Bildschirmausgabe über DRM erfassen
  • Deine Firewall umgehen — arbeitet unterhalb des Betriebssystems, für jede Software unsichtbar
  • Vor deinem Betriebssystem booten — beginnt mit der Ausführung, bevor BIOS/UEFI überhaupt geladen wird
  • Kann nicht deaktiviert werden — keine BIOS-Einstellung, kein OS-Befehl, keine Software deaktiviert sie

Die 29 verborgenen Module

Wir haben alle 29 Module entdeckt, aus denen das interne Betriebssystem der ME besteht:

Kernsystem

Sicherheit & Krypto

Kommunikation

Plattform-Dienste

Konfiguration

Wie wir es gemacht haben

Phase 1: BIOS-Extraktion

root@kitploit:~
Lenovo BIOS Update (JMCN48WW) -> Extracted Win_JMCN.BIN (34.1 MB)

Wir haben Standard-BIOS-Extraktionstools verwendet, um das rohe Firmware-Image aus dem offiziellen Lenovo-Update-Paket zu ziehen.

Phase 2: Intel-ME-Tools

root@kitploit:~
CSME System Tools v16.1
├── MEInfoWin64    -> Queried live ME hardware status
├── FPTW64         -> Dumped live ME firmware from SPI flash
└── MEManufWin64   -> Ran hardware self-tests (10/10 passed)

Wir haben Intels eigene Engineering-Tools verwendet, um über die HECI/MEI-Schnittstelle mit der ME-Hardware zu kommunizieren.

Phase 3: Firmware-Analyse

root@kitploit:~
ME_region.bin (4,943,872 bytes)
├── $FPT at 0x216000     -> Flash Partition Table
├── $CPD at FTPR+0x00    -> Code Partition Directory (29 modules)
├── $MN2 at FTPR+0x2CC   -> Manifest v2 (RSA signatures)
├── X.509 Cert           -> "CSME ADL ROM CA0" (Root CA)
├── Entropy Analysis     -> 85% encrypted, 15% readable
└── ARC Strings          -> Processor architecture confirmed

Phase 4: Modul-Identifikation

root@kitploit:~
FTPR Partition Layout:
Offset 0x0000 - 0x0014  CPD Header (20 bytes)
Offset 0x0014 - 0x049C  CPD Entries (29 x 24 bytes)
Offset 0x02CC - 0x0840  FTPR.man (manifest)
Offset 0x0840 - 0x0888  intl.cfg.met (metadata)
Offset 0x1000 - 0x1798  rot.key (Root of Trust)
Offset 0x2000+          AES-encrypted modules

Phase 5: Architektur-Bestätigung

root@kitploit:~
Unencrypted code at ME+0x1C1000 contains:
  "ARC PARM"   -> ARC Processor Parameters register
  "DROM"       -> ARC Data ROM constant storage
  "EE_CIO"     -> ARC Core I/O exception handler
  "EE_DMA"     -> ARC DMA exception handler
  "EE_LC"      -> ARC Loop Count exception
  "PATCHES"    -> Processor microcode patches
  "APP EM"     -> Application Emulation layer

Sicherheitslage

Aus Live-Abfragen der ME-Hardware:

Das bedeutet: Diese ME-Instanz ist auf Hardware-Ebene dauerhaft gesperrt. Es gibt keine rein softwarebasierte Methode, sie zu verändern, zu deaktivieren oder zu umgehen. Dazu wäre eine physische SPI-Flash-Programmierung mit Hardware-Werkzeugen erforderlich — und selbst dann können die durchgebrannten Fuses im PCH nicht rückgängig gemacht werden.

MEAnalyzer-Fix

MEAnalyzer v1.311.0 stürzt mit KeyError: '01' ab, wenn CSME-16.x-ADL-Firmware analysiert wird, da ein nicht unterstützter Lookup im EFS-Dateisystem-Wörterbuch (EFS File System Dictionary) erfolgt.

Fix: Die Funktion efs_anl() wurde so gepatcht, dass sie sicheren Wörterbuchzugriff verwendet (dict.get() statt direkter Schlüsselindizierung), und der EFS-Analyseaufruf wurde in einen try/except-Block gekapselt.

root@kitploit:~
# Before (crashes):
if 'EFST' in ftbl_dict[ftbl_plat_id][ftbl_dict_id]:

# After (safe):
if ftbl_plat_id in ftbl_dict and ftbl_dict_id in ftbl_dict[ftbl_plat_id] and 'EFST' in ftbl_dict[ftbl_plat_id][ftbl_dict_id]:

Verwendete Tools

Projektstruktur

root@kitploit:~
intel-me-research/
├── README.md                    # This file
├── scripts/
│   ├── heci_spy.py              # 🔥 FLAGSHIP: Talk to your Intel ME directly
│   ├── analyze_cpd.py           # Code Partition Directory parser
│   ├── analyze_me_region.py     # Full ME region analysis
│   ├── extract_modules.py       # Module extraction tool
│   └── patch_mea.py             # MEAnalyzer fix for CSME 16.x
├── evidence/
│   ├── WORLD_FIRST_EVIDENCE.py  # Master evidence presentation
│   ├── DEEPER_LAYER.py          # Timestamp + EC + cert analysis
│   ├── NUCLEAR_SCAN.py          # Complete flash + security map
│   ├── DEEP_SECRET_HUNT.py      # Secret hunting script
│   ├── DEEP_DIVE_3.py           # JSON config + cert decoding
│   ├── DECODE_CERTIFICATES.py   # X.509 certificate decoder
│   └── certs/                   # Extracted DER certificates (13)
├── docs/
│   ├── METHODOLOGY.md           # Detailed methodology
│   └── FINDINGS.md              # All findings with evidence
└── results/
    ├── modules_summary.csv      # Module inventory
    └── security_posture.csv     # Security status results

Haftungsausschluss

Dieses Projekt dient ausschließlich Bildungs- und Forschungszwecken. Die hier gezeigten Tools und Techniken sollten nur auf Hardware verwendet werden, die dir gehört. Unbefugter Zugriff auf Computersysteme ist illegal. Diese Forschung zielt darauf ab, das Verständnis von Hardwaresicherheit für defensive Zwecke zu verbessern.

Autor

Gebaut mit Neugier und Koffein. Dieses Projekt zeigt, dass Hardwaresicherheitsforschung zugänglich ist — du brauchst kein Labor und keine teure Ausrüstung. Nur einen Laptop, Entschlossenheit und die richtigen Werkzeuge.


Wenn dir dieses Projekt geholfen hat, Hardwaresicherheit zu verstehen, gib ihm einen Stern. Wenn du etwas Neues gefunden hast, eröffne ein Issue. Machen wir Hardwaresicherheitsforschung offen und für alle zugänglich.

Tool herunterladen
EigenschaftWert
LaptopLenovo IdeaPad Gaming 3 15IAH7 (82S9)
CPUIntel Core i7-12650H (12. Generation Alder Lake)
ME-VersionCSME 16.0.15.1735
ME-SKUConsumer LP
ME-Datum2022-02-17
BuildJMCN48WW
PCHADL Device 5182, Rev A1
ModulGrößeZweck
kernel106 KBDer OS-Kernel — das Gehirn des geheimen Computers
bup312 KBBoot Up — der erste Code, der beim Einschalten des PCs ausgeführt wird
syslib148 KBSystembibliothek — zentrale OS-Funktionen
loadmgr28 KBModul-Lader — lädt andere Module dynamisch
vfs92 KBVirtuelles Dateisystem — verwaltet den internen ME-Speicher
evtdisp16 KBEreignisverteiler — behandelt Interrupts und Ereignisse
maestro16 KBOrchestrierungs-Engine — koordiniert Subsysteme
ModulGrößeZweck
crypto216 KBAES/RSA/HMAC — verschlüsselt alles, was die ME berührt
policy36 KBSicherheitsrichtlinien-Engine — entscheidet, was DU tun kannst
fpf20 KBFused Protection Fuses — in Hardware verwurzelte Schlüssel
rot.key2 KBRoot-of-Trust-Schlüssel — die kryptografische Identität der ME
mca_boot16 KBBoot-Authentifizierung — prüft die Firmware-Integrität
mca_srv28 KBLaufzeit-Sicherheit — überwacht das System kontinuierlich
ModulGrößeZweck
heci36 KBHost-Embedded-Controller-Schnittstelle — CPU<->ME-Bus
ipc_drv16 KBInterprozesskommunikation — Nachrichtenaustausch zwischen Modulen
sec_msg4 KBSichere Nachrichtenübermittlung — verschlüsselte interne Nachrichten
prtc8 KBProtokoll-Handler — Kommunikationsprotokolle
smbus8 KBSMBus-Schnittstelle — Kommunikation mit Hardware-Sensoren
busdrv8 KBBustreiber — interne Kommunikation
ModulGrößeZweck
ptt164 KBIntel PTT — Firmware-TPM-Ersatz
pm16 KBPower Manager — Schlaf-/Aufwachzustände
pmdrv12 KBPower-Management-Treiber
fwupdate36 KBFirmware-Update — aktualisiert die ME im Hintergrund
storage72 KBFlash-Speicher — liest/schreibt SPI-Flash
gpio8 KBGPIO-Controller — physische Pin-Steuerung
ModulGrößeZweck
intl.cfg18 KBIntel-Konfiguration — Plattformeinstellungen
FTPR.man1 KBFirmware-Manifest — Integritäts-Metadaten
fitc.cfg0 KBFlash-Image-Tool-Konfiguration (leerer Platzhalter)
intl.cfg.met72 BPrüfsumme der Konfigurations-Metadaten
SicherheitsfunktionStatusBedeutung
FPF CommittedJaEinmalige Fuses dauerhaft durchgebrannt
PCH UnlockedDeaktiviertHardware-Sperre aktiv
Flash ProtectionGeschütztSPI-Flash schreibgeschützt
BootGuard Profile3 (Voll)Maximale Boot-Verifizierung
Measured BootAktiviertJede Boot-Komponente wird gehasht
NVAR ConfigGesperrtKonfiguration kann nicht geändert werden
EOM SettingsSperreEnd-of-Manufacturing gesperrt
FWUpdate SupportNeinFirmware-Updates deaktiviert
CPU DebuggingAktiviertIntel kann debuggen (du nicht)
ToolZweck
heci_spy.py 🔥Unser HECI Spy — sprich live mit der Intel ME, ohne Abhängigkeiten
Intel MEInfoWin64 v16.1Live-Abfrage der ME-Hardware
Intel FPTW64 v16.1Live-SPI-Flash-Dump
Intel MEManufWin64 v16.1Fertigungs-Selbsttests
MEAnalyzer v1.311.0Firmware-Metadaten-Analyse
Radare2 6.1.8Binär-Disassemblierung
Python 3.14Eigene Analyse-Skripte
Ghidra 11.3.2Reverse Engineering von Firmware