SEED 암호화 코드 - KISA

암호화 클래스

from cryptography.hazmat.backends.openssl.backend import backend
from cryptography.hazmat.primitives.ciphers import algorithms, base, modes
import base64


class SEED128:

    def encrypt(self, key, txt):
        key_bytes = self.convert_key_to_byte_array(key)
        padded_txt_bytes = self.convert_txt_to_padded_byte_array(txt)
        encrypted_txt_bytes = self.seed_encrypt(key_bytes, padded_txt_bytes)

        b64_encrypted_txt_bytes = base64.b64encode(encrypted_txt_bytes)
        print("ENCODED BASE64 = {}".format(b64_encrypted_txt_bytes))

        return b64_encrypted_txt_bytes

    def decrypt(self, key, b64_enc_txt):
        key_bytes = self.convert_key_to_byte_array(key)
        encrypted_txt = base64.b64decode(b64_enc_txt)
        print("DECODED ENCRYPTION = {}".format(encrypted_txt))

        decrypted_txt = self.seed_decrypt(key_bytes, encrypted_txt)
        print("DECODED TXT = {}".format(decrypted_txt))
        unpadded_txt = self.unpad_txt(decrypted_txt)
        print("UNPADDED = {}".format(unpadded_txt))
        return unpadded_txt.decode()

    def seed_encrypt(self, key_bytes, txt_bytes):
        mode = modes.ECB()
        cipher = base.Cipher(
            algorithms.SEED(key_bytes),
            mode,
            backend
        )
        encryptor = cipher.encryptor()
        ct = encryptor.update(txt_bytes)
        ct += encryptor.finalize()
        return ct

    def seed_decrypt(self, key_bytes, enc_txt):
        mode = modes.ECB()
        cipher = base.Cipher(
            algorithms.SEED(key_bytes),
            mode,
            backend
        )
        decryptor = cipher.decryptor()
        ct = decryptor.update(enc_txt)
        ct += decryptor.finalize()
        return ct

    def convert_key_to_byte_array(self, key):
        key_array = [int(key[i:i+2], 16) for i in range(0, len(key), 2)]
        print("KEY ARRAY = {}".format(key_array))
        key_bytes = bytes(key_array)
        print("KEY BYTES = {}".format(key_bytes))
        return key_bytes

    def convert_txt_to_padded_byte_array(self, txt):
        txt_array = [ord(val) for val in txt]
        print("TXT ARRAY = {}".format(txt_array))
        padded_txt_array = self.pad_txt_to_sixteen_bytes(txt_array)
        padded_txt_byte_array = bytes(padded_txt_array)
        print("TXT BYTES = {}".format(padded_txt_byte_array))
        return padded_txt_byte_array

    def pad_txt_to_sixteen_bytes(self, txt_array):
        padded_txt_array = [] + txt_array
        if len(txt_array) < 16:
            for _ in range(16 - len(txt_array)):
                padded_txt_array.append(int('0e', 16))
        print("PADDED TXT ARRAY = {}".format(padded_txt_array))
        return padded_txt_array

    def unpad_txt(self, padded_txt_array):
        idx = padded_txt_array.find(b'\x0e')
        if idx == -1:
            return padded_txt_array
        return padded_txt_array[:idx]

 

사용 예제

key = "0123456789ABCDEF0123456789ABCDEF"
txt = "1234"

seed128 = SEED128()
enc_result = seed128.encrypt(key, txt)
print("=" * 30)
dec_result = seed128.decrypt(key, enc_result)

 

아웃풋

KEY ARRAY = [1, 35, 69, 103, 137, 171, 205, 239, 1, 35, 69, 103, 137, 171, 205, 239]
KEY BYTES = b'\x01#Eg\x89\xab\xcd\xef\x01#Eg\x89\xab\xcd\xef'
TXT ARRAY = [49, 50, 51, 52]
PADDED TXT ARRAY = [49, 50, 51, 52, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14]
TXT BYTES = b'1234\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e'
ENCODED BASE64 = b'nAvLgEsRpgqT1JWG35OYAA=='
==============================
KEY ARRAY = [1, 35, 69, 103, 137, 171, 205, 239, 1, 35, 69, 103, 137, 171, 205, 239]
KEY BYTES = b'\x01#Eg\x89\xab\xcd\xef\x01#Eg\x89\xab\xcd\xef'
DECODED ENCRYPTION = b'\x9c\x0b\xcb\x80K\x11\xa6\n\x93\xd4\x95\x86\xdf\x93\x98\x00'
DECODED TXT = b'1234\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e'
UNPADDED = b'1234'

 

*

python2.7에서 실행할 경우에는 bytes대신 bytearray 사용