USB Rubber Ducky

From Embedded Lab Vienna for IoT & Security
Jump to navigation Jump to search
Name USB Rubber Ducky
Manufacturer Hak5
Specification supportedTechnologies: USB 2.0
Technologies USB 2.0
Included equipment 1x USB rubber ducky PCB, 1x USB to Micro USB adaptor, 1x 128 MB Micro sd card, 1x USB Micro SD card writer, 1x case, 1x clip


rogue USB attack stick re-writeable


USB Rubber Ducky


The USB Rubber Ducky is a discreet penetration testing device designed to operate covertly by masquerading as a standard USB keyboard. Its versatility lies in its capability to execute predefined scripts upon connection, enabling security professionals to evaluate and potentially exploit USB vulnerabilities. This device is an essential tool in USB security assessments, allowing for the simulation of various attack scenarios, providing a comprehensive evaluation of USB security.

Security Threats

Testing the Rubber Ducky is a necessary step in understanding how this USB device works and ensuring it is used responsibly. This process helps evaluate its potential impact and uncover any security risks it might pose. The functionalities listed below highlight potential risks associated with a Rubber Ducky:

1. Automated Script Execution

The Rubber Ducky can be programmed to mimic a keyboard and execute predefined scripts once connected to a computer. This allows it to automate a sequence of keystrokes, potentially performing malicious actions.

2. Payload Delivery

The Rubber Ducky can carry and execute payloads that exploit vulnerabilities in the target system. This might include downloading and executing malware, creating backdoors, or initiating other malicious activities.

3. Password Theft

The device can be programmed to capture sensitive information such as usernames and passwords by simulating keyboard input. This information can then be exfiltrated or used for unauthorized access.

4. Network Attacks

A Rubber Ducky can be used to launch network-based attacks once connected to a system. It might attempt to exploit vulnerabilities, perform privilege escalation, or establish unauthorized connections.

5. Data Exfiltration

The Rubber Ducky can be programmed to collect and exfiltrate sensitive data from the target system. This could include documents, credentials, or other confidential information.

6. Device Spoofing

By emulating a keyboard, the Rubber Ducky can trick the system into thinking it is a legitimate input device, enabling it to bypass certain security measures.

7. Malicious Scripting

Since the Rubber Ducky supports scripting languages, it can execute malicious scripts on the target system. This can be used to manipulate files, change system settings, or disrupt normal operations.


Mitigating the risks associated with Rubber Ducky and similar USB-based attacks involves a combination of technical measures, security practices, and user awareness. To protect against potential harm from devices like Rubber Ducky, it is essential for individuals and organizations to implement security measures such as:

1. Endpoint Security Solutions

Deploying endpoint security solutions can monitor and control USB device usage on networks. These solutions can help detect and prevent unauthorized devices, including Rubber Ducky, from interacting with the system.

2. Device Authentication

Implementing device authentication mechanisms ensures that only authorized USB devices can connect to host systems. This can involve using digital signatures or certificates to verify the legitimacy of connected devices.

3. USB Port Controls

Physical access to USB ports should be restricted, particularly in sensitive environments. Measures such as USB port locks can be utilized to prevent unauthorized physical access, reducing the risk of connecting malicious devices.

4. User Education

Users should be made aware of the potential risks associated with connecting unknown USB devices. It is advisable to foster a security-conscious mindset and recommend against the use of untrusted USB devices or obtaining them from unreliable sources.

5. Security Policies

Establish and enforce security policies regarding the use of USB devices within an organization. Clearly define acceptable use and implement controls to prevent unauthorized devices from connecting to company systems.

6. Behavioral Analysis

The use of behavioral analysis tools is recommended for identifying unusual or suspicious behavior, especially related to keyboard input. This approach assists in detecting and preventing automated script execution by devices like Rubber Ducky.

7. Regular Updates

Ensuring the operating systems, antivirus software, and security solutions are regularly updated is essential to address known vulnerabilities. Up-to-date systems provide protection against potential exploits that may be attempted by malicious devices.

8. Network Segmentation

Implementing network segmentation to isolate critical systems from less secure areas is recommended. This practice helps contain the impact of a potential breach and prevents lateral movement by malicious devices.

9. Encryption

Encrypting sensitive data is advised to safeguard it from unauthorized access, even in the event of an attempted interception or exfiltration by a malicious device. This adds an additional layer of security to protect critical data.

10. Security Audits and Testing

Regular security audits and penetration testing should be conducted to identify and address vulnerabilities in the network and systems. Simulating USB-based attacks helps assess the effectiveness of implemented security measures.

11. Use of Whitelists

Maintaining a whitelist of approved USB devices and permitting connections exclusively from devices on the list is advisable. This practice helps prevent unauthorized devices, including Rubber Ducky, from interacting with the system.

12. Physical Security Measures

Implementing physical security measures, such as securing the physical location of computers and servers, is crucial. This helps prevent unauthorized individuals from gaining physical access and connecting malicious devices.

By adopting a combination of these mitigation strategies, individuals and organizations can enhance their defenses against USB-based attacks, including those involving devices like Rubber Ducky. The key is to implement a multi-layered approach that includes technical controls, user education, and regular security assessments.

Use Case: USB Rubber Ducky Scripting

In penetration testing and automation scenarios, the USB Rubber Ducky utilizes Ducky Script commands to simulate keyboard actions. These commands allow security professionals to automate sequences of keystrokes for various testing purposes. Below are some fundamental Ducky Script commands:

- DELAY [time]: Delays the specified time in milliseconds before executing the next command. Example: `DELAY 500`.

- REM [comment]: Adds a comment to the script, which is ignored during execution. Example: `REM This is a comment`.

- STRING [text]: Types the specified text as if it were being entered via a keyboard. Example: `STRING Open Notepad ENTER` (opens Notepad).

- ENTER: Simulates pressing the Enter key. Example: `ENTER`.

- SPACE: Simulates pressing the Spacebar key. Example: `STRING Hello SPACE World ENTER` (types "Hello World").

- TAB: Simulates pressing the Tab key. Example: `TAB`.

- CTRL [key]: Simulates holding down the Ctrl key. Example: `CTRL c` (copies selected text).

- ALT [key]: Simulates holding down the Alt key. Example: `ALT F4` (closes the active window).

- GUI [key]: Simulates pressing the GUI (Windows) key. Example: `GUI r` (opens the Run dialog).

- REPEAT [number]: Repeats the next command or sequence of commands a specified number of times. Example: `REPEAT 3 { STRING Hello ENTER }` (prints "Hello" three times).

- DELAY [time]: Delays the specified time in milliseconds before executing the next command. Example: `DELAY 500`.

Use Case: USB Rubber Ducky Testing

Step 1: Craft the Payload Script

Create a payload script using the Ducky Script language. This script outlines actions for the Rubber Ducky to execute upon connecting to a target system.

Step 2: Convert Script to Binary

Use a DuckEncoder tool to convert the script into an "injection.bin" file. For instance, using a Bash command with DuckEncoder: java -jar duckencoder.jar -i script.txt -o injection.bin Alternatively, tools like [Payload Studio (available on (] can be used for this conversion.

Step 3: Load Binary onto USB Rubber Ducky

Transfer the resulting "injection.bin" file onto the USB Rubber Ducky for execution. This can be done by connecting the Rubber Ducky to a computer and treating it as a USB storage device to copy the binary file onto it.

Step 4: Connect Rubber Ducky to Target System

Insert the USB Rubber Ducky into the target system. Upon connection, it will execute the predefined payload script, simulating keyboard inputs.

Step 5: Monitor and Analyze

Observe the impact of the script on the target system. Effectiveness of security measures can be assessed by monitoring the simulated sequence of actions triggered by the USB Rubber Ducky.



  • M. Tischer et al., ”Users Really Do Plug in USB Drives They Find,” 2016 IEEE Symposium on Security and Privacy (SP), San Jose, CA, USA, 2016, pp. 306-319, doi:10.1109/SP.2016.26.
  • Saurabh Verma and Abhishek Singh. Data theft prevention endpoint protection from unauthorized usb devices —implementation. In 2012 Fourth International Conference on Advanced Computing (ICoAC), pages 1–4, 2012.
  • Michael Kofler, Andr´e Zingsheim, Klaus Gebeshuber, Markus Widl, Roland Aigner, Thomas Hackner, Stefan Kania, Peter Kloep, and Frank Neugebauer. Hacking Security: Das umfassende Handbuch. Rheinwerk, Bonn, Germany, 1 edition, 2018.