From 5d7ed2be9c3082a55adbb658598d32db84cd9e04 Mon Sep 17 00:00:00 2001 From: Saquib Jawed <138011435+saquibjawedbit@users.noreply.github.com> Date: Sun, 15 Nov 2026 23:02:45 +0530 Subject: [PATCH] fix(parameters): ignore malformed POWERTOOLS_PARAMETERS_SSM_DECRYPT instead of crashing An empty or unparsable value made every SSM lookup raise ValueError before any API call. The six SSM entry points now read the variable through the shared resolve_bool_env_var, which warns with PowertoolsUserWarning and falls back to False. An explicit decrypt argument still takes precedence and the variable is not read. --- .../utilities/parameters/ssm.py | 39 ++---- .../_boto3/test_utilities_parameters.py | 120 ++++++++++++++++++ 2 files changed, 133 insertions(+), 26 deletions(-) diff --git a/aws_lambda_powertools/utilities/parameters/ssm.py b/aws_lambda_powertools/utilities/parameters/ssm.py index 35b56d4c089..e8dd6941629 100644 --- a/aws_lambda_powertools/utilities/parameters/ssm.py +++ b/aws_lambda_powertools/utilities/parameters/ssm.py @@ -5,7 +5,6 @@ from __future__ import annotations import logging -import os import warnings from typing import TYPE_CHECKING, Any, Literal, overload @@ -13,7 +12,7 @@ from aws_lambda_powertools.shared import constants from aws_lambda_powertools.shared.functions import ( - resolve_truthy_env_var_choice, + resolve_bool_env_var, slice_dictionary, ) from aws_lambda_powertools.utilities.parameters.base import ( @@ -183,10 +182,8 @@ def get_multiple( # type: ignore[override] # ty: ignore[invalid-method-overrid max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) sdk_options["decrypt"] = decrypt sdk_options["recursive"] = recursive @@ -237,10 +234,8 @@ def get( # type: ignore[override] # ty: ignore[invalid-method-override] max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) # Add to `decrypt` sdk_options to we can have an explicit option for this sdk_options["decrypt"] = decrypt @@ -492,10 +487,8 @@ def get_parameters_by_name( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) # Init potential batch/decrypt batch responses and errors batch_ret: dict[str, Any] = {} @@ -883,10 +876,8 @@ def get_parameter( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) return DEFAULT_PROVIDERS["ssm"].get( name=name, @@ -1021,10 +1012,8 @@ def get_parameters( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) return DEFAULT_PROVIDERS["ssm"].get_multiple( path=path, @@ -1217,10 +1206,8 @@ def get_parameters_by_name( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) # Only create the provider if this function is called at least once if "ssm" not in DEFAULT_PROVIDERS: diff --git a/tests/functional/parameters/_boto3/test_utilities_parameters.py b/tests/functional/parameters/_boto3/test_utilities_parameters.py index a7482896988..14990ab180c 100644 --- a/tests/functional/parameters/_boto3/test_utilities_parameters.py +++ b/tests/functional/parameters/_boto3/test_utilities_parameters.py @@ -5,6 +5,7 @@ import random import string import uuid +import warnings from datetime import datetime, timedelta from io import BytesIO from typing import Any @@ -4817,3 +4818,122 @@ def test_secrets_provider_get_multiple_only_prefix_matches(config): provider.get_multiple(["db"]) assert not provider.store stubber.assert_no_pending_responses() + + +SSM_DECRYPT_PARAM_PATH = "/app" +SSM_DECRYPT_PARAM_NAME = "/app/param" +SSM_DECRYPT_PARAM_VALUE = "value" +SSM_DECRYPT_ENTRY_POINTS = [ + "SSMProvider.get", + "SSMProvider.get_multiple", + "SSMProvider.get_parameters_by_name", + "get_parameter", + "get_parameters", + "get_parameters_by_name", +] + + +def stub_ssm_lookup(stubber: stub.Stubber, entry_point: str, decrypt: bool) -> None: + if entry_point in ("SSMProvider.get", "get_parameter"): + response = { + "Parameter": { + "Name": SSM_DECRYPT_PARAM_NAME, + "Type": "String", + "Value": SSM_DECRYPT_PARAM_VALUE, + "Version": 1, + }, + } + stubber.add_response("get_parameter", response, {"Name": SSM_DECRYPT_PARAM_NAME, "WithDecryption": decrypt}) + elif entry_point in ("SSMProvider.get_multiple", "get_parameters"): + response = { + "Parameters": [ + {"Name": SSM_DECRYPT_PARAM_NAME, "Type": "String", "Value": SSM_DECRYPT_PARAM_VALUE, "Version": 1}, + ], + } + expected_params = {"Path": SSM_DECRYPT_PARAM_PATH, "WithDecryption": decrypt, "Recursive": stub.ANY} + stubber.add_response("get_parameters_by_path", response, expected_params) + else: + expected_params = {"Names": [SSM_DECRYPT_PARAM_NAME]} + if decrypt: + expected_params["WithDecryption"] = True + response = build_get_parameters_stub({SSM_DECRYPT_PARAM_NAME: SSM_DECRYPT_PARAM_VALUE}) + stubber.add_response("get_parameters", response, expected_params) + + +def call_ssm_lookup(monkeypatch, provider: SSMProvider, entry_point: str, **kwargs) -> Any: + monkeypatch.setitem(parameters.base.DEFAULT_PROVIDERS, "ssm", provider) + calls = { + "SSMProvider.get": lambda: provider.get(SSM_DECRYPT_PARAM_NAME, **kwargs), + "SSMProvider.get_multiple": lambda: provider.get_multiple(SSM_DECRYPT_PARAM_PATH, **kwargs), + "SSMProvider.get_parameters_by_name": lambda: provider.get_parameters_by_name( + parameters={SSM_DECRYPT_PARAM_NAME: {}}, + **kwargs, + ), + "get_parameter": lambda: parameters.get_parameter(SSM_DECRYPT_PARAM_NAME, **kwargs), + "get_parameters": lambda: parameters.get_parameters(SSM_DECRYPT_PARAM_PATH, **kwargs), + "get_parameters_by_name": lambda: parameters.get_parameters_by_name( + parameters={SSM_DECRYPT_PARAM_NAME: {}}, + **kwargs, + ), + } + return calls[entry_point]() + + +@pytest.mark.parametrize("entry_point", SSM_DECRYPT_ENTRY_POINTS) +@pytest.mark.parametrize("env_value", ["", "maybe"]) +def test_ssm_lookup_with_invalid_decrypt_env_var_warns_and_does_not_decrypt( + monkeypatch, + config, + entry_point, + env_value, +): + # GIVEN POWERTOOLS_PARAMETERS_SSM_DECRYPT is set to an empty or invalid value + monkeypatch.setenv("POWERTOOLS_PARAMETERS_SSM_DECRYPT", env_value) + provider = SSMProvider(boto_config=config) + + # WHEN a parameter is fetched without an explicit decrypt argument + with stub.Stubber(provider.client) as stubber: + stub_ssm_lookup(stubber, entry_point, decrypt=False) + with pytest.warns(PowertoolsUserWarning, match="POWERTOOLS_PARAMETERS_SSM_DECRYPT"): + value = call_ssm_lookup(monkeypatch, provider, entry_point) + + # THEN the lookup succeeds without decryption + stubber.assert_no_pending_responses() + + assert SSM_DECRYPT_PARAM_VALUE in (value if isinstance(value, str) else list(value.values())) + + +@pytest.mark.parametrize("entry_point", SSM_DECRYPT_ENTRY_POINTS) +@pytest.mark.parametrize("env_value, expected_decrypt", [("true", True), ("1", True), ("false", False), ("0", False)]) +def test_ssm_lookup_with_valid_decrypt_env_var(monkeypatch, config, entry_point, env_value, expected_decrypt): + # GIVEN POWERTOOLS_PARAMETERS_SSM_DECRYPT is set to a valid boolean value + monkeypatch.setenv("POWERTOOLS_PARAMETERS_SSM_DECRYPT", env_value) + provider = SSMProvider(boto_config=config) + + # WHEN a parameter is fetched without an explicit decrypt argument + with stub.Stubber(provider.client) as stubber: + stub_ssm_lookup(stubber, entry_point, decrypt=expected_decrypt) + with warnings.catch_warnings(): + warnings.simplefilter("error", PowertoolsUserWarning) + call_ssm_lookup(monkeypatch, provider, entry_point) + + # THEN decryption follows the environment variable, with no warning + stubber.assert_no_pending_responses() + + +@pytest.mark.parametrize("entry_point", SSM_DECRYPT_ENTRY_POINTS) +@pytest.mark.parametrize("decrypt", [True, False]) +def test_ssm_lookup_explicit_decrypt_wins_over_invalid_decrypt_env_var(monkeypatch, config, entry_point, decrypt): + # GIVEN POWERTOOLS_PARAMETERS_SSM_DECRYPT is set to an invalid value + monkeypatch.setenv("POWERTOOLS_PARAMETERS_SSM_DECRYPT", "maybe") + provider = SSMProvider(boto_config=config) + + # WHEN a parameter is fetched with an explicit decrypt argument + with stub.Stubber(provider.client) as stubber: + stub_ssm_lookup(stubber, entry_point, decrypt=decrypt) + with warnings.catch_warnings(): + warnings.simplefilter("error", PowertoolsUserWarning) + call_ssm_lookup(monkeypatch, provider, entry_point, decrypt=decrypt) + + # THEN the explicit argument is used and the environment variable is not read + stubber.assert_no_pending_responses()