Automating Windows Firewall with

后端未结

关注

 3  688

I have C# Application that uses PORT 777 for asynchronous communication and PORT 3306 for communication with My Sql Server. Problems arise when the ports is blocked by a fir

相关标签:

3条回答

情深已故

2020-12-14 14:11

http://www.codeproject.com/Articles/14906/Open-Windows-Firewall-During-Installation

Before using the program below, please add reference FirewallAPI.dll to Visual Studio 2010. Do the following: Right-click the Project from the Solution Explorer of Visual Studio 2010 - Select the Add Reference - Select C:\Windows\System32\FirewallAPI.dll - Ok

Calling program firewall with 3 line code below. You can put this code in the form load of your program:

  private clsFirewall objFirewall = new clsFirewall();
  objFirewall.CloseFirewall();
  objFirewall.OpenFirewall();

/* Automating Windows Firewall with C# Support Windows 7 */

using System; 
using System.Collections; 
using System.Collections.Generic; 
using System.Data; 
using System.Diagnostics; 
using System.Threading; 
using NetFwTypeLib; 
using System.Windows.Forms;


namespace MyFirewall {

  public class clsFirewall {

    private int[] portsSocket = { 777, 3306 };
    private string[] portsName = { "AsyncPort", "MySqlPort" };
    private INetFwProfile fwProfile = null;

    protected internal void OpenFirewall() {
        INetFwAuthorizedApplications authApps = null;
        INetFwAuthorizedApplication authApp = null;
        INetFwOpenPorts openPorts = null;
        INetFwOpenPort openPort = null;
        try {
            if (isAppFound(Application.ProductName + " Server") == false) {
                SetProfile();
                authApps = fwProfile.AuthorizedApplications;
                authApp = GetInstance("INetAuthApp") as INetFwAuthorizedApplication;
                authApp.Name = Application.ProductName + " Server";
                authApp.ProcessImageFileName = Application.ExecutablePath;
                authApps.Add(authApp);
            }

            if (isPortFound(portsSocket[0]) == false) {
                SetProfile();
                openPorts = fwProfile.GloballyOpenPorts;
                openPort = GetInstance("INetOpenPort") as INetFwOpenPort;
                openPort.Port = portsSocket[0];
                openPort.Protocol = NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP;
                openPort.Name = portsName[0];
                openPorts.Add(openPort);
            }

            if (isPortFound(portsSocket[1]) == false) {
                SetProfile();
                openPorts = fwProfile.GloballyOpenPorts;
                openPort = GetInstance("INetOpenPort") as INetFwOpenPort;
                openPort.Port = portsSocket[1];
                openPort.Protocol = NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP;
                openPort.Name = portsName[1];
                openPorts.Add(openPort);
            }

        }
        catch (Exception ex) {
            MessageBox.Show(ex.Message);
        }
        finally {
            if (authApps != null) authApps = null;
            if (authApp != null) authApp = null;
            if (openPorts != null) openPorts = null;
            if (openPort != null) openPort = null;
        }
    }

    protected internal void CloseFirewall() {
        INetFwAuthorizedApplications apps = null;
        INetFwOpenPorts ports = null;
        try {
            if (isAppFound(Application.ProductName + " Server") == true) {
                SetProfile();
                apps = fwProfile.AuthorizedApplications;
                apps.Remove(Application.ExecutablePath);
            }

            if (isPortFound(portsSocket[0]) == true) {
                SetProfile();
                ports = fwProfile.GloballyOpenPorts;
                ports.Remove(portsSocket[0], NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP);
            }

            if (isPortFound(portsSocket[1]) == true) {
                SetProfile();
                ports = fwProfile.GloballyOpenPorts;
                ports.Remove(portsSocket[1], NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP);
            }
        }
        catch (Exception ex) {
            MessageBox.Show(ex.Message);
        }
        finally {
            if (apps != null) apps = null;
            if (ports != null) ports = null;
        }
    }

    protected internal bool isAppFound(string appName) {
        bool boolResult = false;
        Type progID = null;
        INetFwMgr firewall = null;
        INetFwAuthorizedApplications apps = null;
        INetFwAuthorizedApplication app = null;
        try {
            progID = Type.GetTypeFromProgID("HNetCfg.FwMgr");
            firewall = Activator.CreateInstance(progID) as INetFwMgr;
            if (firewall.LocalPolicy.CurrentProfile.FirewallEnabled) {
                apps = firewall.LocalPolicy.CurrentProfile.AuthorizedApplications;
                IEnumerator appEnumerate = apps.GetEnumerator();
                while ((appEnumerate.MoveNext())) {
                    app = appEnumerate.Current as INetFwAuthorizedApplication;
                    if (app.Name == appName) {
                        boolResult = true;
                        break;
                    }
                }
            }
        }
        catch (Exception ex) {
            MessageBox.Show(ex.Message);
        }
        finally {
            if (progID != null) progID = null;
            if (firewall != null) firewall = null;
            if (apps != null) apps = null;
            if (app != null) app = null;
        }
        return boolResult;
    }

    protected internal bool isPortFound(int portNumber) {
        bool boolResult = false;
        INetFwOpenPorts ports = null;
        Type progID = null;
        INetFwMgr firewall = null;
        INetFwOpenPort currentPort = null;
        try {
            progID = Type.GetTypeFromProgID("HNetCfg.FwMgr");
            firewall = Activator.CreateInstance(progID) as INetFwMgr;
            ports = firewall.LocalPolicy.CurrentProfile.GloballyOpenPorts;
            IEnumerator portEnumerate = ports.GetEnumerator();
            while ((portEnumerate.MoveNext())) {
                currentPort = portEnumerate.Current as INetFwOpenPort;
                if (currentPort.Port == portNumber) {
                    boolResult = true;
                    break;
                }
            }
        }
        catch (Exception ex) {
            MessageBox.Show(ex.Message);
        }
        finally
        {
            if (ports != null) ports = null;
            if (progID != null) progID = null;
            if (firewall != null) firewall = null;
            if (currentPort != null) currentPort = null;
        }
        return boolResult;
    }

    protected internal void SetProfile() {
        INetFwMgr fwMgr = null;
        INetFwPolicy fwPolicy = null;
        try {
            fwMgr = GetInstance("INetFwMgr") as INetFwMgr;
            fwPolicy = fwMgr.LocalPolicy;
            fwProfile = fwPolicy.CurrentProfile;
        }
        catch (Exception ex) {
            MessageBox.Show(ex.Message);
        }
        finally {
            if (fwMgr != null) fwMgr = null;
            if (fwPolicy != null) fwPolicy = null;
        }
    }

    protected internal object GetInstance(string typeName) {
        Type tpResult = null;
        switch (typeName) {
            case "INetFwMgr":
                tpResult = Type.GetTypeFromCLSID(new Guid("{304CE942-6E39-40D8-943A-B913C40C9CD4}"));
                return Activator.CreateInstance(tpResult);
            case "INetAuthApp":
                tpResult = Type.GetTypeFromCLSID(new Guid("{EC9846B3-2762-4A6B-A214-6ACB603462D2}"));
                return Activator.CreateInstance(tpResult);
            case "INetOpenPort":
                tpResult = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
                return Activator.CreateInstance(tpResult);
            default:
                return null;
        }
    }

  } 
}

0 讨论(0)

你的背包

2020-12-14 14:19

The accepted answer by Javanese Girl had a C-like implementation with a declare-use-free pattern, and redundant code. Here is a refactored implementation based on that answer. It uses all the same calls into FirewallAPI.dll; it is functionally equivalent, so it solves the original question's problem of not being able to get these sorts of firewall operations to work. This solution has a simple interface that hides all the details: IsPortOpen, OpenPort, and ClosePort.

Example Usage:

int port = 9914;
if (IsPortOpen(port))
    ClosePort(port);
OpenPort(port, "StreamBeam API");

Implementation:

using System;
using System.Collections;

using NetFwTypeLib;

namespace YourCompany
{
    public static class FirewallUtils
    {
        public static bool IsPortOpen(int port)
        {
            EnsureSetup();

            Type progID = Type.GetTypeFromProgID("HNetCfg.FwMgr");
            INetFwMgr firewall = Activator.CreateInstance(progID) as INetFwMgr;
            INetFwOpenPorts ports = firewall.LocalPolicy.CurrentProfile.GloballyOpenPorts;
            IEnumerator portEnumerate = ports.GetEnumerator();
            while ((portEnumerate.MoveNext()))
            {
                INetFwOpenPort currentPort = portEnumerate.Current as INetFwOpenPort;
                if (currentPort.Port == port)
                    return true;
            }
            return false;
        }

        public static void OpenPort(int port, string applicationName)
        {
            EnsureSetup();

            if (IsPortOpen(port))
                return;

            INetFwOpenPort openPort = GetInstance("INetOpenPort") as INetFwOpenPort;
            openPort.Port = port;
            openPort.Protocol = NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP;
            openPort.Name = applicationName;

            INetFwOpenPorts openPorts = sm_fwProfile.GloballyOpenPorts;
            openPorts.Add(openPort);
        }

        public static void ClosePort(int port)
        {
            EnsureSetup();

            if (!IsPortOpen(port))
                return;

            INetFwOpenPorts ports = sm_fwProfile.GloballyOpenPorts;
            ports.Remove(port, NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP);
        }

        private static object GetInstance(string typeName)
        {
            Type tpResult = null;
            switch (typeName)
            {
                case "INetFwMgr":
                    tpResult = Type.GetTypeFromCLSID(new Guid("{304CE942-6E39-40D8-943A-B913C40C9CD4}"));
                    return Activator.CreateInstance(tpResult);
                case "INetAuthApp":
                    tpResult = Type.GetTypeFromCLSID(new Guid("{EC9846B3-2762-4A6B-A214-6ACB603462D2}"));
                    return Activator.CreateInstance(tpResult);
                case "INetOpenPort":
                    tpResult = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
                    return Activator.CreateInstance(tpResult);
                default:
                    throw new Exception("Unknown type name: " + typeName);
            }
        }

        private static void EnsureSetup()
        {
            if (sm_fwProfile != null)
                return;

            INetFwMgr fwMgr = GetInstance("INetFwMgr") as INetFwMgr;
            sm_fwProfile = fwMgr.LocalPolicy.CurrentProfile;
        }

        private static INetFwProfile sm_fwProfile = null;
    }
}

0 讨论(0)

暗喜

2020-12-14 14:28

I came here via Google looking for a .net method of listing the Windows Firewall open ports. The answers described above did not work. Specifically the firewall.LocalPolicy.CurrentProfile.GloballyOpenPorts always had a count of zero. These answers are old and may well apply to Windows 7. What worked for me on Windows 10 was this code.

using System;
using System.Collections;
using NetFwTypeLib;

namespace FirewallPorts
{
    class FwPorts
    {
        static void Main(string[] args)
        {
            Type fwPolicy2Type = Type.GetTypeFromProgID("HNetCfg.FwPolicy2", true);
            INetFwPolicy2 fwPolicy = (INetFwPolicy2)Activator.CreateInstance(fwPolicy2Type);
            int currentProfs = fwPolicy.CurrentProfileTypes;
            NET_FW_PROFILE_TYPE2_ foo = (NET_FW_PROFILE_TYPE2_)currentProfs;
            if (foo.HasFlag(NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE))
                Console.WriteLine("PrivateNet");
            if (!foo.HasFlag(NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PUBLIC))
                Console.WriteLine("NOT PUBLIC");
            bool fpsEnabled = fwPolicy.IsRuleGroupCurrentlyEnabled["File and Printer Sharing"];
            bool FwEnabled = fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PUBLIC] || fwPolicy.FirewallEnabled[NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE];
            Console.WriteLine($"Windows Firewall enabled is {FwEnabled}");
            INetFwRules rules = fwPolicy.Rules;
            foreach (INetFwRule item in rules)
            {
                if (item.Enabled && item.Name.Contains("Sharing"))
                {
                    Console.WriteLine(item.Name);
                    Console.WriteLine($"LocalPorts: {item.LocalPorts}, {(NET_FW_PROFILE_TYPE2_)item.Profiles}");
                    Console.WriteLine(item.Description + "\r\n");
                }
            }
        }
    }
}

I did not need to open or close Ports but it can be done by changing rule status, or creating new rules and enabling them. Hope this saves someone else a few hours.

0 讨论(0)