python破解压缩包密码

1. 前言

2. 破解zip、7z等

2.1 快速开始

python里有个内置库zipfile可以对zip格式压缩包进行操作。

import zipfile
 
# 创建文件句柄
file = zipfile.ZipFile("测试.zip", 'r')
# 提取压缩包内所有内容，path为目标目录，pwd为密码，需为bytes格式
file.extractall(path='.', pwd='123'.encode('utf-8'))
# 关闭文件
file.close()

知道了如何使用代码解压文件，下面只需生成所有可能的密码，编写代码逐一调用函数，直至成功。

2.2 拓展：“深浅拷贝”

在生成密码列表的时候，需要对数字/字母进行排列组合，此时利用itertools可以方便的生成。

nums = [str(i) for i in range(10)]
password_lst = itertools.permutations(nums, 2)  # 生成2位数字的所有排列，不重复

这里有2个需要注意的地方，第一个是permutations()生成的是不重复的“排列”，故上述代码生成的列表只有90个元素。

正确的姿势应该是用product()。

itertools官方文档

第二个，生成的密码列表password_lst实际上是一个迭代器，对他进行去长度实际上是遍历了一次，这时他指向最后一个元素，生命周期已然耗尽。故我们在获取长度时需要复制一个新的迭代器。

重点来了，这里涉及到深浅拷贝的问题。简单的赋值操作是浅拷贝，只是传地址，新的变量仍然指向password_lst而不是独立的。

要实现深拷贝需要用到copy模块

import copy

# 获取迭代器长度
def get_length(generator):
    if hasattr(generator,"__len__"):
        return len(generator)
    else:
        return sum(1 for _ in generator)

nums = [str(i) for i in range(10)]
password_lst = itertools.permutations(nums, 2)
new_lst = copy.deepcopy(password_lst)
length = get_length(new_lst)

还有一种方法，直接遍历一遍password_lst并将所有元素加入到空列表。这样做的好处是方便求长度。下面的代码都会采用这种方法。

nums = [str(i) for i in range(10)]
password_lst = [''.join(x) for x in itertools.product(*[nums] * 2)]
length = len(password_lst)

2.3 多线程提高效率

为了提高破解速度，还可以加入多线程，而且使用线程池(ThreadPoolExecutor)，方便管理、重复利用资源。

但是在实验过程中还发现一个问题：ThreadPoolExecutor默认使用的是无界队列，尝试密码的速度跟不上生产密码的速度，会把生产任务无限添加到队列中，导致内存被占满，最终导致程序崩溃。

此处不做展示，请自行测试。

要解决这个问题，可以重写ThreadPoolExecutor类，给队列设置一个最大值，使无界队列变成有界。

代码如下

展开/隐藏代码

import zipfile
import itertools
from concurrent.futures import ThreadPoolExecutor
import queue

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) # 设置队列大小


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


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



flag = True

# 创建一个线程池，参数为最大工作数
pool = BoundedThreadPoolExecutor(4)


#密码构成，字母或数字；若含有其他符号，则需修改
nums = [str(i) for i in range(10)]
chrs = [chr(i) for i in range(65, 91)]

# 生成数字4位数密码
password_lst = [''.join(x) for x in itertools.product(*[nums] * 4)]#此处数字4可换为其他所知道的密码位数


# 创建文件句柄
zfile = zipfile.ZipFile("test.zip", 'r')# 此处压缩包名称可换，格式可为zip或7z格式，不可为rar格式，其他格式未测试
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)

# 关闭资源，防止内存泄露
zfile.close()
pool.shutdown(wait=True)  # 等待所有线程完成

2.3.1 测试

下面来测试一下。

创建一个测试文件test.txt，并压缩成test.zip，设置密码为1234

运行程序

可以看到已经解压成功了

2.4 进度条+用时(两种方案)

2.4.1 ①子线程打印

进度条功能需要实时监控当前已完成数量，并且与生成的密码列表长度进行比对。因为主线程在不断遍历生成的密码列表，并且不断将新任务放入线程池，故不可能使用主线程进行。而线程池使用队列的形式，不可能让一个线程占用太长时间，否则后面就会卡住进行不下去。

在这种情况下，只能使用最原始的多线程方式threading开始一个子线程。threading有两种写法，这里我选择的是重写Tread类，并在run方法里写上要运行的代码。

class myThread (threading.Thread):   #继承父类threading.Thread
    def __init__(self, name, length):
        threading.Thread.__init__(self)
        self.name = name
        self.length = length
    def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
        global flag,process
        while True:
            if not flag: return
            percent = process / self.length * 100
            print(f"\r当期进度：{process} - {percent}%", end="")

效果

完整代码如下

展开/隐藏代码

import zipfile
import itertools
from concurrent.futures import ThreadPoolExecutor
import queue
import threading
import time


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) # 设置队列大小


class myThread (threading.Thread):   #继承父类threading.Thread
    def __init__(self, name, length):
        threading.Thread.__init__(self)
        self.name = name
        self.length = length
    def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
        global flag,process
        last_time = time.time()
        number = 0
        while True:
            time.sleep(0.1)
            p = process
            if not flag: return
            percent = p / self.length * 100
            current_time = time.time()
            speed = (p-number)/(current_time-last_time)
            number = p
            last_time = current_time
            print("\r已完成：%d/%d - %.2f"%(p,self.length,percent)+"%  "+"速度：%.2fp/s"%(speed), end="")
            # 未找到密码
            if (p >= self.length) and flag:
                print('\n未找到密码')
                return


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


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



flag = True

# 创建一个线程池
pool = BoundedThreadPoolExecutor(4)

# 进度
process = 0


#密码构成，字母或数字；若含有其他符号，则需修改
nums = [str(i) for i in range(10)]
chrs = [chr(i) for i in range(65, 91)]

# 生成数字+字母的4位数密码
password_lst = [''.join(x) for x in itertools.product(*[nums+chrs] * 4)]


# 创建进度显示线程
process_bar = myThread(name='process_bar',length=len(password_lst))
process_bar.setDaemon(True)   # 守护线程
process_bar.start()


# 创建文件句柄
zfile = zipfile.ZipFile("before/test.zip", 'r')# 此处压缩包名称可换，格式可为zip或7z格式，不可为rar格式，其他格式未测试
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)

# 关闭资源，防止内存泄露
zfile.close()
pool.shutdown(wait=True)  # 等待所有线程完成

# 等待子线程退出
process_bar.join()

2.4.2 ②tqdm第三方库

2.4.2.1 快速开始

安装

pip install tqdm

示例

from tqdm import tqdm
import time

for i in tqdm(range(6)):
    time.sleep(0.5)

输出

2.4.2.2 应用

只需将tqdm写在主线程的for循环上即可

for pwd in tqdm(password_lst):
    if not flag: break
    f = pool.submit(extract, zfile, pwd)
    f.pwd = pwd
    f.pool = pool
    f.add_done_callback(result)

效果：

2.5 封装

至此，程序搭建成功。

下面可以进行封装，方便调用。

完整代码如下

展开/隐藏代码

import zipfile
import itertools
import queue
import threading
import time
import sys
from concurrent.futures import ThreadPoolExecutor
from tqdm import tqdm


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) # 设置队列大小


class BreakZip():
    def __init__(self, srcpath, despath):
        self.srcpath = srcpath  # 原文件路径
        self.despath = despath  # 目标目录
        self.zfile = None
        self._check_file()  # 校验文件
        self.flag = True  # 标志位
        self.process = 0  # 进度
        self.pool = BoundedThreadPoolExecutor(2)  # 创建一个线程池
        self.password_lst = []  # 密码本
        self._gen_pwd_lst()  # 生成密码本
        self.length = len(self.password_lst)
        self.lock = threading.Lock()  # 同步锁

    def _check_file(self):
        try:
            # 创建文件句柄
            self.zfile = zipfile.ZipFile(self.srcpath, 'r')  # 此处压缩包名称可换，格式可为zip或7z格式，不可为rar格式，其他格式未测试
        except Exception as e:
            print(e)
            sys.exit()

    def set_pwd_lst(self, password_lst):
        self.password_lst = password_lst
        self.length = len(self.password_lst)

    def _gen_pwd_lst(self):
        # 密码构成，字母或数字；若含有其他符号，则需修改
        nums = [str(i) for i in range(10)]
        chrs = [chr(i) for i in range(65, 91)]
        # 生成数字+字母的4位数密码
        self.password_lst = [''.join(x) for x in itertools.product(*[nums + chrs] * 2)]

    def _extract(self, password):
        if not self.flag: return
        with self.lock:
            self.process += 1
        self.zfile.extractall(path=self.despath, pwd=''.join(password).encode('utf-8'))

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


    def start(self):
        # 遍历密码本，进度条显示
        for pwd in tqdm(self.password_lst):
            if not self.flag: break
            f = self.pool.submit(self._extract, pwd)
            f.pwd = pwd
            f.pool = self.pool
            f.add_done_callback(self._result)

        # 关闭资源，防止内存泄露
        self.zfile.close()
        self.pool.shutdown(wait=True)  # 等待所有线程完成
        # 未找到密码
        if self.flag:
            print('\n未找到密码')
            return



def gen_pwd_lst():
    
    # 密码构成，字母或数字；若含有其他符号，则需修改
    nums = [str(i) for i in range(10)]
    chrs = [chr(i) for i in range(65, 91)]
    # 生成数字+字母的4位数密码
    password_lst = [''.join(x) for x in itertools.product(*[nums + chrs] * 4)]
    return password_lst



if __name__ == '__main__':
    srcpath = 'before/test.zip'
    despath = 'after'
    password_lst = gen_pwd_lst()
    breakzip = BreakZip(srcpath,despath)
    breakzip.set_pwd_lst(password_lst)
    breakzip.start()

上面的密码本生成和文件路径都是写死的，所以除此之外，还可以通过输入来获取以上信息。而且还加入了第三方库filetype用来判断文件类型。

完整代码如下

展开/隐藏代码

import zipfile
import itertools
import queue
import threading
import time
import filetype
import os
import sys
import re
from concurrent.futures import ThreadPoolExecutor
from tqdm import tqdm


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) # 设置队列大小



class BreakZip():
    def __init__(self, srcpath, despath):
        self.srcpath = srcpath  # 原文件路径
        self.despath = despath  # 目标目录
        self.zfile = None
        self._check_file()  # 校验文件
        self.flag = True  # 标志位
        self.process = 0  # 进度
        self.pool = BoundedThreadPoolExecutor(2)  # 创建一个线程池
        self.password_lst = []  # 密码本
        self._gen_pwd_lst()  # 生成密码本
        self.length = len(self.password_lst)
        self.lock = threading.Lock()  # 同步锁

    def _check_file(self):
        try:
            # 创建文件句柄
            self.zfile = zipfile.ZipFile(self.srcpath, 'r')  # 此处压缩包名称可换，格式可为zip或7z格式，不可为rar格式，其他格式未测试
        except Exception as e:
            print(e)
            sys.exit()

    def set_pwd_lst(self, password_lst):
        self.password_lst = password_lst
        self.length = len(self.password_lst)

    def _gen_pwd_lst(self):
        # 密码构成，字母或数字；若含有其他符号，则需修改
        nums = [str(i) for i in range(10)]
        chrs = [chr(i) for i in range(65, 91)]
        # 生成数字+字母的4位数密码
        self.password_lst = [''.join(x) for x in itertools.product(*[nums + chrs] * 2)]

    def _process_bar(self):
        last_time = time.time()
        number = 0
        while True:
            time.sleep(0.1)
            p = self.process
            if not self.flag: return
            percent = p / self.length * 100
            current_time = time.time()
            speed = (p - number) / (current_time - last_time)
            number = p
            last_time = current_time
            print("\r已完成：%d/%d - %.2f" % (p, self.length, percent) + "%  " + "速度：%.2fp/s" % (speed), end="")
            # 未找到密码，退出
            if (p >= self.length) and self.flag:
                return


    def _extract(self, password):
        if not self.flag: return
        with self.lock:
            self.process += 1
        self.zfile.extractall(path=self.despath, pwd=''.join(password).encode('utf-8'))

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


    def start(self):
        # 遍历密码本
        for pwd in tqdm(self.password_lst):
            if not self.flag: break
            f = self.pool.submit(self._extract, pwd)
            f.pwd = pwd
            f.pool = self.pool
            f.add_done_callback(self._result)

        # 关闭资源，防止内存泄露
        self.zfile.close()
        self.pool.shutdown(wait=True)  # 等待所有线程完成
        # 未找到密码
        if self.flag:
            print('\n未找到密码')
            return


def get_input_info():
    # 获取文件、目录路径
    while True:
        srcpath = str(input('请输入要破解的压缩包位置(绝对/相对路径)：'))
        despath = str(input('请输入要保存的位置(回车默认文档名字目录)：'))
        if despath == '':
            despath = srcpath.replace('.zip', '\\')
        # 校验文件
        try:
            kind = filetype.guess(srcpath)
            if kind is None:
                print('Cannot guess file type!')
                continue
            elif kind.extension != 'zip' and '7z':
                print('Is not a zip or 7z file')
                continue
        except Exception as e:
            print(e)
            continue
        break
    # 检查输出目录
    if not os.path.isdir(despath):
        os.mkdir(despath)
    # 获取密码相关信息
    nums = [str(i) for i in range(10)]  # 数字
    hchrs = [chr(i) for i in range(65, 91)]  # 大写字母
    lchrs = [chr(i) for i in range(97, 123)]  # 小写字母
    spes = [chr(i) for i in range(20, 48)]+[chr(i) for i in range(91, 97)]+[chr(i) for i in range(123, 127)]  # 特殊字符
    type_all = [chr(i) for i in range(32, 127)]  # 所有
    wordstype_all = [nums,lchrs,hchrs,spes]
    words = []
    # 密码范围
    print('请指定密码可能涉及的字符:')
    print('1.数字')
    print('2.小写英文字母')
    print('3.大写英文字母')
    print('4.特殊字符')
    print('5.所有可打印字符')
    print('6.自由组合')
    while True:
        wordstype = input('>>')
        if wordstype == '1':
            words = nums
        elif wordstype == '2':
            words = lchrs
        elif wordstype == '3':
            words = hchrs
        elif wordstype == '4':
            words = spes
        elif wordstype == '5':
            words = type_all
        elif wordstype == '6':
            comwords = input('请指定组合类型（如2,1或3,4）：')
            comlist = re.split(',|，',comwords)
            print(comlist)
            for i in comlist:
                words += wordstype_all[int(i) - 1]
        else:
            print('非法输入，请重试',end='')
            continue
        break
    # 密码长度
    while True:
        wordsnum = input('请输入长度：')
        if wordsnum.isdigit():
            wordsnum = int(wordsnum)
            break
        else:
            print('非法输入，请重试')

    password_lst = [''.join(x) for x in itertools.product(*[words] * wordsnum)]
    return (srcpath,despath,password_lst)


if __name__ == '__main__':
    srcpath, despath, password_lst = get_input_info()
    breakzip = BreakZip(srcpath,despath)
    breakzip.set_pwd_lst(password_lst)
    breakzip.start()
    

效果如下（绿色字体为手动输入）

3. 破解rar

3.1 环境配置

安装unrar模块

pip install unrar

下载安装 unrar library（按照默认路径）

http://www.rarlab.com/rar/UnRARDLL.exe

（注：下面都是以win64位演示）

配置环境变量

系统变量中新建变量，变量名输入 UNRAR_LIB_PATH，变量值为 C:Files (x86).dll

进入目录C:Files (x86)64修改下文件名

重启pycharm

3.2 快速开始

将test.txt压缩成test.rar，密码设置为123，运行代码

from unrar import rarfile


file = rarfile.RarFile('test.rar')  #这里写入的是需要解压的文件，别忘了加路径
file.extractall(path='.', pwd='123')  #这里写入的是你想要解压到的文件夹

解压成功

需要注意的是，与zipfile不同，此处extractall()的pwd不需要encode转码，该方法会自动转码。

3.3 多线程

待续。。。