A tabela nat (Network Address Translation) - fazendo nat

A tabela nat serve para controlar a tradução dos endereços que atravessam o código de roteamento da máquina Linux. Existem 3 chains na tabela nat: PREROUTING, OUTPUT e POSTROUTING . A tradução de endereços tem inúmeras utilidades, uma delas é o Masquerading, onde máquinas de uma rede interna podem acessar a Internet através de uma máquina Linux, redirecionamento de porta, proxy transparente, etc. Abordaremos os tipos de NAT, exemplos de como criar rapidamente uma conexão IP masquerading e entender como a tradução de endereços funciona no iptables. Se sua intenção é ligar sua rede a Internet existem duas opções:
Você possui uma conexão que lhe oferece um endereço IP dinâmico (a cada conexão é dado um endereço IP - como uma conexão PPP) então o IP masquerading é o que precisa,
Você tem uma conexão que lhe oferece um endereço IP permanente (ADSL, por exemplo) então o SNAT é o que precisa.
Criando um novo chain na tabela NAT
O procedimento para criação de um novo chain nesta tabela é o mesmo descrito em nossa matéria anterior será necessário somente especificar a tabela nat (-t nat) para que o novo chain não seja criado na tabela padrão (-t filter).
iptables -t nat -N intra-inter
Que criará o chain chamado intra-inter na tabela nat. Para inserir regras neste chain será necessário especificar a opção "-t nat".
Fazendo IP masquerading (para os apressados)
Você precisará de um kernel com suporte ao iptables e ip_forward e então digitar os dois comandos abaixo para habilitar o masquerading para todas as máquinas da rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE
echo "1" >/proc/sys/net/ipv4/ip_forward
A configuração do servidor Linux está completa, agora os clientes da rede precisarão ser configurados para usar o endereço IP do servidor Linux como gateway. É recomendável instalar um servidor proxy e DNS na máquina Linux para acelerar o desempenho das requisições/resolução de nomes das máquinas em rede. A utilização de bits TOS também pode trazer um grande aumento de velocidade para os diferentes serviços da rede.
Fazendo SNAT
SNAT (source nat - nat no endereço de origem) consiste em modificar o endereço de origem das máquinas clientes antes dos pacotes serem enviados. A máquina roteadora é inteligente o bastante para lembrar dos pacotes modificados e reescrever os endereços assim que obter a resposta da máquina de destino, direcionando os pacotes ao destino correto. Toda operação de SNAT é feita no chain POSTROUTING. É permitido especificar endereços de origem/destino, protocolos, portas de origem/destino, interface de entrada/saída (dependendo do chain), alvos, etc. É desnecessário especificar fragmentos na tabela nat, pois eles serão remontados antes de entrar no código de roteamento. O SNAT é a solução quando você tem acesso a internet através de um único IP e deseja fazer que sua rede tenha acesso a Internet através da máquina Linux. Nenhuma máquina da Internet poderá ter acesso direto as máquinas de sua rede interna via SNAT. OBS: A observação acima não leva em conta o controle de acesso externo configurado na máquina que estiver configurando o iptables, uma configuração mau realizada pode expor sua máquina a acessos externos indesejados e comprometer sua rede interna caso alguém consiga acesso direto ao servidor. É necessário especificar SNAT como alvo (-j SNAT) quando desejar que as máquinas de sua rede interna tenha acesso a Internet através do IP fixo da máquina Linux. O parâmetro --to IP:portas deve ser usado após o alvo SNAT. Ele serve para especificar um endereço IP, faixa de endereços e opcionalmente uma porta ou faixa de portas que será substituída. Toda a operação de SNAT é realizada através do chain POSTROUTING:
# Modifica o endereço IP dos pacotes vindos da máquina 192.168.1.2 da rede interna
# que tem como destino a interface eth1 para 200.200.217.40 (que é o nosso endereço
# IP da interface ligada a Internet).
iptables -t nat -A POSTROUTING -s 192.168.1.2 -o eth1 -j SNAT --to 200.200.217.40
Os pacotes indo para a Internet (nossa conexão é feita via eth1, nossa interface externa) vindo do endereço 192.168.1.2, são substituídos por 200.241.200.40 e enviados para fora. Quando a resposta a requisição é retornada, a máquina com iptables recebe os pacotes e faz a operação inversa, modificando o endereço 200.241.200.40 novamente para 192.168.1.2 e enviando a resposta a máquina de nossa rede interna. Após definir suas regras de NAT, execute o comando echo "1" >/proc/sys/net/ipv4/ip_forward para habilitar o suporte a redirecionamento de pacotes no kernel. Também é possível especificar faixas de endereços e portas que serão substituídas:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50
Modifica o endereço IP de origem de todas as máquinas da rede 192.168.1.0/24 que tem o destino a interface eth0 para 200.241.200.40 a 200.241.200.50. O endereço IP selecionado é escolhido de acordo com o último IP alocado.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50:1-1023
Idêntico ao anterior, mas faz somente substituições na faixa de portas de origem de 1 a 1023.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50 --to 200.200.217.70-200.200.217.73
Faz o mapeamento para a faixa de portas 200.200.217.40 a 200.200.217.50 e de 200.200.217.70 a 200.200.217.73. OBS1: Se por algum motivo não for possível mapear uma conexão NAT, ela será derrubada. OBS2: Tenha certeza que as respostas podem chegar até a máquina que fez o NAT. Se estiver fazendo SNAT em um endereço livre em sua rede (como 200.200.217.73). OBS3: Como notou acima, o SNAT é usado quando temos uma conexão externa com um ou mais IP's fixos. O Masquerading é uma forma especial de SNAT usada para funcionar em conexões que recebem endereços IP aleatórios (PPP). OBS4: Não se esqueça de habilitar o redirecionamento de pacotes após fazer suas regra de NAT com o comando: echo "1" >/proc/sys/net/ipv4/ip_forward, caso contrário o redirecionamento de pacotes não funcionará.
Fazendo IP Masquerading
O IP Masquerading é um tipo especial de SNAT usado para conectar a sua rede interna a internet quando você recebe um IP dinâmico de seu provedor (como em conexões ppp). Todas as operações de IP Masquerading são realizadas no chain POSTROUTING. Para fazer IP Masquerading de uma máquina com o IP 192.168.1.2 para ter acesso a Internet, use o comando:
iptables -t nat -A POSTROUTING -s 192.168.1.2/32 -o ppp0 -j MASQUERADE
A diferença é que o alvo é -j MASQUERADE. O comando acima faz IP Masquerading de todo o tráfego de 192.168.1.2 indo para a interface ppp0: O endereço IP dos pacotes vindos de 192.168.1.2 são substituídos pelo IP oferecido pelo seu provedor de acesso no momento da conexão, quando a resposta é retornada a operação inversa é realizada para garantir que a resposta chegue ao destino. Nenhuma máquina da internet poderá ter acesso direto a sua máquina conectava via Masquerading. Para fazer o IP Masquerading de todas as máquinas da rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o ppp0 -j MASQUERADE
Após definir a regra para fazer Masquerading (SNAT), execute o comando echo "1" >/proc/sys/net/ipv4/ip_forward para habilitar o suporte a redirecionamento de pacotes no kernel.
Fazendo DNAT
DNAT (Destination nat - nat no endereço de destino) consiste em modificar o endereço de destino das máquinas clientes. O destination nat é muito usado para fazer redirecionamento de pacotes, proxyes transparentes e balanceamento de carga. Toda operação de DNAT é feita no chain PREROUTING. As demais opções e observações do SNAT são também válidas para DNAT (com exceção que somente é permitido especificar a interface de origem no chain PREROUTING).
# Modifica o endereço IP destino dos pacotes de 200.200.217.40 vindo da interface eth0
# para 192.168.1.2.
iptables -t nat -A PREROUTING -s 200.200.217.40 -i eth0 -j DNAT --to 192.168.1.2
Também é possível especificar faixas de endereços e portas que serão substituídas no DNAT:
iptables -t nat -A PREROUTING -i eth0 -s 192.168.1.0/24 -j DNAT --to 200.200.217.40-200.200.217.50
Modifica o endereço IP de destino do tráfego vindos da interface 192.168.1.0/24 para um IP de 200.241.200.40 a 200.241.200.50. Este é um excelente método para fazer o balanceamento de carga entre servidores. O endereço IP selecionado é escolhido de acordo com o último IP alocado.
iptables -t nat -A PREROUTING -i eth0 -s 192.168.1.0/24 -j DNAT --to 200.200.217.40-200.200.217.50:1024:5000
Idêntico ao anterior, mas faz somente substituições na faixa de portas de destino de 1024 a 5000. A operação acima é a mesma realizada pelo ipmasqadm dos kernels da série 2.2. OBS1: Se por algum motivo não for possível mapear uma conexão NAT, ela será derrubada. OBS2: Não se esqueça de conferir se o ip_forward está ajustado para 1: echo "1" >/proc/sys/net/ipv4/ip_forward.
Redirecionamento de portas
O redirecionamento de portas permite a você repassar conexões com destino a uma porta para outra porta na mesma máquina. O alvo REDIRECT é usado para fazer esta operação, junto com o argumento --to-port especificando a porta que será redirecionada. Este é o método DNAT específico para se para fazer proxy transparente (para redirecionamento de endereços/portas. Todas as operações de redirecionamento de portas é realizada no chain PREROUTING e OUTPUT da tabela nat.
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 81
Redireciona as conexões indo para a porta 80 para a porta 81 (rodando squid) no firewall. ATENÇÃO: O squid possui suporte a proxy transparente, e poderá atender as requisições acima da regra acima.
Monitorando conexões feitas na tabela nat
Use o comando cat /proc/net/ip_conntrack para listar todas as conexões atuais tratadas pelo módulo nat.

Firewall Iptables

O Iptables é um firewall em nível de pacotes, ou seja, toma as decisões baseadas nos parâmetros do pacote, como porta/endereço de origem/destino, estado da conexão, e outros parâmetros do pacote. Funciona através da comparação de regras para saber se um pacote tem ou não permissão para passar. O iptables tem inúmeras possibilidades de controle oferecidas pelos recursos de filtragem, flexibilidade na manipulação dando lugar à imaginação do administrador.
Algumas aplicações do iptables:

• Construir firewalls de Internet baseados em filtragem de pacotes "stateless" e "stateful"
• Usar NAT e masquerading para compartilhamento de Internet com uma rede local
• Usar NAT para implementar proxies transparentes
• Realizar manipulação de pacotes adicional (mangling), como alterar bits no cabeçalho IP
• Monitorar o volume de tráfego de rede
• Realizar Encaminhamento de Portas (que é um tipo de DNAT)
• Balanceamento de carga de rede.

Entre outras aplicações.
Funcionamento do iptables:
O firewall iptables trabalha comparando o tráfego de rede que a máquina recebe com um conjunto de regras pré-especificadas, as quais definem as características que os pacotes devem possuir para corresponderem às regras, e as ações que serão tomadas para esses pacotes.
Podemos criar regras que verifiquem a correspondência de uma pacote com uma regra específica de várias formas, como por exemplo por tipo de protocolo, portas de origem ou destino, endereços IP de origem ou destino, interfaces em uso, tipos de mensagens, entre muitas outras.
Quando ocorre uma correspondência entre um pacote e uma regra, uma ação será tomada, e a essa ação dá-se o nome de target. O target (“objetivo”) pode determinar se um pacote será aceito ou descartado, movido para outra cadeia para processamento, logado, ou ainda outras opções.
A arquitetura do iptables agrupa o processamento dos pacotes de rede em tabelas por função (filtro de pacotes, tradução de endereços de rede e outras formas de configuração de pacotes), cada qual possui cadeias (chains) de regras de processamento. As regras consistem em correspondências (matches) usadas para determinar a quais pacotes cada regra será aplicada, e objetivos (targets), que determinam o que será feito com os pacotes que correspondam às regras.
Tabelas
O iptables organiza suas regras em uma estrutura que contém tabelas e cadeias. As tabelas são um agrupamento de cadeias em um nível mais alto, e determinam grosso modo o escopo das regras que serão criadas. O iptables possui três tabelas ou listas de regras:

• filter - Tabela padrão para manipular pacotes de rede, usada para configurar políticas para o tráfego que entra, atravessa ou sai do computador.
• nat - Usada para alterar pacotes que criam uma nova conexão, e para redirecionar conexões para NAT..
• mangle - Usada para tipos específicos de alteração de pacotes, como a modificação de opções do cabeçalho IP de um pacote..
• raw - Marca pacotes que não devem ser manipulados pelo sistema de rastreamento de conexões.

Uma tabela contém cadeias, e as cadeias contém regras, como podemos ver na figura a seguir:

As tabelas possuem as cadeias a seguir:
Tabela FIlter: Cadeias INPUT, OUTPUT e FORWARD
Tabela NAT: Cadeias PREROUTING, OUTPUT, POSTROUTING
Tabela Mangle: Cadeias PREROUTING, OUTPUT, POSTROUTING, INPUT e FORWARD
Tabela raw: Cadeias PREROUTING e OUTPUT
Tabela security - Usada para regras de rede MAC (Mandatory Access Control)
Cadeias
As regras são organizadas em grupos denominados cadeias (chains), que por sua vez ficam contidas nas tabelas. Uma cadeia é então um conjunto de regras usadas para verificar a correspondência com um pacote - de forma sequencial. Um pacote é verificado junto às regras na chain, e se não há correspondência, a próxima regra na ordem é verificada. Quando um pacote corresponde a uma regra na cadeia, a ação associada a essa regra é executada e as regras restantes não são verificadas contra esse pacote. Caso nenhuma regra corresponda ao pacote, a regra padrão (policy) será aplicada.
Podemos criar nossas próprias cadeias se for necessário, mas no geral utilizamos as cadeias já existentes e definidas por padrão. São elas:

• INPUT - aplica regras aos pacotes de rede que chegam ao servidor.
• OUTPUT - aplica regras aos pacotes de rede originados e que partem do servidor.
• FORWARD -  aplica regras aos pacotes de rede roteados através do servidor (para outro servidor ou outra interface de rede no mesmo servidor)
• PREROUTING - Altera pacotes de rede quando eles chegam e antes do roteamento. Usado para DNAT (Destination NAT)
• POSTROUTING - Altera pacotes de rede após o roteamento. Usado para SNAT (Source NAT)

As cadeias podem ter zero ou mais regras, e possuem uma política padrão. A política (policy) determina o que acontece com um pacote caso nenhuma das regras da cadeia corresponda a ele, e somente pode ser ACCEPT ou DROP (RETURN para cadeias definidas pelo usuário).
Por meio de módulos que podem ser carregados via regras, o iptables também pode rastrear conexões. Assim, podemos criar regras que definem o que acontece com um pacote baseado em sua relação com pacotes anteriores. Chamamos essa técnica de “rastreamento de estado” ou “rastreamento de conexão”.
Veja nas figuras a seguir a relação entre as cadeias apresentadas e as tabelas filter, nat e mangle:

1. Fluxo de pacotes de rede e pontos de hook da tabela filter

2. Fluxo de pacotes de rede e pontos de hook da tabela NAT

3. Fluxo de pacotes de rede e pontos de hook da tabela mangle
Regras (Rules)
Uma regra do iptables consiste em um ou mais critérios de correspondência que determinam quais pacotes de rede serão afetados, e uma especificação de objetivo (“target”) que determina como o pacote de rede será afetado. Para que a regra seja aplicada a um pacote todas as opções de correspondência listadas na regra devem ser satisfeitas. Se não houver um critério de correspondência especificado na regra, então todos os pacotes serão considerados como correspondentes.
Há muitas correspondências (“matches”) disponíveis para uso com o iptables. Além das correspondências genéricas, como tipo de protocolo, IP de origem e destino, portas de comunicação, entre outras, também é possível utilizar correspondências (parâmetros) disponibilizados por meio de extensões carregadas dinamicamente, e informadas na regra com o uso da opção -m ou --match.
Já as ações (targets / objetivos) são usadas para especificar a ação que será tomada quando uma regra corresponder a um pacote e também para especificar a regra padrão da cadeia. Há quatro targets disponíveis no iptables, e podemos acrescentar outros por meio de módulos de extensão. Os targets padrão são ACCEPT, DROP, QUEUE e RETURN, descritos à frente no texto.
A estrutura geral de uma regra é a seguinte:
iptables subcomando chain parâmetro_1 valor_1 parâmetro_n valor_n ação
Os subcomandos principais que podem ser usados são os seguintes:

-A anexa a regra no final da cadeia especificada -F apaga todas as regras na cadeia especificada -L lista todas as regras da cadeia -N cria uma nova cadeia com o nome desejado -P configura a regra padrão da cadeia -D apaga uma regra em uma posição na cadeia -X exclui uma cadeia vazia -I insere uma regra em uma posição na cadeia

Já as ações (targets) possíveis estão listadas na tabela a seguir:

Ações embutidas no iptables: ACCEPT - pacote permitido DROP - Descartar o pacote QUEUE - Enviar o pacote ao userspace (código fora do kernel) RETURN - Descontinuar o processamento do pacote e aplicar a regra padrão a ele. Ações adicionais: REJECT - Descarta o pacote e envia feedback ao remetente. DNAT - reescreve endereço de destino (NAT) SNAT - reescreve endereço de origem (NAT) LOG - coloca no log informações sobre o pacote

Com relação aos parâmetros, existem dezenas deles para que possamos criar regras dos mais variados tipos. Na tabela a seguir listamos alguns dos parâmetros mais comuns:

Parâmetro	Significado
-t tabela	Especificar a tabela (filter é a padrão)
-j ação	Realiza a ação especificada
-p protocolo	Especifica o protocolo (icmp, tcp, udp, all)
-s IP	IP de origem do pacote
-d IP	IP de destino do pacote
-i interface	Nome da interface de rede de entrada do pacote
-o interface	Nome da interface de rede de saída do pacote
--sport portas	Portas de origem
--dport portas	Portas de destino
--syn	Identifica nova requisição de conexão
--icmp-type	tipo de mensagem ICMP

Podemos visualizar as regras atuais de uma cadeia por meio do comando iptables -L (ou iptables --list):
# iptables -L

Veja que não há nenhuma regra criada, além da regra padrão (policy), que está configurada para aceitar todos os pacotes em todas as cadeias. Como não especificamos a tabela, a saída mostrada é a da tabela padrão, que é a FILTER. Para especificarmos uma outra tabela, usamos a opçãa -t. Veja no exemplo abaixo a listagem da tabela nat:
# iptables -t nat -L

Perceba que neste caso aparecem também as cadeias específicas PREROUTING e POSTROUTING.
Os campos mostrados na saída do comando de listagem de regras são os seguintes:
target - Ação a ser realizada no pacote
prot - Protocolo especificado
opt - Opções especiais da regra
source - Endereço IP de origem do pacote
destination - Endereço IP de destino do pacote.
num - Exibido com a opção --line-numbers. Mostra o número da regra dentro da cadeia.
Vamos analisar um exemplo típico de uma regra do iptables:
iptables -A INPUT -s 0/0 -i eth0 -d 192.168.1.1 -p TCP -j ACCEPT
Destrinchando a regra acima, temos:
iptables - Comando iptables
-A INPUT - Anexar a regra no final da cadeia INPUT
-s 0/0 - Endereço IP de origem: qualquer um
-i eth0 - Interface de entrada a ser monitorada: eth0
-d 192.168.1.1 - Endereço IP de destino do pacote: 192.168.1.1
-p TCP - Protocolo a ser verificado: TCP
-j ACCEPT - Ação a ser aplicada no pacote: ACCEPT (permitir)
Limpando as regras de uma cadeia
Podemos apagar todas as regras de uma cadeia (exceto a regra padrão) com a opção -F:
# iptables -F INPUT
Ou limpar todas as regras de todas as cadeias da tabela especificada:
# iptables -F
Configurando a regra padrão de uma cadeia
Usamos a opção -P para configurar a regra padrão de uma cadeia. Veja os exemplos:
# iptables -P INPUT DROP
# iptables -P OUTPUT ACCEPT
# iptables -L

Rastreamento de conexões (Connection Tracking)
O iptables associa os pacotes com as conexões lógicas às quais eles pertencem. Para isso, ele segue o progresso das conexões através de seu ciclo de vida, e essa informação de rastreamento é disponibilizada por meio da extensão de equivalência conntrack.
A tabela a seguir mostra os estados de rastreamento de conexão mais comuns:

Estado	Descrição
ESTABLISHED	A conexão já viu pacotes trafegando em ambas as direções.
INVALID	O pacote não pertence a nenhuma conexão rastreada
NEW	O pacote está iniciando uma nova conexão ou é parte de uma conexão que ainda não teve pacotes trafegados em ambas as direções.
RELATED	O pacote está iniciando uma nova conexão, mas a nova conexão é relacionada a uma conexão já existente (como a conexão de dados em uma transferência FTP).

Alguns exemplos de regras do iptables
1. Vamos começar configurando as regras-padrão da tabela FILTER. Vamos descartar todos os pacotes que chegam ao servidor por meio da cadeia INPUT e liberar todos os pacotes originados no servidor por meio da cadeia OUTPUT:
# iptables -P INPUT DROP
# iptables -P OUTPUT ACCEPT
2. Vamos testar o acesso ao servidor via SSH usando o PuTTY. A conexão será negada, pois todas as conexões entrantes estão bloqueadas no momento:

Devemos, então, liberar o acesso SSH por meio da porta 22 com a regra a seguir:
# iptables -A INPUT -p tcp --dport 22 -j ACCEPT
Testamos agora a conexão via PuTTY:

Conexão efetuada com sucesso, pois a porta 22 está agora liberada. Vejamos a regra criada no firewall:
# iptables -L --line-numbers

Isso é muito importante caso desejemos inserir uma regra nova em uma posição específica, ou excluir uma regra sem afetar as demais.
Podemos também ver una versão resumida das regras atuais do firewall com a opção -S:
# iptables -S
3. Muitos servidores Linux permitem acesso via interface Web a seus serviços administrativos. Para que isso funcione, é necessário liberar a porta usada pelo servidor web, que normalmente é a porta 80. Liberaremos também o protocolo HTTPS, que usa a porta 443. Vamos liberá-las:
# iptables -A INPUT -m state --state NEW -p tcp --dport 80 -j ACCEPT
# iptables -A INPUT -m state --state NEW -p tcp --dport 443 -j ACCEPT
4. Geralmente os serviços em um computador se comunicam entre si enviando pacotes de rede de um para outro. Para isso, é usada normalmente a interface de rede de loopback, a qual direciona o tráfego de rede de volta para o próprio servidor, em vez de enviá-lo para a rede local.
Vamos então liberar o tráfego na interface de loopback:
# iptables -I INPUT 1 -i lo -j ACCEPT
Neste caso, a opção -I nos permite inserir a regra em uma posição específica na cadeia INPUT - no caso, na posição número 1. E com a opção -i podemos selecionar a interface a ser afetada, lo, que é a interface de loobback.
4. Agora vamos bloquear todo o tráfego proveniente de um IP específico na rede. Bloquearemos o tráfego do IP 10.10.10.20 para o nosso servidor:
# iptables -A INPUT -s 10.10.10.20 -j DROP
5. Podemos aceitar todo o tráfego na cadeia INPUT proveniente de um computador em particular na rede, por meio de seu MAC Address:
# iptables -A INPUT -m mac --mac-source 00:12:A1:24:BB:0C -j ACCEPT
6. Bloqueando o ping. Vamos bloquear as mensagens de requisição de eco do icmp, de modo que nosso servidor não responderá a requisições de ping:
# iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
7. Porém o servidor ainda pode enviar requisições de ping para outras máquinas. Se quisermos bloquear as requisições de saída devemos criar a regra a seguir:
# iptables -A OUTPUT -p icmp --icmp-type echo-request -j DROP
Se quisermos bloquear as mensagens de resposta do ping, devemos usar o tipo de icmp echo-reply.
8. Suponhamos que seja necessário abrir uma faixa de portas no servidor, como por exemplo, as portas de 5100 a 5150. Não precisamos criar uma regra para cada porta. Em vez disso, indicamos na regra que queremos usar uma faixa de portas em vez de uma única:
# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 5100:5150 -j ACCEPT
9. Liberando o servidor de impressão na rede local 10.10.0.0/24: para isso temos de liberar as portas do CUPS, que são as portas 631 TCP e UDP:
# iptables -A INPUT -s 10.10.1.0/24 -p udp -m udp --dport 631 -j ACCEPT
# iptables -A INPUT -s 10.10.1.0/24 -p tcp -m tcp --dport 631 -j ACCEPT
10. Caso seu servidor Linux também seja o servidor DNS da rede, será necessário liberar as portas adequadas para os clientes da rede:
# iptables -A INPUT -m state --state NEW -p udp --dport 53 -j ACCEPT
# iptables -A INPUT -m state --state NEW -p tcp --dport 53 -j ACCEPT
11. É muito comum termos um servidor de arquivos em Linux na rede, servindo a clientes Windows via SAMBA. Vamos então liberar acesso ao servidor de arquivos para os clientes de nossa rede interna (10.10.1.0/24):
iptables -A INPUT -s 10.10.1.0/24 -m state --state NEW -p tcp --dport 137 -j ACCEPT
iptables -A INPUT -s 10.10.1.0/24 -m state --state NEW -p tcp --dport 138 -j ACCEPT
iptables -A INPUT -s 10.10.1.0/24 -m state --state NEW -p tcp --dport 139 -j ACCEPT
iptables -A INPUT -s 10.10.1.0/24 -m state --state NEW -p tcp --dport 445 -j ACCEPT
Salvando as regras do iptables em arquivo
Após criarmos as regras do firewall, é possível salvá-las em um arquivo com o comando:
# iptables-save > arquivo



E podemos recuperá-las com:
# iptables-restore < arquivo
Tornando as regras do firewall permanentes:
Por padrão, as regras que nós adicionamos ao iptables não são permanentes - se o servidor for reiniciado, serão todas perdidas.
Como devemos proceder para que as regras se tornem permanentes? Bem, há algumas maneiras de conseguirmos isso. A maneira mais fácil, a meu ver, é usando o pacote iptables-persistent. Ele está disponível para Debian, Ubuntu, CentOS e muitas outras distribuições Linux.
Vamos instalar o pacote iptables-persistent:
# yum install iptables-persistent

Escolha a opção Sim e pressione enter para salvar automaticamente as regras atuais do firewall iptables. Se houverem regras IPv6 a serem salvas, repita o processo na próxima tela. Veja o resultado:

Agora, ao reiniciar o servidor,as regras do firewall existentes atualmente serão preservadas (na verdade, recarregadas). As regras são salvas no arquivo /etc/iptables/rules.v4 e relidas durante a reinicialização do sistema.
Caso sejam criadas novas regras ou as regras atuais sejam alteradas, rode o comando a seguir para atualizar o arquivo de regras do iptables-persistent, para garantir que as novas regras também sejam carregadas durante a inicialização do sistema:
# iptables-save > /etc/iptables/rules.v4
Ou podemos também rodar o comando a seguir para salvar as regras, caso não tenhamos permissão de alteração no arquivo rules.v4 (usar o sudo no Ubuntu):
# service iptables-persistent save
Vejamos agora alguns exemplo do uso do target REJECT. Para isso usaremos algumas mensagens ICMP para visualizar a resposta do firewall ao remetente dos pacores que serão bloqueados.
O target REJECT só é válido nas cadeias INPUT, OUTPUT e FORWARD, e possui uma opção, --reject-with, a qual exploraremos nos exemplos sugeridos.
Primeiro, vamos limpar a regras atuais do firewall, cujo IP é 192.168.1.101, para que não interfiram em nossos exemplos:
# iptables -F
Vamos também alterar a regra padrão da chain INPUT para ACCEPT:
# iptables -P INPUT ACCEPT
E agora vamos enviar pacotes icmp usando o ping e testar a conectividade entre as máquinas (usarei um cliente WIndows, de IP 192.168.1.105, via prompt de comandos):

O ping está operando normalmente. Vamos então criar algumas regras que bloqueiem o ping no servidor e que emitam de volta ao remetente (no caso, a máquina WIndows) mensagens específicas. Após testar cada regra, limpe a cadeia com iptables -F.
Regra #1: Usando um REJECT simples, sem especificar nenhuma mensagem de retorno:
# iptables -A INPUT -s 192.168.1.105 -j REJECT
Testando a partir do cliente:

Observe que o ping foi bloqueado no servidor e foi emitida uma mensagem padrão do REJECT “Porta de destino inacessível” ao cliente de IP 192.168.1.105.
Regra #2:  Emitindo a mensagem “Rede de destino inacessível” com o REJECT:
# iptables -A INPUT -s 192.168.1.105 -j REJECT --reject-with icmp-net-unreachable
Testando a partir do cliente:

O parâmetro --reject-with deve sempre vir após a palavra REJECT.
Regra #3: Emitindo a mensagem “Host de destino inacessível” com o REJECT:
# iptables -A INPUT -s 192.168.1.105 -j REJECT --reject-with icmp-host-unreachable

Regra #4: Emitindo a mensagem padrão “Porta de destino inacessível” com o REJECT:
# iptables -A INPUT -s 192.168.1.105 -j REJECT --reject-with icmp-port-unreachable

Note que essa é a mensagem padrão do REJECT, que é emitida se nenhuma outra for especificada com --reject-with.
Regra #5: Emitindo a mensagem padrão “Protocolo de destino inacessível” com o REJECT:
# iptables -A INPUT -s 192.168.1.105 -j REJECT --reject-with icmp-proto-unreachable

Há algumas outras mensagens icmp que podem ser emitidas, como icmp-tcp-reset, icmp-host-prohibited, icmp-network-prohibited e icmp-admin-prohibited.

Em nossa próxima matéria, iremos aprofundar os estudos em NAT.

Qualquer dúvida, deixe nos comentários.

PHP: como dar os primeiros passos

Se você sempre teve vontade de programar em PHP, mas nunca soube por onde começar, saiba que não está sozinho. Embora seja possível encontrar praticamente qualquer tipo de conteúdo na internet, muitas vezes os aspirantes a programadores ficam um pouco perdidos com tanta informação e não conseguem encontrar um ponto de partida para a sua empreitada.



Às vezes, ter alguém para apontar o caminho certo é tudo o que uma pessoa precisa para se encontrar no mundo da programação. Por isso, o Tecmundo resolveu criar este guia, mostrando onde encontrar as informações necessárias para começar a programar em PHP e também o que é importante saber e fazer antes de avançar para os níveis mais complexos. Confira!

Por onde começar?

Antes de começar a codificar uma página, é importante configurar o seu computador com os aplicativos necessários. Normalmente, quando um programador vai realizar alguma alteração em um site, o trabalho é feito primeiro em uma cópia local dos endereços para só então ser enviado para o servidor. Dessa forma, não há o risco de o portal ficar fora do ar devido a alguma falha durante a manutenção.

Para ter essa cópia local funcionando corretamente no seu computador, é preciso instalar e configurar ferramentas como o Apache, PHP e MySQL. Assim, você consegue simular um ambiente de servidor na máquina e abrir a página no navegador mesmo sem estar conectado à internet.

A parte de configuração das ferramentas citadas é de extrema importância, pois garante a exibição correta do conteúdo programado. Para quem nunca realizou a tarefa de instalação dos aplicativos, ter um guia mostrando todos os passos por perto é uma ótima ideia.

Se você digitar no Google os termos “instalar apache php mysql windows”, certamente vai encontrar diversos fóruns e tutoriais mostrando todo o processo de forma detalhada. Além disso, existem alguns pacotes que facilitam bastante a tarefa de instalação, pois oferecem todos os recursos necessários para rodar sua página localmente em uma só aplicação. Confira abaixo algumas dessas ferramentas.

• XAMPP

• EasyPHP

• PHP Triad

• WampServer

Escolhendo um bom editor

Outra ferramenta indispensável para um programador é o editor ou IDE utilizado na hora de mexer no código. Uma ferramenta não precisa ter dezenas de funcionalidades para ser boa, executando as funções básicas de forma satisfatória pode ser o suficiente.

Cada programador possui a sua ferramenta preferida. Tenha em mente que funcionalidades como autocompletar e destaque de sintaxe não são obrigatórias, mas ajudam muito na hora de programar, principalmente se você está começando e não lembra muito bem os comandos de cabeça. Boas opções de editor para PHP (e outras linguagens também) são:

• PHP Editor

• PHP Anywhere

• Bluefish

• Eclipse PDT

• Notepad++

Agora sim, programar!

Se você decidiu criar um site em PHP, mas não tem ideia de como começar a programar, uma boa ideia é entender melhor alguns conceitos de programação, saber bem como funciona a linguagem PHP e procurar alguns tutoriais bem básicos na internet.

Apesar de já instalado e configurado o Apache, PHP e MySQL, entender a utilidade de cada um desses itens pode ser de grande ajuda, pois, caso haja algum problema no futuro, fica mais fácil diagnosticar o que o está causando.

O Curso de PHP em Vídeo Aulas, disponível para download no Baixaki, pode ser uma ótima forma de estudar alguns conceitos e aprender na prática os passos básicos para programar em PHP. No siteApostilando.com também é possível encontrar diversas apostilas gratuitas que explicam muito bem os conceitos para quem deseja embarcar nesse mundo do desenvolvimento de sites.

Há também o portal PHP.net. Além de explicar bem o que é o PHP (não a linguagem), você encontra diversos tutoriais ensinando a instalar e configurar o serviço no seu computador.

Outro serviço que certamente é muito útil para os programadores web é o w3schools.com. Nele, você encontra tutoriais, exemplos e explicações detalhadas de utilização para quase todos os comandos utilizados nas linguagens de desenvolvimento mais comuns para a internet. O conteúdo encontra-se apenas em inglês.

Apesar de ter um nome um tanto peculiar, o Dummies.com é um bom lugar para encontrar informações básicas a respeito de programação e desenvolvimento com PHP. Infelizmente, o site não possui tradução para o português, mas não é preciso dominar muito o inglês para compreender os textos disponíveis.

Não há muitos segredos para desenvolver um site em PHP, mas é preciso ter um pouco de paciência no começo e insistir. Se você não entender algum conceito ou termo presente nas apostilas, livros ou portais, procure os fóruns de programadores e não tenha vergonha de perguntar.

Como fazer o root em celulares android

Aviso aos navegantes!

Antes de mais nada, os procedimentos citados aqui são única e exclusivamente de sua responsabilidade, portanto,não me responsabilizo por qualquer dano ou prejuízo derivado dos procedimentos adotados aqui.

Apesar do procedimento não apresentar qualquer risco, assim como citado em outra matéria link, alguns fabricantes podem invalidar a garantia do aparelho. Tenha certeza da escolha de proceder levando em consideração as questões acima.

Ingredientes

Os passos para realizar os procedimentos requer que o sistema operacional esteja reconhecendo o celular plenamente, ou seja, com os drivers instalados. Isso é feito quando se instala o software de gerenciamento incluso junto do aparelho, ou pode ser baixado no site do fabricante. Cada fabricante tem o seu conjunto de software correspondente ao aparelho e, por isso, é diferente em cada caso.

Com os drivers devidamente instalados, desative o antivírus de seu computador antes de prosseguir. De preferência, e para garantir alguma segurança, desconecte o cabo de rede para o computador não ficar conectado na internet e desprotegido.

A necessidade de se desabilitar o antivírus é que o mesmo reconhece alguns exploits presentes no programa para root como vírus. No entanto, não apresentam qualquer perigo para sistemas Windows e nem mesmo para distros Linux cuja versão do kernel seja a mais recente.

No aparelho, habilite a depuração USB nas opções para desenvolvedor. Isso é muito importante para ter êxito na instalação e habilitação do root. Nas versões 2.0 até 2.3, acesse as configurações do Android, acesse Aplicativos>Desenvolvimento e depois marque a caixa Depuração USB. Também por garantia, habilite a opção Fontes desconhecidas, em Aplicativos.

Em configurações, desconecte o cartão SD em Armazenamento>Desconectar cartão SD, só por garantia, ou tenha backup dos dados presentes no cartão em local seguro.

Agora só falta um clique!

No PC, baixe e execute o programa SuperOneClick. O uso é bem simples. Com o programa aberto, conecte o celular via cabo USB no PC. Espere o reconhecimento habitual do windows. Desative ou feche o programa de gerenciamento do fabricante do seu celular.

No programa SuperOneClick, clique no botão Root e espere o processo terminar. Pode demorar de cinco a dez minutos, e o celular irá reiniciar. Qualquer aviso durante o processo, basta concordar em Yes. Se o processo terminar sem o reinício do aparelho, desconecte o cabo USB, e reinicie manualmente.

Pronto. Entrando na lista de aplicativos do Android, um ícone de um aplicativo com o mascote do Android com tapa-olho vai estar lá. É o app Superuser. Esse é o aplicativo responsável por gerenciar quem tem ou não acesso aos recursos de super-usuário ou root.

Após a instalação do root, a primeira coisa a se fazer é abrir o aplicativo do Google Play e verificar se o aplicativo de Superuser possui atualização, Faça se tiver. Depois, abra o aplicativo, vá em configurações e atualize o binário “su”.

O processo é feito pelo aplicativo, e será pedido confirmação para o próprio app! Autorize e espere o processo terminar. Desse momento, seu Android Froyo (versão 2.0 a 2.2) e Gingerbread (2.3.x) estará rootado.

As vantagens e desvantagens de conseguir root no sistema

Um leque de novas possibilidades

A grande dúvida para os usuários que ouvem falar no tal “root do Android” é entender porque conseguir isso é importante. Sabe-se que há muitos aplicativos na Google Play, que requerem o root no sistema tanto para funcionarem, como para funções extras. O fato desses aplicativos precisarem de root não tem a ver com capricho do desenvolvedor, ou para “limitar” os usuários que podem ou não usar o aplicativo.

Como dito acima, a Dalvik responsável por construir a interface de aplicativos e permitir acessos a certas funções físicas do aparelho também respeita as permissões Linux, e por questões óbvias de segurança. Basicamente, a Dalvik gerencia o que um aplicativo pode ou não fazer, dado as limitações impostas para o funcionamento do sistema.

Em suma, o aplicativo não “conversa” com o Linux, mas sim com a Dalvik que repassa o necessário ao Linux para ativar alguma função de algum hardware do aparelho. Mas os aplicativos que necessitam de root no aparelho possuem funções extendidas que não podem ser satisfeitas pela máquina Dalvik, de modo que é necessário fazer as requisições diretamente ao Linux.

Normalmente são comandos simples, como a criação de um arquivo em um diretório do sistema, ou modificação de uma configuração padrão do kernel Linux. A vantagem como um todo não é só fazer uso desses aplicativos. A vantagem está em usar toda a flexibilidade que é pertinente ao Linux, conseguindo maior controle sobre o seu dispositivo e seu comportamento. Os aplicativos só são facilitadores.

Um exemplo que posso citar é o uso de firewall. Isso mesmo, firewall! É possível ativar o filtro Iptables presente por padrão no kernel Linux para bloquear ou restringir o uso de interfaces para aplicativos. No caso do Android, e diferentemente do que ocorre no desktop, o filtro só faz sentido ao bloquear conexões de saída, quer seja WiFi, 3G ou rede de telefonia sem fio, usado por aplicativos maliciosos para envio de SMS para contas premium sem que você saiba.

Existem inúmeros aplicativos destinados a essa função na loja do Google. No entanto esses aplicativos não fazem a filtragem, eles apenas criam as regras e executam, cabendo ao próprio recurso no kernel Linux fazer a filtragem com a ferramenta que já está embutida no sistema e que usuários de Linux para desktop já conhecem bem.

Com o Android rootado ou rooteado (dos dois jeitos está certo), você pode mudar aspectos de configurações impostas pelo fabricante, como aumentar o clock do processador, atribuir um esquema diferente de gerenciamento de memória, modificar arquivos de configuração internas que alteram o comportamento do Android, fazer cópias de segurança de configurações dos aplicativos e restaurá-las posteriomente são só alguns exemplos.

Mas tudo claro, depende de certos aspectos de configuração do kernel imposto pelo fabricante. Muitos fabricantes compilam o kernel excluíndo essas características por, talvez, acharem desnecessário. A grande vantagem de se ter root, é a possibilidade de instalar ferramentas que permitam mudar o kernel por um "mais completo" que o comumente usado no Android e mais próximo ou praticamente o kernel usado em desktops.

Desvantagem é o descuido!

A desvantagem de se ter o root tem mais a ver com o usuário descuidado que pode apagar ou modificar coisas que não deve e simplesmente estragar o sistema, fazendo-o não funcionar direito ou pior, sequer ligar novamente. Outra possibilidade seriam aplicativos maliciosos instalarem rootkits ou abrir brechas propositais quando instalados e executados pelo usuário desatento, quebrando por fim qualquer segurança do sistema.

Afinal, o aplicativo está com plenos poderes, podendo fazer tudo que fora programado dentro do sistema. Por esse motivo, o Android sai de “fábrica” totalmente bloqueado, sem acesso root. Inclusive alguns fabricantes incluem cláusulas que invalidam a garantia do aparelho em caso de aplicação do processo root.