Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 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=Falclass 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_saltself.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 = 16padding_length = block_size - (len(data) % block_size)@@ -71,5 +95,15 @@ class AES(BaseEncryptor):return data + paddingdef _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.pynew file mode 100644index 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"