alt-python-pysypt 1.0.0__tar.gz

alt_python_pysypt-1.0.0/.gitignore

@@ -0,0 +1,30 @@
+
+# ── GSD baseline (auto-generated) ──
+.gsd
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+*~
+.idea/
+.vscode/
+*.code-workspace
+.env
+.env.*
+!.env.example
+node_modules/
+.next/
+dist/
+build/
+__pycache__/
+*.pyc
+.venv/
+venv/
+target/
+vendor/
+*.log
+coverage/
+.cache/
+tmp/
+.bg_shell
+/.bg-shell/

alt_python_pysypt-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: alt-python-pysypt
+Version: 1.0.0
+Summary: Jasypt-compatible PBE encryption and digest for Python
+Requires-Python: >=3.12
+Requires-Dist: alt-python-common
+Requires-Dist: cryptography>=42.0

alt_python_pysypt-1.0.0/README.md

@@ -0,0 +1,261 @@
+# pysypt
+
+[![Language](https://img.shields.io/badge/language-Python-3776ab.svg)](https://www.python.org/)
+[![Python](https://img.shields.io/badge/python-3.12%2B-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+Jasypt-compatible password-based encryption (PBE) and iterated-hash digest for
+Python. Interoperable with Spring Boot applications that use `ENC(...)` encrypted
+configuration values.
+
+Port of [`@alt-javascript/jasypt`](https://github.com/alt-javascript/jasypt) to
+Python.
+
+## Install
+
+```bash
+uv add pysypt        # or: pip install pysypt
+```
+
+Requires Python 3.12+ and `cryptography` >= 42.
+
+## Quick Start
+
+```python
+from pysypt import Jasypt
+
+jasypt = Jasypt()
+
+# Encrypt and decrypt
+ciphertext = jasypt.encrypt("admin", "mySecretKey")
+plaintext  = jasypt.decrypt(ciphertext, "mySecretKey")
+# plaintext == "admin"
+
+# One-way digest
+stored = jasypt.digest("admin")
+jasypt.matches("admin", stored)  # True
+jasypt.matches("wrong", stored)  # False
+```
+
+## API
+
+### `Jasypt`
+
+High-level facade. Each method constructs a fresh `Encryptor` or `Digester`
+internally — the `Jasypt` class is stateless and thread-safe.
+
+#### `jasypt.encrypt(message, password, algorithm="PBEWITHMD5ANDDES", iterations=1000, salt=None)`
+
+Encrypts a plaintext string. Returns a base64-encoded ciphertext with the salt
+prepended.
+
+Returns `None` if `message` is empty or `None`.
+
+```python
+jasypt.encrypt("admin", "secret")
+# => "nsbC5r0ymz740/aURtuRWw=="
+
+jasypt.encrypt("admin", "secret", algorithm="PBEWITHHMACSHA256ANDAES_256")
+# => "K3q8z..."  (AES-256-CBC, PBKDF2-SHA256)
+```
+
+#### `jasypt.decrypt(encrypted_message, password="", algorithm="PBEWITHMD5ANDDES", iterations=1000, salt=None)`
+
+Decrypts a base64-encoded ciphertext. The salt is extracted from the ciphertext
+automatically.
+
+Returns `None` if `encrypted_message` is empty or `None`.
+
+```python
+jasypt.decrypt("nsbC5r0ymz740/aURtuRWw==", "secret")
+# => "admin"
+```
+
+#### `jasypt.digest(message, salt=None, iterations=1000, algorithm="SHA-256")`
+
+Produces a one-way hash. Returns `base64(salt_bytes + hash_bytes)`.
+
+Returns `None` if `message` is empty or `None`.
+
+```python
+stored = jasypt.digest("admin")
+```
+
+#### `jasypt.matches(message, stored_digest, salt=None, iterations=1000, algorithm="SHA-256")`
+
+Verifies a plaintext message against a stored digest. Uses constant-time
+comparison.
+
+Returns `None` if `message` is empty or `None`.
+
+```python
+stored = jasypt.digest("admin")
+jasypt.matches("admin", stored)  # True
+jasypt.matches("wrong", stored)  # False
+```
+
+---
+
+### `Encryptor`
+
+Low-level class for direct control over encryption parameters.
+
+```python
+from pysypt import Encryptor
+
+enc = Encryptor(
+    algorithm="PBEWITHHMACSHA256ANDAES_256",
+    iterations=10000,
+)
+
+ciphertext = enc.encrypt("admin", "secret")
+plaintext  = enc.decrypt(ciphertext, "secret")
+```
+
+#### Constructor
+
+```python
+Encryptor(algorithm="PBEWITHMD5ANDDES", salt=None, iterations=1000)
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `algorithm` | `str` | `PBEWITHMD5ANDDES` | PBE algorithm name (see table below) |
+| `salt` | `bytes \| None` | random | Salt bytes. `None` generates a random salt of the correct length. |
+| `iterations` | `int` | `1000` | KDF iteration count |
+
+#### Methods
+
+| Method | Description |
+|---|---|
+| `set_algorithm(algorithm)` | Change the algorithm. Raises `ValueError` for unsupported names. |
+| `set_salt(salt)` | Set the salt. Accepts `bytes`, `str` (UTF-8 encoded), or `None` (random). Short salts are zero-padded; long salts are truncated to the required length. |
+| `set_iterations(iterations)` | Set the iteration count. |
+| `encrypt(payload, password, salt=None, iterations=None)` | Encrypt. Returns base64 string. |
+| `decrypt(payload, password, iterations=None)` | Decrypt. Returns plaintext string. |
+
+---
+
+### `Digester`
+
+Low-level class for direct control over digest parameters.
+
+```python
+from pysypt import Digester
+
+d = Digester(algorithm="SHA-512", iterations=5000)
+d.set_salt("fixedsalt")
+
+stored   = d.digest("admin")
+is_match = d.matches("admin", stored)  # True
+```
+
+#### Constructor
+
+```python
+Digester(algorithm="SHA-256", salt=None, iterations=1000)
+```
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `algorithm` | `str` | `SHA-256` | Digest algorithm name (see table below) |
+| `salt` | `str \| None` | random per digest | Fixed salt string. If `None`, a random 8-byte salt is generated per call. |
+| `iterations` | `int` | `1000` | Hash iteration count |
+
+#### Methods
+
+| Method | Description |
+|---|---|
+| `set_algorithm(algorithm)` | Change the algorithm. Raises `ValueError` for unsupported names. |
+| `set_salt(salt)` | Set a fixed salt. |
+| `set_iterations(iterations)` | Set the iteration count. |
+| `digest(message, salt=None, iterations=None)` | Produce `base64(salt + hash)`. |
+| `matches(message, stored_digest, salt=None, iterations=None)` | Constant-time verification. |
+
+---
+
+## Supported Algorithms
+
+### Encryption
+
+| Algorithm | Type | Notes |
+|---|---|---|
+| `PBEWITHMD5ANDDES` | PBE1 | Default. EVP_BytesToKey KDF + DES-CBC. See [ADR-005](../../docs/decisions/ADR-005-pbe1-des-emulation.md). |
+| `PBEWITHMD5ANDTRIPLEDES` | PBE1 | EVP_BytesToKey KDF + 3DES-CBC |
+| `PBEWITHSHA1ANDDESEDE` | PBE1 | EVP_BytesToKey KDF (SHA-1) + 3DES-CBC |
+| `PBEWITHHMACSHA1ANDAES_128` | PBE2 | PBKDF2-SHA1 + AES-128-CBC |
+| `PBEWITHHMACSHA1ANDAES_256` | PBE2 | PBKDF2-SHA1 + AES-256-CBC |
+| `PBEWITHHMACSHA224ANDAES_128` | PBE2 | PBKDF2-SHA224 + AES-128-CBC |
+| `PBEWITHHMACSHA224ANDAES_256` | PBE2 | PBKDF2-SHA224 + AES-256-CBC |
+| `PBEWITHHMACSHA256ANDAES_128` | PBE2 | PBKDF2-SHA256 + AES-128-CBC |
+| `PBEWITHHMACSHA256ANDAES_256` | PBE2 | PBKDF2-SHA256 + AES-256-CBC (**recommended**) |
+| `PBEWITHHMACSHA384ANDAES_128` | PBE2 | PBKDF2-SHA384 + AES-128-CBC |
+| `PBEWITHHMACSHA384ANDAES_256` | PBE2 | PBKDF2-SHA384 + AES-256-CBC |
+| `PBEWITHHMACSHA512ANDAES_128` | PBE2 | PBKDF2-SHA512 + AES-128-CBC |
+| `PBEWITHHMACSHA512ANDAES_256` | PBE2 | PBKDF2-SHA512 + AES-256-CBC |
+
+**PBE1** uses an iterative MD5/SHA-1 KDF (EVP_BytesToKey-style) with an 8-byte
+salt prepended to the ciphertext.
+
+**PBE2** uses PBKDF2 with a 16-byte salt and a random 16-byte IV, both prepended
+to the ciphertext.
+
+RC2 and RC4 variants are not supported — see
+[ADR-006](../../docs/decisions/ADR-006-rc2-rc4-omitted.md).
+
+### Digest
+
+| Algorithm | Available by default |
+|---|---|
+| `MD5` | ✅ |
+| `SHA-1` | ✅ |
+| `SHA-224` | ✅ |
+| `SHA-256` | ✅ (default) |
+| `SHA-384` | ✅ |
+| `SHA-512` | ✅ |
+| `SHA-512/224` | ✅ |
+| `SHA-512/256` | ✅ |
+| `SHA3-224` | ✅ |
+| `SHA3-256` | ✅ |
+| `SHA3-384` | ✅ |
+| `SHA3-512` | ✅ |
+| `MD2` | Rarely available |
+
+`Digester.SUPPORTED_ALGORITHMS` reflects only algorithms available in the current
+OpenSSL build. `Digester.set_algorithm("MD2")` raises `ValueError` if MD2 is
+unavailable.
+
+## Wire Format
+
+Both classes produce self-describing base64 ciphertext — the salt (and IV for
+PBE2) is stored inline so decryption requires only the password:
+
+```
+PBE1:  base64( salt[8]  + ciphertext )
+PBE2:  base64( salt[16] + iv[16]     + ciphertext )
+Digest: base64( salt[8]  + hash_bytes )
+```
+
+## Java Interoperability
+
+PBE2 algorithms (`PBEWITHHMACSHA*ANDAES_*`) are fully interoperable with Java
+jasypt. If you encrypt a value in Java using `PBEWITHHMACSHA256ANDAES_256` and
+the same password, `pysypt` will decrypt it correctly.
+
+PBE1 DES (`PBEWITHMD5ANDDES`) is **not** byte-for-byte compatible with Java due
+to the TripleDES-EDE emulation (ADR-005). Use a PBE2 algorithm for cross-language
+scenarios.
+
+## Troubleshooting
+
+**`ValueError: Unsupported algorithm: MYALGO`**
+The algorithm name is not in the supported list. Check spelling and case — names
+must match exactly (e.g. `PBEWITHHMACSHA256ANDAES_256`).
+
+**Decryption produces garbled text**
+The password or algorithm does not match what was used to encrypt. Both the
+encryptor and decryptor must use the same algorithm and password.
+
+**`ValueError: Invalid padding bytes`**
+The ciphertext is corrupt, truncated, or was encrypted with a different algorithm.
+This can also occur if the base64 string was URL-encoded and not decoded first.

alt_python_pysypt-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "alt-python-pysypt"
+version = "1.0.0"
+description = "Jasypt-compatible PBE encryption and digest for Python"
+requires-python = ">=3.12"
+dependencies = [
+    "cryptography>=42.0",
+    "alt-python-common",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["pysypt"]
+
+[tool.uv.sources]
+alt-python-common = { workspace = true }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

alt_python_pysypt-1.0.0/pysypt/__init__.py

@@ -0,0 +1,31 @@
+"""
+pysypt — Jasypt-compatible PBE encryption and digest for Python.
+
+Mirrors the JS @alt-javascript/jasypt package.
+
+Quick start::
+
+    from pysypt import Jasypt, Encryptor, Digester
+
+    jasypt = Jasypt()
+    ciphertext = jasypt.encrypt("admin", "mypassword")
+    plaintext  = jasypt.decrypt(ciphertext, "mypassword")
+
+    stored = jasypt.digest("admin")
+    assert jasypt.matches("admin", stored) is True
+"""
+
+__author__ = "Craig Parravicini"
+__collaborators__ = ["Claude (Anthropic)"]
+
+from pysypt.jasypt import Jasypt
+from pysypt.encryptor import Encryptor, SUPPORTED_ALGORITHMS
+from pysypt.digester import Digester, SUPPORTED_ALGORITHMS as SUPPORTED_DIGEST_ALGORITHMS
+
+__all__ = [
+    "Jasypt",
+    "Encryptor",
+    "Digester",
+    "SUPPORTED_ALGORITHMS",
+    "SUPPORTED_DIGEST_ALGORITHMS",
+]

alt_python_pysypt-1.0.0/pysypt/digester.py

@@ -0,0 +1,176 @@
+"""
+pysypt.digester — Jasypt-compatible iterated-hash digest.
+
+Output format: base64(salt_bytes + hash_bytes)
+  - Random salt is prepended when no fixed salt is provided.
+  - matches() extracts the salt from the stored digest for verification.
+
+Algorithm map mirrors the JS Digester ALGO_MAP.
+"""
+
+from __future__ import annotations
+
+__author__ = "Craig Parravicini"
+__collaborators__ = ["Claude (Anthropic)"]
+
+import hashlib
+import hmac as _hmac
+import os
+import base64
+from typing import Optional
+
+from common import is_empty
+
+# ---------------------------------------------------------------------------
+# Algorithm table
+# ---------------------------------------------------------------------------
+
+_ALGO_MAP: dict[str, str] = {
+    "MD2": "md2",       # may not be available
+    "MD5": "md5",
+    "SHA-1": "sha1",
+    "SHA-224": "sha224",
+    "SHA-256": "sha256",
+    "SHA-384": "sha384",
+    "SHA-512": "sha512",
+    "SHA-512/224": "sha512_224",
+    "SHA-512/256": "sha512_256",
+    "SHA3-224": "sha3_224",
+    "SHA3-256": "sha3_256",
+    "SHA3-384": "sha3_384",
+    "SHA3-512": "sha3_512",
+}
+
+_AVAILABLE = set(hashlib.algorithms_available)
+
+# Normalise hashlib naming differences (sha512_224 vs sha512-224)
+def _normalise_algo(name: str) -> Optional[str]:
+    """Return the hashlib name if available, else None."""
+    if name in _AVAILABLE:
+        return name
+    # Try underscored variant
+    alt = name.replace("-", "_")
+    if alt in _AVAILABLE:
+        return alt
+    # Try dashed variant
+    alt2 = name.replace("_", "-")
+    if alt2 in _AVAILABLE:
+        return alt2
+    return None
+
+
+def _resolve(algo_key: str) -> Optional[str]:
+    raw = _ALGO_MAP.get(algo_key)
+    if raw is None:
+        return None
+    return _normalise_algo(raw)
+
+
+SUPPORTED_ALGORITHMS: list[str] = [k for k in _ALGO_MAP if _resolve(k) is not None]
+
+
+# ---------------------------------------------------------------------------
+# Digester
+# ---------------------------------------------------------------------------
+
+class Digester:
+    """
+    Jasypt-compatible iterated-hash digester.
+
+    Default: SHA-256, 1000 iterations, random 8-byte salt.
+    """
+
+    DEFAULT_SALT_SIZE = 8
+
+    def __init__(
+        self,
+        algorithm: str = "SHA-256",
+        salt: Optional[str] = None,
+        iterations: int = 1000,
+    ) -> None:
+        self.set_algorithm(algorithm)
+        self.salt: Optional[str] = salt
+        self.salt_size = self.DEFAULT_SALT_SIZE
+        self.iterations = iterations
+
+    def set_algorithm(self, algorithm: str) -> None:
+        resolved = _resolve(algorithm)
+        if resolved is None:
+            raise ValueError(f"Unsupported digest algorithm: {algorithm}")
+        self.algorithm = algorithm
+        self._hashlib_algo = resolved
+
+    def set_salt(self, salt: Optional[str]) -> None:
+        self.salt = salt
+
+    def set_iterations(self, iterations: int) -> None:
+        self.iterations = iterations
+
+    # ------------------------------------------------------------------
+    # Core compute
+    # ------------------------------------------------------------------
+
+    def _compute(self, salt_bytes: bytes, message: str, iterations: int) -> bytes:
+        """
+        Iterated hash: first = Hash(salt + message), subsequent = Hash(digest).
+        Mirrors the JS Digester._compute().
+        """
+        msg = message.encode("utf-8")
+        digest = hashlib.new(self._hashlib_algo, salt_bytes + msg).digest()
+        for _ in range(1, iterations):
+            digest = hashlib.new(self._hashlib_algo, digest).digest()
+        return digest
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def digest(
+        self,
+        message: str,
+        salt: Optional[str] = None,
+        iterations: Optional[int] = None,
+    ) -> str:
+        """
+        Digest a message.  Returns base64(salt_bytes + hash_bytes).
+        """
+        if not is_empty(salt):
+            salt_bytes = salt.encode("utf-8")  # type: ignore[union-attr]
+        elif not is_empty(self.salt):
+            salt_bytes = self.salt.encode("utf-8")  # type: ignore[union-attr]
+        else:
+            salt_bytes = os.urandom(self.salt_size)
+
+        _iters = iterations if iterations is not None else self.iterations
+        digest_bytes = self._compute(salt_bytes, message, _iters)
+        return base64.b64encode(salt_bytes + digest_bytes).decode("ascii")
+
+    def matches(
+        self,
+        message: str,
+        stored_digest: str,
+        salt: Optional[str] = None,
+        iterations: Optional[int] = None,
+    ) -> bool:
+        """
+        Verify message against a stored digest.
+
+        For random-salt digests, the salt is extracted from the first salt_size
+        bytes of the decoded stored value.  For fixed-salt digests, that salt is
+        used directly.
+        """
+        stored_bytes = base64.b64decode(stored_digest)
+
+        if not is_empty(salt):
+            salt_bytes = salt.encode("utf-8")  # type: ignore[union-attr]
+        elif not is_empty(self.salt):
+            salt_bytes = self.salt.encode("utf-8")  # type: ignore[union-attr]
+        else:
+            salt_bytes = stored_bytes[: self.salt_size]
+
+        expected = stored_bytes[len(salt_bytes) :]
+        _iters = iterations if iterations is not None else self.iterations
+        computed = self._compute(salt_bytes, message, _iters)
+
+        # Constant-time comparison
+        return _hmac.compare_digest(computed, expected)

alt_python_pysypt-1.0.0/pysypt/encryptor.py

@@ -0,0 +1,336 @@
+"""
+pysypt.encryptor — Jasypt-compatible PBE encryption.
+
+Supports the same algorithm table as the JS alt-javascript/jasypt Encryptor:
+
+PBE1 (EVP_BytesToKey-style KDF + DES / 3DES):
+  PBEWITHMD5ANDDES, PBEWITHMD5ANDTRIPLEDES, PBEWITHSHA1ANDDESEDE
+
+PBE2 (PBKDF2 + AES-CBC):
+  PBEWITHHMACSHA{1,224,256,384,512}ANDAES_{128,256}
+
+Wire format (base64-encoded):
+  PBE1 / PBE1N:  salt(8) + ciphertext
+  PBE2:          salt(16) + iv(16) + ciphertext
+
+All algorithms operate in CBC mode.  RC2 / RC4 variants from the JS version
+are intentionally omitted — they are removed from modern OpenSSL and have no
+safe analogue in the cryptography package.
+"""
+
+from __future__ import annotations
+
+__author__ = "Craig Parravicini"
+__collaborators__ = ["Claude (Anthropic)"]
+
+import os
+from typing import Any
+
+from cryptography.hazmat.primitives.ciphers import Cipher, modes
+from cryptography.hazmat.primitives.ciphers import algorithms as std_algorithms
+from cryptography.hazmat.primitives import hashes, padding as sym_padding
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.backends import default_backend
+
+# TripleDES moved to decrepit in cryptography 44+; fall back gracefully
+try:
+    from cryptography.hazmat.decrepit.ciphers.algorithms import TripleDES as _TripleDES
+except ImportError:
+    _TripleDES = std_algorithms.TripleDES  # type: ignore[attr-defined]
+import hashlib
+import base64
+
+from common import is_empty
+
+# ---------------------------------------------------------------------------
+# Algorithm table
+# ---------------------------------------------------------------------------
+
+_PBE1_SALT_LEN = 8
+_PBE2_SALT_LEN = 16
+_PBE2_IV_LEN = 16
+
+_HASH_MAP = {
+    "md5": hashes.MD5,
+    "sha1": hashes.SHA1,
+    "sha224": hashes.SHA224,
+    "sha256": hashes.SHA256,
+    "sha384": hashes.SHA384,
+    "sha512": hashes.SHA512,
+}
+
+# Each entry:  type, hash/hmac name, key_len (bytes), iv_len (bytes)
+# PBE1 uses DES/3DES; PBE2 uses AES-CBC via PBKDF2
+_ALGO_CONFIG: dict[str, dict[str, Any]] = {
+    # PBE1 — EVP_BytesToKey KDF + DES
+    "PBEWITHMD5ANDDES": {
+        "type": "pbe1",
+        "hash": "md5",
+        "cipher": "des-cbc",
+        "key_len": 8,
+        "iv_len": 8,
+    },
+    # PBE1 — EVP_BytesToKey KDF + 3DES
+    "PBEWITHMD5ANDTRIPLEDES": {
+        "type": "pbe1",
+        "hash": "md5",
+        "cipher": "3des-cbc",
+        "key_len": 24,
+        "iv_len": 8,
+    },
+    "PBEWITHSHA1ANDDESEDE": {
+        "type": "pbe1",
+        "hash": "sha1",
+        "cipher": "3des-cbc",
+        "key_len": 24,
+        "iv_len": 8,
+    },
+    # PBE2 — PBKDF2 + AES-CBC
+    "PBEWITHHMACSHA1ANDAES_128": {"type": "pbe2", "hmac": "sha1", "key_len": 16},
+    "PBEWITHHMACSHA1ANDAES_256": {"type": "pbe2", "hmac": "sha1", "key_len": 32},
+    "PBEWITHHMACSHA224ANDAES_128": {"type": "pbe2", "hmac": "sha224", "key_len": 16},
+    "PBEWITHHMACSHA224ANDAES_256": {"type": "pbe2", "hmac": "sha224", "key_len": 32},
+    "PBEWITHHMACSHA256ANDAES_128": {"type": "pbe2", "hmac": "sha256", "key_len": 16},
+    "PBEWITHHMACSHA256ANDAES_256": {"type": "pbe2", "hmac": "sha256", "key_len": 32},
+    "PBEWITHHMACSHA384ANDAES_128": {"type": "pbe2", "hmac": "sha384", "key_len": 16},
+    "PBEWITHHMACSHA384ANDAES_256": {"type": "pbe2", "hmac": "sha384", "key_len": 32},
+    "PBEWITHHMACSHA512ANDAES_128": {"type": "pbe2", "hmac": "sha512", "key_len": 16},
+    "PBEWITHHMACSHA512ANDAES_256": {"type": "pbe2", "hmac": "sha512", "key_len": 32},
+}
+
+SUPPORTED_ALGORITHMS = list(_ALGO_CONFIG.keys())
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _pkcs7_pad(data: bytes, block_size: int) -> bytes:
+    padder = sym_padding.PKCS7(block_size * 8).padder()
+    return padder.update(data) + padder.finalize()
+
+
+def _pkcs7_unpad(data: bytes, block_size: int) -> bytes:
+    unpadder = sym_padding.PKCS7(block_size * 8).unpadder()
+    return unpadder.update(data) + unpadder.finalize()
+
+
+def _evp_bytes_to_key(
+    hash_name: str, password: bytes, salt: bytes, iterations: int, key_len: int, iv_len: int
+) -> tuple[bytes, bytes]:
+    """
+    OpenSSL EVP_BytesToKey-compatible KDF.
+
+    Produces successive hash blocks: H_i = Hash^n(H_{i-1} || password || salt)
+    Returns (key[:key_len], key[key_len:key_len+iv_len])
+    """
+    total = key_len + iv_len
+    result = b""
+    prev = b""
+    while len(result) < total:
+        block = prev + password + salt
+        for _ in range(iterations):
+            block = hashlib.new(hash_name, block).digest()
+        result += block
+        prev = block
+    key = result[:key_len]
+    iv = result[key_len : key_len + iv_len]
+    return key, iv
+
+
+def _pbkdf2_key(
+    hmac_name: str, password: bytes, salt: bytes, iterations: int, key_len: int
+) -> bytes:
+    """PBKDF2 key derivation using the cryptography library."""
+    hash_cls = _HASH_MAP[hmac_name]
+    kdf = PBKDF2HMAC(
+        algorithm=hash_cls(),
+        length=key_len,
+        salt=salt,
+        iterations=iterations,
+        backend=default_backend(),
+    )
+    return kdf.derive(password)
+
+
+# ---------------------------------------------------------------------------
+# Encryptor
+# ---------------------------------------------------------------------------
+
+class Encryptor:
+    """
+    Jasypt-compatible PBE encryptor.
+
+    Default algorithm: PBEWITHMD5ANDDES (same as Java jasypt default).
+    """
+
+    def __init__(
+        self,
+        algorithm: str = "PBEWITHMD5ANDDES",
+        salt: bytes | None = None,
+        iterations: int = 1000,
+    ) -> None:
+        self.set_algorithm(algorithm)
+        cfg = _ALGO_CONFIG[self.algorithm]
+        salt_len = _PBE2_SALT_LEN if cfg["type"] == "pbe2" else _PBE1_SALT_LEN
+        self.salt: bytes = salt if salt is not None else os.urandom(salt_len)
+        self.iterations = iterations
+
+    def set_algorithm(self, algorithm: str) -> None:
+        norm = algorithm.upper()
+        if norm not in _ALGO_CONFIG:
+            raise ValueError(f"Unsupported algorithm: {algorithm}")
+        self.algorithm = norm
+
+    def set_salt(self, salt: bytes | str | None) -> None:
+        cfg = _ALGO_CONFIG[self.algorithm]
+        salt_len = _PBE2_SALT_LEN if cfg["type"] == "pbe2" else _PBE1_SALT_LEN
+        if salt is None:
+            self.salt = os.urandom(salt_len)
+            return
+        if isinstance(salt, str):
+            b = salt.encode("utf-8")
+        else:
+            b = bytes(salt)
+        # Empty → random; short → zero-pad to required length; long → truncate
+        if len(b) == 0:
+            self.salt = os.urandom(salt_len)
+        elif len(b) < salt_len:
+            self.salt = b.ljust(salt_len, b"\x00")
+        else:
+            self.salt = b[:salt_len]
+
+    def set_iterations(self, iterations: int) -> None:
+        self.iterations = iterations or 1000
+
+    # ------------------------------------------------------------------
+    # Encrypt
+    # ------------------------------------------------------------------
+
+    def encrypt(
+        self,
+        payload: str,
+        password: str,
+        salt: bytes | None = None,
+        iterations: int | None = None,
+    ) -> str:
+        cfg = _ALGO_CONFIG[self.algorithm]
+        _salt = salt if salt is not None else self.salt
+        _iters = iterations if iterations is not None else self.iterations
+        pwd_bytes = (password or "").encode("utf-8")
+        data = payload.encode("utf-8")
+
+        if cfg["type"] == "pbe1":
+            return self._encrypt_pbe1(cfg, _salt, _iters, pwd_bytes, data)
+        # pbe2
+        return self._encrypt_pbe2(cfg, _salt, _iters, pwd_bytes, data)
+
+    def _encrypt_pbe1(
+        self,
+        cfg: dict,
+        salt: bytes,
+        iterations: int,
+        password: bytes,
+        data: bytes,
+    ) -> str:
+        key, iv = _evp_bytes_to_key(cfg["hash"], password, salt, iterations, cfg["key_len"], cfg["iv_len"])
+        ciphertext = self._pbe1_cipher_encrypt(cfg["cipher"], key, iv, data)
+        return base64.b64encode(salt + ciphertext).decode("ascii")
+
+    def _encrypt_pbe2(
+        self,
+        cfg: dict,
+        salt: bytes,
+        iterations: int,
+        password: bytes,
+        data: bytes,
+    ) -> str:
+        iv = os.urandom(_PBE2_IV_LEN)
+        key = _pbkdf2_key(cfg["hmac"], password, salt, iterations, cfg["key_len"])
+        padded = _pkcs7_pad(data, 16)
+        cipher = Cipher(std_algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+        enc = cipher.encryptor()
+        ciphertext = enc.update(padded) + enc.finalize()
+        return base64.b64encode(salt + iv + ciphertext).decode("ascii")
+
+    # ------------------------------------------------------------------
+    # Decrypt
+    # ------------------------------------------------------------------
+
+    def decrypt(
+        self,
+        payload: str,
+        password: str,
+        iterations: int | None = None,
+    ) -> str:
+        cfg = _ALGO_CONFIG[self.algorithm]
+        _iters = iterations if iterations is not None else self.iterations
+        pwd_bytes = (password or "").encode("utf-8")
+        buf = base64.b64decode(payload)
+
+        if cfg["type"] == "pbe1":
+            return self._decrypt_pbe1(cfg, buf, _iters, pwd_bytes)
+        return self._decrypt_pbe2(cfg, buf, _iters, pwd_bytes)
+
+    def _decrypt_pbe1(
+        self,
+        cfg: dict,
+        buf: bytes,
+        iterations: int,
+        password: bytes,
+    ) -> str:
+        salt = buf[:_PBE1_SALT_LEN]
+        ciphertext = buf[_PBE1_SALT_LEN:]
+        key, iv = _evp_bytes_to_key(cfg["hash"], password, salt, iterations, cfg["key_len"], cfg["iv_len"])
+        plaintext = self._pbe1_cipher_decrypt(cfg["cipher"], key, iv, ciphertext)
+        return plaintext.decode("utf-8")
+
+    def _decrypt_pbe2(
+        self,
+        cfg: dict,
+        buf: bytes,
+        iterations: int,
+        password: bytes,
+    ) -> str:
+        salt = buf[:_PBE2_SALT_LEN]
+        iv = buf[_PBE2_SALT_LEN : _PBE2_SALT_LEN + _PBE2_IV_LEN]
+        ciphertext = buf[_PBE2_SALT_LEN + _PBE2_IV_LEN :]
+        key = _pbkdf2_key(cfg["hmac"], password, salt, iterations, cfg["key_len"])
+        cipher = Cipher(std_algorithms.AES(key), modes.CBC(iv), backend=default_backend())
+        dec = cipher.decryptor()
+        padded = dec.update(ciphertext) + dec.finalize()
+        return _pkcs7_unpad(padded, 16).decode("utf-8")
+
+    # ------------------------------------------------------------------
+    # Internal cipher wrappers
+    # ------------------------------------------------------------------
+
+    def _pbe1_cipher_encrypt(self, cipher_name: str, key: bytes, iv: bytes, data: bytes) -> bytes:
+        if cipher_name == "des-cbc":
+            # Single DES: cryptography library has no DES primitive; emulate using
+            # TripleDES-EDE with k1=k2=k3 (same 8-byte key repeated 3 times).
+            padded = _pkcs7_pad(data, 8)
+            c = Cipher(_TripleDES(key * 3), modes.CBC(iv), backend=default_backend())
+            enc = c.encryptor()
+            return enc.update(padded) + enc.finalize()
+        elif cipher_name == "3des-cbc":
+            padded = _pkcs7_pad(data, 8)
+            c = Cipher(_TripleDES(key), modes.CBC(iv), backend=default_backend())
+            enc = c.encryptor()
+            return enc.update(padded) + enc.finalize()
+        else:
+            raise ValueError(f"Unknown PBE1 cipher: {cipher_name}")
+
+    def _pbe1_cipher_decrypt(self, cipher_name: str, key: bytes, iv: bytes, data: bytes) -> bytes:
+        if cipher_name == "des-cbc":
+            c = Cipher(_TripleDES(key * 3), modes.CBC(iv), backend=default_backend())
+            dec = c.decryptor()
+            padded = dec.update(data) + dec.finalize()
+            return _pkcs7_unpad(padded, 8)
+        elif cipher_name == "3des-cbc":
+            c = Cipher(_TripleDES(key), modes.CBC(iv), backend=default_backend())
+            dec = c.decryptor()
+            padded = dec.update(data) + dec.finalize()
+            return _pkcs7_unpad(padded, 8)
+        else:
+            raise ValueError(f"Unknown PBE1 cipher: {cipher_name}")

alt_python_pysypt-1.0.0/pysypt/jasypt.py

@@ -0,0 +1,79 @@
+"""
+pysypt.jasypt — Thin facade matching the JS Jasypt class API.
+"""
+
+from __future__ import annotations
+
+__author__ = "Craig Parravicini"
+__collaborators__ = ["Claude (Anthropic)"]
+
+from typing import Optional
+
+from common import is_empty
+from pysypt.encryptor import Encryptor
+from pysypt.digester import Digester
+
+
+class Jasypt:
+    """
+    Facade providing encrypt / decrypt / digest / matches — mirrors the JS Jasypt class.
+
+    Each call constructs a fresh Encryptor or Digester with the provided options
+    so this class is stateless and thread-safe.
+    """
+
+    def encrypt(
+        self,
+        message: str,
+        password: str,
+        algorithm: str = "PBEWITHMD5ANDDES",
+        iterations: int = 1000,
+        salt: Optional[bytes] = None,
+    ) -> Optional[str]:
+        """Encrypt a plaintext message.  Returns None for empty input."""
+        if is_empty(message):
+            return None
+        enc = Encryptor(algorithm=algorithm, salt=salt, iterations=iterations)
+        return enc.encrypt(message, password)
+
+    def decrypt(
+        self,
+        encrypted_message: Optional[str],
+        password: str = "",
+        algorithm: str = "PBEWITHMD5ANDDES",
+        iterations: int = 1000,
+        salt: Optional[bytes] = None,
+    ) -> Optional[str]:
+        """Decrypt an encrypted message.  Returns None for empty input."""
+        if is_empty(encrypted_message):
+            return None
+        enc = Encryptor(algorithm=algorithm, salt=salt, iterations=iterations)
+        return enc.decrypt(encrypted_message, password)  # type: ignore[arg-type]
+
+    def digest(
+        self,
+        message: str,
+        salt: Optional[str] = None,
+        iterations: int = 1000,
+        algorithm: str = "SHA-256",
+    ) -> Optional[str]:
+        """One-way digest a message.  Returns None for empty input."""
+        if is_empty(message):
+            return None
+        digester = Digester(algorithm=algorithm, iterations=iterations)
+        return digester.digest(message, salt=salt)
+
+    def matches(
+        self,
+        message: str,
+        stored_digest: str,
+        salt: Optional[str] = None,
+        iterations: int = 1000,
+        algorithm: str = "SHA-256",
+    ) -> Optional[bool]:
+        """Verify plaintext against a stored digest.  Returns None for empty message."""
+        if is_empty(message):
+            return None
+        return Digester(algorithm=algorithm, iterations=iterations).matches(
+            message, stored_digest, salt=salt
+        )

alt_python_pysypt-1.0.0/tests/test_jasypt.py

@@ -0,0 +1,220 @@
+"""
+tests/test_jasypt.py — pysypt test suite.
+
+Mirrors the JS test/jasypt.test.js coverage:
+  - empty input handling
+  - encrypt/decrypt round-trips for all supported PBE algorithms
+  - digest / matches for all supported hash algorithms
+  - custom salt and iterations
+  - unsupported algorithm errors
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from pysypt import Jasypt, Encryptor, Digester, SUPPORTED_ALGORITHMS, SUPPORTED_DIGEST_ALGORITHMS
+
+PASSWORD = "G0CvDz7oJn60"
+MESSAGE = "admin"
+
+# ---------------------------------------------------------------------------
+# Empty-input guards
+# ---------------------------------------------------------------------------
+
+def test_encrypt_empty_returns_none():
+    j = Jasypt()
+    assert j.encrypt("", PASSWORD) is None
+
+
+def test_decrypt_none_returns_none():
+    j = Jasypt()
+    assert j.decrypt(None) is None  # type: ignore[arg-type]
+
+
+def test_decrypt_empty_string_returns_none():
+    j = Jasypt()
+    assert j.decrypt("") is None
+
+
+def test_digest_empty_returns_none():
+    j = Jasypt()
+    assert j.digest("") is None
+
+
+def test_matches_empty_returns_none():
+    j = Jasypt()
+    stored = Jasypt().digest(MESSAGE)
+    assert j.matches("", stored) is None  # type: ignore[arg-type]
+
+
+# ---------------------------------------------------------------------------
+# Basic encrypt / decrypt round-trip (default PBEWITHMD5ANDDES)
+# ---------------------------------------------------------------------------
+
+def test_encrypt_decrypt_default():
+    j = Jasypt()
+    encrypted = j.encrypt(MESSAGE, PASSWORD)
+    assert encrypted is not None
+    assert j.decrypt(encrypted, PASSWORD) == MESSAGE
+
+
+# ---------------------------------------------------------------------------
+# Encryptor class direct usage
+# ---------------------------------------------------------------------------
+
+def test_encryptor_set_salt_and_iterations():
+    enc = Encryptor()
+    enc.set_salt(b"")
+    enc.set_iterations(100)
+    ciphertext = enc.encrypt(MESSAGE, PASSWORD)
+    assert enc.decrypt(ciphertext, PASSWORD) == MESSAGE
+
+
+def test_encryptor_unsupported_algorithm_raises():
+    enc = Encryptor()
+    with pytest.raises(ValueError, match="Unsupported algorithm"):
+        enc.set_algorithm("INVALID")
+
+
+# ---------------------------------------------------------------------------
+# PBE1 DES / 3DES
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("algorithm", [
+    "PBEWITHMD5ANDDES",
+    "PBEWITHMD5ANDTRIPLEDES",
+    "PBEWITHSHA1ANDDESEDE",
+])
+def test_pbe1_round_trip(algorithm: str):
+    j = Jasypt()
+    encrypted = j.encrypt(MESSAGE, PASSWORD, algorithm=algorithm)
+    assert j.decrypt(encrypted, PASSWORD, algorithm=algorithm) == MESSAGE
+
+
+# ---------------------------------------------------------------------------
+# PBE2 AES-CBC (PBKDF2)
+# ---------------------------------------------------------------------------
+
+_AES_ALGORITHMS = [
+    "PBEWITHHMACSHA1ANDAES_128",
+    "PBEWITHHMACSHA1ANDAES_256",
+    "PBEWITHHMACSHA224ANDAES_128",
+    "PBEWITHHMACSHA224ANDAES_256",
+    "PBEWITHHMACSHA256ANDAES_128",
+    "PBEWITHHMACSHA256ANDAES_256",
+    "PBEWITHHMACSHA384ANDAES_128",
+    "PBEWITHHMACSHA384ANDAES_256",
+    "PBEWITHHMACSHA512ANDAES_128",
+    "PBEWITHHMACSHA512ANDAES_256",
+]
+
+
+@pytest.mark.parametrize("algorithm", _AES_ALGORITHMS)
+def test_pbe2_aes_round_trip(algorithm: str):
+    j = Jasypt()
+    encrypted = j.encrypt(MESSAGE, PASSWORD, algorithm=algorithm)
+    assert j.decrypt(encrypted, PASSWORD, algorithm=algorithm) == MESSAGE
+
+
+# ---------------------------------------------------------------------------
+# SUPPORTED_ALGORITHMS list coverage
+# ---------------------------------------------------------------------------
+
+def test_all_supported_algorithms_round_trip():
+    j = Jasypt()
+    for algo in SUPPORTED_ALGORITHMS:
+        encrypted = j.encrypt(MESSAGE, PASSWORD, algorithm=algo)
+        assert j.decrypt(encrypted, PASSWORD, algorithm=algo) == MESSAGE, algo
+
+
+# ---------------------------------------------------------------------------
+# Digester
+# ---------------------------------------------------------------------------
+
+def test_digester_default_sha256():
+    d = Digester()
+    stored = d.digest(MESSAGE)
+    assert d.matches(MESSAGE, stored) is True
+    assert d.matches("wrong", stored) is False
+
+
+def test_jasypt_digest_and_matches():
+    j = Jasypt()
+    stored = j.digest(MESSAGE)
+    assert j.matches(MESSAGE, stored) is True
+    assert j.matches("wrong", stored) is False
+
+
+@pytest.mark.parametrize("algorithm", SUPPORTED_DIGEST_ALGORITHMS)
+def test_digester_all_algorithms(algorithm: str):
+    d = Digester()
+    d.set_algorithm(algorithm)
+    stored = d.digest(MESSAGE)
+    assert d.matches(MESSAGE, stored) is True
+    assert d.matches("wrong", stored) is False
+
+
+def test_digester_custom_salt_and_iterations():
+    d = Digester()
+    d.set_algorithm("SHA-512")
+    d.set_salt("123456789012345")
+    d.set_iterations(500)
+    stored = d.digest(MESSAGE)
+    assert d.matches(MESSAGE, stored) is True
+    assert d.matches("other", stored) is False
+
+
+def test_digester_unsupported_algorithm_raises():
+    d = Digester()
+    with pytest.raises(ValueError, match="Unsupported digest algorithm"):
+        d.set_algorithm("AES")
+
+
+# ---------------------------------------------------------------------------
+# Encryptor salt handling
+# ---------------------------------------------------------------------------
+
+def test_encryptor_string_salt():
+    """set_salt accepts a string and encodes it as UTF-8."""
+    enc = Encryptor()
+    enc.set_salt("myfix")
+    # Encrypt twice with same string salt — same ciphertext
+    c1 = enc.encrypt(MESSAGE, PASSWORD)
+    enc2 = Encryptor()
+    enc2.set_salt("myfix")
+    c2 = enc2.encrypt(MESSAGE, PASSWORD)
+    assert enc.decrypt(c1, PASSWORD) == MESSAGE
+    assert enc2.decrypt(c2, PASSWORD) == MESSAGE
+
+
+def test_encryptor_none_salt_generates_random():
+    enc = Encryptor()
+    enc.set_salt(None)
+    c1 = enc.encrypt(MESSAGE, PASSWORD)
+    enc2 = Encryptor()
+    enc2.set_salt(None)
+    c2 = enc2.encrypt(MESSAGE, PASSWORD)
+    # Each encrypt uses a fresh random salt — ciphertexts differ
+    assert c1 != c2
+    assert enc.decrypt(c1, PASSWORD) == MESSAGE
+    assert enc2.decrypt(c2, PASSWORD) == MESSAGE
+
+
+# ---------------------------------------------------------------------------
+# Different messages and passwords
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("msg,pw", [
+    ("hello world", "secret"),
+    ("", "anything"),          # empty message → encrypt returns None
+    ("unicode: \u00e9\u00e0\u00fc", "p@ss"),
+    ("admin", ""),             # empty password
+])
+def test_encrypt_decrypt_various(msg: str, pw: str):
+    j = Jasypt()
+    if msg == "":
+        assert j.encrypt(msg, pw) is None
+    else:
+        encrypted = j.encrypt(msg, pw)
+        assert j.decrypt(encrypted, pw) == msg