In case of video embed fail: https://vimeo.com/1244884865/3b1b289117

Inspiration

We all click "Accept all" on cookie banners a dozen times a day without reading them. Cookie fatigue is real, and it hides a bigger problem: none of us actually knows what our apps are saying to each other. You look at a pair of shoes in one app and an ad for them shows up in another an hour later. It feels like magic, but it is just traffic: requests your apps send to companies you have never heard of.

We wanted to see that traffic, in plain language, without handing it to yet another company. The name comes from doppelganger: the copy of you that companies assemble from your data. Doppel shows you that copy and keeps it on your own machine.

What it does

Doppel runs on your computer and records what each app sends to third parties. When you open it, it tells you, since you last looked:

  • Who received what. Each request is matched to the company behind it, and flagged for tracking IDs, the page you were on, device fingerprinting, and sensitive data inside the request itself: health, finance, personal details, precise location, and more. This is flagged by your local AI.
  • How risky it was. Every request gets a 0 to 100 score from plain rules, with a breakdown you can click. Processed by the analyzer.
  • What you can do about it. Block a company, strip its IDs, open its opt-out page, or generate a data-access request letter.

A Privacy screen runs live checks on your real data to make sure direct payload is never accidentally stored, and an Outgoing calls screen lists every byte Doppel itself has ever sent.

Our app is built around privacy: everything is local, direct data is removed after analysis, the app uses 30-day local certificate, database is encrypted with the key in credential manager, your search history and system traffic is ignored, so even if it's compromised, the attacker won't find anything.

How we built it

Doppel has three parts that never talk over a network port.

  1. Recorder. A Python addon for mitmproxy's local capture mode. It tags every connection with the app that opened it and decides, before decrypting, whether to look inside: per app you choose track, metadata only, or don't track. A sanitizer then drops cookies, login headers, passwords, search queries and DNS lookups, and replaces identifiers with keyed hashes (HMAC-SHA256), so the log can match an ID across sites without ever storing it in plaintext. Rows go into a SQLCipher-encrypted database whose key lives only in Windows Credential Manager.
  2. Analyzer. A Python process the app starts, takes the sanitized data and it identifies the company, looks for sensitive data types or high-concern privacy policies, scores each request, and then deletes the raw content.
  3. App. Electron and React in TypeScript, sandboxed with a strict content security policy and no network access of its own.

Scoring is deliberately not AI. Each signal adds points (third party +10, advertising +20, cross-site ID +25, sensitive data +30, and so on), and a sensitive topic or sensitive data multiplies the total:

$$\text{score} = \min\left(100,\ m \sum_i p_i\right), \qquad m = \begin{cases} 1.5 & \text{sensitive context} \ 1 & \text{otherwise} \end{cases}$$

The score maps to four tiers by their purpose: Minimum utility (low risk) (0 to 19), Measurement (medium) (20 to 49), Profile building (high) (50 to 79), and High concern (severe risk) (80 to 100).

A local model (qwen2.5 in Ollama) labels page topics and acts as a fallback when our rules can't place a payload. It has to answer from a fixed list of categories, or we ignore it. Its answers are cached by the payload's shape, with IDs, emails and numbers blanked, so the same event with a new ID is one model call, and IDs never reach the model.

Our company research uses Tavily and Exa to pull privacy policies, data-broker registrations and enforcement news. Every request goes through a single egress gate that only allows HTTPS to those two hosts, and is written to a hash-chained ledger before it is sent. The only thing that leaves is a company name.

Challenges we ran into

  • A privacy tool built on a man-in-the-middle. Reading app traffic means decrypting it, which is exactly what a privacy tool should be wary of. We spent the most time here: decide before decrypting, strip secrets in memory, encrypt what's stored, delete raw content after analysis, use a 30-day certificate whose key never touches disk, and always verify real websites' certificates. The user gets to decide which apps they allow the recorder to track, and for how long each session.
  • Installing without admin rights. Task Scheduler refused to create the login task on a student laptop. We fall back to the user's own Run registry key and install the certificate only in the user's store.
  • Categorizing payload info without compromising security. Our first version tagged a request as sensitive based on the page it came from. A Criteo pixel on healthline.com counted as “health”, but we never looked inside the request itself. So a fitness app sending your heart rate from a neutral-looking screen would have slipped through. We added data-type detection inside request bodies: health, location, contacts and similar. Where rules couldn’t decide, we asked the local AI. The catch was that a model reading payloads could see your IDs. So we strip identifiers before anything reaches it, and we cache answers by the payload’s shape rather than its contents.

Accomplishments that we're proud of

We built a product that we would actually use. Before turning on Doppel, we didn't realize how many traffic actually happened when we clicked on websites, especially how much data is being sent to ad companies. The computer sends hundreds of requests every minute, and being able to see those transparently is a huge source of satisfaction. We believe our app would help users feel more secure and in control of their system, and potentially help protect the privacy of stakeholder with sensitive/privacy required positions.

What we learned

  • Collecting less beats protecting more. Hashing at capture and deleting after analysis removed whole classes of risk we would otherwise have had to defend.
  • A privacy claim should be a test. Writing the checks changed how we designed features: if we couldn't verify something on screen, we questioned whether we were doing it right.
  • Rules for decisions, AI for gaps. Explainable rules are faster, testable and arguable. The model earns its place only where rules can't reach, and only with constrained output.

What's next for Doppel

  • Adding a more fine-grained auditing methodology to preserve user privacy (we started on this, but we ran out of time before we could add more scoped permissions)
  • A larger tracker map built from DuckDuckGo Tracker Radar (ours has 117 domains today), and scores checked against hand-labelled requests.
  • OS specific testing
  • Optimization to reduce data processing time for large amounts of requests within a short period

Built With

Share this project:

Updates

Submission history