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 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('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('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...')
# 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 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 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...')
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 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 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 testAffine(self):
self = self.strip()
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, self)
print('Tried Key %s : (%s)' % (key, decryptedText[:40]))
checkMatch(decryptedText, key, 'Affine')
def testAffine(self):
self = self.strip()
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, self)
print('Tried Key %s : (%s)' % (key, decryptedText[:40]))
checkMatch(decryptedText, key, 'Affine')
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
def hackAffine(message):
# Comment the code
# and put this into its own module??
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)
print('Tried Key %s... (%s)' % (key, decryptedText[:40]))
if detectEnglish.isEnglish(decryptedText):
# Check with the user if the decrypted key has been found.
CipherName = ("Affine cipher with key of {}".format(key))
englishMSG = ("key {}: {}".format(key, decryptedText))
EnglishDetected(CipherName, EnglishMSG, File)
return None
def hackAffine(message):
# ketikkan code dari slide 8 - 11 atau menggunakan versi Anda.
print("Use Ctrl+C/Ctrl+D to exit")
print("Trying keys....")
for key in range(len(affineCipher.SYMBOLS)**2):
keyA = affineCipher.getKeyParts(key)[0]
if cryptomath.gcd(keyA, len(affineCipher.SYMBOLS)) != 1:
print("key %s is not valid for this cipher" % (key))
continue
decrypted = affineCipher.decryptMessage(key, message)
if not SILENT_MODE:
print("Key yang dipakai %s (%s)" % (key, decrypted[:40]))
if detectEnglish.isEnglish(decrypted):
print()
print("Used Key :" + str(key))
print("Message : %s" % (decrypted[:200]))
print("Enter anything to continue, D to stop")
User = input("> ")
if User.strip().upper().startswith("D"):
return decrypted
return None
def hackAffine(message):
print("Attempting break...")
print("Press Ctrl+C (Ctrl+D for macOS and Linux) to quit.")
# Brute-Force by looping 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
decrypted_text = affineCipher.decryptMessage(key, message)
if not SILENT_MODE:
print(f"Tried Key {key}... {decrypted_text[:40]}")
if detectEnglish.isEnglish(decrypted_text):
# Check with user if key has been found
print("\nPossible encryption hack: ")
print(f"Key: {key}")
print(f"Decrypted Message: {decrypted_text[:200]}")
response = input("\nEnter 'D' for done, or press Enter to continue: ")
if response == 'D':
return decrypted_text
return None
def hackAffine(message):
print("Hacking...")
print("Press cntl + c 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):
#asks user if this is right key
print()
print("Possible hack:")
print(decryptedText[:200])
print()
print("Press 'd' if done")
response = input(">")
if response.strip().upper().startswith("D"):
return decryptedText
return None
