VC++ 修改 Windows 操作系统防火墙规则（需要管理员权限）

于 2023-05-25 13:52:47 发布
阅读量406 收藏 1
点赞数 1
分类专栏： C/C++ Extension 文章标签： c++ windows microsoft
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/130865615
版权

 小例子：

Fw::NetFirewallAddApplication("TEST", "C:\\1.EXE");

头文件：

#pragma once

#include <ppp/stdafx.h>

namespace ppp
{
    namespace win32
    {
        namespace network
        {
            class Fw
            {
            public:
                typedef enum
                {
                    NetFirewallType_DomainNetwork,
                    NetFirewallType_PrivateNetwork,
                    NetFirewallType_PublicNetwork,
                } NetFirewallType;
                static bool NetFirewallAddApplication(const char* name, const char* executablePath, NetFirewallType netFwType) noexcept;
                static bool NetFirewallAddApplication(const char* name, const char* executablePath) noexcept;
                static bool NetFirewallAddAllApplication(const char* name, const char* executablePath) noexcept;
            };
        }
    }
}

源文件：

#include <windows/ppp/win32/network/Firewall.h>
#include <windows/ppp/win32/Win32Native.h>
#include <windows/ppp/win32/Win32Variant.h>

#include <Windows.h>
#include <atlbase.h>
#include <netfw.h>
#include <comutil.h>

#pragma comment(lib, "ole32.lib")          /* netfw32.lib */
#pragma comment(lib, "comsuppw.lib")

namespace ppp
{
    namespace win32
    {
        namespace network
        {
            static bool FW_NetFirewallAddApplication(const wchar_t* name, const wchar_t* executablePath, NET_FW_PROFILE_TYPE netFwType) noexcept
            {
                if (!name || !executablePath)
                {
                    return false;
                }

                if (GetFileAttributes(executablePath) == INVALID_FILE_ATTRIBUTES)
                {
                    return false;
                }

                CComPtr<INetFwMgr> pNetFwMgr;
                HRESULT hr = CoCreateInstance(__uuidof(NetFwMgr), NULL, CLSCTX_INPROC_SERVER, __uuidof(INetFwMgr), (void**)&pNetFwMgr);
                if (FAILED(hr))
                {
                    return false;
                }

                CComPtr<INetFwPolicy> pNetFwPolicy;
                hr = pNetFwMgr->get_LocalPolicy(&pNetFwPolicy);
                if (FAILED(hr))
                {
                    return false;
                }

                CComPtr<INetFwAuthorizedApplication> pApp;
                hr = CoCreateInstance(__uuidof(NetFwAuthorizedApplication), NULL, CLSCTX_INPROC_SERVER, __uuidof(INetFwAuthorizedApplication), (void**)&pApp);
                if (FAILED(hr))
                {
                    return false;
                }

                // 在例外列表里，程序显示的名称
                BSTR bstrName = SysAllocString(name);
                pApp->put_Name(bstrName);
                SysFreeString(bstrName);

                // 程序的路径及文件名
                BSTR bstrExecutablePath = SysAllocString(executablePath);
                pApp->put_ProcessImageFileName(bstrExecutablePath);
                SysFreeString(bstrExecutablePath);

                // 是否启用该规则
                pApp->put_Enabled(VARIANT_TRUE);

                // 加入到防火墙的管理策略
                CComPtr<INetFwProfile> pNetFwProfile;
                hr = pNetFwPolicy->GetProfileByType(netFwType, &pNetFwProfile);
                if (FAILED(hr))
                {
                    return false;
                }

                CComPtr<INetFwAuthorizedApplications> pApps;
                hr = pNetFwProfile->get_AuthorizedApplications(&pApps);
                if (FAILED(hr))
                {
                    return false;
                }

                hr = pApps->Add(pApp);
                if (FAILED(hr))
                {
                    return false;
                }
                return true;
            }

            static bool FW_NetFirewallAddApplication(const wchar_t* name, const wchar_t* executablePath)
            {
                HRESULT hr = S_OK;

                // 创建NetFwPolicy2对象
                INetFwPolicy2* pPolicy = NULL;
                hr = CoCreateInstance(__uuidof(NetFwPolicy2), NULL, CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2), (void**)&pPolicy);
                if (FAILED(hr))
                {
                    return false;
                }

                // 获取INetFwRules对象
                INetFwRules* pRules = NULL;
                hr = pPolicy->get_Rules(&pRules);
                if (FAILED(hr))
                {
                    pPolicy->Release();
                    return false;
                }

                // 创建规则对象
                INetFwRule* pRule = NULL;
                hr = CoCreateInstance(__uuidof(NetFwRule), NULL, CLSCTX_INPROC_SERVER, __uuidof(INetFwRule), (void**)&pRule);
                if (FAILED(hr))
                {
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                // 设置规则属性
                _bstr_t bstrName(name);
                _bstr_t bstrExecutablePath(executablePath);

                hr = pRule->put_Name(bstrName);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                hr = pRule->put_Description(bstrName);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                hr = pRule->put_ApplicationName(bstrExecutablePath);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                hr = pRule->put_Direction(NET_FW_RULE_DIR_IN);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                hr = pRule->put_Action(NET_FW_ACTION_ALLOW);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                hr = pRule->put_Enabled(VARIANT_TRUE);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                // 检查是否已存在同名规则
                VARIANT_BOOL bFound = VARIANT_FALSE;
                IUnknown* pEnumeratorUnk = NULL;
                hr = pRules->get__NewEnum(&pEnumeratorUnk);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                IEnumVARIANT* pEnumerator = NULL;
                hr = pEnumeratorUnk->QueryInterface(__uuidof(IEnumVARIANT), (void**)&pEnumerator);
                pEnumeratorUnk->Release();
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                VARIANT var;
                ULONG cElems;
                while (pEnumerator->Next(1, &var, &cElems) == S_OK)
                {
                    IUnknown* pUnknown = var.punkVal;
                    INetFwRule* pExistingRule = NULL;
                    hr = pUnknown->QueryInterface(__uuidof(INetFwRule), (void**)&pExistingRule);
                    if (hr == S_OK)
                    {
                        _bstr_t bstrExistingName;
                        hr = pExistingRule->get_Name(bstrExistingName.GetAddress());
                        if (FAILED(hr))
                        {
                            continue;
                        }

                        _bstr_t bstrExistingAppPath;
                        hr = pExistingRule->get_ApplicationName(bstrExistingAppPath.GetAddress());
                        if (FAILED(hr))
                        {
                            continue;
                        }

                        if (bstrExistingName == bstrName && bstrExistingAppPath == bstrExecutablePath) {
                            bFound = VARIANT_TRUE;
                            break;
                        }
                        else
                        {
                            pExistingRule->Release();
                        }
                    }
                    VariantClear(&var);
                }

                // 如果已存在同名规则，则释放资源并返回
                pEnumerator->Release();
                if (bFound)
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return true;
                }

                // 添加规则
                hr = pRules->Add(pRule);
                if (FAILED(hr))
                {
                    pRule->Release();
                    pRules->Release();
                    pPolicy->Release();
                    return false;
                }

                // 释放资源
                pRule->Release();
                pRules->Release();
                pPolicy->Release();

                return true;
            }

            static bool FW_NetFirewallAddAllApplication(const wchar_t* name, const wchar_t* executablePath) noexcept
            {
                if (FW_NetFirewallAddApplication(name, executablePath))
                {
                    return true;
                }

                bool b = true;
                b &= FW_NetFirewallAddApplication(name, executablePath, NET_FW_PROFILE_STANDARD); // 1
                b &= FW_NetFirewallAddApplication(name, executablePath, NET_FW_PROFILE_CURRENT);  // 2
                return b;
            }

            static bool FW_require(const char* name, const char* executablePath, NET_FW_PROFILE_TYPE netFwType, bool(*f)(_bstr_t&, _bstr_t&, NET_FW_PROFILE_TYPE)) noexcept
            {
                SYSTEM_WINDOWS_COM_INITIALIZED WINDOWS_COM_INITIALIZED;

                if (NULL == name)
                {
                    name = "";
                }

                if (NULL == executablePath)
                {
                    executablePath = "";
                }

                _bstr_t bstr_name(name);
                _bstr_t bstr_executablePath(executablePath);

                return f(bstr_name, bstr_executablePath, netFwType);
            }

            bool Fw::NetFirewallAddApplication(const char* name, const char* executablePath, NetFirewallType netFwType) noexcept
            {
                NET_FW_PROFILE_TYPE netFwProfileType = NET_FW_PROFILE_DOMAIN; // 城域网络
                if (netFwType == NetFirewallType_PrivateNetwork)   // 专用网络
                {
                    netFwProfileType = NET_FW_PROFILE_STANDARD;
                }
                elif(netFwType == NetFirewallType_PublicNetwork) // 公共网络
                {
                    netFwProfileType = NET_FW_PROFILE_CURRENT;
                }

                return FW_require(name, executablePath, netFwProfileType, [](_bstr_t& name, _bstr_t& executablePath, NET_FW_PROFILE_TYPE netFwType) noexcept
                    {
                        return FW_NetFirewallAddApplication(name, executablePath, netFwType);
                    });
            }

            bool Fw::NetFirewallAddApplication(const char* name, const char* executablePath) noexcept
            {
                return FW_require(name, executablePath, NET_FW_PROFILE_TYPE_MAX, [](_bstr_t& name, _bstr_t& executablePath, NET_FW_PROFILE_TYPE netFwType) noexcept
                    {
                        return FW_NetFirewallAddApplication(name, executablePath);
                    });
            }

            bool Fw::NetFirewallAddAllApplication(const char* name, const char* executablePath) noexcept
            {
                return FW_require(name, executablePath, NET_FW_PROFILE_TYPE_MAX, [](_bstr_t& name, _bstr_t& executablePath, NET_FW_PROFILE_TYPE netFwType) noexcept
                    {
                        return FW_NetFirewallAddAllApplication(name, executablePath);
                    });
            }
        }
    }
}

VC++检测防火墙是否开启、判断程序是否加入防火墙白名单（附源码）
dvlinker的技术专栏
03-27 1万+
检测Windows防火墙是否开启、判断程序是否加入Windows防火墙白名单
VC++常用功能开发汇总
热门推荐
dvlinker的技术专栏
04-19 12万+
VC++常用功能开发汇总
VC代码添加防火墙规则
深之JohnChen的专栏
05-20 2696
一、VC代码添加防火墙规则（调用netsh命令）BOOL DealExecCmd(CString strCommandLine) { USES_CONVERSION; STARTUPINFO StartInfo; memset(&amp;StartInfo, '\0', sizeof(StartInfo)); StartInfo.cb = sizeof(StartInfo); ...
vc操作windows防火墙的方法
weixin_30835933的博客
07-01 304
收藏该地址，以备不时之需。 http://msdn.microsoft.com/en-us/library/aa364726.aspx 转载于:https://www.cnblogs.com/RascallySnake/p/3165355.html
VC实现的简易防火墙
旧雨绵绵的专栏
05-26 2509
、  一、实验目的(1)  修改代码，完成下述功能：a) 由本机登录ftp服务器成功（通过用户名、密码验证）；b) 无法将ftp内容列表或上传、下载数据；(2) 作业要求：a) 明确提出自己的方案设计，即通过何原理实现上述功能；b) 纸版作业只需要粘贴自己撰写的代码部分；c) 实验结果需要截图证明；二、实验过程1， 学习FTP应用的相关知识FTP（File Transfer Protocal），是
vc++开发的班级年级学生成绩管理系统
3. **用户权限管理**：不同的用户（如教师、学生、管理员）需要有不同的访问权限。 4. **界面友好性**：提供清晰、直观、易于操作的用户界面。 ### 根据班级、年级划分功能 针对描述中提到的“根据班级、年级来划分...
基于VC++的图幅信息管理系统开发
08-04
- **权限控制**: 不同的用户角色具有不同的操作权限，例如管理员可以查看所有信息，普通用户只能查看特定信息。 **2. 数据库操作** - **数据源连接**: 使用ADO技术连接Access数据库，实现数据的高效读写操作。 - *...
VC++6.0 支持win7
07-29
- 使用管理员权限运行安装程序，确保程序有足够的权限访问系统目录。 3. **解决常见问题** - 如果遇到“msdev.exe已停止工作”或“不能创建新工程”的错误，可能需要手动注册一些DLL文件，如msvcrt.dll和msvcp60....
VC++6.0文件夹打开崩溃问题的系统性解决方法
请确保以管理员身份运行VC++6.0，并检查系统的用户权限设置。 5. 文件系统问题： 硬盘或文件系统错误有时也会引起程序不稳定。可以进行磁盘检查和修复来解决潜在的文件系统问题。在命令提示符下运行以下命令： - ...
简易防火墙（VC++）
10-23
一个简易的防火墙程序，VC编写，已有项目文件了，学习用非常好。
基于VC＋＋的防火墙NetDefender
10-18
基于VC＋＋的防火墙NetDefender 不错的网络编程实例
VC++防火墙源代码
09-11
VC++防火墙源代码
VC++网络防火墙综合实例
06-24
使用VC++进行编写的防火墙，是对VC++的一个综合练习，尤其是网络方面的。
简单个人防火墙VC原代码
03-20
一个很简单的vc防火墙程序里面只实现了部分功能适合初学者使用，可自行添加功能。
【小沐学C++】C++ 修改防火墙firewall设置（Windows）
爱看书的小沐
02-16 1695
防火墙（英语：Firewall）技术是通过有机结合各类用于安全管理与筛选的软件和硬件设备，帮助计算机网络于其内、外网之间构建一道相对隔绝的保护屏障，以保护用户资料与信息安全性的一种技术。所谓“防火墙”是指一种将内部网和公众访问网（如Internet）分开的方法，它实际上是一种建立在现代通信网络技术和信息安全技术基础上的应用性安全技术，隔离技术。越来越多地应用于专用网络与公用网络的互联环境之中，尤其以接入Internet网络为最甚。
基于VC++包过滤技术防火墙设计与实现
毕业作品网站
10-27 1643
这种技术是在网络中适当的位置对数据包实施有选择的通过,选择依据,即为系统内设置的过滤规则(通常称为访问控制表-----Access Control List),只有满足过滤规则的数据包才被转发至相应的网络接口,其余数据包则被从数据流中删除。本文主要研究个人安全防御系统中包过滤系统的设计与实现,通过对现有包过滤技术深入的研究与分析,发现其中的不足之处,并在设计实现的过程中对其进行改进和完善。1全面深入的研究现有的包过滤技术,分析比较每一种包过滤技术的优缺点,结合个人安全防御系统的特点确定所要使用的技术。
基于VC++的包过滤防火墙系统设计与实现
毕业作品网站
09-09 2083
该工具最大优点就是提供了功能强大的MFC类库，MFC是一个很大的C++类层次结构，其中封装了大量的类及其函数，很多Windows程序所共有的标准内容可以由M-FC的类来提供，MFC类为这些内容提供了用户接口的标准实现方法，程序员所要做的就是通过预定义的接口把具体应用程序特有的东西填入这个轮廓，这将简化编程工作，大大地减少程序员编写的代码数量，使编程工作变得更加轻松容易。这样程序的功能模块应该有：过滤规则添加删除功能模块，过滤规则显示功能模块，过滤规则存储功能模块，文件储存功能模块，安装卸载规则功能模块。
防火墙（入站规则）C++修改方法 以解决服务器无法连接问题
wangchaoqi1985的博客
10-04 343
防火墙（入站规则）C++修改方法 以解决服务器无法连接问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值