← Voltar para Artigos

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