逆向入门学习-【Base64 编码逆向 Base64 变表逆向 IDA 动态调试 IDA 8.3 IDA 动态调试解RC4 绕过反调试 IDA 代码修复 & 数组识别 】

最新推荐文章于 2024-07-13 00:21:28 发布
最新推荐文章于 2024-07-13 00:21:28 发布
阅读量1.3k 收藏 9
点赞数 38
分类专栏： CTF-REVERSE-入门 文章标签： 学习 逆向
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llovewuzhengzi/article/details/136367715
版权

文章目录

异或

在这里插入图片描述

Base64 编码逆向

在这里插入图片描述
Base64 编码是一种用于将二进制数据转换为文本字符串的编码方式。它常用于在文本协议中传输二进制数据，或者用于存储二进制数据在文本文件中。

当遇到某些很复杂的函数时，可以寻找函数中使用到的常量，然后去搜索引擎上搜索，有可能能够找到相关源码，然后进行比对

/*base64.c*/  
#include "base64.h"  
  
unsigned char *base64_encode(unsigned char *str)  
{  
    long len;  
    long str_len;  
    unsigned char *res;  
    int i,j;  
//定义base64编码表  
    unsigned char *base64_table="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";  
  
//计算经过base64编码后的字符串长度  
    str_len=strlen(str);  
    if(str_len % 3 == 0)  
        len=str_len/3*4;  
    else  
        len=(str_len/3+1)*4;  
  
    res=malloc(sizeof(unsigned char)*len+1);  
    res[len]='\0';  
  
//以3个8位字符为一组进行编码  
    for(i=0,j=0;i<len-2;j+=3,i+=4)  
    {  
        res[i]=base64_table[str[j]>>2]; //取出第一个字符的前6位并找出对应的结果字符  
        res[i+1]=base64_table[(str[j]&0x3)<<4 | (str[j+1]>>4)]; //将第一个字符的后位与第二个字符的前4位进行组合并找到对应的结果字符  
        res[i+2]=base64_table[(str[j+1]&0xf)<<2 | (str[j+2]>>6)]; //将第二个字符的后4位与第三个字符的前2位组合并找出对应的结果字符  
        res[i+3]=base64_table[str[j+2]&0x3f]; //取出第三个字符的后6位并找出结果字符  
    }  
  
    switch(str_len % 3)  
    {  
        case 1:  
            res[i-2]='=';  
            res[i-1]='=';  
            break;  
        case 2:  
            res[i-1]='=';  
            break;  
    }  
  
    return res;  
}  
  
unsigned char *base64_decode(unsigned char *code)  
{  
//根据base64表，以字符找到对应的十进制数据  
    int table[]={0,0,0,0,0,0,0,0,0,0,0,0,
    		 0,0,0,0,0,0,0,0,0,0,0,0,
    		 0,0,0,0,0,0,0,0,0,0,0,0,
    		 0,0,0,0,0,0,0,62,0,0,0,
    		 63,52,53,54,55,56,57,58,
    		 59,60,61,0,0,0,0,0,0,0,0,
    		 1,2,3,4,5,6,7,8,9,10,11,12,
    		 13,14,15,16,17,18,19,20,21,
    		 22,23,24,25,0,0,0,0,0,0,26,
    		 27,28,29,30,31,32,33,34,35,
    		 36,37,38,39,40,41,42,43,44,
    		 45,46,47,48,49,50,51
    	       };  
    long len;  
    long str_len;  
    unsigned char *res;  
    int i,j;  
  
//计算解码后的字符串长度  
    len=strlen(code);  
//判断编码后的字符串后是否有=  
    if(strstr(code,"=="))  
        str_len=len/4*3-2;  
    else if(strstr(code,"="))  
        str_len=len/4*3-1;  
    else  
        str_len=len/4*3;  
  
    res=malloc(sizeof(unsigned char)*str_len+1);  
    res[str_len]='\0';  
  
//以4个字符为一位进行解码  
    for(i=0,j=0;i < len-2;j+=3,i+=4)  
    {  
        res[j]=((unsigned char)table[code[i]])<<2 | (((unsigned char)table[code[i+1]])>>4); //取出第一个字符对应base64表的十进制数的前6位与第二个字符对应base64表的十进制数的后2位进行组合  
        res[j+1]=(((unsigned char)table[code[i+1]])<<4) | (((unsigned char)table[code[i+2]])>>2); //取出第二个字符对应base64表的十进制数的后4位与第三个字符对应bas464表的十进制数的后4位进行组合  
        res[j+2]=(((unsigned char)table[code[i+2]])<<6) | ((unsigned char)table[code[i+3]]); //取出第三个字符对应base64表的十进制数的后2位与第4个字符进行组合  
    }  
  
    return res;  
  
}

Base64 变表逆向

在这里插入图片描述

IDA 动态调试 IDA 8.3

我们可以通过动态调试知道某些值或者其变化，也可以通过观察函数前后相关值的变化进而猜测其功能

在Windows机器上运行IDA可以直接动态调试exe文件，但不可以调试elf文件。
如果需要调试elf文件需要选择远程调试

远程调试参考链接

将Windows上的IDA的服务器组件移动到Ubuntu上去

在这里插入图片描述
linux_server：在Linux计算机上执行的、用于调试32位Linux应用程序的服务器组件。
linux_server64：在64位Linux计算机上执行的、用于调试64位Linux应用程序的服务器组件。

运行组件

根据要调试的elf文件类型运行不同组件
在这里插入图片描述

IDA选择调试器

在这里插入图片描述

选择设置

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

相关动态调试功能

在这里插入图片描述
run to cursor：运行到光标

快捷键A：尝试将一段数据制定为字符串字面量（String Literal）

IDA 动态调试解RC4

在这里插入图片描述
也是根据输入输出来猜测

绕过反调试

int __cdecl main_0(int argc, const char **argv, const char **envp)
{
  int j; // [esp+31Ch] [ebp-69Ch]
  int i; // [esp+328h] [ebp-690h]
  size_t v6; // [esp+334h] [ebp-684h]
  char v7[55]; // [esp+340h] [ebp-678h]
  char v8; // [esp+377h] [ebp-641h]
  unsigned int v9; // [esp+380h] [ebp-638h]
  int v10; // [esp+38Ch] [ebp-62Ch]
  char Str[520]; // [esp+398h] [ebp-620h] BYREF
  char v12[264]; // [esp+5A0h] [ebp-418h] BYREF
  char v13[264]; // [esp+6A8h] [ebp-310h] BYREF
  char v14[516]; // [esp+7B0h] [ebp-208h] BYREF

  __CheckForDebuggerJustMyCode(&unk_49C00F);
  j__memset(v14, 0, 0x200u);
  j__memset(v13, 0, 0x100u);
  j__memset(v12, 0, 0x100u);
  j__memset(Str, 0, 0x200u);
  v10 = 0;
  v9 = 0;
  v7[0] = -28;
  v7[1] = 21;
  v7[2] = -60;
  v7[3] = -19;
  v7[4] = -90;
  v7[5] = 47;
  v7[6] = 86;
  v7[7] = 16;
  v7[8] = -69;
  v7[9] = 19;
  v7[10] = -21;
  v7[11] = -83;
  v7[12] = 117;
  v7[13] = 86;
  v7[14] = -57;
  v7[15] = -69;
  v7[16] = -69;
  v7[17] = -23;
  v7[18] = -71;
  v7[19] = -52;
  v7[20] = 2;
  v7[21] = 58;
  v7[22] = 80;
  v7[23] = -97;
  v7[24] = 54;
  v7[25] = -112;
  v7[26] = 105;
  v7[27] = -66;
  v7[28] = 124;
  v7[29] = 66;
  v7[30] = 68;
  v7[31] = -54;
  v7[32] = -58;
  v7[33] = -44;
  v7[34] = 36;
  v7[35] = 92;
  v7[36] = -46;
  v7[37] = -71;
  v7[38] = 36;
  v7[39] = -63;
  v7[40] = 24;
  v7[41] = -109;
  v7[42] = -77;
  v7[43] = -22;
  sub_42F057(v14);
  sub_42C40B("Welcome!! give me your flag:\n");
  do
  {
    v8 = j_j_j___fgetchar();
    if ( v8 == 10 )
      break;
    Str[v9++] = v8;
  }
  while ( (int)v9 < 44 );
  if ( v9 >= 0x200 )
    j____report_rangecheckfailure();
  Str[v9] = 0;
  v6 = j__strlen(Str);
  sub_42CEFB(v13, v14, v6);
  for ( i = 0; i < 256; ++i )
    v12[i] = v13[i];
  sub_42D5B8(v13, Str, v6);
  for ( j = 0; j < 44; ++j )
  {
    if ( v7[j] == Str[j] )
      ++v10;
  }
  if ( v10 == 44 )
    sub_42C40B("Yes, u right!\n");
  else
    sub_42C40B("no no no\n");
  sub_42D0CC("pause");
  return 0;
}

反调试函数

  __CheckForDebuggerJustMyCode(&unk_49C00F);
………
………
  sub_42F057(v14);

sub_42f057()

_BYTE *__cdecl sub_4325D0(_BYTE *a1)
{
  HWND ForegroundWindow; // eax
  unsigned __int64 v2; // rax
  unsigned __int64 v3; // rax
  int v5; // [esp+25Ch] [ebp-438h]
  CHAR String[1028]; // [esp+28Ch] [ebp-408h] BYREF

  if ( IsDebuggerPresent() )
    *a1 = 89;
  else
    *a1 = 88;
  ForegroundWindow = GetForegroundWindow();
  GetWindowTextA(ForegroundWindow, String, 1023);
  if ( j__strstr(String, "WinDbg")
    || j__strstr(String, "x64dbg")
    || j__strstr(String, "x32dbg")
    || j__strstr(String, "OllyICE")
    || j__strstr(String, "OllyDBG")
    || j__strstr(String, "Immunity") )
  {
    a1[1] = 111;
  }
  else
  {
    a1[1] = 48;
  }
  SetLastError((DWORD)"12345");
  OutputDebugStringW("Test for debugger!");
  if ( (char *)GetLastError() == "12345" )
    a1[2] = 110;
  else
    a1[2] = 117;
  if ( !CloseHandle((HANDLE)0x1234) && GetLastError() == 6 )
    a1[3] = 66;
  else
    a1[3] = 65;
  if ( NtCurrentPeb()->BeingDebugged )
    a1[4] = 97;
  else
    a1[4] = 64;
  v2 = __rdtsc();
  v5 = v2;
  v3 = __rdtsc();
  if ( (unsigned int)(v3 - v5) >= 0xFF )
    a1[5] = 100;
  else
    a1[5] = 68;
  a1[6] = 0;
  return a1;
}

此时需要使用atttach调试来绕过反调试
核心就是使得程序在非调试条件下正常运行过调试函数后再介入调试
先用IDA打开对应文件，在反调试函数后同时是exe此时还没运行的地方下断点
在这里插入图片描述

选择调试器
在这里插入图片描述
直接运行exe文件
在这里插入图片描述
在这里插入图片描述
选择对应运行的exe文件
在这里插入图片描述
此时程序会固定停在此处
在这里插入图片描述
然后continue
在这里插入图片描述
然后输入
在这里插入图片描述
停在之前所设断点处
在这里插入图片描述
此时即可调试了

IDA 代码修复 & 数组识别

根据某些暗示将数组合并为一个大数组

可以先根据熟悉函数判断相关变量类型进而确定某些函数的参数类型
根据陌生函数实际用处和定义来修改参数类型和返回值类型

看星猩的柴狗
关注
专栏目录
IDA动态调试
liulala987的博客
09-11 744
通用寄存器：共有rax、rbx、rcx、rdx、rsi、rdi、rbp、rsp、r8、r9、r10、r11、r12、r13、r14、r15这16个寄存器，CPU对它们的用途没有做特殊规定，可以自定义其用途（其中rsp、rbp这两个寄存器有特殊用途）。其中，rsp栈顶寄存器以及rbp栈基寄存器都和函数调用栈相关，其中rsp寄存器一般用来存放函数调用栈的栈顶在内存中的地址，rbp寄存器通常用来存放函数的栈帧在内存中的起始地址。点击带有绿色三角符号的Start process即可开始调试程序。
base64算法逆向分析
xiaokong的专栏
04-22 1864
BASE64编码代码分析： 00401000 /$ 55 push ebp 00401001 |. 8BEC mov ebp,esp 00401003 |. 53 push ebx 00401004 |. 57 push edi 00401005 |. 56 push
base64逆向加密分析
最新发布
m0_62280492的博客
07-13 1223
CTF逆向中常见的base64加密分析
BASE64编码原理分析脚本实现及逆向案例
xiaoi123的博客
11-28 725
BASE64编码原理分析脚本实现及逆向案例 0x01 简单介绍 数据传送时并不支持所有的字符，很多时候只支持可见字符的传送。但是数据传送不可能只传送可见字符为解决这个问题就诞生了base64编码。base64编码将所有待编码字符转换成64个可见字符表中的字符。 0x02 编码原理 被Base64编码之后所得到的所有字符都是在以下这个表当中的。 上表中总共有64个字符，2^6=...
reverse逆向算法之base64和RC4
yhfgs的博客
10-12 1788
目录 一.base64 二.RC4加密 一.base64 1.简述： base64是逆向很常见，也很简单的算法，基本上是新手CTF必备。 2.主要原理： 将三个八位的字符转化位四个六位的二进制数（不足八位，高位补0），在通过查表来转化为字符。 （众所周知，一个字符通常可以由八个二进制数来表示，例如：a 他的ascii码为0x61，转化为二进制数为：0110 0001） 例如，将"abc'进行base64加密. 将abc转化为二进制数为01100001 01100010 011000.
JS逆向之 Base64 加密算法特征全方位解析
小鱼神1024的博客
06-24 1320
逆向过程中，`Base64` 加密特征是常见的特征，但是你知道： - `Base64` 加密算法的特征是什么？ - 如何多场景快速使用 `Base64` 加密算法？ - 如何手写 `Base64` 加密算法，了解其实现原理? - 如何魔改 `Base64` 加密算法，实现自定义加密规则？
反编译工具IDA Freeware 7.6以及Qt5 程序初步逆向分析+解析脚本
01-09
《反编译与逆向分析：IDA Freeware 7.6与Qt5程序解析》 在信息安全和软件调试领域，逆向工程是一项重要的技术。它允许我们理解原本封闭的二进制代码，揭示其内部工作机制。本文将深入探讨反编译工具IDA Freeware ...
2019ctf变形金刚ida分析RC4和Base64魔改过程.zip
04-01
获取RC4的密钥算法\Base64魔改部分。对应加解密的掌握有极大的帮助
IDA pro逆向工具的使用以及逆向分析程序实例操作
04-18
3.加密编码算法 包括base64变表编码和简单异或加密解密案例并带有加解密源码 4.动态调试 包括动态调试解密案例 5.脱壳处理 包括解压壳脱壳解密案例 6.附带4个解密案例程序，包括三个exe文件和一个linux程序的逆向...
C++软件调试与异常排查从入门到精通系列文章汇总
热门推荐
dvlinker的技术专栏
06-29 17万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
IDA调试脱壳用例
05-24
IDA调试脱壳用例
针对自定义码表的Base64简单思路-易语言
06-14
首先来看一个列子 如图这是一个随机打乱码表的小列子 运行后谁也不知道码表是什么样子的 常见在配置项保存时候 或者 tcp协议传输加密 使用 先来简单判断下长度 如图所示 加密同样的文本 长度是一样的 在来对比下 标准的B64加密后是什么样子的 标准加密  ：MTIzNDU2 软件加密1：Kdx9Jhke 软件加密2：vB6fNbGW 长度是一样的 在来判断下 加密123123是什么情况 加密1： Kdx9 Kdx9 加密2： vB6f vB6f 可以看到 2组有重复的特征 基本可以断定是简单的码表打乱 下面来说下猜解码表的思路 标准的B64加密123123结果是 MTIz MTIz 标准  ：  MTIz MTIz 加密1： Kdx9 Kdx9 加密2： vB6f vB6f 通过对比可以得知  在标准编码表里的M对应 加密1的编码里的K  对面加密2的编码里的v （注意是区分大小写的） 是存在对应关系的 那么如果我们来几个文本 加密后的密文 包含了所有的码表字符 去进行对比 自定义码表是不是就出来了呢 经过实际测试是可以的 有图为真 如果每次加密限制了长度呢 分次提交 也就是多了几次而已 然后计算 也就是逐字对应 然后按标准码表顺序输出
安卓逆向——Ida 动态调试
含笑
04-22 560
Ida 动态调试 本文的使用的IDA_Pro_v7.0_Portable 版本，下面介绍一下动态调试so文件的流程： 1. 在IDA的安装路径中找到android_server文件 # 查看手机型号 arm64-v8a adb shell getprop ro.product.cpu.abi 2. 将android_server拷贝到手机的/data/local/tmp目录下面 # 进入对应的文件夹，把文件push到手机 adb push android_server64 ...
CTF - Base64换表
JiangBuLiu的博客
06-07 4831
Base64换表原题复制保存为16进制即可得文件IDA显示题目解读提示：base64程序逆向特点Base64算法特征Base64表格位移等号补位结论Base64变体之 - 换表Base64变体解法在线编码转化Python脚本 原题 复制保存为16进制即可得文件 7F 45 4C 46 02 01 01 00 00 00 00 00 00 00 00 00 03 00 3E 00 01 00 00 00 10 06 00 00 00 00 00 00 40 00 00 00 00 00 00 00 28 11
base64反汇编
qq_35289660的博客
04-12 1339
base64反汇编 文章目录base64反汇编1.C语言代码（base64加密）2.base64反汇编3.对比分析 1.C语言代码（base64加密） #include<stdio.h> #include<string.h> #include<stdlib.h> void jiami(char x,char y,char z); char s[100]; i...
CTF-reverse-simpleRE（base64变表逆向）
这个博主不懒，但Ta什么也没写~（私信互关24小时必回）
04-22 998
看下来似乎是很复杂的加密，但有经验的话从特征不难识别出来是base64加密，比如红框里的三个经典等号（ASCII码是61）和循环里的位移操作。下载得到的文件使用ida64分析，如果报错就换ida32，得到分析结果，有main函数就先看main。密文中第一个字符是5，在换表中的索引（下标）为19，而在标准表中，索引19处的字符为【密文中第二个字符是M，在换表中的索引（下标）为37，而在标准表中，索引19处的字符为【这个数组，双击跟进看内容，这字符一看就base64了，而且是魔改换表版本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

看星猩的柴狗

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

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

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

打赏作者

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

抵扣说明：

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

余额充值