21、多进程在文件哈希和密码表生成中的应用

多进程在文件哈希和密码表生成中的应用

在数字取证和密码破解等领域，处理大量数据和复杂计算时，性能往往是关键。Python 提供了强大的多进程库，能有效利用多核处理器的优势，显著提升处理速度。本文将详细介绍多进程在文件哈希和密码表生成中的应用，并对比单核心和多核心解决方案的性能。

1. 多进程文件哈希

1.1 单核心解决方案

单核心解决方案按顺序处理每个文件，依次计算哈希值。以下是单线程文件哈希的代码：

import hashlib
import os
import sys
import time

# 创建本地目录常量
HASHDIR = 'c:\\HASHTEST\\'
# 创建空列表存储哈希结果
results = []

try:
    # 获取 HASHDIR 中的文件列表
    listOfFiles = os.listdir(HASHDIR)
    # 记录主循环开始时间
    startTime = time.time()
    for eachFile in listOfFiles:
        # 尝试打开文件
        fp = open(HASHDIR + eachFile, 'rb')
        # 将文件内容读入缓冲区
        fileContents = fp.read()
        # 关闭文件
        fp.close()
        # 创建 sha256 哈希对象
        hasher = hashlib.sha256()
        # 对缓冲区内容进行哈希处理
        hasher.update(fileContents)
        # 将结果存储在 results 列表中
        results.append([eachFile, hasher.hexdigest()])
        # 删除哈希对象
        del hasher
    # 计算所有文件哈希处理后的耗时
    elapsedTime = time.time() - startTime
except:
    # 若发生异常，通知用户并退出
    print('File Processing Error')
    sys.exit(0)

# 输出结果
# 耗时（秒）和文件名/哈希结果
print('Elapsed Time:', elapsedTime)
for eachItem in results:
    print(eachItem)

1.2 多核心解决方案 A

多核心解决方案 A 为每个核心创建一个 Process 对象，并行处理文件哈希。以下是多进程文件哈希 A 的代码：

import hashlib
import os
import sys
import time
import multiprocessing

# 创建本地目录常量
HASHDIR = 'c:\\HASHTEST\\'

# hashFile 函数，用于多进程处理
def hashFile(fileName):
    try:
        fp = open(fileName, 'rb')
        # 将文件内容读入缓冲区
        fileContents = fp.read()
        # 关闭文件
        fp.close()
        # 创建 sha256 哈希对象
        hasher = hashlib.sha256()
        # 对缓冲区内容进行哈希处理
        hasher.update(fileContents)
        print(fileName, hasher.hexdigest())
        # 删除哈希对象
        del hasher
    except:
        # 若发生异常，通知用户并退出
        print('File Processing Error')
        sys.exit(0)
    return True

# 创建主函数
if __name__ == '__main__':
    # 获取 HASHDIR 中的文件列表
    listOfFiles = os.listdir(HASHDIR)
    # 记录主循环开始时间
    startTime = time.time()
    # 创建 4 个子进程进行工作
    coreOne = multiprocessing.Process(target=hashFile, args=(HASHDIR + listOfFiles[0],))
    coreOne.start()
    coreTwo = multiprocessing.Process(target=hashFile, args=(HASHDIR + listOfFiles[1],))
    coreTwo.start()
    coreThree = multiprocessing.Process(target=hashFile, args=(HASHDIR + listOfFiles[2],))
    coreThree.start()
    coreFour = multiprocessing.Process(target=hashFile, args=(HASHDIR + listOfFiles[3],))
    coreFour.start()

    # 使用 join 等待所有进程完成
    coreOne.join()
    coreTwo.join()
    coreThree.join()
    coreFour.join()

    # 所有进程完成且文件哈希处理完成后，计算耗时
    elapsedTime = time.time() - startTime
    print('Elapsed Time:', elapsedTime)

1.3 多核心解决方案 B

多核心解决方案 B 使用 Pool 类简化多进程处理，通过 map 方法将任务分配给多个进程。以下是多进程文件哈希 B 的代码：

import hashlib
import os
import sys
import time
import multiprocessing

# 创建本地目录常量
HASHDIR = 'c:\\HASHTEST\\'

# hashFile 函数，用于多进程处理
def hashFile(fileName):
    try:
        fp = open(fileName, 'rb')
        # 将文件内容读入缓冲区
        fileContents = fp.read()
        # 关闭文件
        fp.close()
        # 创建 sha256 哈希对象
        hasher = hashlib.sha256()
        # 对缓冲区内容进行哈希处理
        hasher.update(fileContents)
        print(fileName, hasher.hexdigest())
        # 删除哈希对象
        del hasher
    except:
        # 若发生异常，通知用户并退出
        print('File Processing Error')
        sys.exit(0)
    return True

# 创建主函数
if __name__ == '__main__':
    # 获取 HASHDIR 中的文件列表
    listOfFiles = os.listdir(HASHDIR)
    # 记录主循环开始时间
    startTime = time.time()
    # 创建一个包含 4 个进程的进程池，对应笔记本电脑的 4 个核心
    corePool = multiprocessing.Pool(processes=4)
    # 将 corePool 映射到 hashFile 函数
    results = corePool.map(hashFile, (HASHDIR + listOfFiles[0],
                                       HASHDIR + listOfFiles[1],
                                       HASHDIR + listOfFiles[2],
                                       HASHDIR + listOfFiles[3],))
    # 所有文件哈希处理完成并输出结果后，计算耗时
    elapsedTime = time.time() - startTime
    print('Elapsed Time:', elapsedTime, 'Seconds')

1.4 性能对比

实现方案	处理时间（秒）	每秒处理 MB 数	备注
单核心解决方案	27.851	35.76	目前典型的顺序处理每个文件的实现方式
多核心解决方案 A	8.409	118.44	使用 Process 类以及 start 和 join 方法
多核心解决方案 B	8.138	122.39	使用 Pool 类简化通用函数处理的实现，性能稍好

从性能对比可以看出，多核心解决方案显著提高了文件哈希处理的速度，尤其是多核心解决方案 B，不仅性能更好，而且代码实现更简洁。

1.5 多进程文件哈希流程

graph LR
    A[开始] --> B[获取文件列表]
    B --> C{单核心/多核心}
    C -- 单核心 --> D[按顺序处理文件]
    C -- 多核心 --> E[创建进程/进程池]
    D --> F[计算哈希值]
    E --> G[分配任务到进程]
    F --> H[存储结果]
    G --> I[并行计算哈希值]
    I --> H
    H --> J[计算耗时]
    J --> K[输出结果]
    K --> L[结束]

2. 多进程密码表生成

2.1 彩虹表简介

彩虹表是一种将已知哈希值转换为可能密码等效值的工具，可用于破解操作系统、受保护文档和网络用户登录的密码。但近年来，加盐哈希的方法使彩虹表的效果降低，因为每次加盐值修改都需要生成新的表。为了生成更动态的查找表，多进程可以发挥重要作用。

2.2 单核心密码生成器

单核心密码生成器按顺序生成所有可能的密码组合，并计算其哈希值。以下是单核心密码表生成器的代码：

import hashlib
import time
import itertools

# 创建包含小写、大写、数字和特殊字符的列表
lowerCase = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
upperCase = ['G', 'H', 'I', 'J', 'K', 'L']
numbers = ['0', '1', '2', '3']
special = ['!', '@', '#', '$']

# 合并列表
allCharacters = []
allCharacters = lowerCase + upperCase + numbers + special

# 定义密码文件的目录路径
DIR = 'C:\\PW\\'
# 定义假设的 SALT 值
SALT = '&45Bvx9'
# 定义允许的密码长度范围
PW_LOW = 2
PW_HIGH = 6

# 记录开始时间
startTime = time.time()

# 创建空列表存储最终密码
pwList = []

# 生成所有允许长度范围内的密码
for r in range(PW_LOW, PW_HIGH):
    for s in itertools.product(allCharacters, repeat=r):
        pwList.append(''.join(s))

try:
    # 打开输出文件
    fp = open(DIR + 'all', 'w')
    # 处理每个生成的密码
    for pw in pwList:
        # 对密码进行哈希处理
        md5Hash = hashlib.md5()
        md5Hash.update(SALT + pw)
        md5Digest = md5Hash.hexdigest()
        # 将哈希值和密码对写入文件
        fp.write(md5Digest + ' ' + pw + '\n')
        del md5Hash
except:
    print('File Processing Error')
    fp.close()

# 创建字典存储哈希值和密码对，方便查找
pwDict = {}
try:
    # 打开输出文件
    fp = open(DIR + 'all', 'r')
    # 处理文件中的每一行
    for line in fp:
        # 提取键值对并更新字典
        pairs = line.split()
        pwDict.update({pairs[0]: pairs[1]})
    fp.close()
except:
    print('File Handling Error')
    fp.close()

# 计算耗时
elapsedTime = time.time() - startTime
print('Elapsed Time:', elapsedTime)
print('Passwords Generated:', len(pwDict))

# 输出部分字典条目作为示例
cnt = 0
for key, value in (pwDict.items()):
    print(key, value)
    cnt += 1
    if cnt > 10:
        break

# 使用字典根据已知哈希值查找密码
pw = pwDict.get('c6f1d6b1d33bcc787c2385c19c29c208')
print('Hash Value Tested = c6f1d6b1d33bcc787c2385c19c29c208')
print('Associated Password=' + pw)

2.3 多核心密码生成器

多核心密码生成器使用 Pool 类将不同长度的密码生成任务分配给多个进程并行处理。以下是多核心密码表生成器的代码：

import hashlib
import time
import itertools
import multiprocessing

# 创建包含小写、大写、数字和特殊字符的列表
lowerCase = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
upperCase = ['G', 'H', 'I', 'J', 'K', 'L']
numbers = ['0', '1', '2', '3']
special = ['!', '@', '#', '$']

# 合并列表
allCharacters = []
allCharacters = lowerCase + upperCase + numbers + special

# 定义密码文件的目录路径
DIR = 'C:\\PW\\'
# 定义假设的 SALT 值
SALT = '&45Bvx9'
# 定义允许的密码长度范围
PW_LOW = 2
PW_HIGH = 6

def pwGenerator(size):
    pwList = []
    # 生成指定长度的所有密码
    for r in range(size, size + 1):
        for s in itertools.product(allCharacters, repeat=r):
            pwList.append(''.join(s))
    try:
        # 打开输出文件
        fp = open(DIR + str(size), 'w')
        # 处理每个生成的密码
        for pw in pwList:
            # 对密码进行哈希处理
            md5Hash = hashlib.md5()
            md5Hash.update(SALT + pw)
            md5Digest = md5Hash.hexdigest()
            # 将哈希值和密码对写入文件
            fp.write(md5Digest + ' ' + pw + '\n')
            del md5Hash
    except:
        print('File Processing Error')
    finally:
        fp.close()

# 创建主函数
if __name__ == '__main__':
    # 记录主循环开始时间
    startTime = time.time()
    # 创建一个包含 4 个进程的进程池
    corePool = multiprocessing.Pool(processes=4)
    # 将 corePool 映射到 pwGenerator 函数
    results = corePool.map(pwGenerator, (2, 3, 4, 5))

    # 创建字典存储哈希值和密码对，方便查找
    pwDict = {}
    # 处理每个输出文件
    for i in range(PW_LOW, PW_HIGH):
        try:
            # 打开输出文件
            fp = open(DIR + str(i), 'r')
            # 处理文件中的每一行
            for line in fp:
                # 提取键值对并更新字典
                pairs = line.split()
                pwDict.update({pairs[0]: pairs[1]})
            fp.close()
        except:
            print('File Handling Error')
            fp.close()

    # 所有文件哈希处理完成后，计算耗时
    elapsedTime = time.time() - startTime
    print('Elapsed Time:', elapsedTime, 'Seconds')
    print('Passwords Generated:', len(pwDict))

    # 输出部分字典条目作为示例
    cnt = 0
    for key, value in (pwDict.items()):
        print(key, value)
        cnt += 1
        if cnt > 10:
            break

    # 使用字典根据已知哈希值查找密码
    pw = pwDict.get('c6f1d6b1d33bcc787c2385c19c29c208')
    print('Hash Value Tested = 2bca9b23eb8419728fdeca3345b344fc')
    print('Associated Password=' + pw)

2.4 性能对比

实现方案	彩虹表生成器	处理时间（秒）	每秒生成密码数	备注
单核心解决方案	89.11	≈60 K	目前典型的单核心处理方式
多核心解决方案	50.50	≈106 K	使用 Pool 类简化实现

从性能对比可以看出，多核心解决方案在密码表生成方面也显著提高了处理速度，且代码实现依然简洁易懂。

2.5 多进程密码表生成流程

graph LR
    A[开始] --> B[定义字符集和参数]
    B --> C{单核心/多核心}
    C -- 单核心 --> D[按顺序生成密码组合]
    C -- 多核心 --> E[创建进程池]
    D --> F[计算哈希值]
    E --> G[分配不同长度任务到进程]
    F --> H[存储哈希值和密码对]
    G --> I[并行生成密码组合]
    I --> F
    H --> J[合并结果到字典]
    J --> K[计算耗时]
    K --> L[输出结果]
    L --> M[结束]

3. 总结

多进程在文件哈希和密码表生成中展现出了显著的性能优势。通过合理利用多核处理器，我们可以大幅缩短处理时间，提高效率。在实际应用中，根据具体需求选择合适的多进程解决方案，如使用 Process 类或 Pool 类，能更好地平衡性能和代码复杂度。同时，Python 的标准库提供了丰富的工具，如 itertools 模块，为数据处理和组合生成提供了便利。希望本文能帮助你更好地理解和应用多进程技术，提升工作效率。

4. 多进程应用的注意事项

4.1 资源管理

在使用多进程时，需要注意资源的合理分配和管理。例如，在文件哈希和密码表生成过程中，每个进程都会占用一定的内存和文件句柄。如果同时启动过多的进程，可能会导致系统资源耗尽，从而影响性能甚至导致程序崩溃。因此，在创建进程池时，应根据系统的实际情况合理设置进程数量。

4.2 异常处理

多进程环境下的异常处理需要特别注意。由于每个进程是独立运行的，一个进程中的异常不会影响其他进程的执行。因此，在每个进程的函数中都应该包含适当的异常处理代码，以确保在出现异常时能够及时通知用户并进行相应的处理，避免程序陷入不可控状态。

4.3 进程同步

在某些情况下，多个进程可能需要访问共享资源，如文件或数据库。这时就需要进行进程同步，以避免数据冲突和不一致。Python 的 multiprocessing 库提供了多种同步机制，如锁（ Lock ）、信号量（ Semaphore ）等，可以根据具体需求选择合适的同步方式。

5. 拓展应用

5.1 分布式处理

除了在单机上使用多进程，还可以将多进程技术拓展到分布式系统中。通过网络连接多个计算机，将任务分配到不同的节点上并行处理，可以进一步提高处理能力。Python 的 multiprocessing 库可以与分布式计算框架（如 Dask 、 Ray 等）结合使用，实现更强大的分布式处理能力。

5.2 实时数据处理

在实时数据处理场景中，多进程可以用于并行处理大量的实时数据。例如，在网络监控、传感器数据处理等领域，多进程可以及时处理和分析海量的数据，确保系统的实时性和响应速度。

5.3 机器学习模型训练

在机器学习模型训练过程中，多进程可以用于并行计算模型的梯度和更新参数，从而加速训练过程。特别是对于大规模数据集和复杂模型，多进程可以显著缩短训练时间，提高效率。

6. 总结与展望

6.1 总结回顾

本文详细介绍了多进程在文件哈希和密码表生成中的应用，对比了单核心和多核心解决方案的性能。通过实际代码示例和性能分析，我们可以看到多进程技术在处理大量数据和复杂计算时具有显著的优势。无论是文件哈希还是密码表生成，多核心解决方案都能大幅缩短处理时间，提高效率。

6.2 未来展望

随着计算机硬件技术的不断发展，多核处理器将越来越普及，多进程技术的应用前景也将更加广阔。未来，我们可以进一步探索多进程在更多领域的应用，如大数据处理、人工智能、科学计算等。同时，随着 Python 语言的不断发展和完善，多进程库的功能也将更加强大，使用起来更加方便。

6.3 建议与思考

在实际应用中，我们应该根据具体的需求和场景选择合适的多进程解决方案。同时，要注意多进程应用中的资源管理、异常处理和进程同步等问题，确保程序的稳定性和可靠性。此外，我们还可以不断学习和探索新的多进程技术和框架，以适应不断变化的需求和挑战。

6.4 多进程应用的综合对比

应用场景	单核心解决方案	多核心解决方案	优势
文件哈希	按顺序处理文件，处理时间长	并行处理文件，处理时间显著缩短	提高处理速度，充分利用多核资源
密码表生成	按顺序生成密码组合，效率低	并行生成不同长度的密码组合，效率高	快速生成大量密码组合，适应大规模需求

6.5 多进程应用的整体流程

graph LR
    A[开始] --> B[确定应用场景]
    B --> C{单核心/多核心}
    C -- 单核心 --> D[顺序处理任务]
    C -- 多核心 --> E[创建进程/进程池]
    D --> F[完成任务]
    E --> G[分配任务到进程]
    G --> H[并行处理任务]
    H --> F
    F --> I[处理结果汇总]
    I --> J[计算耗时和评估性能]
    J --> K[输出结果和分析报告]
    K --> L[结束]

通过本文的介绍和分析，相信读者对多进程在文件哈希和密码表生成中的应用有了更深入的理解。在实际工作中，合理运用多进程技术可以显著提升处理效率，为解决复杂问题提供有力支持。