crypt.py

import os
from Globals import Global

CHARS = Global.CHARS
CHARS_LEN = Global.CHARS_LEN


def file_check(infile, outfile):
    if os.path.isfile(infile):
        if os.path.isfile(outfile):
            if os.path.samefile(infile, outfile):
                raise ValueError('Input and output files are the same.')
        else:
            raise ValueError('Error while writing file.')
    else:
        raise ValueError('Error while reading file.')

    if not os.path.getsize(infile):
        raise ValueError('Input file is empty.')
    if os.path.getsize(outfile):
        raise ValueError('Output file is not empty.')


def key_check(key):
    if os.path.isfile(key):
        if not os.path.getsize(key):
            raise ValueError('Key file is empty.')
    else:
        raise ValueError('Error while reading file.')


def caesar_encode(infile, outfile, key):
    file_check(infile, outfile)

    source = open(infile, 'r', encoding='utf8')
    result = open(outfile, 'w', encoding='utf8')

    while True:

        symbol = source.read(1).lower()

        if not symbol:
            break
        if symbol not in CHARS:
            result.write(symbol)
            continue

        result.write(CHARS[(CHARS.find(symbol) + key) % CHARS_LEN])

    source.close()
    result.close()


def caesar_decode(infile, outfile, key):
    file_check(infile, outfile)

    source = open(infile, 'r', encoding='utf8')
    result = open(outfile, 'w', encoding='utf8')

    while True:
        symbol = source.read(1).lower()
        if not symbol:
            break
        if symbol not in CHARS:
            result.write(symbol)
            continue

        result.write(CHARS[(CHARS.find(symbol) - key) % CHARS_LEN])

    source.close()
    result.close()


def vigenere_encode(infile, outfile, key_word):
    file_check(infile, outfile)

    source = open(infile, 'r', encoding='utf8')
    result = open(outfile, 'w', encoding='utf8')
    key_len = len(key_word)
    i = 0
    while True:
        symbol = source.read(1).lower()
        if not key_word:
            raise ValueError('Key is empty.')
        if not symbol:
            break
        if symbol not in CHARS:
            result.write(symbol)
            continue

        symbol_idx = (CHARS.find(symbol)
                      + CHARS.find(key_word[i].lower())) % CHARS_LEN
        result.write(CHARS[symbol_idx])
        i = (1 + i) % key_len

    source.close()
    result.close()


def vigenere_decode(infile, outfile, key_word):
    file_check(infile, outfile)

    source = open(infile, 'r', encoding='utf8')
    result = open(outfile, 'w', encoding='utf8')
    key_len = len(key_word)
    i = 0
    while True:
        symbol = source.read(1).lower()
        if not key_word:
            raise ValueError('Key is empty.')
        if not symbol:
            break
        if symbol not in CHARS:
            result.write(symbol)
            continue

        symbol_idx = (CHARS.find(symbol)
                      - CHARS.find(key_word[i].lower())) % CHARS_LEN
        result.write(CHARS[symbol_idx])
        i = (1 + i) % key_len

    source.close()
    result.close()


def vernam_encode(infile, outfile, key):
    file_check(infile, outfile)
    key_check(key)

    source = open(infile, 'r', encoding='utf8')
    result = open(outfile, 'w', encoding='utf8')
    key_file = open(key, 'r', encoding='utf8')

    symbol = source.read(1).lower()
    letter = key_file.read(1).lower()

    while True:
        if symbol not in CHARS:
            result.write(symbol)
            symbol = source.read(1).lower()
            continue
        if letter not in CHARS:
            letter = key_file.read(1).lower()
            continue
        if bool(letter) ^ bool(symbol):
            raise EOFError('EOF reached.')
        if not symbol or not letter:
            break
        result.write(CHARS[(CHARS.find(symbol) + CHARS.find(letter))
                           % CHARS_LEN])
        symbol = source.read(1).lower()
        letter = key_file.read(1).lower()

    source.close()
    result.close()
    key_file.close()


def vernam_decode(infile, outfile, key):
    file_check(infile, outfile)
    key_check(key)
    source = open(infile, 'r', encoding='utf8')
    result = open(outfile, 'w', encoding='utf8')
    key_file = open(key, 'r', encoding='utf8')

    symbol = source.read(1).lower()
    letter = key_file.read(1).lower()

    while True:
        if symbol not in CHARS:
            result.write(symbol)
            symbol = source.read(1).lower()
            continue
        if letter not in CHARS:
            letter = key_file.read(1).lower()
            continue
        if bool(letter) ^ bool(symbol):
            raise EOFError('EOF reached.')
        if not symbol or not letter:
            break
        result.write(CHARS[(CHARS.find(symbol) - CHARS.find(letter))
                           % CHARS_LEN])
        symbol = source.read(1).lower()
        letter = key_file.read(1).lower()

    source.close()
    result.close()
    key_file.close()


def analyses(infile, outfile):
    file_check(infile, outfile)
    letters = [0 for _ in range(CHARS_LEN)]
    source = open(infile, 'r', encoding='utf8')

    while True:
        symbol = source.read(1).lower()
        if not symbol:
            break
        if symbol in CHARS:
            letters[CHARS.find(symbol)] += 1

    key = letters.index(max(letters)) - CHARS.find('e')
    caesar_decode(infile, outfile, key)
    source.close()