Python修改exe之类的游戏文件中的数值

场景

1. 某些游戏数值（攻击力、射程、速度…）被写在exe之类的文件里
   要先查找游戏数值，然后修改
2. 修改存档

查找

比较2个文件差异

只改1个游戏数值，存档2次，比较2个文件

F1 = '存档1'
F2 = '存档2'

def compare(d1=F1, d2=F2):
    with open(d1, 'rb') as f1:
        b1 = f1.read()
    with open(d2, 'rb') as f2:
        b2 = f2.read()
    for i in range(min(len(b1), len(b2))):
        if b1[i] != b2[i]:
            print(i, b1[i], b2[i])

查找大数字

某些数值无法在游戏里修改，可直接找，大数重复较少，建议先找大数

F = '游戏文件路径'

def find_your_sister_en(a: bytes, extension=20, f_name=F):
    """查找字符串"""
    length = len(a)
    with open(f_name, 'rb') as f:
        b = f.read()
    for i in range(len(b) - length + 1):
        if b[i: i + length] == a:
            print(i, b[i - extension: i + length + extension])

def find_your_sister_cn(a: str, extension=0, f_name=F, e='gbk'):
    """查找中文（注意extension>0时容易报错）"""
    a = a.encode(e)
    length = len(a)
    with open(f_name, 'rb') as f:
        b = f.read()
    for i in range(len(b) - length + 1):
        if b[i: i + length] == a:
            print(i, b[i - extension * 2: i + length + extension * 2].decode('gbk'))

def find_your_sister01(a: int):
    """查找0~255的数"""
    with open(F, 'rb') as f:
        b = f.read()  # <class 'bytes'>
    for i in range(len(b)):
        if b[i] == a:
            if b[i + 1] == b[i + 2] == b[i + 3] == 0:
                print(i)

def find_your_sister02(a: int):
    """查找0~65535的数"""
    ab = a.to_bytes(2, byteorder='little')
    print(a, '转字节数组', ab)
    with open(F, 'rb') as f:
        b = f.read()
    for i in range(len(b) - 1):
        if b[i: i + 2] == ab:
            if b[i + 2] == b[i + 3] == 0:
                print(i)

def find_context(offset: int, section=4):
    """根据offset查找上下文"""
    with open(F, 'rb') as f:
        b = f.read()  # <class 'bytes'>
    for i in range(offset - section, offset + section):
        print(i, b[i])

def find_number(ls: list):
    """查找连续数字"""
    with open(F, 'rb') as f:
        b = f.read()  # <class 'bytes'>
    length = len(ls)
    for i in range(len(b) - length + 1):
        if [b[i + j] for j in range(length)] == ls:
            print(i, ls, [b[i + j + length] for j in range(length)], i + length)

def find_section(offset: int, section=100, m=500):
    """查找指定offset区间内0~500的数"""
    with open(F, 'rb') as f:
        b = f.read()  # <class 'bytes'>
    for i in range(offset - section, offset + section):
        if b[i + 2] == b[i + 3] == 0:
            if b[i] + b[i + 1] * 256 < m:
                print(i, b[i], b[i + 1], b[i] + b[i + 1] * 256)

if __name__ == '__main__':
    find_your_sister_en(b'fighter', 33)
    # find_your_sister_cn('美洲狮', 5)
    # find_your_sister01(200)
    # find_your_sister02(1000)
    # find_context(439609)
    # find_number([38, 0, 0, 184])
    # find_section(439609)

修改

F1 = '游戏原件.exe'
F2 = '魔改文件.exe'

def cp():
    with open(F1, 'rb') as f:
        b = f.read()
    with open(F2, 'wb') as f:
        f.write(b)

def replace_en(offset: int, new_data: str, old_data: str = None):
    """修改字符串"""
    if old_data is None:
        length = len(new_data)
    else:
        length = len(old_data)
        print(length, len(new_data))
    with open(F2, 'rb') as f:
        b = f.read()
    with open(F2, 'wb') as f:
        f.write(b[:offset])
        for i in new_data:
            f.write(ord(i).to_bytes(1, byteorder='little'))
        f.write(b[offset + length:])
    print(offset, '偏移量的位置', b[offset], '修改为', new_data)

def replace1(offset: int, new_data: int):
    """修改1个byte"""
    with open(F2, 'rb') as f:
        b = f.read()
    with open(F2, 'wb') as f:
        f.write(b[:offset])
        f.write(new_data.to_bytes(1, byteorder='little'))
        f.write(b[offset + 1:])
    print(offset, '偏移量的位置', b[offset], '修改为', new_data)

def replace2(offset: int, new_data: int):
    """修改2个bytes"""
    nb = new_data.to_bytes(2, byteorder='little')  # 例如：256 --> b'\x00\x01'
    with open(F2, 'rb') as f:
        b = f.read()
    with open(F2, 'wb') as f:
        f.write(b[:offset])
        f.write(nb)
        f.write(b[offset + 2:])
    print(offset, '和', offset + 1, '偏移量的位置', b[offset: offset + 2], '修改为', nb)

def replace_cn(offset: int, length: int, new_data: str):
    """修改文案"""
    new_data = new_data.encode('gbk')
    print(new_data, len(new_data))
    with open(F2, 'rb') as f:
        b = f.read()
    extension = length - len(new_data)
    with open(F2, 'wb') as f:
        f.write(b[:offset])
        f.write(new_data)
        for _ in range(extension):
            f.write(ord(' ').to_bytes(1, byteorder='little'))
        f.write(b[offset + length:])

if __name__ == '__main__':
    cp()
    replace_en(659824, 'abcd.edf')
    replace1(439609, 5)  # 阿基里斯 180
    replace2(44811, 300)  # 美洲狮210
    replace_cn(676444, 160, '天空母舰')

补充

字节

字节（Byte）是计算机信息技术用于计量存储容量的一种计量单位，储存的数值范围为0~255

WinHex是一款十六进制编辑器，编辑界面如下

def translate(*args):
    """计算相邻数字的值（其中int(a, 16)可将字符串转10进制数字）"""
    print(sum(int(a, 16) * (256 ** e) for e, a in enumerate(args)))

# 假设在WinHex中看到 E8 03 00 00，那么该值可能是1000
translate('E8', '03')

to_bytes

函数说明

Return an array of bytes representing an integer.

  length
    Length of bytes object to use.  An OverflowError is raised if the
    integer is not representable with the given number of bytes.
  byteorder
    The byte order used to represent the integer.  If byteorder is 'big',
    the most significant byte is at the beginning of the byte array.  If
    byteorder is 'little', the most significant byte is at the end of the
    byte array.  To request the native byte order of the host system, use
    `sys.byteorder' as the byte order value.
  signed
    Determines whether two's complement is used to represent the integer.
    If signed is False and a negative integer is given, an OverflowError
    is raised.

函数示例（256–>100–>0100–>01,00–>00,01）

>>> a = 256

>>> hex(a)
'0x100'

>>> a.to_bytes(2, byteorder='little')
b'\x00\x01'