1:

a56b8e7uzx + 1 = a56b8e7uzy                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

function DezToX(dez, bas: Cardinal): String;
const
zahlen: array[0..15] of Char =
  ('0', '1', '2', '3', '4', '5', '6', '7',
   '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
begin
If (Bas>16) OR (bas<2) Then Begin
   MessageDlg('Unzulässige Zahlenbasis:'+IntToStr(bas),mtWarning,[mbOK],0);
   Abort; // Damit auch Nachfolgende Routinen abgebrochen werden
End;
if dez <> 0 then
  Result := DezToX(dez div bas, bas) + zahlen[dez mod bas]
else
  Result := '';
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

type
  TPWLaenge = 0..12;  //maximal 12 Zeichen

procedure GeneriereKombinationen(const aRekursion: TPWLaenge;
                               const aPasswort: String): Boolean;
var
  i: Char;
begin
  i := #0;  //#0 markiert ein Stringende, bracuht imho nciht durchlaufen werden
  if aRekursion <> 0 then begin
    repeat
      Inc(i);
      result := GeneriereKombinationen(Pred(aRekursion), aPasswort + i);
    until i = #255;
  end else begin  //letzte Rekursionsstufe, nun ausprobieren.
    repeat
      Inc(i);
      result := ProbiereAus(aPasswort + i);
    until i = #255;
  end;
end;

procedure KnackePasswort();
var
  i: Integer;
begin
  for i := 0 to 12 do begin  //iterative Tiefensuche probiert nach und nach längere Passwörter
    if GeneriereKombinationen(i, '') then
      break;  //Fertig, PW geknackt.
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:

var 
  Jump     : Integer;     // Wird benötigt um das nächste Zeichen im String zu erhöhen wenn das vorherige an der Grenze ankommt.
  Str      : String;      // Zeichenkette die "bearbeitet" wird
  StPos    : Integer;     // Zähler für Rekursion
  pwLength : Integer;     // Länge des Passwortes
  Spectrum : Integer;     // Anzahl möglicher Zeichen
  CombList : TStringList; // Hier werden alle Kombinationen gelistet
...
procedure TBruteForcer.GenerateCombinations;
var i : integer;
begin
 StPos := 0;
 Str   := '';
 for i := 1 to pwLength do Str:=Str + chr(1);
 CombList.Add(Str);
 Step;
end;
procedure TBruteForcer.Step;
begin
 inc(Stpos,1);
 jump := 0;
 Compare;
 CombList.Add(Str);
 if StPos < power(Spectrum,pwLength)-1 then
  Step;
end;
procedure TBruteForcer.Compare;
begin
 if ord(Str[pwLength-jump]) < Spectrum then Str[pwLength-jump]:=chr(ord(Str[pwLength-jump])+1) // erhöht den Asciiwert um 1 wenn inerhalb der Grenze 
 else
 if jump < pwLength then
 begin
  Str[pwLength-jump]:=chr(1);
  inc(jump,1);
  Str[pwLength-jump]:=chr(ord(Str[pwLength-jump])+1);
  Compare;
 end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:

var
  combs : Comp;
  digits : integer;
  characters : integer;
  position : int64;
  rest : integer;
  count : integer;
  limit : integer;
  DateTime1 : TDateTime;
  DateTime2 : TDateTime;
  Ziit : Comp;

begin
  { TODO -oUser -cConsole Main : Insert code here }

  //write('Anzahl Stellen: ');readln(digits);
  //write('Anzahl Zeichen: ');readln(characters);
  //combs:=power(characters,digits);
  write('Anzahl Kombinationen: ');readln(combs);
  DateTime1 := Time;
  position:=0;
  count:=0;
  limit:=(characters+1)*100;
  rest:=100-characters;
  repeat
     repeat
        repeat
        inc(count);
        inc(position);
        until count = characters;
        inc(position,rest);
        count:=0;
     until position = limit;
     inc(position,((rest-1)*100));
  until position = combs;
  writeln(combs);
  DateTime2 := Time;
  ziit := DateTime2-DateTime1;
  writeln(ziit);
  readln;
end.                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

int length;        // Current length

void init()
{
  word[0] = 'A' - 1;    // Start with "A"
  word[length = 1] = 0;
}

void generate()
{
  int i;

  i = length - 1;      // Start from the last character
  while (++word[i] > 'Z')    // Try to increase it
  if (i)        // Overflow here, any more positions?
    word[i--] = 'A';  // Yes, move to the left, and repeat
  else        // No
  if (length < 7) {
    word[i = ++length] = 0;  // Switch to the next length
    while (i--)
      word[i] = 'A';
    return;
  } else {
    word = 0; return;  // We're done
  }
}

void restore()
{
  length = 0;      // Calculate the length
  while (word[length]) length++;
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

var
  Start: Cardinal;
begin
  Start := GetTickCount;

  // Tue was

  ShowMessage(IntToStr(GetTickCount - Start) + ' ms');
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

procedure Gen();
var
  X, Y, Len: Integer;
  Wort: Array[0..10] of Byte;
begin
  Len := 0;

  for X := 0 to 10 do
    Wort[X] := ord('A') - 1;

  for X := 0 to 100 do
  begin
    Y := 0;
    inc(Wort[0]);

    while Wort[Y] > Ord('Z') do
    begin
      inc(Wort[Y + 1]);
      Wort[Y] := ord('A');
      inc(Y);

      Len := max(Y, Len);
    end;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

procedure Gen();
var
  X, Y, Len: Integer;
  Wort: Array[0..10] of Char;
begin
  Len := 0;

  for X := 0 to 10 do
    Wort[X] := Chr(Ord('A') - 1);

  for X := 0 to 100 do
  begin
    Y := 0;
    inc(Wort[Y]);

    while Wort[Y] > 'Z' do
    begin
      inc(Wort[Y + 1]);
      Wort[Y] := 'A';
      inc(Y);

      Len := max(Y, Len);
    end;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

procedure Gen();
var
  X, Y, Len: Integer;
  Wort: Array[0..10] of Char;     //Erstellt einen Array, welcher 11 Characters beinhaltet
begin
  Len := 0;

  for X := 0 to 10 do
    Wort[X] := Chr(Ord('A') - 1); //Wandelt in ASCII-Wert um, zieht 1 ab, und wieder zurück
                                  //A entspricht 65, wieso geht man hier auf 64 zurück? 64=@
  for X := 0 to 100 do            //Wieso muss dies genau 100 mal durchgeführt werden?
  begin
    Y := 0;
    inc(Wort[Y]);                 //Was geschieht, wenn man einen Array um 1 erhöht?

    while Wort[Y] > 'Z' do        //Wann ist ein Buchstaben grösser als der andere?
    begin
      inc(Wort[Y + 1]);
      Wort[Y] := 'A';             //Wieso wird die Position im Array zu A überschrieben?
      inc(Y);

      Len := max(Y, Len);         // Wofür wird überhaupt Len benötigt?
    end;
  end;
end;                    

1:

//A entspricht 65, wieso geht man hier auf 64 zurück? 64=@                    

1:

//Wieso muss dies genau 100 mal durchgeführt werden?                    

1:

//Was geschieht, wenn man einen Array um 1 erhöht?                    

1:

//Wann ist ein Buchstaben grösser als der andere?                    

1:

//Wieso wird die Position im Array zu A überschrieben?                    

1:

// Wofür wird überhaupt Len benötigt?                    

1:
2:
3:
4:
5:
6:

Tmp := '';  // Tmp = String

for X := Len downto 0  do
  Tmp := Tmp + Wort[X];

Form1.Memo1.Lines.Add(Tmp);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

procedure Gen();  
var  
  X, Y:  Integer;  
  Wort:  String;     // Direkt String
  fChar: PChar;
begin  
  SetLength(Wort, 1);         // String = 1 Zeichen lang
  fChar  := @Wort[1];         // Pointer auf den 1. Char --> schneller Zugriff
  fChar^ := Chr(Ord('A') - 1);

  for X := 0 to 100 do  
  begin  
    Y := 1;  
    inc(fChar^);  
 
    while Wort[Y] > 'Z' do  
    begin  
      inc(Y);

      if Y > Length(Wort) then
      begin
        SetLength(Wort, Y);     // Eventuell String verlängern
        Wort[Y] := 'A';
      end
      else
        inc(Wort[Y]);

      Wort[Y - 1] := 'A';
    end;  
  end;  
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

function Gen();
var
  X, Y:  Integer;
  Signs: Array of Char;
  Wort:  Array of PChar;
  Temp:  String;
begin
  Temp := 'abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
  SetLength(Signs, Length(Temp) + 2);
  CopyMemory(@Signs[1], @Temp[1], Length(Signs));

  Signs[0] := #0;
  Signs[High(Signs)] := #0;

  SetLength(Wort, 1);
  Wort[0] := @Signs[0];

  for X := 0 to 1000 do
  begin
    Y := 0;
    inc(Wort[Y]);

    while Wort[Y]^ = #0 do
    begin
      Wort[Y] := @Signs[1];
      inc(Y);

      if Y > Length(Wort) - 1 then
      begin
        SetLength(Wort, Y + 1);
        Wort[Y] := @Signs[1];
      end
      else
        inc(Wort[Y]);
    end;
  end;
end;                    

1:
2:
3:
4:
5:

   Temp := '';
   for Y := 0 to High(Wort) do
      Temp := Temp + Wort[Y]^;

    SList.Add(Temp);