1:

var sourcef, keyf, targetf:file of byte;					

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

procedure usekey;
var temp, temp2:byte
begin
repeat
if eof(keyf) then reset(keyf);  {sollte die keydatei kleiner sein als die zu verschlüsselte Datei wird die keyfile zwischendurch resetet werden müssen} 
read(temp, sourcef); //den bytewert aus der Quelldatei lesen
read(temp2, keyf); //den bytewert aus der Schlüsseldatei lesen
temp := temp xor temp2; //xor ist ein operator der Bitweise die beiden bytes addiert
write (temp, targetf); //das Ergebnis der Operation wird angewendet
until eof(sourcef); //wiederholen bis die Quelldatei am Ende ist					

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

type
  PCustomRecord = ^TCustomRecod;
  TCustomRecord = record
    Wert1 : Integer;
    Wert2 : Boolean;
    Wert3 : String[50]; // Strings sollten immer begrenzt sein beim Dateieinlesen oder du musst Byte für Byte lesen
  end;					

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

var
EinleseListe : TList;

procedure xyz;
var CustomRecord : PCustomRecord;
begin
...

in der Leseschleife siehts so aus:

InPtr := Pointer(InBuf);
i := 0;
while i <= NumRead do
begin
  new(CustomRecord);
  EinleseListe.Add(CustomRecord);
  CustomRecord := TCustomRecord(InPtr^);
  InPtr := Pointer(Cardinal(InPtr) + SizeOf(CustomRecord);
  i := i + SizeOf(CustomRecord);
end;
...
end;					

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

//Auf die Liste Greifst du so zu:
var
  CustomRecord : PCustomRecord;
  Wert : Integer;
begin
  if EinleseListe.Count > 0 then
  begin
    CustomRecord := PCustomRecord(EinleseListe.Items[0]);
    Wert := CustomRecord^.Wert1;
  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:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:

function Datei_encryption_decryption(InputFile : String; OutputFile : String; Overwrite : Boolean; Frequency : Integer) : Boolean;
var
  i : Integer;
  InFile          : File;    // Eingangsdatei
  OutFile         : File;    // Ausgangsdatei
  InBuf           : PChar;   // Eingangsbuffer
  InPtr           : Pointer; // Zeiger auf den InBuffer
  OutBuf           : PChar;   // Ausgangsbuffer
  OutPtr           : Pointer; // Zeiger auf den OutBuffer
  NRead, NWritten : Integer;
  w               : double;
  SoundValue      : byte;
const
  BufSize = 1000000; // 1000 K speicher wird als Buffer deklariert
  SampleRate : integer = 11025; // 8000, 11025, 22050, oder 44100 kann also geändert werden
begin
  Result := True;
  if (FileExists(OutputFile) AND Overwrite) OR NOT (FileExists(OutputFile)) then  // Existiert die Ausgangs datei und überschreibenaktiviert?
  begin
    AssignFile(InFile, InputFile);
    AssignFile(OutFile, OutputFile);
    try
      Rewrite(OutFile, 1);
    except
      Result := False;   // die Ausgabedatei kann nicht geöffnet werden
      exit;
    end;
    try
      Reset(InFile, 1);
    except
      Result := False;   // die Eingangsdatei kann nicht geöffnet werden
      exit;
    end;
    try
      GetMem(InBuf, BufSize);
      GetMem(OutBuf, BufSize);
    except
      MessageDlg('Zu wenig Arbeitsspeicher für diese Operation. Bitte beenden Sie einige Anwendungen, damit Arbeitsspeicher für diesen Prozess frei wird.', mtError, [mbOk], 0);
      CloseFile(InFile);
      CloseFile(OutFile);
      exit;
    end;
    w := 2 * Pi * Frequency;  // omega
    repeat
      BlockRead(InFile, InBuf^, BufSize, NRead);
      InPtr := Pointer(InBuf);
      OutPtr := Pointer(OutBuf);
      for i := 0 to NRead - 1 do
      begin
        SoundValue := 127 + trunc(127 * sin(i * w / SampleRate));
        Byte(OutPtr^) := Byte(InPtr^) XOR SoundValue;
        InPtr := Pointer(Cardinal(InPtr) + 1);
        OutPtr := Pointer(Cardinal(OutPtr) + 1);
      end;
      BlockWrite(OutFile, OutBuf^, NRead, NWritten);
    until (NRead = 0) or (NWritten <> NRead);
    CloseFile(InFile);
    CloseFile(OutFile);
  end else begin
    Result := False;
  end;
end;