From f295e9f34207bb79f1fccacdb1fd56ef10cc8409 Mon Sep 17 00:00:00 2001 From: mateo-berri <277851410+mateo-berri@users.noreply.github.com> Date: Thu, 29 Oct 2026 11:58:51 -0700 Subject: [PATCH] fix(bedrock): sign an explicit AWS key pair with only its own session token --- litellm/llms/bedrock/base_aws_llm.py | 27 ++++++--- tests/unit/llms/bedrock/test_base_aws_llm.py | 58 +++++++++++++++++++ .../test_opensearch_transformation.py | 23 ++++++++ 3 files changed, 100 insertions(+), 8 deletions(-) diff --git a/litellm/llms/bedrock/base_aws_llm.py b/litellm/llms/bedrock/base_aws_llm.py index 9591b962ab5..58a281cd67b 100644 --- a/litellm/llms/bedrock/base_aws_llm.py +++ b/litellm/llms/bedrock/base_aws_llm.py @@ -368,6 +368,13 @@ class BaseAWSLLM(SignsRequestsWithAWS): ) -> bool: return aws_access_key_id is not None and aws_secret_access_key is not None and aws_region_name is not None + @staticmethod + def _env_session_token_for_key_pair(aws_access_key_id: str | None, aws_secret_access_key: str | None) -> str | None: + env_key_pair: Final = (os.getenv("AWS_ACCESS_KEY_ID"), os.getenv("AWS_SECRET_ACCESS_KEY")) + if (aws_access_key_id, aws_secret_access_key) != env_key_pair: + return None + return os.getenv("AWS_SESSION_TOKEN") + @tracer.wrap() def get_credentials( self, @@ -391,11 +398,11 @@ class BaseAWSLLM(SignsRequestsWithAWS): # os.environ/ references in the model config are resolved at load time, # so any reference still present at this point is caller-supplied input and is # left as-is rather than expanded into a process environment variable. Each - # unset param falls back to its matching fixed AWS_* ambient env var. + # unset param falls back to its matching fixed AWS_* ambient env var, except the + # session token, which belongs to the env key pair and is only used beside it. ( aws_access_key_id, aws_secret_access_key, - aws_session_token, aws_region_name, aws_session_name, aws_profile_name, @@ -408,7 +415,6 @@ class BaseAWSLLM(SignsRequestsWithAWS): for value, env_var in ( (aws_access_key_id, "AWS_ACCESS_KEY_ID"), (aws_secret_access_key, "AWS_SECRET_ACCESS_KEY"), - (aws_session_token, "AWS_SESSION_TOKEN"), (aws_region_name, "AWS_REGION_NAME"), (aws_session_name, "AWS_SESSION_NAME"), (aws_profile_name, "AWS_PROFILE_NAME"), @@ -418,6 +424,11 @@ class BaseAWSLLM(SignsRequestsWithAWS): (aws_external_id, "AWS_EXTERNAL_ID"), ) ) + session_token: Final = ( + aws_session_token + if aws_session_token is not None + else self._env_session_token_for_key_pair(aws_access_key_id, aws_secret_access_key) + ) session_tags: Final = _canonical_aws_session_tags(aws_session_tags) verbose_logger.debug( @@ -435,7 +446,7 @@ class BaseAWSLLM(SignsRequestsWithAWS): "aws_session_tags=%s", aws_access_key_id is not None, aws_secret_access_key is not None, - aws_session_token is not None, + session_token is not None, aws_region_name, aws_session_name, aws_profile_name, @@ -449,7 +460,7 @@ class BaseAWSLLM(SignsRequestsWithAWS): args: Final = { "aws_access_key_id": aws_access_key_id, "aws_secret_access_key": aws_secret_access_key, - "aws_session_token": aws_session_token, + "aws_session_token": session_token, "aws_region_name": aws_region_name, "aws_session_name": aws_session_name, "aws_profile_name": aws_profile_name, @@ -495,7 +506,7 @@ class BaseAWSLLM(SignsRequestsWithAWS): lambda: self._resolve_role_credentials( aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, - aws_session_token=aws_session_token, + aws_session_token=session_token, aws_role_name=cast(str, aws_role_name), aws_session_name=aws_session_name, aws_region_name=aws_region_name, @@ -512,12 +523,12 @@ class BaseAWSLLM(SignsRequestsWithAWS): elif self._is_auth_with_aws_session_token_tuple( aws_access_key_id, aws_secret_access_key, - aws_session_token, + session_token, ): credentials, _cache_ttl = self._auth_with_aws_session_token( aws_access_key_id=cast(str, aws_access_key_id), aws_secret_access_key=cast(str, aws_secret_access_key), - aws_session_token=cast(str, aws_session_token), + aws_session_token=cast(str, session_token), ) return credentials elif self._is_auth_with_access_key_and_secret_key( diff --git a/tests/unit/llms/bedrock/test_base_aws_llm.py b/tests/unit/llms/bedrock/test_base_aws_llm.py index c220e39f4d1..3b512a74c6c 100644 --- a/tests/unit/llms/bedrock/test_base_aws_llm.py +++ b/tests/unit/llms/bedrock/test_base_aws_llm.py @@ -222,6 +222,64 @@ def test_get_credentials_falls_back_to_ambient_aws_profile_name_env(): assert mock_profile.call_args.args[0] == "ambient-profile" +ENV_ACCESS_KEY: Final = "ASIAENVIDENTITY" +ENV_SECRET_KEY: Final = "env-identity-secret" +ENV_SESSION_TOKEN: Final = "env-identity-session-token" + + +@pytest.mark.parametrize( + "credential_params,expected_access_key,expected_session_token", + [ + pytest.param( + {"aws_access_key_id": "AKIADEPLOYMENT", "aws_secret_access_key": "deployment-secret"}, + "AKIADEPLOYMENT", + None, + id="deployment-key-pair-without-token", + ), + pytest.param( + { + "aws_access_key_id": "ASIADEPLOYMENT", + "aws_secret_access_key": "deployment-secret", + "aws_session_token": "deployment-session-token", + }, + "ASIADEPLOYMENT", + "deployment-session-token", + id="deployment-key-pair-with-its-own-token", + ), + pytest.param( + {"aws_access_key_id": ENV_ACCESS_KEY, "aws_secret_access_key": ENV_SECRET_KEY}, + ENV_ACCESS_KEY, + ENV_SESSION_TOKEN, + id="config-references-the-env-key-pair", + ), + pytest.param({}, ENV_ACCESS_KEY, ENV_SESSION_TOKEN, id="ambient-env-key-pair"), + ], +) +def test_bedrock_request_carries_only_the_session_token_of_the_key_pair_that_signs_it( + credential_params: Dict[str, str], + expected_access_key: str, + expected_session_token: Optional[str], +): + env = { + **_os_environ_without_aws_keys(), + "AWS_ACCESS_KEY_ID": ENV_ACCESS_KEY, + "AWS_SECRET_ACCESS_KEY": ENV_SECRET_KEY, + "AWS_SESSION_TOKEN": ENV_SESSION_TOKEN, + } + with patch.dict(os.environ, env, clear=True): + headers, _ = BaseAWSLLM()._sign_request( + service_name="bedrock", + headers={}, + optional_params={**credential_params, "aws_region_name": "us-west-2"}, + request_data={"messages": [{"role": "user", "content": [{"text": "hi"}]}]}, + api_base="https://bedrock-runtime.us-west-2.amazonaws.com/model/anthropic.claude-sonnet-4-6/converse", + ) + + lowered: Final = {name.lower(): value for name, value in headers.items()} + assert lowered["authorization"].startswith(f"AWS4-HMAC-SHA256 Credential={expected_access_key}/") + assert lowered.get("x-amz-security-token") == expected_session_token + + def test_get_credentials_ambient_fallback_resolves_aws_external_id(): """ Each unset param falls back to its own AWS_* env var. Regression for an index diff --git a/tests/unit/llms/opensearch/vector_stores/test_opensearch_transformation.py b/tests/unit/llms/opensearch/vector_stores/test_opensearch_transformation.py index 07836d57af0..213e9b8f4ba 100644 --- a/tests/unit/llms/opensearch/vector_stores/test_opensearch_transformation.py +++ b/tests/unit/llms/opensearch/vector_stores/test_opensearch_transformation.py @@ -353,6 +353,29 @@ def test_failing_credential_source_is_a_401_that_keeps_its_output_out_of_the_rep assert CREDENTIAL_SOURCE_OUTPUT not in str(error.value) +@pytest.mark.parametrize("asynchronous", [False, True]) +@pytest.mark.parametrize( + "store_session_token", + [pytest.param({}, id="store-keys-without-token"), pytest.param({"aws_session_token": "store-token"}, id="own-token")], +) +@pytest.mark.asyncio +async def test_store_keys_are_never_signed_with_the_ambient_session_token( + asynchronous: bool, store_session_token: Mapping[str, str], monkeypatch: pytest.MonkeyPatch +) -> None: + for name in _AMBIENT_AWS_ENV: + monkeypatch.delenv(name, raising=False) + monkeypatch.setenv("AWS_ACCESS_KEY_ID", "ASIAAMBIENTIDENTITY") + monkeypatch.setenv("AWS_SECRET_ACCESS_KEY", "ambient-secret") + monkeypatch.setenv("AWS_SESSION_TOKEN", "ambient-session-token") + respond: Final = MagicMock(return_value=httpx.Response(200, json=_opensearch_hits("text", "embedding"))) + + await _search(asynchronous, respond, RecordingEmbeddingExecutor(), store_session_token) + + sent: Final = _sent(respond) + assert _signature_scope(sent[0]) == ("aoss", "us-east-1") + assert sent[0].headers.get("x-amz-security-token") == store_session_token.get("aws_session_token") + + @pytest.mark.parametrize("asynchronous", [False, True]) @pytest.mark.asyncio async def test_opensearch_index_name_picks_the_index_so_the_store_id_can_differ(asynchronous: bool) -> None: