| CVE |
Vendors |
Products |
Updated |
CVSS v3.1 |
| Inscriptis is a Python library for converting HTML to text. From 2.0.0 until 2.7.6, when the parent is block-level, table_end_handler() in model/tag/table_tag.py writes each sibling table through HtmlElement.write_verbatim_text() in model/html_element.py; Canvas.open_block() leaves the parent padding_inline prefix on the stack, Canvas.close_block() does not remove it, and only Canvas.close_tag() calls prefix.remove_last_prefix(). Each following sibling table therefore carries forward accumulated indentation, making get_text() output grow quadratically and allowing small attacker-controlled HTML to exhaust memory in applications converting it without authentication or user interaction. This issue is fixed in 2.7.6. |
| codebase-memory-mcp provides local code intelligence for developers and AI agents through a persistent graph and MCP tools. Prior to 0.10.0, the indexer's .gitignore matcher implemented * and ** through recursive backtracking without a work bound. A repository containing a pattern with repeated wildcard groups and a long path could make matching work grow exponentially, allowing a single ignore rule to stall discovery indefinitely and, before worker isolation, stall the server. The impact is limited to availability, and the bounded matcher does not claim that every expensive input is eliminated. This issue is fixed in version 0.10.0. |
| Vikunja from 0.19.0 before 2.8.0 contains a denial of service vulnerability that allows authenticated CalDAV users to exhaust server CPU by uploading VTODO properties with many parameters. Attackers can PUT an iCalendar body with thousands of parameters on one line to any valid project ID, triggering superlinear parsing before permission checks. |
| Vikunja from 0.21.0 before 2.8.0 contains a denial of service vulnerability that allows authenticated users to exhaust memory and CPU by creating tasks with many reminders and long titles. Attackers can store a task whose ParseAlarms rendering in pkg/caldav/caldav.go uses quadratic string concatenation, causing every CalDAV read, including other members' automatic syncs, to allocate gigabytes. |
| Vikunja from 0.21.0 before 2.8.0 contains a resource exhaustion vulnerability that allows authenticated users to trigger instance-wide database writes by setting a project position below 0.1. Attackers can repeatedly send PUT requests to /api/v2/projects/{id} so recalculateProjectPositions updates every user's root projects, holding SQLite's write lock and degrading availability. |
| Vikunja from 0.18.0 before 2.8.0 contains a resource amplification vulnerability in pkg/models/export.go that allows authenticated users to exhaust server memory by exporting heavily related tasks. Attackers can relate many tasks to one task with a large description and request a user export, causing an out-of-memory crash for all users. |
| Vikunja from 0.8.0 before 2.8.0 contains a denial of service vulnerability that allows authenticated project readers to amplify response size by repeating requested properties in CalDAV PROPFIND requests. Attackers can send PROPFIND requests to the dav projects endpoint with hundreds of duplicate calendar-data properties to exhaust server memory, CPU, and bandwidth. |
| actix-http 3.0.0 before 3.20.3 contains a denial of service vulnerability that allows unauthenticated remote attackers to exhaust memory by sending large-window brotli request bodies. Attackers can send an 850-byte body with Content-Encoding: br declaring a 2^30 window, forcing about 1 GiB of decoder allocation per request and OOM-killing servers. |
| A vulnerability in the Object Linking and Embedding, 2nd Generation (OLE2) file parser for ClamAV could allow an unauthenticated, remote attacker to exceed the configured MaxScanTime and cause a DoS condition on an affected device.
This vulnerability is due to inefficiencies when parsing specifically formatted files with the OLE2 file parser. An attacker could exploit this vulnerability by by sending a crafted Microsoft Compound File Binary (CFB) file to be scanned. A successful exploit could allow the attacker to effectively cause the ClamAV OLE2 parser to get into an infinite loop, resulting in a DoS condition on the affected software. |
| The IPv6 neighbour discovery code in subsys/net/ip/ipv6_nbr.c keeps packets that are waiting for address resolution on a per-neighbour pending queue. A queued packet holds two references: the one handed over by the sender and a second one taken by net_ipv6_send_ns() when the packet is put on the queue. The Router Advertisement handler handle_ra_input() popped each packet off the queue and passed it to net_send_data(), relying on a trailing nbr_clear_ns_pending() call to release the queue reference — but that call then found the queue already empty and released nothing, so one reference was leaked for every pending packet flushed on an RA.
Router Advertisements are unauthenticated link-local ICMPv6 messages, so any node on the same link can trigger the flush. An attacker can make the leak deterministic by advertising itself as a router without a source link-layer address option, so the victim's neighbour entry stays INCOMPLETE, then inducing the victim to transmit through that next hop (the packet is queued and a neighbour solicitation is sent), leaving the solicitation unanswered and sending a further RA to drain the queue. Each round leaks one struct net_pkt together with its net_buf chain.
Leaked packets are never returned to the fixed-size pools, so the loss is permanent for the lifetime of the boot. With CONFIG_NET_PKT_TX_COUNT defaulting to 4 (14 with CONFIG_NET_PKT_LARGE_DEFAULTS), a small number of repetitions exhausts the transmit packet slab and the node stops being able to send any traffic. The impact is availability only: the reference count is always too high, never too low, so no use-after-free or memory corruption arises.
The fix moves the flush into a helper, nbr_send_pending(), which releases the queue reference for every packet it takes off the queue before handing the remaining reference to net_send_data(), and releases that one too if the send is refused. |
| netty-incubator-codec-ohttp implements Oblivious HTTP (OHTTP) gateway and client functionality using Netty. Prior to 0.0.23.Final, BinaryHttpParser.readFieldSection in codec-bhttp/src/main/java/io/netty/incubator/codec/bhttp/BinaryHttpParser.java loops while fieldSectionLength is nonzero and relies on disabled-by-default assertions to require BinaryHttpParser.readFieldLine to return a value and consume bytes. A corrupt field line can consume more bytes than its understated declared section length and drive the counter negative, or a truncated field line can return without consuming data and leave the parser in the same state. An unauthenticated OHTTP peer can encrypt such Binary HTTP content under the gateway public configuration, reach OHttpRequestResponseContext.ContentDecoder.decodeChunk, and permanently pin a Netty event-loop thread at full CPU before application business logic. Multiple requests can exhaust the event-loop group and deny service until restart. This issue is fixed in version 0.0.23.Final. |
| netty-incubator-codec-ohttp implements Oblivious HTTP (OHTTP) gateway and client functionality using Netty. Prior to 0.0.23.Final, BinaryHttpParser.readFieldLine in codec-bhttp/src/main/java/io/netty/incubator/codec/bhttp/BinaryHttpParser.java treats a complete field line that ends exactly at a known field-section boundary as incomplete and returns without consuming bytes. BinaryHttpParser.readFieldSection then leaves fieldSectionLength unchanged and repeats the loop because its forward-progress checks are Java assertions, which are normally disabled in production. A remote peer that sends a known-length Binary HTTP header or trailer section ending at that boundary can make the parser spin indefinitely and pin the Netty event-loop or worker thread responsible for the channel. This issue is fixed in version 0.0.23.Final. |
| A vulnerability was detected in smartalock wireguard-lwip up to cfba91666590e86bd67842c71cedf9a423be823a. This affects the function wireguard_generate_unique_index of the file src/wireguard.c of the component Session Index Allocator. The manipulation of the argument receiver_index results in allocation of resources. The attack is only possible with local access. The project was informed of the problem early through an issue report but has not responded yet. |
| Validating an untrusted URL with a long scheme and many hosts into a multi-host URL field (e.g. PostgresDsn) takes quadratic time and memory: an input of about a hundred kilobytes takes around a gigabyte of memory to validate.
The parse_multihost_url() function (in pydantic-core/src/validators/url.rs) parses each host separately, prepending the whole URL prefix (including the scheme) to every one of them. As the scheme can be arbitrarily long, and is parsed and stored once per host, both time and memory grow quadratically with the input size. Allowed schemes (e.g. postgres for PostgresDsn) are only checked after parsing, so they don't prevent the issue.
The issue was fixed in commit b4028f9d87e34750e53be0ba011d70f3c0fcc94e.
Impact: denial of service through validation of untrusted input. Affected are applications validating untrusted strings into multi-host URL fields (PostgresDsn, MongoDsn, NatsDsn, or custom types built on MultiHostUrl). |
| A vulnerability was found in hiparker opsli-boot up to 2.2.1. This affects the function getInputStream of the file opsli-plugins/opsli-plugins-waf/src/main/java/org/opsli/plugins/waf/servlet/WafHttpServletRequestWrapper.java of the component WAF Plugin. The manipulation results in denial of service. The attack can be executed remotely. |
| A weakness has been identified in PowerJob up to 5.1.7. This affects the function CustomHttpServletRequestWrapper of the file powerjob-server/powerjob-server-starter/src/main/java/tech/powerjob/server/config/CachingRequestBodyFilter.java of the component CachingRequestBodyFilter. Executing a manipulation can lead to denial of service. It is possible to launch the attack remotely. |
| FlowIntel contains a resource exhaustion vulnerability in its file-to-note conversion feature. When a user converts an attached CSV or JSON file into a case note, the application renders the data as a Markdown table by padding every row to the maximum column count. A crafted file with a small number of filled cells but a very large number of columns (or keys) causes the application to allocate a quadratic number of padded table cells, potentially exhausting a worker process in memory or CPU.
The same issue affects nested JSON values rendered inside table cells, where pretty-printed indentation further inflates the output size.
Preconditions:
- An authenticated user with access to a case in FlowIntel
- Ability to attach and convert a CSV or JSON file to a note
Impact:
- Denial of service: exhaustion of a worker process, potentially disrupting service for other users
- No confidentiality or integrity impact
Affected versions: FlowIntel prior to 4.1.0 |
| A vulnerability was determined in tianshiyeben wgcloud up to 4.0.1. This vulnerability affects unknown code of the file AgentController.java of the component minTask Endpoint. Executing a manipulation can lead to allocation of resources. The attack can be executed remotely. |
| A security flaw has been discovered in sofastack sofa-bolt up to 1.6.12. Affected by this issue is the function HessianSerializer.deserialize of the file src/main/java/com/alipay/remoting/serialization/HessianSerializer.java of the component Hessian2 Deserialization. Performing a manipulation results in allocation of resources. The attack can be initiated remotely. The vendor was contacted early about this disclosure but did not respond in any way. |
| Validating an untrusted string in exponent notation into a Fraction field computes the full power of ten without any bound: an input of a few bytes takes seconds to validate.
String inputs are passed to the Fraction constructor. For strings in exponent notation (e.g. '1e8000000'), CPython computes the corresponding power of ten as an integer (in Lib/fractions.py).
The issue was fixed in commit 69ed168e9ad465eef4c8d81efb152a93b604daf5. For strings in exponent notation, the exponent is now parsed before calling the Fraction constructor, and exponents larger than 4300 (in absolute value) are rejected.
Impact: denial of service through validation of untrusted input. Affected are applications validating untrusted strings into Fraction fields (in both JSON and Python mode, including in strict mode), using Pydantic from 2.10.0 up to (but excluding) 2.14.0.
From 2.14.0, exponents larger than 4300 (in absolute value) are rejected, matching the maximum number of digits accepted for integers. |