DOS és NT útvonalak konvertálása RTL függvényekkel

Ha ezt a bejegyzést olvasod, az azt jelenti, hogy módot keresel a DOS és/vagy NT útvonalak konvertálására a szoftveredben. Légy nyugodt, pontosan ezt fogod ma itt megtanulni!

A Windows útvonalak problémája nyilvánvaló: rendkívül zavaros. Hadd ismételjem meg: rendkívül zavaros. Ez problémává válik, amikor a fantasztikus szoftvereden dolgozol, és DOS és NT útvonalakat kell konvertálnod.

Ebben a cikkben megpróbálom röviden és tömören tartani a dolgokat, szóval kezdjük is.

Az ntdll-ben vannak dokumentálatlan függvények, amelyek különböző konverziókhoz használhatók. Ezek a függvények Rtl* előtaggal kezdődnek, és a következők:

RtlDosPathNameToNtPathName_U (minden Windows)
RtlDosPathNameToNtPathName_U_WithStatus (minden Windows)
RtlDosLongPathNameToNtPathName_U_WithStatus (Windows 10 Redstone 3)
RtlDosPathNameToRelativeNtPathName_U (minden Windows)
RtlDosPathNameToRelativeNtPathName_U_WithStatus (minden Windows)
RtlDosLongPathNameToRelativeNtPathName_U_WithStatus (Windows 10 Redstone 3)
RtlNtPathNameToDosPathName (minden Windows; Ez a függvény meglehetősen rejtélyes, mert sehol sem találsz hozzá definíciókat vagy információt. Mindazonáltal az összes függvényt megfelelően teszteljük és megnézzük az eredményüket.)

A fenti függvények azonos bemeneti/kimeneti paraméterekkel rendelkeznek:

DosFileName (be - kötelező): Egy konstans sztring, amely a cél fájl vagy könyvtár DOS nevét tartalmazza.
NtFileName (ki - kötelező): Az NT útvonalat adja vissza egy fájlhoz vagy könyvtárhoz. UNICODE_STRING-et kell használni, amelyet nem kell inicializálni.
FilePart (ki - opcionális): A kimenetben a fájlnév címe kerül a mutatóba a generált útvonalban. Ha ez a paraméter NULL értékkel van kitöltve a kimenetben, akkor csak a könyvtárnév van megadva.
RelativeName (ki - opcionális): Mutató egy RTL_RELATIVE_NAME_U struktúrára, amely az aktuális könyvtárról tartalmaz információt.

A függvények teszteléséhez 3 útvonalat definiáltam:

1static const wchar_t NormalNamespace[MAX_PATH] = L"C:\\Windows\\System32\\csrss.exe"; // Normal Win32 namespace
2static const wchar_t DeviceNamespace[MAX_PATH] = L"\\\\.\\C:\\Windows\\System32\\csrss.exe"; // Win32 Device Namespace
3static const wchar_t FileNamespace[MAX_PATH] = L"\\\\?\\C:\\Windows\\System32\\csrss.exe"; // Win32 Device Namespace
4static const wchar_t DevicePath[MAX_PATH] = L"\\Device\\HarddiskVolume1\\Windows\\System32\\csrss.exe"; // Win32 Device Path
5static const wchar_t ExtraTest[MAX_PATH] = L"directory.name\\file.name"; // Relative Path

Az RtlDosPathNameToNtPathName_U használata

Ez a függvény BOOLEAN értéket ad vissza.

TRUE - Az útvonal-átalakítási művelet sikeresen befejeződött.
FALSE - Az útvonal-konverziós művelet sikertelen volt.

Kód:

 1{
 2UNICODE_STRING Converted{};
 3RTL_RELATIVE_NAME_U RelativeName{};
 4PWSTR FilePart{};
 5
 6    static const wchar_t NormalNamespace[MAX_PATH]  = L"C:\\Windows\\System32\\csrss.exe"; // Normal Win32 namespace
 7    static const wchar_t DeviceNamespace[MAX_PATH]  = L"\\\\.\\C:\\Windows\\System32\\csrss.exe"; // Win32 Device Namespace
 8    static const wchar_t FileNamespace[MAX_PATH]    = L"\\\\?\\C:\\Windows\\System32\\csrss.exe"; // Win32 Device Namespace
 9    static const wchar_t DevicePath[MAX_PATH]       = L"\\Device\\HarddiskVolume1\\Windows\\System32\\csrss.exe"; // Win32 Device Path
10    static const wchar_t ExtraTest[MAX_PATH]        = L"directory.name\\file.name"; // Relative Path
11
12    pRtlDosPathNameToNtPathName_U _RtlDosPathNameToNtPathName_U = reinterpret_cast<pRtlDosPathNameToNtPathName_U>(GetProcAddress(GetModuleHandle(L"ntdll.dll"), "RtlDosPathNameToNtPathName_U"));
13
14    if (_RtlDosPathNameToNtPathName_U(NormalNamespace, &Converted, &FilePart, &RelativeName))
15    {
16        std::wcout << L"[NormalNamespace] (previous): " << NormalNamespace << std::endl;
17        std::wcout << L"[NormalNamespace] (converted): " << Converted.Buffer << std::endl;
18        std::wcout << L"[NormalNamespace] FilePart: " << FilePart << std::endl;
19        std::wcout << L"[NormalNamespace] RelativeName.Buffer: " << ((RelativeName.RelativeName.Buffer != NULL) ? RelativeName.RelativeName.Buffer : L"NULL") << std::endl;
20        std::wcout << L"[NormalNamespace] ContainingDirectory: " << (void*)RelativeName.ContainingDirectory << std::endl;
21        std::wcout << L"[NormalNamespace] CurDirRef->DirectoryHandle: " << ((RelativeName.CurDirRef != nullptr) ? (void*)RelativeName.CurDirRef->DirectoryHandle : L"NULL") << std::endl;
22        std::wcout << L"[NormalNamespace] CurDirRef->ReferenceCount: " << ((RelativeName.CurDirRef != nullptr) ? RelativeName.CurDirRef->ReferenceCount : 0UL) << std::endl;
23    }
24
25    std::wcout << L"------------------------------------------------------------------------" << std::endl;
26
27    Converted = { 0 };
28    RelativeName = { 0 };
29    FilePart = { 0 };
30
31    if (_RtlDosPathNameToNtPathName_U(DeviceNamespace, &Converted, &FilePart, &RelativeName))
32    {
33        std::wcout << L"[DeviceNamespace] (previous): " << DeviceNamespace << std::endl;
34        std::wcout << L"[DeviceNamespace] (converted): " << Converted.Buffer << std::endl;
35        std::wcout << L"[DeviceNamespace] FilePart: " << FilePart << std::endl;
36        std::wcout << L"[DeviceNamespace] RelativeName.Buffer: " << ((RelativeName.RelativeName.Buffer != NULL) ? RelativeName.RelativeName.Buffer : L"NULL") << std::endl;
37        std::wcout << L"[DeviceNamespace] ContainingDirectory: " << (void*)RelativeName.ContainingDirectory << std::endl;
38        std::wcout << L"[DeviceNamespace] CurDirRef->DirectoryHandle: " << ((RelativeName.CurDirRef != nullptr) ? (void*)RelativeName.CurDirRef->DirectoryHandle : L"NULL") << std::endl;
39        std::wcout << L"[DeviceNamespace] CurDirRef->ReferenceCount: " << ((RelativeName.CurDirRef != nullptr) ? RelativeName.CurDirRef->ReferenceCount : 0UL) << std::endl;
40    }
41
42    std::wcout << L"------------------------------------------------------------------------" << std::endl;
43
44    Converted = { 0 };
45    RelativeName = { 0 };
46    FilePart = { 0 };
47
48    if (_RtlDosPathNameToNtPathName_U(FileNamespace, &Converted, &FilePart, &RelativeName))
49    {
50        std::wcout << L"[FileNamespace] (previous): " << FileNamespace << std::endl;
51        std::wcout << L"[FileNamespace] (converted): " << Converted.Buffer << std::endl;
52        std::wcout << L"[FileNamespace] FilePart: " << FilePart << std::endl;
53        std::wcout << L"[FileNamespace] RelativeName.Buffer: " << ((RelativeName.RelativeName.Buffer != NULL) ? RelativeName.RelativeName.Buffer : L"NULL") << std::endl;
54        std::wcout << L"[FileNamespace] ContainingDirectory: " << (void*)RelativeName.ContainingDirectory << std::endl;
55        std::wcout << L"[FileNamespace] CurDirRef->DirectoryHandle: " << ((RelativeName.CurDirRef != nullptr) ? (void*)RelativeName.CurDirRef->DirectoryHandle : L"NULL") << std::endl;
56        std::wcout << L"[FileNamespace] CurDirRef->ReferenceCount: " << ((RelativeName.CurDirRef != nullptr) ? RelativeName.CurDirRef->ReferenceCount : 0UL) << std::endl;
57    }
58
59    std::wcout << L"------------------------------------------------------------------------" << std::endl;
60
61    Converted = { 0 };
62    RelativeName = { 0 };
63    FilePart = { 0 };
64
65    if (_RtlDosPathNameToNtPathName_U(DevicePath, &Converted, &FilePart, &RelativeName))
66    {
67        std::wcout << L"[DevicePath] (previous): " << DevicePath << std::endl;
68        std::wcout << L"[DevicePath] (converted): " << Converted.Buffer << std::endl;
69        std::wcout << L"[DevicePath] FilePart: " << FilePart << std::endl;
70        std::wcout << L"[DevicePath] RelativeName.Buffer: " << ((RelativeName.RelativeName.Buffer != NULL) ? RelativeName.RelativeName.Buffer : L"NULL") << std::endl;
71        std::wcout << L"[DevicePath] ContainingDirectory: " << (void*)RelativeName.ContainingDirectory << std::endl;
72        std::wcout << L"[DevicePath] CurDirRef->DirectoryHandle: " << ((RelativeName.CurDirRef != nullptr) ? (void*)RelativeName.CurDirRef->DirectoryHandle : L"NULL") << std::endl;
73        std::wcout << L"[DevicePath] CurDirRef->ReferenceCount: " << ((RelativeName.CurDirRef != nullptr) ? RelativeName.CurDirRef->ReferenceCount : 0UL) << std::endl;
74    }
75
76    std::wcout << L"------------------------------------------------------------------------" << std::endl;
77
78    Converted = { 0 };
79    RelativeName = { 0 };
80    FilePart = { 0 };
81
82    if (_RtlDosPathNameToNtPathName_U(ExtraTest, &Converted, &FilePart, &RelativeName))
83    {
84        std::wcout << L"[ExtraTest] (previous): " << ExtraTest << std::endl;
85        std::wcout << L"[ExtraTest] (converted): " << Converted.Buffer << std::endl;
86        std::wcout << L"[ExtraTest] FilePart: " << FilePart << std::endl;
87        std::wcout << L"[ExtraTest] RelativeName.Buffer: " << ((RelativeName.RelativeName.Buffer != NULL) ? RelativeName.RelativeName.Buffer : L"NULL") << std::endl;
88        std::wcout << L"[ExtraTest] ContainingDirectory: " << (void*)RelativeName.ContainingDirectory << std::endl;
89        std::wcout << L"[ExtraTest] CurDirRef->DirectoryHandle: " << ((RelativeName.CurDirRef != nullptr) ? (void*)RelativeName.CurDirRef->DirectoryHandle : L"NULL") << std::endl;
90        std::wcout << L"[ExtraTest] CurDirRef->ReferenceCount: " << ((RelativeName.CurDirRef != nullptr) ? RelativeName.CurDirRef->ReferenceCount : 0UL) << std::endl;
91    }
92
93}

Eredmény:

Megjegyzések:

Ha relatív útvonalat használsz, a függvény továbbra is sikeresen végrehajtódik. A kimenet azonban nemcsak az NT útvonalat fogja tartalmazni, hanem az aktuális munkakönyvtár útvonalát is elé fogja illeszteni. Nézd meg az utolsó teszteredményt.

Az RtlDosPathNameToNtPathName_U_WithStatus használata

Ez a függvény NTSTATUS-t ad vissza BOOLEAN helyett.

Pontosan ugyanaz, mint a fenti RtlDosPathNameToNtPathName_U, azonban ezzel a verzióval lekérheted az utolsó NTSTATUS-t, ha a függvény sikertelen volt.

Az RtlDosLongPathNameToNtPathName_U_WithStatus használata

Ez a függvény NTSTATUS-t ad vissza.

A tesztjeim alapján ez a függvény pontosan ugyanazt az eredményt adta, mint a fenti, azonban ezzel a verzióval lekérheted az utolsó NTSTATUS-t, ha a függvény sikertelen volt.

Ez a függvény csak a Windows 10 Redstone 3-tól érhető el. Nem találok semmi különlegeset róla.

A feltételezésem szerint hosszabb útvonalakat tud konvertálni, innen a “long” a függvény nevében.

Az RtlDosPathNameToRelativeNtPathName_U használata

Ez a függvény BOOLEAN-t ad vissza.

A tesztjeim alapján ez a függvény pontosan ugyanazt az eredményt adta, mint a fenti, szóval nem vagyok biztos benne, mi a helyzet vele. (nyugodtan írj hozzászólást)

Az RtlDosPathNameToRelativeNtPathName_U_WithStatus használata

Ez a függvény NTSTATUS-t ad vissza BOOLEAN helyett.

A tesztjeim alapján ez a függvény pontosan ugyanazt az eredményt adta, mint a fenti, szóval nem vagyok biztos benne, mi a helyzet vele. (nyugodtan írj hozzászólást)

Az RtlDosLongPathNameToRelativeNtPathName_U_WithStatus használata

Ez a függvény NTSTATUS-t ad vissza BOOLEAN helyett.

Ez a függvény ismét ugyanazokat az eredményeket adta, talán rosszul hívom meg. (nyugodtan írj hozzászólást)

Ez a függvény csak a Windows 10 Redstone 3-tól érhető el.

Az RtlNtPathNameToDosPathName használata

Ez a függvény NTSTATUS-t ad vissza.

Maga a függvény érdekes, mivel a célja az, hogy megfordítsa azt, amit fent elértünk. Őszintén szólva nehézségeim voltak bármilyen dokumentációt találni, bármit is, csak hogy tesztelni tudjam.

Flags (be - opcionális): Fogalmam sincs, mire való.
Path (be/ki - kötelező): Mutató egy inicializált RTL_UNICODE_STRING_BUFFER struktúrára. A végrehajtás után az eredményt is tartalmazza.
Disposition (be - opcionális): Fogalmam sincs, mire való.
FilePart (ki - opcionális): Fogalmam sincs, mire való.

A tesztjeim alapján ezzel a függvénnyel csak útvonalakat konvertálhatsz, teljes útvonalakat (pl. fájlhoz) nem. Ha teljes útvonalat próbálsz, nem konvertálja, de normálisan végrehajtódik o.O

Kód:

 1{
 2
 3    RTL_UNICODE_STRING_BUFFER DosPath = { 0 };
 4    PWSTR FilePart{};
 5
 6    UNICODE_STRING NtPath;
 7    RtlInitUnicodeString(&NtPath, L"\\??\\C:\\WINDOWS\\system32\\drivers");
 8
 9    wchar_t* DosPathBuffer = NULL;
10    wchar_t* NtPathBuffer = NULL;
11
12    DosPathBuffer = (wchar_t*)new char[NtPath.Length + sizeof(wchar_t)];
13    NtPathBuffer  = (wchar_t*)new char[NtPath.Length + sizeof(wchar_t)];
14
15    RtlZeroMemory(DosPathBuffer, NtPath.Length + sizeof(wchar_t));
16    RtlZeroMemory(NtPathBuffer, NtPath.Length + sizeof(wchar_t));
17    RtlCopyMemory(DosPathBuffer, NtPath.Buffer, NtPath.Length);
18    RtlCopyMemory(NtPathBuffer, NtPath.Buffer, NtPath.Length);
19
20    DosPath.ByteBuffer.Buffer       = DosPathBuffer;
21    DosPath.ByteBuffer.StaticBuffer = NtPathBuffer;
22    DosPath.String.Buffer           = NtPath.Buffer;
23    DosPath.String.Length           = NtPath.Length;
24    DosPath.String.MaximumLength    = NtPath.Length;
25    DosPath.ByteBuffer.Size         = NtPath.Length;
26    DosPath.ByteBuffer.StaticSize   = NtPath.Length;
27
28    pRtlNtPathNameToDosPathName _RtlNtPathNameToDosPathName = reinterpret_cast<pRtlNtPathNameToDosPathName>(GetProcAddress(GetModuleHandle(L"ntdll.dll"), "RtlNtPathNameToDosPathName"));
29
30    if (NT_SUCCESS(_RtlNtPathNameToDosPathName(0, &DosPath, NULL, &FilePart)))
31    {
32        //RtlCopyMemory(pszDosPath, ByteDosPathBuffer, wcslen(ByteDosPathBuffer) * sizeof(wchar_t));
33
34        std::wcout << L"[NtPath] (previous): " << NtPath.Buffer << std::endl;
35        std::wcout << L"[DosPathBuffer] (converted): " << DosPathBuffer << std::endl;
36        std::wcout << L"[NtPathBuffer] (untouched): " << NtPathBuffer << std::endl;
37        std::wcout << L"[NormalNamespace] FilePart: " << ((FilePart != nullptr) ? FilePart : L"NULL") << std::endl;
38    }
39
40    std::wcout << L"------------------------------------------------------------------------" << std::endl;
41
42}

Eredmény:

Az általam bemutatott kódpélda zavaros, de hadd próbáljam meg tisztázni a helyzetet. Ami történik, az az, hogy ez a függvény kicseréli az NT útvonalakat a megadott struktúrában.

Beállítottam egy töréspontot a függvény végrehajtása előtt: