Buu学习之Reverse

BUU–Reverse

ida操作和ASCII码值见附录篇
附录

easyre

主要逻辑就是让你输入连续的两个数，如果这两个数相同，那么就输出flag

查壳为64位程序，ida64反编译即可

或者f5（tab）进入伪c代码

flag{this_Is_a_EaSyRe}

reverse1

主要逻辑：对已有的字符串进行字符替换，字符o替换成数字0，最后跟Str1(即你输入的字符串)进行比较

64位程序，ida反编译，进入伪c（f5/tab）

111为小写字母o的ASCII码值，48为数字0的ASCII码值，就算不知道是它的ASCII码值，可以利用ida里的转换：
点击对应的数值，摁一下键盘的R键即可看到对应的字符

//关键代码：
for ( j = 0; ; ++j )
  {
    v10 = j;
    if ( j > j_strlen(Str2) )
      break;
    if ( Str2[j] == 'o' )
      Str2[j] = '0';
  }
//这一个代码其实是遍历Str2所有的字符
  for ( j = 0; j < strlen(Str2) ; ++j ){
    if ( Str2[j] == 'o' )
      Str2[j] = '0';
  }
 //这两是等价的

双击蓝色的Str2，查看Str2的字符串—> {hello_world}
有人可能会发现了刚开始进入的界面中就有这个字符串

根据替换规则，那么修改成{hell0_w0rld}即可
flag{hell0_w0rld}

reverse2

主要逻辑：对已有的字符串进行字符替换，字符i或者r替换成数字1，最后跟Str1(即你输入的字符串)进行比较

64位

//关键代码：
for ( i = 0; i <= strlen(&flag); ++i )
    {
      if ( *(&flag + i) == 'i' || *(&flag + i) == 'r' )
        *(&flag + i) = '1';
    }
//这一个代码其实是遍历flag所有的字符,只不过是用了指针进行操作而已
  for ( j = 0; j < strlen(flag) ; ++j ){
    if ( flag[j] == 'i' || flag[j] == 'r')
      flag[j] = '1';
  }
 //这两是等价的

查看flag的内容（双击蓝色的flag），或者在汇编解密也是可以看到的
{hacking_for_fun}

根据替换规则得到
flag{hack1ng_fo1_fun}

内涵的软件

IDA扔进去就有

32位程序
DBAPP{49d3c93df25caad81232130f3d2ebfad}

新年快乐

不清楚的可以看这一篇

upx壳，需要手动脱壳或者使用工具脱壳

32程序，难点在upx上，脱壳完进去就是答案

flag{HappyNewYear!}

xor

不清楚xor的可以看这一篇

主要逻辑：从第二位开始，异或前一位，结果存放在当前位上，最后将结果与global进行对比

64位，扔进ida，查看逻辑：

查看global数据，杂乱无章，点击aFKWOXZUPFVMDGH 标签，摁一下键盘上的U


提取global的数据：

1. 全选数据后，摁下组合键shift+e
2. 全选数据后，右键，选取BYTE（C/C++或者python都可以），会在output窗口中获取到数据
3. 利用ida内置的python库进行获取数据：点击文件（file）
   

addr = 0x00100000F6E#数据的起始地址
data = []
for i in range(33):#获取数据的个数
    data.append(get_wide_byte(addr+i))
print(data)
#同样在output窗口看到结果

解题要点：当前位置（除第一位外）的数据是异或得来的数据，所以我们需要倒着回去，从最后一位开始异或前一位得到原来的数据。（最后一位的数据并没有被覆盖，即原来的数据，利用这个原始数据去还原其他数据）

exp

1. 利用ida内置的python来写

addr = 0x00100000F6E
data = []
for i in range(33):
    data.append(get_wide_byte(addr+i))
for i in range(len(data)-1,0,-1):
    data[i] ^= data[i-1]
print(bytes(data))

2. 利用获取到的数据来写python

data = [102, 10, 107, 12, 119, 38, 79, 46, 64, 17, 120, 13, 90, 59, 85, 17, 112, 25, 70, 31, 118, 34, 77, 35, 68, 14, 103, 6, 104, 15, 71, 50, 79]
for i in range(len(data)-1,0,-1):
    data[i] ^= data[i-1]
print(bytes(data))

3. 利用获取到的数据来写c/c++

#include<bits/stdc++.h>
using namespace std;

int main() {
    unsigned char ida_chars[] =
            {
                    0x66, 0x0A, 0x6B, 0x0C, 0x77, 0x26, 0x4F, 0x2E, 0x40, 0x11,
                    0x78, 0x0D, 0x5A, 0x3B, 0x55, 0x11, 0x70, 0x19, 0x46, 0x1F,
                    0x76, 0x22, 0x4D, 0x23, 0x44, 0x0E, 0x67, 0x06, 0x68, 0x0F,
                    0x47, 0x32, 0x4F,0x00
            };
    for (int i = sizeof(ida_chars)-1; i > 0; i--) {
        ida_chars[i] ^= ida_chars[i-1];
    }
    ida_chars[sizeof(ida_chars)-1] = 0;//设置字符串结尾\x00
    cout << ida_chars;
    return 0;
}

flag{QianQiuWanDai_YiTongJiangHu}

reverse3

对输入的字符串进行base64加密（标准），然后对得到加密后的字符串的ASCII码值进行变化，最后与Str2进行比较

32位程序，看看逻辑

发现程序让我们输入一个字符串Str后，对Str进行了一个函数加密sub_4110BE(Str, v3, v14)，跟进看看

看到特殊的数组名aAbcdefghijklmn[64]，查看数组数据

ok，长度为64，标准base64加密。

base64加密完后得到的字符串分别+上他们对应下标的数字得到新的密文，最后与Str2比较

ok获得思路：获取Str2的数据，数据分别减去他们对应下标的数字，最后进行base64解密
exp

import base64
v = [0x65, 0x33, 0x6E, 0x69, 0x66, 0x49, 0x48, 0x39, 0x62, 0x5F, 0x43, 0x40, 0x6E, 0x40, 0x64, 0x48]
for i in range(len(v)):
    v[i] -= i
ans = base64.b64decode(bytes(v))
print(ans)

flag{i_l0ve_you}

helloword

android逆向，推荐使用工具 jadx/jeb

放入jadx或者jeb中即可看到答案

flag{7631a988259a00816deda84afb29430a}

不一样的flag

maze(迷宫类)，找到路径即可

32位程序，看看逻辑

似乎是要我们到达某个点，配合输出的字符，maze（迷宫）应该跑不掉了
找找迷宫地图，似乎只有*11110100001010000101111#符合迷宫地图，将其打印出来

#为什么以5作为换行呢，题目逻辑给了一点点暗示，去尝试一下不吃亏，没准就出来了呢
v = '*11110100001010000101111#'
for i in range(len(v)//5):
    print(v[i*5:i*5+5])
"""
*1111
01000
01010
00010
1111#
"""

打出路径：222441144222
自测

flag{222441144222}

SimpleRev

字符偏移，大小端存储问题

64位程序，看看逻辑

跟进Decry函数

拆分逻辑，找到key3和key1

 *src = 0x534C43444ELL;
  v7 = 0LL;
  v8 = 0;
  v9[0] = 0x776F646168LL;
  v9[1] = 0LL;
  v10 = 0;
  text = join(key3, v9);
  strcpy(key, key1);
  strcat(key, src);
  //key3 = 'kills'
  //key1 = 'ADSFK'

这一段的逻辑

1. text的赋值，将v9的值添加到key3后，key3是一个字符串，那么v9也一定是一个字符串，我们尝试用ida的快捷键R选中v9的值进行转换得到v9 = ‘wodah’，所以text应该为key3+v9 即text = killswodah
2. key的获取，复制key1的值给到key，然后将src的值添加到key值后，对src进行同样的处理后，那么key应该为key1+src 即key = ADSFKSLCDN

for ( i = 0; i < v5; ++i )
  {
    if ( key[v3 % v5] > 64 && key[v3 % v5] <= 90 )
      key[i] = key[v3 % v5] + 32;
    ++v3;
  }

这一段的逻辑就是将key中的所有字符进行大小写转换
为什么这么说：
首先是大写字母和小写字母之间相差了32
其次，if判断语句中的范围正式大写字母A~Z的ASCII码值的范围
那么我们来更新key的值 key = adsfkslcdn

  while ( 1 )
  {
    v1 = getchar();
    if ( v1 == 10 )
      break;
    if ( v1 == 32 )
    {
      ++v2;
    }
    else
    {
      if ( v1 <= 96 || v1 > 122 )
      {
        if ( v1 > 64 && v1 <= 90 )
        {
          str2[v2] = (v1 - 39 - key[v3 % v5] + 97) % 26 + 97;
          ++v3;
        }
      }
      else
      {
        str2[v2] = (v1 - 39 - key[v3 % v5] + 97) % 26 + 97;
        ++v3;
      }
      if ( !(v3 % v5) )
        putchar(32);
      ++v2;
    }
  }

这一段就是将所输入的字符，进行字符偏移（类似Casa（凯撒密码））
偏移量由 39 + key[v3 % v5]控制

 if ( !strcmp(text, str2) )
    puts("Congratulation!\n");
  else
    puts("Try again!\n");

最后则是比较答案，也就是说text是最终需要比较的答案

理解完后，我们就可以开始构建exp了
需要注意的是：面对字符偏移，我们通常不逆向，而是正向的去求解，也就是遍历所有字符进行逐一加密，与目标字符逐一比较，正确则输出，错误则跳过

exp

import string

text = 'killswodah'
key  = 'adsfkslcdn'
for i in range(len(key)):
    for alp in string.printable:
        if alp.isalpha():
            temp = (ord(alp) - 39 - ord(key[i]) + 97) % 26 + 97
            if temp == ord(text[i]):
                print(alp,end='')
                break

得到结果flag{efxkwitzxo}提交！发现不正确。
那么问题来了，我们的思路并没有错误，那么问题只能出在text和key上了，我们所获得的key和text真的是对的吗？

来看一段同样是64为位的程序

//源码如下
#include <iostream>
#include <cstring>
using namespace std;

int main() {
    char ida_chars[] = "flag";
    return 0;
}

同样使用R进行转换

发现竟然是倒过来了的，那么我们联想一下，会不会我们拿到的v9和src是不是也倒了（这其实是有关大小端存储的问题，不做过多介绍，先知道有这个原因）
重新调整text和key：
key = adsfkndcls
text = killshadow

exp(小写)

import string
for i in range(len(key)):
    for alp in string.printable:
        if alp.islower():
            temp = (ord(alp) - 39 - ord(key[i]) + 97) % 26 + 97
            if temp == ord(text[i]):
                print(alp, end='')
                break
# string.printable这个函数囊括了所有的字符，可以直接调用
#alp.isupper()是指，如果alp这个变量的值是大写的话；相反的则是alp.islower()

flag{efxkwoxzti}
exp(大写)

import string
for i in range(len(key)):
    for alp in string.printable:
        if alp.isupper():
            temp = (ord(alp) - 39 - ord(key[i]) + 97) % 26 + 97
            if temp == ord(text[i]):
                print(alp, end='')
                break
# string.printable这个函数囊括了所有的字符，可以直接调用
#alp.isupper()是指，如果alp这个变量的值是大写的话；相反的则是alp.islower()

flag{KLDQCUDFZO}
这道题有点怪，因为按照程序逻辑来说大小写都是可以的，我又去看了看别人的wp，发现都没说，那为什么他们都是大写呢？要知道大写字母的ASCII码值要小，在爆破的时候优先爆破到的值肯定是大写的值 （如果有想法的可以跟我交流交流）

[GXYCTF2019]luck_guy

64位程序，看看逻辑

跟进可疑函数


发现flag由f1和f2构成，整个语句通过switch-case控制，选项又由rand控制，要是让程序自己跑，那么真的lucky-dog才能跑出来了，好在我们静态分析即可
f1我们直接查看即可f1 = 'GXY{do_not_'
f2被操作了，但是给了我们操作前的值s（又是上一题的问题，那么我们吧数据提取好（别倒着哦））；
f2的解密为：如果当前位为基数，ASCII码值-2，反之-1
得到f2 = 'hate_me}'
构造exp

exp

v = [0x69,0x63,0x75,0x67,0x60,0x6f,0x66,0x7f]
for i in range(len(v)):
    if i % 2 == 0:
        v[i] -= 1
    else:
        v[i] -= 2
print(bytes(v))

# 完整exp
f1 = 'GXY{do_not_'
v = [0x69,0x63,0x75,0x67,0x60,0x6f,0x66,0x7f]
for i in range(len(v)):
    if i % 2 == 0:
        v[i] -= 1
    else:
        v[i] -= 2
print(f1+bytes(v).decode())

GXY{do_not_hate_me}

Java逆向解密

简单xor

附件为.class文件，三种方法，jadx、jeb还有一种是idea（自带反编译class文件）

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

import java.util.ArrayList;
import java.util.Scanner;

public class Reverse {
    public Reverse() {
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("Please input the flag ：");
        String str = s.next();
        System.out.println("Your input is ：");
        System.out.println(str);
        char[] stringArr = str.toCharArray();
        Encrypt(stringArr);
    }

    public static void Encrypt(char[] arr) {
        ArrayList<Integer> Resultlist = new ArrayList();

        for(int i = 0; i < arr.length; ++i) {
            int result = arr[i] + 64 ^ 32;
            Resultlist.add(result);
        }

        int[] KEY = new int[]{180, 136, 137, 147, 191, 137, 147, 191, 148, 136, 133, 191, 134, 140, 129, 135, 191, 65};
        ArrayList<Integer> KEYList = new ArrayList();

        for(int j = 0; j < KEY.length; ++j) {
            KEYList.add(KEY[j]);
        }

        System.out.println("Result:");
        if (Resultlist.equals(KEYList)) {
            System.out.println("Congratulations！");
        } else {
            System.err.println("Error！");
        }

    }
}

对输入的数据的码值+64后再^32，最后与KEY值进行比较，那么就有思路了，先^32后再-64即可
exp

v = [180, 136, 137, 147, 191, 137, 147, 191, 148, 136, 133, 191, 134, 140, 129, 135, 191, 65]
for i in range(len(v)):
    v[i] ^= 32
    v[i] -= 64
print(bytes(v).decode())

flag{This_is_the_flag_!}

[BJDCTF2020]JustRE

32位程序，看看逻辑

发现没有信息，shift+f12查看字符串

找到一个类似flag的字符串，跟进看看

点击aBjdDD2069a4579，摁下x，查看调用


还记得我们学习c的时候吗，printf(“%d%d”,1,2)
那么直接套进去试试，提交正确

BJD{1999902069a45792d233ac}

刮开有奖

32位程序，老样子看看逻辑

看样子有数学了。
我们来看看最终的判断，要求是判断String和v4、v5，而v4、v5和String又有间接的联系
那么我们来拆分一下

String[0] == v7[0] + 34 ; v7[0] = 90; sub_5D10F0(v7, 0, 10);
String[1] == v10 ; v10 = 67;
4 * String[2] - 141 == 3 * v8 ; v8 = 83;
String[3] / 4 == 2 * (v13 / 9) ; v13 = 72;

String[4]与v5挂钩

v18[1] = String[3];
v18[0] = String[2];
v18[2] = String[4];
v5最终的值为: V1Ax

String5、6、7与v4挂钩

v18[0] = String[5];
v18[2] = String[7];
v18[1] = String[6];
v4 = sub_401000(v18, strlen(v18));
v4最终的值：ak1w

而v4、v5又与 sub_401000(v18, strlen(v18));这个函数挂钩

看看这个函数是个啥，跟进发现是一个标准的base64加密算法
那么我们先将567还原出来，再将234给弄出来，最后是0和1
exp

import base64
v = 'ak1w'
print(base64.b64decode(v).decode())

import base64
v = 'V1Ax'
print(base64.b64decode(v).decode())

原始字符串在这

也就是这一部分

这里有一点值得注意，v7[0]的值已经不再是90了，它被sub_5D10F0(v7, 0, 10);该函数操作过了，那么我们直接将这个函数进行复制，运行一下

#include <bits/stdc++.h>

using namespace std;

int __cdecl sub_5D10F0(char *a1, int a2, int a3)
{
  int result; // eax
  int i; // esi
  int v5; // ecx
  int v6; // edx

  result = a3;
  for ( i = a2; i <= a3; a2 = i )
  {
    v5 = i;
    v6 = *(i + a1);
    if ( a2 < result && i < result )
    {
      do
      {
        if ( v6 > *(a1 + result) )
        {
          if ( i >= result )
            break;
          ++i;
          *(v5 + a1) = *(a1 + result);
          if ( i >= result )
            break;
          while ( *(a1 + i) <= v6 )
          {
            if ( ++i >= result )
              goto LABEL_13;
          }
          if ( i >= result )
            break;
          v5 = i;
          *(a1 + result) = *(i + a1);
        }
        --result;
      }
      while ( i < result );
    }
LABEL_13:
    *(a1 + result) = v6;
    sub_5D10F0(a1, a2, i - 1);
    result = a3;
    ++i;
  }
  return result;
}
int main(){
    unsigned char v7[] = "ZJSECaNH3ng";
    sub_5D10F0((char*)v7,0,10);
    cout << v7;
}
//3CEHJNSZagn

那么获取最后的字符
(如果懂得动调的话会更加快一点)

v0 = ord('3')+34
v1 = 67
print(chr(v0),end='')
print(chr(v1),end='')

得到567的原始字符jMp
得到234的原始字符WP1
得到01的原始字符UC
合并UCWP1jMp
flag{UCWP1jMp}

简单注册器

android逆向，逻辑不难就是ASCII码值的变化和位置交换

看看内在：（jadx或者jeb）jadx好像有问题，就是在判断上
看看jadx的

这一条语句无论怎么判断flag的值都是为0的，不知道是jadx的问题还是我的问题
我看的是jeb的

逻辑上说的是只要你输入的字符满足
(s.length() != 0x20 || s.charAt(0x1F) != 97 || s.charAt(1) != 98 || s.charAt(0) + s.charAt(2) - 0x30 != 56)那么就可以得到flag

v = 'flag{tZyktZEpfAksPYyQfEXfmoeUQt}'#32位随机字符串
k = list(v)
k[1] = 'b'
k[31] = 'a'
k[0] = '0'
k[2] = '8'

# 枚举满足s.charAt(0) + s.charAt(2) - 0x30 == 56 条件的字符
# for i in string.printable:
#     for j in string.printable:
#         if ord(i) + ord(j) - 0x30 == 56:
#             print(i,j)
#             exit(0)

print(''.join(k))
# 0b8g{tZyktZEpfAksPYyQfEXfmoeUQta

还有一种，直接运行它的代码(复制粘贴下来即可)

#include <bits/stdc++.h>

using namespace std;


int main(){
    char x[] = "dd2940c04462b4dd7c450528835cca15";
    x[2] = (char) ((x[2] + x[3]) - 50);
    x[4] = (char) ((x[2] + x[5]) - 48);
    x[30] = (char) ((x[31] + x[9]) - 48);
    x[14] = (char) ((x[27] + x[28]) - 97);
    for (int i = 0; i < 16; i++) {
        char a = x[31 - i];
        x[31 - i] = x[i];
        x[i] = a;
    }
    cout << x;
}

flag{59acc538825054c7de4b26440c0999dd}

[ACTF新生赛2020]easyre

upx脱壳

32位程序，看看内在

以v5的值减去1作为下标在_data_start__数组中匹配v4的字符，那么v5就是我们要找的东西，因为v4我们已经懂了

思路清晰：在_data_start__数组中找到v4值对应的下标+1即可

构造exp

v = [42,70,39,34,78,44,34,40,73,63,43,64,]
data = [0x7E, 0x7D, 0x7C, 0x7B, 0x7A, 0x79, 0x78, 0x77, 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x70, 0x6F, 0x6E, 0x6D, 
        0x6C, 0x6B, 0x6A, 0x69, 0x68, 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60, 0x5F, 0x5E, 0x5D, 0x5C, 0x5B,
        0x5A, 0x59, 0x58, 0x57, 0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50, 0x4F, 0x4E, 0x4D, 0x4C, 0x4B, 0x4A, 0x49, 
        0x48, 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x40, 0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39, 0x38, 0x37, 
        0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30, 0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 0x28, 0x27, 0x26, 0x25, 
        0x24, 0x23, 0x20, 0x21, 0x22, 0x00]
for i in v:
    print(chr(data.index(i)+1),end='')

flag{U9X_1S_W6@T?}

[GWCTF 2019]pyre

python文件pyc逆向，可用工具有pycdc、pycdas、在线反编译，uncompyle6等

自行使用即可

看看内在

# Source Generated with Decompyle++
# File: [GWCTF 2019]pyre.pyc (Python 2.7)

print 'Welcome to Re World!'
print 'Your input1 is your flag~'
l = len(input1)
for i in range(l):
    num = ((input1[i] + i) % 128 + 128) % 128
    code += num

for i in range(l - 1):
    code[i] = code[i] ^ code[i + 1]

print code
code = ['\x1f','\x12','\x1d','(','0','4','\x01','\x06','\x14','4',',','\x1b','U','?','o','6','*',':','\x01','D',';','%','\x13']

code的值由num来，而num由我们输入的flag而来，那么我们先求解num，然后爆破flag即可，为什么不逆推num呢，是因为%的特性，%会导致有多种可能

1%3 = 1
4%3 = 1
5%8 = 1
同样的答案却有不同的组合，这使得我们去逆推%的运算难度大大增加

根据xor的特性，推算出num
exp

code = ['\x1f','\x12','\x1d','(','0','4','\x01','\x06','\x14','4',',','\x1b','U','?','o','6','*',':','\x01','D',';','%','\x13']
code_ascii = [ord(i) for i in code]
for i in range(len(code_ascii)-2,-1,-1):
    code_ascii[i] ^= code_ascii[i+1]
print(code_ascii)

再根据num = ((input1[i] + i) % 128 + 128) % 128得到flag

import string

for i in range(len(code_ascii)):
    for alp in string.printable:
        if ((ord(alp) + i) % 128 + 128) % 128 == code_ascii[i]:
            print(alp,end='')
            break

GWHT{Just_Re_1s_Ha66y!}

findit

android 逆向

反编译看看内在

package com.example.findit;

import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

/* loaded from: classes.dex */
public class MainActivity extends ActionBarActivity {
    /* JADX INFO: Access modifiers changed from: protected */
    @Override // android.support.v7.app.ActionBarActivity, android.support.v4.app.FragmentActivity, android.app.Activity
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button btn = (Button) findViewById(R.id.widget3);
        final EditText edit = (EditText) findViewById(R.id.widget2);
        final TextView text = (TextView) findViewById(R.id.widget1);
        final char[] a = {'T', 'h', 'i', 's', 'I', 's', 'T', 'h', 'e', 'F', 'l', 'a', 'g', 'H', 'o', 'm', 'e'};
        final char[] b = {'p', 'v', 'k', 'q', '{', 'm', '1', '6', '4', '6', '7', '5', '2', '6', '2', '0', '3', '3', 'l', '4', 'm', '4', '9', 'l', 'n', 'p', '7', 'p', '9', 'm', 'n', 'k', '2', '8', 'k', '7', '5', '}'};
        btn.setOnClickListener(new View.OnClickListener() { // from class: com.example.findit.MainActivity.1
            @Override // android.view.View.OnClickListener
            public void onClick(View v) {
                char[] x = new char[17];
                char[] y = new char[38];
                for (int i = 0; i < 17; i++) {
                    if ((a[i] < 'I' && a[i] >= 'A') || (a[i] < 'i' && a[i] >= 'a')) {
                        x[i] = (char) (a[i] + 18);
                    } else if ((a[i] >= 'A' && a[i] <= 'Z') || (a[i] >= 'a' && a[i] <= 'z')) {
                        x[i] = (char) (a[i] - '\b');
                    } else {
                        x[i] = a[i];
                    }
                }
                String m = String.valueOf(x);
                if (m.equals(edit.getText().toString())) {
                    for (int i2 = 0; i2 < 38; i2++) {
                        if ((b[i2] >= 'A' && b[i2] <= 'Z') || (b[i2] >= 'a' && b[i2] <= 'z')) {
                            y[i2] = (char) (b[i2] + 16);
                            if ((y[i2] > 'Z' && y[i2] < 'a') || y[i2] >= 'z') {
                                y[i2] = (char) (y[i2] - 26);
                            }
                        } else {
                            y[i2] = b[i2];
                        }
                    }
                    String n = String.valueOf(y);
                    text.setText(n);
                    return;
                }
                text.setText("答案错了肿么办。。。不给你又不好意思。。。哎呀好纠结啊~~~");
            }
        });
    }

    @Override // android.app.Activity
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

类似一个注册机的问题，要求你输入key，key正确则输出flag
两种方法，一种是直接弄key，运行程序即可
exp

#include <bits/stdc++.h>

using namespace std;

char x[17];
int y[38];
int main(){
    char a[] = {'T', 'h', 'i', 's', 'I', 's', 'T', 'h', 'e', 'F', 'l', 'a', 'g', 'H', 'o', 'm', 'e'};


    for (int i = 0; i < 17; i++) {
        if ((a[i] < 'I' && a[i] >= 'A') || (a[i] < 'i' && a[i] >= 'a')) {
            x[i] = (char) (a[i] + 18);
        } else if ((a[i] >= 'A' && a[i] <= 'Z') || (a[i] >= 'a' && a[i] <= 'z')) {
            x[i] = (char) (a[i] - '\b');
        } else {
            x[i] = a[i];
        }
    }
    cout << x << endl;
}

key = LzakAkLzwXdsyZgew

第二种直接求flag即可
exp

#include <bits/stdc++.h>

using namespace std;

char x[17];
int y[38];
int main(){
    char b[] = {'p', 'v', 'k', 'q', '{', 'm', '1', '6', '4', '6', '7', '5', '2', '6', '2', '0', '3', '3', 'l', '4', 'm', '4', '9', 'l', 'n', 'p', '7', 'p', '9', 'm', 'n', 'k', '2', '8', 'k', '7', '5', '}'};

    for (int i2 = 0; i2 < 38; i2++) {
        if ((b[i2] >= 'A' && b[i2] <= 'Z') || (b[i2] >= 'a' && b[i2] <= 'z')) {
            y[i2] = (b[i2] + 16);
            if ((y[i2] > 'Z' && y[i2] < 'a') || y[i2] >= 'z') {
                y[i2] =(y[i2] - 26);
            }
        } else {
            y[i2] = b[i2];
        }
    }
    for (int i2 = 0; i2 < 38; i2++) {
        y[i2] %= 128;
        cout <<(char)y[i2];
    }

}

这里为啥要%128呢，因为ASCII码值的最大就是128。我用的c写出来不%的话会出现乱码，（数据溢出了）
flag{c164675262033b4c49bdf7f9cda28a75}

[ACTF新生赛2020]rome

32位程序，老样子看看内在
简单的字符偏移，照抄一下代码即可

v = [ord(i) for i in 'Qsw3sj_lz4_Ujw@l']
for i in range(len(v)):
    for alp in string.printable:
        if alp.isupper():
            if (ord(alp) - 51) % 26 + 65 == v[i]:
                v[i] = ord(alp)
                break
        elif alp.islower():
            if (ord(alp) - 79) % 26 + 97 == v[i]:
                v[i] = ord(alp)
                break
print(bytes(v))

因为它只针对字母变化，所以要注意保留不是字母的字符
ACTF{Cae3ar_th4_Gre@t}

rsa

密码学的东西，一般来说套模板即可，对逆向的要求不高

exp

import rsa
import gmpy2

# 公钥形式：从key中薅来
# -----BEGIN PUBLIC KEY-----
# MDwwDQYJKoZIhvcNAQEBBQADKwAwKAIhAMAzLFxkrkcYL2wch21CM2kQVFpY9+7+
# /AvKr1rzQczdAgMBAAE=
# -----END PUBLIC KEY-----

e = 65537  # 一般都是固定的
c = 0xad939ff59f6e70bcbfad406f2494993757eee98b91bc244184a377520d06fc35  # 密文
n = 86934482296048119190666062003494800588905656017203025617216654058378322103517  # 由公钥解析出：
p = 285960468890451637935629440372639283459  # n分解
q = 304008741604601924494328155975272418463  # n分解
# 已知公钥，求解析得到e、n：网址
# http://www.hiencode.com/pub_asys.html


# 通过n计算p、q：网址
# http://www.factordb.com/index.php?query=86934482296048119190666062003494800588905656017203025617216654058378322103517


phin = (q - 1) * (p - 1)
d = gmpy2.invert(e, phin)

# 有.enc文件时如下处理：
key = rsa.PrivateKey(n, e, int(d), p, q)

with open(r"D:\CTF\Match\BUU\rsa\flag.enc", "rb+") as f:
    # 打开对应路径下的xxx.enc文件
    f = f.read()
flag = rsa.decrypt(f, key)
print(flag)

flag{decrypt_256}

[FlareOn4]login

新语言html逆向

看看源代码，双击.html文件，然后f12进入开发者模式

字符偏移？那么首先想到Case，结合.txt文件

Hint:本题解出相应字符串后请用flag{}包裹，形如：flag{123456@flare-on.com}
随便找一个在线网站进行Case爆破即可，key=13
一个个试也行也就26次而已

flag{ClientSideLoginsAreEasy@flare-on.com}

[WUSTCTF2020]level1

64位程序，看看内在

逻辑：

1. 奇数位进行位运算，左移i个单位，即*2ⁱ
2. 偶数位进行乘法运算，*i
   结合output.txt给出的数据，构造exp

v = [198,232,816,200,1536,300,6144,984,51200,570,92160,1200,565248,756,1474560,800,6291456,1782,65536000,]
for i in range(len(v)):
    if ((i+1) & 1) != 0:
        v[i] >>= (i+1)
    else:
        v[i] //= (i+1)
print(bytes(v).decode())

这里注意一点，程序里写的是从1开始，对应的数据就是output.txt的第一个数据，所以记得略作修改一下
ctf2020{d9-dE6-20c}

[GUET-CTF2019]re

upx壳，记得脱壳

64位elf文件，看看内在

数学计算题，直接掏出计算器也行，这里讲一下程序中的计算求解问题，这里使用的z3约束求解

也是跟我们数学中的一样，我们需要定义好未知量，也就是a1数组里的各个数据都是需要我们去定义的

from z3 import *

# 定义未知量
a1 = [Int('a1[%d]' % i) for i in range(0, 32)]  # 32遍历不到，那么也就是我们定义了a1[0~31]的未知量

s = Solver()  # 定义解决方法s

s.add(1629056 * a1[0] == 166163712,

      6771600 * a1[1] == 731332800,

      3682944 * a1[2] == 357245568,

      10431000 * a1[3] == 1074393000,

      3977328 * a1[4] == 489211344,

      5138336 * a1[5] == 518971936,

      7532250 * a1[7] == 406741500,

      5551632 * a1[8] == 294236496,

      3409728 * a1[9] == 177305856,

      13013670 * a1[10] == 650683500,

      6088797 * a1[11] == 298351053,

      7884663 * a1[12] == 386348487,

      8944053 * a1[13] == 438258597,

      5198490 * a1[14] == 249527520,

      4544518 * a1[15] == 445362764,

      3645600 * a1[17] == 174988800,

      10115280 * a1[16] == 981182160,

      9667504 * a1[18] == 493042704,

      5364450 * a1[19] == 257493600,

      13464540 * a1[20] == 767478780,

      5488432 * a1[21] == 312840624,

      14479500 * a1[22] == 1404511500,

      6451830 * a1[23] == 316139670,

      6252576 * a1[24] == 619005024,

      7763364 * a1[25] == 372641472,

      7327320 * a1[26] == 373693320,

      8741520 * a1[27] == 498266640,

      8871876 * a1[28] == 452465676,

      4086720 * a1[29] == 208422720,

      9374400 * a1[30] == 515592000,
      5759124 * a1[31] == 719890500)  # 添加方程组

if s.check() == sat:  # 求解
    m = s.model()
    for i in range(0, 32):
        if m[a1[i]] is not None: 判断是否有没有解出的
        print(chr(m[a1[i]].as_long()), end='')
    else:
        print('?', end='')

flag{e?65421110ba03099a1c039337}
真有没有解出的，看看是在a1[6]，发现真没有这个约束项，那么没办法了只能把所有可见字符都试一遍了
flag{e165421110ba03099a1c039337}

CrackRTF