[!IMPORTANT] To all my hindi people, 'no_ble' folder contains version of AtomDucky without BLE, so don't message me about not having BLE. All love ❤️
Atom Ducky is a HID device controlled through a web browser. It's designed to function as a wirelessly operated Rubber Ducky, personal authenticator, or casual keyboard. Its primary aim is to help ethical hackers gain knowledge about Rubber Ducky devices while integrating their use into everyday life.
[!IMPORTANT] This project may not be suitable for the very beginners, as it requires some knowledge of the operating system command line interface.
Let's fully cover the setup process, including available microcontrollers. From first commands in the terminal, to the web interface of Atom Ducky.
First, we will need a Microcontroller device supporting HID, WiFi, and preferably BLE. Perfect choice would be an AtomS3U, link to official website: M5Stack AtomS3U.
For full version of AtomDucky
HID, WiFi and BLE:
Click to see full list
For no_ble version of AtomDucky
Boards supporting WiFi and HID:
Click to see full list
[!TIP] Choosing a board supporting BLE will let you have two bonus features, but they are not relevant to the keyboard at all.
Not every board has CircuitPython installed by default (very few to be clear), and installation process may vary between devices, the general advice is to plug your microcontroller into the computer, visit CircuitPython Official Website, and search for your board.
Boards without .UF2 bootloader:
Click to expand
In case of the ATOM S3U based on ESP32S3 (CircuitPython M5stack AtomS3U), scroll down until you see:
Click on Download Bootloader ZIP on the website, create a folder anywhere, and unpack the downloaded .zip file there. Save the path of the folder to your clipboard, or just remember it.
For flashing the bootloader, we will need an esptool.py, we can also try using a web browser ESP Web Flasher.
Install esptool.py, use terminal and make sure you have Python installed.
$ pip install esptool
Flash the device with bootloader.
Before flashing, the board has to enter into the bootloader mode, this is different for all boards, usually holding the button itself works, but in case of Atom S3U we must hold the main button and the reset button until the green light.
# Find the port
# Windows:
$ mode
# Look for devices that have 9600-460800 Baud
Status for device COM13:
------------------------
Baud: 9600
Parity: None
Data Bits: 8
Stop Bits: 1.5
Timeout: OFF
XON/XOFF: OFF
CTS handshaking: OFF
DSR handshaking: OFF
DSR sensitivity: OFF
DTR circuit: OFF
RTS circuit: OFF
# Linux:
dmesg | grep tty
Next, use the esptool to flash:
The flash offset '-z' may vary, please check which flash offset your board has, common offsets to try are '0, 0x0, 0x1000'
# (--port /dev/ttyPORT for linux)
$ esptool --port COM13 erase_flash
$ esptool --port COM13 --baud 460800 write_flash -z 0 /path/to/your/downloaded/bootloader/combined.bin
Great, now click RESET button once, or just unplug and plug the board.
There should be a new drive detected by your computer, usually with the BOOT name or 'BOARD_NAMEBOOT'.
With bootloader installed:
Visit the CircuitPython Official Website and search for your board, the CircuitPython version that interests us is:
Download the .uf2 file and just copy or move it to the BOOT drive of the microcontroller.
This same drive should now be named CIRCUITPY, that means we have successfully installed CircuitPython.
$ git clone https://github.com/FLOCK4H/AtomDucky
Move all files from AtomDucky folder, or AtomDucky_no_ble folder for boards without BLE module, excluding README.md, to the CIRCUITPY drive.
Press RESET button once, or plug the device again.
Voila, the AtomDucky is ready to use, and it should already create an Access Point
The LED on the board should signal whether the device is starting (yellow light) or has initialized successfully (cyan light).
We need to join the Access Point hosted by our device, ESSID of the network is Atom Ducky, and it should have no encryption.
SetupConfiguration:
Access Point IP address, we do not need to change it at all, so just press Next whenever you're ready.
NORMAL, second is RUBBER. The difference is that RUBBER mode will inject the payload from atoms/payload.txt before the initialization of the web interface.TRUE for the Atom Ducky access point, or necessarily change to FALSE if you are connecting it to your network.Click Save button, this will save the config to atoms/_config file and restart the board.
Connecting Atom Ducky to your network will result in different IP address assigned to the device (and this address may change irregularly), without this address, it's not possible to open the web interface. One may find the new IP address on network's config website in e.g. Attached Devices subpage.
The hostname is ATOM-DUCKY
After plugging the Atom Ducky into a device supporting HID (computer, smartphone etc.), we want to open the web interface (open web browser and go to the IP address of Atom Ducky).
Web interface buttons:
In the hamburger dropdown menu, there is a Settings page where we can modify _config file easily.
The BLE section is fully additional, and it contains functions that when launched can crash/ freeze iOS devices, or disrupt others in using their iOS/Samsung phones.
[!IMPORTANT] To hide USB drive just simply uncomment the line mentioned in
boot.pyfile.
The syntax is inherited from NeoDucky project.
Let's write a simple payload with Hello World!
atoms/payload.txt
Hello World!
Now let's run it in loop:
One liner
Hello <time1>World<time1><LOOP>
Multiple lines
Hello<time2> ;
World<time1>!;
<LOOP>;
Notice the semicolon use, it has to be at the end of the line in multi-line payloads
'timeX' - where X is the amount of time to sleep (can be float e.g. 0.1 or XXX number like 360)
'LOOP' - as one of special tags, when used will repeat the operation over and over, it has a near second cooldown to reduce eventual damage
[!CAUTION] Be very careful when using LOOP tag, as it may result in inpredictable and irreversible damage.
Keycodes are mostly single character format so "A" = "A" but there are exceptions:
Used to perform specific actions in the payload, there are two types of tags:
1. Single
``` - ESC
$ claude mcp add AtomDucky \
-- python -m otcore.mcp_server <graph>