【密码工程】AES 侧信道攻击

遇到的问题：一开始编写的攻击脚本运行效率太低。

解决方法：更换了使用的统计函数，使得运行速度大幅提升。

实验亮点：

使用 python 的 matplotlib 库绘制了功耗曲线。
使用数学公式分析了 DPA 方法和 CPA 方法。
对实验代码进行了清晰的说明，并使用 tqdm 库显示了攻击的进度。

实验前置说明

实验给出了三个 npy 文件：

AES_tracesPart0.npy: 储存了AES加密时的功耗曲线，共1000条曲线，每个曲线有70000个采样点。
AES_textinPart0.npy: 存储了1000个随机的明文，加密的密钥是固定的。
AES_textoutPart0.npy: 存储了1000条加密后的密文。

可以使用 numpy 来读取 npy 文件

绘制功耗曲线

我们可以使用 python 的 matplotlib 库来绘制功耗曲线：

import matplotlib.pyplot as plt
import numpy as np

num_traces = 10 #绘制前10条功耗曲线
num_points = 70000 #每条曲线70000个采样点
power_traces = np.load('AES_tracesPart0.npy') #导入功耗曲线

plt.figure(figsize=(10,5))

colors = plt.cm.viridis(np.linspace(0, 1, num_traces))

for i in range(num_traces):
    plt.plot(power_traces[i], color=colors[i], alpha=0.7)
    
plt.title('All Power Consumption Traces')
plt.xlabel('Sample Points')
plt.ylabel('Power Consumption')
plt.grid(True)
plt.show()

这里我们绘制前10条功耗曲线：

可以看到功耗曲线有10个尖峰，这表示这AES加密的10轮加密。

使用DPA方法攻击第一轮轮密钥

关于DPA方法

DPA（Differential Power Analysis，差分功耗分析）是一种侧信道攻击方法，用于分析加密算法在执行过程中泄露的功耗信息，从而推测出加密密钥等敏感信息。

DPA 原理

功耗模型
假设设备的功耗 $P$ 可以表示为： $$ P = P_{\text{data}} + P_{\text{noise}} $$ 其中：
- $P_{\text{data}}$：与处理中间数据相关的功耗。
- $P_{\text{noise}}$：环境噪声或设备内部非相关部分的功耗。
分类依据：
攻击者假设密钥 $K$，通过 S 盒变换计算中间值： $$ V = SBOX(P_{\text{plaintext}}[i] \oplus K) $$ 然后根据 $V$ 的最低有效位对功耗曲线分类。
差分计算：
对分类后的两组曲线分别计算平均功耗： $$ \bar{P}1 = \frac{1}{N_1} \sum{i \in \text{Group1}} P_i, \quad \bar{P}0 = \frac{1}{N_0} \sum{i \in \text{Group0}} P_i $$ 其中 $N_1$ 和 $ N_0 $ 分别是分组中的样本数量。
差分功耗： 计算两组平均功耗的差值： $$ \Delta P = \bar{P}_1 - \bar{P}_0 $$ 如果猜测的 $K$ 正确，则在特定的时间点 $ t $（例如 S 盒变换时）出现显著的功耗差异。

关键步骤：

使用 S 盒计算明文和猜测密钥 $ K $ 的中间值。
根据中间值分组，并计算差分功耗。
根据时间窗口内的最大差分功耗，判断最优密钥。

实现DPA方法

import numpy as np
from tqdm import tqdm #用于显示进度条

# 读取 AES 的功耗数据和明文数据
traces = np.load('AES_tracesPart0.npy')  # 1000条功耗曲线，每条有70000个功耗点
plaintexts = np.load('AES_textinPart0.npy')  # 对应的1000条随机明文

# AES S 盒，用于 SubBytes 操作
SBOX = [
    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
]

# 恢复整个第一轮的子密钥（16个字节）
num_traces, trace_length = traces.shape
key_guesses = np.zeros((16, 256))  # 16个字节，每个字节有256个猜测值
best_keys = np.zeros(16, dtype=int)  # 用于存储每个字节的最优猜测

# 针对每个字节进行攻击
for target_byte in tqdm(range(16)):
    for guess in range(256):
        group1_sum = np.zeros(trace_length)  # 假设中间值的某比特为1的功耗和
        group2_sum = np.zeros(trace_length)  # 假设中间值的某比特为0的功耗和
        group1_count = 0
        group2_count = 0

        for i in range(num_traces):
            # 输出字节 SubBytes(明文字节 ⊕ 密钥猜测)
            intermediate_value = SBOX[plaintexts[i][target_byte] ^ guess]

            # 使用中间值的某一位作为分类标准，使用最低位
            if intermediate_value & 1:  # 根据中间值最低位分类
                group1_sum += traces[i]
                group1_count += 1
            else:
                group2_sum += traces[i]
                group2_count += 1

        # 计算两组的平均功耗差异
        if group1_count > 0 and group2_count > 0:
            group1_avg = group1_sum / group1_count
            group2_avg = group2_sum / group2_count
            power_diff = group1_avg - group2_avg

            # 在关键的时间窗口（3000到6000之间）寻找最大差异
            key_guesses[target_byte][guess] = np.max(np.abs(power_diff[3000:6000]))

    # 找到每个字节的密钥猜测
    best_keys[target_byte] = np.argmax(key_guesses[target_byte])

# 输出整个第一轮的子密钥
print('Best key guess:',end='')
for i in range(16):
    print(hex(best_keys[i]), end=' ')

对于轮密钥的16个字节，每个字节逐个遍历。
然后经过SBOX得到中间值，根据中间值的最低位对1000条功耗曲线进行分类。
然后计算出两种类型的平均功耗的差值。
在第一轮 Subbytes 的时间窗口（3000-6000）寻找平均功耗的最大差值对应的字节作为猜测的密钥

运行结果

使用CPA方法攻击最后一轮轮密钥

关于CPA方法

**CPA（Correlation Power Analysis，相关功率分析）**攻击是一种侧信道攻击技术，利用硬件设备在执行加密操作时的功耗泄漏来推测加密算法的密钥。侧信道攻击不依赖于直接破解加密算法，而是通过外部信息（如功耗、电磁辐射、执行时间等）来获得密钥信息。

CPA 原理

功耗模型
假设设备的功耗 $P$ 与数据 $D$ 具有线性关系： $$ P = \alpha \cdot D + \beta + \epsilon $$ 其中：
- $\alpha$ 和 $\beta$：线性系数。
- $\epsilon$：噪声。
计算中间值： 根据明文和密钥猜测 $K$ 计算中间值： $$ V = SBOX(P_{\text{plaintext}}[i] \oplus K) $$ 然后计算中间值的特征（例如汉明重量或比特翻转数）： $$ H(V) = \text{HW}(V) $$ 其中 $\text{HW}(V)$ 表示汉明重量。
相关性分析：
通过统计分析功耗 $P$ 与特征值 $H(V)$ 的相关性： $$ \rho(P, H) = \frac{\text{cov}(P, H)}{\sigma_P \cdot \sigma_H} $$ 其中：
- $\text{cov}(P, H)$ 是 $P$ 和 $H$ 的协方差： $$ \text{cov}(P, H) = \frac{1}{N} \sum_{i=1}^N (P_i - \bar{P})(H_i - \bar{H}) $$
- $\sigma_P$ 和 $\sigma_H$ 分别是 $P$ 和 $H$ 的标准差。
最优密钥选择： 遍历所有可能的密钥 $K$，计算其相关性 $\rho$，取相关性最大的密钥作为猜测结果。

实现CPA方法

import numpy as np
from tqdm import trange
sbox = [
    # 0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f
    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,  # 0
    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,  # 1
    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,  # 2
    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,  # 3
    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,  # 4
    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,  # 5
    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,  # 6
    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,  # 7
    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,  # 8
    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,  # 9
    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,  # a
    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,  # b
    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,  # c
    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,  # d
    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,  # e
    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16  # f
]

inv_sbox = [
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
]


def aes_internal(inputdata, key):
    return inv_sbox[inputdata ^ key]


HW = [bin(n).count("1") for n in range(0, 256)]  # 计算汉明重量


def mean(X):  # 计算均值
    return np.mean(X, axis=0)


def std_dev(X, X_bar):  # 计算标准差
    return np.sqrt(np.sum((X-X_bar)**2, axis=0))


def cov(X, X_bar, Y, Y_bar): # 计算协方差
    return np.sum((X-X_bar)*(Y-Y_bar), axis=0)


def CPA(trace, textout_array): # CPA攻击
    cpa_correlation = [0]*16
    bestguess = [0]*16
    for byte in trange(16):
        trace_mean = np.average(trace, axis=0)
        trace_omega = np.sqrt(np.sum((trace - trace_mean)**2, axis=0)) # 计算标准差
        maxcpa = [0]*256
        for kguess in range(0, 256):
            hws = np.array([[HW[aes_internal(textout[byte], kguess)]
                           for textout in textout_array]]).transpose()
            hws_bar = mean(hws)
            o_hws = std_dev(hws, hws_bar)
            correlation = cov(trace, trace_mean, hws, hws_bar) # 计算协方差
            cpaoutput = correlation/(o_hws*trace_omega) # 计算相关系数
            maxcpa[kguess] = max(abs(cpaoutput)) # 取绝对值最大的相关系数
            bestguess[byte] = np.argmax(maxcpa) # 取相关系数最大的猜测值
            cpa_correlation[byte] = max(maxcpa) # 取相关系数最大的值
    print("Best Key Guess: ", end="")
    for i in range(16):
        print("%02x" % bestguess[i], end=" ")
    print()
    print("相关系数: ", cpa_correlation)


if __name__ == '__main__':
    trace = np.load("AES_tracesPart0.npy")
    trace_sbox_position = trace[:, 58000:61000]
    # textin_array=np.load("AES_textinPart0.npy")
    textout_array = np.load("AES_textoutPart0.npy")
    CPA(trace_sbox_position, textout_array)

遍历256个可能的轮密钥的值。
先将遍历的轮密钥的值与输出结果做异或得到中间值，将中间值的汉明重量存储到一个向量中。
然后计算汉明重量的平均值，方差，协方差和相关系数。
找到最大的相关系数对应的值作为猜测结果。
依次遍历16次得到轮密钥的16个字节。

运行结果

最后一轮 Subbytes 的时间窗口设置为 $(58000,61000)$，运行后得到的最后一轮的轮密钥为：

实验总结

通过本次实验，我深刻认识到了侧信道攻击（DPA 和 CPA）的强大威胁，这类攻击利用硬件泄露的信息（如功耗）即可恢复加密密钥，而无需破解算法本身。实验展现了攻击过程中统计分析的重要性，以及在硬件实现中避免信息泄露的紧迫性。这提醒我们，密码系统的设计不仅要注重算法安全性，更要考虑物理层面的防护措施。

实验前置说明#

绘制功耗曲线#

使用DPA方法攻击第一轮轮密钥#

关于DPA方法#

DPA 原理#

关键步骤：#

实现DPA方法#

运行结果#

使用CPA方法攻击最后一轮轮密钥#

关于CPA方法#

CPA 原理#

实现CPA方法#

运行结果#

实验总结#

实验前置说明

绘制功耗曲线

使用DPA方法攻击第一轮轮密钥

关于DPA方法

DPA 原理

关键步骤：

实现DPA方法

运行结果

使用CPA方法攻击最后一轮轮密钥

关于CPA方法

CPA 原理

实现CPA方法

运行结果

实验总结