Zahlencode bruten

[cydo]

also. ich habs mal durchprobiert, aber das kann nicht sein. Bist Du dir mit der Lösungszahl sicher? Und dass der Bereich "a"-"z" ist? Habs auch grad mal mit "A"-"Z" probiert, aber beides mal kein Ergebnis. Bist Du mit dem Verschlüsselungsalgo sicher?

[cydo]

gleich nochmal: also hab alle durchprobiert im ASCII-Bereich 10-250, kein Erfolg. Der Verschlüsselungsalgo ist auch selten dämlich. Als Beispiel verschlüsselt man mal das Wort "delphi" (=1334092032000) ergibt das 1440 andere Worte, die auf das selbe Ergebnis passen (z.B. "dblhex").
Ich glaub Du hast Dich mit dem Algo vertan....

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  BigInt in 'BigInt.pas';

var
 loesungs: integer;
 bigint: TBigInt;


function Verschl(input: string): TBigint;
var
  i: integer;
  test: TBigint;
begin
  result := TBigInt.Create(ord(input[1]));
  for I := 2 to length(input) do
  begin
    test := TBigint.Create(ord(input[i]));
    result.mul(test);
    test.free;
  end;
end;


procedure Back(zahl: TBigint;pass: string);
var
  i: integer;
  test: TBigint;
  Divi: TBigint;
begin

  test := TBigInt.Create(1);
  if test.IsEqual(zahl) then
  begin
    writeln('Loesung: '+pass);
    inc(loesungs);
    test.Free;
    exit;
  end;
  test.Free;

  //for I := 10 to 250 do
  for I := 97 to 122 do
  begin
    divi := TBigInt.Create(i);
    test := TBigInt.Create(zahl);
    test.div_(divi);
    test.mul(divi);
    if test.IsEqual(zahl) then
    begin
      test.div_(divi);
      Back(test,pass+chr(i));
    end;
    test.free;
    divi.free;
  end;
end;

begin
  loesungs :=0;
  BigInt := Verschl('delphi');
  //BigInt := TBigInt.Create('219235317047744800000');
  Writeln('Suche Loesung zu ',BigInt.ToString);
  readln;
  Back(Bigint,'');
  writelN('ende');
  writeln(loesungs,' Loesungen');
  readln;
end.

[MrKnogge]

Zitat:

Zitat von cydo

Als Beispiel verschlüsselt man mal das Wort "delphi" (=1334092032000) ergibt das 1440 andere Worte, die auf das selbe Ergebnis passen

Dann ist es keine Verschlüsselung, sondern ein Hash.

[-=Breeze=-]

Großen Dank für die vielen Antworten :-D :dp:

Das eingegebene Passwort wird vor der Rechnung in Kleinbuchstaben umgewandelt, kann daher nur zwischen 97 und 122 liegen, außer vllt Zahlen, die ich bis jetzt noch nicht beachtet habe.

Code:

<alles zu Kleinbuchstaben>
for(i = 0; i < password.length; i++) {
passcode *= password.charCodeAt(i);
}
for(x = 0; x < username.length; x++) {
usercode *= username.charCodeAt(x);
}
if(usercode==<zahl>)&&passcode==219235317047744800000)
{
window.location=password+".htm"
}

Der username ging schnell (~2 Minuten), weil das eine recht kleine Zahl (ca 6 Buchstaben) ist. Das PW aber ist eine größere Zahl (10 Buchstaben) :wall: :wall: :wall:

Gesucht sei nach allen möglichen Variationen :shock:

@cydo: Könntest du kurz erläutern, wie ich den Code in mein Programm einbaue? :coder2:

[everdream]

Wenn du nur eine mögliche Lösung brauchst, dann würde ich dir vielleicht (rekursives) Backtracking ans Herz legen. Das ganze kombiniert mit der Ganzzahldivision div (weil du mehr ja hier nicht benötigst) sollte dir in akzeptabler Zeit eine Lösung liefern.

edit: Habe zu viel Zeit und dir darum mal den Code dafür geschrieben:

Delphi-Quellcode:

function rekBacktracking(Hash: Int64; Laenge{in Zeichen}: byte): shortstring;
var
  i: byte;
begin
  if (Laenge = 1) then 
  begin  // Beim letzten Zeichen der Reihe
    for i:=97 to 122 do
      if i=Hash then
        Result:= Char(i);
  end else
  begin  // Bei den Zeichen 1 bis Laenge-1
    for i:=97 to 122 do
    begin
      if (Hash mod i = 0) then
        Result:=Char(i) + rekBacktracking(Hash div i, Laenge-1);
    end;
  end;
end;

Beachte, dass nur die erste erfolgreiche Zeichenkette ausgegeben wird und dass die Zeichen mit dem größten ASCII-Wert dabei immer vorne stehen.

Wenn du die Abbruchbedingung etwas änderst, kannst du auch z.B. alle Lösungen nacheinander in ein Textfile oder Memo schreiben lassen, dann hast du nach ein bischen Rechenzeit vielleicht alle. Das ganze sollte jedenfalls schneller sein als deine For-to-Schleifen, weil nicht alle Kombinationen zuende gerechnet werden.

edit2: 9 Zeichen sind innerhalb eines Augenschlages berechnet. Auch 10 Zeichen sind in relativ kurzer Zeit entschlüsselt, allerdings reicht in diesem Bereich der Typ Int64 auch schon nicht mehr aus.

edit3: Habe das ganze aus Spaß auch nochmal für alle möglichen Lösungen geschrieben:

Delphi-Quellcode:

procedure TForm2.rekBacktracking(Text: string; Hash: extended; Laenge: byte);
var
  i: byte;
begin
  if (Laenge = 1) then
  begin
    for i:=97 to 122 do
    begin
      if i=Hash then
      begin
        Memo.Lines.Add(Text + Char(i));
        Inc(Counter);
      end;
    end
  end else
  begin
    for i:=97 to 122 do
    begin
      Application.ProcessMessages;
      if ((round(Hash) mod i = 0) and (Run)) then
        rekBacktracking(Text + Char(i), round(Hash) div i, Laenge-1);
    end;
  end;
end;

Für den Hash habe ich extended genommen, weil da 2 Bytes mehr drin sind als im Int64. Dafür muss ich ab und an mit round() rumkaspern.

Beispiel:
Der Hash 2001968049246036480 mit einer Wortlänge von 9 Zeichen (maximum, da bei 10 zeichen auch extended eventuell nicht mehr reicht):
181440 Möglichkeiten [abffpqrsz..zsrqpffba] wurden in 16,69 Sekunden berechnet und in das Memo eingetragen.

Ich hänge dir das Proggi inkl. Source mal an. Copyright kannste haben... :drunken:

Hoffe, dass ich dir damit helfen konnte.

Mein Tipp: Vom ASCII-Code der Zeichen erst 96 abziehen (nicht 97!), damit du Zahlen von 1 bis 26 inklusive multiplizierst. Dann reichen auch "normale" Datentypen aus, um den Hash zu speichern.

[alzaimar]

Ein klitzekleine Verschönerung vielleicht?

Delphi-Quellcode:

function rekBacktracking(Hash: Int64; Laenge{in Zeichen}: byte): shortstring;
var
  i: byte;

begin
  if (Laenge = 0) then
    Result := ''
  Else for i:=97 to 122 do
    if (Hash mod i = 0) then
      Result := Char(i) + rekBacktracking(Hash div i, Laenge-1);
end;

[cydo]

öhm. ich weiss ja nicht, ob es schon jemand aufgefallen ist: der von mir gepostete code macht rekursives backtracking mit bigint zahlen und ergibt als ergebnis: es gibt keine lösung zu der genannten zahl.

ausserdem kann "charCodeAt" auch unicode zurückliefern, damit ist der bereich dann wirklich nicht mehr 97-122 (oder wie von mir getestet 10-250).

http://developer.mozilla.org/en/docs...ing:charCodeAt
"Note that charCodeAt will always return a value that is less than 65,536"
ok, dann ist der Bereich also 2-65536 ;-)

@breezel:
der von mir gepostete code einfach in delphi reinkopieren (neu|konsolenanwendung) und die unit bigint noch mit ins verzeichnis packen (einfach hier mal nach "bigint" suchen (von F. Rienhardt).

gehts hier um eine japanische p**n-seite? dann liesse sich der unicode bereich einschränken;-)

[gammatester]

Zitat:

Zitat von cydo

öhm. ich weiss ja nicht, ob es schon jemand aufgefallen ist: der von mir gepostete code macht rekursives backtracking mit bigint zahlen und ergibt als ergebnis: es gibt keine lösung zu der genannten zahl.

ausserdem kann "charCodeAt" auch unicode zurückliefern, damit ist der bereich dann wirklich nicht mehr 97-122 (oder wie von mir getestet 10-250).

http://developer.mozilla.org/en/docs...ing:charCodeAt
"Note that charCodeAt will always return a value that is less than 65,536"
ok, dann ist der Bereich also 2-65536 ;-)

Ist mir schon aufgefallen, aber wie ich schon geschrieben habe, zeigt doch die Primzahlzerlegung

219235317047744800000 = 2^8 * 5^5 * 11 * 7321 * 3402964651

daß es selbst im vergrößerten Bereich kein Lösung gibt.

Gruß Gammatester

[cydo]

Zitat:

Ist mir schon aufgefallen, aber wie ich schon geschrieben habe, zeigt doch die Primzahlzerlegung

219235317047744800000 = 2^8 * 5^5 * 11 * 7321 * 3402964651

daß es selbst im vergrößerten Bereich kein Lösung gibt.

stimmt. noch einfacher. noch schlüssiger.

[everdream]

Zitat:

Zitat von cydo

der von mir gepostete code macht rekursives backtracking mit bigint zahlen

Dann kann der Threadstarter sich ja jetzt meinen Algorithmus (mit alzaimar's Verschönerdung :wink: ) schnappen, da dein BigInt reinhämmern und sollte dann eigentlich alles haben. Mit BigInt kann er dann ja auch mal über die 10 Zeichen hinaus versuchen, was noch so möglich ist.

Oder sind noch fragen offen?