Spy Gadgets: Building a Listening Device

You’ve probably heard that almost anything can be turned into a spy device—even something as ordinary as a charging cable. In this article, I’ll show you how to assemble and program a GSM bug using Arduino, which you can call from a specific number to listen in on what’s happening. We’ll disguise our invention as a portable power bank.

Note: Officially, only companies with government licenses are allowed to manufacture equipment for covert listening, video surveillance, or data extraction from computers. These companies are supposed to fulfill only government contracts. However, simpler spy devices can be made by anyone with basic soldering skills. The parts for such devices are easy to find at any electronics store.

Types of Surveillance Devices

• Radio bugs
• Mini voice recorders
• Hidden cameras
• Laser listening devices

We’ll be building a GSM bug—a device with a large operating range and a high-capacity battery. These features allow it to work in standby mode for up to ten days, and up to four hours in listening mode. The key advantage is that you can listen in real time, not just to recordings.

Choosing a Disguise

The easiest way to hide something is often in plain sight, inside an object that doesn’t attract attention. Here are some interesting ways to disguise a listening device:

• A computer mouse with a built-in GSM bug
• A smartphone charger with a built-in GSM bug
• A keyboard with a built-in voice recorder

These options are especially effective because the items are almost always plugged in, so the bug never runs out of power and can function longer. If your bug will only run on its own battery, you’ll need to think about how to recharge it—which, as spy movies show, can be a hassle. We want to avoid that.

That’s why my choice is to hide the bug inside an external power bank for charging smartphones. People often carry these around and recharge them, and even if they don’t, the power bank itself becomes a power source for the bug. In my opinion, this is a great place to hide a listening device.

Assembly

To build the device, you’ll need:

• GSM module Sim 800
• Arduino Pro Mini
• Power bank case for four Li-ion 18650 batteries
• Two or three 18650 batteries (I used two)
• Microphone
• SIM card

To assemble the device correctly, you need to know the pin assignments for the GSM Sim 800 module and the Arduino Pro Mini.

1. Solder the antenna to the GSM module at the NET socket.
2. Solder the microphone to the MIC+ and MIC- outputs.
3. Connect RXD and TXD on the GSM module to pins 6 and 7 on the Arduino.
4. Solder Vcc and GND from the module to the Arduino and to the contacts on the external battery.

After soldering all the components in place, make sure everything is connected correctly by flashing the controller with the following code:

// Include the software serial library
#include <SoftwareSerial.h>

SoftwareSerial SIM800(7, 6); // RX, TX

// Variable to store module response
String _response = "";

void setup() {
  Serial.begin(19200); // PC communication speed
  SIM800.begin(19200); // Modem communication speed
  Serial.println("Start!");
  sendATCommand("AT", true);
  // Modem setup commands
  _response = sendATCommand("AT+CLIP=1", true);
  // For DTMF option
  //_response = sendATCommand("AT+DDET=1", true);
}

String sendATCommand(String cmd, bool waiting) {
  String _resp = "";
  Serial.println(cmd);
  SIM800.println(cmd);
  if (waiting) {
    _resp = waitResponse();
    if (_resp.startsWith(cmd)) {
      _resp = _resp.substring(_resp.indexOf("\r", cmd.length()) + 2);
    }
    Serial.println(_resp);
  }
  return _resp;
}

String waitResponse() {
  String _resp = "";
  long _timeout = millis() + 10000;
  while (!SIM800.available() && millis() < _timeout)  {};
  if (SIM800.available()) {
    _resp = SIM800.readString();
  } else {
    Serial.println("Timeout...");
  }
  return _resp;
}

void loop() {
  if (SIM800.available())   {
    _response = waitResponse();
    _response.trim();
    Serial.println(_response);
    String whiteListPhones = "+380713337866";
    if (_response.startsWith("RING")) {
      int phoneindex = _response.indexOf("+CLIP: \"");
      String innerPhone = "";
      if (phoneindex >= 0) {
        phoneindex += 8;
        innerPhone = _response.substring(phoneindex, _response.indexOf("\"", phoneindex));
        Serial.println("Number: " + innerPhone);
      }
      if (innerPhone.length() >= 7 && whiteListPhones.indexOf(innerPhone) >= 0) {
        sendATCommand("ATA", true);
      } else {
        sendATCommand("ATH", true);
      }
    }
  }
  if (Serial.available())  {
    SIM800.write(Serial.read());
  };
}

If everything is soldered and flashed correctly, your bug will only answer incoming calls from the mobile numbers listed in the firmware.

Now, remove any long connecting wires and desolder the LEDs from the Arduino board. Isolate the microphone with heat shrink tubing, drill a hole in the power bank case for it, and secure both the microphone and the two boards with hot glue in place of one of the 18650 batteries.

In my build, I used two batteries, but you can use three—there’s enough space.

Improvements

• Use a case with a higher battery capacity.
• For longer battery life, put the GSM module into sleep mode and activate listening only when the power bank’s button is pressed.
• Send a notification to the owner when the power bank button is pressed.

Conclusion

We’ve designed and assembled a GSM bug disguised as an external power bank. Its cost is much lower than similar bugs you can buy online or in specialty stores. You can replicate my device or improve upon it. Most importantly, remember that privacy is a fundamental right—don’t use your knowledge for malicious purposes!