TL;DR
This paper introduces AutoDES, a novel framework for automatically discovering and exploiting vulnerabilities in Internet of Things (IoT) devices. It addresses the limitations of existing methods by employing an "Anti-Driller" technique to mitigate path explosion during vulnerability discovery and a suite of advanced attack methods for exploitation, all managed by an efficient genetic algorithm-based scheduler.
What Problem Does This Paper Address?
The rapid growth of the Internet of Things (IoT) has led to an explosion of interconnected devices and software, creating a vast attack surface. While automated vulnerability discovery and exploitation are crucial for securing these systems, existing methods face significant challenges:
- Limited Effectiveness: Current techniques often struggle to find vulnerabilities that can compromise IoT systems, especially those with complex or diverse architectures.
- Scalability Issues: Methods like dynamic symbolic execution suffer from "path explosion," making them inefficient for large-scale IoT deployments.
- IoT Specific Challenges: The fragmented nature of IoT hardware and operating systems, coupled with the sheer volume of software, makes manual security analysis impractical.
- Exploitation Gaps: Existing exploitation methods may require source code, are designed for specific challenges (like CGC), or are not effective against real-world applications.
This paper aims to bridge these gaps by providing a comprehensive, automated solution for both finding and exploiting vulnerabilities in IoT devices.
Methods
AutoDES is a framework composed of three main components:
- AutoD (Automated Vulnerability Discovery):
- Anti-Driller: This novel technique addresses the "path explosion" problem by first using a concolic execution engine to generate a specific input that targets a particular path identified from a Control Flow Graph (CFG). This input is then fed to a mutation-based fuzzer, which intelligently explores the software and avoids invalid mutations, leading to more efficient vulnerability discovery.
- Leverages Existing Tools: It also incorporates other fuzzing tools like AFL, AFLFast, and AFLGo for broader coverage.
- AutoE (Automated Vulnerability Exploitation):
- IPOV Fuzzer: An improved version of the POV fuzzer, designed to efficiently find vulnerabilities in simpler programs by targeting stack overflows and overwriting return addresses with shellcode.
- AutoJS: This method generates exploits to bypass stack randomization by injecting shellcode and using a "jmp esp" instruction to redirect execution.
- AutoROP: For systems with executable-space protection, this technique employs Return-Oriented Programming (ROP) to chain together existing code snippets (gadgets) to achieve the desired malicious outcome without injecting new shellcode.
- AutoS (Efficient Scheduling Solution):
- Genetic Algorithm (GA)-Based Scheduler: This component dynamically allocates computing resources (CPU cores, memory) to the various discovery and exploitation tasks. It uses a GA to optimize the scheduling sequence, aiming to minimize execution time and maximize efficiency across the entire AutoDES framework.
Datasets
The paper evaluates AutoDES on two real-world datasets:
- RHG (Robot Hacking Game) 2018 Dataset: Consists of 25 binary files from a cybersecurity challenge, categorized into Stack Overflow, Format String Overflow, and Heap Overflow vulnerabilities.
- BCTF-RHG 2019 Dataset: Includes 20 binary files from another challenge, featuring a broader range of vulnerabilities: Stack Overflow, Format String Overflow, Integer Overflow, Heap Overflow, Protocol Vulnerability, and Logical Vulnerability.
Key Insights and Ideas
- Mitigating Path Explosion is Key: The "Anti-Driller" approach highlights that intelligently guiding fuzzing with concolic execution and CFG analysis is more effective than brute-force fuzzing alone for finding vulnerabilities in complex code.
- Layered Exploitation Strategy: The combination of IPOV fuzzer, AutoJS, and AutoROP provides a robust exploitation pipeline, starting with simpler methods and escalating to more complex techniques like ROP when necessary, adapting to different security mechanisms.
- Resource Management is Crucial for Automation: The success of an automated framework hinges on efficient resource allocation. The GA-based scheduler (AutoS) demonstrates that intelligent dynamic scheduling can significantly improve overall efficiency.
- IoT Security Demands Tailored Automation: The challenges specific to IoT (fragmentation, diverse architectures) necessitate specialized automated tools that can handle binaries directly, as demonstrated by the case study.
Key Results
- Vulnerability Discovery (AutoD): Anti-Driller successfully identified vulnerabilities in binary files (R4 and R8) that other methods struggled with, likely due to its ability to bypass sanity checks by leveraging CFG analysis.
- Vulnerability Exploitation (AutoE): AutoJS and AutoROP outperformed Rex and IPOV fuzzer in terms of the number of exploitable binary files (8 each vs. 3 and 4 respectively). IPOV fuzzer was the fastest but couldn't exploit all files.
- Scheduling Efficiency (AutoS): AutoS consistently outperformed the Round-Robin (RR) scheduling algorithm, achieving better average running times for tasks, demonstrating its efficiency in resource management.
- Overall Framework Performance: AutoDES achieved competitive rankings in the RHG 2018 (7th place) and BCTF-RHG 2019 (5th place) challenges, showcasing its effectiveness in real-world scenarios.
- Case Study Success: The framework successfully exploited a remote buffer overflow vulnerability in MikroTik RouterOS, demonstrating its applicability to practical IoT devices.
Limitations and Future Work
- Limitations:
- The paper notes that Anti-Driller's performance may be limited by complex code structures in some binary files.
- AutoROP could not exploit binary file B4 due to the absence of suitable ROP gadgets.
- The current framework primarily focuses on binary files.
- Future Work:
- Improve the effectiveness and efficiency of vulnerability discovery and exploitation, particularly for Heap Overflow vulnerabilities.
- Extend the framework to analyze binaries in practical IoT applications.
- Further research into handling more complex code structures and exploit techniques.
Summary updated