Python库zipfile破解zip文件解压密码

原创已于 2025-09-03 10:38:14 修改 · 5.8k 阅读

33 ·

CC 4.0 BY-SA版权

文章标签：

#python

于 2025-06-23 19:33:32 首次发布

Python 专栏收录该内容

22 篇文章

订阅专栏

本文介绍了使用Python的zipfile模块暴力破解ZIP文件密码的方法，包括纯数字密码和字母数字混合密码的尝试。通过创建多线程进行尝试，对于纯数字密码，从1到9999遍历；对于字母数字混合密码，使用迭代器生成随机组合，直到找到正确密码。这种方法适用于传统加密的ZIP文件，但不适用于所有加密方式，且在实际操作中可能耗时较长。

1. 简介

在数字化时代，文件加密成为保护敏感信息的标配。然而，面对忘记密码或需要合法访问加密文件的困境，我们如何高效解决？本文将深入探讨如何使用Python实现Zip文件的暴力破解，旨在帮助读者理解加密机制，并在合法场景下解决实际问题。请注意，未经授权的破解行为是非法的，本文内容仅供教育和学习之用。

使用的核心模块是Python标准库中的zipfile模块。这个模块可以实现zip文件的各种功能，具体可以查看官方参考文档。这里的暴力破解的意思是对密码可能序列中的值一个一个进行密码尝试，这对人来说是很难的，可是对计算机而言并不难。有时候我们下载的zip文件需要密码解压而我们不知道，需要付费才知道。所有这里主要介绍两种暴力破解的密码：纯数字密码和英文数字组合密码。

2. 核心概念与原理

暴力破解 (BruteForce)：一种通过尝试所有可能的密码组合来找到正确密码的方法。在Python中，我们主要依赖以下核心概念实现Zip文件的暴力破解：

zipfile模块
Python标准库中的zipfile模块允许我们读取、写入和修改ZIP文件。对于暴力破解，ZipFile类和extractall()方法至关重要。
迭代器和生成器
Python的迭代器和生成器特性允许我们以内存友好的方式处理大量可能的密码组合，提高破解效率。
多线程和并发
利用Python的threading模块，我们可以并行尝试多个密码，显著加快破解速度。
字符集和密码空间
了解可能的字符集（如数字、字母、特殊字符）和密码长度范围，对于确定搜索空间至关重要。

3. 文件创建

首先测试文件为test.txt（仅包含单行文本），压缩后文件为test.zip，压缩密码为2340，压缩后删除目录下的txt文件。

上图注意勾选传统加密。

4. 已知密码

import zipfile

# 创建文件句柄
file = zipfile.ZipFile("测试.zip", 'r')
# 提取压缩文件中的内容，注意密码必须是bytes格式，path表示提取到哪
file.extractall(path='.', pwd='2340'.encode('utf-8'))

5. 未知纯数字密码

指的是不用0开头的数字密码，0开头见后面的字母组合。原理就是zipfile模块解压压缩文件时，一旦密码不正确，程序会终止，在try语句只有成功解压的密码才会执行到extract函数调用后面的语句。

代码：

import zipfile
import time
import threading
startTime = time.time()
# 判断线程是否需要终止
flag = True
 
 
def extract(password, file):
    try:
        password = str(password)
        file.extractall(path='.', pwd=password.encode('utf-8'))
        print("the password is {}".format(password))
        nowTime = time.time()
        print("spend time is {}".format(nowTime-startTime))
        global flag
        # 成功解压其余线程终止
        flag = False
    except Exception as e:
        print(e)
 
 
def do_main():
    zfile = zipfile.ZipFile("test.zip", 'r')
    # 开始尝试
    for number in range(1, 9999):
        if flag is True:
            t = threading.Thread(target=extract, args=(number, zfile))
            t.start()
            t.join()
 
 
if __name__ == '__main__':
    do_main()

解压成功，这里提一下这种编码密码的方式只适用于传统zip加密，winrar有一种新式的默认加密方式，是不可以的。

6. 未知字母数字混合密码

这里情况密码组合太多，为了防止内存溢出，改用迭代器。这种情况费时很久，可以闲来无事挂着脚本。这里再次压缩文件，密码为Python。

import zipfile
import random
import time
import sys
 
 
class MyIterator():
    # 单位字符集合
    letters = 'abcdefghijklmnopqrstuvwxyz012345678'
    min_digits = 0
    max_digits = 0
 
    def __init__(self, min_digits, max_digits):
        # 实例化对象时给出密码位数范围，一般4到10位
        if min_digits < max_digits:
            self.min_digits = min_digits
            self.max_digits = max_digits
        else:
            self.min_digits = max_digits
            self.max_digits = min_digits
 
    # 迭代器访问定义
    def __iter__(self):
        return self
 
    def __next__(self):
        rst = str()
        for item in range(0, random.randrange(self.min_digits, self.max_digits+1)):
            rst += random.choice(MyIterator.letters)
        return rst
 
 
def extract():
    start_time = time.time()
    zfile = zipfile.ZipFile("test.zip")
    for p in MyIterator(5, 6):
        try:
            zfile.extractall(path=".", pwd=str(p).encode('utf-8'))
            print("the password is {}".format(p))
            now_time = time.time()
            print("spend time is {}".format(now_time-start_time))
            sys.exit(0)
        except Exception as e:
            pass
 
 
if __name__ == '__main__':
    extract()

为了提高速度，可以使用多进程：

import zipfile
import itertools
from concurrent.futures import ThreadPoolExecutor

def extract(file, password):
    if not flag: return
    file.extractall(path='.', pwd=''.join(password).encode('utf-8'))


def result(f):
    exception = f.exception()
    if not exception:
        # 如果获取不到异常说明破解成功
        print('密码为：', f.pwd)
        global flag
        flag = False


if __name__ == '__main__':
    # 创建一个标志用于判断密码是否破解成功
    flag = True
    # 创建一个线程池
    pool = ThreadPoolExecutor(100)
    nums = [str(i) for i in range(10)]
    chrs = [chr(i) for i in range(65, 91)]
    # 生成数字+字母的6位数密码
    password_lst = itertools.permutations(nums + chrs, 6)
    # 创建文件句柄
    zfile = zipfile.ZipFile("加密文件.zip", 'r')
    for pwd in password_lst:
        if not flag: break
        f = pool.submit(extract, zfile, pwd)
        f.pwd = pwd
        f.pool = pool
        f.add_done_callback(result)

这样会导致内存溢出，这是因为ThreadPoolExecutor默认使用的是无界队列。而程序中尝试密码的速度跟不上生产密码的速度，就会把生产任务无限添加到队列中。继承需要重写ThreadPoolExecutor类中的_work_queue属性，将无界队列改成有界队列，这样就不会出现内存爆满的问题，用自定义的BoundedThreadPoolExecutor类替代前面代码中的ThreadPoolExecutor。

import queue
from concurrent.futures import ThreadPoolExecutor


class BoundedThreadPoolExecutor(ThreadPoolExecutor):
    def __init__(self, max_workers=None, thread_name_prefix=''):
        super().__init__(max_workers, thread_name_prefix)
        self._work_queue = queue.Queue(self._max_workers * 2) # 设置队列大小