什么工具能将给定的几个单词的所有组合生成指定位数的字典？跑hashcat用
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了什么工具能将给定的几个单词的所有组合生成指定位数的字典？跑hashcat用相关的知识，希望对你有一定的参考价值。
四年前的一个密码忘记了，手动试了几个密码都没对上，萌生了用hashcat自动跑密码的想法。由于很清楚自己会使用哪些词组合成密码，所以基础词还是可以自己列出来的，加上0-9和部分特殊符号大约70个左右，例如这样的形式：
password
Password
PASSWORD
1100
121
*
&
以此类推...
另外密码的总位数不能超过20位，也在一定程度上限制了生成的有效密码总数。
官方Wiki对最新版hashcat的说明不是特别详细，没有找到能将这几十个基础词自动穷举出所有可能排列组合的命令参数，也找不到限定限定词组组合后位数的参数，只能寻找其他工具。
找了很多工具也只有“真空密码字典生成器2.51”能将一个单词作为生成的依据，其他只能设置一个字符。
但很遗憾，由于工具本身的bug，导入基础词字典时它会将一些拼写相同，但是大小写不同的词合并去重，比如apple、Apple、APPLE，导入后就只有一个apple或者三个词的其中一个，其他的两个都被舍弃了，这样组合成的字典自然不完整。
更要命的是无法指定组合后的密码位数，一些超长的无效密码也被搞出来了。
如果无法用上面的词组生成字典，就只能退而求其次用hashcat的暴力破解，需要加入所有的大写字母、小写字母、0-9数字、以及8个指定的特殊符号，然后指定密码位数。同样，因为wiki没有写清楚，只知道所有大小写字母和数字可以用?u?l?d来表示，但不知道如何加入7个指定的特殊符号，特别是像空格这种特殊符号。
各位大神有合适的工具给推荐一下，如果hashcat自带命令能完成当然最好。python啥的，并不会用...
kali内置 很好用的密码生成工具 功能强大
为给定的基数和位数生成所有可能的排列
【中文标题】为给定的基数和位数生成所有可能的排列【英文标题】：Generating all possible permutations for a given base and number of digits 【发布时间】：2012-05-03 21:05:53 【问题描述】：我确信这很简单，但我很难找到一种方法来做到这一点。本质上，如果我有一个包含 P 列和 V^P 行的数组，我该如何填写所有组合，也就是说，基本上，所有可能的数字都在 P 位的基数 V 中。例如，对于 P=3 和 V=2：
000
001
010
011
100
101
110
111
请记住，这是一个二维数组，而不是整数数组。
对于 P=4 和 V=3。
0000
0001
0002
0010
0011
0012
....
生成了这个数组后，我想要开发的其余工作就变得微不足道了。因此，非常感谢您提供一些有关如何执行此操作的代码/提示。谢谢。
【问题讨论】：
【参考方案1】：以 P=3 和 V=2 为例，在第一列中，您需要以下数字序列：
0, 0, 0, 0, 1, 1, 1, 1
所以你基本上需要四个 0，然后是四个 1。
在第二列中你需要：
0, 0, 1, 1, 0, 0, 1, 1
所以你想要两个 0 后跟两个 1，然后再跟一个。
一般情况下，在第n列，每个数字需要V^(P-n)，重复V^(n-1)次。
P=3 和 V=2 时的示例：
第 1 列：我们需要每个数字的 V^(P-n) = 2^(3-1) = 4，重复 V^(n-1) = 2^0 = 1 次：
[0, 0, 0, 0, 1, 1, 1, 1]
第2列：我们需要每个数字的V^(P-n) = 2^(3-2) = 2，重复V^(n-1) = 2^1 = 2次：
[0, 0, 1, 1], [0, 0, 1, 1]
第 3 列：我们需要每个数字的 V^(P-n) = 2^(3-3) = 1，重复 V^(n-1) = 2^2 = 4 次：
[0, 1], [0, 1], [0, 1], [0, 1]
生成此序列的一些 Python 代码：
def sequence(v, p, column):
subsequence = []
for i in range(v):
subsequence += [i] * v**(p - column)
return subsequence * v**(column - 1)
【讨论】：
【参考方案2】：基本上这是制作一个 vp 数字列表，从 0 到基数 v 中的最大数字宽度 p。 numpy.base_repr 可用于在 Python 中执行此操作：
from numpy import base_repr
def base_of_size(base, size):
for i in range(base ** size):
yield base_repr(i, base).rjust(size, "0")
此外，itertools.product(range(v), repeat=p) 是另一个可以完成这项工作的 Python 内置函数（结果证明效率最高——请参阅下面的基准测试）。
这是从 numpy.base_repr 转换为 C# 的算法（Convert.ToString() 对碱基非常有选择性）：
using System;
using System.Collections.Generic;
class Converter
public static IEnumerable<string> BaseOfSize(int baseN, int size)
for (int i = 0; i < Math.Pow(baseN, size); i++)
yield return BaseRepr(i, baseN).PadLeft(size, '0');
public static string BaseRepr(int n, int baseN)
string digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var res = new List<char>();
for (int num = Math.Abs(n); num > 0; num /= baseN)
res.Add(digits[num%baseN]);
if (n < 0) res.Add('-');
res.Reverse();
return string.Join("", res);
public static void Main(string[] args)
foreach (var n in BaseOfSize(2, 3))
Console.WriteLine(n);
Console.WriteLine();
foreach (var n in BaseOfSize(3, 4))
Console.WriteLine(n);
输出：
000
001
010
011
100
101
110
111
0000
0001
0002
0010
0011
0012
0020
...
2220
2221
2222
虽然 numpy 版本使用简单且可迭代，但速度也很慢。使用递归 DFS 方法意味着我们不必从头开始计算每个数字，而是可以简单地增加前一个数字，直到我们到达新的叶子。这些版本不使用生成器，但很容易调整：
Python：
def base_of_size(base, size):
def recurse(res, row, i=0):
if i >= size:
res.append(row[:])
else:
for j in range(base):
row[i] = j
recurse(res, row, i + 1)
return res
return recurse([], [None] * size)
C#：
using System;
using System.Collections.Generic;
class Converter
public static List<List<int>> BaseOfSize(int v, int p)
var res = new List<List<int>>();
BaseOfSize(v, p, 0, new List<int>(new int[p]), res);
return res;
private static void BaseOfSize(int v, int p, int i, List<int> row, List<List<int>> res)
if (i >= p)
res.Add(new List<int>(row));
else
for (int j = 0; j < v; j++)
row[i] = j;
BaseOfSize(v, p, i + 1, row, res);
快速基准测试（使用生成器）：
from itertools import product
from time import time
from numpy import base_repr
def base_of_size(base, size):
def recurse(res, row, i=0):
if i >= size:
yield row[:]
else:
for j in range(base):
row[i] = j
yield from recurse(res, row, i + 1)
return res
yield from recurse([], [None] * size)
def base_of_size2(base, size):
for i in range(base ** size):
yield base_repr(i, base).rjust(size, "0")
if __name__ == "__main__":
start = time()
list(base_of_size(10, 6))
end = time()
print("dfs:", end - start)
start = time()
list(base_of_size2(10, 6))
end = time()
print("base_repr:", end - start)
start = time()
list(product(range(10), repeat=6))
end = time()
print("product:", end - start)
输出：
dfs: 4.616123676300049
base_repr: 9.795292377471924
product: 0.5925478935241699
itertools.product 以远射获胜。
【讨论】：
这可行，但如果长度太大，我会得到堆栈溢出异常。有没有办法不用递归来实现？ 好的，添加了重写。这个版本如何为您工作？它更慢但迭代。还在思考这个问题。 是的，我看的越多，我就越不明白递归版本上的堆栈是如何溢出的。深度是p，它是指数，所以即使只有 2^30 也会给你 1073741824 个数字的结果，而 30 远不及堆栈限制。我不确定我是否可以在没有大量字符串连接或数组复制的情况下迭代地编写堆栈版本，也没有必要。如果是内存问题，也许生成器版本可以工作。
别担心。我搞砸了并传入了一个对 p 来说太大的值。它工作正常。【参考方案3】：
如果每个“数字”中有不同数量的选项，则可以使用此代码。
也许在某些优化工具中存在执行此操作的算法，因为它可能对蛮力方法有用。下面的代码添加了一个显示“最大数字的值”的列，可以忽略：
import numpy as np
val=np.arange(15)
options=[2,2,3]
print(val)
print(options)
opt = options + [1] # Assumes options to be a list
opt_cp = np.flip(np.cumprod(np.flip(np.array(opt))))
ret = np.floor_divide(val[:,np.newaxis], opt_cp[np.newaxis,:])
ret[:,1:] = np.remainder(ret[:,1:], np.array(opt[:-1])[np.newaxis,:])
inds = ret[:,1:]
print(inds)
【讨论】：
【参考方案4】：您还可以使用 numpy 的 N 维网格网格函数。
例如
np.mgrid[0:2,0:2,0:2].reshape((3, 8)).T
array([[0, 0, 0],
[0, 0, 1],
[0, 1, 0],
[0, 1, 1],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0],
[1, 1, 1]])
或
np.stack(np.meshgrid(range(2), range(2), range(2), indexing='ij')).reshape(3, -1).T
或者一般来说任何P、V：
np.mgrid[[slice(0, V)]*P].reshape((P, -1)).T
或
np.stack(np.meshgrid(*[range(V)]*P, indexing='ij')).reshape((P, -1)).T
一定有更明显的方法，但我想不出什么。
【讨论】：
以上是关于什么工具能将给定的几个单词的所有组合生成指定位数的字典？跑hashcat用的主要内容，如果未能解决你的问题，请参考以下文章