CacheToolsUtils 10.1__py3-none-any.whl → 10.2__py3-none-any.whl

{CacheToolsUtils-10.1.dist-info → CacheToolsUtils-10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CacheToolsUtils
-Version: 10.1
+Version: 10.2
 Summary: Cachetools Utilities
 Author-email: Fabien Coelho <cachetools.utils@coelho.net>
 License: CC0

CacheToolsUtils-10.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+CacheToolsUtils.py,sha256=etJrt34OkZtSMXK1wGJIg9VcDYxH3pXzpJy6OowAMnY,26120
+CacheToolsUtils-10.2.dist-info/LICENSE,sha256=y_yFW1bmBAUFCF-ZDyDiq10Ykns_19If5pFnZUzYgeU,33
+CacheToolsUtils-10.2.dist-info/METADATA,sha256=rEY3PJdfjL-E-QVqAt36vb7voJqxZYaeqze-Lk7YuQ0,4759
+CacheToolsUtils-10.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+CacheToolsUtils-10.2.dist-info/top_level.txt,sha256=qCyE4jGot5mOmvIQrZueCnPtbYtRe2hqke4sGojm3zI,16
+CacheToolsUtils-10.2.dist-info/RECORD,,

CacheToolsUtils.py

@@ -367,6 +367,48 @@ class TwoLevelCache(_MutMapMix, MutableMapping):
         self._cache2.reset()  # type: ignore
 
 
+# NOTE this is quite costly, a Cipher object is created to encrypt/decrypt each value.
+# another design could keep a persistant cipher.
+class _Cipher:
+    """Not so convincing internal class to abstract cipher algorithms."""
+
+    def __init__(self, name):
+        self._name = name
+        if name == "Salsa20":
+            from Crypto.Cipher import Salsa20 as cipher
+            # NOTE hash and nonce may overlap, which is not an issue
+            params = {"key": (32, 64), "nonce": (24, 32)}
+            kwargs = {}
+            size = 0
+        elif name == "ChaCha20":
+            from Crypto.Cipher import ChaCha20 as cipher
+            # NOTE hash and nonce may overlap, which is not an issue
+            params = {"key": (32, 64), "nonce": (24, 32)}
+            kwargs = {}
+            size = 0
+        elif name in ("AES", "AES-128", "AES-128-CBC"):
+            from Crypto.Cipher import AES as cipher
+            params = {"key": (48, 64), "iv": (32, 48)}
+            kwargs = {"mode": cipher.MODE_CBC}
+            size = 16
+        else:
+            raise Exception(f"unexpected cipher: {name}")
+        self._cipher = cipher
+        self._params = params
+        self._kwargs = kwargs
+        if size:
+            from Crypto.Util.Padding import pad, unpad
+            self._pad = lambda s: pad(s, size)
+            self._unpad = lambda s: unpad(s, size)
+        else:
+            self._pad = lambda s: s
+            self._unpad = lambda s: s
+
+    def new(self, derived: bytes):
+        kwargs = {k: derived[v[0]: v[1]] for k, v in self._params.items()}
+        return self._cipher.new(**kwargs, **self._kwargs)  # type: ignore
+
+
 #
 # Encrypted Cache
 #
@@ -376,6 +418,7 @@ class EncryptedCache(_KeyMutMapMix, _StatsMix, MutableMapping):
     :param secret: bytes of secret, at least 16 bytes.
     :param hsize: size of hashed key, default is *16*.
     :param csize: value checksum size, default is *0*.
+    :param cipher: chose cipher from "Salsa20", "AES-128-CBC" or "ChaCha20".
 
     The key is *not* encrypted but simply hashed, thus they are
     fixed size with a very low collision probability.
@@ -384,11 +427,12 @@ class EncryptedCache(_KeyMutMapMix, _StatsMix, MutableMapping):
     as each value is encrypted with its own key and nonce.
 
     Algorithms:
+
     - SHA3: hash/key/nonce derivation and checksum.
-    - Salsa20: value encryption.
+    - Salsa20, AES-128-CBC or ChaCha20: value encryption.
     """
 
-    def __init__(self, cache: MutableMapping, secret: bytes, hsize: int = 16, csize: int = 0):
+    def __init__(self, cache: MutableMapping, secret: bytes, hsize: int = 16, csize: int = 0, cipher: str = "Salsa20"):
         self._cache = cache
         assert len(secret) >= 16
         self._secret = secret
@@ -396,34 +440,31 @@ class EncryptedCache(_KeyMutMapMix, _StatsMix, MutableMapping):
         self._hsize = hsize
         assert 0 <= csize <= 32
         self._csize = csize
-        from Crypto.Cipher import Salsa20
-        self._cipher = Salsa20
+        self._cipher = _Cipher(cipher)
 
-    def _keydev(self, key) -> tuple[bytes, bytes, bytes]:
-        """Compute hash, key and nonce from initial key."""
-        hkey = hashlib.sha3_512(key + self._secret).digest()
-        # NOTE hash and nonce may overlap, which is not an issue
-        return (hkey[:self._hsize], hkey[32:], hkey[24:32])
+    def _derive(self, key) -> tuple[bytes, bytes]:
+        """Derive hash and stuff from initial key and secret."""
+        derived = hashlib.sha3_512(key + self._secret).digest()
+        return (derived[:self._hsize], derived)
 
     def _key(self, key):
-        return self._keydev(key)[0]
+        return self._derive(key)[0]
 
     def __setitem__(self, key, val):
-        hkey, vkey, vnonce = self._keydev(key)
-        xval = self._cipher.new(key=vkey, nonce=vnonce).encrypt(val)
+        hkey, derived = self._derive(key)
+        xval = self._cipher.new(derived).encrypt(self._cipher._pad(val))
         if self._csize:
-            cs = hashlib.sha3_256(val).digest()[:self._csize]
-            xval = cs + xval
+            xval = hashlib.sha3_256(val).digest()[:self._csize] + xval
         self._cache[hkey] = xval
 
     def __getitem__(self, key):
-        hkey, vkey, vnonce = self._keydev(key)
+        hkey, derived = self._derive(key)
         xval = self._cache[hkey]
         if self._csize:  # split cs from encrypted value
             cs, xval = xval[:self._csize], xval[self._csize:]
         else:
             cs = None
-        val = self._cipher.new(key=vkey, nonce=vnonce).decrypt(xval)
+        val = self._cipher._unpad(self._cipher.new(derived).decrypt(xval))
         if self._csize and cs != hashlib.sha3_256(val).digest()[:self._csize]:
             raise KeyError(f"invalid encrypted value for key {key}")
         return val
@@ -597,7 +638,9 @@ class _HashJsonKey:
         return self._key
 
 
+# NOTE not very useful, behaves as _HashJsonKey.
 def hash_json_key(*args, **kwargs):
+    """Function handling of above class, to keep it hidden."""
     return _HashJsonKey(*args, **kwargs)
 
 
@@ -639,7 +682,7 @@ class JsonSerde:
         elif flag == 3:
             return json.loads(value.decode("utf-8"))
         else:
-            raise Exception("Unknown serialization format")
+            raise Exception(f"Unknown serialization format: {flag}")
 
 
 class MemCached(_KeyMutMapMix, MutableMapping):

CacheToolsUtils-10.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-CacheToolsUtils.py,sha256=vFzAsKANXs-VdsW5vHMTjaSlRbZ230Yt5KhCVNanU8k,24360
-CacheToolsUtils-10.1.dist-info/LICENSE,sha256=y_yFW1bmBAUFCF-ZDyDiq10Ykns_19If5pFnZUzYgeU,33
-CacheToolsUtils-10.1.dist-info/METADATA,sha256=iNx4pKMTm34ot0u_vWQOo2-GXfcTw9DR_C3OwH7Lkk8,4759
-CacheToolsUtils-10.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-CacheToolsUtils-10.1.dist-info/top_level.txt,sha256=qCyE4jGot5mOmvIQrZueCnPtbYtRe2hqke4sGojm3zI,16
-CacheToolsUtils-10.1.dist-info/RECORD,,