Two pieces of vulnerability news landed within a day of each other last week, and together they make a better lesson than either does alone.
On Thursday, November 12, the PostgreSQL project released updates that fix 52 security vulnerabilities, many of them scored 8.8 out of 10 for severity. On Friday, November 13, the U.S. Cybersecurity and Infrastructure Security Agency (CISA) added a flaw in UnrealIRCd, an open-source chat server, to its list of vulnerabilities that attackers are exploiting right now. That flaw scores 8.6. The two scores are almost the same. The urgency is not.
One team can read “52 fixes” and spend a month planning. Another can read “8.6, exploited” and miss it, because it sits in a tool nobody tracks. This post explains how to tell the difference with three signals, CVSS, KEV and EPSS, plus a fourth that only you can supply: where the vulnerable software actually runs. Every term is defined, and the end of the post gives a process, commands and a policy template that you can use in a team meeting.
Primary sources: The Hacker News on the UnrealIRCd flaw and CISA’s KEV listing (including the NVD description it quotes), the PostgreSQL project’s security page and its entry for CVE-2026-6460, and The Hacker News on the PostgreSQL release. We could not open CISA’s catalog directly (it blocked automated access), so KEV facts come from The Hacker News. EPSS and CVSS definitions are standard. Commands are our own guidance, to be tested before use.
Who Should Read What
- Developers and DevOps engineers: “Two Flaws, Two Different Answers,” then Steps 3 and 5.
- Security and vulnerability management teams: the whole guide, especially Steps 1 to 4.
- CISOs and security leaders: “Why CVSS Alone Misleads” and Step 6 (the policy). Both help set expectations and service-level targets.
- Compliance and audit teams: Step 6. A written, risk-based policy is easier to defend than “we patch everything eventually.”
- Engineering managers: “Key Takeaways.” Good prioritization shrinks the list your teams are asked to fix.
What Happened
The PostgreSQL release (November 12)
PostgreSQL published minor releases 18.7, 17.12, 16.16, 15.20 and 14.25. According to The Hacker News, they fix 52 security flaws. The project’s security page lists them. Entries include several memory-safety and type-confusion bugs in the core server, bugs in procedural languages and contributed modules, and problems with row-level security and extension scripts. Many of the code-execution entries are scored 8.8 (high).
The flaw that drew the most coverage, CVE-2026-6460, is a type confusion bug that lets a database user who can create objects run code as the operating system user running the database. The Hacker News reports that the bug has existed for 22 years, that the project has not reported attacks using it, and that CISA’s assessment in the CVE record lists exploitation as none. For the technical detail, see our companion post on PostgreSQL’s 52 security fixes.
The UnrealIRCd flaw (November 13)
On Friday, November 13, CISA added CVE-2026-114713 to its Known Exploited Vulnerabilities (KEV) catalog, following reports of active exploitation, according to The Hacker News. Key facts from the NVD description it quotes:
- Product: UnrealIRCd, an open-source Internet Relay Chat (IRC) server. IRC is an older real-time chat protocol that some organizations still run for communities, developers or internal tools.
- Affected versions: 6.0.0 up to (not including) 6.2.7.1.
- The bug: the
labeled-responsemodule does not escape the IRCv3labelmessage tag when it echoes it into replies. That lets a user on a network with two or more linked servers inject commands between servers, and those commands run with server authority. - Severity: CVSS 8.6. The impact is arbitrary command execution with server or IRC operator privileges.
- Timing: The Hacker News says the listing came nearly a week after the project’s maintainer, Bram Matthys, addressed the issue.
An IRC server is not what most people think of when they imagine “critical infrastructure.” That is exactly why it matters here: a flaw in a forgotten tool that attackers are using today outranks a larger set of flaws in a system that nobody is attacking.
Two Flaws, Two Different Answers
| PostgreSQL CVE-2026-6460 | UnrealIRCd CVE-2026-114713 | |
|---|---|---|
| CVSS score | 8.8 (High) | 8.6 (High) |
| In CISA KEV? | No, exploitation listed as “none” in the CVE record | Yes, added November 13 |
| Exploitation reported? | None reported | Active exploitation reported |
| Needs a login? | Yes, a role that can create objects | Needs a user on a network with linked servers |
| What to ask next | Is any affected server reachable? Which roles can create objects? | Do we run UnrealIRCd anywhere, and is it online? |
Both should be fixed. But if you can only start one today, the one in KEV wins. CVSS says how bad a flaw could be. KEV says that someone is already using it.
Why CVSS Alone Misleads
CVSS (Common Vulnerability Scoring System) gives each flaw a score from 0 to 10 based on its technical properties: how it is reached, how hard it is, what privileges it needs and what it could do. It is useful, and it is severity, not risk. It does not know whether anyone is exploiting the flaw, and it does not know anything about your environment.
This causes two common failures:
- Everything is “High.” On the day of the PostgreSQL release, dozens of entries score 8.8. A rule of “fix all High and Critical within 30 days” puts every one of them at the top of the same list. The team cannot sort them, so it either does them all at once or does none.
- Something that matters scores “Medium.” A moderate-looking flaw that is being exploited, in a system exposed to the internet, can matter more than a Critical in an isolated one.
The fix is not to ignore CVSS. It is to add two signals about the real world and one about your estate.
Signal 1: CISA KEV (what attackers are doing now)
The Known Exploited Vulnerabilities catalog is a list that CISA maintains of vulnerabilities with evidence of active exploitation. Entries include a date added and, for U.S. federal agencies, a required remediation due date. It is narrow: only a small share of all published CVEs ever appear on it. Being on the list is a strong signal. Not being on it does not prove a flaw is safe, only that CISA has not recorded exploitation of it. See What Is the CISA KEV Catalog?.
Signal 2: EPSS (what attackers are likely to do next)
The Exploit Prediction Scoring System, maintained by FIRST, estimates the probability that a vulnerability will be exploited in the wild in the next 30 days. It is a number between 0 and 1 (or 0% and 100%) that updates daily. Think of KEV as a record of what has happened and EPSS as a forecast. A new flaw with a public proof-of-concept and a rising EPSS score may not be in KEV yet and still deserve attention. See What Is EPSS?.
Signal 3: Exposure and context (what it means for you)
A flaw only becomes a risk where the vulnerable software runs and can be reached. The questions are:
- Do we run this software at all? In which repositories, images and servers?
- Is it running in production or only declared in a file somewhere?
- Is it reachable from the internet, or only from an internal network?
- What can it reach if it is taken over: what data, what credentials, what other systems?
Without these answers, KEV and EPSS can only tell you which CVEs to care about in general. With them, they tell you which machines to fix first.

The Prioritization Guide
Step 1: Build the inventory the signals will be applied to
You cannot prioritize what you cannot list. You need two inventories:
- Software you build: the libraries and packages that each repository depends on, including indirect ones. A software bill of materials (SBOM) is the standard way to record this. Common formats are CycloneDX and SPDX.
- Software you run: the operating systems, container images and applications that are actually deployed, including forgotten tools like chat servers.
Generate an SBOM for a repository with an open source tool:
# CycloneDX SBOM for a project (cdxgen)
npx @cyclonedx/cdxgen -o sbom.json .
# Or for a container image (Syft)
syft your-registry/your-image:tag -o cyclonedx-json > image-sbom.json
For servers, start with a list of every host and its listening ports, then compare against what you believe you run. Surprises (an IRC server, an old test database) are the valuable finds.
Step 2: Check KEV membership
CISA publishes the catalog as a machine-readable file. You can query it directly:
# Is a specific CVE in KEV?
curl -s https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json \
| jq -r '.vulnerabilities[] | select(.cveID=="CVE-2026-114713")
| [.cveID, .vendorProject, .product, .dateAdded, .dueDate] | @tsv'
# Check a list of CVEs (one per line in cves.txt) against KEV
curl -s https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json \
| jq -r '.vulnerabilities[].cveID' | sort > kev-ids.txt
sort cves.txt | comm -12 - kev-ids.txt
The second command prints only the CVEs from your list that are in KEV. That list is your first-day work.
Step 3: Look up EPSS for the rest
FIRST provides a free API:
# EPSS for one CVE
curl -s "https://api.first.org/data/v1/epss?cve=CVE-2026-6460" | jq '.data[]'
# Several at once
curl -s "https://api.first.org/data/v1/epss?cve=CVE-2026-6460,CVE-2026-114713" | jq '.data[]'
The response includes an epss value (the probability) and a percentile (how that probability ranks against all CVEs). Treat percentile as the easier number to reason about. A CVE in the 95th percentile is in the top 5% for likelihood. Check the live values yourself at the time you read this, because EPSS changes daily and we are not quoting a number that will go stale.
Step 4: Combine the signals into tiers
A simple, defensible scheme:
| Tier | Rule | Typical target |
|---|---|---|
| P0 (emergency) | In KEV and the software is running on an internet-reachable asset | Mitigate or patch in hours to 1 to 2 days |
| P1 (urgent) | In KEV on an internal asset, or high EPSS (for example, top 10th percentile) on an internet-reachable asset | Within about a week |
| P2 (planned) | High CVSS with low EPSS, not in KEV | Next regular patch cycle |
| P3 (routine) | Low scores, unreachable or not running | Handle with normal updates |
The thresholds are yours to set. What matters is that the rule is written down, applied the same way every time, and records why each item landed in its tier.
Apply it to our two examples. UnrealIRCd, in KEV, goes to P0 if any server you run is reachable, and P1 otherwise. The PostgreSQL 52 go to P2 by default, move to P1 for any server that is internet-reachable or has many login roles with create rights, and move up immediately if a later KEV listing or exploit appears. You would still patch all of it, but you would do it in an order that matches real risk.
Step 5: Move the check into pull requests and pipelines
Vulnerability work is cheaper before the code ships. Run dependency scanning on every pull request, and set the pipeline to fail the merge for the top tier only (for example, KEV-listed vulnerabilities with a fix available). Failing for every High teaches developers to ignore the gate. Failing for the few that attackers are using teaches them to respect it.
# Example pattern (GitHub Actions): fail only on known-exploited findings
- name: Scan dependencies
run: |
grype sbom:./sbom.json -o json > findings.json
- name: Fail on KEV-listed findings
run: |
jq -e '[.matches[] | select(.vulnerability.knownExploited != null and (.vulnerability.knownExploited | length > 0))] | length == 0' findings.json
Field names differ between tools and versions, so check your scanner’s output format before relying on this exact filter.
Step 6: Write the policy down
Auditors and customers increasingly ask not just whether you patch but how you decide. A one-page policy covers:
- Which signals you use (CVSS, KEV, EPSS, exposure)
- The tiers and the target time to fix for each
- Who can approve an exception, and for how long
- How you verify that the fix was applied
Use the policy to defend decisions such as “we deferred 40 High-scored flaws because none are reachable, in KEV, or likely to be exploited, and here is the record.” Our guide to prioritizing vulnerabilities based on business risk and which CVEs to fix first offer more depth.
Where Cloudanix Fits
Prioritization tools only help if they know what you run. Cloudanix is built around that link.
KEV and EPSS inside the scanner. Code Security runs software composition analysis (SCA) on your repositories. It reads manifests and lockfiles across npm, PyPI, Maven, Go modules, RubyGems, NuGet and Cargo, finds direct and indirect dependencies, and generates a CycloneDX SBOM for each repository. Findings are matched against the Cloudanix VulnDB, which draws on 28 upstream feeds (including OSV, NVD, GitLab Advisory and Trivy) and adds CISA KEV and EPSS for exploitability and prioritization, so you are not working from NVD alone.
Gates that block the right pull requests. Pull request scanning posts a comment or status check and can block the merge through quality gates. You decide which findings qualify, so the gate can be strict on the few that matter. For a worked example, see prioritizing high and critical dependency CVEs with KEV and EPSS.

Container and runtime context. Container image scanning covers build time and runtime for Kubernetes workloads, with SBOMs, CVEs, secrets, licenses and fixability and exploitability. When your code, image and runtime layers are connected, code-to-cloud correlation traces a finding from repository to image to running workload, to the role it uses and the data it can reach. That answers “is it running, and what could it touch?” For more, see which vulnerabilities are actually running in production. Note that this correlation depends on those layers being connected. It is not automatic for every repository.
Exposure in the cloud. CSPM shows which assets are internet-facing and applies contextual severity, so the same CVE ranks differently on an exposed production host than on an isolated one.
What this does not do. Cloudanix does static and dependency analysis plus runtime context. It is not a dynamic testing (DAST) tool, and it does not replace one. It can only prioritize software that it can see through your repositories, images and cloud accounts, so an unmanaged server running a forgotten chat daemon needs to be found by your inventory first. And no scanner patches the software for you. AI-assisted fixes are offered for code and dependency issues, with manual steps for sensitive, high-impact ones.
Quick Reference Checklist
- Generated SBOMs for repositories and container images
- Listed running hosts and services, including old or forgotten ones
- Checked your CVEs against the CISA KEV feed
- Looked up EPSS scores and percentiles for the rest
- Marked which vulnerable software is running and internet-reachable
- Defined P0 to P3 tiers with target times
- Set pull request gates to fail only on the highest tier
- Wrote a one-page prioritization policy with an exception process
- Patched UnrealIRCd 6.0.0 to 6.2.7.0 installs to 6.2.7.1 or later, or removed them
- Scheduled the PostgreSQL minor updates in order of exposure
Key Takeaways
- Two flaws with nearly the same CVSS scores (8.8 and 8.6) need different responses: UnrealIRCd’s CVE-2026-114713 is in CISA’s KEV catalog and is being exploited, while PostgreSQL’s CVE-2026-6460 has no reported exploitation.
- CVSS measures how bad a flaw could be. KEV says it is being used. EPSS estimates the chance it will be used in the next 30 days. Your inventory says whether it matters to you.
- A written, tiered policy turns “we patch everything” into “we fix the right things first, and here is why.”
- Put the gate where code is cheapest to fix, in the pull request, and keep it strict only for what attackers are using.
- You still need to patch PostgreSQL. The point is the order.
Want to see which vulnerabilities in your repositories and clouds are in KEV, likely to be exploited and actually running in production? Book a free assessment and we will map it with you.
People Also Read
- PostgreSQL Fixes 52 Security Flaws, Including a 22-Year-Old Bug That Lets a Database User Run Code on the Server
- CISA Flags an Ivanti Connect Secure Zero-Day: Why the Fix Is Exposure and Blast Radius
- Which Vulnerabilities Are Actually Running in Production
- Code-to-Cloud Security Explained: Following a Vulnerability From GitLab to a Running ECS Task
- Cloudanix: Code Security