Aula 05

4. Trabalhando com Executáveis .......................................................................................................49

4.1. Identificação do arquivo .............................................................................................................49
4.2. Unpacking Automático ...............................................................................................................49
4.3. Strings .........................................................................................................................................50
4.4. Strings criptografadas .................................................................................................................50
4.5. Debugging ..................................................................................................................................51
4.6. Lab 04-01 Análise de executável malicioso com strings criptografadas ...................................51
 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 49

4. Trabalhando com Executáveis

Executáveis ainda são os malwares mais comuns, dos milhares de spams phishings que
chegam nas caixas postais todos os dias a maioria tem a instalação de instalar alguma executável
malicioso no Windows.
A análise de um executável desconhecido costuma seguir uma sequência pré-estabelecida de
passos, desse modo conseguimos progressivamente extrair as informações que desejamos. Nesse
capítulo utilizaremos as técnicas da análise estática e no próximo da análise dinâmica.
Vejamos agora uma breve descrição dessas etapas, lembrando que para iniciar a análise
devemos já estar com a máquina virtual configurada, com todas as ferramentas instaladas e com um
snapshot limpo.

4.1. Identificação do arquivo

Quando vamos inciar a análise de um arquivo malicioso não temos nenhuma informação
prévia sobre ele, não sabemos nem mesmo se é um executável legítimo, mesmo que ele tenha no
Windows a extensão .EXE isso não garante que ele seja um executável.
Então, como já vimos, a primeira coisa que devemos fazer é obter um perfil inicial do
arquivo. Para isso utilizamos as ferramentas identificadoras. Com elas saberemos se o malware em
questão é um executável, se ele possui algum tipo de proteção e caso afirmativo qual ferramenta
buscar para remover essa proteção e também na ausência da proteção saberemos o compilador
utilizado. Para obter resultados melhores é recomendável utilizar mais de uma ferramenta pois há
arquivos que são identificados em uma ferramenta e na outra não.

4.2. Unpacking Automático

Após a identificação de uma proteção no arquivo é hora de buscar uma ferramenta que
remova essa proteção. As proteções mais comuns de serem encontradas são os packers, dependendo
do grau de sofisticação e popularidade do packer pode ser fácil ou difícial encontrar uma ferramenta
de unpacking.
A ferramenta Exeinfo PE nos ajuda na tarefa de buscar um unpacker, assim que identifica
uma assinatura de packer ela nos apresenta uma dica de qual unpacker procurar. De qualquer forma,
mesmo sem a dica podemos buscar pelos termos “unpacker” ou “unpack” e o nome_do_packer.
Mesmo encontrando o unpacker isso não é garantia que conseguiremos retirar a proteção,

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 50

muitas vezes as versões não são compatíveis ou acontece algum erro e prejudica a execução.
Por fim, para nos certificarmos que o arquivo agora está livre de proteções devemos
submetê-lo novamente à ferramenta de identificação, dessa vez ela provavelmente irá exigir o
compilar do arquivo.

4.3. Strings

Strings são sequências de caracteres, como por exemplo “essa frase”. Geralmente elas estão
dentro do malware em forma de mensagens, URLs, conexões de banco de dados, caminhos de
arquivos, chaves de registro, nome de funções, etc.
Buscar por strings é um jeito fácil e rápido de obter dicas da funcionalidade do malware.
Isso pode ser feito com o utilitário strings das Sysinternals, ele encontra tanto strings em ASCII
quanto UNICODE.
O ASCII e o UNICODE são terminados com um caracter NULL que indica para o programa
que a sequência está completa. ASCII usa 1 byte por caractere, UNICODE 2 bytes. Vejamos a
representação de duas strings nesses formatos.

ASCII
M A L W A R E NULL
4D 41 4C 57 41 52 45 00

UNICODE
M A L W A R E NULL
4D 00 41 00 4C 00 57 00 41 00 52 00 45 00 00 00

O utilitário strings, em sua configuração padrão, busca por sequências de no mínimo três
caracteres seguidos de um terminador NULL, nos dois formatos. Isso pode ser alterado através dos
parâmetros do programa.

4.4. Strings criptografadas

Nos trojans-bankers brasileiros é muito comum no momento que estamos buscando por
strings nos depararmos com uma espécie de criptografia. Isso é utilizado para esconder de olhos
curiosos informações importante do malware, já que na maioria das vezes eles utilizam strings de
OYS Academy – Ronaldo Pinheiro de Lima
 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 51

URLs, caminhos de arquivos ou conexão com banco de dados.

Apesar de a primeira vista essas strings parecem um empecilho para a análise, há meios para
reverter essa ofuscação, basicamente sempre após cada string criptografada haverá a chamada da
função que faz a descriptografia, então aí basta pegarmos o retorno dessa função com a string em
texto plano.

4.5. Debugging

O debugger nos auxilia nesse processo de executar trechos do código do malware e observar
os resultados e alterações que ele provoca na CPU e memória. Através dele conseguimos identificar
e até modificar o código do malware que está na memória.
O OllyDbg permite alterar uma instrução assembly em tempo de execução, para isso basta
dar dois cliques em cima na instrução ou apertar o <SPACE>.

4.6. Lab 04-01 Análise de executável malicioso com strings criptografadas

Nesse Lab iremos praticar os conceitos aprendidos até aqui, utilizaremos as ferramentas para
identificar o malware e descobrir pistas de suas funcionalidades. Veremos que mesmo um arquivo
aparentemente simples pode esconder informações interessantes.

Material necessário:
- Máquina virtual com Windows XP 32-bit
- PEiD, Exeinfo PE
- strings
- OllyDbg
-Arquivo: Lab-04-01.scr

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 52

Passo a Passo

1- A primeira coisa é obter um perfil inicial do arquivo com nossas ferramentas identificadores
PEiD e Exeinfo PE.

2- Vemos que as duas ferramentas identificaram no arquivo a presença do packer UPX, inclusive o
Exeinfo PE deu dica de como remover o packer. O UPX é o mais popular packer freeware
disponível na Internet. Esse packer foi projetado justamente para comprimir os executáveis, nada
além disso. Mesmo assim os atacantes ainda o utilizam esperando obter alguma ofuscação de
código. De fato ele consegue esconder algumas strings como podemos ver na listagem abaixo,
porém o próprio UPX possui a função de unpacking “upx –d”.

3- Com ajuda da ferramenta strings.exe vemos abaixo as strings principais encontradas no arquivo
ainda compactado com o UPX.
OYS Academy – Ronaldo Pinheiro de Lima
 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 53

:mpeiraProject1
C:\Arqu
ivos de p
gramas\Mic
ft Visual Studio\VB98
6.OLB
VS_VERSION_INFO
VarFileInfo
Translation
StringFileInfo
040904B0
CompanyName
ProductName
Project1
FileVersion
1.00
ProductVersion
1.00
InternalName
loader_beyb_3
OriginalFilename
loader_beyb_3.exe
KERNEL32.DLL
MSVBVM60.DLL
LoadLibraryA
GetProcAddress
VirtualProtect
VirtualAlloc
VirtualFree
ExitProcess

Pouca coisa de útil, apenas uma referência ao Visual Studio/Visual Basic.

4- Agora vamos descompactar o arquivo com o “upx –d Lab-04-01.scr”.

OYS Academy – Ronaldo Pinheiro de Lima
 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 54

Nota-se que realmente o arquivo estava compactado, a taxa de compressão era de 35%.

5- Vamos submeter o arquivo descompactado para o Exeinfo PE novamente para conferir se

realmente saiu a proteção.

Agora sim, foi identificado o compilador utilizado, MS Visual Basic 5.0 ou 6.0.

6- Possivelmente encontraremos novas strings agora que está descompactado. Strings.exe entra em
ação novamente.

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 55

mpeiraProject1
IXA\Esp
Form1
Form1
Form1
Timer5
Timer4
Timer3
Timer2
Timer1
VB5!
loader_beyb_3
Project1
Project1
@*\AC:\Documents and Settings\dilma\Desktop\Loader_BEYBAO\Project1.vbp
Form1
Module1
Module2
Module3
Module4
Project1
\Tx^
Timer4
C:\Arquivos de programas\Microsoft Visual Studio\VB98\VB6.OLB
Timer3
Timer5
Timer1
Form
Timer2
nwTW2wACnwK72kA7nwT
nkJz2SN8nSjz2SYmnHK7nSYunH2OnkjF
h,9@
CloseHandle
__vbaStrCat

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 56

nkjOykNcnk272FAC2HAW2FYFnHAWnFYWnSpWKFKFnH2z2FYunSK
kernel32
LoadLibraryA
CreateThread
hT:@
WaitForSingleObject
FreeLibrary
GetProcAddress
h<;@
advapi32.dll
RegCreateKeyA
RegQueryValueExA
RegCloseKey
h(<@
RegSetValueExA
hp<@
nkKOnkYmnHKWnSYunSAznFYWnFpt/kA7nkYW...nF2O/SjWnFpO2FYWnA272FNwnF2Oyk
Y7
nSTOnwY7nAYO2kjOnF2F2Spo2Sj
2SjtKFpz
2SJtnFsw2Sj
nFHzykjunFHt/wNTnHKt/wY7nSKt2wKonwfFKk/TnTKFKkAFnk2
2SjtyK
nkjOykNcnSKO/SjznF27KFYunFYOnkscnkpOykYFnSfW/SKFnH2O2kjFnF2WKFKFnH2z2FYun
SK
VBA6.DLL
__vbaCastObj
__vbaNew
__vbaExitProc
__vbaFreeStrList
__vbaStrCmp
__vbaFreeVar
__vbaFreeStr
__vbaStrCopy

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 57

B(__vbaFreeVarList
__vbaVarCat
__vbaStrVarMove
__vbaStrMove
__vbaOnError
__vbaObjSet
__vbaEnd
__vbaFreeObj
__vbaNew2
__vbaHresultCheckObj
nHAO/wN8nH2Onwj7nHAt/kY7nH2OKC
nS2O/kYOnHKz2SjCnH2t/kY7nH2OKC
nHKO/SjOnHpOnwYWnFft/kY7nH2OKC
nk2W2k/wnTY7KFKWnwK72f
nSfO/SjWnF2OnkYFnSTz2SscnSKO2Ssc2FjF2k2z2Fp...tnSAz2FN8nFAz2SYFnSAt/kYFnHYO/J
InstancesOf
nwKO2kj7nSTt2wAFnHYznkjtnS2OnK
nSfO/SjWnF2OnkYFnSTz2f
nwHO/kYunFKOykYmnH2t2wKFnSTznwYmnH2O/SYz
nkAz2FYWnFpt2wKunwK
nwpznkj7nSHO/kYm2FYFnS2O
nkJO2kjFnF2znFN8nFpOnJ
__vbaVarTstEq
__vbaVarMove
nFpOnkj7nHYz2SNcnSTW/SY7nSTOnwN8nF2
nSKO2kY7nHYz2F2m
nSKO2kY7nHYz2F2t
nSKO2kY7nHYz2F2F
__vbaVarTstNe
__vbaFreeObjList
nkjOykNc2F2F2Sa8nTYz2wYWnFpO2kj7nSHO/kYznk2zykjFnFKOnkNT
nFjOykNcnHKOnFNTnFKz2FnUn7pOykNTnFJOnkjtnF2O/SN...wYWnFpz2FN8nHAO2kj7nSAz
/J
Caption

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 58

nk2WykAFnkK7nk/Tnkp7/S/8nkK
nA2z2FjunF2znwYWnHKF2F2tnA2
nSHOnkYOnFpO2kNTnSAt/kY7nH2OKC
nF2OywY7nHYO2FjOnFjt/kY7nH2OKC
nTKO/SqUnSHOKFNwnSTt2wKOnSHz2SYWnSYO/SjonA2OnS..FpOnkYOnHYzywscnSAzyw
YW
nA27nFYtnkJOKFjWnSjOykNcnA2O2SYt2HAOnFjCnS2
nA27nFYtnkJOKFjWnSjOykNcnA2O2kYtnHAt/kYznFJO2C
nA27nFYtnkJOKFjWnSjOykNcnA2O2FYWnSYt/kYznFJO2C
nA27nFYtnkJOKFjWnSjOykNcnA2znkNcnSHt/kYznFJO2C
nF2zykjFnFKOnkNTnSKz2SYunFYOnK
nkfWywAonkfWywAonkfWyJ
nkfWywAonkfWywa8
__vbaFPInt
__vbaStrR8
__vbaLenBstr
__vbaStrI4
__vbaNextEachCollAd
__vbaLateMemCallLd
__vbaForEachCollAd
__vbaBoolVar
__vbaVarLateMemCallLd
__vbaObjVar
__vbaObjSetAddref
nwKOKFNwnkpOnkYznSHz2Fj7nSAz2SAFnSAz2SjOnSAz2f
nwKOKFNwnkAO/kjtnSAOnFYunF2znwYWnFpW2FYWnFpznSYWnFp
nk27/SKOnkKWnFKmnkp7nkawnTKOykYFnFpO/SjFnHYOn...O2SNUnSAO2Fj7nF2WKC
__vbaVarCmpEq
__vbaBoolVarNull
__vbaVarDup
__vbaInStr
__vbaLsetFixstr
__vbaStrToUnicode
__vbaSetSystemError

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 59

__vbaStrToAnsi
__vbaGenerateBoundsError
__vbaPowerR8
__vbaFpI4
__vbaErrorOverflow
__vbaInStrVar
__vbaVarSub
__vbaI2Var
__vbaI2I4
InternalName
loader_beyb_3
OriginalFilename
loader_beyb_3.exe

Algumas strings foram truncadas para caber na folha. Nessa listagem podemos identificar
algumas coisas:
 Presença de componentes e funções utilizadas pelo MS Visual Basic.
 Nome e local de salvamento do projeto original:
C:\Documents and Settings\dilma\Desktop\Loader_BEYBAO\Project1.vbp
 Nome original do executável: loader_beyb_3.exe.
 Strings suspeitas que seguem um padrão aleatório de caracteres, possivelmente
criptografadas:
nk2WykAFnkK7nk/Tnkp7/S/8nkK
nA2z2FjunF2znwYWnHKF2F2tnA2
nSHOnkYOnFpO2kNTnSAt/kY7nH2OKC
nF2OywY7nHYO2FjOnFjt/kY7nH2OKC

7- Vamos abrir agora o arquivo Lab-04-01.scr no OllyDbg. Após o arquivo aberto clique com o
botão direito em cima da janela de código e Search for – All referenced text strings.

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 60

8- O Olly exibe em uma nova janela todas as strings encontradas no executável. Podemos rolar a
janela até encontrar as strings criptografadas. Dois cliques em cima de qualquer string da janela nos
leva ao código do malware onde essa string é utilizada. Clicando por exemplo na string do endereço
0x00407684 o Olly nos leva ao código abaixo.

Destacado em cinza a string que selecionamos, abaixo dela vemos uma chamada a função
referenciada pelo ESI e mais abaixo quatro PUSHs e uma chamada a outra função:
CALL 0040A7A0.

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 61

9- Vamos voltar à janela de Strings, isso pode ser feito minimizando a janela da CPU ou através do
Menu Window – Text strings. Selecione outra string qualquer que aparenta estar criptografada,
como por exemplo a do endereço 0x00408616. O código onde ela está sendo utilizada é esse abaxo.

Vemos a mesma estrutura de código que a anterior, novamente a instrução:

CALL 0040A7A0.

10- Se formos fazendo isso com todas as strings criptografadas iremos encontrar o mesmo código.
Parece que essa função que está no endereço 0040A7A0 tem alguma relação com a string
criptografada. Se quisermos saber quais locais do código (endereços) que chamam essa mesma
função, o Olly tem uma opção que é conhecido como referências cruzadas (xref). Podemos buscar
as xref selecionando a linha de código da função, clicando com o botão direito e depois em Find
references to – Call destination.

São encontrados inúmeros locais no código onde essa função é utilizada, possivelmente em
todos os locais onde haja as strings criptografadas.
OYS Academy – Ronaldo Pinheiro de Lima
 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 62

11- Podemos confirmar nossa teoria através do debugging, vamos até o início dessa função no
endereço 0x0040A7A0 e colocar um breakpoint com o F2, assim na primeira vez que o programa
for acessar essa função ele irá parar no nosso breakpoint. Agora execute o programa com F9.

12- A execução do programa parou no nosso breakpoint e agora para descobrirmos onde quem no
código chamou essa função a gente pode olha pra pilha. Recordando as aulas sobre a pilha, assim
que é feita uma CALL o endereço de retorno é colocado na pilha, então saberemos quem chamou a
função.

Vemos aí que após a execução da função o programa retornará para o endereço

OYS Academy – Ronaldo Pinheiro de Lima
 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 63

0x00405D77. Vamos procurar essa linha no programa através do Ctrl + G e endereço.

13- Encontramos o trecho de código que chamou pela primeira vez a função suspeita.

Vemos logo no começo uma string criptografada e aquela mesma estrutura de código
analisada anteriormente. Então, para enfim descobrirmos o que essa função retorna, podemos
colocar um breakpoint nessa string criptografada que está no endereço 0x00405D4F. Antes de
colocar o breakpoint vamos desativar o outro, se clicarmos no botão B da barra de ferramentas do
OllyDbg é aberta uma janela com todos os breakpoints ativos, só selecionar o que quer desativar e
apertar Del. Agora sim coloque o breakpoint no endereço acima, reinicie o debugger com Ctrl + F2
, escolha Sim e execute novamente com F9.

14- A execução parou na instrução da string criptografada, agora vamos apertando F8 até a linha
abaixo da CALL 0040A7A0.

Já conseguimos ver o retorno da função, o Olly nos mostra que o EAX (que costumar ser o retorno)
possui a string “APPDATA”, ou seja, é a string descriptografada.
Criptografada Descriptografada
nwTW2wAcnwK72kA7nwT APPDATA

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 64

15- O malware possui inúmeras outras strings criptografadas, só descobrimos o que uma significa,
como poderíamos descobrir outras? Há um método manual que podemos utilizar para fazer isso,
veja nesse código a instrução que utiliza a string criptografada:

MOV EDX, [nomedoarquivo].0040386C

Sabemos por essa instrução que a primeira string que foi descriptografada estava no
endereço 0040386C, o operando origem do MOV. No momento que o debugger parar a execução
nessa instrução, podemos alterar esse endereço da string para apontar para outra. Para descobrir
endereços de outras strings é só abrir a janela de Strings novamente e reparar na instrução que a
utiliza, terá o endereço dela assim como nessa instrução que vimos.

16- Vamos descobrir o que a string criptografada que está no endereço: 004041B0 significa.
Reinicie o debugger, execute o malware, o breakpoint vai ser atingido, agora pressione a barra de
espaço <SPACE> para editar a instrução assembly, conseguimos modificar a instrução que está na
memória, apague o enderço original que está lá (0040386C) e insira o endereço da outra string que
queremos descriptografar (004041B0), clique em Assemble e depois no X para fechar a janelinha.

Vemos por baixa da janela que o código já foi modificado, em vermelho os opcodes
modificados e a string que aparece à direita já é outra.

17- Agora é só ir executando linha a linha com o F8 até passar pela CALL da função e vermos o
retorno no EAX.

OYS Academy – Ronaldo Pinheiro de Lima

 CAPÍTULO 4 – TRABALHANDO COM EXECUTÁVEIS | 65

Essa string descriptografada já vemos que é mais interessante, é uma URL:

housecar.db.7172228.hostedresource.com

18- Talvez esse malware esconda mais informações interessantes nas outras strings criptogradas,
que tal repetir esse mesmo processo, dos passos 16 e 17. Tente descobrir o que as strings dos
endereços abaixo significam:
0040429C
00404310
0040439C
004043C8
00404400

OYS Academy – Ronaldo Pinheiro de Lima