예제 #1
0
def substitution_cipher(request):
    from pycipher import SimpleSubstitution as SimpleSub
    import random
    import re
    from decryptionwithoutkey.ngram_score import ngram_score
    fitness = ngram_score('english_quadgrams.txt')  # load our quadgram statistics
    if request.method == 'POST':
        form = CryptoAnalysis(request.POST)
        if form.is_valid():
            cipher = request.POST['input']
            cipher = str(cipher)
            ctext = cipher.upper()
            ctext = re.sub('[^A-Z]', '', ctext.upper())
            maxkey = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
            maxscore = -99e9
            parentscore, parentkey = maxscore, maxkey[:]
            print("Substitution Cipher solver, you may have to wait several iterations")
            print("for the correct result. Press ctrl+c to exit program.")
            # keep going until we are killed by the user
            i = 0
            k = 0
            best_key = ''
            plaintext = ''
            while k < 30:
                i = i + 1
                random.shuffle(parentkey)
                deciphered = SimpleSub(parentkey).decipher(ctext)
                parentscore = fitness.score(deciphered)
                count = 0
                while count < 1000:
                    a = random.randint(0, 25)
                    b = random.randint(0, 25)
                    child = parentkey[:]
                    # swap two characters in the child
                    child[a], child[b] = child[b], child[a]
                    deciphered = SimpleSub(child).decipher(ctext)
                    score = fitness.score(deciphered)
                    # if the child was better, replace the parent with it
                    if score > parentscore:
                        parentscore = score
                        parentkey = child[:]
                        count = 0
                    count = count + 1
                # keep track of best score seen so far
                k += 1
                if parentscore > maxscore:
                    maxscore, maxkey = parentscore, parentkey[:]
                    print('\nbest score so far:', maxscore, 'on iteration', i)
                    ss = SimpleSub(maxkey)
                    best_key = ''.join(maxkey)
                    plaintext = ss.decipher(ctext)
                    # print('    best key: ' + ''.join(maxkey))
                    # print('    plaintext: ' + ss.decipher(ctext))
                    return render(request, 'dwok/substution.html', {'form': form,'key':best_key,'plain':plaintext})
            # return HttpResponse("KEY = " + str(best_key) + " \nPLAIN TEXT =   " + plaintext)
        else:
            return HttpResponse("Form is not valid")
    else:
        form = CryptoAnalysis()
    return render(request, 'dwok/substution.html', {'form': form})
예제 #2
0
 def guess(self, text, n=3):
     result = []
     for candidate in self.candidates[0:n]:
         key, score = candidate
         decryption = SimpleSubstitution(key).decipher(text)
         result.append((decryption, score, key))
     return result
예제 #3
0
def break_substitution(plaintext, masker):
    # key1 = ['L', 'C', 'N', 'D', 'T', 'H', 'E', 'W', 'Z', 'S', 'A', 'R', 'X',
    #       'V', 'O', 'J', 'B', 'P', 'F', 'U', 'I', 'Q', 'M', 'K', 'G', 'Y']
    # key1 = ['Y', 'B', 'X', 'O', 'N', 'G', 'S', 'W', 'K', 'C', 'P', 'Z', 'F',
    #        'M', 'T', 'D', 'H', 'R', 'Q', 'U', 'J', 'V', 'E', 'L', 'I', 'A']

    # key1 = ['J', 'E', 'K', 'P', 'H', 'X', 'G', 'L', 'S', 'Z', 'R', 'T', 'C',
    #        'Y', 'W', 'A', 'D', 'B', 'F', 'M', 'Q', 'I', 'U', 'V', 'N', 'O']
    key1 = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
    random.shuffle(key1)
    # print(key1)
    ciphertext = SimpleSubstitution(key1).encipher(plaintext)

    print("\nCiphertext:")
    print(masker.extend(ciphertext))
    #print("---\n")

    print("\nProcessing...\n")
    scorer = NgramScorer(load_ngrams(1))
    # breaker = SubstitutionBreak(scorer,seed = 42)
    breaker = SubstitutionBreak(scorer)

    # breaker.optimise(ciphertext, n=10) # for text
    # breaker.optimise(ciphertext, n=30) # for text
    breaker.optimise(ciphertext,
                     n=3)  # generate n local optima and choose the best
    decryption, score, key = breaker.guess(ciphertext)[
        0]  # get the best local optima
    print("Substitution decryption (key={}, score={}):\n---\nPlaintext:\n{}".
          format(key, score, masker.extend(decryption)))
예제 #4
0
 def getIteration(self, text):
     key = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
     random.shuffle(key)
     score = self.scorer.score(SimpleSubstitution(key).decipher(text))
     count = 0
     while count < 1000:
         newKey = self.swap(key)
         newScore = self.scorer.score(
             SimpleSubstitution(newKey).decipher(text))
         if newScore > score:
             key = newKey
             score = newScore
             count = 0
         else:
             count += 1
     return key, score
예제 #5
0
 def decrypt(self, cipherText, keys):
     plainWordList = list()
     for i in range(len(keys)):
         k = keys[i]
         pword = SimpleSubstitution(k).decipher(cipherText)
         plainWordList.append(pword)
     return plainWordList
예제 #6
0
def subDecode(text):
    maxscore = -99999999999
    ctext = text
    ctext = ctext.replace(" ","").upper()
    print("Adjusted Text: " + ctext)
    maxkey = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    pText, pKey = ctext,maxkey
    decipher = SimpleSubstitution(pKey).decipher(pText)
    pscore = fitness.score(decipher)
    print("Deciphered: " + decipher)
    print("Score: " + str(pscore))
    i = 0
    while 1:
        i = i + 1
        pKeyL = list(pKey)
        random.shuffle(pKeyL)
        pKey = ''.join(pKeyL)
        decipher = SimpleSubstitution(pKey).decipher(ctext)
        pscore = fitness.score(decipher)
        count = 0
        while count  < 1000:

            cKey = pKey
            x = random.randint(0,25)
            y = random.randint(0,25)
            cKeyL = list(cKey)
            cKeyL[x] = pKey[y]
            cKeyL[y] = pKey[x]
            cKey = ''.join(cKeyL)
            #print("Key swapped")
            decipher = SimpleSubstitution(cKey).decipher(pText)
            score = fitness.score(decipher)
            #print("Attempt: " + decipher)
            #print("Score: " + str(score))
            if score > pscore:
                pscore = score
                pKey = cKey
                count = 0
            count = count + 1
    if(pScore > maxscore):
        maxscore = pScore
        maxkey = pKey
        ss = SimpleSubstitution(maxkey).decipher(ctext)
        print("Best Key: "+maxkey)
        print("plaintext: "+ss)
def word_decrypt_sub(word):
    fitness = ngram_score('english_quadgrams.txt') # load our quadgram statistics

    ctext = word
    ctext = re.sub('[^A-Z]', '', ctext.upper())

    maxkey = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
    maxscore = -99e9 # First generated key will always replace this
    parentscore, parentkey = maxscore, maxkey[:]
    # keep going until we are killed by the user
    i = 0
    while (True):
        i = i + 1
        random.shuffle(parentkey)
        # SimpleSub will replace the 'abc...' with the key e.g 'dje...'
        deciphered = SimpleSub(parentkey).decipher(ctext)
        parentscore = fitness.score(deciphered)

        # If there are no improvement then we move to a different set of keys
        # Checking for improvements within 1000 iterations
        count = 0
        while count < 1000:
            a = random.randint(0, 25)
            b = random.randint(0, 25)
            child = parentkey[:]

            # swap two characters in the child
            child[a], child[b] = child[b], child[a]
            deciphered = SimpleSub(child).decipher(ctext)
            score = fitness.score(deciphered)
            # if the child was better, replace the parent with it
            if score > parentscore:
                parentscore = score
                parentkey = child[:]
                count = 0
            count = count + 1
        # keep track of best score seen so far
        if parentscore > maxscore:
            maxscore, maxkey = parentscore, parentkey[:]
            print ('\nbest score so far:',maxscore,'on iteration',i)
            ss = SimpleSub(maxkey)
            print ('    best key: ' + ''.join(maxkey))
            print ('    plaintext: ' + ss.decipher(ctext))
예제 #8
0
def substitution(request):
    form = Substitution()
    if request.method == 'POST':
        form = Substitution(request.POST)
        if form.is_valid():
            cipher = request.POST['input']
            key = request.POST['key']
            cipher = str(cipher)
            key = str(key)
            ss = SimpleSubstitution(key)
            plain = ss.decipher(cipher)
            return render(request, 'dwk/substitution.html', {
                'form': form,
                'plain': plain
            })
            # return HttpResponse("Plain Text: %s" % plain)
    else:
        form = Substitution()
    return render(request, 'dwk/substitution.html', {'form': form})
예제 #9
0
def substitution(request):
    form = Substitution()
    if request.method == 'POST':
        form = Substitution(request.POST)
        if form.is_valid():
            plain = request.POST['input']
            key = request.POST['key']
            plain = str(plain)
            key = str(key)
            ss = SimpleSubstitution(key)
            cipher = ss.encipher(plain)
            return render(request, 'en/substitution.html', {
                'form': form,
                'cipher': cipher
            })
            # return HttpResponse("Encrypted Text: %s" % cipher)
    else:
        form = Substitution()
    return render(request, 'en/substitution.html', {'form': form})
예제 #10
0
def SimpleSubstitutionBF(ctext, dictionary):

    f = open(dictionary, 'r')
    keys = f.readlines()

    for i in keys:
        i = i[:-1]
        out = SimpleSubstitution(i).decipher(ctext)
        print('\033[1;34m[*]\033[0m Key = ' + i + ' ; Out = ' + out)

    print('\033[1;32m[+]\033[0m Brute Force finished.')
예제 #11
0
def SubsCracker(ctext, ngram):

    fitness = ngram_score(ngram)

    ctext = re.sub('[^A-Z]', '', ctext.upper())

    maxkey = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
    maxscore = -99e9
    parentscore, parentkey = maxscore, maxkey[:]
    i = 0
    print(
        '\033[1;34m[*]\033[0m Cracking the cipher. This might take a while...')
    while 1:
        i = i + 1
        random.shuffle(parentkey)
        deciphered = SimpleSub(parentkey).decipher(ctext)
        parentscore = fitness.score(deciphered)
        count = 0
        while count < 1000:
            a = random.randint(0, 25)
            b = random.randint(0, 25)
            child = parentkey[:]
            child[a], child[b] = child[b], child[a]
            deciphered = SimpleSub(child).decipher(ctext)
            score = fitness.score(deciphered)
            if score > parentscore:
                parentscore = score
                parentkey = child[:]
                count = 0
            count = count + 1
        if parentscore > maxscore:
            maxscore, maxkey = parentscore, parentkey[:]
            print('\n\033[1;34m[*]\033[0m Best score so far: ' +
                  str(maxscore) + ' on iteration ' + str(i))
            ss = SimpleSub(maxkey)
            print('    \033[1;32m[+]\033[0m Best key: ' + ''.join(maxkey))
            print('    \033[1;32m[+]\033[0m Plaintext: ' + ss.decipher(ctext))
예제 #12
0
def break_substitution_example(plaintext, masker):
    print("#############################################")
    print("######## Substitution cipher example ########")
    print("#############################################")

    key = [
        'L', 'C', 'N', 'D', 'T', 'H', 'E', 'W', 'Z', 'S', 'A', 'R', 'X', 'V',
        'O', 'J', 'B', 'P', 'F', 'U', 'I', 'Q', 'M', 'K', 'G', 'Y'
    ]
    ciphertext = SimpleSubstitution(key).encipher(plaintext)

    print("\nCiphertext:\n---")
    print(masker.extend(ciphertext))
    print("---\n")

    print("\nCracking...\n")
    scorer = NgramScorer(load_ngrams(4))
    breaker = SubstitutionBreak(scorer, seed=42)
    breaker.optimise(ciphertext, n=3)
    decryption, score, key = breaker.guess(ciphertext)[0]
    print("Substitution decryption (key={}, score={}):\n---\n{}---\n".format(
        key, score, masker.extend(decryption)))
예제 #13
0
def encrypt(keycodeLines, encryptionDirection, plaintextContents):
    for i in range(len(keycodeLines)):  #Iterate over the keycode.
        if (encryptionDirection == "encrypt"):
            splitLine = keycodeLines[i].split()
        else:
            splitLine = keycodeLines[len(keycodeLines) - 1 - i].split(
            )  #This ensures that if the encryption direction is set to decrypt, that this for loop reads the keycode.txt from end to beginning.

        # print("Line " + str(i) + " is " + keycodeLines[i] + " and the split line is: " + str(splitLine)) # This was an old debugging line that may be useful in the future.
        if (splitLine[0] == "caesar"):
            if (int(splitLine[1]) > 25 or int(splitLine[1]) < 1):
                print("Keycode line: " + str(i + 1) +
                      ": Caesar shift detected on keycode line " + str(i) +
                      " attempting to shift by value " + splitLine[1] + ".")
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Caesar shift detected with an argument of " +
                          splitLine[1] + ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Caesar(int(
                        splitLine[1])).encipher(plaintextContents)
                else:
                    plaintextContents = Caesar(int(
                        splitLine[1])).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) + ": Caesar shifted " +
                          originalPlaintext + " by " + splitLine[1] +
                          " with a result of " + plaintextContents + ".")
        elif (splitLine[0] == "vigenere"):
            if (type(splitLine[1] != str)):
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Vigenère shift detected with an argument of " +
                          splitLine[1] + ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Vigenere(
                        splitLine[1]).encipher(plaintextContents)
                else:
                    plaintextContents = Vigenere(
                        splitLine[1]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Vigenère shifted " + originalPlaintext + " by " +
                          splitLine[1] + " with a result of " +
                          plaintextContents + ".")
            else:
                print("Keycode line: " + str(i + 1) +
                      ": Vigenère shift detected on keycode line " + str(i) +
                      " attempting to use key that is not a string.")
        elif (splitLine[0] == "porta"):
            if (type(splitLine[1] != str)):
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Porta cipher detected with an argument of " +
                          splitLine[1] + ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Porta(
                        splitLine[1]).encipher(plaintextContents)
                else:
                    plaintextContents = Porta(
                        splitLine[1]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Vigenère shifted " + originalPlaintext + " by " +
                          splitLine[1] + " with a result of " +
                          plaintextContents + ".")
            else:
                print("Keycode line: " + str(i + 1) +
                      ": Vigenère shift detected on keycode line " + str(i) +
                      " attempting to use key that is not a string.")
        elif (splitLine[0] == "adfgx"):
            if (
                    len(splitLine[1]) != 25
            ):  # This makes sure that the keysquare's length is exactly 25.
                print(
                    "Keycode line: " + str(i + 1) +
                    ": ADFGX cipher detected on keycode line " + str(i) +
                    " attempting to use keysquare that is not 25 characters long."
                )
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": ADFGX cipher detected with a keysquare of " +
                          splitLine[1] + " and a keyword of " + splitLine[2] +
                          ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = ADFGX(
                        splitLine[1], splitLine[2]).encipher(plaintextContents)
                else:
                    plaintextContents = ADFGX(
                        splitLine[1], splitLine[2]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) + ": ADFGX ciphered " +
                          originalPlaintext + " by a keysquare of " +
                          splitLine[1] + " and a keyword of " + splitLine[2] +
                          " with a result of " + plaintextContents + ".")
        elif (
                splitLine[0] == "adfgvx"
        ):  #The first argument is the keysquare, and the second argument is the keyword.
            if (
                    len(splitLine[1]) != 36
            ):  # This makes sure that the keysquare's length is exactly 36.
                print(
                    "Keycode line: " + str(i) +
                    ": ADFGVX cipher detected on keycode line " + str(i) +
                    " attempting to use keysquare that is not 25 characters long, but is instead "
                    + str(len(splitLine[1])) + " characters long.")
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": ADFGVX cipher detected with a keysquare of " +
                          splitLine[1] + " and a keyword of " + splitLine[2] +
                          ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = ADFGVX(
                        splitLine[1], splitLine[2]).encipher(plaintextContents)
                else:
                    plaintextContents = ADFGVX(
                        splitLine[1], splitLine[2]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": ADFGVX ciphered " + originalPlaintext +
                          " by a keysquare of " + splitLine[1] +
                          " and a keyword of " + splitLine[2] +
                          " with a result of " + plaintextContents + ".")
        elif (splitLine[0] == "affine"):
            if ((int(splitLine[2]) < 1) or (int(splitLine[2]) > 25)):
                print(
                    "Keycode line: " + str(i + 1) +
                    ": Affine cipher detected on keycode line " + str(i) +
                    " attempting to use b value outside of the range of 1-25.")
                sys.exit()
            elif ((int(splitLine[1]) == 13) or (int(splitLine[1]) % 2 != 1)
                  or (int(splitLine[1]) > 25) or (int(splitLine[1]) < 1)):
                print(
                    "Keycode line: " + str(i + 1) +
                    ": Affine cipher detected on keycode line " + str(i) +
                    " attempting to use an a value outside of the range of 1-25, that is even, or that is 13, all of which are not permitted."
                )
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Affine cipher detected with an a value of " +
                          splitLine[1] + " and a b value of " + splitLine[2] +
                          ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Affine(
                        int(splitLine[1]),
                        int(splitLine[2])).encipher(plaintextContents)
                else:
                    plaintextContents = Affine(
                        int(splitLine[1]),
                        int(splitLine[2])).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Affine ciphered " + originalPlaintext +
                          " by value a " + splitLine[1] + " and value b " +
                          splitLine[2] + " with a result of " +
                          plaintextContents + ".")
        elif (
                splitLine[0] == "autokey"
        ):  #TODO: The autokey cipher actually doesn't have any requirements for the key, but will be configured to set off a ton of warnings assuming the config flags allow for it.
            originalPlaintext = plaintextContents
            if (debug):
                print("Keycode line: " + str(i + 1) +
                      ": Autokey cipher detected with an key of " +
                      splitLine[1] + ".")
            if (encryptionDirection == "encrypt"):
                plaintextContents = Autokey(
                    splitLine[1]).encipher(plaintextContents)
            else:
                plaintextContents = Autokey(
                    splitLine[1]).decipher(plaintextContents)
            if (debug):
                print("Keycode line: " + str(i + 1) + ": Autokey ciphered " +
                      originalPlaintext + " by key of " + splitLine[1] +
                      " for a result of " + plaintextContents + ".")
        elif (splitLine[0] == "atbash"):
            originalPlaintext = plaintextContents
            if (debug):
                print("Keycode line: " + str(i + 1) +
                      ": Autokey cipher detected.")
            if (encryptionDirection == "encrypt"):
                plaintextContents = Affine(25, 25).encipher(plaintextContents)
            else:
                plaintextContents = Affine(25, 25).decipher(plaintextContents)
            if (debug):
                print("Keycode line: " + str(i + 1) + ": Atbash ciphered " +
                      originalPlaintext + " for a result of " +
                      plaintextContents + ".")
        elif (splitLine[0] == "beaufort"):
            if (type(splitLine[1] == str)):
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Beaufort shift detected with an argument of " +
                          splitLine[1] + ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Beaufort(
                        splitLine[1]).encipher(plaintextContents)
                else:
                    plaintextContents = Beaufort(
                        splitLine[1]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Beaufort shifted " + originalPlaintext + " by " +
                          splitLine[1] + " with a result of " +
                          plaintextContents + ".")
            else:
                print("Keycode line: " + str(i + 1) +
                      ": Beaufort shift detected on keycode line " + str(i) +
                      " attempting to use key that is not a string.")
        elif (splitLine[0] == "bifid"):
            if (
                    len(splitLine[1]) != 25
            ):  # This makes sure that the keysquare's length is exactly 25.
                print(
                    "Keycode line: " + str(i + 1) +
                    ": Bifid cipher detected on keycode line " + str(i) +
                    " attempting to use keysquare that is not 25 characters long."
                )
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Bifid cipher detected with a keysquare of " +
                          splitLine[1] + " and a keyword of " + splitLine[2] +
                          ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Bifid(splitLine[1], int(
                        splitLine[2])).encipher(plaintextContents)
                else:
                    plaintextContents = Bifid(splitLine[1], int(
                        splitLine[2])).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) + ": Bifid ciphered " +
                          originalPlaintext + " by a keysquare of " +
                          splitLine[1] + " and a keyword of " + splitLine[2] +
                          " with a result of " + plaintextContents + ".")
        elif (splitLine[0] == "coltrans"):
            if (type(splitLine[1] != str)
                ):  # Check that the encryption key is a string.
                originalPlaintext = plaintextContents
                if (debug):
                    print(
                        "Keycode line: " + str(i + 1) +
                        ": Columnar transposition shift detected with an argument of "
                        + splitLine[1] + ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = ColTrans(
                        splitLine[1]).encipher(plaintextContents)
                else:
                    plaintextContents = ColTrans(
                        splitLine[1]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Columnar transposition shifted " +
                          originalPlaintext + " by " + splitLine[1] +
                          " with a result of " + plaintextContents + ".")
            else:
                print(
                    "Keycode line: " + str(i + 1) +
                    ": Columnar transposition shift detected on keycode line "
                    + str(i) + " attempting to use key that is not a string.")
        elif (splitLine[0] == "foursquare"):
            if (
                    len(splitLine[1]) != 25
            ):  # This makes sure that the keysquare's length is exactly 25.
                print(
                    "Foursquare cipher detected on keycode line " + str(i) +
                    " attempting to use keysquare that is not 25 characters long."
                )
                sys.exit()
            elif (len(splitLine[2]) != 25):
                print(
                    "Foursquare cipher detected on keycode line " + str(i) +
                    " attempting to use keysquare that is not 25 characters long."
                )
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (debug):
                    print("Foursquare cipher detected with a keysquare of " +
                          splitLine[1] + " and a keyword of " + splitLine[2] +
                          ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Foursquare(
                        key1=splitLine[1],
                        key2=splitLine[2]).encipher(plaintextContents)
                else:
                    plaintextContents = Foursquare(
                        key1=splitLine[1],
                        key2=splitLine[2]).decipher(plaintextContents)
                if (debug):
                    print("Foursquare ciphered " + originalPlaintext +
                          " by a keysquare of " + splitLine[1] +
                          " and a keyword of " + splitLine[2] +
                          " with a result of " + plaintextContents + ".")
        elif (splitLine[0] == "playfair"):
            if (
                    len(splitLine[1]) != 25
            ):  # This makes sure that the keysquare's length is exactly 25.
                print(
                    "Keycode line: " + str(i + 1) +
                    ": Playfair cipher detected on keycode line " + str(i) +
                    " attempting to use keysquare that is not 25 characters long."
                )
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Playfair(
                        splitLine[1]).encipher(plaintextContents)
                else:
                    plaintextContents = Playfair(
                        splitLine[1]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Playfair ciphered " + originalPlaintext +
                          " by a keysquare of " + splitLine[1] +
                          " with a result of " + plaintextContents + ".")
        elif (
                splitLine[0] == "railfence"
        ):  #TODO: Fix this so that it throws an error if the key is a bad length relative to the plaintext.
            if (splitLine[1].isdigit() == False):
                print("Keycode line: " + str(i + 1) +
                      ": Railfence cipher detected on keycode line " + str(i) +
                      " with a non-numerical key.")
                sys.exit()
            elif (
                    int(splitLine[1]) < 1
            ):  # This makes sure that the keysquare's length is exactly 25.
                print("Keycode line: " + str(i + 1) +
                      ": Railfence cipher detected on keycode line " + str(i) +
                      " attempting to use a key less than 0.")
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (encryptionDirection == "encrypt"):
                    plaintextContents = Railfence(int(
                        splitLine[1])).encipher(plaintextContents)
                else:
                    plaintextContents = Railfence(int(
                        splitLine[1])).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Railfence ciphered " + originalPlaintext +
                          " by a key of " + splitLine[1] +
                          " with a result of " + plaintextContents + ".")
        elif (splitLine[0] == "rot13"):
            originalPlaintext = plaintextContents
            if (debug):
                print("Keycode line: " + str(i + 1) +
                      ": Rot13 cipher detected.")
            if (encryptionDirection == "encrypt"):
                plaintextContents = Rot13().encipher(plaintextContents)
            else:
                plaintextContents = Rot13().decipher(plaintextContents)
            if (debug):
                print("Keycode line: " + str(i + 1) + ": Rot13 ciphered " +
                      originalPlaintext + " with a result of " +
                      plaintextContents + ".")
        elif (splitLine[0] == "simplesub"):
            if (
                    len(splitLine[1]) != 26
            ):  # This makes sure that the keysquare's length is exactly 25.
                print(
                    "Keycode line: " + str(i + 1) +
                    ": Simple substitution cipher detected on keycode line " +
                    str(i) +
                    " attempting to use key that is not 26 characters long.")
                sys.exit()
            else:
                originalPlaintext = plaintextContents
                if (debug):
                    print(
                        "Keycode line: " + str(i + 1) +
                        ": Simple substitution cipher detected with a key of "
                        + splitLine[1] + ".")
                if (encryptionDirection == "encrypt"):
                    plaintextContents = SimpleSubstitution(
                        splitLine[1]).encipher(plaintextContents)
                else:
                    plaintextContents = SimpleSubstitution(
                        splitLine[1]).decipher(plaintextContents)
                if (debug):
                    print("Keycode line: " + str(i + 1) +
                          ": Simple substitution ciphered " +
                          originalPlaintext + " by a key of " + splitLine[1] +
                          " with a result of " + plaintextContents + ".")
    if (i == (len(keycodeLines) - 1)):
        # print(plaintextContents) #A debug catch that you may find useful later.
        return plaintextContents
# Keep going until the program is killed
start_time = time.time()
i = 0
while 1:
    i = i + 1
    random.shuffle(parentkey)
    deciphered = SimpleSub(parentkey).decipher(ctext)
    parentscore = fitness.score(deciphered)
    count = 0
    while count < 1000:
        a = random.randint(0, 25)
        b = random.randint(0, 25)
        child = parentkey[:]
        # Swap 2 characters in the Child Key and calculate the fitness score of deciphered text using this key
        child[a], child[b] = child[b], child[a]
        deciphered = SimpleSub(child).decipher(ctext)
        score = fitness.score(deciphered)
        # If the child has a better score - replace the parent
        if score > parentscore:
            parentscore = score
            parentkey = child[:]
            count = 0
        count = count + 1
    # Print out the best score gotten after this iteration
    if parentscore > maxscore:
        maxscore, maxkey = parentscore, parentkey[:]
        print '\nBest fitness score so far: ', maxscore, ' on iteration ', i
        ss = SimpleSub(maxkey)
        print '    Best Key: ' + ''.join(maxkey)
        print '    Best Plaintext: ' + ss.decipher(ctext)
        print '    Time Taken: %f s' % (time.time() - start_time)
예제 #15
0
파일: main.py 프로젝트: y0d4a/cryptovenom
def simsubencode(importx, infilepath, outfilepath, inputformat, export, raw, key):

    if importx == 'file':
    
        f = open(infilepath, 'r')
        raw = f.read()
        f.close()
        
    elif importx == 'print':
    
        raw = raw
        
    else:
    
        print('\033[1;31m[-]\033[0m Unknown error.')
        return False
        
    inp = raw
    
    if inputformat == 'base64':
    
        iput = base64.b64decode(inp)
        
    elif inputformat == 'raw':
    
        iput = inp 
    
    elif inputformat == 'base32':
    
        iput = base64.b32decode(inp)
    
    elif inputformat == 'base16':
    
        iput = base64.b16decode(inp)
    
    elif inputformat == 'base58':
    
        iput = base58.b58decode(inp)
    
    elif inputformat == 'base85':
    
        print('\033[1;31m[-]\033[0m Option not available yet')
    
    elif inputformat == 'hex':
    
        iput = inp.decode('hex')
    
    elif inputformat == 'dec':
    
        print('\033[1;31m[-]\033[0m Option not available yet')
    
    elif inputformat == 'octal':
    
        print('\033[1;31m[-]\033[0m Option not available yet')
    
    elif inputformat == 'binary':
    
        iput = text_from_bits(inp)
        
    else:
    
        print('\033[1;31m[-]\033[0m Unknown error.')
        return False
        
    output = SimpleSubstitution(key).encipher(iput)

    if export == 'file':
    
        f = open(outfilepath, 'w')
        f.write(output)
        f.close()
        return True
        
    elif export == 'print':
    
        return output
        
    else:
    
        print('\033[1;31m[-]\033[0m Unknown error.')
        return False
예제 #16
0
 def encipher(self, key, text):
     return SimpleSubstitution(key).encipher(text, True)
예제 #17
0
i = 0
while 1:
    i = i+1
    random.shuffle(parentkey)
    deciphered = SimpleSub(parentkey).decipher(ctext)
    parentscore = fitness.score(deciphered)
    count = 0
    while count < 1000:
        a = random.randint(0,25)
        b = random.randint(0,25)
        child = parentkey[:]
        # swap two characters in the child
        child[a],child[b] = child[b],child[a]
        deciphered = SimpleSub(child).decipher(ctext)
        score = fitness.score(deciphered)
        # if the child was better, replace the parent with it
        if score > parentscore:
            parentscore = score
            parentkey = child[:]
            count = 0
        count = count+1
    # keep track of best score seen so far
    if parentscore>maxscore:
        maxscore,maxkey = parentscore,parentkey[:]
        print '\nbest score so far:',maxscore,'on iteration',i
        ss = SimpleSub(maxkey)
        print '    best key: '+''.join(maxkey)
        print '    plaintext: '+ss.decipher(ctext)


init_time = time.time()
i = 0
while 1:
    i = i+1
    random.shuffle(parentkey)
    deciphered = SimpleSub(parentkey).decipher(ctext)
    parentscore = fitness.score(deciphered)
    count = 0
    while count < 1000:
        a = random.randint(0,25)
        b = random.randint(0,25)
        child = parentkey[:]
        # swap two characters in the child
        child[a],child[b] = child[b],child[a]
        deciphered = SimpleSub(child).decipher(ctext)
        score = fitness.score(deciphered)
        # if the child was better, replace the parent with it
        if score > parentscore:
            parentscore = score
            parentkey = child[:]
            count = 0
        count = count+1    
    # keep track of best score seen so far
    if parentscore>maxscore:        
        maxscore,maxkey = parentscore,parentkey[:]        
        print '\nbest score so far:',maxscore,'on iteration',i
        ss = SimpleSub(maxkey)
        print '    best possible key: '+''.join(maxkey)
        print '    candidate plaintext: '+ss.decipher(ctext)
        print '    time taken to break: %fs' % (time.time() - init_time)
예제 #19
0

fitness = ngram_score('quadgrams.txt')

#test cipher text
ctext = 'pmpafxaikkitprdsikcplifhwceigixkirradfeirdgkipgigudkcekiigpwrpucikceiginasikwduearrxiiqepcceindgmieinpwdfprduppcedoikiqiasafmfddfipfgmdafmfdteiki'
ctext = re.sub('[^A-Z]', '', ctext.upper())

maxkey = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
maxscore = -99e9
parentscore, parentkey = maxscore, maxkey[:]
i = 0
while 1:
    i = i + 1
    random.shuffle(parentkey)
    deciphered = SimpleSubstitution(parentkey).decipher(ctext)
    parentscore = fitness.score(deciphered)
    count = 0
    while count < 1000:
        a = random.randint(0, 25)
        b = random.randint(0, 25)
        child = parentkey[:]
        # swap two characters in the child
        child[a], child[b] = child[b], child[a]
        deciphered = SimpleSubstitution(child).decipher(ctext)
        score = fitness.score(deciphered)
        # if the child was better, replace the parent with it
        if score > parentscore:
            parentscore = score
            parentkey = child[:]
            count = 0
예제 #20
0
 def encrypt(self, key, plaintext):
     masker = Masker(plaintext)
     ciphertext = SimpleSubstitution(key).encipher(plaintext)
     return masker.extend(ciphertext)
예제 #21
0
 def decrypt(self, key, ciphertext):
     masker = Masker(ciphertext)
     plaintext = SimpleSubstitution(key).decipher(ciphertext)
     return masker.extend(plaintext)
start_time = time.time()
i = 0
while 1:
    i = i + 1
    random.shuffle(parentkey)
    deciphered = SimpleSub(parentkey).decipher(ctext)
    parentscore = fitness.score(deciphered)
    count = 0
    while count < 1000:
        a = random.randint(0, 25)
        b = random.randint(0, 25)
        child = parentkey[:]
        # Swap 2 characters in the Child Key and calculate the fitness score of deciphered text using this key
        child[a], child[b] = child[b], child[a]
        deciphered = SimpleSub(child).decipher(ctext)
        score = fitness.score(deciphered)
        # If the child has a better score - replace the parent
        if score > parentscore:
            parentscore = score
            parentkey = child[:]
            count = 0
        count = count + 1
    # Print out the best score gotten after this iteration
    if parentscore > maxscore:
        maxscore, maxkey = parentscore, parentkey[:]
        print "\nBest fitness score so far: ", maxscore, " on iteration ", i
        ss = SimpleSub(maxkey)
        print "    Best Key: " + "".join(maxkey)
        print "    Best Plaintext: " + ss.decipher(ctext)
        print "    Time Taken: %f s" % (time.time() - start_time)
예제 #23
0
print "Substitution Cipher solver, you may have to wait several iterations"
print "Press ctrl+c to exit program."
i = 0
while 1:
    i = i + 1
    random.shuffle(parent_key)
    deciphered = SimpleSub(parent_key).decipher(ctext)
    parent_score = fitness.score(deciphered)
    count = 0
    while count < 1000:
        a = random.randint(0, 25)
        b = random.randint(0, 25)
        child = parent_key[:]
        # swap two characters in the child
        child[a], child[b] = child[b], child[a]
        deciphered = SimpleSub(child).decipher(ctext)
        score = fitness.score(deciphered)
        # if the child was better, replace the parent with it
        if score > parent_score:
            parent_score = score
            parent_key = child[:]
            count = 0
        count = count + 1
    # keep track of best score seen so far
    if parent_score > max_score:
        max_score, max_key = parent_score, parent_key[:]
        print '\nbest score so far:', max_score, 'on iteration', i
        ss = SimpleSub(max_key)
        print '    best key: ' + ''.join(max_key)
        print '    plaintext: ' + ss.decipher(ctext)
 def decipher(self, text, key):
     return SimpleSubstitution(key).decipher(text)
예제 #25
0
def brute_force(input_file, output_file, iterations):
    img = Image.open(input_file)

    alphabet = [
        "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n",
        "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
    ]
    primes = [
        2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
        71, 73, 79, 83, 89, 97, 101
    ]

    ary = np.array(img)
    rows = ary.shape[0]
    cols = ary.shape[1]
    depth = ary.shape[2]

    hidden_message = []

    for i in range(0, rows):
        for j in range(0, cols):
            for k in range(0, depth):
                if ary[i, j, k] < 102:
                    if is_prime(ary[i, j, k]):
                        hidden_message.append(ary[i, j, k])

    encrypted_message = ""

    for prime in hidden_message:
        encrypted_message += (alphabet[primes.index(prime)])

    ctext = encrypted_message
    ctext = re.sub('[^A-Z]', '', ctext.upper())

    maxkey = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
    maxscore = -99e9
    parentscore, parentkey = maxscore, maxkey[:]

    # keep going until we are killed by the user
    return_ary = []
    file_out = open(output_file, "w")
    file_out.write('')
    for i in range(iterations):
        i = i + 1
        random.shuffle(parentkey)
        deciphered = SimpleSub(parentkey).decipher(ctext)
        parentscore = fitness.score(deciphered)
        count = 0
        while count < 1000:
            a = random.randint(0, 25)
            b = random.randint(0, 25)
            child = parentkey[:]
            # swap two characters in the child
            child[a], child[b] = child[b], child[a]
            deciphered = SimpleSub(child).decipher(ctext)
            score = fitness.score(deciphered)
            # if the child was better, replace the parent with it
            if score > parentscore:
                parentscore = score
                parentkey = child[:]
                count = 0
            count = count + 1
        # keep track of best score seen so far
        if parentscore > maxscore:
            maxscore, maxkey = parentscore, parentkey[:]
            ss = SimpleSub(maxkey)
            if len(output_file) > 1:
                file_out = open(output_file, "a")
                file_out.write('\n\nbest score so far: ' + str(maxscore) +
                               ' on iteration ' + str(i))
                file_out.write('\n    best key: ' + ''.join(maxkey))
                file_out.write('\n    plaintext: ' + ss.decipher(ctext))
                file_out.close()
            return_ary = [0, 0, 0, 0]
            return_ary[0] = maxscore
            return_ary[1] = maxkey
            return_ary[2] = ss.decipher(ctext)
            return_ary[3] = i

    return return_ary
예제 #26
0
def simple_sub_decipher(cipher_text):
    # the english_quadrams text file contains 4-count letter words with their score
    # their score is based on their frequency in the English language
    ng = ngram_score('english_quadgrams.txt')

    input(
        "The simple substitution decipher will take a while to complete. The program will terminate at a certain point. "
        "Please be patient\n"
        "Press ENTER to begin: ")
    cipher_text.upper()
    max_key = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')

    # the default score
    max_score = -99e9

    parent_key = max_key

    # list to store keys already used
    discarded_keys = []
    i = 0
    while True:
        # get a random key
        random.shuffle(parent_key)

        # use that key to decipher the ciphertext
        deciphered_text = SS(parent_key).decipher(cipher_text)

        # get the score from the deciphered text
        parent_score = ng.score(deciphered_text)

        # generate a new key
        new_key = parent_key[:]
        random.shuffle(new_key)

        # if a generated key was used before, then another one will be generated
        if new_key in discarded_keys:
            flag = True
            while flag:
                # the loop will continue to generate a unique key that is not already used before
                random.shuffle(new_key)
                if new_key not in discarded_keys:
                    flag = False

        # new deciphered text using the new key
        deciphered_text = SS(new_key).decipher(cipher_text)

        # get the score from the new deciphered text using the new key
        child_score = ng.score(deciphered_text)

        # if the score is an improvement on the previous score
        if child_score > parent_score:
            parent_score = child_score

        # used keys will be put in the discarded keys list so they wouldn't be used anymore
        discarded_keys.append(new_key)
        discarded_keys.append(parent_key)

        # if the score is greater than the max score, then the key used is more likely to decipher the cipher text
        if parent_score > max_score:
            max_score = parent_score
            max_key = new_key
            ss = SS(max_key)
            print('---------------------------------------------'
                  '\nSCORE:', max_score)
            print('KEY:', list_to_string(max_key))
            print('DECIPHERED TEXT:', ss.decipher(cipher_text))

        i += 1

        # statement for ending the program after certain number of iterations
        if i == 50000:
            print('The program has run for long enough. Terminating...')
            break