bin Datei verschlüsseln und entschlüsseln

Gray85 · Hält's aus hier Beiträge: 3

Hallo Leute,

ich stehe gerade vor dem Problem, dass ich eine .bin-Datei verschlüsseln soll bevor sie Kunden als Download zur Verfügung gestellt bekommen. Anschließend soll die .bin-Datei in einem Programm geladen, entschlüsselt und direkt per Schnittstelle auf ein Gerät geladen werden. Leider habe ich aktuell keine Idee, wie ich die .bin-Datei ver- und entschlüsseln soll - immerhin kann ich die Datei ja nicht wie eine normale Textdatei behandeln?

Zum Verständnis wozu es gebraucht wird: Es soll verhindert werden, dass ein Kunde (theoretisch) die bin-Datei ausließt und so an die Programmierung für das Gerät, auf das sie geladen werden soll, kommt.

Ralf Jansen · Verfasst: Mi 09.01.19 12:58

Zitat:

immerhin kann ich die Datei ja nicht wie eine normale Textdatei behandeln?

Jede Datei ist einfach nur eine Folge von Bytes. Die Dateiendung ist nur hilfreich für einen anschließenden Benutzer damit er weiß wie die Bytes zu interpretieren sind. Aus der Sicht einer Verschlüsselung sind Bytes auch einfach nur Bytes egal wofür die gut sind oder was die in bestimmten Kontexten bedeuten. Der anschließende Benutzer muss nur wissen das die Verschlüsselt sind und was dann zu tun ist.

Was das für eine Datei ist kann für dich also egal sein.

Gray85 · Hält's aus hier Beiträge: 3

Ralf Jansen hat folgendes geschrieben :

Jede Datei ist einfach nur eine Folge von Bytes. Die Dateiendung ist nur hilfreich für einen anschließenden Benutzer damit er weiß wie die Bytes zu interpretieren sind. Aus der Sicht einer Verschlüsselung sind Bytes auch einfach nur Bytes egal wofür die gut sind oder was die in bestimmten Kontexten bedeuten. Der anschließende Benutzer muss nur wissen das die Verschlüsselt sind und was dann zu tun ist.

Was das für eine Datei ist kann für dich also egal sein.

Danke. Das würde dann bedeuten, dass man per Bitmanipulation die Datei verschlüsseln könnte?

Ich habe bisher versucht es so zu lösen:

markieren

Delphi-Quelltext

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:
42:
43:

procedure Tfrm_firmware_uebertragen.Codieren(klarText, codierterText : String); 
var
  infile, outfile : TextFile;
  key, ch : Char;
begin
  key := 'A';
  AssignFile(infile, klarText);
  Reset(infile);
  Assignfile(outfile, codierterText);
  Rewrite(outfile);

  while not Eof(infile) do
  begin
    Read(infile, ch);
    ch := Chr(Ord(key) Xor Ord(ch));
    Write(outfile, ch);
  end;

  CloseFile(infile);
  CloseFile(outfile);
end;

procedure Tfrm_firmware_uebertragen.Decodieren(codierterText, klarText : String);  
var
  infile, outfile : TextFile;
  key, ch : Char;
begin
  key := 'A';
  AssignFile(infile, codierterText);
  Reset(infile);
  AssignFile(outfile, klarText);
  Rewrite(outfile);

  while not Eof(infile) do
  begin
    read(infile, ch);
    ch := Chr(Ord(key) Xor Ord(ch));
    Write(outfile, ch);
  end;

  CloseFile(infile);
  CloseFile(outfile);
end;

Verwende ich die beiden Methoden dann auf eine .bin-Datei, verdoppelt sich die Größe der Datei dadurch.
Darf ich in diesem Fall kein TextFile verwenden? Falls ja, was wäre richtig?

Gausi · Verfasst: Mi 09.01.19 16:50

Als Suchbegriff werfe ich mal TStream bzw. TMemoryStream und TFileStream in den Raum. Das ist der übliche Weg, um auf beliebige Dateien mit beliebigem Inhalt zuzugreifen.

Deine Methode funktioniert nur, wenn in deiner .bin-Datei wirklich nur Strings drinstecken, und selbst dann wird es über die Verschlüsselung schwierig mit einigen nicht-druckbaren Zeichen. Das wird dann recht schnell unsauber bzw. kann sogar kaputt gehen.

Die Frage nach dem Sinn stellt sich aber hier irgendwie auch. Wenn die verschlüsselte Datei von dem Programm entschlüsselt wird, dann hat der Anwender ja auch theoretisch Zugriff darauf. Wenn der Anwender die Daten nicht einsehen darf, weil er dann etwas "geheimes" erfährt, was er nicht erfahren soll, ist vermutlich das Konzept überdenkenswert. Und wenn er die .bin-Datei nicht manipulieren darf, um mit dem Gerät etwas zu tun, was nicht beabsichtigt ist, dann wäre eine Signierung der bin-Datei der bessere Weg als eine Verschlüsselung (wobei das dann ein Henne-Ei-Problem wäre, weil der Code zur Überprüfung der Signatur ja auch erstmal aufs Gerät muss).

_________________
Oel ngati kameie.

Gray85 · Hält's aus hier Beiträge: 3

Gausi hat folgendes geschrieben :

Als Suchbegriff werfe ich mal TStream bzw. TMemoryStream und TFileStream in den Raum. Das ist der übliche Weg, um auf beliebige Dateien mit beliebigem Inhalt zuzugreifen.

Danke, ich werde mich da ein wenig einlesen!

Gausi hat folgendes geschrieben :

Die Frage nach dem Sinn stellt sich aber hier irgendwie auch. Wenn die verschlüsselte Datei von dem Programm entschlüsselt wird, dann hat der Anwender ja auch theoretisch Zugriff darauf. Wenn der Anwender die Daten nicht einsehen darf, weil er dann etwas "geheimes" erfährt, was er nicht erfahren soll, ist vermutlich das Konzept überdenkenswert. Und wenn er die .bin-Datei nicht manipulieren darf, um mit dem Gerät etwas zu tun, was nicht beabsichtigt ist, dann wäre eine Signierung der bin-Datei der bessere Weg als eine Verschlüsselung (wobei das dann ein Henne-Ei-Problem wäre, weil der Code zur Überprüfung der Signatur ja auch erstmal aufs Gerät muss).

Da die Datei zum Entschlüsseln nur gelesen, entschlüsselt und direkt, ohne sie in einer anderen Datei zwischen zu speichern, auf das Gerät geladen wird, dürfte es nicht so einfach werden Zugriff zu bekommen. Ich habe mir das Verschlüsseln der Datei als Ansatz nicht ausgesucht, sondern sie von der Firma für die ich das mache vorgegeben bekommen. Von daher kann hier gerne über die Sinnhaftigkeit diskutiert werden - mir hilft es halt leider nichts ^^°

GuaAck · Verfasst: Mi 16.01.19 12:37

Hallo,

ist das Thema noch aktuell? Ich hatte mal eine Klasse XTEAFilestream gemacht. Die ist von TFilestream abgeleitet, bei den Read- und Write-Operationen wird aber gleich ent- bzw. verschlüsselt. Mein Programm, was ich damit gemacht habe, nutze ich seit vielen Jahren ohne Probleme.

Kann den Code ggf. gerne posten.

Gruß
GuaAck

ub60 · Beiträge: 694 Erhaltene Danke: 92

GuaAck hat folgendes geschrieben :

...
Kann den Code ggf. gerne posten.

Da würde ich gern mal draufschauen :lol:

.

ub60

GuaAck · Verfasst: Do 17.01.19 22:13

Hallo,

der Quellcode im Anhang,

Gruß
GuaAck

Nachtrag, bevor sich eine Crypt-Experte meldet: Das XTEA-Verfahren habe ich nicht geprüft. Meine Anwendung ist nicht so kritisch, dass ich Angst vor professionellen "Crypt-Knackern" haben müsste. Es werden nie unverschlüsselte Daten auf der Festplatte abgelegt, (außer evtl. in der Windows Auslagerungsdatei, die aber heute ohnehin kaum gebraucht wird.)

Einloggen, um Attachments anzusehen!

ub60 · Beiträge: 694 Erhaltene Danke: 92

@GuaAck:
Danke erst mal für den Quelltext. XTEA scheint ja für den geringen Programmieraufwand ziemlich sicher zu sein.
Das Verschlüsseln einer Datei habe ich ja schon hinbekommen (hoffe ich

, zumindest wird eine Datei erzeugt. ), leider habe ich das Entschlüsseln nicht hinbekommen. Hättest Du da mal noch einen kleinen Code-Schnipsel (am Besten für Ver- und Entschlüsselung).

Danke!
ub60

Frühlingsrolle · Verfasst: So 20.01.19 10:34

Hier ist ein (C++) Beispiel dazu. Die Methode FileCrypt() kann sogar beides:

Zitat:

markieren

C++-Quelltext

1:
2:

FileCrypt("file.txt",true); // encrypt
FileCrypt("file.txt",false); // decrypt

Sie baut auf die Methoden encipher() und decipher() auf, die man auch unter Wikipedia nachlesen kann.
Frei übersetzt:

markieren

Delphi-Quelltext

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:
42:
43:
44:
45:
46:
47:
48:
49:

type
// "stdint.h"
// typedef unsigned int                uint32_t;
  uint32_t = UINT;  //... nur um zu verstehem, was mit "uint32_t" gemeint ist

  UInts2 = array[0..1] of uint32_t;
  UInts4 = array[0..3] of uint32_t;

procedure encipher(num_rounds: UINT; var v: UInts2; key: UInts4);
var
  i: UINT;
  v0, v1, sum, delta: uint32_t;
begin
  v0 := v[0];
  v1 := v[1];
  sum := 0;
  delta := $9E3779B9;

  for i := 0 to num_rounds - 1 do
  begin
    v0 := v0 + (((v1 shl 4) xor (v1 shr 5)) + v1) xor (sum + key[sum and 3]);
    sum := sum + delta;
    v1 := v1 + (((v0 shl 4) xor (v0 shr 5)) + v0) xor (sum + key[(sum shr 11) and 3]);
  end;

  v[0] := v0;
  v[1] := v1;
end;

procedure decipher(num_rounds: UINT; var v: UInts2; key: UInts4);
var
  i: UINT;
  v0, v1, sum, delta: uint32_t;
begin
  v0 := v[0];
  v1 := v[1];
  delta := $9E3779B9;
  sum := delta * num_rounds;

  for i := 0 to num_rounds - 1 do
  begin
    v1 := v1 - (((v0 shl 4) xor (v0 shr 5)) + v0) xor (sum + key[(sum shr 11) and 3]);
    sum := sum - delta;
    v0 := v0 - (((v1 shl 4) xor (v1 shr 5)) + v1) xor (sum + key[sum and 3]);
  end;

  v[0] := v0;
  v[1] := v1;
end;

Die Übersetzung des verlinkten Artikels schafft ihr auch ohne mich. :beer:

_________________
„Politicians are put there to give you the idea that you have freedom of choice. You don’t. You have no choice. You have owners. They own you. They own everything." (George Denis Patrick Carlin)

GuaAck · Verfasst: So 20.01.19 22:20

Hier im Anhang ein kleines Testprogramm.
Gruß
GuaAck

Einloggen, um Attachments anzusehen!

Frühlingsrolle · Verfasst: So 20.01.19 23:15

@ GuaAck

Die Klasse TFileStream besitzt, wie jede andere Klasse von TObject abgeleitet, einen Destruktor namens "Destroy".
Einen (neuen) Destruktor brauchst du daher garnicht anzulegen!
Wenn in deiner Klasse sowieso kein Objekt freigeben wird, brauchst du den Destruktor weder überschreiben noch irgendwo aufrufen.
Und vom Destruktor soll und darf man keine überladenen Methoden haben.

_________________
„Politicians are put there to give you the idea that you have freedom of choice. You don’t. You have no choice. You have owners. They own you. They own everything." (George Denis Patrick Carlin)

ub60 · Beiträge: 694 Erhaltene Danke: 92

@Frühlingsrolle, @GuaAck:
Danke erst mal für die Quelltexte. Das Verfahren steht ja z.B. in der Wikipedia gur beschrieben, das war nicht mein Problem.
Die Programme von Frühlingsrolle und GuaAck sind in C++ bzw. PHP. Ich würde gerne die Units von GuaAck in Delphi verwenden, erhalte aber leider keine schlüssigen Ergebnisse.
Hier mal zur Kontrolle mein Quelltext:

markieren

Delphi-Quelltext

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:

procedure TForm1.CryptBtnClick(Sender: TObject);
var FS: TFileStream;
    OutStream: TXTEAfilestream;
    Laenge: Integer;
begin
  FS := TFileStream.Create('original.txt', fmOpenRead);
  Laenge:=FS.Size;
  OutStream:=TXTEAFileStream.Create('geheim.dat', fmCreate);
  OutStream.setpasswort('Geheimpasswort');
  OutStream.WriteBuffer(FS, Laenge);
  OutStream.fill_and_flush;
  OutStream.Free;
  FS.Free;
end;

procedure TForm1.DecryptBtnClick(Sender: TObject);
var FS: TFileStream;
    InStream: TXTEAfilestream;
    Laenge: Integer;
    Buffer: array[0..63] of Byte;
begin
  InStream:=TXTEAFileStream.Create('geheim.dat', fmOpenRead);
  InStream.setpasswort('Geheimpasswort');
  Laenge:=InStream.Read(Buffer, 64);
  FS:=TFileStream.Create('neu.txt', fmCreate);
  FS.Write(Buffer, Laenge);
  InStream.Free;
  FS.Free;
end;

Das Verschlüsseln liegert bei einer kleinen Ausgangsdatei eine verschlüsselte Datei von 80 Byte (16 Byte Header+64 Byte verschlüsselter Puffer). Das war für mich plausibel.
Das Entschlüsseln liefert zwar eine Datei von 64 Byte Länge, aber der Inhalt entspricht nicht dem Original. Leider sehe ich meinen Fehler nicht. Deshalb die Bitte nach einem kleinen (Delphi-) Beispieltext.

ub60

GuaAck · Verfasst: Mo 21.01.19 11:34

Hallo,

Du musst den Inhalt(!) von original.txt erst in einen Buffer einlesen. Bei TFilestream gibt es auch die Methode Copyfrom, die habe ich aber nicht implementiert.

Gruß
GuaAck

markieren

Delphi-Quelltext

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

procedure TForm1.CryptBtnClick(Sender: TObject);
var FS: TFileStream;
    OutStream: TXTEAfilestream;
    Laenge: Integer;
    Buffer: array[0..63] of Byte; // <<<<

begin
  FS := TFileStream.Create('original.txt', fmOpenRead);
  Laenge:=sizeof(Buffer);// <<<<
  fs.ReadBuffer(Buffer, Laenge);// <<<<<<<<<
  OutStream:=TXTEAFileStream.Create('geheim.dat', fmCreate);
  OutStream.setpasswort('Geheimpasswort');
  OutStream.WriteBuffer(Buffer, Laenge);
  OutStream.fill_and_flush;
  OutStream.Free;
  FS.Free;
end;

Frühlingsrolle · Verfasst: Mi 23.01.19 07:31

Der etwas andere Ansatz:

markieren

Delphi-Quelltext

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:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:

unit ufrXTEA;

interface

uses
  Windows, Classes, SysUtils;

type
  TUInt2 = array[0..1] of UINT;
  TUInt4 = array[0..3] of UINT;

  TfrXTEA = class
  private
    FEncrypt, FIsStream: Boolean;
    FKey: TUInt4;
    FRounds: UINT;
    FStream: TFileStream;
    procedure SetEncrypt(Value: Boolean);
  protected
    procedure Decipher(Rounds: UINT; var V: TUInt2; Key: TUInt4);
    procedure Encipher(Rounds: UINT; var V: TUInt2; Key: TUInt4);
    procedure FileCrypt(Rounds: UINT; FileStream: TFileStream;
      Key: TUInt4; Encrypt: Boolean); overload;
    procedure FileCrypt(FileStream: TFileStream; Encrypt: Boolean); overload;
  public
    constructor Create;
    destructor Destroy; override;
    procedure LoadFromFile(const FileName: string);
    procedure LoadFromStream(FileStream: TFileStream);
    property Encrypt: Boolean read FEncrypt write SetEncrypt;
    property Rounds: UINT read FRounds write FRounds;
    property Key: TUInt4 read FKey write FKey;
  end;

function UInt4(const A, B, C, D: UINT): TUInt4;

implementation

procedure TfrXTEA.SetEncrypt(Value: Boolean);
begin
  FileCrypt(FStream, Value);
  FEncrypt := Value;
end;

procedure TfrXTEA.Decipher(Rounds: UINT; var V: TUInt2; Key: TUInt4);
var
  v0, v1, sum, delta, i: UINT;
begin
  v0 := v[0];
  v1 := v[1];
  delta := $9E3779B9;
  sum := delta * Rounds;

  for i := 0 to Rounds - 1 do
  begin
    v1 := v1 - ((((v0 shl 4) xor (v0 shr 5)) + v0) xor (sum + key[(sum shr 11) and 3]));
    sum := sum - delta;
    v0 := v0 - ((((v1 shl 4) xor (v1 shr 5)) + v1) xor (sum + key[sum and 3]));
  end;

  v[0] := v0;
  v[1] := v1;
end;

procedure TfrXTEA.Encipher(Rounds: UINT; var V: TUInt2; Key: TUInt4);
var
  v0, v1, sum, delta, i: UINT;
begin
  v0 := v[0];
  v1 := v[1];
  sum := 0;
  delta := $9E3779B9;

  for i := 0 to Rounds - 1 do
  begin
    v0 := v0 + ((((v1 shl 4) xor (v1 shr 5)) + v1) xor (sum + key[sum and 3]));
    sum := sum + delta;
    v1 := v1 + ((((v0 shl 4) xor (v0 shr 5)) + v0) xor (sum + key[(sum shr 11) and 3]));
  end;

  v[0] := v0;
  v[1] := v1;
end;

procedure TfrXTEA.FileCrypt(Rounds: UINT; FileStream: TFileStream;
  Key: TUInt4; Encrypt: Boolean);
const
  BLOCK_SIZE = 8;
var
  fileSize, filePos, nBlocks, i: UINT;
  fileData: array[0..BLOCK_SIZE - 1] of Byte;
begin
  fileSize := fileStream.Size;
  FileStream.Position := 0;
  filePos := FileStream.Position;

  nBlocks := fileSize div BLOCK_SIZE;
  if fileSize mod BLOCK_SIZE <> 0 then
    nBlocks := nBlocks + 1;

  for i := 0 to nBlocks - 1 do
  begin
    ZeroMemory(@fileData, SizeOf(fileData));

    FileStream.Position := filePos;
    FileStream.Read(fileData[0], BLOCK_SIZE);

    if Encrypt then
      Encipher(Rounds, TUInt2(fileData), Key) else
      Decipher(Rounds, TUInt2(fileData), Key);

    FileStream.Position := filePos;
    FileStream.Write(fileData[0], BLOCK_SIZE);

    filePos := filePos + BLOCK_SIZE;
  end;
end;

procedure TfrXTEA.FileCrypt(FileStream: TFileStream; Encrypt: Boolean);
begin
  FileCrypt(FRounds, FileStream, FKey, Encrypt);
end;

constructor TfrXTEA.Create;
begin
  inherited;
  FEncrypt := true;
  FKey := UInt4($ACED, $BABE, $DEAF, $FACE);
  FRounds := 32;
end;

destructor TfrXTEA.Destroy;
begin
  if Assigned(FStream) and (not FIsStream) then
    FStream.Free;
  inherited;
end;

procedure TfrXTEA.LoadFromFile(const FileName: string);
begin
  FIsStream := false;
  if Assigned(FStream) then
    FStream.Free;
  FStream := TFileStream.Create(FileName, fmOpenReadWrite);
end;

procedure TfrXTEA.LoadFromStream(FileStream: TFileStream);
begin
  FIsStream := true;
  FStream := FileStream;
end;

function UInt4(const A, B, C, D: UINT): TUInt4;
begin
  result[0] := A;
  result[1] := B;
  result[2] := C;
  result[3] := D;
end;

end.

Beispiel:

markieren

Delphi-Quelltext

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:

// Variante 1
var
  frXTEA: TfrXTEA;
  filePath: string;
begin
  filePath := 'D:\geheim.dat';
  frXTEA := TfrXTEA.Create;
  try
    frXTEA.LoadFromFile(filePath);
    frXTEA.Encrypt := CheckBox1.Checked;
  finally
    frXTEA.Free;
  end;
end;

// Variante 2
var
  frXTEA: TfrXTEA;
  stream: TFileStream;
  filePath: string;
begin
  filePath := 'D:\geheim.dat';
  stream := TFileStream.Create(filePath, fmOpenReadWrite);
  try
    frXTEA := TfrXTEA.Create;
    try
      frXTEA.LoadFromStream(stream);
      frXTEA.Encrypt := CheckBox1.Checked;
    finally
      frXTEA.Free;
    end;
  finally
    stream.Free;
  end;
end;

_________________
„Politicians are put there to give you the idea that you have freedom of choice. You don’t. You have no choice. You have owners. They own you. They own everything." (George Denis Patrick Carlin)

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme