🖍️ 🈴 🤵🏿 पर्यावरण चर के बारे में कहानी की निरंतरता, या पीईबी की जगह 👨🏻‍🚀 🚅 🖕🏽

आज रात पहली बार मैंने इस विषय में ilya314 कमियों के बारे में यहाँ लिखने के लिए Habré पर पंजीकरण करने का निर्णय लिया, लेकिन मुझे बहुत आश्चर्य हुआ कि मैं किसी भी चीज़ पर टिप्पणी नहीं कर सकता, क्योंकि मैं एक सम्मानजनक ~~हबल-उपयोगकर्ता~~ नहीं हूँ। क्या खौफ है।

इसलिए, मैंने PEB प्रक्रिया से Syshny रनटाइम में डेटा को डुप्लिकेट करने की समस्या पर अपने विचार व्यक्त करने के लिए कोड को संक्षेप में बताने का निर्णय लिया।

असल में, लेखक के पास जो समस्या है, उसे हल करने के लिए, कई तरीके हैं - उनमें से सबसे सरल है गेटेन रनटाइम के लाइब्रेरी फ़ंक्शंस को छोड़ देना और कर्नेल 32 का उपयोग करना। लेकिन विषय को और विकसित करते हुए, मैं पर्यावरण चर खोजना चाहता था और एक विशिष्ट प्रक्रिया के लिए उन्हें बदलने का प्रयास करना चाहता था।

आइए एक आंख के साथ अनिर्धारित पीईबी विज्ञापन पर एक नज़र डालें (एम $, निश्चित रूप से, हमें गुणों की एक एड़ी प्रदान करता है, लेकिन Google या डीबगर के उचित उपयोग के साथ, सब कुछ जगह में आता है):

typedef struct _PEB { BOOLEAN InheritedAddressSpace; BOOLEAN ReadImageFileExecOptions; BOOLEAN BeingDebugged; BOOLEAN Spare; HANDLE Mutant; PVOID ImageBaseAddress; PPEB_LDR_DATA LoaderData; PRTL_USER_PROCESS_PARAMETERS ProcessParameters; PVOID SubSystemData; PVOID ProcessHeap; PVOID FastPebLock; PPEBLOCKROUTINE FastPebLockRoutine; PPEBLOCKROUTINE FastPebUnlockRoutine; ULONG EnvironmentUpdateCount; PPVOID KernelCallbackTable; PVOID EventLogSection; PVOID EventLog; PPEB_FREE_BLOCK FreeList; ULONG TlsExpansionCounter; PVOID TlsBitmap; ULONG TlsBitmapBits[0x2]; PVOID ReadOnlySharedMemoryBase; PVOID ReadOnlySharedMemoryHeap; PPVOID ReadOnlyStaticServerData; PVOID AnsiCodePageData; PVOID OemCodePageData; PVOID UnicodeCaseTableData; ULONG NumberOfProcessors; ULONG NtGlobalFlag; BYTE Spare2[0x4]; LARGE_INTEGER CriticalSectionTimeout; ULONG HeapSegmentReserve; ULONG HeapSegmentCommit; ULONG HeapDeCommitTotalFreeThreshold; ULONG HeapDeCommitFreeBlockThreshold; ULONG NumberOfHeaps; ULONG MaximumNumberOfHeaps; PPVOID *ProcessHeaps; PVOID GdiSharedHandleTable; PVOID ProcessStarterHelper; PVOID GdiDCAttributeList; PVOID LoaderLock; ULONG OSMajorVersion; ULONG OSMinorVersion; ULONG OSBuildNumber; ULONG OSPlatformId; ULONG ImageSubSystem; ULONG ImageSubSystemMajorVersion; ULONG ImageSubSystemMinorVersion; ULONG GdiHandleBuffer[0x22]; ULONG PostProcessInitRoutine; ULONG TlsExpansionBitmap; BYTE TlsExpansionBitmapBits[0x80]; ULONG SessionId; } PEB, *PPEB;

हम ProcessParameters संपत्ति में रुचि रखते हैं, जिसमें कमांडलाइन शामिल है ; पर्यावरण; और अन्य उपहार जो रिंग 3 से रिंग 3 में डुप्लिकेट किए गए हैं और यहीं से फ्लाई फ्लाई पर Syshnom रनटाइम द्वारा कैश किया गया है। संभवतः, रनटाइम मानक कर्नेल 32-> एनडीटीएल इंटरफेस का उपयोग करता है और उन्हें बस हुक किया जा सकता है, लेकिन मैंने खंड रजिस्टर के माध्यम से पीईबी को खींचने का फैसला किया और डेटा को मेमोरी में प्रचलित के साथ प्रतिस्थापित किया। बस बदलें और देखें कि विंडोज इस पर कैसे प्रतिक्रिया देगा। हाल ही में, मैं AMD64 के तहत जा रहा हूं, इसलिए हम इसे विशेष रूप से इस मंच के लिए संकलित करेंगे।

अद्भुत एम $ समाधान के लिए धन्यवाद, जिसने 64-बिट प्लेटफार्मों के लिए इनलाइन एसम आवेषण की संभावना को काट दिया, हम परियोजना में कोडांतरक कार्यों को ~~चुनने के~~ लिए एक दिलचस्प खोज की प्रतीक्षा कर रहे हैं और एक अलग ऑब्जेक्ट सूची के साथ लिंक (आप इसके लिए एक पूर्ण लेख लिख सकते हैं, इसलिए मैं यहां नहीं रुकूंगा, मैं यह कहूंगा कि मैं बस इसके लिए थक गया, जबकि सब कुछ काम करना चाहिए जैसा कि)।

 ; ; Utils.asm ; INCLUDE Utils.inc .code GetCurrentUserProcessParameters PROC mov rax, gs:[60h] mov rax, [rax + 20h]; ret; GetCurrentUserProcessParameters ENDP END

वैसे, यह ध्यान देने योग्य है कि, विंडोज़ ओएस परिवार के 32-बिट संस्करण के विपरीत, 64-बिट पीईबी में यह जीएस रजिस्टर के सापेक्ष ऑफसेट होता है, 32-बिट संस्करण में इसे इस तरह से प्राप्त किया जा सकता है:

 __declspec(naked) PVOID GetCurrentUserProcessParameters() { __asm { mov eax, fs:[30h]; mov eax, [eax + 10h]; ret; } }

PEB को देखते हुए, 32 बिट्स के लिए, ProcessParameters की ऑफसेट गणना करना आसान है। 4 बाइट्स के संरेखण के साथ, यह 16 बाइट्स में फिट बैठता है। 64 बिट्स के लिए, 8 बाइट पॉइंटर्स को ध्यान में रखते हुए और 4 बाइट्स से जुड़े पहले BOOLEANs, 28 + 4 बाइट्स जारी किए जाएंगे। आप डिबगर का उपयोग करके प्रक्रिया मेमोरी को देखकर इसे सत्यापित कर सकते हैं।

अब हम अपनी प्रक्रिया की PEB में शक्ति एकत्र करेंगे और ProcessParameters को प्रतिस्थापित करेंगे, और अधिक विशेष रूप से, इसके पर्यावरण चर। लेकिन पहले, आइए पर्यावरण ब्लॉक में तारों के भंडारण के प्रारूप को देखें। M $ जोर देते हैं कि लाइनें VAR = VALUE के रूप की हैं और एक शून्य बाइट द्वारा अलग की जाती हैं, ब्लॉक के अंत का संकेत एक पंक्ति में दो शून्य बाइट्स हैं। हम इसे अपनी आँखों से सत्यापित करेंगे और नुकसान पर प्रकाश डालेंगे:

वर्तमान पृष्ठ के लिए मेमोरी सुरक्षा की निगरानी करना और सेवा संरचनाओं को स्पूफिंग और लेखन के बाद उन्हें पुनर्स्थापित करना आवश्यक है
यह हमेशा माना जाना चाहिए कि छवि का निष्पादन योग्य कोड, या इंजेक्शन कोड, एक ही पृष्ठ पर रखा जा सकता है, इसलिए, निष्पादन अधिकार आवंटित किए जाने चाहिए। बेशक, यह संभावना नहीं है, छवियों के संरेखण और स्मृति आवंटन की ग्रेन्युलिटी को ध्यान में रखते हुए, लेकिन इसे सुरक्षित रूप से खेलने के लिए अतिरंजित नहीं होगा, खासकर अगर हम एक खराब वातावरण में खराब / स्थानापन्न हैं
काम खत्म करने के बाद, मूल तालिका (तालिका के सूचक) को पुनर्स्थापित करना न भूलें, जो पहले से सहेजा गया था, और नकली तालिका की मेमोरी को मुक्त कर दिया।
यह उदाहरण प्रकृति में विशुद्ध रूप से अकादमिक है, क्योंकि परिवर्तन के समय पीईबी (किसी अन्य वर्कफ़्लो से) तक पहुँचने वाली प्रणाली से बचने के लिए प्रवेश बिंदु पर यह पहले से एक होना चाहिए। यदि यह अच्छा है, तो यह प्रक्रिया में सभी थ्रेड्स "zanemit" के लायक है और परिवर्तन के समय उन्हें निलंबित कर देता है।

 #include <windows.h> #include <stdio.h> #include <conio.h> #include "Utils.h" typedef struct _LSA_UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } LSA_UNICODE_STRING, *PLSA_UNICODE_STRING, UNICODE_STRING, *PUNICODE_STRING; typedef struct _RTL_USER_PROCESS_PARAMETERS { ULONG MaximumLength; ULONG Length; ULONG Flags; ULONG DebugFlags; PVOID ConsoleHandle; ULONG ConsoleFlags; HANDLE StdInputHandle; HANDLE StdOutputHandle; HANDLE StdErrorHandle; UNICODE_STRING CurrentDirectoryPath; HANDLE CurrentDirectoryHandle; UNICODE_STRING DllPath; UNICODE_STRING ImagePathName; UNICODE_STRING CommandLine; PVOID Environment; ULONG StartingPositionLeft; ULONG StartingPositionTop; ULONG Width; ULONG Height; ULONG CharWidth; ULONG CharHeight; ULONG ConsoleTextAttributes; ULONG WindowFlags; ULONG ShowWindowFlags; UNICODE_STRING WindowTitle; UNICODE_STRING DesktopName; UNICODE_STRING ShellInfo; UNICODE_STRING RuntimeData; PVOID DLCurrentDirectory; } RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS; PVOID ReplacePEBEnvironmentTableAndAddValue(LPCWSTR Variable, LPCWSTR Value) { PRTL_USER_PROCESS_PARAMETERS ProcessParams; MEMORY_BASIC_INFORMATION MemoryInformation; PBYTE NewEnvironment; PWCHAR Token; size_t EnvironmentSize; if (!Variable || !Value || !*Variable || !*Value) return NULL; /*    RTL_USER_PROCESS_PARAMETERS  PEB   */ /*   Environment   */ /*     ,   ,    */ /*  L'\0' L'\0',   MSDN */ /*  4   */ ProcessParams = GetCurrentUserProcessParameters(); Token = (PWCHAR)ProcessParams->Environment; while (!(!*Token && !*(Token + 1))) ++Token; EnvironmentSize = (ULONG_PTR)Token - (ULONG_PTR)ProcessParams->Environment; /*      Environment   ,    */ /*  ,   */ MemoryInformation.AllocationProtect = PAGE_EXECUTE_READWRITE; VirtualQuery(ProcessParams->Environment, &MemoryInformation, sizeof(MEMORY_BASIC_INFORMATION)); /*       Environment +  */ /*          */ /*    */ /*  ,      Environment, */ /*       */ NewEnvironment = (PBYTE)VirtualAlloc(0, EnvironmentSize + 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE); if (NewEnvironment) { /*           */ /*  Var=Value (+ 2 widechar  L'='   ) */ DWORD OldProtect = PAGE_EXECUTE_READWRITE, OldProtect2 = PAGE_EXECUTE_READWRITE; size_t Size = (wcslen(Variable) + wcslen(Value)) * sizeof(WCHAR) + 2 * sizeof(WCHAR); PWCHAR EnvironmentString = malloc(Size); if (EnvironmentString) { /*         */ /*      */ PVOID OldEnvironment = ProcessParams->Environment; UINT EndOfEnvironment = 0; _snwprintf_s(EnvironmentString, Size / sizeof(WCHAR), _TRUNCATE, L"%ws=%ws", Variable, Value); memcpy(NewEnvironment, ProcessParams->Environment, EnvironmentSize); /*     -      MSDN */ *((PWCHAR)(NewEnvironment + EnvironmentSize)) = L'\0'; /*        */ /*    4   */ memcpy(NewEnvironment + EnvironmentSize + 2, EnvironmentString, Size - sizeof(WCHAR)); memcpy(NewEnvironment + EnvironmentSize + 2 + Size - sizeof(WCHAR), &EndOfEnvironment, 4); /*         */ VirtualProtect(NewEnvironment, EnvironmentSize + 0x1000, MemoryInformation.AllocationProtect, &OldProtect); /*     RTL_USER_PROCESS_PARAMETERS  PEB */ /*       */ /*  Environment block       */ VirtualProtect(ProcessParams, sizeof(RTL_USER_PROCESS_PARAMETERS), PAGE_EXECUTE_READWRITE, &OldProtect); ProcessParams->Environment = NewEnvironment; VirtualProtect(ProcessParams, sizeof(RTL_USER_PROCESS_PARAMETERS), OldProtect, &OldProtect2); /*           */ /*     Environment block */ free(EnvironmentString); return OldEnvironment; } VirtualFree(NewEnvironment, 0, MEM_RELEASE); } return NULL; } void RestorePEBEnvironmentTable(PVOID OriginalEnvironment) { PRTL_USER_PROCESS_PARAMETERS ProcessParams; DWORD OldProtect = PAGE_EXECUTE_READWRITE, OldProtect2; PVOID OldEnvironment; if (!OriginalEnvironment) return; /*  PEB          */ ProcessParams = GetCurrentUserProcessParameters(); VirtualProtect(ProcessParams, sizeof(RTL_USER_PROCESS_PARAMETERS), PAGE_EXECUTE_READWRITE, &OldProtect); OldEnvironment = ProcessParams->Environment; ProcessParams->Environment = OriginalEnvironment; VirtualProtect(ProcessParams, sizeof(RTL_USER_PROCESS_PARAMETERS), OldProtect, &OldProtect2); /*       ,   */ VirtualFree(OldEnvironment, 0, MEM_RELEASE); } void main(int argc, char *argv[]) { PVOID OriginalEnvironment; UNREFERENCED_PARAMETER(argc); UNREFERENCED_PARAMETER(argv); OriginalEnvironment = ReplacePEBEnvironmentTableAndAddValue(L"NewVar", L"NewValue"); if (OriginalEnvironment) { WCHAR Buff[1024] = {0}; if (GetEnvironmentVariableW(L"NewVar", Buff, sizeof(Buff))) wprintf_s(L"GetEnvironmentVariableW(): NewVar == %ws\n", Buff); printf_s("Restoring PEB Environment Table...\n"); RestorePEBEnvironmentTable(OriginalEnvironment); if (!GetEnvironmentVariableW(L"NewVar", Buff, sizeof(Buff))) printf_s("GetEnvironmentVariableW(): NewVar not found\n"); } _getch(); }

फिर निष्कर्ष इस प्रकार है:

"मूल" तालिका पर लौटने से कैश का पुनर्निर्माण नहीं होता है। इस प्रकार, पर्यावरण चर के ब्लॉक के साथ काम करने के लिए उपयुक्त कर्नेल 32 इंटरफेस का उपयोग करके लेखक की समस्या को हल किया जाता है।

सबसे दिलचस्प बात यह है कि यह विधि तीसरे पक्ष की प्रक्रिया में डेटा बदलते समय काम करेगी, जिसे बाद में दिखाया जा सकता है।

अद्यतन: जैसा कि क्लीवरमाउस ने सही ढंग से उल्लेख किया है, सी लाइब्रेरी के माध्यम से पर्यावरण चर के साथ काम करने से एक विशिष्ट उदाहरण में अर्थ नहीं होता है, जैसा कि मुख्य फ़ंक्शन के मामले में, _environ कैश भरा हुआ है, _wenviron नहीं, इसलिए मैं इसे डीबगिंग प्रिंट के रूप में विचार कर रहा हूं।

हमेशा के लिए तुम्हारा
rwx64

पर्यावरण चर के बारे में कहानी की निरंतरता, या पीईबी की जगह

More articles: