Python在二进制文件中进行数据搜索的实战指南

模式	含义	说明
r	读取（文本模式）	默认打开文件为文本模式
rb	读取（二进制模式）	原始字节流读取，不进行编码转换
w	写入（文本模式）	覆盖写入文本
wb	写入（二进制模式）	覆盖写入原始字节
a	追加（文本模式）	在文件末尾追加文本
ab	追加（二进制模式）	在文件末尾追加字节
+	读写模式	与 r / w / a 结合使用
b	二进制标志	与其他模式结合使用

例如：

# 文本模式
with open("example.txt", "r") as f:
    content = f.read()

# 二进制模式
with open("example.bin", "rb") as f:
    content = f.read()

在文本模式下，读取的内容会被解码为 str 类型；而在二进制模式下，内容是原始的 bytes 类型。

文本模式 会自动进行字符编码转换。例如，当使用 "r" 模式打开一个UTF-8编码的文件时，Python会将读取的字节按照UTF-8解码为字符串。
二进制模式 不进行任何编码转换，直接读取或写入原始字节。这在处理非文本文件（如图片、音频、可执行文件）时尤为重要。

举例说明：

假设有一个文本文件 utf8.txt ，内容为：

你好，世界

使用文本模式读取：

with open("utf8.txt", "r", encoding="utf-8") as f:
    text = f.read()
print(type(text))  # <class 'str'>

使用二进制模式读取：

with open("utf8.txt", "rb") as f:
    data = f.read()
print(type(data))  # <class 'bytes'>

此时 data 变量是原始字节序列，如： b'xe4xbdxa0xe5xa5xbdxefxbcx8cxe4xb8x96xe7x95x8c' 。

使用 `rb` 模式读取文件是处理二进制数据的首选方式。它允许我们访问文件的原始字节内容，而不受编码和换行符转换的影响。

open() 函数的完整语法如下：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

在二进制模式下，以下参数具有特殊意义：

mode='rb' ：表示以二进制只读方式打开文件。
encoding ：在二进制模式下被忽略。
errors ：无效，因为不会尝试解码。
newline ：在二进制模式下不进行换行符转换（如 rn 不转为 n ）。

示例：读取任意文件并输出其前16个字节

with open("example.bin", "rb") as f:
    header = f.read(16)
print(header)

输出示例（假设文件是PNG图像）：

b'x89PNGrnx1anx00x00x00rIHDRx00'

这段数据就是PNG文件的文件头，用于标识文件类型。

当处理非常大的二进制文件（如视频、磁盘镜像、大型数据库文件）时，一次性读取整个文件会占用大量内存，甚至导致程序崩溃。因此，推荐使用 分块读取 策略。

分块读取的实现：

CHUNK_SIZE = 1024 * 1024  # 每次读取1MB

with open("large_file.bin", "rb") as f:
    while True:
        chunk = f.read(CHUNK_SIZE)
        if not chunk:
            break
        # 处理当前块
        process(chunk)

流程图说明：

graph TD
A[打开文件 rb 模式] –> B[读取第一个块]
B –> C{是否读取到数据?}
C –>|是| D[处理当前块]
D –> E[继续读取下一块]
E –> C
C –>|否| F[关闭文件，处理完成]

Python提供了两种用于处理字节序列的类型： `bytes` 和 `bytearray` 。它们是处理二进制数据的核心类型。

bytes 是不可变的字节序列，而 str 是 Unicode 字符串。两者之间的转换必须通过编码（encode）和解码（decode）操作。

示例：

# 字符串转 bytes
s = "Hello, world!"
b = s.encode("utf-8")
print(b)  # b'Hello, world!'

# bytes 转字符串
b = b"Hello, world!"
s = b.decode("utf-8")
print(s)  # Hello, world!

注意：编码和解码时使用的字符集必须一致，否则可能导致乱码或报错。

表格：常见编码方式

编码	说明
utf-8	可变长度编码，兼容ASCII，广泛用于网络传输
ascii	仅支持英文字符（0-127）
latin1	又称ISO-8859-1，覆盖西欧字符
utf-16	固定长度编码，占用更多空间
gb2312/gbk	中文编码标准

bytearray 是可变版本的 bytes 对象，允许我们修改其中的内容。

示例：

b = bytearray(b"Hello")
b[0] = ord('h')  # 修改第一个字符为小写
print(b)  # bytearray(b'hello')

适用场景：

修改文件头信息（如PE、ELF文件）；
网络协议中构建/解析数据包；
图像处理（如修改像素数据）；
缓冲区操作（如网络通信缓冲）。

处理二进制数据时，常见的操作包括拼接、切片、编码解码等。

bytes 和 bytearray 支持使用 + 运算符进行拼接，也支持切片操作。

示例：

a = b"Hello"
b = b" World"
c = a + b
print(c)  # b'Hello World'

# 切片操作
print(c[6:])  # b'World'

多个字节对象拼接：

parts = [b"part1", b"part2", b"part3"]
result = b"".join(parts)
print(result)  # b'part1part2part3'

注意： bytes 是不可变类型，频繁拼接会产生大量中间对象。若需要频繁修改，建议使用 bytearray 。

虽然 bytes 本身不涉及编码，但在实际应用中，我们经常需要将字节数据解释为某种编码的字符串。

示例：读取一段字节并尝试解码

data = b"xe4xbdxa0xe5xa5xbd"  # UTF-8编码的“你好”
try:
    s = data.decode("utf-8")
    print(s)  # 你好
except UnicodeDecodeError:
    print("解码失败")

自动识别编码的技巧：

可以使用第三方库如 chardet 来自动检测字节流的编码：

pip install chardet

import chardet

data = open("unknown_encoding.txt", "rb").read()
result = chardet.detect(data)
encoding = result["encoding"]
confidence = result["confidence"]

print(f"检测编码为：{encoding}，置信度：{confidence:.2f}")

本章从Python中二进制文件读取的基本原理出发，详细讲解了二进制模式与文本模式的区别、如何使用 rb 模式高效读取文件、 bytes 和 bytearray 类型的特点及使用场景，以及对二进制数据进行拼接、切片和编码解码的基本操作方法。这些内容为后续章节中实现二进制搜索功能奠定了坚实的基础。

在处理二进制文件时，搜索特定的字符串或十六进制值是一项常见但极具挑战性的任务。由于二进制文件不依赖于可读性强的文本结构，而是以字节流形式存储数据，因此必须结合编码知识、字节操作技巧和搜索算法来实现高效的查找。本章将从字符串的二进制表示、十六进制值的匹配、编码兼容性处理以及结果展示四个方面，深入探讨如何在Python中实现对二进制文件中字符串与十六进制模式的搜索与提取。

字符串在计算机中是以字节形式存储的，而不同的字符编码方式决定了字符串如何被转换为字节。最基础的编码方式是ASCII（American Standard Code for Information Interchange），它使用7位二进制数表示英文字符，每个字符占用1个字节（8位）。随着多语言支持的发展，UTF-8成为广泛使用的编码方式，它是一种可变长度编码，英文字符仍使用1个字节，而中文等字符则可能占用2到4个字节。

编码方式特点示例（”Hello”）

ASCII 单字节，仅支持英文字符 48 65 6C 6C 6F

UTF-8 可变长度，兼容ASCII，支持多语言 48 65 6C 6C 6F

UTF-16 双字节或四字节，适合中文 0048 0065 006C 006C 006F

GBK 中文专用编码，双字节 B2 E2 C4 E3 （“你好”）

在二进制文件中查找字符串时，必须清楚目标字符串所使用的编码方式，否则会出现乱码或匹配失败的问题。

编码方式	特点	示例（”Hello”）
ASCII	单字节，仅支持英文字符	48 65 6C 6C 6F
UTF-8	可变长度，兼容ASCII，支持多语言	48 65 6C 6C 6F
UTF-16	双字节或四字节，适合中文	0048 0065 006C 006C 006F
GBK	中文专用编码，双字节	B2 E2 C4 E3 （“你好”）

查找ASCII字符串相对简单，因为每个字符都对应一个固定的单字节表示。例如，字符串 “hello” 在ASCII编码下对应的字节序列是b'x68x65x6Cx6Cx6F' 。

以下是一个Python示例，演示如何在二进制文件中搜索ASCII字符串：

def search_ascii_string_in_binary(file_path, target_str):
    target_bytes = target_str.encode('ascii')  # 将字符串转换为ASCII字节
    with open(file_path, 'rb') as f:
        data = f.read()
        offset = data.find(target_bytes)
        if offset != -1:
            print(f"Found '{target_str}' at offset: 0x{offset:X}")
        else:
            print(f"'{target_str}' not found in the file.")

代码逐行解析：

target_str.encode('ascii') ：将目标字符串转换为ASCII编码的字节串。
open(file_path, 'rb') ：以二进制模式读取文件。
data.find(target_bytes) ：在读取的二进制数据中查找目标字节序列的位置。
0x{offset:X} ：将偏移量以十六进制形式输出。

该方法适用于已知字符串编码为ASCII的情况。如果目标字符串包含非ASCII字符（如中文），则需要使用对应的编码方式进行转换。

在实际的二进制搜索中，有时需要直接查找特定的十六进制字节序列，例如在逆向分析中查找特定的机器指令或数据结构。这种情况下，通常会使用十六进制字符串（hex字符串）来表示目标字节，例如 '48656C6C6F' 对应字符串 “Hello”。

Python中可以使用 binascii 模块进行 hex 字符串与 bytes 的转换：

import binascii

hex_str = '48656C6C6F'  # Hex representation of 'Hello'
byte_data = binascii.unhexlify(hex_str)  # Convert to bytes
print(byte_data)  # Output: b'Hello'

逻辑分析：

binascii.unhexlify() ：将格式为 '00AAFF' 的十六进制字符串转换为对应的字节对象。
此方法适用于查找特定字节序列（如 E9 00 00 00 00 对应 jmp 指令）。

查找多字节十六进制模式时，可以使用类似ASCII字符串的查找方式。例如，在ELF或PE文件中查找特定的机器码指令，可以将目标模式转换为 bytes 后进行匹配。

def search_hex_pattern(file_path, hex_pattern):
    pattern_bytes = binascii.unhexlify(hex_pattern)
    with open(file_path, 'rb') as f:
        data = f.read()
        offset = data.find(pattern_bytes)
        if offset != -1:
            print(f"Found pattern '{hex_pattern}' at offset: 0x{offset:X}")
        else:
            print(f"Pattern '{hex_pattern}' not found.")

流程图：

graph TD
A[Start] –> B[Read hex pattern]
B –> C[Convert to bytes using unhexlify]
C –> D[Open binary file in rb mode]
D –> E[Read entire file into bytes]
E –> F[Use bytes.find() to locate pattern]
F –> G{Offset found?}
G –>|Yes| H[Output offset in hex]
G –>|No| I[Pattern not found]

该流程展示了从 hex 字符串转换到实际匹配的全过程，适用于查找固定长度的十六进制模式。

在实际操作中，我们可能不知道二进制文件中字符串所使用的编码格式。这时可以采用“试探性解码”的策略，即尝试使用不同的编码方式对字节序列进行解码，判断是否能得到可读字符串。

以下是一个示例函数，尝试使用多种编码方式对一段字节数据进行解码：

def try_decode(byte_seq):
    encodings = ['utf-8', 'ascii', 'gbk', 'utf-16', 'latin-1']
    for enc in encodings:
        try:
            decoded = byte_seq.decode(enc)
            print(f"Decoded with {enc}: {decoded}")
            return decoded
        except UnicodeDecodeError:
            continue
    print("Failed to decode byte sequence with common encodings.")
    return None

逻辑分析：

decode() 方法尝试使用指定编码解码字节序列。
如果失败则抛出 UnicodeDecodeError ，继续尝试下一种编码。
该方法适用于从未知编码的二进制文件中提取字符串。

对于更复杂的场景，可以借助第三方库（如 chardet 或 cchardet ）自动识别字节数据的编码格式。

示例代码如下：

import chardet

def detect_encoding(byte_data):
    result = chardet.detect(byte_data)
    encoding = result['encoding']
    confidence = result['confidence']
    print(f"Detected encoding: {encoding}, Confidence: {confidence:.2f}")
    if confidence > 0.7:
        try:
            return byte_data.decode(encoding)
        except Exception as e:
            print(f"Decoding failed: {e}")
    else:
        print("Encoding not confidently detected.")
    return None

逻辑分析：

chardet.detect() ：返回字节数据的编码猜测结果。
根据置信度（confidence）决定是否尝试解码。
适用于处理编码未知的大块二进制数据。

在二进制文件中搜索到目标内容后，获取其在文件中的偏移量是非常关键的一步。偏移量是指目标字节序列起始位置相对于文件开头的字节数。

在 Python 中， bytes.find() 方法返回的是第一个匹配项的偏移量（以字节为单位）。例如：

data = b'x00x01x02x03x02x03x04'
pattern = b'x02x03'
offset = data.find(pattern)
print(f"Pattern found at offset: {offset}")  # 输出: Pattern found at offset: 2

若要获取多个匹配位置，可以使用循环查找：

def find_all_offsets(data, pattern):
    offsets = []
    start = 0
    while True:
        offset = data.find(pattern, start)
        if offset == -1:
            break
        offsets.append(offset)
        start = offset + 1  # 从下一个位置继续查找
    return offsets

为了提高调试和分析效率，搜索结果应包括匹配内容及其上下文信息。例如，可以在匹配位置前后各提取若干字节作为上下文：

def show_match_context(data, offset, context_size=16):
    start = max(0, offset - context_size)
    end = offset + len(pattern) + context_size
    context = data[start:end]
    print(f"Match context (offset {offset}):")
    print(' '.join(f"{b:02X}" for b in context))

示例输出：

Match context (offset 2):
00 01 02 03 02 03 04

此方法有助于在复杂二进制文件中快速定位目标内容及其周边数据，便于进一步分析。

本章从字符串的二进制表示、十六进制模式的查找、编码兼容性处理到搜索结果的展示，系统地讲解了如何在Python中实现对二进制文件中字符串与十六进制值的高效查找。下一章将进一步探讨如何优化搜索策略，包括滑动窗口算法、哈希比对等高级技巧。

在处理嵌入式系统或大型二进制文件时，搜索特定的二进制片段（如字符串、固定格式的结构体、配置块、签名信息等）是一项常见的任务。本章将深入探讨如何在Python中实现高效的二进制文件搜索，并结合实际场景介绍多种优化策略，包括滑动窗口算法和哈希比对技术。通过这些方法，我们可以在面对大规模或复杂结构的二进制数据时，依然保持搜索的高效性和准确性。

嵌入式二进制文件通常包含大量非结构化的原始数据，例如固件、驱动程序、编译后的可执行文件等。在这些文件中查找特定的二进制模式（pattern），例如某个十六进制序列或特定字符串，需要理解其存储结构和匹配逻辑。

在嵌入式系统中，数据通常以原始字节形式进行存储，不依赖特定的文件系统结构。例如：

配置信息：可能以固定格式的结构体形式嵌入在固件中；

加密签名：以固定长度的十六进制串形式存在；

字符串资源：如产品型号、版本号等信息可能以ASCII或UTF-8编码嵌入；

函数调用表：常以二进制偏移量的形式存在。

这些数据往往不具有明确的边界，因此需要通过特定的模式进行匹配。

在进行模式匹配时，首先需要明确目标模式的表示方式，例如：

字符串 "hello" 在二进制中可能表示为 b'hello' ；
十六进制序列 48656C6C6F 对应 ASCII 字符串 "hello" 。

使用 Python 的 bytes 类型可以直接进行比对操作。例如：

with open('firmware.bin', 'rb') as f:
    data = f.read()

pattern = b'hello'
if pattern in data:
    print("Pattern found!")
else:
    print("Pattern not found.")

逻辑分析与参数说明：

open(..., 'rb') ：以二进制模式读取文件；
f.read() ：一次性读取全部内容，适用于小文件；
b'hello' ：构造一个字节对象；
in 操作符：用于在字节数据中查找模式是否存在。

此方法适用于简单的存在性判断，但无法定位具体位置，也不适合大规模文件处理。

在实际应用中，我们不仅需要知道目标模式是否存在，还需要定位其在文件中的具体偏移位置。Python 的 `bytes.find()` 方法可以满足这一需求。

bytes.find(sub[, start[, end]]) 方法用于查找子字节序列 sub 在 bytes 对象中的首次出现位置。返回值为匹配位置的索引（从 0 开始），若未找到则返回 -1 。

data = b'x00x01x02hellox03x04'
pattern = b'hello'

offset = data.find(pattern)
if offset != -1:
    print(f"Pattern found at offset: {offset}")

代码分析：

data.find(pattern) ：在 data 中查找 pattern 的首次出现位置；
offset ：如果匹配成功，返回其在字节流中的偏移地址。

如果目标模式可能多次出现，可以使用循环查找所有匹配位置：

def find_all_offsets(data, pattern):
    offsets = []
    start = 0
    while True:
        offset = data.find(pattern, start)
        if offset == -1:
            break
        offsets.append(offset)
        start = offset + 1  # 从下一个位置继续查找
    return offsets

data = b'hello world hello again'
pattern = b'hello'
offsets = find_all_offsets(data, pattern)
print("Found at offsets:", offsets)

输出结果：

Found at offsets: [0, 12]

逻辑分析：

start 控制查找的起始位置；
每次找到匹配后，更新 start 为当前位置加1，防止死循环；
最终返回所有匹配偏移量的列表。

当处理非常大的二进制文件时，一次性读取全部内容到内存中可能导致内存溢出。此时可以采用滑动窗口算法，逐块读取并进行模式匹配。

滑动窗口是一种分块处理策略，它将整个文件划分为多个小块（chunk），每次读取一块进行搜索。为了避免跨块匹配的遗漏问题，窗口之间需有一定的重叠区域。

例如，假设窗口大小为 `CHUNK_SIZE` ，重叠大小为 `len(pattern) - 1` ，则：

graph LR
A[Chunk 1] –> B[Chunk 2]
B –> C[Chunk 3]
C –> D[…]

以下是滑动窗口算法的实现示例：

CHUNK_SIZE = 1024  # 每次读取的字节数
OVERLAP_SIZE = 15  # 重叠区域大小，设为目标模式长度-1

def sliding_window_search(file_path, pattern):
    with open(file_path, 'rb') as f:
        buffer = bytearray()
        offsets = []

        while True:
            chunk = f.read(CHUNK_SIZE)
            if not chunk:
                break
            buffer.extend(chunk)

            # 保持 buffer 长度不超过 CHUNK_SIZE + OVERLAP_SIZE
            if len(buffer) > CHUNK_SIZE + OVERLAP_SIZE:
                buffer = buffer[-OVERLAP_SIZE:]

            # 搜索当前 buffer 中的模式
            start = 0
            while True:
                pos = buffer.find(pattern, start)
                if pos == -1:
                    break
                # 计算全局偏移量
                global_pos = f.tell() - len(buffer) + pos
                offsets.append(global_pos)
                start = pos + 1  # 避免重复匹配

        return offsets

参数说明：

CHUNK_SIZE ：每次读取的块大小，控制内存占用；
OVERLAP_SIZE ：防止模式被截断，建议设为模式长度-1；
buffer ：保存当前窗口的字节数据；
f.tell() ：获取当前文件指针位置，用于计算全局偏移量。

优化点：

内存占用低，适用于大文件；
可避免一次性读取导致的内存溢出；
可通过调整 CHUNK_SIZE 与 OVERLAP_SIZE 平衡性能与准确性。

在某些场景下，我们需要在多个文件中查找相同的二进制片段（如签名、特征码等）。此时可以使用哈希比对技术，将目标模式预先哈希化，再与文件中的数据进行比对，从而提升效率。

常用的哈希算法包括 MD5、SHA-1、SHA-256 等。我们可以为每个待搜索的模式计算哈希值，然后在文件中提取相同长度的字节块，逐一计算哈希并比较。

import hashlib

def compute_hash(data, hash_func=hashlib.sha256):
    return hash_func(data).digest()

def find_hash_match(file_path, target_hash, pattern_length):
    with open(file_path, 'rb') as f:
        buffer = bytearray(pattern_length)
        view = memoryview(buffer)

        # 初始化第一个 buffer
        bytes_read = f.readinto(buffer)
        if bytes_read < pattern_length:
            return None

        while True:
            current_hash = compute_hash(buffer)
            if current_hash == target_hash:
                return f.tell() - pattern_length

            # 滑动一个字节
            for i in range(pattern_length - 1):
                buffer[i] = buffer[i + 1]
            byte = f.read(1)
            if not byte:
                break
            buffer[pattern_length - 1] = byte[0]

        return None

逻辑分析：

compute_hash ：计算给定数据的哈希值；
find_hash_match ：逐字节滑动查找哈希匹配项；
memoryview(buffer) ：提高内存访问效率；
每次滑动一个字节，避免遗漏可能的匹配。

在实际使用中，由于哈希冲突的可能性较低，可以先通过哈希筛选出候选位置，再进行精确比对。这种方法结合了哈希的高效性与精确比对的准确性。

def find_hash_candidates(file_path, pattern):
    pattern_length = len(pattern)
    target_hash = compute_hash(pattern)

    candidates = []
    with open(file_path, 'rb') as f:
        buffer = bytearray(pattern_length)
        view = memoryview(buffer)

        bytes_read = f.readinto(buffer)
        if bytes_read < pattern_length:
            return candidates

        while True:
            current_hash = compute_hash(buffer)
            if current_hash == target_hash:
                offset = f.tell() - pattern_length
                # 精确比对确认
                if buffer == pattern:
                    candidates.append(offset)
            # 滑动窗口
            for i in range(pattern_length - 1):
                buffer[i] = buffer[i + 1]
            byte = f.read(1)
            if not byte:
                break
            buffer[pattern_length - 1] = byte[0]

    return candidates

优点：

减少逐字节比较的次数；
避免哈希冲突带来的误判；
适用于特征码匹配、恶意代码识别等场景。

小结

本章详细介绍了在嵌入式二进制文件中进行模式匹配的基本原理与优化策略。从简单的 bytes.find() 到滑动窗口算法，再到哈希比对技术，每种方法都有其适用场景和优化空间。在实际应用中，应根据文件大小、搜索频率、精度要求等因素选择合适的策略，以达到性能与准确性的最佳平衡。

后续章节预告 ：第五章将深入解析 SearchBin-master 项目的代码结构，帮助读者理解如何将这些搜索技术集成到一个完整的工具系统中。

在实际的二进制文件搜索项目中，一个良好的代码结构是实现高效、可维护和可扩展功能的关键。 `SearchBin-master` 是一个典型的 Python 二进制文件搜索工具项目，其设计体现了模块化、面向对象以及良好的参数处理机制。本章将深入分析该项目的整体架构、核心搜索模块、配置处理流程以及日志与异常处理机制，帮助读者理解如何构建一个结构清晰、逻辑严谨的二进制搜索工具。

`SearchBin-master` 项目的目录结构清晰，模块划分明确。典型的目录结构如下：

SearchBin-master/
├── main.py
├── search_engine.py
├── config_handler.py
├── logger.py
├── utils.py
└── README.md

文件名功能说明

main.py 程序入口，负责解析命令行参数并调用搜索模块

search_engine.py 核心搜索逻辑，包含搜索算法和匹配处理

config_handler.py 配置文件读取与处理模块

logger.py 日志记录模块，支持不同级别的日志输出

utils.py 工具函数集合，如文件读取、字节处理等

README.md 项目说明文档，包含使用说明和示例

这种结构将不同功能模块解耦，便于维护和扩展。

文件名	功能说明
main.py	程序入口，负责解析命令行参数并调用搜索模块
search_engine.py	核心搜索逻辑，包含搜索算法和匹配处理
config_handler.py	配置文件读取与处理模块
logger.py	日志记录模块，支持不同级别的日志输出
utils.py	工具函数集合，如文件读取、字节处理等
README.md	项目说明文档，包含使用说明和示例

项目中主要采用面向对象的方式设计，核心类包括：

SearchEngine ：封装搜索逻辑，提供统一接口进行字符串、十六进制或二进制模式匹配。
ConfigHandler ：读取和解析配置文件，支持 YAML 或 JSON 格式。
Logger ：统一日志输出接口，支持 debug、info、warning、error 等级别。
FileScanner ：用于处理大文件的分块读取和搜索。

例如， SearchEngine 类的定义如下：

class SearchEngine:
    def __init__(self, pattern: bytes):
        self.pattern = pattern
        self.matches = []

    def search_in_file(self, file_path: str):
        with open(file_path, 'rb') as f:
            data = f.read()
            offset = data.find(self.pattern)
            while offset != -1:
                self.matches.append(offset)
                offset = data.find(self.pattern, offset + 1)

代码逻辑分析：

构造函数 __init__ ：接收一个字节模式 pattern ，并初始化匹配结果列表 matches 。
方法 search_in_file ：使用 bytes.find() 方法查找所有匹配位置，并记录偏移量。
循环查找逻辑： 每次找到匹配后，从当前位置后一位继续查找，直到找不到为止。

该类的设计体现了单一职责原则和封装性，便于扩展支持更多搜索模式。

核心搜索模块的调用流程如下：

graph TD
A[main.py] –> B[解析命令行参数]
B –> C[加载配置文件]
C –> D[初始化SearchEngine]
D –> E[调用search_in_file]
E –> F[遍历文件列表]
F –> G[输出匹配结果]

流程说明：

参数解析：通过 `argparse` 解析用户输入的搜索模式、文件路径等。

配置加载：使用 `ConfigHandler` 读取配置文件，设置默认参数。

搜索初始化：根据用户输入的模式构造 `SearchEngine` 实例。

执行搜索：遍历目标文件，逐个执行搜索逻辑。

结果输出：将匹配结果以日志或控制台形式输出。

为了支持多个搜索模式， SearchEngine 可以扩展为支持列表模式：

class MultiPatternSearchEngine:
    def __init__(self, patterns: list[bytes]):
        self.patterns = patterns
        self.match_results = {}

    def search_in_file(self, file_path: str):
        with open(file_path, 'rb') as f:
            data = f.read()
            for pattern in self.patterns:
                matches = []
                offset = data.find(pattern)
                while offset != -1:
                    matches.append(offset)
                    offset = data.find(pattern, offset + 1)
                if matches:
                    self.match_results[pattern.hex()] = matches

代码逻辑分析：

构造函数 __init__ ：接收多个字节模式列表，并初始化一个字典用于记录每个模式的匹配结果。
方法 search_in_file ：遍历每个模式，使用同样的 find() 方法查找所有匹配位置。
结果记录： 以模式的十六进制字符串为键，存储所有匹配偏移量。

这种方式提高了灵活性，支持用户一次搜索多个目标。

main.py 使用 Python 的 argparse 库进行参数解析：

import argparse

def parse_args():
    parser = argparse.ArgumentParser(description="Binary file search utility")
    parser.add_argument("pattern", help="Search pattern in hex or string")
    parser.add_argument("files", nargs='+', help="Files to search in")
    parser.add_argument("--hex", action="store_true", help="Interpret pattern as hex")
    parser.add_argument("--config", default="config.yaml", help="Path to config file")
    return parser.parse_args()

代码逻辑分析：

pattern ：搜索目标，可以是字符串或十六进制。
files ：支持多个文件路径。
--hex ：标志是否将模式解释为十六进制。
--config ：配置文件路径，默认为 config.yaml 。

通过这种方式，用户可以灵活指定搜索内容和行为。

config_handler.py 实现了对 YAML 格式配置文件的读取：

import yaml

class ConfigHandler:
    def __init__(self, config_path: str):
        with open(config_path, 'r') as f:
            self.config = yaml.safe_load(f)

    def get(self, key: str, default=None):
        return self.config.get(key, default)

代码逻辑分析：

构造函数 __init__ ：打开并加载 YAML 配置文件。
方法 get ：提供安全的键值获取方式，避免 KeyError。

示例配置文件 config.yaml 内容如下：

default:
  block_size: 1024 * 1024  # 1MB
  max_results: 100

在搜索模块中，可通过 config_handler.get("block_size", 1024 * 1024) 获取配置参数，便于统一控制。

logger.py 封装了日志记录功能，支持不同级别输出：

import logging

class Logger:
    def __init__(self, level=logging.INFO):
        logging.basicConfig(
            format='%(asctime)s [%(levelname)s] %(message)s',
            level=level
        )
        self.logger = logging.getLogger(__name__)

    def debug(self, msg):
        self.logger.debug(msg)

    def info(self, msg):
        self.logger.info(msg)

    def warning(self, msg):
        self.logger.warning(msg)

    def error(self, msg):
        self.logger.error(msg)

代码逻辑分析：

使用 logging 标准库配置格式和级别。
提供统一接口封装日志输出方法，便于替换日志系统。

日志示例输出：

2025-04-05 10:23:12,345 [INFO] Searching for pattern in file: target.bin
2025-04-05 10:23:13,001 [DEBUG] Match found at offset: 0x1234

在文件读取和搜索过程中，可能遇到文件不存在、权限不足等异常，项目采用如下策略处理：

try:
    engine.search_in_file(file_path)
except FileNotFoundError:
    logger.error(f"File not found: {file_path}")
except PermissionError:
    logger.error(f"Permission denied: {file_path}")
except Exception as e:
    logger.error(f"Unexpected error occurred: {e}")

代码逻辑分析：

使用 try-except 捕获常见异常类型。
通过日志记录错误信息，提升用户调试效率。
对于非致命错误（如单个文件失败），程序继续处理其他文件，保证整体流程不受中断。

此外，还可以引入 contextlib.closing 来确保资源释放，或使用 with 语句自动管理文件句柄，提升程序健壮性。

通过上述章节的分析，我们可以清晰地看到 SearchBin-master 项目在代码结构、模块划分、搜索逻辑、参数处理和异常管理方面的设计思路和实现细节。这些内容不仅有助于理解项目运行机制，也为开发类似的二进制搜索工具提供了良好的参考模板。

在逆向工程领域，二进制搜索技术是定位和分析目标文件内容的重要手段之一。通过在原始字节数据中查找特定的字符串、十六进制序列或嵌入对象，逆向工程师可以快速识别程序行为、提取敏感信息或定位漏洞点。

在分析恶意软件时，攻击者往往将敏感信息（如C2服务器地址、命令字符串、注册表键值）以明文或编码形式嵌入在二进制中。通过搜索ASCII或UTF-8格式的字符串，可以快速提取这些信息。

例如，使用Python读取恶意样本的二进制内容，并提取长度大于等于5的可打印字符串：

import re

def extract_ascii_strings(file_path, min_length=5):
    with open(file_path, 'rb') as f:
        data = f.read()
    # 匹配连续的可打印字符，长度>=min_length
    ascii_strings = re.findall(b'[%s]{%d,}' % (re.escape(bytes(string.printable, 'utf-8')), min_length), data)
    return [s.decode('ascii', errors='ignore') for s in ascii_strings]

# 示例调用
strings = extract_ascii_strings("malware_sample.exe")
for s in strings:
    print(s)

参数说明：

file_path ：恶意样本的路径。
min_length ：最小字符串长度。
re.escape(bytes(string.printable, 'utf-8')) ：确保只匹配可打印字符。

固件文件（如路由器、摄像头固件）通常以二进制格式存储，其中可能包含配置参数、密码、API密钥等。通过二进制搜索技术，可以在固件中定位这些隐藏信息。

例如，搜索固件中是否包含“admin:123456”这类默认账户密码组合：

def search_hex_pattern(file_path, hex_pattern):
    pattern_bytes = bytes.fromhex(hex_pattern)
    with open(file_path, 'rb') as f:
        data = f.read()
    offset = data.find(pattern_bytes)
    if offset != -1:
        print(f"Pattern found at offset: 0x{offset:x}")
    else:
        print("Pattern not found.")

# 查找“admin:123456”的十六进制表示
search_hex_pattern("firmware.bin", "61646d696e3a313233343536")

输出示例：

Pattern found at offset: 0x12a3f

ELF（Executable and Linkable Format）是Linux系统下常见的可执行文件格式。ELF文件结构复杂，字符串通常存储在 `.strtab` 或 `.shstrtab` 段中。

ELF文件主要包括以下几个部分：

ELF Header ：描述文件整体信息。

Program Headers ：用于运行时加载。

Section Headers ：用于链接和分析。

各段（Sections）：如 `.text` 、 `.data` 、 `.rodata` 、 `.strtab` 等。

字符串通常存储在 `.strtab` 节中，可通过遍历节头表来定位。

我们可以使用 pyelftools 库解析ELF文件并提取字符串段内容：

pip install pyelftools

from elftools.elf.elffile import ELFFile

def extract_elf_strings(file_path):
    with open(file_path, 'rb') as f:
        elffile = ELFFile(f)
        for section in elffile.iter_sections():
            if isinstance(section, StringTableSection):
                string_data = section.data()
                # 提取可打印ASCII字符串
                strings = [s.decode('ascii') for s in re.findall(b'[x20-x7E]{5,}', string_data)]
                return strings
    return []

# 示例调用
elf_strings = extract_elf_strings("example.elf")
for s in elf_strings:
    print(s)

代码说明：

ELFFile ：用于解析ELF文件。
StringTableSection ：字符串表段类型。
re.findall ：用于提取连续的可打印字符。

PE（Portable Executable）是Windows系统下的可执行文件格式。许多恶意软件或加壳程序会将资源（如图标、配置文件、其他可执行文件）嵌入到PE文件的资源节中。

PE文件主要结构包括：

DOS Header

NT Headers

Section Table

各个节（如 `.text` , `.rsrc` , `.data` ）

资源节（ `.rsrc` ）通常包含图标、对话框模板、字符串表等嵌入资源。

我们可以使用 pefile 库解析PE文件并提取 .rsrc 段的内容：

pip install pefile

import pefile

def extract_pe_resources(file_path):
    pe = pefile.PE(file_path)
    for section in pe.sections:
        if b'.rsrc' in section.Name:
            print(f"Found .rsrc section at offset: 0x{section.PointerToRawData:x}")
            resources_data = pe.get_memory_mapped_image()[section.VirtualAddress:section.VirtualAddress + section.Misc_VirtualSize]
            # 提取ASCII字符串
            ascii_strings = re.findall(b'[x20-x7E]{5,}', resources_data)
            print("ASCII Strings in .rsrc section:")
            for s in ascii_strings:
                print(s.decode('ascii', errors='ignore'))
            break

# 示例调用
extract_pe_resources("example.exe")

输出示例：

Found .rsrc section at offset: 0x1a000
ASCII Strings in .rsrc section:
http://malicious-server.com/api
username=admin
password=secret123

在逆向分析中，自动化脚本能显著提升效率。建议采用以下策略编写脚本：

技巧描述

模块化设计将字符串提取、偏移计算、日志记录等功能封装为独立函数

错误处理机制使用try-except结构处理文件读取错误或格式异常

输出格式统一使用JSON或CSV格式输出结果，便于后续分析

多平台兼容使用 `sys.platform` 判断操作系统，兼容Linux和Windows

技巧	描述
模块化设计	将字符串提取、偏移计算、日志记录等功能封装为独立函数
错误处理机制	使用try-except结构处理文件读取错误或格式异常
输出格式统一	使用JSON或CSV格式输出结果，便于后续分析
多平台兼容	使用 `sys.platform` 判断操作系统，兼容Linux和Windows

虽然Python脚本可以快速定位目标数据，但在深入分析时，通常需要结合专业工具如IDA Pro、Ghidra等进行逆向分析。以下是联合分析的典型流程：

graph TD
A[加载目标文件] –> B{是否为PE/ELF文件?}
B –>|是| C[使用pefile/elftools提取关键段]
B –>|否| D[使用通用二进制搜索]
C –> E[提取字符串/资源]
D –> E
E –> F[输出匹配结果与偏移]
F –> G[在IDA中跳转至对应偏移]
G –> H[分析函数调用关系]
H –> I[结合符号信息进一步分析]

通过Python脚本初步定位目标字符串或资源后，可以在IDA Pro中使用 `Jump to Address` 功能直接跳转至对应偏移位置，进一步分析函数调用逻辑、控制流等信息。

到此这篇关于Python在二进制文件中进行数据搜索的实战指南的文章就介绍到这了,更多相关Python二进制文件搜索数据内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

Python二进制文件转换为文本文件的代码实现

Python读写二进制文件的示例详解

Python如何利用struct进行二进制文件或数据流

Python读取二进制文件代码方法解析

使用Python读取二进制文件的实例讲解

华夏福临门盛世加强版怎么样？产品责任是重中之重

国寿福庆典版值得买吗？附投保建议

理财中低风险是几级？中低风险理财会亏吗

瑞泰泰安心防癌险优缺点是什么？这份分析不容错过

2020最新自助免费申请Office365教育版，免费5TOneDrive云盘详细图文教程

MacBook怎么绕过BootCamp安装Win10双系统？

国内知名的前端博客

域名为什么会被墙？如何检测域名是否被墙？域名被墙如何处理？

最新的windows xp sp3产品密匙 xp sp3序列号 xp sp3激活码

Python在二进制文件中进行数据搜索的实战指南

目录

Python中打开文件的方式分为 文本模式 （默认）和 二进制模式 。这两种模式在处理文件内容时有本质区别。

使用 rb 模式读取文件是处理二进制数据的首选方式。它允许我们访问文件的原始字节内容，而不受编码和换行符转换的影响。

Python提供了两种用于处理字节序列的类型： bytes 和 bytearray 。它们是处理二进制数据的核心类型。

处理二进制数据时，常见的操作包括拼接、切片、编码解码等。

嵌入式二进制文件通常包含大量非结构化的原始数据，例如固件、驱动程序、编译后的可执行文件等。在这些文件中查找特定的二进制模式（pattern），例如某个十六进制序列或特定字符串，需要理解其存储结构和匹配逻辑。

在实际应用中，我们不仅需要知道目标模式是否存在，还需要定位其在文件中的具体偏移位置。Python 的 bytes.find() 方法可以满足这一需求。

当处理非常大的二进制文件时，一次性读取全部内容到内存中可能导致内存溢出。此时可以采用 滑动窗口 算法，逐块读取并进行模式匹配。

在某些场景下，我们需要在多个文件中查找相同的二进制片段（如签名、特征码等）。此时可以使用哈希比对技术，将目标模式预先哈希化，再与文件中的数据进行比对，从而提升效率。

在逆向工程领域，二进制搜索技术是定位和分析目标文件内容的重要手段之一。通过在原始字节数据中查找特定的字符串、十六进制序列或嵌入对象，逆向工程师可以快速识别程序行为、提取敏感信息或定位漏洞点。

ELF（Executable and Linkable Format）是Linux系统下常见的可执行文件格式。ELF文件结构复杂，字符串通常存储在 .strtab 或 .shstrtab 段中。

PE（Portable Executable）是Windows系统下的可执行文件格式。许多恶意软件或加壳程序会将资源（如图标、配置文件、其他可执行文件）嵌入到PE文件的资源节中。

PE文件主要结构包括： DOS Header NT Headers Section Table 各个节（如 .text , .rsrc , .data ） 资源节（ .rsrc ）通常包含图标、对话框模板、字符串表等嵌入资源。

更多文章

站内搜索

标签云

热门文章

友情链接

Python中打开文件的方式分为文本模式（默认）和二进制模式。这两种模式在处理文件内容时有本质区别。

使用 `rb` 模式读取文件是处理二进制数据的首选方式。它允许我们访问文件的原始字节内容，而不受编码和换行符转换的影响。

Python提供了两种用于处理字节序列的类型： `bytes` 和 `bytearray` 。它们是处理二进制数据的核心类型。

在实际应用中，我们不仅需要知道目标模式是否存在，还需要定位其在文件中的具体偏移位置。Python 的 `bytes.find()` 方法可以满足这一需求。

当处理非常大的二进制文件时，一次性读取全部内容到内存中可能导致内存溢出。此时可以采用滑动窗口算法，逐块读取并进行模式匹配。

ELF（Executable and Linkable Format）是Linux系统下常见的可执行文件格式。ELF文件结构复杂，字符串通常存储在 `.strtab` 或 `.shstrtab` 段中。

PE文件主要结构包括：

DOS Header

NT Headers

Section Table

各个节（如 `.text` , `.rsrc` , `.data` ）

资源节（ `.rsrc` ）通常包含图标、对话框模板、字符串表等嵌入资源。