Add Camellia encryption

docs/crypto.rst

@@ -56,6 +56,48 @@ Supported modes: ECB.
 .. autofunction:: malduck.blowfish.ecb.encrypt
 .. autofunction:: malduck.blowfish.ecb.decrypt
 
+Camellia
+--------------
+
+Camellia block cipher.
+
+Supported modes: ECB, CBC, CTR, CFB, OFB.
+
+.. code-block:: python
+
+    from malduck import camellia
+
+    key = b'A'*16
+    iv = b'B'*16
+    plaintext = b'data'*16
+    ciphertext = camellia.ecb.encrypt(key, iv, plaintext)
+
+
+Camellia-ECB mode
+~~~~~~~~~~~~
+.. autofunction:: malduck.camellia.ecb.encrypt
+.. autofunction:: malduck.camellia.ecb.decrypt
+
+Camellia-CBC mode
+~~~~~~~~~~~~
+.. autofunction:: malduck.camellia.cbc.encrypt
+.. autofunction:: malduck.camellia.cbc.decrypt
+
+Camellia-CTR mode
+~~~~~~~~~~~~
+.. autofunction:: malduck.camellia.ctr.encrypt
+.. autofunction:: malduck.camellia.ctr.decrypt
+
+Camellia-CFB mode
+~~~~~~~~~~~~
+.. autofunction:: malduck.camellia.cfb.encrypt
+.. autofunction:: malduck.camellia.cfb.decrypt
+
+Camellia-OFB mode
+~~~~~~~~~~~~
+.. autofunction:: malduck.camellia.ofb.encrypt
+.. autofunction:: malduck.camellia.ofb.decrypt
+
 ChaCha20
 --------
 

malduck/__init__.py

@@ -8,6 +8,7 @@
 
 from .crypto import (
     aes,
+    camellia,
     blowfish,
     chacha20,
     des3,
@@ -135,6 +136,7 @@
     "lznt1",
     # crypto
     "aes",
+    "camellia",
     "blowfish",
     "chacha20",
     "des3",

malduck/crypto/__init__.py

@@ -1,4 +1,5 @@
 from .aes import aes
+from .camellia import camellia
 from .blowfish import blowfish
 from .chacha20 import chacha20
 from .des3 import des3
@@ -11,6 +12,7 @@
 
 __all__ = [
     "aes",
+    "camellia",
     "blowfish",
     "chacha20",
     "des3",

malduck/crypto/camellia.py

@@ -0,0 +1,201 @@
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+
+__all__ = ["camellia"]
+
+
+class CamelliaCbc:
+    def encrypt(self, key: bytes, iv: bytes, data: bytes) -> bytes:
+        """
+        Encrypts buffer using Camellia algorithm in CBC mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param iv: Initialization vector
+        :type iv: bytes
+        :param data: Buffer to be encrypted
+        :type data: bytes
+        :return: Encrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.CBC(iv))
+        enc = cipher.encryptor()
+        return enc.update(data) + enc.finalize()
+
+    def decrypt(self, key: bytes, iv: bytes, data: bytes) -> bytes:
+        """
+        Decrypts buffer using Camellia algorithm in CBC mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param iv: Initialization vector
+        :type iv: bytes
+        :param data: Buffer to be decrypted
+        :type data: bytes
+        :return: Decrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.CBC(iv))
+        dec = cipher.decryptor()
+        return dec.update(data) + dec.finalize()
+
+
+class CamelliaCfb:
+    def encrypt(self, key: bytes, iv: bytes, data: bytes) -> bytes:
+        """
+        Encrypts buffer using Camellia algorithm in CFB mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param iv: Initialization vector
+        :type iv: bytes
+        :param data: Buffer to be encrypted
+        :type data: bytes
+        :return: Encrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.CFB(iv))
+        enc = cipher.encryptor()
+        return enc.update(data) + enc.finalize()
+
+    def decrypt(self, key: bytes, iv: bytes, data: bytes) -> bytes:
+        """
+        Decrypts buffer using Camellia algorithm in CFB mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param iv: Initialization vector
+        :type iv: bytes
+        :param data: Buffer to be decrypted
+        :type data: bytes
+        :return: Decrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.CFB(iv))
+        dec = cipher.decryptor()
+        return dec.update(data) + dec.finalize()
+
+
+class CamelliaOfb:
+    def encrypt(self, key: bytes, iv: bytes, data: bytes) -> bytes:
+        """
+        Encrypts buffer using Camellia algorithm in OFB mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param iv: Initialization vector
+        :type iv: bytes
+        :param data: Buffer to be encrypted
+        :type data: bytes
+        :return: Encrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.OFB(iv))
+        enc = cipher.encryptor()
+        return enc.update(data) + enc.finalize()
+
+    def decrypt(self, key: bytes, iv: bytes, data: bytes) -> bytes:
+        """
+        Decrypts buffer using Camellia algorithm in OFB mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param iv: Initialization vector
+        :type iv: bytes
+        :param data: Buffer to be decrypted
+        :type data: bytes
+        :return: Decrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.OFB(iv))
+        dec = cipher.decryptor()
+        return dec.update(data) + dec.finalize()
+
+
+class CamelliaEcb:
+    def encrypt(self, key: bytes, data: bytes) -> bytes:
+        """
+        Encrypts buffer using Camellia algorithm in ECB mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param data: Buffer to be encrypted
+        :type data: bytes
+        :return: Encrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.ECB())
+        enc = cipher.encryptor()
+        return enc.update(data) + enc.finalize()
+
+    def decrypt(self, key: bytes, data: bytes) -> bytes:
+        """
+        Decrypts buffer using Camellia algorithm in ECB mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param data: Buffer to be decrypted
+        :type data: bytes
+        :return: Decrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.ECB())
+        dec = cipher.decryptor()
+        return dec.update(data) + dec.finalize()
+
+
+class CamelliaCtr:
+    def encrypt(self, key: bytes, nonce: bytes, data: bytes) -> bytes:
+        """
+        Encrypts buffer using Camellia algorithm in CTR mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param nonce: Initial counter value, big-endian encoded
+        :type nonce: bytes
+        :param data: Buffer to be encrypted
+        :type data: bytes
+        :return: Encrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.CTR(nonce))
+        enc = cipher.encryptor()
+        return enc.update(data) + enc.finalize()
+
+    def decrypt(self, key: bytes, nonce: bytes, data: bytes) -> bytes:
+        """
+        Decrypts buffer using Camellia algorithm in CTR mode.
+
+        :param key: Cryptographic key (128, 192 or 256 bits)
+        :type key: bytes
+        :param nonce: Initial counter value, big-endian encoded
+        :type nonce: bytes
+        :param data: Buffer to be decrypted
+        :type data: bytes
+        :return: Decrypted data
+        :rtype: bytes
+        """
+        algo = algorithms.Camellia(key)
+        cipher = Cipher(algo, modes.CTR(nonce))
+        dec = cipher.decryptor()
+        return dec.update(data) + dec.finalize()
+
+
+class Camellia:
+    cbc = CamelliaCbc()
+    ecb = CamelliaEcb()
+    ctr = CamelliaCtr()
+    cfb = CamelliaCfb()
+    ofb = CamelliaOfb()
+
+
+camellia = Camellia()

requirements.txt

@@ -5,3 +5,4 @@ pycryptodomex>=3.8.2
 capstone>=4.0.1
 yara-python
 typing-extensions>=3.7.4.2
+cryptography>=3.1