deardaniel/secdata-raw huggingface dataset:
GitHub Security Advisory: GHSA-rqc4-2hc7-8c8v
Package: virtualenv (PIP)
Severity: HIGH (CVSS 8.4)
CWE: CWE-77: Improper Neutralization of Special Elements used in a Command ('Command Injection'), CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')
Vulnerable versions: < 20.26.6
Patched in: 20.26.6

Summary: virtualenv allows command injection through activation scripts for a virtual environment

Details:
virtualenv before 20.26.6 allows command injection through the activation scripts for a virtual environment. Magic template strings are not quoted correctly when replacing. NOTE: this is not the same as CVE-2024-9287.
GitHub Security Advisory: GHSA-3pww-qvr8-6mhp
Package: ray (PIP)
Severity: CRITICAL (CVSS 9.3)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), CWE-29: Path Traversal: '..filename'
Vulnerable versions: < 2.8.1
Patched in: 2.8.1

Summary: Ray Path Traversal vulnerability

Details:
LFI in Ray's log API endpoint allows attackers to read any file on the server without authentication. The issue is fixed in version 2.8.1+. Ray maintainers response can be found here: https://www.anyscale.com/blog/update-on-ray-cves-cve-2023-6019-cve-2023-6020-cve-2023-6021-cve-2023-48022-cve-2023-48023
GitHub Security Advisory: GHSA-6cxr-8q3m-jwrr
Package: ray (PIP)
Severity: CRITICAL (CVSS 9.3)
CWE: CWE-598: Use of GET Request Method With Sensitive Query Strings, CWE-862: Missing Authorization
Vulnerable versions: < 2.8.1
Patched in: 2.8.1

Summary: Ray Missing Authorization vulnerability

Details:
LFI in Ray's /static/ directory allows attackers to read any file on the server without authentication. The issue is fixed in version 2.8.1+. Ray maintainers response can be found here: https://www.anyscale.com/blog/update-on-ray-cves-cve-2023-6019-cve-2023-6020-cve-2023-6021-cve-2023-48022-cve-2023-48023
GitHub Security Advisory: GHSA-h3xg-wv58-5p43
Package: ray (PIP)
Severity: CRITICAL (CVSS 9.8)
CWE: CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')
Vulnerable versions: < 2.8.1
Patched in: 2.8.1

Summary: Ray OS Command Injection vulnerability

Details:
A command injection exists in Ray's cpu_profile URL parameter allowing attackers to execute os commands on the system running the ray dashboard remotely without authentication.
GitHub Security Advisory: GHSA-5xh2-23cc-5jc6
Package: strawberry-graphql (PIP)
Severity: LOW (CVSS 3.7)
CWE: CWE-351: Insufficient Type Distinction, CWE-843: Access of Resource Using Incompatible Type ('Type Confusion')
Vulnerable versions: >= 0.182.0, < 0.257.0
Patched in: 0.257.0

Summary: Strawberry GraphQL has type resolution vulnerability in node interface that allows potential data leakage through incorrect type resolution

Details:
**Vulnerability Summary**
A type confusion vulnerability exists in Strawberry GraphQL's relay integration that affects multiple ORM integrations (Django, SQLAlchemy, Pydantic). The vulnerability occurs when multiple GraphQL types are mapped to the same underlying model while using the relay `node` interface.

**Affected Components**
- Strawberry GraphQL relay integration
- Specifically impacts implementations using:
  - Django integration
  - SQLAlchemy integration
  - Pydantic integration

**Technical Details**

The vulnerability manifests when:
1. Multiple GraphQL types inherit from `relay.Node`
2. These types are mapped to the same database model
3. The global `node` field is used for type resolution

Example of vulnerable code:

```python
from fruits.models import Fruit
import strawberry_django
import strawberry

@strawberry_django.type(Fruit)
class FruitType(relay.Node):
    name: strawberry.auto

@strawberry_django.type(Fruit)
class SpecialFruitType(relay.Node):
    secret_name: strawberry.auto

@strawberry.type
class Query:
    node: relay.Node = strawberry_django.node()
```

**Security Impact**

When querying for a specific type using the global `node` field (e.g., `FruitType:some-id`), the resolver may incorrectly return an instance of a different type mapped to the same model (e.g., `SpecialFruitType`). This can lead to:

1. Information disclosure if the alternate type exposes sensitive fields
2. Potential privilege escalation if the alternate type contains data intended for restricted access

**Note**
Even with knowledge of the correct type name (e.g., `SpecialFruitType`), attackers may still be able to access unauthorized data through direct type queries.

We recommend to use permission on fields instead of creating a dedicate type.

**Recommendations**
1. Avoid mapping multiple relay Node types to the same model
2. Implement strict access controls at the field resolution level (using permissions)
3. Consider using separate models for different access levels of the same data
4. Update to `strawberry-graphql>=0.257.0`
5. If using `strawberry-graphql-django`, update to `strawberry-graphql-django>=0.54.0`
GitHub Security Advisory: GHSA-7w6r-748w-mh52
Package: pgadmin4 (PIP)
Severity: HIGH (CVSS 8.0)
CWE: CWE-276: Incorrect Default Permissions, CWE-488: Exposure of Data Element to Wrong Session
Vulnerable versions: < 7.0
Patched in: 7.0

Summary: pgAdmin has Incorrect Default Permissions

Details:
A vulnerability was found in pgadmin. Users logging into pgAdmin running in server mode using LDAP authentication may be attached to another user's session if multiple connection attempts occur simultaneously.
GitHub Security Advisory: GHSA-f27h-g923-68hw
Package: neutron (PIP)
Severity: MODERATE (CVSS 7.5)
CWE: CWE-345: Insufficient Verification of Data Authenticity, CWE-754: Improper Check for Unusual or Exceptional Conditions
Vulnerable versions: >= 25.0.0, < 25.0.1
Patched in: 25.0.1

Summary: OpenStack Neutron can use an incorrect ID during policy enforcement

Details:
In OpenStack Neutron before 25.0.1, neutron/extensions/tagging.py can use an incorrect ID during policy enforcement. It does not apply the proper policy check for changing network tags. An unprivileged tenant is able to change (add and clear) tags on network objects that do not belong to the tenant, and this action is not subjected to the proper policy authorization check. This affects 23 before 23.2.1, 24 before 24.0.2, and 25 before 25.0.1.
GitHub Security Advisory: GHSA-f27h-g923-68hw
Package: neutron (PIP)
Severity: MODERATE (CVSS 7.5)
CWE: CWE-345: Insufficient Verification of Data Authenticity, CWE-754: Improper Check for Unusual or Exceptional Conditions
Vulnerable versions: >= 24.0.0, < 24.0.2
Patched in: 24.0.2

Summary: OpenStack Neutron can use an incorrect ID during policy enforcement

Details:
In OpenStack Neutron before 25.0.1, neutron/extensions/tagging.py can use an incorrect ID during policy enforcement. It does not apply the proper policy check for changing network tags. An unprivileged tenant is able to change (add and clear) tags on network objects that do not belong to the tenant, and this action is not subjected to the proper policy authorization check. This affects 23 before 23.2.1, 24 before 24.0.2, and 25 before 25.0.1.
GitHub Security Advisory: GHSA-f27h-g923-68hw
Package: neutron (PIP)
Severity: MODERATE (CVSS 7.5)
CWE: CWE-345: Insufficient Verification of Data Authenticity, CWE-754: Improper Check for Unusual or Exceptional Conditions
Vulnerable versions: >= 23.0.0, < 23.2.1
Patched in: 23.2.1

Summary: OpenStack Neutron can use an incorrect ID during policy enforcement

Details:
In OpenStack Neutron before 25.0.1, neutron/extensions/tagging.py can use an incorrect ID during policy enforcement. It does not apply the proper policy check for changing network tags. An unprivileged tenant is able to change (add and clear) tags on network objects that do not belong to the tenant, and this action is not subjected to the proper policy authorization check. This affects 23 before 23.2.1, 24 before 24.0.2, and 25 before 25.0.1.
GitHub Security Advisory: GHSA-6gf2-ffq8-gcww
Package: sickchill (PIP)
Severity: LOW (CVSS 0.0)
CWE: CWE-601: URL Redirection to Untrusted Site ('Open Redirect')
Vulnerable versions: <= 2024.3.1
Patched in: unpatched

Summary: GHSL-2024-288: SickChill open redirect in login

Details:
SickChill is an automatic video library manager for TV shows. A user-controlled `login` endpoint's `next_` parameter takes arbitrary content. Prior to commit c7128a8946c3701df95c285810eb75b2de18bf82, an authenticated attacker may use this to redirect the user to arbitrary destinations, leading to open redirect. Commit c7128a8946c3701df95c285810eb75b2de18bf82 changes the login page to redirect to `settings.DEFAULT_PAGE` instead of to the `next` parameter.
GitHub Security Advisory: GHSA-cjgq-5qmw-rcj6
Package: keras (PIP)
Severity: MODERATE (CVSS 0.0)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: <= 3.7.0
Patched in: unpatched

Summary: keras Path Traversal vulnerability

Details:
An issue in keras 3.7.0 allows attackers to write arbitrary files to the user's machine via downloading a crafted tar file through the get_file function.
GitHub Security Advisory: GHSA-8863-4qmg-fr45
Package: apache-airflow-providers-fab (PIP)
Severity: LOW (CVSS 0.0)
CWE: CWE-613: Insufficient Session Expiration
Vulnerable versions: < 1.5.2
Patched in: 1.5.2

Summary: Apache Airflow Fab Provider Insufficient Session Expiration vulnerability

Details:
Insufficient Session Expiration vulnerability in Apache Airflow Fab Provider.

This issue affects Apache Airflow Fab Provider: before 1.5.2.

When user password has been changed with admin CLI, the sessions for that user have not been cleared, leading to insufficient session expiration, thus logged users could continue to be logged in even after the password was changed. This only happened when the password was changed with CLI. The problem does not happen in case change was done with webserver thus this is different from [CVE-2023-40273](https://github.com/advisories/GHSA-pm87-24wq-r8w9) which was addressed in Apache-Airflow 2.7.0


Users are recommended to upgrade to version 1.5.2, which fixes the issue.
GitHub Security Advisory: GHSA-gmj6-6f8f-6699
Package: jinja2 (PIP)
Severity: MODERATE (CVSS 8.8)
CWE: CWE-150: Improper Neutralization of Escape, Meta, or Control Sequences
Vulnerable versions: >= 3.0.0, <= 3.1.4
Patched in: 3.1.5

Summary: Jinja has a sandbox breakout through malicious filenames

Details:
A bug in the Jinja compiler allows an attacker that controls both the content and filename of a template to execute arbitrary Python code, regardless of if Jinja's sandbox is used.

To exploit the vulnerability, an attacker needs to control both the filename and the contents of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates where the template author can also choose the template filename.
GitHub Security Advisory: GHSA-v6jv-p6r8-j78w
Package: nicegui (PIP)
Severity: HIGH (CVSS 7.5)
CWE: CWE-287: Improper Authentication
Vulnerable versions: <= 2.9.0
Patched in: 2.9.1

Summary: NiceGUI On Air authentication issue

Details:
### Summary
Once a user logins to one browser, all other browsers are logged in without entering password. Even incognito mode.

### Impact
high
GitHub Security Advisory: GHSA-7p2g-2vxc-5g55
Package: letta (PIP)
Severity: HIGH (CVSS 7.5)
CWE: CWE-863: Incorrect Authorization
Vulnerable versions: <= 0.3.17
Patched in: unpatched

Summary: Letta (previously MemGPT) incorrect access control vulnerability

Details:
Incorrect access control in the /users endpoint of Cpacker MemGPT v0.3.17 allows attackers to access sensitive data.
GitHub Security Advisory: GHSA-hq4h-w933-jm6c
Package: khoj (PIP)
Severity: MODERATE (CVSS 4.3)
CWE: CWE-639: Authorization Bypass Through User-Controlled Key
Vulnerable versions: < 1.29.0
Patched in: 1.29.0

Summary: khoj has an IDOR in subscription management allows unauthorized subscription modifications

Details:
### Summary
An Insecure Direct Object Reference (IDOR) vulnerability in the update_subscription endpoint allows any authenticated user to manipulate other users' Stripe subscriptions by simply modifying the email parameter in the request.

### Details
The vulnerability exists in the subscription endpoint at `/api/subscription`. The endpoint uses an email parameter as a direct reference to user subscriptions without verifying object ownership. While authentication is required, there is no authorization check to verify if the authenticated user owns the referenced subscription.

Vulnerable code in `/api/subscription`:
```python
@subscription_router.patch("")
@requires(["authenticated"])
async def update_subscription(request: Request, email: str, operation: str):
    # IDOR: email parameter directly references user subscriptions without ownership verification
    customers = stripe.Customer.list(email=email).auto_paging_iter()
    customer = next(customers, None)
    
    if operation == "cancel":
        # Any authenticated user can modify any subscription referenced by email
        customer_id = customer.id
        for subscription in stripe.Subscription.list(customer=customer_id):
            stripe.Subscription.modify(subscription.id, cancel_at_period_end=True)
```

### PoC
1. Create a customer account in stripe:
   - Customer A: `adventure8812@zeropath.com` (attacker)

2. Log in as any user.

3. Send this request:
```http
PATCH /api/subscription?email=adventure8812@zeropath.com&operation=cancel HTTP/1.1
```

4. The subscription for Customer A is successfully set to cancel.

### Impact
High:
Revenue loss via mass cancellation of subscriptions.
Loss of customer trust by re-enabling subscriptions they had set to cancel.

### Resolution

This was fixed in the following commit which limited subscription update operations to the authenticated user: https://github.com/khoj-ai/khoj/commit/47d3c8c23597900af708bdc60aced3ae5d2064c1. Support for arbitrarily presenting an email for update has been deprecated.
GitHub Security Advisory: GHSA-q34m-jh98-gwm2
Package: Quart (PIP)
Severity: MODERATE (CVSS 7.5)
CWE: CWE-400: Uncontrolled Resource Consumption
Vulnerable versions: < 0.20.0
Patched in: 0.20.0

Summary: Werkzeug possible resource exhaustion when parsing file data in forms

Details:
Applications using Werkzeug to parse `multipart/form-data` requests are vulnerable to resource exhaustion. A specially crafted form body can bypass the `Request.max_form_memory_size` setting.


The `Request.max_content_length` setting, as well as resource limits provided by deployment software and platforms, are also available to limit the resources used during a request. This vulnerability does not affect those settings. All three types of limits should be considered and set appropriately when deploying an application.
GitHub Security Advisory: GHSA-pq9p-pc3p-9hm4
Package: python-sql (PIP)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-150: Improper Neutralization of Escape, Meta, or Control Sequences
Vulnerable versions: < 1.5.2
Patched in: 1.5.2

Summary: python-sql SQL injection vulnerability

Details:
A vulnerability was found in python-sql where unary operators do not escape non-Expression (like `And` and `Or`) which makes any system exposing those vulnerable to an SQL injection attack.
GitHub Security Advisory: GHSA-j5vv-6wjg-cfr8
Package: changedetection.io (PIP)
Severity: HIGH (CVSS 8.6)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), CWE-200: Exposure of Sensitive Information to an Unauthorized Actor
Vulnerable versions: < 0.48.05
Patched in: 0.48.05

Summary: changedetection.io Vulnerable to Improper Input Validation Leading to LFR/Path Traversal

Details:
### Summary
Improper input validation in the application can allow attackers to perform local file read (LFR) or path traversal attacks. These vulnerabilities occur when user input is used to construct file paths without adequate sanitization or validation. For example, using `file:../../../etc/passwd` or `file: ///etc/passwd` can bypass weak validations and allow unauthorized access to sensitive files. Even though this has been addressed in previous patch, it is still insufficient.

### Details
The check in this line of code is insufficient.
```
if re.search(r'^file:/', url.strip(), re.IGNORECASE):
```
The attacker can still bypass this by using:
-`file:../../../../etc/passwd`
-`file: ///etc/passwd` (with space before /)

### PoC
- Open up a changedetection.io instance with a webdriver configured.
- Create a new watch with `file:../../../../etc/passwd`.
- Check the watch preview.
- The contents of `/etc/passwd` should pop out.

### Screenshots
![image](https://github.com/user-attachments/assets/55c34f2e-cafb-4a7a-a7ef-ec222e3f519b)
![image](https://github.com/user-attachments/assets/d41189f5-7bf2-48b5-9ce3-c26f79cefeda)
GitHub Security Advisory: GHSA-8gc2-vq6m-rwjw
Package: redshift_connector (PIP)
Severity: HIGH (CVSS 8.0)
CWE: CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection')
Vulnerable versions: = 2.1.4
Patched in: 2.1.5

Summary: Amazon Redshift Python Connector vulnerable to SQL Injection

Details:
### Summary
A SQL injection in the Amazon Redshift Python Connector in version 2.1.4 allows a user to gain escalated privileges via schema injection in the get_schemas, get_tables, or get_columns Metadata APIs. Users should upgrade to the driver version 2.1.5 or revert to driver version 2.1.3.

### Impact
A SQL injection is possible in the Amazon Redshift Python Connector, version 2.1.4, when leveraging metadata APIs to retrieve information about database schemas, tables, or columns.

**Impacted versions:** Amazon Redshift Python Connector version 2.1.4.

### Patches
The issue described above has been addressed in the Amazon Redshift Python Connector, version 2.1.5. 

The patch implemented in this version ensures that every metadata command input is sent to the Redshift server as part of a parameterized query, using either QUOTE_IDENT(string) or QUOTE_LITERAL(string). After processing all the inputs into quoted identifiers or literals, the metadata command is composed using these inputs and then executed on the server.

### Workarounds
Use the previous version of the Amazon Redshift Python Connector, version 2.1.3.

### References
If you have any questions or comments about this advisory we ask that you contact AWS/Amazon Security via our vulnerability reporting page [1] or directly via email to [aws-security@amazon.com](mailto:aws-security@amazon.com). Please do not create a public GitHub issue.

[1] Vulnerability reporting page: https://aws.amazon.com/security/vulnerability-reporting
GitHub Security Advisory: GHSA-g2vg-8hfg-79vj
Package: koji (PIP)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-116: Improper Encoding or Escaping of Output
Vulnerable versions: < 1.33.2
Patched in: 1.33.2

Summary: Koji Cross-site Scripting

Details:
A vulnerability in Koji was found. An unsanitized input allows for an XSS attack. Javascript code from a malicious link could be reflected in the resulting web page. It is not expected to be able to submit an action or make a change in Koji due to existing XSS protections in the code.
GitHub Security Advisory: GHSA-g2vg-8hfg-79vj
Package: koji (PIP)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-116: Improper Encoding or Escaping of Output
Vulnerable versions: >= 1.34.0, < 1.34.3
Patched in: 1.34.3

Summary: Koji Cross-site Scripting

Details:
A vulnerability in Koji was found. An unsanitized input allows for an XSS attack. Javascript code from a malicious link could be reflected in the resulting web page. It is not expected to be able to submit an action or make a change in Koji due to existing XSS protections in the code.
GitHub Security Advisory: GHSA-g2vg-8hfg-79vj
Package: koji (PIP)
Severity: MODERATE (CVSS 5.4)
CWE: CWE-116: Improper Encoding or Escaping of Output
Vulnerable versions: = 1.35.0
Patched in: 1.35.1

Summary: Koji Cross-site Scripting

Details:
A vulnerability in Koji was found. An unsanitized input allows for an XSS attack. Javascript code from a malicious link could be reflected in the resulting web page. It is not expected to be able to submit an action or make a change in Koji due to existing XSS protections in the code.
GitHub Security Advisory: GHSA-q2x7-8rv6-6q7h
Package: jinja2 (PIP)
Severity: MODERATE (CVSS 7.8)
CWE: CWE-693: Protection Mechanism Failure
Vulnerable versions: <= 3.1.4
Patched in: 3.1.5

Summary: Jinja has a sandbox breakout through indirect reference to format method

Details:
An oversight in how the Jinja sandboxed environment detects calls to `str.format` allows an attacker that controls the content of a template to execute arbitrary Python code.

To exploit the vulnerability, an attacker needs to control the content of a template. Whether that is the case depends on the type of application using Jinja. This vulnerability impacts users of applications which execute untrusted templates.

Jinja's sandbox does catch calls to `str.format` and ensures they don't escape the sandbox. However, it's possible to store a reference to a malicious string's `format` method, then pass that to a filter that calls it. No such filters are built-in to Jinja, but could be present through custom filters in an application. After the fix, such indirect calls are also handled by the sandbox.
GitHub Security Advisory: GHSA-47h8-jmp3-9f28
Package: pyrage (PIP)
Severity: HIGH (CVSS 9.8)
CWE: CWE-25: Path Traversal: '/../filedir', CWE-94: Improper Control of Generation of Code ('Code Injection'), CWE-1395: Dependency on Vulnerable Third-Party Component
Vulnerable versions: >= 1.2.0, < 1.2.3
Patched in: 1.2.3

Summary: pyrage vulnerable to malicious plugin names, recipients, or identities causing arbitrary binary execution

Details:
`pyrage` uses the Rust `age` crate for its underlying operations, and `age` is vulnerable to GHSA-4fg7-vxc8-qx5w.

All details of GHSA-4fg7-vxc8-qx5w are relevant to `pyrage` for the versions specified in this advisory. See GHSA-4fg7-vxc8-qx5w for full details.

Versions of `pyrage` before 1.2.0 lack plugin support and are therefore **not affected**.

An equivalent issue was fixed in [the reference Go implementation of age](https://github.com/FiloSottile/age), see advisory [GHSA-32gq-x56h-299c](https://github.com/FiloSottile/age/security/advisories/GHSA-32gq-x56h-299c).

Thanks to ⬡-49016 for reporting this issue.
GitHub Security Advisory: GHSA-m9hc-vxjj-4x6q
Package: pghoard (PIP)
Severity: MODERATE (CVSS 6.5)
CWE: CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')
Vulnerable versions: < 2.6.1-rc
Patched in: 2.6.1-rc

Summary: PGHoard Path Traversal vulnerability

Details:
A vulnerability has been discovered that could allow an attacker to acquire disk access with privileges equivalent to those of pghoard, allowing for unintended path traversal.  Depending on the permissions/privileges assigned to pghoard, this could allow disclosure of sensitive information.
GitHub Security Advisory: GHSA-c33w-24p9-8m24
Package: configobj (PIP)
Severity: LOW (CVSS 3.7)
CWE: CWE-1333: Inefficient Regular Expression Complexity
Vulnerable versions: < 5.0.9
Patched in: 5.0.9

Summary: configobj ReDoS exploitable by developer using values in a server-side configuration file

Details:
All versions of the package configobj are vulnerable to Regular Expression Denial of Service (ReDoS) via the validate function, using (.+?)\((.*)\). **Note:** This is only exploitable in the case of a developer, putting the offending value in a server side configuration file.
GitHub Security Advisory: GHSA-v49p-m6gh-747c
Package: djoser (PIP)
Severity: HIGH (CVSS 7.1)
CWE: CWE-287: Improper Authentication, CWE-295: Improper Certificate Validation
Vulnerable versions: < 2.3.0
Patched in: 2.3.0

Summary: djoser Authentication Bypass

Details:
Versions of the package djoser before 2.3.0 are vulnerable to Authentication Bypass when the authenticate() function fails. This is because the system falls back to querying the database directly, granting access to users with valid credentials, and eventually bypassing custom authentication checks such as two-factor authentication, LDAP validations, or requirements from configured AUTHENTICATION_BACKENDS.