def PigLatinCipher(message): File.write("\n") File.write("This is the results of the Pig Latin Decryption ") File.write("\n") logging.info("PigLatinCipher()") # Goes to Pig latin Module PigLatinDecrypted = PigLatin.PigLatinDecrypt(message) logging.info("Completed pig latin cipher") logging.debug("here are the results from pig latin ") # Pig Latin decrypted should always return a tuple because # of how the multiple return statement works # because of this, we split up the tuple by turning it # into a list below, allowing us to alter it # Since we're splitting it up, if Pig Latin is too short, it'll return # an error, we can't print this error if we run these list operations on it # so we use an If statement to check if PigLatinDecrypted[0] == "\n": print(PigLatinDecrypted) File.write(PigLatinDecrypted) logging.error(PigLatinDecrypted) else: PigLatinDecrypted_1 = PigLatinDecrypted[0] PigLatinDecrypted_2 = PigLatinDecrypted[1] # writes pig latin to logging file logging.debug(PigLatinDecrypted_1) logging.debug(PigLatinDecrypted_2) if detectEnglish.isEnglish(PigLatinDecrypted_1) == True: # If Engish is detected, write the english into a variable # and the name of the cipher into a variable, send it to # EnglishDetected() EnglishMSG = PigLatinDecrypted_1 CipherName = "Pig Latin 1" EnglishDetected(EnglishMSG, CipherName, File) elif detectEnglish.isEnglish(PigLatinDecrypted_2) == True: # If Engish is detected, write the english into a variable # and the name of the cipher into a variable, send it to # EnglishDetected() EnglishMSG = PigLatinDecrypted_1 CipherName = "Pig Latin 2" EnglishDetected(EnglishMSG, CipherName, File) # writes pig latin to file File.write(PigLatinDecrypted_1) File.write(PigLatinDecrypted_2) # Prints pig latin to screen print("\nThis is the results of the Pig Latin Cipher") print(PigLatinDecrypted_1) print(PigLatinDecrypted_2)
def hackAffine(message): print('Hacking...') print('(Press Ctrl-C or Ctrl-D to quit at any time.)') for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print('Tried Key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def decode_cz(message): attempts = [] results = [] # The same process as encoding, but for all 66 possible keys for key in range(len(symbols)): # translated is reset to '' on every iteration translated = '' for i in message: if i in symbols: index = symbols.find(i) translatedIndex = index - key # Handle wrap if translatedIndex < 0: translatedIndex = translatedIndex + len(symbols) translated = translated + symbols[translatedIndex] else: translated = translated + i attempts.append(translated) # Check if each 'decoded' string is legible English # If it is, append it to the results list for attempt in attempts: if isEnglish(attempt): results.append(attempt) else: pass print(results) return results
def hackTransposition(message): print('Hacking...') # Python programs can be stopped at any time by pressing Ctrl-C (on # Windows) or Ctrl-D (on Mac and Linux) print('(Press Ctrl-C or Ctrl-D to quit at any time.)') # brute-force by looping through every possible key for key in range(1, len(message)): print('Trying key #%s...' % (key)) decryptedText = transpositionDecrypt.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): # Check with user to see if the decrypted key has been found. print() print('Possible encryption hack:') print('Key %s: %s' % (key, decryptedText[:100])) #To be sure, this prints out the first 100 characters of the decryptedText print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') """The strip() string method returns a version of the string that has any whitespace at the beginning and end of the string stripped out.""" if response.strip().upper().startswith('D'): #D for done return decryptedText return None
def hackAffine(message): print('Hacking...') # Python programs can be stopped at any time by pressing Ctrl-C (on # Windows) or Ctrl-D (on Mac and Linux) print('(Press Ctrl-C or Ctrl-D to quit at any time.)') # brute force by looping through every possible key for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print('Tried Key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): # Check with the user if the decrypted key has been found. print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def hackAffine(message): print('Hacking...') print('(Press Ctrl-C or Ctrl-D to quit at any time.)') for key in range(len(SYMBOLS)**2): keyA = getKeyParts(key)[0] if cryptomath.gcd(keyA, len(SYMBOLS)) != 1: continue decryptedText = decryptMessage(key, message) if not SILENT_MODE: print('Tried Key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D if done, anything else to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def hackAffine(message): print('Attempting to hack message...') print('To quit any time prss CTRL-C (Windows) or CTRL-D (macOS && Linux') # Begin the brute-force of every key for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print('Treid Key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): # Ask user is decrypted key was found print() print('Possible encryption hack...') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done, or ENTER to continue hacking') response = input('>') if response.strip().upper().startswith('D'): return decryptedText return None
def hackAffine(message): print "\nAttempting to decode message...\n" # Brute-force by looping through every possible key for key in range(len(affineCipher.SYMBOLS)**2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print 'Tried Key %s... (%s)' % (key, decryptedText[:40]) startTime = time.time() isEnglish = detectEnglish.isEnglish(decryptedText) totalTime = round(time.time() - startTime, 2) print 'English detection time: %s seconds' % totalTime if isEnglish: print "\nPossible decrypted message:" print " Key %s: %s" % (key, decryptedText[:100]) response = raw_input( "\nEnter D if done, or any other key to continue the attack: ") if response.strip().upper().startswith('D'): return decryptedText return None
def hackSimpleSubIsEnglish(message): tryNum = 1 while 1: # Python programs can be stopped at any time by pressing Ctrl-C (on Windows) or Ctrl-D (on Mac and Linux) # brute-force by looping through every possible key decKey = getRandomKey() print('[%d th try] DecKey: %s' % (tryNum, decKey)) decryptedText = simpleSubCipher.decryptMessage(decKey, message) if detectEnglish.isEnglish(decryptedText) > 0.20: # Check with the user to see if the decrypted key has been found. print() print('Possible Ciphertext hack:') print('Key: ' + str(decKey)) print('Decrypted message: ' + decryptedText[:100]) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.upper().startswith('D'): return decryptedText tryNum += 1 if tryNum >= ITERATION: return None return None
def hackTransposition(message): print('Hacking...') # Python programs can be stopped at any time by pressing Ctrl-C (on # Windows) or Ctrl-D (on Mac and Linux) print('(Press Ctrl-C or Ctrl-D to quit at any time.)') # brute-force by looping through every possible key for key in range(1, len(message)): print('Trying key #%s...' % (key)) decryptedText = transpositionDecrypt.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): # Check with user to see if the decrypted key has been found. print() print('Possible encryption hack:') print('Key %s: %s' % (key, decryptedText[:100])) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def hackAffine(message): print('Hacking...') print('(Press Ctrl-C or Ctrl-D to stop at any time)') for key in range(len(affine_cipher.SYMBOLS) ** 2): keyA = affine_cipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affine_cipher.SYMBOLS)) != 1: continue text = affine_cipher.decryptMessage(key, message) if SILENT_MODE is False: print() print('+: key:\t%s' % (key)) print('+: msg:\t%s' % (text[200:])) print() if detectEnglish.isEnglish(text) is True: print() print('+: key:\t%s' % (key)) print('+: msg:\t%s' % (text[200:])) print() print('Enter D for done, or just press Enter to continue') prompt = input('> ') if prompt.upper().startswith('D') is True: return text return None
def hackNull(ciphertext): # The program needs to try keys of length 1 (such as '5'), of length 2 # (such as '5 3'), and so on up to length MAX_KEY_DIGITS. for keyLength in range(1, MAX_KEY_DIGITS + 1): for keyParts in itertools.product(range(MAX_KEY_NUMBER + 1), repeat=keyLength): key = [] for digit in keyParts: key.append(str(digit)) key = ''.join(key) decryptedText = nullCipher.decryptMessage(key, ciphertext) if not SILENT_MODE: print('Key %s: %s' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None # failed to hack encryption
def hackTransposition(message): print('Hacking...') # Python programs can be stopped at any time by pressing Ctrl-C (on # Windows) or Ctrl-D (on Mac and Linux) print('(Press Ctrl-C or Ctrl-D to quit at any time.)') # Brute-force by looping through every possible key. for key in range(1, len(message)): print('Trying key #%s...' % (key)) decryptedText = transpositionDecrypt.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): # Ask user if this is the correct decryption. print() print('Possible encryption hack:') print('Key %s: %s' % (key, decryptedText[:100])) print() print('Enter D if done, anything else to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def hackAffine(message): print 'Hacking...' for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if affineCipher.gcd(keyA,len(affineCipher.SYMBOLS)) != 1: continue decryptedMessage = affineCipher.decryptMessage(key,message) if not SILENT_MODE: print 'Tried key ' + str(key) + '...' print decryptedMessage[:70] if detectEnglish.isEnglish(decryptedMessage): print 'Possible encryption hack,fisrt 500 letters in decrypted message:' print decryptedMessage[:500] isDone = False i = 0 while(not isDone): print 'Enter D for done, Enter C for more message,or just press Enter to continue hacking: ' i+=1 response = raw_input('>') if(response.lower().startswith('d')): return decryptedMessage elif(response.lower().startswith('c')): print decryptedMessage[500*i:500*i+500] else: break return None
def hackTransposition(message): print 'Hacking...' print '(Press Ctrl-C or Ctrl-D to quit at any time.)' # brute-force by looping through every possible key for key in range(1, len(message)): print 'Trying key #%s...' % (key) decryptedText = decryptTransposition.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): # Check with user to see if the decrypted key has been found. print print 'Possible encryption hack:' print 'Key %s: %s' % (key, decryptedText[:100]) print #accounts for false positives print 'Enter D for done, or just press Enter to continue hacking:' response = raw_input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def breakAffine(message): print('Breaking...') # Python programs can be stopped at any time by pressing Ctrl-C (on # Windows) or Ctrl-D (on Mac and Linux) print('(Press Ctrl-C or Ctrl-D to quit at any time.)') # brute force by looping through every possible key for keyA in range(len(affineCipher.SYMBOLS)): if affineCipher.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue for keyB in range(len(affineCipher.SYMBOLS)): decryptedText = affineCipher.decryptMessage(keyA, keyB, message) print('Tried KeyA %s, KeyB %s... (%s)' % (keyA, keyB, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): # Check with the user if the decrypted key has been found. print() print('Possible encryption break:') print('KeyA: %s, KeyB: %s' % (keyA, keyB)) print('Decrypted message: ' + decryptedText[:100]) print() print('Enter D for done, or just press Enter to continue breaking:') response = input('> ') if response.upper().startswith('D'): return decryptedText return None
def hackCeasar(message): for key in range(len(SYMBOLS)): translated = '' for symbol in message: if symbol in SYMBOLS: symbolIndex = SYMBOLS.find(symbol) translatedIndex = symbolIndex - key if translatedIndex < 0: translatedIndex = translatedIndex + len(SYMBOLS) translated = translated + SYMBOLS[translatedIndex] else: translated = translated + symbol if detectEnglish.isEnglish(translated): # Ask user if this is the correct decryption. print() print('Possible encryption hack:') print('Key %s: %s' % (key, translated[:100])) print() print('Enter D if done, anything else to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): print('the decrypted text is: ', translated) return translated
def hackAffine(message): print('Hacking ..........') # python program can be stopped at any time in windows by pressing # Ctrl+C or Ctrl+D ( on Mac or Linux ) print('(Press Ctrl+C or Ctrl+D to stop the program)') # brute force by looping through every possible key for key in range(len(affine_cipher.SYMBOLS)**2): keyA = affine_cipher.getKeyParts(key)[0] if affine_cipher.gcd(keyA, len(affine_cipher.SYMBOLS)) != 1: continue decryptedText = affine_cipher.decryptMessage(key, message) if not SILENT_MODE: print('Tried key {0} ....({1})'.format(key, decryptedText)) if detectEnglish.isEnglish(decryptedText): # heck if the decrypted key has found print() print('Possible encryption hack:') print('key: {0}'.format(key)) print('Decrypted message : ' + decryptedText[:200]) print() print( 'Enter D for done, of just press Enter to continue hacking: ') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def hackNull(ciphertext): # The program needs to try keys of length 1 (such as '5'), of length 2 # (such as '5 3'), and so on up to length MAX_KEY_DIGITS. for keyLength in range(1, MAX_KEY_DIGITS + 1): for keyParts in itertools.product(range(MAX_KEY_NUMBER + 1), repeat=keyLength): key = [] for digit in keyParts: key.append(str(digit)) key = ''.join(key) decryptedText = nullCipher.decryptMessage(key, ciphertext) if not SILENT_MODE: print('Key %s: %s' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print( 'Enter D for done, or just press Enter to continue hacking:' ) response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None # failed to hack encryption
def hackVigenere(ciphertext): wordNumber = 1 fo = open("C:\\Users\\theka\\Desktop\\Crypto\\Input\\dictionary.txt") words = fo.readlines() fo.close() print("Attempting dictionary decryption") for word in words: print(str(wordNumber)) word = word.strip() decryptedText = vigenere.decryptMessage(word, ciphertext) if detectEnglish.isEnglish(decryptedText, wordPercentage=40): print() print("Possible encryption break:") print() print("key" + str(word) + ": " + decryptedText[:100]) print("Enter " "D" " for done, or hit enter to continue") response = input("> ") if response.upper().startswith("D"): return decryptedText wordNumber += 1
def hackTransposition(message): print 'hacking...' for key in range(1,len(message)): print str(round(float(key)/len(message),7)*100) + '%' decryptedMessage = tranEncrypt.decryptMessage(key,message) if(detectEnglish.isEnglish(decryptedMessage)): print 'Possible encryption hack,fisrt 500 letters in decrypted message:' print 'Key: ' + str(key) print decryptedMessage[:500] isDone = False i = 0 while(not isDone): print 'Enter D for done, Enter C for more message,or just press Enter to continue hacking: ' i+=1 response = raw_input('>') if(response.lower().startswith('d')): return decryptedMessage elif(response.lower().startswith('c')): print decryptedMessage[500*i:500*i+500] else: break return None
def hackAffine(message): global SILENT_MODE # ketikkan code dari slide 8 - 11 atau menggunakan versi Anda. print("Hacking...") print("Ctrl-C or Ctrl-D to quit at any time") for key in range(len(affineCipher.SYMBOLS)**2): keyA=affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS))!=1: continue decryptedtext=affineCipher.decryptMessage(key,message) if not SILENT_MODE: print(f"Tried key {key}... ({decryptedtext[:40]})") if detectEnglish.isEnglish(decryptedtext): print("Possible encryption hack: ") print(f"Key: {key}") print(f"Decrypted message: {decryptedtext[:200]}") print("Enter D for done, or just press Enter to continue hacking: ") response=input("> ") if response.upper()=="D": return decryptedtext return None
def hackAffine(message): print('Hacking...') # To stop: # Ctrl-C print('(Ctrl-C to quit)') # brute-force by looping through every possible key for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print('Tried Key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): # Check w/user to see if key found print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done, or just press enter to continue') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def attemptBreakWithKeyLength(ciphertext, mostLikelyKeyLength): # Determine the most likely letters for each letter in the key. # allFreqScores is a list of mostLikelyKeyLength number of lists. # These inner lists are the freqScores list. allFreqScores = [] for nth in range(1, mostLikelyKeyLength + 1): nthLetters = getNthLetter(nth, mostLikelyKeyLength, ciphertext) # freqScores is a list of tuples (<letter>, <eng. freq. match score>) # This list is sorted by match score (a lower score means a better # match. See the englishFreqMatch() comments in freqFinder). freqScores = [] for possibleKey in LETTERS: translated = vigenereCipher.decryptMessage(nthLetters, possibleKey) freqScores.append((possibleKey, freqFinder.englishFreqMatch(translated))) # Each value in freqScores is a tuple (<letter>, <match score>). Since # we want to sort by match score, we need to pass a "lambda" function # to sort()'s "key" parameter to look at the value at the [1] index. freqScores.sort(key=lambda x: x[1], reverse=True) allFreqScores.append(freqScores[:NUM_MOST_FREQ_LETTERS]) for i in range(len(allFreqScores)): # use i+1, because otherwise the "first" letter is called the "0th" letter print('Possible letters for letter %s of the key: ' % (i + 1), end='') for freqScore in allFreqScores[i]: print('%s ' % freqScore[0], end='') print() # Try every combination of the most likely letters for each position # in the key. for indexes in itertools.product(range(NUM_MOST_FREQ_LETTERS), repeat=mostLikelyKeyLength): # Create a possible key from the letters in allFreqScores possibleKey = '' for i in range(mostLikelyKeyLength): possibleKey += allFreqScores[i][indexes[i]][0] if not SILENT_MODE: print('Attempting with key: %s' % (possibleKey)) decryptedText = vigenereCipher.decryptMessage(ciphertext, possibleKey) if freqFinder.englishTrigramMatch(decryptedText): if detectEnglish.isEnglish(decryptedText): # Check with the user to see if the decrypted key has been found. print() print('Possible encryption break:') print('Key ' + str(possibleKey) + ': ' + decryptedText[:200]) print() print('Enter D for done, or just press Enter to continue breaking:') response = input('> ') if response.upper().startswith('D'): return decryptedText # No English-looking decryption found with any of the possible keys, # so return None. return None
def hackAffine(message): print('Hacking...') print('Press Ctrl-C or Ctrl-D to quit at any time.') # brute-fore by looping through every possible key for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print('Tried key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): # Check with the user if the decrypt key was correct. print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done, or Enter to continue:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def hackAffine(message): print('Hacking...') # Python programs can be stopped at any time by pressing Ctrl-C (on # Windows) or Ctrl-D (on Mac and Linux) print('(Press Ctrl-C or Ctrl-D to quit at any time.)') # brute-force by looping through every possible key for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print('Tried Key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): # Check with the user if the decrypted key has been found. print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def MorseCipher(message): # TODO clean this up logging.info("Trying morse code") File.write("\n") File.write("This is the results of the Morse Code Cipher.") File.write("\n") check = morsecode.Is_Morse(message) # Checks to make sure the message is actually morse code # or contains morse code # if it returns FAIL, it failed the test and message is not morse code if check != True: File.write("Morse code failed. Message is not morse.") print("Morse code failed. Message is not morse.") return ("Morse code failed.") # if message is or looks like morse code, run it through the morse code # decrypter else: MorseCode = morsecode.from_morse(message) if detectEnglish.isEnglish(MorseCode) == True: # If Engish is detected, write the english into a variable # and the name of the cipher into a variable, send it to # EnglishDetected() EnglishMSG = MorseCode CipherName = "Morse Code" EnglishDetected(EnglishMSG, CipherName, File) File.write("Morse Code sucessful.") File.write("\n") File.write(MorseCode) print("\nMorse code sucessful\n") print(MorseCode)
def bruteForce(self, sentence, order=False): """ Brute force attack on Ceaser cipher with any key. decode given sentence, tokenize it and if it is accessed as English sentence, then add it to candidate list """ ## TODO : IMPLEMENT BRUTE FORCE # all key m n pairs, both way # possibly all orders, brute force should have more parameters in order to know what to use lRet=[] tables = self.getTables(sentence) l=lWay = ["column"]#,"line"] for i in range(0,len(tables)): # over all tables # no order implementation for now for way in lWay: # over two ways of writing to table if way == "column": lOrder = [list(range(0,tables[i][0]))] else: lOrder = [list(range(0,tables[i][1]))] #print(i) #print(lOrder) for o in lOrder: sDecoded = self.decode(sentence, tables[i],way,o) if not len(sDecoded) == 0: lRet.append([sDecoded, [tables[i], way, o]]) #print(sDecoded,tables[i], way,"\n") sTokenized = tokenizer.tokenize(sDecoded) #print(sTokenized) if detectEnglish.isEnglish(sTokenized): print(sTokenized) self.printResult([sDecoded,[tables[i], way, o]]) # to result I add sentence without whitespaces, tokenize it after the result is tested return lRet
def hackAffine(message): print('Hacking...') print('(Press Ctrl-C or Ctrl-D to quit at any time.)') #brute-force by looping through each key for key in range(len(affineCipher.SYMBOLS)**2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)): continue decryptedText = affineCipher.decryptMessage(key, message) if not SILENT_MODE: print('Tried Key %s... (%s)' % (key, decryptedText[:40])) if detectEnglish.isEnglish(decryptedText): #Check with the user f the decrypted key has been found print() print('Possible encryption hack:') print('Key: %s' % (key)) print('Decrypted message: ' + decryptedText[:200]) print() print('Enter D for done,or just press Enter to Continue Hacking') response = input('>') if response.strip().upper().startswith('D'): return decryptedText return None #if affineHacker.py is run as module if __name__ == '__main__': main()
def hackTransposition(message): print('Hacking...') # Python programs can be stopped at any time by pressing Ctrl-C (on Windows) # or Ctrl-D (on Mac and Linux) print('(Press Ctrl-C or Ctrl-D to quit at any time.)') # brute-force by looping through every possible key for key in range(1, len(message)): print('Trying key #%s...' % (key)) decryptedText = transDecrypt.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): # Check with user to see if the decrypted key has been found print() print('Possible encryption hack:') print('Key %s: %s' % (key, decryptedText[:100])) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def ReverseCipher(message): logging.info("trying reverse cipher") File.write("\n") File.write("This is the result of the Reverse Cipher") ReversedCipher = Reverse.reverseCipher(message) # Creates varialbe of the reversed string logging.info("Reverse Cipher") # creates varaible, and goes to Reverse module to reverse string if detectEnglish.isEnglish(ReversedCipher) == True: # If Engish is detected, write the english into a variable # and the name of the cipher into a variable, send it to # EnglishDetected() EnglishMSG = ReversedCipher CipherName = "Reverse Cipher" EnglishDetected(EnglishMSG, CipherName, File) else: File.write("\n") File.write(ReversedCipher) File.write("\n") print("\nThis is the result of the Reverse cipher\n" "{}".format(ReversedCipher)) # Prints and logs to debug logging.debug("reverse cipher sucessful. result is ") logging.debug(ReversedCipher)
def task12(): encrypted_data = read('./text_files/text2_permutation_c.txt') for key in permutations([0, 1, 2, 3, 4, 5]): decrypted_text = decrypt(encrypted_data, key, len(key)) if isEnglish(decrypted_text): print(f"Possible key: {key}") print(f'Message part: {decrypted_text}')
def brute(self, text): keys = [] for a1 in self.reverses: for a2 in self.reverses: for b1 in range(1, len(self.alphabet)): for b2 in range(1, len(self.alphabet)): decrypted_text = (self.decode(text[:15], a1, b1, a2, b2)) if detectEnglish.isEnglish(decrypted_text[:8]) and detectEnglish.isEnglish(decrypted_text[8:15]): decrypted_text = (self.decode(text, a1, b1, a2, b2)) print('Возможный вариант дешифрования:') print() print('Дешифрованное сообщение: ' + decrypted_text) print() print('Введите D, если хотите закончить перебор, или нажмите Enter, чтобы продолжить:') response = input('> ') if response.strip().upper().startswith('D'): return decrypted_text
def attemptHackWithKeyLength(ciphertext, mostLikelyKeyLength): # menentukan huruf yang mirip pada setiap kata dalam kunci ciphertextUp = ciphertext.upper() allFreqScores = [] for nth in range(1, mostLikelyKeyLength + 1): nthLetters = getNthSubkeysLetters(nth, mostLikelyKeyLength, ciphertextUp) freqScores = [] for possibleKey in LETTERS: decryptedText = vigenereCipher.decryptMessage( possibleKey, nthLetters) keyAndFreqMatchTuple = ( possibleKey, freqAnalysis.englishFreqMatchScore(decryptedText)) freqScores.append(keyAndFreqMatchTuple) # mengurutkan score freqScores.sort(key=getItemAtIndexOne, reverse=True) allFreqScores.append(freqScores[:NUM_MOST_FREQ_LETTERS]) if not SILENT_MODE: for i in range(len(allFreqScores)): # use i + 1 so the first letter is not called the "0th" letter print('Possible letters for letter %s of the key: ' % (i + 1), end='') for freqScore in allFreqScores[i]: print('%s ' % freqScore[0], end='') print() # print a newline #coba kombinasi yang mirip setiap formasi for indexes in itertools.product(range(NUM_MOST_FREQ_LETTERS), repeat=mostLikelyKeyLength): possibleKey = '' for i in range(mostLikelyKeyLength): possibleKey += allFreqScores[i][indexes[i]][0] if SILENT_MODE: print('Mencoba dengan Kata Kunci: %s' % (possibleKey)) decryptedText = vigenereCipher.decryptMessage(possibleKey, ciphertextUp) if detectEnglish.isEnglish(decryptedText): origCase = [] for i in range(len(ciphertext)): if ciphertext[i].isupper(): origCase.append(decryptedText[i].upper()) else: origCase.append(decryptedText[i].lower()) decryptedText = ''.join(origCase) return decryptedText # No English-looking decryption found, so return None. return None
def task1(): encrypted_data = read('./text_files/t3_caesar_c_all.txt') for key in range(256): decrypted = Caesar.decrypt_data(encrypted_data[:25], key) txt = ''.join(chr(ch) for ch in decrypted) if isEnglish(txt): break decrypted_data = Caesar.decrypt_data(encrypted_data, key) write('./text_files/task1_decrypted.txt', decrypted_data)
def zigzag_cracker(message): all_trans = [] translated = '' for size in range(2, len(message) - 1, 1): translated = decrypt(message, size) if isEnglish(translated, 80): all_trans.append(translated) return all_trans
def Is_Morse(message): try: # some charecters force this to divide by 0 for some reason # this entire block of a function is all for making sure # that the message is actually morse code, if its not morse code # and it runs through the program, this program will crash # try / except clauses are in place for this too. LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' # defines message varaible for use later # checks to make sure message is morse if LETTERS in message.upper(): # if the message contains any english letters, it's not Morse Code. return False allowed = {".", "-", " "} # creates a weird type of list which stores all charecters used in morse code check = allowed.issuperset(message) # checks to see if the message only contains the charecters in the "allowed" # variable, if it contains a charecter which isn't in this set then return # false, if only the above charecters are in the message variable return True # into the check Variable if check: # if check is equal to true then import the detectEnglish module import detectEnglish try: # puts this into a try statement as this can often break the code # if a code passes the allowed.issuperset test it can still not be # morse code, examples of things that can get through are # "---------" " .. - -- .. . .. " and " ". # takes the message and tries to convert it from morse code to english # if it fails then message = from_morse(message) except: # print an error message and return False. print("Could not convert message from Morse Code.") print("RETURNING FALSE") return False try: # if it was sucessful, then try to find out if the converted message # from morse code to english, is actually an english word or sentence # by putting it through the detectEnglish module. # If the word didn't convert properly, like if it was "--------" # this can also make this module error, so it's in a try statement. if detectEnglish.isEnglish(message) == True: # if the converted word is English, then return True return True except AttributeError as e: return True else: # if it doesnt contain the issuperset then return False return False except Exception as e: print("An error occured, it might not be morse code.") return False
def attemptHackWithKeyLength(ciphertext, mostLikelyKeyLength): # Determine the most likely letters for each letter in the key. ciphertextUp = ciphertext.upper() # allFreqScores is a list of mostLikelyKeyLength number of lists. # These inner lists are the freqScores lists. allFreqScores = [] for nth in range(1, mostLikelyKeyLength + 1): nthLetters = getNthSubkeysLetters(nth, mostLikelyKeyLength, ciphertextUp) # freqScores is a list of tuples like: # [(<letter>, <Eng. Freq. match score>), ... ] # List is sorted by match score. Higher score means better match. # See the englishFreqMatchScore() comments in freqAnalysis.py. freqScores = [] for possibleKey in LETTERS: decryptedText = vigenereCipher.decryptMessage(possibleKey, nthLetters) keyAndFreqMatchTuple = (possibleKey, freqAnalysis.englishFreqMatchScore(decryptedText)) freqScores.append(keyAndFreqMatchTuple) # Sort by match score freqScores.sort(key=getItemAtIndexOne, reverse=True) allFreqScores.append(freqScores[:NUM_MOST_FREQ_LETTERS]) if not SILENT_MODE: for i in range(len(allFreqScores)): # use i + 1 so the first letter is not called the "0th" letter print("Possible letters for letter %s of the key: ' % (i + 1), end='") for freqScore in allFreqScores[i]: print("%s ' % freqScore[0], end=") print() # print a newline # Try every combination of the most likely letters for each position # in the key. for indexes in itertools.product(range(NUM_MOST_FREQ_LETTERS), repeat=mostLikelyKeyLength): # Create a possible key from the letters in allFreqScores possibleKey = '' for i in range(mostLikelyKeyLength): possibleKey += allFreqScores[i][indexes[i]][0] if not SILENT_MODE: print('Attempting with key: %s' % (possibleKey)) decryptedText = vigenereCipher.decryptMessage(possibleKey, ciphertextUp) if detectEnglish.isEnglish(decryptedText): # Set the hacked ciphertext to the original casing. origCase = [] for i in range(len(ciphertext)): if ciphertext[i].isupper(): origCase.append(decryptedText[i].upper()) else: origCase.append(decryptedText[i].lower()) decryptedText = ''.join(origCase) # Check with user to see if the key has been found. print('Possible encryption hack with key %s:' % (possibleKey)) print(decryptedText[:200]) # only show first 200 characters print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText # No English-looking decryption found, so return None. return None
def findMissingWords(letterMap, ciphertext): # This function is meant to fill any gaps in the decrypted plaintext caused # by letters our other functions were unable to decrypt. do = open('dictionary.txt') dict = do.read().split('\n') do.close() letterMapping = copy.deepcopy(letterMap) ciphertextList = nonLettersOrSpacePattern.sub('', ciphertext.upper()).split() # Check to see if each word in the decrypted plaintext is an # English word according to our dictionary.txt file. loop = True while loop: plaintext = decryptWithCipherletterMapping(ciphertext, letterMapping) tempPlaintext = [] for plainchar in plaintext.upper(): if plainchar in LETTERS or plainchar == ' ' or plainchar == '_': tempPlaintext.append(plainchar) tempPlaintext = ''.join(tempPlaintext) plaintextList = tempPlaintext.upper().split() loop = False solvedLetter = {} for i in range(len(plaintextList)): plainword = plaintextList[i] if plainword not in dict and '_' in plainword: if plainword.count('_') >= 2: loop = True continue cipherword = ciphertextList[i] index = plainword.find('_') numWords = 0 possibleLetters = [] if letterMapping[cipherword[index]] == []: continue for letter in letterMapping[cipherword[index]]: testWord = plainword.replace('_', letter) if detectEnglish.isEnglish(testWord): numWords += 1 possibleLetters.append([cipherword[index], letter]) if numWords == 1 and possibleLetters[0][0] not in solvedLetter: solvedLetter[possibleLetters[0][0]] = [ possibleLetters[0][1] ] if solvedLetter != {}: letterMapping.update(solvedLetter) return letterMapping
def task10(): encrypted_data = read('./text_files/text4_vigener_c_all.txt') known_data = [ord(ch) for ch in 'housewives'] for i in range(len(encrypted_data) - len(known_data)): text = '' for j in range(len(known_data)): ch = (encrypted_data[i + j] - known_data[j]) % alphabet_size text += chr(ch) if isEnglish(text): print(f'**** POSSIBLE ENGLISH: {text} ******') print(text)
def guess_keys(encrypted_data, known_bytes): keys = [] for i in range(len(encrypted_data) - len(known_bytes)): text = '' for j in range(len(known_bytes)): ch = (encrypted_data[i + j] - known_bytes[j]) % alphabet_size text += chr(ch) if isEnglish(text): keys.append(text) print(text) return keys
def bruteForce(message): knownPortion = 'edcbwvutsrqponml' unknownPortion = 'afghijkxyz' perm = permutations(unknownPortion) for key in list(perm): keyChange = ''.join(key) testKey = knownPortion + keyChange output = monoalphabeticCipher.decrypt(message, testKey) if detectEnglish.isEnglish(output): print('Key:', testKey, output)
def bruteforceTransCipher(m): message=str(m) for key in range(1, len(str(message))): print("Trying key: "+str(key)) decryptedText=transpositionCipherDec(key, message) if detectEnglish.isEnglish(decryptedText): print() print("possible decryption:") print("Key %s: %s" % (key, decryptedText[:100])) print() print("Enter D if done, anything else to continue:") response = input("> ")
def hackvigenere(ciphertext): words = open('dict.txt').readlines() for word in words: word = word.strip() decrytedtext = vigenereCipher.decryptMessage(word,ciphertext) if detectEnglish.isEnglish(decrytedtext,40): print 'Possible encryption break:' print 'key ' + word + ':' + decrytedtext[:100] print 'enter d for done ,or just press enter to continue' response = raw_input('>') if response.upper().startswith('D'): return decrytedtext
def unscramble(scrambledLetters): solvedWords = [] searchLetters = list( itertools.permutations(scrambledLetters, r=len(scrambledLetters))) for i in range(len(searchLetters)): word = ''.join(searchLetters[i]) if detectEnglish.isEnglish(word): if word not in solvedWords: solvedWords.append(word) return solvedWords
def decode_aff(message): possible_solutions = [] # the key 'a' can't be even or 13, so we leave those out for j in [n for n in range(1, 27) if n % 2 != 0 and n != 13]: # 'b' can be anything up to 25 for i in range(0, 26): # Looping to brute force every possible key for affine de = affine.Affine(j, i).decipher(message, keep_punct=True) # Compare the results to see if it contains english words if isEnglish(de): possible_solutions.append(de) else: pass # If there are more than 1 solutions returned, run each through # another round of isEnglish with higher requirements if len(possible_solutions) > 1: for solution in possible_solutions: if not isEnglish(solution, wordPercent=75): possible_solutions.remove(solution) return possible_solutions
def bruteVigKey(etxt): f = open('dictionary.txt') wrds = f.readlines() f.close() for i in wrds: wrd = i.strip() ptext = vigenere_cipher.decrypt(wrd, etxt) if detectEnglish.isEnglish(ptext, wordPercentage=40): print(f"\nPossible decrypted text: {ptext}") willcontinue = input("Enter T to terminate brute attack or just press Enter to continue: ") if 'T' in willcontinue.upper(): return ptext else: pass
def hackVigenere(ciphertext): # fungsi kasiskiExamination(ciphertext) akan me-return list dari semua kemungkinan # panjang keyword dalam integer di sebuah list (faktor pembagi dari jarak antar perulangan) allLikelyKeyLengths = kasiskiExamination(ciphertext) if not SILENT_MODE: keyLengthStr = '' for keyLength in allLikelyKeyLengths: keyLengthStr += '%s ' % (keyLength) print('Kemungkinan panjang kunci adalah: ' + keyLengthStr + '\n') for keyLength in allLikelyKeyLengths: if not SILENT_MODE: print('Mencari kata kunci dengan panjang %s ...' % keyLength) if keyLength == 2: fo = open('2letter.txt') elif keyLength == 3: fo = open('3letter.txt') elif keyLength == 4: fo = open('4letter.txt') elif keyLength == 5: fo = open('5letter.txt') elif keyLength == 6: fo = open('6letter.txt') elif keyLength == 7: fo = open('7letter.txt') elif keyLength == 8: fo = open('8letter.txt') words = fo.readlines() fo.close() for word in words: word = word.strip() # menghilangkan line baru pada akhir kata # meng-dekrip pesan dengan tiap kata kunci decryptedText = vigenereCipher.decryptMessage(word, ciphertext) # pengecekan tiap kata hasil dekrip dalam bahasa inggris, jika hasil return True maka akan di-print if detectEnglish.isEnglish(decryptedText, wordPercentage=40): print() print('Enkripsi yang mungkin:') print('Kunci ' + str(word) + ': ' + decryptedText[:100]) print() print( 'Tekan D jika enkripsi benar, atau Enter untuk melanjutkan mencoba:' ) response = raw_input('> ') if response.upper().startswith('D'): return decryptedText else: continue
def hackTransposition(message): print("Hacking...") for key in range(1, len(message)): print("Trying key #%s..." % (key)) decryptedText = transpositionDecrypt.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): CipherName = ("Transposition cipher with key of {}".format(key)) EnglishMSG = ("key {}: {}".format(key, decryptedText[:100])) EnglishDetected(CipherName, EnglishMSG, File)
def CaeserCipher(message): File.write("\n") File.write("This is the results of the Caeser Cipher Decryption ") File.write("\n") print("\n") print("This is the result of the Caeser Cipher.") print("\n") # TODO why is it that when File is first, Message is equal to # TODO the File, but when Message is first, message = message ?? logging.info("Start of caser cipher") CaeserDecrpted = CaeserCipherHacker.caeserCipherDecrypt(message) logging.info("Went to external Caeser Cipher module") # Creates a counter which counts up, for every list item in # CaeserDecrypted, Print the position of counter in the list # the counter iterates over the list, one by one # and prints that item, it then adds one to it self and goes back around # once every list item has been printed, it stops the loop counter = 0 for i in CaeserDecrpted: print(CaeserDecrpted[(counter)]) File.write(CaeserDecrpted[(counter)]) CheckEnglish = (CaeserDecrpted[(counter)]) # TODO this # if the counter is two digits big, add another number to ignore to # in the CheckEnglis section, if you do not take into account single # and double digits, Detect English will not work properly if counter > 8: CheckEnglish = CheckEnglish[8:] logging.debug(CheckEnglish) else: CheckEnglish = CheckEnglish[9:] logging.debug(CheckEnglish) if detectEnglish.isEnglish(CheckEnglish) == True: # If Engish is detected, write the english into a variable # and the name of the cipher into a variable, send it to # EnglishDetected() EnglishMSG = CheckEnglish CipherName = "Caeser Cipher with key of {}".format(counter) EnglishDetected(EnglishMSG, CipherName, File) counter = counter + 1
def hackVigenere(ciphertext): fo=open('dictionary.txt') words=fo.readlines() fo.close() for word in words: word=word.strip() decryptedText=vigenereCipher.decryptMessage(word,ciphertext) if detectEnglish.isEnglish(decryptedText,wordPercentage=40): #print() #print 'Possible encryption break:' #print 'Key' , str(word) , ':' , decryptedText[:100] vigenereCipher.main(str(word))
def hackTransposition(message): print('Hacking...') print('Press Ctrl-C (Win) or Ctrl-D (X-os) to quit.') for key in range(1,len(message)): print('Trying key #%s...' %(key)) decryptedText = transpositionDecrypt.decryptMessage(key,message) if detectEnglish.isEnglish(decryptedText): print() print('Possible encryption hack:') print('Key %s: %s' %(key, decryptedText[:100])) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None
def brute(self, text): for a in self.reverses: for b in range(1, len(self.alphabet)): decrypted_text = self.decode(text[:12], a, b) if detectEnglish.isEnglish(decrypted_text): decrypted_text = self.decode(text, a, b) print() print("Возможный вариант дешифрования:") print([a, b]) print("Дешифрованное сообщение: " + decrypted_text) print() print("Введите D, если хотите закончить перебор, или нажмите Enter, чтобы продолжить:") response = input("> ") if response.strip().upper().startswith("D"): return decrypted_text return None
def hackTransposition(message): print("Hacking...") for key in range(1, len(message)): print("Trying key #%s..." % key) decryptedText = transpositionDecrypt.decryptMessage(key, message) # print("DEBUG: %s" % decryptedText) if detectEnglish.isEnglish(decryptedText): print("\nPossible encryption hack") print("Key %s: %s\n" % (key, decryptedText[:100])) print("Enter D for done or ENTER to continue hacking.") response = input(">") if response.strip().upper().startswith("D"): return decryptedText return None
def hack(message): fo = open('dict.txt') words = fo.readlines() fo.close() for word in words: word = word.strip() decrypted = vigenere_cipher.decrypt(message, word) if detectEnglish.isEnglish(decrypted, wordPercentage=40.0): print() print('Possible encryption break:') print('Key ' + str(word) + ':' + decrypted[:100]) print() print('Enter D for done, or just press Enter to continue breaking:') response = input('> ') if response.lower().startswith('d'): return decrypted return None
def hackTransposition(message): print('Hacking...') # Brute force time! for key in range(1, len(message)): print('Trying key #%s..' % (key)) decryptedText = transposition.decrypt(message, key) if detectEnglish.isEnglish(decryptedText): print('\nPossible encryption hack:') print('Key %s: "%s"' % (key, decryptedText[:50])) response = raw_input('Enter D for done, or ENTER to continue: ') if response == 'D': return decryptedText # If loop finishes return None
def attemptHackWithKeyLength(ciphertext,mostLikelyKeyLength): ciphertextUp = ciphertext.upper() allFreqScores = [] for nth in range(1, mostLikelyKeyLength + 1): nthLetters = getNthSubkeyLetters(nth,mostLikelyKeyLength,ciphertextUp) freqScores = [] for possibleKey in LETTERS: decryptedText = vigenereCipher.decryptMessage(possibleKey,nthLetters) keyAndFreqMatchTuple = (possibleKey,freqAnalysis.englishFreqMatchScore(decryptedText)) freqScores.append(keyAndFreqMatchTuple) freqScores.sort(key=getItemAtIndexOne,reverse=True) allFreqScores.append(freqScores[:NUM_MOST_FREQ_LETTERS]) if not SILENT_MODE: for i in range(len(allFreqScores)): print 'Possible letters for letter' for freqScore in allFreqScores[i]: print freqScore[0] print '' for indexes in itertools.product(range(NUM_MOST_FREQ_LETTERS),repeat=mostLikelyKeyLength): possibleKey = '' for i in range(mostLikelyKeyLength): possibleKey += allFreqScores[i][indexes[i]][0] if not SILENT_MODE: print 'Attempting with key: '+ possibleKey decryptedText = vigenereCipher.decryptMessage(possibleKey,ciphertextUp) if detectEnglish.isEnglish(decryptedText): origCase = [] for i in range(len(ciphertext)): if ciphertext[i].isupper(): origCase.append(decryptedText[i].upper()) else: origCase.append(decryptedText[i].lower()) decryptedText = ''.join(origCase) print 'Possible encryption hack with key '+possibleKey print decryptedText[:200] print '' print 'enter d for done ,or just press enter to continue' response = raw_input('>') if response.upper().startswith('D'): return decryptedText return None
def hackVigenere(ciphertext): fo = open('dictionary.txt') words = fo.readlines() fo.close() for word in words: word = word.strip() # remove the newline at the end decryptedText = vigenereCipher.decryptMessage(word, ciphertext) if detectEnglish.isEnglish(decryptedText, wordPercentage=40): # Check with user to see if the decrypted key has been found. print() print('Possible encryption break:') print('Key ' + str(word) + ': ' + decryptedText[:100]) print() print('Enter D for done, or just press Enter to continue breaking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText
def hackAffine(message): # Python programs can be stopped at any time by pressing Ctrl-C (on # Windows) or Ctrl-D (on Mac and Linux) # brute-force by looping through every possible key for key in range(len(affineCipher.SYMBOLS) ** 2): keyA = affineCipher.getKeyParts(key)[0] if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1: continue decryptedText = affineCipher.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): # Check with the user if the decrypted key has been found. print('\nKey: %s' % (key)) response = 'D' if response.strip().upper().startswith('D'): return decryptedText return None