python 破解zip\rar压缩文件的密码

原理说明 程序分成两个py文件,
一个利用 itertools 标准库,用生成器生成密码,解决密码文件占用过多内存的问题。
一个用多进程+多线程来百分百利用CPU进行密码历遍。

解压 zip 文件用到 zipfile 标准库, 解压 rar 文件用到 rarfile 库,需用 pip install rarfile 进行安装。
其中 rar 库需要调用 UnRAR.exe 文件,该文件在 winRAR 安装目录中,只要把这个文件拷贝到代码目录中就可以了。如果没有这个文件,运行时会报错提示 UnRAR 未安装。

这是打包好,可直接运行的的破解软件

首先创建 generate_pass_word.py 文件

from itertools import chain, product, permutations, combinations_with_replacement


class Generate_pass_word:
    def __init__(self):
        self.num = [str(i) for i in range(0, 10)]
        self.lower_letter = 'abcdefghijklmnopqrstuvwxyz'
        self.upper_letter = self.lower_letter.upper()
        self.simple_char = '@#$&%^*!'
        self.minority_char = ",./?;:\'\"\\|,。;:”“‘~·`()(){}[]【】"

    def num_password_1_6(self, n=6):  # 生成1~6位数的数字密码组合。
        num_password = ''
        for i in range(1, n + 1):
            num_password = chain(num_password, product(self.num, repeat=i))
        for i in num_password:
            yield ''.join(i)

    def num_password_n(self, n):  # 生成n位数的数字密码组合。
        num_password = product(self.num, repeat=n)
        for i in num_password:
            yield ''.join(i)

    def low_letter_password_1_6(self, n=6):  # 生成1~6位数的小写字母密码组合。
        low_letter_password = ''
        for i in range(1, n + 1):
            low_letter_password = chain(low_letter_password, product(self.lower_letter, repeat=i))
        for i in low_letter_password:
            yield ''.join(i)

    def low_letter_password_n(self, n):  # 生成n位数的小写字母密码组合。
        low_letter_password = product(self.lower_letter, repeat=n)
        for i in low_letter_password:
            yield ''.join(i)

    def upper_letter_password(self, n=6):  # 生成1~6位数的大写字母密码组合。
        for i in self.low_letter_password_1_6(n):
            yield i.upper()

# =================  所有字符的密码组合  ======================
    def all_letter_password_1_4(self, simple=True):      # 由数字、字母、字符组成的 1到4位 密码。
        dic = {'num': self.num,
               "lower_letter": self.lower_letter,
               "upper_letter": self.upper_letter,
               "char": self.simple_char,
               }
        if simple:
            pass
        else:
            dic['char'] = self.simple_char + self.minority_char

        gene_password_1 = self.simple_char + self.minority_char     # 1 位数密码

        gene_password_2 = ''                                    # 2 位数密码
        group = []         # 存放密码类型的组成
        for i in combinations_with_replacement(dic.keys(), 2):  # 先有放回的取出两种类型的密码。
            for r in permutations(i):                           # 对取出的密码进行排列组合。
                group.append(r)
        pass_group = set(group)                                 # 去除重复项。
        pass_group.discard(('num', 'num'))                      # 去除纯数字和纯字母的。
        pass_group.discard(('lower_letter', 'lower_letter'))
        pass_group.discard(('upper_letter', 'upper_letter'))
        for i in pass_group:
            x, y = i
            gene_password_2 = chain(gene_password_2, product(dic[x],dic[y]))

        gene_password_3 = ''
        group = []  # 存放密码类型的组成
        for i in combinations_with_replacement(dic.keys(), 3):  # 先有放回的取出两种类型的密码。
            for r in permutations(i):  # 对取出的密码进行排列组合。
                group.append(r)
        pass_group = set(group)  # 去除重复项。
        pass_group.discard(('num',)*3)  # 去除纯数字和纯字母的。
        pass_group.discard(('lower_letter',)*3)
        pass_group.discard(('upper_letter',)*3)
        for i in pass_group:
            x, y, z = i
            gene_password_3 = chain(gene_password_3, product(dic[x], dic[y], dic[z]))

        gene_password_4 = ''
        group = []  # 存放密码类型的组成
        for i in combinations_with_replacement(dic.keys(), 4):  # 先有放回的取出两种类型的密码。
            for r in permutations(i):  # 对取出的密码进行排列组合。
                group.append(r)
        pass_group = set(group)  # 去除重复项。
        pass_group.discard(('num',)*4)  # 去除纯数字和纯字母的。
        pass_group.discard(('lower_letter',)*4)
        pass_group.discard(('upper_letter',)*4)
        for i in pass_group:
            x, y, z, n = i
            gene_password_4 = chain(gene_password_4, product(dic[x], dic[y], dic[z], dic[n]))

        for i in chain(gene_password_1,gene_password_2,gene_password_3,gene_password_4):
            yield ''.join(i)

    def all_letter_password_n(self, n, simple=True,):      # 由数字、字母、字符组成的 n 位密码。
        dic = {'num': self.num,
               "lower_letter": self.lower_letter,
               "upper_letter": self.upper_letter,
               "char": self.simple_char,
               }
        if simple:
            pass
        else:
            dic['char'] = self.simple_char + self.minority_char
        for i in combinations_with_replacement(dic.keys(), n):         # 先有放回的取出 n 种类型的密码。
            g = set(permutations(i))               # 先对n种类型密码排列组合,然后去除排列组合中的重复项。
            g.discard(('num',) * n)                   # 去除纯数字的组合,discard()即使去除元素不存在,也不报错。
            g.discard(('lower_letter',) * n)       # 去除纯小写字母的组合。
            g.discard(('upper_letter',) * n)      # 去除纯大写字母的组合。
            for i in g:                                        # 历遍组合。
                for r in product(*[dic[d] for d in i]):  
                    yield ''.join(r)

创建 运行文件 unpack.py

from zipfile import is_zipfile, ZipFile
from rarfile import is_rarfile, RarFile, RarCRCError
from multiprocessing import Manager, Pool, freeze_support, cpu_count
from itertools import chain, cycle
from threading import Thread
import os, time
from generate_pass_word import Generate_pass_word


def unpack(flg, password, read_path, save_path):
    if is_zipfile(read_path):                                  # 先判断该文件是不是zip压缩文件。
        compress_file = ZipFile(read_path)
        while flg.run:
            try:    
                pwd = next(password)      # 获取一个密码。
                # print(pwd)
                compress_file.extractall(path=save_path, pwd=pwd.encode('utf-8'))      # 密码需要编码
                print(f'\n解压密码为:{pwd}')
                with open(os.path.join(save_path, '密码.txt'), 'w') as f:
                    f.write(f'解压密码为:{pwd}')
                compress_file.close()
                flg.run = False
            # except BadZipFile as e:
            #     flg.run = False
            #     print('11压缩文件损坏, 程序退出……', e)
            except StopIteration:
                break
            except Exception as e:
                pass
                #print(e, f'  {pwd}')
                
    else:                       # 判断该文件是不是rar压缩文件。
        compress_file = RarFile(read_path)
        while flg.run:
            try:    
                pwd = next(password)                          # 获取一个密码。
                # print(pwd)
                compress_file.extractall(path=save_path, pwd=pwd)        # 密码不需要编码。
                print(f'\n解压密码为:{pwd}')
                with open(os.path.join(save_path, '密码.txt'), 'w') as f:
                    f.write(f'解压密码为:{pwd}')
                compress_file.close()
                flg.run = False
            except RarCRCError:
                flg.run = False
                print('压缩文件损坏, 程序退出……')
            except StopIteration:
                break
            except Exception as e:
                pass
                # print(e)


def process_num(flg, dict_file):
    # print('process_num  已运行')
    read_path = dict_file['read_path']
    save_path = dict_file['save_path']
    g = Generate_pass_word()
    gen_pwd_1_6 = g.num_password_1_6()
    gen_pwd_7_8 = chain(g.num_password_n(7), g.num_password_n(8))
    gen_pwd_9 = g.num_password_n(9)
    gen_pwd_10 = g.num_password_n(10)
    t1 = Thread(target=unpack, args=(flg, gen_pwd_1_6, read_path, save_path))
    t2 = Thread(target=unpack, args=(flg, gen_pwd_7_8, read_path, save_path))
    t3 = Thread(target=unpack, args=(flg, gen_pwd_9, read_path, save_path))
    t4 = Thread(target=unpack, args=(flg, gen_pwd_10, read_path, save_path))
    t1.start()
    t2.start()
    t3.start()
    t4.start()
    t1.join()
    t2.join()
    t3.join()
    t4.join()


def process_letter(flg, dict_file):
    # print('process_letter  已运行')
    read_path = dict_file['read_path']
    save_path = dict_file['save_path']
    g = Generate_pass_word()
    let_pwd_1_6 = g.low_letter_password_1_6()
    let_pwd_7_8 = chain(g.low_letter_password_n(7), g.low_letter_password_n(8))
    let_pwd_9 = g.low_letter_password_n(9)
    let_pwd_10 = g.low_letter_password_n(10)
    let_up_pwd = g.upper_letter_password()
    t1 = Thread(target=unpack, args=(flg, let_pwd_1_6, read_path, save_path))
    t2 = Thread(target=unpack, args=(flg, let_pwd_7_8, read_path, save_path))
    t3 = Thread(target=unpack, args=(flg, let_pwd_9, read_path, save_path))
    t4 = Thread(target=unpack, args=(flg, let_pwd_10, read_path, save_path))
    t5 = Thread(target=unpack, args=(flg, let_up_pwd, read_path, save_path))
    t1.start()
    t2.start()
    t3.start()
    t4.start()
    t5.start()
    t1.join()
    t2.join()
    t3.join()
    t4.join()
    t5.join()


def process_mixture_1_8(flg, dict_file):
    # print('process_mixture_1_8  已运行')
    read_path = dict_file['read_path']
    save_path = dict_file['save_path']
    g = Generate_pass_word()
    pwd_1_4 = g.all_letter_password_1_4()
    pwd_5_6 = chain(g.all_letter_password_n(5), g.all_letter_password_n(6))
    pwd_7 = g.all_letter_password_n(7)
    pwd_8 = g.all_letter_password_n(8)
    t1 = Thread(target=unpack, args=(flg, pwd_1_4, read_path, save_path))
    t2 = Thread(target=unpack, args=(flg, pwd_5_6, read_path, save_path))
    t3 = Thread(target=unpack, args=(flg, pwd_7, read_path, save_path))
    t4 = Thread(target=unpack, args=(flg, pwd_8, read_path, save_path))
    t1.start()
    t2.start()
    t3.start()
    t4.start()
    t1.join()
    t2.join()
    t3.join()
    t4.join()


def process_mixture_9_10(flg, dict_file):
    # print('process_mixture_9_10  已运行')
    read_path = dict_file['read_path']
    save_path = dict_file['save_path']
    g = Generate_pass_word()
    pwd_9 = g.all_letter_password_n(9)
    pwd_10 = g.all_letter_password_n(10)
    t1 = Thread(target=unpack, args=(flg, pwd_9, read_path, save_path))
    t2 = Thread(target=unpack, args=(flg, pwd_10, read_path, save_path))
    t1.start()
    t2.start()
    t1.join()
    t2.join()


def schedule(flg):
    for i in cycle(['|', '/', '—', '\\']):
        if flg.run:
            print(f'{i} {i} {i} {i} {i} {i}', flush=True, end='')
            time.sleep(0.6)
            print('\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b', flush=True, end='')
        else:
            print('\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b', flush=True, end='')
            break


if __name__ == '__main__':
    freeze_support()
    print('该程序可破解10位之内的密码。\n联系:[email protected]')
    path = input('\n请输入压缩文件的完整路径名:\n>>> ')
    read_path = os.path.abspath(path)
    print(read_path)

    if not os.path.exists(read_path) or (not is_zipfile(read_path) and not is_rarfile(read_path)):
        print('该文件不是ZIP、ARA压缩文件!\n\
        程序 3秒后 退出……')
        time.sleep(3)
        os._exit(1)

    # 先创建一个存放的目录。
    dir_path = os.path.dirname(path)
    file_name = os.path.basename(path)
    save_path = os.path.join(dir_path, file_name.split('.')[0])
    dict_file = {'read_path': read_path,
                 'dir_path': dir_path,
                 'file_name': file_name,
                 'save_path': save_path}

    if not os.path.isdir(save_path):
        os.makedirs(save_path)

    Flg = Manager().Namespace()
    Flg.run = True
    print(f'{time.ctime()} 开始对 《{file_name}》 进行密码破解,请等待……')
    Thread(target=schedule, args=(Flg,), daemon=True).start()

    if cpu_count() <= 4:
        cpu_num = cpu_count()
    else:
        cpu_num = 4
    pool = Pool(processes=cpu_num)
    pool.apply_async(process_num, args=(Flg, dict_file))
    pool.apply_async(process_letter, args=(Flg, dict_file))
    pool.apply_async(process_mixture_1_8, args=(Flg, dict_file))
    pool.apply_async(process_mixture_9_10, args=(Flg, dict_file))
    pool.close()
    pool.join()
    if not Flg.run:
        print('\n解压密码保存在 密码.txt 文件中。\n')
        print('单击右上角 X,退出程序。')
        time.sleep(300)
    print('程序结束。')
    time.sleep(3)

你可能感兴趣的:(技术分享)