Understanding Vulnerability Impact
Assess exploitability, attacker prerequisites, confidentiality, integrity, availability, and severity with evidence from code and deployment context.
Vulnerability impact is the harm an attacker can cause to an asset under stated conditions. To judge it, connect the actor’s prerequisites, the reachable behavior, and the resulting confidentiality, integrity, or availability loss.
Compare findings using the same assumptions. Your task is to explain a priority decision that another engineer can verify, rather than attach a dramatic label to a function name.
What you should be able to do
- State attacker prerequisites and the affected asset.
- Separate confidentiality, integrity, and availability consequences.
- Distinguish demonstrated impact, plausible extensions, and unknowns.
- Compare two vulnerabilities under consistent deployment assumptions.
Start with the asset and the consequence
A title such as "SQL injection" or "missing authorization" names a class of weakness. It does not tell you which data the attacker can read, what state they can change, or whether the affected function is reachable. The same class can range from a low-impact leak in a disposable test environment to a serious compromise of production data.
Before rating severity, write one sentence for each of these:
| Question | Example |
|---|---|
| What asset is protected? | Customer invoices and the personal data inside them |
| What action should be controlled? | Exporting one invoice PDF |
| Who can attempt it? | Any signed-in customer |
| What code path is reachable? | GET endpoint → invoice lookup → PDF renderer |
| What rule fails? | Lookup is not scoped to the customer's tenant |
| What can be observed safely? | A cross-tenant test account receives a PDF it does not own |
Only then ask how broad the impact is. Does the bug expose one known invoice, any invoice whose ID can be obtained, a list of IDs, or all invoices? Does the response include billing addresses, tax IDs, bank details, or only a document title? Is the data encrypted at another layer? Does a download create an audit record? Those facts affect impact and detectability. They cannot be inferred from a vulnerability label.
This does not mean you should postpone every finding until the entire system is understood. If code clearly crosses a security boundary, record the finding promptly and mark the remaining impact questions. A reviewer can say "The shown route permits a cross-tenant read; the full data scope requires verifying the PDF projection and ID discovery paths." That is honest and actionable.
Select the evidence you need at each stage. A vulnerability name is a starting point, not a completed severity assessment.
Prerequisites. Record whether the actor needs an account, a particular role, a victim interaction, a known object ID, or a special deployment condition.
Reachability. Confirm the route, feature state, branch conditions, and relevant configuration. Separate a visible code weakness from a demonstrated deployed path.
Asset. Name the actual fields, records, business operation, or service resource. “The database” is usually too broad to be useful.
Consequence. Describe confidentiality, integrity, and availability separately. A metadata read and a persistent change to payment instructions have different consequences.
Confidence. State the demonstrated result and the evidence still needed to establish a broader result. The confidence of a claim is distinct from the severity if that claim is true.
Review question: Which additional fact would change your priority decision, and why?
Exploitability: what an attacker must have or do
Exploitability describes whether a capable actor can reach the weakness and satisfy its conditions. In a code review, list prerequisites explicitly rather than compressing them into "easy" or "hard."
- Network position: Is the route exposed to the internet, only to an internal network, or reachable through another service?
- Identity: Must the actor have an account? Can anyone self-register? Is a paid account required? Is a privileged role required?
- Target knowledge: Must the actor know an object ID, URL, secret, or valid file path? Is it discoverable through normal use, logs, or another endpoint?
- Victim interaction: Does someone else need to click a link, open a document, or approve a request?
- Environment: Must a particular feature flag, deployment configuration, plugin, or race condition be present?
- Timing and state: Does the target need to be in a narrow state, such as a draft invoice or a pending approval?
- Reliability: Does the attack work consistently, or only after many attempts and favorable conditions?
Do not equate "requires login" with "low exploitability." A free self-service account is a small barrier compared with a tenant administrator credential. Do not equate "requires an ID" with a secret prerequisite. IDs can appear in URLs, logs, notifications, browser history, support tickets, or other API responses. Conversely, do not assume an internal-only route is publicly reachable without showing an ingress path.
Example: a conditional cross-tenant read
export async function downloadStatement(request: Request, statementId: string) {
const session = await requireSession(request);
if (!session) return new Response('Sign in', { status: 401 });
const statement = await db.statement.findUnique({
where: { id: statementId },
});
if (!statement) return new Response('Not found', { status: 404 });
return new Response(await renderStatement(statement));
}
The code authenticates the caller but does not show a statement-level authorization decision. A signed-in actor who knows another statement ID may reach the renderer. A safe test with two test tenants can establish whether a cross-tenant response occurs. The code alone does not prove how IDs are generated, whether a database row-level security policy also applies, or exactly which fields the renderer includes. Those are specific questions to investigate.
The finding should reflect that evidence:
A signed-in user can request a statement ID outside their tenant. The handler loads by ID alone before rendering. If no downstream row policy applies, this permits cross-tenant disclosure of statement data. Add a tenant or documented sharing predicate at the lookup and a denied cross-tenant test.
Notice the phrase "if no downstream row policy applies." If you have inspected the database policy and proved the leak, remove the qualifier and state the observed result. Precise confidence is more useful than false certainty.
Confidentiality, integrity, and availability
The CIA triad is a compact way to describe technical harm. Treat the three dimensions separately.
Confidentiality is unauthorized disclosure. Examples include another user's document, a secret, private source code, or metadata that reveals a business relationship. Ask who can read, how much, whether the information is sensitive, and whether the disclosure can be repeated or enumerated.
Integrity is unauthorized modification or loss of correctness. Examples include changing a payout destination, editing an approval state, forging a report, altering security logs, or making a calculation use attacker-selected values. Ask what record changes, whether it is trusted downstream, and whether a rollback restores trust.
Availability is loss of access or function. Examples include crashing a worker, exhausting a shared queue, deleting a file needed by others, or blocking a financial reconciliation job. Ask how many users or systems are affected, how long the disruption lasts, and whether operations can recover automatically.
One vulnerability can affect more than one dimension. Remote code execution in a privileged service may permit reading data, modifying records, and disrupting service, but the code review should not claim every possible outcome without considering process permissions and deployment boundaries. A read-only query flaw may primarily affect confidentiality. A stored XSS flaw may affect both confidentiality and integrity depending on what the victim can do and what browser controls are present.
Technical impact is not the full business consequence
Two data leaks with the same number of bytes can have different consequences. An internal public-news cache and a medical record store do not carry the same privacy obligations. A five-minute outage during a sandbox demo and a five-minute outage during payment settlement are not equivalent. Organizational risk combines technical capability with asset value, exposure, operational context, and sometimes regulatory obligations.
NIST's Guide for Conducting Risk Assessments treats risk as involving threat, vulnerabilities, likelihood, and impact. You do not need to run a full NIST assessment for every code review comment. The lesson is to record the context that turns a technical defect into an organizational priority.
A practical impact worksheet
Use the following worksheet before assigning a severity label:
| Dimension | Evidence to collect | Example wording |
|---|---|---|
| Attacker | Reachable account or role; ability to self-register | "Any customer account" |
| Entry point | Route, job, import, or rendered page | "GET /statements/:id/download" |
| Prerequisites | Required ID, victim action, timing, configuration | "A valid statement ID from a link" |
| Controlled input | Exact parameter, field, stored value, or file | "statementId path value" |
| Sensitive operation | Read, write, execution, or resource consumption | "PDF bytes returned to caller" |
| Confidentiality | Data type, records, and affected users | "Another tenant's billing statement" |
| Integrity | Unauthorized changes or downstream trust | "No change shown" |
| Availability | Disruption and recovery | "No disruption shown" |
| Scope | One object, a class of objects, or shared system | "Potentially any known statement ID" |
| Confidence | Confirmed test, code inference, or open question | "Cross-tenant test reproduced in staging" |
The worksheet encourages bounded claims. "Potentially any known statement ID" is not the same as "all statements can be dumped" if the application has no way to discover IDs. If the ID generator is predictable or another list endpoint leaks IDs, update the scope with that evidence.
Avoid double counting
Do not count the same event several times simply because it has multiple descriptions. If an unauthorized download exposes a PDF containing a customer's name and invoice amount, that is one confidentiality event with several data fields, not necessarily multiple independent flaws. If the same endpoint also sends an email to an arbitrary address, that is a distinct effect worth assessing. Keep the chain of consequences explicit.
Likewise, do not score the theoretical compromise of every downstream system merely because a secret might be present. Identify which secret is reachable, what access it grants, and whether the application masks or scopes it. A hypothetical chain can justify further investigation, but not a confirmed impact claim.
Which new fact most directly increases the integrity impact of an unauthorized update?
Severity: a decision with stated assumptions
Severity helps teams order work. A useful severity statement answers: Under these deployment assumptions, how much harm can a capable attacker cause, and how readily can they cause it? It is a prioritization aid, not a property of one code line independent of environment.
Many teams use Critical, High, Medium, and Low. The labels are only useful if their definitions are shared. For example, a team may reserve Critical for remotely reachable compromise of a production service with broad privileges, High for cross-tenant sensitive data disclosure, Medium for narrower or more conditional harm, and Low for limited exposure or hard-to-reach conditions. Another organization may set different thresholds. State the basis and let the security owner map it to the local policy.
If the team uses CVSS, apply the chosen version precisely. CVSS v4.0 separates exploitability characteristics such as attack vector, attack complexity, attack requirements, privileges required, and user interaction from impacts to the vulnerable system and subsequent systems. Its environmental metrics let an organization adjust for its own context. A code snippet alone often cannot establish every metric. Do not invent a numerical score to make a review comment look authoritative.
Base severity versus deployment risk
Suppose a vulnerable PDF renderer can execute code when fed a malicious template. The technical weakness may be serious. In one deployment, only a trusted administrator can upload templates and the renderer runs in an isolated container with no secrets. In another, any customer can upload a template and the renderer has database credentials. The code defect is similar; attacker prerequisites and consequences differ substantially.
You should still recommend a fix in both cases. The first environment's controls may lower immediate incident likelihood or blast radius, but they are not a reason to keep unsafe code indefinitely. Record both the intrinsic weakness and the controls you verified. If a compensating control is merely claimed in a design document, confirm it exists in the actual deployment path before relying on it.
Finding A exposes invoice metadata to customers. Finding B lets an administrator interrupt a recoverable internal job. Can you rank them from their vulnerability names alone?
Compare two vulnerabilities under one scenario
Assume a business-to-business reporting service. Customers belong to separate tenants. A self-service account can be created for a free trial. The service stores invoices with names, addresses, and transaction amounts. It also runs a nightly reconciliation job that updates internal ledger summaries. The following two findings are independent:
Finding A: invoice read without tenant scope
export async function GET(request: Request, invoiceId: string) {
await requireSession(request);
const invoice = await db.invoice.findUnique({ where: { id: invoiceId } });
if (!invoice) return notFound();
return json(invoice);
}
The route verifies identity but not tenant membership for the invoice. Assume a test account from tenant B can fetch one known invoice ID from tenant A. The JSON includes the customer's name, address, and amount. It is unknown whether an actor can enumerate all invoice IDs. The demonstrated impact is cross-tenant confidentiality loss for at least one known ID. The prerequisite is a customer account and a target invoice ID; the route is internet reachable.
Finding B: reconciliation job cancellation without object scope
export async function cancelJob(request: Request, jobId: string) {
const session = await requireSession(request);
if (!session.roles.includes('operations')) return forbidden();
await scheduler.cancel(jobId);
return noContent();
}
Assume an operations user in tenant B can cancel a reconciliation job for tenant A by supplying its job ID. The job can be restarted by an on-call engineer within an hour. The demonstrated impact is availability of a tenant's scheduled reconciliation and possibly delayed integrity of downstream summaries, but the code shown does not prove the ledger is permanently corrupted. The prerequisite is an operations role, which is granted only to a small internal group, and a target job ID.
Which is more severe? Under these assumptions, Finding A may deserve earlier remediation because a self-service account can access sensitive cross-tenant data with relatively low prerequisites, while Finding B requires a privileged internal role and has a documented recovery procedure. That is an inference from stated facts, not a universal ranking of confidentiality over availability.
If reconciliation is legally time-critical, the job cannot be restarted reliably, or operations credentials are widely shared, the ranking may change. If invoice IDs are cryptographically unguessable and never exposed, Finding A's practical reach may be narrower, though the missing authorization rule remains a defect.
Write the comparison, not just the labels
An effective comparison could say:
Prioritize the invoice read first in the current deployment. A self-registered customer can retrieve a known invoice from another tenant, exposing personal and financial data. The job cancellation affects another tenant's reconciliation but requires an internal operations role and has a tested one-hour recovery path. Verify ID discovery and reconciliation dependencies before finalizing severity. Both need tenant-scoped authorization checks and denied cross-tenant tests.
This communicates prerequisites, CIA dimensions, scope, uncertainty, and action. A table with "A = High, B = Medium" alone hides the reasoning.
When impact changes as you trace farther
An initial finding often underestimates or overestimates impact because the reviewer stops at the first sink. Trace one or two steps farther:
- An unauthorized read of a user record may include only a display name in the current response, but another code path may render a full profile or send a CSV. Confirm the actual projection before claiming exposure.
- A write to a harmless-looking label may later feed an approval rule, search index, email template, or report. The integrity impact may emerge downstream.
- A worker crash may be isolated to one task or may stop a shared queue. Inspect worker concurrency, retry policy, and dead-letter handling.
- A path traversal may read only a container's temporary files if filesystem isolation is strong, or it may reach credentials mounted in the same process. Check deployment mounts and permissions.
- A code execution flaw may be limited by a sandbox, or the process may have network and database access. Verify the sandbox and credentials rather than assuming either extreme.
At each step, distinguish a demonstrated consequence from a plausible chain. Use language such as "could" or "may" for a chain that has not been confirmed, and name the missing fact. Avoid attaching every possible worst case to every flaw of a given class.
Reversibility and persistence
Impact is also shaped by whether harm can be undone. A deleted cache entry may be regenerated. A payment destination change followed by a completed transfer may be irreversible. A leaked password cannot be "unseen" even if the endpoint is fixed, so credential rotation and incident response may be necessary. A forged audit record can undermine later investigations even if the application data is restored.
This is why a fix plan sometimes includes containment beyond code: revoking exposed credentials, repairing data, notifying affected owners, reprocessing jobs, or preserving logs. A code reviewer should identify these possibilities, then coordinate with the security and operations owners rather than speculating about legal obligations.
How to confirm impact safely
Use a controlled environment and test accounts. Never access another real customer's data merely to strengthen a code review finding. In code review, a safe reproduction often requires only two fixtures and an assertion:
const tenantA = await testFactory.tenant();
const tenantB = await testFactory.tenant();
const invoiceA = await testFactory.invoice({ tenantId: tenantA.id });
const userB = await testFactory.user({ tenantId: tenantB.id });
const response = await requestAs(userB).get('/invoices/' + invoiceA.id);
expect(response.status).toBe(404);
expect(response.body).not.toContain(invoiceA.customerName);
The expected status reflects this example's nondisclosure policy. A product could choose 403 instead; the essential assertion is that no protected data is returned. For a write, assert the target record remains unchanged and no downstream job was queued. For a rate or availability issue, use bounded tests that cannot exhaust shared infrastructure. Avoid production stress tests without an approved plan.
Evidence should include the code path and a minimal denied case. A flashy exploit chain is rarely necessary to show that a missing object predicate matters. If a manual staging test is inconclusive because a feature flag differs from production, record the mismatch and verify configuration before claiming the result generalizes.
Practice: compare two new findings
Assume a document collaboration product with organizations, projects, and comments. Public sharing is disabled. Anyone can create a free account, but joining another organization requires an invitation.
Finding C: A signed-in user can call GET /api/comments/:commentId with a known comment ID. The route verifies the session but does not check project membership. A staging test with two organizations returns the comment body, which may contain internal project discussion. Comment IDs appear in notification links sent to project members; there is no known public enumeration endpoint.
Finding D: A project administrator can rename any project in the same organization by supplying its ID, even when the administrator is not assigned to that project. The new name appears in project lists and notifications. The user cannot edit project files or membership. The product's current policy says project administrators may manage only assigned projects.
Write a comparison in four sentences:
- State the attacker prerequisite and controlled identifier for each finding.
- State the demonstrated confidentiality, integrity, and availability effect.
- Rank them under the given assumptions and say why.
- Name one fact that could change the ranking and one denied test for each.
Compare your reasoning
Finding C is reachable by any self-registered account with a known comment ID. It demonstrates cross-organization confidentiality loss of at least one comment body; no write or outage is shown. Finding D requires a project administrator in the same organization and demonstrates unauthorized modification of a project name, with limited direct integrity impact in the facts provided.
Under these assumptions, C likely has higher priority because the prerequisite is broader and the data crosses an organization boundary. The ranking could change if comments contain only low-sensitivity public text, or if project names drive a critical automated workflow; the supplied facts do not establish either.
Test C with two organizations and assert the comment body is withheld; test D with an admin assigned to project A but not B and assert B's name and notifications remain unchanged.
Do not copy the words "higher priority" mechanically. If your organization has a stated classification for the documents or an incident timeline, incorporate it. The goal is a defensible comparison under explicit assumptions, not one universal answer.
Replace a dramatic label with a supported impact statement
Which assessment gives the team enough information to verify urgency without guessing what “critical” means?
Severity: Critical
Impact: Complete account takeover and database compromise.
Evidence: The endpoint has an IDOR.
Compare an evidence-based assessment
Actor: A signed-in customer with a known invoice ID.
Observed result: Reads another tenant’s invoice number, total, and billing email.
Confidentiality: Cross-tenant disclosure of those fields.
Integrity / availability: No write or disruption demonstrated.
Unknown: Whether IDs are exposed in any lower-trust response.
Next check: Trace identifier discovery and review other invoice fields.
The second statement separates actor prerequisites, the demonstrated data exposure, and the remaining uncertainty. The team can now evaluate severity and business risk against a concrete claim. A more severe outcome needs its own evidence.
Communicate severity without overstating confidence
A useful impact paragraph has five parts:
Actor and prerequisite. A customer with a self-service account and a known invoice ID. Reachable operation. The download handler loads by ID alone and returns the PDF. Demonstrated harm. A cross-tenant test returned another customer's invoice containing billing details. Scope and uncertainty. One ID was tested; enumeration and additional fields have not been verified. Priority and remedy. Treat as a high-priority confidentiality issue under the current data classification; scope the lookup to authorized tenant access and add a negative test.
Write the paragraph in ordinary prose for the actual review. The labels above are a drafting aid. If no reproduction was performed, substitute "code permits" or "appears to permit" and identify the policy or configuration that could change the conclusion. If the finding is confirmed, name the observed result.
Avoid unsupported absolutes such as "anyone can take over the whole service" when the actor needs an account and the affected process is isolated. Avoid minimizing a flaw as "low because login is required" without examining self-service registration and affected data. A precise sentence may be less dramatic than a generic severity label, but it helps the team fix the right thing.
Evidence levels: what the code shows and what still needs proof
Impact writing improves when each claim has an evidence label. A code review can reveal a missing predicate with high confidence while the final business consequence remains uncertain. Use four practical levels: observed in a controlled test, directly supported by code, conditional on a stated fact, and speculative. These are not formal severity categories. They help you avoid giving an inference the same status as an observed result.
Suppose you see a download route that fetches an attachment by ID without a tenant filter. The route then calls storage.read(attachment.storageKey). The code directly supports that the route lacks a visible tenant check. Whether a cross-tenant caller receives bytes depends on the storage key and any authorization inside storage.read. If a two-tenant test returns the other tenant's document, disclosure is observed.
If the application uses a database policy that automatically scopes queries by tenant, the route may be safe despite its appearance. If a reviewer says, "This exposes every customer document," while only one known ID was tested and no enumeration path was found, the word "every" overstates the evidence.
Write an evidence ladder for each finding:
| Claim | Evidence level | What would strengthen it? |
|---|---|---|
| The handler loads by attacker-supplied ID | Directly supported by code | Route test showing parameter mapping |
| The lookup lacks an application tenant predicate | Directly supported by code | Check ORM middleware and database row policy |
| A tenant B account can read tenant A's fixture | Observed in staging | Repeat through the deployed API path |
| IDs can be enumerated | Conditional | Inspect list endpoints, logs, ID format, and rate limits |
| All customer records are exposed | Speculative with current facts | Prove reachability and scale, then bound the claim |
This practice protects both the engineering team and the people affected. Understatement may delay a fix, but overstatement can also misdirect incident response and erode trust in review findings. A bounded, reproducible claim is easier to triage. It can be updated when new evidence arrives.
Evidence also has a lifetime. A test on a feature branch may not describe production if deployment flags differ. A screenshot of a successful response proves one response under one account, not every account or object. A static route check may miss a policy enforced by the database. Record the environment, commit, account role, object ownership, and configuration used for the observation. When a reviewer cannot access the full deployment, mark the limitation instead of silently assuming the most convenient state.
A second severity walkthrough: untrusted avatar markup
Consider a product that allows users to upload a profile avatar. A code change accepts SVG files and serves them from the same origin as the application. The SVG is shown in an image element on profile cards. The initial review comment says, "SVG upload is critical XSS because an attacker can run JavaScript and take over every account." That conclusion skips several necessary questions.
Start with attacker prerequisites. Who may upload an avatar? A self-registered user, an invited user, or an administrator? Is the uploaded content public, or does a victim have to open the attacker's profile? Is the file rendered only as an image resource, or can a browser navigate directly to its URL as a document? Does the storage service send Content-Type, Content-Disposition, and CSP headers that affect interpretation?
Are uploads served from a separate origin with no application cookies? Those are not academic details; they change whether script execution is reachable and what authority it has.
Next examine actual impact. If a controlled test shows an uploaded SVG executes script only when a victim opens the raw URL, you have a demonstrated stored script execution path with user interaction. It does not prove that every profile card executes the script. If the raw file is on a separate, isolated origin with no sensitive cookies and no privileged APIs, the blast radius may be narrower than same-origin execution.
If the file is same origin and can call authenticated APIs from a logged-in victim's browser, the integrity and confidentiality implications may be substantial. Record exactly what the controlled test showed.
Now examine scope and defenses. A Content Security Policy may block inline script, but a reviewer should verify the actual response header on the uploaded file and whether other script paths remain. A sanitizer may remove active SVG elements, but its version and configuration matter. A proxy may transform SVG to PNG, which can eliminate active markup if implemented correctly; verify the served bytes rather than relying on an upload extension.
Browser behavior can vary by embedding context, so use a supported browser test and avoid making broad claims from one HTML preview.
The appropriate finding might be: "A self-registered user can upload an SVG that is served as an active document from the application origin. In a staging test, opening the file URL while signed in executed script in that origin. A victim must open the uploaded file; we have not confirmed execution inside profile cards.
Serve uploads from an isolated origin as inert downloads or rasterize them, and add a denied active-content test." The severity can then reflect the application's account model, likely victim exposure, origin privileges, and local policy. The impact paragraph is more useful than an unsupported "critical" label.
For comparison, imagine the same product has a read-only endpoint that reveals one nonpublic team name to another tenant. The script execution may be more severe if it is readily reachable and carries application-origin privileges. The team-name leak may be more pressing if SVG navigation is blocked by current headers and the name endpoint is broadly enumerable. There is no universal ordering from the words "XSS" and "information disclosure" alone.
The reviewer compares proven capabilities, required user action, affected assets, and reach under the actual deployment.
How CVSS concepts inform a code review without replacing it
CVSS is a structured way to communicate vulnerability characteristics. Its metrics are not a substitute for understanding the feature. For a code reviewer, the useful habit is to ask the questions behind the metrics before selecting values: Is the attack remote or local? Does exploitation require special timing or configuration? Must the attacker possess a role? Must another user act? What happens to confidentiality, integrity, and availability in the vulnerable system and any subsequent system?
Consider the invoice and job-cancellation examples above. The invoice route is network reachable and requires a customer account plus a known invoice ID. Whether the known ID counts as an additional attack requirement under a chosen CVSS version requires careful interpretation of the specification; do not improvise a score from ordinary language. The job cancellation requires an operations role and a target job ID.
Its availability impact depends on whether the job can be restarted and whether missed reconciliation causes downstream harm. If your organization asks for a CVSS vector, collect the facts first, apply the version's definitions, and have a second reviewer check the vector.
Some important product facts do not fit neatly into a generic base score. A tenant's invoice may contain regulated personal data, while another deployment's invoice contains only public test data. A one-hour reconciliation delay may be acceptable in a development environment and unacceptable during a financial close. Environmental and organizational context should be recorded alongside any standardized score. Priority may also change due to active exploitation, customer exposure, or a release deadline.
Those are triage decisions informed by severity, not proof that the underlying code suddenly changed.
When writing a review comment, separate technical effect, score or label, and priority. Technical effect is what the flaw permits. A score or label summarizes that effect under a methodology. Priority is when the team should fix it given exposure, customer commitments, available mitigations, and competing work. A medium technical severity can be urgent if it affects a currently abused endpoint.
A high severity issue in an unreachable feature branch may have lower immediate incident priority but still block release. Keeping these concepts separate prevents a discussion about scheduling from obscuring the security fact.
An authorized test shows one customer can read one foreign record. What is the defensible next statement?
Extended practice: weigh confidentiality against integrity and reach
Use the following invented scenario to practice a more difficult comparison. A customer-support platform has workspaces. Each workspace contains private support tickets and an automation rule that can set a ticket's priority. Users can create a free trial workspace. A workspace administrator can invite agents; an agent can read only tickets assigned to their team. The platform uses sequential numeric ticket IDs, but the assignment policy is enforced server-side in most routes.
Finding E: ticket preview exposure. A signed-in agent can request GET /api/tickets/:id/preview. The route loads a ticket by ID and returns its subject, the first 160 characters of its body, and the customer's email address. It does not check workspace or team assignment. A two-workspace staging test returned another workspace's fixture ticket. The route has no documented rate limit. The same agent cannot fetch the full ticket through the ordinary detail endpoint.
Finding F: automation rule modification. A workspace agent can request PATCH /api/automation/:id with a rule ID and a new priority value. The route checks that the caller belongs to the workspace but does not require administrator permission. A staging test changed one rule in the agent's own workspace. The rule runs on new tickets and can set priority to low or high. It cannot send data externally or close tickets. An administrator can restore the rule, but the system does not keep version history.
Before reading the worked answer, write a table with actor, prerequisite, controlled input, sensitive operation, CIA effect, affected scope, recovery, and unknowns for both findings. Then write one paragraph ranking the findings for an organization that handles time-sensitive medical support requests. Write a second paragraph for a hobby forum where ticket subjects and customer addresses are already visible to all logged-in agents, but priority rules control the moderator queue. Explain why the rankings may differ even though the code does not.
Compare your reasoning
For E, the actor is a signed-in agent who can create or join a trial workspace. The controlled input is a ticket ID. The operation returns a preview with an email address and some message text. Confidentiality is demonstrably affected across workspaces, and sequential IDs plus the absence of a documented limit suggest a plausible route to scale. However, the test proves one fixture response; it does not yet prove unrestricted bulk extraction.
Integrity and availability are not shown. A denied test should create two workspaces and assert that an agent from one cannot receive the other's subject, body preview, or email through the real API path.
For F, the actor is an agent in the target workspace. The controlled input is the automation rule ID and allowed priority value. The route permits a modification reserved for administrators, so integrity is demonstrably affected. Availability could be affected if low-priority tickets are overlooked, but the code alone does not prove missed responses. No cross-workspace effect is shown.
An administrator can restore the rule, though lack of version history makes it harder to identify exactly what changed. A denied test should verify both that a nonadministrator's PATCH fails and that the stored rule and subsequent job behavior remain unchanged.
In the medical-support deployment, E may take precedence because the preview leaks customer identities and sensitive message fragments across workspaces to a relatively broad actor set. F can also be serious: lowering the priority of urgent requests could delay care, but that harm depends on workflow behavior not yet established. The reviewer should immediately ask whether priority is the only routing signal, whether alerts exist, how often rules run, and how quickly changes are detected.
If the rule governs emergency triage without oversight, F could move ahead. The comparison should not assert a clinical outcome without evidence.
In the hobby-forum deployment, the confidentiality consequence of E may be smaller if the same data is already legitimately visible to every agent. That statement needs confirmation: the finding crosses workspaces, so "visible to all agents" could be true within a workspace but false across customers. F may be the higher priority if a bad rule can hide abuse reports from moderators and the rule runs frequently.
The code-level authorization defects are the same in both deployments; asset sensitivity and operational consequence change the triage. A useful review note gives the current ranking and the fact that would reverse it.
This exercise also shows why severity should be revisited after a fix. If E is fixed by adding a team predicate but the response still leaks customer email in a public cache, a different exposure remains. If F is fixed at the route but a worker accepts unauthenticated rule updates from a queue, the sensitive operation is still reachable. Confirm the actual effect, then update the finding's scope and priority rather than closing it solely because one line changed.
Availability and resource exhaustion need their own evidence
Availability findings are easy to overstate because a slow request can look like a service-wide outage from the reviewer's laptop. A useful availability assessment asks what resource is exhausted, who shares it, how quickly it recovers, and what legitimate work is delayed. CPU time, database connections, worker slots, storage space, memory, and external API quotas are different resources with different blast radii.
A single expensive query may affect only the caller if it runs in an isolated worker, or every customer if it holds a shared connection pool.
Imagine a report endpoint that accepts a date range and runs an aggregation across event records. The server validates that both dates parse but places no limit on the interval. A reviewer sees a request spanning ten years and measures a 20-second response in staging. That is evidence of an expensive request, but it does not yet establish a denial of service.
Ask whether the query has an index, whether a user can send requests concurrently, whether there is a per-account quota, and whether the database serves other workloads from the same pool. A bounded load test in an isolated environment can show whether one self-registered account degrades another account's ordinary requests. The code finding may still be valid before that test: unbounded user-selected work has a plausible availability consequence.
Label the observed latency and the unconfirmed cross-user impact separately.
The remediation should match the resource boundary. A maximum date range, precomputed aggregate, timeout, concurrency limit, and per-account budget can each reduce risk, but none is a universal replacement for the others. A timeout may stop the HTTP request while a database query keeps running. A rate limit can cap request count but allow one extremely expensive request. A cache may help repeated ranges yet do little for unique adversarial ranges.
A reviewer should name the limiting resource and verify that the proposed control actually limits it.
Recovery changes priority. A worker that crashes and restarts automatically in seconds may cause transient delay. A worker that retries a poison message forever can block a queue for hours, and a failed backup job may threaten future recovery even before users notice. Record whether the effect is localized, whether retries amplify it, and whether operators receive an alert. Avoid saying "full outage" when only one job is stuck, but do not dismiss a stuck job if it protects a critical process.
For a compact comparison, suppose Finding G lets any logged-in user request a large report that ties up one of two shared workers for fifteen minutes. Finding H lets an internal administrator delete a generated report file that can be rebuilt in one minute. G may be more urgent because a broad actor can repeatedly consume scarce shared capacity, though the application has not yet shown a complete outage.
H has a stronger-looking verb, "delete," but narrower access and rapid recovery. If the file is the only copy of a regulatory record or the workers are actually isolated per customer, the ranking changes. The reviewer needs those facts, not a generic rule that deletion is always worse or that availability is always less important than integrity.
Try writing a bounded test for G. Create one ordinary report request and one intentionally large request against an isolated staging worker pool. Measure queue wait time and completion time for both, with a small fixed number of iterations and a clear stop condition. If the ordinary request's wait time rises while the large request holds a worker, you have evidence of shared-resource interference.
If it does not, inspect whether staging uses the same pool size and isolation policy as production before downgrading the concern. Report the measured numbers, the test environment, and the missing production facts. Do not run an open-ended stress test against a live customer service merely to force a dramatic result.
For H, verify the recovery claim rather than accepting it as a comforting assumption. Can the report be rebuilt from immutable source data? Does rebuilding reproduce the same content and signatures? Is the source retained long enough? Does an audit log identify which administrator deleted the file? A one-minute rebuild is a meaningful mitigating fact only if it works for the affected record under the deployment's retention and compliance rules.
This is how impact assessment turns a vague statement about reversibility into an evidence-backed bound on harm.
A final review worksheet you can reuse
For any vulnerability you find, fill out these seven lines before choosing a severity label:
- Asset and rule: Name the data, action, or service being protected and the policy that should restrict it.
- Actor and prerequisites: State whether the actor is anonymous, self-registered, invited, privileged, internal, or requires a victim action.
- Reachability: Trace the real entry point through configuration, middleware, and feature flags to the sensitive operation.
- Observed effect: Describe the smallest confirmed unauthorized read, change, execution, or disruption.
- Scope and recovery: Bound the affected objects and explain whether the effect can be reversed or contained.
- Unknowns: Name the exact fact that would raise or lower the impact estimate and how to verify it safely.
- Priority rationale: Explain the local data sensitivity, exposure, and operational context behind the proposed order of work.
Run the worksheet on the invoice route and job cancellation example at the start of this lecture. You should be able to state a ranking under the supplied assumptions, then change that ranking when one assumption changes. That ability is the core skill. A vulnerability name tells you where to look; a defensible impact assessment tells the team what the code enables and how urgently to respond.
Key takeaways
- Impact begins with a protected asset, a reachable operation, and a broken rule; a vulnerability class alone is not enough.
- List attacker prerequisites explicitly, including identity, network, target knowledge, interaction, configuration, and timing.
- Assess confidentiality, integrity, and availability separately, then describe scope and recovery.
- Separate demonstrated outcomes from plausible chains and say what evidence is missing.
- Compare findings under the same deployment assumptions and explain what could change the ranking.
- A severity label is useful only when its rationale and local policy are visible.
Glossary
Exploitability: The extent to which an actor can reach and satisfy the conditions needed to use a weakness.
Attacker prerequisite: Something an actor must possess or cause before exploiting a flaw, such as a role, object ID, victim action, or environment state.
Confidentiality: Protection against unauthorized disclosure.
Integrity: Protection against unauthorized or incorrect modification.
Availability: The ability of authorized users and systems to access a service or data when needed.
Blast radius: The users, data, systems, and processes that could be affected by one successful exploit.
Severity: A prioritization classification for a vulnerability under stated technical and organizational assumptions.
CVSS: A standardized framework for describing vulnerability characteristics and deriving a score under its specification.
Frequently asked questions
Is a vulnerability severe if it has no public exploit?
It can be. A public exploit is evidence about current exploitation and accessibility, not the only basis for impact. Review the reachable code path, attacker prerequisites, and consequences. Do not assume "no public proof of concept" means "no risk."
Does authentication always reduce severity?
Authentication is a prerequisite, but its strength varies. A free self-service account is different from a tightly controlled administrator role. The affected data and action still matter.
Should I always calculate CVSS during code review?
Use the process required by your team. A formal CVSS score can be useful, but it should follow the correct version and verified system facts. A concise impact narrative with evidence and uncertainty is more useful than an invented number.
What if I cannot prove the full blast radius?
Report the demonstrated boundary failure and the scope you can support. State the open questions, such as whether IDs can be enumerated or whether the service account has additional permissions. The finding can be triaged and updated as those facts are checked.
Are confidentiality and privacy the same?
They overlap but are not identical. Confidentiality describes unauthorized disclosure of information. Privacy includes the effect on people and the rules governing personal information. A code review should identify the data exposed; privacy owners can assess legal and policy consequences using that evidence.