November 16, 2026
OPSEC and False Trails
Introduction

By solvnox
10 min read
Introduction
OPSEC (Operational Security) is usually associated with hiding information. Don't publish unnecessary personal details, keep accounts separate, hide your real IP address, remove file metadata, and don't use the same username across ten different platforms. These are the basics, but there's another approach. Sometimes information isn't hidden at all. Instead, it's deliberately left behind in a way that leads an investigator to the wrong conclusion.
That's where false trails come in. They don't make someone anonymous on their own, and they won't fix poor OPSEC. Their purpose is different. If some information is going to remain public anyway, you can make it harder to interpret correctly.
The most convincing false trail usually doesn't look like a made-up identity. If someone openly claims their name is Alexander, they live in Moscow, and they work as a programmer, nobody is required to believe them. But an email address accidentally discovered in an old GitHub commit, a previous username on a forgotten forum, or an author's name embedded in a published document is a different story. The investigator found that information independently, which makes it feel much more credible.
NIST documentation discusses similar methods as part of defensive deception. These can include fake accounts, fabricated data, and other decoys designed to give an observer the wrong impression of a system. The principle is similar in personal OPSEC, although the goals and scale are completely different.
A False Trail Needs to Be Believable
Suppose an investigator finds an old GitHub commit containing:
Захар <zaharivanovaleeksai@gmail.com>
For an investigator, that's already a useful lead. The email address can be checked through search engines, old data breaches, forums, and other platforms. The name can be compared against public profiles, and any accounts that turn up can be investigated further.
But the presence of that line proves only one thing: that particular email address was recorded in the commit metadata. It doesn't prove the address is the developer's primary email, that the name is real, or that profiles found through that email actually belong to the same person.
That's the distinction good false trails are built around. You don't necessarily have to fake the evidence itself. The email address really exists, the commit is genuine, and the information is exactly where the investigator found it. What's false is the conclusion drawn from that evidence.
This works particularly well against automated or superficial OSINT investigations. One tool finds an email address, another service discovers a username associated with it, and a search engine returns a few pages. Suddenly, the report contains a neat chain of connections, even though the very first link was a decoy from the start.
But a single trail like that won't be enough against a proper investigation. Any serious attribution requires independent confirmation.
Multiple Layers of a False Identity
Imagine a more complicated situation. An investigator discovers an identity that looks obviously suspicious. There's barely any history, the information contradicts itself, and some of the traces look deliberately planted.
The investigator realizes it's a decoy and keeps digging.
After a while, another identity turns up. This one has a Gmail address, an old Telegram account, a history of usernames, a GitHub profile, several forum registrations, and years of activity. Some of the details match the person being investigated. This version looks much more convincing.
This is where an interesting psychological effect comes into play. After uncovering the first deception, the investigator may start trusting the second version more. They assume they've already found the fake layer and have finally reached the real identity.
But the second layer could be fake too.
This setup is much more complicated than simply creating a fake email address. The longer an identity exists, the more information has to remain consistent. Activity times, language, interests, services used, old photographs, accounts, and even personal habits gradually form a digital profile of their own.
One mistake can connect that profile to the real identity.
That's why the complexity of maintaining false trails grows so quickly. Creating five email addresses is easy. Maintaining five independent digital histories for several years is a completely different challenge.
Real Data Can Create a False Trail Too
False information doesn't necessarily have to be made up.
For example, someone regularly uses a server in Germany. The IP address really is German. The server really belongs to a German data center. The mistake only happens when someone concludes that the person using it must be physically located in Germany.
The same applies to system language, time zones, email addresses, domains, and VPNs. All these indicators can be genuine, but their connection to an actual person remains a hypothesis.
That's why a good investigator tries to separate facts from interpretations.
"The IP address belongs to a server in the Netherlands" is an observation.
"The person lives in the Netherlands" is a conclusion.
There's a huge gap between the two.
For OPSEC, this is useful because you don't always need to invent an entire biography. Sometimes it's enough to prevent several genuine indicators from coming together into one obvious picture.
False Trails Won't Fix a Real OPSEC Failure
This is the biggest limitation of the whole approach.
Suppose someone creates several fake email addresses, uses different names, and deliberately leaves conflicting information about their location. At the same time, their main account and anonymous account use the same cryptocurrency wallet or another persistent public identifier.
A dozen weak false trails won't erase one strong, genuine connection.
That's why proper separation of environments comes first. Different tasks may require separate browser profiles, separate accounts, and independent connection methods. In Granger Browser, for example, isolated spaces can be used alongside separate routing through Tor or proxies. This helps prevent cookies, website storage, and network contexts from being mixed between different tasks.
But the browser only handles the technical side. If the user manually reuses the same username, photograph, or another unique identifier across two identities, browser isolation won't undo that connection.
The same goes for VPNs. Mullvad VPN, Proton VPN, or another reliable client can hide your home IP address from the website you're visiting, but a VPN doesn't create a new identity. If you connect and then open your main Telegram, GitHub, and email accounts, those services still know which accounts you're using.
Tor, VPNs, and separate browser profiles should therefore be treated as tools for compartmentalization, not as some kind of anonymity button.
Behavior Leaves Traces Too
The technical side is relatively easy to control. Behavior is much harder.
Imagine two accounts with no obvious technical connection. They use different email addresses, different browser profiles, and different network routes. But both accounts use the same expressions, make the same unusual mistakes, are active at roughly the same times, and regularly go silent simultaneously.
Each individual indicator is weak. Matching activity times prove nothing on their own. Neither does using the same word. But when enough of these similarities start piling up, there's at least a reason to investigate whether the accounts might be connected.
The same problem applies to false identities. If someone creates them all using the same template, the creation process itself becomes a fingerprint.
Suppose every fabricated identity uses similar Gmail addresses, the same username style, the same services, and similarly structured biographies. An investigator might stop treating each identity separately and start looking for signs of a common creator instead.
At that point, false trails aren't increasing uncertainty. They're creating a new way to correlate the accounts.
Geography Is Particularly Weak Evidence
One of the most common mistakes in location investigations is treating several technical indicators pointing to the same country as proof that the person is actually there.
In reality, an IP address might belong to a VPN or Tor exit node, time zones can be changed, system language says very little about someone's physical location, and a server might be hosted on an entirely different continent.
Even an ordinary VPN can easily produce a completely genuine technical trace pointing to another country. The website really does see an IP address from that region. The geolocation database really does identify it as belonging there. Nothing on the website's side has been falsified.
The mistake comes afterward, when an investigator assumes the user must be physically located in that region.
That's why independent corroboration matters much more than individual indicators. If the only evidence pointing to a country is an IP address, confidence should remain low. If years of activity patterns, local services, and other historical indicators independently point to the same region, the hypothesis becomes more interesting.
Don't Build a False Identity Around a Real Person
There's another line that's better not crossed at all.
Deliberately creating a trail that points to a specific, unrelated person is a bad idea. If you use their real name, photograph, existing email address, or other identifiers, the consequences of false attribution fall on someone who has nothing to do with your activities.
Keep in mind the relevant legislation, including Article 128.1 of the Russian Criminal Code and Article 73–3 in Kazakhstan.
You don't even need to do this to create a false trail.
If the goal is to increase uncertainty, fictional details or accounts you control yourself are enough. They can appear believable without pointing to an actual, unrelated person.
Tools That Complement OPSEC
False trails only make sense when genuine connections have already been minimized. If two identities share cookies, use the same password, or constantly operate through the same network context, no invented persona is going to fix that.
The tools discussed here are therefore primarily about separating contexts and controlling the traces you leave behind.
Granger Browser
https://github.com/watsoncore/GrangerBrowser
Granger Browser can be used as a separate environment for working with different contexts. The browser supports Tor, bridges, proxies, and isolated spaces, along with separate controls for WebRTC, Canvas, WebGL, cookies, and other components that can create additional digital traces.
For this article, the isolated spaces are the most interesting feature. A research profile and a separate digital identity shouldn't share the same browsing history, cookies, or website storage. Their network routes can also be kept separate from regular browsing.
But there's an important principle here. Creating ten isolated spaces doesn't automatically create ten independent identities. If the user signs into the same Gmail account or carries identical identifiers between them, much of that technical isolation loses its purpose.
Mullvad VPN
When Tor isn't necessary, a separate VPN client can keep your home IP address hidden from websites and separate your regular connection from a particular working environment.
Mullvad provides a dedicated system client using WireGuard, leak protection, and network restrictions. On desktop operating systems, the client integrates with the system firewall to route traffic through the VPN tunnel.
When it comes to false trails, it's especially important not to read too much into a VPN's geographic location. Connecting to a server in Sweden really will give the website a Swedish IP address, but that doesn't make the user Swedish. Weak location attribution often comes down to exactly this kind of interpretation error.
On the other hand, if two identities repeatedly appear from the same uncommon IP address, that's another possible correlation point.
A VPN doesn't solve every OPSEC problem, but it does give you control over one of the most obvious network indicators.
KeePassXC
A password manager might seem like an unexpected tool here, but when you're working with multiple digital contexts, it solves a very practical problem.
Each identity gradually accumulates its own email addresses, passwords, usernames, recovery codes, and notes. If you try to keep all of that in your head, you'll eventually start reusing passwords, mixing up accounts, or signing into the wrong profile.
KeePassXC stores its database locally in encrypted form and doesn't require its own cloud service.
Instead of keeping everything in one massive mess, you can organize entries by context. For example, you can store credentials for a public project, research accounts, and ordinary personal services separately.
That doesn't provide isolation by itself, but it significantly reduces the chance of human error.
There's also an interesting connection to false trails here. If someone creates several Gmail addresses and, a year later, can no longer remember which one was a decoy and which was used for a real registration, the whole setup starts working against them.
Keeping proper records is part of OPSEC too.
MAT2
https://0xacab.org/jvoisin/mat2
MAT2 is designed to remove metadata from files before they're published.
Rather than manually inspecting individual EXIF fields, the idea is simpler: take an existing file and create a cleaned copy with supported hidden metadata removed.
It doesn't just work with photographs. It supports PDFs, office documents, images, audio files, archives, and several other formats.
For OPSEC, this is more useful than manually searching for GPS coordinates or a phone model. A document can contain an author's name, software information, creation timestamps, editing history, and other details the user might never have thought about.
This becomes particularly important when separating digital identities. You could keep accounts and network routes perfectly isolated, then upload documents from both profiles that were created on the same system and contain identical metadata.
The files themselves would then create another point of correlation.
VeraCrypt
Not all OPSEC happens online.
Over time, your storage devices accumulate information that was never meant to become public: password databases, notes, original photographs, documents, backups, account lists, and research materials.
VeraCrypt allows you to create encrypted volumes and encrypt entire partitions or devices. Inside an encrypted volume, both the file contents and the internal filesystem structure are encrypted.
For our topic, this matters for another reason.
If false identities are documented, the details of how they're organized become sensitive information themselves.
A notes file containing entries like "this email is used as a false trail" or "this account belongs to another identity" could compromise the entire setup much faster than any OSINT investigation.
It makes more sense to keep that kind of information separate from ordinary documents.
OnionShare
File sharing creates its own category of digital traces. Cloud storage, public download links, and file-sharing accounts can introduce additional connections between a sender and their infrastructure.
OnionShare approaches this differently. It runs a service directly on the user's device and makes it accessible through an onion address.
It can be used to send and receive files, host a temporary website, or run a chat.
From an OPSEC perspective, the interesting part is that you don't need to create yet another account with a conventional file-sharing provider.
But OnionShare doesn't eliminate the need to inspect the files themselves.
If you send a photograph containing GPS metadata through Tor, the transport may be protected, but the photograph can still reveal more than you intended.
Different Tools Should Cover Different Layers
In the end, you're not dealing with one universal anonymity toolkit, but several independent layers.
Granger Browser (https://github.com/zakhar-git/Granger-Browser) separates browser contexts and network routing.
Mullvad VPN controls the external network route when Tor isn't being used.
KeePassXC helps prevent credentials from different contexts from getting mixed together.
VeraCrypt protects local files and materials.
OnionShare allows file transfers without requiring another account with a conventional file-sharing service.
None of these tools creates good OPSEC on its own.
That's actually a useful way to judge software in this category. If an application promises complete anonymity with a single click, you should be skeptical of that claim.
This is especially important when dealing with false trails. First, reduce the number of genuine connections. Only then does it make sense to think about making the remaining traces harder to interpret.
P.S. This material is published strictly for educational and research purposes. The methods involving false trails described here may be regulated by the laws of your country, particularly when they involve another person's identity, documents, fraud, or deliberately misleading third parties. Before applying any of these methods, consider local legislation and don't use real people's personal information without their consent. The author does not encourage the use of these approaches for unlawful activities.
Conclusion
False trails don't replace OPSEC, and they won't fix connections that already exist. They only become useful once real digital identities, devices, and network contexts have been properly separated.
A good false trail doesn't necessarily have to convince an investigator that a particular invented identity is real. Sometimes it's enough to make the available evidence insufficient for confident attribution.
More materials on OSINT, CyberSec, and privacy are available in my personal archive.
To get access, message me directly: @solvnox.
Our Telegram channel: @solvnox_project.
MM: Zakhar Alexey (@solvnox)