CrypTool Portal

python transpostion.py --encrypt --message 'Hallo, das ist ein Test. Bitte geben Sie Ihren Text hier ein' --key 'Chiffre' --alphabet '' --case-sensitive   --replace-char ''

import math
import sys
import argparse
from itertools import chain
import re

def encrypt_message(message, key, b_case_sensitive ,b_remove_spaces, replace_char, b_blocks_of_five, alphabet):
    if(replace_char):
        message = message.replace(' ', replace_char)

    if(b_remove_spaces):
        message = message.replace(' ', '')

    #escape all regex special characters in alphabet
    alphabet = re.escape(alphabet)
    dic = "[^{}]".format(alphabet)
    message = re.sub( dic, "" , message)
    key = re.sub( dic, "" , key)

    encrypted_message = ""
    message = list(message)
    ciphertext = []
    column = []
    #if case sensitive is false, then set key to lowercase
    if(not b_case_sensitive):
        key = key.upper()
    # get every nth el and append to a column
    for i in range(len(key)):
        column.append(message[i::len(key)])
    # sort key based on the defined alphabet
    dictKey = {}
    for x in range(len(key)):
        dictKey[x] = key[x]
    sorted_key = sorted(dictKey.items(), key=lambda pair: alphabet.index(pair[1]), reverse=False)
    # append the columns based on the alphabetic order of the key
    for num in range(len(key)):
        encrypted_message += "".join(column[sorted_key[num][0]])
    
    if(b_blocks_of_five):
        # delete spaces
        encrypted_message = list(encrypted_message.replace(' ',''))
        k = ' '
        N = 5
        # insert every N th element k
        encrypted_message = ''.join(list(chain(*[encrypted_message[i : i+N] + [k] 
            if len(encrypted_message[i : i+N]) == N 
            else encrypted_message[i : i+N] 
            for i in range(0, len(encrypted_message), N)])))
    
    return encrypted_message
  

# Decryption 
def decrypt_message(cipher, key, alphabet, b_case_sensitive): 
    decrypted_message = ""
    # calculate the number of rows in matrix
    rows = math.ceil(len(cipher) / len(key))
    # calculate the number of placeholders in the last row
    diff = rows * len(key) - len(cipher)
    empty_matrix = [""] * len(key)
    #if case sensitive is false, then set key to lowercase
    if(not b_case_sensitive):
        key = key.upper()
    
    #escape all regex special characters in alphabet
    alphabet = re.escape(alphabet)
    dic = "[^{}]".format(alphabet)
    #remove non-alphabetic symbols in message and key
    cipher = re.sub( dic, "" , cipher)
    key = re.sub( dic, "" , key)

    # sort key based on the defined alphabet
    dictKey = {}
    for x in range(len(key)):
        dictKey[x] = key[x]
    sorted_key = sorted(dictKey.items(), key=lambda pair: alphabet.index(pair[1]), reverse=False)
    #pointer that point on the row to insert char
    row_pointer = 0
    #pointer that point on the cahr in text
    char_pointer = 0
    for i in range(len(sorted_key)):
        col = sorted_key[i][0]
        #if col is bigger than keylength minus diff it means that in this row is a placeholder on the last row
        if(col >= len(key) - diff):
            rowsMax = rows - 1
        else:
            rowsMax = rows
        for z in range(rowsMax):
            if(char_pointer == len(cipher)):
                break
            empty_matrix[col] += cipher[char_pointer]
            char_pointer += 1

    #get every first,second and so on element from column in matrix
    decrypted_message = ''
    for row in range(rows):
        for i in range(len(key)):
            if(row < len(empty_matrix[i])):
                decrypted_message += empty_matrix[i][row]
            
    return(decrypted_message)
	

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("-a", "--alphabet", help="alphabet for key and inut-tex", type=str)
    parser.add_argument("-k", "--key", help="key to decrypt or encrypt", type=str)
    parser.add_argument('-e','--encrypt', dest='crypt_modus', action='store_true')
    parser.add_argument('-d','--decrypt', dest='crypt_modus', action='store_false')
    parser.add_argument('-f','--blocks-of-five', dest='blocks_of_five', action='store_true')
    parser.add_argument('-cs','--case-sensitive', dest='case_sensitive', action='store_true')
    parser.add_argument('-rs','--remove-spaces', dest='remove_spaces_mod', action='store_true')
    parser.add_argument('-rc','--replace-char', help="char for replacement", type=str)
    parser.add_argument("-m", "--message", help="char for replacement", type=str, required=True)

    if len(sys.argv) == 1:
        sys.exit(1)

    args = parser.parse_args()
    if args.crypt_modus:
        print(encrypt_message(args.message, args.key, args.case_sensitive , args.remove_spaces_mod, args.replace_char, args.blocks_of_five, args.alphabet))
    else:
        print(decrypt_message(args.message, args.key, args.alphabet, args.case_sensitive))

Einfache Spalten-Transposition

Hintergrund

Beschreibung und Bedienung

1. Raster erstellen

2. Raster füllen

3. Tabellenköpfe und Permutation eintragen

4. Spaltenweises Auslesen

Sicherheitsbetrachtung

Referenzen

Über den Code

Über den Editor

Referenzen