Vulnerabilities by weakness type

Untrusted input is placed into a web page without being neutralised, so an attacker's markup or script executes in another user's browser. That can hijack sessions, capture keystrokes, or silently perform actions as the victim. Fixing it properly means context-aware output encoding everywhere data meets HTML, backed by a content-security policy as a second line of defence.

User input is woven into a database query, letting an attacker rewrite the query's logic. From there they can read, alter, or destroy data — frequently the entire database. The reliable fix is parameterised queries (prepared statements), so input is always treated as data and never as SQL.

The program writes past the bounds of a buffer, overwriting adjacent memory an attacker can turn to their advantage. Crafted input can overwrite control data and redirect execution. Remediation is validating every index and length before a write, plus modern memory-safety mitigations.

The program reads or writes outside the bounds of an allocated buffer, corrupting adjacent memory. With crafted input an attacker can overwrite control data and, with effort, redirect execution to their own code. Remediation ranges from bounds checking and safe library functions to compiler mitigations, usually alongside a careful audit of the surrounding code.

The application accepts input without confirming it is well-formed or within expected bounds, so malformed data can push the program into states its author never anticipated. Attackers probe these gaps to trigger crashes, bypass logic, or feed tainted values into more dangerous operations downstream. Remediating it well means validating and normalising every input at the boundary against a strict allow-list — not merely filtering known-bad values.

A file path is built from user input without being confined, so sequences like “../” let an attacker step outside the intended directory. That can expose configuration, credentials, or source code, and in the worst case lets an attacker write files where they shouldn't. A durable fix resolves and canonicalises the path, then rejects anything that escapes a known-safe base directory.

The code reads past the end (or before the start) of a buffer, returning memory that was never meant to be exposed. Attackers use it to leak secrets like keys or to defeat memory-protection defences. Remediation is validating indices and lengths before every read.

Memory is used after it has been freed, so its contents — now potentially attacker-controlled — drive the program's behaviour. With careful heap grooming this becomes code execution. The fix requires disciplined ownership of memory and often a targeted rework of the object lifecycle.

The application discloses data — error detail, internal paths, tokens, or other users' records — to someone who shouldn't see it. On its own it can look minor, but it hands attackers the map they need for a larger attack. Remediation is about minimising what's returned and enforcing authorization on every piece of data.

The application can't tell whether a state-changing request was genuinely intended by the user, so an attacker can trick a logged-in victim's browser into making it. That can transfer funds, change settings, or create accounts silently. Remediation is anti-CSRF tokens — or equivalent same-site protections — on every state-changing request.

The application checks who you are but not whether you're allowed to perform a given action, so any authenticated user can reach things meant for others. This is the classic “change the ID in the URL” bug. The fix is an authorization check on every request, evaluated against the acting user's permissions.

User input reaches a shell or system command without being fully separated from the command itself, so an attacker can append their own instructions. Because these run with the application's privileges, it often means full control of the host. The lasting fix is to avoid the shell entirely — call APIs directly and pass arguments as data, never as concatenated strings.

The application evaluates attacker-influenced input as code, handing them a way to run logic inside the process. Depending on the runtime this can escalate directly to remote code execution. Remediation means removing dynamic evaluation of untrusted input and replacing it with safe, data-driven alternatives.

The application fails to correctly restrict what a user can do or reach, so functions or resources are available to people who should not have them. Attackers simply probe for the paths where the check is missing or wrong. The fix is to enforce access-control decisions consistently on every request, evaluated against the acting user rather than assumed from context.

The code follows a pointer that is null, crashing the process. An attacker who can reliably trigger it turns the crash into a denial of service. The fix is checking for null before use and handling the failure path gracefully.

Untrusted input crosses into a downstream interpreter — SQL, a shell, an HTML page, an LDAP query — without being kept separate from the commands around it, so the attacker's data is read as instructions. This is the parent class behind SQL injection, cross-site scripting, and command injection alike. The durable fix is the same everywhere: keep data and code apart at every boundary, using parameterisation or context-aware encoding rather than building interpreted strings by concatenation.

The mechanism that verifies who a user is can be side-stepped or fooled, letting an attacker act as someone they're not. Everything built on top of that identity then becomes untrustworthy. Fixing it means hardening the full authentication flow, including edge cases, tokens, and secondary paths.

A fixed-size buffer is filled without checking the length of the incoming data, so it overflows into neighbouring memory. This is the classic overflow attackers use to overwrite return addresses and hijack execution. The fix is strict length checks and safe, bounded string and memory functions.

The application accepts uploaded files without properly checking their type or content, so an attacker can upload something executable. If it lands where the server will run it, that is remote code execution. Remediating it means validating content rather than just the extension, storing uploads outside the web root, and never executing them.

A legacy NVD category covering weaknesses where permissions or privileges are assigned, checked, or dropped incorrectly, so an action ends up running with more access than it should. It is an umbrella label from older records, not a single flaw. The remedy depends on the specific case, but the throughline is least privilege with explicit, checked transitions wherever privilege changes.

User input reaches a command interpreter without being fully separated from the command itself, so an attacker can append instructions of their own. Because those run with the application's privileges, it frequently means control of the host. The lasting fix is to avoid constructing commands from input — call APIs directly and pass arguments as data, never as concatenated strings.

Data overflows a fixed-size buffer allocated on the stack, overwriting adjacent stack memory — including saved return addresses — which is the classic route to redirecting execution into attacker-supplied code. Crafted input is all it takes. Remediation is strict length checks, safe bounded string and memory functions, and modern stack-protection mitigations.

An arithmetic operation produces a value too large for its type and wraps around to an unexpected — often tiny or negative — number. That miscalculated value then drives a memory allocation or a bounds check, opening the door to corruption. The fix is checked arithmetic and validating sizes before they're used.

A single request can consume unbounded CPU, memory, or connections, so a modest amount of malicious traffic exhausts the service. The result is denial of service for everyone else. Remediation is enforcing limits, quotas, and timeouts on what any one request can use.

The application rebuilds objects from attacker-supplied serialized data, and the act of rebuilding can trigger dangerous code paths. In many runtimes this leads straight to remote code execution. The durable fix is to avoid deserializing untrusted input — or to use a strict, type-limited format with integrity checks.

Privileges are granted, or fail to be dropped, incorrectly, so an action runs with more power than it should. An attacker who reaches that path inherits the excess privilege. The fix is least-privilege throughout, with explicit, checked transitions whenever privilege changes.

A sensitive function is reachable with no authentication at all, so anyone who finds the endpoint can use it. These are routinely discovered by automated scanning. The fix is to require and enforce authentication on every privileged path, with no exceptions left open.

An authorization check exists but is flawed, so it passes when it should fail. Attackers probe roles and object references to find the gap. Remediation means centralising and correctly implementing the access-control logic, then testing it against every role.

The server can be induced to make requests to a URL an attacker controls, turning it into a proxy into internal networks and cloud metadata services. It's especially dangerous behind a trusted network boundary. The fix is strict allow-listing of destinations and blocking access to internal address ranges.

Data overflows a buffer allocated on the heap, corrupting neighbouring heap structures and allocator metadata that a patient attacker can groom into control of execution. It is subtler than a stack overflow but just as dangerous. The fix is validating lengths before every write and using safe allocators and bounded operations.

A legacy NVD category for weaknesses in how cryptography is chosen or used — weak algorithms, poor key handling, missing integrity protection. It is a broad bucket rather than a specific bug. The remedy depends on the detail, but it comes down to strong modern algorithms, disciplined key management, and validated implementations rather than home-grown schemes.

The application allocates memory, connections, or handles in response to a request without enforcing any cap, so a modest amount of malicious traffic exhausts the resource and denies service to everyone else. The fix is enforcing quotas, limits, and timeouts on what any single request or client can consume.

A legacy NVD category grouping weaknesses in how resources — memory, file handles, connections — are allocated, used, and released. It gathers leaks, exhaustion, and lifecycle bugs under one label rather than naming a single flaw. The fix depends on the specific resource issue, generally pairing acquisition with release and bounding what any request can consume.

Two operations that should be atomic can interleave, so an attacker who wins a narrow timing window reaches an inconsistent, exploitable state. These bugs are subtle and easy to miss in review. Fixing them properly means correct locking or atomic operations around the shared resource.

Allocated memory is never released on some path, so a long-running service or a repeatedly triggered request steadily consumes memory until performance degrades or the process crashes. Attackers exploit it by simply driving the leaking path. Remediation is pairing every allocation with a release and using ownership patterns or tooling to catch what leaks.

The application uses a user-supplied identifier to look up a record without checking that the requester actually owns it, so changing the identifier in a request returns someone else's data. This is the classic insecure-direct-object-reference — the change-the-ID-in-the-URL bug. Remediation is authorizing every object access against the acting user, not merely confirming they are logged in.

A password or key is baked into the source or binary, so anyone who obtains the code obtains the credential. These are trivially found once the software is distributed. Remediation means removing the secret, rotating it, and loading credentials from secured configuration at runtime.

A sensitive file, directory, or resource is created with permissions more open than it needs, so unintended users can read or modify it. Attackers look for exactly these loose defaults. Remediation is assigning the minimum permissions required and verifying them at install time and at runtime.

The application redirects the browser to a URL taken from user input without validating it, so an attacker can craft a link on your trusted domain that quietly bounces victims to a malicious site. It is a staple of phishing and token theft. The fix is to allow-list redirect destinations or use indirect reference keys, never a raw user-supplied URL.

Files, directories, or resources ship with permissions more open than they need to be, so unintended users can read or modify them. Attackers look for exactly these loose defaults. Remediation means tightening permissions to the minimum required and verifying them at install and at runtime.

A file operation follows a symbolic link without checking where it actually points, so an attacker who can plant or swap a link redirects the operation to a file they should not be able to touch. It is a common local privilege-escalation primitive. Remediation is resolving and validating the real target path, and avoiding operations on attacker-controllable links.

The application does not properly validate the TLS certificate presented by the other side — skipping the chain, the hostname, or expiry — so an attacker with a forged or mismatched certificate can sit in the middle of a supposedly secure connection. It is a common trap in custom clients and misconfigured libraries. The fix is full certificate validation, and never disabling verification to make errors go away.

A PHP include or require path is built from user-controlled input, so an attacker can steer it to a remote URL or an unintended local file — and because the target is then executed as code, this often becomes remote code execution. It is the classic remote/local file-inclusion trap. The fix is never to build include paths from input: map requests to a fixed allow-list of includable files.

Credentials are stored or transmitted without adequate protection, so an attacker who reaches them can reuse them directly. One weak link here can unravel an entire system. Remediation means strong hashing for stored secrets, encryption in transit, and never writing credentials to logs.

An XML parser processes external entity references inside untrusted documents, letting an attacker read local files, reach internal systems, or exhaust resources. It's a common trap in anything that accepts XML. The fix is to disable external entities and DTD processing in the parser.

The application confirms who you are but does not properly check whether you are permitted to perform a given action, so authenticated users reach functions or data meant for others. Attackers test roles and object references to find the gap. Remediation is an authorization check on every request, evaluated against the acting user's actual permissions.

The program loads a library or executable from a location an attacker can influence — a writable directory early in the search order — so a malicious file is loaded with the application's privileges. On Windows this is the classic DLL-hijack. Remediation is loading only from fully-qualified trusted paths and controlling the search order explicitly.

A legacy NVD category grouping numeric mistakes — overflows, truncation, sign errors — where a miscalculated value goes on to drive a dangerous decision such as a memory allocation or a bounds check. It is a bucket rather than one specific bug. Remediation is checked arithmetic and validating any computed size or index before it is used.

A user or process is granted a privilege it should not have, so anyone who reaches that path inherits capability beyond what was intended. Attackers seek out exactly these over-granted routes. The fix is assigning the minimum privilege required and verifying every grant explicitly rather than assuming it.

Sensitive values — secrets, tokens, session identifiers, personal data — are written into log files, so anyone with access to the logs, which is often a broad group, obtains them. It turns a routine diagnostic into a credential leak. The fix is redacting sensitive data before it is logged and tightly restricting who can read the logs.

Crafted input drives a loop whose exit condition is never satisfied, hanging the thread and starving the service of the resource it occupies. A single request can be enough to take a worker down. Remediation is bounding iteration counts and validating the conditions that are supposed to terminate the loop.

A resource is accessed as one type when it was actually allocated as another, so the code misreads memory layout — in interpreters and language runtimes this is frequently a direct path to code execution. It often arises from unchecked casts on attacker-influenced objects. The fix is strict type checks before casts and memory-safe access patterns.

The same block of memory is freed twice, corrupting the allocator's bookkeeping in ways an attacker can shape toward code execution. It usually stems from tangled ownership of a pointer. The fix is clear, single ownership of each allocation and clearing pointers once they are freed.

Sensitive information is transmitted over an unencrypted channel, so anyone positioned on the network path can read it as it passes. Credentials, tokens, and personal data are the usual casualties. The fix is to encrypt everything sensitive in transit with TLS and to remove any plaintext fallback.

Attacker-controllable input can reach an assertion that aborts the process when it fails, so a check meant for debugging becomes a denial-of-service in production. A single crafted request takes the service down. The fix is to handle unexpected input gracefully on reachable paths rather than asserting on it.

Memory or a resource is used before it has been initialised, so its contents are whatever happened to be there — sometimes leaking earlier data, sometimes values an attacker can influence. Behaviour becomes unpredictable and occasionally exploitable. Remediation is initialising every resource before use and ensuring initialisation happens on all code paths.

The application accepts signed data without properly verifying the signature, so an attacker can forge or tamper with content that the system is meant to trust — tokens, updates, licences. Everything built on that trust then becomes unreliable. Remediation is verifying every signature against the correct key and rejecting anything that does not validate.

Shared resources are accessed without correct locking, so concurrent operations interleave into inconsistent — and sometimes exploitable — states, or deadlock the service outright. These bugs are subtle and timing-dependent. The fix is correct, consistent locking or atomic operations around every shared resource.