Category: Security

  • Prioritising vulnerabilities: CVSS vs EPSS vs CISA KEV

    Prioritising vulnerabilities: CVSS vs EPSS vs CISA KEV

    Part 1 of 3 in the Vulnerability management that works series.

    Every vulnerability programme I’ve seen fail failed the same way. The scanner produced thousands of findings, someone decided “fix all criticals and highs within 30 days”, the backlog grew faster than anyone could patch, and within a quarter the SLA dashboard was a wall of red that everyone had learned to ignore. The problem usually isn’t effort. It’s that the team is sorting by the wrong number.

    This series is about running vulnerability management so it actually reduces risk. Part one is about the sorting, because if you get that wrong nothing downstream matters.

    CVSS measures severity, not risk

    Flowchart: a scanner finding goes to P1 if in CISA KEV or high EPSS and exposed, P2 for high EPSS or critical CVSS on exposed systems, P3 for CVSS 7 and above, otherwise P4

    The Common Vulnerability Scoring System, maintained by FIRST, is the score everyone knows. A CVSS base score describes the intrinsic characteristics of a vulnerability: attack vector, complexity, privileges required, user interaction, and the impact on confidentiality, integrity and availability. It answers “how bad is this if someone exploits it?”

    It doesn’t answer “will anyone exploit it?”, and the specification says so. The CVSS v3.1 spec states plainly that CVSS measures severity, not risk. Teams use the base score as a risk score anyway, because it’s the column the scanner shows.

    The practical problem is distribution. A large share of published CVEs land at 7.0 or above, so “fix all highs and criticals” means fixing a majority of everything. When half your backlog is priority one, you don’t have priorities.

    CVSS v4.0, released by FIRST in November 2023, tries to address this by making the extra metric groups more visible. There are now Base, Threat, Environmental and Supplemental groups, and the spec asks you to label which ones a score includes (CVSS-B, CVSS-BT, CVSS-BE, CVSS-BTE). The Threat group’s Exploit Maturity metric lets you lower a score when there’s no known exploitation. That’s an improvement in principle. In practice almost every feed you consume publishes base scores only, and the threat data has to come from somewhere else anyway. Which brings us to the other two.

    EPSS estimates likelihood

    The Exploit Prediction Scoring System, also run by a FIRST special interest group, is a model that outputs a probability between 0 and 1 that a given CVE will see exploitation activity in the wild in the next 30 days. It’s trained on observed exploitation telemetry and retrained periodically, with scores recomputed daily. Its inputs include whether public exploit code exists, mentions in security lists, the vendor and the vulnerability type.

    Each CVE gets two numbers: the probability and a percentile. The percentile tells you how it ranks against every other scored CVE. Most CVEs have a very low EPSS probability, which is the whole point. The model is telling you that the vast majority of vulnerabilities never get exploited at all, and it’s trying to tell you which few will.

    You can query it for free:

    curl -s "https://api.first.org/data/v1/epss?cve=CVE-2021-44228,CVE-2023-4863" \
      | jq -r '.data[] | "\(.cve)  epss=\(.epss)  pct=\(.percentile)  as_of=\(.date)"'

    FIRST also publishes the full daily score set as a compressed CSV, which is what you want if you’re enriching a whole scanner export rather than looking up a handful.

    EPSS has limits I’d keep in mind. It’s a prediction about the internet at large, not about your environment. A CVE with a low EPSS score in a product exposed directly to the internet on your perimeter deserves more attention than the model gives it. It also lags. A brand new CVE often scores low on day one simply because the model hasn’t seen any signal yet. And it’s a probability, so treat a score of 0.02 as “unlikely”, never as “safe”.

    KEV is evidence, not prediction

    CISA’s Known Exploited Vulnerabilities catalog launched in November 2021 alongside Binding Operational Directive 22-01. A CVE goes into KEV when three things are true: it has a CVE ID, there’s reliable evidence of active exploitation, and there’s clear remediation guidance such as a vendor patch. BOD 22-01 requires US federal civilian agencies to remediate each entry by a due date CISA sets when adding it, often two or three weeks out.

    KEV is small compared to the CVE corpus, well over a thousand entries against hundreds of thousands of CVEs, and that’s its strength. Every entry is something an attacker has actually used. It’s also available as a JSON feed:

    curl -s https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json \
      | jq -r '.vulnerabilities[] | [.cveID, .dateAdded, .dueDate, .knownRansomwareCampaignUse] | @tsv' \
      > kev.tsv

    The knownRansomwareCampaignUse field is worth carrying into your tooling. “Known” there means CISA has evidence ransomware operators used it, which in my experience is the single fastest way to get an executive to approve an emergency change window.

    What KEV doesn’t give you is coverage. Exploitation that nobody reported to CISA, or that hit products CISA doesn’t track, isn’t in there. Absence from KEV tells you very little.

    Combining them

    None of these three is a prioritisation scheme on its own. Together they’re pretty good. The way I’d layer them:

    1. In KEV: fix now, on the shortest SLA you have. Someone is using this.
    2. High EPSS and exposed: treat almost like KEV. Exposure means reachable by an attacker who doesn’t already have a foothold, so internet-facing services, VPN concentrators, email gateways.
    3. High EPSS or critical CVSS on exposed systems: the next tier, on a normal fast SLA.
    4. Everything else with a high CVSS: the standard backlog, fixed by routine patching and image rebuilds.
    5. The long tail: fixed when the component gets upgraded anyway.

    As code, roughly:

    def priority(cvss: float, epss: float, in_kev: bool, exposed: bool) -> str:
        if in_kev:
            return "P1"
        if epss >= 0.10 and exposed:
            return "P1"
        if epss >= 0.10 or (cvss >= 9.0 and exposed):
            return "P2"
        if cvss >= 7.0:
            return "P3"
        return "P4"

    The 0.10 cutoff is my choice, not a standard. Pick yours by looking at how many of your current findings land in each bucket. If P1 has more than a few dozen items in a mid-sized environment, your thresholds are too loose, or you have a real emergency and should treat it as one.

    If you want something more formal, CISA’s Stakeholder-Specific Vulnerability Categorization (SSVC) is a decision tree that takes exploitation status, exposure, automatability and mission impact and outputs one of four actions: Track, Track*, Attend or Act. It’s the same idea with more rigour, and it’s easier to defend in an audit than a Python function someone wrote on a Friday.

    The part nobody wants to hear

    The inputs that matter most for prioritisation aren’t in any public feed. Whether a vulnerable package is actually loaded at runtime, whether the vulnerable function is reachable, whether the host is exposed to the internet: that’s your asset inventory and your architecture. A Log4Shell finding in a jar that sits in an unused test directory and a Log4Shell finding in your public login service have identical CVSS, EPSS and KEV values. One of them is an incident.

    So the real first step is tagging assets with exposure and ownership. Once you have that, the public scores do most of the remaining work. Part two looks at SBOMs, which are the other half of knowing what you’re actually running.

    Other parts: Part 2: SBOMs: what they’re actually good for, Part 3: Patch SLAs that teams actually meet.

  • Threat modeling with STRIDE for a small team

    Threat modeling with STRIDE for a small team

    Most small teams I talk to think threat modeling is something big companies do with a dedicated security architect, a two-week engagement and a 40-page document nobody reads afterwards. That version exists, and it’s mostly a waste. The version that works for a team of five engineers fits in a 90-minute meeting around a whiteboard and ends with a handful of tickets. STRIDE is the tool I reach for because it gives a room full of people a structured way to ask “what could go wrong here?” without needing a security specialist to lead every question.

    What STRIDE actually is

    Data flow diagram of a payment webhook receiver with three trust boundaries and STRIDE threat badges on each boundary-crossing flow

    STRIDE came out of Microsoft in 1999, from Loren Kohnfelder and Praerit Garg, and was popularised by Adam Shostack’s book Threat Modeling: Designing for Security. It’s a mnemonic for six threat categories, each one the violation of a property you want your system to have:

    • Spoofing violates authentication. Someone claims to be a user, a service or a host they aren’t.
    • Tampering violates integrity. Data in transit, at rest or in memory gets modified.
    • Repudiation violates non-repudiation. Someone does something and you can’t prove it.
    • Information disclosure violates confidentiality.
    • Denial of service violates availability.
    • Elevation of privilege violates authorization. A user or component gets capabilities it shouldn’t have.

    That’s it. It isn’t a methodology on its own, and it doesn’t rank anything. It’s a checklist of question shapes. The value is that it stops the discussion from collapsing into whatever the loudest person in the room worried about last week, which in my experience is usually SQL injection.

    Start from four questions, not from the acronym

    Shostack frames the whole exercise as four questions, and the Threat Modeling Manifesto (2020) kept them:

    1. What are we working on?
    2. What can go wrong?
    3. What are we going to do about it?
    4. Did we do a good enough job?

    STRIDE only answers question two. Teams that skip question one end up applying STRIDE to a vague mental picture of “the system”, which produces vague threats like “an attacker could spoof a user”. True, useless.

    So answer question one concretely. Pick one feature or one change, not the whole platform. “We’re adding a webhook receiver that accepts events from our payment provider and updates order status” is a good scope. “Our backend” is not.

    Draw a data flow diagram with trust boundaries

    The diagram is where most of the value comes from, and it should take 15 to 20 minutes. You need four kinds of things:

    • External entities: users, third-party services, anything you don’t control.
    • Processes: your services, workers, lambdas.
    • Data stores: databases, queues, buckets, caches.
    • Data flows: arrows between them, labelled with what moves and over what protocol.

    Then draw trust boundaries, the dashed lines where the level of trust changes. Internet to your load balancer. Your API to the database. Your worker to the third-party API. Your app to the admin interface. If a flow crosses a dashed line, that’s where you spend your time. Flows entirely inside one trust zone rarely produce interesting threats.

    For the webhook example, the boundaries are the payment provider to your public endpoint, your receiver to the queue, and the worker to the orders database. Three crossings. That’s a manageable meeting.

    Walk STRIDE per element

    The variant that works best for small teams is STRIDE-per-element. Not every category applies to every kind of element, and the classic mapping keeps the discussion short:

    • External entities: spoofing and repudiation.
    • Processes: all six.
    • Data stores: tampering, information disclosure, denial of service, and repudiation if the store is a log.
    • Data flows: tampering, information disclosure, denial of service.

    Go element by element along the flows that cross a boundary and ask each applicable question out loud. For the webhook receiver it might go like this:

    • Spoofing: can anyone on the internet POST a fake “payment succeeded” event? Do we verify the provider’s signature, and do we compare it in constant time?
    • Tampering: can a valid event be replayed? Is there a timestamp in the signed payload, and do we reject old ones?
    • Repudiation: if an order flips to paid by mistake, can we show which event did it and where it came from?
    • Information disclosure: do our error responses leak stack traces or internal hostnames to the caller?
    • Denial of service: what happens if someone sends 10,000 large bodies a second? Is there a size limit before we parse JSON?
    • Elevation of privilege: does the worker’s database role need to write to anything except the orders table?

    Every one of those is a concrete, testable question, and most of them are a few lines of code to fix.

    Record threats as tickets, not as a document

    The output of the session is a list of threats, each with a decision. Mitigate, accept, transfer or eliminate the feature. I like a plain table in the repo next to the code, because it gets reviewed in pull requests and it ages with the system:

    | ID | Element            | STRIDE | Threat                                  | Decision  | Ticket   |
    |----|--------------------|--------|-----------------------------------------|-----------|----------|
    | W1 | Webhook endpoint   | S      | Forged event without valid signature    | Mitigate  | PAY-412  |
    | W2 | Webhook endpoint   | T      | Replay of a captured valid event        | Mitigate  | PAY-413  |
    | W3 | Receiver -> queue  | D      | Unbounded body size exhausts memory     | Mitigate  | PAY-414  |
    | W4 | Worker DB role     | E      | Role can write to users table           | Mitigate  | PAY-415  |
    | W5 | Provider outage    | D      | Events delayed for hours                | Accept    | -        |

    Accepted risks are fine. Write down who accepted them. A threat model where everything is “mitigate” usually means nobody was honest about the effort.

    Making it stick on a small team

    Teams rarely fail by modeling badly. They model once at a kickoff and never again, and a few habits help prevent that.

    Tie it to design review. If a change adds a new trust boundary crossing, a new external entity or a new data store with sensitive data, it gets a STRIDE pass. Everything else doesn’t. That keeps it rare enough that people don’t resent it.

    Rotate who facilitates. The facilitator’s job is to keep the group moving through the elements and to stop the session from becoming a design argument. Any engineer can do that after watching it twice, and the person who facilitates tends to start thinking this way in code review too.

    Keep the diagram in the repo as text. A diagram drawn in a SaaS whiteboard is dead the day the meeting ends. Mermaid, PlantUML or OWASP Threat Dragon’s JSON files all diff fine. Microsoft’s Threat Modeling Tool is also free if your team is on Windows and wants STRIDE suggestions generated from the diagram, though I find the generated list too long for a small team to triage.

    Revisit question four. A month after the feature ships, spend ten minutes asking whether any incident, bug report or pentest finding touched an element you modeled. If one did and the model missed it, that’s the most useful feedback you’ll get about your process.

    Where STRIDE falls short

    STRIDE is good at technical threats along data flows. It’s weak on abuse of legitimate functionality, like a referral program being farmed, and on privacy harms, where LINDDUN is a better fit. It also says nothing about likelihood. When a session produces more threats than you can fix, rank them by what an attacker can reach from outside your trust boundaries first, and by what you’d have to explain in an incident report second. That’s crude, and it’s still better than ranking by gut feeling about which bug sounds scariest.

    I’ve watched a five-person team find a missing webhook signature check, an admin endpoint reachable from the public load balancer and a worker with database superuser rights, all in one 90-minute session. Nobody in the room was a security specialist; they drew the thing and asked the questions in order.

  • Cloud IAM misconfigurations: public buckets, broad roles and Capital One

    Cloud IAM misconfigurations: public buckets, broad roles and Capital One

    Most cloud breaches I’ve read about didn’t need a zero-day in the provider. They needed a bucket readable by the world, a role that could do far more than its job required, or both. The provider did exactly what it was told. The configuration just told it the wrong thing.

    The 2019 Capital One breach is still the best case study I know. It shows how a small flaw in one place becomes a large one when identity permissions are too broad.

    What happened at Capital One

    Sequence diagram of the Capital One 2019 breach chain with the control that breaks each step

    The public record, from the Justice Department’s case and the bank’s own disclosures, goes roughly like this. Capital One ran a web application firewall on EC2 in front of some of its applications. The WAF was misconfigured so that an outside attacker could make it send requests on their behalf, a server-side request forgery (SSRF).

    From the EC2 instance, the attacker requested the instance metadata service at 169.254.169.254. At the time, that service answered any plain HTTP GET from the instance, including the temporary credentials for the IAM role attached to it. So the SSRF returned working AWS credentials.

    The role attached to the WAF instance could list and read a large number of S3 buckets, more than 700 according to the criminal complaint, which held credit card application data. Data on about 100 million people in the US and 6 million in Canada was taken. The OCC fined Capital One $80 million in 2020, and the attacker was convicted in 2022.

    Notice that no single control failed outright. The WAF had a configuration bug. The metadata service worked as designed. The role had convenient permissions. The breach needed all three.

    Fix the metadata path first

    AWS introduced IMDSv2 in November 2019, a few months after the breach became public. It requires a session token obtained with a PUT request carrying a custom header, and by default it won’t answer requests that have passed through too many network hops. Most SSRF bugs can only make simple GET requests, so IMDSv2 blocks the exact path used at Capital One.

    Make it mandatory, not optional. For existing instances:

    aws ec2 modify-instance-metadata-options \
      --instance-id i-0123456789abcdef0 \
      --http-tokens required \
      --http-put-response-hop-limit 1

    Then stop new instances launching without it. A service control policy at the organisation level enforces that across every account:

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "RequireIMDSv2",
          "Effect": "Deny",
          "Action": "ec2:RunInstances",
          "Resource": "arn:aws:ec2:*:*:instance/*",
          "Condition": {
            "StringNotEquals": { "ec2:MetadataHttpTokens": "required" }
          }
        }
      ]
    }

    Containers have the same problem one layer down. A pod on a node that can reach the node’s metadata endpoint can borrow the node’s role. Use per-workload identities (IRSA or EKS Pod Identity on AWS, Workload Identity on GCP and Azure) and keep the hop limit at 1 so containers can’t reach node credentials.

    Keep roles narrow

    The WAF needed, at most, to write its own logs. It didn’t need to read customer data. Broad roles usually happen for understandable reasons: someone was in a hurry, a wildcard made the error go away, and nobody revisited it.

    {
      "Effect": "Allow",
      "Action": "s3:*",
      "Resource": "*"
    }

    That statement is a bug waiting to be reported. A role for a component should name the actions and resources it actually uses:

    {
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Resource": "arn:aws:s3:::example-waf-logs/waf/*"
    }

    Writing these by hand is tedious, so use the tools built for it. IAM Access Analyzer can generate a policy from the role’s real activity in CloudTrail, and the “last accessed” data shows which granted services a role has never touched. Start broad in development if you must, then generate the narrow policy from observed use before production.

    Two more patterns keep the blast radius small. Put sensitive data in separate accounts from internet-facing workloads, because cross-account access must be granted explicitly on both sides. And add resource policies on the most sensitive buckets that deny access from anything outside your expected principals or network paths, using conditions such as aws:PrincipalOrgID or aws:SourceVpce. Even if a role is over-granted, the bucket says no.

    Public buckets: turn the default on everywhere

    Accidentally public buckets have exposed voter rolls, military files and plenty of corporate backups over the years. The fix is now mostly one setting. S3 Block Public Access overrides any ACL or bucket policy that would make data public, and since April 2023 AWS enables it, with ACLs disabled, on all new buckets by default. Buckets created before that keep whatever they had, so set it at the account level too:

    aws s3control put-public-access-block \
      --account-id 111122223333 \
      --public-access-block-configuration \
      BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true

    If something genuinely needs to be public, like static website assets, serve it through a CDN with origin access control from a bucket that stays private, or put it in a dedicated account where public is the expected state and nothing sensitive lives.

    Other clouds have equivalents: public access prevention on Google Cloud Storage and disabling anonymous blob access on Azure storage accounts. Same idea, different flag.

    Detect what you can’t prevent

    Prevention won’t be perfect, so watch for the signs. GuardDuty flags EC2 instance credentials being used from outside AWS, which is the signature of stolen metadata credentials. CloudTrail data events for S3 on sensitive buckets will show a role suddenly listing hundreds of buckets it normally never touches. That pattern was visible in the Capital One case, and it’s a detection worth writing. AWS Config rules or a CSPM tool can continuously report public buckets, roles with wildcard actions, and instances without IMDSv2.

    A quick audit you can run this week

    Find every role with * in its actions or resources, and work through them starting with roles attached to internet-facing compute. Check that IMDSv2 is required across all instances and launch templates. Confirm account-level Block Public Access everywhere. Pick your three most sensitive buckets and read their access logs for a week.

    None of this is exotic. Capital One had a large, capable security team, and the breach still came down to a convenient role and a metadata endpoint that answered too easily. Most of us have less, which is all the more reason to make the defaults strict.