Dev.to Security 🔐 Cybersecurity 👁 0 📖 4 min read

A Month Later, Memories Merge: The One Line Every Incident Record Needs — 'Temporary or Permanent?'

The question that arrived a month later One day in November, a non-engineer colleague came to me holding a link to a news article. "That PHP vulnerability back in October — there was no fix available, so we just disa

The question that arrived a month later

One day in November, a non-engineer colleague came to me holding a link to a news article.

"That PHP vulnerability back in October — there was no fix available, so we just disabled a feature to get by, right? Has the real fix been applied yet?"

For a moment I had no idea what they were asking. The critical RCE that made the news in October was patched with an official fix on the day it was disclosed. The "no fix available" situation belonged to a different CVE, published two days later. But in their memory, the two incidents had merged into one.

And to be honest, I fumbled too: my first answer was "we installed 8.3.36" — the wrong version. What we actually installed was a fixed release in the 8.2 series. That's when it hit me: after a month, memories don't so much go wrong as blend together.

Root cause: three ingredients for a merged memory

Re-laying the timeline:

Date Event Response
Late October Critical RCE disclosed (the one in the news) Two-step response, same day
Two days later A separate CVE disclosed. No fix available — "disable the feature and hold on" Mitigated by disabling the feature
Mid-November Official fix for the second CVE finally released Applied, done

Three ingredients made the merge almost inevitable.

1. The day-one response had two steps. Our response to the newsworthy CVE was "① disable a feature via ini as mitigation → ② update packages to the fixed release." Step ① was temporary; step ② was the permanent fix.

; ① Mitigation (temporary): disable the feature used as an attack vector
session.upload_progress.enabled = 0
# ② Permanent fix: update to the fixed release published that day
$ sudo yum update 'php*'

2. The setting in step ① had the same name as the mitigation for the second CVE. By coincidence, the recommended mitigation for the "no fix available" CVE two days later was exactly the same setting. The memory "we turned something off" could no longer be attributed to the right incident.

3. The "we couldn't go to the latest version" fact got mixed in. Because the OS was EOL, we couldn't move to the 8.3 series and instead applied the fixed release in the 8.2 series. That is a legitimate permanent fix — but if only the fragment "we couldn't go to the latest" survives, it reads as "they never properly fixed it."

In other words, my colleague's memory wasn't fabricated. It was three real facts recomposed into a single story. That's why "no, that's wrong" alone doesn't convince anyone.

Resolution: the moment the record beat the memory

What settled it was a single yum history snippet pasted into the incident record at the time.

$ sudo yum history list 'php*'
ID | Command             | Date/time        | Action | Changed
42 | update php*         | 10-22 14:03      | Update |   11

$ sudo yum history info 42 | grep -A1 'php-common'
    Updated   php-common-8.2.30-1
    Update to php-common-8.2.35-1

With dates, transaction IDs, and before/after versions on record, I could answer from the record instead of memory:

  • The news incident → official fixed release (8.2 series) applied the same day it was disclosed; the disabled feature was an extra mitigation layer
  • The incident two days later → that was the "no fix available" one, and it was completed last week when the official fix shipped

The news link my colleague brought was in fact the follow-up: "the fix for the second CVE is out." With a record in hand, two merged incidents can be separated in five minutes.

The line your incident record is missing: a "temporary vs. permanent" table

From this experience I added one table to our incident record template. We already had the chronological "what we did" log. What was missing was which actions were temporary and which were permanent.

Action Type Completion condition Status
Disable feature (ini setting) Temporary (mitigation) Reassess after permanent fix Kept as defense in depth
Update to 8.2-series fixed release Permanent — Done same day
Response to the second CVE Temporary only (no fix yet) Apply fix once released Completed in November

The question that arrives a month later is almost never "what did you do?" — it is "is that thing done?" This table is the answer to that question. The "completion condition" column does the heavy lifting: if it says "apply the fix once released," then November's follow-up news is no longer a source of confusion — it's a task notification.

Takeaways

  • Memories don't go wrong; they merge. A shared setting name, close dates, and a "couldn't go to latest" fragment will recompose into one story within a month
  • Record not just "what we did" but a table of what's temporary vs. what's permanent, including a completion condition column
  • Pasting raw yum history (or dnf history) output preserves dates, transaction IDs, and version before/after — facts nobody can argue with
  • When explaining to non-experts, drop the CVE numbers. What they remember is not the number but the event name: "the one in the news," "the one two days later." Index your explanation to their memory

People say incident records are for your future self. In practice, the ones who demand you reread them are your future boss and colleagues — and they remember incidents by the news, not by the number.

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.