GhidrOllama
1.0.0
Script Ghidra de interação da API Ollama para engenharia reversa assistida por LLM.
Este script interage com a API do Ollama para interagir com Large Language Models (LLMs). Ele utiliza a API Ollama para realizar várias tarefas de engenharia reversa sem sair do Ghidra. Ele oferece suporte a instâncias locais e remotas do Ollama. Este script é inspirado em GptHidra.
Este script oferece suporte a qualquer modelo compatível com Ollama
Ollama também adicionou recentemente suporte para qualquer modelo disponível no HuggingFace no formato GGUF, por exemplo:
ollama run hf.co/arcee-ai/SuperNova-Medius-GGUF
Sinta-se à vontade para substituir llama3.1:8b por qualquer um dos modelos compatíveis com Ollama
curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.1:8b
Agora você deve estar pronto, localhost:11434 deve estar pronto para lidar com solicitações
Nota: Este script também suporta instâncias remotas, defina o endereço IP e a porta durante a primeira configuração.
As seguintes opções de configuração estão disponíveis e podem ser configuradas na primeira execução:
localhost11434http ou https dependendo de como sua instância está configuradaAs opções 11 e 12 podem ser usadas para ajustar as configurações após a primeira execução.
~/ghidra_scripts ).Entrar na janela do script para executar esse script sempre é inconveniente, o script pode ser facilmente executado das seguintes maneiras:
Para ativar, depois de adicionar seu script à lista de diretórios de script Ghidra, localize o script na lista. Clique com o botão direito no resultado e selecione "Atribuir vinculação de teclas". Se solicitar uma chave, insira q .
Para ativar o ícone da barra de ferramentas, localize o script no gerenciador de scripts e clique na caixa de seleção na primeira coluna (a coluna Na barra de ferramentas ). O ícone GhidrOllama deve aparecer na barra de ferramentas.
Abaixo está uma implementação de strchr() conforme visto na janela de descompilação do Ghidra com símbolos removidos:
char * FUN_801a7490 ( char * param_1 , char param_2 )
{
char cVar1 ;
char * pcVar2 ;
cVar1 = * param_1 ;
if ( cVar1 == ' ' ) {
pcVar2 = ( char * ) 0x0 ;
}
else {
pcVar2 = ( char * ) 0x0 ;
do {
if ( param_2 == cVar1 ) {
pcVar2 = param_1 ;
}
param_1 = param_1 + 1 ;
cVar1 = * param_1 ;
} while ( cVar1 != ' ' );
}
if ( param_2 != ' ' ) {
param_1 = pcVar2 ;
}
return param_1 ;
}A análise a seguir foi realizada usando o modelo llama3.1:8b .
Função interessante! Como assistente de engenharia reversa, detalharei o que esse código faz e fornecerei alguns insights.
Assinatura de Função
char * FUN_801a7490(char *param_1,char param_2)A função leva dois parâmetros:
param_1: um ponteiro para uma matriz de caracteres (provavelmente uma string)param_2: um único caractereCorpo funcional
A função faz o seguinte:
- Verifica se o primeiro caractere de
param_1(cVar1) é. Se for,pcVar2será definido como(char *)0x0, que é essencialmente NULL.- Se
cVar1não for, ele entra em um loop onde:
- Ele verifica se o caractere
param_2corresponde ao caractere atual emparam_1(cVar1). Se corresponderem,pcVar2será definido como o endereço deparam_1.- O ponteiro
param_1é incrementado em um para apontar para o próximo caractere na string.- O loop continua até que o final da string seja alcançado (ou seja,
cVar1se torna).
- Se
param_2não for nulo, a função retornará o endereço armazenado empcVar2.Percepções
Com base neste código, parece estar procurando um caractere (
param_2) dentro de uma string (param_1). A pesquisa é interrompida assim que encontra a primeira ocorrência desse caractere.O
if (param_2 != ' ') { param_1 = pcVar2; }A instruçãoif (param_2 != ' ') { param_1 = pcVar2; }sugere que separam_2for encontrado na string, a função retornará um ponteiro para esse local dentro da string. Caso contrário, ele ainda retornará um ponteiro válido (provavelmente apontando para o início da string).
GhidrOllama renomeou a função para find_char_in_string
Aqui está a função modificada com comentários adicionais para explicar seu comportamento:
char * FUN_801a7490 ( char * param_1 , char param_2 ) { // Initialize a character variable (cVar1) to hold the first character of param_1. char cVar1 ; // Initialize a pointer variable (pcVar2) to point to null initially. char * pcVar2 ; // Assign the first character of param_1 to cVar1. This will be used as a starting point for searching in the string. cVar1 = * param_1 ; // Check if the input string (param_1) is empty (' '). if ( cVar1 == ' ' ) { // If it's empty, set pcVar2 to null, effectively indicating that no match was found. pcVar2 = ( char * ) 0x0 ; } else { // Initialize pcVar2 to null, which will be updated later if a match is found. pcVar2 = ( char * ) 0x0 ; // Loop through the string param_1 until we reach its end (' '). do { // Check if the current character (cVar1) matches the input parameter (param_2). if ( param_2 == cVar1 ) { // If it's a match, update pcVar2 to point to the beginning of param_1, effectively returning its address. pcVar2 = param_1 ; } // Move on to the next character in param_1 by incrementing its pointer (param_1 = param_1 + 1). param_1 = param_1 + 1 ; // Update cVar1 to hold the new current character. cVar1 = * param_1 ; } while ( cVar1 != ' ' ); } // Check if a match was found by verifying that param_2 is not null (' '). if ( param_2 != ' ' ) { // If it's not null, update param_1 to point to the matched string in pcVar2. param_1 = pcVar2 ; } // Return the address of the matched string or an empty string if no match was found. return param_1 ; }Esta função parece estar procurando um único caractere (param_2) dentro de uma string (param_1). Ele retorna o endereço da string correspondente ou nulo se nenhuma correspondência for encontrada. Se a string de entrada estiver vazia, ela retornará nulo imediatamente.
Aqui está a função reescrita com nomes e comentários mais descritivos:
/** * Find the index of a given character in a string. * * @param str The input string to search in. * @param charToFind The character to find in the string. * * @return A pointer to the found character in the string, or NULL if not found. */ char * findCharacterInString ( char * str , char charToFind ) { // Initialize variables char currentChar ; char * foundCharPtr ; // Check if the input string is empty currentChar = * str ; if ( currentChar == ' ' ) { // If the string is empty, return NULL foundCharPtr = NULL ; } else { // Initialize pointer to point to end of string foundCharPtr = NULL ; // Loop through each character in the string do { // Check if current character matches the character to find if ( charToFind == currentChar ) { // If a match is found, update the pointer and break out of loop foundCharPtr = str ; break ; } // Move to next character in string str ++ ; currentChar = * str ; } while ( currentChar != ' ' ); } // Ensure that if charToFind is not empty, we return the pointer to the found character if ( charToFind != ' ' ) { str = foundCharPtr ; } // Return the pointer to the found character, or NULL if not found return str ; }Observe que usei um nome de função mais descritivo,
findCharacterInString, e adicionei comentários para explicar o que cada parte do código está fazendo. Também usei nomes de variáveis mais descritivos comocurrentChar,foundCharPtr,strem vez decVar1,pcVar2, etc.
Forneci ao GhidrOllama um código que sei que contém um estouro de pilha para ver se ele detecta isso, e aqui está a resposta:
Áreas interessantes que podem apresentar vulnerabilidades de segurança no trecho de código fornecido:
Desreferência de ponteiro NULL : Na função
upnp_device_discovery, existe a possibilidade de desreferência de ponteiro NULL ao acessariVar2no deslocamento0x2910. Isso pode acontecer seDAT_8025d514for menor que 3 e*(int *)(param_1 + 0x2910)retornar NULL. Para corrigir isso, adicione uma verificação para garantir queiVar2não seja NULL antes de desreferenciá-lo.if ( DAT_8025d514 < 3 && iVar2 != NULL ) { iVar2 = * ( int * )( param_1 + 0x2910 ); }Buffer Overflow : Na função
upnp_device_discovery, existe a possibilidade de buffer overflow ao chamarstrcpy(auStack_98, iVar2 + 5);. Isso pode acontecer seiVar2mais 5 exceder os limites do arrayauStack_98. Para corrigir isso, adicione verificações para garantir que os buffers de origem e destino não sejam muito grandes para a sequência de destino.if ( iVar2 != NULL && iVar2 + 5 <= iVar1 ) { strcpy ( auStack_98 , iVar2 + 5 ); }Use-After-Free : Na função
upnp_device_discovery, existe a possibilidade de use-after-free ao acessariVar1após ele ter sido liberado no seguinte trecho de código:iVar1 = FUN_801a6bb4 ( iVar2 , s_urn_schemas_wifialliance_org_dev_801eb090 , 0x24 ); if ( iVar1 == 0 ) { iVar2 = iVar2 + 0x24 ; iVar1 = FUN_801a7114 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 ); }O
iVar1é liberado na linha onde está atribuído aFUN_801a7114, mas ainda está sendo usado como argumento na linha seguinte. Para corrigir isso, reatribua o resultado deFUN_801a7114de volta paraiVar1.iVar1 = FUN_801a7114 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );Injeção de SQL : Na função
upnp_device_discovery, existe a possibilidade de injeção de SQL ao chamarFUN_801a6bb4com a entrada do usuário como argumento. Para corrigir isso, use consultas parametrizadas ou instruções preparadas para evitar injeção de SQL.iVar1 = FUN_801a6bb4 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );Estas são algumas das possíveis vulnerabilidades de segurança que podem ser encontradas no trecho de código fornecido.
Podemos ver que ele encontrou o estouro de pilha no ponto 2, nos outros pontos parece fazer suposições sobre comportamento que estão completamente incorretas.
O script também pode fornecer descrições de instruções na janela de listagem (salva a navegação nos manuais dos programadores), aqui está um exemplo disso:
movz v1, a0, v0
Aqui está a resposta:
Uma deliciosa instrução MIPS!
A instrução
movz v1, a0, v0é uma instrução de carregamento/armazenamento que executa um movimento inteiro com operação de extensão zero.Vamos decompô-lo:
movz: Este é o mnemônico da instrução, que significa "mover com extensão zero". É usado para transferir dados entre registradores enquanto estende bits de sinal.v1,a0ev0são nomes de registro. No MIPS, esses registradores têm as seguintes funções:
v1: Registro de destino (onde será armazenado o resultado).a0: Registro fonte 1 (contém o valor a ser movido).v0: O registro de origem 2 não é necessário neste caso.O objetivo desta instrução é copiar o conteúdo de
a0parav1e estender o bit de sinal dea0se for negativo. O resultado será armazenado emv1.Para entender o que significa "extensão zero", vamos considerar um exemplo:
Suponha que
a0contenha o valor-5. Na representação binária, isso é11111011. Quando realizamos uma operação de extensão de zero neste valor, essencialmente adicionamos zeros à esquerda para torná-lo um número inteiro de 32 bits. O valor binário resultante seria00000000011111011.Em exemplos de código assembly:
- Suponha que você tenha os seguintes valores nos registradores:
a0: -5 (binário:11111011)v0não é usado neste exemplo Então, após executarmovz v1, a0, v0, o registradorv1conterá o valor-5.
- Agora suponha que você tenha:
a0: 17 (binário:00010001)- Novamente,
v0não é usadoDepois de executar
movz v1, a0, v0, o registrov1ainda manterá o valor binário original de17, pois já é positivo e não requer nenhuma extensão zero.
- Mais um exemplo com:
a0: -128 (binário:10000000)- Novamente,
v0não é usadoApós executar
movz v1, a0, v0, o registradorv1conterá o valor-128.Lembre-se que no MIPS a instrução
movzsó pode se mover entre registradores do mesmo tamanho (números inteiros de 32 bits). Os valores são repassados diretamente sem qualquer conversão ou promoção.Em resumo,
movz v1, a0, v0é usado para copiar dados inteiros de um registrador (a0) para outro (v1), estendendo bits de sinal se necessário.
Pedi ao modelo que explicasse a seguinte montagem:
801a7490 00 00 82 80 lb v0,0x0(a0)
801a7494 00 2e 05 00 sll a1,a1,0x18
801a7498 0b 00 40 10 beq v0,zero,LAB_801a74c8
801a749c 03 2e 05 00 _sra a1,a1,0x18
801a74a0 21 18 00 00 clear v1
LAB_801a74a4 XREF[1]: 801a74b4(j)
801a74a4 26 10 a2 00 xor v0,a1,v0
801a74a8 0a 18 82 00 movz v1,a0,v0
801a74ac 01 00 84 24 addiu a0,a0,0x1
801a74b0 00 00 82 80 lb v0,0x0(a0)
801a74b4 fb ff 40 14 bne v0,zero,LAB_801a74a4
801a74b8 00 00 00 00 _nop
LAB_801a74bc XREF[1]: 801a74c8(j)
801a74bc 21 10 80 00 move v0,a0
801a74c0 08 00 e0 03 jr ra
801a74c4 0b 10 65 00 _movn v0,v1,a1
LAB_801a74c8 XREF[1]: 801a7498(j)
801a74c8 2f 9d 06 08 j LAB_801a74bc
801a74cc 21 18 00 00 _clear v1
Aqui está a resposta:
Um trecho de código assembly do MIPS!
Aqui está uma análise do que cada instrução faz:
0x801a7490: lb v0,0x0(a0)
lbé a instrução "carregar byte".v0é o registrador de destino (ou seja, onde o resultado será armazenado).0x0(a0)é o endereço efetivo do byte a ser carregado. A parte(a0)significa que o valor no registroa0deve ser adicionado ao valor imediato0x0para formar o endereço efetivo.- Portanto, esta instrução carrega um byte do local de memória
a0 + 0 = a0no registradorv0.0x801a7494: sll a1,a1,0x18
sllé a instrução "deslocamento lógico para a esquerda".a1é o registrador fonte (isto é, o valor a ser deslocado).- O valor imediato
0x18especifica quantos bits serão deslocados. Nesse caso, são 24 bits (já que o MIPS usa palavras de 32 bits), então todos os bits são efetivamente zerados.- Portanto, esta instrução limpa os bits superiores do registrador
a1.0x801a7498: beq v0,zero,0x801a74c8
beqé a instrução "branch if equal".- Os dois primeiros operandos são comparados. Se eles forem iguais (ou seja, ambos zero), então...
- ...o programa ramifica para o endereço especificado pelo terceiro operando: 0x801a74c8 .
0x801a749c: _sra a1,a1,0x18
- Esta instrução é semelhante a
sll, mas é "alteração aritmética para a direita". O efeito é o mesmo da instrução anterior.0x801a74a0: limpar v1
_clear(observe o sublinhado) limpa o valor do registrov1.0x801a74a4:xor v0,a1,v0
xoré a instrução "OR exclusivo".- Os dois primeiros operandos são comparados. Se um dos bits estiver definido em um operando, mas não em ambos, então...
- ...o bit correspondente no resultado (registro
v0) é definido.0x801a74a8:movz v1,a0,v0
_movz(observe o sublinhado) carrega uma palavra do local de memóriaa0 + 0 = a0no registrov1.0x801a74ac: adicione a0,a0,0x1
addiué a instrução "adicionar imediato não assinado".- O valor no registro
a0é incrementado em 1.0x801a74b0: lb v0,0x0(a0)
- Isso é semelhante à primeira instrução. Ele carrega um byte do local da memória
a0 + 0 = a0no registrov0.0x801a74b4: bom v0,zero,0x801a74a4
bneé a instrução "branch if not equal".- O valor no registro
v0é comparado a zero. Se eles não forem iguais (ou seja,v0é diferente de zero), então...- ...o programa volta para 0x801a74a4 .
0x801a74b8: _nop
_nopé uma instrução autônoma, que não tem efeito.0x801a74bc: mover v0,a0
movecarrega o valor do registroa0no registrov0.0x801a74c0: jr ra
jré a instrução de "registro de salto".- O programa salta para o endereço armazenado no registrador
ra. Este é provavelmente o endereço de retorno, portanto a função será encerrada.0x801a74c4: _movn v0,v1,a1
_movncarrega uma palavra do local de memóriaa1 + 0 = a1no registrov0.0x801a74c8: j 0x801a74bc
- Este é o alvo de ramificação da primeira instrução
beq.- O programa ramifica para 0x801a74bc .
0x801a74cc: _limpar v1
_clearlimpa o valor do registrov1.O código parece estar implementando algum tipo de loop, incrementando um contador (
a0) e fazendo alguns cálculos com base em seu valor. Os detalhes não são claros sem mais contexto.
Este script é fornecido como exemplo e pode exigir modificações para se adequar a casos de uso específicos ou alterações na API Ollama. Consulte a documentação da API para quaisquer atualizações ou alterações.
Este script é inspirado no repositório GptHidra.
Este script também usa uma versão ligeiramente modificada de um desses scripts Ghidra.
Muito obrigado aos colaboradores destes projetos pelo seu trabalho inicial.
