官方bilibiliWindows破解入门Android逆向入门
【网络诊断修复工具】切换到窄版

吾爱破解 - 52pojie.cn

 找回密码
 注册[Register]

QQ登录

只需一步，快速开始

吾爱破解 - 52pojie.cn»网站 › 【 软件安全 】 › 『脱壳破解区』 › 新手的第一个CTF逆向
12下一页
返回列表 发新帖
查看: 256|回复: 12
上一主题 下一主题
收起左侧

[CTF] 新手的第一个CTF逆向

  [复制链接]
Nevvb1e251111
跳转到指定楼层
楼主
Nevvb1e251111 发表于 2026-3-17 22:35 回帖奖励
本帖最后由 Nevvb1e251111 于 2026-3-17 22:39 编辑

【说明】本人纯新手，找了一个特别简单的逆向题做了一下，其实大部分是靠蒙和AI，简单记录一下。有哪些不对的还请大佬批评指正。

文件地址https://wwbfl.lanzouu.com/iD9Z03kv4s3a
文件是一个elf文件，用Exeinfo看了一下有upx壳。不会手动脱，直接用工具了。


拖进IDA分析，找关键词

输入flag，输出正确or错误，感觉sub_400E28是主函数，跟进去看一下

看了一下，感觉sub_4009AE是用来验证的函数，继续跟进

[C] 纯文本查看 复制代码
__int64 __fastcall sub_4009AE(__int64 a1)
{
  __int64 result; // rax@2

  if ( 1629056 * *(_BYTE *)a1 == 166163712 )
  {
    if ( 6771600 * *(_BYTE *)(a1 + 1) == 731332800 )
    {
      if ( 3682944 * *(_BYTE *)(a1 + 2) == 357245568 )
      {
        if ( 10431000 * *(_BYTE *)(a1 + 3) == 1074393000 )
        {
          if ( 3977328 * *(_BYTE *)(a1 + 4) == 489211344 )
          {
            if ( 5138336 * *(_BYTE *)(a1 + 5) == 518971936 )
            {
              if ( 7532250 * *(_BYTE *)(a1 + 7) == 406741500 )
              {
                if ( 5551632 * *(_BYTE *)(a1 + 8) == 294236496 )
                {
                  if ( 3409728 * *(_BYTE *)(a1 + 9) == 177305856 )
                  {
                    if ( 13013670 * *(_BYTE *)(a1 + 10) == 650683500 )
                    {
                      if ( 6088797 * *(_BYTE *)(a1 + 11) == 298351053 )
                      {
                        if ( 7884663 * *(_BYTE *)(a1 + 12) == 386348487 )
                        {
                          if ( 8944053 * *(_BYTE *)(a1 + 13) == 438258597 )
                          {
                            if ( 5198490 * *(_BYTE *)(a1 + 14) == 249527520 )
                            {
                              if ( 4544518 * *(_BYTE *)(a1 + 15) == 445362764 )
                              {
                                if ( 3645600 * *(_BYTE *)(a1 + 17) == 174988800 )
                                {
                                  if ( 10115280 * *(_BYTE *)(a1 + 16) == 981182160 )
                                  {
                                    if ( 9667504 * *(_BYTE *)(a1 + 18) == 493042704 )
                                    {
                                      if ( 5364450 * *(_BYTE *)(a1 + 19) == 257493600 )
                                      {
                                        if ( 13464540 * *(_BYTE *)(a1 + 20) == 767478780 )
                                        {
                                          if ( 5488432 * *(_BYTE *)(a1 + 21) == 312840624 )
                                          {
                                            if ( 14479500 * *(_BYTE *)(a1 + 22) == 1404511500 )
                                            {
                                              if ( 6451830 * *(_BYTE *)(a1 + 23) == 316139670 )
                                              {
                                                if ( 6252576 * *(_BYTE *)(a1 + 24) == 619005024 )
                                                {
                                                  if ( 7763364 * *(_BYTE *)(a1 + 25) == 372641472 )
                                                  {
                                                    if ( 7327320 * *(_BYTE *)(a1 + 26) == 373693320 )
                                                    {
                                                      if ( 8741520 * *(_BYTE *)(a1 + 27) == 498266640 )
                                                      {
                                                        if ( 8871876 * *(_BYTE *)(a1 + 28) == 452465676 )
                                                        {
                                                          if ( 4086720 * *(_BYTE *)(a1 + 29) == 208422720 )
                                                          {
                                                            if ( 9374400 * *(_BYTE *)(a1 + 30) == 515592000 )
                                                              result = 5759124 * *(_BYTE *)(a1 + 31) == 719890500;
                                                            else
                                                              result = 0LL;
                                                          }
                                                          else
                                                          {
                                                            result = 0LL;
                                                          }
                                                        }
                                                        else
                                                        {
                                                          result = 0LL;
                                                        }
                                                      }
                                                      else
                                                      {
                                                        result = 0LL;
                                                      }
                                                    }
                                                    else
                                                    {
                                                      result = 0LL;
                                                    }
                                                  }
                                                  else
                                                  {
                                                    result = 0LL;
                                                  }
                                                }
                                                else
                                                {
                                                  result = 0LL;
                                                }
                                              }
                                              else
                                              {
                                                result = 0LL;
                                              }
                                            }
                                            else
                                            {
                                              result = 0LL;
                                            }
                                          }
                                          else
                                          {
                                            result = 0LL;
                                          }
                                        }
                                        else
                                        {
                                          result = 0LL;
                                        }
                                      }
                                      else
                                      {
                                        result = 0LL;
                                      }
                                    }
                                    else
                                    {
                                      result = 0LL;
                                    }
                                  }
                                  else
                                  {
                                    result = 0LL;
                                  }
                                }
                                else
                                {
                                  result = 0LL;
                                }
                              }
                              else
                              {
                                result = 0LL;
                              }
                            }
                            else
                            {
                              result = 0LL;
                            }
                          }
                          else
                          {
                            result = 0LL;
                          }
                        }
                        else
                        {
                          result = 0LL;
                        }
                      }
                      else
                      {
                        result = 0LL;
                      }
                    }
                    else
                    {
                      result = 0LL;
                    }
                  }
                  else
                  {
                    result = 0LL;
                  }
                }
                else
                {
                  result = 0LL;
                }
              }
              else
              {
                result = 0LL;
              }
            }
            else
            {
              result = 0LL;
            }
          }
          else
          {
            result = 0LL;
          }
        }
        else
        {
          result = 0LL;
        }
      }
      else
      {
        result = 0LL;
      }
    }
    else
    {
      result = 0LL;
    }
  }
  else
  {
    result = 0LL;
  }
  return result;
}

这个代码应该是 每个字符都满足：系数 * 字符ASCII码 = 目标值 共31个判断条件
然后让AI写了一个脚本
[Python] 纯文本查看 复制代码
# 提取的数据（按代码中的顺序）
data = [
    (0, 1629056, 166163712),
    (1, 6771600, 731332800),
    (2, 3682944, 357245568),
    (3, 10431000, 1074393000),
    (4, 3977328, 489211344),
    (5, 5138336, 518971936),
    (7, 7532250, 406741500),
    (8, 5551632, 294236496),
    (9, 3409728, 177305856),
    (10, 13013670, 650683500),
    (11, 6088797, 298351053),
    (12, 7884663, 386348487),
    (13, 8944053, 438258597),
    (14, 5198490, 249527520),
    (15, 4544518, 445362764),
    (17, 3645600, 174988800),
    (16, 10115280, 981182160),
    (18, 9667504, 493042704),
    (19, 5364450, 257493600),
    (20, 13464540, 767478780),
    (21, 5488432, 312840624),
    (22, 14479500, 1404511500),
    (23, 6451830, 316139670),
    (24, 6252576, 619005024),
    (25, 7763364, 372641472),
    (26, 7327320, 373693320),
    (27, 8741520, 498266640),
    (28, 8871876, 452465676),
    (29, 4086720, 208422720),
    (30, 9374400, 515592000),
    (31, 5759124, 719890500),
]

# 计算每个字符
print("按代码顺序计算：")
chars = []
for idx, coeff, target in data:
    char_code = target // coeff
    remainder = target % coeff
    print(f"索引{idx:2d}: {target} / {coeff} = {char_code} (余数: {remainder}) -> '{chr(char_code)}'")
    chars.append((idx, char_code))

# 按索引排序得到flag
print("\n按索引排序后的flag：")
flag = ['?'] * 32
for idx, code in chars:
    flag[idx] = chr(code)
    print(f"flag[{idx}] = {code} -> '{chr(code)}'")

print("\n初步flag:", ''.join(flag))

最后得到的flag是flag{e?65421110ba03099a1c039337} 发现索引6缺失
又写了个爆破脚本
[Python] 纯文本查看 复制代码
flag_template = ['f','l','a','g','{','e','?','6','5','4','2','1','1','1','0',
                 'b','a','0','3','0','9','9','a','1','c','0','3','9','3','3','7','}']

possible_chars = '0123456789abcdefghijklmnopqrstuvwxyz_-'

for c in possible_chars:
    flag_template[6] = c
    flag = ''.join(flag_template)
    print(f"尝试: {flag}")

结果
尝试: flag{e065421110ba03099a1c039337}
尝试: flag{e165421110ba03099a1c039337}
尝试: flag{e265421110ba03099a1c039337}
尝试: flag{e365421110ba03099a1c039337}
尝试: flag{e465421110ba03099a1c039337}
尝试: flag{e565421110ba03099a1c039337}
尝试: flag{e665421110ba03099a1c039337}
尝试: flag{e765421110ba03099a1c039337}
尝试: flag{e865421110ba03099a1c039337}
尝试: flag{e965421110ba03099a1c039337}
尝试: flag{ea65421110ba03099a1c039337}
尝试: flag{eb65421110ba03099a1c039337}
尝试: flag{ec65421110ba03099a1c039337}
尝试: flag{ed65421110ba03099a1c039337}
尝试: flag{ee65421110ba03099a1c039337}
尝试: flag{ef65421110ba03099a1c039337}
尝试: flag{eg65421110ba03099a1c039337}
尝试: flag{eh65421110ba03099a1c039337}
尝试: flag{ei65421110ba03099a1c039337}
尝试: flag{ej65421110ba03099a1c039337}
尝试: flag{ek65421110ba03099a1c039337}
尝试: flag{el65421110ba03099a1c039337}
尝试: flag{em65421110ba03099a1c039337}
尝试: flag{en65421110ba03099a1c039337}
尝试: flag{eo65421110ba03099a1c039337}
尝试: flag{ep65421110ba03099a1c039337}
尝试: flag{eq65421110ba03099a1c039337}
尝试: flag{er65421110ba03099a1c039337}
尝试: flag{es65421110ba03099a1c039337}
尝试: flag{et65421110ba03099a1c039337}
尝试: flag{eu65421110ba03099a1c039337}
尝试: flag{ev65421110ba03099a1c039337}
尝试: flag{ew65421110ba03099a1c039337}
尝试: flag{ex65421110ba03099a1c039337}
尝试: flag{ey65421110ba03099a1c039337}
尝试: flag{ez65421110ba03099a1c039337}
尝试: flag{e_65421110ba03099a1c039337}
尝试: flag{e-65421110ba03099a1c039337}
常见的哈希值一般以e1开头，尝试flag{e165421110ba03099a1c039337} 结果正确

免费评分

参与人数 1吾爱币 +1 热心值 +1 收起 理由
gunxsword + 1 + 1 热心回复！

查看全部评分

发帖前要善用【论坛搜索】功能，那里可能会有你要找的答案或者已经有人发布过相同内容了，请勿重复发帖。
回复

举报

Nevvb1e251111
沙发
 楼主| Nevvb1e251111 发表于 2026-3-17 22:41 |楼主
最后一个图片不知道啥时候插进去的，编辑里也看不到，非常抱歉
【吾爱破解论坛总版规】 - [让你充分了解吾爱破解论坛行为规则]
回复

举报

1587704506
3#
1587704506 发表于 2026-3-18 10:00
吾爱破解论坛没有任何官方QQ群，禁止留联系方式，禁止任何商业交易。
学到了，回头我也试试
如何升级？如何获得积分？积分对应解释说明！
回复

举报

skynetHX
4#
skynetHX 发表于 2026-3-18 10:16
《站点帮助文档》有什么问题来这里看看吧，这里有你想知道的内容！
学习了，谢谢分享
呼吁大家发布原创作品添加吾爱破解论坛标识！
回复

举报

qihundanxin
5#
qihundanxin 发表于 2026-3-18 10:18
比我厉害，支持楼主
如何快速判断一个文件是否为病毒！
回复

举报

xiaosexiong
6#
xiaosexiong 发表于 2026-3-18 10:35
学到了，感谢分享
回复

举报

hhq305376030
7#
hhq305376030 发表于 2026-3-18 10:38
楼主好强，也希望楼主继续加油
回复

举报

xxx123444
8#
xxx123444 发表于 2026-3-18 10:49
学习，楼主你这个对我有用，再接再厉[加油]
回复

举报

wstcdw123
9#
wstcdw123 发表于 2026-3-18 11:01
非常厉害！可以学到很多有用之处
回复

举报

btwlon
10#
btwlon 发表于 2026-3-18 13:20
学到了，新手友好
回复

举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册[Register]

本版积分规则


免责声明：
吾爱破解所发布的一切破解补丁、注册机和注册信息及软件的解密分析文章仅限用于学习和研究目的；不得将上述内容用于商业或者非法用途，否则，一切后果请用户自负。本站信息来自网络，版权争议与本站无关。您必须在下载后的24个小时之内，从您的电脑中彻底删除上述内容。如果您喜欢该程序，请支持正版软件，购买注册，得到更好的正版服务。如有侵权请邮件与我们联系处理。

Mail To:Service@52pojie.cn

返回列表

RSS订阅|小黑屋|处罚记录|联系我们|吾爱破解 - 52pojie.cn ( 京ICP备16042023号 | 京公网安备 11010502030087号 )

GMT+8, 2026-3-18 20:01

Powered by Discuz!

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表