Ideea de a scrie un driver de pseudo-dispozitiv nu a venit imediat. La începutul drumului, întrebarea a fost pentru mine în prim plan - este util acest program deloc? Programatorul mediu, și chiar mai mult utilizatorul, necesită mecanismul de blocare a cotelor de disc sau, să zicem, scrie în memorie cu atributul "no access"? Acum că primele rezultate ale testelor sunt primite în sistemul de operare Windows NT, nu mai există nici o îndoială. În opinia mea, acest program va fi cel mai util pentru experții în domeniul securității informațiilor, utilizând sistemul de operare WindowsNT, adică acest program va ajuta dezvoltatorii de aplicații eficiente pentru a asigura securitatea informațiilor din WindoewsNT.
De asemenea, este de dorit să avem o idee despre modelul arhitectural al driverelor de dispozitive. Se pune un accent deosebit pe interacțiunea mediului software cu managerul de sistem al intrărilor / ieșirilor.
2. Modul kernel și modul utilizator
microprocesor Pentium are patru nivele de privilegiu (niveluri privilegiu), de asemenea, cunoscut sub numele de inel (inele), care este controlată, de exemplu, accesul la memorie, capacitatea de a utiliza unele procesor critice de comandă (cum ar fi comenzi legate de protecție), etc. Fiecare fir rulează pe unul dintre aceste niveluri de privilegii. Inelul 0 este cel mai privilegiat nivel, cu acces deplin la întreaga memorie și la toate comenzile procesorului. Inelul 3 este cel mai puțin privilegiat.
Pentru a asigura compatibilitatea cu sistemele bazate pe altele decât cele eliberate de procesoare, Intel, Windows NT suportă doar două niveluri de privilegii - Ring 0 și 3. În cazul în care firul se execută în inel 0, spun că se execută în modul kernel (modul de kernel) . În literatură, modul kernel este uneori numit și modul supervizor. Dacă firul rulează în ringul 3, se spune că rulează în modul de utilizare. În modul Utilizator, se execută aplicații și subsisteme ale mediului (Win32, OS / 2 și POSIX). Driverele de dispozitive grafice de sistem grafic, drivere de imprimantă și manager de windowing rula în modul kernel (a se vedea. Schema «Arhitectura Windows NT într-o formă simplificată"). Modul de executare a modului de utilizare este mult mai fiabil, dar necesită costuri suplimentare, care reduc performanța generală a procesului. Codul executat în modul utilizator nu poate rupe integritatea executabilului Windows NT, kernel-ului și driverelor de dispozitive. Interesant este faptul că driverele de dispozitive funcționează în modul kernel. Această circumstanță are două consecințe. În primul rând, spre deosebire de o aplicație care funcționează necorespunzător, un driver de dispozitiv care rulează incorect poate întrerupe întregul sistem, deoarece are acces la întregul cod de sistem și la întreaga memorie. În al doilea rând, un programator de aplicații poate accesa resursele protejate prin scrierea unui driver de dispozitiv fals, deși acest lucru nu este o sarcină ușoară.
#ifdef _X86_ // structura se referă la modelul de procesor x86
typedef struct _CONTEXT
// un set de steaguri de biți care definește conținutul structurii
DWORD ContextFlags;
// Registrele de depanare
DWORD Dr0;
DWORD Dr1;
DWORD Dr2;
DWORD Dr3;
DWORD Dr6;
DWORD Dr7;
// registre cu puncte plutitoare
FLOATING_SAVE_AREA FloatSave;
// Segmente de registru
SegGs DWORD;
DWORD SegFs;
SegEs DWORD;
SegDs DWORD;
// Registre întregi
DWORD Edi;
DWORD Esi;
DWORD Ebx;
DWORD Edx;
DWORD Ecx;
DWORD Eax;
// Registre de control
DWORD Ebp;
DWORD Eip;
SegCs DWORD;
DWORD EFlags;
DWORD Esp;
DWORD SegSs;
// Registre suplimentare
BYTE ExtendedRegistează [MAXIMUM_SUPPORTED_EXTENSION];
# endif
// ALPHA, _ MIPS_, _AMD64_, _M_IA64 și altele.
e) Lista 2
/ * ++
Numele modulului:
spurp.h
Descriere:
Definește tipul dispozitivului asociat cu SPURP,
funcția de procesare și codul IOCTL pentru aplicații și driver
--* /
#ifndef SPURP_H
# definește SPURP_H
// macro care definește codul pentru noul IOCTL
#define IOCTL_SWITCH_CONTEXTS CTL_CODE (FILE_DEVICE_UNKNOWN, 0x802, \
METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA)
#define SPURP_DEVICE_NAME_U L "\\ Device \\ SPURP"
#define SPURP_WIN_DEVICE_NAME_U L "\\ DosDevices \\ SPURP"
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRINGregiunea Path
);
NTSTATUS
SwitchStackDispatchIoctl (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
NULĂ
SpurpUnload (
IN PDRIVER_OBJECT DriverObject
);
# endif
f) Lista 3
/ * ++
Numele modulului:
spurp.c
Descriere:
conducătorul auto care execută funcții de utilizator
cu argumentele transferate în modul kernel
--* /
#include
#include "spurp.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text (INIT, DriverEntry)
#pragma alloc_text (PAGE, SwitchStackDispatchIoctl)
#pragma alloc_text (PAGE, SpurpUnload)
# endif
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
În PUNICODE_STRINGPath of Registry
)
Statutul NTSTATUS = STATUS_SUCCESS;
UNICODE_STRING unicodeDeviceName;
UNICODE_STRING unicodeWinDeviceName;
PDEVICE_OBJECT deviceObject;
status = IoCreateDevice (
DriverObject,
0
unicodeDeviceName,
FILE_DEVICE_UNKNOWN,
0
(BOOLEAN) TRUE,
deviceObject
);
dacă (! NT_SUCCESS (status))
statutul de returnare;
>
//
// Selectați memoria și inițializați UNICODE - șirul cu numele
// dispozitivul nostru, vizibil în subsistemul Win32
//
(vid) RtlInitUnicodeString (void) unicodeWinDeviceName, SPURP_WIN_DEVICE_NAME_U);
status = IoCreateSymbolicLink (
(PUNICODE_STRING) unicodeWinDeviceName,
(PUNICODE_STRING) unicodeDeviceName
);
dacă (! NT_SUCCESS (status))
IoDeleteDevice (deviceObject);
statutul de returnare;
>
DriverObject-> MajorFunction [IRP_MJ_DEVICE_CONTROL] = SwitchStackDispatchIoctl;
DriverObject-> DriverUnload = SpurpUnload;
// ++
// SwitchStackDispatchIoctl
//
// Aceasta este rutina de expediere a proceselor
// Funcții de control I / O ale dispozitivului trimise la acest dispozitiv
//
// Parametri:
// DeviceObject - pointer și obiect de dispozitiv
// Irp este un pointer la un pachet de solicitare I / O
//
// Valoarea returnata:
// Statutul de finalizare NSTATUS IRP
//
// -
NTSTATUS SwitchStackDispatchIoctl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
PIO_STACK_LOCATION Io_s;
Statutul NTSTATUS;
//
// Obțineți un pointer la poziția curentă a stivei I / O (I / O Stack)
//
Io_s = IoGetCurrentIrpStackLocation (Irp);
//
// Asigurați-vă că acest lucru este valabil. IOCTL pentru noi.
//
dacă (Io_s-> Parameters.DeviceIoControl.IoControlCode! = IOCTL_SWITCH_CONTEXTS)
Stare = STATUS_INVALID_PARAMETER;
>
altfel
//
// Obțineți un pointer la funcția de apelat.
//
VOID (* UserFunctToCall) (PULONG) = Irp-> UserBuffer;
//
// și argumentul de trimis
//
PVOID UserArg;
UserArg = Io_s-> Parameters.DeviceIoControl.Type3InputBuffer;
//
// Apelați funcția utilizatorului cu parametrii expediați
//
(VOID) (* UserFunctToCall) ((UserArg));
Stare = STATUS_SUCCESS;
>
Irp-> IoStatus.Status = Statut;
Irp-> IoStatus.Information = 0;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
retur (Stare);
>
// ++
// SpurpUnload
//
// Această funcție eliberează șoferul
// și elimină obiectul dispozitivului (obiect dispozitiv).
//
// Parametri:
// DeviceObject - indicatorul obiectului dispozitivului
//
// Valoarea returnata:
// VOID (funcția oprește driverul)
//
// -
VOID SpurpUnload (ÎN PDRIVER_OBJECT DriverObject)
UNICODE_STRING uniWin32NameString;
//
// Eliminați numele dispozitivului vizibil
//
RtlInitUnicodeString ( uniWin32NameString, SPURP_WIN_DEVICE_NAME_U);
IoDeleteSymbolicLink ( uniWin32NameString);
//
// Ștergeți dispozitivul
//
IoDeleteDevice (DriverObject-> DeviceObject);
g) Lista 4
; Numele modulului:
; spurp.inf
; Descriere:
; datele de instalare pentru driverul spurp.sys
[DestinationDirs]
SPURP.Files.x86_12 = 12
[SPURP_Inst.ntx86.Services]
AddService = spurp, 0x00000002, SPURP_Service_Instx86,
[SPURP_Service_Instx86]
ServiceType =% SERVICE_KERNEL_DRIVER%
StartType =% SERVICE_SYSTEM_START%
ErrorControl =% SERVICE_ERROR_NORMAL%
ServiceBinary =% 12% \ spurp.sys
[SPURP_EventLog_Inst]
AddReg = SPURP_EventLog_Inst.AddReg
[SPURP_EventLog_Inst.AddReg]
HKR ,, EventMessageFile,% REG_EXPAND_SZ%, "%% SystemRoot %% \ System32 \ IoLogMsg.dll"
HKR ,, TypesSupported,% REG_DWORD%, 7
; ******* Stringuri care nu pot fi localizate *******
SERVICE_BOOT_START = 0x0
SERVICE_SYSTEM_START = 0x1
SERVICE_AUTO_START = 0x2
SERVICE_DEMAND_START = 0x3
SERVICE_DISABLED = 0x4
SERVICE_KERNEL_DRIVER = 0x1
SERVICE_ERROR_IGNORE = 0x0
SERVICE_ERROR_NORMAL = 0x1
SERVICE_ERROR_SEVERE = 0x2
SERVICE_ERROR_CRITICAL = 0x3
De fapt, aceasta este cercetarea mea, în timpul căreia am scris un driver de pseudo-dispozitiv.
Semnificația acestei dezvoltări este stipulată în textul studiului și înțeleg despre posibilități, cred și astfel este clar pentru toți (execuția comenzilor la nivelul kernel-ului din modul de utilizare, care extinde semnificativ posibilitățile de utilizare a sistemului).
Trimiteți-le prietenilor: