Ejemplo n.º 1
0
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
Ejemplo n.º 3
0
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
Ejemplo n.º 4
0
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
Ejemplo n.º 5
0
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
Ejemplo n.º 6
0
    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
Ejemplo n.º 8
0
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
Ejemplo n.º 9
0
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
Ejemplo n.º 11
0
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
Ejemplo n.º 12
0
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
Ejemplo n.º 13
0
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
Ejemplo n.º 14
0
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
Ejemplo n.º 16
0
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
Ejemplo n.º 17
0
    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
Ejemplo n.º 19
0
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
Ejemplo n.º 20
0
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
Ejemplo n.º 21
0
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
Ejemplo n.º 23
0
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
Ejemplo n.º 24
0
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
Ejemplo n.º 25
0
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
Ejemplo n.º 26
0
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
Ejemplo n.º 27
0
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)
Ejemplo n.º 28
0
	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
Ejemplo n.º 29
0
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()
Ejemplo n.º 30
0
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
Ejemplo n.º 31
0
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)
Ejemplo n.º 32
0
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}')
Ejemplo n.º 33
0
 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
Ejemplo n.º 35
0
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)
Ejemplo n.º 36
0
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
Ejemplo n.º 37
0
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
Ejemplo n.º 38
0
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
Ejemplo n.º 39
0
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
Ejemplo n.º 40
0
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)
Ejemplo n.º 41
0
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)
Ejemplo n.º 43
0
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("> ")
Ejemplo n.º 44
0
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
Ejemplo n.º 45
0
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
Ejemplo n.º 46
0
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
Ejemplo n.º 47
0
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
Ejemplo n.º 48
0
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
Ejemplo n.º 49
0
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)
Ejemplo n.º 50
0
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
Ejemplo n.º 51
0
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))
Ejemplo n.º 52
0
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
Ejemplo n.º 53
0
 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
Ejemplo n.º 54
0
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
Ejemplo n.º 56
0
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
Ejemplo n.º 57
0
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
Ejemplo n.º 59
0
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