ProtectedMemory Delphi

Mémoire protégée pour Delphi

Préserver les données sensibles des pirates ou les débuggeurs de processus en protégeant les régions de la mémoire contre l'accès et en garantissant que les données sont effacées lorsqu'elles ne sont plus nécessaires.

Utilisation | Quoi de neuf | Exemples | Procédures

Pourquoi vous en avez besoin !?

Il est crucial de protéger les informations sensibles, telles que les clés de chiffrement, les mots de passe et d'autres données confidentielles, contre l'accès non autorisé. Sans protection de la mémoire appropriée, même des données sensibles temporairement stockées en mémoire peuvent être vulnérables aux attaques comme les vidages de mémoire ou l'injection de processus. Cette unité aide à verrouiller et à protéger la mémoire, en veillant à ce que les données sensibles soient protégées et effacées en toute sécurité lorsqu'elles ne sont plus nécessaires.

Usage

1. Clone ou simplement télécharger l'unité : cloner le référentiel ou télécharger l'unité ProtectedMemory sur votre projet Delphi.
2. Commencez à l'utiliser : utilisez les procédures ProtectMemory , UnProtectMemory et ReleaseProtectedMemory pour sécuriser votre mémoire.
3. Libérez la mémoire : assurez-vous que la mémoire est libérée et effacée après utilisation en appelant ReleaseAllProtectedMemory .
4. Veuillez lui donner un? Et partagez-le avec les autres

Quoi de neuf

1. Ajout de classe TProtectedStream

• Une nouvelle classe TProtectedStream a été ajoutée, héritant de TMemoryStream .
• Il utilise VirtualAlloc pour l'allocation de mémoire et VirtualProtect pour protéger et imprégner la mémoire.
• La propriété IsProtected vous permet de basculer entre les états protégés (sans accès) et non protégés (lire / écrire).

Exemples

Exemple: protéger les données constantes

 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 ;

Exemple: protéger la chaîne gérée de Delphi

 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 ;

Exemple: utilisation de la contrainte TPROTECT

 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 ;

Procédures

• ProtectMemory(var DataPtr: Pointer; Size: NativeUInt) : protège la région de mémoire spécifiée en la définissant sur PAGE_NOACCESS et en la verrouillant pour éviter la pagination. Les données sont copiées dans un nouveau bloc de mémoire protégé, et le pointeur d'origine est mis à jour pour pointer vers ce bloc protégé.

• UnProtectMemory(DataPtr: Pointer) : Restaure la protection de la mémoire à PAGE_READWRITE et supprime la région de la liste des blocs de mémoire protégés.

• ReleaseProtectedMemory(DataPtr: Pointer) : restaure l'accès à la mémoire, efface le contenu en zéro en fermeture de la mémoire et le supprime de la liste protégée.

• ReleaseAllProtectedMemory() : libère et efface toutes les régions de mémoire protégées.

Auteur

• Shadi Ajam

Unité utile, non?

OUI! Nous aimerions votre soutien! Veuillez lui donner un? et partagez-le avec les autres.

Partager sur les réseaux sociaux :