Zero Data Retention Failed: What 2 Million Canary Prompts Reveal About Where Your AI Prompts Really Go

The CyberSec Guru

Zero Data Retention Failed

If you like this post, then please share it:

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Why your support matters: Zero paywalls: Keep the main content 100% free for learners worldwide.

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

The short version: your privacy flag stops at the first hop

On November 22, OpenRouter told its customers that it had off-boarded three inference providers, pulled 125 endpoints from Zero Data Retention (ZDR) eligibility, and notified every customer who might have been affected. OpenRouter is the API gateway many developers use to reach dozens of model hosts through a single endpoint. The company said its own investigation found no breach or unauthorized access of OpenRouter itself.

The trigger was a report published three days earlier by HD Moore, the creator of Metasploit and now chief research officer at the industrial cybersecurity firm Dragos. Between July and November 2026, his team seeded roughly two million prompts with unique, trackable secrets and watched where those secrets surfaced. The Dragos report found that prompts are routinely copied, logged, forwarded, and read by parties the customer never chose. In at least three cases attackers were already sitting inside the provider’s infrastructure, and the provider learned about it only when the researchers called.

Key takeaways:

  • Three inference hosting providers were being actively robbed of customer data, and none of them knew until Dragos showed them evidence. The earliest intrusion dates to mid-July.
  • Some of the stolen requests carried a Zero Data Retention flag. A retention setting means nothing once an attacker controls the machine that reads the plaintext.
  • A marketplace seller can log every request on purpose, and cheap listings make that profitable.
  • A Chinese AI lab’s scraper fetched secret URLs from more than half of the prompts sent to its models, including about two-thirds of the requests marked as no-data-collection or ZDR.
  • The stolen AWS keys were used within hours, for tens of thousands of API calls, and one key was still being used three weeks after it was planted.
  • If your requests went through the exposure windows listed later in this post, rotate every secret that was inside them today.

Why your prompt is a data object, not a throwaway input

Most developers picture a prompt as something that exists for the length of a forward pass through a transformer and then disappears. Commercial inference does not work that way. A prompt can be retained for abuse monitoring, debugging, billing, training, or resale, and it can cross several organizational boundaries before a single output token exists. Every hop in the chain, whether router, reseller, inference platform, or model developer, sees the complete prompt and the complete response.

When those hops are assembled through commercial APIs and marketplace pricing, with no contractual trust boundary between them, the question of who can read a prompt has no stable answer. That is a hard thing to argue about in the abstract, which is why the Dragos method matters. A canary secret can be learned in exactly one place. If anything touches it, someone in the inference chain read the prompt that carried it.

This matters more for agents than for chatbots. Agents and pipelines send whatever they can read, and that routinely includes repository files, configuration, connection strings, and keys that were never meant to leave the customer’s environment. An inference provider that ingests that traffic holds a credential firehose, and attackers have noticed.

How the Dragos canary experiment worked

The experiment started in July with Thinkst Canarytokens, the free tripwire service, and grew into something purpose-built. Every seeded request carried three baits that had never existed anywhere else: an AWS access key, a DNS name, and a URL. Because the tokens were unique per prompt, any callback could be tied to the exact request, model, router, and privacy setting that carried it.

Dragos then built its own seeding service. It derives unique hostnames, URLs, and credentials from a per-prompt seed, and it runs the infrastructure those credentials point to: DNS, web, git, SSH, databases, mail, and a long tail of older protocols. The AWS keys were real keys attached to empty accounts with full logging turned on, so the team could see every API call made with a stolen key and not merely whether it worked once.

The instrumentation recorded the resolver a scraper used, how long it took to reply, and the full shape of each inbound connection: TCP details, TLS SNI, HTTP Host headers, requested URLs, and presented credentials. That level of detail is what lets researchers tell a scripted crawler from a person typing at a keyboard. Tokens started firing within days, and the July tokens were still firing when the report was published.

Why unique per-prompt tokens beat generic honeypots

A shared honeypot credential tells you that someone, somewhere, found it. A credential that exists in exactly one request tells you which request, which model, which router, and which privacy setting. Dragos could separate the leak that follows a specific seller from the leak that follows a whole marketplace, and the leak that follows a model developer from the leak that follows a hosting company. That attribution is what turns a scary anecdote into a measurement.

📬 Stay Ahead of Cyber Threats

Get the latest cybersecurity news, critical vulnerabilities, threat intelligence, tutorials, and exclusive giveaways delivered straight to your inbox. No spam. Unsubscribe anytime.

A traceroute for inference: how researchers mapped the hidden hops

Canaries prove that a prompt leaked. They do not say where in the chain it leaked, because a router usually reports a single upstream provider, and that provider is often just another router. To reconstruct the real path, the team built the equivalent of traceroute for inference, using two techniques.

The first was passive. Embed an image URL that points back to Dragos servers, and every system that fetches it reveals an IP address, an HTTP client, and a timestamp.

The second used the way these services stack. By sending small, deliberately malformed requests, the researchers collected error responses in which each router wraps the error from the hop behind it in its own format. One reply can contain three or four nested envelopes. Matching each layer against a signature database produced the list of hops, the software at each one, the network it ran on, and often the company operating it.

Across roughly two thousand traced routes, several hundred included a system the team could not identify, and a handful sent the embedded image to a company that was not on the advertised path at all. The documented examples show how much customers cannot see from an API response:

  • A marketplace request reached Anthropic through an OpenRouter hop that the marketplace had never disclosed.
  • One seller quietly appended about a thousand hidden tokens to every prompt.
  • Another seller fetched images through a shared consumer subscription account.

The hidden tokens are a billing problem and an integrity problem at once. The customer pays for input they never wrote, and the model answers a prompt the customer never saw.

Three inference providers were breached and nobody inside noticed

The most serious finding was also the most direct. Attackers were actively stealing data from three different hosting providers, and none of the three knew about the intrusion until Dragos presented evidence. The earliest incident dates to the middle of July. For roughly four months the researchers’ bait prompts were processed next to real customer traffic, and that traffic was almost certainly copied as well.

The provider behind the July breach first blamed a misconfiguration of internal tooling, then a partner’s data processing. Its own investigation eventually found that attackers had compromised its internal credentials. As of the report’s publication it had still not disclosed the incident publicly, and the stolen data kept driving attempted logins as late as the end of October.

The front-door clue in the largest breach

The largest of the three breaches centered on a couple of hundred planted AWS keys. Each key was sent in exactly one request to one provider, all within a few short windows in late October, and every request sent during those windows was stolen.

The forensic detail that matters most for defenders is that some of the stolen keys came from requests the provider had rejected before any model ran. That places the exfiltration point at the provider’s front door, the ingestion or gateway layer where authentication and routing happen, and puts it ahead of the inference stack. An attacker standing there sees prompts in raw, pre-tokenized form, including any credentials, internal hostnames, or source fragments the customer embedded in the context.

In the other two breaches, some of the stolen requests had been marked Zero Data Retention. Moore’s summary of the lesson is that a privacy flag does not help when the attacker is already inside.

What the attacker did with the stolen AWS keys

Once the attacker held the credentials, the playbook was fast and predictable. Keys were tested for validity, in some cases within hours of the request that carried them. The actor then went looking for data by listing S3 buckets and searching AWS Secrets Manager and Systems Manager Parameter Store. To establish persistence, the actor enabled hosted models in Amazon Bedrock, created Bedrock API keys, and added IAM users.

In total the bait keys drove tens of thousands of AWS API calls. One key seeded on October 21 was first used the next day and was still in use three weeks later.

The tooling changed during the observation window. It began as a script impersonating Chrome on Windows, moved to Boto3 running inside OrbStack, and later switched to the AWS CLI on Kali Linux. One adversary appears to have compromised two of the three providers at once, using secrets from both almost immediately from a single rented server. That points to a coordinated campaign against inference infrastructure as a class, and the three incidents are unlikely to be unrelated.

ARTEX: an LLM-driven pentest framework shows up in the logs

On November 1 the same attacker added ARTEX and used it narrowly, making a handful of calls to confirm that keys already in hand were still live. ARTEX is an open-source, multi-agent offensive platform written in Go with a Next.js console. It was released on GitHub in July 2026 under the pseudonym Autumn-27, and Google Cloud threat intelligence and an FBI advisory have since documented it in real intrusions.

Two of the user-agent strings it sent, artex-agent and artex-judge-r121, appear in no public indicator list that Dragos could locate. That is a small but concrete measure of how far attacker tooling has outrun detection content. Both Kali and ARTEX did announce themselves in the user agent that AWS records in CloudTrail, which is the partial good news. The bad news is that this self-identification showed up in only a small fraction of the traffic.

Logging as a business model: the AI inference marketplace problem

The second finding needed no exploit at all. Sellers on an AI inference marketplace listed popular models at the lowest available price, turned on request logging (a standard feature of inference serving frameworks), and collected whatever flowed through.

The economics make sense for a certain kind of operator. Deep discounts can be funded by pooling requests through unmetered consumer-plan subscriptions, by burning startup credits, or, in the shadier corners, by running inference billed to stolen AWS credentials or consumer API keys. A seller who wants the data can list at the lowest price, route the traffic, absorb the cost, and harvest prompts from the platform logs. Dragos notes that some of these marketplaces accept only cryptocurrency, which is a signal worth weighing.

What stood out in the canary data was how personal the abuse was. These were individuals on what looked like home internet connections and personal computers, working through stolen credentials one login at a time.

  • In one case, two prompts sent through a single seller’s offer were followed about a day and a half later by someone on a home broadband connection. That person opened both secret URLs in a desktop browser and guessed usernames at the login page. Prompts for the same model that went through a different seller were never touched, so the leak followed the seller and not the marketplace as a whole.
  • In another case, an attacker on a Mac with a residential line in France took passwords from two prompts and typed root SSH login attempts by hand, using one password four times in two minutes. The same machine then tested several planted AWS keys in a single session.

Neither of these looks like a sophisticated automation pipeline. It is low-effort monetization of data that the marketplace architecture exposes by default.

The undisclosed router behind the router

Most of the keys that Mac tested had been sent through the marketplace, but one had gone to a completely different router. That router turned out to be quietly forwarding a portion of its traffic to the marketplace, another hop that no customer had been told about and no published policy described. After Dragos disclosed the finding, the router said it had stopped.

Anyone who assumes that picking a reputable front end settles where a prompt ends up should take note. The front end can hand the request to a party the customer never evaluated, and nothing in the API response lets the customer see it happen.

Why zero data retention does not travel with your prompt

In its strict form, Zero Data Retention means prompts and completions are processed without routine storage after the request completes. OpenRouter’s documentation describes three data-policy tiers: zero retention, safety retention (a provider may keep data only to prevent abuse), and fixed-period retention (data may also be used for training). It exposes per-endpoint policy metadata plus account-level and per-request filters.

The Dragos data shows the weakness in that model. A flag like this is typically enforced at the first hop and nowhere else. A prompt marked for zero retention can be forwarded by a router to a reseller, logged by the reseller’s serving stack, forwarded again to a model developer’s API, and kept in a cache or a chat application on the other side of the world. The flag does not propagate across those boundaries in any way a customer can verify.

The Chinese AI lab whose scraper followed prompts to every host

The clearest example involved a Chinese AI lab that the research does not name. Its systems fetched the secret URLs from more than half of the prompts sent to its models between July and October. That included roughly two-thirds of the requests marked as no-data-collection or ZDR, and the scraper typically arrived two or three days after the request.

The pattern was not limited to traffic sent to the lab directly. Several U.S. hosting providers resell the lab’s models, and prompts sent to those providers triggered the same scraper, so the prompts flowed back to the lab no matter which front end the customer chose. A customer who picked a U.S. provider specifically to keep data in the United States did not get what they paid for. Later, a git client on a different cloud began trying to clone the private repositories referenced in the prompts, only for prompts that used this lab’s models.

The large U.S. providers had their own issues. One kept crawling a secret URL more than two months after a single inference call to its search endpoint. Another runs a scraper that returns days after each request regardless of which router carried it.

The strangest incident involved a company chat. Twenty-four days after a ZDR-flagged request went to a U.S.-based provider, the secret link embedded in that prompt was posted into a Feishu chat channel (Feishu is the workplace platform known as Lark outside China). Within two minutes the link was opened from three desktops and three phones in Beijing and Shanghai.

Dragos’s disclosure to the provider had included only the first eight characters of that link. Whoever posted it was therefore reading from a stored copy of the full prompt more than three weeks after the request. These are not edge cases from misconfigured accounts. They follow directly from an architecture in which data-handling commitments are asserted through metadata and are not enforced by isolation. In Moore’s words, the flagged prompts were retained, shared with other companies, and read by people.

What OpenRouter did: off-boarding providers and revoking 125 ZDR endpoints

OpenRouter’s response was deliberately broad. The 125 endpoints removed from ZDR eligibility cover both providers the researchers flagged and additional endpoints cut as a precaution, so the number should not be read as 125 confirmed incidents. It is a risk-based revocation of a trust label across endpoints whose data-handling paths the gateway could not verify to its own satisfaction.

The company says it is adapting the researchers’ canary methodology so the checks can run continuously. It is also verifying network paths to detect forwarding to third parties, and it will require assurances and validation before restoring ZDR eligibility to any removed endpoint. Neither Dragos nor OpenRouter has named the three breached or removed providers, and neither has said publicly whether they are the same three.

Phala, Together AI, and Novita: three incident reports, three failure modes

Three providers have published reports, and they show three different ways a prompt can escape.

Phala: a runtime compromise

Phala’s preliminary report, published November 10, describes an attacker who chained a legacy internet-facing service with management interfaces that relied on loopback access for trust and did not authenticate callers on their own. The company detected unauthorized activity on one server on November 5. The access let the attacker create unauthorized confidential virtual machines and steal application credentials. Phala blocked the access paths that day and rotated the KMS root key used to derive application secrets on November 6.

On November 8, Dragos gave Phala evidence that request data for the DeepSeek V4 Flash 0731 model had been exposed. Phala traced it to an inference deployment on a new GPU server that was serving production traffic without the full production security hardening. The attacker had used a similar access pattern to take control of the inference VM, which made in-flight request data visible during processing. The deployment went offline and containment finished at 05:35 UTC that day. Phala assesses that a single actor carried out both intrusions.

The precautionary exposure window runs from October 21 at 00:00 UTC to November 8 at 05:35 UTC. Anyone whose DeepSeek V4 Flash 0731 requests reached Phala through OpenRouter in that window should treat the contents as exposed and rotate every secret inside them. The canary evidence is narrower, since only credentials sent on October 21 and 22 were later misused, but the tests sampled traffic and did not monitor every request, so Phala keeps the wider window.

There is a pointed lesson here for the confidential-computing market Phala serves. Hardware memory encryption protects a workload from the host operator. It does nothing against an attacker who takes control of the machine that is allowed to see the plaintext.

Together AI: an AI coding agent leaked the key to a prompt archive

Together AI’s notice, published November 21, describes a leak with no runtime compromise at all. As part of routine software testing, the company collected authorized prompt samples and stored them in a private Hugging Face repository. The samples came from requests to the MiniMax M3, GLM-5.2, and Kimi K2.6 models, mostly on June 24, July 4, July 8, and July 14.

While the company developed its public GitHub repository, xorl, an AI coding agent, committed a credential that gave access to that private repository. Automated scanning detected the exposure and the commit was reverted, but an unauthorized party obtained the credential during the window and downloaded the samples. That party then searched the samples for credentials to other services and tested them. Five of the tested credentials were canaries from the Dragos experiment.

Together has engaged an external forensic firm and law enforcement. It says it has found no evidence of additional prompt leakage beyond this incident, and it is reviewing the affected contents to decide which customers need direct notification. Its remediation list includes scoped or short-lived credentials, keyless access where supported, credential checks on all pull requests, updated development processes for AI coding agents, and making Zero Data Retention the default for new accounts.

The recursion is hard to miss. An AI coding agent leaked the credential guarding a corpus of AI prompts, and that corpus existed because retaining prompts for testing is a normal, sanctioned practice.

Novita: a routing failure sent traffic to a party the customer never chose

Novita’s privacy notice describes a routing failure and no intrusion. A configuration issue made an API forwarding path intended for specific customers apply more broadly, so some MiniMax requests went to MiniMax’s official API instead of being processed on Novita-hosted infrastructure. The affected window runs from May 28 to November 11, 2026, and covers direct Novita requests as well as those routed through OpenRouter.

Novita suspended the affected models and says it does not retain prompts or outputs or use them for training. The researcher saw accesses to URLs and hostnames embedded in test requests but no use of the AWS test key markers. Novita says that pattern suggests automated content review on the third-party side, an assessment it is still verifying with MiniMax. The company is improving its Partner API labeling and its disclosure of the relevant providers’ retention policies and terms.

The difference from the other two incidents matters. Here the data moved to a party the customer did not select, but the observed behavior was scraping and not credential abuse.

A campaign, not a coincidence: Railway and the attacks on platform companies

These breaches do not stand alone. On October 21, the cloud platform Railway disclosed anomalous activity involving systems that store customer environment variables. It said an unauthorized third party may have accessed encrypted variables and, for some of them, obtained the decrypted contents, which can include API keys and database or registry credentials. Railway believed the intrusion belonged to a series of attacks on platform companies aimed at compromising AI inference providers, and it notified upstream providers so they could revoke keys proactively.

The logic of hitting the platform instead of the provider is easy to follow. A platform that hosts thousands of customers’ environment variables is a concentrated store of the very keys those customers use to reach inference APIs, and compromising it can open many providers at once.

ARTEX’s appearance in this campaign, even for key validation alone, fits a pattern documented across 2026: agentic offensive tooling lowers the skill floor for credential harvesting and cloud pivoting. The two ARTEX user agents missing from every public indicator list are a small, concrete measure of how far defender content lags attacker adoption.

How to choose where your prompts go

The guidance that follows from the research is a set of architectural constraints and carries no product recommendation. Here is how the options compare.

Self-hosting

Self-hosting is the only setup in which no third party reads a prompt. Dragos is candid about the cost. A Mac Studio with 512 GB of memory starts at $22,299, NVIDIA’s DGX Spark is $6,950, a DGX Station is about $105,000, and an eight-GPU B300 server runs $570,000 or more. For most teams that only makes sense for the most sensitive work.

Going direct to a first-tier provider

A direct relationship narrows the trust surface to one company, one contract, and one privacy policy. It can still leak through data-sharing agreements or a breach at that provider, but you know whose policy governs and whom to call.

Using a router without trusting the defaults

Routers need deliberate configuration. On OpenRouter, pin requests with the provider object (only, ignore, or order) instead of accepting the default pool. Set allow_fallbacks to false so a pinned provider cannot silently hand your request to others, and use zdr and data_collection to constrain routing by policy. A request body along these lines expresses that intent, with placeholder provider names:

{
"model": "your-model-id",
"messages": [{ "role": "user", "content": "..." }],
"provider": {
"only": ["provider-you-have-vetted"],
"allow_fallbacks": false,
"data_collection": "deny",
"zdr": true
}
}

Do not stop at setting these fields. Verify that they change where requests go, because the default routing and the sort price or :floor shortcuts hand the decision to the cheapest endpoint, which is the mechanism the marketplace abuse exploited. Dragos-style path tracing, even a crude version using an image URL you control, is the way to check.

Reseller marketplaces

Some of their capacity runs on stolen keys, and a seller can log everything by design. Avoid them for anything that touches real data.

Plant your own canary tokens

The most transferable defensive idea from the research is the tripwire. A fake credential placed in the context that your agents and pipelines already send turns any use of that credential into a high-confidence incident. A free Thinkst Canarytoken is enough to start.

The signal is unambiguous because the secret exists in exactly one place. Anomalous-login heuristics produce false positives, while a canary AWS key that gets used produces a conversation with your incident response team. A practical rollout looks like this:

  • Put a canary AWS key and a canary URL in the files your coding agents read, such as a decoy .env file or a fake config in a scratch repository.
  • Use a different canary for each provider or router you test, so a callback tells you which path leaked.
  • Send the alerts to the same place as your real incident alerts, and write down who owns the response before the first alert fires.
  • Rotate or reseed the canaries on a schedule, so an old callback cannot hide behind a stale token.

Settings that scrub known credential formats from prompts help at the margin. They miss the large category of sensitive data that does not look like an API key, such as database connection strings, internal URLs, and proprietary source code. Treat scrubbing as one layer and keep real secrets out of agent-readable files in the first place. Short-lived, narrowly scoped credentials limit the damage when a prompt does leak.

Who needs to rotate keys right now

If your traffic fell inside a named exposure window, rotation is the immediate action. Treat every key, token, or password inside these requests as compromised:

  • Any request that reached Phala through OpenRouter for DeepSeek V4 Flash 0731 between October 21 and November 8.
  • Any MiniMax request that went through Novita, directly or through OpenRouter, between May 28 and November 11.
  • Any prompts that Together AI notifies you about once it completes its review of the affected samples.

After rotating, check whether the old keys were used. A key that shows activity from an unfamiliar user agent or a rented server after the exposure date tells you the data was harvested and not merely exposed.

Hunting this attacker in CloudTrail

The observed playbook maps cleanly onto CloudTrail detection. Alert on this sequence, especially when it comes from an unfamiliar user agent or rented infrastructure:

  • S3 ListBuckets, followed by reads from Secrets Manager and Systems Manager Parameter Store.
  • IAM CreateUser and CreateAccessKey calls from a principal that does not normally administer IAM.
  • Bedrock API key creation and changes that enable hosted Bedrock models you never used before.
  • The user agents artex-agent and artex-judge-r121, which are worth adding to indicator sets even though they cover only a fraction of the traffic.

If you query CloudTrail through Athena, a starting point looks like this (adjust the table name to your own setup):

SELECT eventtime, eventname, useragent, sourceipaddress, useridentity.accesskeyid
FROM cloudtrail_logs
WHERE eventname IN ('ListBuckets', 'ListSecrets', 'GetSecretValue',
'GetParameter', 'GetParameters', 'GetParametersByPath',
'CreateUser', 'CreateAccessKey',
'CreateServiceSpecificCredential')
AND (lower(useragent) LIKE '%artex%'
OR lower(useragent) LIKE '%kali%'
OR lower(useragent) LIKE '%boto3%')
ORDER BY eventtime DESC;

Expect some noise from your own tooling, and filter by the access key IDs you know you rotated. A user agent is trivial to spoof, so use these strings as extra evidence and base the alert on the behavior sequence.

Frequently asked questions

What is zero data retention for AI APIs?

In its strict form, Zero Data Retention means a provider processes prompts and completions without routine storage once the request completes. In practice it is a policy flag attached to an endpoint, and the Dragos research shows that the flag is typically enforced at the first hop and not across every hop behind it.

Did OpenRouter get hacked?

No. OpenRouter says its investigation found no breach or unauthorized access of OpenRouter itself. It off-boarded three inference providers, removed 125 endpoints from ZDR eligibility, and notified potentially affected customers.

What are canary tokens, and how did Dragos use them?

Canary tokens are fake credentials or links that alert their owner when someone uses them. Dragos put a unique AWS key, DNS name, and URL into each of roughly two million prompts, so any use of one could be traced to the exact request that carried it.

Which providers were breached?

Neither Dragos nor OpenRouter has named the three breached providers. Phala, Together AI, and Novita have each published incident reports describing different failure modes, and neither company has confirmed how those reports line up with the three unnamed providers.

Should I stop using AI routers?

You do not have to stop, but you should stop treating provider choice as a price comparison. Pin providers, disable fallbacks, constrain routing by data policy, keep real secrets out of anything an agent can read, and seed canaries so you find out when a prompt leaks.

The bottom line for security teams

Treating a prompt as a transient input to a model is a convenient fiction that the commercial architecture of AI routing has already abandoned. A prompt is a data object with a lifecycle that runs well past the forward pass, and the security of that lifecycle depends on verifiable isolation, whatever a privacy policy or retention flag says.

The Dragos research did not discover a new attack. It measured an attack surface that attackers were already using, quietly, across several providers and marketplaces, for months before anyone noticed. OpenRouter’s response of off-boarding, de-labeling, continuous canary testing, and path verification is a reasonable first step, and it points toward a model where trust is checked empirically and not declared. Whether the rest of the ecosystem follows depends on whether customers start treating provider selection as a security decision, and whether providers start treating zero retention as a guarantee that travels with the data and stops being a label on an endpoint listing.

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Your contribution powers free tutorials, hands-on labs, and security resources.

Why your support matters:
  • Writeup Access: Get complete writeup access within 12 hours
  • Zero paywalls: Keep the main content 100% free for learners worldwide

Perks for one-time supporters:
☕️ $5: Shoutout in Buy Me a Coffee
🛡️ $8: Fast-track Access to Live Webinars
💻 $10: Vote on future tutorial topics + exclusive AMA access

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

If you like this post, then please share it:

Exploits

Discover more from The CyberSec Guru

Subscribe to get the latest posts sent to your email!

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.