Пример #1
0
        public FwErrorCode IsPortEnabled(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, ref bool bEnable)
        {
            if (_mFirewallProfile == null)
            {
                return(FwErrorCode.FwErrInitialized);
            }

            // Retrieve the open ports collection
            INetFwOpenPorts fwOpenPorts = _mFirewallProfile.GloballyOpenPorts;

            if (fwOpenPorts == null)
            {
                return(FwErrorCode.FwErrGlobalOpenPorts);
            }

            // Get the open port
            try
            {
                INetFwOpenPort fwOpenPort = fwOpenPorts.Item(nPortNumber, ipProtocol);
                bEnable = fwOpenPort?.Enabled == true;
            }
            catch (System.IO.FileNotFoundException)
            {
                bEnable = false;
            }

            return(FwErrorCode.FwNoerror);
        }
Пример #2
0
        public bool IsPortEnabled(int port, NET_FW_IP_PROTOCOL_ ipProtocol)
        {
            DoDisposeCheck();
            DoInitializationCheck();

            bool result = false;

            // Retrieve the open ports collection
            INetFwOpenPorts firewallOpenPorts = mFirewallProfile.GloballyOpenPorts;

            if (firewallOpenPorts == null)
            {
                throw new FirewallException("Failed to get globally open ports.");
            }

            // Get the open port
            try
            {
                INetFwOpenPort firewallOpenPort = firewallOpenPorts.Item(port, ipProtocol);
                if (firewallOpenPort != null)
                {
                    result = firewallOpenPort.Enabled;
                }
            }
            catch (Exception)
            {
            }

            return(result);
        }
Пример #3
0
 // example: AddPort(true, "TCP Port", Int32.Parse(port.Text), NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP);
 public static bool AddPort(bool enabled, string name, int port, NET_FW_IP_PROTOCOL_ protocol)
 {
     // Add the port to the ICF Permissions List
     INetFwMgr mgr = null;
     try
     {
     mgr = (NetFwTypeLib.INetFwMgr)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwMgr"));
     }
     catch
     {
     // XPSP2 not installed
     return false;
     }
     try
     {
     INetFwProfile profile;
     INetFwOpenPort portClass = (NetFwTypeLib.INetFwOpenPort)Activator.CreateInstance(
                                    Type.GetTypeFromProgID("HNetCfg.FWOpenPort"));
     // Get the current profile
     profile = mgr.LocalPolicy.CurrentProfile;
     // Set the port properties
     portClass.Enabled = enabled;
     portClass.Name = name;
     portClass.Port = port;
     portClass.Protocol = protocol;
     // Add the port to the ICF Permissions List
     profile.GloballyOpenPorts.Add(portClass);
     return true;
     }
     catch
     {
     // Log the error or prompt the user
     return false;
     }
 }
Пример #4
0
        public FW_ERROR_CODE IsPortEnabled(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, ref bool bEnable)
        {
            if (m_FirewallProfile == null)
            {
                return(FW_ERROR_CODE.FW_ERR_INITIALIZED);
            }

            // Retrieve the open ports collection
            INetFwOpenPorts FWOpenPorts = m_FirewallProfile.GloballyOpenPorts;

            if (FWOpenPorts == null)
            {
                return(FW_ERROR_CODE.FW_ERR_GLOBAL_OPEN_PORTS);
            }

            // Get the open port
            try
            {
                INetFwOpenPort FWOpenPort = FWOpenPorts.Item(nPortNumber, ipProtocol);
                if (FWOpenPort != null)
                {
                    bEnable = FWOpenPort.Enabled;
                }
                else
                {
                    bEnable = false;
                }
            }
            catch (FileNotFoundException)
            {
                bEnable = false;
            }

            return(FW_ERROR_CODE.FW_NOERROR);
        }
Пример #5
0
        /// <summary>
        /// 添加防火墙例外端口
        /// </summary>
        /// <param name="name">名称</param>
        /// <param name="port">端口</param>
        /// <param name="protocol">协议(TCP、UDP)</param>
        public static void NetFwAddPorts(string name, int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            var     serviceControllers = ServiceController.GetServices();
            string  fireWallServiceName;
            Version currentVersion = Environment.OSVersion.Version;

            if (currentVersion.Major == 5)
            {
                fireWallServiceName = "sharedaccess";
            }
            else
            {
                fireWallServiceName = "mpssvc";
            }

            var server = serviceControllers.FirstOrDefault(service => service.ServiceName.ToLower() == fireWallServiceName);

            if (server != null && server.Status == ServiceControllerStatus.Running)
            {
                //创建firewall管理类的实例
                INetFwMgr netFwMgr = (INetFwMgr)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwMgr"));

                INetFwOpenPort objPort = (INetFwOpenPort)Activator.CreateInstance(
                    Type.GetTypeFromProgID("HNetCfg.FwOpenPort"));

                objPort.Name     = name;
                objPort.Port     = port;
                objPort.Protocol = protocol;
                objPort.Scope    = NET_FW_SCOPE_.NET_FW_SCOPE_ALL;
                objPort.Enabled  = true;

                //加入到防火墙的管理策略,若已存在会启用该规则
                netFwMgr.LocalPolicy.CurrentProfile.GloballyOpenPorts.Add(objPort);
            }
        }
Пример #6
0
        public static void CreateRuleAllow(string ruleName, string ip, int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            RemoveRule(ruleName);
            try
            {
                INetFwRule2   inboundRule    = (INetFwRule2)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FWRule"));
                INetFwPolicy2 firewallPolicy = (INetFwPolicy2)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwPolicy2"));
                inboundRule.Name        = ruleName;
                inboundRule.Description = $"Allow inbound traffic from users over port {port}";
                inboundRule.Action      = NET_FW_ACTION_.NET_FW_ACTION_ALLOW;
                inboundRule.Profiles    = (int)NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_ALL;
                inboundRule.Protocol    = (int)protocol;
                //inboundRule.Direction = NET_FW_RULE_DIRECTION_.NET_FW_RULE_DIR_IN;
                //inboundRule.Grouping = "@firewallapi.dll,-23255";

                inboundRule.RemoteAddresses = ip;
                inboundRule.LocalPorts      = port.ToString();
                inboundRule.Enabled         = true;


                firewallPolicy.Rules.Add(inboundRule);
                Logger.White($" [Firewall] Allow {(protocol == NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP ? "Tcp" : protocol == NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_UDP ? "Udp" : "Unknown")} connection rule on port {port} has been registered in windows firewall.");
                firewallPolicy = null;
                inboundRule    = null;
            }
            catch (Exception ex)
            {
                Logger.Exception(ex);
            }
        }
Пример #7
0
        public bool RemovePort(int port, NET_FW_IP_PROTOCOL_ ipProtocol)
        {
            DoDisposeCheck();
            DoInitializationCheck();

            bool changed = false;

            if (IsPortEnabled(port, ipProtocol))
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts firewallOpenPorts = mFirewallProfile.GloballyOpenPorts;
                if (firewallOpenPorts == null)
                {
                    throw new FirewallException("Failed to get globally open ports.");
                }

                try
                {
                    firewallOpenPorts.Remove(port, ipProtocol);
                    changed = true;
                }
                catch (Exception ex)
                {
                    throw new FirewallException("Failed to remove port.", ex);
                }
            }

            return(changed);
        }
Пример #8
0
        public static void AddFirewallRule(NET_FW_IP_PROTOCOL_ protocol, string remoteAddress, string port, string processPath)
        {
            if (!IsUserAdmin())
            {
                MessageBox.Show("You need to run the application as administrator to use this feature.", "Admin rights required", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            INetFwPolicy2 fwPolicy2       = GetFwPolicy2();
            var           currentProfiles = fwPolicy2.CurrentProfileTypes;

            // New rule.
            INetFwRule2 inboundRule = (INetFwRule2)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FWRule"));

            inboundRule.Enabled         = true;
            inboundRule.Action          = NET_FW_ACTION_.NET_FW_ACTION_BLOCK;
            inboundRule.Direction       = NET_FW_RULE_DIRECTION_.NET_FW_RULE_DIR_IN;
            inboundRule.Protocol        = (int)protocol;
            inboundRule.LocalPorts      = port;
            inboundRule.RemoteAddresses = remoteAddress;
            inboundRule.ApplicationName = processPath;
            inboundRule.Name            = RuleName;
            inboundRule.Profiles        = currentProfiles;

            // Adding rule.
            fwPolicy2.Rules.Add(inboundRule);
        }
Пример #9
0
        // example: RemovePort(Int32.Parse(port.Text), NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP);
        public static bool RemovePort(int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            // Remove the port to the ICF Permissions List
            INetFwMgr mgr = null;

            try
            {
                mgr = (NetFwTypeLib.INetFwMgr)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwMgr"));
            }
            catch
            {
                // XPSP2 not installed
                return(false);
            }

            try
            {
                INetFwProfile profile;

                // Get the current profile
                profile = mgr.LocalPolicy.CurrentProfile;

                // Remove the port to the ICF Permissions List
                profile.GloballyOpenPorts.Remove(port, protocol);
                return(true);
            }
            catch
            {
                // Log the error or prompt the user
                return(false);
            }
        }
Пример #10
0
        /// <summary>
        /// Creates a new port entry in the firewall collection.
        /// </summary>
        /// <param name="port">The port number.</param>
        /// <param name="name">The name of the port.</param>
        /// <param name="protocol">The protocol used.</param>
        /// <param name="scope">The scope of the control.</param>
        public void OpenFirewallPort(int port, string name,
                                     NET_FW_IP_PROTOCOL_ protocol, NET_FW_SCOPE_ scope)
        {
            // Set the current access profile.
            SetProfile();

            // Get the current globall
            // open port profile control.
            INetFwOpenPorts openPorts = fwProfile.GloballyOpenPorts;

            // Create a new instance of the
            // open new port type.
            INetFwOpenPort openPort = (INetFwOpenPort)GetInstance("INetOpenPort");

            // Assign the port specifications.
            openPort.Port     = port;
            openPort.Name     = name;
            openPort.Scope    = scope;
            openPort.Protocol = protocol;

            // Add the new port to the
            // collection of ports.
            openPorts.Add(openPort);
            openPorts = null;
        }
Пример #11
0
 public PortInfo(int portNumber)
 {
     imageFileName   = null;
     ipVersion       = NET_FW_IP_VERSION_.NET_FW_IP_VERSION_V4;
     this.portNumber = portNumber;
     localAddress    = null;
     ipProtocol      = NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP;
 }
Пример #12
0
        public FW_ERROR_CODE AddPort(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, string strRegisterName)
        {
            if (m_FirewallProfile == null)
            {
                return(FW_ERROR_CODE.FW_ERR_INITIALIZED);
            }

            bool          bEnablePort = true;
            FW_ERROR_CODE nError      = IsPortEnabled(nPortNumber, ipProtocol, ref bEnablePort);

            if (nError != FW_ERROR_CODE.FW_NOERROR)
            {
                return(nError);
            }

            // Only add the port, if it isn't added to the collection
            if (bEnablePort == false)
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts FWOpenPorts = m_FirewallProfile.GloballyOpenPorts;
                if (FWOpenPorts == null)
                {
                    return(FW_ERROR_CODE.FW_ERR_GLOBAL_OPEN_PORTS);
                }

                // Create an instance of an open port
                Type typeFwPort = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
                var  FWOpenPort = (INetFwOpenPort)Activator.CreateInstance(typeFwPort);
                if (FWOpenPort == null)
                {
                    return(FW_ERROR_CODE.FW_ERR_CREATE_PORT_INSTANCE);
                }

                // Set the port number
                FWOpenPort.Port = nPortNumber;

                // Set the IP Protocol
                FWOpenPort.Protocol = ipProtocol;

                // Set the registered name
                FWOpenPort.Name = strRegisterName;

                try
                {
                    FWOpenPorts.Add(FWOpenPort);
                }
                catch
                {
                    return(FW_ERROR_CODE.FW_ERR_ADD_TO_COLLECTION);
                }
            }
            else
            {
                return(FW_ERROR_CODE.FW_ERR_SAME_PORT_EXIST);
            }

            return(FW_ERROR_CODE.FW_NOERROR);
        }
Пример #13
0
 public TestFirewallRule(string name, string ports, NET_FW_IP_PROTOCOL_ protocol, NET_FW_RULE_DIRECTION_ direction,
                         string appPath, string grouping)
 {
     this.Name            = name;
     this.Ports           = ports;
     this.Protocol        = protocol;
     this.Direction       = direction;
     this.ApplicationPath = appPath;
     this.Grouping        = grouping;
 }
Пример #14
0
        private bool _IsPortOpen(INetFwProfile profile)
        {
            NET_FW_IP_PROTOCOL_ protocol = _GetProtocol();

            if (!profile.FirewallEnabled)
            {
                return(true);
            }
            return(profile.GloballyOpenPorts.Cast <INetFwOpenPort>().Any(p => p.Protocol == protocol && p.Port == _Port));
        }
Пример #15
0
        public static void RemovePortExceptionFromSP2Firewall(int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            // Instantiating the HNetCfg.NetFwMgr object to get "LocalPolicy" and then "CurrentProfile"
            INetFwMgr     fwMgr     = (INetFwMgr)Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(INetFwMgrGuid)), true);
            INetFwPolicy  fwPolicy  = fwMgr.LocalPolicy;
            INetFwProfile fwProfile = fwPolicy.CurrentProfile;

            // Remove application from exception rule list
            fwProfile.GloballyOpenPorts.Remove(port, protocol);
        }
Пример #16
0
        public static ProtocolPort Convert(NET_FW_IP_PROTOCOL_ item)
        {
            switch (item)
            {
            case NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP: return(ProtocolPort.Tcp);

            case NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_UDP: return(ProtocolPort.Udp);

            default: return(ProtocolPort.Any);
            }
        }
Пример #17
0
        private INetFwOpenPort GetPortObj(string portNumber, NET_FW_IP_PROTOCOL_ ipProtocol)
        {
            Type           tpResult = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
            INetFwOpenPort port     = (INetFwOpenPort)Activator.CreateInstance(tpResult);

            port.Port     = Int32.Parse(portNumber); // port number
            port.Name     = appName;                 // name of the application using the port
            port.Enabled  = true;                    // enable the port
            port.Protocol = ipProtocol;
            return(port);
        }
Пример #18
0
        public FwErrorCode AddPort(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, string strRegisterName)
        {
            if (_mFirewallProfile == null)
            {
                return(FwErrorCode.FwErrInitialized);
            }

            bool        bEnablePort = true;
            FwErrorCode nError      = IsPortEnabled(nPortNumber, ipProtocol, ref bEnablePort);

            if (nError != FwErrorCode.FwNoerror)
            {
                return(nError);
            }

            // Only add the port, if it isn't added to the collection
            if (bEnablePort == false)
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts fwOpenPorts = _mFirewallProfile.GloballyOpenPorts;
                if (fwOpenPorts == null)
                {
                    return(FwErrorCode.FwErrGlobalOpenPorts);
                }

                // Create an instance of an open port
                Type typeFwPort = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
                var  fwOpenPort = (INetFwOpenPort)Activator.CreateInstance(typeFwPort);

                // Set the port number
                fwOpenPort.Port = nPortNumber;

                // Set the IP Protocol
                fwOpenPort.Protocol = ipProtocol;

                // Set the registered name
                fwOpenPort.Name = strRegisterName;

                try
                {
                    fwOpenPorts.Add(fwOpenPort);
                }
                catch
                {
                    return(FwErrorCode.FwErrAddToCollection);
                }
            }
            else
            {
                return(FwErrorCode.FwErrSamePortExist);
            }

            return(FwErrorCode.FwNoerror);
        }
Пример #19
0
        private void OpenPort(string name, int port, NET_FW_IP_PROTOCOL_ protocol, NET_FW_SCOPE_ scope)
        {
            if (openPorts.OfType <INetFwOpenPort>().Where(x => x.Name == name).Count() == 0)
            {
                INetFwOpenPort openPort = (INetFwOpenPort)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwOpenPort"));
                openPort.Port     = port;
                openPort.Protocol = protocol;
                openPort.Scope    = scope;
                openPort.Name     = name;

                openPorts.Add(openPort);
            }
        }
Пример #20
0
        /// <summary>
        /// Removes the port entry from the firewall collection.
        /// </summary>
        /// <param name="port">The port number.</param>
        /// <param name="protocol">The protocol used.</param>
        public void CloseFirewallPort(int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            // Set the current access profile.
            SetProfile();

            // Get the current globall
            // open port profile control.
            INetFwOpenPorts openPorts = fwProfile.GloballyOpenPorts;

            // Remove the specified port from the collection.
            openPorts.Remove(port, protocol);
            openPorts = null;
        }
Пример #21
0
        public bool AddPort(int port, NET_FW_IP_PROTOCOL_ ipProtocol, string registeredName)
        {
            DoDisposeCheck();
            DoInitializationCheck();
            if (string.IsNullOrEmpty(registeredName))
            {
                ThrowHelper.ThrowArgumentNullException("registeredName");
            }

            bool result = false;

            if (!IsPortEnabled(port, ipProtocol))
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts firewallOpenPorts = mFirewallProfile.GloballyOpenPorts;
                if (firewallOpenPorts == null)
                {
                    throw new FirewallException("Failed to get globally open ports.");
                }

                // Create an instance of an open port
                Type           firewallPortType = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
                INetFwOpenPort firewallOpenPort = (INetFwOpenPort)Activator.CreateInstance(firewallPortType);
                if (firewallOpenPort == null)
                {
                    throw new FirewallException("Failed to create port instance.");
                }

                // Set the port number
                firewallOpenPort.Port = port;

                // Set the IP Protocol
                firewallOpenPort.Protocol = ipProtocol;

                // Set the registered name
                firewallOpenPort.Name = registeredName;

                try
                {
                    firewallOpenPorts.Add(firewallOpenPort);
                    result = true;
                }
                catch (Exception ex)
                {
                    throw new FirewallException("Failed to add port.", ex);
                }
            }

            return(result);
        }
Пример #22
0
        public static void AddPortExceptionToSP2Firewall(string name, int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            // Instantiating the HNetCfg.NetFwMgr object to get "LocalPolicy" and then "CurrentProfile"
            INetFwMgr     fwMgr     = (INetFwMgr)Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(INetFwMgrGuid)), true);
            INetFwPolicy  fwPolicy  = fwMgr.LocalPolicy;
            INetFwProfile fwProfile = fwPolicy.CurrentProfile;

            INetFwOpenPort fwOpenPort = (INetFwOpenPort)Activator.CreateInstance(
                Type.GetTypeFromCLSID(new Guid(INetFwOpenPortGuid)), true);

            fwOpenPort.Name     = name;
            fwOpenPort.Port     = port;
            fwOpenPort.Protocol = protocol;
            fwOpenPort.Enabled  = true;
            fwProfile.GloballyOpenPorts.Add(fwOpenPort);
        }
Пример #23
0
        private void CreateRuleOut(String RuleName, String Desc, NET_FW_IP_PROTOCOL_ Protocol, String RemotePorts, NET_FW_RULE_DIRECTION_ Direction, INetFwPolicy2 fwPolicy2)
        {
            Type       typeFWRule = Type.GetTypeFromProgID("HNetCfg.FwRule", false);
            INetFwRule newRule    = (INetFwRule)Activator.CreateInstance(typeFWRule);

            newRule.Name            = RuleName;
            newRule.Description     = Desc;
            newRule.Protocol        = (int)Protocol;
            newRule.RemotePorts     = RemotePorts;
            newRule.RemoteAddresses = txtRemoteAddress.Text.Replace(" ", "").Replace("\r\n", ",");
            newRule.Direction       = Direction;
            newRule.Enabled         = true;
            newRule.Grouping        = "Elasticsearch";
            //newRule.Profiles = fwPolicy2.CurrentProfileTypes;
            newRule.Action = NET_FW_ACTION_.NET_FW_ACTION_ALLOW;
            fwPolicy2.Rules.Add(newRule);
        }
        /// <summary>
        /// Authorizes a program to receive incoming communications through Windows Firewall. If this fails (typically due to insufficient permission), the exception is returned.
        /// </summary>
        /// <param name="title">The title of the firewall rule/program.</param>
        /// <param name="path">Path to the executable that should be authorized.</param>
        /// <param name="remoteAddresses">Comma separated list of remote addresses to authorize, or "*" for all.</param>
        /// <param name="protocol">Internet protocol version.</param>
        /// <param name="networkProfiles">Internet protocol version.</param>
        /// <returns></returns>
        public static Exception AuthorizeProgram(string title
                                                 , string path
                                                 , string remoteAddresses                = "*"
                                                 , NET_FW_IP_PROTOCOL_ protocol          = NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_ANY
                                                 , NET_FW_PROFILE_TYPE2_ networkProfiles = NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_DOMAIN | NET_FW_PROFILE_TYPE2_.NET_FW_PROFILE2_PRIVATE)
        {
            try
            {
                INetFwPolicy2 fwPolicy2 = Create <INetFwPolicy2>("HNetCfg.FwPolicy2");

                foreach (INetFwRule existingRule in fwPolicy2.Rules)
                {
                    if (path.Equals(existingRule.ApplicationName, StringComparison.OrdinalIgnoreCase))
                    {
                        if (existingRule.Protocol == (int)protocol &&
                            existingRule.Profiles == (int)networkProfiles &&
                            existingRule.Action == NET_FW_ACTION_.NET_FW_ACTION_ALLOW &&
                            existingRule.Enabled)
                        {
                            if (existingRule.RemoteAddresses != remoteAddresses)
                            {
                                existingRule.RemoteAddresses = remoteAddresses;
                            }
                            return(null);
                        }
                    }
                }

                INetFwRule rule = Create <INetFwRule>("HNetCfg.FwRule");
                rule.Name            = title;
                rule.Description     = "Allow incoming traffic to " + title;
                rule.ApplicationName = path;
                rule.Protocol        = (int)protocol;
                rule.Enabled         = true;
                rule.Grouping        = title;
                rule.RemoteAddresses = remoteAddresses;
                rule.Profiles        = (int)networkProfiles;
                rule.Action          = NET_FW_ACTION_.NET_FW_ACTION_ALLOW;
                fwPolicy2.Rules.Add(rule);
            }
            catch (Exception ex)
            {
                return(ex);
            }
            return(null);
        }
        public bool RemovePort(int portNo, bool isUDP)
        {
            bool                result   = false;
            INetFwMgr           manager  = _GetFirewallManager();
            NET_FW_IP_PROTOCOL_ protocol = isUDP ? NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_UDP : NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP;

            try
            {
                manager.LocalPolicy.CurrentProfile.GloballyOpenPorts.Remove(portNo, protocol);
                result = true;
            }
            catch (Exception ex)
            {
                Logger.error(ex.ToString());
            }
            return(result);
        }
Пример #26
0
        private FirewallRule GetDynamicPortRangeExceptionRule(string direction, string protocol, NET_FW_PROFILE_TYPE2_ fwProfile)
        {
            string ruleName = string.Format(
                CultureInfo.InvariantCulture,
                FabricNodeFirewallRules.DynamicPortRangeExceptionTemplate,
                this.NodeName,
                protocol,
                GetProfileFriendlyName(fwProfile),
                direction);
            NET_FW_IP_PROTOCOL_ fwProtocol = protocol == FabricNodeFirewallRules.ProtocolTcp ?
                                             NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP :
                                             NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_UDP;
            NET_FW_RULE_DIRECTION_ fwDirection = direction == FabricNodeFirewallRules.inDirection ?
                                                 NET_FW_RULE_DIRECTION_.NET_FW_RULE_DIR_IN :
                                                 NET_FW_RULE_DIRECTION_.NET_FW_RULE_DIR_OUT;

            return(GetRule(ruleName, null, this.DynamicPorts, fwProtocol, fwDirection, fwProfile));
        }
Пример #27
0
 public static void EnableInboundPort(NET_FW_IP_PROTOCOL_ protocol, int port, string description)
 {
     try
     {
         INetFwRule firewallRule = (INetFwRule)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FWRule"));
         firewallRule.Action         = NET_FW_ACTION_.NET_FW_ACTION_ALLOW;
         firewallRule.Name           = description;
         firewallRule.Direction      = NET_FW_RULE_DIRECTION_.NET_FW_RULE_DIR_IN;
         firewallRule.Protocol       = (int)protocol;
         firewallRule.LocalPorts     = port.ToString();
         firewallRule.Enabled        = true;
         firewallRule.InterfaceTypes = "All";
         INetFwPolicy2 firewallPolicy = (INetFwPolicy2)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwPolicy2"));
         firewallPolicy.Rules.Add(firewallRule);
     }
     catch (Exception)
     {
     }
 }
Пример #28
0
    /// <summary>
    /// Open port in network windows firewall
    /// </summary>
    /// <param name="name"></param>
    /// <param name="portNo"></param>
    /// <param name="scope"></param>
    /// <param name="protocol"></param>
    /// <param name="ipVersion"></param>
    /// <returns></returns>
    public static bool GloballyOpenPort(string name, int portNo,
                                        NET_FW_SCOPE_ scope, NET_FW_IP_PROTOCOL_ protocol, NET_FW_IP_VERSION_ ipVersion)
    {
        INetFwMgr manager = GetFirewallManager();

        try
        {
            // Check if port does not exists.
            bool exists = false;
            foreach (INetFwOpenPort openPort in manager.LocalPolicy.CurrentProfile.GloballyOpenPorts)
            {
                if (openPort.Name == name && openPort.Port == portNo)
                {
                    exists = true;
                    break;
                }
            }

            if (!exists)
            {
                // Create the type from prog id
                Type type = Type.GetTypeFromProgID(PROGID_OPEN_PORT);
                // Create instance that provides access to the properties of a port that has been opened in the firewall.
                INetFwOpenPort port = Activator.CreateInstance(type) as INetFwOpenPort;

                // Set properties for port
                port.Name      = name;
                port.Port      = portNo;
                port.Scope     = scope;
                port.Protocol  = protocol;
                port.IpVersion = ipVersion;

                // Add open port to windows firewall
                manager.LocalPolicy.CurrentProfile.GloballyOpenPorts.Add(port);
            }
        }
        catch (Exception ex)
        {
            return(false);
        }
        return(true);
    }
Пример #29
0
 // WINDOWS防火墙添加例外端口,name端口名,portNum端口号,type端口类型
 public static bool addFirewallPort(string name, int portNum, NET_FW_IP_PROTOCOL_ type)
 {
     try
     {
         // 创建端口接口实例
         INetFwOpenPort port = createInstance <INetFwOpenPort>(Type.GetTypeFromProgID("HNetCfg.FwOpenPort"));
         port.Name     = name;                   //端口名
         port.Port     = portNum;                //端口号
         port.Protocol = type;                   //协议类型
         port.Enabled  = true;                   //启用
         // 创建firewall管理接口的实例
         INetFwMgr netFwMgr = createInstance <INetFwMgr>(Type.GetTypeFromProgID("HNetCfg.FwMgr"));
         netFwMgr.LocalPolicy.CurrentProfile.GloballyOpenPorts.Add(port);
         return(true);
     }
     catch
     {
         return(false);
     }
 }
Пример #30
0
        // example: AddPort(true, "TCP Port", Int32.Parse(port.Text), NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP);
        public static bool AddPort(bool enabled, string name, int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            // Add the port to the ICF Permissions List
            INetFwMgr mgr = null;

            try
            {
                mgr = (NetFwTypeLib.INetFwMgr)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwMgr"));
            }
            catch
            {
                // XPSP2 not installed
                return(false);
            }

            try
            {
                INetFwProfile  profile;
                INetFwOpenPort portClass = (NetFwTypeLib.INetFwOpenPort)Activator.CreateInstance(
                    Type.GetTypeFromProgID("HNetCfg.FWOpenPort"));

                // Get the current profile
                profile = mgr.LocalPolicy.CurrentProfile;

                // Set the port properties
                portClass.Enabled  = enabled;
                portClass.Name     = name;
                portClass.Port     = port;
                portClass.Protocol = protocol;

                // Add the port to the ICF Permissions List
                profile.GloballyOpenPorts.Add(portClass);
                return(true);
            }
            catch
            {
                // Log the error or prompt the user
                return(false);
            }
        }
Пример #31
0
        private static bool GloballyOpenPort(string title, int portNo,
            NET_FW_SCOPE_ scope, NET_FW_IP_PROTOCOL_ protocol/*,
            NET_FW_IP_VERSION_ ipVersion*/, INetFwMgr manager)
        {
            Type type = Type.GetTypeFromProgID(PROGID_OPEN_PORT);
            INetFwOpenPort port = Activator.CreateInstance(type)
                as INetFwOpenPort;
            port.Name = title;
            port.Port = portNo;
            port.Scope = scope;
            port.Protocol = protocol;
            //port.IpVersion = ipVersion;

            try
            {
                manager.LocalPolicy.CurrentProfile.GloballyOpenPorts.Add(port);
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }
 private static void GloballyOpenPort(string title, int portNo, NET_FW_SCOPE_ scope, NET_FW_IP_PROTOCOL_ protocol,
                                      NET_FW_IP_VERSION_ ipVersion)
 {
   Type type = Type.GetTypeFromProgID(PROGID_OPEN_PORT);
   INetFwOpenPort port = Activator.CreateInstance(type) as INetFwOpenPort;
   if (port != null)
   {
     port.Name = title;
     port.Port = portNo;
     port.Scope = scope;
     port.Protocol = protocol;
     port.IpVersion = ipVersion;
   }
   INetFwMgr manager = GetFirewallManager();
   try
   {
     manager.LocalPolicy.CurrentProfile.GloballyOpenPorts.Add(port);
   }
   catch
   {
     return;
   }
 }
Пример #33
0
        public FW_ERROR_CODE RemovePort(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol)
        {
            if (m_FirewallProfile == null)
            {
                return(FW_ERROR_CODE.FW_ERR_INITIALIZED);
            }

            bool          bEnablePort = false;
            FW_ERROR_CODE nError      = IsPortEnabled(nPortNumber, ipProtocol, ref bEnablePort);

            if (nError != FW_ERROR_CODE.FW_NOERROR)
            {
                return(nError);
            }

            // Only remove the port, if it is on the collection
            if (bEnablePort)
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts FWOpenPorts = m_FirewallProfile.GloballyOpenPorts;
                if (FWOpenPorts == null)
                {
                    return(FW_ERROR_CODE.FW_ERR_GLOBAL_OPEN_PORTS);
                }

                try
                {
                    FWOpenPorts.Remove(nPortNumber, ipProtocol);
                }
                catch
                {
                    return(FW_ERROR_CODE.FW_ERR_REMOVE_FROM_COLLECTION);
                }
            }

            return(FW_ERROR_CODE.FW_NOERROR);
        }
Пример #34
0
        internal static bool AuthorizeApplication(string title, string applicationPath,
            NET_FW_SCOPE_ scope/*, NET_FW_IP_VERSION_ ipVersion*/, int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            // Create the type from prog id
            Type type = Type.GetTypeFromProgID(PROGID_AUTHORIZED_APPLICATION);
            INetFwAuthorizedApplication auth = Activator.CreateInstance(type)
                as INetFwAuthorizedApplication;
            auth.Name = title;
            auth.ProcessImageFileName = applicationPath;
            auth.Scope = scope;
            //auth.IpVersion = ipVersion; // Not implemented
            auth.Enabled = true;

            INetFwMgr manager = GetFirewallManager();
            try
            {
                manager.LocalPolicy.CurrentProfile.AuthorizedApplications.Add(auth);
            }
            catch (Exception)
            {
                return false;
            }
            return GloballyOpenPort(title, port, scope, protocol, manager);
        }
Пример #35
0
        public static void AddPortExceptionToSP2Firewall(string name, int port, NET_FW_IP_PROTOCOL_ protocol) {
            // Instantiating the HNetCfg.NetFwMgr object to get "LocalPolicy" and then "CurrentProfile"
            INetFwMgr fwMgr = (INetFwMgr)Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(INetFwMgrGuid)), true);
            INetFwPolicy fwPolicy = fwMgr.LocalPolicy;
            INetFwProfile fwProfile = fwPolicy.CurrentProfile;

            INetFwOpenPort fwOpenPort = (INetFwOpenPort)Activator.CreateInstance(
                Type.GetTypeFromCLSID(new Guid(INetFwOpenPortGuid)), true);

            fwOpenPort.Name = name;
            fwOpenPort.Port = port;
            fwOpenPort.Protocol = protocol;
            fwOpenPort.Enabled = true;
            fwProfile.GloballyOpenPorts.Add(fwOpenPort);
        }
Пример #36
0
        /// <summary>
        /// Add a ports/protocol exception rule for all profiles for Vista or later firewall
        /// </summary>
        /// <param name="ruleName"></param>
        /// <param name="appPath"></param>
        /// <returns>false if the firewall type isn't available, true for successful completion.</returns>
        public static bool AddPortExceptionToVistaFirewall(string ruleName, string ports, NET_FW_IP_PROTOCOL_ protocol) {
            Type fwPolicy2Type = Type.GetTypeFromProgID("HNetCfg.FwPolicy2");
            if (fwPolicy2Type == null) {
                return false;
            }

            INetFwPolicy2 fwPolicy2 = (INetFwPolicy2)System.Activator.CreateInstance(fwPolicy2Type);
            INetFwRule fwRule = (INetFwRule)System.Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwRule"));
            fwRule.Name = ruleName;
            fwRule.Protocol = (int)protocol;
            fwRule.LocalPorts = ports;
            fwRule.Enabled = true;
            fwPolicy2.Rules.Add(fwRule);
            return true;
        }
        public FW_ERROR_CODE AddPort(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, string strRegisterName)
        {
            if (m_FirewallProfile == null)
                return FW_ERROR_CODE.FW_ERR_INITIALIZED;

            bool bEnablePort = true;
            FW_ERROR_CODE nError = IsPortEnabled(nPortNumber, ipProtocol, ref bEnablePort);
            if (nError != FW_ERROR_CODE.FW_NOERROR)
                return nError;

            // Only add the port, if it isn't added to the collection
            if (bEnablePort == false)
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts FWOpenPorts = m_FirewallProfile.GloballyOpenPorts;
                if (FWOpenPorts == null)
                    return FW_ERROR_CODE.FW_ERR_GLOBAL_OPEN_PORTS;

                // Create an instance of an open port
                Type typeFwPort = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
                var FWOpenPort = (INetFwOpenPort) Activator.CreateInstance(typeFwPort);
                if (FWOpenPort == null)
                    return FW_ERROR_CODE.FW_ERR_CREATE_PORT_INSTANCE;

                // Set the port number
                FWOpenPort.Port = nPortNumber;

                // Set the IP Protocol
                FWOpenPort.Protocol = ipProtocol;

                // Set the registered name
                FWOpenPort.Name = strRegisterName;

                try
                {
                    FWOpenPorts.Add(FWOpenPort);
                }
                catch
                {
                    return FW_ERROR_CODE.FW_ERR_ADD_TO_COLLECTION;
                }
            }
            else
                return FW_ERROR_CODE.FW_ERR_SAME_PORT_EXIST;

            return FW_ERROR_CODE.FW_NOERROR;
        }
Пример #38
0
        public static void RemovePortExceptionFromSP2Firewall(int port, NET_FW_IP_PROTOCOL_ protocol) { 
            // Instantiating the HNetCfg.NetFwMgr object to get "LocalPolicy" and then "CurrentProfile"
            INetFwMgr fwMgr = (INetFwMgr) Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(INetFwMgrGuid)), true);                
            INetFwPolicy fwPolicy = fwMgr.LocalPolicy;
            INetFwProfile fwProfile = fwPolicy.CurrentProfile;

            // Remove application from exception rule list
            fwProfile.GloballyOpenPorts.Remove(port, protocol);
        }
        public FW_ERROR_CODE IsPortEnabled(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, ref bool bEnable)
        {
            if (m_FirewallProfile == null)
                return FW_ERROR_CODE.FW_ERR_INITIALIZED;

            // Retrieve the open ports collection
            INetFwOpenPorts FWOpenPorts = m_FirewallProfile.GloballyOpenPorts;
            if (FWOpenPorts == null)
                return FW_ERROR_CODE.FW_ERR_GLOBAL_OPEN_PORTS;

            // Get the open port
            try
            {
                INetFwOpenPort FWOpenPort = FWOpenPorts.Item(nPortNumber, ipProtocol);
                if (FWOpenPort != null)
                    bEnable = FWOpenPort.Enabled;
                else
                    bEnable = false;
            }
            catch (FileNotFoundException)
            {
                bEnable = false;
            }

            return FW_ERROR_CODE.FW_NOERROR;
        }
        public FW_ERROR_CODE RemovePort(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol)
        {
            if (m_FirewallProfile == null)
                return FW_ERROR_CODE.FW_ERR_INITIALIZED;

            bool bEnablePort = false;
            FW_ERROR_CODE nError = IsPortEnabled(nPortNumber, ipProtocol, ref bEnablePort);
            if (nError != FW_ERROR_CODE.FW_NOERROR)
                return nError;

            // Only remove the port, if it is on the collection
            if (bEnablePort)
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts FWOpenPorts = m_FirewallProfile.GloballyOpenPorts;
                if (FWOpenPorts == null)
                    return FW_ERROR_CODE.FW_ERR_GLOBAL_OPEN_PORTS;

                try
                {
                    FWOpenPorts.Remove(nPortNumber, ipProtocol);
                }
                catch
                {
                    return FW_ERROR_CODE.FW_ERR_REMOVE_FROM_COLLECTION;
                }
            }

            return FW_ERROR_CODE.FW_NOERROR;
        }
Пример #41
0
 private INetFwOpenPort GetPortObj(string portNumber, NET_FW_IP_PROTOCOL_ ipProtocol)
 {
     Type tpResult = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
     INetFwOpenPort port = (INetFwOpenPort)Activator.CreateInstance(tpResult);
     port.Port = Int32.Parse(portNumber); // port number
     port.Name = appName; // name of the application using the port
     port.Enabled = true; // enable the port
     port.Protocol = ipProtocol;
     return port;
 }
Пример #42
0
        public bool GloballyOpenPort(string title, int portNo,
            NET_FW_SCOPE_ scope, NET_FW_IP_PROTOCOL_ protocol,
            NET_FW_IP_VERSION_ ipVersion)
        {
            Type type = Type.GetTypeFromProgID(PROGID_OPEN_PORT);
            INetFwOpenPort port = Activator.CreateInstance(type)
                as INetFwOpenPort;
            port.Name = title;
            port.Port = portNo;
            port.Scope = scope;
            port.Protocol = protocol;
            port.IpVersion = ipVersion;

            //INetFwMgr manager = GetFirewallManagerCached();
            try
            {
                m_NetFwMgr.LocalPolicy.CurrentProfile.GloballyOpenPorts.Add(port);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return true;
        }
Пример #43
0
        // example: RemovePort(Int32.Parse(port.Text), NET_FW_IP_PROTOCOL_.NET_FW_IP_PROTOCOL_TCP);
        public static bool RemovePort(int port, NET_FW_IP_PROTOCOL_ protocol)
        {
            // Remove the port to the ICF Permissions List
            INetFwMgr mgr = null;

            try
            {
                mgr = (NetFwTypeLib.INetFwMgr)Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwMgr"));
            }
            catch
            {
                // XPSP2 not installed
                return false;
            }

            try
            {
                INetFwProfile profile;

                // Get the current profile
                profile = mgr.LocalPolicy.CurrentProfile;

                // Remove the port to the ICF Permissions List
                profile.GloballyOpenPorts.Remove(port, protocol);
                return true;
            }
            catch
            {
                // Log the error or prompt the user
                return false;
            }
        }
Пример #44
0
        /// 
        /// Create authorization rule for a specific  port 
        /// 
        /// To view app permissions from command line use:
        /// "netsh advfirewall firewall show rule name=udptool.vshost.exe"
        /// 
        public void GrantPortAuthorization(string applicationFullPath, string usedPort, NET_FW_IP_PROTOCOL_ protocol)
        {
            ValidateFields(applicationFullPath);

            if (usedPort == null)
                throw new ArgumentNullException("usedPort");
            if (!IsFirewallInstalled)
                throw new FirewallHelperException("Cannot grant authorization, firewall is not enabled.");
            if (!AppAuthorizationsAllowed)
                throw new FirewallHelperException("Application exceptions are not allowed.");
            // Other properties like Protocol, IP Version can also be set accordingly
            // Now add this to the GloballyOpenPorts collection
            INetFwProfile profile = mgr.LocalPolicy.GetProfileByType(NET_FW_PROFILE_TYPE_.NET_FW_PROFILE_CURRENT);

            profile.GloballyOpenPorts.Add(GetPortObj(usedPort, protocol));
            profile = mgr.LocalPolicy.GetProfileByType(NET_FW_PROFILE_TYPE_.NET_FW_PROFILE_STANDARD);
            profile.GloballyOpenPorts.Add(GetPortObj(usedPort, protocol));
            profile = mgr.LocalPolicy.GetProfileByType(NET_FW_PROFILE_TYPE_.NET_FW_PROFILE_DOMAIN);
            profile.GloballyOpenPorts.Add(GetPortObj(usedPort, protocol));
        }
Пример #45
0
        public FwErrorCode AddPort(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, string strRegisterName)
        {
            if (_mFirewallProfile == null)
                return FwErrorCode.FwErrInitialized;

            bool bEnablePort = true;
            FwErrorCode nError = IsPortEnabled(nPortNumber, ipProtocol, ref bEnablePort);
            if (nError != FwErrorCode.FwNoerror)
                return nError;

            // Only add the port, if it isn't added to the collection
            if (bEnablePort == false)
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts fwOpenPorts = _mFirewallProfile.GloballyOpenPorts;
                if (fwOpenPorts == null)
                    return FwErrorCode.FwErrGlobalOpenPorts;

                // Create an instance of an open port
                Type typeFwPort = Type.GetTypeFromCLSID(new Guid("{0CA545C6-37AD-4A6C-BF92-9F7610067EF5}"));
                var fwOpenPort = (INetFwOpenPort)Activator.CreateInstance(typeFwPort);

                // Set the port number
                fwOpenPort.Port = nPortNumber;

                // Set the IP Protocol
                fwOpenPort.Protocol = ipProtocol;

                // Set the registered name
                fwOpenPort.Name = strRegisterName;

                try
                {
                    fwOpenPorts.Add(fwOpenPort);
                }
                catch
                {
                    return FwErrorCode.FwErrAddToCollection;
                }
            }
            else
                return FwErrorCode.FwErrSamePortExist;

            return FwErrorCode.FwNoerror;
        }
Пример #46
0
        public FwErrorCode IsPortEnabled(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol, ref bool bEnable)
        {
            if (_mFirewallProfile == null)
                return FwErrorCode.FwErrInitialized;

            // Retrieve the open ports collection
            INetFwOpenPorts fwOpenPorts = _mFirewallProfile.GloballyOpenPorts;
            if (fwOpenPorts == null)
                return FwErrorCode.FwErrGlobalOpenPorts;

            // Get the open port
            try
            {
                INetFwOpenPort fwOpenPort = fwOpenPorts.Item(nPortNumber, ipProtocol);
                bEnable = fwOpenPort != null && fwOpenPort.Enabled;
            }
            catch (System.IO.FileNotFoundException)
            {
                bEnable = false;
            }

            return FwErrorCode.FwNoerror;
        }
Пример #47
0
        /// 
        /// Remove port authorization rules.
        /// 
        public void RemovePortAuthorization(string applicationFullPath, string usedPort, NET_FW_IP_PROTOCOL_ protocol)
        {
            ValidateFields(applicationFullPath);

            if (usedPort == null)
                throw new ArgumentNullException("usedPort");

            int port = Int32.Parse(usedPort);

            INetFwProfile profile = mgr.LocalPolicy.GetProfileByType(NET_FW_PROFILE_TYPE_.NET_FW_PROFILE_CURRENT);
            profile.GloballyOpenPorts.Remove(port, protocol);
            profile = mgr.LocalPolicy.GetProfileByType(NET_FW_PROFILE_TYPE_.NET_FW_PROFILE_STANDARD);
            profile.GloballyOpenPorts.Remove(port, protocol);
            profile = mgr.LocalPolicy.GetProfileByType(NET_FW_PROFILE_TYPE_.NET_FW_PROFILE_DOMAIN);
            profile.GloballyOpenPorts.Remove(port, protocol);
        }
Пример #48
0
        public FwErrorCode RemovePort(int nPortNumber, NET_FW_IP_PROTOCOL_ ipProtocol)
        {
            if (_mFirewallProfile == null)
                return FwErrorCode.FwErrInitialized;

            bool bEnablePort = false;
            FwErrorCode nError = IsPortEnabled(nPortNumber, ipProtocol, ref bEnablePort);
            if (nError != FwErrorCode.FwNoerror)
                return nError;

            // Only remove the port, if it is on the collection
            if (bEnablePort)
            {
                // Retrieve the collection of globally open ports
                INetFwOpenPorts fwOpenPorts = _mFirewallProfile.GloballyOpenPorts;
                if (fwOpenPorts == null)
                    return FwErrorCode.FwErrGlobalOpenPorts;

                try
                {
                    fwOpenPorts.Remove(nPortNumber, ipProtocol);
                }
                catch
                {
                    return FwErrorCode.FwErrRemoveFromCollection;
                }
            }

            return FwErrorCode.FwNoerror;
        }
 private void CreateRuleOut(String RuleName, String Desc, NET_FW_IP_PROTOCOL_ Protocol, String RemotePorts, NET_FW_RULE_DIRECTION_ Direction, INetFwPolicy2 fwPolicy2)
 {
     Type typeFWRule = Type.GetTypeFromProgID("HNetCfg.FwRule", false);
          INetFwRule newRule = (INetFwRule)Activator.CreateInstance(typeFWRule);
          newRule.Name = RuleName;
          newRule.Description = Desc;
          newRule.Protocol = (int)Protocol;
          newRule.RemotePorts = RemotePorts;
          newRule.RemoteAddresses = txtRemoteAddress.Text.Replace(" ", "").Replace("\r\n", ",");
          newRule.Direction = Direction;
          newRule.Enabled = true;
          newRule.Grouping = "Elasticsearch";
          //newRule.Profiles = fwPolicy2.CurrentProfileTypes;
          newRule.Action = NET_FW_ACTION_.NET_FW_ACTION_ALLOW;
          fwPolicy2.Rules.Add(newRule);
 }