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 中,有以下几个核心输入:

  1. Key (密钥) 和 IV (初始化向量)。
  2. Plaintext (明文):需要被加密并保护的数据。
  3. AAD (关联数据):不需要加密(保持明文),但必须参与完整性校验的数据(例如网络包头、协议版本号)。

加密后的输出是:Ciphertext (密文) + Tag/MAC (认证标签)。解密时,如果密文或 AAD 被篡改了,Tag 校验就会失败。

内核中 AEAD API实现

用户可以通过前面提的 socket 接口 (AF_ALG) 实现 AEAD 的加密和解密操作。下面是 AF_ALG 的整体生命周期,

  1. 绑定算法:用户态先创建一个基础套接字,并通过 bind 指定 AEAD 算法的类型如 authencesn(hmac(sha256),cbc(aes))
  2. 设置密钥:用户态通过 setsockopt 系统调用,将密钥(Key)传递给内核,并被内核保存在这个基础套接字的上下文中
  3. 建立会话:用户态对这个基础套接字(可以理解为一个模板)调用 accept()。这会返回一个新的“操作套接字”用于实际的加密解密操作
  4. 发送数据:使用 sendmsg向发送“操作套接字”加密或解密需要的数据,内核在底层会自动关联到之前设置好的密钥。

加密时的输入和输出:

通过sendmsg 让内核把 [ AAD | Plaintext ] 拷贝进内核物理页,后续当用户调用 recvmsg 读取时,内核会进行加密操作最终返回 [ AAD | Ciphertext | Auth Tag ]

  1. 关联数据 (AAD):
  • 这是不需要加密,但必须参与防篡改校验的数据(比如 TCP/IP 包头、协议版本号)。
  • 长度可由用户自行设置
  1. 明文 (Plaintext):
  • 真正需要被加密成乱码的核心数据。

[ AAD | Plaintext ] => [ AAD | Ciphertext | Auth Tag ]

解密时的输入和输出:

内核通过sendmsg 把这段 [ AAD | Ciphertext | Auth Tag ] 完整地拷贝进内核物理页。 后续当用户调用 recvmsg 尝试读取时,内核会先用 Key、IV 和 AAD 来进行解密并核对 Auth Tag:

  • 如果 Tag 匹配:说明数据没被篡改,内核解密出明文,并将明文返回给用户。
  • 如果 Tag 不匹配:内核直接拒绝解密,recvmsg 返回错误(通常是 -EBADMSG)。
  1. 关联数据 (AAD):与加密时完全相同的 AAD。
  2. 密文 (Ciphertext):加密后生成的乱码数据。
  3. 认证标签 (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) 将物理上可能不连续的内存页串联起来,在此处分为两条路径
  1. 追加到现有页:如果 ctx->merge 标志为真,内核为了节省内存,会继续把新数据拼接到那一页的末尾。memcpy_from_msg 负责从用户空间安全地拷贝数据。
  2. 分配新页:如果没有空余空间,内核会申请全新的物理页,将其挂载到散列表中,然后再把用户数据拷贝进来
  • 最后检查用户传入的系统标志,如果设置了 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); // 越权写入
    // 省略...
}

运行效果