project-des 0.1.0__tar.gz

project_des-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: project-des
+Version: 0.1.0
+Summary: Educational Python implementation of the Data Encryption Standard (DES)
+Author-email: shrimp2845 <goldencheng15@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/shrimp2845-tw/project_DES
+Project-URL: Repository, https://github.com/shrimp2845-tw/project_DES
+Keywords: des,cryptography,education,feistel
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+**_Warning: This implementation is intended for self learning purposes only and should not be used for real-world security._**
+
+## About
+
+- **Author:** shrimp2845  
+- **Version:** 0.1.0  
+- **License:** MIT
+
+This is an educational Python implementation of the Data Encryption Standard (DES). This project breaks down the complex Feistel network into human-readable modules following the official NIST specifications, and supports ECB and CBC modes for real file encryption.
+
+## Installation & Usage
+
+### install
+Requires Python 3.10+
+```bash
+pip install project-des
+```
+### usage
+```bash
+python -c "from project_DES import DES; cipher = DES(b'key'); print(cipher.encrypt(b'data').hex())"
+```
+
+## Docs
+
+```
+class initialize
+----------------------
+project_DES.DES(key, mode='ECB')
+
+key 
+-> 8 bytes or key file name 
+containing an encryption key,
+if key is str, it extract 
+first 8 bytes in the file
+
+mode
+-> optional, block cipher mode of 
+operation that used,ECB and CBC 
+available in current version
+
+
+methods
+----------------------
+
+encrypt(data: bytes) -> bytes, 
+decrypt(data: bytes) -> bytes
+-> return encrypt/decrypt bytes data
+
+encrypt_file(name: str, new_name: str), 
+decrypt_file(name: str, new_name: str) 
+-> encrypt/decrypt target file 'name' 
+and save it as 'new_name'
+
+get_key(), get_mode()
+-> get current using key/mode of 
+operation
+
+change_key(key: str or bytes),
+change_mode(mode: str)
+-> change current using key/mode of 
+operation
+
+```
+
+## Examples
+Project provides two examples: [string_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/string_cipher.py) & [file_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/file_cipher.py)
+
+you can find samples of [file_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/file_cipher.py) at:
+[ecb_sample](https://github.com/shrimp2845-tw/project_DES/tree/main/examples/ecb_sample) & [cbc_sample](https://github.com/shrimp2845-tw/project_DES/tree/main/examples/cbc_sample)
+
+### explanation for samples
+**mumei.jpg**: plaintext file
+
+**mumei.bin**: encrypt mumei.jpg with key ‘berries’ and mode ECB
+
+**mumei_correct_decrypt**.jpg: decrypt mumei.bin with key ‘berries’ and mode ECB
+
+**mumei_wrong_decrypt.jpg**: decrypt  mumei.bin with key ‘friend’ and mode ECB
+
+**ina.jpg**: plaintext file 
+
+**ina.bin**: encrypt ina.jpg with key ‘takodachi’ and mode CBC
+
+**ina_correct_decrypt.jpg**: decrypt ina.bin with key ‘takodachi’ and mode CBC
+
+**ina_wrong_decrypt.jpg**: decrypt ina.bin with key ‘violet’ and mode CBC
+
+
+## Performance 
+This project is designed for learning and understanding how DES works  rather than for practical encryption use. The implementation prioritizes readability and modular structure over performance.
+
+As a result, encryption process is **very slow**. It takes nearly 2 minutes to encrypt 1MB file.
+
+
+
+

project_des-0.1.0/README.md

@@ -0,0 +1,96 @@
+**_Warning: This implementation is intended for self learning purposes only and should not be used for real-world security._**
+
+## About
+
+- **Author:** shrimp2845  
+- **Version:** 0.1.0  
+- **License:** MIT
+
+This is an educational Python implementation of the Data Encryption Standard (DES). This project breaks down the complex Feistel network into human-readable modules following the official NIST specifications, and supports ECB and CBC modes for real file encryption.
+
+## Installation & Usage
+
+### install
+Requires Python 3.10+
+```bash
+pip install project-des
+```
+### usage
+```bash
+python -c "from project_DES import DES; cipher = DES(b'key'); print(cipher.encrypt(b'data').hex())"
+```
+
+## Docs
+
+```
+class initialize
+----------------------
+project_DES.DES(key, mode='ECB')
+
+key 
+-> 8 bytes or key file name 
+containing an encryption key,
+if key is str, it extract 
+first 8 bytes in the file
+
+mode
+-> optional, block cipher mode of 
+operation that used,ECB and CBC 
+available in current version
+
+
+methods
+----------------------
+
+encrypt(data: bytes) -> bytes, 
+decrypt(data: bytes) -> bytes
+-> return encrypt/decrypt bytes data
+
+encrypt_file(name: str, new_name: str), 
+decrypt_file(name: str, new_name: str) 
+-> encrypt/decrypt target file 'name' 
+and save it as 'new_name'
+
+get_key(), get_mode()
+-> get current using key/mode of 
+operation
+
+change_key(key: str or bytes),
+change_mode(mode: str)
+-> change current using key/mode of 
+operation
+
+```
+
+## Examples
+Project provides two examples: [string_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/string_cipher.py) & [file_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/file_cipher.py)
+
+you can find samples of [file_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/file_cipher.py) at:
+[ecb_sample](https://github.com/shrimp2845-tw/project_DES/tree/main/examples/ecb_sample) & [cbc_sample](https://github.com/shrimp2845-tw/project_DES/tree/main/examples/cbc_sample)
+
+### explanation for samples
+**mumei.jpg**: plaintext file
+
+**mumei.bin**: encrypt mumei.jpg with key ‘berries’ and mode ECB
+
+**mumei_correct_decrypt**.jpg: decrypt mumei.bin with key ‘berries’ and mode ECB
+
+**mumei_wrong_decrypt.jpg**: decrypt  mumei.bin with key ‘friend’ and mode ECB
+
+**ina.jpg**: plaintext file 
+
+**ina.bin**: encrypt ina.jpg with key ‘takodachi’ and mode CBC
+
+**ina_correct_decrypt.jpg**: decrypt ina.bin with key ‘takodachi’ and mode CBC
+
+**ina_wrong_decrypt.jpg**: decrypt ina.bin with key ‘violet’ and mode CBC
+
+
+## Performance 
+This project is designed for learning and understanding how DES works  rather than for practical encryption use. The implementation prioritizes readability and modular structure over performance.
+
+As a result, encryption process is **very slow**. It takes nearly 2 minutes to encrypt 1MB file.
+
+
+
+

project_des-0.1.0/project_DES/__init__.py

@@ -0,0 +1,2 @@
+from .project_DES import DES
+__all__ = ["DES"]

project_des-0.1.0/project_DES/des_core/__init__.py

@@ -0,0 +1 @@
+from .crypto import BasicDES

project_des-0.1.0/project_DES/des_core/bit_utils.py

@@ -0,0 +1,35 @@
+
+meticulous_mode = True
+
+def xor(b1: list[int], b2: list[int]) -> list[int]: 
+    if meticulous_mode and (len(b1) != len(b2)):
+        raise ValueError('xor:invalid input')
+    op = [int(not(i == j)) for i, j in zip(b1, b2)]
+    return op
+
+def bytes_to_bits(byd: bytes) -> list[int]:
+    btd = [int(bit) for byte in byd for bit in format(byte, '08b')]
+    return btd
+
+def bits_to_bytes(btd: list[int]) -> bytes:
+    if meticulous_mode and len(btd)%8 != 0:
+        raise ValueError('bits_to_bytes:invalid input')
+    byd = bytes(int("".join(map(str, btd[i:i+8])), 2) for i in range(0, len(btd), 8))
+    return byd
+    
+def int_to_bits(bid: int, length: int) -> list[int]:
+    btd = [int(bit) for bit in format(bid, f'0{length}b')]
+    if meticulous_mode and len(format(bid, 'b')) > length:
+        raise ValueError('int_to_bits:invalid input')
+    return btd
+ 
+def bits_to_int(btd: list[int]) -> int:
+    bid = int(''.join(map(str,btd)), 2)
+    return bid
+    
+def main():
+    pass
+    
+if __name__ == "__main__":
+    main()
+    

project_des-0.1.0/project_DES/des_core/crypto.py

@@ -0,0 +1,59 @@
+from . import bit_utils as b
+from . import permute as p
+from . import key as k
+from . import mangler as m
+from . import feistel as f 
+
+meticulous_mode = True
+
+def ip(btd: list[int])  -> list[int]:
+    if meticulous_mode and len(btd) != 64:
+        raise ValueError('ip:invalid input')
+    t = [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]
+    nbtd = p.permutation(btd, t)
+    return nbtd
+
+def fp(btd: list[int]) -> list[int]:
+    if meticulous_mode and len(btd) != 64:
+        raise ValueError('fp:invalid input')
+    t = [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]
+    nbtd = p.permutation(btd, t)
+    return nbtd
+    
+class BasicDES:
+    def __init__(self, main_key: bytes):
+        self.rks = k.generate_round_key(main_key)
+        
+    def encrypt(self, block: bytes) -> bytes:
+        if len(block) != 8:
+            raise ValueError('encrypt:invalid block')
+        plaintext = b.bytes_to_bits(block)
+        cipher_text = fp(f.feistel(ip(plaintext), self.rks, m.f))
+        return b.bits_to_bytes(cipher_text)
+    
+    def decrypt(self, block: bytes) -> bytes:
+        if len(block) != 8:
+            raise ValueError('decrypt:invalid block')
+        cipher_text = b.bytes_to_bits(block)
+        plaintext = fp(f.feistel(ip(cipher_text), self.rks[::-1], m.f))
+        return b.bits_to_bytes(plaintext)
+        
+def main():
+    pass
+    
+if __name__ == "__main__":
+    main()

project_des-0.1.0/project_DES/des_core/feistel.py

@@ -0,0 +1,23 @@
+from . import bit_utils as b 
+from typing import Callable
+
+meticulous_mode = True
+
+def feistel(btd:list[list[int]], rks: list[list[int]], f: Callable[[list[int], list[int]], list[int]]) -> list[int]:
+    if meticulous_mode and len(btd) % 2 != 0:
+        raise ValueError("feistel:invalid input")
+    def one_round(l: list[int], r: list[int], rk: list[int]) -> tuple[list[int], list[int]]:
+        nl = r
+        nr = b.xor(l, f(r, rk))
+        return nl, nr
+    l, r = btd[:len(btd)//2], btd[len(btd)//2:]
+    for rk in rks:
+        l, r = one_round(l, r, rk)
+    nbtd = r+l
+    return nbtd
+    
+def main():
+    pass
+
+if __name__ == "__main__":
+    main()

project_des-0.1.0/project_DES/des_core/key.py

@@ -0,0 +1,63 @@
+from . import bit_utils as b
+from . import permute as p
+
+meticulous_mode = True
+
+def pc1(btd: list[int])  -> list[int]:
+    if meticulous_mode and len(btd) != 64:
+        raise ValueError('pc1:invalid input')
+    t = [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]
+    nbtd = p.permutation(btd, t)
+    return nbtd
+    
+def pc2(btd: list[int])  -> list[int]:
+    if meticulous_mode and len(btd) != 56:
+        raise ValueError('pc2:invalid input')
+    t = [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]
+    nbtd = p.permutation(btd, t)
+    return nbtd
+
+def lcs(btd: list[int], t: int)  -> list[int]:
+    op = btd[t:]+btd[:t]
+    return op
+    
+    
+def generate_round_key(mk: bytes)  -> list[list[int]]:
+    if meticulous_mode and len(mk) != 8:
+        raise ValueError('generate_round_key:invalid main key')
+    def generate_ki(rd: int, lsk: list[int]) -> tuple[list[int], list[int]]:#rd -> 1 ~ 16
+        if meticulous_mode and len(lsk) != 56:
+            raise ValueError('generate_ki:invalid sub key')
+        l, r = lsk[:28], lsk[28:]
+        lcs_t = [None, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
+        l, r = lcs(l, lcs_t[rd]), lcs(r, lcs_t[rd])
+        nsk = l+r
+        ki = pc2(nsk)
+        return ki, nsk
+    bmk = b.bytes_to_bits(mk)
+    sk = pc1(bmk)
+    rkl = []
+    for i in range(1, 17):
+        ki, sk = generate_ki(i, sk)
+        rkl.append(ki)
+    return rkl
+    
+def main():
+    pass
+    
+if __name__ == "__main__":
+    main()

project_des-0.1.0/project_DES/des_core/mangler.py

@@ -0,0 +1,97 @@
+from . import bit_utils as b
+from . import permute as p
+
+meticulous_mode = True
+
+def p_box(btd: list[int]) -> list[int]:
+    if meticulous_mode and len(btd) != 32:
+        raise ValueError('p_box:invalid input')
+    t = [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]
+    nbtd = p.permutation(btd, t)
+    return nbtd
+    
+def s_box(btd: list[int])  -> list[int]:
+    if meticulous_mode and len(btd) != 48:
+        raise ValueError('s_box:invalid input')
+    t ={1: [[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7], 
+            [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8], 
+            [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0], 
+            [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],
+        2: [[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10], 
+            [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5], 
+            [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15], 
+            [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],
+        3: [[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
+            [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1], 
+            [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7], 
+            [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],
+        4: [[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
+            [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
+            [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4], 
+            [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],
+        5: [[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9], 
+            [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6], 
+            [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14], 
+            [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],
+        6: [[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11], 
+            [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8], 
+            [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6], 
+            [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],
+        7: [[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1], 
+            [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6], 
+            [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2], 
+            [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],
+        8: [[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7], 
+            [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2], 
+            [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8], 
+            [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]],
+        }
+    def si(bd: list[int], box: int) -> list[int]:
+        nonlocal t
+        if meticulous_mode and (len(bd) != 6 or box > 8):
+            raise ValueError(f'si:invalid input')
+        row = b.bits_to_int([bd[0], bd[-1]])
+        column = b.bits_to_int(bd[1:-1])
+        nbd = b.int_to_bits(t[box][row][column], 4)
+        return nbd
+    sbtd = [btd[i:i+6] for i in range(0, 48, 6)]
+    nbtd = []
+    for i in range(8):
+        nbtd += si(sbtd[i], i+1)
+    return nbtd
+    
+def ep(btd: list[int])  -> list[int]:
+    if meticulous_mode and len(btd) != 32:
+        raise ValueError('ep:invalid input')
+    t = [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]
+    nbtd = p.permutation(btd, t)
+    return nbtd
+
+def f(btd: list[int], rk: list[int])  -> list[int]:
+    if meticulous_mode and len(btd) != 32 or len(rk) != 48:
+        raise ValueError('f:invalid input')
+    ep_btd = ep(btd)
+    rk_btd = b.xor(ep_btd, rk)
+    s_btd = s_box(rk_btd)
+    nbtd = p_box(s_btd)
+    return nbtd
+
+def main():
+    pass
+
+if __name__ == "__main__":
+    main()

project_des-0.1.0/project_DES/des_core/permute.py

@@ -0,0 +1,14 @@
+
+meticulous_mode = True
+
+def permutation(btd: list[int], table: list[int])  -> list[int]:
+    if meticulous_mode and len(btd) < max(table):
+        raise ValueError('permutation:index overflow')
+    n_btd = [btd[i-1] for i in table]
+    return n_btd
+
+def main():
+    pass
+    
+if __name__ == "__main__":
+    main()

project_des-0.1.0/project_DES/project_DES.py

@@ -0,0 +1,158 @@
+from .des_core import BasicDES
+from typing import Union, Iterable
+import os
+
+def read_bytes(name: str, l = 0) -> bytes:
+    """read bytes from target file"""
+    bfile = open(name, 'rb')
+    data = bfile.read()
+    bfile.close()
+    if l == 0:
+        return data
+    return data[:l]
+    
+def write_bytes(name: str, data: bytes):
+    """write bytes into a new created file"""
+    bfile = open(name, 'wb')
+    bfile.write(data)
+    bfile.close()
+    
+class DES:
+    def __init__(self, key: Union[bytes, str], mode: str = 'ECB'):
+        """setting initial mode and cipher machine"""
+        self.modes = {'ECB', 'CBC'}
+        if isinstance(key, str):
+            key = read_bytes(key, 8)
+        if len(key) != 8:
+            raise ValueError('DES: invalid key')
+        self.cipher = BasicDES(key)
+        self.__key = key
+        if mode not in self.modes:
+            raise ValueError('DES: unknown mode of operation')
+        self.__mode = mode
+            
+    @staticmethod
+    def __add_padding(file: bytes) -> bytes:
+        """add padding to a bytes string"""
+        if not isinstance(file, bytes):
+            raise TypeError
+        if len(file)%8 == 0:
+            return file + b'\x08'*8
+        return file + bytes([8-(len(file)%8)]*(8-(len(file)%8)))
+
+    @staticmethod
+    def __remove_padding(file: bytes) -> bytes:
+        """remove padding from a bytes string"""
+        if not isinstance(file, bytes):
+            raise TypeError
+        pl = file[-1]
+        if pl > 8 or pl < 1 or file[-pl:] != bytes([pl])*pl:
+            return file
+        return file[:-pl]
+        
+    @staticmethod
+    def __split_data(file: bytes) -> list[bytes]:
+        """split a bytes string to a list contain bytes strings with length of 8"""
+        if (len(file)%8) != 0:
+            raise ValueError ('split_data: data must be splited perfectly')
+        return [file[i: i+8] for i in range(0, len(file), 8)]
+    
+    @staticmethod
+    def __merge_data(blocks: Iterable[bytes]) -> bytes:
+        """merge a list contain bytes strings into bytes string"""
+        return b''.join(blocks)
+        
+    @staticmethod
+    def __random_iv() -> bytes:
+        """generate a random initialization vector for cbc encryption"""
+        return os.urandom(8)
+        
+    @staticmethod
+    def __xor(b1: bytes, b2: bytes):
+        """perform xor operation between two bytes string of equal length"""
+        return bytes(i^j for i, j in zip(b1, b2))
+    
+    def __ecb(self, blocks: list[bytes], decrypt: bool = False) -> bytes:
+        """perform encrypt & decryption of ECB method"""
+        if not decrypt:
+            return self.__merge_data(self.cipher.encrypt(i) for i in blocks)
+        else:
+            return self.__remove_padding(self.__merge_data(self.cipher.decrypt(i) for i in blocks))
+    
+    def __cbc(self, blocks: list[bytes], decrypt: bool = False) -> bytes:
+        """perform encryption & decryption of CBC method"""
+        if not decrypt:
+            v = self.__random_iv()
+            cipher_data = [v] 
+            for i in blocks:
+                v = self.cipher.encrypt(self.__xor(i, v))
+                cipher_data.append(v)
+            return self.__merge_data(cipher_data)
+        else:
+            if len(blocks) < 2:
+                raise ValueError("cbc: ciphertext too short")
+            va, blocks = blocks[:-1], blocks[1:]
+            return self.__remove_padding(self.__merge_data(self.__xor(self.cipher.decrypt(i), j) for i, j in zip(blocks, va)))
+              
+    def get_modes(self) -> list[str]:
+        """get avaliable cipher mode of operation"""
+        return self.modes
+        
+    def get_mode(self) -> str:
+        """get current cipher mode of operation"""
+        return self.__mode
+    
+    def change_mode(self, mode: str):
+        """change current cipher mode of operation"""
+        if mode not in self.modes:
+            raise ValueError('change_mode: unknown mode of operation')
+        self.__mode = mode
+     
+    def get_key(self) -> bytes:
+        """get current using key"""
+        return self.__key      
+       
+    def change_key(self, key: Union[bytes, str]):
+        """change current using key"""
+        if isinstance(key, str):
+            key = read_bytes(key, 8)
+        if len(key) != 8:
+            raise ValueError('change_key: invalid key')
+        self.cipher = BasicDES(key)
+        self.__key = key
+        
+    def encrypt(self, plaintext: bytes) -> bytes:
+        """encrypt bytes data"""
+        blocks = self.__split_data(self.__add_padding(plaintext))
+        mode = self.__mode
+        if mode == 'ECB':
+            return self.__ecb(blocks)
+        elif mode == 'CBC':
+            return self.__cbc(blocks)
+             
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        """decrypt bytes data"""
+        blocks = self.__split_data(ciphertext)
+        mode = self.__mode
+        if mode == 'ECB':
+            return self.__ecb(blocks, decrypt = True)
+        elif mode == 'CBC':
+            return self.__cbc(blocks, decrypt = True)
+            
+    def encrypt_file(self, name: str, new_name: str):
+        """encrypt target file and save it as 'new_name' """
+        plaintext = read_bytes(name)
+        ciphertext = self.encrypt(plaintext)
+        write_bytes(new_name, ciphertext)
+    
+    def decrypt_file(self, name: str, new_name: str):
+        """decrypt target file and save it as 'new_name' """
+        ciphertext = read_bytes(name)
+        plaintext = self.decrypt(ciphertext)
+        write_bytes(new_name, plaintext)
+                
+def main():
+    pass
+
+if __name__ == "__main__":
+    main()

project_des-0.1.0/project_des.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: project-des
+Version: 0.1.0
+Summary: Educational Python implementation of the Data Encryption Standard (DES)
+Author-email: shrimp2845 <goldencheng15@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/shrimp2845-tw/project_DES
+Project-URL: Repository, https://github.com/shrimp2845-tw/project_DES
+Keywords: des,cryptography,education,feistel
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+**_Warning: This implementation is intended for self learning purposes only and should not be used for real-world security._**
+
+## About
+
+- **Author:** shrimp2845  
+- **Version:** 0.1.0  
+- **License:** MIT
+
+This is an educational Python implementation of the Data Encryption Standard (DES). This project breaks down the complex Feistel network into human-readable modules following the official NIST specifications, and supports ECB and CBC modes for real file encryption.
+
+## Installation & Usage
+
+### install
+Requires Python 3.10+
+```bash
+pip install project-des
+```
+### usage
+```bash
+python -c "from project_DES import DES; cipher = DES(b'key'); print(cipher.encrypt(b'data').hex())"
+```
+
+## Docs
+
+```
+class initialize
+----------------------
+project_DES.DES(key, mode='ECB')
+
+key 
+-> 8 bytes or key file name 
+containing an encryption key,
+if key is str, it extract 
+first 8 bytes in the file
+
+mode
+-> optional, block cipher mode of 
+operation that used,ECB and CBC 
+available in current version
+
+
+methods
+----------------------
+
+encrypt(data: bytes) -> bytes, 
+decrypt(data: bytes) -> bytes
+-> return encrypt/decrypt bytes data
+
+encrypt_file(name: str, new_name: str), 
+decrypt_file(name: str, new_name: str) 
+-> encrypt/decrypt target file 'name' 
+and save it as 'new_name'
+
+get_key(), get_mode()
+-> get current using key/mode of 
+operation
+
+change_key(key: str or bytes),
+change_mode(mode: str)
+-> change current using key/mode of 
+operation
+
+```
+
+## Examples
+Project provides two examples: [string_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/string_cipher.py) & [file_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/file_cipher.py)
+
+you can find samples of [file_cipher.py](https://github.com/shrimp2845-tw/project_DES/blob/main/examples/file_cipher.py) at:
+[ecb_sample](https://github.com/shrimp2845-tw/project_DES/tree/main/examples/ecb_sample) & [cbc_sample](https://github.com/shrimp2845-tw/project_DES/tree/main/examples/cbc_sample)
+
+### explanation for samples
+**mumei.jpg**: plaintext file
+
+**mumei.bin**: encrypt mumei.jpg with key ‘berries’ and mode ECB
+
+**mumei_correct_decrypt**.jpg: decrypt mumei.bin with key ‘berries’ and mode ECB
+
+**mumei_wrong_decrypt.jpg**: decrypt  mumei.bin with key ‘friend’ and mode ECB
+
+**ina.jpg**: plaintext file 
+
+**ina.bin**: encrypt ina.jpg with key ‘takodachi’ and mode CBC
+
+**ina_correct_decrypt.jpg**: decrypt ina.bin with key ‘takodachi’ and mode CBC
+
+**ina_wrong_decrypt.jpg**: decrypt ina.bin with key ‘violet’ and mode CBC
+
+
+## Performance 
+This project is designed for learning and understanding how DES works  rather than for practical encryption use. The implementation prioritizes readability and modular structure over performance.
+
+As a result, encryption process is **very slow**. It takes nearly 2 minutes to encrypt 1MB file.
+
+
+
+

project_des-0.1.0/project_des.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+project_DES/__init__.py
+project_DES/project_DES.py
+project_DES/des_core/__init__.py
+project_DES/des_core/bit_utils.py
+project_DES/des_core/crypto.py
+project_DES/des_core/feistel.py
+project_DES/des_core/key.py
+project_DES/des_core/mangler.py
+project_DES/des_core/permute.py
+project_des.egg-info/PKG-INFO
+project_des.egg-info/SOURCES.txt
+project_des.egg-info/dependency_links.txt
+project_des.egg-info/top_level.txt

project_des-0.1.0/project_des.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

project_des-0.1.0/project_des.egg-info/top_level.txt

@@ -0,0 +1 @@
+project_DES

project_des-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "project-des"
+version = "0.1.0"
+description = "Educational Python implementation of the Data Encryption Standard (DES)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+
+authors = [
+    {name = "shrimp2845", email = "goldencheng15@gmail.com"}
+]
+
+keywords = ["des", "cryptography", "education", "feistel"]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://github.com/shrimp2845-tw/project_DES"
+Repository = "https://github.com/shrimp2845-tw/project_DES"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["project_DES*"]

project_des-0.1.0/setup.cfg

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