DKDKCISSP
← Cybersecurity on the GroundCHALLENGE

One Shared Password and Real Customer Data in Test

By Deepak Kumar, CISSP

The problem: Developers share one admin password and copy real customer data into test systems, because it is quick. Security says it is a risk and a failed audit. The developers say, “We cannot find bugs without real data, and we cannot wait days for access.”

Words used here: a test system is a copy of the product where developers try changes before they go live. Production is the live system that real customers use. Masked data is real-looking data with the sensitive parts replaced.

Think of a spare key under the doormat

A family leaves a spare key under the doormat so that anyone can get in when they forget theirs. It is easy, and for years nothing happens. But anyone who walks past can use it, and nobody knows who came in. Now imagine they also left a box of family photos at the neighbour’s “just in case.” That is a shared password and real data in a test system.

A spare key under the doormat
Front door, spare key under the mat
The spare key is under the mat. Anyone can get in!
The family
Your family photos are here with me, just in case.
The neighbour
Rule: easy for you is easy for everyone, and nobody knows who came in.

What it looks like at work

A team needs to find a bug that only happens with real customer records. A developer copies a slice of the live database into the test system. The test system has fewer locks, and the whole team can open it. To save time, the team shares one admin login, and the password lives in the team chat. Months later, a client’s audit asks: who has access to our data, and where is it? Nobody can answer.

How real data and one password spread
  1. 1Bug foundOnly real data shows this bugNeeds real data
  2. 2Quick copyI will copy 5,000 customers to testFewer locks in test
  3. 3One shared loginShare the admin login. Saves timePassword in chat
  4. 4Someone leavesEx-colleague still has the passwordStill has access
  5. 5Client auditsWho has access to our data? Where?Nobody can answer
A quick shortcut leaves no list of who can see what.

Both sides are half right. The developers are right that they need data that looks real, and fast access. Security is right that real customer data and a shared password are a risk. What is missing is an easy, safe way for developers to get what they need.

You will notice it when:

  • The same admin password is used by many people.
  • The password is in a chat, a wiki page, or a spreadsheet.
  • Test systems hold copies of real customer records.
  • People who left the team can still log in.
  • Nobody can say who changed something last week.

What exactly needs fixing

The first fix is not a lecture on rules. It is a safe and quick way for developers to get access and test data. This card shows the whole problem on one page:

One password, and real customers in test
WHAT IS BROKEN

One admin password, and real customers in test

HIGH
WHERE IT IS

Test database; password in team chat. 5,000 real customer records copied.

WHAT COULD GO WRONG

Anyone in the chat can open it, and nobody can tell who did what.

WHAT IT COSTS US
  • Failed client audit, no access list
  • Data leaks from a place nobody watches
  • Legal and contract trouble
  • No trail of who did what
THE FIX, IN THREE MOVES
  1. 1
    Named logins + vaultOne login per person; shared ones go in a vault
  2. 2
    Masked test dataOne-click copy with names, emails, numbers replaced
  3. 3
    Expire and reviewAccess runs out by itself; review it every quarter
WHO FIXES IT

IT sets up the vault. Dev lead owns the team habit.

BY WHEN

Vault and named logins first, masked test data next. Dates set.

A blank copy of this card is in the Tools section.

Why it happens

  • The safe way is slower than the easy way. Asking for access takes days, so people share.
  • Real data finds real bugs. Developers copy it because fake data is not available.
  • Test systems are thought of as “not real.” So they get fewer locks and less checking.
  • Nobody owns the access list. People join and leave, and the list is never cleaned.
  • Nobody has seen a leak yet. So the risk feels far away.
  • Rules were written for production only. Test systems fall outside them.

What happens if you ignore it

A small shortcut becomes a data leak with no trail.

  • Real customer data leaks from a place nobody was watching.
  • A client audit fails, because you cannot say who has access.
  • When something goes wrong, nobody can tell which person did it.
  • Legal and contract problems follow if the data was protected.

At a glance

QuestionAnswer
How likely is it to hurt us?Likely. It is common in teams that move fast.
Worst case?Real customer data is leaked from a test system.
What does it cost?A failed audit, a talk with the client, and possible legal trouble.
What if we wait?More copies of the data and more people with the password.
What does the fix cost?A password vault, a way to make safe test data, and a few days of setup.

How to fix it, step by step

Make the safe way the easy way.

  1. Find out what is shared and where. List the shared logins and the test systems that hold real data.
  2. Give each person a named login. Put any shared account in a password vault, so the team can use it without seeing the password, and every use is recorded.
  3. Make access expire. Access is granted for a time, and then it needs to be asked for again.
  4. Create safe test data. Use made-up data, or real data with names, numbers, and emails replaced. Offer it as a one-click copy, so developers do not need the real thing.
  5. If real data is truly needed, make it an exception. Name who approved it, limit who can see it, and delete it after a set time.
  6. Remove access when people move on. Review who has access every quarter.
  7. Tell the team what they gain. Quick access, safe data, and no more passwords in chat.
Before and after
LoginsBefore: one shared admin login After: named logins, in a vault
Test dataBefore: 5,000 real customers After: a masked one-click copy
AccessBefore: never expires After: expires, checked quarterly
The vault and masked data make the new way easier than the old one.

The picture shows the change on one page. The vault and the masked data are the two things that make the new way easier than the old one.

Who to bring in: The dev lead (the team’s habits), IT (the vault and the access lists), the data owner or privacy lead (the real data), and security (the rules and the checking).

Tools and templates

Access and data check

QuestionYes or noFix
Does anyone share a login?Named logins and a vault
Is a password in a chat, wiki, or sheet?Move it to the vault, and change it
Does a test system hold real customer data?Replace with masked or made-up data
Do former team members still have access?Remove today, then review every quarter
Can we say who did what last week?Turn on logging per person

Blank finding card

FieldWrite here
What is brokenOne line, in plain words
Where it isThe system, team, or process
What could go wrongIn one sentence
What it costs usMoney, time, a leak, lost trust
The fixThe exact action
Who fixes itOne name or one team
By whenA date, not “soon”

Email to the dev lead

Subject: Making safe access and test data easy for the team

Hi [name]. I know the team shares logins and uses real data in test because the proper way is slow. I would like to fix that by making the safe way quicker: named logins through a password vault, and a one-click copy of test data with the sensitive parts replaced. Can we spend 30 minutes this week to list what the team needs? I will bring a plan for what IT and security can set up.

Field tip

People share passwords because the proper way is slow. Make the proper way quick, and the sharing stops.

Words used in this chapter

  • Test system: a copy of the product where developers try changes before they go live.
  • Production: the live system that real customers use.
  • Masked data: real-looking data with the sensitive parts replaced.
  • Password vault: a tool that keeps passwords safe and records who used them.
  • Audit trail: a record of who did what, and when.