김수정 암호제작기에 오신 것을 환영합니다.

# 파이썬3

# 상수

ENC = 0
DEC = 1

# 카이사르암호표 작성

def makeDisk(key_caesar):
    keytable = map(lambda x: (chr(x+65), x), range(26))
    key2index = {}
    for t in keytable:
    alphabet, index = t[0], t[1]
    key2index[alphabet] = index

    if key_caesar in key2index:
        k = key2index[key_caesar]
    else:
        return None, None

    enc_disk = {}
    dec_disk = {}

    for i in range(26):
        enc_i = (i+k)%26
        enc_ascii = enc_i + 65
        enc_disk[chr(i+65)] = chr(enc_ascii)
        dec_disk[chr(enc_ascii)] = chr(i+65)

    return enc_disk, dec_disk

# 카이사르암호문 작성

def caesar(msg, key_caesar, mode):
    ret = ''

    enc_disk, dec_disk = makeDisk(key_caesar)

    if enc_disk is None:
        return ret

    if mode is ENC:
        disk = enc_disk
    if mode is DEC:
        disk = dec_disk

    for c in msg:
        if c in disk:
            ret += disk[c]
        else:
            ret += c

    return ret

# 주상전치암호표 작성

def parseKey(key_CTC):
    tmp = []

    for i, k in enumerate(key_CTC):
        tmp.append((i, k))
        tmp = sorted(tmp, key=lambda x:x[1])

    enc_table = {}
    dec_table = {}

    for i, r in enumerate(tmp):
        enc_table[r[0]] = i
        dec_table[i] = r[0]

    return enc_table, dec_table

# 주상전치암호문 작성

def transposition(msg, key_CTC, mode):
    msgsize = len(msg)
    keysize = len(key_CTC)
    ret = ''
    filler = ''

    if msgsize%keysize != 0:
        filler = ':'*(keysize - msgsize%keysize)
        msg = msg.upper()
        msg += filler

    enc_table, dec_table = parseKey(key_CTC)

    if mode == ENC:
        table = enc_table
    else:
        table = dec_table

    if mode == ENC:
        buf = ['']*keysize

        for i, c in enumerate(msg):
            col = i%keysize
            index = table[col]
            buf[index] += c

        for text in buf:
            ret += text
    else:
        blocksize = int(msgsize/keysize)
        buf = ['']*keysize
        pos = 0

    for i in range(keysize):
        text = msg[pos:pos+blocksize]
        index = table[i]
        buf[index] += text
        pos += blocksize

    for i in range(blocksize):
        for j in range(keysize):
            if buf[j][i] != '0':
                ret += buf[j][i]

    return ret

# 김수정 암호제작기

def main():

# 암호화 또는 해독 모드 선택 입력

    while True:
        mode = (int(input('Select mode of cipher (1. Encryption, 2. Decryption): ')) - 1)
        if mode == 0 or mode == 1:
            break
        else:
            print('Please select 1 or 2')

# 암호화키 입력 받고 적절한 암호화키인지 확인

    while True:
        cipherkey = (input('Cipher Key :')).upper()
        keylen = len(cipherkey)
        cipher_count = 0

        if cipherkey.isalpha() == False:
            print('You have entered a cipher key with non-alphabet character(s). Enter a valid one.')
        else:
            for c in cipherkey:
                if cipherkey.count(c) == 1:
                    cipher_count += 1
                else:
                    print('You have entered a cipher key with duplicate character(s). Enter a valid one.')
                    break

        if cipher_count == keylen:
            break

# 암호문 또는 평문 입력

    if mode == ENC:
        msg_plain = (input('Enter text to encrypt: ')).upper()
    else:
        msg_ciphered = (input('Enter text to decrypt: ')).upper()

# 암호화키에서 카이사르암호화키와 주상전치암호화키 추출하여 암호문 작성 또는 암호문 해독

    key_caesar = cipherkey[keylen-1]
    key_CTC = cipherkey[0:keylen-1]

    if mode == ENC:
        msg = msg_plain.replace(" ","_")
        msg_caesar = caesar(msg, key_caesar, mode)
        msg_ciphered = (transposition(msg_caesar, key_CTC, mode)).lower()
        print('Encrypted text:\t' + msg_ciphered)
    else:
        msg_caesar = transposition(msg_ciphered, key_CTC, mode)
        msg = caesar(msg_caesar, key_caesar, mode)
        msg_plain = msg.replace("_"," ")
        print('Decrypted text:\t' + msg_plain)

if __name__ == '__main__':
    main()