GhidrOllama
1.0.0
Ollama API-Interaktion Ghidra-Skript für LLM-unterstütztes Reverse Engineering.
Dieses Skript interagiert mit der API von Ollama, um mit Large Language Models (LLMs) zu interagieren. Es nutzt die Ollama-API, um verschiedene Reverse-Engineering-Aufgaben durchzuführen, ohne Ghidra zu verlassen. Es unterstützt sowohl lokale als auch Remote-Instanzen von Ollama. Dieses Skript ist von GptHidra inspiriert.
Dieses Skript unterstützt jedes Modell, das Ollama unterstützt
Ollama hat kürzlich auch Unterstützung für jedes auf HuggingFace verfügbare Modell im GGUF-Format hinzugefügt, zum Beispiel:
ollama run hf.co/arcee-ai/SuperNova-Medius-GGUF
Fühlen Sie sich frei, llama3.1:8b durch eines der Ollama-kompatiblen Modelle zu ersetzen
curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.1:8b
Jetzt sollten Sie startklar sein, localhost:11434 sollte bereit sein, Anfragen zu bearbeiten
Hinweis: Dieses Skript unterstützt auch Remote-Instanzen. Legen Sie die IP-Adresse und den Port bei der ersten Konfiguration fest.
Die folgenden Konfigurationsoptionen sind verfügbar und können beim ersten Start konfiguriert werden:
localhost ein11434http oder https je nachdem, wie Ihre Instanz konfiguriert istMit den Optionen 11 und 12 können die Einstellungen nach dem ersten Start angepasst werden.
~/ghidra_scripts ).Es ist umständlich, jedes Mal in das Skriptfenster zu gehen, um dieses Skript auszuführen. Das Skript kann einfach auf folgende Weise ausgeführt werden:
Um es zu aktivieren, suchen Sie nach dem Hinzufügen Ihres Skripts zur Liste der Ghidra-Skriptverzeichnisse das Skript in der Liste. Klicken Sie mit der rechten Maustaste auf das Ergebnis und wählen Sie „Tastenbelegung zuweisen“. Wenn Sie zur Eingabe eines Schlüssels aufgefordert werden, geben Sie q ein.
Um das Symbolleistensymbol zu aktivieren, suchen Sie das Skript im Skriptmanager und klicken Sie auf das Kontrollkästchen in der ersten Spalte (Spalte „ In der Symbolleiste“ ). Das GhidrOllama-Symbol sollte in der Symbolleiste erscheinen.
Unten ist eine Implementierung von strchr(), wie sie im Ghidra-Dekompilierungsfenster mit entfernten Symbolen zu sehen ist:
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 ;
}Die folgende Analyse wurde mit dem Modell llama3.1:8b durchgeführt.
Interessante Funktion! Als Reverse-Engineering-Assistent werde ich die Funktionsweise dieses Codes aufschlüsseln und einige Einblicke geben.
Funktionssignatur
char * FUN_801a7490(char *param_1,char param_2)Die Funktion benötigt zwei Parameter:
param_1: ein Zeiger auf ein Zeichenarray (wahrscheinlich eine Zeichenfolge)param_2: ein einzelnes ZeichenFunktionskörper
Die Funktion führt Folgendes aus:
- Es prüft, ob das erste Zeichen von
param_1(cVar1)ist. Wenn dies der Fall ist, wirdpcVar2auf(char *)0x0gesetzt, was im Wesentlichen NULL ist.- Wenn
cVar1nichtist, tritt es in eine Schleife ein, in der:
- Es prüft, ob das Zeichen
param_2mit dem aktuellen Zeichen inparam_1(cVar1) übereinstimmt. Wenn sie übereinstimmen, wirdpcVar2auf die Adresse vonparam_1gesetzt.- Der Zeiger
param_1wird um eins erhöht, um auf das nächste Zeichen in der Zeichenfolge zu zeigen.- Die Schleife wird fortgesetzt, bis das Ende der Zeichenfolge erreicht ist (dh
cVar1wird zu).
- Wenn
param_2nicht null ist, gibt die Funktion die inpcVar2gespeicherte Adresse zurück.Einblicke
Basierend auf diesem Code scheint nach einem Zeichen (
param_2) innerhalb einer Zeichenfolge (param_1) zu suchen. Die Suche stoppt, sobald das erste Vorkommen dieses Zeichens gefunden wird.Das
if (param_2 != ' ') { param_1 = pcVar2; }-Anweisung legt nahe, dass die Funktion einen Zeiger auf diese Position innerhalb der Zeichenfolge zurückgibt, wennparam_2in der Zeichenfolge gefunden wird. Wenn nicht, wird immer noch ein gültiger Zeiger zurückgegeben (der wahrscheinlich auf den Anfang der Zeichenfolge zeigt).
GhidrOllama hat die Funktion in find_char_in_string umbenannt
Hier ist die geänderte Funktion mit zusätzlichen Kommentaren zur Erläuterung ihres Verhaltens:
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 ; }Diese Funktion scheint nach einem einzelnen Zeichen (param_2) innerhalb einer Zeichenfolge (param_1) zu suchen. Es gibt die Adresse der übereinstimmenden Zeichenfolge zurück oder null, wenn keine Übereinstimmung gefunden wird. Wenn die Eingabezeichenfolge leer ist, wird sofort null zurückgegeben.
Hier ist die umgeschriebene Funktion mit aussagekräftigeren Namen und Kommentaren:
/** * 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 ; }Beachten Sie, dass ich einen aussagekräftigeren Funktionsnamen
findCharacterInStringverwendet und Kommentare hinzugefügt habe, um zu erklären, was jeder Teil des Codes tut. Ich habe auch aussagekräftigere Variablennamen wiecurrentChar,foundCharPtr,stranstelle voncVar1,pcVar2usw. verwendet.
Ich habe GhidrOllama Code gegeben, von dem ich weiß, dass er einen Stapelüberlauf enthält, um zu sehen, ob er ihn erkennt, und hier ist die Antwort:
Interessante Bereiche, die Sicherheitslücken im angegebenen Code-Snippet aufweisen können:
NULL-Zeiger-Dereferenzierung : In der Funktion
upnp_device_discoverybesteht die Möglichkeit einer NULL-Zeiger-Dereferenzierung beim Zugriff aufiVar2am Offset0x2910. Dies kann passieren, wennDAT_8025d514kleiner als 3 ist und*(int *)(param_1 + 0x2910)NULL zurückgibt. Um dies zu beheben, fügen Sie vor der Dereferenzierung eine Prüfung hinzu, um sicherzustellen, dassiVar2nicht NULL ist.if ( DAT_8025d514 < 3 && iVar2 != NULL ) { iVar2 = * ( int * )( param_1 + 0x2910 ); }Pufferüberlauf : In der Funktion
upnp_device_discoverybesteht die Möglichkeit eines Pufferüberlaufs beim Aufruf vonstrcpy(auStack_98, iVar2 + 5);. Dies kann passieren, wenniVar2plus 5 die Grenzen desauStack_98-Arrays überschreitet. Um dies zu beheben, fügen Sie Prüfungen hinzu, um sicherzustellen, dass die Quell- und Zielpuffer nicht zu groß für die Zielzeichenfolge sind.if ( iVar2 != NULL && iVar2 + 5 <= iVar1 ) { strcpy ( auStack_98 , iVar2 + 5 ); }Use-After-Free : In der Funktion
upnp_device_discoverybesteht die Möglichkeit einer Use-After-Free beim Zugriff aufiVar1, nachdem diese im folgenden Codeausschnitt freigegeben wurde: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 ); }Die
iVar1wird in der Zeile freigegeben, in der sieFUN_801a7114zugewiesen wird, wird dann aber weiterhin als Argument in der folgenden Zeile verwendet. Um dies zu beheben, weisen Sie das Ergebnis vonFUN_801a7114wiederiVar1zu.iVar1 = FUN_801a7114 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );SQL-Injection : In der Funktion
upnp_device_discoverybesteht die Möglichkeit einer SQL-Injection beim AufrufFUN_801a6bb4mit Benutzereingaben als Argument. Um dieses Problem zu beheben, verwenden Sie parametrisierte Abfragen oder vorbereitete Anweisungen, um eine SQL-Injection zu verhindern.iVar1 = FUN_801a6bb4 ( iVar2 , s_check_pse_fid_Q7__801d0030 + 0x10 );Dies sind einige der potenziellen Sicherheitslücken, die im angegebenen Codeausschnitt zu finden sind.
Wir können sehen, dass es den Stapelüberlauf in Punkt 2 gefunden hat, in den anderen Punkten scheint es Annahmen über das Verhalten zu treffen, die völlig falsch sind.
Das Skript kann auch Beschreibungen von Anweisungen im Listenfenster bereitstellen (erspart das Durchsuchen von Programmierhandbüchern). Hier ist ein Beispiel dafür:
movz v1, a0, v0
Hier ist die Antwort:
Eine entzückende MIPS-Anleitung!
Die Anweisung
movz v1, a0, v0ist eine Lade-/Speicheranweisung, die eine Ganzzahlverschiebung mit Null-Erweiterungsoperation ausführt.Lassen Sie es uns aufschlüsseln:
movz: Dies ist die Mnemonik für die Anweisung, die für „Move with Zero-Extend“ steht. Es wird verwendet, um Daten zwischen Registern zu übertragen und gleichzeitig Vorzeichenbits zu erweitern.v1,a0undv0sind Registernamen. In MIPS haben diese Register die folgenden Rollen:
v1: Zielregister (wo das Ergebnis gespeichert wird).a0: Quellregister 1 (enthält den zu verschiebenden Wert).v0: Quellregister 2 ist in diesem Fall nicht erforderlich.Der Zweck dieser Anweisung besteht darin, den Inhalt von
a0inv1zu kopieren und das Vorzeichenbit vona0zu erweitern, wenn es negativ ist. Das Ergebnis wird inv1gespeichert.Um zu verstehen, was „Zero-Extend“ bedeutet, betrachten wir ein Beispiel:
Angenommen,
a0enthält den Wert-5. In binärer Darstellung ist dies11111011. Wenn wir für diesen Wert eine Null-Erweiterungsoperation durchführen, fügen wir im Wesentlichen führende Nullen hinzu, um ihn zu einer 32-Bit-Ganzzahl zu machen. Der resultierende Binärwert wäre00000000011111011.In Assembler-Codebeispielen:
- Angenommen, Sie haben die folgenden Werte in Registern:
a0: -5 (binär:11111011)v0wird in diesem Beispiel nicht verwendet. Nach der Ausführungmovz v1, a0, v0enthält das Registerv1dann den Wert-5.
- Angenommen, Sie haben:
a0: 17 (binär:00010001)- Auch hier wird
v0nicht verwendetNach dem Ausführen von
movz v1, a0, v0enthält das Registerv1immer noch den ursprünglichen Binärwert von17, da dieser bereits positiv ist und keine Nullerweiterung erfordert.
- Noch ein Beispiel mit:
a0: -128 (binär:10000000)- Auch hier wird
v0nicht verwendetNach der Ausführung von
movz v1, a0, v0enthält das Registerv1den Wert-128.Denken Sie daran, dass der Befehl
movzin MIPS nur zwischen Registern gleicher Größe (32-Bit-Ganzzahlen) wechseln kann. Die Werte werden ohne Umrechnung oder Promotion direkt übertragen.Zusammenfassend wird
movz v1, a0, v0verwendet, um ganzzahlige Daten von einem Register (a0) in ein anderes (v1) zu kopieren und bei Bedarf Vorzeichenbits zu erweitern.
Ich habe das Modell gebeten, den folgenden Zusammenbau zu erklären:
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
Hier ist die Antwort:
Ein MIPS-Assembly-Code-Snippet!
Hier ist eine Aufschlüsselung dessen, was jede Anweisung bewirkt:
0x801a7490: lb v0,0x0(a0)
lbist die Anweisung „Byte laden“.v0ist das Zielregister (d. h. dort, wo das Ergebnis gespeichert wird).0x0(a0)ist die effektive Adresse des zu ladenden Bytes. Der(a0)-Teil bedeutet, dass der Wert im Registera0zum unmittelbaren Wert0x0addiert werden sollte, um die effektive Adresse zu bilden.- Dieser Befehl lädt also ein Byte vom Speicherort
a0 + 0 = a0in das Registerv0.0x801a7494: sll a1,a1,0x18
sllist die Anweisung „logisch nach links verschieben“.a1ist das Quellregister (dh der zu verschiebende Wert).- Der unmittelbare Wert
0x18gibt an, wie viele Bits verschoben werden sollen. In diesem Fall sind es 24 Bit (da MIPS 32-Bit-Wörter verwendet), sodass alle Bits effektiv auf Null gesetzt werden.- Dieser Befehl löscht also die oberen Bits des Registers
a1.0x801a7498: beq v0,null,0x801a74c8
beqist die Anweisung „Verzweigen bei Gleichheit“.- Die ersten beiden Operanden werden verglichen. Wenn sie gleich sind (d. h. beide Null), dann...
- ...das Programm verzweigt zu der durch den dritten Operanden angegebenen Adresse: 0x801a74c8 .
0x801a749c: _sra a1,a1,0x18
- Diese Anweisung ähnelt
sll, handelt es sich jedoch um eine „Rechtsverschiebungs-Arithmetik“. Der Effekt ist der gleiche wie in der vorherigen Anleitung.0x801a74a0: v1 löschen
_clear(beachten Sie den Unterstrich) löscht den Wert von Registerv1.0x801a74a4: xor v0,a1,v0
xorist die „exklusive ODER“-Anweisung.- Die ersten beiden Operanden werden verglichen. Wenn eines der Bits in einem Operanden gesetzt ist, aber nicht in beiden, dann...
- ...das entsprechende Bit im Ergebnis (Register
v0) gesetzt ist.0x801a74a8: movz v1,a0,v0
_movz(beachten Sie den Unterstrich) lädt ein Wort vom Speicherorta0 + 0 = a0in das Registerv1.0x801a74ac: Addiu a0,a0,0x1
addiuist die Anweisung „sofort ohne Vorzeichen hinzufügen“.- Der Wert im Register
a0wird um 1 erhöht.0x801a74b0: lb v0,0x0(a0)
- Dies ähnelt der ersten Anweisung. Es lädt ein Byte vom Speicherort
a0 + 0 = a0in das Registerv0.0x801a74b4: bne v0,null,0x801a74a4
bneist die Anweisung „Verzweigen, wenn nicht gleich“.- Der Wert im Register
v0wird mit Null verglichen. Wenn sie nicht gleich sind (d. h.v0ist ungleich Null), dann ...- ...das Programm verzweigt zurück zu 0x801a74a4 .
0x801a74b8: _nop
_nopist eine No-Op-Anweisung, die keine Wirkung hat.0x801a74bc: v0,a0 verschieben
movelädt den Wert von Registera0in Registerv0.0x801a74c0: jr ra
jrist die Anweisung „Sprungregister“.- Das Programm springt zu der im Register
ragespeicherten Adresse. Dies ist wahrscheinlich die Rücksprungadresse, daher wird die Funktion beendet.0x801a74c4: _movn v0,v1,a1
_movnlädt ein Wort vom Speicherorta1 + 0 = a1in das Registerv0.0x801a74c8: j 0x801a74bc
- Dies ist das Verzweigungsziel der ersten
beq-Anweisung.- Das Programm verzweigt zu 0x801a74bc .
0x801a74cc: _clear v1
_clearlöscht den Wert von Registerv1.Der Code scheint eine Art Schleife zu implementieren, einen Zähler (
a0) zu erhöhen und eine Berechnung basierend auf seinem Wert durchzuführen. Die Details sind ohne weiteren Kontext unklar.
Dieses Skript wird als Beispiel bereitgestellt und erfordert möglicherweise Änderungen an bestimmte Anwendungsfälle oder Änderungen in der Ollama-API. Informationen zu Aktualisierungen oder Änderungen finden Sie in der API-Dokumentation.
Dieses Skript ist vom GptHidra-Repository inspiriert.
Dieses Skript verwendet auch eine leicht modifizierte Version eines dieser Ghidra-Skripte.
Vielen Dank an die Mitwirkenden dieser Projekte für ihre anfängliche Arbeit.
