Update shuffled_shift_cipher.py

Author: lighting9999

ciphers/shuffled_shift_cipher.py

@@ -3,182 +3,100 @@
 import random
 import string
 
-
 class ShuffledShiftCipher:
     """
-    This algorithm uses the Caesar Cipher algorithm but removes the option to
-    use brute force to decrypt the message.
-
-    The passcode is a random password from the selection buffer of
-    1. uppercase letters of the English alphabet
-    2. lowercase letters of the English alphabet
-    3. digits from 0 to 9
-
-    Using unique characters from the passcode, the normal list of characters,
-    that can be allowed in the plaintext, is pivoted and shuffled. Refer to docstring
-    of __make_key_list() to learn more about the shuffling.
-
-    Then, using the passcode, a number is calculated which is used to encrypt the
-    plaintext message with the normal shift cipher method, only in this case, the
-    reference, to look back at while decrypting, is shuffled.
-
-    Each cipher object can possess an optional argument as passcode, without which a
-    new passcode is generated for that object automatically.
-    cip1 = ShuffledShiftCipher('d4usr9TWxw9wMD')
-    cip2 = ShuffledShiftCipher()
+    Enhanced Caesar Cipher with shuffled character set for stronger encryption.
+    Uses a passcode to generate a unique shuffled key list and shift key.
     """
 
     def __init__(self, passcode: str | None = None) -> None:
         """
-        Initializes a cipher object with a passcode as it's entity
-        Note: No new passcode is generated if user provides a passcode
-        while creating the object
+        Initialize cipher with optional passcode. 
+        Generates random passcode if none provided.
         """
         self.__passcode = passcode or self.__passcode_creator()
         self.__key_list = self.__make_key_list()
         self.__shift_key = self.__make_shift_key()
 
     def __str__(self) -> str:
-        """
-        :return: passcode of the cipher object
-        """
+        """Return passcode as string representation."""
         return "".join(self.__passcode)
 
-    def __neg_pos(self, iterlist: list[int]) -> list[int]:
-        """
-        Mutates the list by changing the sign of each alternate element
-
-        :param iterlist: takes a list iterable
-        :return: the mutated list
-
-        """
-        for i in range(1, len(iterlist), 2):
-            iterlist[i] *= -1
-        return iterlist
+    def __neg_pos(self, iter_list: list[int]) -> list[int]:
+        """Alternate sign of elements in list."""
+        for i in range(1, len(iter_list), 2):
+            iter_list[i] *= -1
+        return iter_list
 
     def __passcode_creator(self) -> list[str]:
-        """
-        Creates a random password from the selection buffer of
-        1. uppercase letters of the English alphabet
-        2. lowercase letters of the English alphabet
-        3. digits from 0 to 9
-
-        :rtype: list
-        :return: a password of a random length between 10 to 20
-        """
+        """Generate random passcode."""
         choices = string.ascii_letters + string.digits
-        password = [random.choice(choices) for _ in range(random.randint(10, 20))]
-        return password
+        pass_len = random.randint(10, 20)
+        return [random.choice(choices) for _ in range(pass_len)]
 
     def __make_key_list(self) -> list[str]:
-        """
-        Shuffles the ordered character choices by pivoting at breakpoints
-        Breakpoints are the set of characters in the passcode
-
-        eg:
-            if, ABCDEFGHIJKLMNOPQRSTUVWXYZ are the possible characters
-            and CAMERA is the passcode
-            then, breakpoints = [A,C,E,M,R] # sorted set of characters from passcode
-            shuffled parts: [A,CB,ED,MLKJIHGF,RQPON,ZYXWVUTS]
-            shuffled __key_list : ACBEDMLKJIHGFRQPONZYXWVUTS
-
-        Shuffling only 26 letters of the english alphabet can generate 26!
-        combinations for the shuffled list. In the program we consider, a set of
-        97 characters (including letters, digits, punctuation and whitespaces),
-        thereby creating a possibility of 97! combinations (which is a 152 digit number
-        in itself), thus diminishing the possibility of a brute force approach.
-        Moreover, shift keys even introduce a multiple of 26 for a brute force approach
-        for each of the already 97! combinations.
-        """
-        # key_list_options contain nearly all printable except few elements from
-        # string.whitespace
-        key_list_options = (
-            string.ascii_letters + string.digits + string.punctuation + " \t\n"
-        )
-
-        keys_l = []
-
-        # creates points known as breakpoints to break the key_list_options at those
-        # points and pivot each substring
+        """Create shuffled character set using passcode breakpoints."""
+        # Get printable characters except rare whitespace
+        key_options = string.printable.strip("\r\x0b\x0c")
         breakpoints = sorted(set(self.__passcode))
-        temp_list: list[str] = []
-
-        # algorithm for creating a new shuffled list, keys_l, out of key_list_options
-        for i in key_list_options:
-            temp_list.extend(i)
-
-            # checking breakpoints at which to pivot temporary sublist and add it into
-            # keys_l
-            if i in breakpoints or i == key_list_options[-1]:
-                keys_l.extend(temp_list[::-1])
-                temp_list.clear()
-
-        # returning a shuffled keys_l to prevent brute force guessing of shift key
-        return keys_l
+        shuffled = []
+        temp = []
+        
+        for char in key_options:
+            temp.append(char)
+            if char in breakpoints or char == key_options[-1]:
+                shuffled.extend(reversed(temp))
+                temp.clear()
+                
+        return shuffled
 
     def __make_shift_key(self) -> int:
-        """
-        sum() of the mutated list of ascii values of all characters where the
-        mutated list is the one returned by __neg_pos()
-        """
-        num = sum(self.__neg_pos([ord(x) for x in self.__passcode]))
+        """Calculate shift key from passcode ASCII values."""
+        ascii_vals = [ord(x) for x in self.__passcode]
+        num = sum(self.__neg_pos(ascii_vals))
         return num if num > 0 else len(self.__passcode)
 
-    def decrypt(self, encoded_message: str) -> str:
-        """
-        Performs shifting of the encoded_message w.r.t. the shuffled __key_list
-        to create the decoded_message
-
-        >>> ssc = ShuffledShiftCipher('4PYIXyqeQZr44')
-        >>> ssc.decrypt("d>**-1z6&'5z'5z:z+-='$'>=zp:>5:#z<'.&>#")
-        'Hello, this is a modified Caesar cipher'
-
-        """
-        decoded_message = ""
-
-        # decoding shift like Caesar cipher algorithm implementing negative shift or
-        # reverse shift or left shift
-        for i in encoded_message:
-            position = self.__key_list.index(i)
-            decoded_message += self.__key_list[
-                (position - self.__shift_key) % -len(self.__key_list)
-            ]
-
-        return decoded_message
-
     def encrypt(self, plaintext: str) -> str:
-        """
-        Performs shifting of the plaintext w.r.t. the shuffled __key_list
-        to create the encoded_message
-
-        >>> ssc = ShuffledShiftCipher('4PYIXyqeQZr44')
-        >>> ssc.encrypt('Hello, this is a modified Caesar cipher')
-        "d>**-1z6&'5z'5z:z+-='$'>=zp:>5:#z<'.&>#"
-
-        """
-        encoded_message = ""
-
-        # encoding shift like Caesar cipher algorithm implementing positive shift or
-        # forward shift or right shift
-        for i in plaintext:
-            position = self.__key_list.index(i)
-            encoded_message += self.__key_list[
-                (position + self.__shift_key) % len(self.__key_list)
-            ]
-
-        return encoded_message
-
-
-def test_end_to_end(msg: str = "Hello, this is a modified Caesar cipher") -> str:
-    """
-    >>> test_end_to_end()
-    'Hello, this is a modified Caesar cipher'
-    """
-    cip1 = ShuffledShiftCipher()
-    return cip1.decrypt(cip1.encrypt(msg))
+        """Encrypt plaintext using shuffled shift cipher."""
+        encoded = []
+        key_len = len(self.__key_list)
+        
+        for char in plaintext:
+            pos = self.__key_list.index(char)
+            new_pos = (pos + self.__shift_key) % key_len
+            encoded.append(self.__key_list[new_pos])
+            
+        return "".join(encoded)
 
+    def decrypt(self, encoded_message: str) -> str:
+        """Decrypt message using shuffled shift cipher."""
+        decoded = []
+        key_len = len(self.__key_list)
+        
+        for char in encoded_message:
+            pos = self.__key_list.index(char)
+            new_pos = (pos - self.__shift_key) % key_len
+            decoded.append(self.__key_list[new_pos])
+            
+        return "".join(decoded)
+
+def test_end_to_end() -> str:
+    """Test full encryption-decryption cycle."""
+    msg = "Hello, this is a modified Caesar cipher"
+    cipher = ShuffledShiftCipher()
+    return cipher.decrypt(cipher.encrypt(msg))
 
 if __name__ == "__main__":
     import doctest
-
     doctest.testmod()
+    
+    # Example usage
+    cipher = ShuffledShiftCipher("SecurePass123")
+    original = "Encryption test!"
+    encrypted = cipher.encrypt(original)
+    decrypted = cipher.decrypt(encrypted)
+    
+    print(f"Original: {original}")
+    print(f"Encrypted: {encrypted}")
+    print(f"Decrypted: {decrypted}")
+    print(f"Test passed: {decrypted == original}")