Welcome back to the reverse engineering embedded Linux devices blog series from Novetta. In the first post, Emulating Embedded Linux Devices with QEMU, we covered some basic tools commonly used in the reverse engineering process and utilized QEMU to execute a binary in user-mode. In the second part of this series, Emulating Embedded Linux Systems with QEMU, we used QEMU in system mode to create a VM to host the D-Link DIR-866L’s extracted squashfs root, and managed to get the web server started. In this installment, we will design a fuzzer capable of re-discovering a public vulnerability in the D-Link DIR-868L.
Fuzzing Introduction
Fuzzing is an automated method to discover bugs in software. In the simplest terms possible, a fuzzer is a program that feeds random input data into a computer program and analyzes the fuzzed program’s reaction to the input data.
For more on fuzzing, explore: Scale Vulnerability Research Using Modern Fuzzers.
Challenges of Fuzzing Embedded Linux Devices
Fuzzing embedded Linux devices presents several challenges.
1) The usual non-trivial problem with fuzzing across a network connection.
Setting up a network connection is relatively slow, adds additional overhead, and dramatically reduces the number of executions per second, reducing the speed of the fuzzing setup. Additionally, fuzzing across a network reduces the ability of the fuzzer to introspection/instrumentation on the target program (unless the fuzzer is built to be decentralized and stores metadata and state information in a central data store). Without the ability to do introspection or instrumentation, a fuzzer’s value is significantly reduced, especially against “hard target” code bases. Also, crash detection across a network can be a non-trivial problem to solve (especially without introspection to help triage the crashes).
2) Fuzzing forking applications can present issues for some fuzzers, mainly if the target follows a fork/execve pattern.
Often, the fuzzer won’t properly follow the execution of the child process into the newly executed program.
3) Using an emulator can reduce the fuzzing speed.
With embedded Linux devices, often the device has a different CPU architecture than the native OS hosting the fuzzer, so it becomes necessary to run the fuzzer in an emulator (such as Qemu), which can reduce the fuzzing speed.
4) The inability to access source code.
Many public fuzzers expect access to the source code for an application and use a custom compiler to add instrumentation to the target program. With embedded Linux targets, there is no access to source code and all that is given is a binary.
5) Varying sources of input.
Often, especially for CGI binaries, the input to the binary does not come from standard input or from a socket, but rather from getenv() calls to an environment that has been prepared by the webserver process. For a real world example, the ssi binary on the DIR-868L uses getenv() calls to retrieve the data sent by the HTTP client. The environment is set up by the webserver prior to forking, and then starting the ssi binary with a call to execve().
You should consider all of these challenges when selecting a fuzzer.
Selecting a Fuzzer
There are many popular fuzzers in the public domain. Some popular examples are American Fuzzy Lop (AFL), libFuzzer, and HongFuzz. However, many aren’t well suited to accomplish our goal. For example, AFL is optimized to work against applications that have been compiled from source, and not arbitrary binaries.
For this blog post, there are several options:
1) Use American Fuzzy Lop (AFL) to fuzz the target binaries.
As stated above, AFL is optimized for open source applications — especially those that read from stdin. Our target binary, on the other hand, takes input from the getenv() function. AFL does provide that ability to fuzz arbitrary binaries thanks to afl-qemu and afl-unicorn. However, since AFL still expects data from stdin, we would have to write a fairly complicated library that would be injected into the process (via the AFL_PRELOAD environment variable) to hijack getenv(). In attempting this approach, AFL failed to detect instrumentation in the target when the AFL_PRELOAD variable was set. However, it’s possible (and probable!) that I was misusing AFL.
2) Use LibFuzzer to fuzz the target binaries.
Use LibFuzzer to fuzz the target binaries. LibFuzzer is another popular open source fuzzer. However, using LibFuzzer would require building clang on the target, among other things. This method was not pursued simply out of convenience.
3) Develop a custom fuzzer.
Ultimately, due to the problem of trying to fuzz a random binary, and the target taking input from,getenv() developing a custom fuzzer is the best strategy. Since the target is quite simple, the fuzzer could be simple as well.
Designing and Testing our Fuzzer
The fuzzer is simplistic and a basic starting point. It does not do any instrumentation, introspection, advanced input generation or mutation at all. Despite lacking these features, it is capable of finding a surprising number of vulnerabilities in embedded Linux targets and shows how even very basic fuzzers can find vulnerabilities in poorly written code bases.
The fuzzing framework consists of two components: the fuzzer itself and the hook module. The hook module is written in C, and hooks the getenv() function. The hook module is designed to be injected into the target process via the LD_PRELOAD environment variable. When the hooked getenv() function is called, the hook module will connect to a Unix socket, and send the requested variable across the connection. A pointer to the response read from the socket is returned from the hooked getenv() function.
Because our fuzzer was written in Python, it simply uses os.fork() to create a new process, and then executes the target binary with os.execve(). In the call to os.execve(), the newly created process’ environment has the LD_PRELOAD environment variable set to the hook library, allowing the fuzzer to inject input. The fuzzer is configured via a simple INI-like file that lets the user manually set static values for specific environment variables (for example, say the variable FOO must have the value bar for execution to continue, it can be set in the configuration file). If a variable is not listed in the configuration file, the fuzzer simply sends back 10,000 “A” characters.
The fuzzer uses the process’ return code to attempt to do crash detection. The fuzzer considers the target program to have crashed if it exited as a result of a SIGILL, SIGABRT or SIGSEGV signal. If one of these signals caused the target program to exit, the environment is saved as a JSON blob to a file on disk for manual examination. This fuzzer is nothing spectacular, yet sadly is still very effective against many embedded Linux targets.
Download our fuzzer through GitHub.
Examples of the fuzzer in action
First, a sample vulnerable program:
$ cat vuln.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
char *var;
char buf[256];
if((var = getenv("FOO")) == NULL)
{
printf("FOO is undefined.\n");
}
else
{
printf("Calling vulnerable strcpy()...\n");
strcpy(buf, var);
printf("buf = %s\n", buf);
}
return 0;
}
Next, view the usage of the fuzzer:
$ python3 fuzzenv.py -h
usage: fuzzenv.py [-h] [-v] [-l LIBRARY] [-u UNIX_SOCKET] [-e ENVIRONMENT]
[-c CONFIG_FILE]
output_dir target_app [target_args [target_args ...]]
Environment variable fuzzer
positional arguments:
output_dir Output for interesting fuzz cases
target_app Path to target application to fuzz
target_args Arguments to pass to the target app
optional arguments:
-h, --help show this help message and exit
-v, --verbose Run in verbose mode
-l LIBRARY, --library LIBRARY
Library to inject into created processes
-u UNIX_SOCKET, --unix-socket UNIX_SOCKET
Unix socket path
-e ENVIRONMENT, --environment ENVIRONMENT
Extra vars to pass into app
-c CONFIG_FILE, --config-file CONFIG_FILE
Config file for environment variables
Start a simple fuzzer session:
$ python3 fuzzenv.py output1 ./vuln
PID 1523 crashed with signal 11And finally view the results:
$ cd output1/
$ ls
1523
$ cat 1523
{"FOO": "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "}
Next, slightly more complex example target:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
char *var;
char buf[256];
if(getenv("BAR") == NULL || strcmp("MAGIC", getenv("BAR")))
{
printf("Failed check.\n");
return 1;
}
if((var = getenv("FOO")) == NULL)
{
printf("FOO is undefined.\n");
}
else
{
printf("Calling vulnerable strcpy()...\n");
strcpy(buf, var);
printf("buf = %s\n", buf);
}
return 0;
}
This target program requires the BAR environment variable be set to the string value “MAGIC”. This type of pattern is very common in embedded Linux devices, which often require specific environment variables to have specific values (for example, REQUEST_METHOD must be either “GET” or “POST”, etc). You can accomplish this by crafting a configuration file and passing it into the fuzzer:
$ cat config.txt
BAR=MAGIC
$ python3 fuzzenv.py -c config.txt output1 ./vuln2
PID 1572 crashed with signal 11
And, as before, the environment that caused the crash is available:
$ cat output1/1572
{"FOO": "                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ", "BAR": "MAGIC"}
Note that this time the environment has been updated to include the BAR variable.
In this blog post, we discussed the challenges of fuzzing embedded Linux targets and designed and tested a sample fuzzer capable of fuzzing embedded Linux devices. In the next part of the series, we will leverage the fuzzer to re-discover a public vulnerability in the D-Link DIR-868L.
Embedded Linux Device Security Research Series
Post #1: Emulating Embedded Linux Devices with QEMU
Post #2: Emulating Embedded Linux Systems with QEMU
