【reverse】新160个CrackMe之154-cpp_crackme1——MFC+纯算法逆向

已于 2022-09-03 21:04:35 修改
阅读量896 收藏
点赞数 1
分类专栏： python web&CTF 文章标签： 安全 python
于 2022-09-03 20:59:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hans774882968/article/details/126682443
版权

文章目录

依赖

IDA版本为7.7。

PETools查看概况

32位程序，入口点Section: [.text], EP: 0x00001DB9故无壳。

正文

作者：hans774882968以及hans774882968以及hans774882968

本文juejin：https://juejin.cn/post/7139136489585115173/

本文csdn：https://blog.csdn.net/hans774882968/article/details/126682443

本文52pojie：https://www.52pojie.cn/thread-1683826-1-1.html

如何定位关键函数
  1. 因为函数很少，所以一个一个点开来看，即可定位到关键函数sub_401660。
  2. 打开x64dbg，正常地触发一次输入序列号错误，点击暂停键，查看调用堆栈，即可定位。
分析

sub_401660：

int sub_401660()
{
  int iii; // ebx
  int *v2; // edi
  int v3; // eax
  int i; // ecx
  int v5; // ecx
  char *v6; // edi
  int v7; // edx
  int v8; // esi
  char *v9; // eax
  int v10; // ecx
  int v11; // ecx
  int *v12; // edi
  int WindowTextA; // eax
  char v14[120]; // [esp+8h] [ebp-328h] BYREF
  CHAR Caption[256]; // [esp+80h] [ebp-2B0h] BYREF
  CHAR Text[256]; // [esp+180h] [ebp-1B0h] BYREF
  char String[28]; // [esp+280h] [ebp-B0h] BYREF
  __int16 v18; // [esp+29Ch] [ebp-94h]
  char Buf1[28]; // [esp+2A0h] [ebp-90h] BYREF
  __int16 v20; // [esp+2BCh] [ebp-74h]
  char v21; // [esp+2BEh] [ebp-72h]
  char Buf2[28]; // [esp+2C0h] [ebp-70h] BYREF
  __int16 v23; // [esp+2DCh] [ebp-54h]
  char v24; // [esp+2DEh] [ebp-52h]
  int v25; // [esp+2E0h] [ebp-50h]
  int v26; // [esp+2E4h] [ebp-4Ch]
  CHAR Str1[28]; // [esp+2E8h] [ebp-48h] BYREF
  char Source[43]; // [esp+304h] [ebp-2Ch] BYREF
  char v29; // [esp+32Fh] [ebp-1h]

  memset(String, 0, sizeof(String));
  v18 = 0;
  memset(Buf1, 0, sizeof(Buf1));
  v20 = 0;
  memset(Buf2, 0, sizeof(Buf2));
  v23 = 0;
  memset(v14, 0, sizeof(v14));
  memset(Source, 0, 30);
  if ( GetWindowTextA(dword_40974C, String, 30) >= 1 )
  {
    iii = 0;
    v2 = &dword_407030;
    do
    {
      if ( iii >= lstrlenA(String) )
        Buf1[iii] = (iii + (*v2 ^ 0x5A)) % 57 + 65;
      else
        Buf1[iii] = (iii + 1) ^ String[iii];
      ++v2;
      ++iii;
    }
    while ( (int)v2 < (int)&unk_4070A8 );
    v21 = 0;
    _swab(Buf1, Buf2, 30);
    v24 = 0;
    v3 = 0;
    for ( i = 0; i < 30; ++i )
    {
      v29 = Buf2[i];
      LOBYTE(v3) = v29;
      v3 = __ROR4__(v3, 1);
      v29 = v3;
      Buf2[i] = v3;
    }
    v5 = 0;
    v6 = v14;
    do
    {
      v7 = Buf2[v5];
      v8 = Buf1[v5];
      v6 += 4;
      ++v5;
      *((_DWORD *)v6 - 1) = v7 * v8 + (v7 ^ v8);
    }
    while ( v5 < 30 );
    v9 = v14;
    v10 = 15;
    do
    {
      *(_DWORD *)v9 += *((_DWORD *)v9 + 15);
      v9 += 4;
      --v10;
    }
    while ( v10 );
    v11 = 0;
    v12 = (int *)v14;
    do
    {
      v25 = *v12;
      LOBYTE(v26) = v25;
      ++v12;
      Source[v11++] = (unsigned __int8)v25 % 9 + 48;
    }
    while ( v11 < 15 );
    memset(&Source[16], 0, 25);
    Source[16] = toupper(dword_407030 ^ 0x63);
    Source[17] = toupper(dword_407034 ^ 0x63);
    Source[18] = toupper(dword_407038 ^ 0x63);
    Source[19] = '-';
    strncat(&Source[16], Source, 0xFu);
    qmemcpy(&Source[35], "-2413", 5);
    WindowTextA = GetWindowTextA(dword_409750, Str1, 25);
    if ( WindowTextA >= 1 )
    {
      if ( WindowTextA >= 24
        && !strncmp(Str1, &Source[16], 0x14u)
        && (Str1[20] ^ 0x63) == 0x53
        && (Str1[21] ^ 0x63) == 0x52
        && (Str1[22] ^ 0x63) == 0x57
        && (Str1[23] ^ 0x63) == 0x52 )
      {
        sub_401B20(byte_4071CC, 12);
        qmemcpy(Caption, byte_409754, 0xFFu);
        sub_401B20(byte_4071FC, 10);
        qmemcpy(Text, byte_409754, 0xFFu);
        return MessageBoxA(hWnd, Caption, Text, 0x40u);
      }
      else
      {
        sub_401B20(byte_407190, 15);
        qmemcpy(Caption, byte_409754, 0xFFu);
        sub_401B20(byte_407178, 6);
        qmemcpy(Text, byte_409754, 0xFFu);
        return MessageBoxA(hWnd, Caption, Text, 0x10u);
      }
    }
    else
    {
      sub_401B20(byte_407118, 24);
      qmemcpy(Caption, byte_409754, 0xFFu);
      sub_401B20(byte_407178, 6);
      qmemcpy(Text, byte_409754, 0xFFu);
      return MessageBoxA(hWnd, Caption, Text, 0x10u);
    }
  }
  else
  {
    sub_401B20(byte_4070C0, 22);
    qmemcpy(Text, byte_409754, 0xFFu);
    sub_401B20(byte_407178, 6);
    qmemcpy(Caption, byte_409754, 0xFFu);
    return MessageBoxA(hWnd, Text, Caption, 0x10u);
  }
}

这里有两个全局变量，dword_40974C和dword_409750分别对应你的Name和你输入的序列号。

常量串隐藏

为什么不能通过常量串定位关键函数？因为做了常量串隐藏。看到sub_401B20就是一个字符串解密操作，我们写个idapython脚本看看各个常量串：

import idc


def get_dec_str(enc):
    ans = ''
    for i in range(0, len(enc), 4):
        ans += chr(enc[i] ^ 0x63)
    return ans


a = [
    [0x4070c0, 88], [0x407118, 96], [0x407178, 24],
    [0x407190, 60], [0x4071cc, 48], [0x4071fc, 40]
]
mp = {}
for addr, c in a:
    enc_s = get_bytes(addr, c)
    dec_s = get_dec_str(enc_s)
    mp[hex(addr)] = dec_s
print(mp)  # {'0x4070c0': 'You must enter a name!', '0x407118': 'You must enter a serial!', '0x407178': 'Error!', '0x407190': 'Invalid serial!', '0x4071cc': 'Good serial!', '0x4071fc': 'Well Done!'}

接下来我们从下到上分析每一个小模块。

判定：

    WindowTextA = GetWindowTextA(dword_409750, Str1, 25);
    if ( WindowTextA >= 24
        && !strncmp(Str1, &Source[16], 0x14u) // Str1是你输入的序列号
        && (Str1[20] ^ 0x63) == 0x53
        && (Str1[21] ^ 0x63) == 0x52
        && (Str1[22] ^ 0x63) == 0x57
        && (Str1[23] ^ 0x63) == 0x52 )

需要关注Source + 16字符串怎么来：

    v12 = (int *)v14;
    do
    {
      v25 = *v12;
      LOBYTE(v26) = v25;
      ++v12;
      Source[j++] = (unsigned __int8)v25 % 9 + 48;
    }
    while ( j < 15 );

    memset(&Source[16], 0, 25);
    // 期望的序列号的前4个字符：'ULT-'
    Source[16] = toupper(dword_407030 ^ 0x63);
    Source[17] = toupper(dword_407034 ^ 0x63);
    Source[18] = toupper(dword_407038 ^ 0x63);
    Source[19] = '-';
    strncat(&Source[16], Source, 0xFu); // 所以Source[:15]有用
    qmemcpy(&Source[35], "-2413", 5); // 迷惑你的，但用到了"-2413"[0]

所以重点关注对v14所在内存空间的修改：

    v6 = v14;
    do
    {
      v7 = Buf2[ii]; // 注意这里是有符号扩展
      v8 = Buf1[ii];
      v6 += 4;
      ++ii;
      *((_DWORD *)v6 - 1) = v7 * v8 + (v7 ^ v8); // v6+4-1*4
    }
    while ( ii < 30 );
    // 相当于 for i in range(15): v14[i] += v14[i + 15]
    v9 = v14;
    v10 = 15;
    do
    {
      *(_DWORD *)v9 += *((_DWORD *)v9 + 15);
      v9 += 4;
      --v10;
    }
    while ( v10 );

值得注意的是，v7是int，Buf2[ii]是char，cpp里把char赋值给int的隐式类型转换是“有符号扩展”，即把Buf2[ii]解释为8位有符号整数。对应的汇编指令为：movsx。验证demo：

#include <windows.h>
#include <stdio.h>

int main() {
    char c1, c2, c3;
    c1 = 0xfe;
    c2 = 0xfc;
    c3 = 0xfa;
    int v1 = c1, v2 = c2, v3 = c3;
    printf ("%d %d %d\n", v1, v2, v3); // -2 -4 -6
    return 0;
}

接下来看Buf1和Buf2怎么求得。

求Buf2：

    _swab(Buf1, Buf2, 30);    
    v3 = 0;
    for ( i = 0; i < 30; ++i )
    {
      v29 = Buf2[i];
      LOBYTE(v3) = v29;
      v3 = __ROR4__(v3, 1);
      v29 = v3;
      Buf2[i] = v3;
    }
  1. _swab即相邻字符串为一组，交换位置。
  2. 易错点：v3 = __ROR4__(v3, 1)不能理解成右移1位，因为v3是int类型，在操作24次后将不等价于右移1位。

_swab：

void __cdecl _swab(char *Buf1, char *Buf2, int SizeInBytes)
{
  unsigned int v4; // esi
  char v6; // dl
  char *v7; // ecx

  if ( SizeInBytes > 1 )
  {
    v4 = (unsigned int)SizeInBytes >> 1;
    do
    {
      v6 = *Buf1;
      *Buf2 = Buf1[1];
      Buf1 += 2;
      v7 = Buf2 + 1;
      *v7 = v6;
      Buf2 = v7 + 1;
      --v4;
      // Buf2[i] = Buf1[i+1], Buf2[i+1] = Buf1[i], Buf1 += 2, Buf2 += 2
    }
    while ( v4 );
  }
}

求Buf1：

    iii = 0;
    v2 = &dword_407030; // GetWindowTextA(dword_40974C, String, 30)，所以String就是你的Name
    do
    {
      if ( iii >= lstrlenA(String) )
        Buf1[iii] = (iii + (*v2 ^ 0x5A)) % 57 + 65;
      else
        Buf1[iii] = (iii + 1) ^ String[iii];
      ++v2;
      ++iii;
    }
    while ( (int)v2 < (int)&unk_4070A8 );

因此，我们要做的，是把生成序列号的算法复现出来，算法参数：你输入的Name。

踩坑总结

  1. 把char赋值给int的隐式类型转换是“有符号扩展”。
  2. 不要想当然地把__ROR4__简化为右移一位。python实现时不要怕麻烦。

代码

这里我们有两个看上去不错的选择：

  1. 用python来复现。
  2. 用cpp来复现，并用IDA的defs.h来减少代码的改动。defs.h在IDA安装目录下可搜索到。

我把两种方法都做了，法二的心智负担明显更小。

法一
def get_buf1(inp_name):
    dword_407030 = [
        0x16, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x17, 0x00,
        0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
        0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x16, 0x00,
        0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
        0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x52, 0x00,
        0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
        0x17, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00,
        0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
        0x16, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x07, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00
    ]
    buf1 = []
    for i in range(30):
        buf1.append(
            ord(inp_name[i]) ^ (i + 1) if i < len(inp_name) else
            ((i + (dword_407030[4 * i] ^ 0x5A)) % 57 + 65)
        )
    return buf1


def get_buf2(buf1):
    buf2 = []
    for i in range(0, 30, 2):
        buf2.append(buf1[i + 1])
        buf2.append(buf1[i])

    def ror4_1(v): return ((v & 1) << 31) | (v >> 1)
    v3 = 0
    for i, v in enumerate(buf2):
        v3 = (v3 & 0xffffff00) | v
        v3 = ror4_1(v3)
        buf2[i] = v3 & 0xff
    return buf2


def solve(inp_name: str):
    ans16_19 = ''.join([chr(i ^ 0x63).upper()
                       for i in [0x16, 0x0f, 0x17]]) + '-'
    print(ans16_19)  # ULT-
    ans_tail = '-2413'
    serial_tail = ''.join([chr(i ^ 0x63) for i in [0x53, 0x52, 0x57, 0x52]])
    print(serial_tail)  # 0141

    buf1 = get_buf1(inp_name)
    buf2 = get_buf2(buf1)
    v14 = []

    def as_signed8(v): return v if v < 0x7f else (v - 0x100)
    for x, y in zip(buf1, buf2):
        x = as_signed8(x)
        y = as_signed8(y)
        v14.append(y * x + (y ^ x))
    for i in range(15):
        v14[i] += v14[i + 15]
    ans_main = ''
    for i in range(15):
        ans_main += chr((v14[i] & 0xff) % 9 + 48)
    ans = ans16_19 + ans_main + '-' + serial_tail
    return ans


inp_name = "hans"
ans = solve(inp_name)
print(inp_name, ans, len(ans))
inp_name = "acmer"
ans = solve(inp_name)
print(inp_name, ans, len(ans))
inp_name = "Hans774882968"
ans = solve(inp_name)
print(inp_name, ans, len(ans))
法二
#include <bits/stdc++.h>
#include <windows.h>
#include "defs.h"
using namespace std;
#define rep(i,a,b) for(int i = (a);i <= (b);++i)
#define re_(i,a,b) for(int i = (a);i < (b);++i)
#define dwn(i,a,b) for(int i = (a);i >= (b);--i)

void dbg() {
    puts ("");
}
template<typename T, typename... R>void dbg (const T &f, const R &... r) {
    cout << f << " ";
    dbg (r...);
}
template<typename Type>inline void read (Type &xx) {
    Type f = 1;
    char ch;
    xx = 0;
    for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar() ) if (ch == '-') f = -1;
    for (; ch >= '0' && ch <= '9'; ch = getchar() ) xx = xx * 10 + ch - '0';
    xx *= f;
}
void read() {}
template<typename T, typename ...R>void read (T &x, R &...r) {
    read (x);
    read (r...);
}

string solve (string inpName) {
    int v3; // eax
    int v5; // ecx
    char *v6; // edi
    int v7; // edx
    int v8; // esi
    char *v9; // eax
    int *v12; // edi
    char v14[120]; // [esp+8h] [ebp-328h] BYREF
    char Buf1[38]; // [esp+2A0h] [ebp-90h] BYREF
    char v21; // [esp+2BEh] [ebp-72h]
    char Buf2[38]; // [esp+2C0h] [ebp-70h] BYREF
    char v24; // [esp+2DEh] [ebp-52h]
    int v26; // [esp+2E4h] [ebp-4Ch]
    char v29; // [esp+32Fh] [ebp-1h]
    int dword_407030[120] = {
        0x16, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x17, 0x00,
        0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
        0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x16, 0x00,
        0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
        0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x52, 0x00,
        0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
        0x17, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00,
        0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
        0x16, 0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x07, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00
    };
    memset (Buf1, 0, sizeof (Buf1) );
    memset (Buf2, 0, sizeof (Buf2) );
    memset (v14, 0, sizeof (v14) );
    re_ (i, 0, 30) {
        if (i >= inpName.size() )
            Buf1[i] = (i + (dword_407030[4 * i] ^ 0x5A) ) % 57 + 65;
        else
            Buf1[i] = (i + 1) ^ inpName[i];
    }
    v21 = 0;
    for (int i = 0; i < 30; i += 2) {
        Buf2[i] = Buf1[i + 1];
        Buf2[i + 1] = Buf1[i];
    }
    v24 = 0;
    v3 = 0;
    re_ (i, 0, 30) {
        v29 = Buf2[i];
        LOBYTE (v3) = v29;
        v3 = __ROR4__ (v3, 1);
        v29 = v3;
        Buf2[i] = v3;
    }
    v5 = 0;
    v6 = v14;
    do {
        v7 = Buf2[v5];
        v8 = Buf1[v5];
        v6 += 4;
        ++v5;
        * ( (_DWORD *) v6 - 1) = v7 * v8 + (v7 ^ v8);
    } while ( v5 < 30 );
    v9 = v14;
    re_ (_, 0, 15) {
        * (_DWORD *) v9 += * ( (_DWORD *) v9 + 15);
        v9 += 4;
    }
    v12 = (int *) v14;
    string ansMain;
    re_ (_, 0, 15) {
        int v25 = *v12;
        ++v12;
        ansMain += (unsigned __int8) v25 % 9 + 48;
    }
    return "ULT-" + ansMain + "-0141";
}

int main() {
    string inpName, ans;
    inpName = "hans acmer";
    ans = solve (inpName);
    dbg (inpName, ans, ans.size() );
    inpName = "Hans774882968";
    ans = solve (inpName);
    dbg (inpName, ans, ans.size() );
    inpName = "scuctf";
    ans = solve (inpName);
    dbg (inpName, ans, ans.size() );
    return 0;
}

参考资料

  1. movsx命令：https://blog.csdn.net/cswangbin/article/details/3955395
  2. https://www.bilibili.com/video/BV16d4y1d72A
hans774882968
关注
专栏目录
Kernel pwn 入门 (3)
CoLin的pwn小屋
07-08 1866
kernel pwn 入门之 ret2dir
C函数之memcpy()函数用法
zou_albert的博客
03-06 1万+
目录1 基本介绍1.1 函数原型1.2 功能1.3头文件1.4 返回值2 说明3 使用例子3.1 作用：将s中的字符串复制到字符数组d中。3.2 作用：将s中第14个字符开始的4个连续字符复制到d中。(从0开始)3.3 作用：复制后覆盖原有部分数据 1 基本介绍 1.1 函数原型 void *memcpy(void*dest, const void *src, size_t n); 函数原型 void *memcpy(void *dest, const void *src, int count) {
攻防世界elrond32题解
SNiFe的博客
09-12 1711
攻防世界elrond32题解使用exeinfope查看文件信息分析反汇编代码编写代码获取flag 使用exeinfope查看文件信息 查看后发现是一个32位的ELF可执行文件，丢进IDA32查看反汇编代码 分析反汇编代码 首先找到main函数，F5查看伪代码 看见Access granted显然可知sub_8048538()函数是输出flag的函数，点开看看 看代码发现我们需要得到数组a2的值，于是回到main函数，发现a2与sub_8048414()函数有关，点开看看 分析函数，写出代码，得到a
C语言——内存操作函数（memcpy、memmove、memcmp、memset）
NunU的博客
09-18 1万+
C语言进阶内容，内存操作函数的部分模拟实现以及函数说明、使用方法等，干货满满哦！！！
memcpy函数的作用以及四种用法，后面那三种很巧妙（看完不亏）
m0_70832728的博客
07-30 1万+
memcpy() 函数到底是干什么嘞呢😕一般从函数名字里就可以看出函数的功能，此函数即可，mem是memory的缩写，cpy是copy的缩写。二者合体就是内存复制的意思。咋个复制法呢🤔我们先来看官方解释🌞但是用这个函数的时候我们要注意三个点1. 一定要注意memcpy函数第三个参数传的是待传内容的字节数举个例子，如果我们想把整形数组arr1中前五个元素传中arr2，在memcpy就要写20。为什么呢？因为arr1为整型数组，其中包含的元素也是整型，是4个字节。
百度杯CTF比赛二月第三场比赛(Reverse专题赛)的CrackMe-1题目
03-30
百度杯CTF比赛二月第三场比赛(Reverse专题赛)的CrackMe-1题目。
C++_2019-04-28_机器视觉——Opencv——Openvino_加速深度学习运行全部署过程
DONG_LIN_2019的博客
04-08 3366
Openvino环境配置与使用（window） 第一步：安装Openvino前的环境需求： vs2015以上 cmake3.4以上 python3.5以上 openvino安装（openvino的安装附带着opencv4的捆绑安装哦）： openvino序列号：C9PJ-FP9CSFT8https://docs.openvinotoolkit.org/201...
机器学习——K-近邻算法（算法原理+分析+实验结果）
weixin_46120403的博客
09-28 1万+
机器学习——K-近邻算法 （一）K-近邻算法概述 （一）K-近邻算法概述 K-近邻法(K-nearest neighbor, K-NN)是1967年由Cover T和Hart P提出的一种基本分类与回归方法。它的工作原理是：存在一个样本数据集合，也称作为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后，将新的数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本最相似数据(最近邻)的分类标签。一般...
BUUCTF 逆向工程(reverse)之reverse3
weixin_44632787的博客
08-22 2121
用的IDA打开，然后进入的主函数_main_0 __int64 __cdecl main_0() { int v0; // eax const char *v1; // eax size_t v2; // eax int v3; // edx __int64 v4; // ST08_8 signed int j; // [esp+DCh] [ebp-ACh] signed int i; // [esp+E8h] [ebp-A0h] signed int v8; // [esp
buuctf 逆向刷题01——reverse1
qq_42642222的博客
11-03 1929
仅作学习ctf逆向的buu刷题记录，不定期更新，大佬轻拍。
适合破解新手的160个crackme练手.rar
08-12
适合破解新手的160个crackme练手
memmove、memcpy和memccpy简介
merryken的专栏
06-24 868
memmove、memcpy和memccpy三个函数都是内存的拷贝，从一个缓冲区拷贝到另一个缓冲区。 memmove(void *dest,void*src,int count) memcpy(void *dest,void *src,int count) memccpy(void*dest,void*src,int ch,int count) 表头文件: #include 定义函
memcpy的用法总结
热门推荐
lovemysea的专栏
02-01 18万+
1、memcpy 函数用于 把资源内存（src所指向的内存区域） 拷贝到目标内存（dest所指向的内存区域）；拷贝多少个？有一个size变量控制拷贝的字节数；函数原型：void *memcpy(void *dest, void *src, unsigned int count);用法：（1）可以拷贝任何类型的对象，因为函数的参数类型是void*（未定义类型指针），也就是说传进去的实参可以是int*
【c语言】库函数memcpy的用法以及模拟实现memcpy
Lchilde的博客
06-03 383
库函数memcpy的用法以及模拟实现memcpy 一：memcpy的用法 1：将str1复制到str2中 代码实现如下： #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { const char str1[] = "This is a student"; char str2...
IDA PRO 01 - 静态逆向分析基础01
最新发布
a5right的博客
11-28 2277
如果你仔细看下日志，会发现里面报了一些错误，这是因为这个 ida 里面自带了一些插件，而这些插件依赖了 python 的一些模块，所以我们还需要安装这些模块，IDA 里面有 readme 可以看看。需要注意的是，main 函数也是会被别的函数引用的，我们可以写一个最简单的例子，然后编译成 exe 文件，看其符号表，会发现有很多的函数名，这写函数就是用来在启动 main 函数之前做一些事情的。就没有上面这么多问题，因为 ida 目录下是有个 python38 版本的，依赖的模块已经存在了，就不需要再导入了。
CTF逆向-[b01lers2020]little_engine-cpp基本函数用法和byte类型要点
serfend's blog
05-08 1615
CTF逆向-[b01lers2020]little_engine-cpp基本函数用法和byte类型要点 来源：https://buuoj.cn/ 内容： 附件：https://pan.baidu.com/s/1g6wnqkuqydzHHlXInmRCNQ?pwd=mjlu 提取码：mjlu 答案：pctf{th3_m0d3rn_st34m_3ng1n3_w45_1nv3nt3d_1n_1698_buT_th3_b3st_0n3_in_1940} 总体思路 发现主要流程三个函数，分别是输出一个欢迎语、要求用
C++ RC4算法实现
摔不死的笨鸟的博客
07-21 1091
CRC4.h /*********************************************************** * Standard RC4 Encryption * C++ Class * Coded by Viotto © BreakingSecurity.net ***********************************************************/ #include <string> using namespace std; c
C++: byte和int的相互转化和LOBYTE+HIBYTE的应用
bmjhappy的专栏
11-05 2059
byte不是一种新类型，在C++中byte被定义的是unsigned char类型；但在C#里面byte被定义的是unsigned int类型 //int转byte void intToByte(int i,byte *bytes,int size = 4) { //byte[] bytes = new byte[4]; memset(bytes,0,sizeof(byt...
[系统安全]《黑客免杀攻防》MFC逆向基础实战
H4ppyD0g的博客
12-25 2040
本文为笔者从零基础学习系统安全相关内容的笔记，如果您对系统安全、逆向分析等内容感兴趣或者想要了解一些内容，欢迎关注。本系列文章将会随着笔者在未来三年的读研过程中持续更新，由于笔者现阶段还处于初学阶段，不可避免参照复现各类书籍内容，如书籍作者认为侵权请告知，笔者将立刻删除。强调本系列所有内容仅作为学习研究使用，作者对此文章中的代码造成的任何后果不负法律责任。
1801vp1-037最小化原理图：仅RPLY逆向工程分析
资源摘要信息:"037_RPLY_Only_1801vp1-037_reverseengineering_" 1. 逆向工程的基础概念 逆向工程是指对某个产品、系统、软件或任何其他形式的工件进行分析，目的是理解其工作原理、设计、功能和操作方法。在本资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值