HashTabInstaller.cpp

#include <windows.h>
#include <iostream>
#include <string>

static constexpr wchar_t kClsid[] = L"{050DA657-893C-457F-A45E-1A989820E6AC}";
static constexpr wchar_t kAppId[] = L"{55CB3090-D635-4445-B7B3-402BA6DB0DC9}";
static constexpr wchar_t kTypeLib[] = L"{40711F20-20F5-4D19-A0C2-2FFEB51E63D0}";
static constexpr wchar_t kProgId[] = L"HashTabGen.HashPage.1";
static constexpr wchar_t kProgIdVersionless[] = L"HashTabGen.HashPage";
static constexpr wchar_t kClassName[] = L"HashTabGen Class";
static constexpr wchar_t kAppIdName[] = L"HashTabGen";
static constexpr wchar_t kApprovedName[] = L"HashTabGen Shell Extension";

static bool IsRunningAsAdmin()
{
    BOOL isMember = FALSE;
    PSID adminGroup = nullptr;
    SID_IDENTIFIER_AUTHORITY ntAuthority = SECURITY_NT_AUTHORITY;

    if (!AllocateAndInitializeSid(&ntAuthority, 2,
                                  SECURITY_BUILTIN_DOMAIN_RID,
                                  DOMAIN_ALIAS_RID_ADMINS,
                                  0, 0, 0, 0, 0, 0,
                                  &adminGroup))
    {
        return false;
    }

    CheckTokenMembership(nullptr, adminGroup, &isMember);
    FreeSid(adminGroup);
    return isMember == TRUE;
}

static bool RelaunchElevated()
{
    wchar_t path[MAX_PATH] = {};
    if (GetModuleFileNameW(nullptr, path, MAX_PATH) == 0)
    {
        return false;
    }

    SHELLEXECUTEINFOW sei = {};
    sei.cbSize = sizeof(sei);
    sei.fMask = SEE_MASK_NOCLOSEPROCESS;
    sei.lpVerb = L"runas";
    sei.lpFile = path;
    sei.nShow = SW_SHOWNORMAL;

    if (!ShellExecuteExW(&sei))
    {
        return false;
    }

    return true;
}

static std::wstring GetDefaultDllPath()
{
    wchar_t path[MAX_PATH] = {};
    if (GetModuleFileNameW(nullptr, path, MAX_PATH) == 0)
    {
        return L"HashTabGen.dll";
    }

    std::wstring exePath(path);
    size_t pos = exePath.find_last_of(L"\\/");
    if (pos != std::wstring::npos)
    {
        exePath = exePath.substr(0, pos + 1);
    }
    return exePath + L"HashTabGen.dll";
}

static bool FileExists(const std::wstring& path)
{
    DWORD attrs = GetFileAttributesW(path.c_str());
    return attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY) == 0;
}

static REGSAM GetRegistryView()
{
#if defined(_WIN64)
    return KEY_WOW64_64KEY;
#else
    return KEY_WOW64_32KEY;
#endif
}

static HRESULT WriteRegString(HKEY root, const std::wstring& subKey, const wchar_t* name, const std::wstring& value)
{
    HKEY hKey = nullptr;
    LSTATUS status = RegCreateKeyExW(root, subKey.c_str(), 0, nullptr, 0,
                                     KEY_WRITE | GetRegistryView(), nullptr, &hKey, nullptr);
    if (status != ERROR_SUCCESS)
    {
        return HRESULT_FROM_WIN32(status);
    }

    status = RegSetValueExW(hKey, name, 0, REG_SZ,
                            reinterpret_cast<const BYTE*>(value.c_str()),
                            static_cast<DWORD>((value.size() + 1) * sizeof(wchar_t)));
    RegCloseKey(hKey);
    return HRESULT_FROM_WIN32(status);
}

static HRESULT WriteRegDefaultString(HKEY root, const std::wstring& subKey, const std::wstring& value)
{
    return WriteRegString(root, subKey, nullptr, value);
}

static HRESULT EnsureEmptyKey(HKEY root, const std::wstring& subKey)
{
    HKEY hKey = nullptr;
    LSTATUS status = RegCreateKeyExW(root, subKey.c_str(), 0, nullptr, 0,
                                     KEY_WRITE | GetRegistryView(), nullptr, &hKey, nullptr);
    if (status == ERROR_SUCCESS)
    {
        RegCloseKey(hKey);
        return S_OK;
    }
    return HRESULT_FROM_WIN32(status);
}

static HRESULT RegisterHashTab(const std::wstring& dllPath)
{
    const std::wstring clsidRoot = std::wstring(L"SOFTWARE\\Classes\\CLSID\\") + kClsid;
    HRESULT hr = WriteRegDefaultString(HKEY_LOCAL_MACHINE, clsidRoot, kClassName);
    if (FAILED(hr)) return hr;

    hr = WriteRegString(HKEY_LOCAL_MACHINE, clsidRoot, L"AppID", kAppId);
    if (FAILED(hr)) return hr;

    hr = WriteRegDefaultString(HKEY_LOCAL_MACHINE, clsidRoot + L"\\InprocServer32", dllPath);
    if (FAILED(hr)) return hr;

    hr = WriteRegString(HKEY_LOCAL_MACHINE, clsidRoot + L"\\InprocServer32", L"ThreadingModel", L"Apartment");
    if (FAILED(hr)) return hr;

    hr = WriteRegDefaultString(HKEY_LOCAL_MACHINE, clsidRoot + L"\\ProgID", kProgId);
    if (FAILED(hr)) return hr;

    hr = EnsureEmptyKey(HKEY_LOCAL_MACHINE, clsidRoot + L"\\Programmable");
    if (FAILED(hr)) return hr;

    hr = WriteRegDefaultString(HKEY_LOCAL_MACHINE, clsidRoot + L"\\TypeLib", kTypeLib);
    if (FAILED(hr)) return hr;

    hr = WriteRegDefaultString(HKEY_LOCAL_MACHINE, clsidRoot + L"\\VersionIndependentProgID", kProgIdVersionless);
    if (FAILED(hr)) return hr;

    const std::wstring handlers[] = {
        L"SOFTWARE\\Classes\\*\\shellex\\PropertySheetHandlers\\HashTabGen",
        L"SOFTWARE\\Classes\\Directory\\shellex\\PropertySheetHandlers\\HashTabGen",
        L"SOFTWARE\\Classes\\Drive\\shellex\\PropertySheetHandlers\\HashTabGen"
    };
    for (const auto& key : handlers)
    {
        hr = WriteRegDefaultString(HKEY_LOCAL_MACHINE, key, kClsid);
        if (FAILED(hr)) return hr;
    }

    const std::wstring appIdKey = std::wstring(L"SOFTWARE\\Classes\\AppID\\") + kAppId;
    hr = WriteRegDefaultString(HKEY_LOCAL_MACHINE, appIdKey, kAppIdName);
    if (FAILED(hr)) return hr;

    const std::wstring approvedKey = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved";
    hr = WriteRegString(HKEY_LOCAL_MACHINE, approvedKey, kClsid, kApprovedName);
    if (FAILED(hr)) return hr;

    return S_OK;
}

static HRESULT UnregisterHashTab()
{
    const std::wstring clsidRoot = std::wstring(L"SOFTWARE\\Classes\\CLSID\\") + kClsid;
    LSTATUS status = RegDeleteTreeW(HKEY_LOCAL_MACHINE, clsidRoot.c_str());
    if (status != ERROR_SUCCESS && status != ERROR_FILE_NOT_FOUND)
    {
        return HRESULT_FROM_WIN32(status);
    }

    const std::wstring handlers[] = {
        L"SOFTWARE\\Classes\\*\\shellex\\PropertySheetHandlers\\HashTabGen",
        L"SOFTWARE\\Classes\\Directory\\shellex\\PropertySheetHandlers\\HashTabGen",
        L"SOFTWARE\\Classes\\Drive\\shellex\\PropertySheetHandlers\\HashTabGen"
    };
    for (const auto& key : handlers)
    {
        status = RegDeleteTreeW(HKEY_LOCAL_MACHINE, key.c_str());
        if (status != ERROR_SUCCESS && status != ERROR_FILE_NOT_FOUND)
        {
            return HRESULT_FROM_WIN32(status);
        }
    }

    const std::wstring appIdKey = std::wstring(L"SOFTWARE\\Classes\\AppID\\") + kAppId;
    status = RegDeleteTreeW(HKEY_LOCAL_MACHINE, appIdKey.c_str());
    if (status != ERROR_SUCCESS && status != ERROR_FILE_NOT_FOUND)
    {
        return HRESULT_FROM_WIN32(status);
    }

    const std::wstring approvedKey = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved";
    HKEY hApproved = nullptr;
    status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, approvedKey.c_str(), 0,
                           KEY_SET_VALUE | GetRegistryView(), &hApproved);
    if (status == ERROR_SUCCESS && hApproved)
    {
        RegDeleteValueW(hApproved, kClsid);
        RegCloseKey(hApproved);
    }

    return S_OK;
}

int wmain()
{
    auto pauseBeforeExit = []()
    {
        std::wcout << L"\nStisknete libovolnou klavesu pro ukonceni..." << std::endl;
        std::wstring dummy;
        std::getline(std::wcin, dummy);
    };

    if (!IsRunningAsAdmin())
    {
        std::wcout << L"Spoustim s opravnenim spravce..." << std::endl;
        if (RelaunchElevated())
        {
            return 0;
        }
        std::wcout << L"Nepodarilo se spustit jako spravce." << std::endl;
        pauseBeforeExit();
        return 1;
    }

    std::wstring dllPath = GetDefaultDllPath();
    if (!FileExists(dllPath))
    {
        std::wcout << L"DLL nenalezena: " << dllPath << std::endl;
        std::wcout << L"Zadejte cestu k DLL: ";
        std::wstring input;
        std::getline(std::wcin, input);
        if (!input.empty())
        {
            dllPath = input;
        }
    }

    if (!FileExists(dllPath))
    {
        std::wcout << L"Soubor DLL neexistuje." << std::endl;
        pauseBeforeExit();
        return 1;
    }

    std::wcout << L"1) Instalovat (registrace v registru)" << std::endl;
    std::wcout << L"2) Odinstalovat (odstraneni z registru)" << std::endl;
    std::wcout << L"0) Konec" << std::endl;
    std::wcout << L"Volba: ";

    std::wstring choice;
    std::getline(std::wcin, choice);

    if (choice == L"1")
    {
        HRESULT hr = RegisterHashTab(dllPath);
        std::wcout << L"Vysledek: 0x" << std::hex << hr << std::endl;
        std::wcout << L"Pro zmenu v Exploreru muze byt potreba restartovat Explorer." << std::endl;
        pauseBeforeExit();
        return FAILED(hr) ? 1 : 0;
    }
    if (choice == L"2")
    {
        HRESULT hr = UnregisterHashTab();
        std::wcout << L"Vysledek: 0x" << std::hex << hr << std::endl;
        std::wcout << L"Pro zmenu v Exploreru muze byt potreba restartovat Explorer." << std::endl;
        pauseBeforeExit();
        return FAILED(hr) ? 1 : 0;
    }

    pauseBeforeExit();
    return 0;
}