Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

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

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
RightHand-Persistence — COM विंडोज़ स्थिरता तकनीक | Kitploit
उपकरण/GitHubGitHub/i014n/righthand-persistence
स्थायित्व तंत्रशोषणपोस्ट-शोषणलर्निंग और शिक्षारेड टीमिंग
GitHubi014n/righthand-persistence

RightHand-Persistence

COM विंडोज़ स्थिरता तकनीक

रिपॉजिटरी देखें
90113 महीने पहलेKitploit द्वारा समीक्षित

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

राइटहैंड पर्सिस्टेंस

से प्रेरित CVE-2026-21509

सी++ COM संदर्भ मेनू हैंडलर पर्सिस्टेंस के लिए

विंडोज एक्सप्लोरर में जब कोई उपयोगकर्ता विशिष्ट लक्ष्यों (फ़ाइलों, फ़ोल्डरों या पृष्ठभूमि) पर राइट-क्लिक करता है, तो आपका कोड निष्पादित होता है, यह एक स्टेल्थी पर्सिस्टेंस तकनीक का प्रदर्शन करने वाला C++ और COM का उपयोग करके एक सैंपल विंडोज संदर्भ मेनू हैंडलर कार्यान्वयन है।

अस्वीकरण: यह प्रोजेक्ट केवल शैक्षिक और शोध उद्देश्यों के लिए है। यहाँ प्रदर्शित तकनीकों का उपयोग दुर्भावनापूर्ण उद्देश्यों के लिए किया जा सकता है। लेखक इस कोड के किसी भी अवैध गतिविधि में उपयोग का समर्थन नहीं करता है। जिम्मेदार बनें और इस ज्ञान का नैतिक रूप से उपयोग करें।


POC

poc

आरंभ करना

आवश्यक शर्तें

  • C++ कंपाइलर (जैसे, विज़ुअल स्टूडियो से MSVC, या MinGW-w64)
  • विंडोज SDK
  • परीक्षण वर्चुअल मशीन (सुरक्षित पंजीकरण और निष्पादन के लिए)

मेरा सेटअप

  • IDE: विज़ुअल स्टूडियो 2019
  • VM विकास: विंडोज 10 x64 (बिल्ड 19045)
  • VM परीक्षण: विंडोज 10 x64 / विंडोज 11 x64

परियोजना वास्तुकला

root@kitploit:~
                                       DllMain.cpp     
                                +-----------------------+
                                |  DLL Template Project |
                                +-------+-------+-------+
                            ____/           |        \_____
                            |               |             |
                            v               v             v
                    +------------+  +----------------+  +--------------+
                    |   Define   |  | MyClassFactory |  |   Define     |
    clsid_defined.h |   CLSID    |  +----------------+  |   Export     | Source.def
                    +------------+     ClassFactory     |  Functions   |
                                          class         +--------------+
                                            |
                                            |
                                            v
                                     +--------------+    
                                     | MyMenuHandler|
                                     +--------------+         
                                      MyMenuHandler
                                          class

1. DllMain.cpp

इसमें COM ऑब्जेक्ट द्वारा DLL को पंजीकृत और अपंजीकृत करने के लिए आवश्यक मानक फ़ंक्शन शामिल हैं।

  • DllRegisterServer(): लक्ष्य फ़ाइल एक्सटेंशन/पृष्ठभूमि के अनुरूप रजिस्ट्री पथ लिखता है। DLL पंजीकृत होने पर निष्पादित होता है।
root@kitploit:~
STDAPI DllRegisterServer() {
    std::wstring clsidString = MyStringFromCLSID(CLSID_DecrypShellExtensionx64);
    std::wstring dllPath = MyGetModuleFilename();

    // 1. Register the COM Class (CLSID)
    std::wstring clsidBaseKey = L"SOFTWARE\\Classes\\CLSID\\" + clsidString;
    SetRegistryKey(HKEY_LOCAL_MACHINE, clsidBaseKey, L"", L"MyMenuHandler Object");

    // 2. Register the DLL Path and Threading Model
    std::wstring inprocKey = clsidBaseKey + L"\\InprocServer32";
    SetRegistryKey(HKEY_LOCAL_MACHINE, inprocKey, L"", dllPath);
    SetRegistryKey(HKEY_LOCAL_MACHINE, inprocKey, L"ThreadingModel", L"Apartment");

    // 3. Register for all Shell Contexts
    // Array of paths to cover Files, Folders, Backgrounds, and Desktop
    std::wstring handlerPaths[] = {
        L"SOFTWARE\\Classes\\*\\shellex\\ContextMenuHandlers\\",
        L"SOFTWARE\\Classes\\Directory\\shellex\\ContextMenuHandlers\\",
        L"SOFTWARE\\Classes\\Directory\\Background\\shellex\\ContextMenuHandlers\\",
        L"SOFTWARE\\Classes\\DesktopBackground\\shellex\\ContextMenuHandlers\\"
    };

    for (const auto& path : handlerPaths) {
        std::wstring fullPath = path + L"MyMenuHandler"; // Replace with your handler's name
        SetRegistryKey(HKEY_LOCAL_MACHINE, fullPath, L"", clsidString);
    }

    // 4. Register in the Approved list (Required for many Windows versions)
    std::wstring approvedKey = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved";
    SetRegistryKey(HKEY_LOCAL_MACHINE, approvedKey, clsidString, L"MyMenuHandler");

    // 5. Notify the Shell that things have changed
    SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);

    return S_OK;
}
  • DllUnregisterServer(): रजिस्ट्री को साफ करता है। DLL को अपंजीकृत करने पर कॉल किया जाता है।

2. MyClassFactory

COM ऑब्जेक्ट को इंस्टेंशिएट करने के लिए आवश्यक। क्लास फैक्ट्री पर और पढ़ें।

3. Clsid_defined.h

इसमें वह GUID होता है जिसके तहत एप्लिकेशन एक्सप्लोरर में पंजीकृत होगा। आप विज़ुअल स्टूडियो के guidgen.exe या ऑनलाइन GUID जनरेटर का उपयोग करके एक नया GUID उत्पन्न कर सकते हैं।

root@kitploit:~
// {CEF1AA1B-42F7-4A54-AF46-BCEE5B3FE6BF}
DEFINE_GUID(CLSID_DecrypShellExtensionx64, 0xcef1aa1b, 0x42f7, 0x4a54, 0xaf, 0x46, 0xbc, 0xee, 0x5b, 0x3f, 0xe6, 0xbf);

4. Source.def

मॉड्यूल-डेफिनिशन फ़ाइल। यह निर्धारित करती है कि DLL कौन से फ़ंक्शन एक्सपोर्ट करता है। .DEF फ़ाइलों के बारे में और पढ़ें।

root@kitploit:~
EXPORTS
    DllGetClassObject PRIVATE
    DllCanUnloadNow PRIVATE
    DllRegisterServer PRIVATE
    DllUnregisterServer PRIVATE

5. MyMenuHandler.cpp

IShellExtInit और IContextMenu को लागू करने वाली मुख्य क्लास। यहाँ आप अपनी कस्टम क्रियाओं को परिभाषित करते हैं।

  • MyContextMenuHandler::Initialize(PCIDLIST_ABSOLUTE pidlFolder, IDataObject* pdtobj, HKEY hkeyProgId) जब भी आपके पंजीकृत लक्ष्य पर राइट-क्लिक होता है, तब कॉल किया जाता है। इसका उपयोग यह पार्स करने के लिए किया जाता है कि कौन सी फ़ाइल या फ़ोल्डर क्लिक किया गया।
root@kitploit:~
HRESULT MyContextMenuHandler::Initialize(PCIDLIST_ABSOLUTE pidlFolder, IDataObject* pdtobj, HKEY hkeyProgId)
{
    MessageBoxA(NULL, "Initialize Called!", "Debug", MB_OK);

    // 1. Check if we clicked on a FILE/FOLDER
    if (pdtobj)
    {
        STGMEDIUM medium;
        FORMATETC fe = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
        if (SUCCEEDED(pdtobj->GetData(&fe, &medium)))
        {
            DragQueryFileA((HDROP)medium.hGlobal, 0, m_szFile, MAX_PATH);
            ReleaseStgMedium(&medium);
            return S_OK; // Success!
        }
    }

    // 2. Check if we clicked the BACKGROUND (pidlFolder)
    if (pidlFolder)
    {
        if (SHGetPathFromIDListA(pidlFolder, m_szFile))
        {
            return S_OK; // Success!
        }
    }

    // 3. Fallback: If we got neither, still return S_OK to show the menu.
    // You just won't have a path populated in m_szFile.
    return S_OK;
}
  • MyContextMenuHandler::InvokeCommand(LPCMINVOKECOMMANDINFO picp) जब उपयोगकर्ता संदर्भ मेनू से आपके विशिष्ट कस्टम विकल्प पर क्लिक करता है, तब कॉल किया जाता है। यहीं पर आपका पर्सिस्टेंस पेलोड या कस्टम क्रिया निष्पादित होती है।

परीक्षण

लक्ष्य VM पर, संकलित DLL को कॉपी करें और निम्नलिखित कमांड चलाएँ:

1. पंजीकरण

मानक विंडोज बाइनरी का उपयोग करके DLL को पंजीकृत करें।

root@kitploit:~
regsvr32.exe RightHandPersistence.dll

2. एक्सप्लोरर को पुनरारंभ करें

explorer.exe प्रक्रिया को पुनरारंभ करें ताकि यह सुनिश्चित हो सके कि नई शेल एक्सटेंशन मेमोरी में लोड हो।

root@kitploit:~
taskkill /f /im explorer.exe & start explorer.exe

3. अपंजीकरण

संदर्भ मेनू हैंडलर को हटाने और रजिस्ट्री को साफ करने के लिए, regsvr32.exe के साथ /u ध्वज का उपयोग करें। यह आपके DllUnregisterServer फ़ंक्शन को कॉल करता है।

root@kitploit:~
regsvr32.exe /u RightHandPersistence.dll

अनुकूलन

1. विशिष्ट स्थानों को लक्षित करना

विंडोज "खाली स्थान" को फ़ाइलों से अलग वर्गीकृत करता है। पृष्ठभूमि को लक्षित करने के लिए, अपनी रजिस्ट्री कुंजियों को इन विशिष्ट स्थानों से मैप करें।

एक्सटेंशन मैपिंग के बारे में अधिक जानकारी Microsoft शेल संदर्भ मेनू दस्तावेज़ में पाई जा सकती है।

2. कस्टम मेनू कमांड बनाना

आप IContextMenu::QueryContextMenu विधि को लागू करके मेनू के लिए कस्टम टेक्स्ट निर्दिष्ट कर सकते हैं (जैसे, "कस्टम कॉपी" या "डायग्नोस्टिक चलाएं")। इस कस्टम टेक्स्ट पर क्लिक करने से IContextMenu::InvokeCommand के अंदर आपकी तर्क ट्रिगर होती है।


संदर्भ

  • शॉर्टकट मेनू हैंडलर बनाना (Microsoft लर्न)
  • IShellExtInit इंटरफ़ेस (Microsoft लर्न)
  • IContextMenu इंटरफ़ेस (Microsoft लर्न)
  • शेल एक्सटेंशन हैंडलर पंजीकृत करना (Microsoft लर्न)
  • DEF फ़ाइलों का उपयोग करके DLL से निर्यात करना (Microsoft लर्न)
  • GuidGenerator.com
टूल डाउनलोड करें
राइट-क्लिक लक्ष्यरजिस्ट्री कुंजी पथ
फ़ाइलें (सभी)HKEY_CLASSES_ROOT\*\shellex\ContextMenuHandlers
फ़ोल्डर (आइकन)HKEY_CLASSES_ROOT\Directory\shellex\ContextMenuHandlers
फ़ोल्डर पृष्ठभूमिHKEY_CLASSES_ROOT\Directory\Background\shellex\ContextMenuHandlers
डेस्कटॉप पृष्ठभूमिHKEY_CLASSES_ROOT\DesktopBackground\shellex\ContextMenuHandlers