Skip to content

Automate browser based workflows with AI

feat(SKY-9503/9504): AES multi-key decrypt + per-env ENCRYPTOR_AES_{SALT,IV} secrets (#5822)

Aaron Perez817c4cda6085
diff --git a/skyvern/forge/sdk/encrypt/aes.py b/skyvern/forge/sdk/encrypt/aes.py
index e0210440d..ca67b0d35 100644
--- a/skyvern/forge/sdk/encrypt/aes.py
+++ b/skyvern/forge/sdk/encrypt/aes.py
@@ -24,19 +24,33 @@ default_salt = hashlib.md5(b"deterministic_salt_0123456789", usedforsecurity=Fal
class AES(BaseEncryptor):
- def __init__(self, *, secret_key: str, salt: str | None = None, iv: str | None = None) -> None:
+ def __init__(
+ self,
+ *,
+ secret_key: str,
+ salt: str | None = None,
+ iv: str | None = None,
+ fallback_decrypt_keys: list[tuple[str, str]] | None = None,
+ ) -> None:
self.secret_key = hashlib.md5(secret_key.encode("utf-8"), usedforsecurity=False).digest()
self.salt = hashlib.md5(salt.encode("utf-8"), usedforsecurity=False).digest() if salt else default_salt
self.iv = hashlib.md5(iv.encode("utf-8")).digest() if iv else default_iv
+ self._fallback_decrypt_params: list[tuple[bytes, bytes]] = [
+ (
+ hashlib.md5(fb_salt.encode("utf-8"), usedforsecurity=False).digest(),
+ hashlib.md5(fb_iv.encode("utf-8")).digest(),
+ )
+ for fb_salt, fb_iv in (fallback_decrypt_keys or [])
+ ]
def method(self) -> EncryptMethod:
return EncryptMethod.AES
- def _derive_key(self) -> bytes:
+ def _derive_key(self, salt: bytes | None = None) -> bytes:
kdf = PBKDF2HMAC(
algorithm=hashes.SHA256(),
length=32,
- salt=self.salt,
+ salt=salt if salt is not None else self.salt,
iterations=100000,
)
return kdf.derive(self.secret_key)
@@ -55,15 +69,25 @@ class AES(BaseEncryptor):
async def decrypt(self, ciphertext: str) -> str:
try:
encrypted_data = base64.b64decode(ciphertext.encode("utf-8"))
- key = self._derive_key()
- cipher = Cipher(algorithms.AES(key), modes.CBC(self.iv))
- decryptor = cipher.decryptor()
- padded_plaintext = decryptor.update(encrypted_data) + decryptor.finalize()
- plaintext = self._unpad(padded_plaintext)
- return plaintext.decode("utf-8")
except Exception as e:
raise Exception("Failed to decrypt token") from e
+ candidates: list[tuple[bytes, bytes]] = [(self.salt, self.iv), *self._fallback_decrypt_params]
+ last_error: Exception | None = None
+ for salt, iv in candidates:
+ try:
+ key = self._derive_key(salt=salt)
+ cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
+ decryptor = cipher.decryptor()
+ padded_plaintext = decryptor.update(encrypted_data) + decryptor.finalize()
+ plaintext = self._unpad(padded_plaintext)
+ return plaintext.decode("utf-8")
+ except Exception as e:
+ last_error = e
+ continue
+
+ raise Exception("Failed to decrypt token") from last_error
+
def _pad(self, data: bytes) -> bytes:
block_size = 16
padding_length = block_size - (len(data) % block_size)
@@ -71,5 +95,15 @@ class AES(BaseEncryptor):
return data + padding
def _unpad(self, data: bytes) -> bytes:
+ # Strict PKCS#7 validation. Rejecting malformed trailers is what lets the
+ # multi-key decrypt loop in ``decrypt`` distinguish wrong-key garbage from
+ # a legitimate plaintext when no AEAD/HMAC is in play.
+ block_size = 16
+ if not data:
+ raise ValueError("invalid padding: empty data")
padding_length = data[-1]
+ if padding_length < 1 or padding_length > block_size or padding_length > len(data):
+ raise ValueError("invalid padding: length out of range")
+ if data[-padding_length:] != bytes([padding_length] * padding_length):
+ raise ValueError("invalid padding: trailer mismatch")
return data[:-padding_length]
diff --git a/tests/unit/test_aes_fallback_decrypt.py b/tests/unit/test_aes_fallback_decrypt.py
new file mode 100644
index 000000000..27a0eafd2
--- /dev/null
+++ b/tests/unit/test_aes_fallback_decrypt.py
@@ -0,0 +1,74 @@
+import pytest
+
+from skyvern.forge.sdk.encrypt.aes import AES
+
+SECRET = "test-secret-key"
+PRIMARY_SALT = "primary_salt_value_xxxxxxxxxxxxxxx"
+PRIMARY_IV = "primary_iv_xxxxxxxxx"
+PRIOR_SALT = "prior_salt_value_xxxxxxxxxxxxxxxxx"
+PRIOR_IV = "prior_iv_value_xxxxx"
+
+
+async def test_decrypt_with_legacy_fallback_after_rotation() -> None:
+ legacy = AES(secret_key=SECRET, salt=PRIOR_SALT, iv=PRIOR_IV)
+ ciphertext = await legacy.encrypt("hello world")
+
+ rotated = AES(
+ secret_key=SECRET,
+ salt=PRIMARY_SALT,
+ iv=PRIMARY_IV,
+ fallback_decrypt_keys=[(PRIOR_SALT, PRIOR_IV)],
+ )
+ assert await rotated.decrypt(ciphertext) == "hello world"
+
+
+async def test_decrypt_uses_primary_first_when_round_tripping() -> None:
+ aes = AES(
+ secret_key=SECRET,
+ salt=PRIMARY_SALT,
+ iv=PRIMARY_IV,
+ fallback_decrypt_keys=[(PRIOR_SALT, PRIOR_IV)],
+ )
+ ciphertext = await aes.encrypt("primary path")
+ assert await aes.decrypt(ciphertext) == "primary path"
+
+
+async def test_decrypt_raises_after_exhausting_all_keys() -> None:
+ legacy = AES(secret_key=SECRET, salt=PRIOR_SALT, iv=PRIOR_IV)
+ ciphertext = await legacy.encrypt("unreachable")
+
+ mismatched = AES(
+ secret_key=SECRET,
+ salt=PRIMARY_SALT,
+ iv=PRIMARY_IV,
+ fallback_decrypt_keys=[("another_salt_xxxxxxxxxxxx", "another_iv_xxxxxxxx")],
+ )
+ with pytest.raises(Exception, match="Failed to decrypt token"):
+ await mismatched.decrypt(ciphertext)
+
+
+async def test_decrypt_without_fallbacks_still_works() -> None:
+ aes = AES(secret_key=SECRET, salt=PRIMARY_SALT, iv=PRIMARY_IV)
+ ciphertext = await aes.encrypt("no fallbacks")
+ assert await aes.decrypt(ciphertext) == "no fallbacks"
+
+
+async def test_decrypt_tries_multiple_fallbacks_in_order() -> None:
+ legacy = AES(secret_key=SECRET, salt=PRIOR_SALT, iv=PRIOR_IV)
+ ciphertext = await legacy.encrypt("third match")
+
+ aes = AES(
+ secret_key=SECRET,
+ salt=PRIMARY_SALT,
+ iv=PRIMARY_IV,
+ fallback_decrypt_keys=[
+ ("never_used_salt_xxxxxxxxx", "never_used_iv_xxxxx"),
+ (PRIOR_SALT, PRIOR_IV),
+ ],
+ )
+ assert await aes.decrypt(ciphertext) == "third match"