
IAT e EAT no Windows: como funcionam as tabelas de importação e exportação
IAT e EAT no Windows: como funcionam as tabelas de importação e exportação
Quando um programa Windows utiliza uma função fornecida por uma DLL, existe uma infraestrutura do formato PE (Portable Executable) responsável por relacionar o executável às funções disponíveis nas bibliotecas.
Duas estruturas são especialmente importantes para compreender esse mecanismo:
- IAT — Import Address Table
- EAT — Export Address Table
Embora os nomes sejam parecidos, elas desempenham papéis diferentes. A EAT descreve as funções que um módulo disponibiliza para outros módulos, enquanto a IAT contém os endereços utilizados pelo módulo que está fazendo a importação.
Compreender essas estruturas é fundamental para estudar Windows Internals, formato PE, carregamento de DLLs, análise de malware, debugging e engenharia reversa.
1. O modelo básico
Considere um programa Programa.exe que utiliza uma função chamada FuncaoA, disponibilizada por Biblioteca.dll.
Podemos representar a relação de forma simplificada:
Programa.exe
|
| importa FuncaoA
v
IAT
|
| endereço resolvido
v
Biblioteca.dll
|
| exporta FuncaoA
v
EAT
Em termos conceituais:
Programa \rightarrow IAT \rightarrow Endereço(FuncaoA)
Enquanto a DLL possui:
Biblioteca.dll \rightarrow EAT \rightarrow FuncaoA
Portanto, podemos pensar em:
\boxed{IAT = tabela\ de\ endereços\ das\ importações}
e:
\boxed{EAT = tabela\ associada\ às\ funções\ exportadas}
2. O que é a EAT?
A Export Address Table faz parte das estruturas de exportação de um módulo PE.
Uma DLL pode disponibilizar determinadas funções para que outros módulos possam utilizá-las.
Por exemplo, conceitualmente:
Biblioteca.dll
Exportações:
FuncaoA
FuncaoB
FuncaoC
A EAT participa da associação entre uma exportação e seu endereço relativo dentro do módulo.
Podemos representar uma função exportada como:
Export(Function_i) \rightarrow RVA_i
Onde:
Function_i= função exportada;RVA_i= Relative Virtual Address da função.
O endereço virtual efetivo pode ser representado simplificadamente por:
VA_i = Base_{DLL} + RVA_i
Assim:
\boxed{VA_{Function}=ImageBase+RVA_{Function}}
O uso de RVA é importante porque os módulos PE podem ser carregados em endereços diferentes daqueles previstos originalmente.
3. Nome, ordinal e endereço
Uma exportação pode ser identificada por diferentes mecanismos.
Conceitualmente:
Nome → função
ou:
Ordinal → função
Podemos representar a resolução por nome como:
Resolve(Name) \rightarrow Ordinal \rightarrow RVA \rightarrow VA
E, de forma simplificada:
Name
↓
Export Directory
↓
RVA
↓
VA
Isso permite que outro módulo encontre uma função disponibilizada pela DLL.
4. O que é a IAT?
A Import Address Table está relacionada às funções que um módulo utiliza de outros módulos.
Imagine:
Programa.exe
que depende de:
Biblioteca.dll
e utiliza:
FuncaoA
FuncaoB
Durante o carregamento, o sistema precisa resolver essas referências.
O resultado conceitual pode ser representado como:
Programa.exe
IAT:
+----------------------+
| endereço de FuncaoA |
+----------------------+
| endereço de FuncaoB |
+----------------------+
Matematicamente:
IAT[i] = VA(Function_i)
Depois que uma importação é resolvida, a entrada correspondente pode ser vista conceitualmente como:
\boxed{IAT[i]\rightarrow endereço\ da\ função}
5. IAT e EAT trabalham em conjunto
A relação pode ser simplificada desta maneira:
Bibliotecta.dll
+-------------------+
| EAT |
| FuncaoA → RVA |
| FuncaoB → RVA |
+---------+---------+
|
| resolução
v
+-------------------+
| IAT |
| FuncaoA → VA |
| FuncaoB → VA |
+---------+---------+
|
v
Programa.exe
Portanto, a EAT está associada ao lado de exportação, enquanto a IAT está associada ao lado de importação.
Uma abstração útil é:
Exportação:
Nome \rightarrow RVA
e:
Importação:
Nome \rightarrow VA
6. RVA, VA e Image Base
Para compreender PE Internals, é importante diferenciar esses conceitos.
RVA
Relative Virtual Address é um deslocamento relativo à base de carregamento da imagem.
RVA = VA - ImageBase
Logo:
VA = ImageBase + RVA
VA
Virtual Address representa o endereço virtual utilizado pelo processo.
Assim:
\boxed{VA = Base + RVA}
Por exemplo, hipoteticamente:
ImageBase = 0x10000000
RVA = 0x00001234
Então:
VA = 0x10000000 + 0x1234
resultando em:
0x10001234
Esse exemplo é apenas matemático; o endereço real de um módulo depende do processo e de mecanismos modernos de carregamento, como ASLR.
7. O fluxo conceitual de uma importação
Podemos representar o processo de resolução de uma importação como:
Import(Name)
\rightarrow
FindModule
\rightarrow
FindExport(Name)
\rightarrow
RVA
\rightarrow
VA
\rightarrow
IAT[i]
De maneira compacta:
\boxed{
IAT[i] = Base_{DLL} + RVA(Export_i)
}
Essa equação representa a ideia fundamental: a entrada da IAT acaba associada ao endereço virtual da função que o programa pretende utilizar.
8. IAT Hooking
É importante diferenciar IAT hooking de DLL injection.
No IAT hooking, a ideia conceitual é alterar uma referência existente na tabela de importação.
Antes:
IAT[i] = Address_{Original}
Depois:
IAT[i] = Address_{Hook}
Visualmente:
ANTES
Programa
|
v
IAT[i]
|
v
Função original
Depois:
DEPOIS
Programa
|
v
IAT[i]
|
v
Função alternativa
O princípio matemático pode ser resumido como:
\boxed{
IAT_{novo}[i] \neq IAT_{original}[i]
}
O programa continua consultando a IAT, mas a referência armazenada naquela posição foi modificada.
9. IAT Hooking não é EAT Hooking
Os dois mecanismos podem parecer semelhantes, mas modificam conceitos diferentes.
IAT
O alvo é a referência de importação:
IAT[i] = Address_{Function}
Uma alteração conceitual seria:
IAT[i] \leftarrow Address_{Hook}
EAT
O alvo está relacionado à informação de exportação de um módulo:
Export[i] \rightarrow RVA_{Function}
Uma alteração conceitual seria:
Export[i] \rightarrow RVA_{Outro}
Portanto:
IAT → "Quem eu utilizo?"
EAT → "O que este módulo disponibiliza?"
Essa é uma simplificação didática, mas ajuda bastante a separar os conceitos.
10. IAT/EAT e o formato PE
Tanto importações quanto exportações fazem parte da arquitetura do formato Portable Executable.
Um PE contém estruturas organizadas por diretórios de dados.
Entre os conceitos importantes estão:
PE
│
├── Headers
│
├── Sections
│
├── Import Directory
│ └── Import information
│
└── Export Directory
└── Export information
A Import Directory está relacionada à resolução das dependências externas.
A Export Directory descreve informações necessárias para localizar elementos exportados pelo módulo.
11. Uma visão matemática geral
Podemos representar uma DLL como um conjunto de funções exportadas:
E = \{f_1,f_2,...,f_n\}
Cada função possui uma localização relativa:
f_i \rightarrow RVA_i
Para uma DLL carregada em uma determinada base:
VA_i = Base + RVA_i
Um executável que importa algumas dessas funções possui uma tabela de referências:
I = \{I_1,I_2,...,I_m\}
Depois da resolução:
I_j = VA(f_j)
Portanto:
\boxed{
I_j = Base_{DLL} + RVA(f_j)
}
Essa equação resume uma parte importante da relação entre exportação e importação.
12. IAT Hooking versus DLL Injection
Esses conceitos não devem ser tratados como sinônimos.
DLL Injection
O objetivo é fazer com que uma DLL seja carregada em outro processo.
Uma abstração seria:
Processo
\rightarrow
Carregamento(DLL)
\rightarrow
Código da DLL
IAT Hooking
O objetivo é modificar uma referência utilizada pelo módulo:
IAT[Function]
\rightarrow
Outro\ endereço
Portanto:
DLL Injection ≠ IAT Hooking
Eles podem aparecer juntos em determinadas técnicas de instrumentação ou análise, mas representam operações conceitualmente diferentes.
13. Como visualizar isso em uma análise de PE
Em engenharia reversa, uma ferramenta de análise pode apresentar algo semelhante a:
Imports
Biblioteca.dll
├── FuncaoA
├── FuncaoB
└── FuncaoC
E, para outro módulo:
Exports
FuncaoA
FuncaoB
FuncaoC
O analista pode então estudar a relação:
Import \leftrightarrow Export
e observar como o carregador resolve essas dependências.
Ferramentas de análise de PE também permitem examinar:
- seções;
- headers;
- diretórios de importação;
- diretórios de exportação;
- RVAs;
- dependências entre DLLs;
- símbolos e nomes exportados;
- referências utilizadas pelo programa.
14. Por que IAT e EAT são importantes?
Essas estruturas ajudam a explicar como aplicações Windows utilizam código compartilhado.
Elas também são relevantes para:
Engenharia reversa
Permitem identificar APIs utilizadas por um programa e compreender suas dependências.
Debugging
Ajudam a investigar problemas relacionados ao carregamento e resolução de funções.
Malware analysis
Analistas podem examinar importações e exportações para entender características de um binário.
Instrumentação
Técnicas de instrumentação podem utilizar mecanismos de redirecionamento de chamadas para observar o comportamento de um programa.
Windows Internals
IAT e EAT são excelentes exemplos de como o formato PE conecta módulos diferentes dentro de um processo.
15. Resumo matemático
Podemos condensar os conceitos principais em quatro relações:
Exportação
\boxed{Export(Function) \rightarrow RVA}
Conversão para endereço virtual
\boxed{VA = ImageBase + RVA}
Importação resolvida
\boxed{IAT[i] = VA(Function)}
Alteração conceitual de uma entrada da IAT
\boxed{IAT[i] : Address_{Original} \rightarrow Address_{Hook}}
Assim, o modelo completo fica:
PE
│
┌─────────┴─────────┐
│ │
EAT IAT
│ │
Exportações Importações
│ │
└───────┬───────────┘
│
Resolução
│
v
Endereço VA
Conclusão
IAT e EAT são componentes fundamentais para compreender como módulos PE se relacionam no Windows.
A EAT está associada às funções disponibilizadas por um módulo, enquanto a IAT mantém as referências utilizadas por um módulo para acessar funções importadas. A resolução dessas referências pode ser entendida matematicamente pela relação:
VA = ImageBase + RVA
e, para uma importação resolvida:
IAT[i] = VA(Function)
Licença indicada no material: CC BY-NC-SA 4.0
© 2026 — Maximiliano Tarigo