लोकप्रिय बैटलएई एंटिचिटा में बदलाव और उन्हें दरकिनार करने के तरीके

प्रमुख बैटलईये शेलकोड अपडेट

समय बीत जाता है, एंटी-चीट बदलते हैं, और उत्पाद की प्रभावशीलता को बढ़ाने के लिए, उनमें कार्य दिखाई देते हैं और गायब हो जाते हैं। एक साल पहले, मैंने अपने ब्लॉग [हैबे पर अनुवाद ] में बैटलई शेल शेल का विस्तृत विवरण तैयार किया, और लेख का यह हिस्सा शेलकोड में किए गए परिवर्तनों का एक सरल प्रतिबिंब होगा।

ब्लैक लिस्टेड टाइमस्टैम्प्स

हाल ही में बैटलईई विश्लेषण में, छाया प्रतिबंध सूची में केवल दो संकलन टाइमस्टैम्प थे, और ऐसा लगता है कि डेवलपर्स ने बहुत अधिक जोड़ने का फैसला किया:

0x5B12C900 (action_x64.dll)
0x5A180C35 (TerSafe.dll, Epic Games)
0xFC9B9325 (?)
0x456CED13 (d3dx9_32.dll)
0x46495AD9 (d3dx9_34.dll)
0x47CDEE2B (d3dx9_32.dll)
0x469FF22E (d3dx9_35.dll)
0x48EC3AD7 (D3DCompiler_40.dll)
0x5A8E6020 (?)
0x55C85371 (d3dx9_32.dll)
0x456CED13 (?)
0x46495AD9 (D3DCompiler_40.dll)
0x47CDEE2B (D3DX9_37.dll)
0x469FF22E (?)
0x48EC3AD7 (?)
0xFC9B9325 (?)
0x5A8E6020 (?)
0x55C85371 (?)

मैं शेष टाइमस्टैम्प की पहचान करने में असमर्थ था, और दो 0xF ******* विजुअल स्टूडियो निर्धारक विधानसभाओं द्वारा बनाई गई हैश हैं। कुछ टाइमस्टैम्प की पहचान के लिए @mottikraus और T0B1 का धन्यवाद।

मॉड्यूल चेक

जैसा कि मुख्य विश्लेषण से पता चला है, बैटलई की प्रमुख विशेषता मॉड्यूल की गणना है, और अंतिम विश्लेषण के क्षण से, सूची में एक और मॉड्यूल जोड़ा गया था:

 void battleye::misc::module_unknown1() { if (!GetProcAddress(current_module, "NSPStartup")) return; if (optional_header.data_directory[4].size == 0x1B20 || optional_header.data_directory[4].size == 0xE70 || optional_header.data_directory[4].size == 0x1A38 || timestamp >= 0x5C600000 && timestamp < 0x5C700000) { report_module_unknown report = {}; report.unknown = 0; report.report_id = 0x35; report.val1 = 0x5C0; report.timestamp = timestamp; report.image_size = optional_header.size_of_image; report.entrypoint = optional_header.address_of_entry_point; report.directory_size = optional_header.data_directory[4].size; battleye::report(&report, sizeof(report), false); } } 

यह संभवतः कुछ प्रॉक्सी डीएलएस का पता लगाना है, क्योंकि पुनर्निर्देशित तालिका का आकार यहां जांचा गया है।

खिड़की के शीर्षक

पिछले विश्लेषण में, विभिन्न धोखा प्रदाताओं को खिड़की के नामों के साथ चिह्नित किया गया था, लेकिन तब से शेलकोड ने इन विंडो हेडर की जांच बंद कर दी है। विंडो शीर्षक की सूची को पूरी तरह से बदल दिया गया है:

Chod's
Satan5

छवि नाम

BattlEye बहुत आदिम पहचान विधियों का उपयोग करने के लिए कुख्यात है, और उनमें से एक छवि नामों का ब्लैकलिस्ट है। हर साल, छवियों के प्रतिबंधित नामों की सूची लंबी होती जा रही है, और पिछले 11 महीनों में पांच नए जोड़े गए हैं:

frAQBc8W.dll
C:\\Windows\\mscorlib.ni.dll
DxtoryMM_x64.dll
Project1.dll
OWClient.dll

यह ध्यान देने योग्य है कि सूची में किसी भी आइटम के अनुरूप नाम के साथ एक मॉड्यूल की उपस्थिति का मतलब यह नहीं होगा कि आपको तुरंत प्रतिबंधित कर दिया जाएगा। रिपोर्टिंग इंजन बुनियादी मॉड्यूल जानकारी भी देता है, जो कि सबसे अधिक संभावना है कि बैटलएईई सर्वर पर टकराव से धोखा देती है।

7-Zip

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

 void module::check_7zip() { const auto module_handle = GetModuleHandleA("..\\..\\Plugins\\ZipUtility\\ThirdParty\\7zpp\\dll\\Win64\\7z.dll"); // --- REMOVED --- // if (module_handle && *(int*)(module_handle + 0x1000) != 0xFF1441C7) // --- ADDED --- if (module_handle && *(int*)(module_handle + 0x1008) != 0x83485348) { sevenzip_report.unknown_1 = 0; sevenzip_report.report_id = 0x46; sevenzip_report.unknown_2 = 0; sevenzip_report.data1 = *(__int64*)(module_handle + 0x1000; sevenzip_report.data2 = *(__int64*)(module_handle + 0x1008; battleye::report(&sevenzip_report, sizeof(sevenzip_report), false); } } 

ऐसा लगता है कि बैटलवाइ डेवलपर्स ने अनुमान लगाया है कि मेरे पिछले लेख ने कई उपयोगकर्ताओं को इस चेक को बाईपास करने के लिए नेतृत्व किया है, जो कि केवल वांछित बाइट्स को बैटलई द्वारा चेक किए गए स्थान पर कॉपी कर रहा है। उन्होंने स्थिति को कैसे ठीक किया? हमने सत्यापन को आठ बाइट्स में स्थानांतरित कर दिया और अखंडता की जाँच करने के उसी बुरे तरीके का उपयोग करना जारी रखा। केवल पढ़ने योग्य निष्पादन योग्य विभाजन, और आपको केवल डिस्क से 7-ज़िप डाउनलोड करने और एक दूसरे के साथ स्थानांतरित विभाजन की तुलना करने की आवश्यकता है; अगर कोई विसंगतियां हैं, तो कुछ गलत है। गंभीरता से, दोस्तों, अखंडता की जाँच करना कठिन नहीं है।

नेटवर्क की जाँच

टीसीपी तालिका की गणना करना अभी भी काम करता है, लेकिन जब मैंने पिछले विश्लेषण को जारी किया, जिसने क्लाउडफ़्लरे आईपी पते को चिह्नित करने के लिए डेवलपर्स की आलोचना की, तब भी उन्होंने इस चेक को हटा दिया। एंटी-चीट अभी भी उस पोर्ट की रिपोर्ट करता है जो कनेक्शन के लिए xera.ph का उपयोग करता है, लेकिन डेवलपर्स ने यह निर्धारित करने के लिए एक नया चेक जोड़ा कि क्या कनेक्शन के साथ प्रक्रिया में सक्रिय सुरक्षा है (संभवतः हैंडलर का उपयोग करके ऐसा किया जाता है)।

 void network::scan_tcp_table { memset(local_port_buffer, 0, sizeof(local_port_buffer); for (iteration_index = 0; iteration_index; < 500 ++iteration_index) { // GET NECESSARY SIZE OF TCP TABLE auto table_size = 0; GetExtendedTcpTable(0, &table_size, false, AF_INET, TCP_TABLE_OWNER_MODULE_ALL, 0); // ALLOCATE BUFFER OF PROPER SIZE FOR TCP TABLE auto allocated_ip_table = (MIB_TCPTABLE_OWNER_MODULE*)malloc(table_size); if (GetExtendedTcpTable(allocated_ip_table, &table_size, false, AF_INET, TCP_TABLE_OWNER_MODULE_ALL, 0) != NO_ERROR) goto cleanup; for (entry_index = 0; entry_index < allocated_ip_table->dwNumEntries; ++entry_index) { // --- REMOVED --- // const auto ip_address_match_1 = // allocated_ip_table->table[entry_index].dwRemoteAddr == 0x656B1468; // 104.20.107.101 // // const auto ip_address_match_2 = // allocated_ip_table->table[entry_index].dwRemoteAddr == 0x656C1468; // 104.20.108.101 // +++ ADDED +++ const auto target_process = OpenProcess(QueryLimitedInformation, 0, ip_table->table[entry_index].dwOwningPid); const auto protected = target_process == INVALID_HANDLE && GetLastError() == 0x57; if (!protected) { CloseHandle(target_process); return; } const auto port_match = allocated_ip_table->table[entry_index].dwRemotePort == 20480; for (port_index = 0; port_index < 10 && allocated_ip_table->table[entry_index].dwLocalPort != local_port_buffer[port_index]; ++port_index) { if (local_port_buffer[port_index]) continue tcp_table_report.unknown = 0; tcp_table_report.report_id = 0x48; tcp_table_report.module_id = 0x5B9; tcp_table_report.data = BYTE1(allocated_ip_table->table[entry_index].dwLocalPort) | (LOBYTE(allocated_ip_table->table[entry_index.dwLocalPort) << 8; battleye::report(&tcp_table_report, sizeof(tcp_table_report), false); local_port_buffer[port_index] = allocated_ip_table->table[entry_index].dwLocalPort; break } } cleanup: // FREE TABLE AND SLEEP free(allocated_ip_table); Sleep(10 } } 

धन्यवाद IChoose आप और सार

बटलइये स्टैक बायपास

हैकिंग गेम बिल्ली और चूहे का एक निरंतर खेल है, इसलिए नई चाल की अफवाह आग की तरह फैल रही है। इस भाग में, हम नई हेयुरिस्टिक तकनीकों को देखेंगे जो हाल ही में हमारे शस्त्रागार में एंटी-चीट्स बैटलई के एक बड़े प्रदाता द्वारा जोड़े गए थे। ज्यादातर, इन तकनीकों को स्टैक वॉकिंग कहा जाता है। आमतौर पर वे एक फ़ंक्शन को संसाधित करके और स्टैक के माध्यम से यह पता लगाने के लिए कार्यान्वित किए जाते हैं कि कौन विशेष रूप से इस फ़ंक्शन को बुलाता है। आपको ऐसा करने की आवश्यकता क्यों है? किसी भी अन्य कार्यक्रम की तरह, वीडियो गेम हैक्स में प्रसिद्ध कार्यों का एक सेट है जो वे कीबोर्ड से जानकारी प्राप्त करने के लिए उपयोग करते हैं, कंसोल को आउटपुट करते हैं, या कुछ गणितीय अभिव्यक्तियों की गणना करते हैं। इसके अलावा, वीडियो गेम अपने अस्तित्व को छुपाने के लिए प्यार करता है, चाहे वह मेमोरी में हो या डिस्क पर, ताकि एंटी-चीट सॉफ्टवेयर उन्हें न मिले। लेकिन जो चीट प्रोग्राम भूल जाते हैं वह यह है कि वे नियमित रूप से अन्य पुस्तकालयों से कार्यों को बुलाते हैं, और इसका उपयोग अज्ञात धोखा देने वालों का पता लगाने के लिए किया जा सकता है। स्टैक std::print जैसे कार्यों के लिए स्टैक ट्रैवर्सल इंजन को लागू करके, हम इन धोखा दे सकते हैं, भले ही वे नकाबपोश हों।

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

जैसा कि मैंने बैटलई के बारे में पिछले लेख में बताया था, एंटी-चीट सिस्टम गतिशील रूप से शेलकोड को खेल में तब स्ट्रीम करता है जब यह चल रहा होता है। इन शेल कोड के अलग-अलग आकार और कार्य हैं, और एक साथ प्रेषित नहीं किए जाते हैं। ऐसी प्रणाली की एक उल्लेखनीय संपत्ति यह है कि शोधकर्ताओं को मल्टीप्लेयर मैच के दौरान एंटी-चीट का गतिशील विश्लेषण करने की आवश्यकता होती है, जो इस एंटी-चीट की विशेषताओं के निर्धारण को जटिल बनाता है। यह एंटी-चीट को विभिन्न उपयोगकर्ताओं के लिए विभिन्न उपायों को लागू करने की भी अनुमति देता है, उदाहरण के लिए, एक अधिक गहराई से आक्रामक मॉड्यूल को केवल उस व्यक्ति को स्थानांतरित करने के लिए, जिसके पास हत्याओं और मौतों का असामान्य रूप से उच्च अनुपात है, और जैसे।

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

GetAsyncKeyState
GetCursorPos
IsBadReadPtr
NtUserGetAsyncKeyState
GetForegroundWindow
CallWindowProcW
NtUserPeekMessage
NtSetEvent
sqrtf
__stdio_common_vsprintf_s
CDXGIFactory::TakeLock
TppTimerpExecuteCallback

ऐसा करने के लिए, यह मानक रूप से उपयोग किए जाने वाले कार्यों की सूची के चारों ओर पुनरावृत्त करता है, इसी फ़ंक्शन के पहले निर्देश को int3 पर सेट करता है , जिसका उपयोग ब्रेकपॉइंट के रूप में किया जाता है। ब्रेकपॉइंट सेट करने के बाद, संबंधित फ़ंक्शन के सभी कॉल अपवाद हैंडलर से गुजरते हैं, जिसमें रजिस्टरों और स्टैक तक पूर्ण पहुंच होती है। इस पहुंच के बाद, अपवाद हैंडलर स्टैक के शीर्ष से कॉलिंग प्रोग्राम का पता डंप करता है, और यदि हेयुरेटिव शर्तों में से एक को पूरा किया जाता है, तो कॉलिंग फ़ंक्शन के 32 बाइट्स डंप किए जाते हैं और रिपोर्ट आइडेंटिफ़ायर 0x31 के साथ बैटलइवे सर्वर को भेजे जाते हैं:

 __int64 battleye::exception_handler(_EXCEPTION_POINTERS *exception) { if (exception->ExceptionRecord->ExceptionCode != STATUS_BREAKPOINT) return 0; const auto caller_function = *(__int64 **)exception->ContextRecord->Rsp; MEMORY_BASIC_INFORMATION caller_memory_information = {}; auto desired_size = 0; // QUERY THE MEMORY PAGE OF THE CALLER const auto call_failed = NtQueryVirtualMemory( GetCurrentProcess(), caller_function, MemoryBasicInformation, &caller_memory_information, sizeof(caller_memory_information), &desired_size) < 0; // IS THE MEMORY SOMEHOW NOT COMMITTED? (WOULD SUGGEST VAD MANIPULATIUON) const auto non_commit = caller_memory_information.State != MEM_COMMIT; // IS THE PAGE EXECUTABLE BUT DOES NOT BELONG TO A PROPERLY LOADED MODULE? const auto foreign_image = caller_memory_information.Type != MEM_IMAGE && caller_memory_information.RegionSize > 0x2000; // IS THE CALL BEING SPOOFED BY NAMAZSO? const auto spoof = *(_WORD *)caller_function == 0x23FF; // jmp qword ptr [rbx] // FLAG ALL ANBORMALITIES if (call_failed || non_commit || foreign_image || spoof) { report_stack.unknown = 0; report_stack.report_id = 0x31; report_stack.hook_id = hook_id; report_stack.caller = (__int64)caller_function; report_stack.function_dump[0] = *caller_function; report_stack.function_dump[1] = caller_function[1]; report_stack.function_dump[2] = caller_function[2]; report_stack.function_dump[3] = caller_function[3]; if (!call_failed) { report_stack.allocation_base = caller_memory_information.AllocationBase; report_stack.base_address = caller_memory_information.BaseAddress; report_stack.region_size = caller_memory_information.RegionSize; report_stack.type_protect_state = caller_memory_information.Type | caller_memory_information.Protect | caller_memory_information.State; } battleye::report(&report_stack, sizeof(report_stack), false); return -1; } } 

जैसा कि हम देख सकते हैं, अपवाद हैंडलर सभी कॉलिंग फ़ंक्शन को मेमोरी पेज में एक असामयिक परिवर्तन की स्थिति में या जब फ़ंक्शन किसी ज्ञात प्रक्रिया मॉड्यूल से संबंधित नहीं होता है (मेमोरी पेज प्रकार MEM_IMAGE मैनुअलमैनों द्वारा सेट नहीं किया गया था)। यह कॉलिंग फ़ंक्शन को भी डंप करता है जब यह NtQueryVirtualMemory को कॉल करने में विफल रहता है ताकि धोखा इस सिस्टम कॉल के लिए बाध्य न हो और स्टैक डंप से अपने मॉड्यूल को छिपाए। अंतिम स्थिति वास्तव में काफी दिलचस्प है, यह सभी कॉलिंग फ़ंक्शन को चिह्नित करता है जो कि jmp qword ptr [rbx] गैजेट का उपयोग करता है - "रिटर्न एड्रेस को खराब करने" के लिए इस्तेमाल किया जाने वाला तरीका। यह मेरे सह-सचिव सदस्य उपनाम नमाज़ो द्वारा जारी किया गया था । ऐसा लगता है कि बैटलई के डेवलपर्स ने देखा कि लोग अपने खेलों में स्पूफिंग की इस पद्धति का उपयोग करते हैं और सीधे उस पर निशाना लगाने का फैसला किया। यहां यह उल्लेखनीय है कि नमाज़ों द्वारा वर्णित विधि अच्छी तरह से काम करती है, बस एक अलग गैजेट का उपयोग करें, या पूरी तरह से अलग, या बस एक अलग रजिस्टर - यह कोई फर्क नहीं पड़ता।

बैटलएव डेवलपर टिप: CDXGIFactory::TakeLock अपनी मेमोरी में CDXGIFactory::TakeLock वह गलत है क्योंकि आपने (गलती से या जानबूझकर) CC पैडिंग को सक्षम किया है, जो आपके द्वारा संकलित किए जाने पर हर बार बहुत भिन्न होता है। अधिकतम अनुकूलता के लिए, आपको पैडिंग (हस्ताक्षर में पहला बाइट) हटाने की आवश्यकता है और इसलिए आप अधिक संभावना वाले थिएटरों को पकड़ लेंगे :)

बाटलईये सर्वर को भेजी गई पूरी संरचना कुछ इस प्रकार है:

 struct __unaligned battleye_stack_report { __int8 unknown; __int8 report_id; __int8 val0; __int64 caller; __int64 function_dump[4]; __int64 allocation_base; __int64 base_address; __int32 region_size; __int32 type_protect_state; }; 

बाटलीये में हाइपरवाइजर मान्यता

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

हैकिंग गेम्स के लिए रेडी-टू-यूज़ हाइपरविज़र सिस्टम के आगमन के साथ, यह अपरिहार्य हो गया कि बैटली जैसे एंटी-चीट वर्चुअलाइजेशन की सामान्यीकृत मान्यता पर ध्यान केंद्रित करेगा।

हाइपरविजर्स का व्यापक उपयोग एंटी-चीट में हाल के सुधारों के कारण है, जिसने हैकर्स को पारंपरिक तरीकों से गेम को संशोधित करने के बहुत कम अवसर छोड़ दिए हैं। हाइपरवाइजर्स की लोकप्रियता को एंटी-चीट से बचने की सादगी द्वारा समझाया जा सकता है, क्योंकि वर्चुअलाइजेशन सिसकॉल हुक और एमएमयू वर्चुअलाइजेशन जैसे तंत्रों का उपयोग करके जानकारी को छिपाने को सरल बनाता है ।

हाल ही में, बैटलएई ने समय-समय पर पता लगाने का उपयोग करके ऊपर दिए गए प्लेटफ़ॉर्म (डडिमोन, एचवीपीपी) जैसे सामान्य हाइपरविजर्स की मान्यता को लागू किया है। यह मान्यता गैर-मानक CPUID अनुदेश समय मानों का पता लगाने का प्रयास करती है। सीपीयूआईडी वास्तविक उपकरणों पर अपेक्षाकृत कम लागत वाला निर्देश है, आमतौर पर केवल दो सौ चक्रों की आवश्यकता होती है, और एक आभासी वातावरण में, इसके निष्पादन को आत्मनिरीक्षण इंजन के कारण अनावश्यक संचालन के कारण दस गुना अधिक समय लग सकता है। आत्मनिरीक्षण इंजन वास्तविक उपकरणों के विपरीत है, जो केवल अपेक्षित तरीके से ऑपरेशन करता है, क्योंकि एक मनमाना मानदंड के आधार पर यह ट्रैक करता है और सशर्त रूप से अतिथि को लौटाए गए डेटा को बदलता है।

मजेदार तथ्य: सीपीयूआईडी का उपयोग इन अस्थायी मान्यता प्रक्रियाओं में सक्रिय रूप से किया जाता है क्योंकि यह बिना शर्त आउटपुट के साथ-साथ अप्रकाशित क्रमांकन के साथ एक निर्देश है। इसका मतलब है कि सीपीयूआईडी का उपयोग एक बाधा के रूप में किया जाता है और यह सुनिश्चित करता है कि निर्देशों का पालन इसके पहले और बाद में किया जाए; एक ही समय में, निर्देशों के सामान्य पुनरावृत्ति से समय स्वतंत्र हो जाता है। आप XSETBV जैसे निर्देशों का भी उपयोग कर सकते हैं, जो बिना शर्त निकास भी करते हैं, लेकिन स्वतंत्र समय सुनिश्चित करने के लिए, इसमें किसी प्रकार के अवरोधक निर्देश की आवश्यकता होगी, ताकि समय से पहले या बाद में कोई पुनरावृत्ति न हो, जिससे समय की विश्वसनीयता प्रभावित हो।

मान्यता

निम्नलिखित BattlEye "BEClient2" मॉड्यूल से मान्यता प्रक्रिया है; मैंने इसकी रिवर्स इंजीनियरिंग का प्रदर्शन किया और छद्म सी में कोड को फिर से बनाया, और फिर इसे ट्विटर पर पोस्ट किया। मेरे ट्वीट के अगले दिन, बैटलवाइ डेवलपर्स ने अप्रत्याशित रूप से BEClient2 के आक्षेप को बदल दिया, जाहिर है कि यह मुझे मॉड्यूल का विश्लेषण करने से रोक देगा। पिछले आक्षेप एक वर्ष से अधिक नहीं बदले, लेकिन इसके बारे में मेरे ट्वीट के बाद दिन बदल गया - एक प्रभावशाली गति।

 void battleye::take_time() { // SET THREAD PRIORITY TO THE HIGHEST const auto old_priority = SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL); // CALCULATE CYCLES FOR 1000MS const auto timestamp_calibrator = __rdtsc(); Sleep(1000); const auto timestamp_calibration = __rdtsc() - timestamp_calibrator; // TIME CPUID auto total_time = 0; for (std::size_t count = 0; count < 0x6694; count++) { // SAVE PRE CPUID TIME const auto timestamp_pre = __rdtsc(); std::uint32_t cpuid_data[4] = {}; __cpuid(cpuid_data, 0); // SAVE THE DELTA total_time += __rdtsc() - timestamp_pre; } // SAVE THE RESULT IN THE GLOBAL REPORT TABLE battleye::report_table[0x1A8] = 10000000 * total_time / timestamp_calibration / 0x65; // RESTORE THREAD PRIORITY SetThreadPriority(GetCurrentThread(), old_priority); } 

जैसा कि मैंने ऊपर कहा, बिना शर्त इंटरसेप्ट किए गए निर्देशों का उपयोग करने वाली यह सबसे आम मान्यता तकनीक है। हालांकि, यह नकली समय के लिए कमजोर है, और हम इसके बारे में अगले खंड में विस्तार से बात करेंगे।

मान्यता बाईपास

इस मान्यता पद्धति में समस्याएं हैं। सबसे पहले, यह नकली समय के लिए प्रवण होता है, जो आमतौर पर दो तरह से किया जाता है: वीएमसीएस में टीएससी को शिफ्ट करने या टीएससी को कम करके हर बार सीपीयूआईडी निष्पादित किया जाता है। समय-आधारित हमलों से निपटने के कई अन्य तरीके हैं, लेकिन उत्तरार्द्ध को लागू करना बहुत आसान है, क्योंकि आप गारंटी दे सकते हैं कि निर्देश का निष्पादन समय वास्तविक उपकरणों पर निष्पादन सिंक्रनाइज़ेशन के एक या दो घड़ी चक्रों के भीतर होगा। इस बार जालसाजी तकनीक की खोज की कठिनाई डेवलपर के अनुभव पर निर्भर करती है। अगले भाग में, हम बैटलफेई में बनाए गए क्रियान्वयन को बेहतर बनाने और सुधारने पर ध्यान देंगे। इस मान्यता पद्धति के दोष का दूसरा कारण विभिन्न प्रोसेसर में सीपीयूआईडी विलंब (रनटाइम) शीट के मूल्य के आधार पर बहुत अलग है। इसे पूरा करने में 70-300 घड़ी चक्र लग सकते हैं। इस मान्यता प्रक्रिया के साथ तीसरी समस्या SetThreadPriority का उपयोग करना है। इस विंडोज फ़ंक्शन का उपयोग किसी दिए गए स्ट्रीम डिस्क्रिप्टर के प्राथमिकता मूल्य को सेट करने के लिए किया जाता है, हालांकि, ओएस हमेशा अनुरोध को नहीं सुनता है। यह फ़ंक्शन केवल थ्रेड की प्राथमिकता को बढ़ाने के लिए एक सुझाव है, और कोई गारंटी नहीं है कि यह होगा। इस प्रकार, यह संभव है कि यह विधि रुकावटों या अन्य प्रक्रियाओं से प्रभावित होगी।

इस मामले में, मान्यता को दरकिनार करना आसान है, और जालसाजी के समय की वर्णित तकनीक इस मान्यता पद्धति को प्रभावी ढंग से हरा देती है। अगर बैटलई के डेवलपर्स इस पद्धति में सुधार करना चाहते हैं, तो निम्न अनुभाग कुछ सिफारिशें प्रदान करता है।

सुधार

इस सुविधा को कई तरीकों से बेहतर बनाया जा सकता है। सबसे पहले, आप जानबूझकर इंटरप्ट को अक्षम कर सकते हैं और सीआर 8 को उच्चतम आईआरक्यूएल में बदलकर एक धागे की प्राथमिकता को बाध्य कर सकते हैं। इस चेक को एक सीपीयू कोर में अलग करना भी आदर्श होगा। एक और सुधार: आपको विभिन्न टाइमर का उपयोग करना चाहिए, लेकिन उनमें से कई टीएससी के समान सटीक नहीं हैं, लेकिन एक ऐसा टाइमर है जिसे एपीईआरएफ, या वास्तविक प्रदर्शन घड़ी कहा जाता है। मैं इस टाइमर की सलाह देता हूं क्योंकि इसके साथ धोखा देना अधिक कठिन है और यह केवल एक काउंटर को जमा करता है जब तार्किक प्रोसेसर पावर स्टेट C0 में होता है। टीएससी का उपयोग करने के लिए यह एक बढ़िया विकल्प है। आप एसीपीआई, एचपीईटी, पीआईटी टाइमर, जीपीयू टाइमर, एनटीपी टाइमर, या पीपीईआरएफ टाइमर का उपयोग कर सकते हैं, जो एपीईआरएफ के समान है, लेकिन उन उपायों को गिनाता है जिन्हें निर्देश के रूप में माना जाता है। इसका नुकसान यह है कि आपको एचडब्ल्यूपी को सक्षम करने की आवश्यकता है, जिसे मध्यवर्ती ऑपरेटर द्वारा अक्षम किया जा सकता है, और इसलिए यह बेकार है।

नीचे मान्यता प्रक्रिया का एक बेहतर संस्करण है जिसे कर्नेल में किया जाना चाहिए:

 void battleye::take_time() { std::uint32_t cpuid_regs[4] = {}; _disable(); const auto aperf_pre = __readmsr(IA32_APERF_MSR) << 32; __cpuid(&cpuid_regs, 1); const auto aperf_post = __readmsr(IA32_APERF_MSR) << 32; const auto aperf_diff = aperf_post - aperf_pre; // CPUID IET ARRAY STORE // BATTLEYE REPORT TABLE STORE _enable(); } 

नोट: IET का उद्देश्य अनुदेशन निष्पादन समय है।

हालांकि, प्रक्रिया सामान्य हाइपरवाइज़र का पता लगाने में अभी भी बहुत अविश्वसनीय हो सकती है, क्योंकि सीपीयूआईडी रनटाइम बहुत भिन्न हो सकते हैं।दोनों निर्देशों के IET की तुलना करना बेहतर होगा। उनमें से एक को सीपीयूआईडी की तुलना में लंबा निष्पादन विलंब होना चाहिए। उदाहरण के लिए, यह FYL2XP1 हो सकता है - एक अंकगणितीय अनुदेश जो CPUID निर्देश के औसत IET की तुलना में थोड़ा अधिक समय लेता है। इसके अलावा, यह हाइपरविज़र में किसी भी जाल का कारण नहीं बनता है और इसका समय मज़बूती से मापा जा सकता है। इन दो कार्यों का उपयोग करते हुए, प्रोफाइलिंग फ़ंक्शन IET निर्देश CPUID और FYL2XP1 को संग्रहीत करने के लिए एक सरणी बना सकता है। APERF टाइमर का उपयोग करना, एक अंकगणितीय अनुदेश की प्रारंभिक घड़ी प्राप्त करना, निर्देश निष्पादित करना और इसके लिए घड़ी के डेल्टा की गणना करना संभव होगा। परिणामों को एन प्रोफाइलिंग चक्रों के लिए IET सरणी में संग्रहीत किया जा सकता है, औसत मूल्य प्राप्त कर सकता है और CPUID के लिए प्रक्रिया दोहरा सकता है। यदि CPUID निर्देश का निष्पादन समय अंकगणितीय अनुदेश से अधिक है,फिर यह एक विश्वसनीय संकेत है कि सिस्टम आभासी है, क्योंकि किसी भी परिस्थिति में एक अंकगणितीय अनुदेश निर्माता या संस्करण के बारे में जानकारी प्राप्त करने के लिए सीपीयूआईडी निष्पादित करने से ज्यादा समय नहीं दे सकता है। ऐसी मान्यता प्रक्रिया टीएससी ऑफसेट / स्केलिंग का उपयोग करने वालों का पता लगाने में भी सक्षम होगी।

मैं दोहराता हूं, डेवलपर्स को एक कोर पर यह जांच करने के लिए कम्प्यूटेशनल कोर के लिए बाध्यकारी को सक्षम करने के लिए मजबूर करना होगा, इंटरप्ट को अक्षम करना होगा और लगातार और विश्वसनीय डेटा की गारंटी के लिए अधिकतम मूल्य निर्धारित करने के लिए आईआरक्यूएल को मजबूर करना होगा। यह आश्चर्य की बात होगी अगर बैटलइवे के डेवलपर्स ने इसे लागू करने का फैसला किया, क्योंकि इसके लिए बहुत अधिक प्रयास की आवश्यकता है। कर्नेल ड्राइवर में, बैटलईई दो अन्य वर्चुअल मशीन मान्यता रूटीन खाता है, लेकिन यह एक अन्य लेख के लिए एक विषय है।