Simple stateful firewall
This page explains how to set up a stateful firewall using iptables. It also explains what the rules mean and why they are needed. For simplicity, it is split into two major sections. The first section deals with a firewall for a single machine, the second sets up a NAT gateway in addition to the firewall from the first section.
- 1 Prerequisites
- 2 Firewall for a single machine
- 2.1 Creating necessary chains
- 2.2 The FORWARD chain
- 2.3 The OUTPUT chain
- 2.4 The INPUT chain
- 2.5 Example iptables.rules file
- 2.6 The OPEN chains
- 2.7 Protection against spoofing attacks
- 2.8 "Hide" your computer
- 2.9 Protection against other attacks
- 2.10 Saving the rules
- 2.11 IPv6
- 3 Setting up a NAT gateway
- 4 See Also
First, install the userland utilities:
# pacman -S iptables
This HOWTO assumes that there are currently no iptables rules set. To check this, try the command
If not, you can reset the rules by loading a default rule set:
# iptables-restore < /etc/iptables/empty.rules
Firewall for a single machine
Creating necessary chains
For this basic setup, we will create two user-defined chains that we will use to open up ports in the firewall.
# iptables -N TCP # iptables -N UDP
The FORWARD chain
If you want to set up your machine as a NAT gateway, please look at the second section of this HOWTO. For a single machine, however, we simply set the policy of the FORWARD chain to DROP and move on:
# iptables -P FORWARD DROP
The OUTPUT chain
We have no intention of filtering any outgoing traffic, as this would make the setup much more complicated and would require some extra thought. In this simple case, we set the OUTPUT policy to ACCEPT.
# iptables -P OUTPUT ACCEPT
The INPUT chain
First, we set the default policy for the INPUT chain to DROP in case something somehow slips by our rules. Dropping all traffic and specifying what is allowed is the best way to make a secure firewall.
# iptables -P INPUT DROP
Every packet that is received by any network interface will pass the INPUT chain first, if it is destined for this machine. In this chain, we make sure that only the packets that we want are accepted.
The first rule will allow traffic that belongs to established connections, or new valid traffic that is related to these connections such as ICMP errors, or echo replies (the packets a host returns when pinged). ICMP stands for Internet Control Message Protocol. Some ICMP messages are very important and help to manage congestion and MTU, and are accepted by this rule.
# iptables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
The second rule will accept all traffic from the "loopback" (lo) interface, which is necessary for many applications and services.
# iptables -A INPUT -i lo -j ACCEPT
The third rule will drop all traffic with an "INVALID" state match. Traffic can fall into four "state" categories: NEW, ESTABLISHED, RELATED or INVALID and this is what makes this a "stateful" firewall rather than a less secure "stateless" one. States are tracked using the "nf_conntrack_*" kernel modules which are loaded automatically by the kernel as you add rules.
# iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
The next rule will accept all new incoming ICMP echo requests, also known as pings. Only the first packet will count as NEW, the rest will be handled by the RELATED,ESTABLISHED rule. Since the computer is not a router, no other ICMP traffic with state NEW should needs to be allowed.
# iptables -A INPUT -p icmp --icmp-type 8 -m conntrack --ctstate NEW -j ACCEPT
Now we append the OPEN chains to INPUT chain to handle all new incoming connections. Once a connection is accepted by the OPEN chains, it is handled by the RELATED/ESTABLISHED traffic rule. The OPEN chains will either accept new incoming connections, or politely reject them. New TCP connections must be started with SYN packets.
# iptables -A INPUT -p udp -m conntrack --ctstate NEW -j UDP # iptables -A INPUT -p tcp --syn -m conntrack --ctstate NEW -j TCP
We reject TCP connections with TCP RST packets and UDP streams with ICMP port unreachable messages if the ports are not opened. This imitates default Linux behavior (RFC compliant), and it allows the sender to quickly close the connection and clean up.
# iptables -A INPUT -p udp -j REJECT --reject-with icmp-port-unreachable # iptables -A INPUT -p tcp -j REJECT --reject-with tcp-rst
For other protocols, we add a final rule to the INPUT chain to reject all remaining incoming traffic with icmp protocol unreachable messages. This imitates Linux's default behavior.
# iptables -A INPUT -j REJECT --reject-with icmp-proto-unreachable
Example iptables.rules file
This file is generated with:
iptables-save > /etc/iptables/iptables.rules
and can be used to prevent blocking yourself out if you are setting up the firewall remotely, just remember to append:
-A TCP -p tcp -m tcp --dport 22 -j ACCEPT
which will allow ssh in. (Assuming ssh on port 22)
The OPEN chains
The OPEN chains contain rules for accepting new incoming TCP connections and UDP streams to specific ports.
Opening ports to incoming connections
To accept incoming TCP connections on port 80 for a web server:
# iptables -A TCP -p tcp --dport 80 -j ACCEPT
To accept incoming TCP connections on port 443 for a web server (HTTPS):
# iptables -A TCP -p tcp --dport 443 -j ACCEPT
To allow remote SSH connections (on port 22):
# iptables -A TCP -p tcp --dport 22 -j ACCEPT
To accept incoming UDP streams on port 53 for a DNS server:
# iptables -A UDP -p udp --dport 53 -j ACCEPT
man iptables` for more advanced rules, like matching multiple ports.
(xtables-addons ships with xt_pknock which does not require an extra daemon.)
knockd is a port knocking daemon that can provide an added layer of security to your network. The knockd wiki provides three example port knocking configurations. These configs can be easily altered to intergrate properly with firewall described here. You should simply substitue the
INPUT chain specification, with the custom
open chain used in the firewall.
[options] logfile = /var/log/knockd.log [opencloseSSH] sequence = 2222:udp,3333:tcp,4444:udp seq_timeout = 15 tcpflags = syn,ack start_command = /usr/sbin/iptables -A TCP -s %IP% -p tcp --dport 22 -j ACCEPT cmd_timeout = 10 stop_command = /usr/sbin/iptables -D TCP -s %IP% -p tcp --dport 22 -j ACCEPT
It is wise to randomly select the ports that you use for the knock sequence. random.org can help you generate a selection of ports between 1 and 65535. To check that you have not inadvertantly selected commonly used ports, use this port database, and/or your
Protection against spoofing attacks
Blocking reserved local addresses incoming from the internet or local network is normally done through setting the
rp_filter sysctl to 1. To do so, add the following line to your
/etc/sysctl.conf to enable source address verification which is built into Linux kernel itself. The verification by the kernel will handle spoofing better than individual iptables rules for each case.
Only when asynchronous routing and/or rp_filter=0 is used, need extra checks be used:
# iptables -I INPUT ! -i lo -s 127.0.0.0/8 -j DROP
"Hide" your computer
If you are running a desktop machine, it might be a good idea to block some incoming requests.
Block Ping Request
A 'Ping' request is an ICMP packet sent to the destination address to ensure connectivity between the devices. If your network works well, you can safely block all ping requests. It is important to note that this does not actually hide your computer — any packet sent to you is rejected, so you will still show up in a simple nmap "ping scan" of an IP range.
This is rudimentary "protection" and makes life difficult when debugging issues in the future. You should only do this for education purposes.
To block echo requests, add the following line to your
net.ipv4.icmp_echo_ignore_all = 1
Rate-limiting is a better way to control possible abuse. This first method implements a global limit (ie, only X packets per minute for all source addresses):
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 30/min --limit-burst 8 -j ACCEPT iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
Or using the 'recent' module, you can impose a limit per source address:
iptables -A INPUT -p icmp --icmp-type echo-request -m recent --name ping_limiter --set iptables -A INPUT -p icmp --icmp-type echo-request -m recent --name ping_limiter --update --hitcount 6 --seconds 4 -j DROP iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT
If you choose to use either the rate limiting or the source limiting rules the PING rule that already exists in the INPUT chain needs to be deleted. This can be done as shown below, or alternatively don't use it in the first place.
# iptables -D INPUT -p icmp --icmp-type 8 -m conntrack --ctstate NEW -j ACCEPT
Next you need to decide where you wish to place the rate limiting or source limiting rules. If you place the rules below the RELATED,ESTABLISHED rule then you will be counting and limiting new ping connections, not each ping sent to your machine. If you place them before the RELATED,ESTABLISHED rule then these rules will count and limit each ping sent to your machine, not each ping connection made.
More information is in the iptables man page, or reading the docs and examples on the webpage http://snowman.net/projects/ipt_recent/
Tricking port scanners
Port scans are used by attackers to identify open ports on your computer. This allows them to identify and fingerprint your running services and possibly launch exploits against them.
The INVALID state rule will take care of every type of port scan except UDP, ACK and SYN scans (-sU, -sA and -sS in nmap respectively).
ACK scans are not used to identify open ports, but to identify ports filtered by a firewall. Due to the SYN check for all TCP connections with the state NEW, every single packet sent by an ACK scan will be correctly rejected by a TCP RST packet. Some firewalls drop these packets instead, and this allows an attacker to map out the firewall rules.
The recent module can be used to trick the remaining two types of port scans. The recent module is used to add hosts to a "recent" list which can be used to fingerprint and stop certain types of attacks. Current recent lists can be viewed in
In a SYN scan, the port scanner sends SYN packet to every port. Closed ports return a TCP RST packet, or get dropped by a strict firewall. Open ports return a SYN ACK packet regardless of the presence of a firewall.
The recent module can be used to keep track of hosts with rejected connection attempts and return a TCP RST for any SYN packet they send to open ports as if the port was closed. If an open port is the first to be scanned, a SYN ACK will still be returned, so running applications such as ssh on non-standard ports is required for this to work consistently.
First, insert a rule at the top of the TCP chain. This rule responds with a TCP RST to any host that got onto the TCP-PORTSCAN list in the past sixty seconds. The
--update switch causes the recent list to be updated, meaning the 60 second counter is reset.
# iptables -I TCP -p tcp -m recent --update --seconds 60 --name TCP-PORTSCAN -j REJECT --reject-with tcp-rst
Next, the rule for rejecting TCP packets need to be modified to add hosts with rejected packets to the TCP-PORTSCAN list.
# iptables -D INPUT -p tcp -j REJECT --reject-with tcp-rst # iptables -A INPUT -p tcp -m recent --set --name TCP-PORTSCAN -j REJECT --reject-with tcp-rst
UDP port scans are similar to TCP SYN scans except that UDP is a "connectionless" protocol. There are no handshakes or acknowledgements. Instead, the scanner sends UDP packets to each UDP port. Closed ports should return ICMP port unreachable messages, and open ports do not return a response. Since UDP is not a "reliable" protocol, the scanner has no way of knowing if packets were lost, and has to do multiple checks for each port that does not return a response.
The Linux kernel sends out ICMP port unreachable messages very slowly, so a full UDP scan against a Linux machine would take over 10 hours. However, common ports could still be identified, so applying the same countermeasures against UDP scans as SYN scans is a good idea.
First, add a rule to reject packets from hosts on the UDP-PORTSCAN list to the top of the OPEN-UDP chain.
# iptables -I UDP -p udp -m recent --update --seconds 60 --name UDP-PORTSCAN -j REJECT --reject-with port-unreach
Next, modify the reject packets rule for UDP:
# iptables -D INPUT -p udp -j REJECT --reject-with icmp-port-unreach # iptables -A INPUT -p udp -m recent --set --name UDP-PORTSCAN -j REJECT --reject-with icmp-port-unreach
Restore the Final Rule
If either or both of the portscanning tricks above were used the final default rule is no longer the last rule in the INPUT chain. It needs to be the last rule otherwise it will intercept the trick port scanner rules you just added and they will never be used. Simply delete the rule (-D), then add it once again using append (-A) which will place it at the end of the chain.
# iptables -D INPUT -j REJECT --reject-with icmp-proto-unreachable # iptables -A INPUT -j REJECT --reject-with icmp-proto-unreachable
Protection against other attacks
See the TCP/IP stack hardening guide for relevant kernel parameters.
SSH bruteforce attacks
Here are some rules which help to mitigate ssh brute force attacks using iptables:
# iptables -N IN_SSH # iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -j IN_SSH # iptables -A IN_SSH -m recent --name sshbf --rttl --rcheck --hitcounts 3 --seconds 10 -j DROP # iptables -A IN_SSH -m recent --name sshbf --rttl --rcheck --hitcounts 4 --seconds 1800 -j DROP # iptables -A IN_SSH -m recent --name sshbf --set -j ACCEPT
# iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -j IN_SSH
is in an appropriate position in the iptables.rules file.
This arrangement works for the IN_SSH rule if you followed this entire wiki so far:
* -A INPUT -p icmp -m icmp --icmp-type 8 -m conntrack --ctstate NEW -j ACCEPT -A INPUT -p tcp -m tcp --dport 22 -m conntrack --ctstate NEW -j IN_SSH -A INPUT -p udp -m conntrack --ctstate NEW -j UDP *
Saving the rules
The ruleset is now finished and should be saved to your hard drive so that it can be loaded on every boot.
The systemd unit file points to the location where the rule configuration will be saved:
Save the rules with this command:
# iptables-save > /etc/iptables/iptables.rules
and make sure your rules are loaded on boot:
# systemctl enable iptables.service
Check that the rules load correctly using:
# systemctl start iptables.service && systemctl status iptables.service
If you do not use IPv6 (most ISPs do not support it), you should disable it.
Otherwise, you should enable the firewall rules for IPv6. Just copy /etc/iptables/iptables.rules to /etc/iptables/ip6tables.rules and change IPs from v4 format to v6 format and change reject messages from
Please be aware that --reject-with icmp6-proto-unreachable does not exist for ICMPv6, so you may reject without any message. (Does anyone know what message would be correct? communication-prohibited? port-unreachable?).
Now you need to enable the ip6tables service using systemd:
# systemctl enable ip6tables.service
Setting up a NAT gateway
This section of the HOWTO deals with NAT gateways. It is assumed that you already read the first part of the HOWTO and set up the INPUT, OUTPUT, OPEN and interfaces chains like described above. All rules so far have been created in the filter table. In this section, we will also have to use the nat table.
Setting up the filter table
Creating necessary chains
In our setup, we will use another two chains in the filter table, the fw-interfaces and fw-open chains. Create them with the commands
# iptables -N fw-interfaces # iptables -N fw-open
Setting up the FORWARD chain
Setting up the FORWARD chain is similar to the INPUT chain in the first section.
Now we set up a rule with the conntrack match, identical to the one in the INPUT chain:
# iptables -A FORWARD -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
The next step is to enable forwarding for trusted interfaces and to make all packets pass the fw-open chain.
# iptables -A FORWARD -j fw-interfaces # iptables -A FORWARD -j fw-open
The remaining packets are denied with an ICMP message:
# iptables -A FORWARD -j REJECT --reject-with icmp-host-unreach # iptables -P FORWARD DROP
Setting up the fw-interfaces and fw-open chains
The meaning of the fw-interfaces and fw-open chains is explained later, when we deal with the POSTROUTING and PREROUTING chains in the nat table, respectively.
Setting up the nat table
All over this section, we assume that the outgoing interface (the one with the public internet IP) is ppp0. Keep in mind that you have to change the name in all following rules if your outgoing interface has another name.
Setting up the POSTROUTING chain
Now, we have to define who is allowed to connect to the internet. Let's assume we have the subnet 192.168.0.0/24 (which means all addresses that are of the form 192.168.0.*) on eth0. We first need to accept the machines on this interface in the FORWARD table, that is why we created the fw-interfaces chain above:
# iptables -A fw-interfaces -i eth0 -j ACCEPT
Now, we have to alter all outgoing packets so that they have our public IP address as the source address, instead of the local LAN address. To do this, we use the MASQUERADE target:
# iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -o ppp0 -j MASQUERADE
Do not forget the -o ppp0 parameter above. If you omit it, your network will be screwed up.
Let's assume we have another subnet, 10.3.0.0/16 (which means all addresses 10.3.*.*), on the interface eth1. We add the same rules as above again:
# iptables -A fw-interfaces -i eth1 -j ACCEPT # iptables -t nat -A POSTROUTING -s 10.3.0.0/16 -o ppp0 -j MASQUERADE
The last step is to enable IP Forwarding (if it is not already enabled):
# echo 1 > /proc/sys/net/ipv4/ip_forward
Then edit the relevant line in /etc/sysctl.conf so it persists through reboot:
net.ipv4.ip_forward = 1
Machines from these subnets can now use your new NAT machine as their gateway. Note that you may want to set up a DNS and DHCP server like dnsmasq or a combination of bind and dhcpd to simplify network settings DNS resolution on the client machines. This is not the topic of this HOWTO.
Setting up the PREROUTING chain
Sometimes, we want to change the address of an incoming packet from the gateway to a LAN machine. To do this, we use the fw-open chain defined above, as well as the PREROUTING chain in the nat table
I will give two simple examples: First, we want to change all incoming SSH packets (port 22) to the ssh server in the machine 192.168.0.5:
# iptables -A fw-open -d 192.168.0.5 -p tcp --dport 22 -j ACCEPT # iptables -t nat -A PREROUTING -i ppp0 -p tcp --dport 22 -j DNAT --to 192.168.0.5
The second example will show you how to change packets to a different port than the incoming port. We want to change any incoming connection on port 8000 to our web server on 192.168.0.6, port 80:
# iptables -A fw-open -d 192.168.0.6 -p tcp --dport 80 -j ACCEPT # iptables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to 192.168.0.6:80
The same setup also works with udp packets.
Saving the rules
Save the rules
# iptables-save > /etc/iptables/iptables.rules
and make sure your rules are loaded when you boot
# systemctl enable iptables.service