CryptoGear-Verschlüsselungsalgorithmus
Blockverschlüsselung mit symmetrischem Schlüssel, entwickelt von BreakingSecurity.

Sie finden es Delphi Umsetzung hier.

 Inter-process communication using Windows named pipes

Dieses Beispiel soll eine Methode zeigen, mit der verschiedene Prozesse miteinander kommunizieren und Daten untereinander austauschen können.
Ein Dank geht an Peter Bloomfield, der ein nettes geschrieben hat Tutorial über Windows-Pipes in C++.

Programm PipeServer;
// Serveranwendung, die eine eingehende Pipe erstellt und auf Daten von Clientprozessen wartet.
{$ APPTYPE CONSOLE}
verwendet
  SysUtils,
  Windows;
Verfahren ReceivePipeData();
jung
  Rohr: Kardinal;
  RecBuffer: Feld[0..999] of Byte;
  numBytesLesen: DWORD;
  Folge: Longbool;
  sReadData: Ansistring;
  mit: SICHERHEIT_ATTRIBUTE;
  SD: SECURITY_DESCRIPTOR;
beginnen
  // Muss Zugriffsrechte gewähren, falls die Benutzerkontensteuerung aktiviert ist, auf WinVista und höher,
  // und kommunizierende Prozesse sind unter einem anderen Benutzer (der auch SYSTEM sein kann).
  // Andernfalls erhält die andere Seite der Pipe ERROR_ACCESS_DENIED bei CreateFile().
  // Wenn UAC aktiviert ist und wir versuchen, eine Pipe zwischen einer Benutzerebene und einem Systemprozess zu verwenden,
  // Auch wenn wir uns innerhalb desselben Benutzerkontos befinden, schlägt die Pipe-Kommunikation fehl.
  // Um ​​dies zu vermeiden, müssen wir eine Sicherheitsbeschreibung für die Pipe initialisieren.
  InitializeSecurityDescriptor(@sd, SECURITY_DESCRIPTOR_REVISION);
  // Es gibt einen wichtigen Unterschied zwischen einer leeren und einer nicht vorhandenen DACL.
  // Wenn eine DACL leer ist, enthält sie keine Zugriffssteuerungseinträge (ACEs); daher kein Zugriff 
     Rechte sind explizit gewährt.
  // Als Ergebnis wird der Zugriff auf das Objekt implizit verweigert.
  // Wenn ein Objekt keine DACL hat (wenn der pDacl-Parameter NULL ist),
  // Dem Objekt wird kein Schutz zugewiesen und alle Zugriffsanforderungen werden gewährt.
  SetSecurityDescriptorDacl(@sd, Wahre, Null, falsch);
  sa.bInheritHandle := falsch;
  sa.lpSecurityDescriptor := @sd;
  sa.nLänge := Größe von(sa);
  während was immer dies auch sein sollte. do beginnen
    wiederholen
      // Erstellen Sie eine neue Pipe, um Daten zu empfangen
      Rohr := CreateNamedPipe(
         '\.pipeSamplePipe', // Unser Pipe-Name
         PIPE_ACCESS_INBOUND, // Nur-Lese-Pipe
         PIPE_TYPE_MESSAGE or PIPE_READMODE_MESSAGE, // Nachrichtenmodus verwenden
         PIPE_UNLIMITED_INSTANCES ,
         0,  // Kein Ausgangspuffer
         0,  // Kein Eingangspuffer
         0,  // Standardwartezeit verwenden
         @sa // Sicherheitsattribute setzen, um Zugriffsrechte zu gewähren
      );
      if (Rohr = INVALID_HANDLE_VALUE) dann beginnen
        Schreiben('[FEHLER] Pipe konnte nicht erstellt werden. Fehlercode ' + IntToStr(GetLastError()) + # 13 # 10 + 
              'Drücken Sie die Eingabetaste, um es erneut zu versuchen');
        Readln;
      Ende;
    bis Rohr <> INVALID_HANDLE_VALUE;
    Writeln('[INFO] Inbound-Pipe erstellt! Warten auf die Verbindung eines Client-Prozesses...');
    // Dieser Aufruf blockiert, bis ein Client-Prozess eine Verbindung zur Pipe herstellt
    Folge := ConnectNamedPipe(Pipe, Null);
    if (Folge = falsch) dann beginnen
      Writeln('[ERROR] Fehler beim Verbinden mit der Pipe. Fehlercode ' + IntToStr(GetLastError()));
    Ende
    sonst beginnen
      Writeln('[INFO] Client verbunden! Warten auf Daten...');
      numBytesRead := 0;
      // Die Leseoperation wird blockiert, bis Daten zum Lesen vorhanden sind
      Folge := ReadFile(
          Rohr,
          RecBuffer[0], // Die Daten aus der Pipe werden hier abgelegt
          Größe von(RecBuffer), // Anzahl der zugewiesenen Bytes
          numBytesLesen, // Dies speichert die Anzahl der tatsächlich gelesenen Bytes
          Null // Überlappende IO nicht verwenden
      );
      if (Folge = falsch) dann beginnen
          Writeln('[FEHLER] Rohrdaten konnten nicht gelesen werden! Fehlercode ' + IntToStr(GetLastError()));
      Ende sonst beginnen
          SetString(sReadData,PAnsiChar(@recBuffer[0]), numBytesRead); //Byte-Array in String kopieren
          Writeln('[SUCCESS] Daten empfangen: ' + sReadData);
      Ende;
    Ende;
    //Schließen Sie unser Pipe-Handle
    CloseHandle(Pipe);
  Ende;
Ende;
//Programmstartprozedur
beginnen
  Writeln('*** Pipe-Server-Anwendung ***' + # 13 # 10);
  Schreiben('[INFO] Drücken Sie die Eingabetaste, um einen Pipe-Server zu erstellen und auf eingehende Daten zu lauschen');
  ReadLn;
  ReceivePipeData();
Ende.
Programm PipeClient;
// Client-Anwendung, die Daten an den Pipe-Server sendet.
{$ APPTYPE CONSOLE}
verwendet
SysUtils,
Windows,
Klassen;
// Per Pipe zu sendende Daten werden aus einer Datei gelesen.
Funktion GetDataFromFile(sDateiname: Ansistring): Ansistring;
jung
Datendatei: TFileStream;
Lesepuffer: Array of Byte;
sDataToSend: Ansistring;
beginnen
  versuchen
    Datendatei := TFileStream.Create( sDateiname , fmOpenRead);
    SetLength(Lesepuffer, DataFile.Size);
    DataFile.Read(ReadBuffer[0], Länge(Lesepuffer));
    SetString(sDataToSend,PAnsiChar(@ReadBuffer[0]), DataFile.Size); //Byte-Array in String kopieren
    DataFile.Free;
    Ergebnis := sDataToSend;
  nur nicht
    Ergebnis := '';
  Ende;
Ende;
Verfahren SendPipeData();
jung
Rohr: Kardinal;
numBytesGeschrieben: DWORD;
Folge: Longbool;
sDataToSend: Ansistring;
beginnen
  wiederholen
    // Öffnen Sie die Named Pipe, die zuvor von der Serveranwendung erstellt wurde
    Rohr := Erstelle Datei(
    '\.pipeSamplePipe', // Unser Pipe-Name
    GENERIC_WRITE,
    FILE_SHARE_READ or FILE_SHARE_WRITE,
    Null,
    OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL,
    0
    );
    if (Rohr = INVALID_HANDLE_VALUE) dann beginnen
      Schreiben('[FEHLER] Pipe konnte nicht geöffnet werden (der Server muss zuerst laufen).' + # 13 # 10 + 'Drücken Sie die Eingabetaste, um 
      wiederholen');
      Readln;
    Ende;
  bis Rohr <> INVALID_HANDLE_VALUE;
  wiederholen
    //Zu sendende Daten aus Datei abrufen
    sDataToSend := GetDataFromFile(ExtractFilePath(Paramstr(0)) + 'DataToSend.txt');
    if sDataToSend = '' dann beginnen
      Schreiben('[FEHLER] Daten konnten nicht aus Datei gelesen werden (möglicherweise nicht vorhanden oder leer).' + # 13 # 10 + 'Drücken Sie
      Geben Sie ein, um es erneut zu versuchen');
      Readln;
    Ende;
  bis sDataToSend <> '';
  numBytesGeschrieben := 0;
  Folge := WriteFile(
  Rohr, // Handle auf unsere ausgehende Pipe
  sDataToSend[1], // Zeiger auf zu sendende Daten
  Länge(sDataToSend), // Länge der zu sendenden Daten (Bytes)
  numBytesGeschrieben, // Speichert die tatsächlich gesendete Datenmenge
  Null // Überlappende IO nicht verwenden
  );
  if (Folge = falsch) dann
    Writeln('[FEHLER] Rohrdaten konnten nicht gesendet werden. Fehlercode ' + IntToStr(GetLastError()))
  sonst Writeln('[SUCCESS] Pipe-Daten gesendet: ' + sDataToSend);
  // Pipe-Handle schließen
  CloseHandle(Pipe);
Ende;
//Programmstartprozedur
beginnen
  Writeln('*** Pipe-Client-Anwendung ***' + # 13 # 10);
  während was immer dies auch sein sollte. do beginnen
    Schreiben('[INFO] Drücken Sie die Eingabetaste, um Rohrdaten an den Server zu senden');
    Readln;
    SendPipeData();
  Ende;
Ende.
Menü