One place for hosting & domains

      Radamsa

      So installieren und verwenden Sie Radamsa zum Fuzz-Testen von Programmen und Netzwerkdiensten unter Ubuntu 18.04


      Der Autor wählte die Electronic Frontier Foundation Inc, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Sicherheitsbedrohungen werden immer ausgefeilter, sodass Entwickler und Systemadministratoren bei der Verteidigung und dem Testen der Sicherheit ihrer Anwendungen einen proaktiven Ansatz verfolgen müssen.

      Eine gängige Methode zum Testen der Sicherheit von Client-Anwendungen oder Netzwerkdiensten ist das Fuzzing, bei dem wiederholt ungültige oder fehlerhafte Daten an die Anwendung gesendet und deren Antwort analysiert wird. Dies ist nützlich zum Testen, wie widerstandsfähig und robust die Anwendung gegenüber unerwarteten Eingaben ist, zu denen beschädigte Daten oder tatsächliche Angriffe gehören können.

      Radamsa ist ein Open-Source-Fuzzing-Werkzeug, das Testfälle auf der Grundlage von benutzerdefinierten Eingabedaten generieren kann. Radamsa ist vollständig skriptfähig und hat bisher erfolgreich Schwachstellen in realen Anwendungen, wie z. B. Gzip, gefunden.

      In diesem Tutorial werden Sie Radamsa installieren und verwenden, um Fuzz-Tests von Befehlszeilen- und netzwerkbasierten Anwendungen mit Ihren eigenen Testfällen durchzuführen.

      Warnung: Radamsa ist ein Penetrationstesttool, mit dem Sie möglicherweise Schwachstellen oder Schwächen in bestimmten Systemen oder Anwendungen identifizieren können. Sie dürfen die mit Radamsa gefundenen Schwachstellen nicht für fahrlässiges Verhalten, Schädigung oder böswillige Ausnutzung verwenden. Schwachstellen sollten dem Betreuer der betroffenen Anwendung auf ethische Weise gemeldet und nicht ohne ausdrückliche Genehmigung öffentlich bekannt gegeben werden.

      Voraussetzungen

      Bevor Sie diesen Leitfaden beginnen, benötigen Sie Folgendes:

      • Einen Ubuntu-18.04-Server, der gemäß Ersteinrichtung des Servers mit Ubuntu 18.04 eingerichtet wurde, einschließlich eines sudo-Benutzers ohne Rootberechtigung und einer aktivierten Firewall, die weniger wichtige Ports blockiert.
      • Eine befehlszeilen- oder netzwerkbasierte Anwendung, die Sie testen möchten, z. B. Gzip, Tcpdump, Bind, Apache, jq oder eine andere Anwendung Ihrer Wahl. Als Beispiel für die Zwecke dieses Tutorials verwenden wir jq.

      Warnung: Radamsa kann dazu führen, dass Anwendungen oder Systeme instabil laufen oder abstürzen. Führen Sie Radamsa daher nur in einer Umgebung aus, in der Sie darauf vorbereitet sind, z. B. auf einem dedizierten Server. Bitte stellen Sie auch sicher, dass Sie die ausdrückliche schriftliche Genehmigung des Eigentümers eines Systems haben, bevor Sie Fuzz-Tests gegen dieses System durchführen.

      Sobald Sie diese zur Verfügung haben, melden Sie sich zunächst als Benutzer ohne Rootberechtigung auf Ihrem Server an.

      Schritt 1 – Installation von Radamsa

      Zuerst werden Sie Radamsa herunterladen und kompilieren, um es auf Ihrem System zu verwenden. Der Radamsa-Quellcode ist im offiziellen Repository von GitLab verfügbar.

      Beginnen Sie damit, den lokalen Paketindex zu aktualisieren, um alle neuen Änderungen im Upstream zu berücksichtigen:

      Installieren Sie dann die Pakete gcc, git, make und wget, die zum Kompilieren des Quellcodes in eine ausführbare Binärdatei benötigt werden:

      • sudo apt install gcc git make wget

      Nach der Bestätigung der Installation lädt apt die angegebenen Pakete und alle erforderlichen Abhängigkeiten herunter und installiert sie.

      Als Nächstes laden Sie eine Kopie des Quellcodes für Radamsa herunter, indem Sie ihn aus dem Repository, das auf GitLab gehostet wird, klonen:

      • git clone https://gitlab.com/akihe/radamsa.git

      Dadurch wird ein Verzeichnis namens radamsa erstellt, das den Quellcode für die Anwendung enthält. Wechseln Sie in das Verzeichnis, um mit der Kompilierung des Codes zu beginnen:

      Als Nächstes können Sie den Kompilierungsprozess mit make starten:

      Schließlich können Sie die kompilierte Radamsa-Binärdatei in Ihren $PATH installieren:

      Sobald dies abgeschlossen ist, können Sie die installierte Version überprüfen, um sicherzustellen, dass alles funktioniert:

      Ihre Ausgabe wird ähnlich wie die folgende aussehen:

      Output
      Radamsa 0.6

      Wenn Sie einen Fehler radamsa: command not found sehen, überprüfen Sie noch einmal, ob alle erforderlichen Abhängigkeiten installiert wurden und ob es beim Kompilieren keine Fehler gab.

      Nachdem Sie nun Radamsa installiert haben, können Sie damit beginnen, einige Beispieltestfälle zu generieren, um zu verstehen, wie Radamsa funktioniert und wofür es verwendet werden kann.

      Schritt 2 – Generieren von Fuzzing-Testfällen

      Nachdem Radamsa jetzt installiert wurde, können Sie damit einige Fuzzing-Testfälle generieren.

      Ein Testfall ist ein Datenteil, der als Eingabe für das zu testende Programm verwendet wird. Wenn Sie beispielsweise einen Fuzz-Test für ein Archivierungsprogramm wie Gzip durchführen, kann ein Testfall ein Dateiarchiv sein, das Sie zu dekomprimieren versuchen.

      Anmerkung: Radamsa manipuliert Eingabedaten auf eine Vielzahl unerwarteter Arten, einschließlich extremer Wiederholungen, Bit-Flips, Einfügen von Steuerzeichen und so weiter. Dies kann dazu führen, dass Ihre Terminal-Sitzung abbricht oder instabil wird. Seien Sie sich dessen bewusst, bevor Sie fortfahren.

      Geben Sie zunächst ein einfaches Textstück an Radamsa weiter, um zu sehen, was passiert:

      • echo "Hello, world!" | radamsa

      Dadurch werden die eingegebenen Daten manipuliert (oder gefuzzt) und ein Testfall ausgegeben, wie beispielsweise:

      Output
      Hello,, world!

      In diesem Fall hat Radamsa ein zusätzliches Komma zwischen Hello und world eingefügt. Dies mag nicht wie eine wesentliche Änderung erscheinen, aber in einigen Anwendungen kann dies dazu führen, dass die Daten falsch interpretiert werden.

      Versuchen wir es noch einmal, indem wir den gleichen Befehl ausführen. Sie werden eine andere Ausgabe sehen:

      Output
      Hello, '''''''wor'd!

      Dieses Mal wurden mehrere einfache Anführungszeichen (') in die Zeichenfolge eingefügt, darunter eines, das das l in world überschrieb. Dieser spezielle Testfall führt mit größerer Wahrscheinlichkeit zu Problemen für eine Anwendung, da einfache/doppelte Anführungszeichen oft verwendet werden, um verschiedene Datenteile in einer Liste zu trennen.

      Versuchen wir es noch einmal:

      Output
      Hello, $+$PATHu0000`xcalc`world!

      In diesem Fall fügte Radamsa eine Shell-Injektionszeichenfolge ein, die zum Testen auf Befehlsinjektions-Schwachstellen in der zu testenden Anwendung nützlich sein wird.

      Sie haben Radamsa dazu verwendet, eine Eingabezeichenfolge zu fuzzen und eine Reihe von Testfällen zu erstellen. Als Nächstes werden Sie Radamsa zum Fuzzen einer Befehlszeilenanwendung verwenden.

      Schritt 3 – Fuzzing einer Befehlszeilenanwendung

      In diesem Schritt werden Sie Radamsa verwenden, um eine Befehlszeilenanwendung zu fuzzen und über alle auftretenden Abstürze zu berichten.

      Die genaue Technik für das Fuzzing jedes Programms variiert erheblich und verschiedene Methoden werden für verschiedene Programme am effektivsten sein. In diesem Tutorial werden wir jedoch das Beispiel von jq verwenden, das ein Befehlszeilenprogramm zur Verarbeitung von JSON-Daten ist.

      Sie können jedes andere ähnliche Programm verwenden, solange es dem allgemeinen Prinzip folgt, eine Form von strukturierten oder unstrukturierten Daten zu nehmen, etwas damit zu tun und dann ein Ergebnis auszugeben. Dieses Beispiel würde zum Beispiel auch mit Gzip, Grep, bc, tr usw. funktionieren.

      Wenn Sie jq nicht bereits installiert haben, können Sie es mit apt installieren:

      jq wird nun installiert.

      Um mit dem Fuzzing zu beginnen, erstellen Sie eine JSON-Beispieldatei, die Sie als Eingabe für Radamsa verwenden:

      Fügen Sie dann die folgenden JSON-Beispieldaten in die Datei ein:

      test.json

      {
  "test": "test",
  "array": [
    "item1: foo",
    "item2: bar"
  ]
}

      Sie können diese Datei mit jq parsen, wenn Sie überprüfen wollen, ob die JSON-Syntax gültig ist:

      Wenn die JSON gültig ist, wird jq die Datei ausgeben. Andernfalls wird ein Fehler ausgegeben, mit dem Sie die Syntax bei Bedarf korrigieren können.

      Als nächstes fuzzen Sie die JSON-Testdatei mit Radamsa und übergeben diese dann an jq. Dadurch liest jq den gefuzzten/manipulierten Testfall und nicht die ursprünglich gültigen JSON-Daten:

      Wenn Radamsa die JSON-Datei auf eine Art und Weise fuzzt, dass sie syntaktisch noch gültig sind, gibt jq die Daten aus, jedoch mit den Änderungen, die Radamsa daran vorgenommen hat.

      Wenn Radamsa bewirkt, dass die JSON-Daten ungültig werden, zeigt jq alternativ einen entsprechenden Fehler an. Beispiel:

      Output
      parse error: Expected separator between values at line 5, column 16

      Das alternative Ergebnis wäre, dass jq nicht in der Lage ist, die gefuzzten Daten korrekt zu verarbeiten, was zu einem Absturz oder Fehlverhalten führt. Genau das ist es, was Sie beim Fuzzing wirklich suchen, da dies auf eine Sicherheitsschwachstelle wie einen Pufferüberlauf oder eine Befehlsinjektion hindeuten könnte.

      Um effizienter auf solche Schwachstellen zu testen, kann ein Bash-Skript verwendet werden, um den Fuzzing-Prozess zu automatisieren, einschließlich der Generierung von Testfällen, der Übergabe an das Zielprogramm und der Erfassung aller relevanten Ausgaben.

      Erstellen Sie eine Datei namens jq-fuzz.sh:

      Der genaue Inhalt des Skripts hängt von der Art des Programms, das Sie fuzzen, und den Eingabedaten ab, aber im Fall von jq und anderen ähnlichen Programmen reicht das folgende Skript aus.

      Kopieren Sie das Skript in Ihre jq-fuzz.sh-Datei:

      jq-fuzz.sh

      #!/bin/bash
while true; do
  radamsa test.json > input.txt
  jq . input.txt > /dev/null 2>&1
  if [ $? -gt 127 ]; then
    cp input.txt crash-`date +s%.%N`.txt
    echo "Crash found!"
  fi
done

      Dieses Skript enthält ein while, um den Inhalt in einer Schleife zu wiederholen. Bei jedem Durchlaufen der Skript-Schleife generiert Radamsa einen Testfall auf der Basis von test.json und speichert ihn in input.txt.

      Der input.txt-Testfall wird dann durch jq ausgeführt, wobei alle Standard- und Fehlerausgaben zu /dev/null umgeleitet werden, um zu vermeiden, dass der Terminal-Bildschirm überfüllt wird.

      Schließlich wird der Exit-Wert von jq überprüft. Wenn der Exit-Wert größer als 127 ist, was auf einen fatalen Abbruch (einen Absturz) hindeutet, werden die Eingabedaten zur späteren Überprüfung in einer Datei mit dem Namen crash- gespeichert – gefolgt vom aktuellen Datum in Unix-Sekunden und -Nanosekunden.

      Markieren Sie das Skript als ausführbar und führen Sie es aus, um mit dem automatischen Fuzz-Test jq zu beginnen:

      • chmod +x jq-fuzz.sh

      • ./jq-fuzz.sh

      Um das Skript zu beenden können Sie jederzeit STRG+C drücken. Sie können dann überprüfen, ob Abstürze gefunden wurden, indem Sie mit ls eine Verzeichnisliste mit den erzeugten Absturzdateien anzeigen.

      Vielleicht möchten Sie Ihre JSON-Eingabedaten verbessern, da die Verwendung einer komplexeren Eingabedatei wahrscheinlich die Qualität Ihrer Fuzzing-Ergebnisse verbessert. Vermeiden Sie die Verwendung einer großen Datei oder einer Datei, die viele sich wiederholende Daten enthält – eine ideale Eingabedatei ist eine Datei, die klein ist, aber dennoch so viele „komplexe“ Elemente wie möglich enthält. Eine gute Eingabedatei enthält beispielsweise Datenproben, die in allen Formaten gespeichert sind, einschließlich Zeichenfolgen, Ganzzahlen, Boolesche, Listen und Objekte, sowie, wenn möglich, verschachtelte Daten.

      Sie haben Radamsa zum Fuzzen einer Befehlszeilenanwendung verwendet. Als Nächstes werden Sie Radamsa zum Fuzzen von Anfragen an Netzwerkdienste verwenden.

      Schritt 4 – Fuzzing von Anfragen an Netzwerkdienste

      Radamsa kann auch zum Fuzzen von Netzwerkdiensten verwendet werden, wobei es entweder als Netzwerk-Client oder als Server fungiert. In diesem Schritt verwenden Sie Radamsa zum Fuzzen eines Netzwerkdienstes, wobei Radamsa als Client fungiert.

      Der Zweck des Fuzzings von Netzwerkdiensten besteht darin, zu testen, wie belastbar ein bestimmter Netzwerkdienst gegenüber Clients ist, die ihm fehlerhafte und/oder bösartige Daten senden. Viele Netzwerkdienste wie Web- oder DNS-Server sind in der Regel dem Internet ausgesetzt, was bedeutet, dass sie ein häufiges Ziel für Angreifer sind. Ein Netzwerkdienst, der nicht ausreichend widerstandsfähig gegen den Empfang fehlerhafter Daten ist, kann abstürzen oder – schlimmer noch – in einem offenen Zustand ausfallen, sodass Angreifer sensible Daten wie Verschlüsselungsschlüssel oder Benutzerdaten lesen können.

      Die spezifische Technik zum Fuzzing von Netzwerkdiensten variiert je nach dem betreffenden Netzwerkdienst enorm. In diesem Beispiel werden wir jedoch Radamsa zum Fuzzing eines einfachen Webservers verwenden, der statische HTML-Inhalte anbietet.

      Zuerst müssen Sie den Webserver für die Tests einrichten. Sie können dies mit dem integrierten Entwicklungsserver tun, der mit dem php-cli-Paket geliefert wird. Zum Testen Ihres Webservers benötigen Sie auch curl.

      Wenn Sie php-cli und/oder curl nicht installiert haben, können Sie sie mit apt installieren:

      • sudo apt install php-cli curl

      Als Nächstes erstellen Sie ein Verzeichnis, in dem Sie Ihre Webserver-Dateien speichern, und wechseln zu diesem:

      Erstellen Sie dann eine HTML-Datei, die einen Beispieltext enthält:

      Fügen Sie der Datei Folgendes hinzu:

      index.html

      <h1>Hello, world!</h1>

      Nun können Sie Ihren PHP-Webserver ausführen. Sie müssen in der Lage sein, das Webserver-Protokoll einzusehen, während Sie noch eine andere Terminal-Sitzung verwenden. Öffnen Sie dazu eine weitere Terminal-Sitzung und SSH zu Ihrem Server:

      • cd ~/www

      • php -S localhost:8080

      Sie erhalten eine Ausgabe, die der folgenden ähnelt:

      Output
      PHP 7.2.24-0ubuntu0.18.04.1 Development Server started at Wed Jan  1 16:06:41 2020
Listening on http://localhost:8080
Document root is /home/user/www
Press Ctrl-C to quit.

      Sie können jetzt wieder zu Ihrer ursprünglichen Terminalsitzung zurückwechseln und mit curl testen, ob der Webserver funktioniert:

      Dies wird die Beispieldatei index.html ausgeben, die Sie zuvor erstellt haben:

      Output
      <h1>Hello, world!</h1>

      Ihr Webserver muss nur lokal erreichbar sein, Sie sollten also keine Ports auf Ihrer Firewall dafür öffnen.

      Nachdem Sie Ihren Testwebserver eingerichtet haben, können Sie nun damit beginnen, einen Fuzz-Test mit Radamsa durchzuführen.

      Zuerst müssen Sie eine HTTP-Beispielanfrage erstellen, die als Eingabedaten für Radamsa verwendet werden soll. Erstellen Sie eine neue Datei, in der diese gespeichert wird:

      Kopieren Sie dann die folgende HTTP-Beispielanfrage in die Datei:

      http-request.txt

      GET / HTTP/1.1
Host: localhost:8080
User-Agent: test
Accept: */*

      Als Nächstes können Sie Radamsa verwenden, um diese HTTP-Anfrage an Ihren lokalen Webserver zu senden. Dazu müssen Sie Radamsa als TCP-Client verwenden, was durch die Angabe einer IP-Adresse und eines Ports für die Verbindung möglich ist:

      • radamsa -o 127.0.0.1:8080 http-request.txt

      Anmerkung: Beachten Sie, dass die Verwendung von Radamsa als TCP-Client möglicherweise die Übertragung von fehlerhaften/bösartigen Daten über das Netzwerk verursacht. Dies kann zu Problemen führen. Achten Sie daher sehr darauf, nur auf Netzwerke zuzugreifen, die Sie testen dürfen, oder halten Sie sich vorzugsweise an die Adresse localhost (127.0.0.1).

      Wenn Sie sich die ausgegebenen Protokolle für Ihren lokalen Webserver ansehen, werden Sie feststellen, dass er die Anfragen erhalten, sie aber höchstwahrscheinlich nicht verarbeitet hat, da sie ungültig/fehlerhaft waren.

      Die ausgegebenen Protokolle werden in Ihrem zweiten Terminalfenster sichtbar sein:

      Output
      [Wed Jan  1 16:26:49 2020] 127.0.0.1:49334 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:04 2020] 127.0.0.1:49336 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:05 2020] 127.0.0.1:49338 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:07 2020] 127.0.0.1:49340 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:08 2020] 127.0.0.1:49342 Invalid request (Malformed HTTP request)

      Für optimale Ergebnisse und um sicherzustellen, dass Abstürze aufgezeichnet werden, sollten Sie ein Automatisierungsskript ähnlich dem in Schritt 3 verwendeten schreiben. Sie sollten außerdem in Betracht ziehen, eine komplexere Eingabedatei zu verwenden, die möglicherweise Zusätze wie zusätzliche HTTP-Header enthält.

      Sie haben einen Netzwerkdienst mit Radamsa als TCP-Client gefuzzt. Als Nächstes werden Sie einen Netzwerk-Client mit Radamsa als Server fuzzen.

      Schritt 5 – Fuzzing von Netzwerk-Client-Anwendungen

      In diesem Schritt werden Sie Radamsa zum Fuzz-Test einer Netzwerk-Client-Anwendung verwenden. Dies wird erreicht, indem die Antworten eines Netzwerkdienstes abgefangen und gefuzzt werden, bevor sie vom Client empfangen werden.

      Der Zweck dieser Art des Fuzzings besteht darin, zu testen, wie belastbar Netzwerk-Client-Anwendungen gegenüber dem Empfang von fehlerhaften oder bösartigen Daten von Netzwerkdiensten sind. Zum Beispiel das Testen eines Webbrowsers (Client), der fehlerhaftes HTML von einem Webserver (Netzwerkdienst) empfängt, oder das Testen eines DNS-Clients, der fehlerhafte DNS-Antworten von einem DNS-Server empfängt.

      Wie beim Fuzzing von Befehlszeilenanwendungen oder Netzwerkdiensten variiert die genaue Technik für das Fuzzing jeder Netzwerk-Client-Anwendung erheblich. In diesem Beispiel wird jedoch whois verwendet, eine einfache TCP-basierte Sende-/Empfangsanwendung.

      Die whois-Anwendung wird verwendet, um Anfragen an WHOIS-Server zu stellen und WHOIS-Datensätze als Antworten zu erhalten. WHOIS arbeitet im Klartext über den TCP-Port 43 und ist somit ein guter Kandidat für netzwerkbasierte Fuzz-Tests.

      Wenn Sie noch nicht über whois verfügen, können Sie es mit apt installieren:

      Zunächst müssen Sie eine Probe der whois-Antwort erwerben, die Sie als Eingabedaten verwenden können. Sie können dies tun, indem Sie eine whois-Abfrage stellen und die Ausgabe in einer Datei speichern. Sie können hier jede beliebige Domäne verwenden, da Sie das whois-Programm lokal mit Beispieldaten testen:

      • whois example.com > whois.txt

      Als Nächstes müssen Sie Radamsa als Server einrichten, der gefuzzte Versionen dieser whois-Antwort liefert. Sie müssen in der Lage sein, Ihr Terminal weiter zu benutzen, sobald Radamsa im Servermodus läuft. Es wird daher empfohlen, eine weitere Terminalsitzung und eine SSH-Verbindung zu Ihrem Server zu öffnen:

      • radamsa -o :4343 whois.txt -n inf

      Radamsa läuft nun im TCP-Server-Modus und stellt bei jedem Verbindungsaufbau zum Server eine gefuzzte Version von whois.txt zur Verfügung, unabhängig davon, welche Anfragedaten empfangen werden.

      Sie können nun mit dem Testen der whois-Client-Anwendung fortfahren. Sie müssen eine normale whois-Abfrage für eine beliebige Domäne Ihrer Wahl stellen (es muss nicht dieselbe sein, für die die Beispieldaten bestimmt sind), aber mit whois, das auf Ihren lokalen Radamsa-Server verweist:

      • whois -h localhost:4343 example.com

      Die Antwort wird aus Ihren Beispieldaten bestehen, die jedoch von Radamsa gefuzzt wurden. Solange Radamsa ausgeführt wird, können Sie weiterhin Anfragen an den lokalen Server stellen, und es wird jedes Mal eine andere gefuzzte Antwort ausgegeben.

      Wie beim Fuzzing von Netzwerkdiensten können Sie, um die Effizienz dieses Netzwerk-Client-Fuzz-Tests zu verbessern und sicherzustellen, dass alle Abstürze erfasst werden, ein Automatisierungsskript schreiben, das dem in Schritt 3 verwendeten ähnelt.

      In diesem letzten Schritt haben Sie Radamsa zur Durchführung von Fuzz-Tests einer Netzwerk-Client-Anwendung verwendet.

      Zusammenfassung

      In diesem Artikel richteten Sie Radamsa ein und verwendeten es zum Fuzzen einer Befehlszeilenanwendung, eines Netzwerkdienstes und eines Netzwerk-Clients. Sie verfügen nun über die grundlegenden Kenntnisse, die für das Fuzz-Testen Ihrer eigenen Anwendungen erforderlich sind, hoffentlich mit dem Ergebnis, ihre Robustheit und Widerstandsfähigkeit gegen Angriffe zu verbessern.

      Wenn Sie Radamsa weiter erkunden möchten, sollten Sie sich die Radamsa README-Datei im Detail ansehen, da sie weitere technische Informationen und Beispiele für die Verwendung des Tools enthält:

      Vielleicht möchten Sie sich auch einige andere Fuzzing-Tools ansehen, wie z. B. American Fuzzy Lop (AFL), ein fortschrittliches Fuzzing-Tool, das für das Testen von binären Anwendungen mit extrem hoher Geschwindigkeit und Genauigkeit entwickelt wurde:



      Source link

      Cómo instalar y usar Radamsa para probar programas y servicios de red con fuzzing en Ubuntu 18.04


      El autor seleccionó la Electronic Frontier Foundation Inc para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Las amenazas de seguridad son cada vez más complejas, por lo que los desarrolladores y los administradores de sistemas deben adoptar un enfoque proactivo para defender y probar la seguridad de sus aplicaciones.

      Un método frecuente para probar la seguridad de aplicaciones o servicios de red de clientes es el fuzzing, que implica enviar datos no válidos o con formato incorrecto a la aplicación en cuestión y analizar su respuesta. Es útil para ayudar a probar cuán resistente y sólida es una aplicación ante entradas inesperadas, como datos corruptos o ataques reales.

      Radamsa es una herramienta de fuzzing de código abierto que puede generar casos de prueba basados en datos de entrada especificados por el usuario. Se puede programar mediante scripts por completo y se utiliza para detectar vulnerabilidades en aplicaciones reales, como Gzip, de forma exitosa.

      A través de este tutorial, instalará y utilizará Radamsa para probar aplicaciones de línea de comandos y de red con fuzzing usando sus propios casos de prueba.

      Advertencia: Radamsa es una herramienta de pruebas de penetración que le permite identificar vulnerabilidades o deficiencias en sistemas o aplicaciones determinados. No debe usar las vulnerabilidades que detecte Radamsa para ninguna forma de comportamiento imprudente, daño o explotación malintencionada. Las vulnerabilidades se deben informar de manera ética a la persona encargada del mantenimiento de la aplicación afectada y no se deben divulgar públicamente sin permiso explícito.

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      Advertencia: Radamsa puede hacer que aplicaciones o sistemas se ejecuten de forma inestable o se bloqueen, por lo que debe ejecutarlo únicamente en un entorno en el que esté preparado para esto, como un servidor dedicado. Asegúrese también de contar con el permiso explícito por escrito del propietario del sistema que probará con fuzzing antes proceder.

      Una vez que tenga todo esto listo, inicie sesión en su servidor como usuario no root.

      Paso 1: Instalar Radamsa

      Primero, descargará y compilará Radamsa para comenzar a utilizarlo en su sistema. El código fuente de Radamsa está disponible en el repositorio oficial de GitLab.

      Comience actualizando el índice de paquetes locales de modo que se refleje cualquier cambio anterior:

      Luego, instalará los paquetes gcc, git, make y wget necesarios para compilar el código fuente en un binario ejecutable:

      • sudo apt install gcc git make wget

      Después de confirmar la instalación, apt descargará e instalará los paquetes específicos y todas sus dependencias necesarias.

      A continuación, descargará una copia del código fuente de Radamsa clonándolo del repositorio alojado en GitLab:

      • git clone https://gitlab.com/akihe/radamsa.git

      Al hacerlo, se creará un directorio llamado radamsa que contendrá el código fuente de la aplicación. Diríjase al directorio para comenzar a compilar el código:

      Luego, puede iniciar el proceso de compilación usando make:

      Por último, puede instalar el binario de Radamsa compilado en su $PATH:

      Una vez completado esto, puede verificar la versión instalada para asegurar que todo funcione:

      El resultado debe tener un aspecto similar al siguiente:

      Output
      Radamsa 0.6

      Si ve el error radamsa: command not found, verifique que todas las dependencias necesarias se hayan instalado y que no se haya habido errores durante la compilación.

      Ahora que instaló Radamsa, puede comenzar a generar algunos casos de prueba de muestra para comprender el funcionamiento de Radamsa y sus aplicaciones.

      Paso 2: Generar casos de prueba con fuzzing

      Ahora que instaló Radamsa, puede usarlo para generar casos de pruebas con fuzzing.

      Un caso de prueba es información que se utilizará como entrada para el programa que someta a prueba. Por ejemplo, si prueba con fuzzing un programa de archivo, como Gzip, un caso de prueba puede ser un archivo de almacenamiento que intente descomprimir.

      Nota: Radamsa manipula los datos de entrada de una gran variedad de formas inesperadas, como la repetición extrema, la inversión de bits y la inserción de caracteres de control, entre otras. Antes de proceder, tenga en cuenta que esto puede hacer que su sesión de terminal se interrumpa o se vuelva inestable.

      Primero, pase un texto sencillo a Radamsa para ver lo que sucede:

      • echo "Hello, world!" | radamsa

      Con esto, se manipularán (o expondrán a fuzzing) los datos ingresados y se generará un caso de prueba, como el siguiente:

      Output
      Hello,, world!

      En este caso, Radamsa agregó una coma adicional entre Hello y world. A pesar de que no parezca un cambio significativo, en algunas aplicaciones, esto puede hacer que los datos se interpreten de forma incorrecta.

      Hagamos un nuevo intento ejecutando el mismo comando. Obtendrá un resultado distinto:

      Output
      Hello, '''''''wor'd!

      Esta vez, se insertaron varias comillas simples (') en la cadena, entre ellas, una que sobrescribió la l en world. Las posibilidades de que este caso de prueba en particular genere problemas en aplicaciones son más altas, dado que se suelen utilizar comillas simples y dobles para separar diferentes porciones de datos de una lista.

      Probemos una vez más:

      Output
      Hello, $+$PATHu0000`xcalc`world!

      En este caso, Radamsa insertó una cadena de inserción de shell, que será útil para realizar pruebas en busca de vulnerabilidades de inserción de comandos en la aplicación que pruebe.

      Usó Radamsa para someter a fuzzing una cadena de entrada y producir una serie de casos de prueba. A continuación, utilizará Radamsa para someter a fuzzing una aplicación de línea de comandos.

      Paso 3: Someter a fuzzing una aplicación de línea de comandos

      En este paso, utilizará Radamsa para aplicar fuzzing a una aplicación de línea de comandos e informar los bloqueos que se produzcan.

      La técnica exacta para hacer pruebas con fuzzing varía en gran medida de un programa a otro, así como la eficacia de cada método. Sin embargo, en este tutorial usaremos jq como ejemplo, que es un programa de línea de comandos para procesar datos de JSON.

      Puede usar cualquier otro programa similar siempre y cuando aplique el principio general de tomar algún tipo de datos estructurados o no estructurados, hacer algo con ellos y luego producir un resultado. Por ejemplo, este caso también funcionaría con Gzip, Grep, bc y tr, entre otros.

      Si aún no instaló jq, puede hacerlo usando apt:

      De esta manera, jq quedará instalado.

      Para comenzar la prueba con fuzzing, cree un archivo JSON de ejemplo que utilizará como entrada para Radamsa:

      Luego, añada los siguientes datos de JSON de ejemplo al archivo:

      test.json

      {
  "test": "test",
  "array": [
    "item1: foo",
    "item2: bar"
  ]
}

      Puede analizar este archivo usando jq si desea verificar que la sintaxis de JSON sea válida:

      Si el JSON es válido, jq mostrará el archivo. De lo contrario, mostrará un error que puede usar para corregir la sintaxis cuando sea necesario.

      A continuación, aplique fuzzing al archivo JSON de prueba usando Radamsa y, luego, páselo a jq. Esto hará que jq lea el caso de prueba sometido a fuzzing o manipulado en lugar de los datos JSON originales válidos.

      Si Radamsa muestra los datos de JSON de una forma que siga siendo válida desde el punto de vista sintáctico, jq mostrará los datos, pero con los cambios que le haya realizado Radamsa.

      Alternativamente, si Radamsa hace que los datos de JSON no sean válidos, jq mostrará un error que corresponda. Por ejemplo:

      Output
      parse error: Expected separator between values at line 5, column 16

      El resultado alternativo sería que jq no pudiera manejar los datos sometidos a fuzzing de forma correcta, lo cual haría que se bloqueara o no funcionara de forma adecuada. Esto es lo que realmente se busca con el método de fuzzing, ya que podría indicar una vulnerabilidad de seguridad, como un desbordamiento de búfer o una inserción de comandos.

      Para realizar pruebas de detección de vulnerabilidades como estas de forma más eficiente, se puede usar una secuencia de comandos de Bash a fin de automatizar el proceso de fuzzing, incluidos los procesos de generar casos de prueba, pasarlos al programa de destino y detectar cualquier resultado pertinente.

      Cree un archivo llamado jq-fuzz.sh:

      El contenido exacto de la secuencia de comandos variará según el tipo de programa que someta a fuzzing y los datos de entrada. Sin embargo, en el caso de jq y otros programas similares, la secuencia de comandos siguiente será suficiente.

      Copie la secuencia de comandos a su archivo jq-fuzz.sh:

      jq-fuzz.sh

      #!/bin/bash
while true; do
  radamsa test.json > input.txt
  jq . input.txt > /dev/null 2>&1
  if [ $? -gt 127 ]; then
    cp input.txt crash-`date +s%.%N`.txt
    echo "Crash found!"
  fi
done

      Esta secuencia de comandos contiene while para hacer que el contenido se repita reiteradamente. Cada vez que se repita la secuencia de comandos, Radamsa generará un caso de prueba basado en test.json y lo guardará en input.txt.

      Luego, el caso de prueba input.txt se ejecutará en jq y todo el resultado estándar y de error se reenviará a /dev/null para evitar saturar la pantalla del terminal.

      Por último, se verifica el valor de salida de jq. Si el valor de salida es superior a 127, esto indica una interrupción irrecuperable (un bloqueo), por lo que los datos de entrada se guardan para su análisis posterior en un archivo llamado crash- seguido de la fecha actual en segundos y nanosegundos de Unix.

      Marque la secuencia de comandos como ejecutable y ejecútela para comenzar a probar jq con fuzzing de forma automática:

      • chmod +x jq-fuzz.sh

      • ./jq-fuzz.sh

      Puede pulsar CTRL+C en cualquier momento para finalizar la secuencia de comandos. Luego, puede verificar si se encontraron errores utilizando ls para mostrar una lista de directorios en la que se encuentran los archivos de bloqueos que se hayan creado.

      Se recomienda mejorar los datos de JSON de entrada, dado que probablemente el uso de un archivo de entrada más complejo mejore la calidad de los resultados de la aplicación de fuzzing. Evite usar un archivo grande o uno que contenga muchos datos repetidos; lo ideal es usar un archivo de entrada que sea pequeño y, no obstante, tenga la mayor cantidad de elementos “complejos” posible. Por ejemplo, un buen archivo de entrada debe contener muestras de datos almacenados en todos los formatos, incluso cadenas, enteros, booleanos, listas, objetos y datos anidados si es posible.

      Utilizó Radamsa para probar una aplicación de línea de comandos con fuzzing. A continuación, utilizará Radamsa para probar solicitudes a servicios de red.

      Paso 4: Probar solicitudes a servicios de red con fuzzing

      Radamsa también se puede utilizar para probar servicios de red, ya sea como cliente o servidor de red. En este paso, utilizará Radamsa para probar un servicio de red con fuzzing y Radamsa funcionará como cliente.

      El propósito de probar servicios de red con fuzzing es determinar cuán resistente es un servicio de red en particular ante el envío de datos maliciosos o con formato incorrecto. Muchos servicios de red, como los servidores web o DNS, suelen estar expuestos a Internet, lo cual los convierte en un objetivo común para los atacantes. Un servicio de red que no sea suficientemente resistente a la recepción de datos con formato incorrecto puede bloquearse o, lo que sería peor aún, fallar en estado abierto. Esto podría permitir a los atacantes leer datos confidenciales, como claves de cifrado o datos de usuarios.

      Si bien la técnica específica para probar servicios de red con fuzzing varía en gran medida según el servicio de red, en este ejemplo usaremos Radamsa para probar un servidor web básico que proporciona contenido HTML estático.

      Primero, debe configurar el servidor web para su uso en pruebas. Puede hacerlo usando el servidor de desarrollo incorporado que viene con el paquete php-cli. También necesitará curl para probar su servidor web.

      Si no tiene php-cli ni curl instalados, puede instalarlos usando apt:

      • sudo apt install php-cli curl

      A continuación, cree un directorio para almacenar los archivos de su servidor web y posiciónese en él:

      Luego, cree un archivo HTML que contenga texto de ejemplo:

      Añada lo siguiente al archivo:

      index.html

      <h1>Hello, world!</h1>

      Ahora, podrá ejecutar su servidor web de PHP. Tendrá que poder ver el registro del servidor web mientras siga utilizando otra sesión de terminal. Por ello, abra otra sesión y aplique SSH al servidor para lo siguiente:

      • cd ~/www

      • php -S localhost:8080

      Con esto, se mostrará algo similar a lo siguiente:

      Output
      PHP 7.2.24-0ubuntu0.18.04.1 Development Server started at Wed Jan  1 16:06:41 2020
Listening on http://localhost:8080
Document root is /home/user/www
Press Ctrl-C to quit.

      Ahora, podrá regresar a su sesión de terminal original y verificar que el servidor web esté funcionando mediante curl:

      Con esto, se mostrará el archivo de ejemplo index.html que creó anteriormente:

      Output
      <h1>Hello, world!</h1>

      Solo se debe poder acceder a su servidor web de forma local, por lo que no debe abrir ningún puerto en su firewall para él.

      Ahora que configuró su servidor web de prueba, podrá comenzar a realizar pruebas con fuzzing utilizando Radamsa.

      Primero, deberá crear una solicitud HTTP de ejemplo a fin de usarla como información de entrada para Radamsa. Cree un archivo nuevo para almacenar esto en la siguiente ubicación:

      Luego, copie la siguiente solicitud HTTP de ejemplo al archivo:

      http-request.txt

      GET / HTTP/1.1
Host: localhost:8080
User-Agent: test
Accept: */*

      A continuación, puede usar Radamsa para enviar esta solicitud HTTP a su servidor web local. Para hacerlo, deberá usar Radamsa como cliente TCP, lo que se puede hacer especificando una dirección IP y un puerto para establecer conexión:

      • radamsa -o 127.0.0.1:8080 http-request.txt

      Nota: Tenga en cuenta que usar Radamsa como cliente TCP, puede hacer que se transmitan datos maliciosos o con formato incorrecto a través de la red. Esto puede provocar errores; por ello, debe asegurarse de acceder únicamente a las redes que tenga permitido probar o, preferentemente, aténgase a utilizar la dirección de host local (127.0.0.1).

      Por último, si ve los registros de salida de su servidor web local observará que recibió las solicitudes, pero probablemente no las haya procesado porque no eran válidas o tenían un formato incorrecto.

      Los registros de salida se mostrarán en su segunda ventana de terminal:

      Output
      [Wed Jan  1 16:26:49 2020] 127.0.0.1:49334 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:04 2020] 127.0.0.1:49336 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:05 2020] 127.0.0.1:49338 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:07 2020] 127.0.0.1:49340 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:08 2020] 127.0.0.1:49342 Invalid request (Malformed HTTP request)

      Para obtener resultados óptimos y asegurarse de que los bloqueos se registren, es conveniente escribir una secuencia de comandos de automatización similar a la que se utilizó en el paso 3. También debe considerar la posibilidad de usar un archivo de entrada más complejo, que puede contener elementos añadidos, como encabezados HTTP adicionales.

      De esta manera, probó un servicio de red con fuzzing usando Radamsa como cliente TCP. A continuación, probará a un cliente de red utilizando Radamsa como servidor.

      Paso 5: Probar aplicaciones clientes de red con fuzzing

      En este paso, utilizará Radamsa para probar una aplicación cliente de red con fuzzing. Esto se logra interceptando respuestas de un servicio de red y sometiéndolas a fuzzing antes de que las reciba el cliente.

      El propósito de este tipo de fuzzing es probar la resistencia de las aplicaciones clientes de red a la recepción de datos maliciosos o de formato incorrecto de servicios de red. Por ejemplo, probará un navegador web (cliente) que recibirá HTML con formato incorrecto de un servidor web (servicio de red) o un cliente DNS que recibirá respuestas DNS con formato incorrecto de un servidor DNS.

      Al igual que en el caso de aplicaciones de línea de comandos o servicios de red, la técnica exacta para probar con fuzzing cada aplicación cliente de red varía considerablemente. Sin embargo, en este ejemplo utilizará whois, una aplicación de envío y recepción simple basada en TCP.

      La aplicación whois se utiliza para enviar solicitudes a servidores WHOIS y recibir registros WHOIS como respuesta. WHOIS funciona a través del puerto TCP 43 con texto no cifrado, por lo que es ideal para realizar pruebas con fuzzing en redes.

      Si aún no cuenta con whois, puede instalarlo usando apt:

      Primero, deberá adquirir una respuesta whois de muestra para usarla como dato de entrada. Puede hacerlo enviando una solicitud whois y guardando el resultado en un archivo. Puede usar cualquier dominio que desee, dado que probará el programa whois de forma local con datos de muestra:

      • whois example.com > whois.txt

      A continuación, deberá configurar Radamsa como un servidor que proporcione versiones distorsionadas de esta respuesta whois. Deberá poder continuar usando su terminal una vez que Radamsa esté en ejecución en el modo de servidor, por lo que se recomienda abrir otra sesión de terminal y conexión SSH con su servidor para lo siguiente:

      • radamsa -o :4343 whois.txt -n inf

      Con esto, Radamsa se ejecutará en el modo de servidor TCP y enviará una versión de whois.txt sometida a fuzzing cada vez que se establezca una conexión con el servidor, independientemente de los datos de solicitud que se reciban.

      Ahora, puede proceder con la prueba de la aplicación cliente whois. Deberá realizar una solicitud whois normal para cualquier dominio que prefiera (no es necesario que sea el mismo al que se aplican los datos de muestra), pero con whois apuntando a su servidor de Radamsa local:

      • whois -h localhost:4343 example.com

      Recibirá como respuesta sus datos de muestra, aunque distorsionados por Radamsa. Puede continuar realizando solicitudes al servidor local mientras Radamsa esté en ejecución. Este enviará una respuesta diferente en cada ocasión.

      Al igual que con los servicios de red, para mejorar la eficacia de estas pruebas del cliente de red con fuzzing y asegurarse de que se registren los bloqueos, es conveniente escribir una secuencia de comandos de automatización similar a la que se utilizó en el paso 3.

      En este paso final, utilizó Radamsa para probar una aplicación cliente de red con fuzzing.

      Conclusión

      A través de este artículo, configuró Radamsa y lo utilizó para probar una aplicación de línea de comandos, un servicio de red y un cliente de red. Ahora tiene los conocimientos básicos necesarios para probar sus propias aplicaciones con fuzzing y mejorar su solidez y resistencia contra ataques.

      Si desea explorar Radamsa en mayor profundidad, puede revisar el archivo README de Radamsa de forma detallada; contiene más información técnica y ejemplos relacionados con los usos posibles de la herramienta:

      También puede probar otras herramientas de fuzzing como American Fuzzy Lop (AFL), una herramienta de fuzzing avanzada diseñada para probar aplicaciones binarias con una velocidad y una precisión sumamente altas:



      Source link

      Como instalar e utilizar a ferramenta Radamsa para fazer teste de fuzzing em programas e serviços de rede no Ubuntu 18.04


      O autor selecionou a Electronic Frontier Foundation, Inc para receber uma doação como parte do programa Write for DOnations.

      Introdução

      As ameaças de segurança estão se tornando cada vez mais sofisticadas, de modo que os desenvolvedores e administradores de sistemas precisam adotar uma abordagem proativa na defesa e teste da segurança de seus aplicativos.

      Um método comum para testar a segurança dos aplicativos cliente ou serviços de rede é o fuzzing, que envolve a transmissão de dados inválidos ou malformados repetidamente para o aplicativo e analisando sua resposta. Isso é útil para ajudar a testar a resiliência e a robustez do aplicativo a entradas inesperadas, que podem incluir dados corrompidos ou ataques reais.

      A Radamsa é uma ferramenta de fuzzing de código aberto que pode gerar casos de teste baseados em dados de entrada específicos do usuário. A Radamsa é totalmente passível de script e, até agora, tem sido bem-sucedida em encontrar vulnerabilidades em aplicativos reais, como o Gzip.

      Neste tutorial, você instalará e usará a Radamsa para fazer o teste de fuzzing da linha de comando e dos aplicativos baseados em rede, usando seus próprios casos de teste.

      Aviso: a Radamsa é uma ferramenta de teste de penetração que pode permitir que você identifique as vulnerabilidades ou pontos fracos em certos sistemas ou aplicativos. Você não deve usar as vulnerabilidades encontradas com a Radamsa para qualquer forma de comportamento inconsequente, exploração prejudicial ou mal-intencionada. As vulnerabilidades devem ser relatadas para o mantenedor do aplicativo afetado, de maneira ética e não ser divulgadas publicamente, sem permissão expressa.

      Pré-requisitos

      Antes de iniciar este guia, será necessário o seguinte:

      • Um servidor Ubuntu 18.04 configurado de acordo com o tutorial de Configuração Inicial do servidor com o Ubuntu 18.04, incluindo um usuário não raiz com privilégios sudo e firewall habilitado para bloquear portas não essenciais.
      • Um aplicativo de linha de comando ou baseado em rede que deseja testar, como o Gzip, Tcpdumb, Bind, Apache, jq ou qualquer outro aplicativo de sua escolha. A título de exemplo para este tutorial,usaremos o jq.

      Aviso: a Radamsa pode provocar a instabilidade ou a falha dos aplicativos ou sistemas em execução. Assim, somente execute a Radamsa em um ambiente em que você esteja preparado para essa situação, como num servidor dedicado, por exemplo. Além disso, assegure-se de que possui a devida permissão escrita do proprietário de um sistema, antes de realizar o teste de fuzzing em tal sistema.

      Assim que tiver tudo pronto, logue no seu servidor como usuário não raiz para começar.

      Passo 1 — Instalando a Radamsa

      Primeiro, você irá baixar e compilar a Radamsa para começar a usá-la no seu sistema. O código fonte da Radamsa está disponível no repositório oficial no GitLab.

      Comece atualizando o índice de pacotes local para refletir quaisquer novas alterações dos autores do código:

      Em seguida, instale os pacotes gcc, git, make e wget. Eles são necessários para compilar o código fonte em um binário executável:

      • sudo apt install gcc git make wget

      Após confirmar a instalação, a ferramenta apt irá baixar e instalar os pacotes especificados e todas as dependências necessárias.

      Em seguida, você irá baixar uma cópia do código fonte da Radamsa, clonando-o a partir do repositório hospedado no GitLab:

      • git clone https://gitlab.com/akihe/radamsa.git

      Isso criará um diretório chamado radamsa, que contém o código fonte do aplicativo. Vá para o diretório para começar a compilar o código:

      Em seguida, inicie o processo de compilação usando o make:

      Por fim, instale o binário da Radamsa compilado para o seu $PATH:

      Assim que terminar, verifique a versão instalada para garantir que tudo está funcionando:

      Sua saída será semelhante à seguinte:

      Output
      Radamsa 0.6

      Caso veja um erro radamsa: command not found (comando não encontrado), verifique novamente se todas as dependências necessárias foram instaladas e se não houve erros durante a compilação.

      Agora que instalou a Radamsa, comece a gerar alguns exemplos de casos para teste, a fim de entender como a Radamsa funciona e para o que ela pode ser usada.

      Passo 2 — Gerando casos para o teste de fuzzing

      Agora que a Radamsa foi instalada, utilize-a para gerar alguns casos para o teste de fuzzing.

      Um caso de teste é uma fração de dados que será usada como entrada para o programa que você estiver testando. Por exemplo, se estiver fazendo o teste de fuzzing em um programa de arquivamento como o Gzip. Como caso para teste, você pode usar um arquivo morto que estiver tentando descompactar.

      Nota: a Radamsa manipulará os dados de entrada de diversas formas inesperadas, inclusive através de repetição extrema, bit flips [manipulação de bits], controle de injeção de caractere e assim por diante. Isso pode provocar a interrupção ou a instabilidade de sua sessão no terminal; portanto, esteja ciente disso, antes de continuar.

      Primeiro, envie uma mensagem de texto simples para a Radamsa para ver o que acontece:

      • echo "Hello, world!" | radamsa

      Isso manipulará (ou confundirá) os dados inseridos e dará como resultado um caso de teste, por exemplo:

      Output
      Hello,, world!

      Neste caso, a Radamsa adicionou uma vírgula extra entre o Hello e o world. Pode não parecer uma alteração significativa, mas, em alguns aplicativos, pode levar à interpretação incorreta dos dados.

      Vamos tentar novamente, executando o mesmo comando. Você verá um outro resultado:

      Output
      Hello, '''''''wor'd!

      Dessa vez, várias aspas (') foram inseridas na string, incluindo uma que sobrescreveu-e à letra l da palavra world. Esse caso de teste em particular traz maior probabilidade de gerar problemas para um aplicativo, uma vez que as aspas simples/duplas são usadas com frequência para separar diferentes frações de dados em uma lista.

      Vamos testar mais uma vez:

      Output
      Hello, $+$PATHu0000`xcalc`world!

      Nesse caso, a Radamsa inseriu uma string de injeção do shell, o que será útil para testar as vulnerabilidades da injeção de comandos no aplicativo que você está testando.

      Você usou a Radamsa para fazer fuzz com uma string de entrada e produzir uma série de casos de teste. Em seguida, você usará a Radamsa para fazer o fuzz em um aplicativo de linha de comando.

      Passo 3 — Fazendo o fuzzing em um aplicativo de linha de comando

      Neste passo, você utilizará o Radamsa para fazer o fuzz em um aplicativo de linha de comando e informará sobre quaisquer falhas que ocorrerem.

      A técnica exata para o fuzzing em cada programa varia significativamente e métodos distintos serão mais eficazes para programas distintos. No entanto, neste tutorial utilizaremos o exemplo do jq, que é um programa de linha de comando para o processamento de dados JSON.

      Você pode usar qualquer outro programa similar, desde que ele siga o princípio geral de tomar alguma forma de dados estruturados ou não estruturados, fazendo algo com eles e em seguida, exibindo um resultado. Por exemplo, esse exemplo também funcionaria com o Gzip, Grep, bc, tr e assim por diante.

      Se ainda não tiver o jq instalado, instale-o usando a apt:

      O jq será instalado agora.

      Para começar o fuzzing, crie um arquivo de exemplo que você usará como a entrada para a Radamsa:

      Então, adicione os seguintes dados de exemplo em JSON ao arquivo:

      test.json

      {
  "test": "test",
  "array": [
    "item1: foo",
    "item2: bar"
  ]
}

      Você pode analisar esse arquivo usando o jq caso queria verificar se a sintaxe JSON é válida:

      Se o JSON for válido, o jq exibirá o arquivo. Caso contrário, ele exibirá um erro, que você pode usar para corrigir a sintaxe, onde for necessário.

      Em seguida, faça o fuzz no arquivo de teste em JSON usando a Radamsa e, em seguida, envie-o para o jq. Isso fará com que o jq leia o caso de teste de fuzzing/para manipulação, em vez de dados originais JSON válidos:

      Se a Radamsa fizer o fuzzing dos dados JSON, de modo que ainda fiquem válidos – do ponto de vista sintático, o jq exibirá os dados, mas com as alterações que a Radamsa tiver feito neles.

      Como alternativa, se a Radamsa fizer com que os dados JSON se tornem inválidos, o jq exibirá um erro relevante. Por exemplo:

      Output
      parse error: Expected separator between values at line 5, column 16

      O resultado alternativo seria que o jq não conseguiria lidar corretamente com os dados que passaram por fuzzing, fazendo com que ele falhe ou que se comporte indevidamente. É precisamente isso o que você estará buscando alcançar com o fuzzing, uma vez que isso pode ser indicação de uma vulnerabilidade de segurança, tais como um estouro de buffer ou uma injeção de comando.

      Para testar as vulnerabilidades de maneira mais eficaz dessa maneira, um script Bash pode ser usado para automatizar o processo de fuzzing, incluindo a geração de casos de teste, passando-os para o programa alvo e capturando qualquer resultado relevante.

      Crie um arquivo chamado jq-fuzz.sh:

      O conteúdo exato do script irá variar, dependendo do tipo de programa em que você estiver fazendo o fuzzing e os dados de entrada. No caso do jq e de outros programas semelhantes, porém, o script a seguir será o suficiente.

      Copie o script em seu arquivo jq-fuzz.sh:

      jq-fuzz.sh

      #!/bin/bash
while true; do
  radamsa test.json > input.txt
  jq . input.txt > /dev/null 2>&1
  if [ $? -gt 127 ]; then
    cp input.txt crash-`date +s%.%N`.txt
    echo "Crash found!"
  fi
done

      Esse script contém um while para fazer o conteúdo entrar em um loop, repetidas vezes. A cada vez que o script entrar em loop, a Radamsa gerará um caso de teste, com base no test.json e o salvará no arquivo input.txt.

      Na sequência, o caso de teste, input.txt, será executado com o programa jq e todo o resultado – padrão e de erros – será redirecionado para o diretório /dev/null, a fim de evitar que a tela do terminal fique cheia.

      Por fim, o valor de saída do jq é verificado. Se o valor de saída for maior que 127, isso indica que houve um encerramento fatal (uma falha); em seguida, os dados de entrada são salvos – para revisão posterior – em um arquivo chamado crash-, seguido de carimbo de data do Unix, com a data atual em segundos e nanossegundos.

      Marque o script como executável e o coloque em funcionamento, de modo a iniciar o teste de fuzzing do jq, automaticamente:

      • chmod +x jq-fuzz.sh

      • ./jq-fuzz.sh

      Você pode teclar o CTRL+C a qualquer momento para terminar o script. Então, você pode verificar se foram encontradas falhas com o ls, a fim de exibir uma listagem de diretório, contendo quaisquer arquivos de falha que tiverem sido criados.

      Você pode querer melhorar seus dados de entrada JSON, uma vez que o uso de um arquivo de entrada mais complexo provavelmente melhoraria a qualidade de seus resultados de fuzzing. Evite utilizar um arquivo grande ou que contenha muitos dados repetidos—um arquivo pequeno seria a entrada ideal, mas que contenha o máximo de elementos ‘complexos’ possível. Por exemplo, um bom arquivo de entrada conterá amostras de dados armazenados em todos formatos, que incluem strings, números inteiros, booleanos, listas e objetos, bem como dados aninhados, sempre que possível.

      Você usou a Radamsa para fazer o fuzzing em um aplicativo de linha de comando. Em seguida, você usará a Radamsa para fazer o fuzz em serviços de rede.

      Passo 4 — Pedidos de fuzzing em serviços de rede

      A Radamsa também pode ser usada para fazer o fuzzing em serviços de rede, seja atuando como um cliente ou servidor de rede. Neste passo, você usará a Radamsa para fazer o fuzzing em um serviço de rede, com a Radamsa atuando como cliente.

      O objetivo do fuzzing em serviços de rede é testar o quão resiliente um determinado serviço de rede é para os clientes, enviando-lhe dados malformados ou mal-intencionados. Muitos serviços de rede – como servidores Web ou DNS – são geralmente expostos à Internet, o que significa que eles são um alvo comum para invasores. Um serviço de rede que não seja resistente o suficiente para receber dados malformados pode falhar ou, pior ainda, falhar em um estado aberto, o que permite que invasores leiam dados confidenciais, como chaves de criptografia ou dados do usuário.

      A técnica específica para o fuzzing em serviços de rede varia bastante, dependendo do serviço de rede em questão. No entanto, neste exemplo usaremos a Radamsa para fazer o fuzz em um servidor Web básico, servindo conteúdo de HTML estático.

      Primeiro, você precisa configurar o servidor Web para testes. Você pode fazer isso usando o servidor de desenvolvimento integrado que vem com o pacote php-cli. Você também precisará do curl para testar seu servidor Web.

      Se não tiver o php-cli e/ou o curl instalados, instale-os usando a ferramenta apt:

      • sudo apt install php-cli curl

      Em seguida, crie um diretório para armazenar seus arquivos do servidor Web e vá até ele:

      Então, crie um arquivo HTML que contenha uma amostra de texto:

      Adicione o que vem a seguir ao arquivo:

      index.html

      <h1>Hello, world!</h1>

      Agora, você pode executar seu servidor Web do PHP. Você precisará ser capaz de visualizar o registro do servidor Web, ao mesmo tempo que ainda continuará a usar outra sessão de terminal. Dessa maneira, abra outra sessão de terminal e de SSH para o seu servidor para este fim:

      • cd ~/www

      • php -S localhost:8080

      Isso irá gerar algo parecido com o seguinte:

      Output
      PHP 7.2.24-0ubuntu0.18.04.1 Development Server started at Wed Jan  1 16:06:41 2020
Listening on http://localhost:8080
Document root is /home/user/www
Press Ctrl-C to quit.

      Agora, você pode retornar para a sessão de terminal original e testar se o servidor Web está funcionando, usando o curl:

      Isso exibirá o arquivo de exemplo index.html que você criou anteriormente:

      Output
      <h1>Hello, world!</h1>

      Seu servidor Web precisa estar acessível apenas localmente. Assim, você não deve abrir quaisquer portas no seu firewall para ele.

      Agora que você configurou seu servidor Web de teste, você pode iniciar o teste de fuzzing nele, usando a Radamsa.

      Primeiro, será necessário criar um exemplo de pedido de HTTP para usar como dados de entrada para a Radamsa. Crie um novo arquivo para armazenar isso em:

      Então, copie a seguinte amostra de pedido HTTP para o arquivo:

      http-request.txt

      GET / HTTP/1.1
Host: localhost:8080
User-Agent: test
Accept: */*

      Em seguida, utilize a Radamsa para enviar esse pedido HTTP para o seu servidor Web local. Para fazer isso, você terá que usar a Radamsa como cliente TCP, o que pode ser feito especificando-se um endereço IP e porta à qual se conectar:

      • radamsa -o 127.0.0.1:8080 http-request.txt

      Nota: esteja ciente que usar a Radamsa como um cliente TCP possivelmente fará com que dados malformados/mal-intencionados sejam transmitidos pela rede. Isso pode interromper as coisas. Assim, tenha o cuidado de acessar somente as redes que você está autorizado a testar ou, de preferência, continue usando o endereço do localhost (127.0.0.1).

      Por fim, caso visualize os registros produzidos em relação ao seu servidor Web local, verá que ele recebeu os pedidos, mas provavelmente não os processou, já que eles eram inválidos/malformados.

      Os registros produzidos estarão visíveis em sua segunda janela de terminal:

      Output
      [Wed Jan  1 16:26:49 2020] 127.0.0.1:49334 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:04 2020] 127.0.0.1:49336 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:05 2020] 127.0.0.1:49338 Invalid request (Malformed HTTP request)
[Wed Jan  1 16:28:07 2020] 127.0.0.1:49340 Invalid request (Unexpected EOF)
[Wed Jan  1 16:28:08 2020] 127.0.0.1:49342 Invalid request (Malformed HTTP request)

      Para obter resultados ideais e garantir que as falhas fiquem registradas, talvez você queira escrever um script de automação semelhante ao usado no Passo 3. Você deve considerar, ainda, o uso de um arquivo de entrada mais complexo, que possa conter adições, como a função de cabeçalhos HTTP extras.

      Você fez o fuzzing em um serviço de rede usando a Radamsa, que agiu como um cliente TCP. Em seguida você fará o fuzzing em um cliente de rede com a Radamsa atuando como um servidor.

      Passo 5 — Fazendo o fuzzing em aplicativos clientes de rede

      Neste passo, você usará a Radamsa para fazer o teste de fuzzing em um aplicativo cliente de rede. Isso pode ser feito através da interceptação das respostas de um serviço de rede e do fuzzing delas, antes de serem recebidas pelo cliente.

      O objetivo deste tipo de fuzzing é testar o quão resilientes os aplicativos cliente de rede são para receberem dados malformados ou mal-intencionados, vindos de serviços de rede. Por exemplo, testar um navegador Web (cliente) recebendo um HTML malformado de um servidor Web (serviço de rede), ou testar um cliente DNS recebendo respostas de DNS malformadas de um servidor DNS.

      Tal como aconteceu com o fuzzing de aplicativos de linha de comando ou de serviços de rede, a técnica exata para o fuzzing em cada aplicativo cliente de rede varia consideravelmente. No entanto, neste exemplo, você usará o whois, que é um aplicativo de envio/recebimento, baseado no protocolo TCP.

      O aplicativo whois é utilizado para fazer pedidos aos servidores WHOIS e receber registros WHOIS como resposta. O WHOIS opera pela porta TCP 43 em texto não criptografado, o que o torna um bom candidato para testes de fuzzing baseados em rede.

      Se ainda não tiver o whois instalado, instale-o usando a ferramenta apt:

      Primeiro, você precisará adquirir uma amostra de resposta do whois para usar como dados de entrada. Para tanto, você pode fazer um pedido whois e salvar o resultado em um arquivo. Aqui, você pode usar qualquer domínio que quiser, uma vez que estará testando o programa whois localmente, usando dados de amostra:

      • whois example.com > whois.txt

      Em seguida, você precisará configurar a Radamsa como um servidor que atenda versões dessa resposta do whois que já passaram pelo fuzzing. Uma vez que a Radamsa está executando em modo de servidor, você terá que conseguir continuar usando o seu terminal. Assim, é recomendável abrir outra sessão de terminal e outra conexão via protocolo SSH com o seu servidor para esse fim:

      • radamsa -o :4343 whois.txt -n inf

      Agora, a Radamsa estará executando em modo de servidor TCP e atenderá uma versão de whois.txt – que já passou por fuzzing – toda vez que uma conexão for feita no servidor, independentemente de quais dados da solicitação forem recebidos.

      Agora, você já pode prosseguir com o teste do aplicativo cliente whois. Você vai precisar fazer uma solicitação whois normal para um domínio de sua escolha (não precisa ser o mesmo para os quais os dados da amostra se destinam), mas com o whois apontado para o seu servidor local da Radamsa:

      • whois -h localhost:4343 example.com

      A resposta consistirá nos dados da sua amostra, mas que já passaram pelo processo de fuzzing da Radamsa. Desde que a Radamsa esteja em execução, você pode continuar a fazer pedidos para o servidor local, pois toda vez ele irá fornecer uma resposta diferente que já passou pelo fuzzing.

      Assim como ocorre no fuzzing em serviços de rede, para melhorar a eficiência esse teste de fuzzing do cliente de rede e assegurar que eventuais falhas sejam capturadas, talvez você queira escrever um script de automação semelhante ao usado no Passo 3.

      Neste passo final, você usou a Radamsa para realizar o teste de fuzzing de um aplicativo cliente de rede.

      Conclusão

      Neste artigo, você configurou a Radamsa e a usou para fazer o fuzzing em um aplicativo de linha de comando, um serviço de rede e um cliente de rede. Portanto, você já tem o conhecimento básico necessário para fazer o teste de fuzzing em seus próprios aplicativos, com a expectativa de aprimorar a robustez e a resistência deles a ataques.

      Se quiser explorar a Radamsa ainda mais, faça uma revisão detalhada do arquivo README da Radamsa, pois ele traz outras informações técnicas e exemplos de como a ferramenta pode ser usada:

      Confira também algumas outras ferramentas de fuzzing, como a American Fuzzy Lop (AFL), que é uma ferramenta de fuzzing avançada, desenvolvida para testar aplicativos binários em velocidade e com precisão extremamente elevadas.



      Source link

      Forgot Your Password ?