예제 #1
0
def decryptMessage(message, key, alphabet):
    key1 = len(message)
    new_alphabet = AffineCipher.encryptMessage(alphabet, key1, alphabet)
    out1 = ''
    count = 0
    num = len(new_alphabet)
    first_symbol = True
    for symbol in message:
        symbol_index = new_alphabet.find(symbol)
        if symbol_index > -1:
            symbol_index -= new_alphabet.find(new_alphabet[count])
            if first_symbol is True:
                symbol_index -= len(message)
                first_symbol = False
            out1 += new_alphabet[(symbol_index) % num]
        else:
            out1 += symbol
        count = (count + 1) % num
    out2 = TranspositionCipher.decryptMessage(out1, key)
    return out2
예제 #2
0
    def run_algorithm(self):
        # Cleaning the warning messages
        self.warning.grid_forget()
        self.result.configure(state='normal')
        self.result.delete(0.0, END)
        self.result.configure(state='disabled')

        # Getting the cipher
        cipher = self.cipher.get()

        # Getting the alphabet
        self.setDefaultAlphabet()
        if self.alphabetButton.get() == 2 and cipher != 5:
            self.alphabet = self.alphabetEntry.get()
            if len(self.alphabet) == 0:
                # Warning message
                self.warning[
                    "text"] = "Your custom alphabet cannot be empty.\nTip: you should consider enter a large alphabet."
                self.warning.grid(row=self.affine_row + 6,
                                  column=11,
                                  sticky=W + W,
                                  padx=10,
                                  columnspan=2,
                                  rowspan=2)
                return

        # Getting the key
        if len(self.keyEntry.get()) == 0:
            # Warning message
            self.warning["text"] = "Please enter a valid key (numbers only)."
            self.warning.grid(row=self.affine_row + 6,
                              column=11,
                              sticky=W + W,
                              padx=10,
                              columnspan=2,
                              rowspan=2)
            return
        self.key = int(self.keyEntry.get())

        # Getting the message
        # Put end-1c for avoid getting '\n' at the end of the input.
        message = self.plainText.get("1.0", 'end-1c')
        if len(message) == 0:
            # Warning message
            self.warning[
                "text"] = "I think you forgot to enter your message..."
            self.warning.grid(row=self.affine_row + 6,
                              column=11,
                              sticky=W + W,
                              padx=10,
                              columnspan=2,
                              rowspan=2)
            return

        # Configuring the result
        self.result.configure(state='normal')

        # Encrypt according to the selected cipher
        if cipher == 1:  # Affine Cipher
            valid = AffineCipher.validateKey(self.key, len(self.alphabet))
            if valid is True:
                # Continue the algorithm
                self.result.insert(
                    0.0,
                    AffineCipher.decryptMessage(message, self.key,
                                                self.alphabet))
            else:
                # Show a warning message
                self.warning[
                    "text"] = "This key can't be used with this alphabet.\nPlease enter another key."
                self.warning.grid(row=self.affine_row + 6,
                                  column=11,
                                  sticky=W + W,
                                  padx=10,
                                  columnspan=2,
                                  rowspan=2)

        elif cipher == 2:  # Caesar Cipher
            self.result.insert(
                0.0,
                CaesarCipher.decryptMessage(message, self.key, self.alphabet))

        elif cipher == 3:  # Multiplicative Cipher
            valid = MultiplicativeCipher.validateKey(self.key,
                                                     len(self.alphabet))
            if valid is True:
                # Continue the algorithm
                self.result.insert(
                    0.0,
                    MultiplicativeCipher.decryptMessage(
                        message, self.key, self.alphabet))
            else:
                # Show a warning message
                self.warning[
                    "text"] = "This key can't be used with this alphabet.\nPlease enter another key."
                self.warning.grid(row=self.affine_row + 6,
                                  column=11,
                                  sticky=W + W,
                                  padx=10,
                                  columnspan=2,
                                  rowspan=2)

        elif cipher == 4:  # My Cipher
            valid = MyCipher.validateKey(self.key, len(self.alphabet))
            if valid is True:
                # Continue the algorithm
                self.result.insert(
                    0.0,
                    MyCipher.decryptMessage(message, self.key, self.alphabet))
            else:
                # Show a warning message
                self.warning[
                    "text"] = "This key can't be used with this alphabet.\nPlease enter another key."
                self.warning.grid(row=self.affine_row + 6,
                                  column=11,
                                  sticky=W + W,
                                  padx=10,
                                  columnspan=2,
                                  rowspan=2)

        elif cipher == 5:  # Transposition Cipher
            self.result.insert(
                0.0, TranspositionCipher.decryptMessage(message, self.key))

        # Setting result for read-only again
        self.result.configure(state='disabled')