allcfgconv - Ersatz / Gedanken zu Verschlüsselung

#! /usr/bin/python3
import sys
import os

class Base32Exception(Exception):
        pass

class Base32:
        def Encode(self, input):
                if type(input).__name__ != 'bytes':
                        raise Base32Exception("Input data has to be of type 'bytes'.")
                if (len(input) % 5) != 0:
                        raise Base32Exception('Invalid length of binary input data.')
                output = b''
                index_input = 0
                while index_input < len(input):
                        binary = bytes(input[index_input:index_input+5])
                        p = int.from_bytes(binary, byteorder='big', signed=False)
                        s = b''
                        for j in range(8):
                                k = (p >> (j * 5)) & 31
                                c = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ123456'[k]
                                s = bytes(c, 'ascii') + s
                        output += s
                        index_input += 5
                return output

        def Decode(self, input):
                if type(input).__name__ != 'bytes':
                        raise Base32Exception("Input data has to be of type 'bytes'.")
                if (len(input) % 8) != 0:
                        raise Base32Exception('Invalid length of text input data.')
                output = bytearray()
                index_input = 0
                while index_input < len(input):
                        out = bytearray(5)
                        val = 0
                        for j in range(8):
                                c = input[index_input + j]
                                try:
                                        v = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ123456'.index(chr(c))
                                except ValueError:
                                        raise Base32Exception('Invalid character found at text input data.')
                                val = (val << 5) + v
                        for k in range(5):
                                o = val & 255
                                out[4 - k] = o
                                val = val >> 8
                        output.extend(out)
                        index_input += 8
                return output

if __name__ == '__main__':
        rc = 1
        if sys.argv[1] == 'test':
                if Base32().Encode(b'\xFF\xFF\xFF\xFF\xFF') != b'66666666':
                        raise Base32Exception('Error encoding all-ones buffer.')
                if Base32().Encode(b'\x00\x00\x00\x00\x00') != b'AAAAAAAA':
                        raise Base32Exception('Error encoding all-zeros buffer.')
                if Base32().Encode(b'\x00\x44\x32\x14\xC7') != b'ABCDEFGH':
                        raise Base32Exception("Error encoding to 'ABCDFEGH'.")
                if Base32().Encode(b'\x39\x8A\x41\x88\x20') != b'HGFEDCBA':
                        raise Base32Exception("Error encoding to 'HGFEDCBA'.")
                if Base32().Decode(bytes('66666666', 'ascii')) != b'\xFF\xFF\xFF\xFF\xFF':
                        raise Base32Exception('Error decoding to all-ones buffer.')
                if Base32().Decode(bytes('AAAAAAAA', 'ascii')) != b'\x00\x00\x00\x00\x00':
                        raise Base32Exception('Error decoding to all-zeros buffer.')
                if Base32().Decode(bytes('ABCDEFGH', 'ascii')) != b'\x00\x44\x32\x14\xC7':
                        raise Base32Exception("Error decoding from 'ABCDFEGH'.")
                if Base32().Decode(bytes('HGFEDCBA', 'ascii')) != b'\x39\x8A\x41\x88\x20':
                        raise Base32Exception("Error decoding from 'HGFEDCBA'.")
                for i in range(10):
                        binary = bytes(os.urandom(i*5))
                        encoded = Base32().Encode(binary)
                        decoded = Base32().Decode(encoded)
                        if binary != decoded:
                                raise Base32Exception("Error comparing original byte array contents and result after encoding/decoding calls.")
                print('Tests done.', file=sys.stderr)
                rc = 0
        elif sys.argv[1] == 'encode':
                input = sys.stdin.buffer.read()
                output = Base32().Encode(input)
                sys.stdout.write(output.decode('ascii'))
                rc = 0
        elif sys.argv[1] == 'decode':
                input = sys.stdin.buffer.read()
                sys.stdout.buffer.write(Base32().Decode(input))
                rc = 0
        else:
                print("Unknown mode '{0:s}'.".format(sys.argv[1]), file=sys.stderr)
        sys.exit(rc)

#! /usr/bin/python3
import sys
import string
import codecs
import math
from base32 import Base32

class Encoding_Line(object):
        """members:
        encoded_bytes  - bytes(<encoded part of line>)
        encoded_binary - bytes(<base32 decoded data of encoded_text>)
        encoded_length - length of encoded_text
        text_length    - length of plain text encoded to encoded_text"""
        def __init__(self, line):
                parts = str.split(line, '\t')
                self.text_length = int(parts[0])
                self.encoded_length = int(parts[1])
                self.encoded_bytes = bytes(parts[2].rstrip('\n'), 'ascii')
                self.encoded_binary = Base32().Decode(self.encoded_bytes)

def binstring(input):
        out = ''
        for byte in input:
                bits = bin(byte)
                aligned = str('000000000' + bits[bits.index('0b')+2::])[-8::]
                out += aligned
        out = out[::-1]
        return out

def equal_start(bins):
        prefix = bins[0]
        while len(prefix) > 0:
                for b in bins:
                        next_b = True
                        for i in range(len(prefix)):
                                if b[i] != prefix[i]:
                                        prefix = prefix[:i]
                                        next_b = False
                                        break
                        else:
                                if next_b == False:
                                        break
                else:
                        return prefix
        return prefix

def print_changes(enc_bins, old_len, new_len):
        bins = []
        for e in enc_bins:
                bins.append(binstring(e))
        unused_bits = equal_start(sorted(bins))
        print('======================================================')
        print('encoded text length changed from {0} to {1}'.format(old_len, new_len))
        print('encoded text padded with {0} unused bits ({1} bytes)'.format(len(unused_bits),math.ceil(len(unused_bits) / 8)))
        print('======================================================')
        return

file=sys.argv[1]
Lines = []

with open(file) as input:
        for line in input:
                Lines.append(Encoding_Line(line))

input.close

# count characters within the encoded strings
# chars = dict()
# for el in Lines:
#       for c in el.encoded_text:
#               if c in chars:
#                       chars[c]+=1
#               else:
#                       chars[c]=1
# for e in sorted(chars.keys(),key=lambda x: x if not str.isdigit(x) else 'Z'+x):
#       print '{0} {1:d}'.format(e,chars[e])

# print length of plain text and encoded_data and append hexadecimal content of encoded_data
enc_len = 0
enc_bins = []
for el in Lines:
        if el.encoded_length != enc_len:
                if enc_len != 0:
                        print_changes(enc_bins, enc_len, el.encoded_length)
                enc_len = el.encoded_length
                enc_bins = []
        enc_bins.append(el.encoded_binary[-8::])
        needed_bits = el.text_length * 8
        needed_bytes = math.ceil(needed_bits / 5)
        print('{0:3d} {1:3d} {2:3d} {3:3d} {4:s}'.format(el.text_length, needed_bits, needed_bytes, el.encoded_length, ''.join(map(lambda x: format(x, '02X'), el.encoded_binary))))
print_changes(enc_bins, enc_len, -1)