任何人都可以定义 Windows PE 校验和算法吗？

Question

我想在 C# 中实现这个，

我在这里查看： http://www.codeproject.com/KB/cpp/PEChecksum.aspx

并且我知道ImageHlp.dll MapFileAndCheckSum 函数。

然而，由于种种原因，我想自己实现这一点。

我发现的最好的就在这里： 但是

​，我不明白这个解释。谁能解释一下校验和是如何计算的？

谢谢！

更新

从代码示例中，我不明白这意味着什么，以及如何将其翻译成 C#

sum -= sum < low 16 bits of CheckSum in file // 16-bit borrow 
sum -= low 16 bits of CheckSum in file 
sum -= sum < high 16 bits of CheckSum in file 
sum -= high 16 bits of CheckSum in file 

更新#2

谢谢，也遇到了一些类似的 Python 代码此处

    def generate_checksum(self):

    # This will make sure that the data representing the PE image
    # is updated with any changes that might have been made by
    # assigning values to header fields as those are not automatically
    # updated upon assignment.
    #
    self.__data__ = self.write()

    # Get the offset to the CheckSum field in the OptionalHeader
    #
    checksum_offset = self.OPTIONAL_HEADER.__file_offset__ + 0x40 # 64

    checksum = 0

    # Verify the data is dword-aligned. Add padding if needed
    #
    remainder = len(self.__data__) % 4
    data = self.__data__ + ( '\0' * ((4-remainder) * ( remainder != 0 )) )

    for i in range( len( data ) / 4 ):

        # Skip the checksum field
        #
        if i == checksum_offset / 4:
            continue

        dword = struct.unpack('I', data[ i*4 : i*4+4 ])[0]
        checksum = (checksum & 0xffffffff) + dword + (checksum>>32)
        if checksum > 2**32:
            checksum = (checksum & 0xffffffff) + (checksum >> 32)

    checksum = (checksum & 0xffff) + (checksum >> 16)
    checksum = (checksum) + (checksum >> 16)
    checksum = checksum & 0xffff

    # The length is the one of the original data, not the padded one
    #
    return checksum + len(self.__data__)

但是，它仍然对我不起作用 - 这是我对此代码的转换：

using System;
using System.IO;

namespace CheckSumTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var data = File.ReadAllBytes(@"c:\Windows\notepad.exe");

            var PEStart = BitConverter.ToInt32(data, 0x3c);
            var PECoffStart = PEStart + 4;
            var PEOptionalStart = PECoffStart + 20;
            var PECheckSum = PEOptionalStart + 64;
            var checkSumInFile = BitConverter.ToInt32(data, PECheckSum);
            Console.WriteLine(string.Format("{0:x}", checkSumInFile));

            long checksum = 0;

            var remainder = data.Length % 4;
            if (remainder > 0)
            {
                Array.Resize(ref data, data.Length + (4 - remainder));
            }

            var top = Math.Pow(2, 32);

            for (int i = 0; i < data.Length / 4; i++)
            {
                if (i == PECheckSum / 4)
                {
                    continue;
                }
                var dword = BitConverter.ToInt32(data, i * 4);
                checksum = (checksum & 0xffffffff) + dword + (checksum >> 32);
                if (checksum > top)
                {
                    checksum = (checksum & 0xffffffff) + (checksum >> 32);
                }
            }

            checksum = (checksum & 0xffff) + (checksum >> 16);
            checksum = (checksum) + (checksum >> 16);
            checksum = checksum & 0xffff;

            checksum += (uint)data.Length; 
            Console.WriteLine(string.Format("{0:x}", checksum));

            Console.ReadKey();
        }
    }
}

谁能告诉我我在哪里？我很蠢吗？

Answer 1

好吧，终于让它工作正常了...我的问题是我使用的是整数而不是单位！
所以，这段代码可以工作（假设数据是 4 字节对齐的，否则你必须稍微填充它） - 并且 PECheckSum 是 PE 中 CheckSum 值的位置（在计算校验和时显然不使用它！ !!!)

请注意，以下是 C# 代码。

static uint CalcCheckSum(byte[] data, int PECheckSum)
{
    long checksum = 0;
    var top = Math.Pow(2, 32);

    for (var i = 0; i < data.Length / 4; i++)
    {
        if (i == PECheckSum / 4)
        {
            continue;
        }
        var dword = BitConverter.ToUInt32(data, i * 4);
        checksum = (checksum & 0xffffffff) + dword + (checksum >> 32);
        if (checksum > top)
        {
            checksum = (checksum & 0xffffffff) + (checksum >> 32);
        }
    }

    checksum = (checksum & 0xffff) + (checksum >> 16);
    checksum = (checksum) + (checksum >> 16);
    checksum = checksum & 0xffff;

    checksum += (uint)data.Length;
    return (uint)checksum;

}

Answer 2

论坛帖子中的代码与实际反汇编Windows PE代码时注意到的并不严格相同。 您引用的 CodeProject 文章给出了“将 32 位值折叠为 16 位” as：

mov edx,eax    ; EDX = EAX
shr edx,10h    ; EDX = EDX >> 16    EDX is high order
and eax,0FFFFh ; EAX = EAX & 0xFFFF EAX is low order
add eax,edx    ; EAX = EAX + EDX    High Order Folded into Low Order
mov edx,eax    ; EDX = EAX
shr edx,10h    ; EDX = EDX >> 16    EDX is high order
add eax,edx    ; EAX = EAX + EDX    High Order Folded into Low Order
and eax,0FFFFh ; EAX = EAX & 0xFFFF EAX is low order 16 bits  

你可以将其翻译成 C#：

// given: uint sum = ...;
uint high = sum >> 16; // take high order from sum
sum &= 0xFFFF;         // clear out high order from sum
sum += high;           // fold high order into low order

high = sum >> 16;      // take the new high order of sum
sum += high;           // fold the new high order into sum
sum &= 0xFFFF;         // mask to 16 bits

Answer 3

没有人真正回答最初的问题“任何人都可以定义 Windows PE 校验和算法吗？”所以我将尽可能简单地定义它。到目前为止给出的许多示例都是针对无符号 32 位整数（也称为 DWORD）进行优化，但如果您只想从最基本的角度了解算法本身，那么就是这样：

1. 使用无符号 16 位整数整数（也称为 WORD）来存储校验和，将除 PE 可选标头校验和的 4 个字节之外的所有数据 WORD 相加。如果文件不是字对齐的，那么最后一个字节是 0x00。

2. 将校验和从 WORD 转换为 DWORD 并添加文件的大小。

上述 PE 校验和算法实际上与原始 MS-DOS 校验和算法相同。唯一的区别是跳过的位置并替换末尾的 XOR 0xFFFF 并添加文件的大小。

从我的 PHP 的 WinPEFile 类，上面的算法看起来像：

    $x = 0;
    $y = strlen($data);
    $val = 0;
    while ($x < $y)
    {
        // Skip the checksum field location.
        if ($x === $this->pe_opt_header["checksum_pos"])  $x += 4;
        else
        {
            $val += self::GetUInt16($data, $x, $y);

            // In PHP, integers are either signed 32-bit or 64-bit integers.
            if ($val > 0xFFFF)  $val = ($val & 0xFFFF) + 1;
        }
    }

    // Add the file size.
    $val += $y;

Answer 4

以下来自 emmanuel 的 Java 代码可能无法工作。就我而言，它挂起并且未完成。我相信这是由于代码中大量使用 IO：特别是 data.read()。这可以与数组交换作为解决方案。 RandomAccessFile 完全或增量地将文件读取到字节数组中。

我尝试了此操作，但由于校验和偏移的条件是跳过校验和标头字节，因此计算速度太慢。我想OP的C#解决方案也会有类似的问题。

下面的代码也删除了这个。

public static long computeChecksum(RandomAccessFile data, int checksumOffset)
                throws IOException {
        
        ...
        byte[] barray = new byte[(int) length];     
        data.readFully(barray);
        
        long i = 0;
        long ch1, ch2, ch3, ch4, dword;
        
        while (i < checksumOffset) {
            
            ch1 = ((int) barray[(int) i++]) & 0xff;
            ...
            
            checksum += dword = ch1 | (ch2 << 8) | (ch3 << 16) | (ch4 << 24);

            if (checksum > top) {
                checksum = (checksum & 0xffffffffL) + (checksum >> 32);
            }
        }
        i += 4;
        
        while (i < length) {
            
            ch1 = ((int) barray[(int) i++]) & 0xff;
            ...
    
            checksum += dword = ch1 | (ch2 << 8) | (ch3 << 16) | (ch4 << 24);
            
            if (checksum > top) {
                checksum = (checksum & 0xffffffffL) + (checksum >> 32);
            }
        }
        
        checksum = (checksum & 0xffff) + (checksum >> 16);
        checksum = checksum + (checksum >> 16);
        checksum = checksum & 0xffff;
        checksum += length;
        
        return checksum;
    }

然而，我仍然认为代码过于冗长和笨重，因此我用通道替换了 raf，并将罪魁祸首字节重写为零以消除条件。这段代码可能仍然可以使用缓存样式缓冲读取。

public static long computeChecksum2(FileChannel ch, int checksumOffset)
            throws IOException {
    
    ch.position(0);
    long sum = 0;
    long top = (long) Math.pow(2, 32);
    long length = ch.size();
    
    ByteBuffer buffer = ByteBuffer.wrap(new byte[(int) length]);
    buffer.order(ByteOrder.LITTLE_ENDIAN);
    
    ch.read(buffer);
    buffer.putInt(checksumOffset, 0x0000);
    
    buffer.position(0);
    while (buffer.hasRemaining()) {
        sum += buffer.getInt() & 0xffffffffL;
        if (sum > top) {
            sum = (sum & 0xffffffffL) + (sum >> 32);
        }
    }   
    sum = (sum & 0xffff) + (sum >> 16);
    sum = sum + (sum >> 16);
    sum = sum & 0xffff;
    sum += length;
    
    return sum;
}

Answer 5

CheckSum 字段长度为 32 位，计算方式如下

1. 将整个文件的所有 dword（32 位片段）添加到总和中

将整个文件的所有 dword 添加不包括 CheckSum 字段本身，包括所有标题和所有内容，为一个双字。如果双字溢出，则将溢出的位添加回双字的第一位 (2^0)。
如果文件不能完全分为双字（4 位块），请参阅 2。

我知道实现这一点的最佳方法是使用 GNU C 编译器整数溢出内置函数 __builtin_uadd_overflow。
在 Jeffrey 记录的原始 ChkSum 函数 中沃尔顿总和
通过执行 add (%esi),%eax 计算得出，其中
esi 包含文件的基址，eax 为 0，并像这样添加文件的其余部分

adc 0x4(%esi),%eax
adc 0x8(%esi),%eax
adc 0xc(%esi),%eax
adc 0x10(%esi),%eax
...
adc $0x0,%eax

第一个 add 添加第一个 dword 忽略任何进位标志。下一个双字
由 adc 指令添加，该指令的作用与 add 相同，但是
添加在执行指令之前设置的任何进位标志
到被加数。最后一个 adc $0x0,%eax 仅添加最后一个进位标志，如果
已设置且无法丢弃。

请记住，不应添加 CheckSum 字段本身的双字。

2. 如果有一个，则将余数添加到总和中

如果文件不能完全整除为双字，则将余数添加为
零填充双字。例如：假设您的文件有 15 个字节长，如下所示
<代码> 0E 1F BA 0E | 00 B4 09 CD | 21 B8 01 4C | CD 21 54
您需要将余数作为 0x005421CD 添加到总和中。我的系统是
小端系统。我不知道校验和是否会因为
而改变
大端系统上的字节顺序，或者您只需模拟这个
行为。
我通过将 buffer_size 四舍五入到可被 4 整除的下一个字节数来实现此目的
没有余数或换句话说：表示下一个完整的双字计数
以字节为单位。然后我使用 calloc 进行分配，因为它会初始化内存块
全为零。

if(buffer_size%4) {
  buffer_size+=4-(buffer_size%4);
...
calloc(buffer_size,1)

3. 将总和的低位字（16 位片）和高位字相加。

sum=(sum&0xffff)+(sum>>16);

4. 再次添加新的较高位单词

sum+=(sum>>16);

5只保留低位字

sum&=0xffff;

6. 将文件中的字节数与 sum 相加

return(sum+size);

就是这样我写的。它不是C#，而是C。off_t size是文件中的字节数。 uint32_t *base 是指向加载到内存中的文件的指针。内存块应该在下一个可被 4 整除的字节数末尾用零填充。

uint32_t pe_header_checksum(uint32_t *base,off_t size) {
  uint32_t sum=0;
  off_t i;
  for(i=0;i<(size/4);i++) {
    if(i==0x36) continue;
    sum+=__builtin_uadd_overflow(base[i],sum,&sum);
  }
  if(size%4) sum+=base[i];
  sum=(sum&0xffff)+(sum>>16);
  sum+=(sum>>16);
  sum&=0xffff;
  return(sum+size);
}

如果您愿意，您可以查看正在运行的代码并阅读更多内容 此处。

Answer 6

Java 示例并不完全正确。以下 Java 实现与 Microsoft 来自 Imagehlp.MapFileAndCheckSumA 的原始实现的结果相对应。

重要的是输入字节被 inputByte & 屏蔽。 0xff 以及生成的 long 在与 currentWord & 的加法项中使用时再次被屏蔽。 0xffffffffL（考虑L）：

    long checksum = 0;
    final long max = 4294967296L; // 2^32

    // verify the data is DWORD-aligned and add padding if needed
    final int remainder = data.length % 4;
    final byte[] paddedData = Arrays.copyOf(data, data.length
            + (remainder > 0 ? 4 - remainder : 0));

    for (int i = 0; i <= paddedData.length - 4; i += 4)
    {
        // skip the checksum field
        if (i == this.offsetToOriginalCheckSum)
            continue;

        // take DWORD into account for computation
        final long currentWord = (paddedData[i] & 0xff)
                               + ((paddedData[i + 1] & 0xff) << 8)
                               + ((paddedData[i + 2] & 0xff) << 16)
                               + ((paddedData[i + 3] & 0xff) << 24);

        checksum = (checksum & 0xffffffffL) + (currentWord & 0xffffffffL);

        if (checksum > max)
            checksum = (checksum & 0xffffffffL) + (checksum >> 32);
    }

    checksum = (checksum & 0xffff) + (checksum >> 16);
    checksum = checksum + (checksum >> 16);
    checksum = checksum & 0xffff;
    checksum += data.length; // must be original data length

在这种情况下，Java有点不方便。

Answer 7

我试图用Java解决同样的问题。以下是将 Mark 的解决方案翻译成 Java，使用 RandomAccessFile 而不是字节数组作为输入：

static long computeChecksum(RandomAccessFile data, long checksumOffset) throws IOException {
    long checksum = 0;
    long top = (long) Math.pow(2, 32);
    long length = data.length();

    for (long i = 0; i < length / 4; i++) {
        if (i == checksumOffset / 4) {
            data.skipBytes(4);
            continue;
        }

        long ch1 = data.read();
        long ch2 = data.read();
        long ch3 = data.read();
        long ch4 = data.read();

        long dword = ch1 + (ch2 << 8) + (ch3 << 16) + (ch4 << 24);

        checksum = (checksum & 0xffffffffL) + dword + (checksum >> 32);

        if (checksum > top) {
            checksum = (checksum & 0xffffffffL) + (checksum >> 32);
        }
    }

    checksum = (checksum & 0xffff) + (checksum >> 16);
    checksum = checksum + (checksum >> 16);
    checksum = checksum & 0xffff;
    checksum += length;

    return checksum;
}

Answer 8

private unsafe static int GetSetPEChecksum(byte[] Array) {
    var Value = 0;
    var Count = Array.Length;
    if(Count >= 64)
        fixed (byte* array = Array) {
            var Index = 0;
            var Coff = *(int*)(array + 60);
            if(Coff >= 64 && Count >= Coff + 92) {
                *(int*)(array + Coff + 88) = 0;
                var Bound = Count >> 1;
                if((Count & 1) != 0) Value = array[Count & ~1];
                var Short = (ushort*)array;
                while(Index < Bound) {
                    Value += Short[Index++];
                    Value = (Value & 0xffff) + (Value >> 16);
                    Value = (Value + (Value >> 16)) & 0xffff;
                }
                *(int*)(array + Coff + 88) = Value += Count;
            }
        }
    return Value;
}

如果您需要短的不安全...（不需要使用 Double 和 Long 整数，也不需要算法内部的数组对齐）

Answer 9

我想通过 PE 校验和“揭开”整个故事的神秘面纱来澄清这一情况。
校验和算法如下：

• 加载 PE 映像文件
• 确定 CheckSum 结构成员的绝对偏移量（uint32_t，PE/32 位和 PE/64 位不同）
• Set sum := 0
• 添加映像中除uint32_t 包含 CheckSum 本身到 'sum' WITH CARRY
• 最后将 32bit 宽的 PE 图像大小添加到 sum，输出 CheckSum

有没有任何“折叠”。这是考虑到任何溢出的简单有限加法。就 x86 CPU 指令而言，这是“adc”（带进位的加法）助记符，而不是“add”助记符。

在普通 C 中，没有任何编译器内在函数，这是：

#include <stdint.h>
#include <byteswap.h>

#ifdef _BIG_ENDIAN_MACHINE
#define csum_bswap_16(_x) bswap_16(_x)
#else // Little Endian
#define csum_bswap_16(_x) (_x)
#endif

// IMPORTANT NOTE: DO provide one extra zero byte after the image if its
// --------------- size is ODD!!!
uint32_t compute_pe_checksum_16bit ( const uint8_t *image_data, uint32_t image_size, uint32_t csum_ofs )
{
  uint32_t          i;
  register uint16_t csum = 0, carry_check;

  for (i = 0; i < csum_ofs; i += sizeof(uint16_t) )
  {
    carry_check = csum;
    csum += csum_bswap_16( *((uint16_t*)(image_data + i)) );
    csum += (csum < carry_check) ? 1 : 0;
  }

  for (i = csum_ofs + sizeof(uint32_t); i < image_size; i += sizeof(uint16_t))
  {
    carry_check = csum;
    csum += csum_bswap_16( *((uint16_t*)(image_data + i)) );
    csum += (csum < carry_check) ? 1 : 0;
  }

  return ((uint32_t)csum) + image_size;
}

我将整个循环分成两部分（在 CheckSum 结构元素之前和之后，必须排除该元素）以使 CPU 的分支预测单元满意（否则，它会检查每次循环迭代中的 CheckSum 偏移量）。

面临溢出（即CPU进位为1）仅意味着：“如果计算x+y并且结果小于之前的总和（此处：carry_check），则进位为1”。

证明此实现正确的证据很简单：使用 Windows 安装中的“user32.dll”并计算校验和（这就是我为测试所做的）。

一些附加说明：

• 在 Big Endian 机器上，您必须对要添加的 uint16_t 值进行字节交换；
• 如果您修改此函数以使用 uint32_t 而不是 uint16_t（如上面的一些答案/评论所述），那么这会产生完全不同的校验和；
• 这种非常古老的（MS-DOS 风格）算法至今仍在使用：UEFI BIOS 加载 EFI 二进制文件，它们是 PE/COFF 可执行文件。可能存在验证校验和的 UEFI 实现；
• 如果您正在寻找优化的实现，并且您的系统配备了 SIMD（单指令多数据）单元（现在几乎所有 CPU 都配备了该单元），那么您可以完全并行地添加 8 个 16 位值（假设 128 位 SIMD 寄存器）并带有进位，有时称为“水平添加”。