Passwort Entschlüsseln

[gammatester]

Zitat von Movementroboter:

Kann es sein das U5r5klO0zwu674593 das Salz ist ?

Kann sein, aber Du brauchst trotzdem einen Schlüssel (wenn wirklich verschlüsselt wird). Edit: Glaube eher nicht, da das Salz ja immer verschieden sein sollte, nicht nur ein einziges.

Wie schon man angedeutet, kann es aber auch sein, daß gar nicht verschlüsselt wird, sondern Salz und SHA1(passwort) gespeichert werden.

Ohne genaue Angaben, was eigentlich gemacht wird, hast Du kaum eine Chance. Kennst Du denn zumindest die Datenbankstruktur? Vielleicht kann man daraus etwas mehr Informationen ableiten.

[Sir Rufo]

Wenn man einen Blick auf das DEC wirft

Zitat von Movementroboter:

... habe mich ein bisschen mit dem Delphi Encryption Compendium 5 auseinander gesetzt.

dann sollte einem doch auch die Datei Example.txt ins Auge springen.

Und bis auf die Tatsache, dass dort mit with warum auch immer das Lesen und Verstehen des Codes erschwert wird, ist dort aber genau das enthalten, was hier benötigt wird.

Delphi-Quellcode:

var
  ACipherClass: TDECCipherClass = TCipher_Rijndael;
  ACipherMode: TCipherMode = cmCBCx;
  AHashClass: TDECHashClass = THash_Whirlpool;
  ATextFormat: TDECFormatClass = TFormat_Mime64;
  AKDFIndex: LongWord = 1;

function Encrypt( const AText: String; const APassword: String ): String; overload;
function Decrypt( const AText: String; const APassword: String ): String; overload;

Damit das Verstehen besser wird habe ich mal dieses with entfernt und die Parameter mit Kommentaren versehen.

Delphi-Quellcode:

program dp_182529;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  DECUtil, DECCipher, DECHash, DECFmt;

var
  ACipherClass: TDECCipherClass = TCipher_Rijndael;
  ACipherMode: TCipherMode = cmCBCx;
  AHashClass: TDECHashClass = THash_Whirlpool;
  ATextFormat: TDECFormatClass = TFormat_Mime64;
  AKDFIndex: LongWord = 1;

function Encrypt( const AText: String; const APassword: String ): String;
var
  LSalt: Binary;
  LData: Binary;
  LPass: Binary;
  LCipher: TDECCipher;
begin
  LCipher := ValidCipher(
    { CipherClass } ACipherClass ).
  { > } Create;
  try
    LSalt := RandomBinary( 16 );
    LPass := ValidHash(
      { HashClass } AHashClass ).
    { > } KDFx(
      { Data } APassword[1],
      { DataSize } Length( APassword ) * SizeOf( APassword[1] ),
      { Seed } LSalt[1],
      { SeedSize } Length( LSalt ),
      { MaskSize } LCipher.Context.KeySize,
      { Format } TFormat_Copy,
      { Index } AKDFIndex );
    LCipher.Mode := ACipherMode;
    LCipher.Init( LPass );
    SetLength( LData, Length( AText ) * SizeOf( AText[1] ) );
    LCipher.Encode(
      { Source } AText[1],
      { Dest } LData[1],
      { DataSize } Length( LData ) );
    Result := ValidFormat(
      { FormatClass } ATextFormat ).
    { > } Encode(
      { Value } LSalt + LData + LCipher.CalcMAC );
  finally
    LCipher.Free;
    ProtectBinary( LSalt );
    ProtectBinary( LData );
    ProtectBinary( LPass );
  end;
end;

function Decrypt( const AText: String; const APassword: String ): String;
var
  LSalt: Binary;
  LData: Binary;
  LCheck: Binary;
  LPass: Binary;
  LLen: Integer;
  LCipher: TDECCipher;
begin
  LCipher := ValidCipher(
    { CipherClass } ACipherClass ).
  { > } Create;
  try
    LSalt := ValidFormat(
      { FormatClass } ATextFormat ).
    { > } Decode(
      { Value } AText );
    LLen := Length( LSalt ) - 16 - LCipher.Context.BufferSize;
    LData := System.Copy( LSalt, 17, LLen );
    LCheck := System.Copy( LSalt, LLen + 17, LCipher.Context.BufferSize );
    SetLength( LSalt, 16 );
    LPass := ValidHash(
      { HashClass } AHashClass ).
    { > } KDFx(
      { Data } APassword[1],
      { DataSize } Length( APassword ) * SizeOf( APassword[1] ),
      { Seed } LSalt[1],
      { SeedSize } Length( LSalt ),
      { MaskSize } LCipher.Context.KeySize,
      { Format } TFormat_Copy,
      { Index } AKDFIndex );
    LCipher.Mode := ACipherMode;
    LCipher.Init(
      { Key } LPass );
    SetLength( Result, LLen div SizeOf( AText[1] ) );
    LCipher.Decode(
      { Source } LData[1],
      { Dest } Result[1],
      { DataSize } LLen );
    if LCheck <> LCipher.CalcMAC
    then
      raise Exception.Create( 'Invalid data' );
  finally
    LCipher.Free;
    ProtectBinary( LSalt );
    ProtectBinary( LData );
    ProtectBinary( LCheck );
    ProtectBinary( LPass );
  end;
end;

procedure Main;
var
  LText: string;
  LPass: string;
begin
  LText := 'The quick brown fox jumps over the lazy dog';
  LPass := 'U5r5klO0zwu674593';

  Writeln( 'Encode Test: ', Encrypt( LText, LPass ) );
  Writeln( 'Decode Test: ', Decrypt( Encrypt( LText, LPass ), LPass ) );
end;

begin
  try
    Main;
  except
    on E: Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

Mit der Basis müsste man jetzt auch weiterkommen ...

[cookie22]

Die Angaben des Lehrers sind überhaupt nicht ausreichend.

Es wird weder angegeben, in welchem Modus verschlüsselt wird.

CBC, ECB, CTR, OCB, CFB oder was? Soll er das raten oder wie?

Wozu dient der Hash Algo? Wird er in einer KDF verwedet?

Wenn ja welche? KDFx oder KDF2?

Da zu raten ist völlige Zeitverschwendung. Der Lehrer muss sich klar ausdrücken und alle wichtigen Informationen liefern.

[Dejan Vu]

-- Hier stand etwas persönliches, das man auch per PN übermitteln kann--

[Insider2004]

Das ist ja wieder zum Kugeln! Kann es sein, dass Dein Lehrer etwas überfordert ist? Was soll das Ganze für ein Schmarrn sein? Was ist überhaupt das Lernziel?

[Movementroboter]

Ich habe neue Informationen

Delphi-Quellcode:

ACipherClass: TDECCipherClass = TCipher_Rijndael;
  ACipherMode: TCipherMode = cmCBCx;
  AHashClass: TDECHashClass = THash_Whirlpool;
  ATextFormat: TDECFormatClass = TFormat_Mime64; //MIME64 = BASE64 ? 
  AKDFIndex: LongWord = 1;
Padding = Hat er keine Ahnung von :evil:

APass := ValidHash(AHashClass).KDFx(APassword[1], Length(APassword) * SizeOf(APassword[1]), ASalt[1], Length(ASalt), KeySize, TFormat_Copy, AKDFIndex); Habe bereits nach der WhirlPool Library für Visual Studio geschaut aber ich glaube das was ich da gefunden habe ist nicht passend oder ?

Zitat von cookie22:

Die Angaben des Lehrers sind überhaupt nicht ausreichend.

Es wird weder angegeben, in welchem Modus verschlüsselt wird.

CBC, ECB, CTR, OCB, CFB oder was? Soll er das raten oder wie?

Wozu dient der Hash Algo? Wird er in einer KDF verwedet?

Wenn ja welche? KDFx oder KDF2?

Da zu raten ist völlige Zeitverschwendung. Der Lehrer muss sich klar ausdrücken und alle wichtigen Informationen liefern.

[Sir Rufo]

Zitat von Movementroboter:

Ich habe neue Informationen

Delphi-Quellcode:

ACipherClass: TDECCipherClass = TCipher_Rijndael;
ACipherMode: TCipherMode = cmCBCx;
AHashClass: TDECHashClass = THash_Whirlpool;
ATextFormat: TDECFormatClass = TFormat_Mime64;
AKDFIndex: LongWord = 1;

Na dann frisch ans Werk. Alles was du brauchst, steht hier im Thread.

BTW Es wäre sehr freundlich von dir, wenn du Quelltext auch in die Code-Tags packst.

Code:

[DELPHI]
// Hier jetzt DELPHI-Quelltext rein
[/DELPHI]

[cookie22]

Er weiß wirklich nicht was Padding ist? Vielleicht sollte er sich erst mal mit Kryptographie beschäftigen, bevor er versucht sie anderen beizubringen.

Mit VS und C# hat das Ganze nun gar nichts zu tun. THash_Whirlpool ist eine Hash-Klasse aus dem DEC für Delphi mit dem du ja arbeitest.

Sir Rufo hat ja schon die Lösung gepostet.

[Sir Rufo]

Zitat von cookie22:

Er weiß wirklich nicht was Padding ist? Vielleicht sollte er sich erst mal mit Kryptographie beschäftigen, bevor er versucht sie anderen beizubringen.

Mit VS und C# hat das Ganze nun gar nichts zu tun. THash_Whirlpool ist eine Hash-Klasse aus dem DEC für Delphi mit dem du ja arbeitest.

Sir Rufo hat ja schon die Lösung gepostet.

Eigentlich habe ich (wie auch geschrieben) nur den Inhalt einer Datei hier reingeklatscht.

Somit stellt sich die Frage was der Lehrer wirklich damit vermitteln wollte: Hör genau zu und lies dir die Doku durch?
Den Test scheint er nicht bestanden zu haben

[cookie22]

Zitat von Sir Rufo:

Somit stellt sich die Frage was der Lehrer wirklich damit vermitteln wollte...

Das würde mich auch interessieren.