轻量级分组密码LBlock的Python实现

最新推荐文章于 2024-09-26 11:55:47 发布

_AaRong_

最新推荐文章于 2024-09-26 11:55:47 发布

阅读量225

点赞数 3

文章标签： python 算法 linux

本文链接：https://blog.csdn.net/weixin_52497013/article/details/138419588

版权

密钥编排算法

# S盒的定义
S8 = [8, 7, 14, 5, 15, 13, 0, 6, 11, 12, 9, 10, 2, 4, 1, 3]
S9 = [11, 5, 15, 0, 7, 2, 9, 13, 4, 8, 1, 12, 14, 10, 3, 6]

def s8_lookup(input_half):
    return S8[input_half]

def s9_lookup(input_half):
    return S9[input_half]

# 密钥调度算法
def key_schedule(initial_key, nr):
    round_keys = []

    # 将初始密钥保存在移位寄存器中
    key_register = initial_key

    for round_counter in range(nr):
        # 第一步：循环左移29位
        key_register = ((key_register << 29) | (key_register >> 51)) & 0xFFFFFFFFFFFFFFFF

        # 第二步：用S8和S9进行代换运算
        key_register_part_1 = (key_register >> 76) & 0xF
        key_register_part_2 = (key_register >> 72) & 0xF

        key_register_part_1_substituted = s9_lookup(key_register_part_1)
        key_register_part_2_substituted = s8_lookup(key_register_part_2)

        key_register &= 0xFFFFFFFFFFFFFFFF ^ (0xF << 76)  # 清除原来的部分
        key_register &= 0xFFFFFFFFFFFFFFFF ^ (0xF << 72)
        key_register |= key_register_part_1_substituted << 76
        key_register |= key_register_part_2_substituted << 72

        # 第三步：与轮数进行按位异或运算
        key_register ^= round_counter

        # 第四步：提取左边32bit作为轮密钥Ki
        round_key = key_register >> 48
        round_keys.append(round_key)

    return round_keys

轮函数

# S盒的定义
S_boxes = [
    [14, 9, 15, 0, 13, 4, 10, 11, 1, 2, 8, 3, 7, 6, 12, 5],
    [4, 11, 14, 9, 15, 13, 0, 10, 7, 12, 5, 6, 2, 8, 1, 3],
    [1, 14, 7, 12, 15, 13, 0, 6, 11, 5, 9, 3, 2, 4, 8, 10],
    [7, 6, 8, 11, 0, 15, 3, 14, 9, 10, 12, 13, 5, 2, 4, 1],
    [14, 5, 15, 0, 7, 2, 12, 13, 1, 8, 4, 9, 11, 10, 6, 3],
    [2, 13, 11, 12, 15, 14, 0, 9, 7, 10, 6, 3, 1, 8, 4, 5],
    [11, 9, 4, 14, 0, 15, 10, 13, 6, 12, 5, 7, 3, 8, 1, 2],
    [13, 10, 15, 0, 14, 4, 9, 11, 2, 1, 8, 3, 7, 5, 12, 6]
]

# P盒的置换规则
P_box_permutation = [6, 4, 7, 5, 2, 0, 3, 1]



# 下面是轮函数的实现
# 加密函数所使用到的S盒置换函数
def s_box_lookup(input_half):
    output_half = 0
    for i in range(8):
        s_box = S_boxes[i]
        input_half_part = (input_half >> (4 * (7 - i))) & 0xF  # 取输入的一部分数据，因为S盒每个输入为4位
        output_half_part = s_box[input_half_part]             # 在S盒中查找对应的输出
        output_half |= output_half_part << (4 * (7 - i))      # 将查找得到的输出放置到输出的相应位置
    return output_half

def p_box_permutation(input_half):
    output_half = 0
    for i in range(8):
        output_bit = (input_half >> (7 - P_box_permutation[i])) & 0x1  # 计算输出位，P_box_permutation[i]表示第i个置换位置
        output_half |= output_bit << (7 - i)  # 将计算得到的输出位加入到输出的相应位置
    return output_half

# 轮函数F
def lblock_round(XL, XR, round_key):
    # 第一步：轮密钥加
    XL ^= round_key
    # 第二步：S盒代换
    XL_permuted = s_box_lookup(XL)
    # 第三步：P盒置换
    XL_permuted = p_box_permutation(XL_permuted)
    # 第四步：XR循环左移8位并与右半部分异或
    # 将右半部分XR循环左移8位并与左半部分异或的结果作为下一轮的左半部分XL
    XR_shift = (((XR << 8) | (XR >> 24)) & 0xFFFFFFFF)
    XL_next = XR_shift ^ XL_permuted
    # 下一轮的右半部分XR为当前轮的左半部分XL
    XR_next = XL

    # 返回下一轮的左右部分
    return XL_next, XR_next