device-activity-tracker: a PoC to tell whether a phone is active, idle, or offline over WhatsApp and Signal

A proof of concept (PoC) implementing in TypeScript the academic “Careless Whisper” attack (Gegenhuber et al., RAID 2025, Best Paper): it measures the round-trip time (RTT) of WhatsApp and Signal delivery receipts to infer, from nothing but a phone number, when a device is in use, idle, or offline. As of September 1, 2026 it carries 5,107 stars.

What device-activity-tracker is

device-activity-tracker is an open-source (MIT) tool implementing the research from the paper “Careless Whisper: Exploiting Silent Delivery Receipts to Monitor Users on Mobile Instant Messengers” by Gabriel K. Gegenhuber, Maximilian Günther, Markus Maier, Aljosha Judmayer, Florian Holzbauer, Philipp É. Frenzel, and Johanna Ullrich (University of Vienna and SBA Research). The README itself frames it with a warning: “Proof-of-concept for educational and security research purposes only. Demonstrates privacy vulnerabilities in WhatsApp and Signal.”

It isn’t a messaging service or a commercial app — it’s a security PoC demonstrating a real privacy vulnerability. It sends probes (probing messages) to a target number and measures the RTT (the time between sending the probe and the platform’s CLIENT ACK) to classify the device’s state:

🟢 Online — RTT below the threshold: the device is actively in use.
🟡 Standby — RTT above the threshold: the device is idle/locked.
🔴 Offline — no CLIENT ACK received: the device is disconnected or unreachable.

Per the README, it can also infer activity patterns over time and, less reliably, possible network switches (mobile data versus Wi-Fi). The project supports WhatsApp and Signal, with a web interface (React) and a CLI mode (WhatsApp only).

Origin: a PoC built on a RAID 2025 award-winning paper

The repository was created on December 7, 2025 by Gommzy (GitHub account gommzystudio, created in 2020, 196 followers, 27 public repositories, no company or bio on the profile), with the last push dating from December 31, 2025. The default branch is master.

The project’s authority doesn’t come from a company but from the academic paper it implements. Per the arXiv page (2411.11194, v1 on November 17, 2024, and v4 on October 31, 2025), the work was presented at the 28th International Symposium on Research in Attacks, Intrusions and Defenses (RAID 2025) and was “Distinguished with the Best Paper Award.” The paper’s abstract argues that instant messaging apps (over 3 billion users) allow, through specifically crafted messages, triggering delivery receipts to “ping” any user without their knowledge or consent; done at high frequency, an attacker can extract private information such as online/activity status (screen on/off), infer the number of active devices and their operating system, and launch resource-exhaustion attacks (battery or data) without generating any notification on the target.

The relevant narrative detail is the tension between the tool and the apps: the Hacker News thread about the paper itself (20 points, 4 comments) shows the reaction to “the foundation” (Signal Foundation) not having responded to the finding (see “Community reception”). This PoC is the executable translation of that research.

Philosophy and principles

The verifiable ideas running through the README, CONTRIBUTING.md, and the LICENSE:

Demonstrate a real vulnerability, not build a product. The README and the license (MIT with additional disclaimers) insist the goal is “educational and security research purposes only,” and warn that “this tool demonstrates real security vulnerabilities that affect millions of users.”
Build on peer-reviewed work. Rather than an invented attack, the implementation is based on a paper with a Best Paper Award (RAID 2025), anchoring the method in verifiable, citable literature (the README includes the BibTeX citation).
Passive, silent measurement. The mechanism relies on delivery receipts the recipient never notices (“silent delivery receipts”); the demo’s value is extracting a side-channel (RTT) that leaves no notification on the target device.
Transparency about mitigations and ethical limits. The README dedicates a section to “How to Protect Yourself,” clarifies that disabling read receipts does not protect against this specific attack, and notes that as of December 2025 the vulnerability remained exploitable in WhatsApp and Signal; it also asks users not to track people without consent (“this may violate privacy laws”).

How it works

The technical flow documented in the README, src/, package.json, and docker-compose.yml:

Authentication: for WhatsApp, a QR code is scanned with the app (via the @whiskeysockets/baileys library); for Signal, the signal-cli-rest-api service is used in json-rpc mode, connecting over WebSocket to receive receipts.
Sending probes: the tracker sends probes to the target number. Two methods:
- Delete (default): sends a “delete” request for a nonexistent message ID.
- Reaction: sends a reaction emoji to a nonexistent message ID.
- On Signal, the methods are reaction and message (per src/signal-tracker.ts).
RTT measurement: the time between sending the probe and receiving the CLIENT ACK (state 3) is measured as RTT.
Dynamic-threshold classification: a threshold is computed as 90% of the median RTT; values below it indicate active use, above it indicate standby. Measurements are stored in a history, and the median continuously updates to adapt to different network conditions.
Interface: the web UI (React + Tailwind + Recharts) shows real-time measurements, state and pattern detection, with a dropdown to switch the probe method; the CLI mode (WhatsApp only) prints a panel with JID, state, RTT, average (3), median, and threshold.

Verified stack from package.json: backend in TypeScript 5 + Express 5 + socket.io + pino (logging) + ws; WhatsApp via @whiskeysockets/baileys (^7.0.0-rc.9); Signal via the bbernhard/signal-cli-rest-api service; frontend in React 18 with Tailwind CSS; packaged with Docker Compose (three services: backend, client, and signal-api). Languages reported by the API: TypeScript (105,143 bytes), HTML (1,721), Dockerfile (1,529), CSS (1,043), and JavaScript (246).

Project structure (per the README):

device-activity-tracker/
├── src/
│   ├── tracker.ts         # WhatsApp RTT logic
│   ├── signal-tracker.ts  # Signal RTT logic
│   ├── server.ts          # API server (both platforms)
│   └── index.ts           # CLI interface
├── client/                # React web interface
└── package.json

Official and semi-official status

It isn’t a marketplace listing or a product: it’s a self-hosted PoC with no package published to any registry (package.json declares private: true, so there’s no npm/PyPI/crates.io/Docker Hub version of the project itself).
Its “endorsement” is academic, not commercial: credibility comes from the underlying paper — a work with a Best Paper Award at RAID 2025 — that this implementation executes. In practice this makes the repository a community reference for the “Careless Whisper” attack, though there’s no record of WhatsApp or Signal officially acknowledging it or any vendor “certifying” it.
No formal designation from the platforms: the README states that, as of December 2025, the vulnerability “remains exploitable in WhatsApp and Signal”; there’s no trace of a public patch or an official statement from the companies in the sources consulted.
Ethical/semi-official framework: the MIT license adds disclaimers absolving the authors of misuse, recommending responsible vulnerability disclosure, and discouraging unauthorized spying. This isn’t a status, but it conditions how the project should be read.

The ecosystem

Ecosystem dependencies it’s built on

Repository	Stars (GitHub API, Sep 1, 2026)	Function
`WhiskeySockets/Baileys`	10,950 (3,347 forks)	“Socket-based TS/JavaScript API for WhatsApp Web”; the foundation the PoC uses to talk to WhatsApp without the official app.
`bbernhard/signal-cli-rest-api`	2,821	“Dockerized Signal Messenger REST API”; the service the PoC uses to send probes to Signal and receive receipts.

Independent reimplementations of the “Careless Whisper” attack

A GitHub repository search returned several unrelated PoCs replicating the same attack (the closest real “competitors”). Star counts as retrieved in this run:

Repository	Stars	Verifiable difference
`ctrlsam/careless-whisper-python`	17	“Monitoring users via Silent Delivery Receipts Exploit (WhatsApp and Signal)” in Python.
`Ti-03/Careless-Whisper`	14	“real-time surveillance tool leverages WhatsApp RTT” — real-time surveillance focus.
`190-785/WhatsApp-Careless-Whisper`	6	“Go-based RTT probe tool for WhatsApp, replicating the Careless Whisper.”
`milouk/whatsapp-tracker`	6	“Whatsapp side-channel attack and monitoring tool based on the Careless [Whisper].”
`xalaetrx/Whatsapp-Tracker`	4	“research POC for WhatsApp OS fingerprinting and presence monitoring” — adds OS fingerprinting.
`moltrus/careless-whisper`	0	“PoC to track any WhatsApp phone number based on delivery receipts + [RTT].”
`Ionete-Andrei/careless-whisper-survey`	0	“A technical survey of the Careless Whisper attack (Gegenhuber et al.)” — a technical survey, not a PoC.
`tr4m0ryp/wa-activity-collector`	0	“WhatsApp RTT side-channel tracker (Careless Whisper / RAID 2025)” with logging.

Forks of the repository itself

The API listed a total of 699 forks, most with no stars. The few with stars registered: guberm/device-activity-tracker (8), mwakidenis/device-activity-tracker (5), imanbarati/device-activity-tracker (1), HiS515HAM/device-activity-tracker (1), and mikebodojr/device-activity-tracker (1). No non-English translation was detected among the forks; the issue history does show a PR (#48, “Translation pipeline for internationalization of the repo,” closed) that attempted to add internationalization.

Other projects by the author

The gommzystudio account has 27 public repositories, none directly related to messaging security (notable ones are AldiTalk-True-Unlimited with 55 stars and BambuStudio with 2). The author is, therefore, a generalist developer; this PoC is by far their most visible project.

These figures come from the GitHub API and repository searches during this research; they are not an audit of quality, support, or compatibility of each derivative.

Repo numbers

Measured: September 1, 2026, GitHub API.

Metric	Value
Stars	5,107
Forks	699
Subscribers	64
Open issues per the API	33
Primary language	TypeScript
License	MIT (with additional disclaimers)
Created	December 7, 2025
Last push	December 31, 2025
Last metadata update	September 1, 2026
Releases	None published (empty endpoint)
Repo size	374 KB

Top contributors returned by the API, by contribution count: gommzystudio (37), robcerda (2), and several with 1 (AjayAntoIsDev, verynewusername, JathinYadav, onem0). Activity is heavily concentrated in the author.

API caveats: open_issues_count (33) includes open pull requests, so it shouldn’t be read as an issues-only count. The general response’s watchers_count field mirrors the star count (5,107); that’s why subscribers_count (64) is reported separately as real subscribers. No releases were published, so the version is tracked in code (1.0.0 in package.json) rather than via tags.

How to contribute

CONTRIBUTING.md documents a standard flow:

Fork the repository and clone it.
Create a branch: git checkout -b feature/my-change.
Install dependencies: npm install (and cd client && npm install && cd ..).
Make the changes.
Open a pull request with a short description and motivation.

Documented guidelines: keep PRs small and focused, prefer TypeScript and follow the existing style, don’t commit authentication/session data or secrets, and respect the README’s ethical/legal notes (research and education only). No specific test/evaluation harness was found; the issue history shows community PRs following this flow (for example, #88 “fix: WhatsApp QR code not loading in web UI,” #66/#61 “Fix Recharts Tooltip labelFormatter TypeScript error,” #49 “feat: Implement Smart Adaptive Prediction using K-Means,” #53 “Refactor/separate frontend from backend,” #56 “Add api port env var”).

Community reception

The repository has little traction on Hacker News by itself, but the paper it implements did generate debate. Verifiable submissions:

About the paper (arXiv 2411.11194):

46085197 “Exploiting silent delivery receipts to monitor users on instant messengers” — 20 points, 4 comments (November 29, 2025). Specific comments:
- rzl: “This has been making the rounds in privacy-focused forums and whatnot and still no comment from the foundation. That doesn’t inspire a lot of confidence in the Signal Foundation. If nothing else, I would expect that sending delivery receipts to invalid messages be considered a bug to fix…”
- Stefan-H (reply to rzl): “An attacker with a privileged position on the network allowing them to eavesdrop (but not decrypt) traffic could use a bug like this to identify the device on the network associated with a phone number in Signal. Given nation state level adversaries, that seems like a significant privacy issue to me.”
- 8cvor6j844qw_d6 linked a related read about FBI tactics (Press Herald).
Other paper submissions with little traction: 46034272 (5 points, 0 comments), 46466372 (3 points, 0 comments).

About the repository specifically (all with 0 comments):

46220607 “Device Activity Tracker: WhatsApp Activity Tracker via RTT Analysis” — 1 point (December 10, 2025).
46422304 “Exploiting Silent Delivery Receipts to Monitor Users on WhatsApp/Signal” — 1 point (December 29, 2025).
46443724 “Exploiting Silent Delivery Receipts to Monitor Users on Instant Messengers” — 3 points (December 31, 2025).

Recurring issues (GitHub): the issue thread shows one concrete, measurable complaint that repeats:

WhatsApp QR doesn’t show, but Signal’s does: #52 “Signal QR code is working, but WhatsApp’s doesn’t,” #74 “Follow up (WA not working)” (“signal works and i successfully connected… but qr code for whatsup doesn’t show up… In CLI version it just says qr:undefined”), #67 “QR code is not generating anymore for whatsapp since last 4 hours,” and #64 “Verification Failed.”
Client build failure: #68 “Client Build Failed both through docker and npm” with the error TS2322: Type '(t: number) => string' is not assignable… (a Recharts tooltip typing issue, also addressed in #69 and PRs #66/#61).
Signal QR not visible: #54 “Signal QR Code Not Showing On port 3000” (the user copies .env.sample to .env, runs docker compose up -d/--build, accesses localhost:3000 but the Signal QR doesn’t show and localhost:8080 returns 404).
Several issues with no useful content (e.g., #79 “Fff,” #62 and #60 with just phone numbers) and some with clear spam/no-signal character (PR #85 “Rename README.md to 0812-9328-1098,” PR #79/#87/#86 “Create SECURITY.md”).

Video (YouTube search, September 1, 2026): titles clearly tied to the topic were found; they’re listed without view/channel counts since those couldn’t be reliably captured: “Explorando Vulnerabilidades de Privacidade no WhatsApp: Device Activity Tracker na prática” (Portuguese, explicitly about this repo) and “Track Anyone On WhatsApp | WhatsApp Tracker | Real Time Tracing” (a generic title, not confirmed to be about this exact repo). The rest of the search results were commercial “WhatsApp tracking” apps unrelated to this project.

No verifiable evidence was found on Reddit (the site returned unparseable content), X/Twitter (blocked), or Product Hunt; therefore no metrics from those platforms are claimed.

device-activity-tracker versus other proposals

Project	Stars (GitHub API, Sep 1, 2026)	Verifiable difference
`ctrlsam/careless-whisper-python` (17)	Reimplementation of the same attack.	Written in Python; this PoC is TypeScript with a React web UI + CLI, and supports Signal natively.
`Ti-03/Careless-Whisper` (14)	Another PoC of the same attack.	Framed as a “real-time surveillance tool”; different stack, no web layer like this one.
`190-785/WhatsApp-Careless-Whisper` (6)	RTT probe for WhatsApp.	Written in Go and limited to WhatsApp; this one also supports Signal.
`milouk/whatsapp-tracker` (6)	“Side-channel attack and monitoring tool based on Careless Whisper.”	WhatsApp-focused; different stack.
`xalaetrx/Whatsapp-Tracker` (4)	OS fingerprinting and presence PoC.	Adds OS fingerprinting as an explicit target; this repo’s README only mentions it as a possible inference.
`Ionete-Andrei/careless-whisper-survey` (0)	Not a PoC.	It’s a technical survey of the attack; useful as background reference, not as a tool.

The most useful comparison isn’t popularity: this repo stands out because it combines both platforms (WhatsApp and Signal) in a single web app + CLI over the ecosystem’s two mature dependencies (Baileys and signal-cli-rest-api). Other PoCs tend to limit themselves to WhatsApp or a single language. Its practical downside is operational immaturity (the WhatsApp QR and client build issues recur) and the lack of formal releases/versioning.

Quick-start guide

Warning: the README and license strictly declare this for research and education. Using it to track people without consent may violate privacy, wiretapping, and computer-fraud laws.

Installation and first boot

Prerequisites: Node.js 20+, npm, and a WhatsApp account (and, for Signal, the signal-cli-rest-api service, already included in docker-compose.yml).

git clone https://github.com/gommzystudio/device-activity-tracker.git
cd device-activity-tracker
npm install
cd client && npm install && cd ..

Docker option (recommended by the README):

cp .env.example .env
docker compose up --build

On startup, the app is available at:

Frontend: http://localhost:3000 (or the configured CLIENT_PORT).
Backend: http://localhost:3001 (or BACKEND_PORT).

To stop: docker compose down.

Manual setup (without Docker):

# Terminal 1: backend
npm run start:server
# Terminal 2: frontend
npm run start:client

Open http://localhost:3000, scan the QR code with WhatsApp, and then enter the number to track (e.g., 491701234567).

CLI (WhatsApp only):

npm start

Follow the prompts to authenticate and enter the target number. The result is printed in the terminal as a panel with JID, state, RTT, average (3), median, and threshold (the README shows an example with “Standby” state and RTT 1104 ms).

Common workflows

Track a number’s state on the web: start the app → scan the WhatsApp QR → type the target number → the interface shows real-time RTT, state (🟢/🟡/🔴), and the activity pattern; the result updates live in the UI (React + Recharts).
Switch the probe method: on the web interface, use the control panel’s dropdown to toggle between Delete (default) and Reaction; the CLI mode uses “delete” by default.
Track via Signal: with Docker, the signal-api service (bbernhard/signal-cli-rest-api) already runs; on the web, select Signal and scan its QR. The available probe methods for Signal are reaction and message.
Track from the terminal (WhatsApp): npm start → authenticate → enter the number → watch the status panel in the console.

Essential configuration

Per .env.example and the README, what a new user touches first:

BACKEND_PORT (default 3001) — the backend server’s port.
CLIENT_PORT (default 3000) — the web interface’s port.
SIGNAL_API_URL (default http://localhost:8080) — the URL of the Signal API service, required for Signal tracking.
BACKEND_URL (default http://localhost:3001) — the backend URL the frontend consumes.
NODE_ENV (default production) — Node’s runtime environment.

Common pitfalls and fixes

Per the README, issues, and community threads:

Doesn’t connect to WhatsApp: the documented fix in the README is deleting the auth_info_baileys/ folder and re-scanning the QR. (Note: the docker-compose.yml volume is mounted as baileys_auth:/app/baileys_auth_info, with a slightly different name; worth checking the actual container path if state persists across restarts.)
WhatsApp QR doesn’t show but Signal’s does (issues #52, #67, #74, #64): this is the most reported failure. The README doesn’t fix it directly; there are open correction PRs (e.g., #88 “fix: WhatsApp QR code not loading in web UI”). In practice, updating to the latest branch and regenerating the auth state are the usual steps.
Client build failure (TS2322 on Recharts tooltip) (#68, #69, PR #66/#61): the error Type '(t: number) => string' is not assignable… blocks npm run build both via Docker and npm. It was fixed in labelFormatter typing PRs; if it appears, apply that fix or use an already-fixed client version.
Signal QR not visible and localhost:8080 returning 404 (#54): indicates the signal-api service isn’t ready or doesn’t expose the expected endpoint; verify the signal-api container started and that SIGNAL_API_URL points to the correct port.
Disabling read receipts does NOT protect you: the README clarifies this mitigation applies to normal messages but not to this specific attack; the suggested more effective mitigation is enabling “Block unknown account messages” in WhatsApp (Settings → Privacy → Advanced), though WhatsApp doesn’t publish what it considers “high volume,” so it doesn’t fully prevent probes before the rate limit.
Non-obvious threshold behavior: classification depends on the moving median; on unstable networks the threshold recalculates continuously, so a “Standby” doesn’t necessarily mean the device is off, only that RTT exceeded 90% of the median.

Integrations and migration

With Baileys (WhatsApp Web): the PoC relies on @whiskeysockets/baileys for all WhatsApp communication; any WhatsApp Web integration via Baileys reuses the same session pattern (QR + local state).
With signal-cli-rest-api (Signal): Signal tracking requires that service (json-rpc mode, WebSocket); it’s an external dependency running as a separate container.
With Docker Compose: the three services (backend, client, signal-api) are orchestrated together; the backend persists WhatsApp’s auth state in the baileys_auth volume.
Migration between PoCs of the same attack: since all of them (ctrlsam/careless-whisper-python, 190-785/WhatsApp-Careless-Whisper, Ti-03/Careless-Whisper, etc.) implement the same principle (receipt RTT), “migrating” amounts to switching language/stack (TypeScript → Python/Go) and dependency (Baileys for WhatsApp); the median-based threshold logic is common to the paper’s approach. No documented converter exists between them.

Use cases and who this repository can help

Security and privacy researchers who need a runnable implementation of the “Careless Whisper” paper: the PoC translates the RAID 2025 work into ready-to-test code (with the paper’s BibTeX citation), useful for reproducing, validating, or extending the attack in a controlled, consensual environment.
Teams auditing or wanting to audit the side-channel surface of their messaging flows: by showing how a delivery receipt RTT reveals presence/activity, it serves as a reference for understanding what metadata (status, network, usage frequency) can leak in messaging apps.
Security educators and communicators: the explicit “research and educational purposes only” disclaimer, the “How to Protect Yourself” section, and the three states (online/standby/offline) make it suitable teaching material for explaining privacy vulnerabilities with a concrete case.
Users who want to understand how to protect themselves: the README documents concrete mitigations (enabling “Block unknown account messages” in WhatsApp; understanding that disabling read receipts isn’t enough), so a person can use the tool to check their own exposure and then apply defenses.
Developers working with Baileys or signal-cli-rest-api: the web app + CLI + Docker Compose shows a practical pattern for combining both dependencies (WhatsApp session via QR through Baileys and Signal receipts via WebSocket) in a single Express + socket.io backend.

Resources

Repository: https://github.com/gommzystudio/device-activity-tracker
Academic paper (source): Careless Whisper, arXiv:2411.11194 — RAID 2025, Best Paper Award
Core dependencies: WhiskeySockets/Baileys (WhatsApp Web) · bbernhard/signal-cli-rest-api (Signal)
Community / discussion: GitHub Issues (https://github.com/gommzystudio/device-activity-tracker/issues) and GitHub Discussions (https://github.com/gommzystudio/device-activity-tracker/discussions)
Hacker News threads (repo): 46220607 (1 pt) · 46422304 (1 pt) · 46443724 (3 pts)
Hacker News thread (paper, 20 pts, 4 cmts): 46085197
Independent reimplementations: ctrlsam/careless-whisper-python (17★) · Ti-03/Careless-Whisper (14★) · 190-785/WhatsApp-Careless-Whisper (6★) · milouk/whatsapp-tracker (6★) · xalaetrx/Whatsapp-Tracker (4★)
Video: “Explorando Vulnerabilidades de Privacidade no WhatsApp: Device Activity Tracker na prática” (Portuguese, about this repo) and “Track Anyone On WhatsApp | WhatsApp Tracker | Real Time Tracing” (titles found via YouTube search on September 1, 2026; no view/channel counts captured)
Package registries: the project isn’t published to any registry (private: true in package.json); the dependencies themselves are available (Baileys on npm, signal-cli-rest-api as a Docker image)
Star History (embedded in the README): https://www.star-history.com/#gommzystudio/device-activity-tracker&type=date&legend=top-left

Methodology note: this article draws on the repository’s README, CONTRIBUTING.md, LICENSE, package.json, .env.example, and docker-compose.yml, the arXiv paper page (2411.11194), the GitHub API (repository, contributors, forks, repository search), the dependencies’ profiles, and Hacker News threads consulted on September 1, 2026. Figures change over time. Sources on Reddit, X/Twitter, and Product Hunt, as well as YouTube view/channel counts, could not be verified during this research; those platforms are expressly left unclaimed. The project declares itself for research and education purposes only.