Belső kontrasztok (külső környezetek)
Az ál-eszközmeghajtó létrehozásának ötlete nem jött azonnal. Az út elején a kérdés az előtérben volt számomra - ez a program egyáltalán hasznos? Az átlagos programozó, és még inkább a felhasználó igényli a lemez kvótazáró mechanizmust, vagy írja a memóriába a "nincs hozzáférés" attribútumot? Most, hogy az első vizsgálati eredmények a Windows NT operációs rendszerben érkeznek, már nem kétséges. Véleményem szerint ez a program a leghasznosabb az informatikai biztonság területén dolgozó szakértők számára, az operációs rendszer WindowsNT használatával. ez a program segít a hatékony alkalmazások fejlesztőinek a WindoewsNT információbiztonságának biztosításához.
Szintén kívánatos egy ötlet az eszközvezérlők építészeti modelljéről. Különös hangsúlyt kap a szoftverkörnyezet és a bemeneti / kimeneti rendszerkezelő kölcsönhatása.
2. Kernel mód és felhasználói mód
Pentium mikroprocesszor négy hozzáférési szintek (hozzáférési szintek), más néven a gyűrű (gyűrűk), amely vezérli, például a hozzáférést a memória, a képesség, hogy néhány kritikus parancs processzor (például a parancsokat védelmével kapcsolatos) stb Mindegyik szál ezen a privilegiumnál van. A 0-as csengetés a leginkább privilegizált szint, amely teljes hozzáférést biztosít az összes memóriához és az összes processzorparancshoz. A 3. gyűrű a legkevésbé privilegizált szint.
Annak érdekében, hogy kompatibilitás alapuló rendszerek processzorok eltérő megjelent, az Intel, a Windows NT csak két szintje kiváltságok - Ring 0 és 3 Ha a szál fut ring 0, azt mondják, hogy fut kernel módban (kernel mód) . Az irodalomban a kernel módot néha felügyeleti módnak is hívják. Ha a szál a 3. gyűrűben fut, azt mondják, hogy felhasználói üzemmódban fut. Felhasználói módban a környezet alkalmazásai és alrendszerei futnak (Win32, OS / 2 és POSIX). A grafikus rendszert, a grafikus illesztőprogramokat, a nyomtatóillesztőket és az ablakkezelőt kernel módban hajtják végre (lásd a "Windows NT Architecture in Simplified View" ábrát). A felhasználói mód végrehajtásának módja sokkal megbízhatóbb, de további költségeket igényel, amelyek csökkentik a folyamat általános teljesítményét. A felhasználói módban végrehajtott kód nem tudja megtörni a Windows NT futtatható, a rendszermag és az eszközillesztők integritását. Érdekes módon az eszközvezérlők kernel módban működnek. Ez a körülmény két következménnyel jár. Először is, ellentétben egy nem megfelelően működő alkalmazással, egy nem megfelelően működő eszközillesztő megszakíthatja a teljes rendszert, mivel hozzáfér a teljes rendszerkódhoz és az összes memóriához. Másodszor, egy alkalmazásprogramozó hozzáférhet a védett erőforrásokhoz egy hamis eszközillesztővel, bár ez nem könnyű feladat.
#ifdef _X86_ // szerkezet az x86 processzor modellre vonatkozik
typedef struct _CONTEXT
// a bit-jelzőkészlet, amely meghatározza a struktúra tartalmát
DWORD ContextFlags;
// Hibakeresési nyilvántartások
DWORD Dr0;
DWORD Dr1;
DWORD Dr2;
DWORD Dr3;
DWORD Dr6;
DWORD Dr7;
// lebegőpontos regiszterek
FLOATING_SAVE_AREA FloatSave;
// szegmensrekordok
DWORD SegGs;
DWORD SegFs;
DWORD szegmensek;
DWORD SegDs;
// Integer regiszterek
DWORD Edi;
DWORD Esi;
DWORD Ebx;
DWORD Edx;
DWORD Ecx;
DWORD Eax;
// Ellenőrzési nyilvántartások
DWORD Ebp;
DWORD Eip;
DWORD szegmensek;
DWORD EFlags;
DWORD Esp;
DWORD SegSs;
Kiegészítő nyilvántartások
BYTE ExtendedRegisters [MAXIMUM_SUPPORTED_EXTENSION];
#endif
// ALPHA, _ MIPS_, _AMD64_, _M_IA64 és mások.
e) felsorolás 2
/ * ++
Modulnév:
spurp.h
Leírás:
Meghatározza az SPURP-hez kapcsolódó eszköztípust,
feldolgozási funkció és IOCTL kód az alkalmazásokhoz és a meghajtóhoz
--* /
#ifndef SPURP_H
#define SPURP_H
// a makró, amely meghatározza az új IOCTL kódját
#define IOCTL_SWITCH_CONTEXTS CTL_CODE (FILE_DEVICE_UNKNOWN, 0x802, \
METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA)
#define SPURP_DEVICE_NAME_U L "\\ Eszköz \\ SPURP"
#define SPURP_WIN_DEVICE_NAME_U L "\\ DosDevices \\ SPURP"
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING rendszerleíró adatbázisbanPath
);
NTSTATUS
SwitchStackDispatchIoctl (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp);
VOID
SpurpUnload (
IN PDRIVER_OBJECT DriverObject
);
#endif
f) felsorolás 3
/ * ++
Modulnév:
spurp.c
Leírás:
a felhasználói funkciókat végrehajtó illesztőprogram
a kernel módban elfogadott érvekkel
--* /
#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,
IN PUNICODE_STRING RegistryPath
)
NTSTATUS status = STATUS_SUCCESS;
UNICODE_STRING unicodeDeviceName;
UNICODE_STRING unicodeWinDeviceName;
PDEVICE_OBJECT eszközObjektum;
status = IoCreateDevice (
DriverObject,
0
unicodeDeviceName,
FILE_DEVICE_UNKNOWN,
0
(BOOLEAN) IGAZ,
DeviceObject
);
ha (! NT_SUCCESS (állapot))
visszatérési állapot;
>
//
// Válassza ki a memóriát és indítsa el a UNICODE-t - a karakterláncot a névvel
// eszközünk látható a Win32 alrendszerben
//
(üres) RtlInitUnicodeString (üres) unicodeWinDeviceName, SPURP_WIN_DEVICE_NAME_U);
status = IoCreateSymbolicLink (
(PUNICODE_STRING) unicodeWinDeviceName,
(PUNICODE_STRING) unicodeDeviceName
);
ha (! NT_SUCCESS (állapot))
IoDeleteDevice (deviceObject);
visszatérési állapot;
>
DriverObject-> MajorFunction [IRP_MJ_DEVICE_CONTROL] = SwitchStackDispatchIoctl;
DriverObject-> DriverUnload = SpurpUnload;
// ++
// SwitchStackDispatchIoctl
//
// Ez a küldési rutin, mely folyamatok
// Eszköz I / O vezérlőfunkciók erre az eszközre
//
// Paraméterek:
// DeviceObject - mutató és eszközobjektum
// Irp egy mutató egy I / O Request Packet-hez
//
// Visszatérési érték:
// NSTATUS IRP befejezési állapot
//
// -
NTSTATUS SwitchStackDispatchIoctl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
PIO_STACK_LOCATION Io_s;
NTSTATUS státusz;
//
// Mutasson egy mutatót az I / O verem aktuális pozíciójához (I / O Stack)
//
Io_s = IoGetCurrentIrpStackLocation (Irp);
//
// Győződjön meg arról, hogy ez érvényes, az IOCTL számunkra.
//
ha (Io_s-> Parameters.DeviceIoControl.IoControlCode! = IOCTL_SWITCH_CONTEXTS)
Status = STATUS_INVALID_PARAMETER;
>
más
//
// Mutasson egy mutatót a hívni kívánt függvényre.
//
VOID (* UserFunctToCall) (PULONG) = Irp-> UserBuffer;
//
// és a küldeni kívánt érv
//
PVOID UserArg;
UserArg = Io_s-> Parameters.DeviceIoControl.Type3InputBuffer;
//
// Hívja a felhasználói funkciót az elavult paraméterekkel
//
(VOID) (* UserFunctToCall) ((UserArg));
Status = STATUS_SUCCESS;
>
Irp-> IoStatus.Status = Állapot;
Irp-> IoStatus.Information = 0;
IoCompleteRequest (Irp, IO_NO_INCREMENT);
visszatérés (Állapot);
>
// ++
// SpurpUnload
//
// Ez a funkció felszabadítja a meghajtót
// erőforrásokat és eltávolítja eszközobjektumát (eszközobjektumát).
//
// Paraméterek:
// DeviceObject - mutató az eszközobjektumhoz
//
// Visszatérési érték:
// VOID (a funkció leállítja a meghajtót)
//
// -
VOID SpurpUnload (IN PDRIVER_OBJECT DriverObject)
UNICODE_STRING uniWin32NameString;
//
// Vegye le a látható eszköz nevét
//
RtlInitUnicodeString ( uniWin32NameString, SPURP_WIN_DEVICE_NAME_U);
IoDeleteSymbolicLink ( uniWin32NameString);
//
// A készülék törlése
//
IoDeleteDevice (DriverObject-> DeviceObject);
g) 4. felsorolás
Modulnév:
; spurp.inf
; Leírás:
; a spurp.sys illesztőprogram telepítési adatai
[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 ,, Típusok támogatott,% REG_DWORD%, 7
; ******* Nem lokalizálható karakterláncok *******
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
Valójában ez az én kutatásom, amelynek során pszeudo eszköz-illesztőprogramot írtam.
Ennek a fejlesztésnek a jelentését a tanulmány szövege írja le, és a lehetőségekről megértem, úgy gondolom, és így mindenki számára egyértelmű (parancsmunka végrehajtása a kernel szintjén a felhasználói módból, ami jelentősen bővíti a rendszer használatának lehetőségeit).
