学习笔记 on 安洛的小窝

Transformer 中的位置编码

Thu, 24 Jul 2025 07:55:02 +0000

封面图为原神 4 周年官方贺图。

本文旨在讨论Transformer中的几种位置编码，以直观感受其特性。本文对应此 Jupyter Notebook

环境准备

`1`	`import numpy as np`

首先生成一个模拟的tokens列表，为了突出位置编码的影响，tokens的初值为1。

dim = 2
len = 4
tokens = np.ones([len,dim])
print(tokens)

Output:

[[1. 1.]
 [1. 1.]
 [1. 1.]
 [1. 1.]]

位置编码

整型编码

直接使用数组下标标记位置。

1
2
3

int_pe = np.arange(0,len).reshape([len,1])
int_pe = np.broadcast_to(int_pe, [len,dim])
int_pe

Output:

array([[0, 0],
       [1, 1],
       [2, 2],
       [3, 3]])

1
2

int_pe_embed = np.add(tokens, int_pe)
int_pe_embed

Output:

array([[1., 1.],
       [2., 2.],
       [3., 3.],
       [4., 4.]])

非常直观的标记方法，缺点是随着tokens长度变长，位置编码会变得非常大

[0,1]浮点数编码

将数组下标压缩映射到[0,1]范围内以标记位置，避免位置编码过大的问题。

1
2
3

zeroone_pe = np.arange(0, 1, 1.0/len).reshape([len,1])
zeroone_pe = np.broadcast_to(zeroone_pe, [len,dim])
zeroone_pe

Output:

array([[0.  , 0.  ],
       [0.25, 0.25],
       [0.5 , 0.5 ],
       [0.75, 0.75]])

1
2

zeroone_pe_embed = np.add(tokens, zeroone_pe)
zeroone_pe_embed

Output:

array([[1.  , 1.  ],
       [1.25, 1.25],
       [1.5 , 1.5 ],
       [1.75, 1.75]])

确实解决了整数编码中位置编码过大的问题。然而，当序列长度不同时，tokens的相对距离会改变。这不是我们想要的。

二进制编码

考虑到tokens中是多维向量，比起为一个向量的每个维度都加相同的整数，为不同维度加上不同的位置编码可以容纳更多信息。因此考虑二进制编码，将下标转换为二进制向量作为位置编码。

def binary_vector_array(dim, length):
    if length > 2 ** dim:
        raise ValueError("length 不能超过 2^dim")
    result = np.empty((length, dim), dtype=int)
    for i in range(length):
        # 格式化为二进制字符串，前导0补齐
        bin_str = format(i, f'0{dim}b')
        result[i] = [int(bit) for bit in bin_str]
    return result

binary_PE = binary_vector_array(dim,len)
binary_PE

Output:

array([[0, 0],
       [0, 1],
       [1, 0],
       [1, 1]])

1
2

binary_PE_embed = np.add(tokens, binary_PE)
binary_PE_embed

Output:

array([[1., 1.],
       [1., 2.],
       [2., 1.],
       [2., 2.]])

比起前面几种做法，这种做法更加充分利用了向量的空间。然而，这种方式编码出来的位置向量在空间中是离散的。下面是二进制编码位置向量的绘图，每个向量被绘制为3维空间中的一个点。

import matplotlib.pyplot as plt

def PE_plt(points):
    fig = plt.figure()
    ax = fig.add_subplot(111)

    x = points[:, 0]
    y = points[:, 1]

    ax.scatter(x, y, c='r', marker='o')

    for idx, (xi,yi) in enumerate(points):
        ax.text(x=xi,y=yi, s=f'{idx}')

    ax.set_xlabel('X')
    ax.set_ylabel('Y')

    plt.show()

`1`	`PE_plt(binary_PE)`

Output:

`1`	`<Figure size 640x480 with 1 Axes>`

可以看到，位置1和位置2明明是相邻位置，其位置向量距离却很远。这对于模型学习相邻位置的关系是不利的。而且将这些点按顺序连接起来，不是一个连续可微的函数，这使得它很难泛化，例如很难处理浮点数位置。

sin 编码

从二进制编码位置向量离散的问题，想到采用高维空间上的连续函数作为编码。其中一种思路是使用 $\sin$ 编码。第 $t$ 个 token 的 $\sin$ 编码形式： $$ PE_t=[\sin(\frac{t}{2^0}),\sin(\frac{t}{2^1}),…,\sin(\frac{t}{2^i}),…,\sin(\frac{t}{2^{dim-1}})] $$ 其中 $t$ 表示这是第 $t$ 个 token。

import math

sin_PE = np.empty([len,dim])
for t in range(len):
    sin_PE[t] = [math.sin(t/2**i) for i in range(dim)]

sin_PE

Output:

array([[0.        , 0.        ],
       [0.84147098, 0.47942554],
       [0.90929743, 0.84147098],
       [0.14112001, 0.99749499]])

可以看到，在 $\sin$ 编码中，越低维度的向量变化越剧烈，越高维度的向量变化越平缓。这和二进制编码正好相反，但是思路其实是一样的，和前面整型编码中所有维度向量以相同速度变化形成对比。

1
2

sin_PE_embed = np.add(tokens, sin_PE)
sin_PE_embed

Output:

array([[1.        , 1.        ],
       [1.84147098, 1.47942554],
       [1.90929743, 1.84147098],
       [1.14112001, 1.99749499]])

下面是 $\sin$ 编码的绘图

`1`	`PE_plt(sin_PE)`

Output:

`1`	`<Figure size 640x480 with 1 Axes>`

可以看到，这个就没有距离突变，而且连接起来是一个连续可微的函数。不过，起始位置和结束位置离得太近，如果 tokens 继续增加，甚至有可能重合。要解决这个问题，只需要增大 $\sin$ 函数的周期。例如，采用 $\sin(\frac{t}{10000^{\frac{i}{dim-1}}})$

Sinusoidal 编码

这是原始 Transformer 论文中采用的编码方法。Sinusoidal 编码在 $\sin$ 编码的基础上，额外希望解决一个问题：能否使得已知位置 $t$ 的编码 $PE_t$ 和距离 $\Delta t$，通过线性变化就可以算出 $PE_{t+\Delta t}$？即满足： $$ PE_{t+\Delta t} = T_{\Delta t}PE_{t} $$ 其中 $T_{\Delta t}$ 是一个线性变化矩阵。

这样可以更清晰地编码 tokens 之间的相对位置，同时也有利于计算优化。

观察上述等式，可以联想到旋转矩阵。令

$$ T_{\Delta t} = \begin{pmatrix} \cos{\Delta t}&\sin{\Delta t}\\ -\sin{\Delta t}&\cos{\Delta t} \end{pmatrix}\\ PE_t = \begin{pmatrix} \sin{t}\\ \cos{t} \end{pmatrix} $$

则

$$ \begin{pmatrix} \sin(t+\Delta t)\\ \cos(t+\Delta t) \end{pmatrix}= \begin{pmatrix} \cos{\Delta t}&\sin{\Delta t}\\ -\sin{\Delta t}&\cos{\Delta t} \end{pmatrix} \begin{pmatrix} \sin{t}\\ \cos{t} \end{pmatrix} $$

模仿 $\sin$ 编码的方式，扩展到多维，则有 $$ PE_t = [\sin(w_0t), \cos(w_0t), \sin(w_1t), \cos(w_1t), …] $$ 在 Sinusoidal 编码中，采用 $$ PE_t = \begin{cases} \sin(\frac{t}{10000^{\frac{i}{dim}}}) & i=2k, k\in N \\ \cos(\frac{t}{10000^{\frac{i-1}{dim}}}) & i=2k+1, k\in N \end{cases} $$ Sinusoidal编码要求向量维度必须是偶数。

dim = 2
def gen_Sinusoidal_PE(len,dim):
    Sinusoidal_PE = np.empty([len, dim])
    for t in range(len):
        Sinusoidal_PE[t] = [math.sin(t/10000**(i/dim)) if i%2==0 else math.cos(t/10000**((i-1)/dim)) for i in range(dim)]
    return Sinusoidal_PE
Sinusoidal_PE = gen_Sinusoidal_PE(len,dim)
Sinusoidal_PE

Output:

array([[ 0.        ,  1.        ],
       [ 0.84147098,  0.54030231],
       [ 0.90929743, -0.41614684],
       [ 0.14112001, -0.9899925 ]])

1
2

Sinusoidal_PE_embed = np.add(tokens, Sinusoidal_PE)
Sinusoidal_PE_embed

Output:

array([[1.        , 2.        ],
       [1.84147098, 1.54030231],
       [1.90929743, 0.58385316],
       [1.14112001, 0.0100075 ]])

绘图如下：

`1`	`PE_plt(Sinusoidal_PE)`

Output:

`1`	`<Figure size 640x480 with 1 Axes>`

和 $\sin$ 编码的图像有点像，毕竟都是三角函数。

Sinusoidal 编码还有一些其它优异性质。例如两个位置向量的点积只取决于 $\Delta t$，即两个位置向量的点积可以反映其距离。同时这个点积是无向的。下图展示了一个 Sinusoidal 编码中，中间位置编码和其它位置编码的点积结果。

orig_len = len
len = 9
Sinusoidal_PE = gen_Sinusoidal_PE(len, dim)
Sinusoidal_PE_dot_product = [np.dot(Sinusoidal_PE[i], Sinusoidal_PE[len//2]) for i in range(len)]
plt.plot(Sinusoidal_PE_dot_product, marker='o')
plt.xlabel("pos")
plt.ylabel("dot product")
plt.show()
len = orig_len

Output:

`1`	`<Figure size 640x480 with 1 Axes>`

RoPE编码

RoPE是目前最流行的位置编码之一。

Sinusoidal 编码尽管生成的位置向量隐含了相对位置信息，拥有点积与距离有关的优秀特性，可是一但其位置向量加到 tokens 上，这个特性就消失了。那如果直接将旋转矩阵应用到 tokens 上呢？在RoPE编码中，不生成显式的位置向量，而是直接把旋转矩阵和 tokens 相乘。即： $$ x’_t = \begin{pmatrix} \cos{t\theta}&-\sin{t\theta}\\ \sin{t\theta}&\cos{t\theta} \end{pmatrix}x_t $$ 扩展到多维，自然就是更改 $\theta$ 为 $\theta_i$ 了。在 RoPE 中，令 $$ \theta_i = \begin{cases} \frac{1}{10000^{\frac{i}{dim}}} & i=2k, k\in N\\ \frac{1}{10000^{\frac{i-1}{dim}}} & i=2k+1, k\in N \end{cases} $$ 从而组合形成 $$ \begin{pmatrix} \cos{t\theta_0}&-\sin{t\theta_0}&0&0&\cdots\\ \sin{t\theta_0}&\cos{t\theta_0}&0&0&\cdots\\ 0&0&\cos{t\theta_1}&-\sin{t\theta_1}&\cdots\\ 0&0&\sin{t\theta_1}&\cos{t\theta_1}&\cdots\\ \cdots&\cdots&\cdots&\cdots&\ddots \end{pmatrix} $$ 这样的形式。

RoPE_embed = np.empty([len, dim])
for t in range(len):
    RoPE = np.array([[math.cos(t/(10000**(0/dim))), -math.sin(t/(10000**(0/dim)))],[math.sin(t/(10000**(0/dim))), math.cos(t/(10000**(0/dim)))]])
    print(RoPE)
    RoPE_embed[t] = np.matmul(RoPE, tokens[t].T).T
RoPE_embed

Output:

[[ 1. -0.]
 [ 0.  1.]]
[[ 0.54030231 -0.84147098]
 [ 0.84147098  0.54030231]]
[[-0.41614684 -0.90929743]
 [ 0.90929743 -0.41614684]]
[[-0.9899925  -0.14112001]
 [ 0.14112001 -0.9899925 ]]

array([[ 1.        ,  1.        ],
       [-0.30116868,  1.38177329],
       [-1.32544426,  0.49315059],
       [-1.1311125 , -0.84887249]])

`1`	`PE_plt(RoPE_embed)`

Output:

`1`	`<Figure size 640x480 with 1 Axes>`

当然实际的 RoPE 编码不会像上面那样实现，而且在 Transformer 中，一般对 q, k 向量进行位置嵌入，而不是直接对原始 token 进行位置嵌入。详情可参考 LLAMA 的实现：https://github.com/meta-llama/llama-models/blob/a9c89c471f793423afd4cc3ca8671d6e56fe64cb/models/llama4/model.py#L89

为什么对 $q$, $k$ 向量进行位置嵌入呢？刚刚提到，RoPE 编码想要使得编码后的向量内积和距离相关。在 Transformer 中，q 和 k 向量正好需要进行内积操作： $$ Attention(q,k,v) = softmax(\frac{qk^t}{\sqrt{d_k}})v $$ 因此，在 $Attention$ 操作前对 $q$ 和 $k$ 向量进行 RoPE 编码，$qk^t$ 就隐含了相对位置信息，从而使得 $Attention$ 也隐含了相对位置信息。

缓冲区溢出漏洞及缓解机制

Wed, 20 Nov 2024 16:37:15 +0800

封面图：https://www.bilibili.com/opus/993288080028860441

引言

迄今为止，缓冲区溢出已被识别为最常见且最危险的漏洞。根据 2019 年通用漏洞和暴露（CVE）列表，它是报告频率最高的漏洞，报告了超过 400 个漏洞。截至 2021 年 5 月，CVE 数据库中报告的缓冲区溢出漏洞数量已达到 13,700 多个。在所有缓冲区溢出漏洞中，基于栈的缓冲区溢出是最常见的类型。本文将介绍各种用于缓解缓冲区溢出漏洞的机制和它们的绕过方法，并介绍最近的一个栈溢出漏洞 CVE-2024-9632。

基于硬件的缓解技术

基于硬件的缓解技术中，最著名的就是 NX（No-eXecute）技术。NX 技术是一种硬件支持的内存保护技术，它通过在内存页表中设置一个标志位来防止代码执行。当试图执行一个被标记为不可执行的内存区域时，CPU 会产生一个异常，从而阻止攻击者执行恶意代码。还有一些其它的研究工作，如 SmashGuard 通过在 CPU 上实现一个硬件堆栈来保存返回地址，HSDefender 通过设计安全的call指令来防止栈溢出攻击等。以下主要介绍 NX 技术。

NX技术

在冯诺依曼架构中，使用相同的内存空间来存储代码和数据。这是通过分页来实现的，但分页机制不允许用户在特定内存区域上独立设置读写和执行权限，而仅允许三种权限：non-accessible、readable-executable（RX）和 readablewriteable-executable（RWX）。因此，如果页面设置了可读写，那么它就一定是可执行的。攻击者可以利用这一点，将恶意代码注入到内存中，并通过覆盖返回地址的方式来执行恶意代码。为了解决这个问题，NX技术被引入到现代 CPU 中。

操作系统可以通过操作NX位来将某些内存区域标记为不可执行。NX 的位号是 63，这是页表中最高有效位。如果特定页面的 NX 位设置为 0，则可以执行该代码；如果设置为 1，则它是仅包含数据的不可执行页面。NX（no-execute）功能仅适用于 64 位模式。NX 功能的一个重要之处在于它是运行时策略，应用无需重新编译即可从此功能中受益。操作系统利用 NX 位将堆栈/堆内存标记为不可执行，从而防止了相当一部分利用缓冲区溢出的代码注入攻击。

NX技术的绕过

为了绕过 NX 技术，一种常见的思路是代码重用攻击。代码重用攻击是一种利用程序中已有的代码片段来实现攻击目的的攻击方式。这种攻击方式不需要向内存中注入恶意代码。ROP攻击是一种高级形式的代码重用攻击。以下介绍 ROP 攻击的基本原理。

ROP攻击

ROP 使用预先存在的名为 “gadgets” 的小指令序列来实施攻击。这些 gadgets 是结合在一起可以执行高级任务的短指令序列。gadgets 必须是有效的以返回指令结尾指令序列，从而让 CPU 继续执行下一个 gadgets 或有效载荷。在发起攻击时，攻击者通常会用跳转到第一个 gadgets 的代码指针覆盖堆栈上保存的返回地址。ROP 攻击的流程图如下：

常见的可用于 ROP 攻击的 gadgets 包括 pop rdi; ret 和 system() 等。system() 函数可以执行系统命令，而 pop rdi; ret 可以将参数传递给 system() 函数。通过将这两个 gadgets 结合在一起，攻击者可以执行任意系统命令。在查找 gadgets 的步骤，攻击者可以通过各种调试器和反汇编工具来在二进制文件中查找这些指令。

基于操作系统的缓解技术

有许多基于操作系统的缓解技术。例如 libsafe 通过修改标准库来提供更安全的函数，地址混淆和二进制搅拌技术都是在加载时对目标二进制文件进行修改，以使攻击者难以找到目标函数的地址。而最常见的基于操作系统的缓解技术是 ASLR 技术。以下主要介绍 ASLR 技术。

ASLR技术

在上文中介绍了 ROP，其必须知道 gadgets 的地址。ASLR随机化进程各个部分的基址，包括堆栈、堆、共享库和可执行文件。因此，攻击者不能每次都使用相同的漏洞来滥用相同的易受攻击的程序。每次程序运行时，系统会将程序的代码段、堆、栈以及动态库加载到不同的随机地址。攻击者无法直接预测这些关键区域的精确地址，从而难以利用固定地址的内存漏洞。

ASLR技术的绕过

在 32 位系统中，ASLR 技术的绕过相对容易，因为 32 位系统的内存地址空间相对较小，ASLR 的随机性有限，地址中通常只有 8 或 16 位被随机化。攻击者可以通过不断尝试可能的内存地址来暴力破解 ASLR。在 64 位系统中，地址中有 40 位被随机化，因此暴力破解的难度大大增加。但是，攻击者仍然可以通过泄露内存地址和信息泄露等方式来绕过 ASLR。以下主要介绍信息泄露技术。

信息泄露技术

信息泄露技术的流程如下：

其中一种信息泄露方法是利用过程链接表（PLT）和全局偏移表（GOT）这两种数据结构。PLT 是一种数据结构，用于调用外部函数，这些函数的地址在运行时由动态链接器解析。GOT 是一个数组，其中包含进程当前使用的全局变量和库函数的绝对地址。当程序调用函数时，查找 PLT 中的条目，条目中包含跳转指令，可以跳转到 GOT 中的条目。GOT 调用动态链接器来获取函数地址并存储在自己的条目中，这样程序就可以通过函数地址来调用函数。如下图所示。

通过获取 PLT 和 GOT 中的地址，攻击者可以泄露程序中的地址信息，从而绕过 ASLR。具体地说，利用调试器可以获取某个函数的 PLT 地址，之后反汇编该地址的指令就能获得 GOT 的地址。通过获得 GOT 中的地址，攻击者可以获取到函数的绝对地址。之后通过库文件来获取其它函数和该函数的相对偏移，就可以利用该函数的地址加上相对偏移来调用任意库函数。

另外，printf() 函数也是一个常用的信息泄露工具。如果攻击者可以修改 printf() 函数的格式控制字符串，就可以泄露栈上的数据。例如，通过 %lx 格式控制字符，攻击者就可以获得泄露的内存地址。

基于编译器的缓解技术

有许多缓解技术在编译器这一层面实现。其中一些可视为对基于操作系统和硬件的缓解技术的补充。例如，PIC 技术将代码编译为位置无关的机器码指令，从而让这些指令可以被加载到任意地址；PIE 技术编译出的可执行文件的不同部分可以使用不同的基址，从而增加了攻击者猜测基址的难度。这两个技术都是 ASLR 的补充。另一些技术则从其它方面进行保护，例如 StackGuard, ProPolice, Address Sanitizer 等。基于编译器的缓解技术很多，且大多数都在主流编译器中有广泛应用，无法一一列举，以下主要介绍 RELRO 和 StackGuard 两种技术。

RELRO技术

RELRO 技术是一种保护机制，用于防止全局偏移表（GOT）被攻击者利用。在首次调用共享库函数时，动态链接器会将 GOT 表中的地址填充为真实地址。也就是说，GOT 表在程序运行时是可写的。并且，GOT 表需要位于已知位置，因为它包含了程序运行时的必要信息。这给了攻击者一个机会，可以通过覆盖 GOT 表中的地址来执行恶意代码。

RELRO 技术通过将 GOT 表标记为只读来解决这个问题。RELRO 技术有两种类型：Partial RELRO 和 Full RELRO。Partial RELRO 会在程序启动时将 GOT 表的部分标记为只读，通常只保护不频繁改变的全局变量和一些只读数据段。动态链接中的某些函数指针仍可能被攻击者利用。Full RELRO比Partial RELRO更安全，它会在程序加载完成后，将整个GOT段标记为只读。所有GOT表项，包括动态链接的函数指针，都会被标记为只读，彻底防止了指针修改。其缺点是对程序启动速度影响较大，因为它要求在程序运行前完成所有符号解析。

RELRO技术的绕过

RELRO 技术的绕过方法主要针对 Partial RELRO。对于 Partial RELRO，动态链接中的某些函数指针未受保护，例如 printf() 函数。可以通过覆写 GOT 表中的 printf() 函数指针来执行任意代码。

StackGuard 技术

StackGuard 通过在返回地址旁边插入一个“护符”（Canary）来防止返回地址被修改。该护符将会挡在缓冲区和返回地址之间。在函数体执行完毕后，控制返回前，它会将护符与保存在其它位置的副本进行比较，只有当护符保持不变时，才会跳转到函数的返回地址。在常规的栈溢出攻击中，攻击者采用的方法是线性、顺序且按升序覆盖字节。这使得在不覆盖护符的情况下改变返回地址几乎不可能。

StackGuard 技术的绕过

绕过 StackGuard 技术的主要思路是想办法找到护符的值。刚刚提到，护符位于缓冲区和返回地址之间的某个位置，同时在其它位置还会有护符的副本；在程序返回时，为了检查护符是否被篡改，护符通常还会被加载到寄存器中。这些情况为信息泄露攻击提供了机会。通过信息泄露攻击，攻击者可以获取到护符的值，从而绕过 StackGuard 技术。

漏洞 CVE-2024-9632 介绍

CVE-2024-9632 漏洞是一个缓冲区溢出漏洞。该漏洞存在于 xorg-xserver 中。该软件是 Linux 系统下最常见的显示服务器，用于管理图形显示设备。本地攻击者可以通过利用该漏洞发起拒绝服务攻击，如果 xorg-xserver 以 root 权限运行，攻击者还能获得提升的权限，甚至完全控制系统。该漏洞被标记为高危险性。

漏洞原理

产生漏洞的代码如下：

        XkbSymInterpretPtr sym;
        unsigned int skipped = 0;

        if ((unsigned) (req->firstSI + req->nSI) > compat->num_si) {
            compat->num_si = req->firstSI + req->nSI;
            compat->sym_interpret = reallocarray(compat->sym_interpret,
                                                 compat->num_si,
                                                 sizeof(XkbSymInterpretRec));
            if (!compat->sym_interpret) {
                compat->num_si = 0;
                return BadAlloc;
            }
        }

其中，compat->sym_interpret 是一个数组，存储了 XkbSymInterpretRec 类型的结构体，每个结构体表示一种键盘符号（symbol）与修饰符（modifier）组合的解释方式。该解释方式用于决定在特定符号与修饰符输入下应该执行的操作，例如：

激活一个功能键。
触发一个特定的动作（如执行 XFree86 私有动作 XkbSA_XFree86Private）。

而 compat->num_si 是一个整型变量，记录当前 compat->sym_interpret 数组中元素的个数。

在这段代码中没有出现的还有一个变量，那就是 compat->size_si。该变量用于记录 compat->sym_interpret 数组的容量。它和 compat->num_si 的区别在于，compat->num_si 记录的是当前数组中的元素个数，而 compat->size_si 记录的是数组的容量。也就是说，在理想情况下，compat->num_si 应该永远小于等于 compat->size_si。当 compat->num_si 等于 compat->size_si 时，表示数组已满。

xorg-xserver 允许客户端发起更新 compat->sym_interpret 数组的请求。请求中的 firstSI 和 nSI 字段分别表示要更新的数组元素的起始位置和更新的元素个数。当它们之和超过了当前元素个数时，表示客户端需要增加数组的大小。reallocarray 函数会重新分配内存，以容纳新的元素。这就是这段代码的主要工作。

然而，这段代码中仅仅更新了 compat->num_si，而没有更新 compat->size_si。这样就可能不再满足上文提到的 compat->num_si 应永远小于等于 compat->size_si 的假设。在之后，它调用 reallocarray 将 compat->sym_interpret 调整为了 compat->num_si 的大小。这就导致数组被分配到的内存空间超过了它本应占有的内存空间 compat->size_si，从而导致了缓冲区溢出漏洞。攻击者可以通过构造一个特别长的更新请求来触发这个漏洞。

防御措施

以下是修复补丁，相关链接

@@ -2990,13 +2990,13 @@ _XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
         XkbSymInterpretPtr sym;
         unsigned int skipped = 0;
 
-        if ((unsigned) (req->firstSI + req->nSI) > compat->num_si) {
-            compat->num_si = req->firstSI + req->nSI;
+        if ((unsigned) (req->firstSI + req->nSI) > compat->size_si) {
+            compat->num_si = compat->size_si = req->firstSI + req->nSI;
             compat->sym_interpret = reallocarray(compat->sym_interpret,
-                                                 compat->num_si,
+                                                 compat->size_si,
                                                  sizeof(XkbSymInterpretRec));
             if (!compat->sym_interpret) {
-                compat->num_si = 0;
+                compat->num_si = compat->size_si = 0;
                 return BadAlloc;
             }
         }

从补丁文件中可以看出，主要的修复措施是在更新 compat->num_si 时，同时更新 compat->size_si。这样就保证了 compat->sym_interpret 数组的大小不会超过它的容量。

总结

本文介绍了缓冲区溢出漏洞的概念，以及各种缓解缓冲区溢出漏洞的技术。其中，NX 技术通过将内存区域标记为不可执行来防止代码注入攻击；ASLR 技术通过随机化进程各个部分的基址来增加攻击者猜测基址的难度；RELRO 技术通过将 GOT 表标记为只读来防止攻击者利用 GOT 表；StackGuard 技术通过在返回地址旁边插入一个护符来防止返回地址被修改。最后，本文介绍了一个最近的栈溢出漏洞 CVE-2024-9632 的原理和修复措施。可以看到，尽管有了这些防御措施，但仍然有很多方法可以绕过这些技术，而错误的代码实现也会导致漏洞的产生。现有的漏洞缓解技术仍有很大提升空间，值得进一步研究。同时开发者也应该在编写代码时遵循安全编程规范，同时关注最新的漏洞信息，及时修复已知的漏洞。

一道关于内存分配的题

Thu, 26 Jan 2023 15:54:53 +0800

封面图：https://www.pixiv.net/artworks/95681846

曾经我以为没有递归的程序阅读题都是渣渣，直到……

题目描述

下面代码进行数组与指针的操作，已知&score[0]的值为 0x00FF2000。

#include <stdio.h>
int main()
{
short int *p1;
long int *p3;
short int score[10] = { 1,2,3,4,5,6,7,8,9 };
p1 = score;
p3 = (long int*)score;
printf("%p, %p\n", p1 + 1, p3 + 1);
printf("%d, %d\n", *p1, *p3);
return 0;
}

(1) 请说明数组名score 的含义。

(2) 写出程序执行结果。

非官方答案：

(1)指向数组score头元素的指针
(2)
0x00FF2002 0x00FF2004
1 131073

注：在64位linux系统上时，第一个printf输出的第二个数应为0x00FF2008

题目详解

首先第一小题完全莫名其妙，不讲。

有意思的是第二小题，这个程序有两个printf语句，第一个printf主要考察指针运算。众所周知，假设指针的类型长度为n，那么指针加k，指针实际移动n*k。在本例中，指针p1的类型是short int *，short int的类型长度是2个字节，此处p1+1，实际地址增加2，即0x00FF2002。p3+1同理。但是这里有个小坑，long int 在64位linux系统上是8个字节，在windows上是4个字节。实际考试中应指定long int长度。

第二个printf语句是输出两个指针对应的内容。我们先忽略格式控制符，看后面的两个参数。第一个参数是*p1，又因为p1=score，p1和score都是short int *类型，所以毫无疑问这里是取score[0]，也就是1。第二个参数是*p3，也有p3=score，但是p3是long int *，在它执行*运算的时候会一次取long int长度的内容，也就是取4个字节。然而，一个short int类型只占2个字节，所以这里发生了访问溢出。那么这里到底取出来了什么呢？这就需要从内存里分析了。

程序内存分配分析

相信大家都很熟悉下面这张图：这张图展示了计算机内存分配的顺序。我们知道，对于局部变量，系统在栈区从高地址向低地址分配内存。而在数组内部则是从低地址向高地址分配内存。因此变量相对位置如表：

内存内容	内存属主
0x00FF2000	p1
0x00FF2000	p3
未知	score[9]
9	score[8]
8	score[7]
7	score[6]
6	score[5]
5	score[4]
4	score[3]
3	score[2]
2	score[1]
1	score[0]

当进行*p3操作时，从低地址向高地址进行操作，取出的即为score[0]和score[1]占用的内存空间。

计算机中的整数

一般来说，整数以补码的形式存储在内存中。

正数的补码等于其原码，负数的补码等于模减去其绝对值的原码

考虑到short int 占两个字节，也就是16位二进制，4位十六进制，那么可以得到：

1
2

(short int)1=0000000000000001B=0001H
(short int)2=0000000000000010B=0002H

在常用家用计算机（小端机）中，数字高位存储在高地址，低位存储在低地址，在虚拟内存中，最小操作单位是字节，也即两位16进制。因此在虚拟内存中存储情况类似：

内存内容
高地址
00H
02H
00H
01H
低地址

回到`*p3`

当*p3取数时，取出的即为上面这一串十六进制。我们按我们习惯的高位在前进行拼接，最终结果就是00020001H，即131073。除此之外，我们还需要关注格式控制符。幸运的是，这里的格式控制符是%d，在Windows平台下刚好能够兼容*p1和*p3，因此没有什么问题。于是我们能够得出最后的结果：

`1`	`1 131073`

总结

其实这是一道非常简单的关于内存分配的题目，不过涉及到比较复杂的内存分配机制问题，所以记个笔记来记录一下。

学习笔记 on 安洛的小窝

Transformer 中的位置编码

环境准备

位置编码

整型编码

[0,1]浮点数编码

二进制编码

sin 编码

Sinusoidal 编码

RoPE编码

缓冲区溢出漏洞及缓解机制

引言

基于硬件的缓解技术

NX技术

NX技术的绕过

ROP攻击

基于操作系统的缓解技术

ASLR技术

ASLR技术的绕过

信息泄露技术

基于编译器的缓解技术

RELRO技术

RELRO技术的绕过

StackGuard 技术

StackGuard 技术的绕过

漏洞 CVE-2024-9632 介绍

漏洞原理

防御措施

总结

一道关于内存分配的题

题目描述

题目详解

程序内存分配分析

计算机中的整数

回到*p3

总结

回到`*p3`