C# 4.0 并行蛮力算法

因此，我开始好奇，在一台功能强大的台式计算机上，不同的散列可以以多快的速度被强制执行，并试图对其进行测试

不过，我看到的大多数算法都是单线程的，这让我想到，在使用c#4.0 Parallel.net/plink扩展和并发结构（如ConcurrentBag和IProducerConsumer）时，这将是一个非常有趣的挑战

因此，我的任务如下：使用并行化，构建n长度密码和字符集[x]的最高效/性能最强的bruteforce检查器，即生成给定字符集和长度的所有可能字符串，直到找到匹配项。假设至少有两个内核和合理数量的ram

我要亲自试一试，让最好的男/女获胜：）

编辑

第一次尝试，但没有比较性能和有限的范围和已知密码长度

    char[] chars = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };

    public long NrCombinations(int nrChars, int stringLength)
    {
        Func<long, int, long> power = null;
        power = (i, p) => p == 1 ? i : i * power(i, p - 1);

        return power(nrChars, stringLength);
    }


    public static bool StringArrayEquals(char[] a, char[] b)
    {
        if (a.Length != b.Length)
            return false;
        for (int i = 0; i < a.Length; i++)
        {
            if (!a[i].Equals(b[i]))
                return false;
        }
        return true;
    }

    public char[]  GenerateString(int i, int stringLength)
    {
        char[] current = new char[stringLength];
        for (int i = 0; i < stringLength; i++)
        {
            double remainder = i % this.chars.Length;   
            i = i / this.chars.Length;         
            current[i] = this.chars[(int) remainder];
        }
        return current;
    }

    public bool IsMatch(int i, char[] password)
    {
        return StringArrayEquals(GenerateString(i, password.Length), password);
    }

    private int GetMatching(string passwordString)
    {
        char[] password = passwordString.ToArray();
        int nrCombinations = (int)NrCombinations(this.chars.Length, password.Length);

        return ParallelEnumerable.Range(0, nrCombinations).WithDegreeOfParallelism(10).FirstOrDefault(i => IsMatch(i, password));

    }

char[]chars=新字符[]{'0'，'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'a'，'b'，'c'，'d'，'e'，'f'，'g'，'h'，'i'，'j'，'k'，'l'，'m'，'n'，'o'，'p'，'q'，'r'，'s'，'t'，'u'，'v'，'w'，'x'，'y'，'z'}；
公共长NRC组合（整数nrChars、整数stringLength）
{
Func power=null；
功率=（i，p）=>p==1？i:i*功率（i，p-1）；
返回功率（nrChars，stringLength）；
}
公共静态布尔字符串数组相等（字符[]a，字符[]b）
{
如果（a.长度！=b.长度）
返回false；
for（int i=0；iIsMatch（i，password））；
}

下一次尝试

使用ParallelEnumerable并不聪明，因为它的大小限制为int，所以您很快就需要至少长的时间，尽管我怀疑这会让您在使用大密码字符集时保持长时间。我猜你要么去比基特，要么在那之后开始分解它

    public long NrCombinations(int nrChars, int stringLength)
    {
        Func<long, int, long> power = null;
        power = (i, p) => p == 1 ? i : i * power(i, p - 1);

        return power(nrChars, stringLength);
    }


    public string GenerateString(long number, int sentenceLength)
    {
        char[] current = new char[sentenceLength];
        for (int i = 0; i < sentenceLength; i++)
        {
            double remainder = number % this.chars.Length;   
            number = number / this.chars.Length;         
            current[i] = this.chars[(int) remainder];
        }
        return new string(current);
    }

    public bool IsMatch(string hash, long  i, int passwordLength)
    {
        string generated = GenerateString(i, passwordLength);
        string hashed = GetMasterHash(generated, this.site);
        return string.Equals(hashed, hash);
    }

    private string GetMatching(string hash,int passwordLength)
    {
        string result = string.Empty;
        int stringlength = passwordLength;
        long  nrCombinations = NrCombinations(this.chars.Length, stringlength);
        long x = 0;

        Parallel.For(0, nrCombinations, (i, loopState) =>
        {
            if (IsMatch(hash,i, passwordLength))
            {
                x = i;
                loopState.Stop();
                return;
            }
        }); 


        if (x > 0)
        {
            result = this.GenerateString(x, passwordLength);
        }

        return result;

    }

public-long-nrChars组合（int-nrChars，int-stringLength）
{
Func power=null；
功率=（i，p）=>p==1？i:i*功率（i，p-1）；
返回功率（nrChars，stringLength）；
}
公共字符串生成器（长数字，int语句长度）
{
字符[]当前=新字符[句子长度]；
for（int i=0；i
{
if（IsMatch（散列，i，密码长度））
{
x=i；
loopState.Stop（）；
返回；
}
}); 
如果（x>0）
{
结果=此.GenerateString（x，密码长度）；
}
返回结果；
}

为什么使用

nr组合

方法而不仅仅是

long combinations = (long)Math.Pow(base, stringLength);

我还建议不要将

int

用于

nr组合

，因为基本36字母表中只有6个字符，你会遇到麻烦（36^6>2^31）。使用

long

。我不认为需要

biginger

，因为如果你需要大数字，暴力将不是一种选择

---

我的想法是，通过使用一种De Bruijn序列流，可以加速暴力。这似乎是合理的，但我必须重新开始，因为我现在没有代码要显示。

为什么使用

NrCombinations

方法，而不仅仅是

long combinations = (long)Math.Pow(base, stringLength);

我还建议不要将

int

用于

nr组合

，因为基本36字母表中只有6个字符，你会遇到麻烦（36^6>2^31）。使用

long

。我不认为需要

biginger

，因为如果你需要大数字，暴力将不是一种选择

---

我的想法是，通过使用一种De Bruijn序列流，可以加速暴力。看起来很合理，但我必须重新开始，因为我现在没有代码显示。

只是生成字符串组合。。通过散列运行这些代码总是可以添加到最上面。您可以为代码添加文档吗？：）只是生成字符串组合。。通过散列运行这些代码总是可以添加到最上面。您可以为代码添加文档吗？：）Math.Pow使用double，因此它不会对更大的数字进行缩放。是的，但是2^53对于暴力来说是非常重要的。你永远不会有太多的暴力；）数学。Pow使用双精度，所以它不会缩放