copy failed 原理详解
Copy Fail (CVE-2026-31431) 是 Linux 内核身份验证加密模块中的一个逻辑错误。它允许**非特权用户向任意可读文件的页缓存中写入 4 字节的任意数据,并且支持多次写入**
Copy Fail (CVE-2026-31431) 是 Linux 内核身份验证加密模块中的一个逻辑错误。它允许非特权用户向任意可读文件的页缓存中写入 4 字节的任意数据,并且支持多次写入。
内核不会将被写入的文件页标记为脏页并进行写回,因此不会修改硬盘上的数据。但是,实际访问文件时读取的是内存中的页缓存,因此内存中文件页的损坏会影响实际文件的运行。
exploit c语言版:https://github.com/tgies/copy-fail-c
AFL_SOCKET
具体使用参考内核文档 https://www.kernel.org/doc/html/v6.1/crypto/userspace-if.html
afl_socket是内核提供给用空间的一组加密API,用户可以在参数中指定加密算法,并通过内核API将请求传递给内核进行实现。可以使用加密算法有:
- 消息摘要,包括密钥消息摘要(HMAC、CMAC)
- 对称密码
- AEAD密码
- 随机数生成器
用户空间接口允许就地执行加密操作。这意味着用于 write/send系统调用的输入缓冲区和用于 read/recv 系统调用的输出缓冲区可以是同一个。
交互方式
我们必须使用socket来与API进行交互,使用 socket 函数需要指定类型为 AF_ALG。使用 setsockopt 函数需要指定协议层为 SOL_ALG。
#ifndef AF_ALG
#define AF_ALG 38
#endif
#ifndef SOL_ALG
#define SOL_ALG 279
#endif用户必须创建一个 socket,然后使对 socket 使用 send()/write() 系统调用来进行加密或解密操作,使用 read()/recv() 系统调用来获取结果。
创建方式
int ctrl_sock = -1, op_sock = -1, pipefd[2] = { -1, -1 };
int rc = -1;
ctrl_sock = socket(AF_ALG, SOCK_SEQPACKET, 0);
if (ctrl_sock < 0) { perror("socket(AF_ALG)"); goto out; }
struct sockaddr_alg sa = { .salg_family = AF_ALG };
memcpy(sa.salg_type, "aead", 5);
memcpy(sa.salg_name, "authencesn(hmac(sha256),cbc(aes))",
sizeof "authencesn(hmac(sha256),cbc(aes))");
if (bind(ctrl_sock, (struct sockaddr *)&sa, sizeof sa) < 0) {
perror("bind(AF_ALG: authencesn(hmac(sha256),cbc(aes)))");
goto out;
}
if (setsockopt(ctrl_sock, SOL_ALG, ALG_SET_KEY,
AUTHENC_KEY, sizeof AUTHENC_KEY) < 0) {
perror("setsockopt(ALG_SET_KEY)"); goto out;
}
if (setsockopt(ctrl_sock, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 4) < 0) {
perror("setsockopt(ALG_SET_AEAD_AUTHSIZE)"); goto out;
}
op_sock = accept(ctrl_sock, NULL, 0);
if (op_sock < 0) { perror("accept(AF_ALG)"); goto out; }使用 socket 获得一个 afl_socket 的文件描述符,并填充 struct sockaddr_alg ,使用 bind 对 socket 进行初始化。当使用 AEAD时,必须使用 setsockopt 调用设置认证标签大小和密钥。配置好后,需要通过 accept() 生成一个用于实际数据操作的 socket。
AEAD 原理
AEAD(Authenticated Encryption with Associated Data,带关联数据的认证加密)是一种同时保证数据机密性和完整性的加密模式。
在 AEAD 中,有以下几个核心输入:
- Key (密钥) 和 IV (初始化向量)。
- Plaintext (明文):需要被加密并保护的数据。
- AAD (关联数据):不需要加密(保持明文),但必须参与完整性校验的数据(例如网络包头、协议版本号)。
加密后的输出是:Ciphertext (密文) + Tag/MAC (认证标签)。解密时,如果密文或 AAD 被篡改了,Tag 校验就会失败。
内核中 AEAD API实现
用户可以通过前面提的 socket 接口 (AF_ALG) 实现 AEAD 的加密和解密操作。下面是 AF_ALG 的整体生命周期,
- 绑定算法:用户态先创建一个基础套接字,并通过 bind 指定 AEAD 算法的类型如 authencesn(hmac(sha256),cbc(aes))
- 设置密钥:用户态通过 setsockopt 系统调用,将密钥(Key)传递给内核,并被内核保存在这个基础套接字的上下文中
- 建立会话:用户态对这个基础套接字(可以理解为一个模板)调用 accept()。这会返回一个新的“操作套接字”用于实际的加密解密操作
- 发送数据:使用 sendmsg向发送“操作套接字”加密或解密需要的数据,内核在底层会自动关联到之前设置好的密钥。
加密时的输入和输出:
通过sendmsg 让内核把 [ AAD | Plaintext ] 拷贝进内核物理页,后续当用户调用 recvmsg 读取时,内核会进行加密操作最终返回 [ AAD | Ciphertext | Auth Tag ]
- 关联数据 (AAD):
- 这是不需要加密,但必须参与防篡改校验的数据(比如 TCP/IP 包头、协议版本号)。
- 长度可由用户自行设置
- 明文 (Plaintext):
- 真正需要被加密成乱码的核心数据。
[ AAD | Plaintext ] => [ AAD | Ciphertext | Auth Tag ]
解密时的输入和输出:
内核通过sendmsg 把这段 [ AAD | Ciphertext | Auth Tag ] 完整地拷贝进内核物理页。 后续当用户调用 recvmsg 尝试读取时,内核会先用 Key、IV 和 AAD 来进行解密并核对 Auth Tag:
- 如果 Tag 匹配:说明数据没被篡改,内核解密出明文,并将明文返回给用户。
- 如果 Tag 不匹配:内核直接拒绝解密,recvmsg 返回错误(通常是 -EBADMSG)。
- 关联数据 (AAD):与加密时完全相同的 AAD。
- 密文 (Ciphertext):加密后生成的乱码数据。
- 认证标签 (Auth Tag / MAC):
- 这是 AEAD 加密时生成的校验码(通常是 16 字节)。在 Linux Crypto API 中,Tag 通常被直接追加在密文的末尾。
[ AAD | Ciphertext | Auth Tag ] => [ AAD | Plaintext ]
内核态的实现
内核中 aead_sendmsg 用于解析并保存配置指令和接收并缓冲用户数据
static int aead_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
{
struct sock *sk = sock->sk;
struct alg_sock *ask = alg_sk(sk);
struct sock *psk = ask->parent;
struct alg_sock *pask = alg_sk(psk);
struct aead_tfm *aeadc = pask->private;
struct crypto_aead *tfm = aeadc->aead;
unsigned int ivsize = crypto_aead_ivsize(tfm);
return af_alg_sendmsg(sock, msg, size, ivsize);
}其实是 af_alg_sendmsg 的封装
- 调用 af_alg_cmsg_send 从控制消息中提取控制信息,存储在 配置上下文变量 con 中
- 将配置上下文写入 ctx 中
- 将用户态传来的数据,拉取到内核空间。为了高效管理内存,内核使用了散列表 (Scatterlist) 将物理上可能不连续的内存页串联起来,在此处分为两条路径
- 追加到现有页:如果 ctx->merge 标志为真,内核为了节省内存,会继续把新数据拼接到那一页的末尾。memcpy_from_msg 负责从用户空间安全地拷贝数据。
- 分配新页:如果没有空余空间,内核会申请全新的物理页,将其挂载到散列表中,然后再把用户数据拷贝进来
- 最后检查用户传入的系统标志,如果设置了 MSG_MORE,ctx->more 就会被置为真,告知内核还有数据,此时不会触发实际的加密/解密引擎,而是直接解锁并返回。
<!-- 散列表可以理解为一个 SG 数组链表,每个链表节点都包含了一组 SG 数组
struct af_alg_tsgl {
struct list_head list; /* 空间不够时再申请一组数组,并通过 list 链接起来
unsigned int cur; /* 最后一个 SG 条目*/
struct scatterlist sg[]; /* SG 数组 */
};而 SG 其实就是一个记录数据信息的结构体
struct scatterlist {
unsigned long page_link;
unsigned int offset;
unsigned int length;
dma_addr_t dma_address;
#ifdef CONFIG_NEED_SG_DMA_LENGTH
unsigned int dma_length;
#endif
};- page_link:数据所在页的 page 指针,这里申明为 unsigned long 是为了对内存进行标记,如果最低位是 1,说明这是当前数组的最后一个节点,如果次低位是 1,说明这个节点里存的不是物理页,而是一个指向下一个散列表数组的指针
- offset(偏移量):数据在这 4KB 页面内部的起始起点。
- length(长度):数据的具体大小。-->
int af_alg_sendmsg(struct socket *sock, struct msghdr *msg, size_t size,
unsigned int ivsize)
{
struct sock *sk = sock->sk;
struct alg_sock *ask = alg_sk(sk);
struct af_alg_ctx *ctx = ask->private;
struct af_alg_tsgl *sgl;
struct af_alg_control con = {}; // 配置上下文
long copied = 0;
bool enc = false;
bool init = false;
int err = 0;
//=============== 解析控制信息=======================
if (msg->msg_controllen) {
err = af_alg_cmsg_send(msg, &con);
if (err)
return err;
init = true;
switch (con.op) {
case ALG_OP_ENCRYPT:
enc = true;
break;
case ALG_OP_DECRYPT:
enc = false;
break;
default:
return -EINVAL;
}
if (con.iv && con.iv->ivlen != ivsize)
return -EINVAL;
}
//============== 状态校验与上下文更新 =================
lock_sock(sk);
if (ctx->init && !ctx->more) {
if (ctx->used) {
err = -EINVAL;
goto unlock;
}
pr_info_once(
"%s sent an empty control message without MSG_MORE.\n",
current->comm);
}
ctx->init = true;
if (init) {
ctx->enc = enc;
if (con.iv)
memcpy(ctx->iv, con.iv->iv, ivsize);
ctx->aead_assoclen = con.aead_assoclen;
}
//============== 核心数据拷贝循环 =================
while (size) {
struct scatterlist *sg;
size_t len = size;
size_t plen;
// 1. 追加到现有页
if (ctx->merge) {
sgl = list_entry(ctx->tsgl_list.prev,
struct af_alg_tsgl, list);
sg = sgl->sg + sgl->cur - 1;
len = min_t(size_t, len,
PAGE_SIZE - sg->offset - sg->length);
err = memcpy_from_msg(page_address(sg_page(sg)) +
sg->offset + sg->length,
msg, len);
if (err)
goto unlock;
sg->length += len;
ctx->merge = (sg->offset + sg->length) &
(PAGE_SIZE - 1);
ctx->used += len;
copied += len;
size -= len;
continue;
}
if (!af_alg_writable(sk)) {
err = af_alg_wait_for_wmem(sk, msg->msg_flags);
if (err)
goto unlock;
}
// 2. 申请新的内存页
len = min_t(unsigned long, len, af_alg_sndbuf(sk));
err = af_alg_alloc_tsgl(sk); // 如果散列表还没分配会在此处分配
if (err)
goto unlock;
sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl,
list);
sg = sgl->sg;
if (sgl->cur)
sg_unmark_end(sg + sgl->cur - 1);
do {
unsigned int i = sgl->cur;
plen = min_t(size_t, len, PAGE_SIZE);
sg_assign_page(sg + i, alloc_page(GFP_KERNEL));
if (!sg_page(sg + i)) {
err = -ENOMEM;
goto unlock;
}
err = memcpy_from_msg(page_address(sg_page(sg + i)),
msg, plen);
if (err) {
__free_page(sg_page(sg + i));
sg_assign_page(sg + i, NULL);
goto unlock;
}
sg[i].length = plen;
len -= plen;
ctx->used += plen;
copied += plen;
size -= plen;
sgl->cur++;
} while (len && sgl->cur < MAX_SGL_ENTS);
if (!size)
sg_mark_end(sg + sgl->cur - 1);
ctx->merge = plen & (PAGE_SIZE - 1);
}
err = 0;
//============== 保存标志位 =================
ctx->more = msg->msg_flags & MSG_MORE;
unlock:
af_alg_data_wakeup(sk);
release_sock(sk);
return copied ?: err;
}
EXPORT_SYMBOL_GPL(af_alg_sendmsg);接着通过 splice() 将只读文件页挂载到管道中,再从管道移动到 socket 中。在将只读文件页从管道移动到 socket 中时,内核会调用 af_alg_sendpage,直接把包含目标文件缓存的只读物理页的指针挂载到了 sg 中。
- 先获取 sgl,消除其 sg数组 中最后一个 sg 的 end 标记
- 再将我们的文件填入 sg数组 中,设置数据长度为我们 splice中传入的长度 ,并打上 end 标记
这里 0xffffea00001322c2 就是只读文件页 ,0x28 就是我们传入的长度
ssize_t af_alg_sendpage(struct socket *sock, struct page *page,
int offset, size_t size, int flags)
{
struct sock *sk = sock->sk;
struct alg_sock *ask = alg_sk(sk);
struct af_alg_ctx *ctx = ask->private;
struct af_alg_tsgl *sgl;
int err = -EINVAL;
if (flags & MSG_SENDPAGE_NOTLAST)
flags |= MSG_MORE;
lock_sock(sk);
if (!ctx->more && ctx->used)
goto unlock;
if (!size)
goto done;
if (!af_alg_writable(sk)) {
err = af_alg_wait_for_wmem(sk, flags);
if (err)
goto unlock;
}
//==============获取当前的散列表,并处理结尾标记=============
err = af_alg_alloc_tsgl(sk);
if (err)
goto unlock;
ctx->merge = 0;
sgl = list_entry(ctx->tsgl_list.prev, struct af_alg_tsgl, list);
if (sgl->cur)
sg_unmark_end(sgl->sg + sgl->cur - 1);
sg_mark_end(sgl->sg + sgl->cur);
//===============将文件页填入散列表================
get_page(page);
sg_set_page(sgl->sg + sgl->cur, page, size, offset);
sgl->cur++;
ctx->used += size;
done:
ctx->more = flags & MSG_MORE;
unlock:
af_alg_data_wakeup(sk);
release_sock(sk);
return err ?: size;
}
EXPORT_SYMBOL_GPL(af_alg_sendpage);接着用户调用 recvmsg 触发 加密/解密,在内核中实际会调用到 aead_recvmsg ,其实际上就是对 _aead_recvmsg 函数的封装。
该函数主要涉及3个sgl,分别对应 TX(发送的待加密/解密数据)RX(内核处理后产生的数据),TAGX(TAG 的数据)。
- 首先内核计算出所需的接收缓冲区大小,并分配了 RX SGL
1. TX 缓冲区 (包含完整的用户输入)
+---------+------------------+---------+
| AAD | 密文 (CT) | TAG |
+---------+------------------+---------+
2. areq->tsgl (此时尚未分配)
( NULL )
3. RX SGL (内核刚分配好,等待填充数据)
+---------+------------------+
| (空白) | (空白) |- 将 TX 中的除了 TAG 以外的数据拷贝到 RX 中
1. TX 缓冲区 (保持不变)
+---------+------------------+---------+
| AAD | 密文 (CT) | TAG |
+---------+------------------+---------+
| |
(copy) (copy)
v v
3. RX SGL (已填入 AAD 和 CT)
+---------+------------------+
| AAD | 密文 (CT) |
+---------+------------------+- 对于 TAG 数据则是又专门创建了一个 sgl(TAGX),,然后通过 pull 操作,释放 TX 中 AAD 和 CT 占据的物理页引用,仅仅保留 TAG 所在的物理页引用,并将其赋值给刚刚分配的 areq->tsgl。
1. TX 缓冲区 (物理内存仍存在,但 AAD/CT 的引用已被释放)
[已释放引用] [已释放引用] +---------+
| TAG | <-- 这是真实存在的物理页
+---------+
^
| (物理内存引用,Zero-Copy)
2. areq->tsgl (新分配的 SGL 节点) +
[ pointer & length ] -------------+
3. RX SGL (目前仍是独立的)
+---------+------------------+
| AAD | 密文 (CT) |
+---------+------------------+- 通过 sg_chain 强制让 RX SGL 的尾部指针跳跃指向 areq->tsgl,将 TAGX 中的数据页链接到 RX 中
1. TX 缓冲区 (残留的物理内存)
+---------+
| TAG |
+---------+
^
| (物理引用)
2. areq->tsgl |
[ pointer & length ] -------------+
|
|
|
3. RX SGL |
+---------+------------------+ |
| AAD | 密文 (CT) |----+
+---------+------------------+- 接着调用 aead_request_set_crypt 初始化 加/解密 操作,因为是就地操作所以输入和输出缓冲区其实是同一个 buffer(RX)
- 最后调用 crypto_aead_decrypt 执行实际的 加/解 密逻辑
static int _aead_recvmsg(struct socket *sock, struct msghdr *msg,
size_t ignored, int flags)
{
struct sock *sk = sock->sk;
struct alg_sock *ask = alg_sk(sk);
struct sock *psk = ask->parent;
struct alg_sock *pask = alg_sk(psk);
struct af_alg_ctx *ctx = ask->private;
struct aead_tfm *aeadc = pask->private;
struct crypto_aead *tfm = aeadc->aead;
struct crypto_sync_skcipher *null_tfm = aeadc->null_tfm;
unsigned int i, as = crypto_aead_authsize(tfm); // as 为 TAG 的长度
struct af_alg_async_req *areq;
struct af_alg_tsgl *tsgl, *tmp;
struct scatterlist *rsgl_src, *tsgl_src = NULL;
int err = 0;
size_t used = 0; /* [in] 待加密/解密的 TX(发送)缓冲区数据长度 */
size_t outlen = 0; /* [out] 内核处理后产生的 RX(接收)缓冲区数据长度 */
size_t usedpages = 0; /* [in] 从用户态空间获取并准备使用的 RX 缓冲区页数/长度 */
size_t processed = 0; /* [in] 实际被消耗(处理完成)的 TX 缓冲区长度 */
// 省略...
if (ctx->enc)
outlen = used + as; // 加密后会在末尾追加 TAG
else
outlen = used - as; //
/*
* The cipher operation input data is reduced by the associated data
* length as this data is processed separately later on.
*/
used -= ctx->aead_assoclen;
areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) + // 创建 RX 的 sgl
crypto_aead_reqsize(tfm));
if (IS_ERR(areq))
return PTR_ERR(areq);
/* convert iovecs of output buffers into RX SGL */
err = af_alg_get_rsgl(sk, msg, flags, areq, outlen, &usedpages);
if (err)
goto free;
// 省略 ...
rsgl_src = areq->first_rsgl.sgl.sg;
if (ctx->enc) {
err = crypto_aead_copy_sgl(null_tfm, tsgl_src,
areq->first_rsgl.sgl.sg, processed);
if (err)
goto free;
af_alg_pull_tsgl(sk, processed, NULL, 0);
} else {
/* 只把 AAD 和密文 (不包含 Tag) 拷贝到 RX */
err = crypto_aead_copy_sgl(null_tfm, tsgl_src,
areq->first_rsgl.sgl.sg, outlen);
if (err)
goto free;
areq->tsgl_entries = af_alg_count_tsgl(sk, processed,
processed - as);
if (!areq->tsgl_entries)
areq->tsgl_entries = 1;
areq->tsgl = sock_kmalloc(sk, array_size(sizeof(*areq->tsgl), // 在这里又创建了一个 sgl
areq->tsgl_entries),
GFP_KERNEL);
if (!areq->tsgl) {
err = -ENOMEM;
goto free;
}
sg_init_table(areq->tsgl, areq->tsgl_entries);
af_alg_pull_tsgl(sk, processed, areq->tsgl, processed - as);
/* 将 TAGX 中的数据页链接到 RX SGL 上 */
if (usedpages) {
/* RX SGL present */
struct af_alg_sgl *sgl_prev = &areq->last_rsgl->sgl;
sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1);
sg_chain(sgl_prev->sg, sgl_prev->npages + 1,
areq->tsgl);
} else
/* no RX SGL present (e.g. authentication only) */
rsgl_src = areq->tsgl;
}
/* 初始化加解密操作 */
aead_request_set_crypt(&areq->cra_u.aead_req, rsgl_src, // rsgl_src == areq->first_rsgl.sgl.sg
areq->first_rsgl.sgl.sg, used, ctx->iv);
aead_request_set_ad(&areq->cra_u.aead_req, ctx->aead_assoclen);
aead_request_set_tfm(&areq->cra_u.aead_req, tfm);
if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
/* AIO operation */
sock_hold(sk);
areq->iocb = msg->msg_iocb;
/* Remember output size that will be generated. */
areq->outlen = outlen;
aead_request_set_callback(&areq->cra_u.aead_req,
CRYPTO_TFM_REQ_MAY_SLEEP,
af_alg_async_cb, areq);
err = ctx->enc ? crypto_aead_encrypt(&areq->cra_u.aead_req) : // 此处进入加/解密逻辑
crypto_aead_decrypt(&areq->cra_u.aead_req);
// 省略...
free:
af_alg_free_resources(areq);
return err ? err : outlen;
}这里通过函数表跳转进入解密的处理函数 crypto_authenc_esn_decrypt
struct aead_alg {
int (*setkey)(struct crypto_aead *tfm, const u8 *key,
unsigned int keylen);
int (*setauthsize)(struct crypto_aead *tfm, unsigned int authsize);
int (*encrypt)(struct aead_request *req);
int (*decrypt)(struct aead_request *req);
int (*init)(struct crypto_aead *tfm);
void (*exit)(struct crypto_aead *tfm);
unsigned int ivsize;
unsigned int maxauthsize;
unsigned int chunksize;
struct crypto_alg base;
};
int crypto_aead_decrypt(struct aead_request *req)
{
struct crypto_aead *aead = crypto_aead_reqtfm(req);
struct crypto_alg *alg = aead->base.__crt_alg;
unsigned int cryptlen = req->cryptlen;
int ret;
crypto_stats_get(alg);
if (crypto_aead_get_flags(aead) & CRYPTO_TFM_NEED_KEY)
ret = -ENOKEY;
else if (req->cryptlen < crypto_aead_authsize(aead))
ret = -EINVAL;
else
ret = crypto_aead_alg(aead)->decrypt(req); // 函数表跳转
crypto_stats_aead_decrypt(cryptlen, alg, ret);
return ret;
}
EXPORT_SYMBOL_GPL(crypto_aead_decrypt);由于就地处理的缘故,req->src == req->dst所以不会进入第一个 if 语句的逻辑中。
- 内核在栈上分配的一个 8 字节的数组u32 tmp[2];在普通的 IPsec 传输中,序列号是 32 位的。但是由于千兆/万兆网络太快,32 位序列号很快就会用完,所以引入了 ESN,把序列号扩展到了 64 位。
但是在网络上传输数据包时,为了节省带宽,只传输低 32 位序列号,高 32 位不传输,只在接收端本地参与 HMAC(哈希验证)的计算。
为了让 HMAC 算法能够把没传输的“高 32 位”和传输的“低 32 位”一起算进去,内核必须在内存里手动把它们拼起来。内核的策略是:把这高 32 位序列号,临时贴到整个数据包的尾部 算完哈希,再把它扔掉。
- scatterwalk_map_and_copy(tmp, dst, 0, 8, 0); 提取原始 AAD 的前 8 个字节
- scatterwalk_map_and_copy(tmp, dst, 4, 4, 1);把 tmp前 4 字节写到 dst 的偏移量 4 的位置
- scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1); 写到 dst 缓冲区的 写到 dst 缓冲区的 assoclen + cryptlen,也就是 TAG 的部分。
这里可以直接覆盖 TAG 是因为先使用了catterwalk_map_and_copy将 TAG 数据进行了备份,那此时原本再 RX 中的 TAG 数据页就没用了,因此内核开发者就直接将其当成了草稿,将4 字节的 ESN 写入其中,但是如果TAG是只读文件页的话就行发生越权写入。

static int crypto_authenc_esn_decrypt(struct aead_request *req)
{
struct crypto_aead *authenc_esn = crypto_aead_reqtfm(req);
struct authenc_esn_request_ctx *areq_ctx = aead_request_ctx(req);
struct crypto_authenc_esn_ctx *ctx = crypto_aead_ctx(authenc_esn);
struct ahash_request *ahreq = (void *)(areq_ctx->tail + ctx->reqoff);
unsigned int authsize = crypto_aead_authsize(authenc_esn);
struct crypto_ahash *auth = ctx->auth;
u8 *ohash = PTR_ALIGN((u8 *)areq_ctx->tail,
crypto_ahash_alignmask(auth) + 1);
unsigned int assoclen = req->assoclen;
unsigned int cryptlen = req->cryptlen;
u8 *ihash = ohash + crypto_ahash_digestsize(auth);
struct scatterlist *dst = req->dst;
u32 tmp[2];
int err;
cryptlen -= authsize;
if (req->src != dst) {
err = crypto_authenc_esn_copy(req, assoclen + cryptlen);
if (err)
return err;
}
scatterwalk_map_and_copy(ihash, req->src, assoclen + cryptlen, // 备份 TAG 数据
authsize, 0);
if (!authsize)
goto tail;
/* Move high-order bits of sequence number to the end. */
scatterwalk_map_and_copy(tmp, dst, 0, 8, 0);
scatterwalk_map_and_copy(tmp, dst, 4, 4, 1);
scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1); // 越权写入
// 省略...
}