Administracao de Redes Linux I PDF

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 1
Sumário
Introdução................................................................................................................................................................................4
Introdução às redes locais.................................................................................................................................................4
Introdução ao Linux..........................................................................................................................................................4
Introdução às distribuições...............................................................................................................................................4
A distribuição Debian........................................................................................................................................................5
Requerimento de hardware para cada tipo de aplicação.............................................................................................. 5
Procedimento para instalação.......................................................................................................................................... 6
Conhecendo o sistema Linux..................................................................................................................................................8
Comandos Básicos............................................................................................................................................................. 8
Comandos de sistemas de arquivos............................................................................................................................ 8
Comandos diversos.................................................................................................................................................... 10
Comandos para gerenciamento de usuários............................................................................................................11
Editores de texto.............................................................................................................................................................. 13
Principais arquivos do sistema....................................................................................................................................... 13
Permissões de arquivos................................................................................................................................................... 17
Gerenciamento de Pacotes.............................................................................................................................................. 19
Instalação de aplicativos............................................................................................................................................19
Atualizando sua distribuição.................................................................................................................................... 20
Instalando novos pacotes...........................................................................................................................................20
Removendo pacotes instalados................................................................................................................................. 21
Serviços básicos..................................................................................................................................................................... 22
Servidor dhcp...................................................................................................................................................................22
Conceitos e instalação................................................................................................................................................ 22
Configuração básica e avançada.............................................................................................................................. 22
Servidor de DNS.............................................................................................................................................................. 23
Conceitos e instalação................................................................................................................................................ 23
Configuração avançada............................................................................................................................................. 23
Servidor Proxy(Squid).......................................................................................................................................................... 25
Conceitos.......................................................................................................................................................................... 25
Instalação..........................................................................................................................................................................26
Configuração....................................................................................................................................................................26
Proxy transparente.......................................................................................................................................................... 26
ACLs................................................................................................................................................................................. 26
Exemplo de Configuração...............................................................................................................................................27
Servidor de arquivos(SaMBa)..............................................................................................................................................30
Conceitos.......................................................................................................................................................................... 30
Instalação..........................................................................................................................................................................30
Arquivo de configuração.................................................................................................................................................30
Níveis de segurança......................................................................................................................................................... 31
Configuração de servidor de arquivos simples............................................................................................................. 32
Configuração de máquinas rWindows.......................................................................................................................... 33
Gerenciamento de usuários samba................................................................................................................................ 33
Criando contas confiáveis......................................................................................................................................... 33
Contas de Usuários.................................................................................................................................................... 33
Removendo Usuários................................................................................................................................................. 34
Mudando a senha do usuário.................................................................................................................................... 34
Samba como servidor de autenticação de usuários Windows..................................................................................... 34
Configuração de uma situação real para o SAMBA como PDC........................................................................... 34
Scripts de Logon.........................................................................................................................................................34
Configuração de máquinas rWindows.......................................................................................................................... 37
Usando Linux como firewall................................................................................................................................................ 38
Conceitos.......................................................................................................................................................................... 38
Tipos de firewalls....................................................................................................................................................... 38
O que proteger?......................................................................................................................................................... 38
Introdução........................................................................................................................................................................ 38
Políticas(policiamento) de segurança....................................................................................................................... 39
Regras......................................................................................................................................................................... 39
Chains......................................................................................................................................................................... 40
Tabelas........................................................................................................................................................................ 40

Manipulando Chains....................................................................................................................................................... 40
Adicionando regras....................................................................................................................................................41
Listando regras – L....................................................................................................................................................41
Apagando uma regra – D.......................................................................................................................................... 42
Inserindo uma regra – I.............................................................................................................................................42
Limpando as regras de um chain – F....................................................................................................................... 43
Especificando o policiamento padrão de um chain – P.......................................................................................... 43
Outras opções do iptables..........................................................................................................................................43
Outras formas de identificar pacotes do iptables................................................................................................... 46
Especificando um alvo............................................................................................................................................... 48
NAT...................................................................................................................................................................................50
MASQUERADE.........................................................................................................................................................50
DNAT.......................................................................................................................................................................... 50
Fazendo scripts para inicialização do firewall.............................................................................................................. 51
Exemplos.......................................................................................................................................................................... 52

Introdução
Introdução às redes locais

A conexão de vários computadores em rede é uma solução extremamente difundida em empresas dos mais variados tipos e
portes. Praticamente todos os tipos de computadores podem ser ligados em rede, desde simples desktops, formando redes
departamentais até mainframes, servindo a uma empresa inteira.
A principal vantagem do uso de redes de computadores está na possibilidade de compartilhar recursos dos mais variados tipos.
Um exemplo bem comum é centralizar os discos em uma máquina e as outras acessarem esses discos via rede. A maquina que centraliza
tais discos é chamada de servidor de arquivos.
O mesmo princípio pode também ser aplicado a impressoras. Assim, não é necessário que cada computador tenha sua própria
impressora. A impressora, portanto, pode ter seu uso otimizado, pois normalmente os usuários só precisam da impressora
eventualmente.
Um outro recurso muito utilizado atualmente é o correio eletrônico. Com ele, documentos que antes precisavam ser impresso,
tais como memorandos, circulares, atas e até ofícios, podem circular de maneira rápida confiável e sem custos entre os funcionários
através da rede.
No ambiente de rede um dos sistemas operacionais mais utilizados para servidores é o linux. Desde sua concepção o linux é
usado como plataforma para servidor e sua fama se deve principalmente a sua estabilidade, segurança e otimização de recursos.
Introdução ao Linux
O Linux é um sistema operacional criado em 1991 por Linus Torvalds na universidade de Helsinki na Finlândia. É um sistema
Operacional de código aberto distribuído gratuitamente pela Internet. Seu código fonte é liberado como Free Software (software livre) o
aviso de copyright do kernel feito por Linus descreve detalhadamente isto e mesmo ele não pode fechar o sistema para que seja usado
apenas comercialmente. Isto quer dizer que você não precisa pagar nada para usar o Linux, e não é crime fazer cópias para instalar em
outros computadores, nós inclusive incentivamos você a fazer isto. Ser um sistema de código aberto pode explicar a performance,
estabilidade e velocidade em que novos recursos são adicionados ao sistema.
Para rodar o Linux você precisa, no mínimo, de um computador 386 SX com 2 MB de memória 4MB e 40MB disponíveis em
seu disco rígido para uma instalação básica e funcional.
O sistema segue o padrão POSIX que é o mesmo usado por sistemas UNIX e suas variantes. Assim, aprendendo o Linux você
não encontrará muita dificuldade em operar um sistema do tipo UNIX, FreeBSD, HPUX, SunOS, etc., bastando apenas aprender alguns
detalhes encontrados em cada sistema.
O código fonte aberto permite que qualquer pessoa veja como o sistema funciona (útil para aprendizado), corrija alguma
problema ou faça alguma sugestão sobre sua melhoria, esse é um dos motivos de seu rápido crescimento, do aumento da
compatibilidade de periféricos (como novas placas sendo suportadas logo após seu lançamento) e de sua estabilidade.
Outro ponto em que ele se destaca é o suporte que oferece a placas, CD-Roms e outros tipos de dispositivos de última geração e
mais antigos (a maioria deles já ultrapassados e sendo completamente suportados pelo sistema operacional). Este é um ponto forte para
empresas que desejam manter seus micros em funcionamento e pretendem investir em avanços tecnológicos com as máquinas que
possui.
Hoje o Linux é desenvolvido por milhares de pessoas espalhadas pelo mundo, cada uma fazendo sua contribuição ou mantendo
alguma parte do kernel gratuitamente. Linus Torvalds ainda trabalha em seu desenvolvimento e também ajuda na coordenação entre os
desenvolvedores.
O suporte ao sistema também se destaca como sendo o mais eficiente e rápido do que qualquer programa comercial disponível
no mercado. Existem centenas de consultores especializados espalhados ao redor do mundo. Você pode se inscrever em uma lista de
discussão e relatar sua dúvida ou alguma falha, e sua mensagem será vista por centenas de usuários na Internet e algum irá te ajudar ou
avisará as pessoas responsáveis sobre a falha encontrada para devida correção.
Introdução às distribuições
Só o kernel GNU/Linux não é suficiente para se ter uma sistema funcional, mas é o principal. Existem grupos de pessoas,
empresas e organizações que decidem “distribuir” o Linux junto com outros programas essenciais (como por exemplo editores gráficos,
planilhas, bancos de dados, ambientes de programação, formatação de documentos, firewalls, etc).
Este é o significado básico de distribuição. Cada distribuição tem sua característica própria, como o sistema de instalação, o
objetivo, a localização de programas, nomes de arquivos de configuração, etc. A escolha de uma distribuição é pessoal e depende das
necessidades de cada um.
Algumas distribuições bastante conhecidas são: Slackware, Debian, Red Hat, Suse, Monkey, todas usando o SO Linux como
kernel principal (a Debian é uma distribuição independente de kernel e pode ser executada sob outros kernels, como o GNU hurd).

A distribuição Debian
A escolha de sua distribuição deve ser feita com muita atenção, não adianta muita coisa perguntar em canais de IRC sobre qual é
a melhor distribuição, ser levado pelas propagandas, pelo vizinho, etc. O melhor caminho para a escolha da distribuição, acredito eu,
seria perguntar as características de cada uma e porque essa pessoa gosta dela ao invés de perguntar qual é a melhor, porque quem lhe
responder isto estará usando uma distribuição que se encaixa de acordo com suas necessidade e esta mesma distribuição pode não ser a
melhor para lhe atender.
A distribuição Debian é desenvolvida e atualizada através do esforço de voluntários espalhados ao redor do mundo, seguindo o
estilo de desenvolvimento GNU/Linux. Por este motivo, foi adotada como a distribuição oficial do projeto GNU. Possui suporte a língua
Portuguesa, é a única que tem suporte a 10 arquiteturas diferentes (i386, Alpha, Sparc, PowerPc, Macintosh, Arm, etc.) e
aproximadamente 15 sub-arquiteturas. A instalação da distribuição pode ser feita tanto através de Disquetes, CD-ROM, Tftp, Ftp, NFS
ou através da combinação de vários destes em cada etapa de instalação.
Acompanha mais de 8710 programas distribuídos em forma de pacotes divididos em 4 CDs binários e 2 de código fonte (ocupou
2.1 GB em meu disco rígido), cada um destes programas são mantidos e testados pela pessoa responsável por seu empacotamento. Os
pacotes são divididos em diretórios de acordo com sua categoria e gerenciados através de um avançado sistema de gerenciamento de
pacotes (o dpkg) facilitando a instalação e atualização de pacotes. Possui tanto ferramentas para administração de redes e servidores
quanto para desktops, estações multimídia, jogos, desenvolvimento, web, etc.
A atualização da distribuição ou de pacotes individuais pode ser feita facilmente através de 2 comandos, não requerendo adquirir
um novo CD para usar a última versão da distribuição. É a única distribuição não comercial onde todos podem contribuir com seu
conhecimento para o seu desenvolvimento. Para gerenciar os voluntários, conta com centenas de listas de discussão envolvendo
determinados desenvolvedores das mais diversas partes do mundo.
São feitos extensivos testes antes do lançamento de cada versão para atingir um alto grau de confiabilidade. As falhas
encontradas nos pacotes podem ser relatados através de um sistema de tratamento de falhas que encaminha a falha encontrada
diretamente ao responsável para avaliação e correção. Qualquer um pode receber a lista de falhas ou sugestões sobre a distribuição
cadastrando-se em uma das lista de discussão que tratam especificamente da solução de falhas encontradas na distribuição (disponível na
página principal da distribuição).
Os pacotes podem ser instalados através de Tarefas contendo seleções de pacotes de acordo com a utilização do computador
(servidor Web, desenvolvimento, TeX, jogos, desktop, etc.), Perfis contendo seleções de pacotes de acordo com o tipo de usuário
(programador, operador, etc.), ou através de uma seleção individual de pacotes, garantindo que somente os pacotes selecionados serão
instalados fazendo uma instalação enxuta.
Existe um time de desenvolvedores com a tarefa específica de monitorar atualizações de segurança em serviços (apache,
sendmail, e todos os outros 8000 pacotes)que possam comprometer o servidor, deixando-o vulnerável a ataques. Assim que uma falha é
descoberta, é enviado uma alerta (DSA - Debian Security Alert) e disponibilizada uma atualização para correção das diversas versões da
Debian. Isto é geralmente feito em menos de 48 horas desde a descoberta da falha até a divulgação da correção. Como quase todas as
falhas são descobertas nos programas, este método também pode ser usado por administradores de outras distribuições para manterem
seu sistema seguro e atualizado.
O suporte ao usuário e desenvolvimento da distribuição são feitos através de listas de discussões e canais IRC. Existem uma lista
de consultores habilitados a dar suporte e assistência a sistemas Debian ao redor do mundo na área consultores do site principal da
distribuição.
Requerimento de hardware para cada tipo de aplicação

Saber dimensionar os recursos de hardware em um servidor é a chave para o seu sucesso como administrador de rede. Uma
configuração errônea pode fazer com que você tenha que fazer uma manutenção no seu servidor após um mês de instalado. Uma parada
em em servidor è sempre um gasto desnecessário e motivos de insatisfação de seus clientes.
Um bom planejamento de hardware pode lhe poupar de paradas indesejadas em seus serviços. Por exemplo, um mau
dimensionamento de um HD pode fazer com que seu servidor de arquivos para de um dia para o outro.
O hardware necessário para um servidor linux depende de vários fatores tais como:
• Tipo de aplicação
• Quantidade de usuários
• Quantidade de acessos simultâneos
• Perfil de usuário
• etc...
Nosso curso baseia-se em cinco tipos de serviços: squid(cache de internet), dhcp, bind(servidor de DNS), SAMBA(Servidor de
arquivos) e iptables(firewal). Vejamos os pré-requisitos para cada um de nossos servidores:
Squid
O squid é um serviço que requer muita memória e o mesmo irá toda a memória disponível no sistema para guardar nela os
objetos em transito. Um outro fator importante também é a qualidade do HD e da controladora de disco. Os objetos que o squid não
puder guardar na memória ele irá tentar gravar no disco, e o mesmo irá tentar lê-lo quando o objeto for requisitado. Imagine agora um
servidor que chega a ter 250 clientes acessando páginas simultaneamente. O quanto de memória esse serviço irá consumir? O quanto

será usado do barramento de leitura de disco quando estiver no horário de pico? CPU também é um fator a ser levado em conta.
Considerando seus clientes com um perfil “medio” de uso, para uma quantidade de 250 clientes poderíamos usar uma máquina
com uma CPU dual core de à partir de 2Ghz, 4GB de RAM e de preferência discos SCSI de 32 GB, com uma boa controlador SCSI ou
SAS. Neste serviço um hardware deficiente pode causar lentidão no acesso.
dhcp
O serviço dhcp não é um serviço exigente em termos de recursos de hardware. Porém, caso falte o dhcp na sua rede todos os
clientes que dependem dele perderão contato com todos os tipos de serviços, é melhor investir em uma máquina muito estável.
Em uma rede onde tenhamos uns 250 dispositivos ligados simultaneamente, poderemos usar qualquer CPU de pelo menos 1
Ghz, 512 MB de RAM e pelos menos um disco com 5 GB.
Bind
O serviço de DNS não é um serviço que vá lhe exigir muito de disco entre outros recursos. Porém é um serviço crítico e pode
parar boa parte de seus serviços, o acesso à Internet por exemplo, por isso geralmente se usa dois servidores.
Uma máquina semelhante ao servidor de DHCP, porém com uma CPU de 1,5 Ghz pode suprir as suas necessidades.
SAMBA
No caso do serviço de servidor de arquivos, os requisitos de hardware vai depender da quantidade de dados a ser guardada, a
frequência de acesso a esses arquivos e o quanto sua rede vai depender deste serviço.
Para serviços de compartilhamentos onde os arquivos são usados pelos próprios usuários e estes usam o compartilhamento para
centralizar documentos, é fácil calcular o quanto de espaço em disco será necessário. Porém, se você irá usar a opção de roamming
profiles vai ter algo a mais com o que se preocupar. Lembre-se que ao usar os roamming profiles o papel de parede, as demais coisas da
área de trabalho, seus documentos pessoais e até seus e-mails irão ser guardados no servidor. A palavra chave neste caso é disco. Um
disco grande para caber todos os dados em conjunto com uma boa controladora de disco irá satisfazer bem suas necessidades.
Para uma rede acima de 30 usuários simultâneos aconselho ter uma máquina com no mínimo CPU de 1.5 Ghz e 512 MB de
RAM
Iptables
O iptables é um firewall a nível de kernel, ou seja, não é mais um aplicativo para que o sistema manipule por isso ele consome
menos processamento da maquina. Como todas as suas regras são guardadas na memória, ele quase não necessita de acesso ao disco(na
verdade ele não acessa, porém se você usar opções para “logar” atividades estranhas em sua rede, os sistema linux vai ter que acessar o
disco para salvar essas informações).
Um caso de maiores proporções é quando você usa o NAT. O iptables têm que manter na memória registros de todas as
conexões abertas, isso aumenta um pouco o consumo de memória. Uma máquina como o do servidor bind serve muito bem para
tráfegos até 4 Mbps.
Uma observação importantíssima é sobre a acumulação de mais de um desses serviços em uma mesma máquina. Nem sempre
acumular dois serviços significa acumular suas necessidades. Isso depende muito do ambiente onde o serviço está inserido.
Ao longo do curso aprenderemos várias ferramentas para acompanhar o desempenho de nossos sistemas.
Procedimento para instalação

Há vários métodos de instalação válidos para os sistemas debian. Desde começando a instalação de um sistema que rode em um
disquete a um DVD-ROM. Em nosso curso usaremos o modo de instalação por CD-ROM. Todas as imagens ISO podem ser
conseguidas a partir da url: http://cdimage.debian.org.br. Note que para a versão com CD-ROM existem as variantes netinstall(vem
somente o sistema mínimo e o resto dos pacotes devem ser baixados da internet), kde(Vem com o ambiente gráfico KDE – A adotada no
curso) e a padrão(que vem com o ambiente gráfico gnome). Dê preferência aos ISO completos para que não tenha que baixar vários
arquivos da internet. Caso prefira, baixe as imagens de DVD´s.
Com posse do cdrom de instalação do debian 4.0, codinome etch, vamos instalar nosso sistema debian. A partir da versão 4.0 a
distribuição debian possui a possibilidade de instalar o sistema de um modo gráfico. A instalação é bem simples bastando para isso
alguns passos.
Antes que você inicie a instalação aconselho que você faça backup de seus arquivos. Caso você esteja instalando o linux em uma
máquina para fazer dual-boot deixe uma partição vazia de pelo menos 6 GB para instalar o linux. De preferência deixe um HD somente
para o linux.
Nesta etapa da intalação já devemos ter o nosso planejamento sobre o que serviços iremos rodar neste servidor. Por exemplo,
caso tivessemos montando um servidor de arquivos e nele fossemos colocar roamming profiles iríamos precisar de quatro partições uma
para colocarmos o sistema, outra para colocar os dados dos usuários, outra pra colocar os profiles, outra para os diretórios homes. Isso
garante que caso um cliente encha o seu profile, não faça com que todos os compartilhamentos sejam afetados.

Conhecendo o sistema Linux
Comandos Básicos
Diferentemente do Windows, que tem sua administração totalmente baseada em interface gráfica, o linux tem como sua
principal forma de configuração o modo texto, onde interagimos com o sistema na forma de comandos.
Comandos de sistemas de arquivos

Nos sistemas linux por padrão já vem uma série de comandos para manipulação de arquivos e diretórios não sendo portanto
necessário instalá-los, entre eles podemos citar:
ls
O comando ls serve para listar o conteúdo de um diretório.
ls [opções] [caminho/arquivo] [caminho1/arquivo1]
onde:
caminho/arquivo Diretório/arquivo que será listado.
caminho1/arquivo1 Outro Diretório/arquivo que será listado. Podem ser feitas várias listagens de uma só vez.
Opções:
-a, –all Lista todos os arquivos (inclusive os ocultos) de um diretório.
-A, –almost-all Lista todos os arquivos (inclusive os ocultos) de um diretório, exceto o diretório atual e o de nível anterior.
-d, –directory Lista os nomes dos diretórios ao invés do conteúdo.
-f Não classifica a listagem.
-G, –no-group Oculta a coluna de grupo do arquivo.
-h, –human-readable Mostra o tamanho dos arquivos em Kbytes, Mbytes, Gbytes.
-H Faz o mesmo que -h, mas usa unidades de 1000 ao invés de 1024 para especificar Kbytes, Mbytes, Gbytes.
-l Usa o formato longo para listagem de arquivos. Lista as permissões, data de modificação, donos, grupos, etc.
-n Usa a identificação de usuário e grupo numérica ao invés dos nomes.
-R Lista diretórios e sub-diretórios recursivamente.
Cd
Entra em um diretório. Você precisa ter a permissão de execução para entrar no diretório.
cd [diretório]
onde:
diretório - diretório que deseja entrar.
Exemplos:
• Usando cd sem parâmetros ou cd ~, você retornará ao seu diretório de usuário (diretório home).
• cd /, retornará ao diretório raíz.
• cd -, retornará ao diretório anteriormente acessado.
• cd .., sobe um diretório.
• cd ../[diretório], sobe um diretório e entra imediatamente no próximo (por exemplo,quando você está em /usr/sbin, você digita
cd ../bin, o comando cd retorna um diretório (/usr) e entra imediatamente no diretório bin (/usr/bin).
pwd
Mostra o nome e caminho do diretório atual.
Você pode usar o comando pwd para verificar em qual diretório se encontra (caso seu aviso de comandos não mostre isso).
Mkdir
Cria um diretório no sistema. Um diretório é usado para armazenar arquivos de um determinado tipo. O diretório pode ser
entendido como uma pasta onde você guarda seus papeis (arquivos). Como uma pessoa organizada, você utilizará uma pasta para
guardar cada tipo de documento, da mesma forma você pode criar um diretório vendas para guardar seus arquivos relacionados com
vendas naquele local.
mkdir [opções] [caminho/diretório] [caminho1/diretório1]
onde:
caminho Caminho onde o diretório será criado.
diretório Nome do diretório que será criado.
opções:
Para criar um novo diretório, você deve ter permissão de gravação. Por exemplo, para criar um diretório em /tmp com o nome de
teste que será usado para gravar arquivos de teste, você deve usar o comando "mkdir/tmp/teste".
Podem ser criados mais de um diretório com um único comando (mkdir /tmp/teste /tmp/teste1 /tmp/teste2).

cat
Mostra o conteúdo de um arquivo binário ou texto.
cat [opções] [diretório/arquivo] [diretório1/arquivo1]
diretório/arquivo Localização do arquivo que deseja visualizar o conteúdo.
opções
-n, –number Mostra o número das linhas enquanto o conteúdo do arquivo é mostrado.
-s, –squeeze-blank Não mostra mais que uma linha em branco entre um parágrafo e outro.
O comando cat trabalha com arquivos texto. Use o comando zcat para ver diretamente arquivos compactados com gzip.
Exemplo: cat /usr/doc/copyright/GPL
rm
Apaga arquivos. Também pode ser usado para apagar diretórios e sub-diretórios vazios ou que contenham arquivos.
rm [opções][caminho][arquivo/diretório] [caminho1][arquivo1/diretório1]
onde:
caminho Localização do arquivo que deseja apagar. Se omitido, assume que o arquivo esteja no diretório atual.
arquivo/diretório Arquivo que será apagado.
opções
-i, –interactive Pergunta antes de remover, esta é ativada por padrão.
-v, –verbose Mostra os arquivos na medida que são removidos.
-r, –recursive Usado para remover arquivos em sub-diretórios. Esta opção também pode ser usada para remover sub-diretórios.
-f, –force Remove os arquivos sem perguntar.
– arquivo Remove arquivos/diretórios que contém caracteres especiais. O separador “–” funciona com todos os comandos do
shell e permite que os caracteres especiais como “*”, “?”, “-”, etc. sejam interpretados como caracteres comuns.
Use com atenção o comando rm, uma vez que os arquivos e diretórios forem apagados, eles não poderão ser mais recuperados.
Exemplos:
• rm teste.txt - Apaga o arquivo teste.txt no diretório atual.
• rm *.txt - Apaga todos os arquivos do diretório atual que terminam com .txt.
• rm *.txt teste.novo - Apaga todos os arquivos do diretório atual que terminam com .txt e também o arquivo teste.novo.
• rm -rf /tmp/teste/* - Apaga todos os arquivos e sub-diretórios do diretório /tmp/teste mas mantém o sub-diretório /tmp/teste.
• rm -rf /tmp/teste - Apaga todos os arquivos e sub-diretórios do diretório /tmp/teste, inclusive /tmp/teste.
• rm -f -- --arquivo-- - Remove o arquivo de nome -arquivo-.
cp
Copia arquivos.
cp [opções] [origem] [destino]
onde:
origem Arquivo que será copiado. Podem ser especificados mais de um arquivo para ser copiado usando “Curingas” (veja
‘Curingas’ on page 12).
destino O caminho ou nome de arquivo onde será copiado. Se o destino for um diretório, os arquivos de origem serão copiados
para dentro do diretório.
opções
-i, –interactive Pergunta antes de substituir um arquivo existente.
-f, –force Não pergunta, substitui todos os arquivos caso já exista.
-r Copia arquivos dos diretórios e subdiretórios da origem para o destino. É recomendável usar -R ao invés de -r.
-R, –recursive Copia arquivos e sub-diretórios (como a opção -r) e também os arquivos especiais FIFO e dispositivos.
-v, –verbose Mostra os arquivos enquanto estão sendo copiados.
-s, –simbolic-link Cria link simbólico ao invés de copiar.
-l, –link Faz o link no destino ao invés de copiar os arquivos.
-p, –preserve Preserva atributos do arquivo, se for possível.
-u, –update Copia somente se o arquivo de origem é mais novo que o arquivo de destino ou quando o arquivo de destino não
existe.
-x Não copia arquivos que estão localizados em um sistema de arquivos diferente de onde a cópia iniciou.
O comando cp copia arquivos da ORIGEM para o DESTINO. Ambos origem e destino terão o mesmo conteúdo após a cópia.
Exemplos:
cp teste.txt teste1.txt Copia o arquivo teste.txt para teste1.txt.
cp teste.txt /tmp Copia o arquivo teste.txt para dentro do diretório /tmp.
cp * /tmp Copia todos os arquivos do diretório atual para /tmp.
cp /bin/* . Copia todos os arquivos do diretório /bin para o diretório em que nos encontramos no momento.
cp -R /bin /tmp Copia o diretório /bin e todos os arquivos/sub-diretórios existentes para o diretório /tmp.
cp -R /bin/* /tmp Copia todos os arquivos do diretório /bin (exceto o diretório /bin) e todos os arquivos/sub-diretórios existentes
dentro dele para /tmp.
cp -R /bin /tmp Copia todos os arquivos e o diretório /bin para /tmp.
mv
Move ou renomeia arquivos e diretórios. O processo é semelhante ao do comando cp mas o arquivo de origem é apagado após o
término da cópia.

mv [opções] [origem] [destino]
Onde:
origem Arquivo/diretório de origem.
destino Local onde será movido ou novo nome do arquivo/diretório.
opções
-f, –force Substitui o arquivo de destino sem perguntar.
-i, –interactive Pergunta antes de substituir. É o padrão.
-v, –verbose Mostra os arquivos que estão sendo movidos.
-u, –update Move somente arquivos antigos, ou novos arquivos.
O comando mv copia um arquivo da ORIGEM para o DESTINO (semelhante ao cp), mas após a cópia, o arquivo de ORIGEM é
apagado.
Exemplos:
mv teste.txt teste1.txt Muda o nome do arquivo teste.txt para teste1.txt.
mv teste.txt /tmp Move o arquivo teste.txt para /tmp. Lembre-se que o arquivo de origem é apagado após ser movido.
mv teste.txt teste.new (supondo que teste.new já exista) Copia o arquivo teste.txt por cima de teste.new e apaga teste.txt após
terminar a cópia.
Comandos diversos
df
Mostra o espaço livre/ocupado de cada partição.
df [opções]
onde:
opções
-a Inclui sistemas de arquivos com 0 blocos.
-h, –human-readable Mostra o espaço livre/ocupado em MB, KB, GB ao invés de blocos.
-H Idêntico a -h mas usa 1000 ao invés de 1024 como unidade de cálculo.
-k Lista em Kbytes.
-l Somente lista sistema de arquivos locais.
-m Lista em Mbytes (equivalente a –block-size=1048576).
–sync Executa o sync antes de mostrar os dados.
-T Lista o tipo de sistema de arquivos de cada partição
-t tipo Lista somente sistema de arquivos do tipo tipo.
-x tipo Não lista sistemas de arquivos do tipo tipo.
Exemplos: df, df -h, df -t vfat.
du
Mostra o espaço ocupado por arquivos e sub-diretórios do diretório atual.
du [opções]
onde:
opções
-a, –all Mostra o espaço ocupado por todos os arquivos.
-b, –bytes Mostra o espaço ocupado em bytes.
-c, –total Faz uma totalização de todo espaço listado.
-D Não conta links simbólicos.
-h, –human Mostra o espaço ocupado em formato legível por humanos (Kb, Mb) ao invés de usar blocos.
-H Como o anterior mas usa 1000 e não 1024 como unidade de cálculo.
-k Mostra o espaço ocupado em Kbytes.
-m Mostra o espaço ocupado em Mbytes.
-S, –separate-dirs Não calcula o espaço ocupado por sub-diretórios.
-x Não faz a contagem de diretórios em sistemas de arquivos diferentes do atual.
Exemplo: du -h, du -hc.
free
Mostra detalhes sobre a utilização da memória RAM do sistema.
free [opções]
Onde:
opções
-b Mostra o resultado em bytes.
-k Mostra o resultado em Kbytes.
-m Mostra o resultado em Mbytes.
-o Oculta a linha de buffers.
-t Mostra uma linha contendo o total.
-s [num ] Mostra a utilização da memória a cada [num] segundos.
O free é uma interface ao arquivo /proc/meminfo.

grep
Procura por um texto dentro de um arquivo(s) ou no dispositivo de entrada padrão.
grep [expressão] [arquivo] [opções]
Onde:
expressão palavra ou frase que será procurada no texto. Se tiver mais de 2 palavras você deve identifica-la com aspas “” caso
contrário o grep assumirá que a segunda palavra é o arquivo!
arquivo Arquivo onde será feita a procura.
opções
-A [número ] Mostra o [número] de linhas após a linha encontrada pelo grep.
-B [número ] Mostra o [número] de linhas antes da linha encontrada pelo grep.
-f [arquivo ] Especifica que o texto que será localizado, esta no arquivo [arquivo].
-h, –no-filename Não mostra os nomes dos arquivos durante a procura.
-i, –ignore-case Ignora diferença entre maiúsculas e minúsculas no texto procurado e arquivo.
-n, –line-number Mostra o nome de cada linha encontrada pelo grep.
-U, –binary Trata o arquivo que será procurado como binário.
Se não for especificado o nome de um arquivo ou se for usado um hífen “-”, grep procurará a string no dispositivo de entrada
padrão. O grep faz sua pesquisa em arquivos texto. Use o comando zgrep para pesquisar diretamente em arquivos compactados com
gzip, os comandos e opções são as mesmas.
Exemplos: grep “capitulo” texto.txt, ps ax|grep inetd, grep “capitulo” texto.txt -A 2 -B 2.
head
Mostra as linhas iniciais de um arquivo texto.
head [opções]
Onde:
-c [numero ] Mostra o [numero] de bytes do inicio do arquivo.
-n [numero ] Mostra o [numero] de linhas do inicio do arquivo. Caso não for especificado, o
head mostra as 10 primeiras linhas.
Exemplos: head teste.txt, head -n 20 teste.txt.
tail
Mostra as linhas finais de um arquivo texto.
tail [opções]
Onde:
-c [numero ] Mostra o [numero] de bytes do final do arquivo.
-n [numero ] Mostra o [numero] de linhas do final do arquivo.
Exemplos: tail teste.txt, tail -n 20 teste.txt.
Comandos para gerenciamento de usuários.
adduser
Adiciona um usuário ou grupo no sistema. Por padrão, quando um novo usuário é adicionado, é criado um grupo com o mesmo
nome do usuário. Opcionalmente o adduser também pode ser usado para adicionar um usuário a um grupo . Será criado um diretório
home com o nome do usuário (a não ser que o novo usuário criado seja um usuário do sistema) e este receberá uma identificação. A
identificação do usuário (UID) escolhida será a primeira disponível no sistema especificada de acordo com a faixa de UIDS de usuários
permitidas no arquivo de configuração /etc/adduser.conf.
Este é o arquivo que contém os padrões para a criação de novos usuários no sistema.
adduser [opções] [usuário/grupo]
Onde:
usuário/grupo Nome do novo usuário que será adicionado ao sistema.
opções
-disable-passwd Não executa o programa passwd para escolher a senha e somente permite o uso da conta após o usuário escolher
uma senha.
–force-badname Desativa a checagem de senhas ruins durante a adição do novo usuário. Por padrão o adduser checa se a senha
pode ser facilmente adivinhada.
–group Cria um novo grupo ao invés de um novo usuário. A criação de grupos também pode ser feita pelo comando addgroup.
-uid [num ] Cria um novo usuário com a identificação [num] ao invés de procurar o próximo UID disponível.
-gid [num ] Faz com que o usuário seja parte do grupo [gid] ao invés de pertencer a um novo grupo que será criado com seu
nome. Isto é útil caso deseje permitir que grupos de usuários possam ter acesso a arquivos comuns. Caso estiver criando um novo grupo
com adduser, a identificação do novo grupo será [num].
–home [dir ] Usa o diretório [dir] para a criação do diretório home do usuário ao invés de usar o especificado no arquivo de
configuração /etc/adduser.conf.
–ingroup [nome ] Quando adicionar um novo usuário no sistema, coloca o usuário no grupo [nome] ao invés de criar um novo
grupo.

–quiet Não mostra mensagens durante a operação.
–system Cria um usuário de sistema ao invés de um usuário normal.
Os dados do usuário são colocados no arquivo /etc/passwd após sua criação e os dados do grupo são colocados no arquivo
/etc/group.
OBSERVAÇÃO: Caso esteja usando senhas ocultas (shadow passwords), as senhas dos usuários serão colocadas no arquivo
/etc/shadow e as senhas dos grupos no arquivo /etc/gshadow. Isto aumenta mais a segurança do sistema porque somente o usuário root
pode ter acesso a estes arquivos, ao contrário do arquivo /etc/passwd que possui os dados de usuários e devem ser lidos por todos.
addgroup
Adiciona um novo grupo de usuários no sistema. As opções usadas são as mesmas do ‘adduser’.
addgroup [usuário/grupo] [opções]
passwd
Muda a senha do usuário ou grupo. Um usuário somente pode alterar a senha de sua conta, mas o superusuário (root) pode
alterar a senha de qualquer conta de usuário, inclusive a data de validade da conta, etc. Os donos de grupos também podem alterar a
senha do grupo com este comando.
Os dados da conta do usuário como nome, endereço, telefone, também podem ser alterados com este comando.
passwd [usuário/grupo] [opções]
Onde:
usuário Nome do usuário/grupo que terá sua senha alterada.
opções
-g Se especificada, a senha do grupo será alterada. Somente o root ou o administrador do grupo pode alterar sua senha. A opção
-r pode ser usada com esta para remover a senha do grupo. A opção -R pode ser usada para restringir o acesso do grupo para outros
usuários.
-x [dias ] Especifica o número máximo de dias que a senha poderá ser usada. Após terminar o prazo, a senha deverá ser
modificada.
-i Desativa a conta caso o usuário não tenha alterado sua senha após o tempo especificado por -x.
-n [dias ] Especifica o número mínimo de dias para a senha ser alterada. O usuário não poderá mudar sua senha até que [dias]
sejam atingidos desde a última alteração de senha.
-w [num ] Número de dias antecedentes que o usuário receberá o alerta para mudar sua senha. O alerta ocorre [num] dias antes
do limite da opção -x, avisando ao usuários quantos dias restam para a troca de sua senha.
-l [nome ] Bloqueia a conta do usuário [nome]. Deve ser usada pelo root. O bloqueio da conta é feito acrescentando um caracter
a senha para que não confira com a senha original.
-u [nome ] Desbloqueia a conta de um usuário bloqueada com a opção -l.
-S [nome ] Mostra o status da conta do usuário [nome]. A primeira parte é o nome do usuário seguido de L(conta bloqueada),
NP(sem senha), ou P (com senha), a terceira parte é a data da última modificação da senha, a quarta parte é a período mínimo, máximo,
alerta e o período de inatividade para a senha.
Procure sempre combinar letras maiúsculas, minúsculas, e números ao escolher suas senhas. Não é recomendado escolher
palavras normais como sua senha pois podem ser vulneráveis a ataques de dicionários cracker. Outra recomendação é utilizar senhas
ocultas em seu sistema (shadow password).
Você deve ser o dono da conta para poder modificar a senhas. O usuário root pode modificar/apagar a senha de qualquer
usuário.
Exemplo: passwd root.
userdel
Apaga um usuário do sistema. Quando é usado, este comando apaga todos os dados da conta especificado dos arquivos de contas
do sistema.
userdel [-r] [usuário]
Onde:
-r Apaga também o diretório HOME do usuário.
OBS: Note que uma conta de usuário não poderá ser removida caso ele estiver no sistema, pois os programas podem precisar ter
acesso aos dados dele (como UID, GID) no /etc/passwd.
groupdel
Apaga um grupo do sistema. Quando é usado, este comando apaga todos os dados do grupo especificado dos arquivos de contas
do sistema.
groupdel [grupo]

OBS: Você não pode remover o grupo primário de um usuário. Remova o usuário primeiro.
Editores de texto
No linux existem vários editores de texto, sendo que alguns são em modo gráfico, como o kate, kwrite,kedit, gnome-editor. E
outros em modo texto. Os editores em modo texto são os aconselhados pois podemos usá-los sob a maioria das situações. Ex:
usando console remota em uma linha discada. Alguns editores em modo texto:
nano ou pico
O nano é um editor bem simples e muito fácil de usar e já vem por padrão na distribuição debian. Na parte inferior há os atalhos
para diversas opções do editor. Ex.: ctrl-x(^X) sair, etc.
Joe
Para quem já usou o Wordperfect, esse editor implementa uma aparência semelhante ao seu predecessor. Tendo uma linha de
status que fica no topo da janela, com as informações de status do arquivo, nome do arquivo, linha, coluna, hora e as teclas para se obter
a ajuda, é um editor muito leve e prático. Tem uma "janela" de ajuda que pode ficar visível durante todo o tempo ou oculta, bastando
para isso pressionar Ctrl-H, alternando-se o modo de exibição da janela.
Vi e vim
Neste editor de textos temos dois modos principais de interação com o usuário: o modo de edição de textos e o modo comando.
No modo comando são digitados os comandos para o editor de textos.
Assim que iniciado o vi abre no modo de comando onde então podemos dar comando ao editor como:
■ :e arquivo.txt para abrir
■ :q! sai do arquivo sem salvar nenhuma alteração
■ :wq salva o arquivo atual e sai
■ Note que ao digitar o ”:” o comando é exibido na parte inferior da tela.
■ “c” corta a linha atual.
■ “p” cola o texto anteriormente recortado.
Para iniciar o modo de edição basta teclar a letra i(insert) e digitar normalmente. Para voltar ao modo de comando novamente
basta teclar “esc”.
Mcedit(midnight commander editor)

De modo semelhante ao joe, este editor de textos também possui uma linha de status no topo da tela, mas, além disso, tem uma
linha com as teclas de atalho de seus comandos principais no rodapé da tela. Grande parte de suas funções são acessadas via menu.
Observe no topo da tela a linha de status: ela muda para um menu que abre as opções do editor, pelas quais você pode navegar
facilmente com as setas de direção.
Principais arquivos do sistema

No linux todos os arquivos de configuração se encontram por padrão no diretorio /etc. Eis alguns dos principais arquivos.
Comento aqui somente alguns.
/etc/network/interfaces
Este é o arquivo de configuração usado pelos programas ifup e ifdown, respectivamente para ativar e desativas as interfaces de
rede.
O que estes utilitários fazem na realidade é carregar os utilitários ifconfig e route através dos argumentos passados do arquivo
/etc/network/interfaces, permitindo que o usuário iniciante configure uma interface de rede com mais facilidade.
Abaixo um exemplo do arquivo interfaces é o seguinte:
auto eth0
iface eth0 inet static
address 192.168.99.1
netmask 255.255.255.0

network 192.168.99.0
broadcast 192.168.1.255
As interfaces e roteamentos são configurados na ordem que aparecem neste arquivo. Cada configuração de interface inicia com a
palavra chave iface. A próxima palavra é o nome da interface que deseja configurar (da mesma forma que é utilizada pelos comandos
ifconfig e route). Você pode também usar IP aliases especificando eth0:0 mas tenha certeza que a interface real (eth0) é inicializada
antes.
A próxima palavra especifica a familia de endereços da interface; Escolha inet para a rede TCP/IP, ipx para interfaces IPX e
IPv6 para interfaces configuradas com o protocolo IPV6.
A palavra static especifica o método que a interface será configurada, neste caso é uma interface com endereço estático (fixo).
Outros métodos e seus parâmetros são especificados abaixo (traduzido da página do arquivo interfaces):
O método loopback
É usado para configurar a interface loopback (lo) IPv4.
O método static
É usado para configurar um endereço IPv4 fixo para a interface. As opções que podem ser usadas com o métodos static são as
seguintes (opções marcadas com * no final são requeridas na configuração):
address endereço *
Endereço IP da Interface de rede (por exemplo, 192.168.99.1).
netmask máscara *
Máscara de rede da Interface de rede (por exemplo, 255.255.255.0).
broadcast endereço
Endereço de Broadcast da interface (por exemplo, 192.168.1.255).
network endereço
Endereço da rede (por exemplo, 192.168.99.0).
gateway endereço
Endereço do gateway padrão (por exemplo, 192.168.1.10). O gateway é o endereço do computador responsável por conectar o
seu computador a outra rede. Use somente se for necessário em sua rede.
O método dhcp
Este método é usado para obter os parâmetros de configuração através de um servidor DHCP da rede através das ferramentas:
dhclient, pump (somente Kernels 2.2.x) ou dpcpcp (somente kernels 2.0.x e 2.2.x)
hostname nome
Nome da estação de trabalho que será requisitado. (pump, dhcpcd)
leasehours leasttime
Lease time preferida em horas (pump)
leasetime leasetime
Lease time preferida em segundos (dhcpcd)
vendor vendedor
Identificador do vendedor (dhcpcd)
cliente identificação
Identificação do cliente (dhcpcd)
O método bootp
Este método pode ser usado para obter um endereço via bootp:
bootfile arquivo
Diz ao servidor para utilizar arquivo como arquivo de inicialização
server endereço
Especifica o endereço do servidor bootp.
hwaddr endereço
Usa endereço como endereço de hardware no lugar do endereço original.
Algumas opções se aplicam a todas as interfaces e são as seguintes:
noauto
Não configura automaticamente a interface quando o ifup ou ifdown são executados com a opção -a (normalmente usada
durante a inicialização ou desligamento do sistema).
pre-up comando
Executa o comando antes da inicialização da interface.
up comando
Executa o comando após a interface ser iniciada.
down comando
Executa o comando antes de desativar a interface.
pre-down comando
Executa o comando após desativar a interface.
Os comandos que são executados através das opções up, pre-up e down podem aparecer várias vezes na mesma interface, eles
são executados na seqüência que aparecem. Note que se um dos comandos falharem, nenhum dos outros será executado. Você pode ter
certeza que os próximos comandos serão executados adicionando || true ao final da linha de comando.

/etc/fstab
O arquivo /etc/fstab permite que as partições do sistema sejam montadas facilmente especificando somente o dispositivo ou o
ponto de montagem. Este arquivo contém parâmetros sobre as partições que são lidos pelo comando mount. Cada linha deste arquivo
contém a partição que desejamos montar, o ponto de montagem, o sistema de arquivos usado pela partição e outras opções. fstab tem a
seguinte forma:
Sist. De arquivos Ponto de Montagem Tipo Opções dump ordem
/dev/hda1 / ext2 defaults 0 1
/dev/hda2 /boot ext2 defaults 0 2
/dev/hda3 /dos msdos defaults,noauto,rw 0 0
/dev/hdg /cdrom iso9660 defaults,noauto 0 0
Onde:
Sistema de Arquivos
Partição que deseja montar.
Ponto de montagem
Diretório do GNU/Linux onde a partição montada será acessada.
Tipo
Tipo de sistema de arquivos usado na partição que será montada. Para partições GNU/Linux use ext2,ext3 ou reiserfs, para
partições DOS (sem nomes extensos de arquivos) use msdos, para partições Win 95 (com suporte a nomes extensos de arquivos) use
vfat, para unidades de CD-ROM use iso9660.
Opções
Especifica as opções usadas com o sistema de arquivos. Abaixo, algumas opções de montagem para ext2/3 (a lista completa
pode ser encontrada na página de manual do mount):
defaults - Utiliza valores padrões de montagem.
noauto - Não monta os sistemas de arquivos durante a inicialização (útil para CD-ROMS e disquetes).
ro - Monta como somente leitura.
user - Permite que usuários montem o sistema de arquivos (não recomendado por motivos de segurança).
sync é recomendado para uso com discos removíveis (disquetes, zip drives, etc) para que os dados sejam gravados
imediatamente na unidade (caso não seja usada, você deve usar o comando sync antes de retirar o disquete da unidade.
Dump
Especifica a frequência de backup feita com o programa dump no sistema de arquivos. 0 desativa o backup.
Ordem
Define a ordem que os sistemas de arquivos serão verificados na inicialização do sistema. Se usar 0, o sistema de arquivos não
é verificado. O sistema de arquivos raíz que deverá ser verificado primeiro é o raíz "/" (a não ser que você tenha um sistema de arquivos
de outro tipo que não é montado dentro do diretório raíz e possui seu suporte embutido no kernel) .
Após configurar o /etc/fstab, basta digitar o comando mount /dev/hdg ou mount /cdrom para que a unidade de CD-ROM seja
montada. Você deve ter notado que não é necessário especificar o sistema de arquivos da partição pois o mount verificará se ele já existe
no /etc/fstab e caso existir, usará as opções especificadas neste arquivo. Para maiores detalhes veja as páginas de manual fstab e mount.
/etc/hosts
O arquivo /etc/hosts faz o relacionamento entre um nome de computador e endereço IP local. Recomendado para IPs
constantemente acessados e para colocação de endereços de virtual hosts (quando deseja referir pelo nome ao invés de IP). A inclusão de
um computador neste arquivo dispenda a consulta de um servidor de nomes para obter um endereço IP, sendo muito útil para máquinas
que são acessadas frequentemente. A desvantagem de fazer isto é que você mesmo precisará manter este arquivo atualizado e se o
endereço IP de algum computador for modificado, esta alteração deverá ser feita em cada um dos arquivos hosts das máquinas da rede.
Em um sistema bem gerenciado, os únicos endereços de computadores que aparecerão neste arquivo serão da interface loopback e os
nomes de computadores.
# /etc/hosts
127.0.0.1 localhost loopback
192.168.99.1 maquina.dominio.com.br
Você pode especificar mais que um nome de computador por linha como demonstrada pela primeira linha, a que identifica a
interface loopback. Certifique-se de que a entrada do nome de domínio neste arquivo aponta para a interface de rede e não para a
interface loopback, ou terá problema com o comportamento de alguns serviços.
OBS: Caso encontre problemas de lentidão para resolver nomes e até para executar os aplicativos (como o mc, etc), verifique se
existem erros neste arquivo de configuração.
Estes sintomas se confundem com erros de memória ou outro erro qualquer de configuração de hardware, e somem quando a
interface de rede é desativada (a com o IP não loopback). Isto é causados somente pela má configuração do arquivo /etc/hosts. O bom

funcionamento do Unix depende da boa atenção do administrador de sistemas para configurar os detalhes de seu servidor.
/etc/hostname
Arquivo lido pelo utilitário hostname para definir o nome de sua estação de trabalho.
/etc/issue
Contém um texto ou mensagem que será mostrada antes do login do sistema.
/etc/motd
Mostra um texto ou mensagem após o usuário se logar com sucesso no sistema. Também é usado pelo telnet, ftp, e outros
servidores que requerem autenticação do usuário (nome e senha).
/etc/passwd
É o arquivo mais cobiçado por Hackers porque contém os dados pessoais do usuário como o login, uid, telefone e senha (caso
seu sistema esteja usando senhas ocultas, a senha terá um * no lugar e as senhas reais estarão armazenadas no arquivo /etc/shadow).
/etc/protocols
O arquivo /etc/protocols é um banco de dados que mapeia números de identificação de protocolos novamente em nomes de
protocolos. Isto é usado por programadores para permiti-los especificar protocolos por nomes em seus programas e também por alguns
programas tal como tcpdump permitindo-os mostrar nomes ao invés de números em sua saída. A sintaxe geral deste arquivo é:
nomeprotocolo número apelidos
/etc/resolv.conf
O /etc/resolv.conf é o arquivo de configuração principal do código do resolvedor de nomes. Seu formato é um arquivo texto
simples com um parâmetro por linha e o endereço de servidores DNS externos são especificados nele. Existem três palavras chaves
normalmente usadas que são:
domain
Especifica o nome do domínio local.
search
Especifica uma lista de nomes de domínio alternativos ao procurar por um computador, separados por espaços. A linha search
pode conter no máximo 6 domínios ou 256 caracteres.
nameserver
Especifica o endereço IP de um servidor de nomes de domínio para resolução de nomes. Pode ser usado várias vezes.
Como exemplo, o /etc/resolv.conf se parece com isto:

domain linux.org.br
search linux.org
nameserver 192.168.99.1
nameserver 192.168.99.2
Este exemplo especifica que o nome de domínio a adicionar ao nome não qualificado (i.e. hostnames sem o domínio) é
linux.org.br e que se o computador não for encontrado naquele domínio então a procura segue para o domínio linux.org diretamente.
Duas linhas de nomes de servidores foram especificadas, cada uma pode ser chamada pelo código resolvedor de nomes para resolver o
nome.
/etc/services
O arquivo /etc/services é um banco de dados simples que associa um nome amigável a humanos a uma porta de serviço
amigável a máquinas. É um arquivo texto de formato muito simples, cada linha representa um item no banco de dados. Cada item é
dividido em três campos separados por qualquer número de espaços em branco (tab ou espaços). Os campos são:
nome porta/protocolo apelido # comentário
nome
Uma palavra simples que representa o nome do serviço sendo descrito.

porta/protocolo
Este campo é dividido em dois sub-campos.
porta - Um número que especifica o número da porta em que o serviço estará disponível. Muitos dos serviços comuns tem
designados um número de serviço. Estes estão descritos no RFC-1340.
protocolo - Este sub-campo pode ser ajustado para tcp ou udp. É importante notar que o item 18/tcp é muito diferente do item
18/udp e que não existe razão técnica porque o mesmo serviço precisa existir em ambos. Normalmente o senso comum prevalece e que
somente se um serviço esta disponível em ambos os protocolos tcp e udp, você precisará especificar ambos.
apelidos
Outros nomes podem ser usados para se referir a entrada deste serviço.
Comentário
Qualquer texto aparecendo em uma linha após um caracter "#" é ignorado e tratado como comentário.
/etc/shadow
Este arquivo armazena as senhas criptografadas caso estiver usando o recurso de senhas ocultas. Este arquivo somente pode ser
lido pelo usuário root.
/etc/shells
Contém uma lista de interpretadores de comando (shells) válidos no sistema.
Permissões de arquivos
A permissão de acesso protege o sistema de arquivos Linux do acesso indevido de pessoas ou programas não autorizados. A
permissão de acesso do Linux também impede que um programa mal intencionado, por exemplo, apague um arquivo que não deve,
envie arquivos para outra pessoa ou forneça acesso da rede para que outros usuários invadam o sistema. O sistema GNU/Linux é muito
seguro e como qualquer outro sistema seguro e confiável impede que usuários iniciantes (ou mal intencionados) instalem programas
enviados por terceiros sem saber para que eles realmente servem e causem danos irreversíveis em seus arquivos, seu micro ou sua
empresa.
O princípio da segurança no sistema de arquivos GNU/Linux é definir o acesso aos arquivos por donos, grupos e outros
usuários:
dono
É a pessoa que criou o arquivo ou o diretório. O nome do dono do arquivo/diretório é o mesmo do usuário usado para entrar no
sistema GNU/Linux. Somente o dono pode modificar as permissões de acesso do arquivo. As permissões de acesso do dono de um
arquivo somente se aplicam ao dono do arquivo/diretório. A identificação do dono também é chamada de user id (UID). A identificação
de usuário e o nome do grupo que pertence são armazenadas respectivamente nos arquivos /etc/passwd e /etc/group.
Grupo
Para permitir que vários usuários diferentes tivessem acesso a um mesmo arquivo (já que somente o dono poderia ter acesso ao
arquivo), este recurso foi criado. Cada usuário pode fazer parte de um ou mais grupos e então acessar arquivos que pertençam ao mesmo
grupo que o seu (mesmo que estes arquivos tenham outro dono). Por padrão, quando um novo usuário é criado, o grupo ele pertencerá
será o mesmo de seu grupo primário. A identificação do grupo é chamada de gid (group id).
Um usuário pode pertencer a um ou mais grupos. Para detalhes de como incluir o usuário em mais grupos veja o comando
adduser.
Outros
É a categoria de usuários que não são donos ou não pertencem ao grupo do arquivo. Cada um dos tipos acima possuem três
tipos básicos de permissões de acesso que serão vistas na próxima seção.
Tipos de permissões de arquivos
Quanto aos tipos de permissões que se aplicam ao dono, grupo e outros usuários, temos 3 permissões básicas:

•r
Permissão de leitura para arquivos. Caso for um diretório, permite listar seu conteúdo (através do comando ls, por exemplo).
•w
Permissão de gravação para arquivos. Caso for um diretório, permite a gravação de arquivos ou outros diretórios dentro dele.
Para que um arquivo/diretório possa ser apagado, é necessário o acesso a gravação.
•x
Permite executar um arquivo (caso seja um programa executável). Caso seja um diretório, permite que seja acessado através do
comando cd.
As permissões de acesso a um arquivo/diretório podem ser visualizadas com o uso do comando ls -la. As 3 letras (rwx) são
agrupadas da seguinte forma:
-rwxrwxrwx linuxuser linuxgroup arquivo.txt
A primeira letra diz qual é o tipo do arquivo. Caso tiver um “d” é um diretório, um “l” um link a um arquivo no sistema , um “-”
quer dizer que é um arquivo comum, etc.
Da segunda a quarta letra (rwx) dizem qual é a permissão de acesso ao dono do arquivo. Neste caso linuxuser ele tem a
permissão de ler (r - read), gravar (w - write) e executar (x - execute) o arquivo arquivo.txt.
Da quinta a sétima letra (rwx) diz qual é a permissão de acesso ao grupo do arquivo. Neste caso todos os usuários que pertencem
ao grupo users tem a permissão de ler (r), gravar (w), e também executar (x) o arquivo arquivo.txt.
Da oitava a décima letra (rwx) diz qual é a permissão de acesso para os outros usuários. Neste caso todos os usuários que não
são donos do arquivo arquivo.txt tem a permissão para ler, gravar e executar o programa.
Usa-se o comando chmod a mudar as permissões de acesso de arquivos/diretórios.
Modo de permissões octais

Uma outra forma de se utilizar os modos de permissão +r, -r, etc, pode ser usado o modo octal para se alterar/ler/configurar a
permissão de acesso a um arquivo. O modo octal é um conjunto de oito números onde cada número define um tipo de acesso diferente.
É mais flexível gerenciar permissões de acesso usando o modo octal ao invés do comum, pois você especifica diretamente a
permissão do dono, grupo, outros ao invés de gerenciar as permissões de cada um separadamente. Abaixo a lista de permissões de
acesso octal:
• 0 - Nenhuma permissão de acesso. Equivalente a -rwx.
• 1 - Permissão de execução (x).
• 2 - Permissão de gravação (w).
• 3 - Permissão de gravação e execução (wx).
• 4 - Permissão de leitura (r).
• 5 - Permissão de leitura e execução (rx).
• 6 - Permissão de leitura e gravação (rw).
• 7 - Permissão de leitura, gravação e execução. Equivalente a +rwx.
O uso de um deste números define a permissão de acesso do dono, grupo ou outros usuários. Um modo fácil de entender como
as permissões de acesso octais funcionam, é através da seguinte tabela:
1 = Executar
2 = Gravar
4 = Ler
O acesso a um arquivo/diretório é feito verificando primeiro se o usuário que acessará o arquivo é o seu dono, caso seja, as
permissões de dono do arquivo são aplicadas. Caso não seja o dono do arquivo/diretório, é verificado se ele pertence ao grupo
correspondente, caso pertença, as permissões do grupo são aplicadas. Caso não pertença ao grupo, são verificadas as permissões de
acesso para os outros usuários que não são donos e não pertencem ao grupo correspondente ao arquivo/diretório.
Após verificar aonde o usuário se encaixa nas permissões de acesso do arquivo (se ele é o dono, pertence ao grupo, ou outros
usuários), é verificado se ele terá permissão acesso para o que deseja fazer (ler, gravar ou executar o arquivo), caso não tenha, o acesso é
negado, mostrando uma mensagem do tipo: “Permission denied” (permissão negada). O que isto que dizer é que mesmo que você seja o
dono do arquivo e definir o acesso do dono (através do comando chmod) como somente leitura (r) mas o acesso dos outros usuários
como leitura e gravação, você somente poderá ler este arquivo mas os outros usuários poderão ler/grava-lo.
As permissões de acesso (leitura, gravação, execução) para donos, grupos e outros usuários são independentes, permitindo assim
um nível de acesso diferenciado. Lembre-se: Somente o dono pode modificar um arquivo/diretório!
Gerenciamento de Pacotes
Pacotes são programas colocados dentro de um arquivo incluindo arquivos necessários para a instalação do programa, um
sistemas de listagem/checagem de dependências, scripts de automatização para remoção parcial/total do pacote, listagem de arquivos,
etc.
O dpkg (Debian Package) é o programa responsável pelo gerenciamento de pacotes em sistemas Debian. Sua operação é feita

em modo texto e funciona através de comandos, assim caso deseje uma ferramenta mais amigável para a seleção e instalação de pacotes,
prefira o apt. O dpkg é muito usado por usuários avançados da Debian e desenvolvedores para fins de instalação, manutenção e
construção de pacotes. Um nome de pacote tem a forma nome-versão_revisão.deb
Dependências são pacotes requeridos para a instalação de outro pacote. Na Debian cada pacote contém um programa com uma
certa função. Por exemplo, se você tentar instalar o pacote de edição de textos supertext que usa o programa sed, você precisará verificar
se o pacote sed está instalado em seu sistema antes de tentar instalar o supertext, caso contrário, o pacote supertext pedirá o sed e não
funcionará corretamente. Note que o pacote supertext é apenas um exemplo e não existe (pelo menos até agora :-). O programa dselect
faz o trabalho de checagem de dependências automaticamente durante a instalação dos pacotes. A colocação de cada programa em seu
próprio pacote parece ser uma dificuldade a mais para a instalação manual de um certo programa. Mas para os desenvolvedores que
mantém os mais de 8710 pacotes existentes na distribuição Debian, é um ponto fundamental, porque não é preciso esperar uma nova
versão do supertext ser lançada para instalar a versão mais nova do pacote sed. Por este motivo também é uma vantagem para o usuário.
Instalação de aplicativos
O apt é sistema de gerenciamento de pacotes de programas que possui resolução automática de dependências entre pacotes,
método fácil de instalação de pacotes, facilidade de operação, permite atualizar facilmente sua distribuição, etc. Ele funciona através de
linha de comando sendo bastante fácil de usar. Mesmo assim, existem interfaces gráficas para o apt como o synaptic (modo gráfico) e o
aptitude (modo texto) que permitem poderosas manipulações de pacotes sugeridos, etc.
O apt pode utilizar tanto com arquivos locais como remotos na instalação ou atualização, desta maneira é possível atualizar toda
a sua distribuição Debian via ftp ou http com apenas 2 simples comandos!
É recomendável o uso do método apt no programa dselect pois ele permite a ordem correta de instalação de pacotes e checagem
e resolução de dependências, etc. Devido a sua facilidade de operação, o apt é o método preferido para os usuários manipularem pacotes
da Debian.
O apt é exclusivo da distribuição Debian e distribuições baseadas nela e tem por objetivo tornar a manipulação de pacotes
poderosa por qualquer pessoa.
O arquivo /etc/apt/sources.list
Este arquivo contém os locais onde o apt encontrará os pacotes, a distribuição que será verificada (stable, testing, unstable,
Woody, Sarge) e a seção que será copiada (main, non-free, contrib, non-US).
Etch(Debian 4.0) e Lenny(4.1) são os nomes das versões enquanto stable e unstable são links para as versões estável e testing
respectivamente. Se desejar usar sempre uma distribuição estável (como a Etch), modifique o arquivo sources.list e coloque etch como
distribuição.
Caso você desejar estar sempre atualizado mas é uma pessoa cuidadosa e deseja ter sempre a última distribuição estável da
Debian, coloque stable como versão. Assim que a nova versão for lançada, os links que apontam de stable para Etch serão alterados
apontando para Lenny e você terá seu sistema atualizado.
Abaixo um exemplo simples de arquivo /etc/apt/sources.list com explicação das seções:
deb http://www.debian.org/debian stable main contrib non-free
deb http://nonus.debian.org/debian-non-US stable non-US
Você pode interpretar cada parte da seguinte maneira:
• deb - Identifica um pacote da Debian. A palavra deb-src identifica o código fonte.
• http://www.debian.org/debian - Método de acesso aos arquivos da Debian, site e diretório principal. O caminho pode ser
http://, ftp://, file:/.
• stable - Local onde serão procurados arquivos para atualização. Você pode tanto usar o nome de sua distribuição (Etch,
Lenny) ou sua classificação (stable, testing). Note que unstable é recomendada somente para desenvolvedores, máquinas de testes e se
você tem conhecimentos para corrigir problemas. Nunca utilize unstable em ambientes de produção ou servidores críticos, use a stable.
• main contrib non-us - Seções que serão verificadas no site remoto. Note que tudo especificado após o nome da distribuição
será interpretado como sendo as seções dos arquivos (main, non-free, contrib, non-US). As linhas são processadas na ordem que estão
no arquivo, então é recomendável colocar as linhas que fazem referência a pacotes locais primeiro e mirrors mais perto de você para ter
um melhor aproveitamento de banda. O caminho percorrido pelo apt para chegar aos arquivos será o seguinte:
http://www.debian.org/debian/dists/stable/main/binary-i386
http://www.debian.org/debian/dists/stable/non-free/binary-i386
http://www.debian.org/debian/dists/stable/contrib/binary-i386
Você notou que o diretório dists foi adicionado entre http: //www.debian.org/debian e stable, enquanto as seções main, non-free
e contrib são processadas separadamente e finalizando com o caminho binary-[arquitetura], onde [arquitetura] pode ser i386, alpha,
sparc, powerpc, arm, etc. dependendo do seu sistema. Entendendo isto, você poderá manipular o arquivo sources.list facilmente.
OBS: Caso tenha mais de uma linha em seu arquivo sources.list de onde um pacote pode ser instalado, ele será baixado da
primeira encontrada no arquivo. Ë recomendável colocar primeiro repositórios locais ou mais perto de você, como recomendado nesta
seção.
Segue abaixo uma relação de servidores que podem ser colocados em seu arquivo sources.list:

ftp://ftp.debian.org.br/debian
ftp://ftp.br.debian.org/debian
ftp://ftp.debian.org/debian
ftp://download.sourceforge.net/debian
ftp://ftp.quimica.ufpr.br/debian
ftp://download.unesp.br/linux/debian
Um modelo de arquivo sources.list

Você pode copiar o modelo do sources.list abaixo para ser usado em sua distribuição Stable ou personaliza-lo modificando a
distribuição utilizada e servidores:
# Arquivos principais da stable

deb ftp://ftp.debian.org.br/debian stable main non-free contrib
# Non-US da Stable
deb ftp://ftp.debian.org.br/debian-non-US stable/non-US main non-free contrib
# Atualizações propostas para Stable main e non-US
deb ftp://ftp.debian.org.br/debian dists/proposed-updates/
deb ftp://ftp.debian.org.br/debian-non-US dists/proposed-updates/
# Atualizações de segurança da Stable
deb ftp://nonus.debian.org/debian-security stable/updates main
# Ximian é um conjunto de pacotes atualizados freqüentemente e compatíveis
# com a distribuição Debian. Entre estes programas estão o Gimp 1.2 e outros
# mais atuais e compatíveis com a Debian. Para usa-los inclua a seguinte linha
# seu sources.list
# deb ftp://spidermonkey.ximian.com/pub/red-carpet/binary/debian-22-i386/ ./
Atualizando sua distribuição

O apt tem uma grande característica: Atualizar toda a sua distribuição de uma forma inteligente e segura. O apt lê a listagem de
pacotes disponíveis no servidor remoto, verifica quais estão instalados e suas versões, caso a versão do pacote seja mais nova que a já
instalada em seu sistema, o pacote será imediatamente atualizado.
A cópia dos arquivos pelo apt pode ser feita via FTP, HTTP ou através de uma cópia local dos arquivos no disco rígido (um
mirror local). Em nenhuma circunstância os pacotes existentes em seu sistema serão removidos ou sua configuração apagada durante um
upgrade na distribuição.
Os arquivos de configuração em /etc que foram modificados são identificados e podem ser mantidos ou substituídos por versões
existentes nos pacotes que estão sendo instalado, esta escolha é feita por você.
Após isto, a atualização da distribuição Debian pode ser feita através de dois simples comandos:
apt-get update #Para atualizar a lista de pacotes (obrigatório)
apt-get -f dist-upgrade #Para atualizar a distribuição
A opção -f faz com que o apt verifique e corrija automaticamente problemas de dependências entre pacotes. Recomendo executa
o comando apt-get -f –dry-run dist-upgrade|less para ver o que vai acontecer sem atualizar a distribuição, se tudo ocorrer bem, retire o --
dry-run e vá em frente.
A distribuição usada na atualização pode ser:
Instalando novos pacotes

Use o comando apt-get install [pacotes] para instalar novos pacotes em sua distribuição. Podem ser instalados mais de um
pacotes ao mesmo tempo separando os nomes por espaços. Somente é preciso especificar o nome do pacote (sem a versão e revisão).
Se preciso, o apt instalará automaticamente as dependências necessárias para o funcionamento correto do pacote. Quando
pacotes além do solicitado pelo usuário são requeridos para a instalação, o apt mostrará o espaço total que será usado no disco e
perguntará ao usuário se ele deseja continuar. Após a instalação, o pacote será automaticamente configurado pelo dpkg para ser
executado corretamente em seu sistema.
Removendo pacotes instalados

Use o comando apt-get remove [pacotes] para remover completamente um pacote do sistema. Podem ser removidos mais de um
pacote ao mesmo tempo separando os nomes dos pacotes com espaços. O apt-get remove remove completamente o pacote mas mantém
os arquivos de configuração, exceto se for adicionada a opção –purge. É preciso especificar somente o nome do pacote (sem a versão e
revisão).

Serviços básicos
Servidor dhcp
Quando temos uma rede pequena, somente com alguns poucos dispositivos, é possível você associar um
IP fixo a cada máquina - e saber quem é quem. Porém quando a rede cresce, fica difícil manter na memória
todos os ips da rede.
Conceitos e instalação
O DHCP (Dynamic Host Configuration Protocol) é definido na RFC 2131
(http://www.ietf.org/rfc/rfc2131.txt) e tem como objetivo definir um modo de passar informações para outros
hosts em uma rede TCP/IP. É baseado num antigo protocolo chamado BOOTP (ainda usado em boot de
estações diskless).
Frequentemente o DHCP é usado para fornecer dinamicamente um endereço IP para outros dispositivos de rede, porém o DHCP
pode fornecer outras informações, tais como: IP, DNS, nomes de domínios, gateways e até uma imagem do sistema operacional para
que a máquina inicie.
Em Linux, o servidor DHCP mais utilizado é o ISC-DHCPD, da Internet Software Consortium
(http://www.isc.org), de configuração fácil.
Configuração básica e avançada

O arquivo de configuração principal do DHCP é o /etc/dhcpd.conf. Lembrando que este arquivo usa blocos de configuração, ou
seja, as linhas de configuração tem lugares diferentes para serem colocados. As linhas de configuração são organizadas por blocos
delimitados por '{' e '}'.
Antes de tudo a interface de rede do servidor linux que servirá de servidor de DHCP deverá estar configurada e ativa. Neste
exemplo, usaremos a classe de ips 192.168.99.0/255.255.255.0 e nosso servidor terá o IP 192.168.99.254. Nesta rede de exemplo
também usaremos como gateway o IP 192.168.99.1 mas nada impede que a mesma máquina que seja o servidor de DHCP seja também
o gateway da rede.
No arquivo /etc/dhcpd.conf devemos declarar todas as subnets que compõem a rede. Na declaração da subnet declaramos
também a máscara de rede.
Subnet 192.168.99.0 netmask 255.255.255.0{
...
}
Dentro do bloco subnet podemos colocar várias opções, entre elas:

routers: especificando o(s) gateways da rede. Se houver mais de um gateway os ips devem ser separados por virgulas.
Subnet-mask: a máscara de rede que o DHCP vai enviar para o cliente.
Domain-name: Nome de domínio de DNS da maquina de destino.
Domain-name-servers: Especifica os servidores de DNS que o host deverá usar.
Default-lease-time: Define o tempo(em segundos) padrão em que o servidor de DHCP “emprestará” o IP ao host. Após esgotado
este tempo o host deverá “Pedir um novo empréstimo” ao servidor.
Max-lease-time: Define o tempo(em segundos) máximo que o servidor de DHCP poderá emprestar o IP ao host.
range dynamic-bootp: define o range de IPS que o servidor DHCP usará para emprestar aos hosts da rede. A definição é feita
colocando o primeiro IP disponível e o último separados por um espaço.
À seguir um exemplo de configuração básica de um servido DHCP(dhcpd.conf).

Subnet 192.168.99.0 netmask 255.255.255.0{
option routers 192.168.99.1;
option subnet-mask 255.255.255.0;
option domain-name “curso.linux.org”;
option domain-servers 192.168.99.2, 192.168.99.3;
default-lease-time 300;
max-lease-time 600;
range dynamic-bootp 192.169.99.128 192.168.99.253;
}
Uma característica interessante do servidor DHCP é que podemos ter hosts com IPS dinâmicos mas que sempre pagarão o
mesmo IP. Essa configuração é feita usando sub-blocos “host” dentro do bloco subnet. Ao declarar um bloco host é necessário fornecer

tanto o IP quanto o endereço MAC do host de destino. Exemplo a seguir:
host always10{
hardware ethernet 00:0a:0b:0c:0d;
fixed-address 192.168.99.10;
}
Assim desta maneira, o host com o MAC 00:0a:0b:0c:0d sempre receberá o IP 192.168.99.10. O nome always10 não faz sentido
algum para o DHCP ele é apenas uma sequência de caracteres para que o administrador identifique o host, no entanto ele não deve
conter caracteres especiais nem espaços.
Uma implementação de segurança frequentemente utilizada é fazer com que o DHCP não “empreste” ips à host desconhecidos
na rede. Para tanto é necessário que o administrador cadastre todos os hosts da rede no servidor dhcp e depois disso basta usar a opção
deny unknown-clients. Segue abaixo um exemplo de configuração para essa nova implementação:
Subnet 192.168.99.0 netmask 255.255.255.0{
option routers 192.168.99.1;
option subnet-mask 255.255.255.0;
option domain-name “curso.linux.org”;
option domain-servers 192.168.99.2, 192.168.99.3;
default-lease-time 300;
max-lease-time 600;
range dynamic-bootp 192.169.99.128 192.168.99.253;
host always10{
}
host always11{
}
deny unknown-clients;
}
Servidor de DNS
O DNS (Domain Name System - Sistema de Nomes de Domínios) é um sistema de gerenciamento de nomes. O servidor DNS
traduz nomes para os endereços IP e endereços IP para nomes respectivos, e permitindo a localização de hosts em um domínio
determinado. Num sistema livre o serviço é implementado pelo software BIND.
Conceitos e instalação
Um software de DNS é importantíssimo para as redes locais. quando um cliente tenta acessar um site o sistema do cliente faz
uma consulta a um servidor de dns para descobrir o endereço IP do servidor do site. Caso essa consulta seja feita em um servidor de
DNS distante isso irá acarretar em uma demora na conexão e posteriormente uma insatisfação de seu cliente.
O servidor de DNS pode fazer cache de consultas, ou seja, caso um cliente tente resolver um domínio e posteriormente outro
faça outra consulta sobre o mesmo domínio, este segundo irá se beneficiar da consulta que o primeiro fez e o servidor de DNS irá fazer
somente uma consulta para fora da sua rede local, economizando recursos.
No linux há varios softwares servidores de DNS, o mais conhecido entre eles é o BIND(Berkeley Internet Name Domain). Em
nosso curso usaremos o BIND na versão 9.
Para instalar basta usar o apt-get:
apt-get install bind9
O bind assim que instalado já está pronto para ser usado como servidor de DNS
Configuração avançada
O arquivo principal de configuração do BIND é o “/etc/bind/named.conf”, porém neste curso iremos fazer um servidor de DNS
caching-only( um servidor que apenas resolve nomes e faz cache de consultas), para isso iremos fazer nossas alterações somente em
algumas opções do BIND.
O arquivo do BIND que iremos editar é o “/etc/bind/named.conf.options”. Esse arquivo, por padrão vem com o seguite
conteúdo:
options {
directory "/var/cache/bind";
auth-nxdomain no;
listen-on-v6 { any; };
};

Atenção: O arquivo de configuração do BIND é super rigoroso. Nele não devemos usar espaços. E além disso que há seções que
começam com “{“ e terminam com “};” . Não devemos nos perder na configuração deste arquivo.
Por padrão o BIND vem configurado para responder a qualquer consulta de DNS de qualquer cliente(mesmo que não seja seu).
Para evitar que nosso servidor seja usado como servidor de DNS de outros vamos usar alguns recursos do BIND. Primeiro
vamos criar uma ACL para dizer ao BIND quais endereços estão permitidos a consultar nosso DNS.
acl minhasredes {
127.0.0.1/24;
192.168.99.0/24;
}
Agora dentro da seção “options” vamos dizer ao BIND o que fazer:
allow-recursion { minhasredes; };
recursion no;
Agora nosso BIND já está com uma configuração básica funcional e segura:
acl minhasredes {
127.0.0.1/24;
192.168.99.0/24;
}
options {
directory "/var/cache/bind";
auth-nxdomain no;
listen-on-v6 { any; };
allow-recursion { minhasredes; };
recursion no;
};
O BIND têm muitas utilidades e recursos que não fazem parte do escopo deste curso. Esse é apenas o indispensável para o seu
funcionamento.

Servidor Proxy(Squid).
Conceitos
A World Wide Web (WWW) é, sem a menor dúvida, a forma mais conhecida da internet. Tanto isso é verdade, que os leigos
tem uma certa dificuldade em entender que a internet não se resume ao www. Sua popularidade e crescimento são explicados pela
grande variedade de assuntos encontrados nela, pela facilidade de busca, simples entendimento, baixo custo e, via de regra, privacidade.
Em decorrência dessa grande procura alguns efeitos colaterais ocorrem. Não é incomum ouvir as pessoas dizerem que "a internet
está lenta", ou os administradores de rede observarem seus backbones atingirem seus limites em horários de pico. Do lado dos
servidores e ISPs (Internet Service Providers) também existe um lado que poucas pessoas pensam. Somente quem já passou pelo "Efeito
Slashdot1" sabe do que estou falando. Em um momento de sobrecarga dos servidores, como ocorreu na última copa do mundo ou no
tenebroso 11 de setembro, um sistema de caches bem planejado e distribuído seria muito bem visto pelos grandes portais.
A utilização de sistemas de cache, como o Squid, têm se mostrado excelentes para aliviar esses sintomas, reduzindo o tráfego na
rede e, conseqüentemente, a latência da mesma.
Toda a idéia por trás de um sistema de caching é criar um grande banco de dados onde os sites mais populares ou acessados
recentemente são armazenados para futuras consultas. Isso significa que se 10 usuários da sua rede tentarem acessar um mesmo site ao
mesmo tempo, somente uma das conexões realmente irá ser feita a esse site. Todas as outras 9 vão se aproveitar do primeiro acesso e
utilizar a página já em memória. Isso é um enorme ganho de desempenho para seu backbone local, para o backbone do ISP onde o site
está armazenado e para o servidor que hospeda o mesmo.
Além disso, sua banda fica livre para que sites menos acessados, ou que não estejam no cache sejam baixados com maior
velocidade.
Com um sistema de caching bem planejado e mantido, todos tem a ganhar.
São vários os benefícios entre eles podemos citar:
• Velocidade de acesso
A melhor forma de verificar se o seu cache está sendo eficiente é pela velocidade. Um sistema de cache que não agrega
velocidade não está cumprindo o seu papel.
• Disponibilidade
De nada adianta um sistema veloz disponível apenas 2 horas por dia, ou mesmo que precise de um reboot a cada 2 semanas. Em
casos de grandes instalações, ainda é preciso ir mais a fundo, buscando a altíssima disponibilidade. Redundância de servidores, backup,
eliminação de ponto único de falha e disaster recover são uma exigência.
• Transparência ou Ostensividade
São conceitos específicos e que se adaptam a cada caso. Grandes instalações, ISPs e empresas não preocupadas com que seus
usuários vêem ou fazem na internet devem preferir a transparência, onde o usuário desconhece ou não se sente afetado (exceto pelo
ganho de velocidade) pela presença de um cache.
Por outro lado, empresas com uma política de segurança mais rígida, órgãos com informações críticas, ou mesmo pais querendo
controlar o acesso de seus filhos a alguns sites, vão preferir a ostensividade.
• Capacidade de trabalhar com redes heterogêneas.
Alguns sistemas de proxy/cache funcionam baseados com sistemas de autenticação especiais, feitos para rodar somente em uma
plataforma, fazem integração com o serviço de diretórios daquele ou desse sistema ou exigem que o usuário esteja rodando a versão
XYZ do fabricante ABC e deixam todos os outros a ver navios. Em uma instalação séria, é preciso que usuários de todas as plataformas
que saibam como trabalhar com HTTP sejam bem atendidos.
• Simplicidade
Deixando um pouco de lado o usuário e focando no administrador, é preciso ter consciência de que um sistema bom é um
sistema fácil de administrar. O mais rápido, mais disponível e mais abrangente sistema de caching é totalmente inútil se somente uma
pessoa no mundo souber lidar com ele.
Podemos dizer que existem dois grandes motivos pelo qual se deve utilizar um PROXY/CACHE:
• Controle de acesso
Com a internet cada vez mais acessível a pequenas e médias empresas, um número imenso de pessoas está se interligando a
internet. Além de todos os benefícios trazidos por ela, como informação em tempo real, comunicação mundial a baixo custo, contato
com possíveis clientes e fornecedores por todo o mundo, a mesma trouxe alguns problemas.
As pessoas tendem a passar cada vez mais tempo navegando por sites não relativos ao seu trabalho primário, acessam sites que
não condizem com a política da empresa, utilizam a banda de internet destinada a serviços como WEB ou VPN e podem, em muitos
casos, acabar infectando toda a rede da empresa com vírus e worms que são adquiridos em sites impróprios. Isso sem contar na ameaça
sempre presente de propagação de downloads de softwares piratas e músicas, fatores que podem complicar a vida de uma empresa
durante fiscalizações.
De acordo com a Rede Nacional de Ensino e Pesquisa (RNP) , 65% da largura de banda das empresas é utilizada em navegação

WEB. E esse número tende a crescer.
• Performance
Como dissemos anteriormente, a internet está mais acessível para todos, fator causado pela ampla utilização das conexões de
banda larga, como xDSL, Cable Modem, ISDN, etc.
Essas tecnologias são excelentes para pequenas e médias empresas, mas devido a suas características de velocidades diferentes
de upstream e downstream (xDSL), compartilhamento de banda total (Cable Modem) ou baixo desempenho (ISDN), além da notável
falta de qualidade das operadoras, tornam−se quase inúteis para grandes empresas e provedores de internet (ISPs).
Essas empresas são então levadas a utilizar sistemas de maior qualidade, como links por fibra ótica, satélites e rádio. Mas como
se pode esperar, qualidade tem preço, e, nesse caso, bem salgado. Visando aproveitar ao máximo essa banda de qualidade, a utilização
de PROXY/CACHE torna−se quase que obrigatória. Ainda de acordo com a Rede Nacional de Ensino e Pesquisa (RNP) − 2, a
utilização de PROXY/CACHE pode gerar uma economia entre trinta e cinqüenta por cento nos horários de pico. Isso significa que para
um link de 2 Mbps que está operando a plena carga e considerando uma redução de 30 %, o mesmo produziria um ganho na banda
agregada de aproximadamente 600 Kbps. Ou seja, a simples implementação de um PROXY/CACHE bem ajustado gera uma economia
da ordem de milhares de Reais por mês para a empresa. Conexões são feitas no Proxy, evitando saída à internet.
O Squid está continuamente melhorando sua performance, além de adicionar novas features e ter uma excelente estabilidade em
condições extremas. Sua compatibilidade com várias plataformas e a imensa gama de software para analisar logs, gerar relatórios,
melhorar o desempenho e adicionar segurança providos pela comunidade open source, combinados com ferramentas de administração
simplificada e baseadas em web agregam grande valor ao produto.
Podemos ainda citar a capacidade de clustering, transparent proxy, cache de FTP e, é claro, seu baixo custo. Para os mais
corajosos, ou para os melhores programadores, não podemos deixar de dizer que o sistema é totalmente aberto, possibilitando a sua
otimização no nível de código, além da otimização via configuração.
Instalação
Em sistemas debian a instalação é muito simples: apt-get install squid
Configuração
O arquivo de configuração do squid é o squid.conf, normalmente ele se encontra em /etc/squid/squid.conf
Pode parecer fútil, mas uma limpeza inicial no arquivo squid.conf pode ser bem útil. O arquivo de configuração original tem, em
média um pouco mais de 2000 linhas. Porém para quem ainda está aprendendo a configurar é bom dar uma lida no arquivo todo.
# cp squid.conf squid.conf.original
# egrep −v "^#|^$" squid.conf.original > squid.conf
As regras contidas no squid.conf são interpretadas de cima para baixo. Ou seja, a ordem de onde você as coloca interfere no
resultado.
Proxy transparente
Esse recurso é muito útil para evitar que seus usuários "burlem" o proxy removendo as configurações do browser. Eles serão
obrigados a passar pelo proxy, mesmo que as máquinas não estejam configuradas para tal.
Extremamente recomendado, principalmente em casos de bloqueio de sites ou limitação de banda. Experiências pessoais
comprovam que usuários com um pouco mais de conhecimentos irão remover a configuração de proxy assim que o administrador sair
da sala, seja por ignorância das funcionalidades, seja por medo de ser auditado ou simplesmente por má conduta.
Para ser possível o uso de proxy transparente com o Squid, o firewall deve ser configurado adequadamente. Algumas pessoas
desejam trabalhar ao mesmo tempo com autenticação e proxy transparente. Isso é possível de ser feito com uma interação entre o
firewall e um cgi, ou algo do gênero.
ACLs
O conceito de ACL é muito útil, por nos permitir trabalhar com níveis de acesso baseados em diversas informações. Não é
incomum que em uma instalação de Squid, a diretoria possa acessar qualquer site, a gerência não possa acessar determinados sites e os
"peões" tenham acesso apenas ao site da empresa e de parceiros. Graças ao uso de ACLs e um pouco de imaginação e suor, podemos
fazer todas essas restrições.
Todas as configurações de usuários, grupos, horários e SITES são configuradas em ACLs. A ordem em que as ACLs aparecem é
muito importante, por isso a ACL que bloqueia os sites deve ser a primeira a aparecer.
Procure no seu squid.conf onde começam a ser descritas as ACLs. Geralmente a primeira ACL a aparecer é:
acl all src 0.0.0.0/0.0.0.0
As ACLs podem ser escritas tendo como base uma série de propriedades contidas nos cabeçalhos HTTP. Entre eles podemos

citar: URL, Endereço de origem, domínio de destino, endereço MAC, dia da semana, numero de conexões, etc...
Exemplo de Configuração
Eis um exemplo de arquivo de configuração do squid.conf com explicações importantes no final. Neste arquivo de exemplo
suprimimos algumas linhas para explicá-las mas detalhadamente no final.
OBS.: O squid lê o arquivo de configuração de cima para baixo. E em muitos casos a ordem das linhas faz diferenca.
(Opções de rede)
http_port 3128 transparent
acl QUERY urlpath_regex cgi-bin \?
cache deny QUERY
hierarchy_stoplist cgi-bin ?
acl apache rep_header Server ^Apache
broken_vary_encoding allow apache
(opções de logging, memória e disco)
cache_mem 800 MB
cache_dir diskd /var/spool/squid 10000 16 256
access_log /var/log/squid/access.log squid
hosts_file /etc/hosts
refresh_pattern ^ftp: 1440 20% 10080
refresh_pattern ^gopher: 1440 0% 1440
refresh_pattern . 0 20% 4320
acl all src 0.0.0.0/0.0.0.0
acl manager proto cache_object
acl localhost src 127.0.0.1/255.255.255.255
acl to_localhost dst 127.0.0.0/8
acl SSL_ports port 443
acl Safe_ports port 80
acl Safe_ports port 1025-65535
acl purge method PURGE
acl CONNECT method CONNECT
http_access allow manager localhost
http_access deny manager
http_access allow purge localhost
http_access deny purge
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports
(Explicações sobre acls)
http_reply_access allow all
always_direct allow all
Agora vamos as opções interessantes da configuração
Opções de rede
• http_port 3128 transparent
Esta opção especifica a porta que o squid irá escutar. Por padrão é a 3128. O parâmetro “transparent” especifica que o squid
poderá fazer proxy transparente.
• acl QUERY urlpath_regex cgi-bin \?
cache deny QUERY
Essas duas linhas faz com que o squid não faça cache de urls que fazem parte de uma consulta HTTP. Como essas urls não são
na verdade arquivos não é uma boa idéia cacheá-los.

Opções de logging, memória e disco.
• cache_mem 800 MB
cache_mem especifica a quantidade de memória RAM que os squid poderá alocar permanentemente para objetos. Isso não
significa que o squid não passará deste limite. O uso da memória é feito conforme a necessidade.
• cache_dir diskd /var/spool/squid 10000 16 256
cache_dir manipula o diretório dos arquivos onde o squid guarda os arquivos que não podem ser mantidos na memória RAM.
Com o parâmetro diskd o squid usará dois processos(programas) separados coordenar o processo de leitura e escrita de arquivos
no disco.
/var/spool/squid é o diretório onde os arquivos serão gravados. É interessante que você separe na hora da instalação uma partição
específica para este fim. Essa partição preferencialmente deve ter sistemas de arquivos reiserfs e com as opções notail e noatime pois
aumenta a performance do sistema.
10000 significa que o squid poderá usar até 10000 MB de disco para armazenar os objetos;
16 e 156 são o número de diretório e subdiretórios que os squid irá criar no diretório acima, por motivos de limite de número de
arquivos por diretório.
Explicações sobre ACLs

ACLs é um assunto transversal, você pode notar que em várias partes do squid.conf aparecem ACLS. Com base em uma ACL
podemos negar ou permitir o acesso do cliente ao determinado site.
Primeiro vamos começar a definir as ACLs. Todas as ACLs têm a seguinte forma:
acl nomeACL tipoACL [ -i ] String1 [String2 [Strings] ]
ou
acl nomeACL tipoACL [- i ] “Arquivo”
Strings significam caracteres que devem serem compatíveis com o tipoACL usado. podemos usar várias Strings e separá-las por
espaços e colocá-la toda em uma mesma linha. Caso uma ACL esteja ficando grande podemos colocar as strings em um arquivo(uma
string por linha) separado.
Mas vamos aprender melhor como definir ACLs por exemplos explicando os tipos de ACLs:
• por endereço IP de origem
acl porip src 192.168.99.10 10.1.1.0/24
Essa regra irá “bater” com todos os acessos cujos endereços IPS dos clientes seja o IP 192.168.99.10 ou a rede 10.1.1.0/24.
• por endereço IP de destino
acl poripdestino dst 200.200.200.1 201.4.4.0/24
Essa ACL retornará verdadeiro caso o endereço IP de destino seja o IP 200.200.200.1 ou a rede 201.4.4.0/24
• endereço MAC do cliente
acl pormac arp 00:0a:0b:0c:0d:0e
Essa ACL so retornará verdadeiro caso o endereço MAC seja o MAC 00:0a:0b:0c:0d:0e.
Lembrando que para fazer ACLs de MAC é necessário que o cliente esteja na mesma rede que o squid, pois senão o squid não
será capaz de identificar o endereço MAC.
• domínio de destino
acl pordominio dstdomain uol.com.br
Essa regra só irá “bater” caso o site que o cliente esteja querendo acessar faça parte do domínio uol.com.br
• por horário
Para especificar o horário precisaremos aprender as siglas dos dias da semana:
S –Domingo(Sunday) , M – Segunda-feira(Monday), T – Terça-Feira(Tuesday), W – (Quarta-feira(Wednesday), H -Quinta-
feira(Thursday), F – Sexta-feira(Friday), A - Sábado(Saturday).
As ACLs por horário têm o seguinte formato
acl porhorario time MTWHF 12:00-13:00
Essa ACL irá conferir com todos os acessos nos dias de Segunda a Sexta e no horário das 12:00 as 13:00.

• por url
Quando fazemos ACLs por url podemos especificar apenas alguns trechos da url, por exemplo:
acl porurl url_regex -i .mp3 .mp4 .mpeg
Essa ACL irá conferir com todas as url contenham essas extensões de arquivos.
Agora que aprendemos como construir ACLs vamos usá-las para controlar o acesso a internet através de nosso proxy squid. Para
isso usaremos a tag(linha de configuração) http_access.
http_access allow|deny acl1 [acl2 [acl3 ] ]
Sendo que allow ou deny deve ser mencionado para bloquear ou permitir o acesso. Caso coloquemos mais de uma ACL na linha
http_access o acesso só será permitido ou bloqueado caso todas as ACLs “batam”. Caso quisermos que uma regra não case com uma
ACL podemos colocar um “!” antes da ACL.
Imagine o caso simples, todos os clientes de nossa rede podem acessar a internet sem restrições de acesso:
acl mynetwork src 192.168.99.0/24
http_access allow mynetworks
http_access deny all
Simples. Vamos agora implementar uma restrição onde os usuários só podem acessar o domínio orkut.com no horário de
almoço.
acl orkut dst_domain orkut.com
acl horariopermitido time MTWHF 12:00-14:00
http_access deny orkut !horariopermitido
Mais ou menos. Observe que agora estamos usando para bloquear o orkut em horário não permitido. Agora vamos aumentar o
tamanho, imagine que um cliente deve não ter nenhum acesso, um cliente privilegiado não dever ter restrição alguma. E
devemos bloquear várias extensões de arquivos.
acl orkut dst_domain orkut.com
acl horariopermitido time MTWHF 12:00-14:00
acl privilegiado src 192.168.99.2
acl semacesso arp 00:01:02:03:04:05
acl extensoes url_regex -i “/etc/extensoes”
http_access deny semacesso

http_access allow privilegiado
http_access deny extensoes
http_access deny orkut !horariopermitido
Observe que a ordem em que colocamos as linhas http_access são importantes. Se a linha “http_access allow privilegiado”
viesse primeiro aconteceria que se o cliente que não deve ter acesso colocasse o IP em sua máquina ele teria acesso facilmente.
Observe também que sempre no final de nossas regras sempre colocamos “http_access deny all” pois o cliente que não pertence
a nossa rede(http_access allow mynetworks) não deve ter acesso. Observe também que não foi necessário especificar a ACL all pois ela
já é declarada no squid.conf(acl all src 0.0.0.0/0.0.0.0).

Servidor de arquivos(SaMBa)
Conceitos
O SMB é um acrônimo para Server Message Block, ou Servidor de Bloco de Mensagens. Ele é o protocolo usado em redes
Microsoft para compartilhamento de recursos, como impressoras e discos.
O samba é composto por uma série de programas que permitem que estações clientes acessem discos e impressoras
compartilhadas em um servidor usando os protocolos SMB e CIFS(Common Internet Filesystem). Através desses protocolos
um servidor Linux comporta-se como em servidor LAN Server ou Windows NT. Desta forma, os recursos compartilhados
podem ser acessados por uma série de clientes na rede.
PDC-Controlador primário de domínio

O PDC guarda um banco de dados que vale para todo o domínio no qual estão armazenadas as mais diversas informações
sobre um domínio, a maioria delas geralmente relacionada com usuaários e suas permissões.
Workgroups
Um grupo de trabalho é uma coleção de máquinas que implementam o protocolo NetBIOS. Não existe hierarquia de máquinas
dentro de um grupo de trabalho. Cada Computador é dono e responsável por seus próprios recursos. Não existe gerenciamento
centralizado de usuários, senhas ou permissões.
É claro que se pode exigir autenticação por usuário/senha no acesso aos recursos. Mas não existe nada que impeça que um
usuário libere totalmente o acesso aos recursos de sua máquina.
Domínios
Os domínios são workgroups onde existem uma hierarquia, ou separação entre clientes e servidores, sendo que essa hierarquia é
garantida pelo protocolo.
A primeira adição ao conceito de workgroups é o navegador-meste de domínios, que tem de ser indicado explicitamente pelo
administrador. Compeensivelmente, essa função é acumulada pelo PDC.
Um outro aspecto dos domínios é o login do domínio. Isso faz mais sentido quando as máquinas clientes são windows. Para
entrar no domínio, o usuário precisa digitar um usuário/senha válidos, do contrário não poderá ter acesso a nenhum servidor SMB, e
talvez nem à sua própria máquina. Note como isso é diferente de um workgroup onde basta digitar um par usuário/senha no windows
que terá acesso a todos os recursos da rede.
Outro aspecto do login de domínio é o profile, que poderá ficar armazenado no servidor de domínio. Seja qual for a máquina que
o usuário estiver logado, receberá seu próprio ambiente de trabalho, com letras e cores de seu gosto e com as restrições impostas pelo
administrador.
O domínio permite a agregação de servidores com administração centralizada. Ou seja, um computador pode ser definido como
servidor pertencente ao domínio. O acesso dos usuários aos recursos do servidor é cadastrado no servidor.
Instalação
A instalação é simples baseando-se que você está usando o apt-get install samba. Isso fará com que o apt instale o servidor
samba(samba-server), porém aconselha-se instalar também o pacote smbfs.
Arquivo de configuração
O arquivo de configuração do samba é o smb.conf que geralmente está localizado no diretório /etc/samba. Este arquivo é
basicamente dividido em três seções: a configuração do servidor samba(seção [global]), a configuração dos diretórios pessoais dos
usuários(seção [homes]) e as demais seções que representam os diretórios compartilhados e as impressoras. Dentro das seções podem
ser colocadas várias opções como no exemplo a seguir.
[global]
log level = 1
guest ok = no
workgroup = linux
...
[compartilhamento1]
path = /home/samba
Observe que não existem marcações de início e fim de uma seção. As opcões são lidas e são consideradas pertencentes a última

seção declarada.
Uma outra característica que o samba fornece são um conjunto completo de variáveis. Essas variáveis(que sempre começam
com um sinal de porcentagem %). Elas podem ser usadas em opções para refletir maneiras diferentes de comportamento do samba
baseados em certas características do servidor, do cliente, do usuário, ou do sistema operacional do usuário.
A tabela a seguir mostra algumas variáveis que podem ser usadas para a configuração do smb.conf
Variável Significado
%I(i maiúsculo) Endereço IP do cliente
%m Nome NetBIOS do cliente
%u Nome do usuário
%U Nome do usuário NetBIOS, pode ser diferente de %u
%g Grupo primário linux de %u
%H Diretório home de %u
%h Nome de DNS da maquina na qual o samba está rodando.
%L Nome NetBIOS do servidor samba
%v Versão do samba
%S Nome do serviço corrente
Exemplos de utilização de variáveis:

server string = Samba %v em %L
netbios name = supertux
Essa configuração faria com que as maquinas windows que varressem a rede vissem por exemplo uma máquina com nome
supertux e cujo comentário é “Samba 3.0.3 em supertux”.
Níveis de segurança
Cada vez que um usuário tenta se conectar a um compartilhamento que não permite convidados, ele deve fornecer uma senha
para tornar possível a conexão. O que o SAMBA faz com a senha e consequentemente qual a estratégia ela usará para lidar com a
autenticação de usuários, e por consequência seu nível de segurança será configurado através da opção security. Há quatro opções share,
user, server e domain.
Security= share
Com este nível de segurança, se algum recurso for configurado como compartilhado, ele será compartilhado ara todo mundo. Ele
difere dos outros modos de segurança, pois nele não há restrições quanto a quem pode acessar o compartilhamento.
É possível associar uma ou mais senhas a um recurso e não por usuário, ou seja, cada diretório ou impressora poderá ter uma
senha ou mais senhas conhecidas pelos usuários autorizados.
Por exemplo, uma senha pode garantir acesso apenas leitura, enquanto outra pode garantir acesso de escrita e assim por em
diante. A segurança será mantida enquanto usuários não autorizados não descobrem a senha para um compartilhamento que não devem
ter acesso.
Security= user
Este é nível de segurança de usuário; com este método, a cada compartilhamento são designados usuários que podem acessar.
As permissões são dadas de acordo com o nome do usuário, ou através dos grupos criados. Logo após a negociação de
protocolos, a todo usuário é solicitado informar um nome de usuário e senha, e estes seriam usados para logar-se no servidor linux. O
SAMBA fará a autenticação através da validação do nome de usuário e senha com os usuários autorizados no banco de dados do
SAMBA. O servidor poderá aceitar ou não a combinação. Repare que neste estágio o servidor não tem idéia de qual compartilhamento o
cliente irá eventualmente tentar conectar, por isso, ele não só poderá basear sua decisão de aceitar ou não a combinação em nome de
usuário e senha e a máquina do cliente.
Se o servidor aceitar o nome de usuário e senha o cliente espera ser capaz de montar qualquer compartilhamento sem especificar
uma senha, pois todos os direitos de acesso são especificados na hora da conexão.
security=server
Este é o nível de segurança de servidor. É parecido com o de usuário, mas outro servidor SAMBA ou Windows é utilizado para
autenticar o usuário, normalmente outro servidor SAMBA ou Windows NT agindo como PDC na rede. Se este servidor se este servidor
tiver um nível de segurança de usuário e aceitar a senha, o SAMBA aceita a conexão do cliente. Este servidor é definido dentro da seção
global na opção “password server”, onde é fornecido seu nome NetBIOS.
Quando um cliente tenta fazer uma conexão a um compartilhamento em particular, o SAMBA valida se o usuário é realmente

autorizado a conectar ao compartilhamento contactando o servidor de senhas SAMBA através de um protocolo conhecido. Se a senha
for aceita, uma seção será estabelecida com o cliente.
Security= domain
Este é o nível de segurança de domínio e é parecido com o servidor, só que o SAMBA agirá como membro do domínio
Windows.
Cada domínio Windows tem um controlador de domíno(PDC), o qual é normalmente um servidor Windows NT que oferece
autenticação de senhas. Os controladores de domínios mantém um controle de usuários e senhas em seu próprio módulo de autenticação,
e autenticam cada usuário quando ele ou ela faz um login e deseja acessar um compartilhamento de outra máquina.
Para que este nível funcione corretamente será necessário além da opção “password server”, criar uma conta do tipo máquina
para o sistema linux. Note que esta conta deve existir tanto no linux como no PDC. E em seguida, adicionar as linhas a seguir na seção
global:
domain master = no
local master = no
preferred master = no
ostype=no
Configuração de servidor de arquivos simples

O samba pode atuar de diversas formas em uma rede Windows, de um servidor de arquivos a um PDC. Nesta seção iremos fazer
um servidor de arquivos simples. Onde iremos compartilhar alguns diretórios.
[global]
workgroup = GNU
server string = Samba %v em %L
security=share
interfaces = eth1, lo
bind interfaces only = Yes
unix charset = utf-8

display charset = cp850
obey pam restrictions = Yes

passdb backend = tdbsam
pam password change = Yes
log file = /var/log/samba/log.%u

max log size = 1000
time server = Yes
panic action = /usr/share/samba/panic-action %d
admin users = root

hosts allow = 192.168.99.0/24, 127.0.0.0/8
[publico]
comment = Diretorio de Acesso Publico
path = /var/samba/publico
read only = No
create mask = 0666
directory mask = 0777
guest ok = Yes
Este arquivo de exemplo criou um compartilhamento típico de disco. Sendo mapeado o diretórios /var/samba/publico no
servidor SAMBA. Também foi fornecido um comentário que descreve o compartilhamento como um drive de dados e também um
nome de volume para ele.
As opções create mask e directory mask definem respectivamente as permissões de arquivos que o SAMBA criar neste diretório.
No caso este compartilhamento usará a máscara que dá permissão de leitura e escrita para os arquivos e leitura, escrita e execução para
os diretório para todos os usuários e grupos.
Lembrando que caso o diretório /var/samba/publico não exista ele deve ser criado e além disso ele deve ter permissões de escrita
por todos os usuários.

mkdir /var/samba/publico
chmod 777 /var/samba/publico
Neste compartilhamento estamos usando a opção “guest ok” que da acesso a todos os clientes sem requerer senhas. Poderíamos
incrementar a segurança neste servidor fazendo com sejam requeridas usuário e senha para o compartilhamento.
[publico]
read only = No
create mask = 0660
valid users = @usuarios
Veja que adicionamos a opção “valid users”, o valor @usuarios especifica que todos os usuários que pertencem ao grupo
“usuarios” podem acessar este compartilhamento. Mais detalhes de sobre usuários e grupos adiante neste capítulo na seção
Gerenciamento de usuários samba.
Configuração de máquinas rWindows

A configuração do Windows para acessar o servidor SAMBA é simples pois o SMB é a linguagem nativa da Microsoft para
compartilhamento de recursos em uma rede local.
No momento da configuração do cliente Windows, antes de tudo, deve-se verificar se o protocolo de rede TCP/IP está instalado
e configurado corretamente. Para fazer isto basta ir nas propriedades de rede de sua conexão de rede local. Devemos conferir se as
informações de endereço IP, DNS, Mascara de Rede estão configuradas corretamente.
Neste momento devemos habilitar também o “Cliente para redes Microsoft” e o “Compartilhamento de arquivos e impressoras
para redes Microsoft” estão habilitados.
O próximo passo é a configuração do nome e grupo de trabalho. Bastando para isso ir em propriedades de “Meu Computador” e
na aba “Nome do Computador” ir em “Alterar” colocar o nome do computador(por exemplo: pascal) e o nome do grupo de
Trabalho(workgroup) no nosso exemplo “GNU”.
Após isso basta acessar via “explorer” os arquivos em nosso servidor SAMBA.
Gerenciamento de usuários samba

Antes de prosseguir-mos para a criação de um domínio usando o SAMBA como PDC, devemos aprender a como gerenciar os
usuários.
Criando contas confiáveis

Após a inclusão da opção sobre as senhas é preciso criar um conta confiável; todas as estações usarão essas contas para conectar
a um PDC. Essas contas permitem efetuar um logon no PDC(não acessam compartilhamentos). Para todos os propósitos uma conta
confiável é idêntica a uma conta de usuário.
Um grande detalhe é que o login de uma conta confiável de uma máquina é o seu nome com um sinal de $ no final, por
exemplo: apache$. Para produzir esta conta será necessário criar esta conta no Linux e posteriormente adicioná-la ao banco de dados do
samba.
Para adicionar a conta no Linux utilizamos os seguinte comando:
adduser –ingroup maquinas –shel /bin/false –home /dev/null apache$
Caso o grupo maquinas ainda não exista podemos criá-lo com:

addgroup maquinas
Para adicionar a conta ao banco de dados do SAMBA usamos o comando smbpasswd

smbpasswd -am apache$
A opção “a” especifica que uma conta está sendo adicionada e a “m” especifica que esta é uma conta de máquina.
Contas de Usuários
Da mesma forma que criamos as contas confiáveis, iremos criar também as contas do usuários(lembrando que as contas de
usuários não precisam ter o $ no final).
Criaremos o grupo usuarios, para comportar os usuários SAMBA:

addgroup usuarios
É interessante que os usuários SAMBA não sejam usuários normais do linux, caso contrário, eles poderão efetuar login no shell
do servidor ou até mesmo abrir uma sessão por ssh. Então para isso vamos criar os usuário e adicioná-los ao SAMBA usando os
seguintes comandos:
adduser -g usuarios -s /bin/false –disabled-login nomedeumusuario
smbpasswd -a nomedeumusuario
Removendo Usuários
Para remover usuários, removemos tanto do banco de dados do SAMBA quanto do linux:
smpasswd -x nomedeumusuario
userdel nomedeumusuario
Mudando a senha do usuário

smpasswd -x nomedeumusuario
Samba como servidor de autenticação de usuários Windows

Como os tradicionais grupos de trabalho Windows aceitam cada usuário e senha que forem fornecidos na hora do logon. O
sistema operacional simplesmente solicita uma um senha e autentica o usuário com a senha que possui.
Contudo, em uma rede de computadores onde hajam vários computadores, deverá existir o login de usuário em todos os
computadores onde determinado usuário queira se conectar e então poderão existir várias senhas para o mesmo usuário. Entretanto com
domínios de logons os logins de usuários e senhas são guardadas em um banco de dados centralizado. Na inicialização o usuário deve
apresentar seu nome de usuário e senha e então é feita a autenticação na base de dados, no caso o PDC.
Há também uma outra vantagem: uma vez efetuado um logon será possível acessar qualquer compartilhamento para o qual o
usuário tem permissão, sem ter que se reautenticar.
Para que o servidor SAMBA atue como PDC de um cliente Windows é preciso assegurar-se de que:
• O samba seja o único controlador primário de domínio do grupo de trabalho.
• O samba esteja configurado com nível de segurança “user”
Para isso será necessário incluir as seguintes opções no arquivo de configuração do samba:
[global]
workgroup = GNU
domain logons = yes
security = user
os level = 254
local master = yes
preferred master = yes
domain master = yes
Após a configuração das opções será necessário criar um compartilhamento de disco chamado netlogon. Esse compartilhamento
é obrigatório e cada cliente windows deve conseguir conectar-se a ele. Além disso não pode ser public, writeable ou browseable. Esse
compartilhamento é usado pelos scripts de logons(scripts que são execultados após o processo de autenticação do usuário), que serão
explicados um pouco mais adiante.
Configuração de uma situação real para o SAMBA como PDC

Em nosso exemplo, iremos demonstrar um arquivo de configuração do samba para atuar como PDC e além disso com os
diretórios HOME dos usuários, ROAMING PROFILES e Scripts de Logon.
Iremos utilizar dois grupos, usuarios e financeiro. O grupo usuarios é um grupo comum apenas para dar acesso ao sistema e a
um compartilhamento chamado de publico. O outro grupo, financeiro, é um grupo restrito com um compartilhamento
específico(chamado de financeiro) para ele.
Scripts de Logon
Os scripts de logon são scripts que são executados no cliente quando um usuário faz logon no domínio Windows. Interessante é
que esses scripts são armazenados no servidor Linux e são encaminhados através da rede ao cliente. Porém, como eles serão executados
por Sistemas Windows, ele devem conter comandos Windows.

De preferência esses arquivos devem ser criados usando um utilitário Windows(notepad por exemplo), pois existe uma diferença
entre os caracteres de fim de linha usado pelo Windows em relação ao linux.
Para configurar scripts de logon, o arquivo de configuração do SAMBA deve conter uma opção semelhante a:
logon script = script.bat
O diretório base dos scripts é um compartilhamento chamado de netlogon; veja um exemplo:

[netlogon]
comment = Servico de Logon na Rede
path = /var/samba/netlogon
public = no
writeable = no
browseable = no
Neste caso o script seria localizado em /var/samba/netlogon.

Segue abaixo o nosso arquivo de configuração completo e logo abaixo comentários sobre cada opção utilizada:
[global]
workgroup = GNU
server string = Supertux Linux SAMBA server
interfaces = eth1, lo, 192.168.99.0/24, 127.0.0.0/8

bind interfaces only = Yes
unix charset = utf8

display charset = cp850
obey pam restrictions = Yes

passdb backend = tdbsam
log file = /var/log/samba/log.%u

max log size = 1000
time server = Yes
socket options = TCP_NODELAY SO_RCVBUF=8192 SO_SNDBUF=8192
logon script = %G.bat

logon path = \\%L\profiles\%U
logon home = \\%L\%U\profiles
domain logons = Yes
os level = 100
preferred master = Yes

domain master = Yes
local master = Yes
admin users = root

hosts allow = 127.0.0.0/8, 192.168.99.0/24
[homes]
comment = Diretorios Home
valid users = %S
read only = No
create mask = 0600
browseable = No
[profiles]
comment = Servico de Roamming profiles na Rede
path = /var/samba/profiles
read only = No
create mask = 0600
browseable = No

[netlogon]
comment = Servico de Logon na Rede
path = /var/samba/netlogon
public = no
writeable = no
browseable = no
[publico]
valid users = @usuarios @financeiro
read only = No
create mask = 0666
[financeiro]
comment = Diretorio de acesso ao financeiro
path = /var/samba/financeiro
valid users = @financeiro
read only = No
create mask = 0660
Seção global
logon script = %G.bat
Usaremos como nome de script de logon o nome do grupo do usuário, ou seja, iremos fazer dois scripts, um para o grupo
usuarios e outro para financeiro.
logon path = \\%L\profiles\%U
O diretório do roaming profile do usuário. Como vimos antes, %L é o nome netbios do servidor(no nosso caso supertux) e %U o
nome do usuário.
logon home = \\%L\%U\profiles
O diretório Home do usuário.
domain logons = Yes
Para permitir os usuários da rede fazer logon.
os level = 100
O parâmetro “os level” é usado quando existem mais de um PDC para o dímínio, para fazer eleição de qual servidor será eleito
como PDC.
preferred master = Yes
domain master = Yes
local master = Yes
Diz ao servidor samba que ele seja o preferencialmente o PDC da rede.
admin users = root
É necessário uma conta de administrador para ingressar em um domínio, neste caso iremos usar a conta root.
hosts allow = 127.0.0.0/8, 192.168.99.0/24
Vamos permitir somente que as redes 127.0.0.0/8 e 192.168.99.0/24 possam acessar nosso servidor.
Seção Homes
valid users = %S
Vamos restringir o acesso do diretório “home” aos usuários do domínio
read only = No
Os usuários podem escrever neste diretório
create mask = 0600
Os arquivos criados pelos usuários neste compartilhamento serão criados no sistema linux como leitura e gravação somente pelo
usuário.
Os diretórios serão criados com todas as permissões para o usuário.
browseable = No
Este compartilhamento não será visualizável pelos usuários.
Observe que não colocamos nenhuma opção path, pois os diretórios homes estão definidos nas propriedades do usuário no linux.
Ao criar um usuário no linux ele recebe um diretório home para seus arquivos pessoais. Caso não tenha sido especificado outro então
por padrão será o /home.

Seção Profiles
Mesmas opções da seção homes.
Compartilhamento netlogon
Conforme explicado anteriormente as opções são como o esperado.
Em nosso exemplo usamos os scripts conforme o grupo do cliente. Vamos escrever dois scripts:
• financeiro.bat
net use T: \\supertux\financeiro
net use U:\\supertux\publico
• usuarios.bat
net use U:\\supertux\publico
Compartilhamento publico
Os dados serão guardados no diretório /var/samba/publico
valid users = @usuarios @financeiro
Apenas os clientes do grupos usuarios e financeiro terão acesso a este compartilhamento.
create mask = 0666
Observe que os clientes podem pertencer a grupos diferentes ou seja se colocar-mos permissões diferentes poderá ocorrer que o
arquivo que um cliente criar outro não possa acessar.
O mesmo que acontece com os arquivos.
Compartilhamento financeiro
path = /var/samba/financeiro
Os dados serão guardados no diretório /var/samba/financeiro
valid users = @financeiro
Apenas os clientes do grupo financeiro poderão acessar este compartilhamento.
create mask = 0660
Veja que neste compartilhamento usamos a máscara que da permissão de leitura e escrita pelo usuário e pelo grupo.
O mesmo para a criação de diretórios.
Configuração de máquinas rWindows

A configuração dos clientes Windows para se conectar ao domínio é semelhante à configuração para cliente normal. Com alguns
detalhes a seguir:
Conforme descrito antes precisaremos criar uma conta de usuário confiável(e posteriormente adicionar à base de dados do
SAMBA) no servidor SAMBA para cada máquina que iremos adicionar ao domínio. Como exemplo criaremos a máquina torvalds.
adduser –ingroup maquinas –shel /bin/false –home /dev/null torvalds$
smbpasswd -am torvalds
Caso não tenha adicionado o usuário root a base de dados do SAMBA, adicione:
smbpasswd -a root
Na aba “Nome do Computador” basta clicar em “ID da Rede”. No campo “Nome do computador” preencher com o nome do
usuário que acabamos de criar(torvalds). E no campo “Membro de” preencher com o nome do nosso domínio,no nosso exemplo GNU e
clicar em “Ok”.
Ainda não ingressamos a máquina Windows no nosso domínio. Para poder continuar é necessário uma conta de administrador
do nosso domínio. Como nosso servidor é Linux/SAMBA já temos uma conta administrativa, o root. Basta agora fornecer usuário root
e a senha do root e prosseguir.
Agora deve aparecer na tela a mensagem “Bem vindo ao domínio GNU.” Basta reiniciar o computador e pronto. Quando o
computador reiniciar a tela de login irá mudar e a partir de agora irá aparecer a opção “Fazer logon em” que deve ser sempre o nome do
domínio da rede. A partir de agora qualquer usuário que seja cadastrado no SAMBA deve ter acesso a seus arquivos nesta máquina.

Usando Linux como firewall
Conceitos
Tipos de firewalls
Existem basicamente dois tipos de firewalls:
Em nível de aplicação - Este tipo de firewall analisam o conteúdo do pacote para tomar suas decisões de filtragem. Firewalls
deste tipo são mais intrusivos (pois analisam o conteúdo de tudo que passa por ele) e permitem um controle relacionado com o conteúdo
do tráfego. Alguns firewalls em nível de aplicação combinam recursos básicos existentes em firewalls em nível de pacotes combinando
as funcionalidade de controle de tráfego/controle de acesso em uma só ferramenta. Servidores proxy, como o squid, são um exemplo
deste tipo de firewall.
A nível de pacotes - Este tipo de firewall 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. O firewall então pode negar o pacote (DROP) ou deixar o pacote
passar (ACCEPT). O iptables é um excelente firewall que se encaixa nesta categoria. Firewall em nível de pacotes é o assunto explicado
nesta seção do guia mas será apresentada uma explicação breve sobre o funcionamento de análise de strings do iptables.
Os dois tipos de firewalls podem ser usados em conjunto para fornecer uma camada dupla de segurança no acesso as suas
máquinas/máquinas clientes.
O que proteger?
Antes de iniciar a construção do firewall é bom pensar nos seguintes pontos:
Quais serviços precisamos proteger. Serviços que devem ter acesso garantido a usuários externos e quais serão bloqueados a
todas/determinadas máquinas. É recomendável bloquear o acesso a todas portas menores que 1024 por executarem serviços que rodam
com privilégio de usuário root, e autorizar somente o acesso as portas que realmente deseja (configuração restritiva nesta faixa de
portas).
E que tipo de conexões eu posso deixar passar e quais bloquear. Serviços com autenticação em texto plano e potencialmente
inseguros como rlogin, telnet, ftp, NFS, DNS, LDAP, SMTP RCP, X-Window são serviços que devem ser ter acesso garantido somente
para máquinas/redes que você confia. Estes serviços podem não ser só usados para tentativa de acesso ao seu sistema, mas também
como forma de atacar outras pessoas aproveitando-se de problemas de configuração. A configuração do firewall ajuda a prevenir isso,
mesmo se um serviço estiver mal configurado e tentando enviar seus pacotes para fora, será impedido. Da mesma forma se uma
máquina Windows de sua rede for infectada por um trojan não haverá pânico: o firewall poderá estar configurado para bloquear
qualquer tentativa de conexão vinda da internet (cracker) para as máquinas de sua rede. Para cópia de arquivos via rede insegura (como
através da Internet), é recomendado o uso de serviços que utilizam criptografia para login e transferência de arquivos ou a configuração
de uma VPN.
• Que máquinas terão acesso livre e quais serão restritas.
• Que serviços deverão ter prioridade no processamento.
• Que máquinas/redes NUNCA deverão ter acesso a certas/todas máquinas.
• O volume de tráfego que o servidor manipulará. Através disso você pode ter que balancear o tráfego entre outras máquinas,
configurar proteções contra DoS, syn flood, etc.
• O que tem permissão de passar de uma rede para outra (em máquinas que atuam como roteadores/gateways de uma rede
interna).
A análise destes pontos pode determinar a complexidade do firewall, custos de implementação, prazo de desenvolvimento e
tempo de maturidade do código para implementação. Existem muitos outros pontos que podem entrar na questão de
desenvolvimento de um sistema de firewall, eles dependem do tipo de firewall que está desenvolvendo e das políticas de
segurança de sua rede.
Introdução
O Firewall é um programa que como objetivo proteger a máquina contra acessos indesejados, tráfego indesejado, proteger
serviços que estejam rodando na máquina e bloquear a passagem de coisas que você não deseja receber (como conexões vindas da
Internet para sua segura rede local, evitando acesso aos dados corporativos de uma empresa ou a seus dados pessoais).
No kernel do Linux 2.4, foi introduzido o firewall iptables (também chamado de netfilter) que substitui o ipchains dos kernels da
série 2.2. Este novo firewall tem como vantagem ser muito estável (assim como o ipchains e ipfwadm), confiável, permitir muita
flexibilidade na programação de regras pelo administrador do sistema, mais opções disponíveis ao administrador para controle de
tráfego, controle independente do tráfego da rede local/entre redes/interfaces devido a nova organização das etapas de roteamento de
pacotes.
O iptables é um firewall em nível de pacotes e funciona baseado no endereço/porta de origem/destino do pacote, prioridade, etc.

Ele funciona através da comparação de regras para saber se um pacote tem ou não permissão para passar. Em firewalls mais restritivos,
o pacote é bloqueado e registrado para que o administrador do sistema tenha conhecimento sobre o que está acontecendo em seu
sistema.
Ele também pode ser usado para modificar e monitorar o tráfego da rede, fazer NAT (masquerading, source nat, destination nat),
redirecionamento de pacotes, marcação de pacotes, modificar a prioridade de pacotes que chegam/saem do seu sistema, contagem de
bytes, dividir tráfego entre máquinas, criar proteções anti-spoofing, contra syn flood, DoS, etc. O tráfego vindo de máquinas
desconhecidas da rede pode também ser bloqueado/registrado através do uso de simples regras. As possibilidades oferecidas pelos
recursos de filtragem iptables como todas as ferramentas UNIX maduras dependem de sua imaginação, pois ele garante uma grande
flexibilidade na manipulação das regras de acesso ao sistema, precisando apenas conhecer quais interfaces o sistema possui, o que deseja
bloquear, o que tem acesso garantido, quais serviços devem estar acessíveis para cada rede, e iniciar a construção de seu firewall.
O iptables ainda tem a vantagem de ser modularizável, funções podem ser adicionadas ao firewall ampliando as possibilidades
oferecidas. Usei por 2 anos o ipchains e afirmo que este é um firewall que tem possibilidades de gerenciar tanto a segurança em
máquinas isoladas como roteamento em grandes organizações, onde a passagem de tráfego entre redes deve ser minuciosamente
controlada.
Um firewall não funciona de forma automática (instalando e esperar que ele faça as coisas por você), é necessário pelo menos
conhecimentos básicos de rede tcp/ip, roteamento e portas para criar as regras que farão a segurança de seu sistema. A segurança do
sistema depende do controle das regras que serão criadas por você, as falhas humanas são garantia de mais de 95% de sucesso nas
invasões.
Enfim o iptables é um firewall que agradará tanto a pessoas que desejam uma segurança básica em seu sistema, quando
administradores de grandes redes que querem ter um controle minucioso sobre o tráfego que passam entre suas interfaces de rede
(controlando tudo o que pode passar de uma rede a outra), controlar o uso de tráfego, monitoração, etc.
Características do firewall iptables
• Especificação de portas/endereço de origem/destino
• Suporte a protocolos TCP/UDP/ICMP (incluindo tipos de mensagens icmp)
• Suporte a interfaces de origem/destino de pacotes
• Manipula serviços de proxy na rede
• Tratamento de tráfego dividido em chains (para melhor controle do tráfego que entra/sai da máquina e tráfego redirecionado.
• Permite um número ilimitado de regras por chain
• Muito rápido, estável e seguro
• Possui mecanismos internos para rejeitar automaticamente pacotes duvidosos ou mal formados.
• Suporte a módulos externos para expansão das funcionalidades padrões oferecidas pelo código de firewall
• Suporte completo a roteamento de pacotes, tratadas em uma área diferente de tráfegos padrões.
• Suporte a especificação de tipo de serviço para priorizar o tráfego de determinados tipos de pacotes.
• Permite especificar exceções para as regras ou parte das regras
• Suporte a detecção de fragmentos
• Permite enviar alertas personalizados ao syslog sobre o tráfego aceito/bloqueado.
• Redirecionamento de portas
• Masquerading
• Suporte a SNAT (modificação do endereço de origem das máquinas para um único IP ou faixa de IP’s).
• Suporte a DNAT (modificação do endereço de destino das máquinas para um único IP ou fixa de IP’s)
• Contagem de pacotes que atravessaram uma interface/regra
• Limitação de passagem de pacotes/conferência de regra (muito útil para criar proteções contra, syn flood, ping flood, DoS,
etc).
Políticas(policiamento) de segurança
Políticas de segurança, ou policiamento, é a ação padrão que o firewall deve fazer quando o forem analizados todas as regras e
nenhuma delas especificar uma ação que deve ser aplicada ao mesmo. Desta forma podemos prever que existem dois tipos de
piliciamentos:
1. Restritivo
No policiamento restritivo quando uma regra não coincidir com o pacote, a ação tomada é descartar o mesmo. Neste tipo de
policiamento devemos ter regras permissivas permitindo o acesso, ou seja, o que não é permitido então será negado.
2. Permissivo
No policiamento permissivo quando uma regra não coincidir com o pacote, a ação tomada é aceitar o mesmo. Neste tipo de
policiamento devemos ter regras restritivas bloqueando o acesso, ou seja, o que não é proibido então será aceito.
Do ponto de vista da segurança, policiamentos restritivos são mais seguros, pois nele é liberado todo o tráfego conhecido e os
outros tráfegos são bloquados refletindo a característica duvidosa desses tráfegos.
Regras
As regras são como comandos passados ao iptables para que ele realize uma determinada ação (como bloquear ou deixar passar

um pacote) de acordo com o endereço/porta de origem/destino, interface de origem/destino, etc. As regras são armazenadas dentro dos
chains e processadas na ordem que são inseridas.
As regras são armazenadas no kernel, o que significa que quando o computador for reiniciado tudo o que fez será perdido. Por
este motivo elas deverão ser gravadas em um arquivo para serem carregadas a cada inicialização.
Um exemplo de regra: iptables -A INPUT -s 123.123.123.1 -j DROP.
Como o iptables verificas as regras dentro das chains na ordem em que estão posicionadas, é importante que prestemos atenção a
ordem em que as regras são apresentadas.
Importante: uma regra se torna tão específica quanto o número de opções ela tem. Vejamos com exemplos:
iptables -A INPUT -j DROP
onde:
iptables – Comando para manipular as regras/chains
-A INPUT – Opção para inserir regra na chain INPUT (explicados mais adiante)
-j DROP – Opção para instruir o firewall a descartar o pacote.
Veja que nessa regra colocamos poucas opções para definir os que será descartado. Resultado, o firewall descartará todos os
pacotes ao analisar essa regra. Vejamos uma outra:
iptables -A INPUT -s 192.168.99.4 -j DROP
A opção “-s 192.168.99.4” diz somente os pacotes com ip de origem 192.168.99.4 devem “casar” com essa regra. Resultado,
somente o tráfego vindo do IP 192.168.99.4 será bloqueado. Uma mais extensa:
iptables -A INPUT -s 192.168.99.4 -p tcp –dport 80 -d 200.123.123.123 -j DROP
Faz com que somente o tráfego oriundo do IP 192.168.99.4 com destino ao IP 200.123.123.123 usando o protocolo TCP e com
porta de destino 80 será descartado, todo os outros tráfegos serão aceitos.
Chains
Os Chains são locais onde as regras do firewall definidas pelo usuário são armazenadas para operação do firewall. Existem dois
tipos de chains: os embutidos (como os chains INPUT, OUTPUT e FORWARD) e os criados pelo usuário. Os nomes dos chains
embutidos devem ser especificados sempre em maiúsculas (note que os nomes dos chains são case-sensitive, ou seja, o chain input é
completamente diferente de INPUT).
Tabelas
Tabelas são os locais usados para armazenar os chains e conjunto de regras com uma determinada característica em comum. As
tabelas podem ser referenciadas com a opção -t tabela e existem 2 tabelas principais no iptables:
• filter
filter - Esta é a tabela padrão, contém 3 chains padrões:
– INPUT - Consultado para dados que chegam a máquina
– OUTPUT - Consultado para dados que saem da máquina
– FORWARD - Consultado para dados que são redirecionados para outra interface de rede ou outra máquina.
Os chains INPUT e OUTPUT somente são atravessados por conexões indo/se originando de localhost.
OBS: Para conexões locais, somente os chains INPUT e OUTPUT são consultados na tabela filter.
• nat
nat - Usada para dados que gera outra conexão (masquerading, source nat, destination nat, port forwarding, proxy transparente
são alguns exemplos). Possui 3 chains padrões:
– PREROUTING - Consultado quando os pacotes precisam ser modificados logo que chegam. É o chain ideal para realização de
DNAT e redirecionamento de portas.
– OUTPUT - Consultado quando os pacotes gerados localmente precisam ser modificados antes de serem roteados. Este chain
somente é consultado para conexões que se originam de IPs de interfaces locais.
– POSTROUTING - Consultado quando os pacotes precisam ser modificados após o tratamento de roteamento. É o chain ideal
para realização de SNAT e IP Masquerading.
Manipulando Chains
O iptables trabalha com uma tabela de regras que é analisada uma a uma até que a última seja processada. Por padrão, se uma

regra tiver qualquer erro, uma mensagem será mostrada e ela descartada. O pacote não conferirá e a ação final (se ele vai ser
aceito ou rejeitado) dependerá das regras seguintes.
As opções passadas ao iptables usadas para manipular os chains são SEMPRE em maiúsculas.
As seguintes operações podem ser realizadas:
Adicionando regras
Como exemplo vamos criar uma regra que bloqueia o acesso a máquina 192.168.99.2. Primeiro daremos um ping para verificar
seu funcionamento:
ping 192.168.99.2
PING 192.168.99.2(192.168.99.2): 56 data bytes
64 bytes from 192.168.99.2: icmp_seq=0 ttl=255 time=0.6 ms
64 bytes from 192.168.99.2: icmp_seq=1 ttl=255 time=0.5 ms
--- 192.168.99.2 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.5/0.5/0.6 ms
Ok, a máquina responde, agora vamos incluir uma regra no chain INPUT (-A INPUT) que bloqueie (-j DROP) qualquer acesso
indo ao endereço 192.168.99.2 (-d 192.168.99.2):
iptables -t filter -A INPUT -d 192.168.99.2 -j DROP
Agora verificamos um novo ping:
#ping 192.168.99.2
PING 192.168.99.2 (192.168.99.2): 56 data bytes
--- 192.168.99.2 ping statistics ---
2 packets transmitted, 0 packets received, 100% packet loss
Desta vez a máquina 192.168.99.2 não respondeu, pois todos os pacotes com o destino 192.168.99.2 (-d 192.168.99.2 ) são
rejeitados (-j DROP). A opção -A é usada para adicionar novas regras no final do chain. Além de -j DROP que serve para rejeitar os
pacotes, podemos também usar -j ACCEPT para aceitar pacotes. A opção -j é chamada de alvo da regra ou somente alvo pois define o
destino do pacote que atravessa a regra.
OBS2: - A tabela filter será usada como padrão caso nenhuma tabela seja especificada através da opção -t.
Listando regras – L
A seguinte sintaxe é usada para listar as regras criadas:
iptables [-t tabela] -L [chain] [opções]
Onde:
tabela - É uma das tabelas usadas pelo iptables. Se a tabela não for especificada, a tabela filter será usada como padrão.
Chain - Um dos chains disponíveis na tabela acima. Caso o chain não seja especificado, todos os chains da tabela serão
mostrados.
opções As seguintes opções podem ser usadas para listar o conteúdo de chains:
• -v - Exibe mais detalhes sobre as regras criadas nos chains.
• -n - Exibe endereços de máquinas/portas como números ao invés de tentar a resolução DNS e consulta ao /etc/services. A
resolução de nomes pode tomar muito tempo dependendo da quantidade de regras que suas tabelas possuem e velocidade de
sua conexão.
• -x - Exibe números exatos ao invés de números redondos. Também mostra a faixa de portas de uma regra de firewall.
• --line-numbers - Exibe o número da posição da regra na primeira coluna da listagem.
Para listar a regra criada anteriormente usamos o comando:
#iptables -t filter -L INPUT

Chain INPUT (policy ACCEPT)
target prot opt source destination
DROP all -- anywhere maquina02
O comando iptables -L INPUT -n tem o mesmo efeito, a diferença é que são mostrados números ao invés de nomes:
#iptables -L INPUT -n
DROP all -- 0.0.0.0/0 192.168.99.2

#iptables -L INPUT -n –line-numbers
num target prot opt source destination
1 DROP all -- 0.0.0.0/0 192.168.99.2
#iptables -L INPUT -n -v
Chain INPUT (policy ACCEPT 78 packets, 5820 bytes)
pkts bytes target prot opt in out source destination
2 194 DROP icmp -- * * 0.0.0.0/0 192.168.99.2
Os campos assim possuem o seguinte significado:

• Chain - INPUT Nome do chain listado (policy ACCEPT 78 packets, 5820 bytes) Policiamento
padrão do chain
• pkts - Quantidade de pacotes que atravessaram a regra
•bytes - Quantidade de bytes que atravessaram a regra. Pode ser referenciado com K (Kilobytes),
M (Megabytes), G (Gigabytes).
• Target - O alvo da regra, o destino do pacote. Pode ser ACCEPT, DROP ou outro chain.
• Prot - Protocolo especificado pela regra. Pode ser udp, tcp, icmp ou all.
• Opt - Opções extras passadas a regra.
• In - Interface de entrada (de onde os dados chegam).
• Out - Interface de saída (para onde os dados vão).
• Source - Endereço de origem.
• Destination - Endereço de destino.
• Outras opções - Estas opções normalmente aparecem quando são usadas a opção -x:
• dpt ou dpts - Especifica a porta ou faixa de portas de destino.
• reject-with icmp-port-unreachable - Significa que foi usado o alvo REJECT naquela regra.
Apagando uma regra – D

Para apagar uma regra de uma chain, existem duas alternativas:
Quando sabemos qual é o número da regra no chain (listado com a opção -L) podemos referenciar o número diretamente. Por
exemplo, para apagar a regra criada acima:
iptables -t filter -D INPUT 1
Esta opção não é boa quando temos um firewall complexo com um grande número de regras por chains, neste caso a segunda
opção é a mais apropriada.
Usamos a mesma sintaxe para criar a regra no chain, mas trocamos -A por -D:
iptables -t filter -D INPUT -d 192.168.99.2 -j DROP
Então a regra correspondentes no Chain INPUT será automaticamente apagada (confira listando o chain com a opção “-L”).
Caso o chain possua várias regras semelhantes, somente a primeira será apagada.
Inserindo uma regra – I

Precisamos que o tráfego com destino ao ip 192.168.99.2 na porta 80 do protocolo tcp não seja rejeitado pelo nosso firewall.
Não podemos adicionar uma nova regra (-A) pois esta seria incluída no final do chain e o tráfego seria rejeitado pela primeira regra
(nunca atingindo a segunda). A solução é inserir a nova regra antes da regra que bloqueia todo o tráfego ao endereço 192.168.99.1 na
posição 1:
iptables -t filter -I OUTPUT 1 -d 192.168.99.2 -p tcp –dport 80 -j ACCEPT
Após este comando, temos a regra inserida na primeira posição do chain (repare no número 1 após OUTPUT) e a antiga regra
número 1 passa a ser a número 2. Desta forma a regra acima será consultada, se a máquina de destino for 192.168.99.2 então o tráfego
estará garantido, caso contrário o tráfego será bloqueado na regra seguinte.

Limpando as regras de um chain – F
Para limpar todas as regras de um chain, use a seguinte sintaxe:
iptables [-t tabela] [-F chain]
Onde:
tabela - Tabela que contém o chain que desejamos zerar.
Chain - Chain que desejamos limpar. Caso um chain não seja especificado, todos os chains da tabela serão limpos.
iptables -t filter -F INPUT
iptables -t filter -F
Especificando o policiamento padrão de um chain – P

O policiamento padrão determina o que acontecerá com um pacote quando ele chegar ao final das regras contidas em um chain.
O policiamento padrão do iptables é “ACCEPT” mas isto pode ser alterado com o comando:
iptables [-t tabela] [-P chain] [ACCEPT/DROP]
Onde:
tabela - Tabela que contém o chain que desejamos modificar o policiamento padrão.
chain Define o chain que terá o policiamento modificado. O chain deve ser especificado.
ACCEPT/DROP ACCEPT aceita os pacotes caso nenhuma regra do chain conferir (usado em regras permissivas). DROP rejeita
os pacotes caso nenhuma regra do chain conferir (usado em regras restritivas).
O policiamento padrão de um chain é mostrado com o comando iptables -L:
# iptables -L INPUT
DROP all -- anywhere 192.168.99.2
No exemplo acima, o policiamento padrão de INPUT é ACCEPT (policy ACCEPT), o que significa que qualquer pacote que
não seja rejeitado pela regra do chain, será aceito. Para alterar o policiamento padrão deste chain usamos o comando:
iptables -t filter -P INPUT DROP
NOTA: Os policiamentos PERMISSIVOS (ACCEPT) normalmente são usados em conjunto com regras restritivas no chain
correspondentes (tudo é bloqueado e o que sobrar é liberado) e policiamentos RESTRITIVOS (DROP) são usados em conjunto com
regras permissivas no chain correspondente (tudo é liberado e o que sobrar é bloqueado pelo policiamento padrão).
Outras opções do iptables
Especificando um endereço de origem/destino

As opções -s (ou –src/–source)e -d (ou –dst/–destination) servem para especificar endereços de origem e destino
respectivamente. É permitido usar um endereço IP completo(como 192.168.1.1), um hostname (debian), um endereço fqdn
(www.debian.org) ou um par rede/máscara (como 200.200.200.0/255.255.255.0 ou 200.200.200.0/24).
Caso um endereço/máscara não sejam especificados, é assumido 0/0 como padrão (todos as máquinas de todas as redes). A
interpretação dos endereços de origem/destino dependem do chain que está sendo especificado (como INPUT e OUTPUT por exemplo).
OBS: Caso seja especificado um endereço fqdn e este resolver mais de um endereço IP, serão criadas várias regras, cada uma se
aplicando a este endereço IP específico. É recomendável sempre que possível a especificação de endereços IP’s nas regras, pois além de
serem muito rápidos (pois não precisar de resolução DNS) são mais seguros para evitar que nosso firewall seja enganado por um ataque
de IP spoofing.
Exemplos:
# Bloqueia o tráfego vindo da rede 200.200.200.*:
iptables -A INPUT -s 200.200.200.0/24 -j DROP
# Bloqueia conexões com o destino 10.1.2.3:
iptables -A OUTPUT -d 10.1.2.3 -j DROP
# Bloqueia o tráfego da máquina www.dominio.teste.org a rede 210.21.1.3
# nossa máquina possui o endereço 210.21.1.3
iptables -A INPUT -s www.dominio.teste.org -d 210.21.1.3 -j DROP
Especificando a interface de origem/destino

As opções -i (ou –in-interface) e -o (ou –out-interface) especificam as interfaces de origem/destino de pacotes. Nem todos as

chains aceitam as interfaces de origem/destino simultaneamente, a interface de entrada (-i) nunca poderá ser especificada em um chain
OUTPUT e a interface de saída (-o) nunca poderá ser especificada em um chain INPUT.
O caminho do pacote na interface será determinado pelo tipo da interface e pela posição dos chains nas etapas de seu
roteamento. O chain OUTPUT da tabela filter somente poderá conter a interface de saída (veja a tabela acima). O chain FORWARD da
tabela filter é o único que aceita a especificação de ambas as interfaces, este é um ótimo chain para controlar o tráfego que passa entre
interfaces do firewall.
Por exemplo para bloquear o acesso do tráfego de qualquer máquina com o endereço 200.123.123.10 vinda da interface eth0
(uma placa de fax-modem):
iptables -A INPUT -s 200.123.123.10 -i eth0 -j DROP
A mesma regra pode ser especificada como

iptables -A INPUT -s 200.123.123.10 -i eth0 -j DROP
O sinal de “+” funciona como um coringa, assim a regra terá efeito em qualquer interface de eth0 a ppp9. As interfaces ativas no
momento podem ser listadas com o comando ifconfig, mas é permitido especificar uma regra que faz referência a uma interface que
ainda não existe, isto é interessante para conexões intermitentes como o PPP. Para bloquear qualquer tráfego local para a Internet:
iptables -A OUTPUT -o eth0 -j DROP
Para bloquear a passagem de tráfego da interface eth0 para a interface eth1 (de uma de nossas redes internas):
iptables -A FORWARD -i eth0 -o eth1 -j DROP
Especificando um protocolo
A opção -p (ou –protocol) é usada para especificar protocolos no iptables. Podem ser especificados os protocolos tcp, udp e
icmp. Por exemplo, para rejeitar todos os pacotes UDP vindos de 200.200.200.200:
iptables -A INPUT -s 200.200.200.200 -p udp -j DROP
OBS1: Tanto faz especificar os nomes de protocolos em maiúsculas ou minúsculas.
Especificando portas de origem/destino

As portas de origem/destino devem ser especificadas após o protocolo e podem ser precedidas por uma das seguintes opções:
--source-port ou --sport - Especifica uma porta ou faixa de portas de origem.
--destination-port ou --dport - Especifica uma porta ou faixa de portas de destino.
Uma faixa de portas pode ser especificada através de PortaOrigem:PortaDestino:

# Bloqueia qualquer pacote indo para 200.200.200.200 na faixa de # portas 0 a 1023
iptables -A OUTPUT -d 200.200.200.200 -p tcp --dport :1023 -j DROP
Caso a PortaOrigem de uma faixa de portas não seja especificada, 0 é assumida como padrão, caso a Porta Destino não seja
especificada, 65535 é assumida como padrão. Caso precise especificar diversas regras que envolvam o tratamento de portas diferentes,
recomendo da uma olhada em ‘Especificando múltiplas portas de origem/destino’, antes de criar um grande número de regras.
Especificando mensagens do protocolo ICMP

O protocolo ICMP não possui portas, mas é possível fazer um controle maior sobre o tráfego ICMP que entra/sai da rede através
da especificação dos tipos de mensagens ICMP. Os tipos de mensagens devem ser especificados com a opção “–icmp-type
CódigoICMP” logo após a especificação do protocolo icmp:
iptables -A INPUT -s 200.123.123.10 -p icmp --icmp-type time-exceeded -i eth0
A regra acima rejeitará mensagens ICMP do tipo “time-exceeded” (tempo de requisição excedido) que venham do endereço
200.123.123.10 através da interface eth0. Alguns tipos de mensagens ICMP são classificados por categoria (como o próprio “time-
exceeded”), caso a categoria “time-exceeded” seja especificada, todas as mensagens daquela categoria (como “ttl-zero-during-transit”,
“ttl-zero-during-reassembly”) conferirão na regra especificada.
Os tipos de mensagens ICMP podem ser obtidos com o comando “iptables -p icmp -h”, os mais importantes são:
• echo-reply (pong)
• destination-unreachable
• network-unreachable
• host-unreachable
• protocol-unreachable
• port-unreachable
• fragmentation-needed

• source-quench
• redirect
• network-redirect
• host-redirect
• echo-request (ping)
• time-exceeded (ttl-exceeded)
• ttl-zero-during-transit
• ttl-zero-during-reassembly
• parameter-problem
OBS1: Não bloqueie mensagens do tipo “host-unreachable” e “source-quench”, pois terá sérios problemas no controle de suas
conexões. A primeira diz que o destino está inalcançavel e a segunda que o host está sobrecarregado, assim os pacotes devem ser
enviados mais lentamente.
Especificando pacotes syn

Pacotes syn são usados para iniciarem uma conexão, o uso da opção –syn serve para especificar estes tipos de pacotes. Desta
maneira é possível bloquear somente os pacotes que iniciam uma conexão, sem afetar os pacotes restantes. Para que uma conexão ocorra
é necessário que a máquina obtenha a resposta a pacotes syn enviados, caso ele seja bloqueado a resposta nunca será retornada e a
conexão não será estabelecida.
iptables -A INPUT -p tcp --syn --dport 23 -i eth0 -j DROP
A regra acima bloqueia (-j DROP) qualquer tentativa de conexão (–syn) vindas da interface eth0 ao telnet (–dport 23) da
máquina local, conexões já efetuadas ão são afetadas por esta regra. A opção –syn somente pode ser especificada para o protocolo tcp.
ATENÇÃO: - A situação de passagem de pacotes durante deve ser levada em conta durante a inicialização do firewall, bloqueando a
passagem de pacotes durante o processo de configuração, criando regras que bloqueiam a passagem de pacotes (exceto para a interface
loopback) até que a configuração do firewall esteja completa, pode ser uma solução eficiente.
Outra alternativa segura é configurar as regras de firewall antes das interfaces de rede se tornarem ativas (usando a opção “pre-
up comando_firewall” no arquivo de configuração /etc/network/interfaces em sistemas Debian.
Especificando fragmentos
A opção “-f” (ou –fragment) permite especificar regras que confiram com fragmentos. Fragmentos são simplesmente um pacote
maior dividido em pedaços para poder ser transmitido via rede TCP/IP para remontagem do pacote pela máquina de destino.
Somente o primeiro fragmento possui detalhes de cabeçalho para ser processado, os segundos e seguintes somente possuem
alguns cabeçalhos necessários para dar continuidade ao processo de remontagem do pacote no destino.
Uma regra como:
iptables -A INPUT -s 200.200.200.1 -f -j DROP
derrubará os fragmentos de 200.200.200.1 derrubará o segundo pacote e pacotes seguintes enviados por 200.200.200.1 até nós.
OBS1: Note que se o cabeçalho do pacote não tiver detalhes suficientes para checagem de regras no iptables, a regra
simplesmente não ira conferir.
OBS2: Não é preciso especificar a opção “-f” para conexões NAT, pois os pacotes são remontados antes de entrarem no código
de filtragem.
OBS3: A opção “-f” também pode ser usada para evitar o flood por fragmentos (bomba de fragmentos) que, dependendo da
intensidade, podem até travar a máquina.
Especificando uma exceção

Muitos parâmetros (como o endereço de origem/destino, protocolo, porta, mensagens ICMP, fragmentos, etc) podem ser
precedidos pelo sinal “!” que significa exceção. Por exemplo:
iptables -t filter -A INPUT -s ! 200.200.200.10 -j DROP
Diz para rejeitar todos os pacotes EXCETO os que vem do endereço 200.200.200.10.
iptables -A INPUT -p tcp ! --syn -s 200.200.200.10 ! -i eth0 -j DROP
Diz para bloquear todos os pacotes EXCETO os que iniciam conexões (! –syn), EXCETO para pacotes vindos pela interface
eth0 (! -i eth0).
iptables -A INPUT -s 200.200.200.10 ! -p tcp -j DROP

Bloqueia todos os pacotes vindos de 200.200.200.10, EXCETO os do protocolo tcp.
Outras formas de identificar pacotes do iptables

Os módulos do iptables são especificados com a opção -m módulo ou –match módulo e permitem expandir a funcionalidade do
firewall através de novas conferências e recursos de filtragem. As regras usadas para coincidir os pacotes têm a sempre a estrutura:
iptables ... “-m [modulo] opções ” ...
como em:
Iptables -A INPUT -m state –state ESTABILISHED -j ACCEPT
Conferindo de acordo com o estado da conexão

Este módulo permite especificar regras de acordo com o estado da conexão do pacote. As opções permitidas são as seguintes:
• NEW - Confere com pacotes que criam novas conexões
• ESTABLISHED - Confere com conexões já estabelecidas
• RELATED - Confere com pacotes relacionados indiretamente a uma conexão, como mensagens de erro icmp, etc.
• INVALID - Confere com pacotes que não puderam ser identificados por algum motivo. Como respostas de conexões
desconhecidas.
Caso seja necessário especificar mais de uma opções estas devem ser separadas por vírgulas.
iptables -A INPUT -m state --state NEW -i eth0 -j DROP
Bloqueia qualquer tentativa de nova conexão vindo da interface eth0.

iptables -A INPUT -m state --state NEW,INVALID -i eth0 -j LOG
Permite registrar novas conexões e pacotes inválidos vindos da interface eth0.
Limitando o número de vezes que a regra confere

A opção -m limit permite especificar o número de vezes que uma regra conferirá quando todas as outras condições forem
satisfeitas. O número padrão de conferência é de 3 por hora, a não ser que seja modificado através dos argumentos aceitos pelo limit:
--limit num/tempo - Permite especificar a taxa de conferências do limit. O parâmetro num especifica um número e tempo pode
ser: s(Segundos), m(Minutos), h(Horas) e d(Dia).
Assim uma regra como:
iptables -A INPUT -p tcp -s 10.1.1.1 -m limit --limit 5/m -j ACCEPT
Permitirá que a regra acima confira apenas 5 vezes por minuto (–limit 2/s). Este limite pode ser facilmente adaptado para uma
regra de log que confere constantemente não causar uma avalanche em seus logs. O valor padrão é 3/h.
--limit-burst num - Especifica o número inicial máximo de pacotes que irão conferir, este número é aumentado por 1 a cada vez
que o parâmetro –limit acima não for atingido. O valor padrão é 5.
Proteção contra ping da morte

A regra abaixo pode tomada como base para proteção contra ping flood:
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit -j ACCEPT
iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
A regra acima limita em 1 vez por segundo (–limit 1/s) a passagem de pings (echo requests) para a máquina Linux.
Proteção contra syn flood

A regra abaixo é uma boa proteção para os ataques syn floods:
iptables -t filter -A INPUT -p tcp --syn -m limit --limit 2/s -j ACCEPT
iptables -t filter -A INPUT -j DROP
Esta regra limita o atendimento de requisições de conexões a 2 por segundo. No entanto, devemos utilizar estas opções com
cautela em servidores que possuem um grande número de acessos para não ter problemas que afetem seu clientes.

Especificando múltiplas portas de origem/destino
O módulo multiport permite que seja especificado múltiplas portas para um alvo. Podem ser especificadas até 15 portas em um
único parâmetro e basta que uma porta confira para que a regra entre em ação, pois a comparação é feita usando condições “ou”. O
parâmetro multiport deve ser acompanhado de um dos argumentos abaixo:
--source-port [porta1, porta2...] - Faz a regra conferir se a porta de origem estiver presente entre as portas especificadas.
--destination-port [porta1, porta2...] - Faz a regra conferir se a porta de destino estiver presente entre as portas especificadas.
--port [porta1, porta2...] - Faz a regra conferir caso a porta de origem ou destino esteja presente no parâmetro.
Este módulo pode eliminar muitas regras de firewall que fazem o mesmo tratamento de pacotes para diversas portas diferentes.
iptables -A INPUT -p tcp -i eth0 -m multiport --destination-port 21,23,25,80,110,113,6667 -j DROP
Bloqueia todos os pacotes vindo de eth0 para as portas 21 (ftp), 23 (telnet), 25 (smtp), 80(www), 110 (pop3), 113 (ident), 6667
(irc).
Especificando o endereço MAC da interface

O módulo mac serve para conferir com o endereço Ethernet dos pacotes de origem. Somente faz sentido se usado nos chains de
PREROUTING (da tabela nat) ou INPUT (da tabela filter). Aceita como argumento a opção –mac-source endereço. O símbolo “!” pode
ser usado para especificar uma exceção.
iptables -A INPUT -s 192.168.99.101 -m mac --mac-source 00:80:AD:B2:60:0B -j ACCEPT
Confere com a máquina com endereço ethernet igual a 00:80:AD:B2:60:0B e IP de origem 192.168.99.101
Conferindo com o conteúdo do pacote

O módulo string do iptables permite a inspeção de conteúdo de um pacote e tomar uma ação se
determinado tipo de tráfego for encontrado em um pacote. Esta técnica pode ser usada tanto para segurança
como para economia de banda dentro da rede. Esta opção NÃO torna o iptables como um firewall proxy, pois o
proxy tem a habilidade de inspecionar o conteúdo, protocolo, comandos do pacote e decidir se o seu conteúdo é
nocivo ou não. O firewall em nível de pacotes fazendo inspeção de conteúdo, chega a ser 3 a 10 vezes mais
rápido do que um proxy, assim seu uso deve ser analisado dependendo do tráfego que circula pelo link e da
segurança dos dados que trafegam através dele.
Uma boa prática é aliar esta opção a um IDS externo usando o alvo QUEUE e deixando o trabalho de
inspeção de conteúdo para ele. Um exemplo de restrição direta é o bloqueio do envio de qualquer informação
confidencial sigilosa para fora da rede interna (número de contas, tudo que conferir com CPF, CGC, endereços
de e-mail, memorandos, etc). De qualquer forma, analise o tráfego de sua rede antes de querer implementar
qualquer solução baseada neste método sob o risco de afetar tráfego legítimo.
Outra utilidade eficiente é a diminuição de tráfego, pois podemos barrar programas que sobrecarregamo
link em uma rede com muitos usuários como, por exemplo, usando o Kazaa ou qualquer outro programa para
cópia de arquivos via Internet. Veja alguns exemplos:
# Bloqueia a passagem de pacotes que contém ".exe" em seu conteúdo
iptables -A INPUT -m string --string ".exe" -j DROP
Conferindo com tipo de pacote

O módulo pkttype permite identificar um pacote do tipo unicast (direcionado a uma única máquina),
broadcast (direcionado a uma determinada rede, definida pela netmask) ou multicast (destinado a grupos de
redes) e desta forma realizar ações em cima destes. O tipo de pacote é identificado logo após a opção –pkt-type.
Veja alguns exemplos:
Bloqueia a passagem de pacotes multicast
iptables -A FORWARD -i eth0 -o eth0 -m pkttype --pkt-type multicast -j DROP
Como deve ter notado, é possível fazer a associação com diversas especificações de módulos, bastando apenas especificar uma
opção "-m" para cada módulo adicional:
Conferindo com o tamanho do pacote

O tamanho do pacote pode ser usado como condição de filtragem através do módulo length. O tamanho

do pacote é especificado através da opção –length e o argumento segue a mesma sintaxe da especificação de
portas no iptables sendo separados por :. Veja alguns exemplos:
Bloqueia qualquer pacote ICMP maior que 300bytes
iptables -A INPUT -i eth0 -m length --length 300: -j DROP
Especificando um alvo
O alvo (-j) é o destino que um pacote terá quando conferir com as condições de uma regra, um alvo pode
dizer para bloquear a passagem do pacote (-j DROP), aceitar a passagem do pacote (-j ACCEPT), registrar o
pacote no sistema de log (-j LOG), rejeitar o pacote (-j REJECT), redirecionar um pacote -j REDIRECT,
retornar ao chain anterior sem completar o processamento no chain atual (-j RETURN), passar para
processamento de programas externos (-j QUEUE), fazer source nat (-j SNAT), destination nat (-j DNAT), etc.
Podem existir mais alvos, pois o iptables é modularizável, e módulos que acrescentam mais funções podem ser
carregados em adição aos já existentes no kernel.
Nos exemplos anteriores vimos o uso de diversos alvos como o DROP e o ACCEPT. Apenas farei uma
breve referência sobre os alvos mais usados em operações comuns dos chains. Os alvos REDIRECT, SNAT e
DNAT serão explicados em uma seção seguinte:
ACCEPT O pacote é ACEITO e o processamento das regras daquele chains é concluído. Pode ser usado
como alvo em todos os chains de todas as tabelas do iptables e também pode ser especificado no policiamento
padrão das regras do firewall.
DROP Rejeita o pacote e o processamento das regras daquele chain é concluído. Pode ser usado como
alvo em todos os chains de todas as tabelas do iptables e também pode ser especificado no policiamento padrão
das regras do firewall.
REJECT Este é um módulo opcional que faz a mesma função do alvo DROP com a diferença de que
uma mensagem ICMP do tipo “icmp-port-unreachable” (TCP/UDP) ou “host-unreachable” (ICMP) é retornada
para a máquina de origem. Pode ser usado como alvo somente nos chains da tabela (não como policiamento
padrão).
LOG Este módulo envia uma mensagem ao syslog caso a regra confira, o processamento continua
normalmente para a próxima regra (o pacote não é nem considerado ACEITO ou REJEITADO).
RETURN Retorna o processamento do chain anterior sem processar o resto do chain atual.
QUEUE Passa o processamento para um programa a nível de usuário.
Alvo REJECT
Este alvo rejeita o pacote (como o DROP) e envia uma mensagem ICMP do tipo “icmp-portunreachable”
como padrão para a máquina de origem. É um alvo interessante para bloqueio de portas TCP, pois em alguns
casos da a impressão que a máquina não dispõe de um sistema de firewall (o alvo DROP causa uma parada de
muito tempo em alguns portscanners e tentativas de conexão de serviços, revelando imediatamente o uso de um
sistema de firewall pela máquina). O alvo REJECT somente pode ser usado na tabela filter. Quando um pacote
confere, ele é rejeitado com a mensagem ICMP do tipo “port unreachable”, é possível especificar outro tipo de
mensagem ICMP com a opção –reject-with tipo_icmp.
OBS: REJECT pode ser usado somente como alvo na tabela filter e não é possível especifica-lo como
policiamento padrão do chain filter (como acontecia no ipchains. Uma forma alternativa é inserir como última
regra uma que pegue todos os pacotes restantes daquele chain e tenha como alvo REJECT (como iptables -A
INPUT -j REJECT), desta forma ele nunca atingirá o policiamento padrão do chain.
# Rejeita pacotes vindos de 200.200.200.1 pela interface eth0:
iptables -A INPUT -s 200.200.200.1 -i eth0 -j REJECT
Alvo LOG
Este alvo é usado para registrar a passagem de pacotes no syslog do sistema. É um alvo muito

interessante para ser usado para regras que bloqueiam determinados tráfegos no sistema (para que o
administrador tome conhecimento sobre tais tentativas), para regras de fim de chain (quando você tem um
grande conjunto de regras em um firewall restritivo e não sabe onde suas regras estão sendo bloqueadas), para
satisfazer sua curiosidade, etc.
Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface
iptables -A INPUT -s 200.200.200.1 -i eth0 -j LOG
Para efetuar o bloqueio

Note que no exemplo anterior a regra que registra o pacote (-j LOG) deve aparecer antes da regra que REJEITA (-j REJECT),
caso contrário a regra de LOG nunca funcionará. A regra que REJEITA poderia também ser trocada por uma regra que ACEITA, caso
queira registrar um pacote que deve ser aceito (se o policiamento padrão do seu firewall for restritivo (-P DROP).
A única coisa que muda nas regras de log é o alvo da regra, isto facilita a implementação de grandes
conjuntos de regras de firewall.
A regra acima mostrará a seguinte saída no syslog do sistema:
Jan 25 09:31:43 supertux kernel: IN=eth0 OUT= MAC=00:08:54:07:45:38:00:06:4f:33:58:e0:08:00
SRC=89.250.7.25 DST=200.210.10.10 LEN=48 TOS=0x00 PREC=0x00 TTL=109 ID=55199 DF
PROTO=TCP SPT=3368 DPT=6588 WINDOW=65535 RES=0x00 SYN URGP=0
Os campos possuem o seguinte significado:
Jan 25 09:31:43 Mês, dia e hora do registro do pacote.
supertux Nome do computador que registrou o pacote.
kernel: Daemon que registrou a mensagem, no caso o iptables faz parte do próprio kernel.
IN=eth0 Especifica a interface de entrada (de onde o pacote veio).
OUT= Especifica a interface de saída (para onde o pacote foi).
MAC= 00:08:54:07:45:38:00:06:4f:33:58:e0:08:00 Endereço mac da interface de rede (pode ser obtido com arp
interface).
SRC=89.250.7.25 Endereço de origem do pacote.
DST=200.210.10.10 Endereço de destino do pacote.
SEQ=234234343 Número de seqüência da recepção. É ativado com a opção –log-tcp-sequence.
LEN=48 Tamanho em bytes do pacote IP.
TOS=0x00 Prioridade do cabeçalho TOS (Tipo).
PREC=0x00 Prioridade do cabeçalho TOS (Precedência).
TTL=109 Tempo de vida do pacote. No exemplo, 64 roteadores (hops).
ID=55199 Identificação única destes datagrama. Esta identificação também é usada pelos fragmentos seguintes deste pacote.
DF Opção “Don’t fragment” (não fragmentar) do pacote. Usada quando o pacote é pequeno o bastante para não precisar ser
fragmentado. MF Opção “More Fragments” (mais fragmentos) estão para ser recebidos.
PROTO=TCP Nome do protocolo. Pode ser TCP, UDP ou ICMP
SPT=3368 Porta de origem da requisição.
DPT=6588 Porta de destino da requisição.
WINDOW=Tamanho do buffer de dados alocado na máquina que enviou os dados
SYN Campo SYN no pacote TCP ativado
O log acima mostra uma varredura de portas para nossa máquina (INPUT) de 89.250.7.25 para
200.210.10.10. O problema é que em um grande número de regras será difícil saber qual regra conferiu (pois
teríamos que analisar o endereço/porta origem/destino) e o destino do pacote (se ele foi ACEITO ou
BLOQUEADO) pois você pode ter regras para ambas as situações. Por este motivo existem algumas opções
úteis que podemos usar com o alvo LOG:
–log-prefix “descrição”
Permite especificar uma descrição para a regra do firewall de até 29 caracteres. Caso tiver espaços, devem ser usadas “aspas”.
–log-level nível
Especifica o nível da mensagem no syslog.
–log-tcp-options
Registra campos do cabeçalho TCP nos logs do sistema.
–log-ip-options
Registra campos do cabeçalho IP nos logs do sistema
–log-tcp-sequence

Registra os números de seqüencia TCP. Evite ao máximo o uso desta opção, pois a seqüencia de números TCP pode ser a chave
para um seqüestro de seção ou IP spoofing em seu sistema caso algum usuário tenha acesso a estes logs. Caso utilize tcp/ip em
servidores públicos, o uso desta opção ajudará a entender bem os ataques DoS causados por syn-flood e porque ativar os SynCookies.
OBS1:Lembre-se que estas opções são referentes ao alvo LOG e devem ser usadas após este, caso
contrário você terá um pouco de trabalho para analisar e consertar erros em suas regras do firewall.
OBS2:Caso esteja usando o firewall em um servidor público, recomendo associar um limite a regra de
log, pois um ataque poderia causar um DoS enchendo sua partição.
Complementando o exemplo anterior:
Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface eth0
iptables -A INPUT -s 200.200.200.1 -i eth0 -j LOG --log-prefix "FIREWALL: Derrubado
Para efetuar o bloqueio
Retornará a seguinte mensagem no syslog:
Aug 25 10:08:01 supertux kernel: FIREWALL: Derrubado IN=eth0 ...
Agora você sabe o que aconteceu com o pacote (Rejeitado). A padronização de mensagens de firewall é também importante para
a criação de scripts de análise que poderão fazer a análise dos logs do seu firewall (para criação de estatísticas que podem servir como
base para a criação de novas regras de firewall ou eliminação de outras).
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. Esta seção abordará 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.
MASQUERADE
O IP Masquerading é usado para conectar a sua rede interna a internet quando você recebe um único IP
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 eth0 -j MASQUERADE
O comando acima faz IP Masquerading de todo o tráfego de 192.168.99.2 indo para a interface eth0: 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 conectada via Masquerading. Observe que nos comandos em que usamos a tabela NAT especificamos
naturalmente que estamos usando a tabela “-t nat ”.
Para fazer o IP Masquerading de todas as máquinas da rede 192.168.99.0:
Após definir a regra para fazer Masquerading, execute o comando:

echo “1” >/proc/sys/net/ipv4/ip_forward
para habilitar o suporte a redirecionamento de pacotes no kernel.
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. Vamos dar alguns exemplos:
Vamos mudar o endereço de todas as conexões vindas de nossa rede(192.168.99.0/24) que vão para o IP
200.123.123.10 para o IP 10.1.1.1
iptables -t nat -A PREROUTING -d 200.123.123.10 -s 192.168.99.0/24 -j DNAT –to 10.1.1.1
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 3128
Redireciona as conexões indo para a porta 80 para a porta 3128 (rodando squid) no firewall.
Um outro uso interessante para o DNAT é o redirecionamento de portas para uma máquina específica de
nossa rede. Ex.: redirecionar todas as conexões oriundas da internet na porta 80 de nosso firewall para a
máquina 192.168.99.3.
iptables -t nat -A PREROUTING -i eth0 -p tcp –dport 80 -j DNAT –to-destination 192.168.99.3
Observe que especificamos que só irão os pacotes TCP, com destino a porta 80 e que entraram no
firewall pela interface eth0. Podemos especificar também a porta de destino na máquina interna. Por exemplo:
iptables -t nat -A PREROUTING -i eth0 -p tcp –dport 4325 -j DNAT –to-destination 192.168.99.3:5900
Fizemos com que as conexões da internet para o nosso firewall na porta TCP 4325 fossem redirecionadas
para a máquina 192.168.99.3 na porta 5900.
Fazendo scripts para inicialização do firewall

Agora que aprendemos a criar regras individuais para tratar determinados tipos de tráfegos, vamos reunir
várias regras juntas em um arquivo. O importante neste caso é a organização das regras junto com a ordem.
A partir de agora iremos trabalhar com scripts para inciar nosso firewall, nele usaremos todas as opções.
Vamos nomear esse arquivo de /sbin/firewall.sh.
Exemplo de conteúdo do arquivo /sbin/firewall.sh
#!/bin/bash
#primeiro vamos limpar todas as regras que já existentes
iptables -F
iptables -t nat -F
#ativamos o repasse de pacotes no kernel
echo 1 > /proc/sys/net/ipv4/ip_forward
#ativa masquerade
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
Bom, esse conteúdo, é somente de exemplo de arquivo. Um firewall mais completo iremos ver na seção
a seguir. Por enquanto, basta dizer que colocando todas as nossas regras neste arquivo, basta torná-lo
executável com “chmod +x /sbin/firewall.sh” e execultar a cada vez que você mudar suas regras no firewall.
OBS.: Esse arquivo serve para agrupar todos os comandos que manipulam o firewall. Alterando o
arquivo não quer dizer que você esteja alterando o firewall que esta sendo executado. As regras somente terão
resultado após executado o arquivo.

Exemplos
Agora um exemplo real de um script de firewall para finalizar:
Neste exemplo vamos assumir que a sua rede local é a 192.168.99.0/24 e a placa de rede local é a eth1.
#!/bin/bash
#ativar encaminhamento de pacotes
echo 1 > /proc/sys/net/ipv4/ip_forward
#limpando regras caso existam

iptables -F
iptables -F -t nat
#configurando o policiamento padrão das regras

iptables -P INPUT DROP
iptables -P FORWARD DROP
iptables -P OUTPUT DROP
#Tabela filter(omitida nos comandos)
#para os pacotes de saida, com exceção dos INVALID serão aceitos

iptables -A OUTPUT -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
#Todos os pacotes originados pelo sistema serão aceitos

iptables -A INPUT -i lo -j ACCEPT
#aceita pacotes cujo estado seja ESTABILISHED ou RELATED

iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
#aceita a entrada de pacotes da rede local com endereços locais

iptables -A INPUT -s 192.168.99.0/24 -i eth1 -j ACCEPT
#tudo o que não seja aceito por INPUT vai ser bloqueado pela politica DROP
#porém vamos fazer LOG antes
iptables -A INPUT -j LOG --log-prefix " INPUT_DROP "
#aceita o repasse de pacotes cujo estado seja ESTABLISHED,RELATED

#caso sejam novas serão tratados a seguir
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
#a rede local pode acessar FTP

iptables -A FORWARD -s 192.168.99.0/24 -p tcp --dport 21 -j ACCEPT
#a rede local pode acessar SSH
#a rede local pode acessar TELNET
#a rede local pode acessar SMTP
#a rede local pode acessar WEB
#a rede local pode acessar POP3
#a rede local pode acessar SSL/HTTPS
#a rede local pode acessar DNS
iptables -A FORWARD -s 192.168.99.0/24 -p udp --dport 53 -j ACCEPT
#a rede local pode pingar maquinas de fora
iptables -A FORWARD -s 192.168.99.0/24 -p icmp --icmp-type echo-request -j ACCEPT
#tudo o que não seja aceito por FORWARD vai ser bloqueado pela politica DROP
#porém vamos fazer LOG antes
iptables -A FORWARD -j LOG --log-prefix " FORWARD_DROP "
#Tabela NAT
#fazer MASQUERADE
#redirecionar pacotes para o nosso squid
iptables -t nat -A PREROUTING -p tcp --dport 80 -s 192.168.99.0/24 -i eth1 -j REDIRECT --to-ports 3128

Administracao de Redes Linux I PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Administracao de Redes Linux I PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 1

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 2

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 3

Introdução às redes locais

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 4

Requerimento de hardware para cada tipo de aplicação

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 5

Procedimento para instalação

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 6

Comandos de sistemas de arquivos

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 7

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 8

Exemplo: du -h, du -hc.

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 9

Comandos para gerenciamento de usuários.

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 10

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 11

Mcedit(midnight commander editor)

Principais arquivos do sistema

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 12

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 13

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 14

Como exemplo, o /etc/resolv.conf se parece com isto:

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 15

Tipos de permissões de arquivos

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 16

Modo de permissões octais

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 17

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 18

Um modelo de arquivo sources.list

# Arquivos principais da stable

Atualizando sua distribuição

Instalando novos pacotes

Removendo pacotes instalados

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 19

Configuração básica e avançada

Dentro do bloco subnet podemos colocar várias opções, entre elas:

À seguir um exemplo de configuração básica de um servido DHCP(dhcpd.conf).

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 20

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 21

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 22

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 23

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 24

Agora vamos as opções interessantes da configuração

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 25

Explicações sobre ACLs

acl porhorario time MTWHF 12:00-13:00

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 26

http_access deny semacesso

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 27

PDC-Controlador primário de domínio

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 28

Exemplos de utilização de variáveis:

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 29

Configuração de servidor de arquivos simples

unix charset = utf-8

obey pam restrictions = Yes

log file = /var/log/samba/log.%u

time server = Yes

panic action = /usr/share/samba/panic-action %d

admin users = root

Administração de Redes Linux I – Por: Edsongley Varela de Almeida Página 30

Configuração de máquinas rWindows