Severity:

HIGH RISK

(7.1)

Unsafe Deserialization in Amazon Braket SDK Job Results

CVE-2026-9291

Awaiting Analysis

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution

Severity:

HIGH RISK

(7.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Insecure deserialization in the job results processing component of the Amazon Braket SDK before version 1.117.0 allows untrusted job output data from S3 to be deserialized in an unsafe manner.

An authenticated attacker with write access to the job output S3 bucket may craft malicious result artifacts that trigger arbitrary code execution on any machine that processes those job results.

Affected context

This vulnerability arises in environments using vulnerable versions of the Amazon Braket SDK to process job results stored in S3.

It particularly affects workflows where:

  • Job results are written to an S3 bucket accessible by multiple parties or automated systems
  • The SDK is used to automatically fetch and deserialize job results
  • There is limited isolation between the machine processing job outputs and other internal systems

The risk is higher in shared or multi-tenant setups where S3 write permissions are broader than strictly needed.

Exploit preconditions

  • Attack surface: Machines (e.g., application servers, CI runners, analysis nodes) that use the Amazon Braket SDK < 1.117.0 to download and process job results from S3.
  • Required access: Authenticated write access to the S3 bucket that stores Braket job outputs, or the ability to replace/overwrite job result objects.
  • Trigger point: Execution occurs when the vulnerable SDK retrieves and deserializes the job result payload, treating the content as trusted serialized data.
  • Why exploitation is possible: The job results deserialization logic assumes that data from the S3 output bucket is trustworthy and uses a general-purpose deserialization mechanism that can instantiate arbitrary objects or trigger object behaviors during deserialization.

Why this happens

The core issue is the use of a generic object deserialization mechanism on data that can be influenced by external actors.

Instead of treating job results as purely data and decoding them with a constrained or schema-validated parser, the component appears to deserialize structured content into objects capable of executing code or invoking callbacks during construction.

This pattern maps directly to CWE-502: Deserialization of Untrusted Data, where serialized input from a less-trusted boundary (S3 job outputs) is treated as safe and rehydrated into in-memory objects without sufficient validation or type restrictions.

Potential impact

  • Arbitrary code execution on machines that process Braket job results
  • Compromise of analysis or orchestration nodes that rely on the SDK
  • Lateral movement inside the environment where the result processing machine has additional access
  • Data exfiltration or manipulation of other workloads running on the same host
  • Disruption of quantum/job processing pipelines and potential tampering with scientific or analytical results

General mitigation guidance

Effective mitigation focuses on reducing trust in externally stored serialized data and tightening deserialization behavior:

  • Prefer data-only formats (e.g., JSON, strictly-typed schemas) and avoid general object deserialization for job result handling.
  • Enforce strict type whitelists or bounded deserialization mechanisms that cannot instantiate arbitrary classes or execute callbacks during object construction.
  • Treat S3 job output buckets as untrusted or semi-trusted sources; validate and sanitize any data loaded from them before using it.
  • Isolate job result processing into constrained environments (e.g., sandboxes or containers) with least-privilege permissions, limiting the blast radius of any potential code execution.
  • Apply robust IAM policies to narrow who and what can write to job output buckets, reducing opportunities for malicious content injection.

How teams detect issues like this

Organizations can detect and manage similar issues by combining code-level and operational monitoring:

  • Static analysis: Configure rules to flag unsafe deserialization APIs and patterns, especially where data originates from cloud storage, message queues, or other remote sources.
  • Code review signals: Treat any use of generic deserialization in result-processing or pipeline components as high-risk and require explicit justification, type constraints, and input validation.
  • Policy enforcement: Embed security checks in CI/CD that disallow the introduction of insecure deserialization primitives or require approval when they are modified.
  • Runtime monitoring: Monitor systems that process job results for anomalous processes, unexpected network connections, or unusual file activity that might indicate code execution stemming from data ingestion.
  • Inventory and dependency tracking: Maintain an inventory of services using the Amazon Braket SDK and monitor for outdated versions, integrating this with software composition analysis tools.

Sources

SourceLink
aws.amazon.comaws.amazon.com/security/security-bulletins/2026-036-aws/
github.comgithub.com/amazon-braket/amazon-braket-sdk-python/releases/tag/v1.117.0
github.comgithub.com/amazon-braket/amazon-braket-sdk-python/security/advisories/GHSA-g697-2xrc-gc46

Frequently asked

questions

Yes, but it is constrained: an attacker must have authenticated write access to the S3 bucket that stores job outputs. From there, they can craft malicious job result payloads that are processed by vulnerable clients.

The attacker needs the ability to write or overwrite objects in the S3 job output bucket consumed by the Amazon Braket SDK. They do not necessarily need access to the machines processing results, only the ability to influence the data those machines read.

The safest pattern is to avoid general-purpose deserialization of untrusted data altogether and instead use constrained, data-only formats with well-defined schemas. Where deserialization is unavoidable, enforce strict type whitelisting, add input validation, and ensure the deserialization environment is highly restricted.

Adopt a design rule that treats all external data sources (including cloud storage like S3) as untrusted, avoid using serialization mechanisms that can instantiate arbitrary objects, and embed secure coding standards into review and CI pipelines so that unsafe deserialization patterns are identified and rejected early.

Find out what's already
exploitable in your codebase.