[GWCTF 2019]babyvm

最新推荐文章于 2023-11-27 19:04:18 发布
最新推荐文章于 2023-11-27 19:04:18 发布
阅读量1.4k 收藏 4
点赞数 3
分类专栏： CTF-RE 文章标签： 反汇编 安全 字符串 信息安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46296905/article/details/116374983
版权

题目：[GWCTF 2019]babyvm

64位程序，好像是个vm题？
在这里插入图片描述
ida64查看主函数

void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  __int64 v3[2]; // [rsp+10h] [rbp-10h] BYREF

  v3[1] = __readfsqword(0x28u);
  v3[0] = 0LL;
  puts("Please input something:");
  sub_CD1(v3);
  sub_E0B(v3);
  sub_F83(v3);
  puts("And the flag is GWHT{true flag}");
  exit(0);
}

看一下sub_F83函数，这应该是check函数了，qword_2022A8存放的应该是加密后的flag。前两个应该就是加密函数了。

unsigned __int64 sub_F83()
{
  int i; // [rsp+Ch] [rbp-14h]
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  for ( i = 0; dword_2022A4 - 1 > i; ++i )
  {
    if ( *(qword_2022A8 + i + 32) != aFzAmAmFmtSum[i] )
    {
      puts("WRONG!");
      exit(0);
    }
  }
  puts("Congratulation?");
  puts("tips: input is the start");
  return __readfsqword(0x28u) ^ v2;
}

先用angr解一下试试水。

import angr
p=angr.Project("./Desktop/attachment",auto_load_libs=False)
sm=p.factory.simulation_manager(p.factory.entry_state())
sm.explore(find=0x401081)
print(sm.found[0].posix.dumps(0))

在这里插入图片描述
解出来是个假flag，不足为奇，是vm题不错了。

解vm题第一步需要搞清楚指令的格式，操作码和操作数。

sub_CD1函数是vm初始化的过程，unk_202060里面存储的是操作码，接下来每一个操作码对应一个函数实现（如0xF1对应sub_B5F函数）
在这里插入图片描述

unsigned __int64 __fastcall sub_CD1(__int64 a1)
{
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);                    // 反调试
  *a1 = 0;
  *(a1 + 4) = 18;
  *(a1 + 8) = 0;
  *(a1 + 12) = 0;
  *(a1 + 16) = &unk_202060;                     // unk_202060是操作码的内容
  *(a1 + 24) = 0xF1;                            // 0xF1操作码代表sub_B5F函数
  *(a1 + 32) = sub_B5F;
  *(a1 + 40) = 0xF2;                            // 0xF2操作码代表sub_A64函数
  *(a1 + 48) = sub_A64;
  *(a1 + 56) = 0xF5;                            // 0xF5操作码代表sub_AC5函数
  *(a1 + 64) = sub_AC5;
  *(a1 + 72) = 0xF4;                            // 0xF4操作码代表sub_956函数
  *(a1 + 80) = sub_956;
  *(a1 + 88) = 0xF7;                            // 0xF7操作码代表sub_A08函数
  *(a1 + 96) = sub_A08;
  *(a1 + 104) = 0xF8;                           // 0xF8操作码代表sub_8F0函数
  *(a1 + 112) = sub_8F0;
  *(a1 + 120) = 0xF6;                           // 0xF6操作码代表sub_99C函数
  *(a1 + 128) = sub_99C;
  qword_2022A8 = malloc(0x512uLL);
  memset(qword_2022A8, 0, 0x512uLL);
  return __readfsqword(0x28u) ^ v2;
}

分析一下各个操作码进行的操作。

0xF1

0xE1，0xE2，0xE3，0xE4对应5个寄存器，实际的具体位置分别是a1，a1+4，a1+8，a1+12，而*(qword_2022A8 + *v2)对应内存单元。

0xF1进行的操作类似于mov操作符，

unsigned __int64 __fastcall sub_B5F(__int64 a1)
{
  int *v2; // [rsp+28h] [rbp-18h]
  unsigned __int64 v3; // [rsp+38h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  v2 = (*(a1 + 16) + 2LL);
  switch ( *(*(a1 + 16) + 1LL) )
  {
    case 0xE1:
      *a1 = *(qword_2022A8 + *v2);
      break;
    case 0xE2:
      *(a1 + 4) = *(qword_2022A8 + *v2);
      break;
    case 0xE3:
      *(a1 + 8) = *(qword_2022A8 + *v2);
      break;
    case 0xE4:
      *(qword_2022A8 + *v2) = *a1;
      break;
    case 0xE5:
      *(a1 + 12) = *(qword_2022A8 + *v2);
      break;
    case 0xE7:
      *(qword_2022A8 + *v2) = *(a1 + 4);
      break;
    default:
      break;
  }
  *(a1 + 16) += 6LL;
  return __readfsqword(0x28u) ^ v3;
}

0xF2

异或xor，两个操作数间隔4。

unsigned __int64 __fastcall sub_A64(__int64 a1)
{
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  *a1 ^= *(a1 + 4);
  ++*(a1 + 16);
  return __readfsqword(0x28u) ^ v2;
}

0xF5

是个读取输入字符并判断长度的操作，存入qword_2022A8。

unsigned __int64 __fastcall sub_AC5(__int64 a1)
{
  const char *buf; // [rsp+10h] [rbp-10h]
  unsigned __int64 v3; // [rsp+18h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  buf = qword_2022A8;
  read(0, qword_2022A8, 0x20uLL);
  dword_2022A4 = strlen(buf);
  if ( dword_2022A4 != 21 )
  {
    puts("WRONG!");
    exit(0);
  }
  ++*(a1 + 16);
  return __readfsqword(0x28u) ^ v3;
}

0xF4

空指令nop

unsigned __int64 __fastcall sub_956(__int64 a1)
{
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  ++*(a1 + 16);
  return __readfsqword(0x28u) ^ v2;
}

0xF7

相乘操作mul，两个操作数间隔12。

unsigned __int64 __fastcall sub_A08(__int64 a1)
{
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  *a1 *= *(a1 + 12);
  ++*(a1 + 16);
  return __readfsqword(0x28u) ^ v2;
}

0xF8

交换swap

unsigned __int64 __fastcall sub_8F0(int *a1)
{
  int v2; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v3; // [rsp+18h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  v2 = *a1;
  *a1 = a1[1];
  a1[1] = v2;
  ++*(a1 + 2);
  return __readfsqword(0x28u) ^ v3;
}

0xF6

线性运算

unsigned __int64 __fastcall sub_99C(__int64 a1)
{
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  *a1 = *(a1 + 8) + 2 * *(a1 + 4) + 3 * *a1;
  ++*(a1 + 16);
  return __readfsqword(0x28u) ^ v2;
}

反汇编

机器码备注
0xF1mov
0xF2xor
0xF4nop
0xF5input
0xF7mul
0xF8swap
0xF6线性运算
0xE1寄存器r1
0xE2寄存器r2
0xE3寄存器r3
0xE4内存单元flag
0xE5寄存器r4

现在开始翻译unk_202060中的字节码

0xF5,                               #获取输入
0xF1, 0xE1, 0x00, 0x00, 0x00, 0x00, #mov r1,flag[0]
0xF2,                               #xor r1,r2
0xF1, 0xE4, 0x20, 0x00, 0x00, 0x00, #mov flag[32],r1
0xF1, 0xE1, 0x01, 0x00, 0x00, 0x00, #mov r1,flag[1]
0xF2,                               #xor r1,r2
0xF1, 0xE4, 0x21, 0x00, 0x00, 0x00, #mov flag[33],r1
0xF1, 0xE1, 0x02, 0x00, 0x00, 0x00, #mov r1,flag[2]
0xF2,                               #xor r1,r2
0xF1, 0xE4, 0x22, 0x00, 0x00, 0x00, #mov flag[34],r1
0xF1, 0xE1, 0x03, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x23, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x04, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x24, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x05, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x25, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x06, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x26, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x07, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x27, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x08, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x28, 0x00, 0x00,0x00, 
0xF1, 0xE1, 0x09, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x29, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x0A, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x2A, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x0B, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x2B, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x0C, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x2C, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x0D, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x2D, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x0E, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x2E, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x0F, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x2F, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x10, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x30, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x11, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x31, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x12, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x32, 0x00, 0x00, 0x00, 
0xF1, 0xE1, 0x13, 0x00, 0x00, 0x00, 
0xF2, 
0xF1, 0xE4, 0x33, 0x00, 0x00, 0x00, 
0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 

#主要是下面这部分字节码,stack即flag
    0xf5,#read(0,buf,0x20)
	0xf1,0xe1,0x0,0x0,0x0,0x0,#r1 = flag[0]
	0xf1,0xe2,0x1,0x0,0x0,0x0,#r2 = flag[1]
	0xf2,#r1 = r1^r2
	0xf1,0xe4,0x0,0x0,0x0,0x0,#stack[0] = r1
	
	0xf1,0xe1,0x1,0x0,0x0,0x0,#r1 = flag[1]
	0xf1,0xe2,0x2,0x0,0x0,0x0,#r2 = flag[2]
	0xf2,#r1 = r1^r2
	0xf1,0xe4,0x1,0x0,0x0,0x0,#stack[1] = r1
	
	0xf1,0xe1,0x2,0x0,0x0,0x0,#r1 = flag[2]
	0xf1,0xe2,0x3,0x0,0x0,0x0,#r2 = flag[3]
	0xf2,#r1 = r1^r2
	0xf1,0xe4,0x2,0x0,0x0,0x0,#stack[2] = r1

	0xf1,0xe1,0x3,0x0,0x0,0x0,#r1 = flag[3]
	0xf1,0xe2,0x4,0x0,0x0,0x0,#r2 = flag[4]
	0xf2,#r1 = r1^r2
	0xf1,0xe4,0x3,0x0,0x0,0x0,#stack[3] = r1

	0xf1,0xe1,0x4,0x0,0x0,0x0,#r1 = flag[4]
	0xf1,0xe2,0x5,0x0,0x0,0x0,#r2 = flag[5]
	0xf2,#r1 = r1^r2
	0xf1,0xe4,0x4,0x0,0x0,0x0,#stack[4] = r1

	0xf1,0xe1,0x5,0x0,0x0,0x0,#r1 = flag[5]
	0xf1,0xe2,0x6,0x0,0x0,0x0,#r2 = flag[6]
	0xf2,#r1 = r1^r2
	0xf1,0xe4,0x5,0x0,0x0,0x0,#stack[5] = r1

	0xf1,0xe1,0x6,0x0,0x0,0x0,#r1 = flag[6]
	0xf1,0xe2,0x7,0x0,0x0,0x0,#r2 = flag[7]
	0xf1,0xe3,0x8,0x0,0x0,0x0,#r3 = flag[8]
	0xf1,0xe5,0xC,0x0,0x0,0x0,#r4 = flag[12]
	0xf6, #r1 = (3*r1+2*r2+r3)
	0xf7, #r1 = r1*r4
	0xf1,0xe4,0x6,0x0,0x0,0x0,#stack[6] = r1

	0xf1,0xe1,0x7,0x0,0x0,0x0,#r1 = flag[7]
	0xf1,0xe2,0x8,0x0,0x0,0x0,#r2 = flag[8]
	0xf1,0xe3,0x9,0x0,0x0,0x0,#r3 = flag[9]
	0xf1,0xe5,0xC,0x0,0x0,0x0,#r4 = flag[12]
	0xf6, #r1 = (3*r1+2*r2+r3)
	0xf7, #r1 = r1*r4
	0xf1,0xe4,0x7,0x0,0x0,0x0,#stack[7] = r1

	0xf1,0xe1,0x8,0x0,0x0,0x0,#r1 = flag[8]
	0xf1,0xe2,0x9,0x0,0x0,0x0,#r2 = flag[9]
	0xf1,0xe3,0xA,0x0,0x0,0x0,#r3 = flag[10]
	0xf1,0xe5,0xC,0x0,0x0,0x0,#r4 = flag[12]
	0xf6, #r1 = (3*r1+2*r2+r3)
	0xf7, #r1 = r1*r4
	0xf1,0xe4,0x8,0x0,0x0,0x0,#stack[8] = r1

	0xf1,0xe1,0xD,0x0,0x0,0x0,#r1 = flag[13]
	0xf1,0xe2,0x13,0x0,0x0,0x0,#r2 = flag[19]
	0xf8,#r1 = r2,r2 = r1
	0xf1,0xe4,0xD,0x0,0x0,0x0,#stack[13] = r1
	0xf1,0xe7,0x13,0x0,0x0,0x0,#stack[19] = r2

	0xf1,0xe1,0xE,0x0,0x0,0x0,#r1 = flag[14]
	0xf1,0xe2,0x12,0x0,0x0,0x0,#r2 = flag[18]
	0xf8,#r1 = r2,r2 = r1
	0xf1,0xe4,0xE,0x0,0x0,0x0,#stack[14] = r1
	0xf1,0xe7,0x12,0x0,0x0,0x0,#stack[18] = r2

	0xf1,0xe1,0xF,0x0,0x0,0x0,#r1 = flag[15]
	0xf1,0xe2,0x11,0x0,0x0,0x0,#r2 = flag[17]
	0xf8,#r1 = r2,r2 = r1
	0xf1,0xe4,0xF,0x0,0x0,0x0,#stack[15] = r1
	0xf1,0xe7,0x11,0x0,0x0,0x0,#stack[17] = r2
	0xf4#ret

再找一下check函数，直接看qword_2022A8的交叉引用，找到真正的check函数

unsigned __int64 sub_F00()
{
  int i; // [rsp+Ch] [rbp-14h]
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  for ( i = 0; dword_2022A4 - 1 > i; ++i )
  {
    if ( *(qword_2022A8 + i) != byte_202020[i] )
      exit(0);
  }
  return __readfsqword(0x28u) ^ v2;
}

byte_202020[]={0x69, 0x45, 0x2A, 0x37, 0x09, 0x17, 
               0xC5, 0x0B, 0x5C, 0x72, 0x33, 0x76, 
               0x33, 0x21, 0x74, 0x31, 0x5F, 0x33,
               0x73, 0x72, 0x00, 0x00, 0x00, 0x00,
               0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
               0x00, 0x00}

EXP

from z3 import *
a=Real('a')
b=Real('b')
c=Real('c')

byte=[0x69, 0x45, 0x2A, 0x37, 0x09, 0x17, 0xC5, 0x0B, 0x5C, 0x72, 0x33, 0x76, 0x33, 0x21, 0x74, 0x31, 0x5F, 0x33, 0x73, 0x72,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0]

temp=byte[15]
byte[15]=byte[17]
byte[17]=temp

temp=byte[14]
byte[14]=byte[18]
byte[18]=temp

temp=byte[13]
byte[13]=byte[19]
byte[19]=temp
solve((3*a+2*b+c)*0x33==0x6dc5,(3*b+2*c+0x72)*0x33==0x5b0b,(3*c+2*0x72+0x33)*0x33==0x705c)
#a = 118,b = 51,c = 95

byte[6] = 118
byte[7] = 51
byte[8] = 95

byte[5]^=(byte[6])
byte[4]^=(byte[5])
byte[3]^=(byte[4])
byte[2]^=(byte[3])
byte[1]^=(byte[2])
byte[0]^=(byte[1])

flag=''
for i in range(32):
	flag+=chr(byte[i])
print(flag)

在这里插入图片描述

flag{Y0u_hav3_r3v3rs3_1t!}
Em0s_Er1t
关注
专栏目录
［GW－CTF2019］ babyvm
0.2°的博客
09-09 477
- [目录] 分析 脚本 总结 GW CTF2019 babyvm 复现 得到一个文件 先exeinfope 64位elf文件 打开后找到main函数 第一个是初始化，第二个是退出，第三个检查flag(但是分析完会发现这个是假的) init进去后 分析完后 分析完后根据自己理解分析出他的指令集 |0xF1|MOV | |0xF2|XOR–| |0xF4|NOP | |0xF5|read_str | |0xF7|computing–| |0xF6 |mul | |0xF8|swap | p
CTF逆向-[GWCTF 2019]babyvm-WP-虚机模拟流程反向编码和z3约束求解器解方程工具的使用
serfend's blog
04-13 726
CTF逆向-[GWCTF 2019]babyvm-WP-虚机模拟流程反向编码和z3约束求解器解方程工具的使用 来源：https://buuoj.cn/ 内容： 附件：https://pan.baidu.com/s/1FKkXN6JDI0QkGw-UE2crNA?pwd=grb0 提取码：grb0 答案：Y0u_hav3_r3v3rs3_1t! 总体思路 发现是虚机模拟 形成每个指令的逆向 找到加密值位置（有可能不止一个位置，该题就给了一个误导的） 找到命令执行的流程（也是不止一个） 逆向编写反向加密得到f
BUUCTF-[GWCTF 2019]babyvm
weixin_61154173的博客
04-09 1054
vm简单逆向，switch不同，赋值给的对象不同，所以可以看做是不同寄存器，所以0xE1->eax，0xE2->ebx，0xE3->ecx，0xE5->edx。这种简单vm逆向搞了快半辈子了，看别人wp也看的迷迷糊糊的，可能是受一个python虚拟机题的影响，第一次见vm，简单记录一下~发现是一堆数据，根据对vm的简单了解，这些应该是操作码，继续看函数其他的部分，应该是操作码及其对应的操作指令。是个异或操作，看异或对象可知，xor eax，ebx。乘的操作，看操作对象是 mul eax，edx。
babyvm wp
12-21
大佬给的练习题，应该是根据广外2019比赛babyvm改的，自己也是第一次接触vm的ctf题，很简单，记录下。 题目下载地址： 链接：https://pan.baidu.com/s/1fWfikdoviwZ2PnkCi2p2zA 提取码：4gbf 0x0 函数分析 载入IDA，F5查看主函数 有三个函数，进一步查看 sub_400839 此函数为VM的初始化过程，6010A0为vm操作码的内容，0xf1代表sub_400738函数，0xf2代表sub_4006B6函数，0xf5代表sub_4006F4函数 unk_6010A0内容（截取部分） sub_400738（0xf1） 分析
[GWCTF 2019]babyvm 详解 （vm逆向 IDA结构体）
最新发布
sirrior的博客
11-27 1152
这是笔者做的第一道vm题，虽然相较于同类题题面很简单，但是在过程中收获了很多。
vnctf——babyvm
weixin_52369224的博客
02-17 3424
深入了解 vm虚拟机逆向 这是一道golang vm题，64位idapro 7.7 对于go反编译进行了优化，可以直接看。 分析主函数，unk_B9D8A0为我们的opcode段 根据部分函数 猜测a7就是虚拟机的寄存器个数，并且为21. 推测栈的大小为0x3e8 struct func { void *call; vm *ptr; }; struct REG { _DWORD R[21]; }; struct vm { REG reg; _DWORD Memor
BUUCTF-[GWCTF 2019]xxor
qq_66455531的博客
07-07 376
HIWORD和LOWORD就是把每一个元素对半分，高位分给HIWORD低位分给LOWORD。这里把输入的数组的高低位分开，高位保留，低位进行tea加密。这里最需要注意的是，v6 和 v7数组的声明是i64，也就是每个元素64bit，也就是8个字节。得到flag{re_is_great!能推出来数组，然后再看tea加密部分。解密就是加密的逆过程，写脚本。先看加密合并后的数组。
[GWCTF 2019]xxor-buuctf
Lenard404的博客
03-14 5499
buuctf做题记录 查壳 64位无壳 分析 IDA反编译main函数 结构还是很清晰的，sub_400686是加密函数，sub_400770是对加密后字符串进行比较，即验证函数。 查看sub_400770 符合条件就返回1，用z3进行一个求解： from z3 import * s = IntVector('s',6) solver = Solver() solver.add(s[0]== 0xdf48ef7e) solver.add(s[2]-s[3] == 0x84a236ff) solver.a
BUUCTF_Crypto_[GWCTF 2019]BabyRSA
qq_58370970的博客
12-08 638
题目：给了一个py文件和一个txt文件（用txt打开） 可以看出flag是分成两段被加密了 通过 可以知道p，q相差不大，可以通过yafu直接分解出来 得到p，q 解出c1,c2后依旧要接F1+F2=c1，F1**3+fF2**3=c2 大佬的解法 代码： import gmpy2 import libnum from z3 import * from sympy.abc import a,b import binascii e=0x10001 n=63658514...
[GWCTF 2019]babyvm 题解
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
07-10 837
[GWCTF 2019]babyvm 题解
[GWCTF 2019]babyvm writeup
weixin_42100211的博客
10-22 213
本文可能需要配合其它wp来看。本文亮点在于angr解法，和更详细的指令翻译。
buuctf GWCTF 2019 pyre
HLi1219的博客
10-30 336
下载题目发现是一个pyc文件，关于pyc的详细解释，我看到了这篇文章(6条消息) .pyc是什么？_loveliuzz的博客-CSDN博客_.pyc pyc文件是PyCodeObject的一种持久化保存方式，当我们第二次运行Python程序时，编译器会运行pyc文件，直接载入，可能是直接载入第一次运行结果吧。 在网站 https://tool.lu/pyc/ 将pyc文件进行还原，达到了Python的代码 #!/usr/bin/env python # visit https://tool.lu..
GWCTF 2019 BabyRSA
pondzhang的专栏
05-01 1411
题目： import hashlib import sympy from Crypto.Util.number import * flag = 'GWHT{******}' secret = '******' assert(len(flag) == 38) half = len(flag) / 2 flag1 = flag[:half] flag2 = flag[half:] sec...
VM虚拟机逆向---[羊城杯 2021]Babyvm 复现【详解】
Sciurdae的博客
11-07 850
无。
Reverse入门[不断记录]
Aiwin的博客
02-18 3791
CTF Reverse入门笔记，不断记录。
[GWCTF 2019]BabyRSA 1
weixin_44110537的博客
07-07 1892
问题 首先拿到压缩包,压缩包中给了我们两个文件 一个是encrypt.py 这个文件是加密脚本 另一个是secret里面有我们所需要的数据 分析加密脚本 打开脚本 import hashlib import sympy from Crypto.Util.number import * flag = 'GWHT{******}' secret = '******' assert(len(flag) == 38) half = len(flag) / 2 flag1 = flag[:half] fla
[GWCTF2019]huyao
07-28
\[GWCTF2019\]huyao是一个CTF比赛中的题目。根据引用\[1\]和引用\[2\]的内容，它可能涉及到频域盲水印隐写。具体的解题方法和细节需要参赛者在比赛中进行分析和解决。 #### 引用[.reference_title] - *1* [BUUCTF MISC刷题笔记(三)](https://blog.csdn.net/weixin_45696568/article/details/116421340)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [BUUCTF misc 解题记录 二（超级详细）](https://blog.csdn.net/qq_51090016/article/details/115712647)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Em0s_Er1t

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

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

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

打赏作者

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

抵扣说明：

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

余额充值