mx-dev.net - Delphi

Sélection logiciels

Pencil Project v1.1

Arora v0.8.0

Audacity v1.3.9 bêta

Windows Live Messenger v8.0

Prism v1.0b4

En bref

01 Juil 2010 Google Me : le nouveau concurrent de Facebook ?

15 Fév 2010 Windows Seven : Les premières conclusions

06 Fév 2010 Une semaine d'actu : retour sur l'actualité de la semaine

28 Déc 2009 2000-2010 : Les révolutions qui ont changé le monde

31 Oct 2009 Google Maps Navigation : nouvelle bombe atomique parmi les GPS

Les derniers dossiers

Cet été, bronzez... Geek !

Google : le maître des noms de domaines

La nouvelle version de GMail en images !

Barème de rémunération pour les disques durs multimédias

Windows Vista

Les ressources Delphi et C/C++

Music Pro

Dessin de texte sur un canvas

Comparer strings sans tenir compte des accents

Drag & Drop à partir d'une fenêtre Windows

SMTPCLIENT et SMTPMESS : Envoyer des mails

Membres en ligne

+10 visiteurs en ligne

Nos partenaires

Espacerezo

KilaSoft

Vous êtes ici : Accueil › Delphi › Sources › BlockProc

BlockProc

Informations sur la source :

Auteur : rt15

Catégorie : Processus

Niveau : Confirmé

Déposé le : 27 Février 2009 à 23h38

2 commentaires sur cette source

Description

## Présentation :

Ce source n'est qu'une traduction du source C/C++ de Anton Bassov vers du Delphi.
http://www.codeproject.com/KB/system/soviet_protector.aspx

Le thème de ce source est le hook d'API native.

L'objectif de l'application est d'informer l'utilisateur en cas de démarrage d'un processus, et de permettre à l'utilisateur d'empècher celui-ci.

## Utilisation :

Lancer le BlockProc.exe. Celui-ci va transformer la .dll en .sys, créer un service associé au driver, et lancer celui-ci. Une icône apparaît dans la barre des tâches et permet d'arrêter l'application (Il ne faut pas qu'une demande soit en cours pour pouvoir arrêter l'application). Si on demande le lancement d'un processus, une boîte de dialogue nous demande de confirmer le lancement.

## Explications :

La principe de l'application est bien détaillé par Anton Bassov.

Toute la difficulté de la conversion a résidé dans le fait que la moitié de son application est un driver, alors que le Delphi n'est pas du tout prévu pour ça. J'aurais pu utiliser le "Delphi Driver Development Kit", mais j'ai préféré travailler à la main. Le DDDK inclus en effet le linker de VC, que je trouvais un peu dommage d'utiliser. L'utilisation de ce kit est probablement aussi assez compliquée (Nombreuses erreurs signalées à la compile ou au link, compilation en plusieurs étapes...). J'ai par contre finalement utilisé leur .pas de déclarations.

Globalement, je compile une dll Delphi classique, et le .exe travaille le fichier de manière à aboutir à un .sys. Le code de conversion ne fait que 200 lignes, et fait en fait plus que le minimum syndical (En calculant les hints de la table d'import).

Le principal souci lors de la réalisation d'un driver (Que ce soit en Delphi ou autre) est qu'en cas d'erreur, on n'échappe pas à l'écran bleu (Ou au reboot, en fonction de la configuration du PC). Un débugueur noyau est un luxe qu'il faut certainement s'offrir, quoiqu'ils soient rare à permettre le débogage du PC en local. Et ce n'est pas parce que l'on débugue le .exe que l'on ne risque rien : on peut laisser un thread boucler dans le noyau. Bref, il faudrait encore pas mal de boulot pour blinder le fonctionnement (Que ce soit de la version Delphi ou C), et sérieusement s'intéresser à un débogueur ring 0.

Mais ce modeste projet ouvre au moins deux perspectives très attrayantes !

1) Le Delphi montre une fois de plus qu'il est un des rares langages à pouvoir suivre le C sur ces terrains de prédilection, ici la programmation en ring 0 au coeur du noyau. N'essayez même pas de faire un driver noyau en Java, VB6 ou encore C# ! En cas de troll Delphi vs C, on a déjà plus de quoi répondre.

2) Sous Windows il y a deux univers distinct, le ring 0 et le ring 3. Bien qu'il y ait beaucoup de ressemblances, ils ont leurs propres API et leurs propres principes. Pouvoir programmer en ring 0 en Delphi, c'est pouvoir faire des applications qui ne sont faisables qu'en ce mode. C'est pouvoir explorer le noyau de windows. Bref, cela ouvre de nouveaux horizons, qui sont très accessibles (Pas de monstrueux ddk, juste 200 lignes de Delphi pour convertir un .dll en .sys).

Code Source

unit pasNtDdk;
 interface
 type TIrp_Mj_Functions = (IRP_MJ_CREATE,
                          IRP_MJ_CREATE_NAMED_PIPE,                          IRP_MJ_CLOSE,
                          IRP_MJ_READ,                          IRP_MJ_WRITE,
                          IRP_MJ_QUERY_INFORMATION,                          IRP_MJ_SET_INFORMATION,
                          IRP_MJ_QUERY_EA,                          IRP_MJ_SET_EA,
                          IRP_MJ_FLUSH_BUFFERS,                          IRP_MJ_QUERY_VOLUME_INFORMATION,
                          IRP_MJ_SET_VOLUME_INFORMATION,                          IRP_MJ_DIRECTORY_CONTROL,
                          IRP_MJ_FILE_SYSTEM_CONTROL,                          IRP_MJ_DEVICE_CONTROL,
                          IRP_MJ_INTERNAL_DEVICE_CONTROL,                          IRP_MJ_SHUTDOWN,
                          IRP_MJ_LOCK_CONTROL,                          IRP_MJ_CLEANUP,
                          IRP_MJ_CREATE_MAILSLOT,                          IRP_MJ_QUERY_SECURITY,
                          IRP_MJ_SET_SECURITY,                          IRP_MJ_POWER,
                          IRP_MJ_SYSTEM_CONTROL,                          IRP_MJ_DEVICE_CHANGE,
                          IRP_MJ_QUERY_QUOTA,                          IRP_MJ_SET_QUOTA,
                          IRP_MJ_PNP); 
const  IRP_MJ_MAXIMUM_FUNCTION = $1B;
  IO_NO_INCREMENT: Char = Char(0);  FILE_DEVICE_UNKNOWN: Cardinal = $22;
 type
  PUnicodeString = ^TUnicodeString;  TUnicodeString = record
    _nLength: Word;    _nMaximumLength: Word;
    _lpBuffer: PWideChar;  end;
 type
  PPDeviceObject = ^PDeviceObject;  PDeviceObject = ^TDeviceObject;
  TDeviceObject = record  end;
 type
  PListEntry = ^TListEntry;  TListEntry = record
    _lpFlink: PListEntry;    _lpBlink: PListEntry;
  end; 
type  PIoStatusBlock = ^PIoStatusBlock;
  TIoStatusBlock = record    _nStatus: Integer;
    _lpInformation: PCardinal;  end;
 type
  PIrp = ^TIrp;  TIrp = record
    _nType: Smallint;    _nSize: Word;
    _lpMdlAddress: Pointer;    _nFlags: Cardinal;
    _nUnion: Cardinal;    _threadListEntry: TListEntry;
    _ioStatus: TIoStatusBlock;  end;
 type TDriverUnload = procedure(lpDriver: Pointer); stdcall;
type TDriverDispatch = function(lpDeviceObject: PDeviceObject; lpIrp: PIrp): Integer; stdcall; 
type  PDriverObject = ^TDriverObject;
  TDriverObject = packed record    _nType: Smallint;
    _nSize: Smallint;    _lpDeviceObject: PDeviceObject;
    _nFlags: Cardinal;    _lpDriverStart: Pointer;
    _nDriverSize: Cardinal;    _lpDriverSection: Pointer;
    _lpDriverExtension: Pointer;    _driverName: TUnicodeString;
    _lpHardwareDataBase: PUnicodeString;    _lpFastIoDispatch: Pointer;
    _lpDriverInit: Pointer;    _lpDriverStartIo: Pointer;
    _driverUnload: TDriverUnload;    _majorFunctions: Array [0..IRP_MJ_MAXIMUM_FUNCTION] of TDriverDispatch;
  end; 
function IoCompleteRequest(lpIrp: PIrp; nPriorityBoost: Char): Integer; stdcall; external 'ntoskrnl.exe';procedure RtlInitUnicodeString(var lpUnicodeString: TUnicodeString; lpVal: WideString); stdcall; external 'ntoskrnl.exe';
procedure IoDeleteSymbolicLink(var lpUnicodeString: TUnicodeString); stdcall; external 'ntoskrnl.exe';procedure IoDeleteDevice(lpDevice: PDeviceObject); stdcall; external 'ntoskrnl.exe';
procedure IoCreateSymbolicLink(var lpLink: TUnicodeString; var lpName: TUnicodeString); stdcall; external 'ntoskrnl.exe'; 
function IoCreateDevice(lpDriver: PDriverObject;                        nDeviceExtensionSize: Cardinal;
                        lpDeviceName: PUnicodeString;                        nDeviceType: Cardinal;
                        nDeviceCharacteristics: Cardinal;                        bExclusive: LongBool;
                        lpDevice: PPDeviceObject): Integer; stdcall; external 'ntoskrnl.exe'; 
procedure KeSetEvent; stdcall; external 'ntoskrnl.exe';procedure KeDelayExecutionThread; stdcall; external 'ntoskrnl.exe';
procedure memmove; stdcall; external 'ntoskrnl.exe';procedure KeWaitForSingleObject; stdcall; external 'ntoskrnl.exe';
procedure RtlFreeAnsiString; stdcall; external 'ntoskrnl.exe';procedure _stricmp; stdcall; external 'ntoskrnl.exe';
procedure ObfDereferenceObject; stdcall; external 'ntoskrnl.exe';procedure RtlUnicodeStringToAnsiString; stdcall; external 'ntoskrnl.exe';
procedure ObReferenceObjectByHandle; stdcall; external 'ntoskrnl.exe';procedure IofCompleteRequest; stdcall; external 'ntoskrnl.exe';
procedure MmUnmapIoSpace; stdcall; external 'ntoskrnl.exe';procedure MmMapIoSpace; stdcall; external 'ntoskrnl.exe';
procedure MmGetPhysicalAddress; stdcall; external 'ntoskrnl.exe';procedure KeServiceDescriptorTable; stdcall; external 'ntoskrnl.exe';
procedure KeInitializeEvent; stdcall; external 'ntoskrnl.exe'; 
 implementation
 end.

Conclusion

AVERTISSEMENT : EN CAS DE BUG, CE PROGRAMME PROVOQUE PRESQUE SYSTEMATIQUEMENT UN ECRAN BLEU OU UN REBOOT. Ce programme est en phase bêta. Testé sous XP et Vista. Ne pas essayer sous une versions antérieure à 2000. Il faut l'exécuter en mode administrateur sous Vista (Clique droit, "Exécuter en tant qu'administrateur"). Ne pas l'exécuter en mode debug avant d'avoir saisi toutes les conséquences qu'une mauvaise manipulation peut avoir. Sauvegarder ses documents et fermer ses applications avant de lancer ce logiciel. Je décline toute responsabilité en cas de perte de document ou de dommage quelconque, qu'ils soient software ou hardware.

Ça c'est fait. J'espère ne pas avoir effrayer grand monde non plus.

Projet proposé au Concours de Programmation 2009.

Fichier Source

13 fichiers 244,89 Ko

BlockProc.sys	15,50 Ko
pasDllToSys.pas	8,21 Ko
pasStatusIcon.pas	6,16 Ko
Driver/BlockProc.dpr	8,03 Ko
Driver/BlockProc.res	1,67 Ko
Driver/DDDK.pas	39,57 Ko
Driver/pasNtDdk.pas	4,86 Ko
BlockProc.bpg	822 Octets
BlockProc.dll	15,50 Ko
BlockProc.dpr	5,54 Ko
BlockProc.exe	390,50 Ko
BlockProc.ico	766 Octets
BlockProc.res	1,64 Ko

Télécharger la source

Commentaires sur la source

oas

Membre

Inscrit le 31 Août 2009

3 points

Posté le Lundi 31 AoÃ»t 2009 à 12:07

Remarquable !

Propre, efficace... et surtout TRÈS utile !

Sh0ck

Membre

Inscrit le 24 Jan 2010

2 points

Posté le Dimanche 24 Janvier 2010 à 13:00

Tout simplement énorme.

Ajoutez votre commentaire & avis sur la ressource :

Vous n'êtes pas connecté !

Rejoignez dès maintenant la communauté en 3 clics et exprimez votre avis !

J'ai déjà un compte