deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-w48f-fwg7-ww6p
Package: @stablelib/cbor (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-1321: Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')
Vulnerable versions: < 2.0.3
Patched in: 2.0.3

Summary: @stablelib/cbor: Prototype poisoning via `__proto__` map keys in CBOR decoding

Details:
### Summary

`@stablelib/cbor` decodes CBOR maps into ordinary JavaScript objects and assigns attacker-controlled keys directly onto those objects. A CBOR map key named `__proto__` therefore changes the prototype of the decoded object instead of becoming an ordinary data property.

### Details

The decoder builds map results with a plain `{}` and then stores attacker-controlled keys using bracket assignment.

That is unsafe for special property names. In JavaScript, assigning to `obj["__proto__"]` on a normal object does not create a plain own property. It invokes the built-in `__proto__` setter and replaces the object’s prototype if the supplied value is an object or `null`.

As a result, a CBOR payload containing a map entry like:

* key: `"__proto__"`
* value: `{ isAdmin: true }`

does not decode to an object with an own property called `__proto__`. It decodes to an object whose prototype is now attacker-controlled. Any code that later reads properties through normal lookup will see inherited attacker-supplied values.

### PoC

```js
import { decode } from "@stablelib/cbor";

// CBOR:
// {
//   "__proto__": { "isAdmin": true }
// }
//
// a1                    map(1)
//   69                  text(9)
//     "__proto__"
//   a1                  map(1)
//     67                text(7)
//       "isAdmin"
//     f5                true

const payload = new Uint8Array([
  0xa1,
  0x69, 0x5f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x5f,
  0xa1,
  0x67, 0x69, 0x73, 0x41, 0x64, 0x6d, 0x69, 0x6e,
  0xf5
]);

const obj = decode(payload);

console.log(Object.hasOwn(obj, "isAdmin")); // false
console.log(obj.isAdmin);                   // true
console.log(Object.getPrototypeOf(obj).isAdmin); // true
```

### Impact

Any application that decodes untrusted CBOR into JavaScript objects can receive objects with attacker-controlled prototypes.

In practice, that can corrupt configuration objects, influence authorization checks, alter feature flags, and break application logic that relies on normal property lookup instead of strict own-property checks. If the decoded object is later merged into other objects, the impact can spread further.

### Solution

Upgrade to version 2.0.4.
GitHub Security Advisory: GHSA-jg4p-7fhp-p32p
Package: @hapi/content (NPM)
Severity: HIGH (CVSS 7.5)
CWE: CWE-1333: Inefficient Regular Expression Complexity
Vulnerable versions: <= 6.0.0
Patched in: 6.0.1

Summary: @hapi/content: Regular Expression Denial of Service (ReDoS) in HTTP header parsing

Details:
All versions of `@hapi/content` through 6.0.0 are vulnerable to Regular Expression Denial of Service (ReDoS) via crafted HTTP header values. Three regular expressions used to parse `Content-Type` and `Content-Disposition` headers contain patterns susceptible to catastrophic backtracking. This has been fixed in v6.0.1.

### Impact

Denial of Service. An unauthenticated remote attacker can cause a Node.js process to become unresponsive by sending a single HTTP request with a maliciously crafted header value.

### Patches

Fixed by tightening all three regular expressions to eliminate backtracking.

### Workarounds

There are no known workarounds. Upgrade to the patched version.
GitHub Security Advisory: GHSA-vr5f-2r24-w5hc
Package: parse-server (NPM)
Severity: LOW (CVSS 0.0)
CWE: CWE-436: Interpretation Conflict
Vulnerable versions: <= 8.6.72
Patched in: 8.6.73

Summary: Parse Server: File upload Content-Type override via extension mismatch

Details:
### Impact

A file can be uploaded with a filename extension that passes the file extension allowlist (e.g., `.txt`) but with a `Content-Type` header that differs from the extension (e.g., `text/html`). The `Content-Type` is passed to the storage adapter without consistency validation. Storage adapters that store and serve the provided Content-Type (such as S3 or GCS) serve the file with the mismatched Content-Type. The default GridFS adapter is not affected because it derives Content-Type from the filename at serving time.

### Patches

The file upload now derives the Content-Type from the filename extension, overriding any user-provided Content-Type when the file has an extension.

### Workarounds

Configure the storage adapter or CDN to derive Content-Type from the filename extension instead of using the stored Content-Type.
GitHub Security Advisory: GHSA-vr5f-2r24-w5hc
Package: parse-server (NPM)
Severity: LOW (CVSS 0.0)
CWE: CWE-436: Interpretation Conflict
Vulnerable versions: >= 9.0.0, < 9.7.1-alpha.4
Patched in: 9.7.1-alpha.4

Summary: Parse Server: File upload Content-Type override via extension mismatch

Details:
### Impact

A file can be uploaded with a filename extension that passes the file extension allowlist (e.g., `.txt`) but with a `Content-Type` header that differs from the extension (e.g., `text/html`). The `Content-Type` is passed to the storage adapter without consistency validation. Storage adapters that store and serve the provided Content-Type (such as S3 or GCS) serve the file with the mismatched Content-Type. The default GridFS adapter is not affected because it derives Content-Type from the filename at serving time.

### Patches

The file upload now derives the Content-Type from the filename extension, overriding any user-provided Content-Type when the file has an extension.

### Workarounds

Configure the storage adapter or CDN to derive Content-Type from the filename extension instead of using the stored Content-Type.
GitHub Security Advisory: GHSA-2gmp-34j9-fqjm
Package: replicator (NPM)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-502: Deserialization of Untrusted Data
Vulnerable versions: <= 1.0.5
Patched in: unpatched

Summary: Replicator deserializes untrusted user input

Details:
An unauthenticated Remote Code Execution (RCE) vulnerability exists in applications that use the Replicator node package manager (npm) version 1.0.5 to deserialize untrusted user input and execute the resulting object.
GitHub Security Advisory: GHSA-hm7r-c7qw-ghp6
Package: fast-jwt (NPM)
Severity: HIGH (CVSS 7.5)
CWE: CWE-345: Insufficient Verification of Data Authenticity, CWE-636: Not Failing Securely ('Failing Open')
Vulnerable versions: <= 6.1.0
Patched in: unpatched

Summary: fast-jwt accepts unknown `crit` header extensions (RFC 7515 violation)

Details:
## Summary

`fast-jwt` does not validate the `crit` (Critical) Header Parameter defined in RFC 7515 §4.1.11. When a JWS token contains a `crit` array listing extensions that `fast-jwt` does not understand, the library accepts the token instead of rejecting it. This violates the **MUST** requirement in the RFC.

---

## RFC Requirement

RFC 7515 §4.1.11:

> If any of the listed extension Header Parameters are **not understood
> and supported** by the recipient, then the **JWS is invalid**.

---

## Proof of Concept

```javascript
const { createSigner, createVerifier } = require("fast-jwt"); // v3.3.3

const signer = createSigner({ key: "secret", algorithm: "HS256" });
const token = signer({
  sub: "attacker",
  role: "admin",
  header: { crit: ["x-custom-policy"], "x-custom-policy": "require-mfa" },
});

// Should REJECT — x-custom-policy is not understood
const verifier = createVerifier({ key: "secret", algorithms: ["HS256"] });
try {
  const result = verifier(token);
  console.log("ACCEPTED:", result);
  // Output: ACCEPTED: { sub: 'attacker', role: 'admin' }
} catch (e) {
  console.log("REJECTED:", e.message);
}
```

**Expected:** Error — unsupported critical extension
**Actual:** Token accepted.

### Comparison

```javascript
// jose (panva) v4+ — correctly rejects
const jose = require("jose");
await jose.jwtVerify(token, new TextEncoder().encode("secret"));
// throws: Extension Header Parameter "x-custom-policy" is not recognized
```

---

## Impact

- **Split-brain verification** in mixed-library environments
- **Security policy bypass** when `crit` carries enforcement semantics
- **Token binding bypass** (RFC 7800 `cnf` confirmation)
- See CVE-2025-59420 for full impact analysis

---

## Suggested Fix

In `src/verifier.js`, add crit validation after header decoding:

```javascript
const SUPPORTED_CRIT = new Set(["b64"]);

function validateCrit(header) {
  if (!header.crit) return;
  if (!Array.isArray(header.crit) || header.crit.length === 0)
    throw new Error("crit must be a non-empty array");
  for (const ext of header.crit) {
    if (!SUPPORTED_CRIT.has(ext))
      throw new Error(`Unsupported critical extension: ${ext}`);
    if (!(ext in header))
      throw new Error(`Critical extension ${ext} not present in header`);
  }
}
```
GitHub Security Advisory: GHSA-gjw9-34gf-rp6m
Package: @budibase/server (NPM)
Severity: HIGH (CVSS 8.8)
CWE: CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')
Vulnerable versions: < 3.33.4
Patched in: 3.33.4

Summary: Budibase: Command Injection in Bash Automation Step

Details:
**Location**: `packages/server/src/automations/steps/bash.ts`  

#### Description
The bash automation step executes user-provided commands using `execSync` without proper sanitization or validation. User input is processed through `processStringSync` which allows template interpolation, potentially allowing arbitrary command execution.

#### Code Reference
```21:28:packages/server/src/automations/steps/bash.ts
    const command = processStringSync(inputs.code, context)

    let stdout,
      success = true
    try {
      stdout = execSync(command, {
        timeout: environment.QUERY_THREAD_TIMEOUT,
      }).toString()
```

#### Attack Vector
An attacker with access to create or modify automations can inject malicious shell commands by including template syntax that evaluates to command injection payloads (e.g., `$(rm -rf /)`, `; malicious-command`, `| malicious-command`).

#### Impact
- Remote code execution (RCE)
- Complete system compromise
- Data exfiltration
- Lateral movement within the infrastructure

#### Recommendation
1. **Immediate**: Disable bash automation step in production until fixed
2. Implement a whitelist of allowed commands
3. Use parameterized command execution with proper escaping
4. Implement command argument validation
5. Consider using a restricted shell or command sandboxing
6. Add rate limiting and monitoring for command execution

#### Example Fix
```typescript
import { spawn } from "child_process"

// Validate against whitelist
const ALLOWED_COMMANDS = ["echo", "date", "pwd"] // Extend as needed

function sanitizeCommand(input: string): string {
  // Remove dangerous characters and command chaining
  return input.replace(/[;&|`$(){}[\]]/g, "").trim()
}

function validateCommand(cmd: string): boolean {
  const parts = cmd.split(/\s+/)
  return ALLOWED_COMMANDS.includes(parts[0])
}

export async function run({ inputs, context }) {
  if (!inputs.code) {
    return { stdout: "Budibase bash automation failed: Invalid inputs" }
  }

  const processedCommand = processStringSync(inputs.code, context)
  const sanitized = sanitizeCommand(processedCommand)
  
  if (!validateCommand(sanitized)) {
    return {
      success: false,
      stdout: "Command not allowed"
    }
  }

  // Use spawn instead of execSync with proper argument handling
  return new Promise((resolve) => {
    const [command, ...args] = sanitized.split(/\s+/)
    const proc = spawn(command, args, {
      timeout: environment.QUERY_THREAD_TIMEOUT,
    })
    
    let stdout = ""
    proc.stdout.on("data", (data) => { stdout += data })
    proc.on("close", (code) => {
      resolve({ stdout, success: code === 0 })
    })
  })
}
```
GitHub Security Advisory: GHSA-8x5q-pvf5-64mp
Package: electron (NPM)
Severity: LOW (CVSS 2.3)
CWE: CWE-416: Use After Free
Vulnerable versions: >= 42.0.0-alpha.1, < 42.0.0-alpha.5
Patched in: 42.0.0-alpha.5

Summary: Electron: Use-after-free in offscreen shared texture release() callback

Details:
### Impact
Apps that use offscreen rendering with GPU shared textures may be vulnerable to a use-after-free. Under certain conditions, the `release()` callback provided on a `paint` event texture can outlive its backing native state, and invoking it after that point dereferences freed memory in the main process, which may lead to a crash or memory corruption.

Apps are only affected if they use offscreen rendering with `webPreferences.offscreen: { useSharedTexture: true }`. Apps that do not enable shared-texture offscreen rendering are not affected.

### Workarounds
Ensure `texture.release()` is called promptly after the texture has been consumed, before the texture object becomes unreachable.

### Fixed Versions
* `42.0.0-alpha.5`
* `41.1.0`
* `40.8.5`
* `39.8.5`

### For more information
If there are any questions or comments about this advisory, send an email to [security@electronjs.org](mailto:security@electronjs.org)
GitHub Security Advisory: GHSA-8x5q-pvf5-64mp
Package: electron (NPM)
Severity: LOW (CVSS 2.3)
CWE: CWE-416: Use After Free
Vulnerable versions: >= 41.0.0-alpha.1, < 41.1.0
Patched in: 41.1.0

Summary: Electron: Use-after-free in offscreen shared texture release() callback

Details:
### Impact
Apps that use offscreen rendering with GPU shared textures may be vulnerable to a use-after-free. Under certain conditions, the `release()` callback provided on a `paint` event texture can outlive its backing native state, and invoking it after that point dereferences freed memory in the main process, which may lead to a crash or memory corruption.

Apps are only affected if they use offscreen rendering with `webPreferences.offscreen: { useSharedTexture: true }`. Apps that do not enable shared-texture offscreen rendering are not affected.

### Workarounds
Ensure `texture.release()` is called promptly after the texture has been consumed, before the texture object becomes unreachable.

### Fixed Versions
* `42.0.0-alpha.5`
* `41.1.0`
* `40.8.5`
* `39.8.5`

### For more information
If there are any questions or comments about this advisory, send an email to [security@electronjs.org](mailto:security@electronjs.org)
GitHub Security Advisory: GHSA-8x5q-pvf5-64mp
Package: electron (NPM)
Severity: LOW (CVSS 2.3)
CWE: CWE-416: Use After Free
Vulnerable versions: >= 40.0.0-alpha.1, < 40.8.5
Patched in: 40.8.5

Summary: Electron: Use-after-free in offscreen shared texture release() callback

Details:
### Impact
Apps that use offscreen rendering with GPU shared textures may be vulnerable to a use-after-free. Under certain conditions, the `release()` callback provided on a `paint` event texture can outlive its backing native state, and invoking it after that point dereferences freed memory in the main process, which may lead to a crash or memory corruption.

Apps are only affected if they use offscreen rendering with `webPreferences.offscreen: { useSharedTexture: true }`. Apps that do not enable shared-texture offscreen rendering are not affected.

### Workarounds
Ensure `texture.release()` is called promptly after the texture has been consumed, before the texture object becomes unreachable.

### Fixed Versions
* `42.0.0-alpha.5`
* `41.1.0`
* `40.8.5`
* `39.8.5`

### For more information
If there are any questions or comments about this advisory, send an email to [security@electronjs.org](mailto:security@electronjs.org)
GitHub Security Advisory: GHSA-8x5q-pvf5-64mp
Package: electron (NPM)
Severity: LOW (CVSS 2.3)
CWE: CWE-416: Use After Free
Vulnerable versions: >= 33.0.0-alpha.1, < 39.8.5
Patched in: 39.8.5

Summary: Electron: Use-after-free in offscreen shared texture release() callback

Details:
### Impact
Apps that use offscreen rendering with GPU shared textures may be vulnerable to a use-after-free. Under certain conditions, the `release()` callback provided on a `paint` event texture can outlive its backing native state, and invoking it after that point dereferences freed memory in the main process, which may lead to a crash or memory corruption.

Apps are only affected if they use offscreen rendering with `webPreferences.offscreen: { useSharedTexture: true }`. Apps that do not enable shared-texture offscreen rendering are not affected.

### Workarounds
Ensure `texture.release()` is called promptly after the texture has been consumed, before the texture object becomes unreachable.

### Fixed Versions
* `42.0.0-alpha.5`
* `41.1.0`
* `40.8.5`
* `39.8.5`

### For more information
If there are any questions or comments about this advisory, send an email to [security@electronjs.org](mailto:security@electronjs.org)
GitHub Security Advisory: GHSA-gfmv-vh34-h2x5
Package: signalk-server (NPM)
Severity: MODERATE (CVSS 7.5)
CWE: CWE-284: Improper Access Control, CWE-306: Missing Authentication for Critical Function
Vulnerable versions: < 2.24.0-beta.1
Patched in: 2.24.0-beta.1

Summary: Signal K Server: Unauthenticated Source Priorities Manipulation 

Details:
## Summary

The SignalK Server exposes an unauthenticated HTTP endpoint that allows remote attackers to modify navigation data source priorities. This endpoint, accessible via `PUT /signalk/v1/api/sourcePriorities`, does not enforce authentication or authorization checks and directly assigns user-controlled input to the server configuration.

As a result, attackers can influence which GPS, AIS, or other sensor data sources are trusted by the system. The changes are immediately applied and persisted to disk, allowing the manipulation to survive server restarts.

### Affected Component
- **File**: `src/serverroutes.ts`
- **Endpoint**: `PUT /signalk/v1/api/sourcePriorities` (also accessible at `/skServer/sourcePriorities`)
- **Lines**: 1064-1076
- **Function**: Source priorities configuration handler

### Vulnerable Code

```typescript
// src/serverroutes.ts - Lines 1064-1076
app.put(
  `${SERVERROUTESPREFIX}/sourcePriorities`,
  (req: Request, res: Response) => {
    app.config.settings.sourcePriorities = req.body
    app.activateSourcePriorities()
    writeSettingsFile(app, app.config.settings, (err: any) => {
      if (err) {
        res
          .status(500)
          .send('Unable to save to sourcePrefences in settings file')
      } else {
        res.json({ result: 'ok' })
      }
    })
  }
)
```
## Vulnerability Characteristics

**Missing Authentication**: The endpoint has zero authentication middleware, allowing unauthenticated access from any network-adjacent attacker.

**Direct Configuration Assignment**: User-supplied request body is directly assigned to app.config.settings.sourcePriorities without validation or sanitization.

**Persistent Storage**: Malicious configuration is written to disk via writeSettingsFile(), ensuring changes survive server restarts.
**Live Configuration Update**: Changes take effect immediately via activateSourcePriorities(), affecting live navigation data processing.

**No Input Validation**: No JSON schema validation, type checking, or field allowlisting is performed on the request body.

## Impact
- **Navigation Data Manipulation**: Attackers can modify source priorities to change which existing, active source's data is being used
GitHub Security Advisory: GHSA-rm5c-4rmf-vvhw
Package: openclaw (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-367: Time-of-check Time-of-use (TOCTOU) Race Condition
Vulnerable versions: <= 2026.3.28
Patched in: 2026.3.31

Summary: OpenClaw: Sandbox file operations use check-then-act, bypassing fd-based TOCTOU defenses

Details:
## Summary
Sandbox file operations use check-then-act, bypassing fd-based TOCTOU defenses

## Current Maintainer Triage
- Status: narrow
- Normalized severity: medium
- Assessment: Released workspace-only apply_patch remove and mkdir operations were still check-then-act, but the draft overstates scope by bundling broader edit paths; keep it open but narrow it to the actual sandbox-workspace mutation boundary.

## Affected Packages / Versions
- Package: `openclaw` (npm)
- Latest published npm version: `2026.3.31`
- Vulnerable version range: `<=2026.3.28`
- Patched versions: `>= 2026.3.31`
- First stable tag containing the fix: `v2026.3.31`

## Fix Commit(s)
- `32a4a47d602e0618f87b3e59f94d8c142767f860` — 2026-03-30T16:49:49+01:00

OpenClaw thanks @AntAISecurityLab for reporting.
GitHub Security Advisory: GHSA-3c7f-5hgj-h279
Package: n8n (NPM)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: = 2.14.0
Patched in: 2.14.1

Summary: n8n has XSS in Chat Trigger Node through Custom CSS

Details:
## Impact
An authenticated user with permission to create or modify workflows could inject malicious JavaScript into the Custom CSS field of the Chat Trigger node. Due to a misconfiguration in the `sanitize-html` library, the sanitization could be bypassed, resulting in stored XSS on the public chat page. Any user visiting the chat URL would be affected.

## Patches
The issue has been fixed in n8n versions 1.123.27, 2.13.3, and 2.14.1. Users should upgrade to one of these versions or later to remediate the vulnerability.

## Workarounds
If upgrading is not immediately possible, administrators should consider the following temporary mitigations:
- Limit workflow creation and editing permissions to fully trusted users only.
- Disable the Chat Trigger node by adding `@n8n/n8n-nodes-langchain.chatTrigger` to the `NODES_EXCLUDE` environment variable.

These workarounds do not fully remediate the risk and should only be used as short-term mitigation measures.
GitHub Security Advisory: GHSA-cjmm-f4jc-qw8r
Package: dompurify (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-183: Permissive List of Allowed Inputs
Vulnerable versions: <= 3.3.1
Patched in: 3.3.2

Summary: DOMPurify ADD_ATTR predicate skips URI validation

Details:
## Summary
DOMPurify allows `ADD_ATTR` to be provided as a predicate function via `EXTRA_ELEMENT_HANDLING.attributeCheck`. When the predicate returns `true`, `_isValidAttribute` short-circuits the attribute check before URI-safe validation runs. An attacker who supplies a predicate that accepts specific attribute/tag combinations can then sanitize input such as `<a href="javascript:alert(document.domain)">` and have the `javascript:` URL survive, because URI validation is skipped for that attribute while other checks still pass. The provided PoC accepts `href` for anchors and then triggers a click inside an iframe, showing that the sanitized payload executes despite the protocol bypass.

## Impact
Predicate-based allowlisting bypasses DOMPurify's URI validation, allowing unsafe protocols such as `javascript:` to reach the DOM and execute whenever the link is activated, resulting in DOM-based XSS.

## Credits
Identified by Cantina’s Apex (https://www.cantina.security).
GitHub Security Advisory: GHSA-cj63-jhhr-wcxv
Package: dompurify (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-1321: Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')
Vulnerable versions: <= 3.3.1
Patched in: 3.3.2

Summary: DOMPurify USE_PROFILES prototype pollution allows event handlers

Details:
## Summary
When `USE_PROFILES` is enabled, DOMPurify rebuilds `ALLOWED_ATTR` as a plain array before populating it with the requested allowlists. Because the sanitizer still looks up attributes via `ALLOWED_ATTR[lcName]`, any `Array.prototype` property that is polluted also counts as an allowlisted attribute. An attacker who can set `Array.prototype.onclick = true` (or a runtime already subject to prototype pollution) can thus force DOMPurify to keep event handlers such as `onclick` even when they are normally forbidden. The provided PoC sanitizes `<img onclick=...>` with `USE_PROFILES` and adds the sanitized output to the DOM; the polluted prototype allows the event handler to survive and execute, turning what should be a blocklist into a silent XSS vector.

## Impact
Prototype pollution makes DOMPurify accept dangerous event handler attributes, which bypasses the sanitizer and results in DOM-based XSS once the sanitized markup is rendered.

## Credits
Identified by Cantina’s Apex (https://www.cantina.security).