deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-2c2j-9gv5-cj73
Package: starlette (PIP)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-770: Allocation of Resources Without Limits or Throttling
Vulnerable versions: < 0.47.2
Patched in: 0.47.2

Summary: Starlette has possible denial-of-service vector when parsing large files in multipart forms

Details:
### Summary
When parsing a multi-part form with large files (greater than the [default max spool size](https://github.com/encode/starlette/blob/fa[PII_REDACTED]f794965ae1af0f87f9fec1b9a3de/starlette/formparsers.py#L126)) `starlette` will block the main thread to roll the file over to disk. This blocks the event thread which means we can't accept new connections.

### Details
Please see this discussion for details: https://github.com/encode/starlette/discussions/2927#discussioncomment-13721403. In summary the following UploadFile code (copied from [here](https://github.com/encode/starlette/blob/fa[PII_REDACTED]f794965ae1af0f87f9fec1b9a3de/starlette/datastructures.py#L436C5-L447C14)) has a minor bug. Instead of just checking for `self._in_memory` we should also check if the additional bytes will cause a rollover.

```python

    @property
    def _in_memory(self) -> bool:
        # check for SpooledTemporaryFile._rolled
        rolled_to_disk = getattr(self.file, "_rolled", True)
        return not rolled_to_disk

    async def write(self, data: bytes) -> None:
        if self.size is not None:
            self.size += len(data)

        if self._in_memory:
            self.file.write(data)
        else:
            await run_in_threadpool(self.file.write, data)
```

I have already created a PR which fixes the problem: https://github.com/encode/starlette/pull/2962


### PoC
See the discussion [here](https://github.com/encode/starlette/discussions/2927#discussioncomment-13721403) for steps on how to reproduce.

### Impact
To be honest, very low and not many users will be impacted. Parsing large forms is already CPU intensive so the additional IO block doesn't slow down `starlette` that much on systems with modern HDDs/SSDs. If someone is running on tape they might see a greater impact.
GitHub Security Advisory: GHSA-wcwp-9rcp-jvfg
Package: open-webui (PIP)
Severity: HIGH (CVSS 7.5)
CWE: CWE-400: Uncontrolled Resource Consumption
Vulnerable versions: <= 0.3.8
Patched in: unpatched

Summary: Open WebUI Uncontrolled Resource Consumption vulnerability

Details:
A vulnerability in open-webui/open-webui v0.3.8 allows an unauthenticated attacker to sign up with excessively large text in the 'name' field, causing the Admin panel to become unresponsive. This prevents administrators from performing essential user management actions such as deleting, editing, or adding users. The vulnerability can also be exploited by authenticated users with low privileges, leading to the same unresponsive state in the Admin panel.
GitHub Security Advisory: GHSA-h5gc-rm8j-5gpr
Package: langchain-community (PIP)
Severity: HIGH (CVSS 8.4)
CWE: CWE-918: Server-Side Request Forgery (SSRF)
Vulnerable versions: < 0.0.28
Patched in: 0.0.28

Summary: LangChain Community SSRF vulnerability exists in RequestsToolkit component 

Details:
A Server-Side Request Forgery (SSRF) vulnerability exists in the RequestsToolkit component of the langchain-community package (specifically, langchain_community.agent_toolkits.openapi.toolkit.RequestsToolkit) in langchain-ai/langchain version 0.0.27. This vulnerability occurs because the toolkit does not enforce restrictions on requests to remote internet addresses, allowing it to also access local addresses. As a result, an attacker could exploit this flaw to perform port scans, access local services, retrieve instance metadata from cloud environments (e.g., Azure, AWS), and interact with servers on the local network. This issue has been fixed in version 0.0.28.
GitHub Security Advisory: GHSA-qccg-9m4q-xfm6
Package: dbgpt (PIP)
Severity: CRITICAL (CVSS 9.1)
CWE: CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
Vulnerable versions: < 0.7.1
Patched in: 0.7.1

Summary: DB-GPT is vulnerable to SQL Injection attacks from unauthenticated users

Details:
In eosphoros-ai/db-gpt version v0.6.0, the web API `POST /api/v1/editor/sql/run` allows execution of arbitrary SQL queries without any access control. This vulnerability can be exploited by attackers to perform Arbitrary File Write using DuckDB SQL, enabling them to write arbitrary files to the victim's file system. This can potentially lead to Remote Code Execution (RCE).
GitHub Security Advisory: GHSA-8w3f-4r8f-pf53
Package: pyload-ng (PIP)
Severity: CRITICAL (CVSS 9.8)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'), CWE-94: Improper Control of Generation of Code ('Code Injection')
Vulnerable versions: < 0.20
Patched in: 0.20

Summary: pyLoad vulnerable to XSS through insecure CAPTCHA 

Details:
#### Summary
An unsafe JavaScript evaluation vulnerability in pyLoad’s CAPTCHA processing code allows **unauthenticated remote attackers** to execute **arbitrary code** in the client browser and potentially the backend server. Exploitation requires no user interaction or authentication and can result in session hijacking, credential theft, and full system rce.



#### Details
The vulnerable code resides in 
```javascript
function onCaptchaResult(result) {
    eval(result); // Direct execution of attacker-controlled input
}
```

* The `onCaptchaResult()` function directly passes CAPTCHA results (sent from the user) into `eval()`
* No sanitization or validation is performed on this input
* A malicious CAPTCHA result can include JavaScript such as `fetch()` or `child_process.exec()` in environments using NodeJS
* Attackers can fully hijack sessions and pivot to remote code execution on the server if the environment allows it



### Reproduction Methods
1. **Official Source Installation**:
```bash
git clone https://github.com/pyload/pyload
cd pyload
git checkout 0.4.20
python -m pip install -e .
pyload --userdir=/tmp/pyload
```

2. **Virtual Environment**:
```bash
python -m venv pyload-env
source pyload-env/bin/activate
pip install pyload==0.4.20
pyload
```

## CAPTCHA Endpoint Verification


**Technical Clarification**:  
1. The vulnerable endpoint is actually:
   ```
   /interactive/captcha
   ```

2. Complete PoC Request:
```http
POST /interactive/captcha HTTP/1.1
Host: localhost:8000
Content-Type: application/x-www-form-urlencoded

cid=123&response=1%3Balert(document.cookie)
```

3. Curl Command Correction:
```bash
curl -X POST "http://localhost:8000/interactive/captcha" \
  -d "cid=123&response=1%3Balert(document.cookie)"
```


1. **Vulnerable Code Location**:  
   The eval() vulnerability is confirmed in:
   ```
   src/pyload/webui/app/static/js/captcha-interactive.user.js
   ```



### **Resources**

1. https://github.com/pyload/pyload/commit/909e5c[PII_REDACTED]0d1264cfceb5555870eb9546
2. [OWASP: Avoid `eval()`](https://cheatsheetseries.owasp.org/cheatsheets/JavaScript_Security_Cheat_Sheet.html#eval)
3. [#4586](https://github.com/pyload/pyload/pull/4586)
GitHub Security Advisory: GHSA-x8c6-gj59-6rx8
Package: libp2p (PIP)
Severity: MODERATE (CVSS 4.3)
CWE: CWE-770: Allocation of Resources Without Limits or Throttling
Vulnerable versions: < 0.2.3
Patched in: 0.2.3

Summary: py-libp2p is vulnerable to DoS attacks through use of large RSA keys

Details:
py-libp2p before 0.2.3 allows a peer to cause a denial of service (resource consumption) via a large RSA key.
GitHub Security Advisory: GHSA-qxh9-qmf2-rhwc
Package: roundup (PIP)
Severity: MODERATE (CVSS 6.4)
CWE: CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
Vulnerable versions: < 2.5.0
Patched in: 2.5.0

Summary: Roundup is vulnerable to XSS through interactions between URLs and issue tracker templates

Details:
In Roundup before 2.5.0, XSS can occur via interaction between URLs and issue tracker templates (devel and responsive).
GitHub Security Advisory: GHSA-9548-qrrj-x5pj
Package: aiohttp (PIP)
Severity: LOW (CVSS 0.0)
CWE: CWE-444: Inconsistent Interpretation of HTTP Requests ('HTTP Request/Response Smuggling')
Vulnerable versions: < 3.12.14
Patched in: 3.12.14

Summary:  AIOHTTP is vulnerable to HTTP Request/Response Smuggling through incorrect parsing of chunked trailer sections

Details:
### Summary
The Python parser is vulnerable to a request smuggling vulnerability due to not parsing trailer sections of an HTTP request.

### Impact
If a pure Python version of aiohttp is installed (i.e. without the usual C extensions) or AIOHTTP_NO_EXTENSIONS is enabled, then an attacker may be able to execute a request smuggling attack to bypass certain firewalls or proxy protections.

----

Patch: https://github.com/aio-libs/aiohttp/commit/e8d774f635dc6d1cd3174d0e38891da5de0e2b6a
GitHub Security Advisory: GHSA-q28v-664f-q6wj
Package: indico (PIP)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, CWE-639: Authorization Bypass Through User-Controlled Key, CWE-862: Missing Authorization
Vulnerable versions: >= 2.2, < 3.3.7
Patched in: 3.3.7

Summary: Indico vulnerability allows attackers to bulk dump user details

Details:
### Impact
An endpoint used to display details of users listed in certain fields (such as ACLs) could be misused to dump basic user details (such as name, affiliation and email) in bulk.

> [!TIP]
> If your instance allows everyone to create a user account, and you wish to truly restrict access to these user details, consider restricting user search to managers. You can find details on the newly introduced indico.conf setting [`ALLOW_PUBLIC_USER_SEARCH`](https://docs.getindico.io/en/stable/config/settings/#ALLOW_PUBLIC_USER_SEARCH) in our documentation.

### Patches
You should to update to [Indico 3.3.7](https://github.com/indico/indico/releases/tag/v3.3.7) as soon as possible.
See [the docs](https://docs.getindico.io/en/stable/installation/upgrade/) for instructions on how to update.

### Workarounds
It is possible to restrict access to the affected endpoints (e.g. in the webserver config), but doing so would break certain form fields which could no longer show the details of the users listed in those fields, so upgrading instead is highly recommended.

### For more information
If you have any questions or comments about this advisory:

- Open a thread in [our forum](https://talk.getindico.io/)
- Email us privately at [indico-team@cern.ch](mailto:indico-team@cern.ch)

#### Credits
This vulnerability was identified during a security assessment conducted as part of the Red Team Residency Program at RNP (Rede Nacional de Ensino e Pesquisa).
The research and testing were performed by a security researcher working under RNP’s authorization and coordination.
Special acknowledgment goes to the RNP Security Team, which provided the infrastructure, methodology, and ethical oversight for this work.
GitHub Security Advisory: GHSA-37mw-44qp-f5jm
Package: transformers (PIP)
Severity: MODERATE (CVSS 5.3)
CWE: CWE-1333: Inefficient Regular Expression Complexity
Vulnerable versions: <= 4.51.3
Patched in: 4.52.1

Summary: Transformers is vulnerable to ReDoS attack through its DonutProcessor class

Details:
A Regular Expression Denial of Service (ReDoS) vulnerability was discovered in the Hugging Face Transformers library, specifically within the DonutProcessor class's `token2json()` method. This vulnerability affects versions 4.51.3 and earlier, and is fixed in version 4.52.1. The issue arises from the regex pattern `<s_(.*?)>` which can be exploited to cause excessive CPU consumption through crafted input strings due to catastrophic backtracking. This vulnerability can lead to service disruption, resource exhaustion, and potential API service vulnerabilities, impacting document processing tasks using the Donut model.
GitHub Security Advisory: GHSA-5hq9-5r78-2gjh
Package: llama-index-readers-docugami (PIP)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-440: Expected Behavior Violation
Vulnerable versions: < 0.3.1
Patched in: 0.3.1

Summary: LlamaIndex vulnerable to data loss through hash collisions in its DocugamiReader class 

Details:
A vulnerability in the DocugamiReader class of the run-llama/llama_index repository, up to but excluding version 0.12.41, involves the use of MD5 hashing to generate IDs for document chunks. This approach leads to hash collisions when structurally distinct chunks contain identical text, resulting in one chunk overwriting another. This can cause loss of semantically or legally important document content, breakage of parent-child chunk hierarchies, and inaccurate or hallucinated responses in AI outputs. The issue is resolved in version 0.3.1.
GitHub Security Advisory: GHSA-5hq9-5r78-2gjh
Package: llama-index (PIP)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-440: Expected Behavior Violation
Vulnerable versions: < 0.12.41
Patched in: 0.12.41

Summary: LlamaIndex vulnerable to data loss through hash collisions in its DocugamiReader class 

Details:
A vulnerability in the DocugamiReader class of the run-llama/llama_index repository, up to but excluding version 0.12.41, involves the use of MD5 hashing to generate IDs for document chunks. This approach leads to hash collisions when structurally distinct chunks contain identical text, resulting in one chunk overwriting another. This can cause loss of semantically or legally important document content, breakage of parent-child chunk hierarchies, and inaccurate or hallucinated responses in AI outputs. The issue is resolved in version 0.3.1.
GitHub Security Advisory: GHSA-vm7w-2724-5m23
Package: streampipes (PIP)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-269: Improper Privilege Management
Vulnerable versions: < 0.97.0
Patched in: 0.97.0

Summary: Apache StreamPipes has improper privilege management in a REST interface

Details:
Improper privilege management in a REST interface allowed registered users to access unauthorized resources if the resource ID was known. 

This issue affects Apache StreamPipes: through 0.95.1.

Users are recommended to upgrade to version 0.97.0 which fixes the issue.
GitHub Security Advisory: GHSA-rpfv-46xj-5984
Package: upsonic (PIP)
Severity: LOW (CVSS 5.5)
CWE: CWE-20: Improper Input Validation, CWE-502: Deserialization of Untrusted Data
Vulnerable versions: < 0.56.0
Patched in: 0.56.0

Summary: Upsonic has vulnerability in Pickle Handler component that can lead to deserialization

Details:
A vulnerability, which was classified as critical, has been found in Upsonic up to 0.55.6. This issue affects the function cloudpickle.loads of the file /tools/add_tool of the component Pickle Handler. The manipulation leads to deserialization. The exploit has been disclosed to the public and may be used.
GitHub Security Advisory: GHSA-8jf4-fcjr-68c2
Package: upsonic (PIP)
Severity: LOW (CVSS 5.5)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: < 0.56.0
Patched in: 0.56.0

Summary: Upsonic is vulnerable to Path Traversal attack through its os.path.join function

Details:
A vulnerability classified as critical was found in Upsonic up to 0.55.6. This vulnerability affects the function os.path.join of the file markdown/server.py. The manipulation of the argument file.filename leads to path traversal. The exploit has been disclosed to the public and may be used.
GitHub Security Advisory: GHSA-2wcm-vx67-3x4q
Package: pyload-ng (PIP)
Severity: HIGH (CVSS 0.0)
CWE: CWE-281: Improper Preservation of Permissions
Vulnerable versions: <= 0.5.0b3.dev77
Patched in: unpatched

Summary: Duplicate Advisory: GHSA-x698-5hjm-w2m5

Details:
### Duplicate Advisory
This advisory has been withdrawn because it is a duplicate of GHSA-x698-5hjm-w2m5. This link is maintained to preserve external references.

### Original Description
Any unauthenticated attacker can bypass the localhost 
restrictions posed by the application and utilize this to create 
arbitrary packages
GitHub Security Advisory: GHSA-x698-5hjm-w2m5
Package: pyload-ng (PIP)
Severity: HIGH (CVSS 7.5)
CWE: CWE-284: Improper Access Control, CWE-290: Authentication Bypass by Spoofing
Vulnerable versions: <= 0.5.0b3.dev88
Patched in: unpatched

Summary: pyLoad is vulnerable to attacks that bypass localhost restrictions, enabling the creation of arbitrary packages

Details:
### Summary
Any unauthenticated attacker can bypass the localhost restrictions posed by the application and utilize this to create arbitrary packages.

### Details
Any unauthenticated attacker can bypass the localhost restrictions posed by the application and utilize this to create arbitrary packages. This is done by changing the `Host` header to the value of `127.0.0.1:9666`.

### PoC
The application has middleware that prevents access to several routes by checking whether the `Host` header has a specific value. We bypassed this restriction.

https://github.com/pyload/pyload/blob/4159a1191ec4fe6d927e57a9c4bb8f54e16c381d/src/pyload/webui/app/blueprints/cnl_blueprint.py#L21-L36
```python
#: decorator
def local_check(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        remote_addr = flask.request.environ.get("REMOTE_ADDR", "0")
        http_host = flask.request.environ.get("HTTP_HOST", "0")

        if remote_addr in ("127.0.0.1", "::ffff:127.0.0.1", "::1", "localhost") or http_host in (
            "127.0.0.1:9666",
            "[::1]:9666",
        ):
            return func(*args, **kwargs)
        else:
            return "Forbidden", 403

    return wrapper
```

Below we see that the '/flash/add' endpoint uses the middleware above.

https://github.com/pyload/pyload/blob/4159a1191ec4fe6d927e57a9c4bb8f54e16c381d/src/pyload/webui/app/blueprints/cnl_blueprint.py#L56-L58C11
```python
@bp.route("/flash/add", methods=["POST"], endpoint="add")
@local_check
def add():
```

Notice how we are not authorized to access this endpoint when sending a request.
![image](https://user-images.githubusercontent.com/44903767/294[PII_REDACTED]7d91-c0d1-4d8f-963f-cedfa8dc9034.png)

However, if we set the `Host` header to be `127.0.0.1:9666`, we notice the request returns `success`.
![image](https://user-images.githubusercontent.com/44903767/294933755-43ad3826-0e94-4ba5-acf0-48f11670cbc6.png)

Checking the front end as an admin, we now see that this did indeed succeed.
![image](https://user-images.githubusercontent.com/44903767/294934431-5d024c75-59dc-47b6-8887-b14ae91e320f.png)

### Impact
An unauthenticated user can perform actions that should only be available to authenticated users.
GitHub Security Advisory: GHSA-q93c-p2mw-p23f
Package: dagster (PIP)
Severity: MODERATE (CVSS 7.5)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: < 1.5.11
Patched in: 1.5.11

Summary: Dagster vulnerable to Path Traversal attack through its /logs endpoint

Details:
Directory Traversal vulnerability in dagster-webserver Dagster thru 1.5.10 allows remote attackers to obtain sensitive information via crafted request to the /logs endpoint. This may be restricted to certain file names that start with a dot ('.').
GitHub Security Advisory: GHSA-2rhq-96q8-4vjq
Package: llama-index-core (PIP)
Severity: HIGH (CVSS 7.5)
CWE: CWE-29: Path Traversal: '..filename'
Vulnerable versions: >= 0.11.23, < 0.12.41
Patched in: 0.12.41

Summary: LlamaIndex vulnerable to Path Traversal attack through its encode_image function

Details:
A path traversal vulnerability exists in run-llama/llama_index versions 0.11.23 through 0.12.40, specifically within the `encode_image` function in `generic_utils.py`. This vulnerability allows an attacker to manipulate the `image_path` input to read arbitrary files on the server, including sensitive system files. The issue arises due to improper validation or sanitization of the file path, enabling path traversal sequences to access files outside the intended directory. The vulnerability is fixed in version 0.12.41.
GitHub Security Advisory: GHSA-j5pr-vrjj-9v4h
Package: lollms (PIP)
Severity: HIGH (CVSS 7.5)
CWE: CWE-203: Observable Discrepancy
Vulnerable versions: <= 11.0.0
Patched in: unpatched

Summary: Lord of Large Language Models vulnerable to Observable Discrepancy attack via authenticate_user function

Details:
The parisneo/lollms repository is affected by a timing attack vulnerability in the `authenticate_user` function within the `lollms_authentication.py` file. This vulnerability allows attackers to enumerate valid usernames and guess passwords incrementally by analyzing response time differences. The affected version is the latest, and the issue is resolved in commit f78437f. The vulnerability arises from the use of Python's default string equality operator for password comparison, which compares characters sequentially and exits on the first mismatch, leading to variable response times based on the number of matching initial characters.
GitHub Security Advisory: GHSA-3j8r-jf9w-5cmh
Package: llama-index-readers-obsidian (PIP)
Severity: MODERATE (CVSS 6.2)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: < 0.5.2
Patched in: 0.5.2

Summary: LlamaIndex vulnerability in its ObsidianReader class can lead to Path Traversal exploit

Details:
A vulnerability in the ObsidianReader class of the run-llama/llama_index repository, before version 0.5.2 (specifically in version 0.12.27 of llama-index), allows for hardlink-based path traversal. This flaw permits attackers to bypass path restrictions and access sensitive system files, such as /etc/passwd, by exploiting hardlinks. The vulnerability arises from inadequate handling of hardlinks in the load_data() method, where the security checks fail to differentiate between real files and hardlinks. This issue is resolved in llama-index-readers-obsidian version 0.5.2.
GitHub Security Advisory: GHSA-3wxx-q3gv-pvvv
Package: llama-index-core (PIP)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-674: Uncontrolled Recursion
Vulnerable versions: < 0.12.38
Patched in: 0.12.38

Summary: LlamaIndex vulnerable to DoS attack through uncontrolled recursive JSON parsing

Details:
The JSONReader in run-llama/llama_index versions 0.12.28 is vulnerable to a stack overflow due to uncontrolled recursive JSON parsing. This vulnerability allows attackers to trigger a Denial of Service (DoS) by submitting deeply nested JSON structures, leading to a RecursionError and crashing applications. The root cause is the unsafe recursive traversal design and lack of depth validation, which makes the JSONReader susceptible to stack overflow when processing deeply nested JSON. This impacts the availability of services, making them unreliable and disrupting workflows. The issue is resolved in version 0.12.38.
GitHub Security Advisory: GHSA-phhr-52qp-3mj4
Package: transformers (PIP)
Severity: LOW (CVSS 3.5)
CWE: CWE-20: Improper Input Validation
Vulnerable versions: < 4.52.1
Patched in: 4.52.1

Summary: Transformers's Improper Input Validation vulnerability can be exploited through username injection

Details:
Hugging Face Transformers versions up to 4.49.0 are affected by an improper input validation vulnerability in the `image_utils.py` file. The vulnerability arises from insecure URL validation using the `startswith()` method, which can be bypassed through URL username injection. This allows attackers to craft URLs that appear to be from YouTube but resolve to malicious domains, potentially leading to phishing attacks, malware distribution, or data exfiltration. The issue is fixed in version 4.52.1.