ProActive Solutions Blog

Credential Lifecycle Management: Why Long-Lived Credentials Are a Security Risk

Written by Garry Meadows | Nov 19, 2026, 4:30:01 PM

Nobody Broke In. They Just Logged In.

UpGuard recently published a piece called “Left Unsupervised: 10 Times Access Outlived Its Authorization.” If you’re in a security leadership role, it’s worth ten minutes of your time. The article walks through ten real-world incidents where credentials or permissions were granted for a legitimate reason, then left in place long after they should have been revoked, rotated, disabled or deleted.

However, it isn’t one single incident that stands out, but rather the pattern.

In most of these cases, nobody exploited a zero-day or bypassed advanced controls. They simply used a valid credential that still worked. The pattern is credentials that were created on purpose and then forgotten, and later used to simply log in.

Credential lifecycle management is the process of creating, securing, monitoring, rotating and revoking credentials throughout their lifecycle. The goal is simple: credentials should only exist for as long as they are needed and should provide only the access required to perform their intended purpose. Implementing a strong foundation in Security & Compliance is essential to enforcing these policies consistently.

I looked at the five most recent incidents, all from 2023 or later, that map directly to what automated secrets management is designed to prevent. Here’s what happened in each case and how the outcome changes when you have a strong credential lifecycle management program in place.

5 Credential Security Incidents That Expose the Risk of Long-Lived Access

1. Ticketmaster / Snowflake: A Four-Year-Old Password and 560 Million Records

Ticketmaster / Snowflake, 2024

Nobody broke into Snowflake. They just logged in.

The credentials came from infostealer malware, some of which had been around since 2020, and the passwords still worked on customer accounts protected by only a password. The campaign hit around 165 organizations. Ticketmaster had about 560 million customer records exposed.

What went wrong: Static, long-lived passwords with no rotation and no multi-factor authentication. A credential stolen in 2020 was still valid four years later. That’s likely how long it sat on the Dark Web before someone tried using it.

How credential lifecycle management changes this: If those credentials were dynamically generated with a 24-hour TTL, the stolen passwords would have expired within a day of being created. Even basic 30-day auto-rotation would have made those 2020 credentials worthless within a month.

A dynamic secret doesn’t exist long enough to be worth stealing.

2. Cloudflare: Four Credentials Labeled “Unused” That Weren’t

Cloudflare, 2023

After attackers breached Okta’s support system in October 2023, Cloudflare did what you’re supposed to do, which is to rotate the exposed credentials.

But one service token and three service accounts were assessed as unused and left in place. A month later, on Thanksgiving Day, a suspected nation-state actor signed in with all four and reached Cloudflare’s internal wiki, bug tracker and source code management system.

What went wrong: Someone decided these four credentials were “probably fine” and excluded them from the rotation. They were wrong, and a sophisticated adversary exploited the gap within weeks.

How credential lifecycle management changes this: When rotation is automated and policy-driven, there’s no judgment call to make. After a third-party breach disclosure, every credential in the blast radius gets rotated.

If a credential truly is unused, rotating it costs you nothing. If it turns out it wasn’t unused, you just closed the door before the attacker walked through it.

Cloudflare, to their credit, published the full timeline. Most organizations wouldn’t have caught it at all.

3. Replit: When an AI Agent Had the Keys to Production

Replit, 2025

In July 2025, a developer was building an app with Replit’s AI coding agent when the agent deleted his live production database, over 1,200 company records. The agent then told him rollback was impossible.

It wasn’t.

Replit’s CEO called the incident unacceptable and shipped automatic separation between development and production databases within days.

What went wrong: An autonomous AI agent had credentials broad enough to perform destructive operations on a production database. There was no separation between what the agent could reach in development versus production. There was no approval gate before destructive actions took place.

The agent also misreported its own actions twice, first generating fake records to cover the gap and then claiming a rollback was impossible when it wasn’t.

How credential lifecycle management changes this: Each AI agent should get its own short-lived, narrowly scoped credential tied to a specific task and a specific environment.

An agent working in development gets a credential that can only reach development resources. Destructive operations on production must require a separate, human-approved credential.

When the task is done, the credential disappears.

The agent can’t delete what it can’t authenticate to.

As more organizations deploy autonomous AI across their infrastructure, this is the pattern that has to become standard.

4. Salesloft / Drift: An AI Chat Tool Exported Your CRM

Salesloft / Drift, 2025

In August 2025, attackers obtained OAuth tokens tied to Drift, an AI-powered chat tool. They used those tokens to query and export Salesforce data from hundreds of organizations, including Cloudflare, Google and Zscaler.

The export traffic looked exactly like the tool doing its job because, technically, it was. It was using a valid token, with fairly broad scope requests, and the queries were run at relatively normal rates.

What went wrong: Long-lived OAuth tokens with broad scopes and no independent monitoring.

The AI tool had been granted access to CRM data at some point, and that access persisted with no review date, no expiration and no way to distinguish normal usage from data exfiltration.

How credential lifecycle management changes this: AI tool integrations, including Agentic AI, should go through the same access governance as any other identity.

This includes leveraging the principle of least privilege, a named owner inside the business, a defined TTL on the token and a recurring review date on the calendar.

If the token expires every 24 or 48 hours and has to be re-issued, an attacker who compromises the integration has a substantially limited time to exploit.

If you’re also logging what the integration queries into a tool you control, separate from the vendor’s own reporting, you have your own record to check when something looks off.

The thing that separates an AI chatbot from an exfiltration tool is scope and lifespan.

You should control both.

5. npm / Shai-Hulud: A Worm That Eats Long-Lived Tokens

npm / Shai-Hulud, 2025

First seen in September 2025, the Shai-Hulud worm steals a developer’s npm publish token, pushes infected versions of every package that token controls, and collects the next set of tokens from whoever installs them.

Typical of worms, once deployed, it spreads on its own without further human involvement.

The second wave in November 2025 compromised hundreds of packages and exposed thousands of secrets across nearly 500 organizations.

What went wrong: Long-lived publish tokens that never expire.

Each stolen token gave the worm the ability to publish malicious code under a trusted developer identity, and the next round of tokens arrived automatically from developers who installed the compromised packages.

The worm replicated itself through the supply chain.

How credential lifecycle management changes this: If publish tokens are short-lived and minted per release by the build system, each token dies with the release it published.

There’s nothing to steal that’s still valid by the time the worm tries to use it.

This is the most important example on the list, and it is the reason I saved it for last.

Everything in the previous four examples required a person to come along and use the access that had been left open.

This, and the many we can expect to follow it, does not require a human.

It’s automated, fast, and it survives and spreads through environments where long-standing, broad-permissioned credentials reside.

That’s what the threat landscape looks like now.

The thing hunting for your credentials isn’t a person anymore.

The Credential Lifecycle Management Problem

This is five separate incidents over the past few years where the pattern is the same every time.

Someone created a credential for a legitimate purpose. However, nobody set an expiration or reviewed whether it was still needed and, at some point, someone or something used it in a way that was never intended.

This is the default posture still in most organizations, and it’s the root cause of more breaches than most security leaders want to admit.

The fix isn’t better people or better processes, although both could help.

The fix is changing our default posture so that credentials are short-lived, narrowly scoped and automatically revoked.

If a credential isn’t being actively used, it shouldn’t exist.

How HashiCorp Vault Supports Credential Lifecycle Management

This is what platforms like HashiCorp Vault are designed to do. Both Les Washington and I have covered the specifics of Vault in previous blog posts.

For a quick summary, it supports:

Dynamic secrets: Credentials are created on demand and destroyed when they’re no longer needed.

Automated rotation: Certificates and other credentials can be automatically rotated, helping minimize the risk associated with static credentials and certificate-related outages.

Identity-based and limited-scope access: Every credential can be tied to a specific identity and a specific purpose, governed by centrally managed policy.

Audit trails: Security and forensics teams can see exactly who accessed what, when and from where.

None of these five breaches required a sophisticated attacker.

All they required was a credential that nobody was watching.

That’s a problem you can solve.

 

Take the First Step

At ProActive Solutions, we help companies assess their credential lifecycle posture and implement HashiCorp Vault as the foundation, or complement, to their current credential lifecycle management program.

Whether you’re dealing with static credentials that have been sitting in place for years, AI tools with unreviewed access or an overwhelming number of certificates that must be automatically rotated, we can help you move from standing access to a dynamic, policy-driven model.

If any of these patterns sound familiar, request a HashiCorp consultation with ProActive.