ddes-dua-crypto 0.1.0__tar.gz

ddes_dua_crypto-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: ddes-dua-crypto
+Version: 0.1.0
+Summary: Dynamic Data Encryption Standard (D-DES) with a single dynamic S-box.
+Author-email: Dua Amir <duaamir392004@gmail.com>
+Project-URL: Homepage, https://github.com/duaamir39/d-des.git
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# D-DES (Dynamic Data Encryption Standard)
+
+> **⚠️ Security Disclaimer:** This is an experimental cryptographic tool for research and educational purposes. It is not intended for securing sensitive production data.
+
+D-DES is a custom implementation of the classic DES (Data Encryption Standard) block cipher, modified to feature a **Dynamic S-Box**. 
+
+## Requirements
+- **Python 3.13.3+**: This library leverages modern Python type hinting and bit-manipulation features. Ensure you are running Python 3.13.3 or higher.
+
+## Features
+- Standard 64-bit block size and 56-bit effective key.
+- 16 Feistel rounds with standard permutation tables (IP, IP-1, E, P, PC-1, PC-2).
+- **Dynamic S-Box**: Replaces the 8 static S-boxes with a single, dynamically generated $6 \times 4$ S-box completely seeded by the encryption key.
+- **CBC Mode Support**: Prevents repeating data blocks by utilizing an Initialization Vector (IV).
+- **PKCS#7 Padding**: Safely encrypts and decrypts files of any arbitrary size.
+- **CLI Utility**: Built-in command line interface to seamlessly encrypt/decrypt any file on your computer.
+- **Operational Logger**: Automatically and securely logs operation metadata to a `logs.json` file without leaking secrets or plaintext.
+
+## Installation
+
+You can install the package directly from PyPI. In your terminal, run:
+```bash
+pip install ddes-dua-crypto
+```
+
+## CLI Usage
+
+The package installs a globally available `ddes-cli` tool. 
+
+**To encrypt a file (CBC mode):**
+```bash
+ddes-cli encrypt -k "8bytekey" -m CBC --iv "8byte_iv" -i plaintext.txt -o encrypted.bin
+```
+
+**To decrypt a file:**
+```bash
+ddes-cli decrypt -k "8bytekey" -m CBC --iv "8byte_iv" -i encrypted.bin -o decrypted.txt
+```
+
+## Python API Usage
+
+You can also use the cipher directly inside your own Python projects.
+
+```python
+from ddes import DDESCipher
+
+# 8-byte key and IV
+key = b'8bytekey'
+iv = b'8byte_iv'
+
+# Initialize in CBC mode
+cipher = DDESCipher(key, mode='CBC', iv=iv)
+
+# Encrypt
+plaintext = b'Hello World! This is D-DES.'
+ciphertext = cipher.encrypt(plaintext)
+print(f"Ciphertext (Hex): {ciphertext.hex()}")
+
+# Decrypt
+decrypted = cipher.decrypt(ciphertext)
+print(f"Decrypted: {decrypted.decode('utf-8')}")
+```
+
+## Operational Logger
+All CLI encryption and decryption commands automatically append an audit trail to `logs.json`. The logger securely stores the timestamp, operation type, mode, and success status. **It never stores keys or file contents.**
+
+**Example Audit Log (`logs.json`):**
+```json
+[
+    {
+        "timestamp": "2026-05-08T19:02:15.123456",
+        "operation": "Encrypt",
+        "mode": "CBC",
+        "status": "Success"
+    }
+]
+```

ddes_dua_crypto-0.1.0/README.md

@@ -0,0 +1,77 @@
+# D-DES (Dynamic Data Encryption Standard)
+
+> **⚠️ Security Disclaimer:** This is an experimental cryptographic tool for research and educational purposes. It is not intended for securing sensitive production data.
+
+D-DES is a custom implementation of the classic DES (Data Encryption Standard) block cipher, modified to feature a **Dynamic S-Box**. 
+
+## Requirements
+- **Python 3.13.3+**: This library leverages modern Python type hinting and bit-manipulation features. Ensure you are running Python 3.13.3 or higher.
+
+## Features
+- Standard 64-bit block size and 56-bit effective key.
+- 16 Feistel rounds with standard permutation tables (IP, IP-1, E, P, PC-1, PC-2).
+- **Dynamic S-Box**: Replaces the 8 static S-boxes with a single, dynamically generated $6 \times 4$ S-box completely seeded by the encryption key.
+- **CBC Mode Support**: Prevents repeating data blocks by utilizing an Initialization Vector (IV).
+- **PKCS#7 Padding**: Safely encrypts and decrypts files of any arbitrary size.
+- **CLI Utility**: Built-in command line interface to seamlessly encrypt/decrypt any file on your computer.
+- **Operational Logger**: Automatically and securely logs operation metadata to a `logs.json` file without leaking secrets or plaintext.
+
+## Installation
+
+You can install the package directly from PyPI. In your terminal, run:
+```bash
+pip install ddes-dua-crypto
+```
+
+## CLI Usage
+
+The package installs a globally available `ddes-cli` tool. 
+
+**To encrypt a file (CBC mode):**
+```bash
+ddes-cli encrypt -k "8bytekey" -m CBC --iv "8byte_iv" -i plaintext.txt -o encrypted.bin
+```
+
+**To decrypt a file:**
+```bash
+ddes-cli decrypt -k "8bytekey" -m CBC --iv "8byte_iv" -i encrypted.bin -o decrypted.txt
+```
+
+## Python API Usage
+
+You can also use the cipher directly inside your own Python projects.
+
+```python
+from ddes import DDESCipher
+
+# 8-byte key and IV
+key = b'8bytekey'
+iv = b'8byte_iv'
+
+# Initialize in CBC mode
+cipher = DDESCipher(key, mode='CBC', iv=iv)
+
+# Encrypt
+plaintext = b'Hello World! This is D-DES.'
+ciphertext = cipher.encrypt(plaintext)
+print(f"Ciphertext (Hex): {ciphertext.hex()}")
+
+# Decrypt
+decrypted = cipher.decrypt(ciphertext)
+print(f"Decrypted: {decrypted.decode('utf-8')}")
+```
+
+## Operational Logger
+All CLI encryption and decryption commands automatically append an audit trail to `logs.json`. The logger securely stores the timestamp, operation type, mode, and success status. **It never stores keys or file contents.**
+
+**Example Audit Log (`logs.json`):**
+```json
+[
+    {
+        "timestamp": "2026-05-08T19:02:15.123456",
+        "operation": "Encrypt",
+        "mode": "CBC",
+        "status": "Success"
+    }
+]
+```

ddes_dua_crypto-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ddes-dua-crypto"
+version = "0.1.0"
+authors = [
+  { name="Dua Amir", email="duaamir392004@gmail.com" },
+]
+description = "Dynamic Data Encryption Standard (D-DES) with a single dynamic S-box."
+readme = "README.md"
+requires-python = ">=3.13"
+classifiers = [
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Security :: Cryptography",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/duaamir39/d-des.git"
+
+[project.scripts]
+ddes-cli = "ddes.cli:main"

ddes_dua_crypto-0.1.0/setup.cfg

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

ddes_dua_crypto-0.1.0/src/ddes/__init__.py

@@ -0,0 +1,6 @@
+"""
+D-DES: Dynamic Data Encryption Standard library.
+"""
+from .cipher import DDESCipher
+
+__all__ = ["DDESCipher"]

ddes_dua_crypto-0.1.0/src/ddes/cipher.py

@@ -0,0 +1,183 @@
+import hashlib
+import random
+from typing import List
+
+from . import tables
+from . import utils
+
+class DDESCipher:
+    def __init__(self, key: bytes, mode: str = 'ECB', iv: bytes = None):
+        """
+        Initializes the D-DES cipher with a given 8-byte key.
+        """
+        if len(key) != 8:
+            raise ValueError("Key must be exactly 8 bytes (64 bits)")
+        if mode not in ('ECB', 'CBC'):
+            raise ValueError("Mode must be 'ECB' or 'CBC'")
+        if mode == 'CBC':
+            if iv is None or len(iv) != 8:
+                raise ValueError("CBC mode requires exactly an 8-byte IV")
+            self.iv = iv
+        else:
+            self.iv = None
+            
+        self.mode = mode
+        self.key_int = int.from_bytes(key, byteorder='big')
+        self.subkeys = self._generate_subkeys()
+        self.sbox = self._generate_dynamic_sbox(key)
+
+    def _generate_dynamic_sbox(self, key: bytes) -> List[int]:
+        """
+        Generate one single 6x4 S-box (64 entries total, values 0-15) based on the key.
+        """
+        # Derive a seed from the key using SHA-256
+        seed = int(hashlib.sha256(key).hexdigest(), 16)
+        
+        # We need a 64-entry S-box with values 0-15.
+        # A typical S-box has 4 rows of 16 columns. 
+        # For our dynamic S-box, we'll create an array of 64 elements,
+        # consisting of exactly four 0s, four 1s, ..., four 15s.
+        sbox = [i % 16 for i in range(64)]
+        
+        # Shuffle the S-box deterministically using the derived seed
+        r = random.Random(seed)
+        r.shuffle(sbox)
+        
+        return sbox
+
+    def _generate_subkeys(self) -> List[int]:
+        """
+        Generate the 16 48-bit subkeys using the standard DES key schedule.
+        """
+        subkeys = []
+        
+        # Apply PC-1 to the 64-bit key
+        pc1_out = utils.permute(self.key_int, tables.PC_1, 64, 56)
+        
+        # Split into two 28-bit halves
+        c, d = utils.split_half(pc1_out, 56)
+        
+        for shift in tables.SHIFTS:
+            # Circular left shift each half
+            c = utils.left_shift(c, shift, 28)
+            d = utils.left_shift(d, shift, 28)
+            
+            # Merge halves
+            cd = utils.merge_half(c, d, 28)
+            
+            # Apply PC-2
+            subkey = utils.permute(cd, tables.PC_2, 56, 48)
+            subkeys.append(subkey)
+            
+        return subkeys
+
+    def _feistel(self, right_half: int, subkey: int) -> int:
+        """
+        The core Feistel function f(R, K).
+        """
+        # 1. Expansion P-box
+        expanded = utils.permute(right_half, tables.E, 32, 48)
+        
+        # 2. Key mixing
+        xored = expanded ^ subkey
+        
+        # 3. Dynamic S-box substitution
+        # Split 48 bits into 8 6-bit blocks, pass each through the same single S-box
+        sbox_out = 0
+        for i in range(8):
+            # Extract 6 bits from left to right
+            shift_amount = 48 - 6 * (i + 1)
+            six_bit_block = (xored >> shift_amount) & 0x3F
+            
+            # Use the 6 bits as an index into our 64-entry dynamic S-box
+            four_bit_out = self.sbox[six_bit_block]
+            
+            # Append to the 32-bit output
+            sbox_out |= (four_bit_out << (32 - 4 * (i + 1)))
+            
+        # 4. Permutation
+        return utils.permute(sbox_out, tables.P, 32, 32)
+
+    def _process_block(self, block: bytes, decrypt: bool = False) -> bytes:
+        """
+        Encrypts or decrypts a single 64-bit block.
+        """
+        if len(block) != 8:
+            raise ValueError("Block must be exactly 8 bytes (64 bits)")
+            
+        block_int = int.from_bytes(block, byteorder='big')
+        
+        # Initial Permutation (IP)
+        ip_out = utils.permute(block_int, tables.IP, 64, 64)
+        
+        # Split into 32-bit halves
+        left, right = utils.split_half(ip_out, 64)
+        
+        # 16 Feistel rounds
+        # Decryption uses subkeys in reverse order (K16 to K1)
+        subkeys = self.subkeys[::-1] if decrypt else self.subkeys
+        
+        for subkey in subkeys:
+            next_left = right
+            next_right = left ^ self._feistel(right, subkey)
+            left, right = next_left, next_right
+            
+        # Swap halves after the 16th round (before final permutation)
+        pre_output = utils.merge_half(right, left, 32)
+        
+        # Final Permutation (IP-1)
+        final_out = utils.permute(pre_output, tables.IP_INV, 64, 64)
+        
+        return final_out.to_bytes(8, byteorder='big')
+
+    def encrypt(self, data: bytes) -> bytes:
+        """
+        Encrypt data using D-DES (ECB or CBC mode with PKCS#7 padding).
+        """
+        # PKCS7 padding
+        pad_len = 8 - (len(data) % 8)
+        padded_data = data + bytes([pad_len] * pad_len)
+        
+        ciphertext = bytearray()
+        prev_block = self.iv
+        
+        for i in range(0, len(padded_data), 8):
+            block = padded_data[i:i+8]
+            
+            if self.mode == 'CBC':
+                # XOR plaintext block with previous ciphertext block (or IV)
+                block = bytes(a ^ b for a, b in zip(block, prev_block))
+                
+            enc_block = self._process_block(block, decrypt=False)
+            ciphertext.extend(enc_block)
+            prev_block = enc_block
+            
+        return bytes(ciphertext)
+
+    def decrypt(self, data: bytes) -> bytes:
+        """
+        Decrypt data using D-DES (ECB or CBC mode with PKCS#7 unpadding).
+        """
+        if len(data) % 8 != 0:
+            raise ValueError("Ciphertext length must be a multiple of 8 bytes")
+            
+        plaintext = bytearray()
+        prev_block = self.iv
+        
+        for i in range(0, len(data), 8):
+            block = data[i:i+8]
+            dec_block = self._process_block(block, decrypt=True)
+            
+            if self.mode == 'CBC':
+                # XOR decrypted block with previous ciphertext block (or IV)
+                dec_block = bytes(a ^ b for a, b in zip(dec_block, prev_block))
+                prev_block = block
+                
+            plaintext.extend(dec_block)
+            
+        # PKCS7 unpadding
+        pad_len = plaintext[-1]
+        if pad_len < 1 or pad_len > 8:
+            raise ValueError("Invalid padding detected during decryption.")
+            
+        return bytes(plaintext[:-pad_len])

ddes_dua_crypto-0.1.0/src/ddes/cli.py

@@ -0,0 +1,61 @@
+import argparse
+import sys
+from .cipher import DDESCipher
+from .utils import Logger
+
+def main():
+    parser = argparse.ArgumentParser(description="D-DES (Dynamic Data Encryption Standard) CLI")
+    
+    parser.add_argument('action', choices=['encrypt', 'decrypt'], help="Action to perform")
+    parser.add_argument('-k', '--key', required=True, help="8-byte encryption key")
+    parser.add_argument('-i', '--input', required=True, help="Input file path")
+    parser.add_argument('-o', '--output', required=True, help="Output file path")
+    parser.add_argument('-m', '--mode', choices=['ECB', 'CBC'], default='CBC', help="Block cipher mode (default: CBC)")
+    parser.add_argument('--iv', help="8-byte initialization vector (required for CBC mode)")
+    
+    args = parser.parse_args()
+    
+    key_bytes = args.key.encode('utf-8')
+    if len(key_bytes) != 8:
+        print("Error: Key must be exactly 8 characters long.")
+        sys.exit(1)
+        
+    iv_bytes = None
+    if args.mode == 'CBC':
+        if not args.iv:
+            print("Error: CBC mode requires an IV (--iv).")
+            sys.exit(1)
+        iv_bytes = args.iv.encode('utf-8')
+        if len(iv_bytes) != 8:
+            print("Error: IV must be exactly 8 characters long.")
+            sys.exit(1)
+            
+    logger = Logger("logs.json")
+    
+    try:
+        cipher = DDESCipher(key=key_bytes, mode=args.mode, iv=iv_bytes)
+        
+        with open(args.input, 'rb') as f:
+            data = f.read()
+            
+        if args.action == 'encrypt':
+            result = cipher.encrypt(data)
+            print(f"Successfully encrypted {len(data)} bytes to {len(result)} bytes.")
+            print(f"\nCiphertext (Hex): {result.hex()}\n")
+            logger.log("Encrypt", args.mode, "Success")
+        else:
+            result = cipher.decrypt(data)
+            print(f"Successfully decrypted {len(data)} bytes to {len(result)} bytes.")
+            print(f"\nDecrypted Data (Hex): {result.hex()}\n")
+            logger.log("Decrypt", args.mode, "Success")
+            
+        with open(args.output, 'wb') as f:
+            f.write(result)
+            
+    except Exception as e:
+        print(f"Error: {e}")
+        logger.log(args.action.capitalize(), args.mode, f"Failure - {str(e)}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

ddes_dua_crypto-0.1.0/src/ddes/tables.py

@@ -0,0 +1,74 @@
+# Initial Permutation (IP)
+IP = [
+    58, 50, 42, 34, 26, 18, 10, 2,
+    60, 52, 44, 36, 28, 20, 12, 4,
+    62, 54, 46, 38, 30, 22, 14, 6,
+    64, 56, 48, 40, 32, 24, 16, 8,
+    57, 49, 41, 33, 25, 17, 9,  1,
+    59, 51, 43, 35, 27, 19, 11, 3,
+    61, 53, 45, 37, 29, 21, 13, 5,
+    63, 55, 47, 39, 31, 23, 15, 7
+]
+
+# Final Permutation (IP-1)
+IP_INV = [
+    40, 8, 48, 16, 56, 24, 64, 32,
+    39, 7, 47, 15, 55, 23, 63, 31,
+    38, 6, 46, 14, 54, 22, 62, 30,
+    37, 5, 45, 13, 53, 21, 61, 29,
+    36, 4, 44, 12, 52, 20, 60, 28,
+    35, 3, 43, 11, 51, 19, 59, 27,
+    34, 2, 42, 10, 50, 18, 58, 26,
+    33, 1, 41, 9,  49, 17, 57, 25
+]
+
+# Expansion Permutation (E)
+E = [
+    32, 1,  2,  3,  4,  5,
+    4,  5,  6,  7,  8,  9,
+    8,  9,  10, 11, 12, 13,
+    12, 13, 14, 15, 16, 17,
+    16, 17, 18, 19, 20, 21,
+    20, 21, 22, 23, 24, 25,
+    24, 25, 26, 27, 28, 29,
+    28, 29, 30, 31, 32, 1
+]
+
+# Permutation Function (P)
+P = [
+    16, 7,  20, 21,
+    29, 12, 28, 17,
+    1,  15, 23, 26,
+    5,  18, 31, 10,
+    2,  8,  24, 14,
+    32, 27, 3,  9,
+    19, 13, 30, 6,
+    22, 11, 4,  25
+]
+
+# Permuted Choice 1 (PC-1)
+PC_1 = [
+    57, 49, 41, 33, 25, 17, 9,
+    1,  58, 50, 42, 34, 26, 18,
+    10, 2,  59, 51, 43, 35, 27,
+    19, 11, 3,  60, 52, 44, 36,
+    63, 55, 47, 39, 31, 23, 15,
+    7,  62, 54, 46, 38, 30, 22,
+    14, 6,  61, 53, 45, 37, 29,
+    21, 13, 5,  28, 20, 12, 4
+]
+
+# Permuted Choice 2 (PC-2)
+PC_2 = [
+    14, 17, 11, 24, 1,  5,
+    3,  28, 15, 6,  21, 10,
+    23, 19, 12, 4,  26, 8,
+    16, 7,  27, 20, 13, 2,
+    41, 52, 31, 37, 47, 55,
+    30, 40, 51, 45, 33, 48,
+    44, 49, 39, 56, 34, 53,
+    46, 42, 50, 36, 29, 32
+]
+
+# Shifts per round
+SHIFTS = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]

ddes_dua_crypto-0.1.0/src/ddes/utils.py

@@ -0,0 +1,58 @@
+import json
+import os
+import datetime
+
+def permute(block: int, table: list[int], input_size: int, output_size: int) -> int:
+    """Permute an integer block using the given table."""
+    output = 0
+    for i, bit_pos in enumerate(table):
+        # DES tables are 1-indexed, so we subtract 1.
+        # The bit position from the left in a block of size input_size
+        shift = input_size - bit_pos
+        bit = (block >> shift) & 1
+        output |= (bit << (output_size - 1 - i))
+    return output
+
+def split_half(block: int, size: int) -> tuple[int, int]:
+    """Split an integer block into two halves."""
+    half_size = size // 2
+    mask = (1 << half_size) - 1
+    left = block >> half_size
+    right = block & mask
+    return left, right
+
+def merge_half(left: int, right: int, half_size: int) -> int:
+    """Merge two integer halves into a single block."""
+    return (left << half_size) | right
+
+def left_shift(block: int, shift: int, size: int) -> int:
+    """Circular left shift an integer block by the given shift amount."""
+    mask = (1 << size) - 1
+    return ((block << shift) | (block >> (size - shift))) & mask
+
+class Logger:
+    def __init__(self, log_file="logs.json"):
+        self.log_file = log_file
+
+    def log(self, operation: str, mode: str, status: str):
+        log_entry = {
+            "timestamp": datetime.datetime.now().isoformat(),
+            "operation": operation,
+            "mode": mode,
+            "status": status
+        }
+        
+        logs = []
+        if os.path.exists(self.log_file):
+            try:
+                with open(self.log_file, "r", encoding="utf-8") as f:
+                    content = f.read().strip()
+                    if content:
+                        logs = json.loads(content)
+            except json.JSONDecodeError:
+                pass
+
+        logs.append(log_entry)
+        
+        with open(self.log_file, "w", encoding="utf-8") as f:
+            json.dump(logs, f, indent=4)

ddes_dua_crypto-0.1.0/src/ddes_dua_crypto.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: ddes-dua-crypto
+Version: 0.1.0
+Summary: Dynamic Data Encryption Standard (D-DES) with a single dynamic S-box.
+Author-email: Dua Amir <duaamir392004@gmail.com>
+Project-URL: Homepage, https://github.com/duaamir39/d-des.git
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# D-DES (Dynamic Data Encryption Standard)
+
+> **⚠️ Security Disclaimer:** This is an experimental cryptographic tool for research and educational purposes. It is not intended for securing sensitive production data.
+
+D-DES is a custom implementation of the classic DES (Data Encryption Standard) block cipher, modified to feature a **Dynamic S-Box**. 
+
+## Requirements
+- **Python 3.13.3+**: This library leverages modern Python type hinting and bit-manipulation features. Ensure you are running Python 3.13.3 or higher.
+
+## Features
+- Standard 64-bit block size and 56-bit effective key.
+- 16 Feistel rounds with standard permutation tables (IP, IP-1, E, P, PC-1, PC-2).
+- **Dynamic S-Box**: Replaces the 8 static S-boxes with a single, dynamically generated $6 \times 4$ S-box completely seeded by the encryption key.
+- **CBC Mode Support**: Prevents repeating data blocks by utilizing an Initialization Vector (IV).
+- **PKCS#7 Padding**: Safely encrypts and decrypts files of any arbitrary size.
+- **CLI Utility**: Built-in command line interface to seamlessly encrypt/decrypt any file on your computer.
+- **Operational Logger**: Automatically and securely logs operation metadata to a `logs.json` file without leaking secrets or plaintext.
+
+## Installation
+
+You can install the package directly from PyPI. In your terminal, run:
+```bash
+pip install ddes-dua-crypto
+```
+
+## CLI Usage
+
+The package installs a globally available `ddes-cli` tool. 
+
+**To encrypt a file (CBC mode):**
+```bash
+ddes-cli encrypt -k "8bytekey" -m CBC --iv "8byte_iv" -i plaintext.txt -o encrypted.bin
+```
+
+**To decrypt a file:**
+```bash
+ddes-cli decrypt -k "8bytekey" -m CBC --iv "8byte_iv" -i encrypted.bin -o decrypted.txt
+```
+
+## Python API Usage
+
+You can also use the cipher directly inside your own Python projects.
+
+```python
+from ddes import DDESCipher
+
+# 8-byte key and IV
+key = b'8bytekey'
+iv = b'8byte_iv'
+
+# Initialize in CBC mode
+cipher = DDESCipher(key, mode='CBC', iv=iv)
+
+# Encrypt
+plaintext = b'Hello World! This is D-DES.'
+ciphertext = cipher.encrypt(plaintext)
+print(f"Ciphertext (Hex): {ciphertext.hex()}")
+
+# Decrypt
+decrypted = cipher.decrypt(ciphertext)
+print(f"Decrypted: {decrypted.decode('utf-8')}")
+```
+
+## Operational Logger
+All CLI encryption and decryption commands automatically append an audit trail to `logs.json`. The logger securely stores the timestamp, operation type, mode, and success status. **It never stores keys or file contents.**
+
+**Example Audit Log (`logs.json`):**
+```json
+[
+    {
+        "timestamp": "2026-05-08T19:02:15.123456",
+        "operation": "Encrypt",
+        "mode": "CBC",
+        "status": "Success"
+    }
+]
+```

ddes_dua_crypto-0.1.0/src/ddes_dua_crypto.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/ddes/__init__.py
+src/ddes/cipher.py
+src/ddes/cli.py
+src/ddes/tables.py
+src/ddes/utils.py
+src/ddes_dua_crypto.egg-info/PKG-INFO
+src/ddes_dua_crypto.egg-info/SOURCES.txt
+src/ddes_dua_crypto.egg-info/dependency_links.txt
+src/ddes_dua_crypto.egg-info/entry_points.txt
+src/ddes_dua_crypto.egg-info/top_level.txt
+tests/test_cipher.py

ddes_dua_crypto-0.1.0/src/ddes_dua_crypto.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ddes_dua_crypto-0.1.0/src/ddes_dua_crypto.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ddes-cli = ddes.cli:main

ddes_dua_crypto-0.1.0/src/ddes_dua_crypto.egg-info/top_level.txt

@@ -0,0 +1 @@
+ddes

ddes_dua_crypto-0.1.0/tests/test_cipher.py

@@ -0,0 +1,42 @@
+import unittest
+from ddes.cipher import DDESCipher
+
+class TestDDES(unittest.TestCase):
+    def test_encryption_decryption_ecb(self):
+        key = b'secret!!'
+        cipher = DDESCipher(key, mode='ECB')
+        
+        plaintext = b'Cryptography is fascinating!'
+        ciphertext = cipher.encrypt(plaintext)
+        
+        self.assertNotEqual(plaintext, ciphertext)
+        
+        decrypted = cipher.decrypt(ciphertext)
+        self.assertEqual(plaintext, decrypted)
+
+    def test_encryption_decryption_cbc(self):
+        key = b'secret!!'
+        iv = b'init_vec'
+        cipher = DDESCipher(key, mode='CBC', iv=iv)
+        
+        plaintext = b'Cryptography is fascinating! CBC mode is secure.'
+        ciphertext = cipher.encrypt(plaintext)
+        
+        self.assertNotEqual(plaintext, ciphertext)
+        
+        decrypted = cipher.decrypt(ciphertext)
+        self.assertEqual(plaintext, decrypted)
+        
+    def test_different_keys_different_sboxes(self):
+        key1 = b'key_one!'
+        key2 = b'key_two!'
+        
+        cipher1 = DDESCipher(key1)
+        cipher2 = DDESCipher(key2)
+        
+        # Since the keys are different, their seeds are different,
+        # and therefore the shuffled S-boxes should be highly likely to differ.
+        self.assertNotEqual(cipher1.sbox, cipher2.sbox)
+
+if __name__ == '__main__':
+    unittest.main()