IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Codes sources à télécharger Delphi Discussion :

[VCL] Sentinel AntiMalware


Sujet :

Codes sources à télécharger Delphi

  1. #1
    Membre expérimenté
    Avatar de XeGregory
    Homme Profil pro
    Passionné par la programmation
    Inscrit en
    Janvier 2017
    Messages
    431
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Passionné par la programmation
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Janvier 2017
    Messages : 431
    Par défaut [VCL] Sentinel AntiMalware
    La classe TSentinelMalware est conçue pour offrir une solution de détection de malwares en se basant sur la comparaison de signatures SHA-256 de fichiers suspects.

    • Gestion interne des signatures

    La classe utilise une instance de TStringList (stockée dans la variable privée FSignatureList) pour conserver en mémoire la liste des empreintes SHA-256 des fichiers considérés comme suspects.

    • Téléchargement et traitement des signatures

    La méthode DownloadAndLoadSignatures permet de télécharger une liste de signatures depuis MalwareBazaar.
    Elle utilise l’objet THTTPClient pour récupérer le contenu.

    • Vérification de fichiers

    La méthode CheckFileAgainstSHA256Signatures se charge de calculer le hachage SHA-256 d’un fichier en cours d’analyse en utilisant THashSHA2.GetHashString.
    Une fois le calcul effectué, le hash est comparé à la liste des signatures stockées pour déterminer si le fichier correspond à un malware connu.

    • Scan parallèle pour accélérer l’analyse

    La méthode ScanDirectoryParallel exploite la programmation parallèle (grâce à TParallel.For) afin de traiter simultanément plusieurs fichiers, ce qui accélère considérablement l’analyse sur les systèmes comportant un grand nombre de fichiers.

    • Interruption du scan

    Enfin, la méthode StopScan permet de modifier l’indicateur FStopScan à True, ce qui provoque l’arrêt immédiat du scan en cours dans les différentes procédures d’analyse.

    Sentinel.zip
    Vous ne pouvez pas faire confiance à un code que vous n'avez pas totalement rédigé vous-même.
    Ce n’est pas un bogue - c’est une fonctionnalité non documentée.

  2. #2
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 056
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 056
    Par défaut
    Sur le coup, je m'attendais à un sujet sur la solution Sentinel One mais non !

    Dans quel cadre on peut utiliser cette sentinelle ?
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

  3. #3
    Membre expérimenté
    Avatar de XeGregory
    Homme Profil pro
    Passionné par la programmation
    Inscrit en
    Janvier 2017
    Messages
    431
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Passionné par la programmation
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Janvier 2017
    Messages : 431
    Par défaut
    Citation Envoyé par ShaiLeTroll Voir le message
    Dans quel cadre on peut utiliser cette sentinelle ?
    Analyse de fichiers téléchargés : Les entreprises ou les utilisateurs qui manipulent fréquemment des fichiers téléchargés peuvent l'utiliser pour filtrer ceux qui sont suspects avant de les exécuter.
    Vous ne pouvez pas faire confiance à un code que vous n'avez pas totalement rédigé vous-même.
    Ce n’est pas un bogue - c’est une fonctionnalité non documentée.

  4. #4
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 056
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 056
    Par défaut
    N'ayant plus de client lourd mais que des applications serveurs, je n'avais pas envisagé ce cas, surtout que je n'ai jamais eu d'application permettant de télécharger librement des fichiers, ça le Front Web qui le permet, à l'entreprise utilisatrice de pluger sur le navigateur, l'anti-virus de leur choix.

    On a une GED dans le logiciel que l'on maintient et justement, on a optimisé l'arborescence de stockage pour les anti-virus (plus de sous-dossiers et moins de fichier au même niveau)

    Ajout un Duplicates dupIgnore et un Sorted à True, ralentirait DownloadAndLoadSignatures mais gain de temps sur CheckFileAgainstSHA256Signatures
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

  5. #5
    Membre expérimenté
    Avatar de XeGregory
    Homme Profil pro
    Passionné par la programmation
    Inscrit en
    Janvier 2017
    Messages
    431
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Passionné par la programmation
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Janvier 2017
    Messages : 431
    Par défaut
    Citation Envoyé par ShaiLeTroll Voir le message
    Ajout un Duplicates dupIgnore et un Sorted à True, ralentirait DownloadAndLoadSignatures mais gain de temps sur CheckFileAgainstSHA256Signatures
    Ou remplacer la TStringList par un TDictionary<string, Boolean>

    DownloadAndLoadSignatures
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    // Vérifie l'existence avant d'ajouter afin d'éviter les doublons
       if not FSignatures.ContainsKey(signature) then
         FSignatures.Add(signature, True)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    unit Sentinel.Malware;
     
    interface
     
    uses
      System.SysUtils, System.Classes, System.Types, System.IOUtils, System.Hash,
      System.Net.HttpClient, System.Net.URLClient, Vcl.StdCtrls, Vcl.ComCtrls, Vcl.Forms,
      Vcl.Dialogs, System.Threading, System.SyncObjs, System.Generics.Collections;
     
    type
      // Définition de la classe TSentinelMalware
      TSentinelMalware = class
      private
        FSignatures: TDictionary<string, Boolean>; // Dictionnaire contenant les empreintes SHA‑256 des fichiers suspects
        FStopScan: Boolean;                        // Indicateur permettant d'arrêter le scan à tout moment
      public
        constructor Create;
        destructor Destroy; override;
     
        /// Télécharge une liste de signatures SHA‑256 depuis une URL et les charge en mémoire.
        /// Retourne True si le téléchargement a réussi, sinon False.
        function DownloadAndLoadSignatures(const URL: string): Boolean;
     
        /// Vérifie si le fichier donné correspond à une signature malware.
        /// Calcule le SHA‑256 du fichier et le compare à la liste chargée.
        function CheckFileAgainstSHA256Signatures(const FilePath: string): Boolean;
     
        /// Compte le nombre total de fichiers présents dans un répertoire et ses sous-répertoires.
        function CountFiles(const DirectoryPath: string): Integer;
     
        /// Effectue un scan séquentiel des fichiers présents dans un répertoire.
        /// Met à jour l'interface utilisateur avec les fichiers scannés et détecte les malwares.
        procedure ScanDirectory(const DirectoryPath: string; DisplayLabel: TLabel; LogMemo: TMemo;
          ProgressBar: TProgressBar; var ProgressCount: Integer);
     
        /// Effectue un scan parallèle des fichiers pour accélérer l'analyse.
        /// Met à jour l'interface utilisateur tout en vérifiant si le scan doit être arrêté.
        procedure ScanDirectoryParallel(const DirectoryPath: string; DisplayLabel: TLabel; LogMemo: TMemo;
          ProgressBar: TProgressBar);
     
        /// Permet d'arrêter le scan en cours en modifiant l'indicateur FStopScan.
        procedure StopScan;
      end;
     
    implementation
     
    { Création d'une instance de TSentinelMalware }
    constructor TSentinelMalware.Create;
    begin
      inherited Create;
      FSignatures := TDictionary<string, Boolean>.Create;
      FStopScan := False; // Initialise l'indicateur d'arrêt du scan
    end;
     
    { Destruction de l'instance et libération des ressources mémoire }
    destructor TSentinelMalware.Destroy;
    begin
      FSignatures.Free;
      inherited;
    end;
     
    { Télécharge une liste de signatures SHA‑256 depuis une URL et charge en mémoire }
    function TSentinelMalware.DownloadAndLoadSignatures(const URL: string): Boolean;
    var
      HttpClient: THTTPClient;
      Response: IHTTPResponse;
      RawText: string;
      TempList: TStringList;
      I: Integer;
      signature: string;
    begin
      Result := False;
      HttpClient := THTTPClient.Create;
      TempList := TStringList.Create;
      try
        try
          Response := HttpClient.Get(URL);
          if Response.StatusCode = 200 then
          begin
            RawText := Response.ContentAsString;
            if RawText <> '' then
            begin
              TempList.Text := RawText;
              FSignatures.Clear;
              for I := 0 to TempList.Count - 1 do
              begin
                // Ignore les lignes vides et les commentaires (lignes commençant par #)
                if (TempList[I] <> '') and (TempList[I][1] <> '#') then
                begin
                  signature := LowerCase(Trim(TempList[I]));
                  // Vérifie l'existence avant d'ajouter afin d'éviter les doublons
                  if not FSignatures.ContainsKey(signature) then
                    FSignatures.Add(signature, True);
                end;
              end;
              Result := True;
            end;
          end
          else
            ShowMessage('Erreur HTTP - Code: ' + IntToStr(Response.StatusCode));
        except
          on E: Exception do
            ShowMessage('Erreur lors du téléchargement des signatures : ' + E.Message);
        end;
      finally
        TempList.Free;
        HttpClient.Free;
      end;
    end;
     
    { Vérifie si le fichier est répertorié comme malware en comparant son hash SHA‑256 }
    function TSentinelMalware.CheckFileAgainstSHA256Signatures(const FilePath: string): Boolean;
    var
      LStream: TFileStream;
      FileHash: string;
    begin
      Result := False;
      if not TFile.Exists(FilePath) then
        Exit;
     
      LStream := TFileStream.Create(FilePath, fmOpenRead or fmShareDenyWrite);
      try
        // Calcule le hash SHA‑256 du fichier pour vérification
        FileHash := LowerCase(THashSHA2.GetHashString(LStream));
      finally
        LStream.Free;
      end;
     
      // Vérifie si le hash du fichier est présent dans le dictionnaire des signatures
      Result := FSignatures.ContainsKey(FileHash);
    end;
     
    { Compte tous les fichiers présents dans un répertoire, en incluant les sous-dossiers }
    function TSentinelMalware.CountFiles(const DirectoryPath: string): Integer;
    var
      Files: TStringDynArray;
    begin
      if not TDirectory.Exists(DirectoryPath) then
        Exit(0);
      Files := TDirectory.GetFiles(DirectoryPath, '*.*', TSearchOption.soAllDirectories);
      Result := Length(Files);
    end;
     
    { Scan séquentiel des fichiers avec mise à jour de l'interface utilisateur }
    procedure TSentinelMalware.ScanDirectory(const DirectoryPath: string; DisplayLabel: TLabel;
      LogMemo: TMemo; ProgressBar: TProgressBar; var ProgressCount: Integer);
    var
      Files: TStringDynArray;
      SubDirs: TStringDynArray;
      FileName, Dir: string;
    begin
      if not TDirectory.Exists(DirectoryPath) or FStopScan then
        Exit;
     
      Files := TDirectory.GetFiles(DirectoryPath, '*.*', TSearchOption.soTopDirectoryOnly);
      for FileName in Files do
      begin
        if FStopScan then
          Exit;
     
        DisplayLabel.Caption := 'Fichier scanné : ' + FileName;
        Application.ProcessMessages;
     
        Inc(ProgressCount);
        ProgressBar.Position := ProgressCount;
     
        if CheckFileAgainstSHA256Signatures(FileName) then
          LogMemo.Lines.Add('Malware détecté : ' + FileName);
      end;
     
      SubDirs := TDirectory.GetDirectories(DirectoryPath, '*', TSearchOption.soTopDirectoryOnly);
      for Dir in SubDirs do
        ScanDirectory(Dir, DisplayLabel, LogMemo, ProgressBar, ProgressCount);
    end;
     
    { Scan parallèle des fichiers pour une analyse plus rapide }
    procedure TSentinelMalware.ScanDirectoryParallel(const DirectoryPath: string; DisplayLabel: TLabel;
      LogMemo: TMemo; ProgressBar: TProgressBar);
    var
      Files: TArray<string>;
      TotalFiles, LocalProgress: Integer;
    begin
      if not TDirectory.Exists(DirectoryPath) then
        Exit;
     
      FStopScan := False; // Réinitialise l'indicateur d'arrêt
      Files := TDirectory.GetFiles(DirectoryPath, '*.*', TSearchOption.soAllDirectories);
      TotalFiles := Length(Files);
     
      ProgressBar.Min := 0;
      ProgressBar.Max := TotalFiles;
      ProgressBar.Position := 0;
     
      LocalProgress := 0;
      TParallel.For(0, TotalFiles - 1,
        procedure(Index: Integer; LoopState: TParallel.TLoopState)
        var
          FileName: string;
          IsMalware: Boolean;
          CurrentProgress: Integer;
        begin
          if FStopScan then
          begin
            LoopState.Stop;
            Exit;
          end;
     
          FileName := Files[Index];
          IsMalware := CheckFileAgainstSHA256Signatures(FileName);
     
          // Sécurise l'incrémentation de la progression
          CurrentProgress := TInterlocked.Increment(LocalProgress);
          TThread.Queue(nil,
            procedure
            begin
              DisplayLabel.Caption := 'Fichier scanné : ' + FileName;
              ProgressBar.Position := CurrentProgress;
              if IsMalware then
                LogMemo.Lines.Add('Malware détecté : ' + FileName);
            end);
        end);
    end;
     
    { Permet d'arrêter le scan en cours }
    procedure TSentinelMalware.StopScan;
    begin
      FStopScan := True;
    end;
     
    end.
    Il faudrait que j'arrive à trouver une autre liste de signatures SHA-256 de malware, quelque chose de beaucoup plus complet.
    Il y a sûrement ça qui traîne sur le web.
    Vous ne pouvez pas faire confiance à un code que vous n'avez pas totalement rédigé vous-même.
    Ce n’est pas un bogue - c’est une fonctionnalité non documentée.

  6. #6
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 056
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 056
    Par défaut
    Si tu augmentes beaucoup ta base de signature, passe au BTree avec le Hash en TBytes, le noeud pouvant être un Cardinal ou un NativeUInt pour réduire la profondeur (32 bit vs 64 bit -> 8*4 vs 4*8)

    L'avantage du TBytes c'est qui contient 256 bits / 32 bytes contrairement à la string en Hexa qui contient 64 digits (0..F) soit en unicode 128 octets
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

  7. #7
    Membre expérimenté
    Avatar de XeGregory
    Homme Profil pro
    Passionné par la programmation
    Inscrit en
    Janvier 2017
    Messages
    431
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Marne (Champagne Ardenne)

    Informations professionnelles :
    Activité : Passionné par la programmation
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Janvier 2017
    Messages : 431
    Par défaut
    Citation Envoyé par ShaiLeTroll Voir le message
    Si tu augmentes beaucoup ta base de signature, passe au BTree avec le Hash en TBytes, le noeud pouvant être un Cardinal ou un NativeUInt pour réduire la profondeur (64 vs 32)
    Voir même élaborer directement une base de données ou un packet de données Xml. À mon avis, en termes de rapidité, cela sera beaucoup plus efficace.
    Vous ne pouvez pas faire confiance à un code que vous n'avez pas totalement rédigé vous-même.
    Ce n’est pas un bogue - c’est une fonctionnalité non documentée.

  8. #8
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 056
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 056
    Par défaut
    XML, je ne pense pas
    Mais une base type SQLite, l'index est probablement un BTree, ça te permettrait de cumuler effectivement plusieurs sources et conserver la base dans le temps.

    La base doit elle-même est "protégée", un hash et une signature pour garantir que le dictionnaire n'ait pas été changé par un tiers malveillant.
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [VCL] Comment faire une barre d'outils skinable comme FireFox ?
    Par DarkChamallo dans le forum Composants VCL
    Réponses: 23
    Dernier message: 07/05/2008, 18h03
  2. [VCL][TListView]Montrer une ligne à l'écran
    Par ptitbob dans le forum Delphi
    Réponses: 4
    Dernier message: 23/07/2007, 16h35
  3. [VCL]toolbar verticale
    Par mandale dans le forum Composants VCL
    Réponses: 5
    Dernier message: 01/10/2004, 14h26
  4. [VCL] Scroller un contrôle par code
    Par sbeu dans le forum Composants VCL
    Réponses: 3
    Dernier message: 31/03/2004, 10h39
  5. VCL de Crystal Report pour utilisation dans C++Builder
    Par dibak dans le forum C++Builder
    Réponses: 4
    Dernier message: 16/02/2004, 17h04

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo