Question

我正在努力寻找有助于我的管理层了解对编译后的C代码进行逆向工程的难易程度的确凿事实。

之前在这个网站上已经提出了类似的问题（参见例如Is it possible to “decompile” a Windows .exe? Or at least view the Assembly?或Possible to decompile DLL written in C?），但这些问题的要点是反编译编译的C代码“很难，但并非完全不可能”。

为了促进基于事实的答案，我包含了一个神秘函数的编译代码，我建议这个问题的答案衡量所提议技术的成败，因为他们是否可以确定这个函数是做什么的。这可能是不寻常的，但我认为这是获得这个工程问题的“良好主观”或事实答案的最佳方式。因此，您对该功能的作用有何最佳猜测，以及如何？

这是在Mac OSX上使用gcc：

编译的已编译代码

_mystery:
Leh_func_begin1:
    pushq   %rbp
Ltmp0:
    movq    %rsp, %rbp
Ltmp1:
    movsd   LCPI1_0(%rip), %xmm1
    subsd   %xmm0, %xmm1
    pxor    %xmm2, %xmm2
    ucomisd %xmm1, %xmm2
    jbe     LBB1_2
    xorpd   LCPI1_1(%rip), %xmm1
LBB1_2:
    ucomisd LCPI1_2(%rip), %xmm1
    jb      LBB1_8
    movsd   LCPI1_0(%rip), %xmm1
    movsd   LCPI1_3(%rip), %xmm2
    pxor    %xmm3, %xmm3
    movsd   LCPI1_1(%rip), %xmm4
    jmp     LBB1_4
    .align  4, 0x90
LBB1_5:
    ucomisd LCPI1_2(%rip), %xmm1
    jb      LBB1_9
    movapd  %xmm5, %xmm1
LBB1_4:
    movapd  %xmm0, %xmm5
    divsd   %xmm1, %xmm5
    addsd   %xmm1, %xmm5
    mulsd   %xmm2, %xmm5
    movapd  %xmm5, %xmm1
    mulsd   %xmm1, %xmm1
    subsd   %xmm0, %xmm1
    ucomisd %xmm1, %xmm3
    jbe     LBB1_5
    xorpd   %xmm4, %xmm1
    jmp     LBB1_5
LBB1_8:
    movsd   LCPI1_0(%rip), %xmm5
LBB1_9:
    movapd  %xmm5, %xmm0
    popq    %rbp
    ret 
Leh_func_end1:

更新

@Igor Skochinsky是第一个找到正确答案的人：它确实是Heron计算平方根的算法的天真实现。原始源代码在这里：

#include <stdio.h> #define EPS 1e-7 double mystery(double x){ double y=1.; double diff; diff=y*y-x; diff=diff<0?-diff:diff; while(diff>=EPS){ y=(y+x/y)/2.; diff=y*y-x; diff=diff<0?-diff:diff; } return y; } int main() { printf("The square root of 2 is %g\n", mystery(2.)); }

Answer 1

以下是我将代码转换为x86后使用Hex-Rays Decompiler进行反编译的结果（目前它不支持x64），添加了原始帖子中缺少的一些数据定义，并将其汇总：

//-------------------------------------------------------------------------
// Data declarations

double LCPI1_0 =  1.0; // weak
double LCPI1_1[2] = {  0.0,  0.0 }; // weak
double LCPI1_2 =  1.2; // weak
double LCPI1_3 =  1.3; // weak


//----- (00000000) --------------------------------------------------------
void __usercall mystery(__m128d a1<xmm0>)
{
  __m128d v1; // xmm1@1
  __m128d v2; // xmm1@4
  __int128 v3; // xmm2@4
  __m128d v4; // xmm5@7
  __m128d v5; // xmm1@7

  v1 = (__m128d)*(unsigned __int64 *)&LCPI1_0;
  v1.m128d_f64[0] = LCPI1_0 - a1.m128d_f64[0];
  if ( LCPI1_0 - a1.m128d_f64[0] < 0.0 )
    v1 = _mm_xor_pd(v1, *(__m128d *)LCPI1_1);
  if ( v1.m128d_f64[0] >= LCPI1_2 )
  {
    v2 = (__m128d)*(unsigned __int64 *)&LCPI1_0;
    v3 = *(unsigned __int64 *)&LCPI1_3;
    while ( 1 )
    {
      v4 = a1;
      v4.m128d_f64[0] = (v4.m128d_f64[0] / v2.m128d_f64[0] + v2.m128d_f64[0]) * *(double *)&v3;
      v5 = v4;
      v5.m128d_f64[0] = v5.m128d_f64[0] * v5.m128d_f64[0] - a1.m128d_f64[0];
      if ( v5.m128d_f64[0] < 0.0 )
        v5 = _mm_xor_pd(a1, (__m128d)*(unsigned __int64 *)LCPI1_1);
      if ( v5.m128d_f64[0] < LCPI1_2 )
        break;
      v2 = a1;
    }
  }
}
// 90: using guessed type double LCPI1_0;
// 98: using guessed type double LCPI1_1[2];
// A8: using guessed type double LCPI1_2;
// B0: using guessed type double LCPI1_3;

// ALL OK, 1 function(s) have been successfully decompiled

显然，它可以使用一些改进（XMM支持现在有点基础），但我认为基本算法已经可以理解了。

编辑：因为很明显只使用了所有XMM寄存器的低两倍，看起来该函数实际上与标量双精度数而不是向量一起使用。对于_mm_xor_pd（xorpd）内在函数，我认为这只是编译器实现符号反转的方式 - 通过使用预定义常量进行xoring，其中符号位位置为1，其他位置为0。考虑到上述情况，经过一些清理后，我得到以下代码：

double mystery(double a1)
{
  double v1; // xmm1@1
  double v2; // xmm1@4
  double v3; // xmm2@4
  double v4; // xmm5@7
  double v5; // xmm1@7

  v1 = LCPI1_0 - a1;
  if ( v1 < 0.0 )
    v1 = -v1;
  if ( v1 < LCPI1_2 )
  {
    v4 = LCPI1_0;
  }
  else
  {
    v2 = LCPI1_0;
    v3 = LCPI1_3;
    while ( 1 )
    {
      v4 = a1;
      v4 = (v4 / v2 + v2) * v3;
      v5 = v4;
      v5 = v5 * v5 - a1;
      if ( v5 < 0.0 )
        v5 = -v5;
      if ( v5 < LCPI1_2 )
        break;
      v2 = a1;
    }
  }
  return v4;
}

它产生的装配非常类似于原始帖子。

Answer 2

逆向工程/反编译任何代码都需要时间与这样做的好处相关;不是有多难。

如果你有一些秘密的酱汁，你绝对不能让它出去，那么你唯一可以做的就是把这个秘密的酱汁作为一种网络服务，必要时可以调用它。这样二进制文件就永远不会离开你的公司墙。

只要黑客在他们控制的系统上具有已编译的二进制文件，任何事情都可以被追踪，即使是模糊处理也是如此。哎呀，最初的PC克隆是通过逆向工程IBM BIOS创建的。

所以，回到这一点：再说一遍，这不是一个多么艰难的问题，更多的是一个人是否想要尝试的问题......这是基于他们从中得到的感知价值。无论是直接美元（接收还是储蓄），竞争优势还是仅仅是吹牛的权利。更复杂的是应用程序的可用性：更广泛的分发等于更高的潜力，以找到它的方式进入黑客的工作。

如果这些价值存在，那么你可以放心，有人会尝试，他们会成功。哪个应引导您进入下一个问题：如果他们这样做了怎么办？什么是最糟糕的结果？

在某些情况下，它只是一个丢失的销售，你可能还没有得到。在其他情况下，这可能是业务的损失。

Answer 3

从根本上说，执行单独的机器指令“逆向工程”非常简单，因为机器指令具有非常明确的语义。这会给你不好的C代码，但肯定不是目标。（知道文件中的某些二进制模式是机器指令在技术上是图灵硬的，例如，在某些情况下是不可能的;在编译器生成的代码的情况下不太可能如此）。

除此之外，您正在尝试推断算法和意图。那太难了;包含所有这些的知识来自何处？

您可能会发现我的 paper on reverse engineering很有趣。它提出了一种编码必要知识的方法。

在某种程度上也有commercial tools to do this。这并不像我的论文所概述的那样，但仍然产生非常合理的C代码，正如我所理解的那样。（我对此工具没有具体经验，但对作者和他的工具非常尊重）。

反编译汇编代码有多难（真的）？

3 个答案: