DKDKCISSP
← Cybersecurity on the GroundCHALLENGE

The Weakness Between the Server and the App

By Deepak Kumar, CISSP

The problem: A server is run by IT. The application on it is run by a project team. A security scan finds a weakness, and it is not clear who should fix it. IT says, “The app depends on it, ask the project.” The project says, “The server is IT’s job.” Nobody patches it.

Words used here: a patch is a small update that closes a known weakness. A stack is the layers a system is built from, from the machine at the bottom to the app on top. A vulnerability is a weakness that an attacker could use.

Think of a leak in the wall between two flats

Water comes through the wall between two flats. The family in Flat A says, “It is the wall, not our flat.” The family in Flat B says the same. Both are right: the wall belongs to the building, and the building has no manager. Each family waits. The stain grows.

The leak in the wall between two flats
The shared wall: water is coming through
It is the wall, not my flat.
Flat A
It is the wall, not my flat.
Flat B
Each flat is fine. The leak is in the part nobody owns.

What it looks like at work

A scan finds an old piece of software on a shared server. IT says the app needs that old version, and an update might break it, so the project must test and approve. The project says it only builds the app, and the server is IT’s to look after. The ticket goes back and forth for three months. The weakness is public, and attackers know it.

How a weakness sits between two owners
  1. 11. Scan finds itA weakness on a shared server
  2. 22. IT says“The app needs it. Ask the team.”
  3. 33. Project says“The server is IT’s job.”
  4. 44. WaitingEach waits for the other
  5. 55. ResultOpen for months, no patch
Both are right about their own part. Nobody owns the gap.

Both sides are half right. IT is right that it cannot update something that may break a live app without the project’s testing. The project is right that it does not run the server, and cannot patch the base software on its own. What is missing is one name for the gap between them, and an agreed way to test and patch together.

You will notice it when:

  • The same finding is reopened scan after scan.
  • The ticket moves between teams and nobody keeps it.
  • Both teams say “it is their part”.
  • Nobody can say who owns the old software the app uses.
  • Fixes only happen after an audit or an incident.

What exactly needs fixing

The first fix is not the patch. It is naming who owns each layer, and who owns the space in between. This card shows the whole problem on one page:

A weakness that sits between two owners
WHAT IS BROKEN

A known weakness is not patched, because IT and the project each think it is the other’s.

WHERE IT IS

The shared server and the app that runs on it, between two teams.

WHAT COULD GO WRONG

An attacker uses a weakness that is already known and already public.

WHAT IT COSTS US
  • Break-in
  • Long exposure
  • Repeat findings
  • Blame game
THE FIX, IN THREE MOVES
  1. 1
    1. Name the layers
  2. 2
    2. One owner each
  3. 3
    3. Test, then patch
WHO FIXES IT

Who fixes it: IT head and project lead

BY WHEN

By when: owners named in 1 week

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

Why it happens

  • Systems are built in layers. And each layer has its own team.
  • Nobody owns the joins. The old software the app needs sits between two teams.
  • Patching feels risky. An update can break the app, so everyone waits.
  • There is no test environment, or no time to use it. So nobody can prove the patch is safe.
  • Tickets go to the team that found the work, not the one that can do it. So they bounce.
  • No agreed time limit. A finding can sit for months with nobody late.

What happens if you ignore it

The weakness stays open, and it is a known one.

  • An attacker uses a weakness that is already public.
  • The same finding appears in every scan and every audit.
  • The longer it waits, the more the app depends on the old software, and the harder it is to change.
  • IT and the project team lose trust in each other.

At a glance

QuestionAnswer
How likely is it to hurt us?Quite likely. Known, public weaknesses are the first thing attackers try.
Worst case?A break-in through a weakness that was known for months.
What does it cost?A clean-up, an audit finding, and lost customer trust.
What if we wait?The app depends on the old part even more, and the fix costs more.
What does the fix cost?One meeting to name owners, plus a test slot.

How to fix it, step by step

Name the layers, name the owners, and agree how to test and patch together.

  1. Draw the stack on one page. From the server at the bottom to the app at the top. Four or five layers is enough.
  2. Put one owner on each layer. One name, not a team. IT usually owns the server and base software. The project owns the code and what it depends on.
  3. Name an owner for the gap. The old software the app needs: who decides if it can be updated? Usually the project lead, with IT doing the work.
  4. Open one ticket, not two. One ticket, one owner, one due date. Others can be added as helpers.
  5. Test in a copy first. Make a copy of the server and the app. Apply the patch there. If it works, apply it to the live one.
  6. If it cannot be patched, add protection. Limit who can reach it, and watch it. Write it down as a known exception with a review date.
  7. Agree time limits by risk. For example: critical in days, high in weeks. Set your own.
  8. Review the stack once a quarter. Look for layers and joins that have no owner.
Give every layer one owner
Server layer: ITThe operating system and the base software.
App layer: project teamThe code and the parts it depends on.
The gap: one nameAnything in between has one owner and a due date.
If it is in between, it still gets a name.

The picture shows the idea. Every layer has one owner, and the gap between layers gets a name too.

Who to bring in: The head of IT or the server owner, the project or product lead, the lead developer, security, and whoever runs testing.

Tools and templates

Who owns what (example)

LayerExamplesOwner
Hardware and virtual machineThe server itselfIT
Operating systemThe base system and its updatesIT
Base softwareWeb server, database softwareIT, with project approval to change versions
Libraries the app needsCode the app depends onProject team
The appThe code we wroteProject team
The gapOld software the app needsOne named person, set at the start

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 IT and the project lead

Subject: One owner for the old software on the shared server

Hi [name] and [name]. The scan found an old piece of software on [server] that has been open for [time]. It sits between the server and the app, and I think each of you believes the other owns it. Could we meet for 20 minutes to agree one owner, a test slot, and a date? I will bring the one-page layer list.

Field tip

Do not ask, “Whose fault is it?” Ask, “Who owns the old software between the server and the app, and when can we test the patch?”

Words used in this chapter

  • Patch: a small update that closes a known weakness.
  • Stack: the layers a system is built from, from the machine to the app.
  • Vulnerability: a weakness that an attacker could use.
  • Test copy: a copy of the system used to try a change safely.
  • Known exception: an agreed, written reason why a fix has not been done yet, with a review date.