对称密码算法，对str的操作，封装了 symmetric_alg.py

"""symmetric_apply.py 对 symmetric_alg.py 进行了封装
Author: tanglei
DateTime:2024-11-18 完成
微信：ciss_cedar
欢迎一起学习
"""
import base64

from utils.algorithm.symmetric.symmetric_alg import MySymCipher, AlgName, CipherMode

code_tuple = ('Hex', 'base64')
alg_tuple = ('TripleDES', 'Blowfish', 'CAST5', 'IDEA')
Des_3 = 'TripleDES'


def symmetric_encrypt(key, iv, source, mode, alg_name, code=code_tuple[0]):
    if len(key) >= 32 and alg_name == Des_3:
        # key 传入16字节【32字符】，iv传入16字节【字符】
        key = key[:32] + key[:16]  # 可以为48字符，ABA模式的key

    if len(iv) >= 16 and alg_name in alg_tuple:
        iv = iv[:16]

    key_bytes = bytes.fromhex(key)
    iv_bytes = bytes.fromhex(iv)
    plain_bytes = source.encode()
    my_alg = MySymCipher(key_bytes, iv_bytes, mode, alg_name)
    encrypt_bytes = my_alg.encrypt_bytes(plain_bytes)
    if code == code_tuple[0]:
        enc_source = encrypt_bytes.hex().upper()
    else:
        enc_source = base64.b64encode(encrypt_bytes).decode()
    return enc_source


def symmetric_decrypt(key, iv, enc_source, mode, alg_name, code=code_tuple[0]):
    # key 传入16字节【32字符】，iv传入16字节【字符】
    if len(key) >= 32 and alg_name == Des_3:
        # key 传入16字节【32字符】，iv传入16字节【字符】
        key = key[:32] + key[:16]  # 可以为48字符，ABA模式的key

    if len(iv) >= 16 and alg_name in alg_tuple:
        iv = iv[:16]

    key_bytes = bytes.fromhex(key)
    iv_bytes = bytes.fromhex(iv)
    if code == code_tuple[0]:
        cipher_bytes = bytes.fromhex(enc_source)
    else:
        cipher_bytes = base64.b64decode(enc_source)
    my_alg = MySymCipher(key_bytes, iv_bytes, mode, alg_name)
    decrypt_bytes = my_alg.decrypt_bytes(cipher_bytes)
    source = decrypt_bytes.decode()
    return source


def gen_key(length=16):
    # 使用软件算法，可以调用系统函数或者使用secrets生成随机数再进行派生
    # 当前使用32字符，16字节的随机数也是可以的。
    random_bytes = MySymCipher.gen_random_bytes(length)
    key = random_bytes.hex().upper()
    return key


def gen_iv(length=16):
    # 使用软件算法，可以调用系统函数或者使用secrets生成随机数再进行派生
    # 当前使用32字符，16字节的随机数也是可以的。
    random_bytes = MySymCipher.gen_random_bytes(length)
    iv = random_bytes.hex().upper()
    return iv


def gen_key_iv(length=16):
    # 使用软件算法，可以调用系统函数或者使用secrets生成随机数再进行派生
    # 当前使用32字符，16字节的随机数也是可以的。
    random_bytes = MySymCipher.gen_random_bytes(length)
    key = random_bytes.hex().upper()

    random_bytes = MySymCipher.gen_random_bytes(length)
    iv = random_bytes.hex().upper()
    return key, iv


def main():
    key128 = '2934412A66B7A186DC35DC40E926F9EE'
    key192 = '2934412A66B7A186DC35DC40E926F9EE2934412A66B7A186'
    key256 = '2934412A66B7A186DC35DC40E926F9EE2934412A66B7A186DC35DC40E926F9EE'
    # AES key长度变化iv都是128位
    iv = '86CD720D75F4622DBE96078A3CD1076E'

    # key = key192
    source = '1'

    alg_name = AlgName.AES.value
    mode = CipherMode.CBC.value
    cipher = symmetric_encrypt(key128, iv, source, mode, alg_name)
    plain = symmetric_decrypt(key128, iv, cipher, mode, alg_name)
    print(f'alg_name={alg_name},mode={mode}')
    print(f'key={key128},iv={iv}')
    print(f'source=', source)
    print(f'cipher={cipher}')
    print(f'plain={plain}')
    cipher = symmetric_encrypt(key192, iv, source, mode, alg_name)
    plain = symmetric_decrypt(key192, iv, cipher, mode, alg_name)
    print(f'cipher={cipher}')
    print(f'plain={plain}')
    cipher = symmetric_encrypt(key256, iv, source, mode, alg_name)
    plain = symmetric_decrypt(key256, iv, cipher, mode, alg_name)
    print(f'cipher={cipher}')
    print(f'plain={plain}')

    print('-' * 66)
    # code = 'base64'
    # cipher =symmetric_encrypt(key,iv,source,mode,alg_name,code)
    # plain = symmetric_decrypt(key,iv,cipher,mode,alg_name,code)
    # print(f'alg_name={alg_name},mode={mode},code={code}')
    # print(f'key={key},iv={iv}')
    # print(f'source=', source)
    # print(f'cipher={cipher}')
    # print(f'plain={plain}')
    result = ''
    # ALG_NAME = ('TripleDES', 'AES', 'SM4')
    # MODE_NAME = ('ECB',)  # ('ECB', 'CBC')
    # code_tuple = ('Hex',)  # ('Hex', 'base64')
    # for alg_name in ALG_NAME:
    #     for mode_name in MODE_NAME:
    #         for code in code_tuple:
    #             if alg_name == 'TripleDES' and mode_name == 'CBC':
    #                 tempkey = key
    #                 tempiv = iv
    #                 key = key + key[0:16]
    #                 iv = iv[0:16]
    #                 result_value = symmetric_encrypt(key, iv, source, mode_name, alg_name, code)
    #                 length = len(result_value)
    #                 result += f'{alg_name}_{mode_name}_{code}' + f'({length}|{length / 2.0}|{length / 2.0 * 8})=' + result_value + '\n'
    #                 iv = tempiv
    #                 key = tempkey
    #             else:
    #                 result_value = symmetric_encrypt(key, iv, source, mode_name, alg_name, code)
    #                 length = len(result_value)
    #                 result += f'{alg_name}_{mode_name}_{code}' + f'({length}|{length / 2.0}|{length / 2.0 * 8})=' + result_value + '\n'
    #         result += '-' * 99 + '\n'


if __name__ == '__main__':
    main()