Generieren jede Zeichenkombination bis zu einer bestimmten Wortlänge

Ich mache eine Sicherheits-Präsentation für meine Computer-und Informationssicherheit Kurs in ein paar Wochen Zeit, und in dieser Präsentation werde ich zeigen, die vor-und Nachteile der verschiedenen Angriffe (dictionary, Regenbogen-und bruteforce). Ich bin tun, die Wörterbuch-und rainbow-Attacken gut, aber ich brauche zu generieren, die bruteforce-Attacke auf das Fliegen. Ich muss ein Algorithmus gefunden werden, lassen Sie mich-Zyklus, obwohl jede Kombination von Buchstaben, symbol und Zahl bis zu einer gewissen Zeichenlänge.

So als Beispiel für eine Zeichen-Länge von 12, die ersten und letzten paar Generationen werden:

a
ab
abc
abcd
...
...
zzzzzzzzzzzx
zzzzzzzzzzzy
zzzzzzzzzzzz

Aber es wird auch die Verwendung von zahlen und Symbolen, so ist es ziemlich schwer für mich zu erklären... aber ich denke, Sie bekommen die Idee. Verwenden Sie nur Zeichen aus der ASCII-Tabelle ist in Ordnung.

Ich kann die Art des Bildes mithilfe eines ASCII-Funktion zu tun, diese mit einem Zähler, aber ich kann es einfach nicht in meinen Kopf. Wenn jemand könnte einige source-code (ich werde wohl mit C#) oder auch einige pseudo-code, kann ich das Programm eine Funktion aus, die groß sein würde.

Vielen Dank im Voraus. 🙂

Ich denke, dass Sie Sie schon gefunden einer der Nachteile von einem brute-force-Angriff 🙂

InformationsquelleAutor Will | 2010-09-03

brute-force c#random

7

Einer rekursiven Funktion, lassen wir Sie laufen durch alle Kombinationen von ValidChars:
```
    int maxlength = 12;
    string ValidChars;
    private void Dive(string prefix, int level)
    {
        level += 1;
        foreach (char c in ValidChars)
        {
            Console.WriteLine(prefix + c);
            if (level < maxlength)
            {
                Dive(prefix + c, level);
            }
        }
    }
```
Weisen Sie den Satz der gültigen Zeichen ValidChars, die maximale Länge der Zeichenfolge, die Sie wollen, maxlength, dann rufen Sie Dive("", 0); und gehen Sie Weg.

Dein code sieht sehr ähnlich wie mir... ich werde versuchen zu tun, einen Vergleich zu suchen, einige Optimierungen
Die Routinen sind identisch in Bezug auf Leistung langen Stangen. Die string-concat mehr Zeit in Anspruch als die Frage, ob die rekursive Funktion geht ein oder zwei parms.
Der wesentliche Unterschied zwischen unseren Antworten ist, dass ich fertige mir 10 Minuten, bevor Sie. ;>
Ich wollte nicht, um wettbewerbsfähig zu sein, nur versuchen, zu untersuchen, die beste Lösung: ich fand, dass 1) ich habe nicht die Stoppuhr zurückzusetzen zwischen den anrufen zu beginnen, und 2) dein code return string 1 Zeichen größer als angegeben: wo man schreiben: if (level <= maxlength) sollte if (level < maxlength). Grüße
deins ist weniger flexibel, aber richtig. Ich habe die <= in eine < Danny ' s richtig.

InformationsquelleAutor dthorpe
5

Müssen Sie generieren alle Kombinationen von Zeichen aus einem Satz von gültigen Zeichen ; nennen wir dieses set validChars. Im Grunde genommen, jeder Satz der Kombinationen der Länge N ist ein Kartesisches Produkt von validChars mit sich selbst N-mal. Das ist ziemlich einfach zu tun, ist die Verwendung von Linq:
```
char[] validChars = ...;

var combinationsOfLength1 =
    from c1 in validChars
    select new[] { c1 };

var combinationsOfLength2 =
    from c1 in validChars
    from c2 in validChars
    select new[] { c1, c2 };

...

var combinationsOfLength12 =
    from c1 in validChars
    from c2 in validChars
    ...
    from c12 in validChars
    select new[] { c1, c2 ... c12 };

var allCombinations =
    combinationsOfLength1
    .Concat(combinationsOfLength2)
    ...
    .Concat(combinationsOfLength12);
```
Offensichtlich, Sie nicht wollen, um manuell den code schreiben, der für jede Länge, vor allem, wenn Sie nicht im Voraus wissen, die maximale Länge...

Eric Lippert hat einen Artikel zu erzeugen das kartesische Produkt von einer beliebigen Anzahl von Sequenzen. Mit der CartesianProduct Erweiterung Methode von dem Artikel, den Sie erzeugen kann, die alle Kombinationen der Länge N wie folgt:
```
var combinationsOfLengthN = Enumerable.Repeat(validChars, N).CartesianProduct();
```
Da Sie möchten, dass alle Kombinationen von Länge 1 zu MAX, Sie können etwas tun:
```
var allCombinations = 
    Enumerable
        .Range(1, MAX)
        .SelectMany(N => Enumerable.Repeat(validChars, N).CartesianProduct());
```
allCombinations ist ein IEnumerable<IEnumerable<char>>, wenn Sie wollen, um die Ergebnisse zu erhalten wie eine Sequenz von Zeichenfolgen, die Sie gerade brauchen, um hinzuzufügen, eine Projektion:
```
var allCombinations = 
    Enumerable
        .Range(1, MAX)
        .SelectMany(N => Enumerable.Repeat(validChars, N).CartesianProduct())
        .Select(combination => new string(combination.ToArray()));
```
Beachten Sie, dass es sicherlich nicht die effizienteste Lösung, aber es ist wenigstens kurz und lesbar...

Ist new string(combination.ToArray()) das gleiche wie String.Join("", combination).Net 4?
Es ist nicht das gleiche, aber es hat das gleiche Ergebnis. Als ich mit String.Beitreten, aber mit einem leeren Trenner es schien seltsam, und ich denke, die performance ist besser mit den String-Konstruktor, da haben wir schon eine Folge von Zeichen

InformationsquelleAutor Thomas Levesque

Können Sie versuchen, diesen code, die Rekursion zu drucken, alle möglichen Zeichenfolgen von 0 bis stringsLenght chars Länge, die sich durch alle Kombination von chars aus firstRangeChar zu lastRangeChar.

class BruteWriter
{
    static void Main(string[] args)
    {
        var bw = new BruteWriter();
        bw.WriteBruteStrings("");
    }

    private void WriteBruteStrings(string prefix)
    {
        Console.WriteLine(prefix);
        if (prefix.Length == stringsLenght)
            return;

        for (char c = firstRangeChar; c <= lastRangeChar; c++)
            WriteBruteStrings(prefix + c);

    }

    char firstRangeChar='A';
    char lastRangeChar='z';
    int stringsLenght=10;


}

Dieser Blick, schneller zu sein als die Lösung von @dthorpe.Ich habe im Vergleich die algorthms mit diesem code:

class BruteWriter
    {
        static void Main(string[] args)
        {
            var st = new Stopwatch();
            var bw = new BruteWriter();
            st.Start();
            bw.WriteBruteStrings("");
            Console.WriteLine("First method: " + st.ElapsedMilliseconds);

            for (char c = bw.firstRangeChar; c <= bw.lastRangeChar; c++)
                bw.ValidChars += c;

            st.Start();
            bw.Dive("", 0);
            Console.WriteLine("Second method: " + st.ElapsedMilliseconds);

            Console.ReadLine();


        }

        private void WriteBruteStrings(string prefix)
        {
            if (prefix.Length == stringsLenght)
                return;

            for (char c = firstRangeChar; c <= lastRangeChar; c++)
                WriteBruteStrings(prefix + c);

        }

        char firstRangeChar='A';
        char lastRangeChar='R';
        int stringsLenght=5;



        int maxlength = 5;
        string ValidChars;
        private void Dive(string prefix, int level)
        {
            level += 1;
            foreach (char c in ValidChars)
            {
                if (level <= maxlength)
                {
                    Dive(prefix + c, level);
                }
            }
        }
    }

ist, und auf meinen pc, bekomme ich diese Ergebnisse:

First method: 247
Second method: 910

"Dieser Blick, schneller zu sein als die Lösung von @dthorpe": gut, Ihr habt nur vergessen, zum zurücksetzen der Stoppuhr zwischen den beiden tests, so dass offensichtlich die Letzte Methode getestet wird scheinbar immer langsamer 😉
Doh! was für ein missverstehen

InformationsquelleAutor Andrea Parodi

public void BruteStrings(int maxlength)
{
   for(var i=1;i<i<=maxlength;i++)
      BruteStrings(Enumerable.Repeat((byte)0,i));

}

public void BruteStrings(byte[] bytes)
{
   Console.WriteLine(bytes
                       .Cast<char>()
                       .Aggregate(new StringBuilder(), 
                          (sb,c) => sb.Append(c))
                       .ToString());

   if(bytes.All(b=>b.MaxValue)) return;

   bytes.Increment();

   BruteStrings(bytes);
}

public static void Increment(this byte[] bytes)
{
   bytes.Last() += 1;

   if(bytes.Last == byte.MinValue)
   {
      var lastByte = bytes.Last()
      bytes = bytes.Take(bytes.Count() - 1).ToArray().Increment();
      bytes = bytes.Concat(new[]{lastByte});
   }
}

Hast du es testen ? Ich glaube nicht, dass Cast<char>() funktionieren wird, wie bereits erläutert, here
Nicht getestet. Wenn Sie Cast() funktioniert nicht, das byte kann umgewandelt werden in die Aggregate-Funktion, oder in einer Select(b=>(char)b) da der andere thread schon sagt.

InformationsquelleAutor KeithS

Andere alternative, die ich habe, die einen string zurückgeben.

Ich kümmerte sich nicht um die Leistung von dem Ding, denn es war nicht für eine Reale Welt Szenario.

private void BruteForcePass(int maxLength)
    {
        var tempPass = "";
        while (tempPass.Length <= maxLength)
        {
            tempPass = GetNextString(tempPass);//Use char from 32 to 256
            //Do what you want
        }
    }

    private string GetNextString(string initialString, int minChar= 32, int maxChar = 256)
    {
        char nextChar;
        if (initialString.Length == 0)
        {
            nextChar = (char)minChar;//the initialString Length will increase
        }
        else if (initialString.Last() == (char)maxChar)
        {
            nextChar = (char)minChar;
            var tempString = initialString.Substring(0, initialString.Length -1);//we need to increment the char just before the last one
            initialString = GetNextString(tempString, minChar, maxChar); 
        }
        else
        {
            nextChar = (char)(initialString.Last() + 1);//Get the lash Char and increment it;
            initialString= initialString.Remove(initialString.Length - 1);//Remove the last char.
        }
        return initialString + nextChar;
    }

InformationsquelleAutor Guish

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.