周赛博客篇

最新推荐文章于 2024-09-16 17:46:36 发布
最新推荐文章于 2024-09-16 17:46:36 发布
阅读量122 收藏
点赞数
文章标签： c++ 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74375241/article/details/130410252
版权
本文描述了一次逆向工程分析过程，涉及使用ida64对64位程序进行查壳和反编译。文章详细讲解了如何分析三个加密函数，包括SHA1哈希、简单的异或操作以及Base64解码，并给出了相应的解密脚本。最后，利用z3求解器解密了一组方程组，得到了最终的解密结果。
摘要由CSDN通过智能技术生成

easy-re

下载完后进行查壳，如下图，发现无壳且为64位程序用ida64打开
在这里插入图片描述
进去查看字符串发现了几组字符串看着挺可疑但是嘶好像光看这没啥用
在这里插入图片描述
然后接下来看反编译分析了一波是有三个加密的fun函数
在这里插入图片描述
接着就从fun1开始分析到fun3结束，接下来先看fun1加密函数，fun1我们可以看出他是哈希算法的sha1加密，而在主函数中，这里加密后的字符串为f7fae20f2f0b7facff1281fdd1e8fdf6d14cd4c1

int __fastcall fun1(unsigned __int8 *a1, __int64 a2, char *a3)
{
  __int64 v3; // rdx
  int result; // eax
  unsigned int v5[8]; // [rsp+20h] [rbp-70h] BYREF
  unsigned __int8 v6[68]; // [rsp+40h] [rbp-50h] BYREF
  unsigned int v7; // [rsp+84h] [rbp-Ch]
  unsigned int Size; // [rsp+88h] [rbp-8h]
  unsigned int Size_4; // [rsp+8Ch] [rbp-4h]

  v5[0] = 1732584193;
  v5[1] = -271733879;
  v5[2] = -1732584194;
  v5[3] = 271733878;
  v5[4] = -1009589776;
  for ( Size = a2; Size > 0x3F; Size -= 64 )
  {
    v3 = a2 - Size;
    *(_QWORD *)v6 = *(_QWORD *)&a1[v3];
    *(_QWORD *)&v6[8] = *(_QWORD *)&a1[v3 + 8];
    *(_QWORD *)&v6[16] = *(_QWORD *)&a1[v3 + 16];
    *(_QWORD *)&v6[24] = *(_QWORD *)&a1[v3 + 24];
    *(_QWORD *)&v6[32] = *(_QWORD *)&a1[v3 + 32];
    *(_QWORD *)&v6[40] = *(_QWORD *)&a1[v3 + 40];
    *(_QWORD *)&v6[48] = *(_QWORD *)&a1[v3 + 48];
    *(_QWORD *)&v6[56] = *(_QWORD *)&a1[v3 + 56];
    round(v6, v5);
  }
  if ( Size <= 0x37 )
  {
    memset(v6, 0, 0x40ui64);
    memcpy(v6, &a1[a2 - Size], Size);
    v6[Size] = 0x80;
    for ( Size_4 = 56; Size_4 <= 0x3F; ++Size_4 )
      v6[Size_4] = (8 * a2) >> (8 * (63 - (unsigned __int8)Size_4));
  }
  else
  {
    memset(v6, 0, 0x40ui64);
    memcpy(v6, &a1[a2 - Size], Size);
    v6[Size] = 0x80;
    round(v6, v5);
    memset(v6, 0, 0x40ui64);
    for ( Size_4 = 56; Size_4 <= 0x3F; ++Size_4 )
      v6[Size_4] = (8 * a2) >> (8 * (63 - (unsigned __int8)Size_4));
  }
  result = round(v6, v5);
  for ( Size_4 = 0; Size_4 <= 0x13; ++Size_4 )
  {
    v7 = (unsigned __int8)(v5[Size_4 >> 2] >> (8 * (~(_BYTE)Size_4 & 3)));
    result = sprintf(&a3[2 * Size_4], "%02x", v7);
  }
  return result;
}

但由于是周赛所以flag的格式是一定的都是SLsec{，这样前六位就可以确定下来了，接下来就是脚本问题了，这个爆破脚本找了好多表示找不到根本找不到，所以这里就只能借鉴学长给的脚本了

import hashlib
known_prefix = "SLsec{"
known_hash = "f7fae20f2f0b7facff1281fdd1e8fdf6d14cd4c1"

# 枚举后两位字符
for i in range(256):
    for j in range(256):
        candidate = known_prefix + chr(i) + chr(j)
        candidate_hash = hashlib.sha1(candidate.encode()).hexdigest()
        if candidate_hash == known_hash:
            print("Found the original string: ", candidate)
            exit()

运行结果为SLsec{co，第一段ok接下来我们看第二个加密函数fun2

char *__fastcall fun2(char *a1, char *a2)
{
  char *result; // rax
  size_t v3; // [rsp+20h] [rbp-10h]
  size_t i; // [rsp+28h] [rbp-8h]

  v3 = strlen(a1);
  for ( i = 0i64; i < v3; ++i )
    a2[i] = (a1[i] ^ 0x66) + 66;
  result = &a2[v3];
  a2[v3] = 0;
  return result;
}

这里就是一个简单的异或，加密后的字符串为JBUWED{WK，所以这里写一个简单的异或脚本``

def decrypt(a2):
    v3 = len(a2)
    a1 = bytearray(v3)

    for i in range(v3):
        a1[i] = (a2[i] - 66) ^ 0x66

    return a1.decode('utf-8')

encrypted_str = "JBUWED{WK"
decrypt_attempt = decrypt(encrypted_str.encode('utf-8'))

print(decrypt_attempt)

运行结果为nfused_so
在这里插入图片描述
最后看fun3加密函数，加密后的字符串为WPrYVgNoQx6vTPNuU8e!，再点进去函数里面看看发现是base表换了的base64但还是base64加密，这里找一个在线网站base64自定义解码
fun3加密函数为

_BYTE *__fastcall fun3(const unsigned __int8 *a1, int a2)
{
  int v3; // eax
  int v4; // eax
  int v5; // eax
  int v6; // eax
  int v7; // eax
  char v8[72]; // [rsp+20h] [rbp-60h] BYREF
  _BYTE *v9; // [rsp+68h] [rbp-18h]
  int v10; // [rsp+74h] [rbp-Ch]
  int v11; // [rsp+78h] [rbp-8h]
  int i; // [rsp+7Ch] [rbp-4h]

  strcpy(v8, "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz+/@!#$");
  v10 = 4 * ((a2 + 2) / 3);
  v9 = malloc(v10 + 1);
  if ( !v9 )
    return 0i64;
  i = 0;
  v11 = 0;
  while ( i < a2 )
  {
    v9[v11] = v8[a1[i] >> 2];
    if ( a2 <= i + 1 )
      v3 = 0;
    else
      v3 = a1[i + 1] >> 4;
    v9[v11 + 1] = v8[(16 * a1[i]) & 0x30 | v3];
    if ( a2 <= i + 1 )
    {
      v5 = 0;
    }
    else
    {
      if ( a2 <= i + 2 )
        v4 = 0;
      else
        v4 = a1[i + 2] >> 6;
      v5 = (4 * a1[i + 1]) & 0x3C | v4;
    }
    v9[v11 + 2] = v8[v5];
    if ( a2 <= i + 2 )
      v6 = 0;
    else
      v6 = a1[i + 2] & 0x3F;
    v9[v11 + 3] = v8[v6];
    i += 3;
    v11 += 4;
  }
  for ( i = a2; i % 3; ++i )
  {
    v7 = v11++;
    v9[v7] = 61;
  }
  v9[v11] = 0;
  return v9;
}

解密后为ul_run_quietly}
在这里插入图片描述
所以第三段flag为ul_run_quietly}，所以将三段flag何在一起也就是SLsec{confused_soul_run_quietly}

你会解方程组不会

查壳无壳用ida打开，进入主函数的反编译
image-20230422001942638
for循环是对输入的字符出进行异或加密，然后看v1，是一个if函数，函数里面是一堆方程组，然后用z3方程组解密即可

from z3 import *

v2 = Int('a2')
v3 = Int('a3')
v4 = Int('a4')
v5 = Int('a5')
v6 = Int('a6')
v7 = Int('a7')
v8 = Int('a8')
v9 = Int('a9')
v10 = Int('a10')
v11 = Int('a11')
v12 = Int('a12')
v13 = Int('a13')
v14 = Int('a14')
v15 = Int('a15')
s = Solver()

s.add(15 * v11
     + -36 * v10
     + 13 * v9
     + 25 * v8
     + 43 * v6
     + 65 * v4
     + 88 * v2
     + 67 * v3
     - 5 * v5
     + 89 * v7
     + 11 * v12
     + 47 * v13
     - 60 * v14
     + 29 * v15 == 22748,
     -41 * v13
     + 2 * v12
     + 8 * v11
     + 7 * v3
     + 89 * v2
     + 12 * v4
     - 25 * v5
     + 41 * v6
     + 23 * v7
     + 20 * v8
     - 66 * v9
     + 31 * v10
     - 39 * v14
     + 17 * v15 == 7258,
     -34 * v14
     + 90 * v13
     + 101 * v12
     + -33 * v10
     + 15 * v9
     + 27 * v8
     + 53 * v6
     + 35 * v3
     + 28 * v2
     + 16 * v4
     - 65 * v5
     + 39 * v7
     + 13 * v11
     + 23 * v15 == 26190,
     (v9 * 128)
     + 81 * v7
     + -59 * v5
     + 35 * v4
     + 34 * v3
     + 23 * v2
     + 49 * v6
     + 25 * v8
     - 32 * v10
     + 75 * v11
     + 81 * v12
     + 47 * v13
     - 60 * v14
     + 29 * v15 == 37136,
     90 * v8
     + 79 * v7
     + 42 * v6
     + -52 * v5
     + 35 * v4
     + 97 * v3
     + 38 * v2
     + 23 * v9
     - 36 * v10
     + 57 * v11
     + 81 * v12
     + 42 * v13
     - 62 * v14
     - 11 * v15 == 27915,
     -61 * v14
     + 41 * v12
     + -26 * v10
     + 49 * v7
     + 47 * v6
     + -45 * v5
     + 35 * v4
     + 22 * v2
     + 27 * v3
     + 29 * v8
     + 18 * v9
     + 35 * v11
     + 40 * v13
     + 28 * v15 == 17298,
     43 * v13
     + 76 * v12
     + 34 * v11
     + -47 * v10
     + 85 * v9
     + 23 * v8
     + 86 * v7
     + -42 * v6
     + 45 * v3
     + 12 * v2
     + 35 * v4
     - 9 * v5
     - 44 * v14
     + 65 * v15 == 19875,
     57 * v13
     + 25 * v11
     + -30 * v10
     + 86 * v8
     + 79 * v7
     + 35 * v4
     + 62 * v3
     + 79 * v2
     - 85 * v5
     + 33 * v6
     + 14 * v9
     + 11 * v12
     - 50 * v14
     - 9 * v15 == 22784,
     47 * v13
     + 2 * v12
     + -36 * v10
     + 2 * v8
     + 29 * v7
     + (v4 * 64)
     + 8 * v2
     + 6 * v3
     - 85 * v5
     + 73 * v6
     + 23 * v9
     + 5 * v11
     - (v14 * 64)
     + 27 * v15 == 9710,
     41 * v12
     + -38 * v10
     + -51 * v5
     + 68 * v4
     + -68 * v3
     + 67 * v2
     - 43 * v6
     + 81 * v7
     + 22 * v8
     - 12 * v9
     + 75 * v11
     + 27 * v13
     - 52 * v14
     + 31 * v15 == 13376,
    -67 * v14
     + 31 * v12
     + 15 * v9
     + -51 * v5
     + 63 * v3
     + 85 * v2
     + 5 * v4
     + 44 * v6
     + 36 * v7
     + 28 * v8
     - 6 * v10
     + 45 * v11
     + 7 * v13
     + 78 * v15 == 24065,
     43 * v13
     + -35 * v10
     + 25 * v8
     + 43 * v6
     + 47 * v2
     + (v3 * 64)
     + 66 * v4
     - 5 * v5
     + 112 * v7
     + 13 * v9
     + 95 * v11
     + 21 * v12
     - 61 * v14
     + 20 * v15 == 27687,
      -61 * v14
     + 47 * v13
     + 89 * v12
     + 14 * v11
     + -92 * v10
     + 56 * v9
     + 23 * v8
     + 89 * v7
     + 49 * v6
     + -25 * v5
     + 85 * v4
     + 67 * v3
     + 89 * v2
     - 29 * v15 == 29250,
    -60 * v14
     + 51 * v12
     + 16 * v11
     + 12 * v9
     + 25 * v8
     + -43 * v6
     + 34 * v3
     + 95 * v2
     + 62 * v4
     - 9 * v5
     + 83 * v7
     - 36 * v10
     + 47 * v13
     - 24 * v15 == 15317)

if 'un' not in str(s.check()):
    print(s.model())   #输出解

这里解出了方程组的解，但是要注意有些数据换了位置所以要把数据调整后在进行for循环的异或解密，异或脚本如下

direct ={       
     13 : 74,
     3 : 24,
     4 : 119,
     10 : 108,
     12 : 88,
     7 : 43,
     14 : 88,
     9 : 91,
     6 : 104,
     5 : 7,
     8 : 28,
     15 : 33,
     2 : 10,
     11 : 52}
flag = [0 for i in range(15)]
for i in direct:
    flag[i-2] = direct[i]  

for i in range(13, -1, -1):
    flag[i] ^= flag[i + 1]   
flag_str = ''
for i in range(14):
     flag_str += chr(flag[i])
print(flag_str)

运行两端脚本后即可得出flagSLsec{U_G07_th3_k3y!}
但是这里要注意的是在运用z3模块的时候要下载z3和z3-solve两个模块，这样才能保证脚本的正常运行

总结

我是小趴菜！！！！

skdnsj
关注
CSDN 周赛 59 期
文盲的专栏
06-22 497
一如既往的填空题，以及新鲜出炉的带坑编程题
Leetcode周赛记录
一名正在成长的程序员
09-29 3999
开这篇博客的目的就是激励自己不断进步。 2019年9月22日 155场周赛 419名/1602名，刷题记录：题目1完成。 2019年9月29日 156场周赛 242/1432，通过题目：题目1，题目2，题目3。 ...
reverse-BUUCTF
song_10的博客
08-26 1374
1、easyre ida中搜索字符串即可得到flag： 2、helloword 拿到是apk文件，jeb中打开，即可得到flag 3、reverse1 elf文件，IDA中打开，搜索字符串 定位到判断函数： 查看伪代码： __int64 sub_1400118C0() { char *v0; // rdi signed __int64 i; // rcx ...
CSDN周赛回顾
文盲的专栏
05-25 1090
得之我幸，失之我命
CSDN 每日一练及周赛介绍
文盲的专栏
06-21 1414
期待各位小伙伴能将老顾不懂的CSDN每日一练题目破解
VJ个人周赛
Mango.
12-11 430
VJ个人周赛
个人博客详细文章目录索引(持续更新)
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
01-26 7667
本索引目录会一直不断进行更新…最近更新时间：2022.6.7 16:38物联网：2020后半段时间学习的javaweb学习笔记可见语雀(当时记录在那里就不搬过来了)：语雀-Javaweb对应尚硅谷的Spring5学习笔记：语雀-框架/Spring5对应黑马SpringMVC教程学习笔记：语雀-框架/SpringMVC对应黑马SpringMVC教程学习笔记：语雀-框架/MybatisMyBatis插件：...................................................
leetcode周赛226，以及关于博客的杂感
hnZone
01-31 147
今天第一次做Leetcode周赛，226。 里面同样有一些很细小的点。比如一个简单的模拟里，前缀天数的天数少算了第0天。int的溢出又没有考虑到。 也可以用python很优美地解决第一题。 但是同之前水过的很多题解博客一样，这些点子虽然是很关键的，但是作为博客分散着发出来，似乎并不会对知识本身起到良好的巩固作用。在浅层上又重复一遍，无异于浪费时间。这正是之前的很多博客所做的事情。 一篇好的博客往往需要对所需要阐述的内容深刻的了解。没有深入全面的了解和理解，不能写出有用的东西来。 这和问答是不一样的。由于问答
力扣第59场双周赛与第255场周赛总结解析
YiQiesang的博客
08-23 579
力扣第59场双周赛与第255场周赛总结解析 date: 2021-08-22 15:19:02 tags: [dfs,数学,图,竞赛,总结] categories: 算法 个人博客题解地址 经过昨晚的双周赛以及今日午时的周赛，继续感到自己的实力薄弱。双周赛一题，周赛两题。什么时候我也能来个AC呢？不说了，直接开始总结分析吧。 （吐槽一下力扣官方的网络运维，怎么最近一直被攻击，包括我写这篇题解的时候，网页都打不开了……） 力扣双周赛 使用特殊打字机键入单词的最少时间 这道题利用简单的数学知识.
题解 2020级HAUT新生周赛（二）
Love_Jacques的博客
12-08 3309
题解 2020级HAUT新生周赛（二）
Java 学习路线大全，再也不用迷路啦（持续更新）
腾讯全栈-ITCJF
10-14 2758
路线特点 最新，完整一条龙，从入门到入土（⭐ 表示推荐学习） 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 划分阶段、更有计划，且在最后给出持续学习的方向、探索 Java 程序员发展的无限可能 前言 首先呢，我们要了解 Java 的应用场景和就业方向，看看和自己的学习目的是否一致，目前，Java 的岗位需求多，是后台开发的主流编程语言，功能强大，还是很值得学习的。 阶段 1：Java 入门 目标 培养兴趣、快速上手 前期准备 准备好一款在线、随时随地
大厂程序员手把手教你如何写简历（附简历模板）
m0_67266787的博客
05-20 644
代码随想录刷题网站上线咯：programmercarl.com，200道力扣题目刷题顺序，详细题解，支持C++、Java、Python、Go、JS等多语言版本，一个你只要发现，就会收藏的硬核算法学习网站。 文章目录 简历基调 谨慎使用精通两字 拿不准的绝对不要写在简历上 项目经验应该如何写 博客的重要性 简历模板 总结 大家好，我是程序员Carl，毕业先后在腾讯百度工作多年，看过很多社招和校招的简历，这篇文章我来总结一下程序员的简历应该怎么写，有哪些注意事项，还给出了我自己的简历模板，好了，我只能帮.
C++ STL中sort函数
weixin_43349440的博客
09-15 269
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 270
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 526
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C++_map_set详解
最新发布
2302_77644537的博客
09-16 641
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 558
继续学习头文件的数学函数。
C++ 中 vector 的常用功能介绍
2202_75569688的博客
09-12 429
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
重庆八中周赛题解：编程竞赛算法分析
本次重庆八中周赛涉及了多种算法和问题解决策略，主要包括文本排列、矩阵覆盖和区间子序列处理等主题。下面分别对这些知识点进行详细解析： **P1 文本左右对齐** 此题考察的是字符串排列和贪心算法的应用。在处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值