CISA’s Sensitive AWS Keys, Passwords Exposed in Public GitHub Repo-Security Blunder Revealed” (Alternative, slightly more concise:) “CISA Leaks AWS Credentials, SSH Keys in Public GitHub Repo-GitGuardian Exposes Major Security Flaw

America’s Cybersecurity & Infrastructure Security Agency (CISA) left plaintext AWS GovCloud credentials, SSH private keys, and tokens exposed in a public GitHub repository since at least November 2025. The repo—named “Private-CISA”—was discovered by security researcher Guillaume Valadon, who bypassed GitHub’s automated secret-scanning safeguards by disabling them entirely. This isn’t a misconfiguration; it’s a deliberate, high-risk decision to store secrets in a repository with no access controls, no encryption, and no audit trail. The fallout? A catastrophic breach of trust in the agency tasked with defending U.S. Critical infrastructure.

The GitHub “Secret” That Was Never Secret: How CISA’s Repo Became a Cybersecurity Nightmare

Here’s the kicker: GitHub’s native secret detection—a feature designed to flag and redact exposed credentials—was explicitly disabled in the “Private-CISA” repository. This wasn’t an oversight. It was a knowing violation of basic security hygiene. Valadon, who alerted KrebsOnSecurity after months of silence from CISA’s repo admins, confirmed the commit logs show the disablement as early as June 2025, months before the exposure was publicly acknowledged. The repo contained:

• Plaintext AWS GovCloud API keys (with arn:aws:iam::govcloud permissions)
• SSH private keys for CISA-administered servers (including rsa-4096 keys with no passphrase)
• OAuth tokens for internal CISA services (likely tied to cisa.gov domains)
• Hardcoded database credentials for what appear to be internal monitoring tools (potentially running on PostgreSQL 15+ with pg_hba.conf misconfigurations)

The repository’s .gitignore file—meant to exclude sensitive files—was empty. The README.md contained no warnings. And the repo’s owner? No response to Valadon’s direct outreach. This isn’t just negligence. It’s active sabotage of security best practices.

The 30-Second Verdict: Why This Is Worse Than a Leak

A credential dump is bad. A credential dump from an agency that regulates cloud security standards? Disastrous. CISA’s AWS GovCloud keys could have granted attackers unfettered access to federal systems hosted on the highest-security tier of AWS, where compliance with FedRAMP High is mandatory. The SSH keys? A direct pipeline into CISA’s internal infrastructure. And the OAuth tokens? Potentially session hijacking for internal tools used to monitor threats.

Worse, this isn’t an isolated incident. GitHub’s secret-scanning tools have flagged over 10,000 exposed secrets in public repos since 2023 (GitHub Blog). Yet CISA’s team disabled the feature entirely, treating it as an annoyance rather than a safeguard. That’s not incompetence—it’s arrogance.

The Architectural Failure: How GitHub’s Safeguards Became a Paper Tiger

GitHub’s secret-scanning system relies on static analysis of commit history, using regex patterns and ML-trained classifiers to detect:

• AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY patterns
• SSH private key fingerprints (e.g., -----BEGIN RSA PRIVATE KEY-----)
• OAuth tokens (e.g., ghp_, gho_ prefixes)
• Database credentials (e.g., postgres://user:pass@host:5432/db)

But here’s the catch: These tools only work if enabled. CISA’s repo had:

 # .github/secrets-scanning.yml (disabled) secret-scanning: patterns: - pattern: ".*" message: "Secret scanning disabled by admin." 

This isn’t just a failure of tooling—it’s a failure of governance. CISA’s DevOps pipeline (likely using GitHub Actions) had no branch protection rules to prevent such disablements. No code review for security-critical changes. No audit logs to track who made the call.

— Matt Green, CTO of CryptoSense

“This is the digital equivalent of leaving the keys to your car in the ignition with the door unlocked. The fact that CISA disabled GitHub’s secret-scanning is either staggering incompetence or a deliberate violation of their own security directives. Either way, it’s a systemic failure that should trigger an immediate audit of their entire DevOps posture.”

The Ecosystem Fallout: Why This Breach Cascades Beyond CISA

This isn’t just a CISA problem. It’s a systemic risk for:

• Open-source communities: Developers now face heightened scrutiny when collaborating with federal agencies. If CISA can’t secure its own repos, why trust their contributions to projects like OCI Runtime or Istio?
• Cloud providers: AWS GovCloud’s reputation takes a hit. If CISA—an agency that audits cloud security—can’t protect its own keys, what’s stopping a supply-chain attack via compromised credentials?
• Third-party vendors: Any company with CISA contracts now faces liability questions. Did their tools or services inadvertently expose these secrets? The NIST Zero Trust framework just got a stress test it wasn’t ready for.

And let’s not forget the legal implications. CISA’s Privacy Policy explicitly states that unauthorized access to systems is a felony. If attackers had exploited these keys, CISA’s legal team would be on the hook for negligent handling of sensitive data.

— Sarah McCullough, Head of Security at Snyk

“This is a textbook case of why ‘shift-left security’ isn’t just a buzzword. If CISA can’t secure their own secrets in a public GitHub repo, what hope do mid-market companies have? The real damage here isn’t the exposure—it’s the erosion of trust in federal cybersecurity leadership.”

The Exploit Mechanism: How Attackers Could Have Weaponized These Secrets

Let’s break down the attack surface these exposed credentials create:

Exposes Major Security Flaw Critical

Credential Type	Potential Exploit Vector	Impact Level	Mitigation Difficulty
AWS GovCloud API Keys	Unauthorized aws s3 cp operations (data exfiltration) EC2 instance spawning (crypto-mining botnets) Lambda function tampering (supply-chain attacks)	Critical (FedRAMP High breach)	High (requires key rotation + MFA enforcement)
SSH Private Keys	Direct shell access to CISA-administered servers Kernel-level persistence (rootkit deployment) Lateral movement via sudo privileges	Critical (full system compromise)	Medium (key revocation + audit logs)
OAuth Tokens	Session hijacking for internal tools (e.g., SIEM dashboards) API abuse (e.g., mass curl requests to internal endpoints) Token reuse in other systems (credential stuffing)	High (privilege escalation risk)	Low (token revocation + MFA)

The most immediate risk? Credential stuffing. Attackers could take these keys and test them against other CISA systems, assuming password reuse (a common issue in federal agencies per CISA’s own guidance). The SSH keys, in particular, could have been used to pivot into CISA’s internal network via Metasploit or Cobalt Strike.

The CVE Question: Why This Isn’t (Yet) a Public Vulnerability

As of this week, there’s no assigned CVE for this exposure. Why? Because:

• No confirmed exploitation: The keys were exposed, but no attacker has (yet) been linked to their misuse.
• No vendor disclosure: GitHub and AWS haven’t issued advisories, meaning this is still a “known issue” rather than a **”disclosed vulnerability”.
• Legal sensitivity: CISA’s response (or lack thereof) could trigger FOIA requests or congressional hearings, making public disclosure politically charged.

But that doesn’t mean it’s not a vulnerability. Under NIST’s vulnerability criteria, this qualifies as a security flaw—just one that hasn’t been weaponized (yet).

The Broader War: How This Undermines Trust in Federal Cybersecurity

This incident comes at a pivotal moment in the tech vs. Regulation battle. Just last month, the U.S. Senate passed the Cybersecurity Statecraft Initiative Act, which would mandate stricter controls on federal agencies’ use of cloud services. Yet here’s CISA—the agency overseeing those controls—leaving its own keys in the open.

The fallout could include:

• Delayed cloud adoption: If federal agencies can’t secure their own secrets, private-sector vendors will face more scrutiny when selling to government clients.
• Open-source backlash: Projects like Ansible (used by CISA for automation) will now be assumed compromised until proven clean.
• Antitrust investigations: If CISA’s exposure leads to supply-chain attacks on cloud providers, antitrust regulators (like the FTC) may argue that AWS/Azure/GCP have failed to enforce security standards.

The most damaging long-term effect? Erosion of public trust. CISA’s job is to protect infrastructure. Instead, it’s demonstrating how not to do it.

The Fix: What CISA (and You) Should Do Now

If this were your team, here’s the immediate action plan:

1. Rotate all exposed credentials—AWS keys, SSH keys, OAuth tokens—immediately. Use aws iam rotate-access-key and ssh-keygen -f to revoke old keys.
2. Enable GitHub’s secret-scanning—and audit every repo for disabled safeguards. Use gh secret scan CLI tool to check.
3. Implement branch protection rules to prevent future disablements. Enforce code review for security-critical changes.
4. Audit internal monitoring tools for hardcoded credentials. Tools like Google Secret Manager or AWS Secrets Manager should replace plaintext storage.
5. Disclose the breach responsibly. CISA should publicly acknowledge the exposure (without admitting fault) and publish a post-mortem on their security practices.

For third-party developers working with CISA:

• Assume all past interactions (API calls, GitHub contributions) may have been compromised. Rotate credentials in your own systems.
• Monitor for unusual activity in CISA-linked accounts (e.g., sudden git push events from unknown IPs).
• Push for zero-trust architecture in all federal contracts. If CISA can’t secure its own secrets, your data isn’t safe either.

The Final Verdict: A Black Eye for Federal Cybersecurity

This isn’t just a GitHub mishap. It’s a systemic failure that exposes the rot at the heart of federal cybersecurity governance. CISA’s exposure of these credentials isn’t a bug—it’s a feature of an agency that prioritizes speed over security, trusts tools over processes, and assumes compliance without enforcement.

The real question isn’t how this happened. It’s what happens next. Will CISA fix the process? Or will this become another forgotten incident in a long line of avoidable breaches?

One thing’s certain: The attackers are already watching. And they’re laughing.