Descargar GhidrOllama - Descarga del código fuente GhidrOllama

GhidrOllama

Otras categorias

1.0.0

Descargar

Script Ghidra de interacción API de Ollama para ingeniería inversa asistida por LLM.

¿Qué es esto?

Este script interactúa con la API de Ollama para interactuar con modelos de lenguajes grandes (LLM). Utiliza la API de Ollama para realizar diversas tareas de ingeniería inversa sin salir de Ghidra. Admite instancias locales y remotas de Ollama. Este script está inspirado en GptHidra.

Modelos compatibles

Este script soporta cualquier modelo que soporte Ollama.

Ollama también agregó recientemente soporte para cualquier modelo disponible en HuggingFace en formato GGUF, por ejemplo:

 ollama run hf.co/arcee-ai/SuperNova-Medius-GGUF

Requisitos previos

Ghidra
Ollama
Cualquiera de los modelos Ollama

Configuración de Ollama

No dudes en reemplazar llama3.1:8b con cualquiera de los modelos compatibles con Ollama.

 curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.1:8b

Ahora debería estar listo para comenzar, localhost:11434 debería estar listo para manejar solicitudes.

Nota: Este script también admite instancias remotas; configure la dirección IP y el puerto durante la primera configuración.

¿Qué puede hacer?

Explicar la función que se encuentra actualmente en la ventana del descompilador.
Sugiera un nombre para la función actual; nombrará automáticamente la función si se ha habilitado
Reescribir la función actual con comentarios recomendados
Reescriba completamente la función actual, intentando mejorar los nombres de funciones/parámetros/variables y también agregar comentarios
El usuario puede hacer una pregunta sobre una función.
Buscar errores/sugerir vulnerabilidades potenciales en la función actual (más bien para asegurarse de haber cubierto todo, algunas sugerencias son tontas ya que no tienen el contexto)
Utilice una versión modificada de este script LeafBlowerLeafFunctions.py Ghidra para automatizar el análisis de posibles funciones de 'hoja' como strcpy , memcpy , strlen , etc. en binarios con símbolos eliminados, cambio de nombre automático si está habilitado
Explique la instrucción de ensamblaje única que está actualmente seleccionada en la ventana de listado.
Explicar las múltiples instrucciones de ensamblaje que están seleccionadas actualmente en la ventana de listado.
Entrada de aviso general para hacer preguntas (en lugar de tener que buscar en Google, bueno para cosas simples)

Opciones de configuración

Las siguientes opciones de configuración están disponibles y se pueden configurar en la primera ejecución:

IP del servidor : si utiliza una instancia remota, configúrelo en la IP de la instancia remota; de lo contrario, ingrese localhost
Puerto : si su instancia está en un puerto diferente, cámbielo aquí; el valor predeterminado es 11434
Esquema : seleccione http o https según cómo esté configurada su instancia
Modelo : seleccione el modelo que desea utilizar para el análisis, puede cambiarlo en cualquier momento
Mensaje específico del proyecto : se utiliza para dar contexto adicional al modelo si es necesario.
Comentarios de respuesta : algunas opciones almacenan las respuestas como un comentario en la parte superior de la función, esto se puede habilitar/deshabilitar aquí
Cambio de nombre automático : algunas opciones intentan cambiar el nombre de las funciones automáticamente según las respuestas; esto se puede habilitar/deshabilitar aquí

Las opciones 11 y 12 se pueden utilizar para ajustar la configuración después de la primera ejecución.

Uso

Coloque el script GhidrOllama.py y el directorio ghidrollama_utils en su directorio de script Ghidra (generalmente ~/ghidra_scripts ).
Encuentre una función/instrucción que desee enviar al LLM
Ejecute el script desde la ventana del Administrador de scripts
Si es la primera vez que ejecuta el script, complete la configuración inicial (esto se puede cambiar más adelante)
Seleccione cómo desea que funcione/instrucción a analizar
Espere hasta que la salida se imprima en la consola (el tiempo de espera varía según el modelo y las especificaciones del host)

Formas de correr

Entrar en la ventana del script para ejecutar este script cada vez es un inconveniente, el script se puede ejecutar fácilmente de las siguientes maneras:

Combinación de teclas : la combinación de teclas predeterminada para este script es Q
Barra de herramientas : se puede hacer clic en un pequeño icono en la barra de herramientas para ejecutar el script.

Combinación de teclas

Para habilitarlo, una vez que haya agregado su script a la lista de directorios de scripts de Ghidra, ubique el script en la lista. Haga clic derecho en el resultado y seleccione "Asignar combinación de teclas". Si solicita una clave, ingrese q .

Barra de herramientas

Para habilitar el icono de la barra de herramientas, ubique el script en el administrador de scripts y haga clic en la casilla de verificación en la primera columna (la columna En la barra de herramientas ). El icono de GhidrOllama debería aparecer en la barra de herramientas.

Notas

Vale la pena señalar que el análisis solo será tan bueno como el modelo, este script básicamente une los modelos y Ghidra.
Cuanto mejor sea el modelo (más parámetros, más lento), más completo y correcto será el análisis (¡la mayor parte de las veces!)
Si desea una descripción general rápida de una función, llama3.1:8b es rápido y ofrece un análisis decente.
Tenga cuidado con funciones grandes y modelos de bajo contexto, si la función es demasiado grande para la ventana de contexto, el modelo responderá con un completo galimatías (si es que responde).

Ejemplos de análisis de funciones

A continuación se muestra una implementación de strchr() como se ve en la ventana de descompilación de Ghidra con símbolos eliminados:

 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 ;
}

El siguiente análisis se realizó utilizando el modelo llama3.1:8b .

Opción 1: Resumen de funciones

¡Función interesante! Como asistente de ingeniería inversa, desglosaré lo que hace este código y brindaré algunas ideas.
Firma de función
char * FUN_801a7490(char *param_1,char param_2)
La función toma dos parámetros:
param_1 : un puntero a una matriz de caracteres (probablemente una cadena)
param_2 : un solo carácter
Cuerpo de función
La función hace lo siguiente:
Comprueba si el primer carácter de param_1 ( cVar1 ) es . Si es así, entonces pcVar2 se establece en (char *)0x0 , que es esencialmente NULL.
Si cVar1 no es , ingresa a un bucle donde:
Comprueba si el carácter param_2 coincide con el carácter actual en param_1 ( cVar1 ). Si coinciden, entonces pcVar2 se establece en la dirección de param_1 .
El puntero param_1 se incrementa en uno para apuntar al siguiente carácter de la cadena.
El bucle continúa hasta que se alcanza el final de la cadena (es decir, cVar1 se convierte en ).
Si param_2 no es nulo, la función devuelve la dirección almacenada en pcVar2 .
Perspectivas
Según este código, parece estar buscando un carácter ( param_2 ) dentro de una cadena ( param_1 ). La búsqueda se detiene tan pronto como encuentra la primera aparición de ese carácter.
El if (param_2 != '') { param_1 = pcVar2; } sugiere que si se encuentra param_2 en la cadena, la función devuelve un puntero a esa ubicación dentro de la cadena. De lo contrario, aún devuelve un puntero válido (probablemente apuntando al comienzo de la cadena).

Opción 2: denominación de funciones

GhidrOllama cambió el nombre de la función a find_char_in_string

Opción 3: Agregar comentarios

Aquí está la función modificada con comentarios adicionales para explicar su comportamiento:

 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 función parece estar buscando un solo carácter (param_2) dentro de una cadena (param_1). Devuelve la dirección de la cadena coincidente, o nula si no se encuentra ninguna coincidencia. Si la cadena de entrada está vacía, devuelve nulo inmediatamente.

Opción 4: función de reescritura

Aquí está la función reescrita con nombres y comentarios más descriptivos:

 /**
 * 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 ;
}

Tenga en cuenta que utilicé un nombre de función más descriptivo findCharacterInString y agregué comentarios para explicar qué hace cada parte del código. También he usado nombres de variables más descriptivos como currentChar , foundCharPtr , str en lugar de cVar1 , pcVar2 , etc.

Ejemplo de búsqueda de vulnerabilidades

Le di a GhidrOllama un código que sé que contiene un desbordamiento de pila para ver si lo detecta, y aquí está la respuesta:

Áreas interesantes que pueden presentar vulnerabilidades de seguridad en el fragmento de código proporcionado:
Desreferencia del puntero NULL : en la función upnp_device_discovery , existe la posibilidad de desreferencia del puntero NULL al acceder iVar2 en el desplazamiento 0x2910 . Esto puede suceder si DAT_8025d514 es menor que 3 y *(int *)(param_1 + 0x2910) devuelve NULL. Para solucionar este problema, agregue una verificación para asegurarse de que iVar2 no sea NULL antes de eliminar la referencia.
 if ( DAT_8025d514 < 3 && iVar2 != NULL ) {
  iVar2 = * ( int * )( param_1 + 0x2910 );
}
Desbordamiento del búfer : en la función upnp_device_discovery , existe la posibilidad de que se produzca un desbordamiento del búfer al llamar strcpy(auStack_98, iVar2 + 5); . Esto puede suceder si iVar2 plus 5 excede los límites de la matriz auStack_98 . Para solucionar este problema, agregue comprobaciones para garantizar que los buffers de origen y destino no sean demasiado grandes para la cadena de destino.
 if ( iVar2 != NULL && iVar2 + 5 <= iVar1 ) {
    strcpy ( auStack_98 , iVar2 + 5 );
}
Use-After-Free : En la función upnp_device_discovery , existe la posibilidad de use-after-free al acceder iVar1 después de que se haya liberado en el siguiente fragmento 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 );
}
El iVar1 se libera en la línea donde está asignado a FUN_801a7114 , pero aún se usa como argumento en la siguiente línea. Para solucionar este problema, reasigne el resultado de FUN_801a7114 nuevamente a iVar1 .
 iVar1 = FUN_801a7114 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );
Inyección SQL : en la función upnp_device_discovery , existe la posibilidad de inyección SQL al llamar FUN_801a6bb4 con la entrada del usuario como argumento. Para solucionar este problema, utilice consultas parametrizadas o declaraciones preparadas para evitar la inyección de SQL.
 iVar1 = FUN_801a6bb4 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );
Estas son algunas de las posibles vulnerabilidades de seguridad que se pueden encontrar en el fragmento de código proporcionado.

Podemos ver que encontró el desbordamiento de pila en el punto 2, en los otros puntos parece hacer suposiciones sobre el comportamiento que son completamente incorrectas.

Describir el ejemplo de instrucción

El script también puede proporcionar descripciones de instrucciones en la ventana de listado (guarda la navegación por los manuales de los programadores), aquí hay un ejemplo para eso:

 movz v1, a0, v0

Aquí está la respuesta:

¡Una deliciosa instrucción MIPS!
La instrucción movz v1, a0, v0 es una instrucción de carga/almacenamiento que realiza un movimiento de números enteros con operación de extensión cero.
Vamos a desglosarlo:
movz : Este es el mnemónico de la instrucción, que significa "mover con extensión cero". Se utiliza para transferir datos entre registros mientras se extienden los bits de signo.
v1 , a0 y v0 son nombres de registros. En MIPS, estos registros tienen las siguientes funciones:
v1 : Registro de destino (donde se almacenará el resultado).
a0 : Registro fuente 1 (contiene el valor que se va a mover).
v0 : el registro fuente 2 no es necesario en este caso.
El propósito de esta instrucción es copiar el contenido de a0 en v1 y extender el bit de signo de a0 si es negativo. El resultado se almacenará en v1 .
Para entender lo que significa "extensión cero", consideremos un ejemplo:
Supongamos a0 contiene el valor -5 . En representación binaria, esto es 11111011 . Cuando realizamos una operación de extensión de ceros en este valor, esencialmente agregamos ceros a la izquierda para convertirlo en un entero de 32 bits. El valor binario resultante sería 00000000011111011 .
En ejemplos de código ensamblador:
Supongamos que tiene los siguientes valores en los registros:
a0 : -5 (binario: 11111011 )
v0 no se usa en este ejemplo Luego, después de ejecutar movz v1, a0, v0 , el registro v1 contendrá el valor -5 .
Ahora suponga que tiene:
a0 : 17 (binario: 00010001 )
Nuevamente, v0 no se usa.
Después de ejecutar movz v1, a0, v0 , el registro v1 aún mantendrá el valor binario original de 17 , ya que ya es positivo y no requiere ninguna extensión cero.
Un ejemplo más con:
a0 : -128 (binario: 10000000 )
Nuevamente, v0 no se usa.
Después de ejecutar movz v1, a0, v0 , el registro v1 contendrá el valor -128 .
Recuerde que en MIPS, la instrucción movz sólo puede moverse entre registros del mismo tamaño (enteros de 32 bits). Los valores se transfieren directamente sin ninguna conversión o promoción.
En resumen, movz v1, a0, v0 se utiliza para copiar datos enteros de un registro ( a0 ) a otro ( v1 ), ampliando los bits de signo si es necesario.

Describir el ejemplo de ensamblaje

Le pedí al modelo que explicara el siguiente ensamblaje:

  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

Aquí está la respuesta:

¡Un fragmento de código ensamblador MIPS!
Aquí hay un desglose de lo que hace cada instrucción:
0x801a7490: libra v0,0x0(a0)
lb es la instrucción de "cargar byte".
v0 es el registro de destino (es decir, donde se almacenará el resultado).
0x0(a0) es la dirección efectiva del byte que se va a cargar. La parte (a0) significa que el valor en el registro a0 debe agregarse al valor inmediato 0x0 para formar la dirección efectiva.
Entonces, esta instrucción carga un byte desde la ubicación de memoria a0 + 0 = a0 en el registro v0 .
0x801a7494: sll a1,a1,0x18
sll es la instrucción "desplazar lógicamente a la izquierda".
a1 es el registro fuente (es decir, el valor que se va a desplazar).
El valor inmediato 0x18 especifica cuántos bits desplazar. En este caso, son 24 bits (ya que MIPS usa palabras de 32 bits), por lo que todos los bits se ponen a cero de manera efectiva.
Entonces, esta instrucción borra los bits superiores del registro a1 .
0x801a7498: beq v0,cero,0x801a74c8
beq es la instrucción "ramificar si es igual".
Se comparan los dos primeros operandos. Si son iguales (es decir, ambos cero), entonces...
...el programa se bifurca a la dirección especificada por el tercer operando: 0x801a74c8 .
0x801a749c: _sra a1,a1,0x18
Esta instrucción es similar a sll , pero es "desplazamiento aritmético a la derecha". El efecto es el mismo que en la instrucción anterior.
0x801a74a0: borrar v1
_clear (tenga en cuenta el guión bajo) borra el valor del registro v1 .
0x801a74a4: xorv0,a1,v0
xor es la instrucción "OR exclusiva".
Se comparan los dos primeros operandos. Si cualquiera de los bits está establecido en un operando pero no en ambos, entonces...
...se establece el bit correspondiente en el resultado (registro v0 ).
0x801a74a8: movzv1,a0,v0
_movz (tenga en cuenta el guión bajo) carga una palabra desde la ubicación de memoria a0 + 0 = a0 en el registro v1 .
0x801a74ac: agregar a0,a0,0x1
addiu es la instrucción "agregar inmediatamente sin firmar".
El valor del registro a0 se incrementa en 1.
0x801a74b0: libra v0,0x0(a0)
Esto es similar a la primera instrucción. Carga un byte desde la ubicación de memoria a0 + 0 = a0 en el registro v0 .
0x801a74b4: bnev0,cero,0x801a74a4
bne es la instrucción "ramificar si no es igual".
El valor del registro v0 se compara con cero. Si no son iguales (es decir, v0 no es cero), entonces...
...el programa vuelve a 0x801a74a4 .
0x801a74b8: _noop
_nop es una instrucción no operativa, que no tiene ningún efecto.
0x801a74bc: mover v0,a0
move carga el valor del registro a0 en el registro v0 .
0x801a74c0: jr ra
jr es la instrucción de "salto de registro".
El programa salta a la dirección almacenada en el registro ra . Es probable que esta sea la dirección del remitente, por lo que la función finalizará.
0x801a74c4: _movnv0,v1,a1
_movn carga una palabra desde la ubicación de memoria a1 + 0 = a1 en el registro v0 .
0x801a74c8:j 0x801a74bc
Este es el objetivo de la rama de la primera instrucción beq .
El programa se bifurca a 0x801a74bc .
0x801a74cc: _claro v1
_clear borra el valor del registro v1 .
El código parece estar implementando algún tipo de bucle, incrementando un contador ( a0 ) y haciendo algunos cálculos en función de su valor. Los detalles no están claros sin más contexto.

Descargo de responsabilidad

Este script se proporciona como muestra y puede requerir modificaciones para adaptarse a casos de uso específicos o cambios en la API de Ollama. Consulte la documentación de la API para conocer cualquier actualización o cambio.