One place for hosting & domains

      Radamsa

      Установка и использование Radamsa для фаззи-тестирования программ и сетевых служб в Ubuntu 18.04


      Автор выбрал Electronic Frontier Foundation Inc для получения пожертвований в рамках программы Write for DOnations.

      Введение

      Угрозы безопасности постоянно возрастают, и поэтому разработчикам и системным администраторам требуется применять упреждающий подход к защите и тестированию безопасности приложений.

      Для тестирования безопасности клиентских приложений и сетевых служб часто используется метод фаззинга, заключающийся в повторяющейся отправке в приложение недопустимых или неправильно отформатированных данных и последующем анализе получаемых ответов. Это полезно для тестирования надежности и устойчивости приложений к незапланированным вводным данным, включая поврежденные данные и реальные атаки.

      Radamsa — инструмент для фаззинга с открытым исходным кодом, позволяющий генерировать тестовые примеры на основе задаваемых пользователем входных данных. Radamsa полностью поддерживает скрипты и успешно выявляет уязвимости в реальных приложениях, таких как Gzip.

      В этом обучающем руководстве мы выполним установку Radamsa и используем этот инструмент для фаззи-тестирования сетевых приложений и приложений командной строки с использованием собственных примеров.

      Предупреждение. Radamsa — это инструмент тестирования на проникновение, позволяющий определить уязвимости или слабости определенных систем или приложений. Вы не должны использовать уязвимости, обнаруженные с помощью Radamsa, для любого незаконного поведения, нанесения вреда или злонамеренных действий. Согласно этическим нормам, об уязвимостях следует сообщать разработчикам, обслуживающим приложение, и информацию о них не следует публиковать в открытом доступе без прямого разрешения.

      Предварительные требования

      Для прохождения этого обучающего руководства вам потребуется следующее:

      • Один сервер Ubuntu 18.04, настроенный в соответствии с указаниями руководства Начальная настройка сервера Ubuntu 18.04, включая пользователя sudo без привилегий root и активный брандмауэр для блокирования ненужных портов.
      • Приложение командной строки или сетевое приложение, которое вы хотите протестировать, например Gzip, Tcpdump, Bind, Apache, jq или любое другое приложение по вашему выбору. Для целей этого обучающего руководства в качестве примера мы будем использовать jq.

      Предупреждение. Radamsa может вызвать нестабильную работу или сбой в работе приложений или систем. В связи с этим Radamsa следует использовать только в готовой к этому среде, например на выделенном сервере. Также необходимо получить прямое письменное разрешение владельца системы на ее тестирование посредством фаззинга.

      Подготовив все вышеперечисленное, войдите на сервер без привилегий root, чтобы начать подготовку.

      Шаг 1 — Установка Radamsa

      Прежде всего, мы загрузим и выполним компиляцию Radamsa для использования этого инструмента в нашей системе. Исходный код Radamsa доступен в официальном репозитории на GitLab.

      Для начала мы обновим указатель локальных пакетов, чтобы отразить последние изменения на предыдущих уровнях:

      Затем мы установим пакеты gcc, git, make и wget, необходимые для компиляции исходного кода в исполняемый двоичный файл:

      • sudo apt install gcc git make wget

      После подтверждения установки apt выполнит загрузку и установку указанных пакетов и всех необходимых зависимостей.

      Затем мы загрузим копию исходного кода Radamsa, клонировав ее из репозитория на GitLab:

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

      При этом будет создана директория radamsa с исходным кодом приложения. Перейдите в эту директорию, чтобы начать компиляцию кода:

      Далее вы можете запустить процесс компиляции с помощью make:

      Теперь мы можем установить скомпилированный двоичный файл Radamsa в директорию $PATH:

      После этого мы можем проверить установленную версию и убедиться, что все работает правильно:

      Экран результатов должен выглядеть примерно следующим образом:

      Output

      Radamsa 0.6

      Если появится сообщение об ошибке radamsa: command not found, необходимо проверить установку всех требуемых зависимостей и убедиться в отсутствии ошибок при компиляции.

      Мы установили Radamsa и теперь можем рассмотреть примеры тестов, чтобы понять, как работает Radamsa и для чего его можно использовать.

      Шаг 2 — Подготовка примеров для фаззинга

      Мы установили Radamsa и теперь можем использовать его для рассмотрения нескольких примеров фаззинга.

      Пример представляет собой элемент данных, который используется для ввода в тестируемую программу. Например, если вы выполняете фаззинг программы архивирования, такой как Gzip, в качестве примера можно использовать архив файлов, который вы попытаетесь распаковать.

      Примечание. Radamsa производит манипуляции с входными данными множеством разных неожиданных способов, включая чрезмерное повторение, инвертирование разрядов, вставку управляющих символов и т. д. Это может повлечь за собой прекращение или нестабильность сеанса терминала, поэтому нужно учесть это, прежде чем двигаться дальше.

      Вначале следует передать в Radamsa простой текстовый элемент и посмотреть, что произойдет в результате:

      • echo "Hello, world!" | radamsa

      Вводимые данные будут изменены (фаззинг) и получится пример для тестирования:

      Output

      Hello,, world!

      В данном случае Radamsa добавил запятую между Hello и world. Это изменение может выглядеть незначительным, но в некоторых приложениях это может привести к неправильной интерпретации данных.

      Повторим попытку, запустив ту же самую команду еще раз. Вы увидите другой результат:

      Output

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

      На этот раз мы вставили в строку несколько одинарных кавычек ('), в том числе один символ, заменивший l в слове world. Этот пример с большей вероятностью вызовет проблемы в приложении, поскольку одинарные и двойные кавычки часто используются как разделители элементов данных в списке.

      Повторим попытку еще один раз:

      Output

      Hello, $+$PATHu0000`xcalc`world!

      В данном случае Radamsa вставляет строку оболочки, которая поможет тестировать приложение на уязвимость к вставке команд.

      Мы использовали Radamsa для фаззинга вводимой строки и подготовили ряд примеров для тестирования. Далее мы используем Radamsa для фаззинга приложения командной строки.

      Шаг 3 — Фаззинг приложения командной строки

      На этом шаге мы используем Radamsa для фаззинга приложения командной строки и получения отчета о сбоях.

      Конкретные методики фаззинга различаются для разных случаев, и для каждой программы подходят свои методы. В этом обучающем руководстве мы используем в качестве примера программу командной строки jq, предназначенную для обработки данных JSON.

      Вы можете использовать любую другую программу подобного рода, если она также принимает структурированные или неструктурированные данные, выполняет с ними какие-то операции и выводит результат. В частности, данный пример также подойдет для Gzip, Grep, bc, tr и т. д.

      Если вы еще не установили jq, вы можете выполнить установку сейчас с помощью apt:

      Сейчас будет выполнена установка jq.

      Чтобы начать фаззинг, создайте образец файла JSON, который будете использовать в качестве исходного для Radamsa:

      Добавьте в файл следующие данные JSON:

      test.json

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

      Вы можете проверить этот файл с помощью jq, если хотите убедиться в правильности синтаксиса JSON:

      Если синтаксис JSON правильный, jq выведет файл. В противном случае будет выведено сообщение об ошибке, которое вы сможете использовать для исправления синтаксиса в случае необходимости.

      Далее мы проведем фаззинг тестового файла JSON в Radamsa и передадим его в jq. В результате jq прочитает измененный тестовый файл, а не первоначальные правильные данные JSON:

      Если Radamsa изменит данные JSON так, что синтаксис останется верным, jq выведет данные со всеми изменениями, которые были внесены Radamsa.

      Если Radamsa изменит формат данных JSON на неверный, программа jq выдаст сообщение об ошибке. Например:

      Output

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

      Также возможно, что jq не сможет правильно обработать искаженные данные, в результате чего будет наблюдаться сбой или неправильное поведение программы. Именно этого мы и ждем от фаззинга, поскольку такое поведение может указывать на уязвимость безопасности, например при переполнении буфера или вставке команд.

      Чтобы более эффективно тестировать программы на такие уязвимости, можно автоматизировать фаззинг с помощью скрипта Bash, который будет генерировать тестовые примеры, передавать их в программу и собирать результаты.

      Создайте файл с именем jq-fuzz.sh:

      Точное содержание скрипта будет зависеть от типа тестируемой программы и входящих данных, однако для jq и других подобных программ следующий скрипт будет достаточным.

      Скопируйте скрипт в файл 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
      

      Этот скрипт содержит оператор while, чтобы сделать его содержимое цикличным. При каждом цикле скрипта Radamsa генерирует тестовый пример на базе файла test.json и сохраняет его в файл input.txt.

      Тестовый пример input.txt пропускается через jq так, что все стандартные сообщения и сообщения об ошибках направляются в /dev/null для предотвращения переполнения экрана терминала.

      В заключение проверяется значение jq на выходе. Если значение на выходе превышает 127, это означает критическое завершение работы (сбой), и в этом случае входные данные сохраняются для последующего использования в файле с именем crash- и суффиксом текущей даты Unix с указанием секунд и наносекунд.

      Отметьте этот скрипт как исполняемый и запустите его для автоматического тестирования jq методом фаззинга:

      • chmod +x jq-fuzz.sh
      • ./jq-fuzz.sh

      Вы можете в любой момент нажать CTRL+C для остановки скрипта. Затем вы сможете проверить наличие сбоев, используя ls для вывода списка директории с созданными файлами регистрации сбоев.

      Вы можете улучшить входные данные JSON, поскольку использование более сложного входного файла, вероятно, повысит качество результатов фаззинга. Избегайте использовать большие файлы или файлы с большим объемом повторяющихся данных. Идеальный исходный файл должен иметь небольшой размер, но при этом содержать как можно больше сложных элементов. Например, хороший входной файл будет содержать образцы данных, сохраненные во всех форматах, включая строки, целые числа, булевы операторы, списки и объекты, а также вложенные данные, если это возможно.

      Мы использовали Radamsa для фаззинга приложения командной строки. Далее мы будем использовать Radamsa для фаззинга запросов сетевых служб.

      Шаг 4 — Фаззинг запросов сетевых служб

      Radamsa также можно использовать для фаззинга сетевых служб, при этом он может выступать или в качестве сетевого клиента, или в качестве сервера. На этом шаге мы будем использовать Radamsa для фаззинга сетевой службы, где Radamsa будет выступать в качестве клиента.

      Цель фаззинга сетевых служб заключается в проверке устойчивости сетевой службы к отправке клиентами неправильно сформированных и/или вредоносных данных. Многие сетевые службы, в том числе веб-серверы и серверы DNS, обычно доступны из Интернета и часто становятся целью злоумышленников. Сетевая служба, которая недостаточно устойчива к неправильно сформированным данным, может прекратить работу или даже потерять работоспособность в открытом состоянии, в результате чего злоумышленники получат доступ к важным данным, таким как ключи шифрования или пользовательские данные.

      Конкретные методики фаззинга сетевых служб различаются в зависимости от сетевой службы. В данном примере мы используем Radamsa для фаззинга простого веб-сервера, выдающего статический контент в формате HTML.

      Вначале нужно настроить веб-сервер для тестирования. Для этой цели можно использовать встроенный сервер разработки, входящий в состав пакета php-cli. Также для тестирования веб-сервера нам потребуется curl.

      Если у вас не установлены php-cli и/или curl, вы можете установить их с помощью apt:

      • sudo apt install php-cli curl

      Затем создайте директорию для хранения файлов веб-сервера и перейдите в нее:

      Далее создайте файл HTML с образцом текста:

      Добавьте в файл следующее:

      index.html

      <h1>Hello, world!</h1>
      

      Теперь вы можете запустить свой веб-сервер PHP. Вам потребуется возможность просматривать журнал веб-сервера во время использования другого сеанса терминала, и поэтому нужно открыть другой сеанс терминала и канал SSH для подключения к серверу:

      • cd ~/www
      • php -S localhost:8080

      Будет выведен текст следующего вида:

      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.

      Теперь вы можете вернуться к исходному сеансу терминала и проверить работу веб-сервера с помощью curl:

      В результате будет выведен образец файла index.html, который вы создали ранее:

      Output

      <h1>Hello, world!</h1>

      Для вашего веб-сервера потребуется только локальный доступ, поэтому не следует открывать для него порты брандмауэра.

      Мы настроили тестовый веб-сервер и теперь можем начать фаззинг с помощью Radamsa.

      Для начала нам потребуется создать образец запроса HTTP, который будет использоваться в качестве исходных данных Radamsa. Создайте новый файл для его сохранения:

      Затем скопируйте в файл следующий образец запроса HTTP:

      http-request.txt

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

      Теперь мы можем использовать Radamsa для отправки этого запроса HTTP на локальный веб-сервер. Для этого нужно использовать Radamsa в качестве клиента TCP, что можно сделать посредством указания IP-адреса и порта для подключения:

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

      Примечание. Использование Radamsa в качестве клиента TCP может привести к передаче через сеть неправильно сформированных или вредоносных данных. Это может повлечь за собой неисправности, и поэтому вы должны использовать только сети, которые вам разрешено тестировать, а лучше всего использовать только адрес localhost (127.0.0.1).

      Если вы просмотрите журналы локального веб-сервера, вы увидите, что он получал запросы, однако вряд ли обрабатывал их, поскольку они были недопустимыми или неправильно сформированными.

      Журналы будут отображаться во втором окне терминала:

      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)

      Для получения оптимальных результатов и гарантированной регистрации сбоев можно использовать скрипт автоматизации, аналогичный использованному на шаге 3. Также следует попробовать использовать более сложный исходный файл, который может содержать такие дополнения, как дополнительные заголовки HTTP.

      Мы провели тестирование сетевой службы методом фаззинга, использовав Radamsa в качестве клиента TCP. Теперь мы проведем фаззинг сетевого клиента, используя Radamsa в качестве сервера.

      Шаг 5 — Фаззинг сетевых клиентских приложений

      На этом шаге мы используем Radamsa для тестирования сетевого клиентского приложения методом фаззинга. Это реализуется посредством перехвата ответов сетевой службы и их искажения до поступления на клиент.

      Цель такого фаззинга заключается в проверке устойчивости клиентских приложений сети к получению неправильно сформированных или вредоносных данных от сетевых служб. В качестве примера можно привести тестирование браузера (клиента), получающего неправильно сформированный код HTML от веб-сервера (сетевой службы) или тестирование клиента DNS, получающего неправильно сформированные ответы DNS от сервера DNS.

      Как и в случае с фаззингом приложений командной строки или сетевых служб, конкретная методика фаззинга разных сетевых клиентских приложений может значительно различаться, однако в этом примере мы используем whois, простое приложение для приема/передачи на базе TCP.

      Приложение whois используется для отправки запросов на серверы WHOIS и получения записей WHOIS в составе ответов. WHOIS работает через порт TCP 43 в формате простого текста, что делает его отличным вариантом для фаззинга сетевого клиента.

      Если у вас еще нет приложения whois, вы можете установить его с помощью apt:

      Прежде всего, необходимо получить пример ответа whois для использования в качестве исходных данных. Для этого можно создать запрос whois и сохранить результат в файл. Здесь вы можете использовать любой домен, поскольку будете тестировать всю программу whois локально, используя образцы данных:

      • whois example.com > whois.txt

      Далее вам потребуется настроить Radamsa в качестве сервера, который будет отправлять искаженные версии этого ответа whois. Когда Radamsa будет работать в серверном режиме, вам нужна будет возможность и дальше использовать терминал, и для этого нужно будет открыть другой сеанс терминала и канал SSH для связи с сервером:

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

      Теперь Radamsa будет работать в режиме сервера TCP и будет отправлять искаженную версию файла whois.txt при каждой попытке подключения к серверу, вне зависимости от того, какие данные запроса будут получены.

      Теперь вы можете перейти к тестированию клиентского приложения whois. Вам потребуется нормальный запрос whois для любого домена по вашему выбору (не обязательно для того, для которого предназначен образец), но при этом whois должен указывать на ваш локальный сервер Radamsa:

      • whois -h localhost:4343 example.com

      Ответ будет содержать образец данных, искаженный Radamsa. Пока Radamsa будет работать, вы сможете и дальше отправлять запросы на локальный сервер, и каждый раз он будет выдавать разные искаженные ответы.

      Как и в случае с фаззингом сетевых служб, вы можете написать скрипт автоматизации, аналогичный использованному на шаге 3, чтобы повысить эффективность фаззинга сетевых клиентов и гарантировать регистрацию сбоев.

      На этом заключительном шаге мы использовали Radamsa для тестирования сетевого клиентского приложения методом фаззинга.

      Заключение

      В этом обучающем руководстве мы научились настраивать Radamsa и использовать его для тестирования приложения командной строки, сетевой службы и сетевого клиента методом фаззинга. Теперь у вас имеются базовые знания, необходимые для тестирования ваших собственных приложений методов фаззинга. Надеемся, что это поможет вам повысить их надежность и устойчивость к атакам.

      Если вы хотите узнать больше о Radamsa, вы можете более подробно ознакомиться с файлом Radamsa README, где содержится дополнительная техническая информация и дополнительные примеры использования:

      Также вы можете рассмотреть и другие инструменты для фаззинга, например продвинутую программу фаззинга American Fuzzy Lop (AFL), предназначенную для тестирования двоичных приложений с очень высокой скоростью и точностью:



      Source link

      How To Install and Use Radamsa to Fuzz Test Programs and Network Services on Ubuntu 18.04


      The author selected the Electronic Frontier Foundation Inc to receive a donation as part of the Write for DOnations program.

      Introduction

      Security threats are continually becoming more sophisticated, so developers and systems administrators need to take a proactive approach in defending and testing the security of their applications.

      A common method for testing the security of client applications or network services is fuzzing, which involves repeatedly sending invalid or malformed data to the application and analyzing its response. This is useful to help test how resilient and robust the application is to unexpected input, which may include corrupted data or actual attacks.

      Radamsa is an open-source fuzzing tool that can generate test cases based on user-specified input data. Radamsa is fully scriptable, and so far has been successful in finding vulnerabilities in real-world applications, such as Gzip.

      In this tutorial, you will install and use Radamsa to fuzz test command-line and network-based applications using your own test cases.

      Warning: Radamsa is a penetration testing tool which may allow you to identify vulnerabilities or weaknesses in certain systems or applications. You must not use vulnerabilities found with Radamsa for any form of reckless behavior, harm, or malicious exploitation. Vulnerabilities should be ethically reported to the maintainer of the affected application, and not disclosed publicly without explicit permission.

      Prerequisites

      Before you begin this guide you’ll need the following:

      • One Ubuntu 18.04 server set up by following the Initial Server Setup with Ubuntu 18.04, including a sudo non-root user and enabled firewall to block non-essential ports.
      • A command-line or network-based application that you wish to test, for example Gzip, Tcpdump, Bind, Apache, jq, or any other application of your choice. As an example for the purposes of this tutorial, we’ll use jq.

      Warning: Radamsa can cause applications or systems to run unstably or crash, so only run Radamsa in an environment where you are prepared for this, such as a dedicated server. Please also ensure that you have explicit written permission from the owner of a system before conducting fuzz testing against it.

      Once you have these ready, log in to your server as your non-root user to begin.

      Step 1 — Installing Radamsa

      Firstly, you will download and compile Radamsa in order to begin using it on your system. The Radamsa source code is available in the official repository on GitLab.

      Begin by updating the local package index to reflect any new upstream changes:

      Then, install the gcc, git, make, and wget packages needed to compile the source code into an executable binary:

      • sudo apt install gcc git make wget

      After confirming the installation, apt will download and install the specified packages and all of their required dependencies.

      Next, you’ll download a copy of the source code for Radamsa by cloning it from the repository hosted on GitLab:

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

      This will create a directory called radamsa, containing the source code for the application. Move into the directory to begin compiling the code:

      Next, you can start the compilation process using make:

      Finally, you can install the compiled Radamsa binary to your $PATH:

      Once this is complete, you can check the installed version to make sure that everything is working:

      Your output will look similar to the following:

      Output

      Radamsa 0.6

      If you see a radamsa: command not found error, double-check that all required dependencies were installed and that there were no errors during compilation.

      Now that you’ve installed Radamsa, you can begin to generate some sample test cases to understand how Radamsa works and what it can be used for.

      Step 2 — Generating Fuzzing Test Cases

      Now that Radamsa has been installed, you can use it to generate some fuzzing test cases.

      A test case is a piece of data that will be used as input to the program that you are testing. For example, if you are fuzz testing an archiving program such as Gzip, a test case may be a file archive that you are attempting to decompress.

      Note: Radamsa will manipulate input data in a wide variety of unexpected ways, including extreme repetition, bit flips, control character injection, and so on. This may cause your terminal session to break or become unstable, so be aware of this before proceeding.

      Firstly, pass a simple piece of text to Radamsa to see what happens:

      • echo "Hello, world!" | radamsa

      This will manipulate (or fuzz) the inputted data and output a test case, for example:

      Output

      Hello,, world!

      In this case, Radamsa added an extra comma between Hello and world. This may not seem like a significant change, but in some applications this may cause the data to be interpreted incorrectly.

      Let’s try again by running the same command. You’ll see different output:

      Output

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

      This time, multiple single quotes (') were inserted into the string, including one that overwrote the l in world. This particular test case is more likely to result in problems for an application, as single/double quotes are often used to separate different pieces of data in a list.

      Let’s try one more time:

      Output

      Hello, $+$PATHu0000`xcalc`world!

      In this case, Radamsa inserted a shell injection string, which will be useful to test for command injection vulnerabilities in the application that you are testing.

      You’ve used Radamsa to fuzz an input string and produce a series of test cases. Next, you will use Radamsa to fuzz a command-line application.

      Step 3 — Fuzzing a Command-line Application

      In this step, you’ll use Radamsa to fuzz a command-line application and report on any crashes that occur.

      The exact technique for fuzzing each program varies massively, and different methods will be most effective for different programs. However, in this tutorial we will use the example of jq, which is a command-line program for processing JSON data.

      You may use any other similar program as long as it follows the general principle of taking some form of structured or unstructured data, doing something with it, and then outputting a result. For instance this example would also work with Gzip, Grep, bc, tr, and so on.

      If you don’t already have jq installed, you can install it using apt:

      jq will now be installed.

      To begin fuzzing, create a sample JSON file that you’ll use as the input to Radamsa:

      Then, add the following sample JSON data to the file:

      test.json

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

      You can parse this file using jq if you wish to check that the JSON syntax is valid:

      If the JSON is valid, jq will output the file. Otherwise, it will display an error, which you can use to correct the syntax where required.

      Next, fuzz the test JSON file using Radamsa and then pass it to jq. This will cause jq to read the fuzzed/manipulated test case, rather than the original valid JSON data:

      If Radamsa fuzzes the JSON data in a way that it is still syntactically valid, jq will output the data, but with whatever changes Radamsa made to it.

      Alternatively, if Radamsa causes the JSON data to become invalid, jq will display a relevant error. For example:

      Output

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

      The alternate outcome would be that jq is unable to correctly handle the fuzzed data, causing it to crash or misbehave. This is what you’re really looking for with fuzzing, as this may be indicative of a security vulnerability such as a buffer overflow or command injection.

      In order to more efficiently test for vulnerabilities like this, a Bash script can be used to automate the fuzzing process, including generating test cases, passing them to the target program and capturing any relevant output.

      Create a file named jq-fuzz.sh:

      The exact script content will vary depending on the type of program that you’re fuzzing and the input data, but in the case of jq and other similar programs, the following script suffices.

      Copy the script into your jq-fuzz.sh file:

      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
      

      This script contains a while to make the contents loop repeatedly. Each time the script loops, Radamsa will generate a test case based on test.json and save it to input.txt.

      The input.txt test case will then be run through jq, with all standard and error output redirected to /dev/null to avoid filling up the terminal screen.

      Finally, the exit value of jq is checked. If the exit value is greater than 127, this is indicative of a fatal termination (a crash), then the input data is saved for review at a later date in a file named crash- followed by the current date in Unix seconds and nanoseconds.

      Mark the script as executable and set it running in order to begin automatically fuzz testing jq:

      • chmod +x jq-fuzz.sh
      • ./jq-fuzz.sh

      You can issue CTRL+C at any time to terminate the script. You can then check whether any crashes have been found by using ls to display a directory listing containing any crash files that have been created.

      You may wish to improve your JSON input data since using a more complex input file is likely to improve the quality of your fuzzing results. Avoid using a large file or one that contains a lot of repeated data—an ideal input file is one that is small in size, yet still contains as many ‘complex’ elements as possible. For example, a good input file will contain samples of data stored in all formats, including strings, integers, booleans, lists, and objects, as well as nested data where possible.

      You’ve used Radamsa to fuzz a command-line application. Next, you’ll use Radamsa to fuzz requests to network services.

      Step 4 — Fuzzing Requests to Network Services

      Radamsa can also be used to fuzz network services, either acting as a network client or server. In this step, you’ll use Radamsa to fuzz a network service, with Radamsa acting as the client.

      The purpose of fuzzing network services is to test how resilient a particular network service is to clients sending it malformed and/or malicious data. Many network services such as web servers or DNS servers are usually exposed to the internet, meaning that they are a common target for attackers. A network service that is not sufficiently resistant to receiving malformed data may crash, or even worse fail in an open state, allowing attackers to read sensitive data such as encryption keys or user data.

      The specific technique for fuzzing network services varies enormously depending on the network service in question, however in this example we will use Radamsa to fuzz a basic web server serving static HTML content.

      Firstly, you need to set up the web server to use for testing. You can do this using the built-in development server that comes with the php-cli package. You’ll also need curl in order to test your web server.

      If you don’t have php-cli and/or curl installed, you can install them using apt:

      • sudo apt install php-cli curl

      Next, create a directory to store your web server files in and move into it:

      Then, create a HTML file containing some sample text:

      Add the following to the file:

      index.html

      <h1>Hello, world!</h1>
      

      You can now run your PHP web server. You’ll need to be able to view the web server log while still using another terminal session, so open another terminal session and SSH to your server for this:

      • cd ~/www
      • php -S localhost:8080

      This will output something similar to the following:

      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.

      You can now switch back to your original terminal session and test that the web server is working using curl:

      This will output the sample index.html file that you created earlier:

      Output

      <h1>Hello, world!</h1>

      Your web server only needs to be accessible locally, so you should not open any ports on your firewall for it.

      Now that you’ve set up your test web server, you can begin to fuzz test it using Radamsa.

      First, you’ll need to create a sample HTTP request to use as the input data for Radamsa. Create a new file to store this in:

      Then, copy the following sample HTTP request into the file:

      http-request.txt

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

      Next, you can use Radamsa to submit this HTTP request to your local web server. In order to do this, you’ll need to use Radamsa as a TCP client, which can be done by specifying an IP address and port to connect to:

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

      Note: Be aware that using Radamsa as a TCP client will potentially cause malformed/malicious data to be transmitted over the network. This may break things, so be very careful to only access networks that you are authorized to test, or preferably, stick to using the localhost (127.0.0.1) address.

      Finally, if you view the outputted logs for your local web server, you’ll see that it has received the requests, but most likely not processed them as they were invalid/malformed.

      The outputted logs will be visible in your second terminal window:

      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)

      For optimal results and to ensure that crashes are recorded, you may wish to write an automation script similar to the one used in Step 3. You should also consider using a more complex input file, which may contain additions such as extra HTTP headers.

      You’ve fuzzed a network service using Radamsa acting as a TCP client. Next, you will fuzz a network client with Radamsa acting as a server.

      Step 5 — Fuzzing Network Client Applications

      In this step, you will use Radamsa to fuzz test a network client application. This is achieved by intercepting responses from a network service and fuzzing them before they are received by the client.

      The purpose of this kind of fuzzing is to test how resilient network client applications are to receiving malformed or malicious data from network services. For example, testing a web browser (client) receiving malformed HTML from a web server (network service), or testing a DNS client receiving malformed DNS responses from a DNS server.

      As was the case with fuzzing command-line applications or network services, the exact technique for fuzzing each network client application varies considerably, however in this example you will use whois, which is a simple TCP-based send/receive application.

      The whois application is used to make requests to WHOIS servers and receive WHOIS records as responses. WHOIS operates over TCP port 43 in clear text, making it a good candidate for network-based fuzz testing.

      If you don’t already have whois available, you can install it using apt:

      First, you’ll need to acquire a sample whois response to use as your input data. You can do this by making a whois request and saving the output to a file. You can use any domain you wish here as you’re testing the whois program locally using sample data:

      • whois example.com > whois.txt

      Next, you’ll need to set up Radamsa as a server that serves fuzzed versions of this whois response. You’ll need to be able to continue using your terminal once Radamsa is running in server mode, so it is recommended to open another terminal session and SSH connection to your server for this:

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

      Radamsa will now be running in TCP server mode, and will serve a fuzzed version of whois.txt each time a connection is made to the server, no matter what request data is received.

      You can now proceed to testing the whois client application. You’ll need to make a normal whois request for any domain of your choice (it doesn’t have to be the same one that the sample data is for), but with whois pointed to your local Radamsa server:

      • whois -h localhost:4343 example.com

      The response will be your sample data, but fuzzed by Radamsa. You can continue to make requests to the local server as long as Radamsa is running, and it will serve a different fuzzed response each time.

      As with fuzzing network services, to improve the efficiency of this network client fuzz testing and ensure that any crashes are captured, you may wish to write an automation script similar to the one used in Step 3.

      In this final step, you used Radamsa to conduct fuzz testing of a network client application.

      Conclusion

      In this article you set up Radamsa and used it to fuzz a command-line application, a network service, and a network client. You now have the foundational knowledge required to fuzz test your own applications, hopefully with the result of improving their robustness and resistance to attack.

      If you wish to explore Radamsa further, you may wish to review the Radamsa README file in detail, as it contains further technical information and examples of how the tool can be used:

      You may also wish to check out some other fuzzing tools such as American Fuzzy Lop (AFL), which is an advanced fuzzing tool designed for testing binary applications at extremely high speed and accuracy:



      Source link