Byamb4

GeoNode is a geospatial content management system used for managing and publishing geospatial data. A low-privileged remote user can execute arbitrary operating-system commands on the server by uploading a vector file with a crafted layer name that allows for the injection of shell syntax.

A Denial of Service issue exists when using diskStorage. Aborted or malformed multipart uploads leave orphaned partial files on disk because the `Readable.pipe()` call does not propagate the stream destroy signal to the underlying `fs.WriteStream`. This allows an attacker to exhaust disk space by triggering numerous aborted uploads.

Handlebars is a templating engine that allows users to build semantic templates. Versions 4.0.0 through 4.7.8 contain a flaw in the `resolvePartial()` function within the Handlebars runtime. This function resolves partial names using a property lookup on `options.partials` without preventing prototype chain traversal. If `Object.prototype` is polluted with a string value matching a partial reference in a template, the polluted string is used as the partial body and rendered without HTML escaping, potentially leading to reflected or stored cross-site scripting (XSS).

Picomatch, a JavaScript glob matcher, contains a flaw where specially crafted POSIX bracket expressions, such as `[[:constructor:]]`, can inject inherited method names into generated regular expressions due to the `POSIX REGEX SOURCE` object inheriting from `Object.prototype`. This results in incorrect glob matching, potentially causing security-relevant logic errors in applications that rely on glob matching for filtering, validation, or access control. The issue does not allow for remote code execution. The vulnerability affects users of affected `picomatch` versions processing untrusted or user-controlled glob patterns.

Picomatch, a glob matcher written in JavaScript, is susceptible to Regular Expression Denial of Service (ReDoS) when processing crafted extglob patterns. Specific patterns utilizing extglob quantifiers like `+()` and `*()`, particularly when combined with overlapping alternatives or nested extglobs, can be compiled into regular expressions that exhibit catastrophic backtracking on non-matching input. Applications allowing untrusted users to supply glob patterns to `picomatch` for compilation or matching are at risk. An attacker can potentially cause excessive CPU consumption and disrupt the Node.js event loop, leading to a denial of service. Applications using only trusted, developer-controlled glob patterns are less likely to be affected.

music-metadata is a metadata parser for audio and video media files. The ASF parser within music-metadata, specifically the `parseExtensionObject()` function in `lib/asf/AsfParser.ts:112-158`, can enter an infinite loop when processing an ASF Header Extension Object containing a sub-object with `objectSize` equal to 0. This occurs because the `ignore()` function within the tokenizer accepts negative values without validation, leading to a continuous re-reading of a 24-byte header. The affected methods are `parseFile()` and `parseBuffer()`. An estimated 2.2 million weekly npm downloads are potentially impacted. A crafted 100-byte .asf file can cause applications using `parseFile()` or `parseBuffer()` to hang indefinitely. The `parseStream()` function is not affected as it uses a different `ignore()` implementation that throws a RangeError.

file-type detects the file type of a file, stream, or data. A crafted ZIP file can trigger excessive memory growth during type detection when using the `fileTypeFromBuffer()`, `fileTypeFromBlob()`, or `fileTypeFromFile()` APIs. The ZIP inflate output limit is enforced for stream-based detection, but not for known-size inputs. This allows a small compressed ZIP file to cause file-type to inflate and process a much larger payload while probing ZIP-based formats such as OOXML. This is an availability issue, potentially causing applications to consume large amounts of memory, become slow, or crash. The issue stems from different limits being applied to ZIP detection based on whether the tokenizer had a known file size. For known-size inputs, `Number.MAX SAFE INTEGER` was used instead of a more appropriate limit, allowing a crafted ZIP to bypass the intended inflate limit. A ZIP file of approximately 255 KB can cause about 257 MB of RSS growth during `fileTypeFromBuffer()` on version 21.3.1. The affected APIs are `fileTypeFromBuffer()`, `fileTypeFromBlob()`, and `fileTypeFromFile()`.

Locutus is a JavaScript library that aims to bring standard libraries from other programming languages to JavaScript for educational purposes. The `create function(args, code)` function in versions prior to 3.0.14 passes both parameters directly to the `Function` constructor without any sanitization. This allows for arbitrary code execution. The issue resides in the `src/php/funchand/create function.ts` file, specifically at line 17, where `new Function(...params, code)` is used without input validation. An attacker who can control either argument to `create function()` can achieve full remote code execution (RCE). Approximately 597,000 weekly npm downloads are potentially affected. A proof-of-concept (PoC) demonstrates the ability to execute system commands using `require("child process").execSync("id")` through the vulnerable function. This issue is distinct from CVE-2026-29091, which involved `call user func array` using `eval()` in older versions.

flatted is a circular JSON parser. The `parse()` function uses a recursive `revive()` phase to resolve circular references in deserialized JSON. When provided with a crafted payload containing deeply nested or self-referential `$` indices, the recursion depth becomes unbounded, leading to a stack overflow and crashing the Node.js process. This can result in a Denial of Service (DoS). The software has approximately 87 million weekly npm downloads and is used in many caching and logging libraries. The issue is triggered by passing untrusted input to the `flatted.parse()` function. A proof of concept demonstrates building a deeply nested circular reference chain to cause a stack overflow. The vulnerable component is the `parse()` function, which utilizes the `revive()` function.

A flaw in callback URL validation allowed crafted `redirect uri` values containing URL userinfo (`@`) to bypass legitimate callback pattern checks. If an attacker can trick a user into opening a malicious authorization link, the authorization code may be redirected to an attacker-controlled host. This issue affects an OpenID Connect (OIDC) provider, allowing users to authenticate with passkeys.

The webhook URL validation in `plane/app/serializers/webhook.py` only checks if the IP address is loopback, allowing attackers with workspace ADMIN role to create webhooks pointing to private or internal network addresses such as `10.x.x.x`, `172.16.x.x`, `192.168.x.x`, and `169.254.169.254`. When webhook events are triggered, the server sends requests to these internal addresses and stores the response, enabling Server-Side Request Forgery (SSRF) with full response read-back. This can lead to cloud metadata exfiltration, internal service scanning, and data exfiltration via response logs.

SVGO is susceptible to a denial-of-service issue stemming from improper handling of XML custom entities. Specifically, the software does not adequately protect against entity expansion or recursion. A small, maliciously crafted XML file (approximately 811 bytes) can cause the application to stall or crash due to excessive memory consumption, resulting in a JavaScript heap out of memory error. The issue arises because SVGO utilizes an upstream XML parser that, by default, does not interpret custom XML entities. SVGO modifies the parser to support entities declared in the DOCTYPE, but this introduces the risk of exponential expansion when entities reference each other. This can be triggered when processing untrusted SVG input, potentially impacting server-side applications.

The software contains a flaw where routine detail action endpoints check a cache before verifying object ownership using `self.get object()`. Cache keys are scoped only by the primary key (`pk`) and do not include the user ID. This allows an attacker to retrieve cached responses for a routine's primary key without proper authorization, if the victim has previously accessed the routine via the API. The affected **API endpoints** are: '/api/v2/routine/{pk}/date-sequence-display/', '/api/v2/routine/{pk}/date-sequence-gym/', '/api/v2/routine/{pk}/structure/', '/api/v2/routine/{pk}/logs/', and '/api/v2/routine/{pk}/stats/'. The vulnerable variable used in the cache key construction is `routine id`. An attacker can potentially retrieve another user's routine details, including workout day sequences, exercise structure, training logs, and statistics, from the cache without ownership verification. The cache time-to-live (TTL) is one month.

wger is a free, open-source workout and fitness manager. Versions up to and including 2.4 improperly handle user data retrieval. The `RepetitionsConfigViewSet` and `MaxRepetitionsConfigViewSet` API endpoints return all users' repetition configuration data because the `get queryset()` function calls `.all()` instead of filtering by the authenticated user (`user`). This allows any registered user to enumerate the workout structure of every other user. The API endpoints involved are `RepetitionsConfigViewSet` and `MaxRepetitionsConfigViewSet`. The vulnerable function is `get queryset()`.

wger is a free, open-source workout and fitness manager. An issue exists where three `nutritional values` action endpoints bypass user-scoped querysets via a raw ORM call, specifically `Model.objects.get(pk=pk)`. This allows any authenticated user to access another user's private nutrition plan data, including caloric intake and macro breakdown, by providing an arbitrary primary key (`pk`). The issue was addressed in commit 29876a1954fe959e4b58ef070170e81703dab60e.

Parse Dashboard, a standalone dashboard for managing Parse Server apps, contains security issues in the AI Agent API endpoint (`/apps/:appId/agent`). Versions 7.3.0-alpha.42 through 9.0.0-alpha.7 are affected by multiple vulnerabilities that, when combined, could allow attackers without authentication to perform arbitrary read and write operations on any connected Parse Server database using the master key. The agent feature must be enabled for the dashboard to be affected. The issue stems from a lack of authentication, Cross-Site Request Forgery (CSRF) validation, and per-app authorization on the agent endpoint. A cache key collision between the master key and read-only master key also contributed to the problem.

Parse Dashboard, a standalone dashboard for managing Parse Server apps, contains an issue where the AI Agent API endpoint (`POST /apps/:appId`) lacks proper authorization checks. Authenticated users with access to specific applications can access the agent endpoint of any other application by modifying the `appId` in the URL. Read-only users are granted the full master key instead of the read-only master key, enabling them to perform write and delete operations by including write permissions in the request body. Only dashboards with the `agent` configuration enabled are affected.

Manyfold is a self-hosted web application used for managing 3D models, with a focus on 3D printing. Prior to version 0.133.0, a logged-in user could achieve Remote Code Execution (RCE) when model render generation is enabled. This occurs by uploading a ZIP archive containing a file with a shell metacharacter in its filename. The filename is then passed to a Ruby backtick call without proper sanitization. The vulnerable component is the handling of filenames during ZIP archive processing. The `filename` variable is used in a Ruby backtick call.

Karakeep is an elf-hostable bookmark-everything app. Version 0.30.0 does not properly sanitize HTML content received from the Reddit metascraper plugin. Specifically, when the plugin returns `readableContentHtml`, the application directly uses this content in the HTML parsing subprocess without running it through DOMPurify. This unsanitized content is then injected into the application’s Document Object Model (DOM) via React’s `dangerouslySetInnerHTML`, potentially allowing malicious HTML to be executed in a user’s browser.

InvenTree is an Open Source Inventory Management System. Prior to version 1.2.3, insecure server-side templates can be hijacked to expose secure information to the client. When generating custom batch codes, the InvenTree server uses a customizable jinja2 template, which can be modified by a staff user to exfiltrate sensitive information or perform code execution on the server. This issue requires access by a user with staff permissions, followed by a request to generate a custom batch code via the API. Once the template has been modified maliciously, the API call to generate a new batch code could be made by other users, and the template code will be executed with their user context. The batch code template is a configurable global setting which can be adjusted by any user with staff access. The vulnerable API endpoint is used to generate a new batch code. The vulnerable parameters are those used to customize the jinja2 template.