feistel-py 0.1.0__tar.gz

feistel-py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Cyril Dever
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

feistel-py-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+# MANIFEST.in
+
+exclude assets
+exclude publish.sh
+exclude LOCAL.md

feistel-py-0.1.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.1
+Name: feistel-py
+Version: 0.1.0
+Summary: Feistel cipher implementation in Python for format-preserving encryption
+Author-email: Cyril Dever <cdever@pep-s.com>
+License: MIT License
+        
+        Copyright (c) 2024 Cyril Dever
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/cyrildever/feistel-py
+Keywords: feistel,cipher,format-preserving,encryption,fpe
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10.2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pycryptodome>=3.20.0
+Requires-Dist: py-utls>=0.1.6
+
+# feistel-py
+_Feistel cipher implementation in Python for format-preserving encryption_
+
+
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/cyrildever/feistel-py)
+![GitHub last commit](https://img.shields.io/github/last-commit/cyrildever/feistel-py)
+![GitHub issues](https://img.shields.io/github/issues/cyrildever/feistel-py)
+![GitHub license](https://img.shields.io/github/license/cyrildever/feistel-py)
+
+This is a Python library implementing the Feistel cipher for Format-Preserving Encryption (FPE).
+
+### Motivation
+
+The main objective of this library is not to provide a secure encryption scheme but rather a safe obfuscation tool.
+
+
+### Formal description
+
+This library operates on the concept of the Feistel cipher described in [Wikipedia](https://en.wikipedia.org/wiki/Feistel_cipher) as:
+> A Feistel network is subdivided into several rounds or steps. In its balanced version, the network processes the data in two parts of identical size. On each round, the two blocks are exchanged, then one of the blocks is combined with a transformed version of the other block.
+> Half of the data is encoded with the key, then the result of this operation is added using an XOR operation to the other half of the data.
+> Then in the next round, we reverse: it is the turn of the last half to be encrypted and then to be xored to the first half, except that we use the data previously encrypted.
+> The diagram below shows the data flow (the ![${\oplus}$](https://render.githubusercontent.com/render/math?math={\oplus}) represents the XOR operation). Each round uses an intermediate key, usually taken from the main key via a generation called key schedule. The operations performed during encryption with these intermediate keys are specific to each algorithm.
+
+![](assets/400px-Feistel_cipher_diagram_en.svg.png)
+
+The algorithmic description (provided by Wikipedia) of the encryption is as follows:
+* Let ![$n+1$](https://render.githubusercontent.com/render/math?math=n%2B1) be the number of steps, ![$K_{0},K_{1},...,K_{n}$](https://render.githubusercontent.com/render/math?math=K_{0},K_{1},...,K_{n}) the keys associated with each step and ![$F:\Omega\times\mathcal{K}\mapsto\Omega$](https://render.githubusercontent.com/render/math?math=F:\Omega{\times}K\mapsto\Omega) a function of the ![$(words{\times}keys)$](https://render.githubusercontent.com/render/math?math=(words{\times}keys)) space to the ![$words$](https://render.githubusercontent.com/render/math?math=words) space.
+* For each step ![$i{\in}[0;n]$](https://render.githubusercontent.com/render/math?math=i\in[0%3Bn]), note the encrypted word in step ![$i,m_{i}=L_{i}||R_{i}$](https://render.githubusercontent.com/render/math?math=i,m_{i}=L_{i}||R_{i}):
+  * ![$L_{i+1}=R_{i}$](https://render.githubusercontent.com/render/math?math=L_{i%2B1}=R_{i})
+  * ![$R_{i+1}=L_{i}{\oplus}F(L_{i},K_{i})$](https://render.githubusercontent.com/render/math?math=R_{i%2B1}=L_{i}{\oplus}F(L_{i},K_{i}))
+* ![$m_{0}=L_{0}||R_{0}$](https://render.githubusercontent.com/render/math?math=m_{0}=L_{0}||R_{0}) is the unciphered text, ![$m_{n+1}=L_{n+1}||R_{n+1}$](https://render.githubusercontent.com/render/math?math=m_{n%2B1}=L_{n%2B1}||R_{n%2B1}) is the ciphered word. 
+
+There is no restriction on the ![$F$](https://render.githubusercontent.com/render/math?math=F) function other than the XOR operation must be possible. For simplicity, we will choose ![$L_1$](https://render.githubusercontent.com/render/math?math=L_1) of the same size as ![$R_1$](https://render.githubusercontent.com/render/math?math=R_1) and the function ![$F$](https://render.githubusercontent.com/render/math?math=F) shall transform a word of length ![$k$](https://render.githubusercontent.com/render/math?math=k) into a word of length ![$k$](https://render.githubusercontent.com/render/math?math=k) (and this for all ![$k$](https://render.githubusercontent.com/render/math?math=k)).
+
+
+### Usage
+
+```
+pip install feistel-py
+```
+
+To get an obfuscated string from a source data using the SHA-256 hashing function at each round, first instantiate a `Cipher` object, passing it a key and a number of rounds. Then, use the `encrypt()` method with the source data as argument. The result will be a byte array. To ensure maximum security, I recommend you use a 256-bit key or longer and a minimum of 10 rounds.
+
+The decryption process uses the obfuscated buffered data and pass it to the `decrypt()` method of the `Cipher`.
+
+```python
+from feistel.cipher import Cipher
+
+
+source = "my-source-data"
+
+# Encrypt
+cipher = Cipher("some-32-byte-long-key-to-be-safe", 10)
+obfuscated = cipher.encrypt(source)
+
+# Decrypt
+deciphered = cipher.decrypt(obfuscated)
+
+assert deciphered == source, "deciphered should be 'my-source-data'"
+```
+_NB: This is the exact replica of my other implementations (see below)._
+
+You may also use your own set of keys through a `CustomCipher` instance, eg.
+```python
+from feistel.custom import CustomCipher
+
+
+keys = [
+    "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    "9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba",
+    "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789",
+]
+cipher = CustomCipher(keys)
+```
+In that case, the number of rounds depends on the number of provided keys.
+
+Finally, you might want to use the latest cipher, providing true format-preserving encryption for strings:
+```python
+from feistel.fpe import FPECipher
+from feistel.utils.hash import SHA_256
+
+
+cipher = FPECipher(SHA_256, "some-32-byte-long-key-to-be-safe", 128)
+obfuscated = cipher.encrypt(source)
+
+assert len(obfuscated) == len(source)
+```
+_NB: For stability and security purposes, the number `0` always returns itself._
+
+
+You might also want to use it with the command line:
+```
+usage: python3 -m feistel [-h] [-c CIPHER] [-e ENGINE] [-k KEY] [-r ROUNDS] [-o OPERATION] input
+
+positional arguments:
+  input                 The string to obfuscate (watch for quotes)
+
+options:
+  -h, --help            show this help message and exit
+  -c CIPHER, --cipher CIPHER
+                        The type of cipher: feistel [default] | custom | fpe
+  -e ENGINE, --engine ENGINE
+                        The hashing engine [default sha-256]
+  -k KEY, --key KEY     The key(s) to use
+  -r ROUNDS, --rounds ROUNDS
+                        The (optional) number of rounds [default 10]
+  -o OPERATION, --operation OPERATION
+                        The operation to process : cipher | decipher
+```
+
+
+### Dependencies
+
+The following libraries are necessary:
+- `pycryptodome`;
+- `py-utls`.
+
+
+### Tests
+
+```console
+$ python3 -m unittest discover
+```
+
+
+### Other implementations
+
+For those interested, I also made two other implementations of these ciphers:
+* In [Golang](https://github.com/cyrildever/feistel) as an executable;
+* In [Typescript](https://github.com/cyrildever/feistel-cipher) for the browser;
+* In [Scala](https://github.com/cyrildever/feistel-jar) for the JVM.
+
+I also created a special library for redacting classified documents using the new FPE cipher. Feel free to [contact me](mailto:cdever@edgewhere.fr) about it.
+
+
+### License
+
+This module is distributed under a MIT license. \
+See the [LICENSE](LICENSE) file.
+
+
+<hr />
+&copy; 2024 Cyril Dever. All rights reserved.

feistel-py-0.1.0/README.md

@@ -0,0 +1,144 @@
+# feistel-py
+_Feistel cipher implementation in Python for format-preserving encryption_
+
+
+![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/cyrildever/feistel-py)
+![GitHub last commit](https://img.shields.io/github/last-commit/cyrildever/feistel-py)
+![GitHub issues](https://img.shields.io/github/issues/cyrildever/feistel-py)
+![GitHub license](https://img.shields.io/github/license/cyrildever/feistel-py)
+
+This is a Python library implementing the Feistel cipher for Format-Preserving Encryption (FPE).
+
+### Motivation
+
+The main objective of this library is not to provide a secure encryption scheme but rather a safe obfuscation tool.
+
+
+### Formal description
+
+This library operates on the concept of the Feistel cipher described in [Wikipedia](https://en.wikipedia.org/wiki/Feistel_cipher) as:
+> A Feistel network is subdivided into several rounds or steps. In its balanced version, the network processes the data in two parts of identical size. On each round, the two blocks are exchanged, then one of the blocks is combined with a transformed version of the other block.
+> Half of the data is encoded with the key, then the result of this operation is added using an XOR operation to the other half of the data.
+> Then in the next round, we reverse: it is the turn of the last half to be encrypted and then to be xored to the first half, except that we use the data previously encrypted.
+> The diagram below shows the data flow (the ![${\oplus}$](https://render.githubusercontent.com/render/math?math={\oplus}) represents the XOR operation). Each round uses an intermediate key, usually taken from the main key via a generation called key schedule. The operations performed during encryption with these intermediate keys are specific to each algorithm.
+
+![](assets/400px-Feistel_cipher_diagram_en.svg.png)
+
+The algorithmic description (provided by Wikipedia) of the encryption is as follows:
+* Let ![$n+1$](https://render.githubusercontent.com/render/math?math=n%2B1) be the number of steps, ![$K_{0},K_{1},...,K_{n}$](https://render.githubusercontent.com/render/math?math=K_{0},K_{1},...,K_{n}) the keys associated with each step and ![$F:\Omega\times\mathcal{K}\mapsto\Omega$](https://render.githubusercontent.com/render/math?math=F:\Omega{\times}K\mapsto\Omega) a function of the ![$(words{\times}keys)$](https://render.githubusercontent.com/render/math?math=(words{\times}keys)) space to the ![$words$](https://render.githubusercontent.com/render/math?math=words) space.
+* For each step ![$i{\in}[0;n]$](https://render.githubusercontent.com/render/math?math=i\in[0%3Bn]), note the encrypted word in step ![$i,m_{i}=L_{i}||R_{i}$](https://render.githubusercontent.com/render/math?math=i,m_{i}=L_{i}||R_{i}):
+  * ![$L_{i+1}=R_{i}$](https://render.githubusercontent.com/render/math?math=L_{i%2B1}=R_{i})
+  * ![$R_{i+1}=L_{i}{\oplus}F(L_{i},K_{i})$](https://render.githubusercontent.com/render/math?math=R_{i%2B1}=L_{i}{\oplus}F(L_{i},K_{i}))
+* ![$m_{0}=L_{0}||R_{0}$](https://render.githubusercontent.com/render/math?math=m_{0}=L_{0}||R_{0}) is the unciphered text, ![$m_{n+1}=L_{n+1}||R_{n+1}$](https://render.githubusercontent.com/render/math?math=m_{n%2B1}=L_{n%2B1}||R_{n%2B1}) is the ciphered word. 
+
+There is no restriction on the ![$F$](https://render.githubusercontent.com/render/math?math=F) function other than the XOR operation must be possible. For simplicity, we will choose ![$L_1$](https://render.githubusercontent.com/render/math?math=L_1) of the same size as ![$R_1$](https://render.githubusercontent.com/render/math?math=R_1) and the function ![$F$](https://render.githubusercontent.com/render/math?math=F) shall transform a word of length ![$k$](https://render.githubusercontent.com/render/math?math=k) into a word of length ![$k$](https://render.githubusercontent.com/render/math?math=k) (and this for all ![$k$](https://render.githubusercontent.com/render/math?math=k)).
+
+
+### Usage
+
+```
+pip install feistel-py
+```
+
+To get an obfuscated string from a source data using the SHA-256 hashing function at each round, first instantiate a `Cipher` object, passing it a key and a number of rounds. Then, use the `encrypt()` method with the source data as argument. The result will be a byte array. To ensure maximum security, I recommend you use a 256-bit key or longer and a minimum of 10 rounds.
+
+The decryption process uses the obfuscated buffered data and pass it to the `decrypt()` method of the `Cipher`.
+
+```python
+from feistel.cipher import Cipher
+
+
+source = "my-source-data"
+
+# Encrypt
+cipher = Cipher("some-32-byte-long-key-to-be-safe", 10)
+obfuscated = cipher.encrypt(source)
+
+# Decrypt
+deciphered = cipher.decrypt(obfuscated)
+
+assert deciphered == source, "deciphered should be 'my-source-data'"
+```
+_NB: This is the exact replica of my other implementations (see below)._
+
+You may also use your own set of keys through a `CustomCipher` instance, eg.
+```python
+from feistel.custom import CustomCipher
+
+
+keys = [
+    "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    "9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba",
+    "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789",
+]
+cipher = CustomCipher(keys)
+```
+In that case, the number of rounds depends on the number of provided keys.
+
+Finally, you might want to use the latest cipher, providing true format-preserving encryption for strings:
+```python
+from feistel.fpe import FPECipher
+from feistel.utils.hash import SHA_256
+
+
+cipher = FPECipher(SHA_256, "some-32-byte-long-key-to-be-safe", 128)
+obfuscated = cipher.encrypt(source)
+
+assert len(obfuscated) == len(source)
+```
+_NB: For stability and security purposes, the number `0` always returns itself._
+
+
+You might also want to use it with the command line:
+```
+usage: python3 -m feistel [-h] [-c CIPHER] [-e ENGINE] [-k KEY] [-r ROUNDS] [-o OPERATION] input
+
+positional arguments:
+  input                 The string to obfuscate (watch for quotes)
+
+options:
+  -h, --help            show this help message and exit
+  -c CIPHER, --cipher CIPHER
+                        The type of cipher: feistel [default] | custom | fpe
+  -e ENGINE, --engine ENGINE
+                        The hashing engine [default sha-256]
+  -k KEY, --key KEY     The key(s) to use
+  -r ROUNDS, --rounds ROUNDS
+                        The (optional) number of rounds [default 10]
+  -o OPERATION, --operation OPERATION
+                        The operation to process : cipher | decipher
+```
+
+
+### Dependencies
+
+The following libraries are necessary:
+- `pycryptodome`;
+- `py-utls`.
+
+
+### Tests
+
+```console
+$ python3 -m unittest discover
+```
+
+
+### Other implementations
+
+For those interested, I also made two other implementations of these ciphers:
+* In [Golang](https://github.com/cyrildever/feistel) as an executable;
+* In [Typescript](https://github.com/cyrildever/feistel-cipher) for the browser;
+* In [Scala](https://github.com/cyrildever/feistel-jar) for the JVM.
+
+I also created a special library for redacting classified documents using the new FPE cipher. Feel free to [contact me](mailto:cdever@edgewhere.fr) about it.
+
+
+### License
+
+This module is distributed under a MIT license. \
+See the [LICENSE](LICENSE) file.
+
+
+<hr />
+&copy; 2024 Cyril Dever. All rights reserved.

feistel-py-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+# pyproject.toml
+
+[build-system]
+requires = ["setuptools>=58.1.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "feistel-py"
+version = "0.1.0"
+description = "Feistel cipher implementation in Python for format-preserving encryption"
+readme = "README.md"
+authors = [{ name = "Cyril Dever", email = "cdever@pep-s.com" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "feistel",
+    "cipher",
+    "format-preserving",
+    "encryption",
+    "fpe",
+]
+dependencies = [
+    "pycryptodome >= 3.20.0",
+    "py-utls >= 0.1.6",
+]
+requires-python = ">=3.10.2"
+
+[project.urls]
+Homepage = "https://github.com/cyrildever/feistel-py"
+
+[project.scripts]
+feistel-py = "feistel.__main__:main"

feistel-py-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

feistel-py-0.1.0/src/feistel/__init__.py

@@ -0,0 +1,3 @@
+# __init__.py
+
+__version__ = "0.1.0"

feistel-py-0.1.0/src/feistel/__main__.py

@@ -0,0 +1,76 @@
+import argparse
+import ast
+import sys
+
+from feistel.cipher import Cipher
+from feistel.custom import CustomCipher
+from feistel.fpe import Engine, FPECipher
+from feistel.utils.hash import SHA_256, is_available_engine
+
+CUSTOM = "custom"
+FEISTEL = "feistel"
+FPE = "fpe"
+
+
+def main(args):
+    if not args.input or not args.operation:
+        raise Exception("Missing mandatory parameters")
+    data = str(args.input)
+    operation = str(args.operation)
+    if operation != "cipher" and operation != "decipher":
+        raise Exception("Invalid operation")
+
+    cipher_type = (
+        args.cipher
+        if args.cipher and args.cipher in [FEISTEL, CUSTOM, FPE]
+        else FEISTEL
+    )
+    if cipher_type == FEISTEL:
+        if operation == "decipher" and data.startswith("b'") and data.endswith("'"):
+            data = ast.literal_eval(args.input)
+        key = str(args.key)
+        if not key:
+            raise Exception("missing mandatory key")
+        rounds = int(args.rounds) if args.rounds else 10
+        cipher = Cipher(key, rounds)
+    elif cipher_type == CUSTOM:
+        if operation == "decipher" and data.startswith("b'") and data.endswith("'"):
+            data = ast.literal_eval(args.input)
+        keys = str(args.key).split(",")
+        if len(keys) == 0:
+            raise Exception("missing mandatory keys")
+        cipher = CustomCipher(keys)
+    else:
+        key = str(args.key)
+        if not key:
+            raise Exception("missing mandatory key")
+        if not is_available_engine(args.engine):
+            engine = SHA_256
+        else:
+            engine = Engine(args.engine)
+        rounds = int(args.rounds) if args.rounds else 10
+        cipher = FPECipher(engine, key, rounds)
+
+    if operation == "cipher":
+        print(cipher.encrypt(data))
+    else:
+        print(cipher.decrypt(data))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", help="The string to obfuscate (watch for quotes)")
+    parser.add_argument(
+        "-c", "--cipher", help="The type of cipher: feistel [default] | custom | fpe"
+    )
+    parser.add_argument("-e", "--engine", help="The hashing engine [default sha-256]")
+    parser.add_argument("-k", "--key", help="The key(s) to use")
+    parser.add_argument(
+        "-r", "--rounds", help="The (optional) number of rounds [default 10]"
+    )
+    parser.add_argument(
+        "-o", "--operation", help="The operation to process : cipher | decipher"
+    )
+    args = parser.parse_args()
+
+    main(args)

feistel-py-0.1.0/src/feistel/cipher.py

@@ -0,0 +1,63 @@
+from feistel.utils.hash import hash
+from feistel.utils.padding import pad, unpad
+from feistel.utils.strings import add, extract, split, string2bytearray
+from feistel.utils.xor import xor
+
+
+class Cipher:
+    def __init__(self, key: str, rounds: int):
+        """
+        The Cipher class is the main entry point to the Feistel cipher if you want to use the SHA-256 hash function at each round.
+        You should instantiate it with the base key you want to use and the number of rounds to apply.
+        For better security, you should choose a 256-bit key or longer, and 10 rounds is a good start.
+        Once instantiated, use the encrypt() or decrypt() methods on the Cipher instance with the appropriate data.
+        """
+        assert key and rounds >= 2, "CipherError: wrong arguments"
+        self.key = key
+        self.rounds = rounds
+
+    def encrypt(self, data: str) -> bytearray:
+        """
+        Obfuscate the passed data
+        """
+        if len(data) == 0:
+            return bytearray()
+
+        if len(data) % 2 == 1:
+            data = pad(data)
+
+        # Apply the balanced Feistel cipher
+        left, right = split(data)
+        if len(left) != len(right):
+            raise Exception("invalid string: unable to split")
+
+        parts = [left, right]
+        for i in range(0, self.rounds):
+            tmp = xor(parts[0], self._round(parts[1], i))
+            parts = [parts[1], tmp]
+
+        return string2bytearray(parts[0] + parts[1])
+
+    def decrypt(self, obfuscated: bytes | bytearray) -> str:
+        """
+        Deobfuscate the passed data
+        """
+        assert len(obfuscated) % 2 == 0, "CipherError: invalid obfuscated data"
+        if len(obfuscated) == 0:
+            return ""
+
+        o = obfuscated.decode()
+
+        # Apply the balanced Feistel cipher
+        b, a = split(o)
+        for i in range(0, self.rounds):
+            tmp = xor(a, self._round(b, self.rounds - i - 1))
+            a = b
+            b = tmp
+
+        return unpad(b + a)
+
+    def _round(self, item: str, idx: int) -> str:
+        addition = add(item, extract(self.key, idx, len(item)))
+        hex_hashed = hash(string2bytearray(addition)).hex()
+        return extract(hex_hashed, idx, len(item))

feistel-py-0.1.0/src/feistel/custom.py

@@ -0,0 +1,61 @@
+from feistel.utils.hash import hash
+from feistel.utils.padding import pad, unpad
+from feistel.utils.strings import add, extract, split, string2bytearray
+from feistel.utils.xor import xor
+
+
+class CustomCipher:
+    def __init__(self, keys: list[str]):
+        """
+        The CustomCipher uses custom keys instead of the SHA-256 hashing function to provide a new key at each round.
+        The number of rounds is then determined by the number of keys provided.
+        NB: There must be at least two keys.
+        """
+        assert len(keys) >= 2, "CustomCipherError: wrong arguments"
+        self.keys = keys
+
+    def encrypt(self, data: str) -> bytearray:
+        """
+        Obfuscate the passed data
+        """
+        if len(data) == 0:
+            return bytearray()
+
+        if len(data) % 2 == 1:
+            data = pad(data)
+
+        # Apply the balanced Feistel cipher
+        left, right = split(data)
+        if len(left) != len(right):
+            raise Exception("invalid string: unable to split")
+
+        parts = [left, right]
+        for i in range(0, len(self.keys)):
+            tmp = xor(parts[0], self._round(parts[1], i))
+            parts = [parts[1], tmp]
+
+        return string2bytearray(parts[0] + parts[1])
+
+    def decrypt(self, obfuscated: bytes | bytearray) -> str:
+        """
+        Deobfuscate the passed data
+        """
+        assert len(obfuscated) % 2 == 0, "CipherError: invalid obfuscated data"
+        if len(obfuscated) == 0:
+            return ""
+
+        o = obfuscated.decode()
+
+        # Apply the balanced Feistel cipher
+        b, a = split(o)
+        for i in range(0, len(self.keys)):
+            tmp = xor(a, self._round(b, len(self.keys) - i - 1))
+            a = b
+            b = tmp
+
+        return unpad(b + a)
+
+    def _round(self, item: str, idx: int) -> str:
+        addition = add(item, extract(self.keys[idx], idx, len(item)))
+        hex_hashed = hash(string2bytearray(addition)).hex()
+        return extract(hex_hashed, idx, len(item))