BUUCTF reverse wp 11 - 20

最新推荐文章于 2023-07-26 16:31:31 发布
最新推荐文章于 2023-07-26 16:31:31 发布
阅读量1.1k 收藏 4
点赞数 4
分类专栏： 逆向工程 文章标签： windows逆向 Android逆向
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33976344/article/details/121262268
版权

Java逆向解密

java逆向, 用java-decompile逆

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

public class 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 ^ 0x20;
      Resultlist.add(Integer.valueOf(result));
    } 
    int[] KEY = { 
        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(Integer.valueOf(KEY[j])); 
    System.out.println("Result:");
    if (Resultlist.equals(KEYList)) {
      System.out.println("Congratulations);
    } else {
      System.err.println("Error);
    } 
  }
}

当Resultlist.equals(KEYList)时通过检测
Resultlist的逻辑

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

逆回去就是先用Keylist ^ 0x20, 然后减去64(注意java中^的优先级是比+更低的,所以是先+再^

Keylist = [180, 136, 137, 147, 191, 137, 147, 191, 148, 136, \
           133, 191, 134, 140, 129, 135, 191, 65]

flag = ''
for key in Keylist:
    flag += chr((key ^ 0x20) - 64)

print(flag)

结果记得加flag{}

[GXYCTF2019]luck_guy

file看是x64文件, 没壳拖进IDA64

unsigned __int64 get_flag()
{
  unsigned int v0; // eax
  int i; // [rsp+4h] [rbp-3Ch]
  int j; // [rsp+8h] [rbp-38h]
  __int64 s; // [rsp+10h] [rbp-30h] BYREF
  char v5; // [rsp+18h] [rbp-28h]
  unsigned __int64 v6; // [rsp+38h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  v0 = time(0LL);
  srand(v0);
  for ( i = 0; i <= 4; ++i )
  {
    switch ( rand() % 200 )
    {
      case 1:
        puts("OK, it's flag:");
        memset(&s, 0, 0x28uLL);
        strcat((char *)&s, f1);
        strcat((char *)&s, &f2);
        printf("%s", (const char *)&s);
        break;
      case 2:
        printf("Solar not like you");
        break;
      case 3:
        printf("Solar want a girlfriend");
        break;
      case 4:
        s = 0x7F666F6067756369LL;
        v5 = 0;
        strcat(&f2, (const char *)&s);
        break;
      case 5:
        for ( j = 0; j <= 7; ++j )
        {
          if ( j % 2 == 1 )
            *(&f2 + j) -= 2;
          else
            --*(&f2 + j);
        }
        break;
      default:
        puts("emmm,you can't find flag 23333");
        break;
    }
  }
  return __readfsqword(0x28u) ^ v6;
}

在这里插入图片描述
处理一下s字符串, 然后就是flag后半段

flag = "GXY{do_not_"
s = [0x7F, 0x66, 0x6F, 0x60, 0x67, 0x75, 0x63, 0x69] # 0x7F666F6067756369LL
s = s[::-1]
for i in range(8):
    if i % 2 == 1: s[i] -= 2
    else: s[i] -= 1
    flag += chr(s[i])
 
print(flag)

GXY{do_not_hate_me}
提交时改成flag{}

刮开有奖

INT_PTR __stdcall DialogFunc(HWND hDlg, UINT a2, WPARAM a3, LPARAM a4)
{
  const char *v4; // esi
  const char *v5; // edi
  int v7[2]; // [esp+8h] [ebp-20030h] BYREF
  int v8; // [esp+10h] [ebp-20028h]
  int v9; // [esp+14h] [ebp-20024h]
  int v10; // [esp+18h] [ebp-20020h]
  int v11; // [esp+1Ch] [ebp-2001Ch]
  int v12; // [esp+20h] [ebp-20018h]
  int v13; // [esp+24h] [ebp-20014h]
  int v14; // [esp+28h] [ebp-20010h]
  int v15; // [esp+2Ch] [ebp-2000Ch]
  int v16; // [esp+30h] [ebp-20008h]
  CHAR String[65536]; // [esp+34h] [ebp-20004h] BYREF
  char v18[65536]; // [esp+10034h] [ebp-10004h] BYREF

  if ( a2 == 272 )
    return 1;
  if ( a2 != 273 )
    return 0;
  if ( a3 == 1001 )
  {
    memset(String, 0, 0xFFFFu);
    GetDlgItemTextA(hDlg, 1000, String, 0xFFFF);
    if ( strlen(String) == 8 )
    {
      v7[0] = 90;
      v7[1] = 74;
      v8 = 83;
      v9 = 69;
      v10 = 67;
      v11 = 97;
      v12 = 78;
      v13 = 72;
      v14 = 51;
      v15 = 110;
      v16 = 103;
      sub_4010F0(v7, 0, 10);
      memset(v18, 0, 0xFFFFu);
      v18[0] = String[5];
      v18[2] = String[7];
      v18[1] = String[6];
      v4 = sub_401000(v18, strlen(v18));
      memset(v18, 0, 0xFFFFu);
      v18[1] = String[3];
      v18[0] = String[2];
      v18[2] = String[4];
      v5 = sub_401000(v18, strlen(v18));
      if ( String[0] == v7[0] + 34
        && String[1] == v10
        && 4 * String[2] - 141 == 3 * v8
        && String[3] / 4 == 2 * (v13 / 9)
        && !strcmp(v4, "ak1w")
        && !strcmp(v5, "V1Ax") )
      {
        MessageBoxA(hDlg, "U g3t 1T!", "@_@", 0);
      }
    }
    return 0;
  }
  if ( a3 != 1 && a3 != 2 )
    return 0;
  EndDialog(hDlg, a3);
  return 1;
}

输入8字符的string, 通过if校验后为flag

      if ( String[0] == v7[0] + 34
        && String[1] == v10
        && 4 * String[2] - 141 == 3 * v8
        && String[3] / 4 == 2 * (v13 / 9)
        && !strcmp(v4, "ak1w")
        && !strcmp(v5, "V1Ax") )

v7 到 v16会经过sub_4010F0函数, 这里懒得分析了, 直接修改为c语言run, 可以在IDA中修改函数的item type, a1修改为char[]类型
在这里插入图片描述

双击v7局部变量, 进入栈窗口, 右键修改为数组类型

在这里插入图片描述

伪代码中的4 *进行数组索引是不合理的, 去掉之后得到符合语法的C代码如下

#include<iostream>
using namespace std;

int sub_4010F0(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 = *&a1[i];
    if ( a2 < result && i < result )
    {
      do
      {
        if ( v6 > *&a1[result] )
        {
          if ( i >= result )
            break;
          ++i;
          *&a1[v5] = *&a1[result];
          if ( i >= result )
            break;
          while ( *&a1[i] <= v6 )
          {
            if ( ++i >= result )
              goto LABEL_13;
          }
          if ( i >= result )
            break;
          v5 = i;
          *&a1[result] = *&a1[i];
        }
        --result;
      }
      while ( i < result );
    }
LABEL_13:
    *&a1[result] = v6;
    sub_4010F0(a1, a2, i - 1);
    result = a3;
    ++i;
  }
  return result;
}

/*
      v7[0] = 90;
      v7[1] = 74;
      v8 = 83;
      v9 = 69;
      v10 = 67;
      v11 = 97;
      v12 = 78;
      v13 = 72;
      v14 = 51;
      v15 = 110;
      v16 = 103;
*/

int main() {
    char arr[] = {90, 74, 83, 69, 67, 97, 78, 72, 51, 110, 103, 0};
    cout << arr << endl;
    sub_4010F0(arr, 0, 10);
    cout << arr << endl;
    return 0;
}

ZJSECaNH3ng
3CEHJNSZagn

可以确定string的前四位字符

_BYTE *__cdecl sub_401000(int a1, int a2)
{
  int v2; // eax
  int v3; // esi
  size_t v4; // ebx
  _BYTE *v5; // eax
  _BYTE *v6; // edi
  int v7; // eax
  _BYTE *v8; // ebx
  int v9; // edi
  int v10; // edx
  int v11; // edi
  int v12; // eax
  int i; // esi
  _BYTE *result; // eax
  _BYTE *v15; // [esp+Ch] [ebp-10h]
  _BYTE *v16; // [esp+10h] [ebp-Ch]
  int v17; // [esp+14h] [ebp-8h]
  int v18; // [esp+18h] [ebp-4h]

  v2 = a2 / 3;
  v3 = 0;
  if ( a2 % 3 > 0 )
    ++v2;
  v4 = 4 * v2 + 1;
  v5 = malloc(v4);
  v6 = v5;
  v15 = v5;
  if ( !v5 )
    exit(0);
  memset(v5, 0, v4);
  v7 = a2;
  v8 = v6;
  v16 = v6;
  if ( a2 > 0 )
  {
    while ( 1 )
    {
      v9 = 0;
      v10 = 0;
      v18 = 0;
      do
      {
        if ( v3 >= v7 )
          break;
        ++v10;
        v9 = *(v3 + a1) | (v9 << 8);
        ++v3;
      }
      while ( v10 < 3 );
      v11 = v9 << (8 * (3 - v10));
      v12 = 0;
      v17 = v3;
      for ( i = 18; i > -6; i -= 6 )
      {
        if ( v10 >= v12 )
        {
          *(&v18 + v12) = (v11 >> i) & 0x3F;
          v8 = v16;
        }
        else
        {
          *(&v18 + v12) = 64;
        }
        *v8++ = byte_407830[*(&v18 + v12++)];
        v16 = v8;
      }
      v3 = v17;
      if ( v17 >= a2 )
        break;
      v7 = a2;
    }
    v6 = v15;
  }
  result = v6;
  *v8 = 0;
  return result;
}

分析sub_401000函数, 看到byte_407830数组
在这里插入图片描述
所以直接猜测为Base64加密, (因为传入3字节, 输出4字节

import base64

"""
      if ( String[0] == a1[0] + 34
        && String[1] == a1[4]
        && 4 * String[2] - 141 == 3 * a1[2]
        && String[3] / 4 == 2 * (a1[7] / 9)
        && !strcmp(v4, "ak1w")
        && !strcmp(v5, "V1Ax") )
"""
s = "3CEHJNSZagn"
arr = [ord(_) for _ in s]
print(arr)
strings = [arr[0] + 34, arr[4], (3 * arr[2] + 141) // 4, int(2 * (arr[7] / 9) * 4)]
print(strings)

flag = "".join([chr(_) for _ in strings])
# print(flag)

b64str1 = "ak1w"
b64str2 = "V1Ax"
print(base64.b64decode(b64str1))
print(base64.b64decode(b64str2))
flag += "1jMp"
print("flag{" + flag + "}")

findit

安卓逆向
在这里插入图片描述

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;

public class MainActivity extends ActionBarActivity {
    /* access modifiers changed from: protected */
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView((int) R.layout.activity_main);
        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', '}'};
        ((Button) findViewById(R.id.widget3)).setOnClickListener(new 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] = a[i];
                    } else {
                        x[i] = (char) (a[i] - 8);
                    }
                }
                if (String.valueOf(x).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] = b[i2];
                        } else {
                            y[i2] = (char) (b[i2] + 16);
                            if ((y[i2] > 'Z' && y[i2] < 'a') || y[i2] >= 'z') {
                                y[i2] = (char) (y[i2] - 26);
                            }
                        }
                    }
                    text.setText(String.valueOf(y));
                    return;
                }
                text.setText("答案错了肿么办。。。不给你又不好意思。。。哎呀好纠结啊~~~");
            }
        });
    }

    public boolean onOptionsItemSelected(MenuItem item) {
        if (item.getItemId() == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

输入与x相同则输出flag, 图省事, java转cpp比较方便, 所以直接用cpp写exp
exp.cpp

#include<iostream>
#include<string>
using namespace std;

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

    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] = a[i];
    } else {
        x[i] = (char) (a[i] - 8);
        }
    }
    
    cout << x << endl;
}

在这里插入图片描述

[BJDCTF2020]JustRE

shift + F12, 找到flag字符串

INT_PTR __stdcall DialogFunc(HWND hWnd, UINT a2, WPARAM a3, LPARAM a4)
{
  CHAR String[100]; // [esp+0h] [ebp-64h] BYREF

  if ( a2 != 272 )
  {
    if ( a2 != 273 )
      return 0;
    if ( (_WORD)a3 != 1 && (_WORD)a3 != 2 )
    {
      sprintf(String, Format, ++dword_4099F0);
      if ( dword_4099F0 == 19999 )
      {
        sprintf(String, " BJD{%d%d2069a45792d233ac}", 19999, 0);
        SetWindowTextA(hWnd, String);
        return 0;
      }
      SetWindowTextA(hWnd, String);
      return 0;
    }
    EndDialog(hWnd, (unsigned __int16)a3);
  }
  return 1;
}

记得将BJD{} 改为flag{}

简单注册器

package com.example.flag;

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v7.app.ActionBarActivity;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends ActionBarActivity {
    /* access modifiers changed from: protected */
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView((int) R.layout.activity_main);
        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction().add((int) R.id.container, (Fragment) new PlaceholderFragment()).commit();
        }
        final TextView textview = (TextView) findViewById(R.id.textView1);
        final EditText editview = (EditText) findViewById(R.id.editText1);
        ((Button) findViewById(R.id.button1)).setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {
                int flag = 1;
                String xx = editview.getText().toString();
                if (!(xx.length() == 32 && xx.charAt(31) == 'a' && xx.charAt(1) == 'b' && (xx.charAt(0) + xx.charAt(2)) - 48 == 56)) {
                    flag = 0;
                }
                if (flag == 1) {
                    char[] x = "dd2940c04462b4dd7c450528835cca15".toCharArray();
                    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;
                    }
                    textview.setText("flag{" + String.valueOf(x) + "}");
                    return;
                }
                textview.setText("输入注册码错误");
            }
        });
    }

    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    public boolean onOptionsItemSelected(MenuItem item) {
        if (item.getItemId() == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }

    public static class PlaceholderFragment extends Fragment {
        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
            return inflater.inflate(R.layout.fragment_main, container, false);
        }
    }
}

#include<iostream>
#include<string>
using namespace std;

int main() {
    string x = "dd2940c04462b4dd7c450528835cca15";
    x[2] = (x[2] + x[3]) - 50;
    x[4] = (x[2] + x[5]) - 48;
    x[30] = (x[31] + x[9]) - 48;
    x[14] = (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 << "flag{" << x << "}" << endl;
}

[GWCTF 2019]pyre

python逆向
python -m pip install uncompyle
uncompyle6 ./attachment.pyc > rev.py

# uncompyle6 version 3.8.0
# Python bytecode 2.7 (62211)
# Decompiled from: Python 3.8.10 (tags/v3.8.10:3d8993a, May  3 2021, 11:48:03) [MSC v.1928 64 bit (AMD64)]
# Embedded file name: encode.py
# Compiled at: 2019-08-19 21:01:57
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']
# okay decompiling .\attachment.pyc

从后往前逆回去就行, code += num看起来不合理, 先不理它
exp

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

l = len(code)

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

for i in range(l):
    code[i] = chr((ord(code[i]) - i) % 128)
    
flag = ""
for i in range(l):
    flag += code[i]
print(flag)

[ACTF新生赛2020]easyre

在这里插入图片描述

脱壳, 拖进IDA
upx -d easyre.exe

int __cdecl main(int argc, const char **argv, const char **envp)
{
  _BYTE v4[12]; // [esp+12h] [ebp-2Eh] BYREF
  _DWORD v5[3]; // [esp+1Eh] [ebp-22h]
  _BYTE v6[5]; // [esp+2Ah] [ebp-16h] BYREF
  int v7; // [esp+2Fh] [ebp-11h]
  int v8; // [esp+33h] [ebp-Dh]
  int v9; // [esp+37h] [ebp-9h]
  char v10; // [esp+3Bh] [ebp-5h]
  int i; // [esp+3Ch] [ebp-4h]

  __main();
  qmemcpy(v4, "*F'\"N,\"(I?+@", sizeof(v4));
  printf("Please input:");
  scanf("%s", v6);
  if ( v6[0] != 65 || v6[1] != 67 || v6[2] != 84 || v6[3] != 70 || v6[4] != 123 || v10 != 125 )
    return 0;
  v5[0] = v7;
  v5[1] = v8;
  v5[2] = v9;
  for ( i = 0; i <= 11; ++i )
  {
    if ( v4[i] != _data_start__[*((char *)v5 + i) - 1] )
      return 0;
  }
  printf("You are correct!");
  return 0;
}

在这里插入图片描述

强逆, 可从hex窗口拷贝string
在这里插入图片描述

teststr = "*F'\"N,\"(I?+@"
print(len(teststr))

data = "~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>="
data += "<;:9876543210/.-,+*)("
data += chr(0x27)
data += "&%$# !\""

indexs = []
for ch in teststr:
    for i in range(len(data)):
        if ch == data[i]:
            indexs.append(chr(i + 1))
            print(i + 1)

flag = "".join(indexs)
print("ACTF{" + flag + "}")
print("flag{" + flag + "}")

rsa

密码学题目, 怎么丢进reverse来了…
pub.key改成pem文件, 拖进kali用openssl
在这里插入图片描述

n = 86934482296048119190666062003494800588905656017203025617216654058378322103517
http://www.factordb.com/index.php?query=86934482296048119190666062003494800588905656017203025617216654058378322103517
分解得到p, q
p = 285960468890451637935629440372639283459
q = 304008741604601924494328155975272418463

解密exp

import gmpy2
import rsa

e = 65537
n = 86934482296048119190666062003494800588905656017203025617216654058378322103517
p = 285960468890451637935629440372639283459
q = 304008741604601924494328155975272418463
d = gmpy2.invert(e, (q-1)*(p-1))

key = rsa.PrivateKey(n, e, int(d), p, q)

with open("./flag.enc", "rb+") as f:
    f = f.read()
    print(rsa.decrypt(f, key))

CrackRTF

int __cdecl main_0(int argc, const char **argv, const char **envp)
{
  DWORD v3; // eax
  DWORD v4; // eax
  char Str[260]; // [esp+4Ch] [ebp-310h] BYREF
  int v7; // [esp+150h] [ebp-20Ch]
  char String1[260]; // [esp+154h] [ebp-208h] BYREF
  char Destination[260]; // [esp+258h] [ebp-104h] BYREF

  memset(Destination, 0, sizeof(Destination));
  memset(String1, 0, sizeof(String1));
  v7 = 0;
  printf("pls input the first passwd(1): ");
  scanf("%s", Destination);
  if ( strlen(Destination) != 6 )
  {
    printf("Must be 6 characters!\n");
    ExitProcess(0);
  }
  v7 = atoi(Destination);
  if ( v7 < 100000 )
    ExitProcess(0);
  strcat(Destination, "@DBApp");
  v3 = strlen(Destination);
  sub_40100A((BYTE *)Destination, v3, String1);
  if ( !_strcmpi(String1, "6E32D0943418C2C33385BC35A1470250DD8923A9") )
  {
    printf("continue...\n\n");
    printf("pls input the first passwd(2): ");
    memset(Str, 0, sizeof(Str));
    scanf("%s", Str);
    if ( strlen(Str) != 6 )
    {
      printf("Must be 6 characters!\n");
      ExitProcess(0);
    }
    strcat(Str, Destination);
    memset(String1, 0, sizeof(String1));
    v4 = strlen(Str);
    sub_401019((BYTE *)Str, v4, String1);
    if ( !_strcmpi("27019e688a4e62a649fd99cadaafdb4e", String1) )
    {
      if ( !(unsigned __int8)sub_40100F(Str) )
      {
        printf("Error!!\n");
        ExitProcess(0);
      }
      printf("bye ~~\n");
    }
  }
  return 0;
}

int __cdecl sub_401230(BYTE *pbData, DWORD dwDataLen, LPSTR lpString1)
{
  int result; // eax
  DWORD i; // [esp+4Ch] [ebp-28h]
  CHAR String2[4]; // [esp+50h] [ebp-24h] BYREF
  BYTE v6[20]; // [esp+54h] [ebp-20h] BYREF
  DWORD pdwDataLen; // [esp+68h] [ebp-Ch] BYREF
  HCRYPTHASH phHash; // [esp+6Ch] [ebp-8h] BYREF
  HCRYPTPROV phProv; // [esp+70h] [ebp-4h] BYREF

  if ( !CryptAcquireContextA(&phProv, 0, 0, 1u, 0xF0000000) )
    return 0;
  if ( CryptCreateHash(phProv, 0x8004u, 0, 0, &phHash) )
  {
    if ( CryptHashData(phHash, pbData, dwDataLen, 0) )
    {
      CryptGetHashParam(phHash, 2u, v6, &pdwDataLen, 0);
      *lpString1 = 0;
      for ( i = 0; i < pdwDataLen; ++i )
      {
        wsprintfA(String2, "%02X", v6[i]);
        lstrcatA(lpString1, String2);
      }
      CryptDestroyHash(phHash);
      CryptReleaseContext(phProv, 0);
      result = 1;
    }
    else
    {
      CryptDestroyHash(phHash);
      CryptReleaseContext(phProv, 0);
      result = 0;
    }
  }
  else
  {
    CryptReleaseContext(phProv, 0);
    result = 0;
  }
  return result;
}

sub_401230用到了一个windows加密的加密库函数
观察发现6E32D0943418C2C33385BC35A1470250DD8923A9是40位的字符串
猜测可能是sha1加密
用sha1爆破一下6位密码

import hashlib

hash1 = "6E32D0943418C2C33385BC35A1470250DD8923A9".lower()
hash2 = "27019e688a4e62a649fd99cadaafdb4e".lower()
flag = "@DBApp"

for i in range(100000, 999999):
    s = str(i) + flag
    x = hashlib.sha1(s.encode())
    if x.hexdigest() == hash1:
        flag = s
        print(flag)
        break

123321@DBApp

验证通过
在这里插入图片描述

第二次hash是32位的字符串, 猜测是MD5, 但是直接全字符爆破不实际
分析其他线索

char __cdecl sub_4014D0(LPCSTR lpString)
{
  LPCVOID lpBuffer; // [esp+50h] [ebp-1Ch]
  DWORD NumberOfBytesWritten; // [esp+58h] [ebp-14h] BYREF
  DWORD nNumberOfBytesToWrite; // [esp+5Ch] [ebp-10h]
  HGLOBAL hResData; // [esp+60h] [ebp-Ch]
  HRSRC hResInfo; // [esp+64h] [ebp-8h]
  HANDLE hFile; // [esp+68h] [ebp-4h]

  hFile = 0;
  hResData = 0;
  nNumberOfBytesToWrite = 0;
  NumberOfBytesWritten = 0;
  hResInfo = FindResourceA(0, (LPCSTR)0x65, "AAA");
  if ( !hResInfo )
    return 0;
  nNumberOfBytesToWrite = SizeofResource(0, hResInfo);
  hResData = LoadResource(0, hResInfo);
  if ( !hResData )
    return 0;
  lpBuffer = LockResource(hResData);
  sub_401005(lpString, (int)lpBuffer, nNumberOfBytesToWrite);
  hFile = CreateFileA("dbapp.rtf", 0x10000000u, 0, 0, 2u, 0x80u, 0);
  if ( hFile == (HANDLE)-1 )
    return 0;
  if ( !WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, &NumberOfBytesWritten, 0) )
    return 0;
  CloseHandle(hFile);
  return 1;
}

unsigned int __cdecl sub_401420(LPCSTR lpString, int a2, int a3)
{
  unsigned int result; // eax
  unsigned int i; // [esp+4Ch] [ebp-Ch]
  unsigned int v5; // [esp+54h] [ebp-4h]

  v5 = lstrlenA(lpString);
  for ( i = 0; ; ++i )
  {
    result = i;
    if ( i >= a3 )
      break;
    *(_BYTE *)(i + a2) ^= lpString[i % v5];
  }
  return result;
}

从"AAA"resource中读取数据, 然后和输入的6个字符异或得到结果, 写入.rtf文件, 因为rtf文件头是确定的, 所以只要找到AAA中的数据就能得到第二个密钥

用resource-hacker

在这里插入图片描述

.rtf文件头
在这里插入图片描述

写exp解密第二个key, 这里rtf头有5字节, 往后多取一个字节, 为0x31

rtf_header = [0x7B, 0x5C, 0x72, 0x74, 0x66, 0x31]
arr = [0x05, 0x7D, 0x41, 0x15, 0x26, 0x01]

key2 = ''
for i in range(6):
    key2 += chr(rtf_header[i] ^ arr[i])
print(key2)

~!3a@0

输入exe的第二个key, 生成rtf文件, 用wps打开得到flag

fa1c4
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ctf之逆向工具包.zip
10-05
CTF逆向工具包，里面包含Androidnxzh,DeDeDark,IDAPro6.6,ILspyTool,WinHex等安装工具
HECTF2021 Reverse wp
whiteman2的博客
11-15 632
前言 昨天结束的比赛,体验不错,Reverse拿了6个一血,也把Reverse的题目AK了,记录下。 文章目录 hard Baby_upx Baby_pp baby-maze baby_and baby_anti crypt flag hard 直接拖进IDA进行分析,先查找字符串 直接发现flag: HECTF{HElLo_RRRRe} Baby_upx 根据题目提示,估计是加了upx壳,查壳: 果然加了upx壳,首先尝试用工具脱壳，发现脱壳失败,直接使用esp定律，手动dump下来，拖进id
逆向初学者做题记录  3.20
m0_73718199的博客
03-24 219
逆向初学者做题记录
buuctf re逆向6-10wp
weixin_50847719的博客
06-28 417
6.xor 无壳，64位， IDA打开 双击global 复制出来__data:_global ‘f’,0Ah ‘k’,0Ch,‘w&O.@’,11h,‘x’,0Dh,‘Z;U’,11h,‘p’,19h,‘F’,1Fh,‘v"M#D’,0Eh,‘g’,‘h’,0Fh,‘G2O’,0 里面的十六进制换一下 其实就是str1 = [‘f’, 0x0A, ‘k’, 0x0C, ‘w’, ‘&’, ‘O’, ‘.’, ‘@’, 0x11, ‘x’, 0x0D, ‘Z’, ‘;’, ‘U’,
BUUCTF reverse16-20 WP
mumuzi的博客
03-30 1147
写脚本技术很菜，所以和其他wp相比看起来比较麻烦 笔记是按照当时的题目排序写的，顺序可能有出入 做题是从0开始做起，所以前面部分也会尽可能写的详细一点 只要能记录并且了解到怎么做即可，所以就没有去在意排版 遇到不会的函数尽可能去百度了解 因为前面的题难度不大，所以前面的每道题都没有去查壳，除非有特殊:) 题目：[GWCTF 2019]pyre、[BJDCTF2020]JustRE、rsa、CrackRTF、[ACTF新生赛2020]easyre 16.[GWCTF 2019]pyre 得到的 flag 请包
BUUCTF Reverse CrackRTF-附件资源
03-05
BUUCTF Reverse CrackRTF-附件资源
reverse-shell-generator:简单的脚本来生成反向shell
04-10
cd reverse-shell-generator 3. Install Dependencies: pip3 install -r requirements.txt 4. Run the Python-file: python3 main.py 通过脚本安装： chmod +x install.sh ./install.sh 完毕！ 由SoftwareUser23...
Reverse-Proxy-for-Google
04-10
Google反向代理[Nginx]可配置的Nginx com代理反Google产品，可单独使用Archivo默认的默认网站-可用nano / etc / nginx / sites-可用/默认pegar lo siguiente：配置server { listen 80 ; server_name example.com;...
reverse-shell-generator：基于Web的反向shell生成器
02-05
reverse-shell-generator：基于Web的反向shell生成器
REVERSE-PRACTICE-BUUCTF-20
P1umH0的博客
02-27 345
REVERSE-PRACTICE-BUUCTF-20[SCTF2019]creakme[网鼎杯 2020 青龙组]bang[WUSTCTF2020]funnyreDig the way [SCTF2019]creakme exe程序，运行后提示输入ticket，无壳，ida分析 交叉引用字符串“please input your ticket:”来到sub_402540函数 分析sub_402320函数，在DebugBreak和return之间有一段代码引用 修改EIP从地址0x402412处开始执行，
攻防世界 Windows_Reverse1
P_Bloomberg的博客
08-09 430
准备 环境：Windows10 工具：ExeinfoPE、upx、IDA、x32dbg、010Editor 开始 附件是.exe文件，使用ExeinfoPE查看文件信息 能看出来此文件被upx加了壳。 使用upx脱壳 将脱壳后的文件放入IDA静态分析 main函数： int __cdecl main(int argc, const char **argv, const char **envp) { char v4; // [esp+4h] [ebp-804h] BYREF char v5[102
REVERSE-PRACTICE-BUUCTF-11
P1umH0的博客
02-26 276
REVERSE-PRACTICE-BUUCTF-11[FlareOn4]IgniteMe[MRCTF2020]Xor[GKCTF2020]BabyDriver[MRCTF2020]hello_world_go [FlareOn4]IgniteMe exe程序，运行后提示输入flag，无壳，ida分析 主逻辑在start函数中，读取输入后check，验证输入成功则输出“G00d j0b!” 分析sub_401050函数，input和v4异或后放入byte_403180，v4有一个初始值，且在循环中不断变化，
[buuctf.reverse] 11-32
weixin_52640415的博客
05-06 1413
目录 11java逆向解密 012_[GXYCTF2019]luck_guy 013_刮开有奖 014_[BJDCTF2020]JustRE 015_findit 016_简单注册器 017_[GWCTF 2019]pyre 018_[ACTF新生赛2020]easyre 019_rsa 020_[ACTF新生赛2020]rome 021_CrackRTF 022_[FlareOn4]login 023_[2019红帽杯]easyRE 024_[GUET-CTF2019]r.
BUUCTF刷题记录 [Reverse]
weixin_45225566的博客
01-02 262
BUUCTF刷题记录 [Reverse]
Windows_Reverse1
Tigger.run 独立开发者 热爱逆向工程
05-19 686
目录0x0 题目涉及知识点0x1 查壳脱壳0x2 反汇编分析0x3写脚本 0x0 题目涉及知识点 简单脱壳 指针运算 位移量 字符串查询 0x1 查壳脱壳 使用 UPX 工具脱壳 0x2 反汇编分析 初步了解程序执行流程，sub_401000(&v6) 为加密过程，&v4中存放了flag。 char v4; // [esp+4h] [ebp-804h] char v5; // [esp+5h] [ebp-803h] char v6; // [esp+404h] [ebp
CTF比赛必备常用工具（附下载方式）
热门推荐
Python_0011的博客
06-27 1万+
在解题模式CTF赛制中，参赛队伍可以通过互联网或者现场网络参与，这种模式的CTF竞赛与ACM编程竞赛、信息学奥赛比较类似，以解决网络安全技术挑战题目的分值和时间来排名，通常用于在线选拔赛。主要包括六大类：PWN、CRYPTO(解密)、REVERSE（逆向）、WEB、MISC(杂项)其中，REVERSE（逆向）和MISC(杂项)，在比赛中要使用大量的辅助工具，才能快速解题。本文章也主要聚焦这两类赛题的工具。
黑客赚钱的路子有多野？CTF逆向入门指南
weixin_68789096的博客
06-18 1045
在CTF比赛中, CTF逆向题目除了需要分析程序工作原理, 还要根据分析结果进一步求出FLAG。逆向在解题赛制中单独占一类题型, 同时也是PWN题的前置技能。在攻防赛制中常与PWN题结合。CTF逆向主要涉及到逆向分析和破解技巧，这也要求有较强的反汇编、反编译、加解密的功底。1、常见算法与数据结构。2、各种排序算法, 树, 图等数据结构。3、识别加密算法与哈希算法代码特征,识别算法中魔改的部分。4、代码混淆, 代码虚拟化, 修改代码流程, 反调试等。5、软件加密壳是软件保护技术的集中应用。
CTF-REVERSE练习之逆向初探
bdfcfff77fa的博客
07-26 2465
逆向是指通过反汇编和调试等一些手段及工具，分析计算机程序的二进制可执行代码，从而获得程序的算法细节和实现原理的技术。不仅如此，逆向技能在信息安全面向的具体工作，如恶意代码分析、软件漏洞挖掘、移动安全以及对软件的破解方面发挥着巨大的作用。前面介绍过CTF的web真题，那今天我们从CTF中选择一个REVERSE题型来讲解。
BUUCTF的逆向工程(reverse)之reverse1
weixin_44632787的博客
08-19 1966
用IDA64位打开，发现里面没有main函数，所以shift + F12查找一下flag关键词 然后跟着提示找到关键函数sub_1400118C0 __int64 sub_1400118C0() { char *v0; // rdi signed __int64 i; // rcx size_t v2; // rax size_t v3; // rax char v5; // [rsp+0h] [rbp-20h] int j; // [rsp+24h] [rbp+4h] cha
buuctf reverse wp
最新发布
08-03
根据提供的引用内容，我们可以得到以下信息： 引用[1]提供了一个大整数n，以及它的因子p和q。 引用[2]提供了一个函数get_flag()，其中包含了一些逻辑判断和字符串操作。根据代码中的注释，当随机数为1时，会输出一个flag。 引用[3]提供了一个main函数，其中包含了一些字符串比较和逻辑判断。根据代码中的注释，当输入的字符串满足一定条件时，会输出"You are correct!"。 根据以上信息，我们可以推断buuctf reverse wp是关于逆向工程的挑战。具体来说，可能需要分析get_flag()函数和main函数的逻辑，以及对n进行因式分解，以获取flag。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值