IDA使用-2023CICSN华中赛区pwn题逆向为例

文章目录

  • 相关字节标识
  • 导入函数和导出函数
  • 找程序入口函数
  • 选项设置
  • 重命名
  • CISCN2023华中赛区分区赛AWD
    • IDA源码
      • main
  • 构造结构体
      • sub_141B()
    • 打开局部变量类型的视图
    • 增加变量类型
    • 重新定义变量类型
    • 再次设置变量类型并重新定义
    • 再次设置变量类型并重新定义
    • 再次设置变量类型并重新定义
  • 设置函数名
  • 标记已经分析完
  • 找到引用函数的各个地方
  • 对变量重新定义变量类型
  • 转换为字符
  • 格式化字符串"\x1B[36mmybash:%s$ \x1B[0m"
      • sub_25D5()
  • -1转换与相关变量与函数命名
  • 设置sub_25D5()
      • sub_247F(char *a1)
  • 设置sub_247F(char *a1)函数
      • sub_23CA(const char **a1)
  • 设置sub_23CA(const char **a1)函数
      • sub_1523()
  • 设置sub_1523()函数
  • h更换数据形式
  • 更改各个函数名
      • __int64 __fastcall command_touch(__int64 a1)
  • 修改后的__int64 __fastcall command_touch(__int64 a1)
      • __int64 __fastcall command_mkdir(__int64 a1)
  • 修改后的__int64 __fastcall command_mkdir(const char **args)
  • 此时发现void sub_13C8()函数又跳转
  • 注意
  • 修改后的__int64 __fastcall command_cat(const char **args)
  • 修改后的__int64 __fastcall command_rm(const char **args)
  • 修改后的__int64 __fastcall command_echo(char **args)
  • 修改后的__int64 __fastcall command_cd(char **arg)

2023华中pwn题逆向参考视频教程

相关字节标识

_WORD（1个字=2个字节=16位）
_DWORD（2个字=4个字节=32位）
_QWORD（4个字=8个字节=64位）
_OWORD（8个字=16个字节=128位

DB (Define Byte): 用于定义单字节（8位）的数据。
DW (Define Word): 用于定义字（Word）大小的数据，通常为2字节（16位）。
DD (Define Doubleword): 用于定义双字（Doubleword）大小的数据，通常为4字节（32位）。
DQ (Define Quadword): 用于定义四字（Quadword）大小的数据，通常为8字节（64位）。

导入函数和导出函数

在C语言中，导入函数和导出函数是实现模块化编程的关键技术，它们分别用于在不同模块之间共享和使用函数。以下是具体分析：

  • 导出函数：在C语言中，当一个函数被声明为导出时，它意味着这个函数可以在其他模块中被调用。这通常通过特定的编译器指令或关键字来实现，例如在Windows平台的C/C++中使用__declspec(dllexport)来导出DLL中的函数。

在这里插入图片描述

  • 导入函数：与导出函数相对应，导入函数是指在当前模块中引用外部模块定义的函数。在C语言中，导入函数通常涉及到包含相应的头文件，并且确保链接时包含了定义这些函数的目标文件或库文件。

在这里插入图片描述

找程序入口函数

export找到start，start中找到main
在这里插入图片描述

选项设置

在这里插入图片描述

重命名

在这里插入图片描述

CISCN2023华中赛区分区赛AWD

IDA源码

main

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  int v4; // [rsp+Ch] [rbp-14h]
  void *ptr; // [rsp+10h] [rbp-10h]
  void *v6; // [rsp+18h] [rbp-8h]

  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  alarm(0x20u);
  qword_50E0 = sub_141B();
  *(_DWORD *)qword_50E0 = 0;
  qword_5150 = qword_50E0;
  *(_BYTE *)(qword_50E0 + 4) = 47;
  strncpy(dest, (const char *)(qword_50E0 + 4), 1uLL);
  do
  {
    printf("\x1B[36mmybash:%s$ \x1B[0m", dest);
    ptr = (void *)sub_25D5();
    v6 = (void *)sub_247F(ptr);
    v4 = sub_23CA(v6);
    free(ptr);
    free(v6);
  }
  while ( v4 );
  return 0LL;
}

构造结构体

sub_141B()

该函数对建立的堆的不同位置进行变量设置，为了更方便的查看设置的位置，可以设置一个结构体来替代

_QWORD *sub_141B()
{
  _QWORD *v1; // [rsp+8h] [rbp-8h]

  v1 = malloc(0x40uLL);
  if ( !v1 )
    _exit(0);
  memset((char *)v1 + 4, 0, 0x10uLL);
  v1[7] = 0LL;
  v1[5] = 0LL;
  v1[4] = 0LL;
  v1[6] = 0LL;
  return v1;
}

打开局部变量类型的视图

在这里插入图片描述
在这里插入图片描述

增加变量类型

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

重新定义变量类型

在这里插入图片描述
在这里插入图片描述
然后代码变为

SomeStruct *sub_141B()
{
  SomeStruct *v1; // [rsp+8h] [rbp-8h]

  v1 = (SomeStruct *)malloc(0x40uLL);
  if ( !v1 )
    _exit(0);
  memset(&v1->gap[4], 0, 0x10uLL);
  *(_QWORD *)&v1->gap[56] = 0LL;
  *(_QWORD *)&v1->gap[40] = 0LL;
  *(_QWORD *)&v1->gap[32] = 0LL;
  *(_QWORD *)&v1->gap[48] = 0LL;
  return v1;
}

发现在距离起始四个字节后的十六个字节都设置为0
  memset(&v1->gap[4], 0, 0x10uLL);

memset函数

memset函数是C语言标准库中的一个用于内存操作的函数，它主要用于将某一块内存空间的内容设置为指定的值。

memset函数的原型为：

void *memset(void *s, int c, size_t n);
  • void *s：指向要填充的内存块的指针。
  • int c：需要设置的值，该值会被转换为无符号字符后用来设置内存块。
  • size_t n：要设置的内存块的字节数。

再次设置变量类型并重新定义

在这里插入图片描述
在这里插入图片描述
结果代码

SomeStruct *sub_141B()
{
  SomeStruct *v1; // [rsp+8h] [rbp-8h]

  v1 = (SomeStruct *)malloc(0x40uLL);
  if ( !v1 )
    _exit(0);
  memset(v1->some_array, 0, sizeof(v1->some_array));
  *(_QWORD *)&v1->gap[36] = 0LL;
  *(_QWORD *)&v1->gap[20] = 0LL;
  *(_QWORD *)&v1->gap[12] = 0LL;
  *(_QWORD *)&v1->gap[28] = 0LL;
  return v1;
}

再次设置变量类型并重新定义

在这里插入图片描述

SomeStruct *sub_141B()
{
  SomeStruct *v1; // [rsp+8h] [rbp-8h]

  v1 = (SomeStruct *)malloc(0x40uLL);
  if ( !v1 )
    _exit(0);
  memset(v1->some_array, 0, sizeof(v1->some_array));
  *(_QWORD *)&v1->gap[24] = 0LL;
  *(_QWORD *)&v1->gap[8] = 0LL;
  *(_QWORD *)v1->gap = 0LL;
  *(_QWORD *)&v1->gap[16] = 0LL;
  return v1;
}

再次设置变量类型并重新定义

在这里插入图片描述

SomeStruct *sub_141B()
{
  SomeStruct *v1; // [rsp+8h] [rbp-8h]

  v1 = (SomeStruct *)malloc(0x40uLL);
  if ( !v1 )
    _exit(0);
  memset(v1->some_array, 0, sizeof(v1->some_array));
  v1->ptr56 = 0LL;
  v1->ptr40 = 0LL;
  v1->ptr32 = 0LL;
  v1->ptr48 = 0LL;
  return v1;
}

设置函数名

在这里插入图片描述

标记已经分析完

在这里插入图片描述

找到引用函数的各个地方

在这里插入图片描述
在这里插入图片描述

对变量重新定义变量类型

在这里插入图片描述

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  int v4; // [rsp+Ch] [rbp-14h]
  void *ptr; // [rsp+10h] [rbp-10h]
  void *v6; // [rsp+18h] [rbp-8h]

  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  alarm(0x20u);
  qword_50E0 = SomeStruct::CreateInstance();
  qword_50E0->unkown_0 = 0;
  qword_5150 = qword_50E0;
  qword_50E0->some_array[0] = 47;
  strncpy(dest, qword_50E0->some_array, 1uLL);
  do
  {
    printf("\x1B[36mmybash:%s$ \x1B[0m", dest);
    ptr = (void *)sub_25D5();
    v6 = (void *)sub_247F(ptr);
    v4 = sub_23CA(v6);
    free(ptr);
    free(v6);
  }
  while ( v4 );
  return 0LL;
}

转换为字符

在这里插入图片描述

格式化字符串"\x1B[36mmybash:%s$ \x1B[0m"

字符串 “\x1B[36mmybash:%s$ \x1B[0m” 是一个包含ANSI转义序列的字符串，用于在终端上显示颜色文本。在这个字符串中：

\x1B[36m 是一个ANSI转义序列，用于将随后的文本颜色设置为青色（Cyan）。\x1B 是ESC字符的十六进制表示，[ 表示转义序列的开始，36 是选择青色的颜色代码，而 m 表示结束这个颜色设置。
mybash:%s$ 是实际要显示的文本，其中 %s 可能是一个占位符，用于格式化字符串时替换为某个特定的值。
\x1B[0m 是另一个ANSI转义序列，用于重置文本颜色到默认设置。这里 0 表示默认颜色，而 m 同样表示结束这个设置。

sub_25D5()

_BYTE *sub_25D5()
{
  int v1; // [rsp+Ch] [rbp-14h]
  int v2; // [rsp+10h] [rbp-10h]
  int v3; // [rsp+14h] [rbp-Ch]
  _BYTE *ptr; // [rsp+18h] [rbp-8h]

  v1 = 528;
  v2 = 0;
  ptr = malloc(0x210uLL);
  if ( !ptr )
    _exit(0);
  while ( 1 )
  {
    v3 = getchar();
    if ( v3 == -1 || v3 == 10 )
      break;
    ptr[v2++] = v3;
    if ( v2 >= v1 && v1 <= 2147483639 )
    {
      v1 += 496;
      ptr = realloc(ptr, v1);
      if ( !ptr )
      {
        fwrite("mybash: allocation error\n", 1uLL, 0x19uLL, stderr);
        exit(1);
      }
    }
  }
  ptr[v2] = 0;
  return ptr;
}

-1转换与相关变量与函数命名

在这里插入图片描述

设置sub_25D5()

这里根据每次输入一个字符将分配得到的堆指针设置为字符指针类型

void __fastcall read_line()
{
  int high; // [rsp+Ch] [rbp-14h]
  int i; // [rsp+10h] [rbp-10h]
  int tmp_char; // [rsp+14h] [rbp-Ch]
  char *input_content_line; // [rsp+18h] [rbp-8h]

  high = 528;
  i = 0;
  input_content_line = (char *)malloc(0x210uLL);
  if ( !input_content_line )
    _exit(0);
  while ( 1 )
  {
    tmp_char = getchar();
    if ( tmp_char == (unsigned int)EOF || tmp_char == '\n' )
      break;
    input_content_line[i++] = tmp_char;
    if ( i >= high && high <= 2147483639 )
    {
      high += 496;
      input_content_line = (char *)realloc(input_content_line, high);
      if ( !input_content_line )
      {
        fwrite("mybash: allocation error\n", 1uLL, 0x19uLL, stderr);
        exit(1);
      }
    }
  }
  input_content_line[i] = 0;
}

sub_247F(char *a1)

_QWORD *__fastcall sub_247F(char *a1)
{
  int v2; // [rsp+10h] [rbp-20h]
  int v3; // [rsp+14h] [rbp-1Ch]
  _QWORD *ptr; // [rsp+18h] [rbp-18h]
  char *i; // [rsp+20h] [rbp-10h]
  _QWORD *v6; // [rsp+28h] [rbp-8h]

  v2 = 64;
  v3 = 0;
  v6 = malloc(0x200uLL);
  if ( !v6 )
    _exit(0);
  ptr = v6;
  for ( i = strtok(a1, " \t\r\n\a"); i; i = strtok(0LL, " \t\r\n\a") )
  {
    ptr[v3++] = i;
    if ( v3 >= v2 )
    {
      v2 += 64;
      ptr = realloc(ptr, 8LL * v2);
      if ( !ptr )
      {
        fwrite("mybash: allocation error\n", 1uLL, 0x19uLL, stderr);
        exit(1);
      }
    }
  }
  ptr[v3] = 0LL;
  return ptr;
}

设置sub_247F(char *a1)函数

这里i是地址，所以ptr应该是双指针
在这里插入图片描述

char **__fastcall split_string(char *content_line)
{
  int high; // [rsp+10h] [rbp-20h]
  int cur_pos; // [rsp+14h] [rbp-1Ch]
  char **split_content_ptr; // [rsp+18h] [rbp-18h]
  char *one_split_content_ptr; // [rsp+20h] [rbp-10h]
  char **temp_chunk_ptr; // [rsp+28h] [rbp-8h]

  high = 64;
  cur_pos = 0;
  temp_chunk_ptr = (char **)malloc(0x200uLL);
  if ( !temp_chunk_ptr )
    _exit(0);
  split_content_ptr = temp_chunk_ptr;
  for ( one_split_content_ptr = strtok(content_line, " \t\r\n\a");
        one_split_content_ptr;
        one_split_content_ptr = strtok(0LL, " \t\r\n\a") )
  {
    split_content_ptr[cur_pos++] = one_split_content_ptr;
    if ( cur_pos >= high )
    {
      high += 64;
      split_content_ptr = (char **)realloc(split_content_ptr, 8LL * high);
      if ( !split_content_ptr )
      {
        fwrite("mybash: allocation error\n", 1uLL, 0x19uLL, stderr);
        exit(1);
      }
    }
  }
  split_content_ptr[cur_pos] = 0LL;
  return split_content_ptr;
}

sub_23CA(const char **a1)

__int64 __fastcall sub_23CA(const char **a1)
{
  int i; // [rsp+1Ch] [rbp-4h]

  if ( !*a1 )
    return 1LL;
  for ( i = 0; i < (int)sub_1523(); ++i )
  {
    if ( !strcmp(*a1, (const char *)*(&off_5020 + i)) )
      return ((__int64 (__fastcall *)(const char **))funcs_2446[i])(a1);
  }
  printf("%s: ERROR\n", *a1);
  return 0LL;
}

设置sub_23CA(const char **a1)函数

在这里插入图片描述

__int64 __fastcall instruction_proccess(const char **split_content_ptr_array)
{
  int i; // [rsp+1Ch] [rbp-4h]

  if ( !*split_content_ptr_array )
    return 1LL;
  for ( i = 0; i < (int)return_7(); ++i )
  {
    if ( !strcmp(*split_content_ptr_array, struction_name_ptr_array[i]) )
      return struction_function_ptr_array[i](split_content_ptr_array);
  }
  printf("%s: ERROR\n", *split_content_ptr_array);
  return 0LL;
}

sub_1523()

__int64 sub_1523()
{
  return 7LL;
}

设置sub_1523()函数

__int64 return_7()
{
  return 7LL;
}

h更换数据形式

在这里插入图片描述
对应的各个字符串
在这里插入图片描述

更改各个函数名

在这里插入图片描述

__int64 __fastcall command_touch(__int64 a1)

__int64 __fastcall command_touch(__int64 a1)
{
  int v2; // [rsp+1Ch] [rbp-14h]
  void *ptr56; // [rsp+20h] [rbp-10h]
  SomeStruct *Instance; // [rsp+28h] [rbp-8h]

  v2 = 1;
  if ( !*(_QWORD *)(a1 + 8) )
    fwrite("mybash: missing operand\n", 1uLL, 0x18uLL, stderr);
  while ( *(_QWORD *)(8LL * v2 + a1) )
  {
    ptr56 = qword_5150->ptr56;
    if ( (unsigned __int8)sub_13C9((__int64)ptr56, *(const char **)(8LL * v2 + a1)) != 1 )
    {
      ++v2;
    }
    else
    {
      Instance = SomeStruct::CreateInstance();
      Instance->unkown_0 = 1;
      sub_166E(Instance, *(_QWORD *)(8LL * v2 + a1));
      if ( qword_5150->ptr56 )
        sub_1628(ptr56, Instance);
      else
        qword_5150->ptr56 = Instance;
      ++v2;
    }
  }
  return 1LL;
}

修改后的__int64 __fastcall command_touch(__int64 a1)

__int64 __fastcall command_touch(char **args)
{
  int parameter_position; // [rsp+1Ch] [rbp-14h]
  SomeStruct *main_save_instance_ptr_of_first_file_ptr; // [rsp+20h] [rbp-10h]
  SomeStruct *Instance_ptr; // [rsp+28h] [rbp-8h]

  parameter_position = 1;
  if ( !args[1] )
    fwrite("mybash: missing operand\n", 1uLL, 0x18uLL, stderr);
  while ( args[parameter_position] )
  {
    main_save_instance_ptr_of_first_file_ptr = main_save_instance_ptr->first_son;
    if ( (unsigned __int8)SomeStruct::Folder_Not_Eixst(
                            main_save_instance_ptr_of_first_file_ptr,
                            args[parameter_position]) != 1 )
    {
      ++parameter_position;
    }
    else
    {
      Instance_ptr = SomeStruct::CreateInstance();
      Instance_ptr->isfile = 1;
      SomeStruct::set_some_array(Instance_ptr, args[parameter_position]);
      if ( main_save_instance_ptr->first_son )
        sub_1628(main_save_instance_ptr_of_first_file_ptr, Instance_ptr);
      else
        main_save_instance_ptr->first_son = Instance_ptr;
      ++parameter_position;
    }
  }
  return 1LL;
}

__int64 __fastcall command_mkdir(__int64 a1)

__int64 __fastcall command_mkdir(__int64 a1)
{
  char v1; // al
  int v3; // [rsp+1Ch] [rbp-14h]
  void *ptr56; // [rsp+20h] [rbp-10h]
  SomeStruct *Instance; // [rsp+28h] [rbp-8h]

  v3 = 1;
  if ( !*(_QWORD *)(a1 + 8) )
    fwrite("mybash: missing operand\n", 1uLL, 0x18uLL, stderr);
  while ( *(_QWORD *)(8LL * v3 + a1) )
  {
    ptr56 = qword_5150->ptr56;
    ((void (__fastcall *)())((char *)&sub_13C8 + 1))();
    if ( v1 != 1 )
    {
      fprintf(stderr, aMybashCannotCr, *(_QWORD *)(8LL * v3++ + a1));
    }
    else
    {
      Instance = SomeStruct::CreateInstance();
      Instance->unkown_0 = 0;
      Instance->ptr48 = qword_5150;
      sub_166E(Instance, *(_QWORD *)(8LL * v3 + a1));
      if ( qword_5150->ptr56 )
        sub_1628(ptr56, Instance);
      else
        qword_5150->ptr56 = Instance;
      ++v3;
    }
  }
  return 1LL;
}

void sub_13C8()
{
  JUMPOUT(0x13CALL);
}

修改后的__int64 __fastcall command_mkdir(const char **args)

__int64 __fastcall command_mkdir(const char **args)
{
  // [COLLAPSED LOCAL DECLARATIONS. PRESS KEYPAD CTRL-"+" TO EXPAND]

  parameter_position = 1;
  if ( !args[1] )
    fwrite("mybash: missing operand\n", 1uLL, 0x18uLL, stderr);
  while ( args[parameter_position] )
  {
    main_save_instance_ptr_of_first = main_save_instance_ptr->first_son;
    if ( (unsigned __int8)SomeStruct::Folder_Not_Eixst(main_save_instance_ptr_of_first, args[parameter_position]) != 1 )
    {
      fprintf(stderr, aMybashCannotCr, args[parameter_position++]);
    }
    else
    {
      mkdir_create_Instance_ptr = SomeStruct::CreateInstance();
      mkdir_create_Instance_ptr->isfile = 0;    // 0为目录
      mkdir_create_Instance_ptr->parent = main_save_instance_ptr;
      SomeStruct::set_some_array(mkdir_create_Instance_ptr, args[parameter_position]);
      if ( main_save_instance_ptr->first_son )
        sub_1628(main_save_instance_ptr_of_first, mkdir_create_Instance_ptr);
      else
        main_save_instance_ptr->first_son = mkdir_create_Instance_ptr;
      ++parameter_position;
    }
  }
  return 1LL;
}

此时发现void sub_13C8()函数又跳转

Tab键：反编译
在这里插入图片描述
先
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
最后得到的原void sub_13C8()函数

__int64 __fastcall sub_13C9(__int64 a1, const char *a2)
{
  while ( a1 )
  {
    if ( !strcmp((const char *)(a1 + 4), a2) )
      return 0LL;
    a1 = *(_QWORD *)(a1 + 40);
  }
  return 1LL;
}

注意

当一个函数分析有点棘手时可以查看其他引用该函数的地方

修改后的__int64 __fastcall command_cat(const char **args)

__int64 __fastcall command_cat(const char **args)
{
  unsigned __int64 high_parament_length_16; // rax
  void *v2; // rsp
  _BYTE v4[8]; // [rsp+8h] [rbp-70h] BYREF
  const char **args_save; // [rsp+10h] [rbp-68h]
  char v6; // [rsp+1Fh] [rbp-59h]
  int parament_longest_length_more1; // [rsp+20h] [rbp-58h]
  int parameter_position; // [rsp+24h] [rbp-54h]
  SomeStruct *first_son; // [rsp+28h] [rbp-50h]
  __int64 parament_longest_length_more; // [rsp+30h] [rbp-48h]
  char *cat_file_name; // [rsp+38h] [rbp-40h]
  unsigned __int64 v12; // [rsp+40h] [rbp-38h]

  args_save = args;
  v12 = __readfsqword(0x28u);
  parameter_position = 0;
  v6 = 0;
  parament_longest_length_more1 = 0;
  first_son = 0LL;

  while ( args_save[++parameter_position] )
  {
    if ( strlen(args_save[parameter_position]) > parament_longest_length_more1 )
      parament_longest_length_more1 = strlen(args_save[parameter_position]) + 1;
  }

  parament_longest_length_more = parament_longest_length_more1 - 1LL;
  high_parament_length_16 = 16 * ((parament_longest_length_more1 + 15LL) / 0x10uLL);
  while ( v4 != &v4[-(high_parament_length_16 & 0xFFFFFFFFFFFFF000LL)] )
    ;
  v2 = alloca(high_parament_length_16 & 0xFFF);

  if ( (high_parament_length_16 & 0xFFF) != 0 )
    *&v4[(high_parament_length_16 & 0xFFF) - 8] = *&v4[(high_parament_length_16 & 0xFFF) - 8];
  cat_file_name = v4;                           // 上面都没啥用，v2，v4后面都没用到

  parameter_position = 1;



  if ( !args_save[1] )
    fwrite("mybash: missing operand\n", 1uLL, 0x18uLL, stderr);

  while ( args_save[parameter_position] )
  {
    first_son = current_directory_ptr->first_son;
    strcpy(cat_file_name, args_save[parameter_position]);

    while ( first_son )
    {
      if ( !strcmp(cat_file_name, first_son->file_name) )
      {
        if ( first_son->file_content_ptr )
          puts(first_son->file_content_ptr);
        v6 = 1;
        break;
      }
      first_son = first_son->next_ptr;
    }

    if ( v6 != 1 )
      fprintf(stderr, "mybash: %s: No such file or directory\n", args_save[parameter_position]);
    ++parameter_position;
  }

  return 1LL;
}

修改后的__int64 __fastcall command_rm(const char **args)

__int64 __fastcall command_rm(const char **args)
{
  // [COLLAPSED LOCAL DECLARATIONS. PRESS KEYPAD CTRL-"+" TO EXPAND]

  parameter_position = 1;
  if ( !args[1] )
    fwrite("mybash: missing operand\n", 1uLL, 0x18uLL, stderr);
  while ( args[parameter_position] )
  {
    son_file = current_directory_ptr->first_son;
    success_flag = 0;
    while ( son_file )
    {
      if ( !strcmp(son_file->file_name, args[parameter_position]) )
      {
        success_flag = 1;
        if ( IsFile(son_file) )
        {
          memset(son_file->file_name, 0, sizeof(son_file->file_name));
          if ( son_file->file_content_ptr )
            free(son_file->file_content_ptr);
          SomeStruct::unlink_file(son_file);
        }
        else
        {
          fprintf(stderr, "mybash: '%s': Is a directory\n", args[parameter_position]);
        }
        break;
      }
      son_file = son_file->next_ptr;
    }
    if ( success_flag != 1 )
      fprintf(stderr, "mybash: '%s': No such file or directory\n", args[parameter_position]);
    ++parameter_position;
  }
  return 1LL;
}

修改后的__int64 __fastcall command_echo(char **args)

__int64 __fastcall command_echo(char **args)
{
  SomeStruct *v2; // rbx
  SomeStruct *v3; // rbx
  int parameter_position; // [rsp+14h] [rbp-3Ch]
  int i; // [rsp+14h] [rbp-3Ch]
  int content_length; // [rsp+18h] [rbp-38h]
  int last_parameter_position; // [rsp+1Ch] [rbp-34h]
  int input_content_length; // [rsp+24h] [rbp-2Ch]
  SomeStruct *current_son_file; // [rsp+28h] [rbp-28h] BYREF
  const char *last_parameter_ptr; // [rsp+30h] [rbp-20h]
  unsigned __int64 v11; // [rsp+38h] [rbp-18h]

  v11 = __readfsqword(0x28u);
  parameter_position = 0;
  if ( args[1] )
  {
    do
      ++parameter_position;
    while ( args[parameter_position] );

    last_parameter_position = parameter_position - 1;
    if ( Is_No_Echo_to_File(args[parameter_position - 2]) )
    {
      for ( i = 1; i < last_parameter_position; ++i )
        printf(args[i]);
      puts(args[last_parameter_position]);
      return 1LL;
    }
    else
    {
      current_son_file = current_directory_ptr->first_son;
      last_parameter_ptr = args[last_parameter_position];
      if ( Is_Exist_File(&current_son_file, last_parameter_ptr) != 1 )
      {
        fprintf(stderr, "mybash: %s: No such file\n", last_parameter_ptr);
        return 1LL;
      }
      else if ( IsFile(current_son_file) )
      {
        if ( current_son_file->file_content_ptr )
        {
          content_length = SomeStruct::Get_Content_length(current_son_file->file_content_ptr);
        }
        else
        {
          content_length = 0x1F0;
          v2 = current_son_file;
          v2->file_content_ptr = malloc(0x1F0uLL);
          if ( !current_son_file->file_content_ptr )
            _exit(0);
        }

        input_content_length = strlen(args[last_parameter_position - 2]);
        while ( input_content_length > content_length )
          content_length += 0x1F0;

        if ( content_length > SomeStruct::Get_Content_length(current_son_file->file_content_ptr) )
        {
          v3 = current_son_file;
          v3->file_content_ptr = realloc(current_son_file->file_content_ptr, content_length);
        }
        strncpy(current_son_file->file_content_ptr, args[last_parameter_position - 2], input_content_length);
        return 1LL;
      }
      else
      {
        fprintf(stderr, "mybash: %s: Is a directory\n", last_parameter_ptr);
        return 1LL;
      }
    }
  }
  else
  {
    putchar(10);
    return 1LL;
  }
}

修改后的__int64 __fastcall command_cd(char **arg)

__int64 __fastcall command_cd(char **arg)
{
  size_t dest_length; // rbx
  size_t current_file_name_length; // rax
  int main_save_instance_ptr_file_name_length; // [rsp+18h] [rbp-38h]
  const char *after_dlim_para; // [rsp+20h] [rbp-30h]
  SomeStruct *current_file; // [rsp+28h] [rbp-28h]
  char delim[2]; // [rsp+36h] [rbp-1Ah] BYREF
  unsigned __int64 v8; // [rsp+38h] [rbp-18h]

  v8 = __readfsqword(0x28u);
  if ( arg[1] )
  {
    if ( arg[2] )
    {
      fwrite("mybash: too many arguments\n", 1uLL, 0x1BuLL, stderr);
    }
    else
    {
      strcpy(delim, "/");
      for ( after_dlim_para = strtok(arg[1], delim); after_dlim_para; after_dlim_para = strtok(0LL, delim) )
      {
        if ( strcmp(after_dlim_para, ".") )
        {
          if ( !strcmp(after_dlim_para, "..") )
          {
            if ( current_directory_ptr->parent )
            {
              main_save_instance_ptr_file_name_length = strlen(current_directory_ptr->file_name);
              current_directory_path[(strlen(current_directory_path) - 1 - main_save_instance_ptr_file_name_length)] = 0;
              current_directory_ptr = current_directory_ptr->parent;// 当前目录更新为之前目录的父目录
            }
          }
          else
          {
            current_file = current_directory_ptr->first_son;
            if ( SomeStruct::File_Not_Eixst(current_file, after_dlim_para) )
            {
              fprintf(stderr, "mybash: %s: No such file or directory\n", after_dlim_para);
              return 1LL;
            }

            while ( current_file && strcmp(current_file->file_name, after_dlim_para) )
              current_file = current_file->next_ptr;
            if ( !SomeStruct::IsDirectory(current_file) )
            {
              fwrite("something wrong happened\n", 1uLL, 0x19uLL, stderr);
              return 1LL;
            }
            current_directory_ptr = current_file;
            dest_length = strlen(current_directory_path);

            if ( dest_length + strlen(current_file->file_name) + 1 <= 0x4F )
            {
              current_file_name_length = strlen(current_file->file_name);
              strncat(current_directory_path, current_file->file_name, current_file_name_length);
              *&current_directory_path[strlen(current_directory_path)] = 47;
            }
          }
        }
      }
    }
  }
  else
  {
    fwrite("mybash: expected argument\n", 1uLL, 0x1AuLL, stderr);
  }
  return 1LL;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/410724.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

项目实战：Qt监测操作系统cpu温度v1.1.0(支持windows、linux、国产麒麟系统）

项目实战：Qt监测操作系统cpu温度v1.1.0(支持windows、linux、国产麒麟系统）

若该文为原创文章&#xff0c;转载请注明出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/136277231 红胖子(红模仿)的博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV、OpenGL、ffmpeg、OSG、单片机、软硬结…
阅读更多...
linux系统---nginx基础

linux系统---nginx基础

目录 一、Nginx的概念 二、Nginx常用功能 1、HTTP(正向)代理&#xff0c;反向代理 1.1正向代理 1.2 反向代理 2、负载均衡 2.1 轮询法&#xff08;默认方法&#xff09; 2.2 weight权重模式&#xff08;加权轮询&#xff09; 2.3 ip_hash 3、web缓存 三、基础特性 四…
阅读更多...
@ControllerAdvice 统一管理异常/错误

@ControllerAdvice 统一管理异常/错误

ControllerAdvice 统一管理异常/错误 文章目录 ControllerAdvice 统一管理异常/错误一、注意事项二、统一管理异常/错误的好处三、代码实现1. 普通方法2. 统一管理ControllerAdvice3. PostMan测试结果 一、注意事项 1. 如果校验注解不指定 message 属性 ,会返回默认消息, 这些…
阅读更多...
C++之善用const修饰成员函数

C++之善用const修饰成员函数

C之善用const修饰成员函数 文章目录 C之善用const修饰成员函数前言1. 约束函数对成员变量的修改2. 允许 const 对象调用3. 在重载函数中提供重载决策总结 前言 ​ 在C编程中&#xff0c;使用const修饰成员函数是一种非常重要的技术手段&#xff0c;它能够提高代码的可维护性、…
阅读更多...
Object中的hashCode()

Object中的hashCode()

让hashcode方法的返回值为地址 vm参数中输入-XX:UnlockExperimentalVMOptions -XX:hashCode4&#xff0c;如下图&#xff1a; 参考 搞懂JAVAObject中的hashCode()_java_脚本之家 JDK核心JAVA源码解析(9) - hashcode 方法 - 知乎
阅读更多...
【k8s】-- 查询 pod 磁盘容量

【k8s】-- 查询 pod 磁盘容量

命令&#xff1a;kubectl get pvc -n 你的namespace --context上下文命名 -o wide 举例&#xff1a;kubectl get pvc -n my-bigdata --contextprod-6 -o wide
阅读更多...
10分钟快速开始SkyWalking结合Springboot项目

10分钟快速开始SkyWalking结合Springboot项目

10分钟快速开始SkyWalking结合Springboot项目 实习期间&#xff0c;公司让我去学习一下链路追踪如何集成到Springboot项目中。 为此有两个方案&#xff1a; 1.opentelementryjaegerprometheus opentelementry 收集器收集线上的metrics和traces&#xff0c;然后发送给jaeger和p…
阅读更多...
水资源费征收管理系统V1.1

水资源费征收管理系统V1.1

水资源费征收管理系统 Water Resource Fee Collection And Management System 水资源费征收管理系统 Water Resource Fee Collection And Management System
阅读更多...
MS2402隔离Σ-Δ调制器

MS2402隔离Σ-Δ调制器

产品简述 MS2402 是一款二阶 Σ-Δ 调制器&#xff0c;集成片上数字隔离器&#xff0c;能将模 拟输入信号转换为高速 1 位码流。调制器对输入信号连续采样&#xff0c;无 需外部采样保持电路。模拟信号输入满量程为 320mV &#xff0c;转换后的 数字码流的最高数据速率为 1…
阅读更多...
js 常见报错 | js 获取数据类型 | js 判断是否是数组

js 常见报错 | js 获取数据类型 | js 判断是否是数组

文章目录 js 常见报错1.1 SyntaxError&#xff08;语法错误&#xff09;1.2 ReferenceError&#xff08;引用错误&#xff09;1.3 RangeError&#xff08;范围错误&#xff09;1.4 TypeError&#xff08;类型错误&#xff09;1.5 URLError&#xff08;URL错误&#xff09;1.6 手…
阅读更多...
如何用二维码高效收集信息？表单功能轻松实现

如何用二维码高效收集信息？表单功能轻松实现

表单作为草料二维码的高级功能之一&#xff0c;可用于收集格式统一的数据。你可以通过组合姓名、图片、检查项等组件搭建出电子表单&#xff0c;关联到二维码中&#xff0c;扫码填写表单即可更快速、规范的收集数据。 下面为大家介绍下表单的制作教程。 1、新建表单 新建表单…
阅读更多...
跨区域复制建筑UI输入框脚本迷你世界

跨区域复制建筑UI输入框脚本迷你世界

--复制区域文件 --设置坐标起点&#xff0c;终点 --创建区域 --获取坐标id,data --星空露珠工作室制作 local pos1{x-16,y7,z28} local pos2{x28,y44,z-9} local block{num0} local str{} local str0{} local num0 local count0 local ui6 --几个输入框 local romath.random(…
阅读更多...
uniapp 头部设置公共token（确保新增页面不重复提交--每一次新增都获取一次token,后端根据token判断是否有重复，有重复提交后台给提示错误）

uniapp 头部设置公共token（确保新增页面不重复提交--每一次新增都获取一次token,后端根据token判断是否有重复，有重复提交后台给提示错误）

1 在公共文件中请求接口获取token 2 在公共请求中设置token 3 在使用的页面onShow请求
阅读更多...
辽宁博学优晨教育视频剪辑培训探索学习新意义

辽宁博学优晨教育视频剪辑培训探索学习新意义

在当今数字化快速发展的时代&#xff0c;视频已成为信息传达的重要载体。辽宁博学优晨教育视频剪辑培训应运而生&#xff0c;不仅为学员提供了专业的学习平台&#xff0c;更在探索学习的意义方面赋予了新的内涵。 视频剪辑作为现代媒体行业的重要技能&#xff0c;其学习意义不仅…
阅读更多...
武汉建筑安全员ABC小题库不存在未雨绸缪“时间够”

武汉建筑安全员ABC小题库不存在未雨绸缪“时间够”

武汉建筑安全员ABC小题库不存在未雨绸缪“时间够” 关于武汉三类人员&#xff08;安全员ABC&#xff09;考试小题库&#xff0c;一般都是考试时间出来&#xff0c;准考证下来了&#xff0c;匹配题库&#xff0c;好好看题&#xff08;认真练习即可&#xff09;&#xff0c;一般…
阅读更多...
如何在Linux搭建MinIO服务并实现无公网ip远程访问内网管理界面

如何在Linux搭建MinIO服务并实现无公网ip远程访问内网管理界面

文章目录 前言1. Docker 部署MinIO2. 本地访问MinIO3. Linux安装Cpolar4. 配置MinIO公网地址5. 远程访问MinIO管理界面6. 固定MinIO公网地址 前言 MinIO是一个开源的对象存储服务器&#xff0c;可以在各种环境中运行&#xff0c;例如本地、Docker容器、Kubernetes集群等。它兼…
阅读更多...
微信小程序（四十五）登入界面-简易版

微信小程序（四十五）登入界面-简易版

注释很详细&#xff0c;直接上代码 上一篇 此文使用了vant组件库&#xff0c;没有安装配置的可以参考此篇vant组件的安装与配置 新增内容&#xff1a; 1.基础组件的组合 2.验证码倒计时的逻辑处理 源码&#xff1a; app.json {"usingComponents": {"van-field…
阅读更多...
数据结构知识点总结-绪论 数据结构基本术语 算法及评价

数据结构知识点总结-绪论 数据结构基本术语 算法及评价

要求 &#xff08;1&#xff09;对数据结构这么课学了哪些知识有个清楚的认知&#xff1b; &#xff08;2&#xff09;掌握目录结构&#xff0c;能复述出来每个知识点下都有哪些内容。 如下图所示&#xff0c;可自行制作思维导图&#xff0c;针对自己薄弱的地方进行复习。 …
阅读更多...
签三方协议？大家一定要注意的问题！

签三方协议？大家一定要注意的问题！

签三方协议&#xff1f;大家一定要注意的问题&#xff01; 一、三方协议是什么&#xff1f;二、签三方协议要注意什么&#xff1f;1、待遇问题2、发展机会3、违约金 三、三方协议的一些疑问&#xff1f;1、三方协议和劳动合同的区别&#xff1f;2、签了三方会失去应届生身份嘛&…
阅读更多...
Bentley全球COO康岷思：中国市场特别且重要

Bentley全球COO康岷思：中国市场特别且重要

吴付标 疫情之后&#xff0c;中国再次敞开国门&#xff0c;欢迎四海友人。Bentley全球首席运营官康岷思正是其中的一位。 康岷思三年前加入Bentley管理团队。笔者在2023年10月份在新加坡召开的纵览基础设施大会暨光辉大奖盛典上第一次见到他。中国基础设施数字化先锋们所讲述的…
阅读更多...
最新文章

Copyright @ 2022~2023