Criar e usar um servidor SVN

Colaboração: Andre Murbach Maidl

Subversion é um software muito usado para controle de versões de sistemas. Muitas vezes desenvolvemos um projeto e precisamos ter um bom controle do seu versionamento, nesse caso o svn é uma ferramenta muito interessante.

Nesse documento estão descritas algumas maneiras de configurar um servidor svn e alguns comandos úteis para usá-lo.

Os pacotes necessários para a instalação e configuração são os seguintes:

• httpd ou apache ou apache2 (depende da distribuição)
• subversion
• mod_dav_svn ou subversion-server ou libapache2-svn (depende da distribuição)

Partiremos do princípio que os pacotes necessários já estão instalados na máquina que será o servidor svn.

Criar um repositório svn no servidor

Nos passos abaixo usaremos um repositório chamado /svn, mas se desejar criá-lo em /home/usuario/svn, ou em qualquer outro local desejado, basta trocar /svn pelo qual será usado em seu servidor.

Antes de criar o repositório precisamos ter o diretório correspondente no sistema, por isso, use o comando abaixo para criá-lo:

  # mkdir /svn

Agora vamos executar o comando necessário para criar o repositório /svn, vale lembrar que o comando abaixo deve ser executado em um diretório vazio, porém, já existente no sistema, pois o subversion irá apenas criar toda a estrutura necessária para o controle de versões, então execute o comando abaixo para tal procedimento:

  # svnadmin create /svn

Vale uma observação aqui, até a versão 1.1 do subversion, o tipo de repositório padrão era o Berkeley DB, mas a partir da versão 1.2 o padrão passou a ser o FSFS. O suporte FSFS apareceu na versão 1.1. Na 1.0 apenas o Berkeley DB era suportado.

Para especificar o tipo do repositório pode-se usar o argumento --fs-type:

  # svnadmin create --fs-type fsfs /svn
 # svnadmin create --fs-type bdb /svn

O repositório criado estará vazio e começará a contar a partir da revisão 0 (zero), a qual corresponderá à sua criação.

Para mais informações sobre o tipo do repositório acesse http://svnbook.red-bean.com/nightly/en/svn.reposadmin.html

Configurar o apache

O apache é usado porque além de ser o servidor http mais usual, através do módulo mod_dav_svn.so ele consegue acessar um repositório svn e torná-lo acessível para clientes que usam o protocolo WebDAV/DeltaV, (é o caso do comando svn, o qual veremos ainda neste documento), ele é uma extensão do protocolo HTTP.

Onde o arquivo de configuração, do subversion, é armazenado pode variar de distribuição para distribuição. Por exemplo, ele pode estar tanto em /etc/httpd/conf.d/subversion.conf, como em /etc/apache/conf/conf.d/subversion.conf, ou até mesmo em outro diretório.

Muitas vezes é possível localiza-lo através do comando locate:

  # locate subversion.conf

Por isso, neste documento, trataremos o arquivo de configuração apenas por: subversion.conf.

Vamos abordar duas formas de configuração, são elas:

• acesso irrestrito para leitura e escrita (sem senha)
• acesso irrestrito para leitura e acesso restrito para escrita (com senha)

Antes de tudo faça um backup do arquivo de configuração original:

  # cp subversion.conf subversion.conf.orig

Ajustar o dono do svn

Como vamos configurar o apache para o gerenciamento do repositório, é importante configurarmos o seu dono, pois estaremos lendo e escrevendo no svn através do protocolo HTTP.

Mude o dono do diretório /svn de root para apache:

  # chown -R apache.apache /svn

Essa modificação é necessária para que o svn fique acessível via http. Caso o usuário root continuasse como dono do diretório e dos demais arquivos, o apache não teria permissões para acessá-los. Em algumas distribuições o usuário chama-se www ao invés de apache, verifique o nome do usuário do apache antes de executar esse comando.

Acesso irrestrito para leitura e escrita

Abaixo segue um exemplo de configuração do arquivo subversion.conf para o acesso sem senha. Use-o caso deseje configurar um servidor svn sem senha.

  # inicio do arquivo subversion.conf

 LoadModule dav_svn_module     modules/mod_dav_svn.so
 LoadModule authz_svn_module   modules/mod_authz_svn.so

 
 DAV svn
 SVNPath /svn
 # desliga senha
 SVNPathAuthz off
 

 # fim do arquivo subversion.conf

Acesso irrestrito para leitura e acesso restrito para escrita

Abaixo segue um exemplo de configuração do arquivo subversion.conf para o acesso com senha. Use-o caso deseje configurar um servidor svn com senha para escrita.

  # inicio do arquivo subversion.conf

 LoadModule dav_svn_module     modules/mod_dav_svn.so
 LoadModule authz_svn_module   modules/mod_authz_svn.so

 
 DAV svn
 SVNPath /svn
 # autenticando um usuario
 AuthType Basic
 AuthName "Subversion repository"
 AuthUserFile /etc/svn-passwd
 # qualquer operacao que nao seja leitura requer um usuario valido
 
 Require valid-user
 
 

 # fim do arquivo subversion.conf

Mais informações sobre como configurar o arquivo subversion.conf

Criar o arquivo de senha

Se o svn foi configurado com senha, como em um dos exemplos acima, será necessário criar o arquivo /etc/svn-passwd, ou o correspondente da sua configuração, onde serão armazenados os usuários, os quais terão acesso de escrita no repositório /svn e suas respectivas senhas.

Ele pode ser criado por meio do seguinte comando:

  # htpasswd -c /etc/svn-passwd root

O comando acima cria o arquivo /etc/svn-passwd e pede que a senha do usuário root seja informada.

Para adicionar um novo usuário pode-se usar o comando abaixo:

  # htpasswd /etc/svn-passwd andre

O usuário digita a senha e o arquivo é automaticamente atualizado. Ou o usuário executa o seguinte comando:

  # htpasswd -n andre

Envia o resultado do comando para o administrador do svn e ele inclui o usuário e a sua respectiva senha no arquivo correspondente.

Iniciar/Reiniciar o apache

Para efetivar as configurações e tornar o svn acessível através da url: http://nome_do_servidor/svn, precisamos iniciar o apache caso ele esteja parado ou reiniciá-lo, se ele já estiver sendo executado na máquina.

O comando abaixo reinicia o apache estando ele ligado ou desligado:

  # service httpd stop && service httpd start

Observe que o comando pode ser diferente dependendo da distribuição que estiver sendo usada, ou seja, ao invés de httpd pode ser apache ou até mesmo apache2.

Agora o seu repositório svn já pode ser acessado, usando um navegador qualquer, através do link:

http://servidor/svn

Se o servidor svn foi configurado em sua rede, em casa, e não há nenhum dns configurado, para responder pelos nomes das máquinas, pode-se usar apenas o ip do servidor:

http://ip_do_servidor/svn

Alguns comandos úteis para manusear projetos no svn configurado

Após criarmos um repositório svn é interessante conhecermos alguns comandos que possibilitam o manuseio desta ferramenta.

Se uma das variáveis de ambiente $SVN_EDITOR, $VISUAL ou $EDITOR não estiverem definidas, provavelmente uma mensagem de erro, semelhante a que segue abaixo, será exibida ao tentar efetuar uma alteração no svn.

svn: Could not use external editor to fetch log message; consider setting the $SVN_EDITOR environment variable or using the --message (-m) or --file (-F) options svn: None of the environment variables SVN_EDITOR, VISUAL or EDITOR is set, and no 'editor-cmd' run-time configuration option was found

Para definir o editor de texto padrão, o qual será usado para escrever os logs dos commits, pode-se usar a seguinte linha de comando:

  # export SVN_EDITOR='vim'

Acima definimos que o editor padrão será o vim.

Para que todos os usuários tenham essa variável configurada, basta adicionar a linha de comando acima no arquivo /etc/profile.

Criar um diretório no svn

Antes de adicionarmos um projeto em nosso repositório precisamos criar o diretório onde ele ficará armazenado. Pode-se fazer isso através do seguinte comando:

  # svn mkdir http://servidor/svn/projeto

Importar um projeto para o svn

Algumas vezes já temos um projeto em algum canto de nossa máquina; Importe-o para o svn usando a linha de comando abaixo:

  # svn import /tmp/projeto http://servidor/svn/projeto

O comando acima importará todos os arquivos do diretório /tmp/projeto para o repositório projeto em http://servidor/svn/

Uma outra maneira de executar o procedimento acima é acessar o diretório e então importá-lo para o svn:

  # cd /tmp/projeto
 # svn import http://servidor/svn/projeto

Baixar um projeto do svn

Quando for preciso efetuar modificações em um projeto que já está no svn, antes é preciso fazer o checkout, ou seja, efetuar o download dos arquivos correspondentes ao projeto.

Efetuando o checkout:

  # svn co http://servidor/svn/projeto

Efetivar alterações em um projeto do svn

Depois de concluídas as modificações necessárias precisamos colocar a nova revisão do projeto no svn, para isso precisamos efetuar um commit.

De dentro do diretório principal do projeto efetue o commit:

  # svn commit

Listar arquivos de um projeto

Depois de efetuar várias mudanças em um projeto baixado do svn, é importante poder listar o seu conteúdo e saber quais arquivos estão armazenados e quais não estão no seu respectivo repositório no svn.

Para isso, execute o seguinte comando no diretório principal do projeto:

  # svn list

Adicionar arquivos a um projeto

No decorrer de um projeto novos arquivos surgem e precisam ser adicionados no repositório svn.

Para efetuar essa operação pode-se usar o seguinte comando:

  # svn add projeto.c

Quando o commit for efetuado, o arquivo projeto.c será adicionado à árvore correspondente do projeto em que estava trabalhando.

Remover arquivos de um projeto

A medida que arquivos vão sendo incluso no projetos, há a necessidade de excluir alguns.

Use o seguinte comando para efetuar tal operação:

  # svn rm projeto.c

É possível remover um projeto inteiro do svn, para isto basta executar:

  svn rm http://servidor/svn/projeto

Quando o commit for efetuado, o arquivo projeto.c será removido da árvore onde ele era armazenado e na nova revisão ele não fará mais parte do projeto.

Verificar as alterações antes de efetuar um commit

Na maioria das vezes é interessante, antes de efetuar o commit, verificar quais são as modificações. Para isso usamos o svn diff. Porém, se existirem muitas modificações, é preciso jogar a saída do comando para um editor de texto, sendo assim possível analisar todo o diff gerado.

Executando apenas o svn diff:

  svn diff

Jogando a saída para um editor de texto, no caso o vim:

  svn diff | vim -

Lembrando que o comando acima mostra as diferenças do diretório onde foi executado e o seu correspondente no svn. Para verificar todas as modificações de um projeto, basta executá-lo na raiz principal dele.

Verificar o log de um projeto Muitas vezes esquecemos o que fizemos, por isso, ao efetuar um commit o svn sempre pede uma mesagem para ser adicionada ao log do projeto. Para verificar os logs de um determinado projeto: efetue o checkout dele, acesse o diretório onde ele foi baixado e execute o seguinte comando:

  svn log

==Obter ajuda dos próprios comandos== Para verificar os comandos disponíveis use:

  svn help

Uma série de comandos, possíveis, será listada. Para obter informções sobre um comando em específico use:

  svn comando --help

Configurando o Iptables e Fazendo Regras Básicas

Um sistema bem servido de firewall


Existem firewalls para todos os sistemas operacionais mas creio que nenhum deles esteja tão bem servido quanto o Linux. Sem desmerecer outros mas a solução Iptables ao meu ver é uma das melhores, senão a melhor que eu já vi para segurança de sistemas. A grande vantagem do Iptables é a sua estabilidade, rapidez, eficiência reconhecida e relativa facilidade de administração devido a sua configuração poder ser feita através de scripts. Outras características do Iptables:


.: Suporte aos protocolos TCP, UDP, ICMP
.: Pode se especificar portas de endereço e de destino.
.: Suporta módulos externos como FTP e IRC
.: Suporta um número ilimitado de regras por CHAINS ( correntes ).
.: Pode se criar regras de proteção contra ataques diversos
.: Suporte para roteamento de pacotes e redirecionamento de portas.
.: Suporta vários tipos de NAT, como o SNAT e DNAT e mascaramento.
.: Pode priorizar tráfego para determinados tipos de pacotes.
.: Entre outras o Iptables já tem suporte a IPV6, através do programa ip6tables.

O Iptables acompanha o kernel 2.4.x. Antes dele existia o Ipchains ( kernel 2.2.x ) e anteriormente ainda existia o Ipfwadm. Na realidade no kernel 2.4.x ainda existem os filtros Ipchains e Ipfwadm por motivos de compatibilidade mas ambos não estão ativos. Caso estejam ativos ( isto pode acontecer com o Ipchains ) é necessário desativá-los para que o Iptables possa funcionar plenamente.


Funcionamento


Através de regras poderemos fazer com que os pacotes possam ser ou não recebidos a rede toda, a determinada máquina, interface ou mesmo porta de conexão. O Iptables trabalha através de Tabelas, Chains e Regras:

Tabelas: Existem 3 tabelas possíveis de serem utilizadas no Iptables, sendo que uma delas, a mangle raramente é usada, restando a filter, que é a padrão, utilizada nos tráfegos de dados comuns, sem ocorrência de NAT. Quando não especificamos qual tabela a ser utilizada é ela que será ativada. A outra geralmente utilizada é a nat, que como o próprio nome diz, usada quando há ocorrência de NAT.

Chains: Através delas podemos especificar a situação do tratamento dos pacotes, seja qual tabela for.
Quando utilizamos a tabela nat as Chains possíveis são:

PREROUTING – Quando os pacotes entram para sofrerem NAT.
POSTROUTING – Quando os pacotes estão saindo após sofrerem NAT
OUTPUT – Pacotes que são gerados na própria máquina e que sofrerão NAT

Já com a tabela filter as Chains são:

INPUT - Pacotes cujo destino final é a própria máquina firewall.
OUTPUT – Pacotes que saem da máquina firewall
FORWARD – Pacote que atravessa a máquina firewall, cujo destino é uma outra máquina. Este pacote não sai da máquina firewall e sim de outra máquina da rede ou fonte. Neste caso a máquina firewall está repassando o pacote.

Regras: As regras de firewall geralmente são compostas de uma Tabela, Opção, Chain, Dados e Ação. Através destes elementos podemos especificar o que fazer com os pacotes.

Opções:

-P Define uma regra padrão

-A Acrescenta uma nova regra as existentes.
* Este tem prioridade sobre a -P



-D Apaga-se uma regra




-L Lista as regras existentes




-F Apaga todas as regras




-I Insere uma regra nova




-h Muito útil, pois mostra a ajuda



-R Substitui uma regra




-C Faz uma checagem das regras existentes



-Z Zera uma regra específica



-N Cria uma nova regra com um nome



-X Exclui uma regra específica pelo seu nome




Dados:

-s : Especifica o origem do pacote. Este pode ser tanto uma rede ou host. Possíveis combinações podem ser:

-s 192.168.0.0/255.255.255.0

ou

-s 192.168.0.0/24

OBS: No segundo caso estamos especificando a máscara de rede conforme o número de bits 1, por exemplo:

Máscara de rede 255.0.0.0 = 8
Máscara de rede 255.255.0.0 = 16
Máscara de rede 255.255.255.0 = 24


No exemplo acima estamos especificando toda uma rede de máscara C, no exemplo abaixo especificamos um host:

-s 192.168.30.51/255.255.255.255

ou

-s 192.168.30.51

também pode ser assim:

-s 192.168.30.51/32

OBS: A máscara em números de bits 1 para host é 32.


Podemos especificar assim também:

-s www tccamargo.com


Podemos especificar qualquer origem também:

-s 0.0.0.0/0.0.0.0

ou

-s 0/0


-d : Especifica o destino do pacote. A sintaxe é a mesma do -s


-p : Protocolo usado na regra. Pode ser tcp, udp, icmp:

-p tcp
-p udp
-p icmp


-i : Interface de entrada, ou seja, placa de rede, modem ou interface de conexão que estará recebendo o pacote a ser tratado.

-i eth0
-i eth1
-i ppp0


-o : Interface de saída. As sintaxes são as mesmas que -i, sendo que neste caso estará enviando o pacote a ser tratado.


! : Exclui determinado argumento:

-i ! eth0 - Refere-se a qualquer interface de entrada exceto a eth0
-s ! 192.168.0.45 – Refere-se a qualquer endereço de entrada exceto o 192.168.0.45


--sport : Refere-se a porta de origem. Este deve vir acompanhado das funções -p tcp e -p udp :

-p tcp –sport 80 – Refere-se a porta de origem 80 sob protocolo tcp


--dport : Refere-se a porta de destino. Assim como a função –sport, ela trabalha somente com a -p tcp e -p udp. A sintaxe é similar a –sport


Através das funções –sport e –dport podemos especificar não só uma porta específica como também um range de portas:

--sport 33435:33525


Ações:

As ações sempre vem após o parâmetro -j e geralmente são:

ACCEPT – Aceita e permite a passagem do pacote.
DROP – Não permite a passagem do pacote e abandona-o não dando sinais de recebimento.
REJECT – Assim como o DROP, não permite a passagem do pacote, mas envia um aviso ( icmp unreachable )
LOG – Cria um Log referente a regra em /var/log/messages


Com estes fatores podemos criar as nossas regras com a seguinte composição:

# iptables -A FORWARD -s 192.168.0.45 -p icmp -j DROP
Sendo: -A ( opção ) / FORWARD ( Chain ) / -s 192.168.0.45 -p icmp ( Dados ) -j DROP ( Ação )


No caso do exemplo a cima a regra determina que todos os pacotes icmp originários do endereço 192.168.0.45 devem ser barrados.


Salvando as regras


Depois das regras prontas podemos salvá-las com este comando:

# iptables-save >


Para recuperá-las use este comando:

# iptables-restore >


Outra forma seria fazer um script com as regras:

Corpo do Script

#!/bin/bash

#limpando tabelas
iptables -F &&
iptables -X &&
iptables -t nat -F &&
iptables -t nat -X &&

#liberando acesso interno da rede
iptables -A INPUT -p tcp --syn -s 192.168.1.0/255.255.255.0 -j ACCEPT &&
iptables -A OUTPUT -p tcp --syn -s 192.168.1.0/255.255.255.0 -j ACCEPT &&
iptables -A FORWARD -p tcp --syn -s 192.168.1.0/255.255.255.0 -j ACCEPT &&

#compartilhando a web na rede interna
iptables -t nat -A POSTROUTING -s 192.168.1.0/255.255.255.0 -o eth1 -j MASQUERADE &&
echo 1 > /proc/sys/net/ipv4/ip_forward &&

# Protecao contra port scanners ocultos
iptables -A INPUT -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s -j ACCEPT

# Bloqueando tracertroute
iptables -A INPUT -p udp -s 0/0 -i eth1 --dport 33435:33525 -j DROP

#Protecoes contra ataques
iptables -A INPUT -m state --state INVALID -j DROP

#termina
echo "Iptables Pronto"


Salve-o com um nome sugestivo, como por exemplo “start-firewall”.

Dê permissão de execução:

chmod +x start-firewall


Pronto. Toda vez que quiser que ele seja habilitado é só executá-lo ( sempre como root ):

# start-firewall


Para não ter que ficar chamando o script toda vez que inicializar o sistema, podemos fazer com que ele seja ativado na inicialização. Para isso é preciso editar o arquivo

/etc/rc.d/rc.local e incluir o comando no final do arquivo.:-)



Compartilhamento de conexão, mascaramento e redirecionamento de pacotes


Verifique que nestas linhas do script exemplo:

iptables -t nat -A POSTROUTING -s 192.168.1.0/255.255.255.0 -o eth1 -j MASQUERADE &&
echo 1 > /proc/sys/net/ipv4/ip_forward &&


Estou fazendo com que os micros de minha rede possam utilizar a internet através do roteamento dinâmico. A linha que habilita o redirecionamento de pacotes é essa:

echo 1 > /proc/sys/net/ipv4/ip_forward

Mas vale observar que se inserirmos somente esta linha no script, a cada vez que reiniciar o sistema será necessária a ativação do roteamento. Para que não percamos o roteamento é necessário editar o arquivo /etc/sysctl.conf e inserirmos ou modificarmos a linha do modo que fique assim:

net.ipv4.ip_forward= 1


Voltando a nossa regra do script exemplo, verificamos uma ação nova ( MASQUERADE ), servindo para que as máquinas da rede interna possam acessar a internet usando o IP externo do Gateway. Deste modo as máquinas da rede interna ficarão invisíveis para a rede externa. Para que uma máquina da rede interna possa executar serviços onde cuja execução necessita que o IP da máquina seja visível para redes externas, será necessário fazer um redirecionamento de IPs ou portas.

Digamos que uma máquina de IP 192.168.0.45 precise executar um serviço de FTP, na qual é necessária a visibilidade da máquina. Podemos fazer com que a máquina firewall, cujo IP externo seja 200.135.100.102 receba estes pacotes e retransmita:

iptables -t nat -A PREROUTING -s 200.135.100.102 -i eth0 -j DNAT –to 192.168.0.45
iptables -t nat -A POSTROUTING -s 200.135.100.102 -o eth0 -p tcp –dport 21 -j ACCEPT
iptables -t nat -A POSTROUTING -s 192.168.0.45 -o eth0 -j SNAT –to 200.135.100.102
iptables -t nat -A POSTROUTING -s 192.168.0.45 -o eth0 -p tcp –dport 21 -j ACCEPT


Veja que nestas regras temos mais duas ações novas SNAT e DNAT:

SNAT – Aplicada quando queremos alterar o endereço de origem do pacote. Aqui nós utilizamos para fazer o mascaramento. OBS: Somente a Chain POSTROUTING pode ser usada na ação SNAT.
DNAT – Aplicada quando desejamos alterar o endereço de destino do pacote. Esta ação é utilizada para fazer redirecionamento de portas, redirecionamento de servidor, load balance e proxy transparente. As Chains que podem ser utilizadas para esta ação são PREROUTING e OUTPUT.

Além destas duas ações, existe também a REDIRECT que pode ser utilizada para fazer redirecionamento de portas. Quando fazemos um redirecionamento de portas usamos o dado –to-port após a ação REDIRECT:

iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT –to-port 3128

#Esta regra faz com que todos os pacotes direcionados a porta tcp 80 sejam redirecionados para a porta 3128.

Quando utilizamos a tabela nat, é preciso inserir o parâmetro -t para especificar a tabela:

-t nat

Perceba que quando omitimos este parâmetro usamos a tabela filter por padrão.
Além destas ações, veja que existe também um dado novo:

--to : Este dado serve para definir o IP ou porta de destino numa ação SNAT ou DNAT:

iptables -t nat -A PREROUTING -p tcp -d 200.135.100.102 –dport 80 -j DNAT –to 192.168.0.45

# Esta regra faz com que os pacotes direcionados a porta tcp 80 sejam redirecionados para a máquina 192.168.0.45 . Como não especificamos a porta, a máquina de destino receberá o pacote na porta 80

Além do IP podemos definir a porta deste endereço na ação:

iptables -t nat -A PREROUTING -p tcp -d 200.135.100.102 –dport 80 -j DNAT –to 192.168.0.45:3128

# Aqui, assim como na regra anterior, os pacotes são redirecionados para a máquina 192.168.0.45 mas neste caso especificamos a porta, ou seja, porta 3128


Algumas opções e observações


Vale fazer umas pequenas observações a respeito da ordem das regras e manejo. Uma delas é que a a primeira regra tem prioridade sobre a segunda caso ambas estejam em conflito, veja:

iptables -A FORWARD -p tcp --syn -s 192.168.1.0/24 -j ACCEPT
iptables -A FORWARD -p tcp --syn -s 192.168.1.0/24 -j DROP


A que terá valia será a primeira, ou seja:
iptables -A FORWARD -p tcp --syn -s 192.168.1.0/24 -j ACCEPT


Podemos ver todas as regras em andamento ao darmos o comando:

iptables -L


Com os comandos abaixo limpamos todas as tabelas e regras:

iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X


Para que tudo possa funcionar a contento é necessário primeiramente que todos os módulos necessários estejam carregados:

modprobe ip_conntrack
modprobe ip_conntrack_ftp
modprobe ip_nat_ftp
modprobe ip_queue
modprobe ip_tables
modprobe ipt_LOG
modprobe ipt_MARK
modprobe ipt_MASQUERADE
modprobe ipt_MIRROR
modprobe ipt_REDIRECT
modprobe ipt_REJECT
modprobe ipt_TCPMSS
modprobe ipt_TOS
modprobe ipt_limit
modprobe ipt_mac
modprobe ipt_mark
modprobe ipt_multiport
modprobe ipt_owner
modprobe ipt_state
modprobe ipt_tcpmss
modprobe ipt_tos
modprobe ipt_unclean
modprobe iptable_filter
modprobe iptable_mangle
modprobe iptable_nat


É importante ressaltar que as regras devem seguir uma ordem definida, ou seja, a regra posterior deve estar de acordo com a regra anterior para que tudo corra sem problemas.:

iptables -P FORWARD -j DROP
iptables -A FORMARD -s 192.168.0.0/24 -d 10.0.0.0/8 -j ACCEPT


Através desta regra, determinamos que todo o repasse de pacotes seja bloqueado, depois permitimos que possa repassar pacotes da rede 192.168.0.0 para a rede 10.0.0.0 mas esta não poderá retornar os pacotes. Então o correto seria inserir mais uma regra aqui:

iptables -A FORWARD -d 192.168.0.0/24 -s 10.0.0.0/8 -j ACCEPT


Para que a rede 10.0.0.0 possa repassar os pacotes, fazendo deste jeito com que as redes possam conversar sem problemas.

Ao fazer as regras lembre-se de primeiro bloquear, depois abrir o acesso.:

iptables -P FORMARD -j DROP
iptables -A FORWARD -s 192.168.0.45 -p tcp –sport 80 -j ACCEPT


Considerações finais


Iptables tem infinitas possibilidades de regras. É impossível citar todos os parâmetros e regras que podem ser utilizados, pois daria uma verdadeira bíblia. Cabe ao bom administrador estudar com afinco para poder aplicar as regras mais convenientes para a sua rede. E o usuário final tem em mãos um excelente recurso para deixar sua máquina protegida de ataques externos. Esta é a grande vantagem do Iptables, pode se aplicar regras conforme a conveniência da rede e usuários. Sem dúvida nenhuma é uma ferramenta poderosíssima.



Exemplos de regras comumente utilizadas


Nas linhas abaixo incluí algumas regras que são comumente utilizadas. Algumas destas podem ser úteis para fazer o seu firewall mas lembre-se de adaptá-las para sua rede/interface/máquina antes de aplicá-las:


#Libera o apache pra web
iptables -A INPUT -p tcp --destination-port 6080 -j ACCEPT
iptables -A INPUT -p tcp --destination-port 443 -j ACCEPT

#Libera o loopback
iptables -A OUTPUT -p tcp --syn -s 127.0.0.1/255.0.0.0 -j ACCEPT

#Bloqueando todos os endereços vindo de uma determinada rede para a minha máquina
iptables -A INPUT -s 10.0.0.0/8 -j DROP

#Liberando o endereço vindo de uma rede para a minha máquina
iptables -A INPUT -s 10.0.0.1 -j ACCEPT

#Gerando Logs de Portas proibidas
iptables -A INPUT -p tcp --dport 21 -j --log-prefix "Serviço de FTP"

#Gerando log de Backdoors
iptables -A INPUT -p tcp --dport 5042 -j LOG -log-prefix "Wincrash"
iptables -A INPUT -p tcp --dport 12345 -j LOG -log-prefix "backOrifice"
iptables -A INPUT -p tcp --dport 12346 -j LOG -log-prefix "backOrifice"

#Habilitando porta de FTP
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 21 -j ACCEPT

#Habilitando porta de SSH
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 22 -j ACCEPT

#Habilitando porta de SMTP
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 25 -j ACCEPT

#Habilitando porta de DNS
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 53 -j ACCEPT

#Habilitando porta de POP3
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 110 -j ACCEPT

#Habilitando porta de DNS (UDP)
iptables -A INPUT -p udp -s 192.168.0.45 --source-port 53 -j ACCEPT

#Redirecionar Porta
iptables -t nat -A PREROUTING -s IP_NET -i EXT_INT -j DNAT --to IP_DESTINO
iptables -t nat -A POSTROUTING -s IP_NET -o EXT_INT -p tcp --dport PORT -j ACCEPT
iptables -t nat -A POSTROUTING -s IP_DESTINO -o EXT_INT -j SNAT --to IP_NET
iptables -t nat -A POSTROUTING -s IP_DESTINO -o EXT_INT --p tcp --dport PORT -j ACCEPT

IP_NET = IP válido da internet.
EXT_INT = Interface da Internet.
IP_DESTINO = IP inválido da Internet ou melhor ip da rede que vai fazer redirecionamento.
PORT = porta

#Fazendo redirecionamento de portas
iptables -t nat -A PREROUTING -i FACE -p tcp --dport 80 -j REDIRECT --to-port 3128

FACE = interface de rede

#Bloqueando todos os pacotes originários da rede 10.0.0.0 para o host www.tccamargo.com
iptables -A FORWARD -s 10.0.0.0/8 -d www.tccamargo.com -j DROP

#Liberando todos os pacotes originários da rede 10.0.0.0 para o host www.tccamargo.com
iptables -A FORWARD -s 10.0.0.0/8 -d www.tccamargo.com -j ACCEPT

#Liberando todos os pacotes tcp destinados a porta 25
iptables -A FORWARD -p tcp --dport 25 -j ACCEPT

#Liberando acesso interno da rede
iptables -A INPUT -p tcp --syn -s 192.168.1.0/24 -j ACCEPT
iptables -A OUTPUT -p tcp --syn -s 192.168.1.0/24 -j ACCEPT
iptables -A FORWARD -p tcp --syn -s 192.168.1.0/24 -j ACCEPT

#compartilhando a web na rede interna
iptables -t nat -A POSTROUTING -s 192.168.1.0/255.255.255.0 -o eth1 -j MASQUERADE
echo 1 > /proc/sys/net/ipv4/ip_forward &&

#Libera Bittorrent somente para esta maquina
iptables -A INPUT -p tcp --destination-port 6881:6889 -j ACCEPT

#Bloqueando tracertroute
iptables -A INPUT -p udp -s 0/0 -i eth1 --dport 33435:33525 -j DROP

#Protecoes contra ataques
iptables -A INPUT -m state --state INVALID -j DROP

#Bloqueando uma máquina pelo endereço MAC
iptables -A INPUT -m mac --mac-source XX:XX:XX:XX:XX:XX -j DROP

#Proteção contra IP Spoofing
iptables -A INPUT -s 172.16.0.0/16 -i ext_face -j DROP
iptables -A INPUT -s 192.168.0.0/24 -i ext_face -j DROP
iptables -A INPUT -s 192.168.0.0/24 -i ext_face -j DROP

< ext_face =" São">

#Proteção contra Syn-floods
iptables -A FORWARD -p tcp --syn -m limit --limit 1/s -j ACCEPT

#Proteção contra port scanners ocultos
iptables -A FORWARD -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s -j ACCEPT

#Proteção contra ping da morte
iptables -A FORWARD -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT

#Bloqueando ping de um ip
iptables -A INPUT -p icmp -s 192.168.1.1/24 -j DROP

#Bloqueando pacotes fragmentados
iptables -A INPUT -i INTEXT -m unclean -j log_unclean
iptables -A INPUT -f -i INTEXT -j log_fragment

< intext =" Interface">

#Anulando as respostas a ICMP 8 (echo reply)
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all

Configurando Samba no FreeBSD

Enviado por DarkWarrior em Qua, 2007-01-17 14:26.

Autor: João Dantas
eMail: presley[NOSPAM]linuxbsd.com.br>
Data: 2003

Neste artigo, estaremos configurando o Software SAMBA para compartilhamento de serviços e arquivos em um Sistema FreeBSD 4.7, o mesmo deverá funcionar com versões não muito anteriores ou posteriores. Se você não tem o samba instalado no seu FreeBSD, você pode instalá-los de duas formas: pelos ports ou via CD de instalação do Sistema. Existe também a opção de compilar os fontes, baixando os pacotes do http://www.samba.org, mas não enfatizaremos esta opção, levando em consideração a praticidade de instala-los via ports ou via CD.

Passos para instalar via CD

- Primeiramente monte o CD:
# mount –t cd 9660 /dev/acd0c /cdrom
depois, navegue pelo caminho onde estao os arquivos do samba, no meu caso o caminho foi:
# cd /cdrom/packages/net/samba-xxx.xxx.xxx
Para instalá-lo, use o comando de instalação do FreeBSD:
# pkg_add samba-xxx.xxx.xxx

Passos para instalar via ports:

# cd /usr/ports/net/samba
# make
# make install
# make clean
ou melhor
# make && make install && make clean

Pronto, agora é so esperar ele fazer o download do servidor, compilar os pacotes, instalar e limpar os fragmentos, em seguida o seu Samba já vai estar instalado em seu sistema.

Inicializando o SAMBA

Você pode inicializar o samba pelo shell, mas mostraremos como fazê-lo iniciar pelo modo autmotático, no carregamento do sistema.
Localize o script de inicialização do samba com o comando:
# find / -iname samba.sh.sample
Normalmente o samba instala-o em: /usr/local/etc/rc.d/samba.sh.sample.
em seguida renomei ou copie para o diretório de inicialização:
# cp -v /caminho/do/samba.sh.sample /usr/local/etc/rc.d/
vamos ativar agora o script:
# mv samba.sh.sample samba.sh
# chmod 0755 samba.sh
Se quiser iniciar o samba pelo terminal, digite:
# /usr/local/etc/rc.d/samba.sh start
Para parar os serviços, digite:
# /usr/local/etc/rc.d/samba.sh stop
Pronto, agora o samba iniciará normalmente junto com o sistema ou pelo shell.

Criando os usuários samba e usuários FreeBSD

Utilize o comando adduser para criar o usuário:
# adduser usuario [ENTER]

Na primeira opção (Usernames must match regular expression) digite ENTER para colocar as configurações padrão. Apartir dai, continue dando ENTER para aceitar as configurações do sistema. Quando você chegar na opção de (Enter Username), você especificará o nome do usuário, no nosso caso: usuario, em seguida continue dando ENTER até chegar na parte da senha.
Pronto, iremos agora anexar este usuário criado ao samba com o comando smbpasswd:
# smbpasswd -a usuario [ENTER]
ATENÇÃO: A senha tem que ser a mesma do usuário criado com o comando adduser.

Configurando o smb.conf

Edite o arquivo smb.conf em usr/local/etc/smb.conf com o editor de sua preferência. Para configurar o smb.conf (o arquivo de configuração do SAMBA) é necessário estar por dentro de algumas informações, para que você consiga adequar ao seu tipo de rede. Estarei mostrando aqui o básico, para que seu servidor funcione de maneira eficaz. Abaixo estarei listando as principais variáveis do arquivo smb.conf. Deixa-as nesse padrão logo abaixo, para que possamos trabalhar com o servidor SMB (protocolo do samba):

SEÇÃO GLOBALS

# Grupo de trabalhos de sua rede.
workgroup = GRUPO
# O nome de seu host para a rede.
netbios name = MICRO
# Uma descrição do host SAMBA.
Server string = Servidor de arquivos
# Defina como user, afim de compartilhar arquivos e serviços.
Security = user
# Necessário para redes Win9x.
Encrypt password = yes
Local master = yes
Preferred = yes
# Aqui você especifica a sua sub-rede.
Hosts.allow = 192.168.0
# Deixe esta opção por padrão em NO.
Win support = no
# Se você tiver um servidor DNS, coloque o IP dele, caso contrário deixe NO.
Wins server = 192.168.0.1
# Padrão deixar em NO estas opções.
Wins proxy = no
Dns proxy = no

SEÇÃO SHARE

# Nota: O nome compartilha, é o nome da pasta que irá aparecer na rede.
[COMPARTILHA]
# Comentário que aparece na descrição da pasta no acesso a rede Win para o Samba.
comment = Compartilhamento de arquivos
# caminho do compartilhamento.
path = /home/
read only = yes
# Deixe esta opção como NO, afim de que possamos criar os users para acesso, caso contrário, todos terão acesso.
guest ok = no
# Aqui vem o nome do usuário criado que terá acesso a pasta especificada no path.
valid users = usuario
browseable = yes

ACESSANDO A REDE WIN COM O SAMBA

Se tudo deu certo, vamos agora acessar uma maquina Win. Primeiro crie um diretorio na raiz (/):
# mkdir compartilha
para montar o compartilhamento, use os comandos:
- Acessando máquina Windows por IP do host:
# mount_smbfs -I 192.168.0.13 //host_windows98/pasta /compartilha [ENTER]
- Acessando pelo Netbios name da rede Win:
# mount_smbfs -I host_windows98 //host_windows98/pasta /compartilha [ENTER]
Ele vai lhe pedir a senha de acesso, no caso da pasta do host_windows98 tiver senha, digite-a e pronto.
- Se quiser desmontar, use:
# umount //host_windows98/pasta /compartilha

Para acessar nosso servidor SAMBA FreeBSD em maquinas Windows, log com o usuário criado e senhas especificadas.

Espero que esse tutorial possa ajudar os colegas de alguma forma.
Um grande Abraço a Todos!

Talking about the BSD family of free operating systems

http://bsdtalk.blogspot.com/

bsdmall

http://www.bsdmall.com/

FreeBSD Java™ Project

http://www.freebsd.org/java/index.html

Konqueror & Flash HowTo

Prerequisites

You need to be running either FreeBSD 6.1

For KDE versions older than KDE 3.4.0, you also you need to install the konqueror-nsplugins port

Caveat

Note: Sound does not work with wrapped Flash 7. If you require sound, the only option at the time being is installing the linux-firefox port and using the plugin there.

Installing Flash

Since the Flash Player from Macromedia is only distributed in binary form and only for Linux, we need to install a wrapper to make it accessible for Konqueror. Install linuxpluginwrapper and the actual Flash Player linux-flashplugin7 from ports:

cd /usr/ports/www/linuxpluginwrapper && make install clean
cd /usr/ports/www/linux-flashplugin7 && make install clean

Next, edit your /etc/libmap.conf and add the following lines (if it does not exist, create it):

[/usr/local/lib/npapi/linux-flashplugin/libflashplayer.so]
libpthread.so.0                 pluginwrapper/flash6.so
libdl.so.2                      pluginwrapper/flash6.so
libz.so.1                       libz.so
libstdc++-libc6.2-2.so.3        libstdc++.so
libm.so.6                       libm.so
libc.so.6                       pluginwrapper/flash6.so

Setting up Konqueror

In order for Konqueror to find the plugin for the Flash Player, you might have to add an additional search-path to the plugins-section of Konqueror's settings.

• Open Konqueror.
• In the Konqueror menubar, traverse the submenus until you arrive at:
  Settings -> Configure Konqueror -> Plugins
• Check the screenshot below. If you're missing a path that's shown in the screenshot, add it.
• Proceed to the Scan tab.
• Select the Scan for New Plugins button.

Plugins are now searched and if everything worked well, you should see an entry for the Flash-plugin when you switch to the Plugins tab.

The installation is finished.