The Export Address Table is a structure in a Windows Portable Executable file that lists the functions a module makes available to other code. Loaders and import resolvers use it to find exported entry points by name or ordinal, and malware analysts inspect it to map callable functions and resolved API behaviour.
What the Export Address Table does
The Export Address Table, or EAT, is the part of a Windows Portable Executable that points other code to the functions a module exposes. It is not the function body itself, but the lookup structure that lets a loader or import resolver turn an exported name or ordinal into an executable address.
Because the table sits at the boundary between a module and anything that wants to call it, it is a small structure with outsized importance. If an analyst understands how the EAT is laid out, they can reason about which APIs a binary claims to offer and how that binary may be resolving or redirecting calls at runtime.
Why the Export Address Table matters in PE analysis
In practical reverse engineering, the EAT is one of the first places to inspect when you need to understand a DLL or executable’s callable surface. Export names reveal the intended interface, while ordinals can show where a module expects consumers to bind by number rather than by symbol. That distinction matters when strings are stripped, when symbols are incomplete, or when the binary is using a compact export scheme.
The table also helps distinguish declaration from implementation. A module can advertise an export name, but the EAT tells you where that name resolves inside the image. That makes it useful for mapping API behaviour, especially when exports are forwarded, wrapped, or implemented through thunks rather than direct function bodies.
How loaders and analysts use EAT data
Windows loaders and import resolvers use the EAT to locate the address of an exported entry point once a caller asks for a name or ordinal. In legitimate software, that supports dynamic linking and modular design. In analysis work, the same lookup path helps identify what external code can invoke and whether the module exposes more surface area than the import table alone suggests.
Analysts often compare the EAT with imports, disassembly, and runtime traces to see whether a function is a real implementation, a forwarded export, or a redirection point. That comparison can surface plugin-style designs, compatibility shims, and API forwarding chains that are easy to miss if you only read symbol names.
Why malware and defensive tooling care about export tables
Malware analysts inspect the EAT because it can reveal callable functions even when other clues are sparse. A suspicious module may export helper routines, expose misleading names, or use export forwarding to hide where code execution actually lands. The table can also help defenders understand how a binary expects to be loaded, which functions are likely to be reached externally, and where API resolution may support injection or hooking behaviour.
For defenders, the EAT is part of the broader trust boundary of a PE file. A change in exported entry points, unexpected forwarding, or a mismatch between expected and observed exports can be a useful signal during triage, especially when paired with import analysis and runtime monitoring.
Risk and Threat Considerations
The EAT is a legitimate loader structure, but it is also a natural target for abuse because it influences where callers are routed. Attackers can exploit export resolution, redirection, or API hooking to alter execution flow, hide malicious behaviour, or make a module present a safer looking interface than it really provides.
Failure mechanism: If exported addresses are manipulated, forwarded unexpectedly, or interpreted without validation, callers may resolve to attacker-controlled code paths or miss the true implementation behind a benign-looking export.
Impact: This can support code injection, persistence, deception during analysis, and control-flow manipulation in both user space and defensive tooling that trusts the export map too much.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
MITRE ATT&CK addresses the attack and risk surface, while NIST SP 800-53 Rev 5 sets the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| MITRE ATT&CK | T1055 — Process Injection | EAT manipulation can support injected or redirected execution paths. |
| T1218 — System Binary Proxy Execution | Forwarded or redirected exports can help disguise execution through trusted binaries. | |
| T1574 — Hijack Execution Flow | Export table tampering can redirect callers to attacker-chosen code paths. | |
| Recommendation — Correlate export anomalies with process-injection detections and hunt for unexpected module redirection. Inspect trusted binaries for proxy-execution patterns and verify resolved export targets. Map export-resolution anomalies to execution-flow hijacking and validate module integrity. | ||
| NIST SP 800-53 Rev 5 | SI-4 — System Monitoring | Export anomalies and runtime resolution drift are monitoring signals for malicious behavior. |
| SI-7 — Software, Firmware, and Information Integrity | The EAT is part of the integrity picture for a PE module's advertised interface. | |
| Recommendation — Monitor module-loading and export-resolution telemetry for unexpected code-path changes. Validate module integrity when exports, forwarding, or resolved entry points differ from expectation. | ||
Practitioner Guidance
What to watch for: Treat the EAT as one signal, not the whole picture. Compare it with imports, section layout, symbol data, and observed runtime behaviour so you can tell whether the export map matches the code actually present in the module.
Why practitioners should care: A clean-looking export list can still conceal forwarding, indirection, or post-load manipulation. When you review a PE file, the EAT helps you decide whether the module is behaving like a normal library, a wrapper, or a potentially deceptive loader target.
Practitioner takeaway: Use the export table to map intended interface, then validate that the runtime behaviour and resolved addresses support that interface.
Related resources from NHI Mgmt Group
Deepen Your Knowledge
Free weekly newsletter
Subscribe to the NHI & AI Identity Journal
The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.
Bonus 33% off our NHI Course when you subscribe.
Reviewed and updated by the NHIMG editorial team on November 16, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org