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++;
}