GhidrOllama Télécharger - GhidrOllama Téléchargement du code source

GhidrOllama

Autres catégories

1.0.0

Télécharger

Interaction avec l'API Ollama Script Ghidra pour la rétro-ingénierie assistée par LLM.

Qu'est-ce que c'est?

Ce script interagit avec l'API d'Ollama pour interagir avec les grands modèles linguistiques (LLM). Il utilise l'API Ollama pour effectuer diverses tâches d'ingénierie inverse sans quitter Ghidra. Il prend en charge les instances locales et distantes d'Ollama. Ce script est inspiré de GptHidra.

Modèles pris en charge

Ce script prend en charge n'importe quel modèle pris en charge par Ollama

Ollama a également récemment ajouté la prise en charge de tous les modèles disponibles sur HuggingFace au format GGUF, par exemple :

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

Conditions préalables

Ghidra
Ollama
N'importe lequel des modèles Ollama

Configuration Ollama

N'hésitez pas à remplacer llama3.1:8b par l'un des modèles compatibles Ollama

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

Maintenant, vous devriez être prêt à partir, localhost:11434 devrait être prêt à traiter les demandes

Remarque : Ce script prend également en charge les instances distantes, définissez l'adresse IP et le port lors de la première configuration.

Que peut-il faire ?

Expliquez la fonction qui se trouve actuellement dans la fenêtre du décompilateur
Suggérer un nom pour la fonction actuelle, nommera automatiquement la fonction si cela a été activé
Réécrire la fonction actuelle avec les commentaires recommandés
Réécrivez complètement la fonction actuelle, en essayant d'améliorer les noms de fonction/paramètre/variable et en ajoutant également des commentaires
L'utilisateur peut poser une question sur une fonction
Rechercher des bugs/suggérer des vulnérabilités potentielles dans la fonction actuelle (plus simplement pour vous assurer que vous avez tout couvert, certaines suggestions sont stupides car elles n'ont pas de contexte)
Utilisez une version modifiée de ce script LeafBlowerLeafFunctions.py Ghidra pour automatiser l'analyse des fonctions potentielles de « feuille » telles que strcpy , memcpy , strlen , etc. dans les binaires avec des symboles supprimés, renommer automatiquement si cela est activé
Expliquer l'instruction d'assemblage unique actuellement sélectionnée dans la fenêtre de liste
Expliquer plusieurs instructions d'assemblage actuellement sélectionnées dans la fenêtre de liste
Entrée d'invite générale pour poser des questions (plutôt que d'avoir recours à Google, bon pour des choses simples)

Options de configuration

Les options de configuration suivantes sont disponibles et peuvent être configurées lors de la première exécution :

IP du serveur : si vous utilisez une instance distante, définissez-la sur l'adresse IP de l'instance distante, sinon entrez localhost
Port : Si votre instance se trouve sur un autre port, modifiez-le ici - la valeur par défaut est 11434
Schéma : Sélectionnez http ou https en fonction de la configuration de votre instance
Modèle : Sélectionnez le modèle que vous souhaitez utiliser pour l'analyse, vous pouvez le modifier à tout moment.
Invite spécifique au projet : utilisée pour donner un contexte supplémentaire au modèle si cela est nécessaire
Commentaires de réponse : Certaines options stockent les réponses sous forme de commentaire en haut de la fonction, cela peut être activé/désactivé ici
Renommer automatiquement : certaines options tentent de renommer automatiquement les fonctions en fonction des réponses, cela peut être activé/désactivé ici

Les options 11 et 12 peuvent être utilisées pour ajuster les paramètres après la première exécution.

Usage

Placez le script GhidrOllama.py et le répertoire ghidrollama_utils dans votre répertoire de script Ghidra (généralement ~/ghidra_scripts ).
Trouvez une fonction/instruction que vous souhaitez transmettre au LLM
Exécutez le script à partir de la fenêtre Script Manager
Si c'est la première fois que vous exécutez le script, terminez la configuration initiale (cela peut être modifié ultérieurement)
Sélectionnez la manière dont vous souhaitez que la fonction/l'instruction soit analysée
Attendez que la sortie soit imprimée sur la console (le temps d'attente varie en fonction du modèle et des spécifications de l'hôte)

Façons de courir

Entrer dans la fenêtre de script pour exécuter ce script à chaque fois n'est pas pratique, le script peut facilement être exécuté des manières suivantes :

Liaison de touches : La liaison de touches par défaut pour ce script est Q
Barre d'outils : Une petite icône sur la barre d'outils peut être cliquée pour exécuter le script

Reliure aux touches

Pour l'activer, une fois que vous avez ajouté votre script dans la liste des répertoires de scripts Ghidra, localisez le script dans la liste. Faites un clic droit sur le résultat et sélectionnez "Attribuer une liaison de clé". S'il vous demande une clé, entrez q .

Barre d'outils

Pour activer l'icône de la barre d'outils, localisez le script dans le gestionnaire de scripts et cochez la case dans la première colonne (la colonne Dans la barre d'outils ). L'icône GhidrOllama devrait apparaître dans la barre d'outils.

barre d'outils_icon.png

Remarques

Il est à noter que l'analyse ne sera aussi bonne que le modèle, ce script ne fait que relier les modèles et Ghidra.
Plus le modèle est performant (plus de paramètres, plus lent), plus l'analyse sera complète et correcte (la plupart du temps !)
Si vous voulez un aperçu rapide d'une fonction, lama3.1:8b est rapide et donne une analyse décente
Soyez prudent avec les grandes fonctions et les modèles à faible contexte, si la fonction est trop grande pour la fenêtre contextuelle, le modèle répondra avec un charabia complet (s'il répond pas du tout)

Exemples d'analyse de fonction

Vous trouverez ci-dessous une implémentation de strchr() comme on le voit dans la fenêtre de décompilation de Ghidra avec des symboles supprimés :

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

L'analyse suivante a été réalisée à l'aide du modèle lama3.1:8b .

Option 1 - Résumé des fonctions

Fonction intéressante ! En tant qu'assistant d'ingénierie inverse, je vais détailler ce que fait ce code et fournir quelques informations.
Signature de fonction
char * FUN_801a7490(char *param_1,char param_2)
La fonction prend deux paramètres :
param_1 : un pointeur vers un tableau de caractères (probablement une chaîne)
param_2 : un seul caractère
Corps de fonction
La fonction effectue les opérations suivantes :
Il vérifie si le premier caractère de param_1 ( cVar1 ) est . Si tel est le cas, alors pcVar2 est défini sur (char *)0x0 , ce qui est essentiellement NULL.
Si cVar1 n'est pas , il entre dans une boucle où :
Il vérifie si le caractère param_2 correspond au caractère actuel dans param_1 ( cVar1 ). S'ils correspondent, alors pcVar2 est défini sur l'adresse de param_1 .
Le pointeur param_1 est incrémenté de un pour pointer vers le caractère suivant de la chaîne.
La boucle continue jusqu'à ce que la fin de la chaîne soit atteinte (c'est-à-dire que cVar1 devient ).
Si param_2 n'est pas nul, alors la fonction renvoie l'adresse stockée dans pcVar2 .
Connaissances
Sur la base de ce code, il semble rechercher un caractère ( param_2 ) dans une chaîne ( param_1 ). La recherche s'arrête dès qu'elle trouve la première occurrence de ce caractère.
if (param_2 != '') { param_1 = pcVar2; } suggère que si param_2 est trouvé dans la chaîne, la fonction renvoie un pointeur vers cet emplacement dans la chaîne. Sinon, il renvoie toujours un pointeur valide (pointant probablement vers le début de la chaîne).

Option 2 - Dénomination des fonctions

GhidrOllama a renommé la fonction find_char_in_string

Option 3 - Ajouter des commentaires

Voici la fonction modifiée avec des commentaires supplémentaires pour expliquer son comportement :

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

Cette fonction semble rechercher un seul caractère (param_2) dans une chaîne (param_1). Il renvoie l'adresse de la chaîne correspondante, ou null si aucune correspondance n'est trouvée. Si la chaîne d'entrée est vide, elle renvoie immédiatement null.

Option 4 - Fonction de réécriture

Voici la fonction réécrite avec des noms et des commentaires plus descriptifs :

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

Notez que j'ai utilisé un nom de fonction plus descriptif findCharacterInString et ajouté des commentaires pour expliquer ce que fait chaque partie du code. J'ai également utilisé des noms de variables plus descriptifs comme currentChar , foundCharPtr , str au lieu de cVar1 , pcVar2 , etc.

Exemple de recherche de vulnérabilité

J'ai donné à GhidrOllama du code dont je sais qu'il contient un débordement de pile pour voir s'il le détecte, et voici la réponse :

Domaines intéressants pouvant présenter des vulnérabilités de sécurité dans l'extrait de code donné :
Déréférencement de pointeur NULL : Dans la fonction upnp_device_discovery , il existe une possibilité de déréférencement de pointeur NULL lors de l'accès à iVar2 au décalage 0x2910 . Cela peut se produire si DAT_8025d514 est inférieur à 3 et que *(int *)(param_1 + 0x2910) renvoie NULL. Pour résoudre ce problème, ajoutez une vérification pour vous assurer que iVar2 n'est pas NULL avant de le déréférencer.
 if ( DAT_8025d514 < 3 && iVar2 != NULL ) {
  iVar2 = * ( int * )( param_1 + 0x2910 );
}
Buffer Overflow : Dans la fonction upnp_device_discovery , il y a une possibilité de buffer overflow lors de l'appel strcpy(auStack_98, iVar2 + 5); . Cela peut se produire si iVar2 plus 5 dépasse les limites du tableau auStack_98 . Pour résoudre ce problème, ajoutez des vérifications pour vous assurer que les tampons source et de destination ne sont pas trop volumineux pour la chaîne cible.
 if ( iVar2 != NULL && iVar2 + 5 <= iVar1 ) {
    strcpy ( auStack_98 , iVar2 + 5 );
}
Use-After-Free : Dans la fonction upnp_device_discovery , il existe une possibilité d'utilisation après-libération lors de l'accès iVar1 après sa libération dans l'extrait de code suivant :
 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 );
}
Le iVar1 est libéré dans la ligne où il est affecté à FUN_801a7114 , mais il est ensuite toujours utilisé comme argument dans la ligne suivante. Pour résoudre ce problème, réaffectez le résultat de FUN_801a7114 à iVar1 .
 iVar1 = FUN_801a7114 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );
Injection SQL : Dans la fonction upnp_device_discovery , il existe une possibilité d'injection SQL lors de l'appel FUN_801a6bb4 avec la saisie de l'utilisateur comme argument. Pour résoudre ce problème, utilisez des requêtes paramétrées ou des instructions préparées pour empêcher l'injection SQL.
 iVar1 = FUN_801a6bb4 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );
Voici quelques-unes des vulnérabilités de sécurité potentielles qui peuvent être trouvées dans l'extrait de code donné.

Nous pouvons voir qu'il a trouvé le débordement de pile au point 2, dans les autres points, il semble faire des hypothèses sur le comportement qui sont complètement incorrectes.

Décrire un exemple d'instruction

Le script peut également fournir des descriptions d'instructions dans la fenêtre de liste (enregistre la navigation dans les manuels des programmeurs), voici un exemple pour cela :

 movz v1, a0, v0

Voici la réponse :

Une délicieuse instruction MIPS !
L'instruction movz v1, a0, v0 est une instruction de chargement/stockage qui effectue un déplacement d'entier avec une opération d'extension de zéro.
Décomposons-le :
movz : C'est le mnémonique de l'instruction, qui signifie "move with zero-extend". Il est utilisé pour transférer des données entre registres tout en étendant les bits de signe.
v1 , a0 et v0 sont des noms de registre. Dans MIPS, ces registres ont les rôles suivants :
v1 : Registre de destination (où le résultat sera stocké).
a0 : Registre source 1 (contient la valeur à déplacer).
v0 : Le registre source 2 n'est pas nécessaire dans ce cas.
Le but de cette instruction est de copier le contenu de a0 dans v1 et d'étendre le bit de signe de a0 s'il est négatif. Le résultat sera stocké dans v1 .
Pour comprendre ce que signifie « zéro-extension », prenons un exemple :
Supposons que a0 contienne la valeur -5 . En représentation binaire, c'est 11111011 . Lorsque nous effectuons une opération d'extension de zéro sur cette valeur, nous ajoutons essentiellement des zéros non significatifs pour en faire un entier de 32 bits. La valeur binaire résultante serait 00000000011111011 .
Dans les exemples de code assembleur :
Supposons que vous ayez les valeurs suivantes dans les registres :
a0 : -5 (binaire : 11111011 )
v0 n'est pas utilisé dans cet exemple. Ensuite, après avoir exécuté movz v1, a0, v0 , le registre v1 contiendra la valeur -5 .
Supposons maintenant que vous ayez :
a0 : 17 (binaire : 00010001 )
Encore une fois, v0 n'est pas utilisée
Après avoir exécuté movz v1, a0, v0 , le registre v1 contiendra toujours la valeur binaire d'origine de 17 , car elle est déjà positive et ne nécessite aucune extension nulle.
Encore un exemple avec :
a0 : -128 (binaire : 10000000 )
Encore une fois, v0 n'est pas utilisée
Après avoir exécuté movz v1, a0, v0 , le registre v1 contiendra la valeur -128 .
Rappelons qu'en MIPS, l'instruction movz ne peut se déplacer qu'entre registres de même taille (entiers 32 bits). Les valeurs sont transférées directement sans aucune conversion ni promotion.
En résumé, movz v1, a0, v0 est utilisé pour copier des données entières d'un registre ( a0 ) à un autre ( v1 ), en étendant les bits de signe si nécessaire.

Décrire un exemple d'assemblage

J'ai demandé au modèle d'expliquer le montage suivant :

  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

Voici la réponse :

Un extrait de code d'assemblage MIPS !
Voici un aperçu de ce que fait chaque instruction :
0x801a7490 : livre v0,0x0(a0)
lb est l'instruction "load byte".
v0 est le registre de destination (c'est-à-dire où le résultat sera stocké).
0x0(a0) est l'adresse effective de l'octet à charger. La partie (a0) signifie que la valeur du registre a0 doit être ajoutée à la valeur immédiate 0x0 pour former l'adresse effective.
Ainsi, cette instruction charge un octet de l'emplacement mémoire a0 + 0 = a0 dans le registre v0 .
0x801a7494 : toujours a1,a1,0x18
sll est l'instruction "décalage logique vers la gauche".
a1 est le registre source (c'est-à-dire la valeur à décaler).
La valeur immédiate 0x18 spécifie le nombre de bits à décaler. Dans ce cas, il s'agit de 24 bits (puisque MIPS utilise des mots de 32 bits), donc tous les bits sont effectivement mis à zéro.
Ainsi, cette instruction efface les bits supérieurs du registre a1 .
0x801a7498 : beq v0,zéro,0x801a74c8
beq est l'instruction "branche si égal".
Les deux premiers opérandes sont comparés. S'ils sont égaux (c'est-à-dire tous deux nuls), alors...
...le programme passe à l'adresse spécifiée par le troisième opérande : 0x801a74c8 .
0x801a749c : _sra a1,a1,0x18
Cette instruction est similaire à sll , mais c'est du "shift arithmétique à droite". L'effet est le même que dans l'instruction précédente.
0x801a74a0 : effacer la v1
_clear (notez le trait de soulignement) efface la valeur du registre v1 .
0x801a74a4 : xor v0, a1, v0
xor est l'instruction "OU exclusif".
Les deux premiers opérandes sont comparés. Si l'un ou l'autre bit est défini dans un opérande mais pas dans les deux, alors...
...le bit correspondant dans le résultat (registre v0 ) est défini.
0x801a74a8 : movz v1, a0, v0
_movz (notez le trait de soulignement) charge un mot de l'emplacement mémoire a0 + 0 = a0 dans le registre v1 .
0x801a74ac : ajouter a0,a0,0x1
addiu est l'instruction "ajouter immédiatement un signe non signé".
La valeur du registre a0 est incrémentée de 1.
0x801a74b0 : livre v0,0x0(a0)
Ceci est similaire à la première instruction. Il charge un octet de l'emplacement mémoire a0 + 0 = a0 dans le registre v0 .
0x801a74b4 : bne v0,zéro,0x801a74a4
bne est l'instruction "branche si non égale".
La valeur dans le registre v0 est comparée à zéro. S'ils ne sont pas égaux (c'est-à-dire que v0 est différent de zéro), alors...
... le programme revient à 0x801a74a4 .
0x801a74b8 : _nop
_nop est une instruction no-op, qui n'a aucun effet.
0x801a74bc : déplacer v0,a0
move charge la valeur du registre a0 dans le registre v0 .
0x801a74c0 : jr ra
jr est l'instruction "jump register".
Le programme passe à l'adresse stockée dans le registre ra . Il s'agit probablement de l'adresse de retour, donc la fonction se terminera.
0x801a74c4 : _movn v0, v1, a1
_movn charge un mot de l'emplacement mémoire a1 + 0 = a1 dans le registre v0 .
0x801a74c8 : j 0x801a74bc
Il s'agit de la cible de branchement de la première instruction beq .
Le programme passe à 0x801a74bc .
0x801a74cc : _clear v1
_clear efface la valeur du registre v1 .
Le code semble implémenter une sorte de boucle, incrémentant un compteur ( a0 ) et effectuant des calculs en fonction de sa valeur. Les détails ne sont pas clairs sans plus de contexte.

Clause de non-responsabilité

Ce script est fourni à titre d'exemple et peut nécessiter des modifications pour s'adapter à des cas d'utilisation spécifiques ou à des modifications de l'API Ollama. Veuillez vous référer à la documentation de l'API pour toute mise à jour ou modification.