Skip to content
Back to search

iothackbot-marketplace

MarketplaceWorks with Claude CodeGitHub

IoT security testing and hacking tools for Claude Code

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/brownfinesecurity--iothackbot/badge.svg)](/listings/brownfinesecurity--iothackbot)

HTML

<a href="/listings/brownfinesecurity--iothackbot"><img src="/api/listings/brownfinesecurity--iothackbot/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

# Python dependencies
pip install colorama pyserial pexpect requests

# System dependencies (Arch Linux)
sudo pacman -S nmap e2fsprogs f2fs-tools python python-pip inetutils

# For other distributions, install equivalent packages

Setup

1. Clone the repository:

git clone https://github.com/BrownFineSecurity/iothackbot.git
cd iothackbot

2. Add the bin directory to your PATH:

export PATH="$PATH:$(pwd)/bin"

3. For permanent setup, add to your shell configuration:

echo 'export PATH="$PATH:/path/to/iothackbot/bin"' >> ~/.bashrc

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 15 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "iothackbot-marketplace",
  3. "description": "IoT security testing and hacking tools for Claude Code",
  4. "owner": {
  5. "name": "BrownFineSecurity"
  6. },
  7. "plugins": [
  8. {
  9. "name": "iothackbot",
  10. "source": "./",
  11. "description": "IoT security testing toolkit with skills for firmware analysis, network reconnaissance, UEFI security, and device exploitation",
  12. "version": "1.0.0"
  13. }
  14. ]
  15. }
README.md · README · 278 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # IoTHackBot
  2. Open-source IoT security testing toolkit with integrated Claude Code skills for automated vulnerability discovery.
  3. ## Overview
  4. IoTHackBot is a collection of specialized tools and Claude Code skills designed for security testing of IoT devices, IP cameras, and embedded systems. It provides both command-line tools and AI-assisted workflows for comprehensive IoT security assessments.
  5. ## Tools Included
  6. ### Network Discovery & Reconnaissance
  7. - **wsdiscovery** - WS-Discovery protocol scanner for discovering ONVIF cameras and IoT devices
  8. - **iotnet** - IoT network traffic analyzer for detecting protocols and vulnerabilities
  9. - **netflows** - Network flow extractor with DNS hostname resolution from pcap files
  10. - **nmap** (skill) - Professional network reconnaissance with two-phase scanning strategy
  11. ### Device-Specific Testing
  12. - **onvifscan** - ONVIF device security scanner
  13. - Authentication bypass testing
  14. - Credential brute-forcing
  15. ### Firmware & File Analysis
  16. - **chipsec** (skill) - UEFI/BIOS firmware static analysis
  17. - Detect known rootkits (LoJax, ThinkPwn, HackingTeam)
  18. - Generate EFI executable inventories with hashes
  19. - Decode firmware structure and extract NVRAM
  20. - **ffind** - Advanced file finder with type detection and filesystem extraction
  21. - Identifies artifact file types
  22. - Extracts ext2/3/4 and F2FS filesystems
  23. - Designed for firmware analysis
  24. ### Android Analysis
  25. - **apktool** (skill) - APK unpacking and resource extraction
  26. - Decode AndroidManifest.xml
  27. - Extract resources, layouts, strings
  28. - Disassemble to smali code
  29. - **jadx** (skill) - APK decompilation
  30. - Convert DEX to readable Java source
  31. - Search for hardcoded credentials
  32. - Analyze app logic
  33. ### Hardware & Console Access
  34. - **jtagprobe** - SWD/JTAG debug interface probe via SEGGER J-Link
  35. - Classifies targets as OPEN / LOCKED / DEAD
  36. - Sweeps SWD then JTAG across multiple clock speeds
  37. - Decodes DPIDR / IDCODE to vendor (STM32, NXP, Nordic, TI, ...)
  38. - Halt + memory read to confirm true debugger control
  39. - Per-attempt JLinkExe stdout captured for pentest evidence
  40. - **picocom** (skill) - IoT UART console interaction for hardware testing
  41. - Bootloader manipulation
  42. - Shell enumeration
  43. - Firmware extraction
  44. - Includes Python helper script for automated interaction
  45. - **telnetshell** (skill) - IoT telnet shell interaction
  46. - Unauthenticated shell testing
  47. - Device enumeration
  48. - BusyBox command handling
  49. - Includes Python helper script and pre-built enumeration scripts
  50. ## Installation
  51. ### Prerequisites
  52. ```bash
  53. # Python dependencies
  54. pip install colorama pyserial pexpect requests
  55. # System dependencies (Arch Linux)
  56. sudo pacman -S nmap e2fsprogs f2fs-tools python python-pip inetutils
  57. # For other distributions, install equivalent packages
  58. ```
  59. ### Setup
  60. 1. Clone the repository:
  61. ```bash
  62. git clone https://github.com/BrownFineSecurity/iothackbot.git
  63. cd iothackbot
  64. ```
  65. 2. Add the bin directory to your PATH:
  66. ```bash
  67. export PATH="$PATH:$(pwd)/bin"
  68. ```
  69. 3. For permanent setup, add to your shell configuration:
  70. ```bash
  71. echo 'export PATH="$PATH:/path/to/iothackbot/bin"' >> ~/.bashrc
  72. ```
  73. ## Usage
  74. ### Quick Start Examples
  75. #### Discover ONVIF Devices
  76. ```bash
  77. wsdiscovery 192.168.1.0/24
  78. ```
  79. #### Test ONVIF Device Security
  80. ```bash
  81. onvifscan auth http://192.168.1.100
  82. onvifscan brute http://192.168.1.100
  83. ```
  84. #### Analyze Network Traffic
  85. ```bash
  86. # Analyze PCAP file for IoT protocols
  87. iotnet capture.pcap
  88. # Live capture
  89. sudo iotnet -i eth0 -d 60
  90. ```
  91. #### Extract Network Flows
  92. ```bash
  93. # Extract flows from device with DNS resolution
  94. netflows capture.pcap --source-ip 192.168.1.100
  95. # Get just hostname:port list
  96. netflows capture.pcap -s 192.168.1.100 --format quiet
  97. ```
  98. #### Analyze Firmware
  99. ```bash
  100. # Identify file types
  101. ffind firmware.bin
  102. # Extract filesystems (requires sudo)
  103. sudo ffind firmware.bin -e
  104. ```
  105. ### Claude Code Plugin
  106. IoTHackBot is available as a Claude Code plugin, providing AI-assisted security testing with specialized skills.
  107. #### Available Skills
  108. | Skill | Description |
  109. |-------|-------------|
  110. | **chipsec** | UEFI/BIOS firmware static analysis - malware detection, EFI inventory |
  111. | **apktool** | Android APK unpacking and resource extraction |
  112. | **jadx** | Android APK decompilation to Java source |
  113. | **ffind** | Firmware file analysis with filesystem extraction |
  114. | **iotnet** | IoT network traffic analysis |
  115. | **jtagprobe** | SWD/JTAG debug interface probe via J-Link |
  116. | **netflows** | Network flow extraction with DNS hostname resolution |
  117. | **nmap** | Professional network reconnaissance |
  118. | **onvifscan** | ONVIF device security testing |
  119. | **picocom** | UART console interaction |
  120. | **telnetshell** | Telnet shell enumeration |
  121. | **wsdiscovery** | WS-Discovery device discovery |
  122. #### Plugin Installation
  123. **Option 1: Use directly during development**
  124. ```bash
  125. claude --plugin-dir /path/to/iothackbot
  126. ```
  127. **Option 2: Install as local marketplace (persistent)**
  128. Add to `~/.claude/settings.json`:
  129. ```json
  130. {
  131. "extraKnownMarketplaces": {
  132. "iothackbot-local": {
  133. "source": {
  134. "source": "directory",
  135. "path": "/path/to/iothackbot"
  136. }
  137. }
  138. },
  139. "enabledPlugins": {
  140. "iothackbot": true
  141. }
  142. }
  143. ```
  144. Then restart Claude Code for the settings to take effect.
  145. **Option 3: Project-specific setup**
  146. For use within a specific project, the skills are also available via the `.claude/skills/` symlink for backwards compatibility.
  147. ## Tool Architecture
  148. All tools follow a consistent design pattern:
  149. - **CLI Layer** (`tools/iothackbot/*.py`) - Command-line interface with argparse
  150. - **Core Layer** (`tools/iothackbot/core/*_core.py`) - Core functionality implementing ToolInterface
  151. - **Binary** (`bin/*`) - Executable wrapper scripts
  152. This separation enables:
  153. - Easy automation and chaining
  154. - Consistent output formats (text, JSON, quiet)
  155. - Standardized error handling
  156. - Tool composition and pipelines
  157. ## Configuration
  158. ### IoT Detection Rules
  159. `config/iot/detection_rules.json` - Custom IoT protocol detection rules for iotnet
  160. ### Wordlists
  161. - `wordlists/onvif-usernames.txt` - Default usernames for ONVIF devices
  162. - `wordlists/onvif-passwords.txt` - Default passwords for ONVIF devices
  163. ## Development
  164. ### Adding New Tools
  165. See `TOOL_DEVELOPMENT_GUIDE.md` for detailed information on:
  166. - Project structure standards
  167. - Development patterns
  168. - Output formatting guidelines
  169. - Testing and integration
  170. ### Key Interfaces
  171. - **ToolInterface** - Base interface for all tools
  172. - **ToolConfig** - Standardized configuration object
  173. - **ToolResult** - Standardized result object with success, data, errors, and metadata
  174. ## Output Formats
  175. All tools support multiple output formats:
  176. ```bash
  177. # Human-readable text with colors (default)
  178. onvifscan auth 192.168.1.100
  179. # Machine-readable JSON
  180. onvifscan auth 192.168.1.100 --format json
  181. # Minimal output
  182. onvifscan auth 192.168.1.100 --format quiet
  183. ```
  184. ## Security & Ethics
  185. **IMPORTANT**: These tools are designed for authorized security testing only.
  186. - Only test devices you own or have explicit permission to test
  187. - Respect scope limitations and rules of engagement
  188. - Be aware of the impact on production systems
  189. - Use appropriate timing to avoid denial of service
  190. - Document all testing activities
  191. - Follow responsible disclosure practices
  192. ## Contributing
  193. Contributions are welcome! Please ensure:
  194. - New tools follow the architecture patterns in `TOOL_DEVELOPMENT_GUIDE.md`
  195. - All tools support text, JSON, and quiet output formats
  196. - Code includes proper error handling
  197. - Documentation is clear and comprehensive
  198. ## License
  199. MIT License - See LICENSE file for details
  200. ## Disclaimer
  201. This toolkit is provided for educational and authorized security testing purposes only. Users are responsible for ensuring they have proper authorization before testing any systems. The authors are not responsible for misuse or damage caused by this toolkit.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.