Surveiller la base de registre [FAQ]

**RazielReaver** · 06/05/2006, 17h32

Bonjour à tous,

Je suis nouveau sur le forum mais lecteur assidu de developpez.com

Voila je cherche à developper un utilitaire style regmon. Pour le moment j'ai explorer la piste de RegNotifyChangeKeyValue, qui notifie un changement dans la base de registre. Le pb est que cette fonction ne donne aucun renseignement sur la clé ou valuer modifiée, créée..

La fonction avertit seulement d'un changement sur une rootkey.

Avez vous des pites, une adresse sur ce thème.

Pour info j'ai regardé les fonctions importées par regmon avec scanbin (de Jean-Claude Bellamy) ben à ma grande surprise pas de RegNotifyChangeKeyValue

Voila je suis preneur pour la moindre info concernant ce sujet

Merci

**RazielReaver** · 06/05/2006, 22h36

Je viens de penser a un truc. En regardant bien comment fonctionne regmon on s'apercoit qu'il arrive en fait a intercepter l'acces à la base de registre par un processus. Comment peut-on connaitre si tel ou tel processus ecrit dans la base de registre? car a ce momnet il serait facile de connaitre les modification exacte de la base en listant les processus en cours et en regardant s'ils font un requete vers la base !

Vous avez un avis?

**Laurent Dardenne** · 07/05/2006, 18h49

As-tu consulté le SDK ?
http://msdn.microsoft.com/library/de...try_events.asp
et
http://msdn.microsoft.com/library/de...starttrace.asp

**Laurent Dardenne** · 07/05/2006, 19h04

Envoyé par Laurent Dardenne

As-tu consulté le SDK ?
http://msdn.microsoft.com/library/de...try_events.asp
et
http://msdn.microsoft.com/library/de...starttrace.asp

[edit]
WMI permet aussi de surveiller l'activité sur la registry :

http://msdn.microsoft.com/library/de...ry_classes.asp

**RazielReaver** · 07/05/2006, 21h01

merci beaucoup,

je vais explorer la piste desuite je te tiens au courant.

Juste un petit mot. J'ai trouvé cette explication sur le site de regmon.

"
On Windows NT, 2000 and XP the </I>Regmon</I> loads a device driver that uses a technique we pioneered for NT called system-call hooking. When a user-mode component makes a privileged system call, control is transfered to a software interrupt handler in NTOSKRNL.EXE (the core of the Windows NT operating system). This handler takes a system call number, which is passed in a machine register, and indexes into a system service table to find the address of the NT function that will handle the request. By replacing entries in this table with pointers to hooking functions, it is possible to intercept and replace, augment, or monitor NT system services. </I>Regmon</I>, which obviously hooks just the Registry-related services, is merely one example of this capability in action. "

De file en aiguille je suis remonté jusqu'a cet article "Hooking Windows NT System Services" qui se trouve ici : http://www.eviloctal.com/forum/htm_d...603/20388.html

Si ta cinq minutes dis moi ce que tu en penses (je me permet de te tutoyer).

En tout cas merci beaucoup pour ta piste..

Cordialement

**Laurent Dardenne** · 08/05/2006, 10h46

Envoyé par RazielReaver

Si ta cinq minutes dis moi ce que tu en penses

J'ai pas trop le temps désolé, cela me semble trés pointu.
Le code fourni utilise de l'assembleur et concerne un driver il me semble et si c'est le cas Delphi ne te seras d'aucun secours. Et je ne pense pas que cela soit la solution.

Sur le forum de Sysinternals si tu recherches RegNotifyChangeKeyValue un post renvoi vers des API de sécurité, à creuser aussi.

La citation sur regmon t'indique la piste à suivre maintenant faut trouver le début de la pelote

Tu peux aussi poster, après avoir placé celui-ci en résolu, dans le forum Développement Windows.
J'ai regardé sur CodeProject mais je n'ai rien trouvé de concluant, vérifie.

Envoyé par RazielReaver

je me permet de te tutoyer.

Pas de soucis.

**Laurent Dardenne** · 08/05/2006, 16h14

Pour info, pour la surveillance avec WMI il y a une limite, on ne récupére pas le détail d'une modification.Par exemple si on surveille la modification d'une clé on ne connait pas la nouvelle valeur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
     //Classe de base RegistryEvent
     //On est informé d'une opération sur la base de registre :
     //toutes modifications sur la valeur d'une clé particulière
     //  HKEY_LOCAL_MACHINE\SOFTWARE\Developpez\Delphi\Sujet.
     Query:= 'SELECT * FROM RegistryValueChangeEvent'+
             ' WHERE Hive=''HKEY_LOCAL_MACHINE'' AND'+
             ' KeyPath=''SOFTWARE\\Developpez\\Delphi'' AND'+
             'ValueName=''Sujet''';

**RazielReaver** · 09/05/2006, 15h38

Bon j'ai trouvé.

Alors je n'ai pas suivi la piste de regmon, mais par contre je suis tombé sur un site qui propose un solution assez impressionnante.

L'auteur du site à creer un systeme qui permet de surcharger n'importe quelle api winodws, et d'injecter/remplacer la fonction originale par la fonction surcharger. On peut donc hooker n'importe quelle API.

La démarche :

1 creer un dll avec la fonction surchargée (attention cette fonction doit respecter la convention d'écriture de l'originale).

2 injecter cette dll dans le système.

J'ai ainsi tester ce procédé en surchargeant la fonction api regopenkey. Ben ca marche ! j'intercepte ainsi et place dans un fichier log les appels à cette fonction. Et de plus je récupere les paremetre de cette fonction et j'ai donc la clé ouverte. Reste à améliorer le tout en intercpetant aussi les fonction d'ecriture fermeture...

Pour faire fonctionner tout cà Il suffit d'avoir la dcu livreé avec la version freeware (si c a utilisation non commerciale).

Je vous donne le lien du site

Le tuto qui realise un hook de la fonction terminateprocess
http://help.madshi.net/HowToUseMadCodeHook.htm

Et le site lui même

http://www.madshi.net/

Pour le moment je vais mettre un peu d'ordre dans mon code pour qu'il soit plus présentable et je vous livrerais des quej'aurai terminé.

Je vous tiens au courant

A plus

**Laurent Dardenne** · 09/05/2006, 19h21

Envoyé par RazielReaver

Et le site lui même

http://www.madshi.net/

je n'avais pas sur sont site qu'il proposait qq tuto, ses composants sur la gestion des exceptions sont vraiment pointus.

Si t'as un peu de temps se serait bien nous donner un peu plus d'infos, on pourrait les coller dans la FAQ. Si ta solution fonctionne de nombreux membres vont être intéressé je pense.

**RazielReaver** · 09/05/2006, 19h36

Oui ok,

Mais la solution fonctionne c sur je l'ai testée. Seulement le projet est un peu en vrac c un projet de test y a des bouts de code qui trainent et qui ont servis a d'autres solutions... Donc je met de l'ordre et je vous présente ca.

Mais les possibilités offertent par ce genre de solutions sont immense...

**Laurent Dardenne** · 09/05/2006, 20h04

Envoyé par RazielReaver

Mias les possibilité offerte par ce genre de solutions sont immense...

D'ou l'intérêt suscité

**edam** · 09/05/2006, 20h29

Extara supper

RazielReaver

**RazielReaver** · 09/05/2006, 23h15

Bon ayé je suis un peu plus au clair

Voila je vais donc essayer de vous faire une petit topo sur cette méthode. Ce topo ne sera pas complet je compte sur vos compétences pour me reprendre sur quelque points ou pour apporter des précisions à mon propos.

1) Point de départ :
Je cherchais donc comment faire un hook sur la base de registre.

a - première solution imcomplète : RegNotifyChangeKeyValue.
Cette solution est expliquée ici : http://delphi.about.com/od/kbwinshell/l/aa052003a.htm

Le gros défaut de cette solution est qu'elle ne renvoie pas la clé qui a subit une modification. Elle notifie seulement un changement.

b - deuxième solution envisagée : le principe qu'utilise regmon. Là j'ai été un peu perturbé

car le procédé utilise des fonctions non documentées de xp et que tout cela me paraissait un peu trop pointu. Pour info je vous donne différent liens dont j'ai cru comprendre qu'ils traitaient plus ou moins du sujet.

http://www.eviloctal.com/forum/htm_d...603/20388.html

et le site de regmon

http://www.sysinternals.com/Utilities/Regmon.html (voir l'explication : "How Regmon Works")

Peut-être aussi un référence bibliogrpahique :

http://www.amazon.com/gp/product/020...lance&n=283155

c - La solution utilisant le principe de Mathias Rauen (je décrirai plus bas cette méthode)

En gros cette méthode permet de hooker n'importe quelle fonction API de windows. Pour le moment j'ai juste fait un hook sur RegOpenKey cela reste donc incomplet, mais le principe est vraiment très prometteur.

2) Description du principe de Mathias Rauen

Alors là je vais tenter une explication, mais je me reserve le droit d'être approximatif

Les API windows sont donc chargées par le système et les programmes à partir des dll natives de windows. Par exemple on sait que TerminateProcess se trouve dans kernel32.dll. Quand un programme ou un utilisateur demande au systeme de terminer un process celui ci fait appel a cette fonction. Imaginons maintenant qu'il soit possible de surcharger cette fonction. C'est à dire d'executer un bout de code personnel au moment de son appel. On pourrait donc par exemple refuser qu'un processus donné soit terminé sans autorisation.

Ceci est possible grâce au procédé développé par Mathias Rauen. Ce principe permet donc d'injecter la fonction surchargée d'une fonction originale (API) en lieu et place de celle-ci dans le système (system wide). D'ailleurs si quelqu'un veut bien m'expliquer ce que recouvre exactement ce terme (system wide) utilisé pas Mathias je suis preneur.

L'ecriture de la fonction surchargée doit se faire dans une dl qui elle sera injecté dans le système.

Pour développé un projet permettant cette injection il faut télécharger la collection de composants ici : http://madshi.net/madCollection.exe. Le composant qui nous interesse plus particulièrement est nommé madCodeHook.

L'install registre une dcu "madCodeHook.dcu" et fournit une dll madCHook.dll nécessaire à l'injection.

Pour résumé :

on crée un dll contenant la fonction API surchargée. Cette dll est injectée dans le system à l'aide des fonctions contenues dans "madCodeHook.dcu" et de la dll "madCHook.dll". A mon avis c'est la dcu qui fait appel à "madCodeHook.dcu" .

3) Passons à la pratique

a - D'abord l'exemple de de l'auteur : http://help.madshi.net/HowToUseMadCodeHook.htm
Cet exemple nous montre comment hooker l'API TerminanteProcess en autorisant ou non l'arrêt d'un processus donné.

b - Maintenant mon exemple :
Je vais en suivant Mathias hooker la fonction RegOpenKey qui est dans advapi32.dll.

Ecriture de la dll surchargeant RegOpenKey :

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
library HookRegOpenKey;
uses dialogs,classes,Sysutils, Windows, madRemote, madCodeHook, madStrings;
 
// variable représentant l'api originale "function RegOpenKey(hKey: HKEY; lpSubKey: PChar; var phkResult: HKEY): Longint; stdcall;"
 
var RegOpenKeyNext : function (HandleKey: Dword; lpSubKey: PChar; var phkResult: Dword): Longint; stdcall;
 
// Fonction surchargée
 
function RegOpenKeyCallback(HandleKey: Dword; lpSubKey: PChar; var phkResult: Dword) : Longint; stdcall;
Var
Str : TStringList;
RootKey : string;
begin
    // On renvoie la fonction originale pour que la demande soit bien prise en compte
    result := RegOpenKeyNext(HandleKey, lpSubKey,phkResult);
    // surcharge par mon code perso j'ouvre un fichier log ou seront enregistrer les infos
    Str:=TStringList.Create;
    If fileExists('c:\regkey.txt') Then Str.LoadFromFile('c:\regkey.txt');
    Case HandleKey Of
      HKEY_CLASSES_ROOT : RootKey := 'HKEY_CLASSES_ROOT\';
      HKEY_CURRENT_USER : RootKey := 'HKEY_CURRENT_USER\';
      HKEY_LOCAL_MACHINE : RootKey := 'HKEY_LOCAL_MACHINE\';
      HKEY_USERS : RootKey := 'HKEY_USERS\';
      HKEY_CURRENT_CONFIG : RootKey := 'HKEY_CURRENT_CONFIG\';
    End;
    Str.Add('-----------------');
    Str.Add(DateTimeToStr(Now) + ' : RegOpenKey called');
    Str.Add(RootKey + lpSubKey);
    Str.Add('-----------------');
    Str.SaveToFile('c:\regkey.txt');
    Str.Free;
end;
begin
// HookAPI provient de madCodeHook.dcu et permet de subsituer la fonction surchargée à l'API originale.  
HookAPI('advapi32.dll', 'RegOpenKeyA', @RegOpenKeyCallback, @RegOpenKeyNext);
end.

Remarque importante : La fonction surchargée doit impérativement respecter les conventions d'écriture (paramètres et variables) de l'originale.

Maintenant l'ecriture du projet permettant l'injection :

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
unit InjectUnit;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, madCodeHook,
  StdCtrls;
type
  TForm1 = class(TForm)
    ButtonHook: TButton;
    ButtonUnHook: TButton;
    procedure ButtonHookClick(Sender: TObject);
    procedure ButtonUnHookClick(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
var
  Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.ButtonHookClick(Sender: TObject);
begin
  InjectLibrary(ALL_SESSIONS or SYSTEM_PROCESSES, 'HookRegOpenKey.dll');
end;
procedure TForm1.ButtonUnHookClick(Sender: TObject);
begin
UninjectLibrary(ALL_SESSIONS or SYSTEM_PROCESSES, 'HookRegOpenKey.dll');
end;
end.

Voila il suffit d'utiliser InjectLibrary pour Hooker et UninjectLibrary pour UnHooker.

PS : scusez pour les fautes d'orthographe je fait des efforts mais c'est souvent en vain.

Quand j'aurai monté le projet global je vous le ferai parvenir. Car il me reste un autre point a résoudre : connaitre le processus qui vient d'accéder à la base de registre. Il faut aussi que je surcharge les appels aux fonctions d'écriture dans la base.

Raziel

**LadyWasky** · 10/05/2006, 13h09

Alors là, chapeau Raziel

**RazielReaver** · 10/05/2006, 17h29

Merci pour les compliments mais faut plutôt féliciter Mathias Rauen.

Une question pour les modérateurs. Etant donnée que la solution exposée couvre bien d'autre domaine que l'intitulé du post. Ne pourrait-on pas reposter le petit topo que j'ai fait sous une autre objet : "comment surcharger (hook) n'importe quelle api windows".

Je pense que si cette solution serai succeptible d'interesser beaucoup de monde il n'iront pas forcement jusqu'au bout d'un thread intitué Surveiller la base de registre pour la découvrir.

Je pense par exemple :
* a un systeme de surveillance des processus..
* début d'une piste pour developpé un anti-virus
* un controle parental pour navigateur
* surveillance à distance d'un poste reseau...

Donc voila je soumet ma demande au modo..

Raziel

**Laurent Dardenne** · 10/05/2006, 19h25

Un grand bravo RazielReaver

Envoyé par RazielReaver

Ne pourrait-on pas reposter le petit topo que j'ai fait sous une autre objet : "comment surcharger (hook) n'importe quelle api windows".

Oui tout à fait !

Envoyé par RazielReaver

Donc voila je soumet ma demande au modo..

C'est plus aux membres de la FAQ, certains ne sont pas modérateurs.
Et puis c'est pas la même casquette. Mais l'important c'est de participer.

Pour ce sujet il nous faut un peu de temps pour regarder ce qu'on peut en tirer. Mais sache qu'on en fera bon usage

Allez une dernière pour la route

Surveiller la base de registre [FAQ]

Delphi

Discussions similaires

Partager

Partager