<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: GitGuardian</title>
    <description>The latest articles on DEV Community by GitGuardian (gitguardian).</description>
    <link>https://dev.to/gitguardian</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F4775%2Fc847a31e-0f21-49f1-a6fe-7b55c0e0c954.png</url>
      <title>DEV Community: GitGuardian</title>
      <link>https://dev.to/gitguardian</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/gitguardian"/>
    <language>en</language>
    <item>
      <title>Your Leaked Secrets Now Show Up in Wiz</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Tue, 17 Nov 2026 13:46:03 +0000</pubDate>
      <link>https://dev.to/gitguardian/your-leaked-secrets-now-show-up-in-wiz-5323</link>
      <guid>https://dev.to/gitguardian/your-leaked-secrets-now-show-up-in-wiz-5323</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The new GitGuardian Wiz integration:&lt;/strong&gt; GitGuardian now has an integration with Wiz.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Daily sync:&lt;/strong&gt; Once a day, GitGuardian sends open secret incidents from GitHub, GitLab, Bitbucket, and Azure DevOps to Wiz as native secret findings.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Full context:&lt;/strong&gt; Each finding carries the repository, file, commit, detector, validity, and severity, plus a link back to the incident in GitGuardian.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Secret stays private:&lt;/strong&gt; The secret value never leaves GitGuardian. Wiz only receives a hash and metadata.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In a lot of companies, the cloud security team works in Wiz, and the AppSec team works in GitGuardian. Wiz is where cloud risk gets triaged and where the report for the CISO comes from. GitGuardian is where leaked secrets get found and fixed. Until now, the two teams rarely looked at the same thing. So the person looking at an exposed cloud resource in Wiz couldn't see that the AWS key for that same account was committed to a private repo eight months ago and still works.&lt;/p&gt;

&lt;p&gt;That gap is what this integration closes. GitGuardian now sends its secret findings straight into Wiz, so leaked credentials sit next to the cloud and identity risk they're connected to. Both teams now look at the same leaked key, each in the tool they already use.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why secrets belong next to your cloud risk
&lt;/h2&gt;

&lt;p&gt;Attackers don't need to break in when they can log in. Compromised credentials were the most common technique across full breach chains in the &lt;a href="https://www.verizon.com/business/resources/reports/dbir/" rel="noopener noreferrer"&gt;Verizon 2026 Data Breach Investigations Report&lt;/a&gt;, showing up in 39% of them. And leaked secrets don't go away on their own: of the credentials GitGuardian found valid in 2022, more than &lt;a href="https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026/" rel="noopener noreferrer"&gt;64% still worked in January 2026&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Wiz is good at showing how cloud resources connect and which issues matter most. GitGuardian is good at finding secrets across code, developer laptops, collaboration tools, and public sources, checking whether they still work, and helping teams fix them. Customers running both GitGuardian and Wiz kept asking the same thing: why do I need two screens to see one problem?&lt;/p&gt;

&lt;p&gt;Now they don't.&lt;/p&gt;

&lt;h2&gt;
  
  
  What GitGuardian sends to Wiz
&lt;/h2&gt;

&lt;p&gt;For every open secret incident in a connected repository, Wiz receives one finding with:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The repository, file path, and commit where the secret was found.&lt;/li&gt;
&lt;li&gt;The detector that caught it (GitGuardian has 550+ of them).&lt;/li&gt;
&lt;li&gt;Whether the secret is still valid, and when that was last checked, so Wiz can put the keys that still work ahead of every string that only looks like a key.&lt;/li&gt;
&lt;li&gt;The incident's severity in GitGuardian, mapped to a Wiz severity.&lt;/li&gt;
&lt;li&gt;A link back to the full incident in GitGuardian.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If a secret shows up several times in the same repository, Wiz gets the most recent occurrence. The full history stays in GitGuardian.&lt;/p&gt;

&lt;p&gt;The secret itself never leaves GitGuardian. Wiz receives a SHA-256 hash of the value and the metadata above, nothing more.&lt;/p&gt;

&lt;h2&gt;
  
  
  How the sync works
&lt;/h2&gt;

&lt;p&gt;Once a day, GitGuardian sends Wiz the full list of open incidents (triggered or assigned) for each connected source. Wiz keeps a finding open as long as it appears in the latest upload. When your team resolves or ignores an incident in GitGuardian, it drops out of the next sync, and Wiz removes the finding.&lt;/p&gt;

&lt;p&gt;Most severities map across directly. For the two Wiz doesn't have, you decide.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fj2eaz99ou123dpgzu1q7.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fj2eaz99ou123dpgzu1q7.png" alt="How severity maps from GitGuardian to Wiz" width="800" height="512"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;You can change this anytime, and it takes effect at the next sync.&lt;/p&gt;

&lt;h2&gt;
  
  
  What you get by keeping GitGuardian in the loop
&lt;/h2&gt;

&lt;p&gt;Wiz shows you where a leaked secret sits in your cloud risk picture. GitGuardian's secret scanning finds it, proves whether it still works, and gets it fixed. That means 550+ detectors with validity checks that tell you which keys are live, remediation workflows like similar-incident grouping and playbooks, and prevention at commit time with ggshield, so fewer secrets land in your code and other assets in the first place. Every finding in Wiz links back to its incident, so going from "we should look at this" to "this is fixed" takes one click.&lt;/p&gt;

&lt;p&gt;GitGuardian also covers places outside your repositories, like Slack, Jira, Confluence, and &lt;a href="https://blog.gitguardian.com/extending-our-mission-with-developer-endpoint-protection/" rel="noopener noreferrer"&gt;developer machines&lt;/a&gt;. Those findings stay in GitGuardian, because the integration only sends incidents from version control sources.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to set up the GitGuardian Wiz integration
&lt;/h2&gt;

&lt;p&gt;You'll need a Wiz user who can add integrations. You don't need to create a service account first, because the GitGuardian integration in Wiz creates one for you.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;In Wiz, open the &lt;a href="https://app.wiz.io/settings/deployments/integrations/new/git-guardian" rel="noopener noreferrer"&gt;GitGuardian integration page&lt;/a&gt;. Wiz gives you a Client ID, a Client secret, an Authentication URL, and an API endpoint URL.&lt;/li&gt;
&lt;li&gt;In GitGuardian, go to &lt;strong&gt;Settings &amp;gt; Integrations &amp;gt; Wiz&lt;/strong&gt; and click &lt;strong&gt;Configure&lt;/strong&gt;.&lt;/li&gt;
&lt;li&gt;Paste the four values and choose how to map Info and Unknown severities.&lt;/li&gt;
&lt;li&gt;Click &lt;strong&gt;Add integration&lt;/strong&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Your first findings show up in Wiz within 24 hours. You can pause or resume the sync from the same settings page at any time.&lt;/p&gt;

&lt;p&gt;One tip: start from the GitGuardian integration page in Wiz rather than creating a token yourself in Wiz settings. A token you create manually won't have the permissions the sync needs.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz6967we2in1pmiqcjp6d.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz6967we2in1pmiqcjp6d.png" alt="The GitGuardian Wiz integration panel" width="800" height="714"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The full details are in the &lt;a href="https://docs.gitguardian.com/platform/configure-alerting/aspm-integrations/wiz" rel="noopener noreferrer"&gt;GitGuardian Wiz integration docs&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Good to know
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;New findings can take up to 24 hours&lt;/strong&gt; to show up in Wiz, and resolved ones can stay for up to 7 days.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Some findings may be skipped at first.&lt;/strong&gt; If Wiz doesn't support a GitGuardian detector yet, findings from it are held back until Wiz adds it. That usually takes a few days and clears on its own.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Custom detectors and Gerrit aren't supported&lt;/strong&gt;, and findings without a file path are skipped.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;If you already use GitGuardian and Wiz, you can connect them today in a few minutes. If you use Wiz and want to see what's hiding in your repositories, book a demo and we'll show you both together.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/book-a-demo" rel="noopener noreferrer"&gt;Book a demo&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Does GitGuardian integrate with Wiz?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Yes. The GitGuardian Wiz integration sends open secret incidents from your version control sources to Wiz once a day as native secret findings. Each finding links back to the incident in GitGuardian.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does Wiz receive the secret value?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;No. The secret value never leaves GitGuardian. Wiz receives a SHA-256 hash of the value plus metadata: repository, file, commit, detector, validity, and severity.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which sources sync to Wiz?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Only version control sources: GitHub, GitLab, Bitbucket, and Azure DevOps. Findings from Slack, Jira, Confluence, and developer machines stay in GitGuardian. Custom detectors and Gerrit aren't supported.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How often does GitGuardian sync findings to Wiz?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Once a day. New findings can take up to 24 hours to appear in Wiz, and resolved ones can stay visible for up to seven days.&lt;/p&gt;

</description>
      <category>security</category>
      <category>devsecops</category>
      <category>appsec</category>
      <category>secrets</category>
    </item>
    <item>
      <title>Beyond ARTEX: 45 Agentic Attack Frameworks, What They Hunt For, and How to Find Them</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Tue, 17 Nov 2026 13:30:22 +0000</pubDate>
      <link>https://dev.to/gitguardian/beyond-artex-45-agentic-attack-frameworks-what-they-hunt-for-and-how-to-find-them-4g6h</link>
      <guid>https://dev.to/gitguardian/beyond-artex-45-agentic-attack-frameworks-what-they-hunt-for-and-how-to-find-them-4g6h</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;About 45 open-source frameworks now automate attacks:&lt;/strong&gt; Each one wires a language model into a loop that runs tools and acts on their output. We cataloged 32 of them into five families; the rest are forks and variants.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Four ship a real secret scanner, but none ships the full pipeline:&lt;/strong&gt; Pojun, Cybermes, Xalgorix, and AIRecon wire a scanner to the agent, yet none contains a GitHub fetcher. The model can assemble the rest at runtime, because each framework hands its agent a shell and web access.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Dozens of operator consoles sit on the open internet:&lt;/strong&gt; Of the 41 frameworks fingerprinted for Shodan, 11 serve a web UI by default. The ARTEX family alone matched 1,428 Shodan services on Nov. 7, 2026.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The risk clusters in widely forked bases:&lt;/strong&gt; It sits in a handful of heavily forked projects, not in the most-starred repositories.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;ARTEX was one framework. The field around it holds about 45 more, each an open-source project that wires a language model into a loop that runs tools and acts on their output. We read the code and used Shodan to find every one accessible. Four ship a secret scanner wired to the agent by default. Dozens of operator consoles answered a Shodan query today. This post is the catalog: where each tool's code lives, what it ships for hunting secrets on public GitHub, and how it looks on the Internet.&lt;/p&gt;

&lt;h2&gt;
  
  
  ARTEX, briefly
&lt;/h2&gt;

&lt;p&gt;ARTEX is an open-source agentic penetration-testing platform. Its creator took it down on 2026-10-08, 74 days after the first commit, following reports that threat actors were using it to hunt for secrets and move laterally with them. The takedown did not stop the spread: 102 forks and &lt;a href="https://github.com/search?q=ARTEX+autonomous+penetration+testing&amp;amp;type=repositories" rel="noopener noreferrer"&gt;ARTEX-named repositories&lt;/a&gt; appeared in the takedown week alone. Google Threat Intelligence Group (GTIG), Microsoft, Wiz, CrowdStrike, Zscaler, Check Point, Censys, and RST Cloud have all written about ARTEX itself. This post covers the rest of the field.&lt;/p&gt;

&lt;p&gt;ARTEX is not an isolated case. On Nov. 12, 2026, &lt;a href="https://unit42.paloaltonetworks.com/cairn-framework-ai-autonomous-attacks/" rel="noopener noreferrer"&gt;Palo Alto Networks Unit 42 reported&lt;/a&gt; a campaign of autonomous AI attacks built on a customized fork of Cairn, one of the frameworks in our catalog. In an autonomous AI attack, the operator supplies a target and a goal. The agent then plans and executes the intrusion and records the results on its own. Between August and September 2026, attackers ran 25 Cairn operations against at least 19 organizations and gained access or data at 10. One operation included a credential and secret collection phase, even though we found no secret-hunting capability in the public Cairn repository.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 45 frameworks
&lt;/h2&gt;

&lt;p&gt;Each framework has public source code and wires a model into a loop that runs tools and acts on their output. We cataloged 32 of the ~45 into five families, the remaining ~13 are forks, variants that reuse a family's pattern:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Network kill chain.&lt;/strong&gt; End-to-end recon, exploitation, and post-exploitation, usually from a Kali container. &lt;a href="https://github.com/vxcontrol/pentagi" rel="noopener noreferrer"&gt;PentAGI&lt;/a&gt; runs agent teams with Nmap, Metasploit, and sqlmap. &lt;a href="https://github.com/samugit83/redamon" rel="noopener noreferrer"&gt;RedAmon&lt;/a&gt; builds an attack-surface graph. &lt;a href="https://github.com/xalgorix/xalgorix" rel="noopener noreferrer"&gt;Xalgorix&lt;/a&gt;, &lt;a href="https://github.com/Armur-Ai/Pentest-Swarm-AI" rel="noopener noreferrer"&gt;Pentest-Swarm-AI&lt;/a&gt;, &lt;a href="https://github.com/SanMuzZzZz/LuaN1aoAgent" rel="noopener noreferrer"&gt;LuaN1aoAgent&lt;/a&gt;, &lt;a href="https://github.com/pikpikcu/airecon" rel="noopener noreferrer"&gt;AIRecon&lt;/a&gt;, &lt;a href="https://github.com/martian56/redcell" rel="noopener noreferrer"&gt;redcell&lt;/a&gt;, &lt;a href="https://github.com/s0ld13rr/pentestcode" rel="noopener noreferrer"&gt;PentestCode&lt;/a&gt; and &lt;a href="https://github.com/cdxiaodong/cain-agent" rel="noopener noreferrer"&gt;cain-agent&lt;/a&gt; share the pattern. &lt;a href="https://github.com/ASCIT31/Dark-Moon" rel="noopener noreferrer"&gt;DarkMoon&lt;/a&gt; ships 50 specialist agents across web, cloud, Active Directory, and CI/CD.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Web-app and API.&lt;/strong&gt; &lt;a href="https://github.com/usestrix/strix" rel="noopener noreferrer"&gt;Strix&lt;/a&gt; tests web applications autonomously. &lt;a href="https://github.com/KeygraphHQ/shannon" rel="noopener noreferrer"&gt;Shannon&lt;/a&gt; works from source code, closer to a SAST reviewer than a live kill chain. &lt;a href="https://github.com/GreyDGL/PentestGPT" rel="noopener noreferrer"&gt;PentestGPT&lt;/a&gt; is an advisory assistant. &lt;a href="https://github.com/elder-plinius/T3MP3ST" rel="noopener noreferrer"&gt;T3MP3ST&lt;/a&gt;, &lt;a href="https://github.com/pensarai/apex" rel="noopener noreferrer"&gt;Apex&lt;/a&gt;, &lt;a href="https://github.com/straylabs-ai/deadend-cli" rel="noopener noreferrer"&gt;deadend-cli&lt;/a&gt; and &lt;a href="https://github.com/PentesterFlow/agent" rel="noopener noreferrer"&gt;PentesterFlow&lt;/a&gt; sit nearby.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;C2-integrated.&lt;/strong&gt; &lt;a href="https://github.com/MythicAgents/sage" rel="noopener noreferrer"&gt;Sage&lt;/a&gt; and &lt;a href="https://github.com/0xrdi/echidna" rel="noopener noreferrer"&gt;echidna&lt;/a&gt; run as LLM operators inside the Mythic C2 framework. &lt;a href="https://github.com/r74tech/virga" rel="noopener noreferrer"&gt;virga&lt;/a&gt; puts a local model inside the implant. &lt;a href="https://github.com/chu0119/Pojun" rel="noopener noreferrer"&gt;Pojun&lt;/a&gt; and &lt;a href="https://github.com/F0ran9/forang" rel="noopener noreferrer"&gt;FORANG&lt;/a&gt; are ARTEX derivatives that bolt a C2 console onto the base; &lt;a href="https://github.com/2561769445/ycode-auto-pentest" rel="noopener noreferrer"&gt;ycode&lt;/a&gt; is a third ARTEX derivative, and &lt;a href="https://github.com/cskwork/scopeweaver" rel="noopener noreferrer"&gt;ScopeWeaver&lt;/a&gt; is an English- and Korean-localized fork of ARTEX.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Harnesses.&lt;/strong&gt; &lt;a href="https://github.com/gadievron/raptor" rel="noopener noreferrer"&gt;RAPTOR&lt;/a&gt;, &lt;a href="https://github.com/CyberStrikeus/CyberStrike" rel="noopener noreferrer"&gt;CyberStrike&lt;/a&gt;, &lt;a href="https://github.com/chainreactors/cyber-harness" rel="noopener noreferrer"&gt;cyber-harness&lt;/a&gt;, &lt;a href="https://github.com/berylliumsec/nebula" rel="noopener noreferrer"&gt;Nebula&lt;/a&gt; and &lt;a href="https://github.com/Zyrexnn/Cybermes" rel="noopener noreferrer"&gt;Cybermes&lt;/a&gt; wrap a general coding agent (Claude Code, Codex, Hermes) with offensive skills. Plugin packs do the same for coding agents; we track those as one group.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Research prototypes.&lt;/strong&gt; &lt;a href="https://github.com/cylabcyberautonomy/Incalmo" rel="noopener noreferrer"&gt;Incalmo&lt;/a&gt;, &lt;a href="https://github.com/ipa-lab/hackingBuddyGPT" rel="noopener noreferrer"&gt;hackingBuddyGPT&lt;/a&gt;, &lt;a href="https://github.com/KHenryAegis/VulnBot" rel="noopener noreferrer"&gt;VulnBot&lt;/a&gt;, &lt;a href="https://github.com/aielte-research/HackSynth" rel="noopener noreferrer"&gt;HackSynth&lt;/a&gt;, &lt;a href="https://github.com/Dizzy-K/AutoPT" rel="noopener noreferrer"&gt;AutoPT&lt;/a&gt; and &lt;a href="https://github.com/dreadnode/ares" rel="noopener noreferrer"&gt;Ares&lt;/a&gt; come out of academic work.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Three more appear in threat reporting and are worth including. Cairn coordinates worker agents on a shared fact graph, with no authentication by default. HexStrike is an MCP server that exposes more than 150 offensive tools to any MCP client, with no authentication by default. Agent Zero is a general-purpose agent, also with no authentication by default, that threat actors have experimented with. CAI was archived on 2026-08-28.&lt;/p&gt;

&lt;p&gt;The catalog below gives one row per tool: where the code lives, how popular and how active it is, what it ships for secret-hunting, and how visible it is on Shodan. Stars and last-push are from the GitHub API on 2026-11-07. "Not reviewed" means the tool was outside the secret-hunting shortlist, so we did not inspect it: not the same as "None found," where we read the code and found no secret-hunting capability. Section 2 defines the shortlist and full grade scale.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Repo&lt;/th&gt;
&lt;th&gt;Family&lt;/th&gt;
&lt;th&gt;Stars&lt;/th&gt;
&lt;th&gt;Last push&lt;/th&gt;
&lt;th&gt;Secret-hunting&lt;/th&gt;
&lt;th&gt;Shodan class&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Strix&lt;/td&gt;
&lt;td&gt;usestrix/strix&lt;/td&gt;
&lt;td&gt;Web/API&lt;/td&gt;
&lt;td&gt;74.2k&lt;/td&gt;
&lt;td&gt;2026-11-06&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Shannon&lt;/td&gt;
&lt;td&gt;KeygraphHQ/shannon&lt;/td&gt;
&lt;td&gt;Web/API (SAST)&lt;/td&gt;
&lt;td&gt;51.4k&lt;/td&gt;
&lt;td&gt;2026-11-06&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentAGI&lt;/td&gt;
&lt;td&gt;vxcontrol/pentagi&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;33.6k&lt;/td&gt;
&lt;td&gt;2026-10-22&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agent Zero&lt;/td&gt;
&lt;td&gt;agent0ai/agent-zero&lt;/td&gt;
&lt;td&gt;General&lt;/td&gt;
&lt;td&gt;19.8k&lt;/td&gt;
&lt;td&gt;2026-11-05&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestGPT&lt;/td&gt;
&lt;td&gt;GreyDGL/PentestGPT&lt;/td&gt;
&lt;td&gt;Web/API&lt;/td&gt;
&lt;td&gt;16.3k&lt;/td&gt;
&lt;td&gt;2026-07-14&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;HexStrike&lt;/td&gt;
&lt;td&gt;0x4m4/hexstrike-ai&lt;/td&gt;
&lt;td&gt;MCP server&lt;/td&gt;
&lt;td&gt;13.4k&lt;/td&gt;
&lt;td&gt;2026-08-03&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CAI (archived)&lt;/td&gt;
&lt;td&gt;aliasrobotics/cai&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;9.8k&lt;/td&gt;
&lt;td&gt;2026-08-22&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cairn&lt;/td&gt;
&lt;td&gt;oritera/Cairn&lt;/td&gt;
&lt;td&gt;Harness/graph&lt;/td&gt;
&lt;td&gt;4.9k&lt;/td&gt;
&lt;td&gt;2026-09-07&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RAPTOR&lt;/td&gt;
&lt;td&gt;gadievron/raptor&lt;/td&gt;
&lt;td&gt;Harness&lt;/td&gt;
&lt;td&gt;4.0k&lt;/td&gt;
&lt;td&gt;2026-11-07&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CyberStrike&lt;/td&gt;
&lt;td&gt;CyberStrikeus/CyberStrike&lt;/td&gt;
&lt;td&gt;Harness&lt;/td&gt;
&lt;td&gt;3.4k&lt;/td&gt;
&lt;td&gt;2026-11-07&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RedAmon&lt;/td&gt;
&lt;td&gt;samugit83/redamon&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;3.3k&lt;/td&gt;
&lt;td&gt;2026-11-05&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestAgent&lt;/td&gt;
&lt;td&gt;GH05TCREW/pentestagent&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;3.2k&lt;/td&gt;
&lt;td&gt;2026-11-02&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pentest-Swarm-AI&lt;/td&gt;
&lt;td&gt;Armur-Ai/Pentest-Swarm-AI&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;3.1k&lt;/td&gt;
&lt;td&gt;2026-11-03&lt;/td&gt;
&lt;td&gt;Unwired&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;sapper-v2&lt;/td&gt;
&lt;td&gt;N1nEmAn/sapper-v2&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;1.5k&lt;/td&gt;
&lt;td&gt;2026-11-07&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;LuaN1aoAgent&lt;/td&gt;
&lt;td&gt;SanMuzZzZz/LuaN1aoAgent&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;1.5k&lt;/td&gt;
&lt;td&gt;2026-09-15&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentesterFlow&lt;/td&gt;
&lt;td&gt;PentesterFlow/agent&lt;/td&gt;
&lt;td&gt;Web/API&lt;/td&gt;
&lt;td&gt;1.4k&lt;/td&gt;
&lt;td&gt;2026-08-31&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;xalgorix&lt;/td&gt;
&lt;td&gt;xalgorix/xalgorix&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;1.3k&lt;/td&gt;
&lt;td&gt;2026-11-07&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DarkMoon&lt;/td&gt;
&lt;td&gt;ASCIT31/Dark-Moon&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;1.2k&lt;/td&gt;
&lt;td&gt;2026-10-27&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;no usable fingerprint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AIRecon&lt;/td&gt;
&lt;td&gt;pikpikcu/airecon&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;1.1k&lt;/td&gt;
&lt;td&gt;2026-10-27&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cybermes&lt;/td&gt;
&lt;td&gt;Zyrexnn/Cybermes&lt;/td&gt;
&lt;td&gt;Harness&lt;/td&gt;
&lt;td&gt;1.0k&lt;/td&gt;
&lt;td&gt;2026-11-05&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cain-agent&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;946&lt;/td&gt;
&lt;td&gt;2026-10-14&lt;/td&gt;
&lt;td&gt;None found (unwired)&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestCode&lt;/td&gt;
&lt;td&gt;s0ld13rr/pentestcode&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;930&lt;/td&gt;
&lt;td&gt;2026-11-05&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ScopeWeaver&lt;/td&gt;
&lt;td&gt;cskwork/scopeweaver&lt;/td&gt;
&lt;td&gt;Network (ARTEX-like)&lt;/td&gt;
&lt;td&gt;918&lt;/td&gt;
&lt;td&gt;2026-11-04&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T3MP3ST&lt;/td&gt;
&lt;td&gt;elder-plinius/T3MP3ST&lt;/td&gt;
&lt;td&gt;Web/API&lt;/td&gt;
&lt;td&gt;7.0k&lt;/td&gt;
&lt;td&gt;2026-09-08&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cyber-harness&lt;/td&gt;
&lt;td&gt;chainreactors/cyber-harness&lt;/td&gt;
&lt;td&gt;Harness&lt;/td&gt;
&lt;td&gt;384&lt;/td&gt;
&lt;td&gt;2026-11-07&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;redcell&lt;/td&gt;
&lt;td&gt;martian56/redcell&lt;/td&gt;
&lt;td&gt;Network&lt;/td&gt;
&lt;td&gt;356&lt;/td&gt;
&lt;td&gt;2026-10-06&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;deadend-cli&lt;/td&gt;
&lt;td&gt;straylabs-ai/deadend-cli&lt;/td&gt;
&lt;td&gt;Web/API&lt;/td&gt;
&lt;td&gt;324&lt;/td&gt;
&lt;td&gt;2026-08-07&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Apex&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;Web/API&lt;/td&gt;
&lt;td&gt;323&lt;/td&gt;
&lt;td&gt;2026-11-06&lt;/td&gt;
&lt;td&gt;Not reviewed&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Incalmo&lt;/td&gt;
&lt;td&gt;cylabcyberautonomy/Incalmo&lt;/td&gt;
&lt;td&gt;Research&lt;/td&gt;
&lt;td&gt;148&lt;/td&gt;
&lt;td&gt;2026-11-02&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pojun&lt;/td&gt;
&lt;td&gt;chu0119/Pojun&lt;/td&gt;
&lt;td&gt;C2 (ARTEX fork)&lt;/td&gt;
&lt;td&gt;84&lt;/td&gt;
&lt;td&gt;2026-11-06&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sage&lt;/td&gt;
&lt;td&gt;MythicAgents/sage&lt;/td&gt;
&lt;td&gt;C2 (Mythic)&lt;/td&gt;
&lt;td&gt;35&lt;/td&gt;
&lt;td&gt;2026-10-30&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;no listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;virga&lt;/td&gt;
&lt;td&gt;r74tech/virga&lt;/td&gt;
&lt;td&gt;C2 (implant)&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;2026-10-12&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;no usable fingerprint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FORANG&lt;/td&gt;
&lt;td&gt;F0ran9/forang&lt;/td&gt;
&lt;td&gt;C2 (ARTEX fork)&lt;/td&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;2026-11-07&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;echidna&lt;/td&gt;
&lt;td&gt;Echidna-Pentest/Echidna/&lt;/td&gt;
&lt;td&gt;C2 (Mythic)&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;2026-08-25&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;no usable fingerprint&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decepticon&lt;/td&gt;
&lt;td&gt;BitterSecurity/Decepticon&lt;/td&gt;
&lt;td&gt;Harness&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;2026-11-07&lt;/td&gt;
&lt;td&gt;Unwired&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Secret-hunting grades, in short:&lt;/strong&gt; Provisioned (scanner named, reachable by the agent), Text only (recipe or skill, no scanner), Unwired (scanner named, nothing calls it), None found (reviewed, nothing there), Not reviewed (outside the shortlist). Section 2 explains each.&lt;/p&gt;

&lt;h2&gt;
  
  
  What ships for hunting secrets
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvc28875dmbv2310tho3n.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvc28875dmbv2310tho3n.png" alt="Secret-hunting grades for 24 reviewed AI pentesting tools: provisioned 4, text only 5, unwired 2, none found 13." width="799" height="313"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We shortlisted the tools most likely to ship secret-hunting (the ARTEX forks, the Kali-container network agents, and the harnesses with OSINT skills) and read each at a pinned commit, grading what it ships for finding secrets on public GitHub.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Provisioned:&lt;/strong&gt; a scanner is named in the code, and GitHub guidance reaches the agent by default.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Text only:&lt;/strong&gt; recipes or skills, but no scanner the agent can run.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Unwired:&lt;/strong&gt; code present, but no agent can call it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;None found:&lt;/strong&gt; reviewed, nothing present.&lt;/li&gt;
&lt;/ul&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Grade&lt;/th&gt;
&lt;th&gt;What ships&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Pojun&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;gitleaks, named in the worker prompt since 2026-10-20; a default skill that points the agent at public GitHub and the target organization since 2026-11-05&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cybermes&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;Its own secret_scan binary (48 regex patterns); a corpus of 13 GitHub code-search dorks; nine read-only credential validators (AWS, GitHub, Slack, OpenAI, Anthropic and others) loaded as default skills&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Xalgorix&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;gitleaks and trufflehog named; the default "full" checklist tells the agent to use GitHub search and gitleaks to find exposed secrets and keys&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AIRecon&lt;/td&gt;
&lt;td&gt;Provisioned&lt;/td&gt;
&lt;td&gt;gitleaks and trufflehog in its Kali container; a typed web-search tool with dork operators; a default-offered skill with site:github.com secret dorks&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DarkMoon&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;A prompt recipe to mine a named repository's history for keys and pass them to its cloud agents&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ycode&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;GitHub leak-hunting skill text, no scanner installed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ijlalhaider313/ARTEX&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;A secret-scan recipe that calls trufflehog, gitleaks and gh, none of them installed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestAgent&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;Guidance only&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestCode&lt;/td&gt;
&lt;td&gt;Text only&lt;/td&gt;
&lt;td&gt;A recon skill in the binary: GitHub/GitLab search for org:target and target.com password, then trufflehog/gitleaks on found repos; no scanner installed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decepticon&lt;/td&gt;
&lt;td&gt;Unwired&lt;/td&gt;
&lt;td&gt;A GitHub-dork generator merged on 2026-10-09; no agent binds it on the reviewed commit or on main&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pentest-Swarm-AI&lt;/td&gt;
&lt;td&gt;Unwired&lt;/td&gt;
&lt;td&gt;A GitHub code-search client with four secret dorks that no code calls; trufflehog and gitleaks are installed but run only in a CI self-scan playbook for the operator's own repository&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ARTEX v0.3.15&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;Published source only; its one GitHub API call is the self-updater&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cain-agent&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;66 playbook files the loader never reads; a cloud library no agent calls&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;redcell&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;Generic leak collection in its OSINT prompt; GitHub not named; no scanner named&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RedAmon, HexStrike, Sage, echidna, cyber-harness, Incalmo, CAI, Cairn, PentAGI, FORANG&lt;/td&gt;
&lt;td&gt;None found&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Four tools ship a real scanner wired to the agent: Pojun, Cybermes, Xalgorix and AIRecon. None contains a GitHub fetcher. Almost every framework in the catalog hands its agent a shell and web access, so a GitHub search or a scanner download is one improvised tool call away. A model and a prompt supply the capability. The repository does not ship it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What they look like on Shodan
&lt;/h2&gt;

&lt;p&gt;Shodan indexes services, so the first question is whether a framework exposes anything to match. We classified each from its code. Of the ~45 frameworks, 41 are fingerprint-assessed for Shodan; 11 serve a web UI on a network port by default, 18 serve a UI only in some setups or nothing distinctive at the root, and 12 have no listener at all. We wrote 56 fingerprint records, one per build with a distinct web interface.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Exposure class&lt;/th&gt;
&lt;th&gt;Count-only services&lt;/th&gt;
&lt;th&gt;Main ports&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;PentAGI&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;td&gt;419 (233 with its default certificate)&lt;/td&gt;
&lt;td&gt;8443, 8666, 8765&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agent Zero&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;td&gt;173 (134 at a login, 39 open)&lt;/td&gt;
&lt;td&gt;5080, 50080&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ScopeWeaver&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;td&gt;43&lt;/td&gt;
&lt;td&gt;8787&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cairn&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;td&gt;41&lt;/td&gt;
&lt;td&gt;8000&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RedAmon&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;td&gt;27&lt;/td&gt;
&lt;td&gt;3000, 443&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Xalgorix&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;9137&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Strix (results viewer)&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;td&gt;8080&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pojun&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;td&gt;11&lt;/td&gt;
&lt;td&gt;8787&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decepticon&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;3000&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;LuaN1aoAgent&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;8787&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CyberStrike&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;8888&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T3MP3ST&lt;/td&gt;
&lt;td&gt;service in some setups&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;3333&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Incalmo&lt;/td&gt;
&lt;td&gt;web UI by default&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;8443&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxfgg4jxacvbzi0ytwuxd.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxfgg4jxacvbzi0ytwuxd.png" alt="Count-only Shodan services by tool on Nov. 7, 2026, log scale: ARTEX family 1,428, PentAGI 419, Agent Zero 173, ScopeWeaver 43, Cairn 41, RedAmon 27, Strix 13, Pojun 11, Xalgorix 6, Decepticon 4, LuaN1aoAgent 2, CyberStrike 2, T3MP3ST 1, Incalmo 1." width="800" height="587"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Figure: count-only Shodan services per tool on 2026-11-07, log scale, led by the ARTEX family at 1,428&lt;/p&gt;

&lt;h2&gt;
  
  
  What to take from this
&lt;/h2&gt;

&lt;p&gt;Forty-five frameworks, but the risk clusters in a handful of widely forked bases, not in the most-starred repositories.&lt;/p&gt;

&lt;p&gt;Almost none of these tools ship a secret-hunting pipeline, but that is no comfort. Each hands its agent a shell and web access, so the model can assemble one at runtime. A GitHub search, a scanner download, a found key passed to the next call: all one prompt away, none of it shipped in the repo.&lt;/p&gt;

&lt;p&gt;Dozens of operator consoles answered a Shodan query on our scan date, many behind no real barrier. We publish fingerprint descriptions, not a target list, so defenders can find their own exposed instances first.&lt;/p&gt;

&lt;h2&gt;
  
  
  Hunting queries
&lt;/h2&gt;

&lt;p&gt;The following table summarizes the Shodan queries we used to match the live tools' public instances&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Shodan query&lt;/th&gt;
&lt;th&gt;Matches on&lt;/th&gt;
&lt;th&gt;Count&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;PentAGI&lt;/td&gt;
&lt;td&gt;http.title:"PentAGI"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;521&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentAGI&lt;/td&gt;
&lt;td&gt;http.favicon.hash:-1596753120&lt;/td&gt;
&lt;td&gt;favicon hash&lt;/td&gt;
&lt;td&gt;419&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentAGI&lt;/td&gt;
&lt;td&gt;ssl.cert.issuer.cn:"PentAGI CA"&lt;/td&gt;
&lt;td&gt;TLS certificate&lt;/td&gt;
&lt;td&gt;240&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agent Zero&lt;/td&gt;
&lt;td&gt;http.title:"Agent Zero"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;173&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agent Zero&lt;/td&gt;
&lt;td&gt;http.title:"Login - Agent Zero"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;134&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Agent Zero&lt;/td&gt;
&lt;td&gt;http.title:"Agent Zero" -http.title:"Login"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;39&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ScopeWeaver&lt;/td&gt;
&lt;td&gt;http.title:"ScopeWeaver"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;43&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ScopeWeaver&lt;/td&gt;
&lt;td&gt;http.html:"Console for an LLM-driven autonomous penetration testing system"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;49&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RedAmon&lt;/td&gt;
&lt;td&gt;http.title:"RedAmon"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;29&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RedAmon&lt;/td&gt;
&lt;td&gt;http.favicon.hash:964522141&lt;/td&gt;
&lt;td&gt;favicon hash&lt;/td&gt;
&lt;td&gt;28&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RedAmon&lt;/td&gt;
&lt;td&gt;http.html:"Security reconnaissance and vulnerability assessment dashboard"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;29&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Xalgorix&lt;/td&gt;
&lt;td&gt;http.title:"Xalgorix"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Xalgorix&lt;/td&gt;
&lt;td&gt;http.html:"xalgorix.theme"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Xalgorix&lt;/td&gt;
&lt;td&gt;http.favicon.hash:248472114&lt;/td&gt;
&lt;td&gt;favicon hash&lt;/td&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Strix&lt;/td&gt;
&lt;td&gt;http.title:"Strix Results"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Strix&lt;/td&gt;
&lt;td&gt;http.favicon.hash:-566184040&lt;/td&gt;
&lt;td&gt;favicon hash&lt;/td&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decepticon&lt;/td&gt;
&lt;td&gt;http.html:"Autonomous Red Team Platform"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decepticon&lt;/td&gt;
&lt;td&gt;http.title:"Decepticon"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Decepticon&lt;/td&gt;
&lt;td&gt;http.favicon.hash:-1814445533&lt;/td&gt;
&lt;td&gt;favicon hash&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;LuaN1aoAgent&lt;/td&gt;
&lt;td&gt;http.title:"鸾鸟渗透智能体"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;LuaN1aoAgent&lt;/td&gt;
&lt;td&gt;http.title:"鸾鸟Agent"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CyberStrike&lt;/td&gt;
&lt;td&gt;http.title:"CyberStrike"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;19&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CyberStrike&lt;/td&gt;
&lt;td&gt;http.title:"CyberStrike" http.html:"favicon-v3.svg"&lt;/td&gt;
&lt;td&gt;page title + HTML&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T3MP3ST&lt;/td&gt;
&lt;td&gt;http.html:"T3MP3ST"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;T3MP3ST&lt;/td&gt;
&lt;td&gt;http.title:"T3MP3ST"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Incalmo&lt;/td&gt;
&lt;td&gt;http.html:"Incalmo C2 Server API"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;redcell&lt;/td&gt;
&lt;td&gt;http.html:"rc-theme"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;59&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;redcell&lt;/td&gt;
&lt;td&gt;http.title:"REDCELL"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestCode&lt;/td&gt;
&lt;td&gt;http.favicon.hash:-196523122&lt;/td&gt;
&lt;td&gt;favicon hash&lt;/td&gt;
&lt;td&gt;167&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PentestCode&lt;/td&gt;
&lt;td&gt;http.title:"PentestCode"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Pentest-Swarm-AI&lt;/td&gt;
&lt;td&gt;http.html:'{"error":{"code":"404","message":"Cannot GET /"}}'&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;310&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cyber-harness&lt;/td&gt;
&lt;td&gt;http.html:"cyber-theme"&lt;/td&gt;
&lt;td&gt;page HTML&lt;/td&gt;
&lt;td&gt;75&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cyber-harness&lt;/td&gt;
&lt;td&gt;http.title:"Cyber" http.html:"cyber-theme"&lt;/td&gt;
&lt;td&gt;page title + HTML&lt;/td&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ycode&lt;/td&gt;
&lt;td&gt;http.title:"月落"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;virga&lt;/td&gt;
&lt;td&gt;http.html_hash:911008380&lt;/td&gt;
&lt;td&gt;page body hash&lt;/td&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Nebula&lt;/td&gt;
&lt;td&gt;http.title:"Nebula 3"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;sapper-v2&lt;/td&gt;
&lt;td&gt;http.title:"sapper — engagement graph"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FORANG&lt;/td&gt;
&lt;td&gt;http.title:"FORANG"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Mergen MCP&lt;/td&gt;
&lt;td&gt;http.title:"MERGEN — Arsenal"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AutoRedTeam&lt;/td&gt;
&lt;td&gt;ssl.cert.subject.cn:"AutoRedTeam C2"&lt;/td&gt;
&lt;td&gt;TLS certificate&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;pentest-ai&lt;/td&gt;
&lt;td&gt;http.title:"pentest-ai · dashboard"&lt;/td&gt;
&lt;td&gt;page title&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;ARTEX is just one of many tools that hunt for exposed secrets. Do you know what they'd find? &lt;a href="https://www.gitguardian.com/github-security-audit" rel="noopener noreferrer"&gt;Run a free GitHub Security Audit&lt;/a&gt; to see which credentials linked to your organization are already exposed on public GitHub.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What are agentic AI pentesting tools?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Agentic AI pentesting tools are open-source projects that wire a language model into a loop that runs tools and acts on their output. About 45 exist. GitGuardian cataloged 32 of them into five families: network kill chain, web app and API, command-and-control (C2) integrated, harnesses, and research prototypes. The rest are forks and variants that reuse a family's pattern.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is an autonomous AI for cyber attacks?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;An autonomous AI for cyber attacks is a self-sufficient system that can independently plan, execute, and adapt complex cyber intrusions with little to no human involvement. Unlike traditional methods, where a human takes the reins and uses AI to generate code or craft phishing emails, this kind of AI operates on its own. It analyzes the environment, makes tactical decisions in real time, and can quickly change its strategy if it encounters any defenses. Essentially, it's like having a digital strategist that can outsmart obstacles on its own.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do agentic AI pentesting tools hunt for secrets on GitHub?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Agentic AI pentesting tools rarely ship secret-hunting on their own. Four ship a real scanner wired to the agent: Pojun, Cybermes, Xalgorix, and AIRecon. None of them contains a GitHub fetcher.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why do agentic AI pentesting tools still matter if they don't ship a secret-hunting pipeline?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Agentic AI pentesting tools hand their agent a shell and web access, so the model can assemble a pipeline at runtime. A GitHub search, a scanner download, and a found key passed to the next call are all one prompt away, even though none of it ships in the repository.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How many ARTEX consoles are exposed on Shodan?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;ARTEX consoles matched 1,428 count-only Shodan services on Nov. 7, 2026, the most of any tool in the catalog. PentAGI followed with 419 and Agent Zero with 173.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do you find exposed agentic AI pentesting tools on Shodan?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Agentic AI pentesting tools are found on Shodan with fingerprints that match a page title, favicon hash, page HTML, or TLS certificate. Of the 41 frameworks assessed, 11 serve a web UI by default, 18 serve one only in some setups or show nothing distinctive at the root, and 12 have no listener at all. GitGuardian wrote 56 fingerprint records, one per build with a distinct web interface.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Are exposed agentic AI pentesting consoles protected?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Exposed agentic AI pentesting consoles are often not protected. Dozens answered a Shodan query on the scan date, many behind no real barrier. Of the 173 Agent Zero services found, 134 sat at a login and 39 were open.&lt;/p&gt;

</description>
      <category>security</category>
      <category>ai</category>
      <category>github</category>
      <category>devsecops</category>
    </item>
    <item>
      <title>The Agents Have Now Found Your Secrets On GitHub: ARTEX Is Abusing Public Secrets Right Now</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Tue, 10 Nov 2026 14:14:53 +0000</pubDate>
      <link>https://dev.to/gitguardian/the-agents-have-now-found-your-secrets-on-github-artex-is-abusing-public-secrets-right-now-5194</link>
      <guid>https://dev.to/gitguardian/the-agents-have-now-found-your-secrets-on-github-artex-is-abusing-public-secrets-right-now-5194</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Five minutes from GitHub to Azure Key Vault:&lt;/strong&gt; Microsoft Threat Intelligence saw an ARTEX agent find OAuth application secrets on public GitHub, sign in as a service principal, and exfiltrate Key Vault data in five minutes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;64% of 2022's valid secrets still active:&lt;/strong&gt; GitGuardian counted 28.65 million new hardcoded secrets in 2025, and leaked credentials stay usable for years, giving agentic attackers a deep pool to search.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Deleting the commit fixes nothing:&lt;/strong&gt; an exposed credential stays usable until someone revokes or rotates it, so check validity, ownership, and access, then revoke without waiting for proof of abuse.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;On November 5, Microsoft Threat Intelligence published research showing threat actors using an agentic AI framework called ARTEX to &lt;a href="https://www.microsoft.com/en-us/security/blog/2026/11/05/threat-actors-use-agentic-ai-tooling-to-find-and-abuse-exposed-secrets/" rel="noopener noreferrer"&gt;search public GitHub for exposed secrets and abuse them&lt;/a&gt;. The agents found OAuth application secrets, signed in as service principals, and moved through Azure and Microsoft 365 tenants. In one case, an agent went from scanning GitHub to exfiltrating data from Azure Key Vault in five minutes. &lt;strong&gt;Five. minutes.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;At GitGuardian, we have been warning everyone about this exact scenario for years. The only new part is that the attackers are no longer working at human speed. This is what an attack on the &lt;a href="https://blog.gitguardian.com/credential-layer-security/" rel="noopener noreferrer"&gt;credential layer&lt;/a&gt; looks like. A secret exposed in public code gives an attacker access to a trusted identity, which they can then use to move through cloud infrastructure and reach sensitive data.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is ARTEX, and how widely is it being used?
&lt;/h2&gt;

&lt;p&gt;ARTEX is an agentic penetration testing framework built to run offensive tasks autonomously. It is deliberately generic: it ships with only a minimal set of tools and instructions, and few of them are offensive. Most of the decision-making is left to the agent. The operator provides a goal and can step in later to correct the agent when it drifts.&lt;/p&gt;

&lt;p&gt;The tool was published on GitHub in late July and received updates after that, the last one on Oct. 3. It was pulled from GitHub on Oct. 8, right after the first report of use by threat actors.&lt;/p&gt;

&lt;p&gt;The removal did not stop the attacks, as Microsoft noted in its latest report. &lt;a href="https://censys.com/blog/artex-agentic-asbestos/" rel="noopener noreferrer"&gt;Censys data&lt;/a&gt; shows roughly 1,400 publicly exposed ARTEX instances across approximately 800 distinct-looking deployments as of Nov. 4. A &lt;a href="https://research.checkpoint.com/2026/hacking-on-autopilot-inside-artex-cybercrime-campaigns/" rel="noopener noreferrer"&gt;Check Point report&lt;/a&gt; published Nov. 5 reports more than 1,800 publicly exposed instances. The figures use different measurement methods, so they don't necessarily represent an increase of 400 instances in a single day. Both are incomplete views of ARTEX deployment, since its management interface does not need to be publicly exposed.&lt;/p&gt;

&lt;p&gt;ARTEX can be fingerprinted with two requests. &lt;code&gt;GET /api/health&lt;/code&gt; returns a distinctive JSON response on standard builds, and &lt;code&gt;GET /api/auth/status&lt;/code&gt; discloses whether the first-run administrator setup is complete:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight http"&gt;&lt;code&gt;&lt;span class="no"&gt;GET&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;api&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;health&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"ok"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s2"&gt;"service"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"artex"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="s2"&gt;"version"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="s2"&gt;"..."&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="no"&gt;GET&lt;/span&gt; &lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;api&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;auth&lt;/span&gt;&lt;span class="o"&gt;/&lt;/span&gt;&lt;span class="n"&gt;status&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"initialized"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="kc"&gt;true&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="kc"&gt;false&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Together, these endpoints identify the application and reveal whether the deployment is still in its initial setup state.&lt;/p&gt;

&lt;p&gt;The campaigns analyzed by Check Point were mostly opportunistic attacks conducted with minimal human intervention. Their objectives included:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Draining cryptocurrency&lt;/li&gt;
&lt;li&gt;Stealing gaming accounts&lt;/li&gt;
&lt;li&gt;Stealing Apple code-signing certificates&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Since the tool was first published, researchers have also linked ARTEX to attacks involving South Korean financial institutions, ConnectWise customer environments, and WorkOS. Not every reported target experienced a confirmed compromise, but the range of activity shows how broadly the framework is being used.&lt;/p&gt;

&lt;h2&gt;
  
  
  Do this today
&lt;/h2&gt;

&lt;p&gt;Microsoft has observed this activity in real attacks. Their official reports recommend acting on publicly exposed secrets as soon as possible. CERT IN, &lt;a href="https://www.cert-in.org.in/s2cMainServlet?VLCODE=CIAD-2026-0058&amp;amp;pageid=PUBVLNOTES02" rel="noopener noreferrer"&gt;in a recent report&lt;/a&gt; on the ARTEX threat, provides similar guidance.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;"Prohibit hardcoded tokens and credentials in source and build code; deploy automated secret scanning across repositories and CI/CD pipelines; use short-lived, fine-grained, least-privileged access tokens and rotate all build and deployment tokens."&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;If your organization has credentials exposed on GitHub, you need to know which ones are still valid and what they can access.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Check your public exposure with the &lt;a href="https://www.gitguardian.com/github-security-audit" rel="noopener noreferrer"&gt;GitHub Security Audit&lt;/a&gt;.&lt;/strong&gt; Enter your company domain to assess secrets associated with your developers' public GitHub activity, including repositories outside your organization.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Scan your internal repositories for hardcoded secrets.&lt;/strong&gt; Public GitHub is the immediate hunting ground described in Microsoft's research, but your own repositories may contain credentials that create additional exposure. &lt;a href="https://www.gitguardian.com/monitor-internal-repositories-for-secrets" rel="noopener noreferrer"&gt;Start scanning with GitGuardian&lt;/a&gt; to find secrets in your private code and commit history. You can start for free or evaluate broader capabilities through a business trial.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Prioritize and revoke exposed credentials.&lt;/strong&gt; Start with valid, high-privilege credentials, especially OAuth application and service principal secrets that provide access to sensitive cloud resources, data, or other credentials. Revoke or rotate exposed keys immediately, then investigate whether they were used. If an application was compromised, check what else it could access.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Need help assessing exposure at scale?&lt;/strong&gt; &lt;a href="https://www.gitguardian.com/book-a-demo" rel="noopener noreferrer"&gt;&lt;strong&gt;Talk to our team&lt;/strong&gt;&lt;/a&gt;&lt;strong&gt;.&lt;/strong&gt; We can help you identify exposed credentials, prioritize the risks, and coordinate remediation across your organization. You can also reach us at &lt;a href="mailto:sales@gitguardian.com"&gt;sales@gitguardian.com&lt;/a&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  The recipe has been the same since 2017
&lt;/h2&gt;

&lt;p&gt;Searching public code for credentials is the oldest trick in the cloud attack playbook. GitGuardian has scanned every public GitHub commit since 2017. The &lt;a href="https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026/" rel="noopener noreferrer"&gt;State of Secrets Sprawl 2026&lt;/a&gt; counted 28.65 million new hardcoded secrets in 2025. Four years later, 64% of the valid secrets from 2022 are still active.&lt;/p&gt;

&lt;p&gt;Put those numbers next to the Microsoft research, and the conclusion writes itself. Millions of valid credentials sit in public GitHub repositories, many still valid years after they leaked. And AI is adding to the problem: leaks of AI-service secrets grew 81% in 2025 alone. Attackers have been automating the search for exposed credentials for years. Now, with agentic AI, they can find exposed credentials, test their access, and move through compromised environments with minimal human intervention.&lt;/p&gt;

&lt;h2&gt;
  
  
  Attackers are moving at machine speed, targeting your weakest link
&lt;/h2&gt;

&lt;p&gt;Microsoft describes agents sending large volumes of GitHub queries that combine a target company name, secret keywords, and cloud or AI service names. Once inside a tenant, the agent corrected its own failed cloud API calls and retried within a minute or so until it succeeded. Picture a pentester who never sleeps, never gets bored, and costs a few dollars of inference. All it needs is one valid credential to gain access.&lt;/p&gt;

&lt;p&gt;We've seen how quickly attackers can collect and spread stolen credentials. For example, in August 2025, the &lt;a href="https://blog.gitguardian.com/the-nx-s1ngularity-attack-inside-the-credential-leak/" rel="noopener noreferrer"&gt;Nx s1ngularity attack&lt;/a&gt; became the first known malware our researchers looked into that hijacked AI CLI tools on developer laptops to hunt for credentials. Weeks later, &lt;a href="https://blog.gitguardian.com/shai-hulud-a-persistent-secret-leaking-campaign/" rel="noopener noreferrer"&gt;Shai-Hulud&lt;/a&gt; turned stolen npm tokens into a self-spreading credential stealer. &lt;a href="https://blog.gitguardian.com/shai-hulud-2/" rel="noopener noreferrer"&gt;Shai-Hulud 2.0&lt;/a&gt; exposed more than 33,000 unique secrets. The &lt;a href="https://blog.gitguardian.com/a-mini-shai-hulud-targeting-the-sap-ecosystem/" rel="noopener noreferrer"&gt;Mini Shai-Hulud wave&lt;/a&gt; showed the worm still adapting in 2026. These campaigns dumped stolen secrets onto public GitHub, the same hunting ground the ARTEX agents now search.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The reality is you need to assume breach right now&lt;/strong&gt;. Security teams should treat publicly exposed secrets as compromised and apply the same precaution to exposed credentials in internal repositories and systems. Identify which credentials are still valid, understand what they can access, and revoke or rotate them. Investigate whether they've already been used, but don't wait for confirmation of abuse before acting.&lt;/p&gt;

&lt;p&gt;Revoking credentials without knowing what it breaks also brings risks. This leads many teams to think the best move is to simply take those repos offline. That is not enough, though.&lt;/p&gt;

&lt;h2&gt;
  
  
  Deleting the commit fixes nothing
&lt;/h2&gt;

&lt;p&gt;Microsoft says it plainly. A publicly exposed credential stays usable until someone revokes or rotates it. Deleting the file or rewriting Git history doesn't invalidate it. Finding an exposed secret is only the first step. You need to know whether it's still valid, who owns it, and what it can access before you can effectively remediate it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Detect, remediate, and prevent
&lt;/h2&gt;

&lt;p&gt;Attackers are moving faster than ever, and security teams need to know which credentials are exposed, what they can access, and how to shut down that access before attackers can abuse it.&lt;/p&gt;

&lt;p&gt;GitGuardian helps organizations discover exposed credentials across public and private environments. Our free &lt;a href="https://www.gitguardian.com/github-security-audit" rel="noopener noreferrer"&gt;GitHub Security Audit&lt;/a&gt; identifies public exposure associated with your developers, while &lt;a href="https://www.gitguardian.com/monitor-internal-repositories-for-secrets" rel="noopener noreferrer"&gt;Internal Secrets Monitoring&lt;/a&gt; finds hardcoded secrets across private repositories and CI/CD pipelines. We also built &lt;a href="https://blog.gitguardian.com/announcing-has-my-secret-leaked" rel="noopener noreferrer"&gt;HasMySecretLeaked&lt;/a&gt;, a free way to check whether a credential has appeared on public GitHub without revealing the secret itself. Our &lt;a href="https://blog.gitguardian.com/unveiling-public-leak-checks-for-hardcoded-secrets-in-the-gitguardian-platform" rel="noopener noreferrer"&gt;public leak checks&lt;/a&gt; extend that visibility to credentials stored in vaults and pipelines.&lt;/p&gt;

&lt;p&gt;Finding exposed credentials is the beginning. GitGuardian helps teams prioritize remediation by validating which credentials are still active and providing context about their owners, identities, permissions, and potential impact. Incident grouping, automated routing, and custom playbooks help teams coordinate remediation at scale. For supported providers, GitGuardian can even revoke compromised credentials directly, cutting off attackers' access.&lt;/p&gt;

&lt;p&gt;We also need to prevent the next leak. GitGuardian's &lt;a href="https://docs.gitguardian.com/ggshield-docs/integrations/overview" rel="noopener noreferrer"&gt;ggshield&lt;/a&gt; catches secrets before they reach repositories through pre-commit and pre-push scanning. &lt;a href="https://www.gitguardian.com/developer-endpoint-protection" rel="noopener noreferrer"&gt;Developer Endpoint Protection&lt;/a&gt; helps find credentials stored on developer machines, while &lt;a href="https://docs.gitguardian.com/endpoint-protection/ai-hooks" rel="noopener noreferrer"&gt;AI Hooks&lt;/a&gt; add preventative controls to AI coding workflows, stopping secrets from being exposed through agent actions.&lt;/p&gt;

&lt;p&gt;The robots have arrived, and they read GitHub faster than any of us. Let's make sure they don't find secrets.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is ARTEX?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;ARTEX is an agentic penetration testing framework built to run offensive tasks autonomously. It ships with only a minimal set of tools and instructions and leaves most decisions to the agent: the operator sets a goal and can step in to correct the agent when it drifts.&lt;/p&gt;

&lt;p&gt;The tool was published on GitHub in late July 2026 and pulled on Oct. 8, right after the first report of its use by threat actors.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How are attackers using ARTEX to abuse exposed GitHub secrets?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;According to Microsoft Threat Intelligence, ARTEX agents send large volumes of GitHub queries that combine a target company name, secret keywords, and cloud or AI service names. When they find OAuth application secrets, they sign in as service principals and move through Azure and Microsoft 365 tenants.&lt;/p&gt;

&lt;p&gt;In one case Microsoft observed, an agent went from scanning GitHub to exfiltrating data from Azure Key Vault in five minutes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Did removing ARTEX from GitHub stop the attacks?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;No. The removal did not stop the attacks, as Microsoft noted in its latest report. Censys data shows roughly 1,400 publicly exposed ARTEX instances across approximately 800 distinct-looking deployments as of Nov. 4. A Check Point report published Nov. 5 reports more than 1,800 publicly exposed instances.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does deleting a leaked secret from GitHub make it safe?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;No. A publicly exposed credential stays usable until someone revokes or rotates it. Deleting the file or rewriting Git history does not invalidate it.&lt;/p&gt;

&lt;p&gt;Treat any secret exposed in public code as compromised, then check whether it is still valid, who owns it, and what it can access.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What should I do if my credentials are exposed on GitHub?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Assume breach. Identify which exposed credentials are still valid, understand what they can access, and revoke or rotate them, starting with high-privilege OAuth application and service principal secrets. Investigate whether they were used, but don't wait for confirmation of abuse before acting.&lt;/p&gt;

&lt;p&gt;GitGuardian's free GitHub Security Audit shows public exposure tied to your developers, and HasMySecretLeaked checks whether a specific credential has appeared on public GitHub without revealing it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why does agentic AI make leaked secrets more dangerous?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Attackers have automated the search for exposed credentials for years. Agentic AI also lets them test access and move through compromised environments with minimal human intervention, at machine speed.&lt;/p&gt;

&lt;p&gt;The pool of targets is large: the State of Secrets Sprawl 2026 counted 28.65 million new hardcoded secrets on public GitHub in 2025, and leaks of AI-service secrets grew 81% that year.&lt;/p&gt;

</description>
      <category>security</category>
      <category>github</category>
      <category>ai</category>
      <category>secrets</category>
    </item>
    <item>
      <title>GitHub Octoverse 2026: AI Agents, Citizen Developers, and the New Security Reality</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Tue, 03 Nov 2026 14:11:02 +0000</pubDate>
      <link>https://dev.to/gitguardian/github-octoverse-2026-ai-agents-citizen-developers-and-the-new-security-reality-1ifl</link>
      <guid>https://dev.to/gitguardian/github-octoverse-2026-ai-agents-citizen-developers-and-the-new-security-reality-1ifl</guid>
      <description>&lt;h2&gt;
  
  
  &lt;strong&gt;TL;DR&lt;/strong&gt;
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Code is being written three times faster than anyone can review it&lt;/strong&gt;: GitHub logged 34.3 billion commits this year, up from 12.9 billion, and more than 40% of pull requests now start with an AI agent, not a human.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The newest developers are not developers&lt;/strong&gt;: Citizen coders now ship apps wired to business systems with API keys they have never been taught to protect. Claude Code-assisted commits already leak secrets more often than human-made commits.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A leaked key outlives your whole security program&lt;/strong&gt;: 64% of credentials found valid were still valid more than four years later. See which controls actually keep pace with agents, automation, and everyone who can now ship code.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Every year, we look forward to GitHub's State of the Octoverse report. It is one of the best leading indicators of where software development is heading, and what the rest of the technology industry can expect in the coming years. This year's report is especially exciting, and the numbers are staggering.&lt;/p&gt;

&lt;p&gt;Over the past year, developers generated 34.3 billion commits across GitHub, up from 12.9 billion the previous year. That is nearly three times the activity in just one year. Even more remarkable, over 40% of pull requests now start with an AI agent, up from just 17% six months earlier. GitHub Actions also executed more than 45 billion jobs, over three times the previous year's total.&lt;/p&gt;

&lt;p&gt;These numbers signal a fundamental change in who creates software and how quickly it gets built. Professional developers are working faster, citizen developers are creating applications with AI, and autonomous agents are taking on more development tasks.&lt;/p&gt;

&lt;p&gt;These numbers are also startling when you consider trends already reported in other reports like &lt;a href="https://www.gitguardian.com/state-of-secrets-sprawl-report-2026" rel="noopener noreferrer"&gt;GitGuardian's State of Secrets Sprawl 2026&lt;/a&gt;, which documented a record 28.65 million exposed secrets in public GitHub commits during 2025.&lt;/p&gt;

&lt;p&gt;The trends emerging on GitHub today show where we are headed as an industry and what organizations everywhere will soon be managing. Here are the five findings that stood out to our team and what they tell us about the future of software security.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Five key takeaways from GitHub Octoverse 2026&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F19o3yobho3884se2xpim.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F19o3yobho3884se2xpim.png" alt="Five key takeaways from GitHub Octoverse 2026" width="800" height="587"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;GitHub's latest Octoverse report reveals how quickly AI is transforming software development. Here are the top stats that popped out to our team:&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;1. Software development is accelerating faster than ever&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;GitHub recorded 34.3 billion commits in 2026, up from 12.9 billion the previous year. That is not a small increase. That is an explosion. Code pushes increased by approximately 167%, reaching 17.9 billion.&lt;/p&gt;

&lt;p&gt;GitGuardian's State of Secrets Sprawl 2026 had already documented a 43% increase in public commits during 2025, alongside a 34% increase in exposed secrets. The research showed the highest number ever recorded last year, at 28.65 million new secrets in public GitHub commits. While GitHub Push Protection does affect the rate, by their own numbers, they ran 5.8 billion scans this year vs the total 17.9 billion pushes. This implies the majority of code pushes go unchecked, which aligns with our conclusion that &lt;a href="https://blog.gitguardian.com/github-push-protection-enhancing-open-source-security-with-limitations-to-consider/" rel="noopener noreferrer"&gt;Push Protection is no silver bullet&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Across almost all recent security reports, we have seen a consistent trend of rapid growth. As software production accelerates, organizations need secrets detection and credential security controls that keep pace with development.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;2. AI agents are becoming everyday software developers&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;In March 2026, approximately 17% of pull requests started with an AI agent. By September, that figure exceeded 40%, representing approximately 110 million agent-started pull requests in a single month.&lt;/p&gt;

&lt;p&gt;We have previously identified &lt;a href="https://blog.gitguardian.com/claude-code-security-why-the-real-risk-lies-beyond-code/" rel="noopener noreferrer"&gt;security implications of AI-assisted development&lt;/a&gt;. Claude Code-assisted commits exposed secrets at approximately twice the baseline rate, with 3.2% containing a secret compared with 1.5% across public commits. We believe that this implies that people are not reviewing code deeply enough to catch security issues that the AI introduces.&lt;/p&gt;

&lt;p&gt;AI coding agents create many chances for unintended credential exposure and access to sensitive systems during otherwise legitimate development tasks. Preventative security controls need to operate during agent execution, alongside traditional source code scanning.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;3. Citizen developers are expanding software creation into every industry&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;GitHub reports more than 225 million developers on its platform. Public repositories associated with identifiable industries grew from about 9 million in 2022 to 25 million in 2026.&lt;/p&gt;

&lt;p&gt;AI-powered development tools are making it easier for employees without traditional programming experience to build applications. Citizen developers can now create internal dashboards, automate business workflows, and integrate external services using natural language instructions.&lt;/p&gt;

&lt;p&gt;These applications frequently require access to business systems through API keys and service credentials. Citizen developers may have limited experience with secrets management, application security, or cloud permissions.&lt;/p&gt;

&lt;p&gt;Organizations need secure development processes that are accessible to employees across departments. Safe defaults for credential handling let citizen coders build useful applications while reducing exposure. The right guardrails in the right workflows can prevent a lot of issues.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;4. Developer machines are a critical security boundary&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;AI coding assistants most commonly operate directly within a developer's environments. They can read project files, inspect application configurations, and execute commands as part of routine development work.&lt;/p&gt;

&lt;p&gt;Research into the second major wave of the &lt;a href="https://blog.gitguardian.com/shai-hulud-2/" rel="noopener noreferrer"&gt;Shai-Hulud supply chain attack&lt;/a&gt; identified 33,185 unique secrets across 6,943 compromised machines. Separate endpoint research found that 40% of high and critical secrets identified on developer laptops were located in AI tool directories and logs.&lt;/p&gt;

&lt;p&gt;Discovering and eliminating unnecessary local credentials reduces exposure. Preventative controls such as git hooks provide additional protection when agents interact with files and tools.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;5. Automation is growing faster than traditional credential remediation&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;GitHub Actions executed approximately 45.4 billion jobs during the latest reporting period, compared with 14 billion the previous year. This represents growth of more than 220% in automated development activity.&lt;/p&gt;

&lt;p&gt;As automation increases, organizations must manage a growing number of credentials and their associated permissions. This includes moving towards shorter-lived authentication mechanisms.&lt;/p&gt;

&lt;p&gt;More than &lt;a href="https://blog.gitguardian.com/credential-compromise-security-stack/" rel="noopener noreferrer"&gt;64% of credentials&lt;/a&gt;, originally found to be valid, stayed valid for more than four years, according to our research. The report also showed that 46% of critical secrets could be missed when prioritization relies exclusively on provider validation.&lt;/p&gt;

&lt;p&gt;As software development and automation continue accelerating, detecting exposed credentials, remediating existing risks, and preventing new exposures must become part of everyday development workflows.&lt;/p&gt;

&lt;p&gt;For more detail, read the full &lt;a href="https://github.blog/news-insights/octoverse/octoverse-commits-pushes-reach-new-highs-in-2026-as-developers-build-with-agents/" rel="noopener noreferrer"&gt;GitHub Octoverse 2026 report&lt;/a&gt; here.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Practical steps for securing AI-driven development&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F62vdyhts2ny8mq1aqsrm.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F62vdyhts2ny8mq1aqsrm.png" alt="Practical steps for securing AI-driven development" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;As AI agents and citizen developers take on more development tasks, organizations need to account for how credentials are accessed, shared, and used throughout these workflows. A few practical controls can help teams embrace faster development while reducing the risks of unintended credential exposure.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;1. Find and eliminate exposed credentials on developer machines&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Developer workstations frequently contain credentials in local configuration files, environment variables, and application settings. Attackers increasingly target these through infostealer-based supply chain attacks. AI coding agents can encounter and unexpectedly use these credentials while performing routine tasks. &lt;a href="https://www.gitguardian.com/developer-endpoint-protection" rel="noopener noreferrer"&gt;GitGuardian's Developer Endpoint Protection&lt;/a&gt; helps identify exposed secrets on developer machines and provides context for remediation. Moving plaintext credentials into approved secrets managers also reduces the risk of unintended access.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;2. Build credential protection into AI workflows&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;AI coding assistants increasingly interact with local files and external services on developers' behalf. &lt;a href="https://blog.gitguardian.com/ai-hooks-ai-coding-assistants/" rel="noopener noreferrer"&gt;GitGuardian AI Hooks&lt;/a&gt; can prevent credential exposure during these interactions. Embedding preventive controls directly into agent workflows lets developers benefit from AI automation with greater confidence. This supplements pre-commit git hooks to catch secrets out of code, which many developers have already adopted.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;3. Make secure secrets management accessible to everyone&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Citizen developers need straightforward ways to connect applications to business systems securely. Centralized secrets management and appropriate access permissions provide a foundation for safer development. GitGuardian helps teams identify exposed credentials, understand their ownership and potential impact, and prioritize remediation. We work with leading secret management solutions to make it easy to &lt;a href="https://blog.gitguardian.com/push-to-vault/" rel="noopener noreferrer"&gt;Push-to-Vault any exposed plaintext credential&lt;/a&gt;. These capabilities help organizations establish consistent credential security practices across developers of all experience levels.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;4. Strengthen supply chain security through credential protection&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;AI-assisted development is accelerating the creation of applications and infrastructure. Credentials used by repositories, build systems, and deployment pipelines can provide access to critical parts of the software supply chain. &lt;a href="https://www.gitguardian.com/monitor-internal-repositories-for-secrets" rel="noopener noreferrer"&gt;GitGuardian helps teams detect and remediate exposed credentials&lt;/a&gt; while preventing new exposures through local scanning and development workflow integrations. This reduces opportunities for credential compromise as software delivery continues to accelerate.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;AI-driven development demands a new approach to security&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;GitHub's State of the Octoverse 2026 confirms that AI is fundamentally changing how software is created and who gets to create it. Professional developers are producing code at unprecedented rates, AI agents are taking on increasingly complex tasks, and citizen developers are building applications that would have required specialized engineering skills just a few years ago.&lt;/p&gt;

&lt;p&gt;The number of applications, integrations, and credentials organizations must secure has never grown this fast. The attack surface is much larger now. GitGuardian's State of Secrets Sprawl 2026 already showed an increase in exposed secrets alongside the growth of AI-assisted development. As more employees and autonomous agents can build and deploy software, these risks will continue to challenge traditional security processes.&lt;/p&gt;

&lt;p&gt;Organizations need a comprehensive approach to credential layer security that scales with this new development reality. The GitGuardian platform addresses the whole credential layer, helping organizations detect exposed secrets across their environments, remediate credential risks with the context needed to prioritize action, and prevent future exposures throughout the development lifecycle. As citizen developers and AI agents accelerate software creation, this approach enables organizations to maintain control over their credentials while supporting innovation at an unprecedented pace.&lt;/p&gt;

&lt;p&gt;Ready to learn more? Take a quick tour of our platform. We would be glad to work with you if you'd like to start securing your credential layer today.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/interactive-demo" rel="noopener noreferrer"&gt;&lt;em&gt;Take an interactive tour&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is GitHub's State of the Octoverse report?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The State of the Octoverse is GitHub's annual report on how software development is changing. The 2026 edition shows 34.3 billion commits, up from 12.9 billion the year before, along with rapid growth in AI agent activity and automation. It is a useful leading indicator of what organizations everywhere will soon be managing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How is AI changing who builds software?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Professional developers are working faster, citizen developers are building applications with natural language instructions, and autonomous agents are taking on more development tasks. Over 40% of pull requests now start with an AI agent, up from about 17% six months earlier. GitHub also reports more than 225 million developers on its platform.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why do AI coding agents increase secrets exposure risk?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Agents can read project files, inspect configurations, and run commands, which creates many chances to encounter credentials during legitimate work. GitGuardian's State of Secrets Sprawl 2026 found that Claude Code-assisted public commits leaked secrets at 3.2%, compared with a 1.5% baseline across public commits. Preventive controls need to operate while the agent runs, alongside traditional source code scanning.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What security risks come with citizen developers?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Citizen developers can build internal dashboards, automate workflows, and connect external services, and those applications usually need API keys and service credentials. They may have limited experience with secrets management, application security, or cloud permissions. Safe defaults for credential handling let them build useful applications while reducing exposure.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why are developer machines a critical security boundary?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;AI coding assistants usually run directly in the developer's environment, where they can read project files and execute commands. Research on the second wave of the Shai-Hulud supply chain attack found 33,185 unique secrets across 6,943 compromised machines. Separate endpoint research found that 40% of high and critical secrets on developer laptops were in AI tool directories and logs.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does GitHub Push Protection solve the secrets sprawl problem?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;It affects the rate of exposure, but it does not remove the problem. GitHub ran 5.8 billion push protection scans this year against 17.9 billion total pushes. GitGuardian's State of Secrets Sprawl 2026 documented a record 28.65 million new secrets in public GitHub commits during 2025, so teams still need detection, remediation, and prevention across their own environments.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can organizations secure AI-driven development?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Find and eliminate exposed credentials on developer machines, build credential protection into AI workflows with GitGuardian AI Hooks, and make secrets management accessible to citizen developers, including Push-to-Vault for exposed plaintext credentials. Teams should also protect the credentials used by repositories, build systems, and deployment pipelines. Together, these steps support credential layer security that scales with faster development.&lt;/p&gt;

</description>
      <category>github</category>
      <category>security</category>
      <category>ai</category>
      <category>devsecops</category>
    </item>
    <item>
      <title>How GitGuardian Secures the Credential Layer: From Discovery to Remediation</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Mon, 02 Nov 2026 15:07:28 +0000</pubDate>
      <link>https://dev.to/gitguardian/how-gitguardian-secures-the-credential-layer-from-discovery-to-remediation-1epb</link>
      <guid>https://dev.to/gitguardian/how-gitguardian-secures-the-credential-layer-from-discovery-to-remediation-1epb</guid>
      <description>&lt;h2&gt;
  
  
  &lt;strong&gt;TL;DR:&lt;/strong&gt;
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Credentials stay valid long after exposure&lt;/strong&gt;: Exposed secrets are a standing risk because 64% of secrets confirmed valid in 2022 were still valid in January 2026, and they travel across repos, pipelines, laptops, and tickets.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Context turns detection into decisions&lt;/strong&gt;: Secret Analyzers show what a credential can access, and the Exploration Map shows its consumers and resources, so teams know who owns it and what breaks if it is revoked.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One platform covers detect, remediate, prevent&lt;/strong&gt;: Monitoring spans repos, CI/CD, public GitHub, and developer endpoints, with workflows, vault onboarding, and validity rechecks to confirm the old credential no longer works.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Modern enterprises run on credentials; those pieces of data that enable all of our services, infrastructure, AI, and fellow humans to connect together and get their work done.&lt;/p&gt;

&lt;p&gt;This takes many shapes; for example, API keys connect applications to services. Access tokens allow automation to interact with infrastructure. Service accounts keep production systems running. AI agents use credentials hardcoded in MCP (Model Context Protocol) servers to access the tools and resources they need to complete their tasks.&lt;/p&gt;

&lt;p&gt;Every one of those secrets represents real access. When a credential is exposed, an attacker may gain the same access as the person, application, or machine it belongs to. When an AI agent, like a coding assistant, finds it, the outcome can be unpredictable.&lt;/p&gt;

&lt;p&gt;Finding exposed credentials is the first step in our mission to Detect, Remediate, and Prevent plaintext secret sprawl. While many teams have tried various methods to detect secrets in isolated systems, finding all the secrets across the enterprise remains a real challenge, especially as the surface continually grows. GitGuardian helps you see the whole credential layer. The other real challenge for security teams starts after they discover any secret. Answering the resulting questions of "Who owns this?" "What does this connect to?" and "What breaks if I revoke this credential?" become the immediate challenge security teams face. This is where a lot of programs get overwhelmed.&lt;/p&gt;

&lt;p&gt;This is increasingly difficult for organizations as they rapidly expand their infrastructure and see new non-traditional engineers, or "citizen coders," adopt AI-assisted development. &lt;a href="https://www.gitguardian.com/state-of-secrets-sprawl-report-2026" rel="noopener noreferrer"&gt;GitGuardian's State of Secrets Sprawl 2026&lt;/a&gt; found 28.65 million new hardcoded secrets in public GitHub commits during 2025, a 34% increase from the previous year. The number of credentials requiring protection continues to grow as software development expands.&lt;/p&gt;

&lt;p&gt;GitGuardian brings together detection, credential context, remediation workflows, and prevention across the credential layer. This allows security teams to investigate exposures more efficiently, work with the people responsible for fixing them, and understand whether their credential security programs are improving over time.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;What the credential layer is and why attackers target it&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;The credential layer is a very broad concept. Basically, it is every surface where credentials can be created, stored, transmitted, or used. This is the real accounting of all systems, internal and external, where plaintext secrets can end up, regardless of their state or whether they are managed according to organizational policy.&lt;/p&gt;

&lt;p&gt;A credential is any piece of authentication material that grants access to a service, system, or data. API keys, access tokens, passwords, and private keys all fit this definition.&lt;/p&gt;

&lt;p&gt;As explained in our earlier article, &lt;a href="https://blog.gitguardian.com/credential-layer-security/" rel="noopener noreferrer"&gt;&lt;em&gt;What Is Credential Layer Security?&lt;/em&gt;&lt;/a&gt;, the credential layer spans the systems that connect an organization's software, infrastructure, and services.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Where credentials live now&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;It might be helpful to consider a typical application that retrieves customer information from a cloud database, rather than think about credentials in isolation. After all, no identity exists in a vacuum.&lt;/p&gt;

&lt;p&gt;Let's say an application uses an API key. A developer generated it within an identity provider. They stored it in AWS Secrets Manager and referenced it through a Kubernetes configuration, where it is ultimately consumed by a workload in a container.&lt;/p&gt;

&lt;p&gt;Another developer, later, troubleshoots the application and "temporarily" copies the needed credential into a local configuration file, forgetting to remove it before committing.&lt;/p&gt;

&lt;p&gt;Each system has a different purpose and may be managed by a different team. Yet all these surfaces are connected by the same credential. This one secret subsequently appears in a repository, pipeline log, or support ticket.&lt;/p&gt;

&lt;p&gt;Part of the challenge of dealing with this scenario is how we have administered security inside the enterprise. Security programs at most large organizations are divided along technology or departmental boundaries. Application security monitors code. IAM (identity and access management) manages identities and authorization. Platform engineering maintains the vault. Endpoint security monitors workstations.&lt;/p&gt;

&lt;p&gt;The credential moves across all these environments, making the associated risk an enterprise-wide concern.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Why an exposed credential stays a standing risk&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;A credential represents access. Possession of a leaked credential may be enough to authenticate and perform authorized operations under the compromised identity. Those permissions tend to be overly broad when talking about AI or machine access, as non-humans tend to break when they hit permission boundaries rather than raising their hands and asking for more rights.&lt;/p&gt;

&lt;p&gt;Static, plaintext credentials create a persistent opportunity for abuse while the credential remains valid. And they typically stay valid for a long time. The 2026 State of Secrets Sprawl research found that 64% of secrets confirmed valid in 2022 were still valid when retested in January 2026.&lt;/p&gt;

&lt;p&gt;Long-lived credentials provide attackers with a continuing access opportunity, especially when the same secret is reused across multiple systems.&lt;/p&gt;

&lt;p&gt;As AI agents become integrated into enterprise workflows, credential exposure takes on additional significance. Agents need access to APIs, infrastructure, and services to complete tasks. &lt;a href="https://blog.gitguardian.com/agentic-ai-security-blast-radius" rel="noopener noreferrer"&gt;Credentials and permissions determine the blast radius&lt;/a&gt; when one of these identities is compromised.&lt;/p&gt;

&lt;p&gt;Managing these risks requires organizations to understand the credential itself, the access it grants, and the systems that depend on it.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;How GitGuardian approaches credential layer security&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9yxh4mkvi3cdng5e07ws.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9yxh4mkvi3cdng5e07ws.png" alt="How GitGuardian approaches credential layer security" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;GitGuardian approaches credential layer security as a connected process that begins with discovering credentials and continues through investigation, remediation, and prevention.&lt;/p&gt;

&lt;p&gt;The platform brings together evidence from connected development systems, cloud and SaaS environments, developer endpoints, and secrets managers.&lt;/p&gt;

&lt;p&gt;The following table maps common security questions to the technical capabilities that help answer them.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Mapping credential risk to GitGuardian capabilities&lt;/strong&gt;
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Security question&lt;/th&gt;
&lt;th&gt;What GitGuardian provides&lt;/th&gt;
&lt;th&gt;Why it matters&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Where are credentials exposed?&lt;/td&gt;
&lt;td&gt;Scans developer endpoints, repositories, development workflows, supported SaaS platforms, cloud storage, and public GitHub, to name just a few sources.&lt;/td&gt;
&lt;td&gt;Establishes the scope of exposure&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Is the credential valid?&lt;/td&gt;
&lt;td&gt;Provider-specific validity checking and revalidation where supported&lt;/td&gt;
&lt;td&gt;Helps distinguish active access risk from invalid credentials&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What permissions does it grant?&lt;/td&gt;
&lt;td&gt;Secret Analyzers and provider-derived permission information&lt;/td&gt;
&lt;td&gt;Helps assess possible impact and prioritize response&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Who owns it?&lt;/td&gt;
&lt;td&gt;Commit attribution, source metadata, ownership suggestions, and manual assignment&lt;/td&gt;
&lt;td&gt;Connects incidents to people responsible for remediation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Where else does it exist?&lt;/td&gt;
&lt;td&gt;Incident occurrences, secret matching, and inventories across connected sources&lt;/td&gt;
&lt;td&gt;Helps identify additional exposures and stored copies&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Is it properly managed?&lt;/td&gt;
&lt;td&gt;Secrets-manager inventory, vault matching, metadata, and policy assessments&lt;/td&gt;
&lt;td&gt;Reveals unmanaged credentials and vault coverage gaps&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What might break if it changes?&lt;/td&gt;
&lt;td&gt;Exploration Map relationships connecting known consumers, resources, and incidents&lt;/td&gt;
&lt;td&gt;Helps responders investigate operational dependencies&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;How can we resolve the incident?&lt;/td&gt;
&lt;td&gt;Incident workflows, collaboration, feedback, integrations, supported revocation, and vault onboarding&lt;/td&gt;
&lt;td&gt;Reduces manual coordination and supports remediation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Has the risk been addressed?&lt;/td&gt;
&lt;td&gt;Validity rechecks, presence checks, incident activity, and lifecycle tracking&lt;/td&gt;
&lt;td&gt;Provides evidence to support resolution decisions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Is the program improving?&lt;/td&gt;
&lt;td&gt;Coverage, detection, remediation, and prevention analytics&lt;/td&gt;
&lt;td&gt;Helps leadership evaluate security progress and investment effectiveness&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These capabilities depend on the systems an organization has connected and the metadata available from each source. GitGuardian can progressively enrich credential context as coverage expands.&lt;/p&gt;

&lt;p&gt;This is how a credential security platform supports credential lifecycle management: it gives teams a consistent body of evidence to understand risk and coordinate appropriate action across otherwise separate systems.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Detect: find credentials across the enterprise&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;The field of secrets security mostly grew from the world of software development, so it makes sense that traditional secrets scanning has concentrated on source code, the CI/CD (continuous integration and continuous delivery) pipeline, and artifacts created in the process. And that remains an essential starting point, but we need to acknowledge that those are just a few aspects of the credential layer.&lt;/p&gt;

&lt;p&gt;Plaintext credentials routinely appear in places outside repositories and the traditional software supply chain or lifecycle. A comprehensive detection strategy must account for those additional surfaces, including all of the surfaces outside of traditional software delivery.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Code, CI/CD, containers, and collaboration tools&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Git is in our name, so of course we have provided for code scanning in git repositories through &lt;a href="https://www.gitguardian.com/monitor-internal-repositories-for-secrets" rel="noopener noreferrer"&gt;Internal Secrets Monitoring&lt;/a&gt;. But the platform goes beyond code, detecting exposed credentials across connected internal development environments and supported additional sources. This includes monitoring development infrastructure and supported locations such as collaboration tools, cloud storage, and container-related sources.&lt;/p&gt;

&lt;p&gt;This is vital to a complete inventory process, as the same credential may appear in multiple systems.&lt;/p&gt;

&lt;p&gt;An API key discovered in a repository may also have been copied into a Jira ticket or exposed through a configuration file. Finding its other known occurrences helps security teams investigate the full exposure instead of addressing each discovery independently.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Public GitHub, including developers' personal repositories&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/monitor-public-github-for-secrets" rel="noopener noreferrer"&gt;Public Secrets Monitoring&lt;/a&gt; extends discovery to public GitHub.&lt;/p&gt;

&lt;p&gt;This is particularly important for organizations whose developers work on personal projects, contribute to open source, or accidentally push company credentials to repositories outside the corporate GitHub organization.&lt;/p&gt;

&lt;p&gt;GitGuardian can identify public exposures associated with monitored organizational assets and help teams determine which credentials require investigation.&lt;/p&gt;

&lt;p&gt;Public exposure raises the urgency of understanding validity and privileges, since the credential may already be accessible outside the organization.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Developer laptops and the AI coding agents that run there&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;GitGuardian knows that any leak in a codebase, SaaS platform, or tool chain has to start somewhere. And that somewhere is most commonly the environment where the developer first created and copied any secrets. We refer to these environments as Developer Endpoints. This is where local configuration files, shell histories, IDE caches, and AI assistant directories accumulate plaintext secrets during the normal development process.&lt;/p&gt;

&lt;p&gt;GitGuardian's &lt;a href="https://www.gitguardian.com/developer-endpoint-protection" rel="noopener noreferrer"&gt;Developer Endpoint Protection&lt;/a&gt; uncovers these exposed credentials and gives your team insight into the risks they carry.&lt;/p&gt;

&lt;p&gt;Developer Endpoint Protection can be administered to all machines in your fleet via MDM (mobile device management) platforms like Jamf, Intune, or Iru. Detection happens locally, and the tooling only ever sends hashes and finding metadata to the GitGuardian platform. GitGuardian has no intention of storing your plaintext secrets either. Findings are evaluated by machine, severity, and validity.&lt;/p&gt;

&lt;p&gt;This extends detection to credentials that may never enter a repository but remain accessible to local applications, malware, or AI workflows.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Secrets managers and the credentials behind them&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Secrets managers are essential to securing credentials, but they only provide a view of the credentials enrolled in their systems.&lt;/p&gt;

&lt;p&gt;GitGuardian can connect to any popular secrets manager or vault, like Delinea, CyberArk's Conjur, AWS Secrets Manager, and many more, with &lt;a href="https://www.gitguardian.com/ggscout" rel="noopener noreferrer"&gt;ggscout&lt;/a&gt;. This tool securely builds a credential inventory, collecting only partial hash fingerprints and metadata. It can also be connected to CI/CD and Kubernetes artifacts that show how these secrets are used and move through environments.&lt;/p&gt;

&lt;p&gt;This includes information such as secret paths, associated environments, validity, provider permissions, ownership, and expiration where available.&lt;/p&gt;

&lt;p&gt;This enables teams to identify when a credential stored in a vault also appears in plaintext in a monitored source, or when an exposed credential appears to lack an approved vault location.&lt;/p&gt;

&lt;p&gt;GitGuardian can also help you move unvaulted credentials into a secrets manager with our &lt;a href="https://blog.gitguardian.com/push-to-vault/" rel="noopener noreferrer"&gt;Push-to-Vault functionality&lt;/a&gt;, providing a path developers can use to update their applications.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;A detection engine tuned for precision&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Detecting secrets across diverse sources requires handling different formats, providers, and authentication mechanisms.&lt;/p&gt;

&lt;p&gt;GitGuardian's detection engine uses provider-specific and generic detectors to recognize credentials. The platform has built over 600 secret detectors that cover the widest enterprise use cases. You can read more about &lt;a href="https://docs.gitguardian.com/secrets-detection/secrets-detection-engine/quick_start" rel="noopener noreferrer"&gt;how the secret detectors work in detail in our documentation&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://blog.gitguardian.com/precision-recall-security-zines/" rel="noopener noreferrer"&gt;Precision matters in detection&lt;/a&gt;. Security teams only have so much time. They need to devote their attention to actual risks. On the other end, any missed credentials leave potential access paths undiscovered. Teams need to know the alerts they get are real, timely, and actionable.&lt;/p&gt;

&lt;p&gt;After the alert is received, the security team's job is really just beginning. Next, they need to understand the context and risks associated with the detected plaintext credential.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Investigate: what an exposed credential can reach&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Detection merely identifies a possible security problem. The larger challenge comes in the investigation phase, where teams need to determine what the organization should do about it.&lt;/p&gt;

&lt;p&gt;For most, this is where the most time-consuming work begins.&lt;/p&gt;

&lt;p&gt;Consider an exposed AWS credential. AWS supports an enormous range of services and permission configurations. A credential associated with narrowly scoped read access to one service presents a different risk from a root user key granting broad administrative controls.&lt;/p&gt;

&lt;p&gt;Confirming that both credentials are valid is useful, but their privileges and operational roles are essential to determining the appropriate response.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Validity, permissions, and ownership&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;GitGuardian enriches incidents with information about the secret type, its occurrences, validity, source, and related metadata.&lt;/p&gt;

&lt;p&gt;Secret Analyzers provide information about the access a credential grants for an ever-expanding variety of credentials. Connected sources can contribute ownership, environment, and dependency information.&lt;/p&gt;

&lt;p&gt;This enriched data view of the world enables responders to address several questions directly:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Is this credential still usable?&lt;/li&gt;
&lt;li&gt;What can someone do with it?&lt;/li&gt;
&lt;li&gt;Where has it been exposed?&lt;/li&gt;
&lt;li&gt;Who should participate in remediation?&lt;/li&gt;
&lt;li&gt;Which systems may depend on it?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://docs.gitguardian.com/nhi-governance/discover-your-nhis#exploration-map" rel="noopener noreferrer"&gt;GitGuardian's Exploration Map&lt;/a&gt; makes the relationships between a credential, its known consumers, accessed resources, secrets managers, and related incidents visible.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fckcgp9atymqkbtwotbi1.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fckcgp9atymqkbtwotbi1.png" alt="GitGuardian Exploration Map, showing endpoint, consumers, secret managers, the secret type, and permissions" width="800" height="435"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The exploration map assembles and presents all the information collected from across the platform. Responders can easily evaluate potential consequences and prepare informed conversations with the developers and operations teams responsible for the affected systems.&lt;/p&gt;

&lt;p&gt;While it does not automatically eliminate the need for those conversations, it helps empower them to move more effectively.&lt;/p&gt;

&lt;p&gt;GitGuardian can identify that several workloads depend on a credential. The organization must still determine which workloads are business-critical, what downtime is acceptable, and how to coordinate the change safely.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Prioritization that looks past validity&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;A valid credential deserves attention, but validity alone cannot describe the full risk.&lt;/p&gt;

&lt;p&gt;GitGuardian provides incident risk scores that incorporate available context and explain the factors contributing to prioritization. Scores can change as additional information becomes available. These scoring criteria include scope of privileges and whether the secret connects to sensitive data or important operational systems. These high-risk exposures require a different response than narrowly scoped credentials used only in lower-risk environments.&lt;/p&gt;

&lt;p&gt;The final remediation priority also depends on the organization's risk tolerance and business requirements.&lt;/p&gt;

&lt;p&gt;By gathering the technical evidence, GitGuardian helps teams spend less time investigating basic facts and more time determining appropriate actions.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Remediate: close incidents, not just alerts&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Secrets remediation often stalls because the team discovering the exposure lacks the authority or operational knowledge needed to resolve it.&lt;/p&gt;

&lt;p&gt;A security engineer may know that a credential is dangerous while remaining uncertain about what revoking it would affect. Developers who understand those dependencies have limited time themselves and have competing priorities.&lt;/p&gt;

&lt;p&gt;This creates a backlog in which validated exposures can remain unresolved long after their initial discovery.&lt;/p&gt;

&lt;p&gt;GitGuardian helps bridge that gap by providing the technical context needed to move remediation forward. Incident details can identify the developer or other team member associated with a commit, ticket, blob, or message in a system.&lt;/p&gt;

&lt;p&gt;From a security operations workflow perspective, the platform tracks assignments and support feedback from the people responsible for remediation. GitGuardian supports Jira and ServiceNow so that organizations can coordinate work through established processes.&lt;/p&gt;

&lt;p&gt;The goal is to give the assigned developer or operations engineer enough information to act without having to repeat the investigation.&lt;/p&gt;

&lt;p&gt;For example, a remediation request involving a production credential can include its validity, known exposure locations, provider information, and available dependency context.&lt;/p&gt;

&lt;p&gt;The conversation can then focus on the operational implications of the proposed change.&lt;/p&gt;

&lt;p&gt;Instead of spending days identifying which credential is involved, teams can discuss when to rotate the credential, which applications need updating, and how to minimize business disruption.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Rotate, revoke, and move secrets into your vault&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Revocation and rotation are often the most appropriate responses to an exposed credential, particularly when there is a risk that an unauthorized party could use it. Both of these carry some level of risk, especially when the context is not fully understood. Performing any action that removes a credential from service without understanding its dependencies might interrupt production, break pipeline builds, or possibly cause cascading failures.&lt;/p&gt;

&lt;p&gt;GitGuardian helps teams perform the needed contextual analysis, workflow coordination, and provider-specific revocation capabilities where available so they can remediate faster and at scale.&lt;/p&gt;

&lt;p&gt;For credentials that remain outside approved vaults, GitGuardian can help move them into managed storage. Developers must then update their applications and deployment configurations to retrieve the credential through the approved mechanism.&lt;/p&gt;

&lt;p&gt;Our &lt;a href="https://blog.gitguardian.com/service-account-credential-rotation-checklist" rel="noopener noreferrer"&gt;guide to rotating a credential without breaking production&lt;/a&gt; provides additional operational guidance.&lt;/p&gt;

&lt;p&gt;Moving a credential into a vault is one part of the remediation process. The organization must also address exposed copies, revoke or invalidate compromised values when appropriate, and verify that dependent workloads continue to function.&lt;/p&gt;

&lt;p&gt;Human judgment remains essential when balancing immediate risk reduction against potential disruption to critical systems.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Verify remediation and retain the evidence&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Incident closure should be supported by evidence that the relevant security risk has been addressed.&lt;/p&gt;

&lt;p&gt;GitGuardian can recheck credential validity for supported secret types and determine whether known occurrences remain present in monitored surface, be it a repo, a SaaS platform, or the developer's laptop. The incident also captures feedback and remediation activity, including actions taken by developers and responders.&lt;/p&gt;

&lt;p&gt;That history remains useful after the incident is closed.&lt;/p&gt;

&lt;p&gt;GitGuardian provides a Closed but valid incident view, allowing teams to revisit incidents whose associated credentials are still reported as valid. This helps distinguish administrative completion from evidence that the credential can no longer authenticate.&lt;/p&gt;

&lt;p&gt;For security leaders, these records contribute to an ongoing understanding of remediation effectiveness. They support investigations, audits, and the process of identifying recurring weaknesses that require broader corrective action.&lt;/p&gt;

&lt;h3&gt;
  
  
  &lt;strong&gt;Governance policies that improve credential management&lt;/strong&gt;
&lt;/h3&gt;

&lt;p&gt;Prevention also involves identifying recurring weaknesses in how credentials are created, stored, and used.&lt;/p&gt;

&lt;p&gt;GitGuardian can reveal credentials stored outside approved vaults, excessive privileges in supported environments, and weaknesses in credential management practices.&lt;/p&gt;

&lt;p&gt;These insights help organizations evaluate whether established policies are producing the intended results.&lt;/p&gt;

&lt;p&gt;Over time, organizations can use this information to improve vault adoption, reduce credential reuse, address legacy authentication practices, and move suitable workloads toward stronger authentication mechanisms.&lt;/p&gt;

&lt;p&gt;The organization determines the appropriate policies and architectural direction. GitGuardian provides visibility and evidence to support those decisions.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;One credential, end to end: a working example&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Let's tie this together with an example from a fictional organization, based on real-life stories we have seen. In this fictional company, production applications run on Kubernetes.&lt;/p&gt;

&lt;p&gt;The application uses an API credential to access an external service. That credential was originally created through a SaaS provider and later placed in a secrets manager. During troubleshooting, a developer copied it into a local configuration file and eventually committed it to a repository.&lt;/p&gt;

&lt;p&gt;GitGuardian detects the exposed credential and creates an incident.&lt;/p&gt;

&lt;p&gt;Through supported validity checks and Secret Analyzer capabilities, the security team determines that the credential remains active and identifies its available permissions.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fffe5wy0buc0com0mzxh9.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fffe5wy0buc0com0mzxh9.png" alt="GitGuardian Secret Analyzer showing OpenAI secret permissions" width="800" height="716"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Responders use the Exploration Map to review known relationships involving the credential, its consumers, and accessed resources. The available context reveals that a production workload relies on the credential.&lt;/p&gt;

&lt;p&gt;The platform also identifies each occurrence and, where connected sources allow, matches the credential to its vault inventory and provides associated context.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8ky4t9fwwn9j6iensgi7.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8ky4t9fwwn9j6iensgi7.png" alt="GitGuardian exploration map showing multiple occurrences of the same leak" width="800" height="498"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;With information in hand, the security team can act with confidence or have a clear plan when they contact the responsible developer and operations teams.&lt;/p&gt;

&lt;p&gt;Everyone involved needs to agree on a remediation plan that accounts for the production dependency. The team prepares a replacement credential, updates deployment configurations, and revokes the original credential according to the organization's approved process.&lt;/p&gt;

&lt;p&gt;GitGuardian subsequently provides available validity and presence information to help the team verify its remediation work. The incident record preserves the actions and feedback associated with the resolution.&lt;/p&gt;

&lt;p&gt;The same incident also reveals a broader issue: the organization has a valid credential in a vault that was copied into an unmanaged local file and committed to source control.&lt;/p&gt;

&lt;p&gt;That discovery becomes useful beyond the immediate incident.&lt;/p&gt;

&lt;p&gt;The security team can investigate similar patterns across other sources and use coverage and analytics information to determine whether additional preventative controls or improvements to developer workflows are needed.&lt;/p&gt;

&lt;p&gt;One incident has generated the context needed for a safer remediation decision and evidence that can improve the larger credential security program.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Start with the credentials you already have&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Security teams can only remediate credential risks effectively when they understand what those credentials do and how they are connected to the business.&lt;/p&gt;

&lt;p&gt;GitGuardian brings credential discovery, contextual analysis, remediation support, and prevention together across the enterprise.&lt;/p&gt;

&lt;p&gt;For responders, that means spending less time assembling basic facts and more time coordinating the actions that reduce risk.&lt;/p&gt;

&lt;p&gt;For developers and operations teams, it means receiving better-informed remediation requests that account for the systems they maintain.&lt;/p&gt;

&lt;p&gt;For security leadership, it means gaining a clearer understanding of exposure, credential management maturity, and whether security investments are producing measurable improvements.&lt;/p&gt;

&lt;p&gt;The credential layer will continue expanding as organizations build more software, adopt new infrastructure, and introduce increasingly autonomous AI workflows.&lt;/p&gt;

&lt;p&gt;The organizations best positioned to manage that growth will be those that can consistently turn credential discoveries into informed decisions and lasting risk reduction.&lt;/p&gt;

&lt;p&gt;We invite you to take a tour of the GitGuardian platform.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/interactive-demo" rel="noopener noreferrer"&gt;&lt;em&gt;Take an interactive tour.&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;If you are ready to move ahead and improve your credential layer security, you can go ahead and book your demo.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/book-a-demo" rel="noopener noreferrer"&gt;&lt;em&gt;Book a demo.&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Why does an exposed credential stay a standing risk?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Possession of a leaked credential may be enough to authenticate and act as the compromised identity, and static plaintext credentials typically stay valid for a long time. GitGuardian's State of Secrets Sprawl 2026 research found that 64% of secrets confirmed valid in 2022 were still valid when retested in January 2026.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where does GitGuardian detect exposed credentials?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;GitGuardian monitors private repositories, CI/CD pipelines, container images, cloud configs, collaboration tools such as Slack, Jira, Confluence, and Google Drive, public GitHub including developers' personal repositories, and developer endpoints.&lt;/p&gt;

&lt;p&gt;Through ggscout, it also connects to secrets managers to build a credential inventory and spot credentials that never reached the vault or were copied out of it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How does GitGuardian help security teams investigate an exposed credential?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;GitGuardian enriches each incident with the secret type, occurrences, validity, source, and permissions. Secret Analyzers show the access a credential grants, and the Exploration Map shows its known consumers, accessed resources, secrets managers, and related incidents. Incident risk scores combine that context and explain what drives the prioritization.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can teams remediate an exposed credential without breaking production?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Start by understanding what depends on the credential before revoking or rotating it, because removing it from service blindly can interrupt production or break pipeline builds.&lt;/p&gt;

&lt;p&gt;GitGuardian provides ownership and dependency context, workflow integrations such as Jira and ServiceNow, and provider-specific revocation where available. For credentials outside approved vaults, Push-to-Vault helps move them into managed storage.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do you verify that a credential incident is actually resolved?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;GitGuardian can recheck validity for supported secret types and confirm whether known occurrences still exist in monitored sources. The Closed but valid incident view lets teams revisit incidents whose credentials are still reported as valid, which separates administrative completion from evidence that the credential can no longer authenticate.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does Developer Endpoint Protection send my plaintext secrets to GitGuardian?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;No. Detection happens locally on the machine, and the tooling only sends hashes and finding metadata to the GitGuardian platform. Findings are evaluated by machine, severity, and validity, and the tool can be deployed across a fleet through MDM platforms like Jamf, Intune, or Iru (formerly Kandji).&lt;/p&gt;

</description>
      <category>security</category>
      <category>secrets</category>
      <category>devsecops</category>
      <category>appsec</category>
    </item>
    <item>
      <title>Rotating 1,000 Service Account Passwords With Zero Outages: Why the Inventory Comes First</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Fri, 30 Oct 2026 13:28:34 +0000</pubDate>
      <link>https://dev.to/gitguardian/rotating-1000-service-account-passwords-with-zero-outages-why-the-inventory-comes-first-2ijc</link>
      <guid>https://dev.to/gitguardian/rotating-1000-service-account-passwords-with-zero-outages-why-the-inventory-comes-first-2ijc</guid>
      <description>&lt;h3&gt;
  
  
  &lt;strong&gt;TL;DR&lt;/strong&gt;
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Rotation is the last step:&lt;/strong&gt; Rotating more than 1,000 service credentials across more than 150 applications with zero outages showed that most of the work happens before you change a single password.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Controls built for people miss service credentials:&lt;/strong&gt; Service credentials have no human to prompt, no MFA path, often no current owner, and they fail silently. Their copies also spread into scripts, config files, pipelines, and chat.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Inventory first, then SCALER:&lt;/strong&gt; Know who uses each account, who owns it, and whether it's still needed. Then follow six stages in order: Scale, Classify, Assign, Lifecycle, Enforce, and Rotate.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzo08us79uwqnsiz7b01t.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzo08us79uwqnsiz7b01t.png" alt="Mayank Sethi" width="800" height="800"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h4&gt;
  
  
  Mayank Sethi
&lt;/h4&gt;

&lt;p&gt;Mayank is a Principal Data Operations Engineer who led the rotation of more than 1,000 service credentials across 150+ applications without an outage. He developed the SCALER framework and presented it at CornCon 12.&lt;br&gt;
&lt;a href="https://www.linkedin.com/in/sethi-m/" rel="noopener noreferrer"&gt;LinkedIn&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4rbc9z1q759z12uchdfi.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4rbc9z1q759z12uchdfi.png" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;I once led the service account password rotation of more than 1,000 credentials across more than 150 applications. We finished with zero outages. The rotation itself was the easy part. Most of the work happened before we changed a single password.&lt;/p&gt;

&lt;p&gt;That order surprises people. Most teams treat rotation as the job. In my experience, rotation is the last step of a longer process. Skipping the earlier steps is how rotation causes outages.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;The gap a standard identity review misses&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Picture a typical identity review. Multi-factor authentication (MFA) is on for every employee. Single sign-on covers the main applications. Network policies restrict who can reach production. The review passes.&lt;/p&gt;

&lt;p&gt;Now ask a different question. How many service accounts exist on that platform? Who owns each one? When did each credential last change? Most teams can't answer with confidence.&lt;/p&gt;

&lt;p&gt;The broader data on leaked credentials points the same way. GitGuardian found 28.65 million new hardcoded secrets in public GitHub commits in 2025, up 34% from the year before. When it retested &lt;a href="https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026/" rel="noopener noreferrer"&gt;secrets from 2022&lt;/a&gt; in January 2026, more than 64% were still valid. Credentials leak, and then &lt;a href="https://blog.gitguardian.com/why-exposed-secrets-stay-valid/" rel="noopener noreferrer"&gt;&lt;em&gt;they stay live for years&lt;/em&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Service credentials are the passwords, keys, and tokens that applications, scripts, and pipelines use to talk to each other. Most security controls assume a human user. Service credentials don't have one.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Four ways service credentials differ from user passwords&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjgf299almju5ubavk28l.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjgf299almju5ubavk28l.png" alt="Four ways service credentials differ from user passwords: no human to prompt, no MFA path, no current owner, and silent failure." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;When a user password expires, a person gets a prompt and resets it. If someone steals it, MFA stands in the way. If it stops working, the user notices within minutes and calls the help desk.&lt;/p&gt;

&lt;p&gt;Service credentials get none of that support:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;No human to prompt:&lt;/strong&gt; When a service credential expires, nobody reads the warning email. The application fails.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No MFA path:&lt;/strong&gt; An application can't approve a push notification.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No current owner:&lt;/strong&gt; The engineer who created the account may have changed teams or left. The credential outlives the person who understood it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Silent failure:&lt;/strong&gt; Change a credential and something can break hours later, in a job nobody linked to that account.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;I saw the last one firsthand. Application teams updated the new password in every place they knew about. Then a connection would still fail, from a source nobody could identify. Several systems reached the platform through the same shared network address. The owner had done everything right and still couldn't find the last copy.&lt;/p&gt;

&lt;p&gt;After one incident like that, teams hesitate to touch these credentials at all. So the credentials sit unchanged, sometimes for years.&lt;/p&gt;

&lt;p&gt;User passwords are a people problem, and prompts, training, and MFA handle most of it. Service credentials are an inventory problem. You solve them by knowing what exists, who uses it, and who answers for it.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Why controls built for people miss machine identities&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Single sign-on, MFA, and conditional access all assume a person at a login screen. Service credentials skip the login screen entirely.&lt;/p&gt;

&lt;p&gt;They also hold standing access. A service account often keeps the same permissions on its last day as on its first, even after its job shrinks. Nothing forces a change, so the credential stays valid.&lt;/p&gt;

&lt;p&gt;And service credentials travel. To get work done, teams copy them into scripts, config files, continuous integration pipelines, and chat threads. GitGuardian found that internal repositories are roughly six times more likely than public ones to contain hardcoded secrets. About 28% of incidents start entirely outside repositories, in tools like Slack, Jira, and Confluence.&lt;/p&gt;

&lt;p&gt;The platform itself may be locked down well. Its controls never see the copies scattered across code and collaboration tools.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Two instincts that make it worse&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;When a team finds hundreds of unmanaged service credentials, two responses tend to show up. Each seems reasonable in the moment, and each makes the problem harder to fix.&lt;/p&gt;

&lt;p&gt;The first is to rotate everything immediately. It looks decisive. In practice, it causes the outages you were trying to avoid. Nobody knows which jobs depend on which credential, so each rotation breaks something. After a few incidents, teams stop rotating at all.&lt;/p&gt;

&lt;p&gt;The second is to form a working group first. The group drafts a policy, compares tools, and schedules meetings with application teams. Months pass, and the exposure found on day one stays open.&lt;/p&gt;

&lt;p&gt;Both skip the same step. The first acts without knowing what exists. The second plans without finding out.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;What the inventory has to answer&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;Before we rotated anything, every service account needed three answers:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Who uses it?&lt;/strong&gt; Which applications, jobs, or pipelines connect with it today?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Who owns it?&lt;/strong&gt; Which person is accountable for it now?&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Is it still needed?&lt;/strong&gt; Has anything used it recently?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;We didn't have to build most of that from scratch. Application ownership already lived in a configuration database. Account metadata, including last login, already lived on the platform. The missing piece was the join between them. Once we joined the two, most accounts resolved to a named owner automatically.&lt;/p&gt;

&lt;p&gt;The third question paid off fastest. We disabled accounts with no login in 90 days instead of chasing their owners. Owners could request re-enablement through a standard service request if they needed it. That shrank the problem before rotation started.&lt;/p&gt;

&lt;p&gt;It also had a side effect we didn't plan. Once owners could see the last login date for their accounts, they started asking us to disable the ones they no longer needed.&lt;/p&gt;

&lt;p&gt;Platform data is the right starting point because it reflects what is real today. Spreadsheets and documentation drift. But the platform is only half of the inventory. The other half is everywhere its credentials have spread: repositories, config files, pipelines, and chat. Rotate without that half, and the breakage moves downstream.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Six stages, always in this order&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F50ob1poiznuy9zm8mjeu.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F50ob1poiznuy9zm8mjeu.png" alt="The SCALER framework for service account rotation as a closed loop: Scale, Classify, Assign, Lifecycle, Enforce, and Rotate, completed in order." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;There was no name for what we did at the time. Looking back, it was six stages, always in the same order. I've called it SCALER since, because the order is the part worth keeping.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Scale:&lt;/strong&gt; Discover every service account from the platform itself, then find where each credential has spread. Use login history to see what is still active.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Classify:&lt;/strong&gt; Tie each account to the application it supports.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Assign:&lt;/strong&gt; Give every account a named human owner, and keep ownership current as people move.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Lifecycle:&lt;/strong&gt; Set a policy that makes credentials expire, with warnings well ahead of the deadline.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Enforce:&lt;/strong&gt; Make the safe path the easy one. Owners rotate through a workflow they already use, without waiting on a central team.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Rotate:&lt;/strong&gt; Change credentials in a way you can reverse quickly if something breaks.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Each stage depends on the one before it. You can't assign an owner to an account you haven't found. You can't enforce expiry on a credential nobody owns, because nobody will act on the warning. Skip a stage, and it shows up later as an outage.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;strong&gt;Why a revert path made rotation safer&lt;/strong&gt;
&lt;/h2&gt;

&lt;p&gt;This is the choice many security teams won't like. When a rotation broke something, we let the owner temporarily revert to the old credential.&lt;/p&gt;

&lt;p&gt;That sounds like a step backward, so here is the reasoning. Our platform didn't let an account hold two valid passwords at once. With overlapping credentials, you run the old and new side by side until every consumer switches. We had no overlap window.&lt;/p&gt;

&lt;p&gt;The shared-address problem from earlier is exactly this case. Without a way back, that failure becomes an outage, and the owner learns to fear rotation. With a way back, it stays recoverable.&lt;/p&gt;

&lt;p&gt;Validation belonged to the owners. We could see last login, account status, and connection sources. Only the owner could confirm that their downstream jobs still ran. If validation passed, the expiry policy took over. If it failed, the revert path kicked in.&lt;/p&gt;

&lt;p&gt;The revert kept a failed rotation from turning into an outage. It also kept owners willing to rotate the next time.&lt;/p&gt;

&lt;p&gt;If I ran this program again, I would keep the first four stages exactly as they were. I would change the authentication method. On platforms that support two active keys, key-pair authentication lets old and new overlap until validation is clean. That removes the need for a revert.&lt;/p&gt;

&lt;p&gt;Whatever the credential type, the work still starts with the inventory. The fastest first step is finding where your credentials already live outside the platform.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/monitor-internal-repositories-for-secrets" rel="noopener noreferrer"&gt;&lt;em&gt;Scan your repos now.&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is a service account?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A service account is an account that applications, scripts, and pipelines use instead of a person. Its credentials (passwords, keys, and tokens) let those systems talk to each other. Most security controls assume a human user, and service accounts don't have one.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the difference between a service account and a user account?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;When a user password expires, a person gets a prompt and resets it. MFA protects it if it's stolen, and the user notices within minutes if it stops working. A service account has none of that: no one reads the expiry warning, it can't approve an MFA prompt, its creator may have left, and a changed credential can break a job hours later.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Can you use MFA for service accounts?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Not in the usual way. An application can't approve a push notification, and single sign-on, MFA, and conditional access all assume a person at a login screen. Service credentials skip the login screen entirely, so the controls built for people don't protect them.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What are the security risks of service accounts?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Service accounts often keep the same permissions on their last day as on their first, even after their job shrinks. Teams copy their credentials into scripts, config files, CI pipelines, and chat threads, where the platform's controls never see them. Because rotating them can cause outages, they often stay unchanged for years.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is service account management?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Service account management means knowing what exists, who uses it, and who answers for it. For every account, that means answering three questions: which applications or pipelines use it today, which person is accountable for it now, and whether anything has used it recently.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do you rotate service account passwords without outages?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Build the inventory first, then rotate. The SCALER method runs six stages in order: Scale, Classify, Assign, Lifecycle, Enforce, and Rotate. On platforms that can't hold two valid passwords at once, a temporary revert path keeps a failed rotation from turning into an outage.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;This article is a guest post. Views and opinions expressed in this publication are solely those of the author and do not reflect the official policy, position, or views of GitGuardian. The content is provided for informational purposes; GitGuardian assumes no responsibility for any errors, omissions, or outcomes resulting from the use of this information.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;The opinions expressed here are solely those of the author and do not represent the views, positions, or policies of Group 1001 Insurance Holdings, LLC or its affiliates.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>devops</category>
      <category>nhi</category>
      <category>passwords</category>
    </item>
    <item>
      <title>OWASP Top 10 Kubernetes Security Risks Explained: Why Credentials Deserve a Closer Look</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Tue, 27 Oct 2026 14:40:10 +0000</pubDate>
      <link>https://dev.to/gitguardian/owasp-top-10-kubernetes-security-risks-explained-why-credentials-deserve-a-closer-look-3j6j</link>
      <guid>https://dev.to/gitguardian/owasp-top-10-kubernetes-security-risks-explained-why-credentials-deserve-a-closer-look-3j6j</guid>
      <description>&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;K03 turns one leak into a chain&lt;/strong&gt;: Secrets Management Failures let a single exposed token unlock more credentials. GitGuardian found 44 active clusters reachable through leaked secrets, and 30% had been exposed for over two years.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pipelines and repositories feed the cluster&lt;/strong&gt;: GhostAction targeted 2,577 secret values across 772 repositories, and a public CISA-related repo exposed active credentials, showing how continuous integration and continuous delivery (CI/CD) and source control become paths into Kubernetes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Shrink the blast radius across the credential layer&lt;/strong&gt;: Strict RBAC, short-lived workload identity, and credential detection across repos, images, and pipelines limit what any exposed token can reach, with ggshield, AI hooks, and Developer Endpoint Protection preventing new leaks.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Recent attacks make the OWASP Kubernetes Top 10 essential reading
&lt;/h2&gt;

&lt;p&gt;Kubernetes powers modern infrastructure. 82% of container users now run it in production environments, according to the most recent Cloud Native Computing Foundation (CNCF) &lt;a href="https://www.cncf.io/announcements/2026/01/20/kubernetes-established-as-the-de-facto-operating-system-for-ai-as-production-use-hits-82-in-2025-cncf-annual-cloud-native-survey/" rel="noopener noreferrer"&gt;&lt;em&gt;Annual Cloud Native Survey&lt;/em&gt;&lt;/a&gt;. For the majority of DevOps teams who want to run their applications in containers, Kubernetes is the first thing they turn to. Kubernetes (K8s) offers many advantages, but it also has potential pitfalls if you don't set everything up correctly. This is why Kubernetes has its own OWASP Top 10.&lt;/p&gt;

&lt;p&gt;Kubernetes security risks include workloads, identities, and infrastructure. A compromised container can expose a service account. That service account may have permissions to reach other systems, where it could find additional credentials. Credentials very often provide access to systems far beyond the original cluster.&lt;/p&gt;

&lt;p&gt;Recent GitGuardian investigations show how these attack paths work in practice. Researchers discovered leaked credentials that provided access to &lt;a href="https://blog.gitguardian.com/leaked-kubernetes-secret-mitigation/" rel="noopener noreferrer"&gt;&lt;em&gt;44 active Kubernetes clusters&lt;/em&gt;&lt;/a&gt;. The recent round of GhostAction supply chain campaign targeted thousands of &lt;a href="https://blog.gitguardian.com/ghostaction-github-actions-supply-chain-attack-returns/" rel="noopener noreferrer"&gt;&lt;em&gt;K8 credentials through GitHub Actions&lt;/em&gt;&lt;/a&gt;. Another investigation uncovered a public repository containing &lt;a href="https://blog.gitguardian.com/how-we-got-a-cisa-github-leak-taken-down-in-26-hours/" rel="noopener noreferrer"&gt;&lt;em&gt;CISA-related infrastructure configurations&lt;/em&gt;&lt;/a&gt; and active credentials.&lt;/p&gt;

&lt;p&gt;With so much going on in the threat landscape targeting it, we think it is a good time &lt;a href="https://kubernetes-top10.owasp.org/" rel="noopener noreferrer"&gt;to review the &lt;em&gt;OWASP Kubernetes Top 10&lt;/em&gt;&lt;/a&gt;. Its ten categories identify the weaknesses that allow attackers to enter Kubernetes environments, expand their permissions, and reach connected infrastructure.&lt;/p&gt;

&lt;h2&gt;
  
  
  The 10 Kubernetes security risks in the OWASP list
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvzer6goy55qngunny1dh.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvzer6goy55qngunny1dh.png" alt="The OWASP Kubernetes Top 10 Kubernetes security risks, K01 to K10, with K03 Secrets Management Failures highlighted." width="800" height="454"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The OWASP Kubernetes Top 10 gives a prioritized view of the most pressing risks affecting Kubernetes environments. These risks are not theoretical, but real-world issues the community is reporting and working on. This includes insecure configurations, weak access controls, and failures in protecting sensitive resources.&lt;/p&gt;

&lt;p&gt;These risks frequently overlap. A compromised workload may expose credentials with excessive permissions. Those permissions may allow an attacker to access additional workloads or cloud resources.&lt;/p&gt;

&lt;h3&gt;
  
  
  K01: Insecure Workload Configurations
&lt;/h3&gt;

&lt;p&gt;Privileged containers, excessive Linux capabilities, and dangerous host mounts can give workloads more access than they require. Attackers who compromise these workloads may gain access to sensitive files or underlying infrastructure.&lt;/p&gt;

&lt;h3&gt;
  
  
  K02: Overly Permissive Authorization Configurations
&lt;/h3&gt;

&lt;p&gt;Role-Based Access Control (RBAC) determines what users and service accounts can access in Kubernetes. Excessive permissions increase the authority available to compromised identities, including the ability to retrieve Kubernetes Secrets or modify workloads.&lt;/p&gt;

&lt;h3&gt;
  
  
  K03: Secrets Management Failures
&lt;/h3&gt;

&lt;p&gt;K03 covers Kubernetes secrets management failures. Applications depend on credentials to connect: API keys, passwords, and tokens, which can leak in plaintext through repositories, container images, and application configurations. Long-lived credentials and other weak authentication schemes increase their usefulness to attackers.&lt;/p&gt;

&lt;h3&gt;
  
  
  K04: Lack of Cluster-Level Policy Enforcement
&lt;/h3&gt;

&lt;p&gt;Admission policies can help enforce security requirements across workloads. While it should be standard for each action to be within policy, inconsistent enforcement allows dangerous configurations and excessive privileges to reach production environments.&lt;/p&gt;

&lt;h3&gt;
  
  
  K05: Missing Network Segmentation Controls
&lt;/h3&gt;

&lt;p&gt;Kubernetes network policies restrict communication between workloads to what is configured correctly. Weak or missing segmentation can allow attackers to move between services after compromising an application. This is particularly dangerous when valid credentials provide access. If an attacker can get access, they should impact the smallest blast radius possible.&lt;/p&gt;

&lt;h3&gt;
  
  
  K06: Overly Exposed Kubernetes Components
&lt;/h3&gt;

&lt;p&gt;The more of the cluster is reachable from the internet, the larger the advantage the attacker has. Exposed API servers and administrative interfaces increase opportunities for unauthorized access. Attackers may exploit vulnerable components or use stolen credentials to interact with cluster management services.&lt;/p&gt;

&lt;h3&gt;
  
  
  K07: Misconfigured and Vulnerable Cluster Components
&lt;/h3&gt;

&lt;p&gt;There are a lot of ways to misconfigure Kubernetes, but also a lot of ways to get things correct. This is the challenge of deploying open source in general. We must get it right and apply regular updates. Vulnerabilities can provide attackers with access to infrastructure or opportunities to increase their privileges.&lt;/p&gt;

&lt;h3&gt;
  
  
  K08: Cluster to Cloud Lateral Movement
&lt;/h3&gt;

&lt;p&gt;Kubernetes workloads often use cloud identities and credentials. This gives clusters the power to be useful, but there is a lot of danger here. Excessive cloud permissions can allow attackers who compromise a workload to access resources outside the cluster.&lt;/p&gt;

&lt;h3&gt;
  
  
  K09: Broken Authentication Mechanisms
&lt;/h3&gt;

&lt;p&gt;When an attacker compromises a system, they can break in, or they can simply log in. Weak authentication controls and poorly protected service account tokens can let attackers impersonate trusted identities and gain permissions that are often set too broadly. Stolen credentials may provide the same access as the legitimate workload or user.&lt;/p&gt;

&lt;h3&gt;
  
  
  K10: Inadequate Logging and Monitoring
&lt;/h3&gt;

&lt;p&gt;If an attack happens, how would you know and how would you prove that? Security teams need visibility into authentication events, API requests, and changes to sensitive resources. Without sufficient monitoring, credential misuse and unauthorized activity are much harder to detect and prove. Auditors need to know when you knew about the issue and what you did.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why K03 deserves special attention
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmly3seohrddx3tk7wpld.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmly3seohrddx3tk7wpld.png" alt="Six ways Kubernetes secrets get exposed under OWASP K03: container images, ConfigMaps, environment variables, code repositories, WATCH or LIST access, and application logs." width="800" height="480"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;For K03, Secrets Management Failures, OWASP supplies guidance identifying &lt;a href="https://kubernetes-top10.owasp.org/2025/en/src/K03-Secrets-Management-Failures" rel="noopener noreferrer"&gt;&lt;em&gt;six common ways credentials become exposed&lt;/em&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Secrets in container images:&lt;/strong&gt; Credentials get baked into an image or one of its layers. Anyone who can access the image may be able to recover the secret, and rotation becomes much harder.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Secrets in ConfigMaps:&lt;/strong&gt; Sensitive values are placed in ConfigMaps, which often have weaker access controls and are more likely to appear in backups or debugging output.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Secrets in environment variables:&lt;/strong&gt; Secrets passed as environment variables can surface in debugging data, process information, crash reports, or other diagnostic output.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Secrets in code repositories:&lt;/strong&gt; Credentials committed to source code can spread through clones, forks, CI systems, developer machines, and other copies of the repository.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Excessive &lt;code&gt;WATCH&lt;/code&gt; or &lt;code&gt;LIST&lt;/code&gt; access to Secrets:&lt;/strong&gt; A Kubernetes identity with &lt;code&gt;LIST&lt;/code&gt; or &lt;code&gt;WATCH&lt;/code&gt; permissions on Secret objects can effectively retrieve those secrets at scale. This turns an overly broad RBAC permission into a credential exposure path.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Secrets in application logs:&lt;/strong&gt; Applications can accidentally write credentials to &lt;code&gt;stdout&lt;/code&gt; or &lt;code&gt;stderr&lt;/code&gt;, especially when logging configuration or environment state. Those secrets may then spread into centralized logging systems such as Splunk or Elasticsearch and remain there for long periods.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;There are a lot of ways and places these issues can be introduced. Developers may add credentials to Dockerfiles during testing. Automation systems may receive powerful service account tokens. Applications may log sensitive environment variables while diagnosing errors.&lt;/p&gt;

&lt;p&gt;Each exposure can give an attacker usable credentials.&lt;/p&gt;

&lt;p&gt;The permissions associated with a secret determine the consequences of an exposure or attack. A database credential may provide access to customer records. A Kubernetes service account token may allow an attacker to retrieve additional Secret objects. A cloud credential may grant access to infrastructure outside Kubernetes.&lt;/p&gt;

&lt;p&gt;The real risk extends across every system that trusts the exposed credential.&lt;/p&gt;

&lt;h2&gt;
  
  
  Real-world Kubernetes credential leaks expose the larger problem
&lt;/h2&gt;

&lt;p&gt;Three recent GitGuardian investigations demonstrate how credentials can move through software delivery systems and expose connected infrastructure.&lt;/p&gt;

&lt;h3&gt;
  
  
  A Leaked Kubernetes credential opened access to private resources
&lt;/h3&gt;

&lt;p&gt;GitGuardian researchers investigating publicly exposed Kubernetes credentials. They identified 44 active clusters accessible through leaked secrets; this was one research project, and we know many more are exposed every day. In the clusters they examined, four had more than 10 nodes, and one exceeded 200 nodes. A full 30% of the accessible clusters had been exposed for more than two years. The oldest valid leak dated back to 2021.&lt;/p&gt;

&lt;p&gt;One case began when a service account token was embedded in a public Docker image which provided access to a K8 cluster. That cluster contained additional credentials. Ultimately, that key opened access to private container images and GitHub organizations.&lt;/p&gt;

&lt;p&gt;The same research also identified over 2,000 container registry credentials with resolvable hostnames. Forty-six percent remained valid. Those credentials provided access to 309 private Docker Hub images and 730 private GitHub repositories.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4nu4djyyqdqhvas0kxo4.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4nu4djyyqdqhvas0kxo4.png" alt="The chain of a credential making it into the container registry" width="800" height="352"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;A single leaked token created access to more secrets and additional systems.&lt;/p&gt;

&lt;p&gt;K03 directly connects to excessive authorization and cluster-to-cloud lateral movement. A compromised credential can expose the next credential in the chain.&lt;/p&gt;

&lt;h3&gt;
  
  
  GhostAction targeted credentials inside trusted automation
&lt;/h3&gt;

&lt;p&gt;The &lt;a href="https://blog.gitguardian.com/ghostaction-campaign-3-325-secrets-stolen/" rel="noopener noreferrer"&gt;&lt;em&gt;GhostAction supply chain campaign&lt;/em&gt;&lt;/a&gt;, which originally ran between Aug. 31 and Sept. 30, 2026, affected 772 public repositories and targeted 2,577 secret values. GitGuardian's researchers originally uncovered this attack. The attack targeted credentials used by automation, including cloud keys and container registry credentials.&lt;/p&gt;

&lt;p&gt;Most workflow executions during this attack required approvals, which limited how bad this was and how many people were affected. However, a subsequent October wave affected another 346 repositories, with external researchers confirming successful exfiltration.&lt;/p&gt;

&lt;p&gt;GhostAction targeted CI/CD infrastructure. The consequences can extend into Kubernetes because deployment pipelines frequently hold credentials granting access to registries and cloud services.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr8rutjc07ywkcth1n713.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fr8rutjc07ywkcth1n713.png" alt="GhostAction Incident - Top leaked Secrets" width="800" height="498"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;An attacker who steals those credentials may gain access to the same infrastructure used by legitimate deployment automation.&lt;/p&gt;

&lt;p&gt;Securing Kubernetes therefore requires controls around the systems that build and deploy workloads.&lt;/p&gt;

&lt;h3&gt;
  
  
  The CISA repository leak exposed credentials and infrastructure context
&lt;/h3&gt;

&lt;p&gt;In May 2026, GitGuardian researchers discovered a public GitHub repository named Private-CISA. While that might not sound that unusual, since CISA might stand for many different things, this repo contained 844 MB of plain-text passwords, AWS tokens, and Entra ID SAML certificates belonging to CISA, the US Cybersecurity and Infrastructure Security Agency. The exposed files included Kubernetes manifests, ArgoCD configurations, and Terraform infrastructure code.&lt;/p&gt;

&lt;p&gt;Researchers tested many of these credentials and found them valid.&lt;/p&gt;

&lt;p&gt;Researchers also found credentials and documentation describing internal infrastructure. The exposed information provided insight into how systems were configured and connected. Attackers could potentially use that context to identify valuable credentials and determine where those credentials might work.&lt;/p&gt;

&lt;p&gt;The repository was taken offline following coordinated disclosure. But like with any incident, &lt;a href="https://blog.gitguardian.com/cisa-github-leak-incident-response-lessons/" rel="noopener noreferrer"&gt;&lt;em&gt;any exposed credentials still required investigation and appropriate remediation&lt;/em&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Repository scanning and credential lifecycle management help organizations address both the immediate exposure and its continuing consequences.&lt;/p&gt;

&lt;h2&gt;
  
  
  Reducing the blast radius of exposed Kubernetes credentials
&lt;/h2&gt;

&lt;p&gt;Like with all Top 10 lists from OWASP, we have recommendations that provide a practical foundation for reducing risk, this time around Kubernetes credentials.&lt;/p&gt;

&lt;p&gt;Strict RBAC limits which identities can retrieve secrets. Namespace boundaries and network policies restrict access between workloads. Encryption at rest protects sensitive values stored in etcd.&lt;/p&gt;

&lt;p&gt;Credential detection should also cover the software delivery process. Source repositories, CI/CD workflows, and container images all create opportunities for secrets to spread before applications reach production.&lt;/p&gt;

&lt;p&gt;Security teams need to review credentials when they are exposed. While they might not be ultimately the "owner" of these credentials, they are the team responsible for dealing with the fallout of abuse of these credentials. They need to know validity, permissions, and actual usage to help determine the remediation priority. Rotation and revocation remove compromised access, while tighter permissions limit what future exposures can accomplish.&lt;/p&gt;

&lt;p&gt;Workload identity federation provides an opportunity to reduce access persistence. GitGuardian's research found Kubernetes credentials that remained valid years after their original exposure. Supported Kubernetes workloads can use trusted identities to obtain temporary access to external services. Short-lived tokens reduce the useful lifetime of stolen credentials and the need to distribute permanent keys.&lt;/p&gt;

&lt;p&gt;The long-term objective is to reduce the number of standing credentials while strengthening controls around those that remain.&lt;/p&gt;

&lt;h2&gt;
  
  
  How GitGuardian helps secure the Kubernetes credential layer
&lt;/h2&gt;

&lt;p&gt;Kubernetes workloads depend on credentials that originate across the enterprise. Developer endpoints, source repositories, and CI/CD systems all participate in the credential lifecycle.&lt;/p&gt;

&lt;p&gt;GitGuardian helps organizations secure this credential layer through three connected capabilities.&lt;/p&gt;

&lt;h3&gt;
  
  
  Detect exposed credentials and identify their context
&lt;/h3&gt;

&lt;p&gt;GitGuardian detects exposed secrets across supported repositories and development environments. ggshield extends scanning into CI/CD workflows and container images.&lt;/p&gt;

&lt;p&gt;When configured to integrate with Kubernetes clusters, the platform maps identity and infrastructure context, helping security teams understand where credentials are used and what access they provide.&lt;/p&gt;

&lt;h3&gt;
  
  
  Remediate exposed credentials and reduce excessive access
&lt;/h3&gt;

&lt;p&gt;Finding a credential is just the first step; you need to actually remediate the findings. Security teams need to prioritize, investigate, and then take the right actions to reduce risk. This starts with establishing whether it remains valid and which services depend on it.&lt;/p&gt;

&lt;p&gt;GitGuardian empowers investigation and prioritization for teams of any size. Part of this process includes using validity checks and surfacing contextual risk information. This helps teams coordinate rotation and reduce unnecessary permissions while protecting production availability.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkgb4bm409lk5lng00h3l.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fkgb4bm409lk5lng00h3l.png" alt="GitGuardian Exploration Map example" width="800" height="373"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  Prevent new credential exposures
&lt;/h3&gt;

&lt;p&gt;An ounce of prevention is worth a pound of remediation.&lt;/p&gt;

&lt;p&gt;GitGuardian makes tools available for the developer and the local coding assistants to prevent secrets from being added or used throughout the software development process. ggshield, the GitGuardian CLI, supports developer-side checks and automated scanning within CI/CD pipelines. AI hooks provide additional checkpoints where agents interact with sensitive information.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/developer-endpoint-protection" rel="noopener noreferrer"&gt;&lt;em&gt;Developer Endpoint Protection&lt;/em&gt;&lt;/a&gt; extends visibility into local machines where credentials tend to aggregate. This helps teams identify which secrets on a developer's laptop carry the most risk and plan remediation for plaintext secrets that haven't yet been abused or leaked publicly. This also gives you a clear prioritization path in cases of infostealer attacks affecting your organization.&lt;/p&gt;

&lt;p&gt;Together, these capabilities help organizations reduce secrets sprawl across development and production environments.&lt;/p&gt;

&lt;h2&gt;
  
  
  Kubernetes security requires control over your credential layer
&lt;/h2&gt;

&lt;p&gt;The OWASP Kubernetes Top 10 shows how exposed credentials can put entire environments at risk. A single leaked token can provide access to workloads, cloud infrastructure, and connected systems.&lt;/p&gt;

&lt;p&gt;Securing Kubernetes and other production systems requires visibility and control across the entire credential layer. This stretches from developer laptops to repositories, CI/CD pipelines, and production workloads. Every system that can hold plaintext secrets is part of your credential layer.&lt;/p&gt;

&lt;p&gt;GitGuardian helps you gain that control. Discover exposed credentials, prioritize remediation, and prevent new secrets from spreading across your development and production environments.&lt;/p&gt;

&lt;p&gt;Get started with GitGuardian and take control of your credential layer today.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/book-a-demo" rel="noopener noreferrer"&gt;&lt;em&gt;Book a demo now.&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is the OWASP Kubernetes Top 10?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The OWASP Kubernetes Top 10 is a prioritized list of the most pressing risks affecting Kubernetes environments, based on real-world issues the community is reporting and working on. Its ten categories cover insecure workload configurations, overly permissive authorization, secrets management failures, missing network segmentation, exposed components, cluster to cloud lateral movement, broken authentication, and inadequate logging and monitoring.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why does K03, Secrets Management Failures, deserve special attention?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Credentials very often provide access to systems far beyond the original cluster, and the permissions tied to a secret determine the consequences of an exposure. A database credential may expose customer records, a service account token may let an attacker retrieve more Secret objects, and a cloud credential may grant access to infrastructure outside Kubernetes. K03 also connects directly to excessive authorization and cluster to cloud lateral movement.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do secrets get exposed in Kubernetes environments?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;OWASP identifies six common paths: secrets baked into container images, sensitive values in ConfigMaps, secrets passed as environment variables, credentials committed to code repositories, excessive WATCH or LIST access to Secret objects, and secrets written to application logs. Each one can give an attacker usable credentials.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do leaked credentials lead to Kubernetes cluster compromise?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;GitGuardian researchers identified 44 active Kubernetes clusters accessible through leaked secrets, and 30% of them had been exposed for more than two years. In one case, a service account token embedded in a public Docker image opened a cluster that held more credentials, which in turn opened private container images and GitHub organizations. A single leaked token created access to more secrets and additional systems.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the GhostAction campaign and why does it matter for Kubernetes security?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;GhostAction was a supply chain campaign, first uncovered by GitGuardian researchers, that affected 772 public repositories and targeted 2,577 secret values used by automation, including cloud keys and container registry credentials. A later wave affected another 346 repositories. The impact reaches Kubernetes because deployment pipelines frequently hold credentials that grant access to registries and cloud services.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can teams reduce the blast radius of exposed Kubernetes credentials?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Use strict RBAC to limit which identities can retrieve secrets, apply namespace boundaries and network policies, and encrypt sensitive values in etcd at rest. Detect credentials across repositories, CI/CD workflows, and container images, then check validity, permissions, and actual usage to prioritize rotation and revocation. Workload identity federation and short-lived tokens reduce how long stolen credentials stay useful.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How does GitGuardian help secure the Kubernetes credential layer?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;GitGuardian detects exposed secrets across supported repositories and development environments, and ggshield extends scanning into CI/CD workflows and container images. The platform maps identity and infrastructure context when integrated with Kubernetes clusters, and validity checks and contextual risk information help teams prioritize remediation. For prevention, ggshield, AI hooks, and Developer Endpoint Protection catch secrets before they spread.&lt;/p&gt;

</description>
      <category>kubernetes</category>
      <category>security</category>
      <category>owasp</category>
      <category>devops</category>
    </item>
    <item>
      <title>Railway October 2026 Incident: Treat Every Environment Variable as Exposed</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Mon, 26 Oct 2026 12:28:41 +0000</pubDate>
      <link>https://dev.to/gitguardian/railway-october-2026-incident-treat-every-environment-variable-as-exposed-24oa</link>
      <guid>https://dev.to/gitguardian/railway-october-2026-incident-treat-every-environment-variable-as-exposed-24oa</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhmzjruvw53m1y8q1hxbz.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fhmzjruvw53m1y8q1hxbz.png" alt="Railway October 2026 Incident: Treat Every Environment Variable as Exposed" width="800" height="419"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What happened in the Railway security incident
&lt;/h2&gt;

&lt;p&gt;On Oct. 21, 2026, Railway disclosed anomalous activity on the systems that store customer environment variables.&lt;/p&gt;

&lt;p&gt;An unauthorized third party may have accessed encrypted environment variables and, for some of them, obtained the decrypted values. &lt;a href="https://blog.railway.com/p/preliminary-report-october-security-incident" rel="noopener noreferrer"&gt;Railway is asking&lt;/a&gt; all customers to rotate their environment variables, including API keys and private registry credentials, and has paused deployments during the investigation.&lt;/p&gt;

&lt;p&gt;Railway believes the impact is limited to a subset of users, who will be contacted by email. It links the attack to "a series of attacks recently targeting platform companies with the aim of compromising AI inference providers," a pattern that echoes the &lt;a href="https://blog.gitguardian.com/vercel-april-2026-incident-non-sensitive-environment-variables-need-investigation-too/" rel="noopener noreferrer"&gt;Vercel incident&lt;/a&gt; from April.&lt;/p&gt;

&lt;h2&gt;
  
  
  Investigate, then rotate every Railway environment variable
&lt;/h2&gt;

&lt;p&gt;Treat every secret stored in Railway as at risk until investigated. Identify the exposed credentials, check where they are used, and confirm whether they are still active or already abused. Then revoke or rotate them, redeploy, and verify dependent services.&lt;/p&gt;

&lt;p&gt;Railway sealed variables cannot be read back from the UI, the API, or the CLI. That limits casual exposure, but the disclosure does not say whether they were in scope. Rotate them too.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to scan Railway environment variables for secrets
&lt;/h2&gt;

&lt;p&gt;Railway customers can dump their environment variables locally and scan them.&lt;/p&gt;

&lt;p&gt;Dump the variables of each service and environment:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;railway variable list --service &amp;lt;service&amp;gt; --environment &amp;lt;environment&amp;gt; --kv &amp;gt; .env.railway
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Then scan the file with GitGuardian:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;ggshield secret scan path .env.railway
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;GitGuardian identifies which variables contain valid secrets. &lt;strong&gt;This gives you a prioritized list of what to rotate first.&lt;/strong&gt; If you dumped several services into the same directory, scan them all at once:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;ggshield secret scan path -r .
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Rotate secrets in upstream services, such as AWS, GCP, GitHub, or AI providers, before updating the values in Railway. Delete the dumped files once done.&lt;/p&gt;

&lt;h2&gt;
  
  
  Railway's recommended next steps
&lt;/h2&gt;

&lt;p&gt;Railway recommends that customers:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Rotate all &lt;a href="https://blog.gitguardian.com/secure-your-secrets-with-env/" rel="noopener noreferrer"&gt;environment variables&lt;/a&gt;&lt;/strong&gt; stored in Railway, including API keys.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Rotate private registry credentials.&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review logs&lt;/strong&gt; of the services using these credentials for unusual activity. Railway published dedicated guides for &lt;a href="https://blog.railway.com/p/security-disclosure-recommendation-check-for-anomalous-aws-access" rel="noopener noreferrer"&gt;AWS&lt;/a&gt;, &lt;a href="https://blog.railway.com/p/security-disclosure-recommendation-check-for-anomalous-gcp-access" rel="noopener noreferrer"&gt;GCP&lt;/a&gt;, and &lt;a href="https://blog.railway.com/p/security-disclosure-recommendation-check-for-anomalous-github-access" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Follow the &lt;a href="https://status.railway.com/incident/QH8L8B3E" rel="noopener noreferrer"&gt;status page&lt;/a&gt;&lt;/strong&gt;, since new deployments are paused until builds are restored.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Talk to GitGuardian to see how you can strengthen your security controls.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/book-a-demo" rel="noopener noreferrer"&gt;Book the demo now.&lt;/a&gt;&lt;/p&gt;

</description>
      <category>security</category>
      <category>devsecops</category>
      <category>appsec</category>
      <category>devops</category>
    </item>
    <item>
      <title>Responding to php2shell When You Don't Know Your Secrets</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Fri, 23 Oct 2026 18:31:27 +0000</pubDate>
      <link>https://dev.to/gitguardian/responding-to-php2shell-when-you-dont-know-your-secrets-2b75</link>
      <guid>https://dev.to/gitguardian/responding-to-php2shell-when-you-dont-know-your-secrets-2b75</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqeln1x824wn8y1gbdpg1.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqeln1x824wn8y1gbdpg1.png" alt="Responding to php2shell PHP Vulnerability When You Don't Know What Secrets Are Deployed" width="800" height="418"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;TL;DR&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Pre-auth RCE in default PHP setups:&lt;/strong&gt; PHP fixed php2shell on Oct. 21, 2026. It abuses how PHP handles out-of-memory fatal errors and works against Apache mod_php and PHP-FPM on common CMS, webmail, and e-commerce apps.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every secret on the host is exposed:&lt;/strong&gt; The RCE can potentially allow attackers to read config.php and .env files using the PHP worker's existing permissions. That gives them database, SMTP, cloud, and OAuth credentials to move into systems outside PHP.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What is php2shell and how does it work?
&lt;/h2&gt;

&lt;p&gt;The root cause is how PHP handles a fatal error when a request exceeds memory_limit. The fatal error interrupts the operation in progress and leaves it half-finished: a hash table whose counters were incremented before the new bucket was initialized, or session globals still pointing into memory that request shutdown then frees. Calif turns that stale state into code execution.&lt;/p&gt;

&lt;h3&gt;
  
  
  Two ways to trigger the out-of-memory condition
&lt;/h3&gt;

&lt;p&gt;There are two ways to trigger the out-of-memory condition.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Bodies that skip the size check:&lt;/strong&gt; On Apache, a chunked HTTP/1.1 or length-less HTTP/2 multipart body is never checked against &lt;code&gt;post_max_size&lt;/code&gt;, since PHP compares it with the declared Content-Length.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Empty file parts that skip the upload count:&lt;/strong&gt; multipart request with hundreds of file parts using &lt;code&gt;filename=""&lt;/code&gt;, which carry no data, are not counted toward &lt;code&gt;max_file_uploads&lt;/code&gt;, and still each create six &lt;code&gt;$_FILES&lt;/code&gt; entries, combined with nested field names. The body stays under the default 8 MiB &lt;code&gt;post_max_size&lt;/code&gt; while building &lt;code&gt;$_FILES&lt;/code&gt; exceeds the default 128 MiB &lt;code&gt;memory_limit&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Which PHP deployments are exploitable
&lt;/h3&gt;

&lt;p&gt;Both Apache mod_php and PHP-FPM are exploitable: mod_php against arbitrary scripts, PHP-FPM when the application reaches the vulnerable unserialize path. The fix is to upgrade PHP.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why php2shell is a secrets theft vector
&lt;/h2&gt;

&lt;p&gt;The RCE gives read access to everything next to the PHP code: &lt;strong&gt;database credentials&lt;/strong&gt; in &lt;code&gt;config.php&lt;/code&gt;, &lt;strong&gt;API keys, SMTP credentials, cloud access keys, and OAuth client secrets&lt;/strong&gt; in &lt;code&gt;.env&lt;/code&gt; files. No privilege escalation is needed: the PHP worker already has the permissions.&lt;/p&gt;

&lt;p&gt;A compromised WordPress instance hands over the database, the mailer, and whatever third-party service the plugins talk to. From there, the attacker pivots to systems that have nothing to do with PHP.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why secret rotation stalls after a PHP compromise
&lt;/h2&gt;

&lt;p&gt;When the alert fires, the security team contains the server, takes forensics, and looks for persistence. The next questions are which secrets were on that machine, are they still valid, and where else are they used.&lt;/p&gt;

&lt;p&gt;If the team does not know what secrets are deployed on the target, the list has to be rebuilt by hand from deployment scripts and Slack threads. That takes hours, and the &lt;a href="https://blog.gitguardian.com/why-exposed-secrets-stay-valid/" rel="noopener noreferrer"&gt;credentials stay valid the whole time&lt;/a&gt;. In most remediations we see, identifying and rotating exposed secrets is manual, done from dashboard data, and starts after the compromise.&lt;/p&gt;

&lt;h2&gt;
  
  
  php2shell incident response: six immediate actions
&lt;/h2&gt;

&lt;p&gt;Once php2shell exploitation is confirmed or suspected on a host:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Isolate the host:&lt;/strong&gt; Take the host off the network.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Suspend access:&lt;/strong&gt; Suspend user access on the host.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sweep other PHP hosts:&lt;/strong&gt; Check every other PHP host for the same indicators: the attacker's source IPs and the oversized multipart requests in the access logs, new files under the web root.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Inventory and rotate secrets:&lt;/strong&gt; Identify every secret on the host (configuration files, environment, shell history) and rotate them in the order set by your impact mapping.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Audit downstream access:&lt;/strong&gt; Investigate the logs of what those secrets give access to: Kubernetes audit logs, CloudTrail for AWS keys.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hunt for payload execution:&lt;/strong&gt; Look for payload execution indicators: unexpected PHP child processes, outbound connections from the web server, new files under the web root.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Step 4 is where teams lose time. A PHP host that has been running for five years accumulates credentials nobody remembers.&lt;/p&gt;

&lt;h2&gt;
  
  
  Prepare your secrets inventory before you need it
&lt;/h2&gt;

&lt;p&gt;Step 4 takes minutes instead of hours when the following is written down before the incident, for every exposed service, PHP or not.&lt;/p&gt;

&lt;h3&gt;
  
  
  Perimeter knowledge
&lt;/h3&gt;

&lt;p&gt;For each host: the vendors and secret types expected on it (database, cloud provider, GitLab, SMTP), the accounts they belong to (AWS account ID, Azure tenant, GitHub organization), and the domain names and machines it talks to.&lt;/p&gt;

&lt;h3&gt;
  
  
  Secret-to-impact mapping
&lt;/h3&gt;

&lt;p&gt;For each secret: what it protects (customer data, source code, personal data, billing), and the resulting revocation order if everything on the box leaks.&lt;/p&gt;

&lt;h3&gt;
  
  
  Dependencies and authorities
&lt;/h3&gt;

&lt;p&gt;For each secret: what breaks when it is rotated, who owns the vendor account, and who to escalate to when that person is not reachable.&lt;/p&gt;

&lt;p&gt;Keep it next to the incident response runbook and update it when a service is deployed or decommissioned.&lt;/p&gt;

&lt;h2&gt;
  
  
  How GitGuardian helps with php2shell incident response
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2kewrvrkjctts9uv2pds.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F2kewrvrkjctts9uv2pds.png" alt="How GitGuardian helps with php2shell incident response" width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Once php2shell exploitation is confirmed, step four becomes the bottleneck: listing every secret on the host and rotating them in the right order. How fast that goes depends on whether the host was inventoried before the incident.&lt;/p&gt;

&lt;h4&gt;
  
  
  If the host was already inventoried
&lt;/h4&gt;

&lt;p&gt;When a host has already been inventoried, &lt;a href="https://www.gitguardian.com/nhi-governance" rel="noopener noreferrer"&gt;NHI Governance&lt;/a&gt; and &lt;a href="https://www.gitguardian.com/developer-endpoint-protection" rel="noopener noreferrer"&gt;Endpoint Protection&lt;/a&gt; give responders the context they need to prioritize credential rotation:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;What the host held:&lt;/strong&gt; every credential found on the compromised host.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Who owns each one:&lt;/strong&gt; the person accountable for rotating it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Where else it works:&lt;/strong&gt; other hosts, images, repositories, or developer laptops that share the same credential.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;What to revoke first:&lt;/strong&gt; a revocation order based on each credential's criticality.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Knowing the owner is what turns "revoke the SMTP key" into a name to call at 3 a.m.&lt;/p&gt;

&lt;h4&gt;
  
  
  If the host was never inventoried
&lt;/h4&gt;

&lt;p&gt;&lt;a href="https://github.com/GitGuardian/ggshield" rel="noopener noreferrer"&gt;ggshield&lt;/a&gt; scans the forensic image directly, without touching the live host. With a GitGuardian API key configured, this command lists the secrets in the web root and its configuration files, including the ones that never went through a repository:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ggshield secret scan path &lt;span class="nt"&gt;-r&lt;/span&gt; &lt;span class="nt"&gt;-y&lt;/span&gt; /mnt/image/var/www
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The results go into the same platform, so each secret gets an owner and a rotation status like the rest of the inventory. The next incident on that host starts from the case above.&lt;/p&gt;

&lt;p&gt;Patch PHP. Then check that you can list the secrets present on the box and who owns them.&lt;/p&gt;

&lt;h2&gt;
  
  
  How GitGuardian helps you to prepare for the next breach
&lt;/h2&gt;

&lt;p&gt;Steps 4 and 5 are an inventory problem. The inventory is best built before an incident, but GitGuardian can also build it during the response, which is faster than running homemade scripts. To reduce exposure before the next incident and detect intrusion when it happens:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://www.gitguardian.com/nhi-governance" rel="noopener noreferrer"&gt;NHI Governance&lt;/a&gt; builds it: it discovers the service accounts, API keys, and tokens in use across the dev ecosystem, attributes each one to an owner, scores its criticality, and flags the ones overdue for rotation under the policy you configured. The three blocks of the playbook above (perimeter, impact, dependencies, and authorities) come out of that inventory instead of a spreadsheet, and a credential that has not been rotated since the host was built shows up as overdue before anyone exploits php2shell.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.gitguardian.com/developer-endpoint-protection" rel="noopener noreferrer"&gt;Developer Endpoint Protection&lt;/a&gt; feeds the same inventory from the other end of the chain. The .env and config.php that end up on the PHP host start on a developer laptop, next to ~/.aws, shell history, and MCP configuration files. ggshield runs on schedule on those machines, with no continuous agent, and reports the secrets found by machine and severity.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://www.gitguardian.com/honeytoken" rel="noopener noreferrer"&gt;Honeytokens&lt;/a&gt; detect intrusion. Placed in a &lt;code&gt;.env&lt;/code&gt; or &lt;code&gt;config.php&lt;/code&gt; on the host, they fire an alert when used. An attacker who reads the configuration after php2shell will try them.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/book-a-demo" rel="noopener noreferrer"&gt;Book a demo now.&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is php2shell?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;php2shell is a pre-auth remote code execution vulnerability in PHP, named by Calif and fixed on Oct. 21, 2026. It works under default configurations and abuses how PHP handles a fatal error when a request exceeds memory_limit.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do attackers trigger php2shell?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;They push a request past memory_limit in one of two ways. The first sends chunked or length-less multipart bodies on Apache, which skip the post_max_size check. The second sends hundreds of empty file parts, which skip the max_file_uploads count.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Which PHP deployments are vulnerable to php2shell?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Both Apache mod_php and PHP-FPM. mod_php is exploitable through any script, and PHP-FPM when the application reaches the vulnerable unserialize path. The fix is to upgrade PHP.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why is php2shell a secrets theft risk?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The RCE can read config.php and .env files with the PHP worker's existing permissions. That exposes database, SMTP, cloud, and OAuth credentials, which attackers use to move into systems beyond PHP.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What should I do if php2shell was exploited on my server?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Isolate the host, suspend user access, and sweep other PHP hosts for the same indicators. Then rotate every secret on the host, check the logs of the systems those secrets unlock, and look for signs that a payload ran.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do I find out which secrets were on a compromised PHP host?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If the host was inventoried, GitGuardian NHI Governance lists its credentials, owners, and revocation order in one query. If it wasn't, ggshield scans the forensic image to find the secrets in the web root and configuration files.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can I prepare for the next PHP compromise?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Before an incident, document what each host uses, what each secret protects, and who owns it. Keep this next to your incident response runbook so rotating secrets takes minutes instead of hours.&lt;/p&gt;

</description>
      <category>security</category>
      <category>php</category>
      <category>devsecops</category>
      <category>appsec</category>
    </item>
    <item>
      <title>Credential Layer Security Explained: Scope and Controls</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Thu, 22 Oct 2026 22:04:24 +0000</pubDate>
      <link>https://dev.to/gitguardian/credential-layer-security-explained-scope-and-controls-1l5p</link>
      <guid>https://dev.to/gitguardian/credential-layer-security-explained-scope-and-controls-1l5p</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuiuraxk62f08uqbyshmg.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fuiuraxk62f08uqbyshmg.png" alt="What Is Credential Layer Security? The Layer Every Other Control Trusts" width="800" height="420"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The credential layer is every surface holding a secret&lt;/strong&gt;: Code, cloud, laptops, SaaS, collaboration tools, and public sites all hold plaintext credentials, and a single key can travel through all of them during its lifetime.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Six controls form a connected program&lt;/strong&gt;: Discover, prioritize by access risk, connect to owners, remediate copies, prevent spread, and detect harvesting with honeytokens, working alongside IAM, PAM, vaults, EDR, and cloud security.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Endpoints and AI agents raise the stakes&lt;/strong&gt;: Developer laptops average about 150 secrets each, and agents can read files, run commands, and call MCP servers, so credential scope and deterministic controls matter more.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What is credential layer security?
&lt;/h2&gt;

&lt;p&gt;Before we define the full credential layer, let's start by defining "credential." In the context of information technology, we define a credential as any piece of data that grants access to a system, service, resource, or data. We also commonly call these "secrets." Some credentials require additional authentication conditions to be met, but most grant access through possession of the data alone.&lt;/p&gt;

&lt;p&gt;These take the form of passwords, API keys, access tokens, private keys, and other authentication material, which, on its own, allows an entity, be it human, workload, or AI, to authenticate to another system or platform.&lt;/p&gt;

&lt;p&gt;The credential layer enables your organization's connectivity and encompasses every place a credential can exist, in any state or condition. That is a very wide definition, but that is also the honest scope. Any surface that can hold plaintext is part of the credential layer's surface. This includes code, cloud infrastructure, laptops and dev environments, and SaaS applications. All can hold plaintext credentials. That is the reality security teams are up against.&lt;/p&gt;

&lt;p&gt;Putting this all together, we get to our definition: Credential layer security is the practice and focus of protecting every surface where credentials can be created, stored, transmitted, or used. In practice, that means finding all plaintext secrets and connecting identity context, remediation, and prevention across the enterprise.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why are credentials a security concern?
&lt;/h3&gt;

&lt;p&gt;Credentials don't just allow access to systems that contain private data; they also provide access to control an organization's infrastructure.&lt;/p&gt;

&lt;p&gt;An exposed customer record can reveal personally identifiable information, which is highly regulated. An exposed credential can provide ongoing access to systems, giving adversaries more time to plan and explore. Secrets also enable administering your infrastructure, which can be very costly when abused.&lt;/p&gt;

&lt;p&gt;The credential layer stretches across the entire digital environment, including systems that were never designed to manage credentials.&lt;/p&gt;

&lt;p&gt;Protecting it requires understanding where credentials exist, what they can access, who owns them, and how to prevent their exposure or abuse.&lt;/p&gt;

&lt;h3&gt;
  
  
  The credential layer includes every surface that can hold a credential
&lt;/h3&gt;

&lt;p&gt;The credential layer has no single technology boundary. It permeates the systems where software is developed, operated, and maintained.&lt;/p&gt;

&lt;p&gt;A useful way to understand its scope is to group credential surfaces according to their intended purpose and the organization's ability to control them.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Surface group&lt;/th&gt;
&lt;th&gt;What it means&lt;/th&gt;
&lt;th&gt;Where credentials appear&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Governed stores&lt;/td&gt;
&lt;td&gt;Systems intended to hold and manage credentials securely&lt;/td&gt;
&lt;td&gt;Vaults, secrets managers, password managers, CI/CD secret stores&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Working surfaces&lt;/td&gt;
&lt;td&gt;Systems where credentials are used during normal operations&lt;/td&gt;
&lt;td&gt;Source code, pipelines, cloud runtime, developer endpoints, AI agents, MCP servers, logs, backups, and data platforms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Spilled surfaces&lt;/td&gt;
&lt;td&gt;Internal systems where credentials appear outside their intended purpose&lt;/td&gt;
&lt;td&gt;Slack, Jira, Confluence, email, support tickets, documentation, and messaging tools&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Escaped surfaces&lt;/td&gt;
&lt;td&gt;Public or external locations beyond organizational control&lt;/td&gt;
&lt;td&gt;Public GitHub, Docker Hub, package registries, public artifacts, paste sites, and personal repositories&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Each surface creates a different remediation challenge.&lt;/p&gt;

&lt;p&gt;A credential inside a vault can be governed through access controls and rotation policies. You can remove a credential from source code, but its history may remain accessible. A credential in a backup may be difficult to erase. A credential published to the internet must be treated as potentially copied by anyone.&lt;/p&gt;

&lt;p&gt;The same credential can, and often does, move through all four groups during its lifetime, most often moving through the laptop.&lt;/p&gt;

&lt;p&gt;An API key might originate in a cloud service, be stored in a vault, copied onto a local .env file, used by an AI coding assistant, written into a build log, and eventually committed to a public repository.&lt;/p&gt;

&lt;p&gt;Every location becomes part of the credential layer, and the credential can retain its original access throughout that journey.&lt;/p&gt;

&lt;h3&gt;
  
  
  The credential layer and the identity layer work together
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvbp7ewq6bcyaptz2at4h.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvbp7ewq6bcyaptz2at4h.png" alt="5 questions that turn a secret into a risk" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The identity layer establishes who or what is requesting access. This is the bedrock for IAM and how authentication and authorization are governed. The credential layer includes every surface where the authentication material associated with those identities can exist.&lt;/p&gt;

&lt;p&gt;A developer might use their authority to create a service account for a cloud service. That new identity is granted access to a production database with a plaintext key. That API key can exist in a developer's local configuration, a deployment pipeline, and an archived support ticket.&lt;/p&gt;

&lt;p&gt;Every credential security program needs to go beyond just discovering secrets. They need to answer several connected questions around identity and access:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which identity does this credential map to?&lt;/li&gt;
&lt;li&gt;Who owns that identity?&lt;/li&gt;
&lt;li&gt;Is the credential valid?&lt;/li&gt;
&lt;li&gt;What can it access?&lt;/li&gt;
&lt;li&gt;Where else does it exist?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That context turns a discovered string into a security risk that can be understood and addressed.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why attackers target the credential layer
&lt;/h2&gt;

&lt;p&gt;Attackers know that a single plaintext string can let them act as identities with access to systems that already trust them.&lt;/p&gt;

&lt;p&gt;An attacker who obtains a valid credential can authenticate to a service, retrieve protected data, or perform actions within the permissions assigned to that identity. No zero days or deep system knowledge needed.&lt;/p&gt;

&lt;p&gt;The initial exposure may come from a repository, a compromised laptop, a collaboration message, or an external dependency. The pattern is always that an attacker obtains an authentication mechanism and then uses the access it provides. This is why Credential Access is &lt;a href="https://attack.mitre.org/tactics/TA0006/" rel="noopener noreferrer"&gt;tactic 6 of the MITRE ATT&amp;amp;CK framework&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;A single credential can lead to many more credentials.&lt;/p&gt;

&lt;p&gt;Access to a developer workstation might reveal cloud tokens and SSH keys. Access to a CI/CD platform might reveal deployment credentials. Access to a cloud environment might reveal service account permissions or configuration containing more authentication material.&lt;/p&gt;

&lt;p&gt;Each successful step can lead to another part of the credential layer.&lt;/p&gt;

&lt;h3&gt;
  
  
  Machine credentials make access easier for attackers
&lt;/h3&gt;

&lt;p&gt;Human authentication increasingly includes MFA, device verification, and contextual access policies.&lt;/p&gt;

&lt;p&gt;Most machine-to-machine systems still depend on reusable bearer tokens or API keys. A valid credential alone can be sufficient to authenticate a request without additional proof of who possesses it.&lt;/p&gt;

&lt;p&gt;These credentials are often broadly scoped and long-lived. The goal is to keep production running, which means stability and avoiding permission issues while the application operates.&lt;/p&gt;

&lt;p&gt;A pipeline token might have permission to publish packages for years. A cloud key might access production storage long after the related systems have been decommissioned. A service account can retain privileges from a project completed years earlier. By default, most credentials have no expiration date; they keep working forever unless configured otherwise.&lt;/p&gt;

&lt;p&gt;At machine speed, an attacker can harvest, test, and use a credential before a human analyst begins investigating the original exposure.&lt;/p&gt;

&lt;h3&gt;
  
  
  Supply chain attacks demonstrate the power and danger of local credentials
&lt;/h3&gt;

&lt;p&gt;The &lt;a href="https://blog.gitguardian.com/shai-hulud-npm-pypi-supply-chain-attacks/" rel="noopener noreferrer"&gt;Shai-Hulud npm supply chain attacks&lt;/a&gt;, while just one of many similar campaigns, show how attackers exploit the credential layer across multiple systems.&lt;/p&gt;

&lt;p&gt;The attack used compromised packages to harvest credentials from developer and CI/CD environments. Stolen tokens enabled further malicious activity, including propagation through package publishing and exposure of harvested secrets.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://blog.gitguardian.com/shai-hulud-2/" rel="noopener noreferrer"&gt;The GitGuardian analysis of one wave identified 33,185 unique secrets across 294,842&lt;/a&gt; occurrences, including 3,760 credentials confirmed valid during analysis.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn8muq30cydxo976208x9.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn8muq30cydxo976208x9.png" alt="Shai-hulud 2: top 10 types of unique valid secrets" width="800" height="436"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The infostealer malware moved through developer endpoints, package registries, CI/CD infrastructure, and public GitHub, publishing copies of itself forward wherever possible. Each surface it touched had differently managed security strategies, but the credentials layer connected all of those surfaces, regardless of governance policies.&lt;/p&gt;

&lt;p&gt;This is the challenge with treating credential exposures as isolated incidents. A secret discovered in one system may already have been copied into several others, and its permissions can make those other systems reachable.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where credential layer security fits in defense in depth
&lt;/h2&gt;

&lt;p&gt;Enterprise security has been built around specialized controls, separating logical concerns from an IT perspective. Each stack addresses an individual enterprise need: IAM, PAM, secrets managers, EDR, cloud security, and application security are all needed.&lt;/p&gt;

&lt;p&gt;Credential layer security operates across these existing investments because credentials move between the environments they protect.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Security control&lt;/th&gt;
&lt;th&gt;What it primarily manages&lt;/th&gt;
&lt;th&gt;Credential layer consideration&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;IAM and IGA&lt;/td&gt;
&lt;td&gt;Identities, roles, and entitlements&lt;/td&gt;
&lt;td&gt;Credentials associated with identities may exist outside managed systems&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;PAM&lt;/td&gt;
&lt;td&gt;Privileged access and sessions&lt;/td&gt;
&lt;td&gt;Privileged credentials may be copied into files, scripts, or other environments&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Secrets managers and vaults&lt;/td&gt;
&lt;td&gt;Secure storage, delivery, and rotation&lt;/td&gt;
&lt;td&gt;Credentials can exist outside managed stores, including copies of vaulted secrets&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AppSec and code scanning&lt;/td&gt;
&lt;td&gt;Application risks and repository exposure&lt;/td&gt;
&lt;td&gt;Credentials also accumulate outside repositories&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EDR and XDR&lt;/td&gt;
&lt;td&gt;Endpoint behavior and suspicious activity&lt;/td&gt;
&lt;td&gt;Credential inventory, validity, and permissions require additional context&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ITDR&lt;/td&gt;
&lt;td&gt;Identity attacks and suspicious authentication activity&lt;/td&gt;
&lt;td&gt;Credential exposure can be identified before suspicious use&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Cloud security&lt;/td&gt;
&lt;td&gt;Cloud configuration, workloads, and access&lt;/td&gt;
&lt;td&gt;Cloud credentials can spread into development and external systems&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SIEM&lt;/td&gt;
&lt;td&gt;Security telemetry and correlation&lt;/td&gt;
&lt;td&gt;Credential risks depend on whether exposure and identity context are available&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Every one of these controls remains necessary. Credential layer security provides a way to connect the findings from where they overlap or leave gaps.&lt;/p&gt;

&lt;p&gt;Credentials are essential operational resources for most organizations and, at the same time, potential security liabilities. Developers and applications need reliable access to do their work. Controls that introduce excessive friction can encourage unmanaged copies and workarounds.&lt;/p&gt;

&lt;p&gt;A mature program combines visibility and enforcement with practical workflows for securely creating, distributing, using, and retiring credentials.&lt;/p&gt;

&lt;h2&gt;
  
  
  The six controls of credential layer security
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5z3waquiql4bo8a0gc63.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F5z3waquiql4bo8a0gc63.png" alt="The six controls of credential layer security" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Organizations need a consistent approach that works across all credential surfaces. We propose there are six controls that provide that foundation.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. Discover credentials wherever they exist
&lt;/h3&gt;

&lt;p&gt;Visibility across the credential layer is vital. This extends well beyond what is just known and vaulted.&lt;/p&gt;

&lt;p&gt;Scanning source repositories is an important starting point, as applications connect to our most important resources. Coverage also needs to extend into pipelines, developer endpoints, AI configuration, operational data, collaboration tools, public repositories, and other environments where credentials appear.&lt;/p&gt;

&lt;p&gt;GitGuardian's &lt;a href="https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026/" rel="noopener noreferrer"&gt;State of Secrets Sprawl 2026&lt;/a&gt; reported 28.65 million new secrets exposed on public GitHub just during 2025. That's a 34% year-over-year increase. At the same time, the report found that approximately 28% of secret incidents occurred entirely outside code repositories.&lt;/p&gt;

&lt;p&gt;The objective of discovery is to find credentials across the environments where they actually exist, including historical exposure and copies that persist long after their original purpose has ended.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Prioritize credential findings by their access risk
&lt;/h3&gt;

&lt;p&gt;A long, high-entropy string, on its own, is not a danger. Any string that grants access is. Context determines which require attention first. Validation is a good place to start. A credential's validity, type, permissions, exposure location, and associated systems help establish its risk.&lt;/p&gt;

&lt;p&gt;Thinking of extreme examples, a valid production API key with administrative privileges presents a higher risk that requires attention, vs. an expired test credential which is no good for anyone.&lt;/p&gt;

&lt;p&gt;However, some credential providers offer limited or no direct validity checking. For many secrets found by our generic detectors, like SSH keys or custom tokens, it can be impossible to map these back to the issuing system. Security teams need to rely on additional signals, including recent use, credential structure, associated identities, and the environments where the secret appears.&lt;/p&gt;

&lt;p&gt;Prioritization should consider what the credential can reach and the consequences of unauthorized use.&lt;/p&gt;

&lt;p&gt;Security teams should focus remediation efforts on exposures that pose the greatest risk to critical business systems.&lt;/p&gt;

&lt;h3&gt;
  
  
  3. Connect credentials to identities and owners
&lt;/h3&gt;

&lt;p&gt;Every credential had a purpose when created. This means someone created it. Is that same person the owner now, and are they accountable for it?&lt;/p&gt;

&lt;p&gt;Answering this is increasingly difficult as organizations create more non-human identities.&lt;/p&gt;

&lt;p&gt;Their original owners of any minted keys or tokens may change roles or leave the company entirely, while the credentials remain active. After the applications that needed them are retired, these service account passwords, cloud workload tokens, and AI agent keys retain their permissions, granting access to systems for anyone who finds them.&lt;/p&gt;

&lt;p&gt;A complete credential-layer view connects each secret to its associated identity, responsible team, permissions, and rotation requirements. It also identifies orphaned identities, overprivileged accounts, and credentials with uncertain ownership.&lt;/p&gt;

&lt;p&gt;When a critical credential is exposed, the security team will invariably need to identify who has the authority and technical understanding to rotate or revoke it safely.&lt;/p&gt;

&lt;h3&gt;
  
  
  4. Remediate the credential and its exposed copies
&lt;/h3&gt;

&lt;p&gt;For any security team, the immediate instinct when a secret is found is to revoke it, stopping abuse and attacker access. But this carries the risk of reducing the availability of the systems relying on those credentials. After all, if we fail at keeping things running, we have fallen short of the CIA triad: Confidentiality, Integrity, and Availability.&lt;/p&gt;

&lt;p&gt;How you respond to a leak, or exposure, differs by surface. Consider an internal collaboration message; even if deleted, you need to consider exports, notifications, and backups that may retain copies. A credential exposed in a public repository must be treated as potentially copied outside the organization's control. Logs, snapshots, traces, and backups can retain credentials long after the original exposure.&lt;/p&gt;

&lt;p&gt;Rotation, meaning replacing the secret with a new one and invalidating the compromised secret, or simply revoking it, will always need to be a case-by-case decision. Security, platform, and application owners need coordinated workflows to replace it without disrupting operations.&lt;/p&gt;

&lt;p&gt;A mature credential layer security program needs to treat related copies of an exposure as one connected incident. Tracking remediation by confirming the old credential no longer works is the only way to know when it is safe to resolve leak occurrences.&lt;/p&gt;

&lt;h3&gt;
  
  
  5. Prevent credentials from spreading in plaintext
&lt;/h3&gt;

&lt;p&gt;While discovery and remediation make up the core of any credential layer program, preventing the need for scanning and incident management should be a significant part of the mission. Preventing new credentials from entering unmanaged environments is the most cost-effective way to tackle the issue of secret sprawl.&lt;/p&gt;

&lt;p&gt;Teams need to implement controls at the local level. With pre-commit hooks, teams can make sure credentials never make it to shared repositories. This, in turn, keeps them out of pull requests, CI/CD execution, and any logs or build artifacts.&lt;/p&gt;

&lt;p&gt;Developers can get immediate feedback and guidance while any keys are in plaintext in the IDE, when it is far easier to correct. If it never reaches production, revoking and replacing is much safer, since nothing should break when it is invalidated.&lt;/p&gt;

&lt;p&gt;AI coding assistants, now commonplace, are another place where preventive controls are needed. Deterministic hooks can check for secrets in prompts, file reads, commands, and supported tool actions at defined points in an agent workflow, stopping the agent from taking further action if any are found. This prevents secret sprawl and, importantly, adds controls against the AI abusing keys it encounters while working to complete a task.&lt;/p&gt;

&lt;p&gt;Reducing unnecessary credential movement should be the central focus, but security teams need to work with developers to reduce risk further. Short-lived credentials, narrowly scoped permissions, secure injection, and workload identity federation can reduce reliance on reusable secrets.&lt;/p&gt;

&lt;p&gt;For supported machine-to-machine interactions, federation using standards such as OIDC can replace standing API keys with temporary credentials issued for a particular workload or session. Those decisions need to be implemented by platform, DevOps, and development teams.&lt;/p&gt;

&lt;h3&gt;
  
  
  6. Detect suspicious credential harvesting with honeytokens
&lt;/h3&gt;

&lt;p&gt;Some credential exposure becomes visible only when someone attempts to use the information they have obtained.&lt;/p&gt;

&lt;p&gt;Honeytokens provide a way to detect this activity.&lt;/p&gt;

&lt;p&gt;A honeytoken is a decoy credential planted in a location where legitimate workflows have no reason to use it. When someone attempts to authenticate with the decoy, the attempt generates an alert.&lt;/p&gt;

&lt;p&gt;Placed on developer endpoints, honeytokens can help reveal infostealers or other software harvesting local credentials.&lt;/p&gt;

&lt;p&gt;They can also provide useful evidence during incident response, including which protected environment contained the decoy and when an attempted use occurred.&lt;/p&gt;

&lt;p&gt;Honeytokens complement discovery and prevention by identifying attempted abuse of planted credentials.&lt;/p&gt;

&lt;h3&gt;
  
  
  Six controls, one goal
&lt;/h3&gt;

&lt;p&gt;Considered together, these six controls support a connected program.&lt;/p&gt;

&lt;p&gt;Discovery establishes visibility. Validation identifies risk. Ownership establishes accountability. Remediation removes exposed access. Prevention reduces future exposure. Deception helps reveal unauthorized credential activity.&lt;/p&gt;

&lt;p&gt;Combined with a broader defense-in-depth strategy, using the other systems and tools previously outlined, organizations are far more resilient when it comes to access and security.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why developer endpoints and AI agents demand attention
&lt;/h2&gt;

&lt;p&gt;Developer laptops have become some of the richest credential surfaces in the enterprise.&lt;/p&gt;

&lt;p&gt;During an ordinary workday, a developer may authenticate to source control, cloud infrastructure, package registries, CI/CD services, databases, and internal applications.&lt;/p&gt;

&lt;p&gt;Those credentials can accumulate in .env files, shell history, local scripts, CLI configurations, browser storage, caches, and other developer tooling.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://blog.gitguardian.com/extending-our-mission-with-developer-endpoint-protection/" rel="noopener noreferrer"&gt;GitGuardian's Developer Endpoint Protection research&lt;/a&gt; found an average of approximately 150 secrets per developer laptop. Many of these credentials never enter a repository. Traditional downstream scanning has no opportunity to discover them.&lt;/p&gt;

&lt;h3&gt;
  
  
  AI coding assistants extend exposure
&lt;/h3&gt;

&lt;p&gt;AI coding assistants and other local agents, like OpenClaw, offer many advantages for automating tasks and saving everyone toil. They are helpful precisely because they can read files, execute commands, call APIs, and communicate with MCP servers. But this is also where the danger lies.&lt;/p&gt;

&lt;p&gt;When they can encounter credentials, either already present on a developer's machine or introduce new exposures through prompts, generated code, tool responses, and configuration files, their non-deterministic nature means they might act as an insider threat. And they encounter such secrets very often, increasingly due to their own architectures.&lt;/p&gt;

&lt;p&gt;The 2026 State of Secrets Sprawl report identified 24,008 unique secrets in publicly exposed MCP configuration files, including 2,117 valid credentials. Many of them should be considered highly critical and dangerous. While at the same time, credentials related to AI services increased 81% year over year. These findings show how rapidly development practices can create new credential locations.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjgwlcsh2qfbae01130ss.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjgwlcsh2qfbae01130ss.png" alt="Top 5 valid unique secrets in MCP configuration files" width="747" height="365"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;For security teams, the challenge remains consistent: discover what credentials an agent can encounter, understand the access they provide, establish ownership, and prevent unnecessary exposure.&lt;/p&gt;

&lt;p&gt;An agent's intended behavior may be defined in its instructions. Its actual ability to affect enterprise systems depends on the tools, credentials, and permissions available to it.&lt;/p&gt;

&lt;p&gt;This makes credential scope and deterministic access controls increasingly important.&lt;/p&gt;

&lt;h2&gt;
  
  
  From isolated controls to mature credential layer security
&lt;/h2&gt;

&lt;p&gt;Organizations can begin securing the credential layer with relatively simple controls. The challenge is connecting those controls as coverage expands.&lt;/p&gt;

&lt;p&gt;At lower maturity levels, a secret in a repository, a developer laptop, and a collaboration ticket may create three unrelated security incidents.&lt;/p&gt;

&lt;p&gt;At higher levels, those discoveries can be connected to the same credential, its issuing system, the identity behind it, and the access it provides.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://www.gitguardian.com/secrets-management-maturity-questionnaire" rel="noopener noreferrer"&gt;GitGuardian Credential Layer Security Maturity Questionnaire&lt;/a&gt; provides a starting point for organizations assessing their current coverage and maturity.&lt;/p&gt;

&lt;h2&gt;
  
  
  How GitGuardian fits
&lt;/h2&gt;

&lt;p&gt;GitGuardian's mission is to detect, remediate, and prevent secrets sprawl across the credential layer.&lt;/p&gt;

&lt;p&gt;The GitGuardian platform's capabilities cover the six controls described above and provide a unified workspace experience that IAM, DevOps, Security, Platform, and any other team involved in credential creation and management can leverage.&lt;/p&gt;

&lt;p&gt;GitGuardian's Secrets Monitoring discovers exposed credentials across the whole exposed surface, including repositories, CI/CD environments, collaboration tools, and public GitHub. Developer Endpoint Protection extends that same level of discovery into developer machines, which can be deployed via MDM, identifying credentials in local files and tools and scoring exposure by machine, severity, and validity.&lt;/p&gt;

&lt;p&gt;The platform connects credentials to identity ownership, surfaces permissions the credentials hold, and provides context for what is affected if a secret is rotated or revoked. From a security operations perspective, the platform fully supports prioritization and remediation. Honeytoken provides deception signals when decoy credentials are used.&lt;/p&gt;

&lt;p&gt;For prevention, GitGuardian extends the power of the platform to the developer, where they work, through ggshield. Developer-focused tools, like the &lt;a href="https://blog.gitguardian.com/visual-studio-code-extension/" rel="noopener noreferrer"&gt;VS Code Extension&lt;/a&gt; and automated ggshield commands such as pre-commit hooks, give your team commit-time checks and guardrails without asking them to change their workflows. AI hooks can inspect credential exposure at defined checkpoints along coding agents' working paths.&lt;/p&gt;

&lt;p&gt;These capabilities complement the IAM, IGA, PAM, vault, EDR, ITDR, and cloud controls organizations already operating.&lt;/p&gt;

&lt;p&gt;Together, they support a coordinated approach to securing credentials across the many environments where those credentials exist and move.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where credential layer security is heading
&lt;/h2&gt;

&lt;p&gt;The credential layer will continue expanding as software becomes more automated and enterprise systems become more interconnected.&lt;/p&gt;

&lt;p&gt;AI agents, automated workflows, and new integrations will create additional places where credentials are issued, used, cached, and exposed.&lt;/p&gt;

&lt;p&gt;At the same time, changes in authentication architecture offer opportunities to reduce reliance on persistent secrets. Workload identity federation, short-lived tokens, and more narrowly scoped permissions can reduce the number of reusable credentials that remain valuable after exposure.&lt;/p&gt;

&lt;p&gt;Any improvements like these do not eliminate the need for credential-layer visibility. Temporary credentials can still appear in logs or tooling, and systems will continue to depend on authentication material in different forms.&lt;/p&gt;

&lt;p&gt;The future of the credential layer is a connected security program that understands credentials throughout their lifecycle, following where they are created, where they travel, what identities they represent, what systems they can reach, and how they are retired.&lt;/p&gt;

&lt;h2&gt;
  
  
  Secure the credential every other control trusts
&lt;/h2&gt;

&lt;p&gt;Every part of the modern enterprise relies on credentials. The credential layer includes every surface where those credentials can exist. Its boundaries extend across security tools, development processes, organizational departments, and the public internet.&lt;/p&gt;

&lt;p&gt;Securing the credential layer from attackers, insider threats, and AI abuse requires treating those connected exposures as one enterprise-wide security concern. Organizations need visibility across surfaces, knowledge of the identities and permissions behind each credential, and coordinated processes to remove dangerous access and prevent new exposure.&lt;/p&gt;

&lt;p&gt;As automated systems create and use credentials at increasing speed, the ability to secure this layer becomes fundamental to protecting the enterprise.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/interactive-demo" rel="noopener noreferrer"&gt;Take a platform tour now.&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is credential layer security?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Credential layer security is the practice of protecting every surface where credentials can be created, stored, transmitted, or used. In practice, that means finding all plaintext secrets and connecting identity context, remediation, and prevention across the enterprise.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What is the credential layer?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The credential layer encompasses every place a credential can exist, in any state or condition, including code, cloud infrastructure, laptops and dev environments, and SaaS applications. It has four surface groups: governed stores like vaults, working surfaces like pipelines and developer endpoints, spilled surfaces like Slack and Jira, and escaped surfaces like public GitHub and paste sites. A single credential often moves through all four during its lifetime.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why do attackers target the credential layer?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A valid credential lets an attacker act as an identity that systems already trust, with no zero-days or deep system knowledge needed. One credential can also lead to others. Access to a developer workstation might reveal cloud tokens and SSH keys, and access to a CI/CD platform might reveal deployment credentials. Credential Access is tactic 6 of the MITRE ATT&amp;amp;CK framework.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What are the six controls of credential layer security?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The six controls are discovering credentials wherever they exist, prioritizing findings by access risk, connecting credentials to identities and owners, remediating the credential and its exposed copies, preventing credentials from spreading in plaintext, and detecting suspicious credential harvesting with honeytokens. Together, they support a connected program rather than isolated incident response.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How does credential layer security fit with IAM, PAM, and secrets managers?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;It complements them. IAM, PAM, vaults, EDR, ITDR, cloud security, and SIEM each remain necessary, but credentials move between the environments those controls protect. Credentials tied to managed identities may exist outside managed systems, and copies of vaulted secrets can persist elsewhere. Credential layer security connects findings from the places where those controls overlap or leave gaps.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Why do developer endpoints and AI agents need special attention in credential security?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Developer laptops hold an average of approximately 150 secrets each, in places like .env files, shell history, and CLI configurations that never reach a repository. AI coding assistants can read files, execute commands, and call MCP servers, they may encounter those credentials. The 2026 State of Secrets Sprawl report found 24,008 unique secrets in public MCP configuration files, including 2,117 valid credentials.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How does GitGuardian help secure the credential layer?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;GitGuardian covers the six controls across the credential layer. Secrets Monitoring discovers exposed credentials across repositories, CI/CD environments, collaboration tools, and public GitHub. Developer Endpoint Protection extends discovery to developer machines and can be deployed via MDM. The platform adds identity ownership, permissions, and remediation context, honeytokens provide deception signals, and ggshield, the VS Code extension, pre-commit hooks, and AI hooks prevent exposure where developers work.&lt;/p&gt;

</description>
      <category>security</category>
      <category>devsecops</category>
      <category>appsec</category>
      <category>secrets</category>
    </item>
    <item>
      <title>Leaked API Keys in LLMs: How AI Agents Expose Secrets</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Wed, 21 Oct 2026 23:14:37 +0000</pubDate>
      <link>https://dev.to/gitguardian/leaked-api-keys-in-llms-how-ai-agents-expose-secrets-1781</link>
      <guid>https://dev.to/gitguardian/leaked-api-keys-in-llms-how-ai-agents-expose-secrets-1781</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9c4eo6kc4bjw8ftcad9d.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9c4eo6kc4bjw8ftcad9d.png" alt="Leaked API Keys in LLMs: How AI Agents Expose Secrets" width="800" height="420"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  TL;DR
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;LLMs can reproduce real leaked keys&lt;/strong&gt;: Using only API output access, researchers recovered DeepSeek and Google keys from Qwen3-27B, GPT-Codex 5.3, and Claude Haiku 4.5, and every key had a matching public GitHub occurrence.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agents pull secrets in from the laptop&lt;/strong&gt;: Developer endpoints hold credentials in .env files, shell history, and MCP configs that never reach Git. Claude Code-assisted commits leaked secrets at 3.2%, versus a 1.5% baseline.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Stop secrets before the model sees them&lt;/strong&gt;: AI Hooks block secrets in prompts, tool calls, and output, while Developer Endpoint Protection reduces the plaintext credentials on managed fleets that agents can find.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  More AI, more places to leak secrets
&lt;/h2&gt;

&lt;p&gt;More and more teams are adopting AI agents, allowing them to create new tools, apps, and software at unprecedented speed. At the core of every connection these apps require is a credential, often in the form of an API key.&lt;/p&gt;

&lt;p&gt;Those keys get leaked every time they are touched by the AI, and in ways that might not be obvious at first glance.&lt;/p&gt;

&lt;p&gt;A coding agent can read a local configuration file, run a command, or call a Model Context Protocol (MCP) server. Any of those actions can place a credential into the context sent to a large language model (LLM).&lt;/p&gt;

&lt;p&gt;Recent research shows that exposed credentials can also survive much farther downstream. Researchers behind "&lt;a href="https://arxiv.org/html/2609.36941v1" rel="noopener noreferrer"&gt;Practical Secrets Extraction against Black-box LLMs&lt;/a&gt;" recovered strings matching real API keys from Qwen3-27B, GPT-Codex 5.3, and Claude Haiku 4.5 using output-only access.&lt;/p&gt;

&lt;p&gt;Very importantly, they had no access to model weights or token probabilities. This was done completely through "API output-only access."&lt;/p&gt;

&lt;p&gt;LLM API key leakage now reaches across the credential lifecycle. Existing credentials are now part of training data and can and do appear in model output. AI agents can also move fresh credentials into model context during normal development work.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the researchers found from LLM output
&lt;/h2&gt;

&lt;p&gt;The researchers recovered real credential strings from three black-box LLMs. All three exposed a secret.&lt;/p&gt;

&lt;p&gt;Qwen3-27B returned two DeepSeek keys and one Google key. GPT-Codex 5.3 returned a DeepSeek key. Claude Haiku 4.5 returned two DeepSeek keys.&lt;/p&gt;

&lt;p&gt;They then searched GitHub for each complete credential and found a public match every time. That supports the conclusion that the models reproduced real leaked secrets rather than generating strings that only looked valid.&lt;/p&gt;

&lt;p&gt;The researchers stopped there. They masked the credentials and did not test whether the keys still worked.&lt;/p&gt;

&lt;p&gt;An attacker or rogue agent would have no reason to stop. A recovered key could be tested, used to access downstream systems, or abused until it is revoked, &lt;a href="https://blog.gitguardian.com/litellm-supply-chain-attack/" rel="noopener noreferrer"&gt;as we have seen across many attacks&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;What caught our attention about this paper is that black-box, read only access alone can be enough to recover memorized credentials from model output. The next obvious question is, how did those keys get there?&lt;/p&gt;

&lt;h2&gt;
  
  
  Where are LLMs getting keys?
&lt;/h2&gt;

&lt;p&gt;LLMs can find &lt;a href="https://blog.gitguardian.com/api-key-security-7/" rel="noopener noreferrer"&gt;API keys in public training data&lt;/a&gt;, and we know there are a lot there, but AI agents create a more immediate source: the developer laptop.&lt;/p&gt;

&lt;p&gt;Public repositories can become part of datasets used to train or evaluate models. Once a credential appears in public code, it can also spread through forks, copied examples, logs, and other development artifacts. This happens a lot.&lt;/p&gt;

&lt;p&gt;GitGuardian detected &lt;a href="https://www.gitguardian.com/state-of-secrets-sprawl-report-2026" rel="noopener noreferrer"&gt;28.65 million new hardcoded secrets in public GitHub commits in 2025&lt;/a&gt;. Credentials tied to AI services reached 1,275,105, an 81% increase year over year.&lt;/p&gt;

&lt;p&gt;The black-box LLM research shows the downstream result. Researchers recovered credential strings from deployed models and found matching public occurrences on GitHub for every recovered key.&lt;/p&gt;

&lt;h3&gt;
  
  
  AI agents find secrets closer to the developer
&lt;/h3&gt;

&lt;p&gt;Developer laptops have quietly become credential stores. Secrets live in .env files, cloud configuration files, and shell history. They also appear in IDE settings, CLI data, local logs, and temporary debugging files.&lt;/p&gt;

&lt;p&gt;Many of those credentials never reach Git. This is especially true on 'citizen coders' laptops where people are only ever deploying to localhost.&lt;/p&gt;

&lt;p&gt;AI coding agents can still encounter them. Agents can read files, run commands, and inspect application output. They can also call MCP servers that return credentials as part of a response.&lt;/p&gt;

&lt;p&gt;GitGuardian's research really reveals just the tip of this iceberg, looking just at committed code: Claude Code-assisted public commits had a 3.2% secret leak rate, compared with a 1.5% baseline across public GitHub commits. MCP adds another source: 24,008 unique secrets were found in public MCP configuration files, including 2,117 valid credentials.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fh1v1eqm4vg8jyxmum6la.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fh1v1eqm4vg8jyxmum6la.png" alt="Claude Code stats from State of Secrets Sprawl" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Public repositories show the part of credential exposure that becomes visible. The developer endpoint holds a much larger pool of potential secrets. Local configurations, command history, application data, and AI tooling can all contain credentials that never appear in a repository.&lt;/p&gt;

&lt;p&gt;LLMs can therefore encounter credentials from both ends of the development lifecycle. Public data can carry old exposures into model training. AI agents can pull fresh secrets directly from the environments where developers work.&lt;/p&gt;

&lt;h2&gt;
  
  
  How AI agents expose secrets to LLMs
&lt;/h2&gt;

&lt;p&gt;AI coding agents all have a model at their core, taking prompts and data in as tokens and returning generated replies. The tool chain around this LLM defines how credentials can reach a model.&lt;/p&gt;

&lt;p&gt;The developer never needs to copy the API key into the prompt. The credential can enter the interaction as the agent gathers context needed to solve the problem.&lt;/p&gt;

&lt;p&gt;A developer might ask an agent to troubleshoot an API connection. The agent could read an .env file, inspect a cloud configuration, or search application logs. It could also run a shell command or call an MCP server.&lt;/p&gt;

&lt;p&gt;Traditional approaches to secret scanning focused on repository and CI scanning may never see this exposure because there may be no commit or pull request. The secret can move directly from the developer endpoint into an AI workflow.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://blog.gitguardian.com/ai-agents-authentication-how-autonomous-systems-prove-identity/" rel="noopener noreferrer"&gt;AI agents&lt;/a&gt; are entering environments where credentials are already scattered across developer systems. More autonomy gives those agents more opportunities to encounter them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Model context is becoming part of the credential boundary
&lt;/h2&gt;

&lt;p&gt;We do need to acknowledge here that model exposure and model training are separate concerns. A credential can reach an LLM without becoming training data. Enterprise AI providers may limit whether prompts and outputs are used for training.&lt;/p&gt;

&lt;p&gt;Credential exposure happens earlier, when an agent sends a secret outside the developer environment. Once that happens, security teams need to know where the credential went, how long it may be retained, and whether it should still be trusted.&lt;/p&gt;

&lt;p&gt;Training is one possible destination. Model context is the immediate concern. What will it do with that secret it finds?&lt;/p&gt;

&lt;p&gt;The strongest control point sits before transmission. AI agents can encounter secrets while reading files, running commands, or calling tools. Security controls need to inspect those interactions before credentials become part of model context.&lt;/p&gt;

&lt;p&gt;That creates a new credential boundary at the developer endpoint and inside the agent workflow.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep secrets away from the AI agent
&lt;/h2&gt;

&lt;p&gt;The best place to stop LLM credential exposure is before the secret reaches the model. The best way to do that is with deterministic tools around the agent's workflow.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://blog.gitguardian.com/ai-hooks-ai-coding-assistants/" rel="noopener noreferrer"&gt;GitGuardian AI Hooks&lt;/a&gt; put controls directly around the actions AI coding agents take. The GitGuardian CLI, ggshield, can scan a developer's prompt before submission and inspect file reads, shell commands, and MCP calls before execution. When a secret is detected, the action can be blocked before the credential reaches the model. Scanning also happens at any tool output, withholding secret-bearing responses from being passed to the model entirely.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6gvbzztyb7yonbjvq55g.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6gvbzztyb7yonbjvq55g.png" alt="Flowchart of the six-step AI agent loop, with three GitGuardian AI Hooks checkpoints." width="799" height="458"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Anything you ask an agent to do is a suggestion; it might or might not follow it, as we have seen in countless rogue agent stories. Unlike skills, Markdown, or system prompts, AI hooks fire at predictable points along the agent's defined workflow. They are outside the reach of the agent, working at the system level where the agent interacts with the environment. Calling a deterministic tool in a deterministic way is how you go from suggesting the agent not use a secret to halting an operation that would have exposed a secret to the LLM or elsewhere.&lt;/p&gt;

&lt;h3&gt;
  
  
  GitGuardian's Developer Endpoint Protection tackles the much larger pool of credentials the agent might discover
&lt;/h3&gt;

&lt;p&gt;GitGuardian is working to secure the entire credential layer. That is why GitGuardian introduced &lt;a href="https://www.gitguardian.com/developer-endpoint-protection" rel="noopener noreferrer"&gt;Developer Endpoint Protection&lt;/a&gt; to scan developer machines for credentials sitting in local files and local storage. We are giving security teams visibility into which tools are running and what resources the agents can reach, all from one unified secrets security interface. These capabilities can be deployed across managed fleets through Jamf, Iru, Intune, and other MDM solutions, rather than relying on individual developers to configure protections themselves.&lt;/p&gt;

&lt;p&gt;This empowers security teams to work with developers, no matter what department they work in, to reduce how many dangerous plaintext credentials are available for an agent to find.&lt;/p&gt;

&lt;p&gt;Secrets needed by applications and developers belong in &lt;a href="https://blog.gitguardian.com/top-secrets-management-tools/" rel="noopener noreferrer"&gt;managed vaults&lt;/a&gt;. GitGuardian's &lt;a href="https://blog.gitguardian.com/gitguardian-nhi-governance-now-gives-more-comprehensive-visibility/" rel="noopener noreferrer"&gt;secrets manager integrations&lt;/a&gt; can identify whether exposed credentials are already vaulted, connect incidents with vault context, and help move unvaulted secrets into secure storage. That context also makes remediation faster by showing teams where the managed secret lives, the full context around it, and who needs to act.&lt;/p&gt;

&lt;h2&gt;
  
  
  The goal is bigger than just catching a secret in a prompt
&lt;/h2&gt;

&lt;p&gt;Reducing the credentials sitting on developer endpoints should be a stated goal of a security program. Any secrets that do need to remain in the hands of the developer should be properly maintained and scoped as tightly as possible to only the smallest needed access the developer can still use.&lt;/p&gt;

&lt;p&gt;Teams need to work to place controls around AI agents before they can carry credentials into another system.&lt;/p&gt;

&lt;p&gt;GitGuardian can put those controls in place today and scale them across the organization. Every secret stopped before it reaches an LLM is one less credential an AI agent can expose, one less incident to remediate, and one less secret that can enter the downstream data lifecycle that may eventually include model training.&lt;/p&gt;

&lt;h2&gt;
  
  
  Keep API keys out of LLM context
&lt;/h2&gt;

&lt;p&gt;The black-box LLM research shows how far a leaked credential can travel, all the way into training data. Plaintext secrets bring danger wherever they appear because they require no additional proof of identity to use. If you have the string, you can try to log in.&lt;/p&gt;

&lt;p&gt;At the same time, the actions an AI agent takes are non-deterministic and therefore unpredictable. Trying to control every possible agent behavior is a non-starter because that rule set becomes infinitely large, even if AI helps write it.&lt;/p&gt;

&lt;p&gt;The most practical approach is to keep fewer plaintext secrets within reach, limit what agents can access, and stop credentials before they travel any farther.&lt;/p&gt;

&lt;p&gt;GitGuardian is here to help developers put those controls in place with AI Hooks. You can start using this control today for free as an individual or open-source project.&lt;/p&gt;

&lt;p&gt;For organizations that need the same protection across an entire fleet of developer endpoints, GitGuardian can &lt;a href="https://www.gitguardian.com/book-a-demo" rel="noopener noreferrer"&gt;help roll those controls out at scale while helping you evolve your secrets security program&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is LLM API key leakage?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;LLM API key leakage is the exposure of credentials through large language models. It can happen downstream, when a key from public code is memorized and later reproduced in model output, and it can happen immediately, when an AI agent moves a fresh credential into model context while doing normal development work.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What did researchers find when they tested LLMs for leaked API keys?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The researchers behind "Practical Secrets Extraction against Black-box LLMs" recovered real credential strings from all three models they tested, using only API output access and no model weights or token probabilities. Qwen3-27B returned two DeepSeek keys and one Google key, GPT-Codex 5.3 returned a DeepSeek key, and Claude Haiku 4.5 returned two DeepSeek keys. Every recovered key had a matching public occurrence on GitHub.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where do LLMs get API keys from?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Public repositories are one source, since code with exposed credentials can become part of datasets used to train or evaluate models. GitGuardian detected 28.65 million new hardcoded secrets in public GitHub commits in 2025. AI agents add a more immediate source, the developer laptop, where .env files, cloud configurations, shell history, and MCP settings hold credentials that never reach Git.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How do AI coding agents expose secrets to LLMs?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;An agent troubleshooting an API connection might read an .env file, inspect a cloud configuration, search application logs, run a shell command, or call an MCP server. Any of those actions can put a credential into the context sent to the model, and the developer never has to paste the key into a prompt.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Does a secret sent to an LLM become training data?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Not automatically. Model exposure and model training are separate concerns, and enterprise AI providers may limit whether prompts and outputs are used for training. The exposure still happens earlier, when an agent sends a secret outside the developer environment, so teams need to know where the credential went and whether it should still be trusted.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How can I stop AI agents from sending secrets to an LLM?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Use deterministic controls around the agent's workflow. GitGuardian AI Hooks use ggshield to scan prompts before submission, inspect file reads, shell commands, and MCP calls before execution, and withhold secret-bearing tool output from the model. Developer Endpoint Protection then reduces how many plaintext credentials are available for an agent to find, and can be deployed across managed fleets through MDM solutions like Jamf, Iru, and Intune.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>devsecops</category>
      <category>appsec</category>
    </item>
    <item>
      <title>Why We Built the Good Samaritan Program at GitGuardian</title>
      <dc:creator>Dwayne McDaniel</dc:creator>
      <pubDate>Tue, 20 Oct 2026 12:46:02 +0000</pubDate>
      <link>https://dev.to/gitguardian/why-we-built-the-good-samaritan-program-at-gitguardian-5gj8</link>
      <guid>https://dev.to/gitguardian/why-we-built-the-good-samaritan-program-at-gitguardian-5gj8</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiediauzqvmuxfyahneih.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiediauzqvmuxfyahneih.png" alt="Why We Built the Good Samaritan Program" width="800" height="468"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Before GitGuardian was a company, it was a side project. We were two data scientists looking for the answer to one question: how prevalent were leaked secrets on GitHub? So we built a system that scanned every public commit in real time. The scale of what people were exposing- passwords, cloud keys, the credentials that run real businesses- was far larger than we could have imagined.&lt;/p&gt;

&lt;p&gt;The first product we ever shipped did not make us a cent. It sent an email. When our system saw a developer expose a secret in public, it told them, so they could revoke it before someone else used it. We called it the &lt;a href="https://www.gitguardian.com/enterprise-good-samaritan" rel="noopener noreferrer"&gt;Good Samaritan Program&lt;/a&gt;. For eight years, it has done one thing: warn strangers, thousands of times a day. That email is how a lot of people first met GitGuardian, and it helped make us the most installed security application on the GitHub Marketplace.&lt;/p&gt;

&lt;h2&gt;
  
  
  The missing piece was scale
&lt;/h2&gt;

&lt;p&gt;For most of those nine years, the program reached individuals. But many of those individuals work inside larger enterprises, and many of the secrets they expose do not belong to them personally. Some leaks are a solo developer's personal API key. Many others are enterprise credentials: cloud keys, database passwords, and tokens for systems the developer may not even own, pushed to a personal repository by an employee or contractor.&lt;/p&gt;

&lt;p&gt;Warning: a single developer is easy to automate. It is also not enough to stop the sprawl. 64% of the credentials that were valid in 2022 were &lt;a href="https://www.gitguardian.com/state-of-secrets-sprawl-report-2026" rel="noopener noreferrer"&gt;still unrevoked four years later&lt;/a&gt;. We realized the developer alone was never going to be enough. To close exposures like these, we had to reach the organization that owned the credential.&lt;/p&gt;

&lt;p&gt;The hard part was attribution. Connecting a leaked secret to a developer, and then connecting that developer to the right company, was slow, manual work. We could do it, but only a handful of times.&lt;/p&gt;

&lt;p&gt;That has changed. In 2025 alone, 28.65 million new secrets were pushed to public GitHub, a &lt;a href="https://www.gitguardian.com/state-of-secrets-sprawl-report-2026" rel="noopener noreferrer"&gt;34% jump in a single year&lt;/a&gt; and the largest we have ever recorded. The same force behind that number, AI putting more code in more hands faster, is also what now lets us attribute an exposed secret to the organization it belongs to and route it to the right people. The thing making the problem worse turns out to be the thing that lets us help more.&lt;/p&gt;

&lt;p&gt;So we pointed it at the warning and built a second program. The original Good Samaritan Program warns the developer who leaked a secret. The &lt;a href="https://www.gitguardian.com/enterprise-good-samaritan" rel="noopener noreferrer"&gt;Enterprise Good Samaritan Program&lt;/a&gt; warns the company the secret belongs to.&lt;/p&gt;

&lt;p&gt;That sounds simple in one sentence. It is not. Attributing a single leak means starting with a credential sitting in a stranger's public repository and figuring out which organization it belongs to, whether it is real, and how much access it grants. Doing that once takes judgment. Doing it at scale takes infrastructure. We are working across 370M+ historical exposures and 80k+ new exposures every day, which means attribution cannot depend on human review alone. It takes AI agents to handle the early triage, and human researchers to focus on the most critical leaks.&lt;/p&gt;

&lt;p&gt;Our agents are now able to screen more than a million public incidents a month and investigate over 100,000 of them in depth. At its best, manual review handled a few hundred leaks a week. Today, agents analyze 99,9% of eligible public incidents we detect globally, 10x faster and at half the cost. That speed leaves researchers time for the leaks that need human judgment.&lt;/p&gt;

&lt;p&gt;We are investing in that system because it is what lets the program scale without losing the judgment, restraint, and accountability it depends on. When attribution lands, we work to get the warning in front of someone who can act on it, escalating by hand when an automated alert goes nowhere. And we do all of it under a &lt;a href="https://blog.gitguardian.com/gitguardian-responsible-disclosure/" rel="noopener noreferrer"&gt;published set of rules&lt;/a&gt; for what we will and will not do with a credential find.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why we still call it "Good Samaritan"
&lt;/h2&gt;

&lt;p&gt;In the story, the Samaritan stops for a stranger he has no reason to help, and no one would have blamed him for walking on.&lt;/p&gt;

&lt;p&gt;We are in that position. We can see, in real time, leaks that belong to companies who have never heard of us and may never pay us. We can keep walking, because their exposure is not technically our problem. Or we can tell them. We made that choice early, and we have not changed our minds since.&lt;/p&gt;

&lt;h2&gt;
  
  
  The warning doesn't depend on what you do next
&lt;/h2&gt;

&lt;p&gt;I know how this can sound coming from a security vendor. A free warning, from a company that also sells security software, can look like marketing with extra steps. It is a fair suspicion, and I won't pretend we aren't a business.&lt;/p&gt;

&lt;p&gt;Here is what I can tell you. The warning is complete and unconditional. When we contact you about an exposed secret, you get everything we know: where it leaked, whether it's valid, what it can reach, whether or not you ever speak to us again. There is no gated version, no teaser, no "book a call to learn more." Some companies we've warned later became customers. Most never will, and we keep warning them anyway.&lt;/p&gt;

&lt;h2&gt;
  
  
  Make yourself reachable
&lt;/h2&gt;

&lt;p&gt;If I could ask one thing of any security leader reading this, it is small, and it is free: make sure your company has a way to hear it when an outsider finds your exposed secret. Today, a serious disclosure too often lands in a generic contact form, or a bug-bounty queue built to reject anything that is not a classic vulnerability. Our warning arrives, and then it dies in the wrong inbox.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.gitguardian.com/enterprise-good-samaritan" rel="noopener noreferrer"&gt;You need a door, and someone behind it.&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;We will keep knocking either way. We did it for &lt;a href="https://blog.gitguardian.com/how-we-got-a-cisa-github-leak-taken-down-in-26-hours/" rel="noopener noreferrer"&gt;CISA&lt;/a&gt;, and for companies like Oracle, IBM, SAP, and Red Hat, whose security teams have credited our researchers in their halls of fame. And will keep doing it because we did not build a business and then decide to do some good on the side. The good came first. The company grew up around it.&lt;/p&gt;

&lt;p&gt;And, by the way, you don't have to wait for us to find you. See whether your company's credentials have already been exposed on public GitHub with our &lt;a href="https://www.gitguardian.com/github-security-audit" rel="noopener noreferrer"&gt;GitHub Security Audit&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  FAQ
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;What is an Enterprise Good Samaritan Program from GitGuardian?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Since 2018, GitGuardian's Good Samaritan Program has scanned public GitHub in real time and warned developers, for free, when they exposed a secret. Years of alerts taught us that warning the developer isn't enough. Many of the secrets they expose belong to their employer: cloud keys, database passwords, production tokens. Most are never revoked: 64% of valid secrets found in 2022 were still active in 2026.&lt;/p&gt;

&lt;p&gt;The Enterprise Good Samaritan Program alerts the organization instead. It focuses on large companies and public institutions, where one leaked credential can expose production systems or customer data. Alerts go to the security teams who can act: CISOs, AppSec, and SOC teams. The goal is to revoke the secret. Each alert explains where the secret leaked, what it can reach, and how to shut it down.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;How does the Enterprise Good Samaritan Program work?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;We monitor public GitHub and Docker Hub continuously. When we find an exposed credential, our engine works out which organization it belongs to. Then it checks how critical the leak is: is the credential valid, is it still public, and what can it reach? If the leak is serious, we contact your security team directly. We share everything we found: where it leaked, whether it's live, and the attack path it opens. We don't ask for anything in return. We just want you to have what you need to revoke the secret before someone else uses it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Who is the Enterprise Good Samaritan Program for?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;It's for any organization whose credentials have been exposed in public: companies, public institutions, and nonprofits. You don't need to be a GitGuardian customer. We contact the people who can act: CISOs and the AppSec, security operations, and incident response teams. We only alert on secrets we can attribute to your organization, that are valid or likely valid, and that give access to systems or sensitive data. The original Good Samaritan Program continues to warn individual developers.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What to do if you receive an alert?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Each alert contains everything you need to act right away, no call or sign-up required. Revoke or rotate the credential first: deleting the commit isn't enough, because the secret stays in the history and may already have been copied. Then check your logs for any use of the credential since the leak date, and find where it came from to see whether the same repository holds other secrets.&lt;/p&gt;

&lt;p&gt;If you'd like a second opinion, our security researchers are happy to walk you through what we found. And there's no shame in it: leaks happen to every organization.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is GitGuardian legitimate?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Yes. GitGuardian is a cybersecurity company founded in Paris in 2017, and our original Good Samaritan Program has warned developers about leaked secrets since day 1. We're the most installed security app on the GitHub Marketplace. Our platform is used by more than 600K developers and by many of the Fortune 500. GitGuardian has completed a SOC 2 Type II audit. Our researchers have been credited by &lt;a href="https://blog.gitguardian.com/gitguardian-responsible-disclosure/" rel="noopener noreferrer"&gt;CISA, Oracle, IBM, SAP, and Red Hat&lt;/a&gt;. We will never ask for credentials or payment for an alert. If you're unsure whether an alert really came from us, write to &lt;a href="mailto:security@gitguardian.com"&gt;security@gitguardian.com&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>security</category>
      <category>opensource</category>
      <category>devsecops</category>
      <category>github</category>
    </item>
  </channel>
</rss>
