ProtectedMemory Delphi

Geschützter Speicher für Delphi

Sicherung sensibler Daten vor Hackern oder Prozessen Debugger durch den Schutz von Speicherregionen vor Zugriff und sicherstellen, dass Daten gelöscht werden, wenn nicht mehr erforderlich.

Verwendung | Was ist neu | Beispiele | Verfahren

Warum brauchst du es!?

Es ist entscheidend, vertrauliche Daten vor dem nicht autorisierten Zugriff zu schützen, z. B. Verschlüsselungsschlüssel, Passwörter und andere vertrauliche Daten. Ohne einen ordnungsgemäßen Speicherschutz können selbst vorübergehend gespeicherte sensible Daten im Speicher anfällig für Angriffe wie Speichermüll oder Prozesseinspritzung sein. Diese Einheit hilft beim Sperr- und Schutz des Speichers und sorgt dafür, dass empfindliche Daten abgeschirmt und sicher gelöscht werden, wenn sie nicht mehr benötigt werden.

Verwendung

1. Klonen oder einfach das Gerät herunterladen : Klonen Sie das Repository oder laden Sie das ProtectedMemory -Gerät in Ihr Delphi -Projekt herunter.
2. Verwenden Sie es : Verwenden Sie das ProtectMemory , UnProtectMemory und die Verfahren ReleaseProtectedMemory , um Ihren Speicher zu sichern.
3. Veröffentlichen Sie den Speicher : Stellen Sie sicher, dass der Speicher nach dem Gebrauch freigegeben und gelöscht wird, indem Sie ReleaseAllProtectedMemory aufrufen.
4. Bitte geben Sie es ein? und teilen Sie es mit anderen

Was ist neu

TProtectedStream ..

• Eine neue TProtectedStream -Klasse wurde hinzugefügt, die von TMemoryStream erbt.
• Es verwendet VirtualAlloc für Speicherzuweisung und VirtualProtect , um das Gedächtnis zu schützen und zu schützen.
• Mit der IsProtected Eigenschaft können Sie zwischen geschützten (ohne Zugriff) und ungeschützten (Lese-/Schreib-) Zuständen umschalten.

Beispiele

Beispiel: Schützen Sie konstante Daten

 uses
  ProtectedMemory;

var
  Data: array [ 0 .. 255 ] of Byte;
  DataPtr: Pointer;
begin
  Data[ 0 ] := 99 ;
  Data[ 1 ] := 11 ;
  Data[ 2 ] := 22 ;
  Data[ 3 ] := 33 ;
  Data[ 4 ] := 44 ;
  Data[ 5 ] := 55 ;
  DataPtr := @Data[ 0 ];
  
  // Protect the memory (prevents access to the memory region)
  ProtectMemory(DataPtr, SizeOf(Data));

  // Accessing the protected memory here will return zeros.
  // Unprotect the memory before accessing it
  UnProtectMemory(DataPtr);

  // Optionally release the memory and clear its content
  ReleaseProtectedMemory(DataPtr);
end ;

Beispiel: Schutz der Delphi Managed String

 uses
  ProtectedMemory;

var
  SensitiveStr: string;
  NonSensitiveStr: string;
  DataPtr: Pointer;
begin
  SensitiveStr := ' Sensitive Data ' ;
  NonSensitiveStr := ' Not Sensitive Data ' ;

  // Get a pointer to SensitiveStr's memory
  DataPtr := Pointer(SensitiveStr);

  // Protect the memory region containing SensitiveStr
  Writeln( ' Protecting memory... ' );
  ProtectMemory(DataPtr, Length(SensitiveStr) * SizeOf(Char));

  // Accessing SensitiveStr here will return zeros or show undefined behavior
  Writeln( ' SensitiveStr after protection: ' , SensitiveStr);

  // You can still access NonSensitiveStr, which is unaffected
  NonSensitiveStr := ' Updated Non-Sensitive Data ' ;
  Writeln( ' NonSensitiveStr: ' , NonSensitiveStr);

  // UnProtect Memory it's reutrn it's orginal data
  Writeln( ' Releasing memory... ' );
  UnProtectMemory(DataPtr);

  // SensitiveStr is now restored
  Writeln( ' Restored SensitiveStr: ' , SensitiveStr);
end ;

Beispiel: TPRETECTEDSTREAM -Verwendung

 uses
  ProtectedStream;

var
  Stream: TProtectedStream;
  Data: AnsiString;
  Buffer: array [ 0 .. 255 ] of Byte;
begin
  Data := ' Sensitive Data ' ;
  
  Stream := TProtectedStream.Create;
  try
    Stream.Write(PAnsiChar(Data)^, Length(Data));
    Data := ' ' ;
    Stream.IsProtected := True;  // Protect the memory

    // Unprotect to read
    Stream.IsProtected := False;
    Stream.Read(Buffer, 10 );
  finally
    Stream.Free;
  end ;
end ;

Verfahren

• ProtectMemory(var DataPtr: Pointer; Size: NativeUInt) : Schützt die angegebene Speicherregion, indem Sie ihn auf PAGE_NOACCESS einstellen und sperren, um das Paging zu verhindern. Die Daten werden in einen neuen geschützten Speicherblock kopiert und der ursprüngliche Zeiger wird aktualisiert, um auf diesen geschützten Block zu verweisen.

• UnProtectMemory(DataPtr: Pointer) : Stellt den Speicherschutz auf PAGE_READWRITE wieder her und entfernt die Region aus der Liste der geschützten Speicherblöcke.

• ReleaseProtectedMemory(DataPtr: Pointer) : Stellt Speicherzugriff wieder her, löscht den Inhalt, indem Sie sicher den Speicher aufnehmen, und entfernt ihn aus der geschützten Liste.

• ReleaseAllProtectedMemory() : Freisetzung und löscht alle geschützten Speicherregionen.

Autor

• Shadi Ajam

Nützliche Einheit, richtig?

JA! Wir würden Ihre Unterstützung lieben! Bitte geben Sie es ein? und teilen Sie es mit anderen.

In den sozialen Medien teilen :