reg.hpp

Go to the documentation of this file.

//    OpenVPN -- An application to securely tunnel IP networks
//               over a single port, with support for SSL/TLS-based
//               session authentication and key exchange,
//               packet encryption, packet authentication, and
//               packet compression.
//
//    Copyright (C) 2012- OpenVPN Inc.
//
//    SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
 
 
// registry utilities for Windows
 
#pragma once
 
#include <windows.h>
#include <string>
#include <openvpn/win/winerr.hpp>
#include <openvpn/common/size.hpp>
 
namespace openvpn::Win {
 
template <typename E>
static void check_reg_error(DWORD status, const std::string &key)
{
    if (status != ERROR_SUCCESS)
    {
        const Win::Error err(status);
        OPENVPN_THROW(E, "registry key " << key << " error: " << err.message());
    }
}
 
struct Reg
{
    class Key
    {
        Key(const Key &) = delete;
        Key &operator=(const Key &) = delete;
 
      public:
        Key(HKEY key, const std::wstring &subkey, bool create = false)
        {
            LSTATUS error;
            if (create)
            {
                error = ::RegCreateKeyExW(key,
                                          subkey.c_str(),
                                          0,
                                          nullptr,
                                          0,
                                          KEY_ALL_ACCESS,
                                          nullptr,
                                          &key_,
                                          nullptr);
            }
            else
            {
                error = ::RegOpenKeyExW(key,
                                        subkey.c_str(),
                                        0,
                                        KEY_ALL_ACCESS,
                                        &key_);
            }
            if (error)
            {
                key_ = static_cast<HKEY>(INVALID_HANDLE_VALUE);
            }
        }
        Key(Key &key, const std::wstring &subkey, bool create = false)
            : Key(key(), subkey, create)
        {
        }
        Key(const std::wstring &subkey, bool create = false)
            : Key(HKEY_LOCAL_MACHINE, subkey, create)
        {
        }
 
        Key() = default;
 
        Key(Key &&rhs)
        {
            if (defined())
            {
                ::RegCloseKey(key_);
                key_ = static_cast<HKEY>(INVALID_HANDLE_VALUE);
            }
            std::swap(key_, rhs.key_);
        }
        Key &operator=(Key &&rhs)
        {
            Key copy{std::move(rhs)};
            std::swap(copy.key_, this->key_);
            return *this;
        }
 
        ~Key()
        {
            if (defined())
            {
                ::RegCloseKey(key_);
            }
        }
 
        bool defined() const
        {
            return key_ != INVALID_HANDLE_VALUE;
        }
 
        PHKEY ref()
        {
            return &key_;
        }
 
        HKEY operator()()
        {
            return key_;
        }
 
      private:
        HKEY key_ = static_cast<HKEY>(INVALID_HANDLE_VALUE);
    };
 
    class KeyEnumerator : public std::vector<std::wstring>
    {
      public:
        KeyEnumerator(Key &key)
        {
            if (!key.defined())
                return;
 
            LSTATUS status;
            DWORD subkeys_num;
            status = ::RegQueryInfoKeyA(key(),
                                        nullptr,
                                        nullptr,
                                        nullptr,
                                        &subkeys_num,
                                        nullptr,
                                        nullptr,
                                        nullptr,
                                        nullptr,
                                        nullptr,
                                        nullptr,
                                        nullptr);
 
            if (status != ERROR_SUCCESS)
                return;
 
            constexpr int MAX_KEY_LENGTH = 255;
            for (DWORD i = 0; i < subkeys_num; ++i)
            {
                DWORD subkey_size = MAX_KEY_LENGTH;
                WCHAR subkey[MAX_KEY_LENGTH];
                status = ::RegEnumKeyExW(key(),
                                         i,
                                         subkey,
                                         &subkey_size,
                                         nullptr,
                                         nullptr,
                                         nullptr,
                                         nullptr);
                if (status == ERROR_SUCCESS)
                    push_back(subkey);
            }
        }
    };
 
    static constexpr PCWSTR gpol_nrpt_subkey = LR"(SOFTWARE\Policies\Microsoft\Windows NT\DNSClient\DnsPolicyConfig)";
    static constexpr PCWSTR local_nrpt_subkey = LR"(SYSTEM\CurrentControlSet\Services\Dnscache\Parameters\DnsPolicyConfig)";
 
    static constexpr WCHAR subkey_ipv4_itfs[] = LR"(SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces)";
    static constexpr WCHAR subkey_ipv6_itfs[] = LR"(SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters\Interfaces)";
 
    static std::pair<DWORD, LSTATUS> get_dword(Key &key, PCWSTR name)
    {
        DWORD type;
        DWORD value;
        DWORD size = sizeof(value);
        PBYTE data = reinterpret_cast<PBYTE>(&value);
        LSTATUS err;
 
        err = ::RegGetValueW(key(), nullptr, name, RRF_RT_REG_DWORD, &type, data, &size);
        if (err)
        {
            return {0, err};
        }
        else if (type != REG_DWORD)
        {
            return {0, ERROR_DATATYPE_MISMATCH};
        }
 
        return {value, err};
    }
 
    static std::pair<std::wstring, LSTATUS> get_string(Key &key, PCWSTR name)
    {
        LSTATUS err;
        DWORD size = 0;
        DWORD type;
        err = ::RegGetValueW(key(), nullptr, name, RRF_RT_REG_SZ, &type, nullptr, &size);
        if (err)
        {
            return {{}, err};
        }
        else if (type != REG_SZ)
        {
            return {{}, ERROR_DATATYPE_MISMATCH};
        }
 
        std::wstring str(size / sizeof(std::wstring::value_type) + 1, '\0');
        PBYTE data = reinterpret_cast<PBYTE>(str.data());
        err = ::RegGetValueW(key(), nullptr, name, RRF_RT_REG_SZ, nullptr, data, &size);
        if (err)
        {
            return {{}, err};
        }
 
        str.resize(::wcslen(str.c_str())); // remove trailing NULs
        return {str, err};
    }
 
    static std::pair<std::string, LSTATUS> get_binary(Key &key, PCWSTR name)
    {
        LSTATUS err;
        DWORD size = 0;
        DWORD type;
        err = ::RegGetValueW(key(), nullptr, name, RRF_RT_REG_BINARY, &type, nullptr, &size);
        if (err)
        {
            return {{}, err};
        }
        else if (type != REG_BINARY)
        {
            return {{}, ERROR_DATATYPE_MISMATCH};
        }
 
        std::string str(size, '\0');
        PBYTE data = reinterpret_cast<PBYTE>(str.data());
        err = ::RegGetValueW(key(), nullptr, name, RRF_RT_REG_BINARY, nullptr, data, &size);
        if (err)
        {
            return {{}, err};
        }
 
        return {str, err};
    }
 
    static LSTATUS set_dword(Key &key, PCWSTR name, DWORD value)
    {
        const BYTE *bytes = reinterpret_cast<const BYTE *>(&value);
        DWORD size = static_cast<DWORD>(sizeof(value));
        return ::RegSetValueExW(key(), name, 0, REG_DWORD, bytes, size);
    }
 
    static LSTATUS set_string(Key &key, PCWSTR name, const std::wstring &value)
    {
        const BYTE *bytes = reinterpret_cast<const BYTE *>(value.c_str());
        DWORD size = static_cast<DWORD>((value.size() + 1) * sizeof(std::wstring::value_type));
        return ::RegSetValueExW(key(), name, 0, REG_SZ, bytes, size);
    }
 
    static LSTATUS set_multi_string(Key &key, PCWSTR name, const std::wstring &value)
    {
        const BYTE *bytes = reinterpret_cast<const BYTE *>(value.data());
        DWORD size = static_cast<DWORD>(value.size() * sizeof(std::wstring::value_type));
        return ::RegSetValueExW(key(), name, 0, REG_MULTI_SZ, bytes, size);
    }
 
    static LSTATUS delete_subkey(const std::wstring &subkey)
    {
        return ::RegDeleteTreeW(HKEY_LOCAL_MACHINE, subkey.c_str());
    }
 
    static LSTATUS delete_value(Key &key, PCWSTR name)
    {
        return ::RegDeleteValueW(key(), name);
    }
};
 
} // namespace openvpn::Win