FindFunc: Filtragem/Encontro Avançado de Funções no IDA Pro

FindFunc é um plugin do IDA Pro para encontrar funções de código que contenham um determinado padrão de assembly ou byte, referenciem um certo nome ou string, ou estejam em conformidade com várias outras restrições.

FindFunc ganhou o terceiro lugar no Concurso de Plugins do IDA Pro da HexRays 2022!

Filtragem com Regras

A funcionalidade principal do FindFunc é permitir que o usuário especifique um conjunto de "Regras" ou restrições que uma função de código no IDA Pro deve satisfazer. O FF então encontrará e listará todas as funções que satisfazem TODAS as regras (portanto, atualmente todas as Regras estão em uma conjunção AND). Exceção: As regras podem ser "invertidas" para serem correspondências negativas. Tais regras, portanto, se conformam a "AND NOT".

O FF irá agendar as regras em uma ordem inteligente para minimizar o tempo de processamento. Visão geral dos recursos:

• Atualmente 6 Regras disponíveis, veja abaixo
• Ciente de chunks de funções
• Agendamento inteligente de regras para desempenho
• Salvar/Carregar regras de/para arquivo em formato ascii simples
• Várias abas independentes para experimentação
• Copiar regras entre abas via área de transferência (mesmo formato do arquivo)
• Salvar sessão inteira (todas as abas) em arquivo
• Cópia avançada de bytes de instrução (todos, apenas opcodes, todos exceto imediatos, ...)
• Clonar abas para experimentos rápidos com refinamento de resultados
• A correspondência de código respeita Prefixo de Tamanho de Endereçamento e Prefixo de Tamanho de Operando

O botão "Find Functions" limpa os resultados existentes e inicia uma nova pesquisa, "Refine Results" considera apenas os resultados da pesquisa anterior.

Cópia Binária Avançada

Um recurso secundário do FF é a opção de copiar a representação binária de instruções com as seguintes opções:

• copiar tudo -> copiar todos os bytes para a área de transferência
• copiar sem imediatos -> preencher com espaços (AA ?? BB) quaisquer valores imediatos nos bytes da instrução
• apenas opcode -> preencherá tudo exceto o(s) opcode(s) real(is) da instrução (e prefixos)
• ...

Veja a seção "cópia avançada" abaixo para detalhes. Este recurso complementa bem a regra de Padrão de Byte!

Construção e Instalação

FindFunc é um plugin Python do IDA Pro sem dependências de pacotes externos. Pode ser instalado baixando o repositório e copiando o arquivo 'findfuncmain.py' e a pasta 'findfunc' para o diretório de plugins do seu IDA Pro. Para IDA 9.0+, o repositório também pode ser clonado diretamente no diretório de plugins. De qualquer forma, nenhuma construção é necessária.

Requisitos: IDA Pro 8.x (8.3+) com ambiente python3. FindFunc é projetado apenas para a arquitetura x86/x64. Foi testado com IDA 8.3 - 9.2, python 3.11 no Windows 10 + 11

Regras Disponíveis

Atualmente, as seis regras a seguir estão disponíveis. Elas estão ordenadas aqui de pesada a leve em relação ao impacto no desempenho. Com bancos de dados grandes, é uma boa ideia primeiro reduzir as funções candidatas com uma regra barata, antes de fazer correspondência pesada via, por exemplo, Regras de Código. O FF agendará automaticamente as regras de maneira inteligente.

Padrão de Código

Regra para filtrar funções com base em elas conterem um trecho de código assembly fornecido. Isso NÃO é uma pesquisa de texto pela representação textual de desmontagem do IDA, mas sim realiza correspondência avançada da instrução subjacente. O trecho pode conter muitas instruções consecutivas, uma por linha. Chunks de funções são suportados. Suporta correspondência especial com curingas, além de assembly literal:

• "pass" -> corresponde a qualquer instrução com quaisquer operandos
• "mov* any,any" -> corresponde a instruções com mnemônico "mov*" (ex.: mov, movzx, ...) e quaisquer dois argumentos.
• "mov eax, r32" -> corresponde a qualquer instrução com mnemônico "mov", primeiro operando registrador eax e segundo operando qualquer registrador de 32 bits.
  • Análogo: r para qualquer registrador, r8/r16/r32/r64 para registrador de largura específica, "imm" para qualquer imediato
• "mov r64, imm" -> corresponde a qualquer movimentação de uma constante para um registrador de 64 bits
• "any r64,r64" -> corresponde a qualquer operação entre dois registradores de 64 bits
• mov -> corresponde a qualquer instrução do mnemônico mov

mais exemplos:

mov r64, [r32 * 8 + 0x100]
mov r, [r * 8 - 0x100]
mov r64, [r32 * 8 + imm]
pass
mov r, word [eax + r32 * 8 - 0x100]
any r64, r64
push imm
push any

Armadilhas: Tenha cuidado ao copiar assembly do IDA. O IDA mistura nomes de variáveis locais e outras informações na instrução, o que leva a falhas na correspondência. Além disso, rótulos não são suportados ("call sub_123456").

Note que Padrões de Código é a Regra mais cara, e se apenas Regras de Código estiverem presentes, o FF não tem opção a não ser desmontar todo o banco de dados. Isso pode levar vários minutos para binários muito grandes. Veja notas sobre desempenho abaixo.

Valor Imediato (Constante)

A função deve conter o imediato fornecido pelo menos uma vez em qualquer posição. Um valor imediato é um valor fixo na representação binária da instrução. Exemplos de instruções que correspondem ao valor imediato 0x100:

mov eax, 0x100
mov eax, [0x100]
and al, [eax + ebx*8 + 0x100]
push 0x100

Imediatos podem ser colados diretamente da área de transferência na lista de regras. Nota: O IDA realiza correspondência extensiva de qualquer tamanho e qualquer posição do imediato. Se você souber que ele tem uma largura específica de 4 ou 8 bytes, um padrão de byte pode ser mais rápido (mas pode produzir falsos positivos).

Padrão de Byte

A função deve conter o padrão de byte fornecido pelo menos uma vez. O padrão tem o mesmo formato da pesquisa binária do IDA e, portanto, suporta curingas - a combinação perfeita para o recurso de cópia avançada!

Exemplos:

11 22 33 44 aa bb cc
11 22 33 ?? ?? bb cc -> ?? pode ser qualquer byte

Padrões de byte podem ser colados diretamente da área de transferência na lista de regras. Nota: A correspondência de padrões é bastante rápida e uma boa candidata para reduzir correspondências rapidamente!

Referência a String

A função deve referenciar a string fornecida pelo menos uma vez. A string é correspondida de acordo com o módulo 'fnmatch' do Python e, portanto, suporta correspondência do tipo curinga. A correspondência é realizada sem diferenciação de maiúsculas/minúsculas. Strings dos seguintes formatos são consideradas: [idaapi.STRTYPE_C, idaapi.STRTYPE_C_16] (isso pode ser alterado na classe Config).

Exemplos:

• "TestString" -> função deve referenciar a string exata (ignorando maiúsculas/minúsculas) pelo menos uma vez
• "TestStr*" -> função deve referenciar uma string começando com 'TestStr' (ex.: TestString, TestStrong) pelo menos uma vez (ignorando maiúsculas/minúsculas)

Nota: A correspondência de strings é rápida e uma boa escolha para reduzir candidatos rapidamente!

Referência a Nome

A função deve referenciar o nome/rótulo fornecido pelo menos uma vez. O nome/rótulo é correspondido de acordo com o módulo 'fnmatch' do Python e, portanto, suporta correspondência do tipo curinga. A correspondência é realizada sem diferenciação de maiúsculas/minúsculas.

Exemplos:

• "memset" -> função deve referenciar um nome "memset" pelo menos uma vez
• "mem*" -> função deve referenciar um nome começando com "mem" (memset, memcpy, memcmp) pelo menos uma vez

Nota: A correspondência de nomes é muito rápida e ideal para reduzir candidatos rapidamente!

Tamanho da Função

O tamanho da função deve estar dentro do limite fornecido: "min <= tamanhofuncao <= max". Os dados são inseridos como uma string da forma "min,max". O tamanho de uma função inclui todos os seus chunks.

Nota: A correspondência de tamanho de função é muito rápida e ideal para reduzir candidatos rapidamente!

Atalhos de Teclado e GUI

Para facilidade de uso, o FF pode ser usado através dos seguintes atalhos de teclado:

• Ctrl+Alt+F -> iniciar/mostrar TabWidget (GUI principal)
  • Ou View->FindFunc
• Ctrl+F -> iniciar pesquisa com as regras atualmente habilitadas
• Ctrl+R -> refinar resultados existentes com as regras atualmente habilitadas
• Regras
  • Ctrl+C -> copiar regras selecionadas para a área de transferência
  • Ctrl+V -> colar regras da área de transferência na aba atual (anexa)
  • Ctrl+S -> salvar regras selecionadas em arquivo
  • Ctrl+L -> carregar regras selecionadas de arquivo (anexa)
  • Ctrl+A -> selecionar todas as regras
  • Del -> excluir regras selecionadas
• Salvar Sessão
  • Ctrl+Shift+S -> Salvar sessão em arquivo
  • Ctrl+Shift+L -> Carregar sessão de arquivo

Uso adicional da GUI

• Clique direito na aba: opção de clonar aba
• As regras podem ser editadas clicando duas vezes na coluna Data
• As regras podem ser invertidas (correspondência negativa) clicando duas vezes na coluna invert-match
• As regras podem ser habilitadas/desabilitadas clicando duas vezes na coluna enabled
• Clicar com a roda do mouse em qualquer célula em Regras ou Resultados copia a célula para a área de transferência
• Padrões de Byte e imediatos podem ser colados diretamente da área de transferência na tabela de Regras
• As abas podem ser renomeadas clicando duas vezes nelas
• A classificação é suportada tanto para a Lista de Regras quanto para a Lista de Resultados
• Clique duas vezes em um item de Resultado para pular para ele no IDA
  • nome da função: pular para o início da função
  • qualquer outra coluna: pular para a correspondência da última regra correspondida
• Checkbox Profile: Exibe informações de perfil para a pesquisa
• Checkbox Debug: Despeja saída detalhada de depuração para correspondência de regra de código - use apenas se poucas funções chegarem à regra de verificação de código, caso contrário, pode demorar muito!

Cópia Binária Avançada

Frequentemente queremos pesquisar por padrões binários de assembly, mas sem endereços e valores hardcoded (imediatos), ou até mesmo apenas os opcodes reais da instrução. FindFunc torna isso fácil adicionando três opções de cópia ao menu pop-up de desmontagem:

Copiar todos os bytes

Copia todos os bytes da instrução como string hexadecimal para a área de transferência, para uso em uma Regra de Padrão de Byte (ou pesquisa binária do IDA).

B8 44332211      mov eax,11223344
68 00000001      push 1000000
66:894424 70     mov word ptr ss:[esp+70],ax

será copiado como

b8 44 33 22 11 68 00 00 00 01 66 89 44 24 70

Copiar apenas bytes não-imediatos

Copia bytes da instrução para a instrução fornecida, mascarando quaisquer valores imediatos. Exemplo:

B8 44332211      mov eax,11223344
68 00000001      push 1000000
66:894424 70     mov word ptr ss:[esp+70],ax

será copiado como

b8 ?? ?? ?? ?? 68 ?? ?? ?? ?? 66 89 44 24 ??

Copiar apenas opcodes

Copia todos os bytes da instrução como string hexadecimal para a área de transferência, mascarando quaisquer bytes que não sejam o opcode real (incluindo sib, modrm, mas mantendo prefixos legados).

B8 44332211      mov eax,11223344
68 00000001      push 1000000
66:894424 70     mov word ptr ss:[esp+70],ax

será copiado como

b8 ?? ?? ?? ?? 68 ?? ?? ?? ?? 66 89 ?? ?? ??

Copiar opcodes + imediatos

Uma combinação que mantém opcode e imediatos, mas mascara, por exemplo, mod r/m. Note que isso mantém opcodes mesmo que eles exijam registradores específicos, ex.:

B8 44332211      mov eax,11223344

manterá o opcode B8.

Nota: Isso é um "melhor esforço" usando a API do IDA, portanto pode haver alguns casos em que funciona apenas parcialmente. Para uma solução 100% correta, teríamos que enviar uma biblioteca dedicada de desmontagem x86.

Resultados semelhantes podem ser alcançados com Regras de Padrão de Código, mas isso pode ser mais rápido, tanto para interação do usuário quanto para a pesquisa real.

Copiar desmontagem

Copia a desmontagem selecionada para a área de transferência, conforme aparece no IDA.

Desempenho

Uma breve palavra sobre desempenho:

1. nome, string, tamanhofuncao são quase gratuitos em todos os casos
2. padrão de byte é quase gratuito para comprimentos de padrão > 2
3. imediato é difícil: Podemos usar a pesquisa da idaapi, ou podemos desmontar todo o banco de dados e pesquisar nós mesmos - podemos ter que fazer isso de qualquer forma se estivermos procurando por padrões de código. MAS: a varredura por padrões de código é de fato muito mais barata do que a varredura por um imediato. Uma pesquisa via api por todas as correspondências é relativamente custosa - cerca de 1/8 do custo de desmontar todo o banco de dados. Então: Se reduzirmos as correspondências primeiro com regras baratas, então lucramos muito ao desmontar as funções restantes e procurar o imediato nós mesmos, especialmente se uma regra de código já estiver presente. No entanto: Se não houver opções baratas e tivermos que desmontar grandes partes do banco de dados de qualquer forma (devido à presença de regras de padrão de código), então usar uma regra imediata como pré-filtro pode compensar bastante. Pesquisar via api UM imediato é aproximadamente equivalente a 1/8 da pesquisa de qualquer número de regras de padrão de código - embora isso também dependa de muitos fatores diferentes...
4. padrões de código são de longe os mais caros, no entanto, verificar um padrão versus verificar muitos é muito semelhante.

A fazer (não ordenado):

• pseudo-mnemônico jcc
• Permitir locais nomeados em CodeRules ('call memset')
• adicionar regra de xref in/out
• desfazer/refazer
• barra de progresso
• clique do meio para fechar abas
• menu de aba: fechar todas exceto esta
• opção 'ignorar todos os operandos seguintes'
• Regra para parâmetros de chamadas de API dentro da função
• Regra para requisitos de função pai/ponto de chamada/filha
• Regra para parâmetros de função
• Regra de regex
• string/nome: opção de maiúsculas/minúsculas
• converter automaticamente regras imediatas em padrão de byte se aplicável?
• configurações: sensibilidade a maiúsculas/minúsculas, tipos de string, intervalo, ...
• Regras Hexrays?
• Combinação OR de regras
• Pitonicização do código ;)
• Paralelização
• Geração automática de regras para identificar uma função?