Browse / AI Framework and Platform Flaws / Denial of service
Denial of service
377 records in AI Framework and Platform Flaws.
- NLTK: Quadratic-time CPU denial of service in CCG lexicon parser (fromstring) on wide bracket bodies and operator chains A lexicon parser repeatedly copies remaining input while scanning bracket bodies and operators, so long flat inputs cause quadratic CPU consumption.
- NLTK: Quadratic-time CPU denial of service in Tree.chomsky_normal_form right-factor binarization via list.pop(0) A wide flat parse tree makes right-factor binarization quadratic in child count, so a single crafted tree from untrusted input stalls the CPU.
- NLTK: Quadratic-time CPU denial of service in ConllCorpusReader SRL instance builder via nested span rescan Parsing a crafted CoNLL SRL block forces quadratic-time span rescans for each predicate, consuming large amounts of single-threaded CPU.
- NLTK: Unbounded CPU consumption in SteppingRecursiveDescentParser.parse() with ambiguous or self-embedding grammars The stepping recursive descent parser runs without a time or step limit, so an ambiguous grammar with short input can pin a CPU core indefinitely.
- NLTK: Quadratic CPU exhaustion in TreebankWordTokenizer.span_tokenize via list.pop(0) in quote-restore loop Repeated list removal inside the quote-restoration step lets a long run of quote characters consume a CPU core for a prolonged period.
- NLTK: Quadratic CPU exhaustion in LegalitySyllableTokenizer.tokenize via unguarded onset reversal loop Passing one long all-vowel token to the syllable tokenizer triggers a quadratic loop that keeps a CPU core busy for the duration of the call.
- Kubeflow Pipelines: Pipeline archive upload allows decompression bomb to exhaust server memory Pipeline archive uploads are decompressed without bounding the expanded size, so a small zip or tar file can exhaust API server memory.
- ONNX: Null Pointer Dereference in ScanInferenceFunction Due to Missing Required Attribute Shape inference for the Scan operator dereferences a missing required attribute and accepts negative counts, crashing when given a malformed model.
- Docling: Unbounded table rowspan/colspan in HTML, JATS, ODS and BoxNote backends causes CPU/memory exhaustion A tiny HTML or spreadsheet file with huge span attributes makes the converter loop and allocate oversized tables, exhausting CPU and memory.
- Docling: METS-GBS archive member limit enforced after full member enumeration (memory exhaustion during format detection) Tar archives have all member headers enumerated into memory before the member-count limit applies, so many empty entries exhaust memory.
- vLLM: Mirrored multimodal IPC caches desync after a rejected request — a later request reusing the same media hash trips a receiver assertion in the engine core A rejected request leaves the frontend cache believing media is stored in the engine, so a later request reusing that media hash triggers a fatal assertion.
- vLLM: Structured-output request errors escape the request boundary and terminate the shared EngineCore — engine-fatal denial of service (3 sites) Malformed structured-output requests raise an uncaught error in the engine loop, which kills the shared engine and blocks all other requests.
- vLLM: Scale-out disaggregated multimodal transport trusts caller-supplied features The generate endpoint accepts internal multimodal fields from callers as if they came from the trusted renderer, so forged values can crash the shared engine process.
- vm2: Host Promise rejection from an exposed constructor can terminate the vm2 host process A rejected promise returned from an exposed host constructor is not marked handled, so Node terminates the host process.
- vm2: Host-returned Promise rejection can bypass vm2's unhandled-rejection hardening and terminate the host process Sandboxed code can trigger an unhandled host Promise rejection that the bridge leaves unhandled, crashing the Node.js host process.
- vm2: timeout Option Bypass via FinalizationRegistry Cleanup Callback (Unbounded Host Event-Loop Block) Sandboxed code registers a FinalizationRegistry callback that runs during garbage collection, outside the timeout meant to bound execution, blocking the host event loop.
- Open WebUI: Unauthenticated requests can stall the server via uncached OIDC fetches in back-channel logout An unauthenticated back-channel logout request triggers uncached, blocking OIDC discovery and key fetches on the event loop, so repeated requests stall the server.
- Open WebUI: Any authenticated user can start a non-terminating request via a folder parent cycle Re-parenting a folder beneath its own descendant creates a cycle, and the tree walk never tracks visited nodes, so the request never terminates.
- Open WebUI: Any authenticated user can suppress calendar alerts instance-wide via a non-numeric alert value A user stores a non-numeric alert value in calendar event metadata, which breaks the shared scheduler pass for every user.
- n8n: Prototype Pollution via Workflow Structure Summary Can Lead to Denial of Service Posting a workflow with a reserved key such as __proto__ directly to the REST API pollutes Object.prototype, because the editor's client-side name check is skipped.
- n8n: Unauthenticated Persistent Storage Exhaustion via OAuth Dynamic Client Registration Endpoint Unauthenticated OAuth client registration requests accept unbounded client_name and grant_types values, which are stored until database storage grows without limit.
- n8n: Regular Expression Denial of Service in the Default Blocked-File-Pattern Match via a Git Node Clone Path A crafted clone path causes catastrophic regex backtracking in a synchronous check, freezing the n8n process for all users.
- Open WebUI: Any authenticated user can hang the server via message deletion in a cyclic chat tree A chat whose messages reference each other as children makes the message-deletion walk loop forever, blocking the server's event loop.
- Open WebUI: Any authenticated user can hang the server via a cyclic chat message history A chat history whose messages reference each other in a cycle without ids makes the server's walk loop forever, blocking all users.
- NLTK: Pl196xCorpusReader has quadratic ReDoS on malformed TEI blocks Lazy regexes over a TEI block rescan from each unmatched opening tag, so a malformed corpus file causes quadratic CPU growth in reader calls.
- NLTK: Entity-expansion DoS (billion laughs) via remaining raw ElementTree parses Entity-declaring XML handed to several NLTK parsers expands exponentially in memory, exhausting resources, because those call sites bypassed the safe XML parsing helper.
- NLTK: ReDoS in nltk.text.Text.findall() via unvalidated user-supplied regular expressions User-supplied regular expressions passed to NLTK Text.findall run without timeout or validation, allowing catastrophic backtracking.
- NLTK: ReDoS in nltk.tgrep via unvalidated user-supplied regular expressions A user-supplied regular expression in the tgrep query path is compiled and run without limits, so a crafted pattern against a non-matching label causes exponential backtracking.
- NLTK: Uncontrolled recursion in nltk.featstruct.FeatStructReader causes unhandled RecursionError (DoS) via deeply nested feature-structure input The featstruct parser recurses on nested brackets with no depth limit, so a short, deeply nested string exhausts the stack and raises an uncaught RecursionError.
- NLTK: Uncontrolled resource consumption in RecursiveDescentParser via ambiguous or left-recursive grammars The recursive descent parser explores parses without a bound, so crafted left-recursive or ambiguous grammars exhaust CPU and stack.
- NLTK: Quadratic CPU Exhaustion in `XMLCorpusView._read_xml_fragment()` Each read loop iteration rescans the whole accumulated XML buffer, so a malformed corpus file makes parsing time grow quadratically and exhaust CPU.
- NLTK: Quadratic-time DoS in PorterStemmer via long runs of 'y' A long run of the letter y makes the stemmer's measure routine rescan backwards on every call, so stemming time grows quadratically with token length.
- NLTK TweetTokenizer vulnerable to denial of service through catastrophic regex backtracking Crafted strings of repeated separators make a tokenizer regex backtrack exponentially, so a few kilobytes of text can stall a worker thread for minutes.
- New API: Unauthenticated payment webhooks allow memory and disk DoS via unbounded body reads and full-body logging Unauthenticated payment webhook routes read and log entire request bodies before signature checks, so oversized requests exhaust memory and disk.
- vm2's bufferAllocLimit cap bypassed by Buffer.concat and Buffer.from arrayLike Sandboxed code can allocate unlimited host memory through Buffer.concat and array-like Buffer.from, skipping the configured allocation cap.
- vm2 has Memory Exhaustion DoS via bufferAllocLimit Bypass Allocating memory through ArrayBuffer and typed arrays skips the Buffer size cap added by an earlier fix, letting sandboxed code exhaust host memory.
- Open WebUI: Instance-wide stall via automation recurrence rules that force multi-second parsing Minutely recurrence rules force the parser to enumerate decades of occurrences synchronously on the event loop, stalling the server for every user.
- Natural Language Toolkit (NLTK): ReDoS in NLTK ReviewsCorpusReader FEATURES regex A regex in the reviews corpus reader backtracks quadratically on a long line without brackets, so one crafted line stalls parsing.
- Open WebUI: ReDoS in skill-mention regexes causes whole-instance DoS on default config Skill-mention regexes backtrack quadratically on a long input with an unclosed tag, blocking the single worker's event loop.
- n8n: Prototype Pollution via VM Expression Engine Sandbox Escape Leads to Denial of Service An authenticated user's expression escapes the VM engine through array access, reaches a host built-in and pollutes its prototype, causing denial of service in the main process.
- n8n: Authenticated Users Can Exhaust Temporary Disk Storage via Data-Table File Uploads Repeated data-table uploads each pass the per-request quota because earlier temporary files are not counted, filling the disk until periodic cleanup runs.
- n8n: Prototype Pollution via Dot-Notation Field Names Leads To Instance-Wide Denial of Service A dot-notation field name in the Set node pollutes a shared global used in authentication, causing all authenticated requests to fail.
- vLLM: Speech-to-text upload size limit is enforced after full UploadFile read The speech-to-text upload handlers read the whole file before the documented size limit is checked, so oversized uploads consume memory first.
- Langflow: Unauthenticated DoS through multipart form boundary file upload The upload endpoint parses multipart data before authentication and does not limit extremely long boundaries, tying up the server for all users.
- Langflow: Unauthenticated file upload leads to DoS (space exhaustion) and information leak The upload endpoint accepts unlimited unauthenticated data and returns the absolute server path, enabling disk exhaustion and path disclosure.
- n8n: Denial of Service via ZIP decompression in webhook workflow A small compressed archive sent to a public webhook expands without limits and exhausts the process memory.
- n8n: Microsoft SQL Node Prototype Pollution A crafted table parameter in the Microsoft SQL node pollutes Object.prototype process-wide, breaking the server until restart.
- SGLang is Vulnerable to DoS via the data_hash Function Crafted input to the cache's data hashing routine degrades or halts the cache handler.
- SGLang: Reachable Assertion via lora_path in LoRAManager enables remote Denial of Dervice A malformed lora_path value in an inference request trips an unhandled assertion in the LoRA manager, crashing the serving process.
- vllm has Improper Resource Shutdown or Release Requests to vLLM's OpenAI-compatible serving path trigger a resource release flaw that remote attackers can use to take the server down.