deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-mg36-wvcr-m75h
Package: nuxt-og-image (NPM)
Severity: MODERATE (CVSS 6.1)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: < 6.2.5
Patched in: 6.2.5

Summary: Nuxt OG Image is vulnerable to reflected XSS via query parameter injection into HTML attributes

Details:
**Product:** Nuxt OG Image 
**Version:** 6.1.2
**CWE-ID:** [CWE-79](https://cwe.mitre.org/data/definitions/79.html): Improper Neutralization of Input During Web Page Generation
**Description:** Incorrect parsing of GET parameters leads to the possibility of HTML injection and JavaScript code injection.
**Impact:** Client-Side JavaScript Execution
**Exploitation condition:** An external user
**Mitigation:** Correct the logic of parsing GET parameters and their subsequent implementation into the generated page.
**Researcher:** Dmitry Prokhorov (Positive Technologies)

## Research 
During the analysis of the nuxt-og-image package, which is shipped with the nuxt-seo package, a zero‑day vulnerability was discovered.
This research revealed that the image‑generation component by the URI: `/_og/d/` (and, in older versions, `/og-image/`) contains a vulnerability that allows injection of arbitrary attributes into the HTML page body. The vulnerability was reproduced using the standard configuration and the default templates.


_Listing 1. The content of the configuration file `nuxt.config.ts`_ 
```
export default defineNuxtConfig({
  modules: ['nuxt-og-image'],
  devServer: {
    host: 'web-test.local',
    port: 3000
  },
  site: {
    url: 'http://web-test.local:3000',
  },
  ogImage: {
    fonts: [
      'Inter:400', 
      'Inter:700'
    ],
  }
})
```

## Vulnerability reproduction
To demonstrate the proof‑of‑concept, follow the URI: `/_og/d/og.html?width=1000&height=1000&onmouseover=alert(document.cookie)&autofocus`
The injected parameters `onmouseover=alert(document.cookie)` and `autofocus` are treated as attributes and are inserted directly into the generated HTML page.


_Listing 2. HTTP-request example_
```
GET /_og/d/og.html?width=1000&height=1000&onmouseover=alert(document.cookie) HTTP/1.1
Host: web-test.local:3000
```

_Figure 1. The injected attribute in the HTML body_
<img width="974" height="670" alt="image" src="https://github.com/user-attachments/assets/d442c235-71a5-4da9-a963-8cf4b8614745" />

_Figure 2. JavaScript code execution_
<img width="974" height="291" alt="image" src="https://github.com/user-attachments/assets/01579f19-8e80-4fae-8[PII_REDACTED]ee6d8" />


## Credits
Researcher: Dmitry Prokhorov (Positive Technologies)
GitHub Security Advisory: GHSA-pqhr-mp3f-hrpp
Package: nuxt-og-image (NPM)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-918: Server-Side Request Forgery (SSRF)
Vulnerable versions: < 6.2.5
Patched in: 6.2.5

Summary: Nuxt OG Image vulnerable to Server-Side Request Forgery via user-controlled parameters

Details:
**Product:** Nuxt OG Image
**Version:** < 6.2.5
**CWE-ID:** [CWE-918](https://cwe.mitre.org/data/definitions/918.html): Server-Side Request Forgery

## Description

The image generation endpoint (`/_og/d/`) accepts user-controlled parameters that are passed to the server-side renderer without proper validation or filtering. An attacker can trigger server-side requests to internal network addresses through multiple vectors.

## Impact

- Scanning internal ports and services inaccessible from the outside
- Reading sensitive data from cloud infrastructure metadata services (tokens, credentials) when verbose error output is enabled

## Attack Vectors

Three distinct vectors were identified, all exploiting the same underlying lack of URL validation:

### Vector 1: CSS `background-image` injection via `style` parameter

```
GET /_og/d/og.png?style=background-image:+url('http://127.0.0.1:8888/secret')
```

### Vector 2: `<img src>` injection via `html` parameter

```
GET /_og/d/og.png?html=<img src="http://127.0.0.1:8888/secret">
```

When verbose errors are enabled, the response content is leaked in base64-encoded error messages.

### Vector 3: SVG `<image href>` injection via `html` parameter

```
GET /_og/d/og.png?html=<svg><image href="http://127.0.0.1:8888/secret"></svg>
```

## Mitigation

Fixed in v6.2.5. The image source plugin now blocks requests to private IP ranges (IPv4/IPv6), loopback addresses, link-local addresses, and cloud metadata endpoints. Decimal/hexadecimal IP encoding bypasses are also handled.

## Credits

Researcher: Dmitry Prokhorov (Positive Technologies)
GitHub Security Advisory: GHSA-c7xp-q6q8-hg76
Package: nuxt-og-image (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-400: Uncontrolled Resource Consumption, CWE-404: Improper Resource Shutdown or Release
Vulnerable versions: < 6.2.5
Patched in: 6.2.5

Summary: Nuxt OG Image is vulnerable to Denial of Service via unbounded image dimensions

Details:
**Product:** Nuxt OG Image 
**Version:** 6.1.2
**CWE-ID:** [CWE-404](https://cwe.mitre.org/data/definitions/404.html): Improper Resource Shutdown or Release
**Description:** Failure to limit the length and width of the generated image results in a denial of service.
**Impact:** Denial of service
**Exploitation condition:** An external user
**Mitigation:** Implement a limitation on the width and length of the generated image.
**Researcher:** Dmitry Prokhorov (Positive Technologies)

## Research 
During the analysis of the nuxt-og-image package, which is shipped with the nuxt-seo package, a zero‑day vulnerability was discovered.
This research revealed that the image‑generation component by the URI: `/_og/d/` (and, in older versions, `/og-image/`) contains a Denial of Service (DoS) vulnerability. The issue arises because there is no restriction on the width and height parameters of the generated image. The vulnerability was reproduced using the standard configuration and the default templates.

_Listing 1. The content of the configuration file `nuxt.config.ts`_ 
```
export default defineNuxtConfig({
  modules: ['nuxt-og-image'],
  devServer: {
    host: 'web-test.local',
    port: 3000
  },
  site: {
    url: 'http://web-test.local:3000',
  },
  ogImage: {
    fonts: [
      'Inter:400', 
      'Inter:700'
    ],
  }
})
```

## Vulnerability reproduction
To demonstrate the proof‑of‑concept, a request should be sent with the increased `width` and `height` parameters. This will cause a delay and exhaust the server’s resources during image generation.

_Listing 2. HTTP-request example_
```
GET /_og/d/og.png?width=20000&height=20000 HTTP/1.1
Host: web-test.local:3000
```

_Figure 1. HTTP-response: denial-of-service error_
<img width="974" height="663" alt="image" src="https://github.com/user-attachments/assets/ff625249-2e0d-4a03-a734-3a77fd0cbb81" />

After sending a HTTP-request, the test server's memory was exhausted.

_Figure 2. Video memory exhausted error_
<img width="863" height="1033" alt="image" src="https://github.com/user-attachments/assets/66b5919a-f039-468e-812e-1f709c468287" />


## Credits
Researcher: Dmitry Prokhorov (Positive Technologies)
GitHub Security Advisory: GHSA-9pcj-m5rr-p28g
Package: textract (NPM)
Severity: CRITICAL (CVSS 9.8)
CWE: CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), CWE-94: Improper Control of Generation of Code ('Code Injection')
Vulnerable versions: <= 2.5.0
Patched in: unpatched

Summary: textract is vulnerable to OS Command Injection

Details:
textract through 2.5.0 is vulnerable to OS Command Injection via the file path parameter in multiple extractors. When processing files with malicious filenames, the filePath is passed directly to child_process.exec() in lib/extractors/doc.js, rtf.js, dxf.js, images.js, and lib/util.js with inadequate sanitization
GitHub Security Advisory: GHSA-mvhf-547c-h55r
Package: thumbler (NPM)
Severity: CRITICAL (CVSS 9.8)
CWE: CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection'), CWE-94: Improper Control of Generation of Code ('Code Injection')
Vulnerable versions: <= 1.1.2
Patched in: unpatched

Summary: thumbler allows OS Command Injection

Details:
thumbler through 1.1.2 allows OS command injection via the input, output, time, or size parameter in the thumbnail() function because user input is concatenated into a shell command string passed to child_process.exec() without proper sanitization or escaping.
GitHub Security Advisory: GHSA-464q-cqxq-xhgr
Package: jsrsasign (NPM)
Severity: LOW (CVSS 5.9)
CWE: CWE-369: Divide By Zero
Vulnerable versions: < 11.1.1
Patched in: 11.1.1

Summary: jsrsasign: Division by Zero Allows Invalid JWK Modulus to Cause Deterministic Zero Output in RSA Operations

Details:
Versions of the package jsrsasign before 11.1.1 are vulnerable to Division by zero due to the RSASetPublic/KEYUTIL parsing path in ext/rsa.js and the BigInteger.modPowInt reduction logic in ext/jsbn.js. An attacker can force RSA public-key operations (e.g., verify and encryption) to collapse to deterministic zero outputs and hide “invalid key” errors by supplying a JWK whose modulus decodes to zero.
GitHub Security Advisory: GHSA-8qwj-4jxw-m8jw
Package: jsrsasign (NPM)
Severity: HIGH (CVSS 7.5)
CWE: CWE-681: Incorrect Conversion between Numeric Types
Vulnerable versions: < 11.1.1
Patched in: 11.1.1

Summary: jsrsasign: Negative Exponent Handling Leads to Signature Verification Bypass

Details:
Versions of the package jsrsasign before 11.1.1 are vulnerable to Incorrect Conversion between Numeric Types due to handling negative exponents in ext/jsbn2.js. An attacker can force the computation of incorrect modular inverses and break signature verification by calling modPow with a negative exponent.
GitHub Security Advisory: GHSA-wvqx-v3f6-w8rh
Package: jsrsasign (NPM)
Severity: HIGH (CVSS 7.4)
CWE: CWE-347: Improper Verification of Cryptographic Signature
Vulnerable versions: < 11.1.1
Patched in: 11.1.1

Summary: jsrsasign: DSA signatures or X.509 certificates can be forged via DSA domain-parameter validation in KJUR.crypto.DSA.setPublic

Details:
Versions of the package jsrsasign before 11.1.1 are vulnerable to Improper Verification of Cryptographic Signature via the DSA domain-parameter validation in KJUR.crypto.DSA.setPublic (and the related DSA/X509 verification flow in src/dsa-2.0.js). An attacker can forge DSA signatures or X.509 certificates that X509.verifySignature() accepts by supplying malicious domain parameters such as g=1, y=1, and a fixed r=1, which make the verification equation true for any hash.
GitHub Security Advisory: GHSA-5jx8-q4cp-rhh6
Package: jsrsasign (NPM)
Severity: CRITICAL (CVSS 9.1)
CWE: CWE-1023: Incomplete Comparison with Missing Factors
Vulnerable versions: >= 7.0.0, < 11.1.1
Patched in: 11.1.1

Summary: jsrsasign: Incomplete Comparison Allows DSA Private Key Recovery via Biased Nonce Generation

Details:
Versions of the package jsrsasign from 7.0.0 and before 11.1.1 are vulnerable to Incomplete Comparison with Missing Factors via the getRandomBigIntegerZeroToMax and getRandomBigIntegerMinToMax functions in src/crypto-1.1.js; an attacker can recover the private key by exploiting the incorrect compareTo checks that accept out-of-range candidates and thus bias DSA nonces during signature generation.
GitHub Security Advisory: GHSA-68f8-9mhj-h2mp
Package: openclaw (NPM)
Severity: MODERATE (CVSS 4.3)
CWE: CWE-284: Improper Access Control, CWE-863: Incorrect Authorization
Vulnerable versions: <= 2026.3.23
Patched in: 2026.3.24

Summary: OpenClaw has a Gateway HTTP /v1/models Route Bypasses Operator Read Scope

Details:
> Fixed in OpenClaw 2026.3.24, the current shipping release.

## Summary

The OpenAI-compatible HTTP endpoint `/v1/models` accepts bearer auth but does not enforce operator method scopes.

In contrast, the WebSocket RPC path enforces `operator.read` for `models.list`.

A caller connected with `operator.approvals` (no read scope) is rejected for `models.list` (`missing scope: operator.read`) but can still enumerate model metadata through HTTP `/v1/models`.

Confirmed on current `main` at commit `06de515b6c42816b62ec752e1c221cab67b38501`.

## Details

The WS control-plane path enforces role/scope checks centrally before dispatching methods. For non-admin operators, this includes required method scopes such as `operator.read` for `models.list`.

The HTTP compatibility path for `/v1/models` performs bearer authorization and then returns model metadata; it does not apply an equivalent scope check.

As reproduced, a caller with only `operator.approvals` can:

1. connect successfully,
2. fail `models.list` over WS with `missing scope: operator.read`,
3. fetch `/v1/models` over HTTP with status 200 and model data.

This is a cross-surface authorization inconsistency where the stricter WS policy can be bypassed via HTTP.

## Impact

- Callers lacking `operator.read` can still enumerate gateway model metadata through HTTP compatibility routes.
- Breaks scope model consistency between WS RPC and HTTP surfaces.
- Weakens least-privilege expectations for operators granted non-read scopes.

## Patch Suggestion

### 1) Enforce read scope on `/v1/models` routes

Apply a scope gate equivalent to `models.list` before serving `/v1/models` or `/v1/models/:id`.

### 2) Reuse centralized scope-authorization helper for HTTP compatibility endpoints

Use the same operator scope logic used by WS dispatch (`authorizeOperatorScopesForMethod(...)`) to prevent policy drift.

### 3) Add regression tests

Keep this PoC and add explicit negative/positive controls:

- `operator.approvals` without read is rejected on HTTP `/v1/models`.
- `operator.read` is accepted on both WS `models.list` and HTTP `/v1/models`.

## Credit

Reported by @zpbrent.
GitHub Security Advisory: GHSA-q3p6-g7c4-829c
Package: parse-server (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-346: Origin Validation Error
Vulnerable versions: >= 3.5.0, < 8.6.66
Patched in: 8.6.66

Summary: GraphQL API endpoint ignores CORS origin restriction

Details:
### Impact

The GraphQL API endpoint does not respect the `allowOrigin` server option and unconditionally allows cross-origin requests from any website. This bypasses origin restrictions that operators configure to control which websites can interact with the Parse Server API. The REST API correctly enforces the configured `allowOrigin` restriction.

### Patches

The GraphQL API endpoint now uses the same CORS middleware as the REST API, ensuring the `allowOrigin` and `allowHeaders` server options are consistently enforced across all endpoints.

### Workarounds

There is no known workaround other than upgrading.

### Resources

- GitHub security advisory: https://github.com/parse-community/parse-server/security/advisories/GHSA-q3p6-g7c4-829c
- Fix Parse Server 9: https://github.com/parse-community/parse-server/pull/10334
- Fix Parse Server 8: https://github.com/parse-community/parse-server/pull/10335
GitHub Security Advisory: GHSA-q3p6-g7c4-829c
Package: parse-server (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-346: Origin Validation Error
Vulnerable versions: >= 9.0.0, < 9.7.0-alpha.10
Patched in: 9.7.0-alpha.10

Summary: GraphQL API endpoint ignores CORS origin restriction

Details:
### Impact

The GraphQL API endpoint does not respect the `allowOrigin` server option and unconditionally allows cross-origin requests from any website. This bypasses origin restrictions that operators configure to control which websites can interact with the Parse Server API. The REST API correctly enforces the configured `allowOrigin` restriction.

### Patches

The GraphQL API endpoint now uses the same CORS middleware as the REST API, ensuring the `allowOrigin` and `allowHeaders` server options are consistently enforced across all endpoints.

### Workarounds

There is no known workaround other than upgrading.

### Resources

- GitHub security advisory: https://github.com/parse-community/parse-server/security/advisories/GHSA-q3p6-g7c4-829c
- Fix Parse Server 9: https://github.com/parse-community/parse-server/pull/10334
- Fix Parse Server 8: https://github.com/parse-community/parse-server/pull/10335
GitHub Security Advisory: GHSA-m983-v2ff-wq65
Package: parse-server (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-362: Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')
Vulnerable versions: < 8.6.65
Patched in: 8.6.65

Summary: LiveQuery protected field leak via shared mutable state across concurrent subscribers

Details:
### Impact

When multiple clients subscribe to the same class via LiveQuery, the event handlers process each subscriber concurrently using shared mutable objects. The sensitive data filter modifies these shared objects in-place, so when one subscriber's filter removes a protected field, subsequent subscribers may receive the already-filtered object. This can cause protected fields and authentication data to leak to clients that should not see them, or cause clients that should see the data to receive an incomplete object.

Additionally, when an afterEvent Cloud Code trigger is registered, one subscriber's trigger modifications can leak to other subscribers through the same shared mutable state.

Any Parse Server deployment using LiveQuery with protected fields or afterEvent triggers is affected when multiple clients subscribe to the same class.

### Patches

The fix deep-clones the shared objects at the start of each subscriber's processing callback, ensuring each subscriber works on an independent copy. Additionally, a bug was fixed where master key LiveQuery clients could not receive events on classes with protected fields due to an incorrect type passed to the sensitive data filter.

### Workarounds

There is no known workaround.

### Resources

- GitHub security advisory: https://github.com/parse-community/parse-server/security/advisories/GHSA-m983-v2ff-wq65
- Fix Parse Server 9: https://github.com/parse-community/parse-server/pull/10330
- Fix Parse Server 8: https://github.com/parse-community/parse-server/pull/10331
GitHub Security Advisory: GHSA-m983-v2ff-wq65
Package: parse-server (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-362: Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')
Vulnerable versions: >= 9.0.0, < 9.7.0-alpha.9
Patched in: 9.7.0-alpha.9

Summary: LiveQuery protected field leak via shared mutable state across concurrent subscribers

Details:
### Impact

When multiple clients subscribe to the same class via LiveQuery, the event handlers process each subscriber concurrently using shared mutable objects. The sensitive data filter modifies these shared objects in-place, so when one subscriber's filter removes a protected field, subsequent subscribers may receive the already-filtered object. This can cause protected fields and authentication data to leak to clients that should not see them, or cause clients that should see the data to receive an incomplete object.

Additionally, when an afterEvent Cloud Code trigger is registered, one subscriber's trigger modifications can leak to other subscribers through the same shared mutable state.

Any Parse Server deployment using LiveQuery with protected fields or afterEvent triggers is affected when multiple clients subscribe to the same class.

### Patches

The fix deep-clones the shared objects at the start of each subscriber's processing callback, ensuring each subscriber works on an independent copy. Additionally, a bug was fixed where master key LiveQuery clients could not receive events on classes with protected fields due to an incorrect type passed to the sensitive data filter.

### Workarounds

There is no known workaround.

### Resources

- GitHub security advisory: https://github.com/parse-community/parse-server/security/advisories/GHSA-m983-v2ff-wq65
- Fix Parse Server 9: https://github.com/parse-community/parse-server/pull/10330
- Fix Parse Server 8: https://github.com/parse-community/parse-server/pull/10331
GitHub Security Advisory: GHSA-5mx2-2mgw-x8rm
Package: openclaw (NPM)
Severity: MODERATE (CVSS 4.8)
CWE: CWE-306: Missing Authentication for Critical Function
Vulnerable versions: < 2026.2.21
Patched in: 2026.2.21

Summary: OpenClaw: BlueBubbles beta plugin webhook auth hardening (remove passwordless fallback)

Details:
### Summary
BlueBubbles webhook auth in the optional beta iMessage plugin allowed a passwordless fallback path. In some reverse-proxy/local routing setups, this could allow unauthenticated webhook events.

### Affected Component and Scope
- Component: `extensions/bluebubbles` webhook handler
- Scope: only deployments using the optional BlueBubbles plugin where webhook password auth was not configured for incoming webhook events

### Affected Packages / Versions
- Package: `openclaw/openclaw` (npm)
- Latest published npm version at triage time (2026-02-21): `2026.2.19-2`
- Affected structured range: `<=2026.2.19-2`
- Fixed on `main`; planned patched release: `2026.2.21` (`>=2026.2.21`)

### Details
The vulnerable implementation had multiple auth branches, including a passwordless fallback with loopback/proxy heuristics.

The fix now uses one authentication codepath:
- inbound webhook token/guid must match `channels.bluebubbles.password`
- webhook target matching is consolidated to shared plugin-sdk logic
- BlueBubbles config validation now requires `password` when `serverUrl` is set

### Impact
BlueBubbles is an optional beta iMessage plugin, and onboarding/channel-add flows already require a password. Practical exposure is mainly custom/manual configurations that omitted webhook password authentication.

### Remediation
- Upgrade to a release that includes this patch (`>=2026.2.21`, planned).
- Ensure BlueBubbles webhook delivery includes a matching password (`?password=<password>` or `x-password`).

### Fix Commit(s)
- `6b2f2811dc623e5faaf2f76afaa[PII_REDACTED]590`
- `283029bdea23164ab7482b320cb420d1b90df806`

### Release Process Note
`patched_versions` is pre-set to the planned next release (`2026.2.21`) so once npm release is out, advisory publish can proceed without additional ticket edits.

OpenClaw thanks @zpbrent for reporting.
GitHub Security Advisory: GHSA-hggm-x7r9-mm7v
Package: openclaw (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: <= 2026.3.23
Patched in: 2026.03.28

Summary: OpenClaw is vulnerable to Path Traversal through path validation bypass

Details:
OpenClaw through 2026.3.23 (fixed in commit 4797bbc) contains a path traversal vulnerability in media parsing that allows attackers to read arbitrary files by bypassing path validation in the isLikelyLocalPath() and isValidMedia() functions. Attackers can exploit incomplete validation and the allowBareFilename bypass to reference files outside the intended application sandbox, resulting in disclosure of sensitive information including system files, environment files, and SSH keys.
GitHub Security Advisory: GHSA-w8q8-93cx-6h7r
Package: jsrsasign (NPM)
Severity: HIGH (CVSS 8.7)
CWE: CWE-325: Missing Cryptographic Step
Vulnerable versions: < 11.1.1
Patched in: 11.1.1

Summary: jsrsasign: Missing cryptographic validation during DSA signing enables private key extraction

Details:
Versions of the package jsrsasign before 11.1.1 are vulnerable to Missing Cryptographic Step via the KJUR.crypto.DSA.signWithMessageHash process in the DSA signing implementation. An attacker can recover the private key by forcing r or s to be zero, so the library emits an invalid signature without retrying, and then solves for x from the resulting signature.
GitHub Security Advisory: GHSA-8g7p-jf3g-gxcp
Package: jsrsasign (NPM)
Severity: HIGH (CVSS 7.5)
CWE: CWE-835: Loop with Unreachable Exit Condition ('Infinite Loop')
Vulnerable versions: < 11.1.1
Patched in: 11.1.1

Summary: jsrsasign is vulnerable to DoS through Infinite Loop when processing zero or negative inputs

Details:
Versions of the package jsrsasign before 11.1.1 are vulnerable to Infinite loop via the bnModInverse function in ext/jsbn2.js when the BigInteger.modInverse implementation receives zero or negative inputs, allowing an attacker to hang the process permanently by supplying such crafted values (e.g., modInverse(0, m) or modInverse(-1, m)).