FERM é uma ferramenta de manutenção para complexos firewalls, na qual retira o problema de precisar reescrever complexas

regras várias vezes. FERM permite que todo o conjunto de regras do firewall sejam armazenadas em arquivos separados, para
que no futuro possa ser carregado com um só comando.

Sendo assim, FERM é um aplicativo super útil e interessante sob GPL na qual a licença pode ser encontrada na página do "Free
Software Foundation".

Lição 1 - Introdução, Caracteres especiais]

Instalação

Para instalar o ferm basta digitar no terminal, logado como root, o seguinte:

apt-get install ferm

Introdução

O FERM é uma ferramenta que tem como função facilitar a tarefa de criação de regras de firewall. Ele suporta firewalls ipchains,
regras de ipfwadm e firewalls iptables. Esse curso foi baseado na página de manual do FERM.
Vamos começar com um exemplo simples:

chain INPUT {
proto tcp ACCEPT;
}

isto adicionará uma regra ao chain INPUT para que todos os pacotes tcp sejam aceitos. Vejamos o segundo exemplo:

chain (INPUT OUTPUT) {

proto (udp tcp) ACCEPT;
}

Esse exemplo é equivalente a quatro regras:

iptables -A INPUT -p tcp -j ACCEPT

iptables -A OUTPUT -p tcp -j ACCEPT
iptables -A INPUT -p udp -j ACCEPT
iptables -A OUTPUT -p udp -j ACCEPT

Pode-se perceber com esse exemplo que o FERM realmete simplifica bastante a criação de regras. O objetivo desse curso é
justamete aprender como criar essas regras
A estrutura de um arquivo de firewall deve ser semelhante a de um programa em C. Existem alguns caracteres especiais que
podem ser usados nos arquivos de configuração do FERM, além de utilizar também opções e parâmetros.
Com essas palavras você pode definir as características do seu firewall. Qualquer firewall é formado por duas funções
principais: a primeira delas é verificar se o tráfego satisfaz certas condições, a segunda delas é definir o que deve ser feito com
o tráfego.

Caracteres Especiais

Listarei a seguir alguns caracteres especiais:

 • ; é usado o final de regras. É possível escrever mais de uma, separadas por ponto e vírgula, em cada linha. Porém, isso
prejudica a legibilidade do programa.

• {} são usados para delimitar blocos de regras. Blocos são usados para facilitar a tarefa de escrever regras que têm os
primeiros parâmetros iguais e os demais diferentes. Então, os parâmetros comuns às regras são escritos fora do bloco
(apenas uma vez, à esquerda do bloco) e os diferentes dentro dele. Veja um exemplo:

chain INPUT proto tcp {

syn DENY;
ACCEPT;
}

esse bloco equivale as duas seguintes regras:

iptables -A INPUT -p tcp -y -j DENY

iptables -A INPUT -p tcp -j ACCEPT

• $ - é na definição de variáveis. Esse é um recurso pode melhorar a legibilidade dos arquivos, se forem escolhidos nomes
significativos para as variáveis. Ao executar as regras o FERM substitui as variáveis por seus valores. Veja um exemplo:

set IF eth0
set $IF ACCEPT
set TARGET $IF

o resultado dessas definições é o seguinte:

$IF = eth0
$eth0 = ACCEPT
$TARGET = eth0

• & - é usado na chamada de funções. Você aprenderá sobre elas posteriormente.

• - são usados na definição de listas de valores. Tais valores serão aplicados à palavra-chave a esquerda da lista.
Exemplo:

proto ( tcp udp icmp )

o resultado serão três regras com os seguintes trechos:

... -p tcp ...
... -p udp ...
... -p icmp ...

Veja outro exemplo:

chain (INPUT OUTPUT FORWARD) proto (icmp,udp,tcp) DENY;

esta linha tem como resultado 9 regras, pois há 9 possíveis combinações dos elementos das duas listas. Observe duas coisas
importantes: os elementos podem ser separados por espaços ou vírgulas, e as listas podem estar tanto à esquerda quanto à
direita de palavras-chave, ao contrário dos blocos de regras, que têm de estar sempre à direita destas palavras.

• # - esse carácter é usado antes de comentários. Tudo que estiver na mesma linha deste carácter e que for escrito
depois dele será ignorado. Fazer comentários é um bom hábito, que facilita a leitura do arquivo futuramente por nós
mesmos, ou por uma pessoa diiferente da que o escreveu.

• 'comando' - executa, em um shell, o comando escrito dentro das aspas e escreve a mensagem de saída desse
comando.

Lição 2 - Palavras-Chave e parâmetros

Palavras-Chave

Já foram citadas nas páginas anteriores algumas palavras chave, como "chain" e "ACCEPT". Nesta lição você aprenderá muitas
outras.
Existem três tipos de palavras-chave, descritos a seguir:
 • location keywords- definem onde uma regra será criada, por exemplo "table" ou chain".
• match keywords- executam um teste em todos os pacotes. Caso um ou mais dos pacotes não passe nesse teste a
regra não terá efeito. Exemplo: "proto", "daddr". Geralmante matches tem parâmetros: "proto tcp", "daddr
172.16.0.0/12".
• target keywords - especificam o que deve ser feito com um pacote. Exemplo: '' REJECT", "ACCEPT", "goto"

Qualquer regra é costituída de uma location keyword, uma target keyword e algumas match keywords:

table filter #location

proto tcp dport (http https) #match
ACCEPT #target

Parâmentros

Algumas palavras-chave precisam ser complementadas

com parâmetros, que podem ser literais, referências a variáveis ou
listas. Exemplo:

proto tcp
saddr %TRUSTED_HOSTS;
proto tcp dport (http https ssh);
LOG log-prefix "funky wardriver alert: ";

Alguns parâmetros podem ser negados:

proto !esp;
proto udp dport !domain;

Para negar palavras chave que não recebem parâmetros basta digitar ! antes delas:

proto tcp !syn;

Algumas Location Keywords

domain [ip|ip6] - define o domínio. O padrão é ip, que significa IPv4, ip6 é usado para suporte ao protocolo ipv6.

table [filter|nat|mangle] - especifica em qual tabela a regra será inserida. As opções são, "filter", que é o padrão, "nat" e
"mangle"

chain [chain-name] - especifica em qual chain (dentro da tabela atual) a regra será inserida. Geralmete as chains pré-
definidas são "INPUT", "OUTPUT", "FORWARD", "PREROUTING" e "POSTROUTING".

policy [ACCEPT|DROP] - especifica a política padrão do chain atual. Pode ser um dos targets ACCEPT, DROP, REJECT etc. Os
pacotes que não satisfazem as regras serão tratados da maeira especificada pela política padrão. Para evitar ambiguidades,
sempre especifique qual política será adotada para cada chain.

subchain - funciona como um bloco normal, mas o FERM move as regras de detro desse bloco para outro chain. O nome do
novo chain será escolhido automaticamente pelo FERM. Em muitos casos isto é mais rápido que um simples bloco, porque o ferm
pode pular um grande bloco caso a pré-condição for falsa. Veja um exemplo:

table filter chain INPUT {

saddr (1.2.3.4 2.3.4.5 3.4.5.6 4.5.6.7 5.6.7.8) {
proto tcp dport (http https ssh) ACCEPT;
proto udp dport domain ACCEPT;
}
}

serão geradas então 20 regras. Se um pacote chega e não satisfaz o saddr, ainda assim serão testadas as 20 regras. Usando
subchain a checagem será feita apenas uma vez. Assim, o processo será mais rápido.

table filter chain INPUT {

saddr (1.2.3.4 2.3.4.5 3.4.5.6 4.5.6.7 5.6.7.8) subchain {
proto tcp dport (http https ssh) ACCEPT;
proto udp dport domain ACCEPT;
}
}

Algumas Match Keywords

interface [interface-name] - define o nome da interface. É equivalente a -i switch no iptables.

outerface [interface-name] - semelhante a interface, somente para testar a interface de saída dos pacotes, como no iptables.

protocol [protocol-name|protocol-number] - atualmente são suportados pelo kernel os protocolos tcp, udp e icmp, ou seus
respectivos números.

saddr|daddr [address-spec] - testa os pacotes originados de determinado endereço(saddr) ou destinados a um determinado

endereço(daddr). Exemplo:

saddr 192.168/8 ACCEPT; #idêntico ao próximo:

saddr 192.168.0.0/255.255.255.0 ACCEPT;
daddr my.domain.com ACCEPT;

fragment - especifica que apenas pacotes fragmentados devem ser testados. Quando o pacote é maior que o tamanho máximo
de pacote que um sistema está apto a tratar ele será dividido em pedaços menores que serão enviados um a um como se
fossem pacotes.

sport|dport [port-spec] - faz a verificação dos pacotes em portas TCP ou UDP especificadas. sport verifica as portas de
origem dos pacotes e dport verifica as portas de destino. Essas palavras-chave (sport e dport) só podem ser usadas depois de
especificados os protocolos "protocol tcp" ou "protocol udp".

icmp-type [type] - usado para especificar um tipo de uma mensagem icmp. Pode ser usado apenas após "protocol icmp".

module [module-name] - Carrega um módulo do iptables. A maioria dos módulos fornecem mais mach keywords.

Algumas Target Keywords

goto [custon-chain-name] - vai para um outro chain. Caso nesse novo chain não haja regras retorna para o chain anterior,
para a regra seguinte a do goto.

ACCEPT - aceita os pacotes.

DROP - bloqueia os pacotes sem fazer nenhuma advertência.

REJECT - rejeita os pacotes e envia um pacote ICMP para o remetente. Por padrão esse pacote é port-unreachable, mas você
pode especificar um outro tipo de pacote ICMP.
REJECT; #padrão
REJECT reject-with icmp-net-unreachable; # outro tipo especificado

RETURN - finaliza o chain atual e, caso ele tenha sido chamado por um goto retorna ao chain que o chamou.

NOP - nenhuma ação é realizada.

Lição 3 - variáveis, funções, include, opções de comandos

Variáveis

Variáveis são utilizadas com o objetivo de melhorar a

legibilidade de arquivos de firewall, principalmente se estes forem
complexos. Veja um exemplo de definição de variáveis:

def $DEV_INTERNET = eth0;

def $PORTS = (http ftp);
def $MORE_PORTS = ($PORTS 8080);

depois de definir as variáveis use-as da mesma forma que usaria os parâmetros que elas substituem. Veja um exemplo:

chain INPUT interface $DEV_INTERNET proto tcp dport $MORE_PORTS ACCEPT;

OBS: as variáveis não podem conter palavras-chave como "proto" ou "interface" em seus nomes, apenas podem ter parâmetros.

O valor definido para uma variável dentro de um bloco só vale dentro dele. Por exemplo, no trecho seguinte:

def $DEV_INTERNET = eth1;

chain INPUT {
proto tcp {
def $DEV_INTERNET = ppp0;
interface $DEV_INTERNET dport http ACCEPT;
}
 interface $DEV_INTERNET DROP;
}

a definição def $DEV_INTERNET = ppp0 só vale dentro do bloco

{
def $DEV_INTERNET = ppp0;
interface $DEV_INTERNET dport http ACCEPT;
}

fora deste bloco continua valendo a definição def $DEV_INTERNET = eth1.

Se houver uma chamada a um arquivo no qual foi feita uma declaração de
variável então a declaração continua valendo no bloco que fez a
chamada. Isto é útil quando são necessárias muitas declarações. Neste
caso pode-se fazer um arquivo só de declarações e incluí-lo no arquivo
que usa as variáveis.

Variáveis Automáticas

Algumas variáveis vêm definidas pelo FERM. Você pode utilizá-las da mesma fora
que utiliza as que você definiu. São variáveis pré-definidas:

• $DOMAIN - o domínio atual, que pode ser "ip" ou "ip6"

• $TABLE - a tabela atual.
• $CHAIN - o chain atual.

Funções

Funções são semelhantes a variáveis, a diferença é que

funções podem ter parâmetros e que elas fornecem comandos, e não
valores. Veja um exemplo:

def &FOO() = proto (tcp udp) dport domain;

&FOO() ACCEPT;

def &TCP_TUNNEL($port, $dest) = {

table filter chain FORWARD interface ppp0 proto tcp dport $port daddr
$dest outerface eth0 ACCEPT;
table nat chain PREROUTING interface ppp0 proto tcp dport $port daddr 1.2.3.4 DNAT to $dest;
}

&TCP_TUNNEL(http, 192.168.1.33);
&TCP_TUNNEL(ftp, 192.168.1.30;
&TCP_TUNNEL((ssh smtp), 192.168.1.2);

Uma chamda de fução que contém um bloco (como {...}) tem de ser o último comando da regra, isto é, deve prceder um ;. No
exemplo acima você pôde escrever ACCEPT depois da chamada a '&FOO()' porque não há blocos em '&FOO()'.

Include

A palavra-chave include permite a inclusão de arquivos externos. Exemplo:

include 'vars.ferm';

O nome do arquivo é relativo ao arquivo que faz a chamada, ou seja, quando é incluído /etc/ferm/ferm.conf . Variáveis e
funções declaradas em um arquivo incluído ainda ficam
disponíveis no arquivo no qual a chamada é feita. É possível também
usar includes dentro de blocos:

chain INPUT {
include 'input.ferm';
}

Se você incluir um diretório ao invés de um arquivo todos os arquivos desse diretório serão incluídos. Exemplo:

include 'ferm.d/';

Algumas opções de comandos

• --noexec - Pula os comandos iptables ao invés de executá-los.
• --lines - mostra
as linhas do firewall geradas pelas regras. Essas linhas serão
mostradas imeditamente antes de serem executadas. Assim, se houver uma
mensagem de erro você poderá ver a regra que o causou.
• --interactive - aplica
as regras do firewall e pede uma confirmação do usuário. Caso não haja
essa confirmação dentro de 30 segundos o firewall volta a configuração
anterior.
• --help - mostra uma lista das opções disponíveis.
• --version - informa qual é a versão do programa.
• --fast - habilita
o modo rápido. É feito o seguinte: o FERM cria o arquivo iptables-save
e o intala com o iptables-restore. Dessa forma o FERM precisará chamar
o iptables apenas uma vez.
• --domain - lida apenas com o domínio especificado. Caso o domínio não esteja especificado no arquivo de entrada pode
ser que não haja nenhuma saída.