De ULBwiki

--Kamus Hadenes 12h44min de 15 de Fevereiro de 2009 (UTC)

Esta página será constatemente atualizada conforme meu saco para tanto.

Tabela de conteúdo

1 Segurança

Segurança

Olá. Me chamo Kamus Hadenes. Ao menos é este meu nick. Sou uma pessoa paranóica com segurança em geral, principalmente com segurança da informação. Minhas partições são criptografadas com soma de 3 algorítmos e com senhas 100+, e os dados ainda mais importantes possuem encriptação do mais alto nivel com senhas ainda mais assombrosas. Possuo senha na BIOS e no GRUB (a BIOS, infelizmente, é limitada a 6 chars. Mas isso não ocorre com o GRUB). Meu gabinete é lacrado e pretendo implementar alguma solução com thermithe para, num último caso, causar a destruição completa e irremediável dos dados no caso deste lacre ser rompido. Possuo saídas para acabar com meus dados sem deixar qualquer rastro. As pessoas a minha volta não fazem idéia do que me passa pela mente, mas eu as decifro como um livro aberto.

Você deve estar se perguntando o que eu tenho de tão importante para esconder. A resposta é uma única palavra: nada. É só a mais pura falta do que fazer.

Fork Bomb

Um problema bem chatinho é o fork bomb. Apelemos a nossa santa Wikipedia para nos explicar o que é um fork bomb:

"A fork bomb works by creating a large number of processes very quickly in order to saturate the available space in the list of processes kept by the computer's operating system. If the process table becomes saturated, no new programs may start until another process terminates. Even if that happens, it is not likely that a useful program may be started since the instances of the bomb program will each attempt to take any newly-available slot themselves.

Not only do fork bombs use space in the process table: each child process uses further processor-time and memory. As a result of this, the system and existing programs slow down and become much more unresponsive and difficult or even impossible to use."

Bem, mesmo que seu inglês seja uma droga, dá pra perceber que não é algo muito bom de se levar.

Um fork bomb muito conhecido em Linux é o

 :(){ :|:& };:

Um jeito simples de se evitar isto no Linux é seguir a dica do colega David Mendonça, do Viva o Linux, com algumas modificações :

Adicione o seguinte ao final do arquivo /etc/profile:

if [[ "$USER" == "root" ]]; then
    ulimit -S -u 512
else
    ulimit -S -u 300
fi

Agora, como usuário comum, rode o seguinte comando:

 source /etc/profile

Prontinho. Agora, além de bloquear o fork bomb, o usuário que o executar ainda irá receber uma bela mensagem, mostrando que falhou vergonhosamente:

bash: fork: Cannot allocate memory

Obs.: Há um patch para o kernel chamado de GrSecurity, um conjunto de várias utilidades de segurança que além de bloquear o fork, ainda loga o usuário que o tentou rodar. Não irei discutir sobre este patch aqui por não ter testado o suficiente suas funções.

Firewall

Que o Linux é um dos sistemas mais seguros do mundo, isso todos já estamos carecas de saber. Mas, mesmo sendo um sistema de tamanha segurança, um firewall sempre se faz necessário. Aqui irei descrever um forma de se manter protegido com apenas alguns comandos.

Explicando

Existe uma espécie de "firewall embutido" no kernel do Linux que supera qualquer firewall pago. Seu nome é IPTables (netfilter). Ele é controlado através de comandos, o que pode tornar sua administração uma tarefa bastante chata para usuários novatos. Então criei um script de firewall baseado na criação de meu amigo Rhoy. Seu uso é simples:

Aplicando

1. Crie um novo arquivo em /etc/init.d de nome firewall:

# touch /etc/init.d/firewall

2. Edite este arquivo:

# gedit /etc/init.d/firewall

3. e cole o seguinte:

#!/bin/bash                                                                                            
 # **********************************************                                                      
 # ** Script de firewall para proteção básica (mentira, é paranóica mesmo)                             
 # ** Contato:kamushadenes@gmail.com                                                                   
 # ** by: Kamus Hadenes                                                                                
 # **********************************************                                                      
 # Declaração de variáveis.                                                                            
 FIREWALL='/etc/init.d/firewall'                                                                       
 WAN='eth0'                                                                                            
 IPTABLES=$(which 'iptables')                                                                          
 MODPROBE=$(which 'modprobe')                                                                          
 REDE_INTERNA="192.168.1.0/24"                                                                         
 
 
 start() { 
 
        echo "Starting Guardian Angel Firewall..."
 
        echo 'Loading modules...'                 
        $MODPROBE 'ip_tables'                     
        $MODPROBE 'x_tables'                      
        echo 'Cleaning up firewall...'            
 
        iptables -F                               
        iptables -t nat -F                        
        iptables -t mangle -F                     
        iptables -X                               
        iptables -t nat -X                        
        iptables -t mangle -X                     
        iptables -Z                               
        iptables -t nat -Z                        
        iptables -t mangle -Z                     
 
 
        iptables -P INPUT DROP                    
        iptables -P FORWARD DROP                  
        iptables -P OUTPUT ACCEPT                 
        echo 'OK -> Default policy defined...'    
 
 
        echo  'OK -> Loopback interface enabled...'         
        iptables -A INPUT -i lo -j ACCEPT                   
 
        iptables -A FORWARD -p tcp --syn -m limit --limit 1/s -j ACCEPT
        echo OK -> DOS Protection                                      
 
        #echo 'OK -> Comunication trought interfaces enabled...'
        #echo '1' > /proc/sys/net/ipv4/ip_forward               
 
        # Bloquear pacotes com estado "novo/invalido" que saiam pela eth0 
        iptables -A FORWARD -o eth0 -m state --state NEW,INVALID -j DROP  
 
 
        #Bloqueando conexão brute force via SSH:                          
        iptables -A INPUT -p tcp --dport 22 --syn -j ACCEPT               
        echo 'OK -> Accepted SSH Connection (fail2ban enabled)...'                
 
        #Bloqueando conexões vindas em qualquer porta tcp do seu micro            
        #iptables -A INPUT -p tcp --syn -j DROP                                   
        #echo 'OK -> Blocked any tcp connections...'                                   
 
 
        #PROTEÇÃO CONTRA ATAQUES                                                       
        iptables -A INPUT -m state --state INVALID -j DROP                             
        echo "OK -> Blocking attacks..."                                               
 
        #PROTEGE CONTRA PACOTES QUE PODEM PROCURAR E OBTER INFORMAÇÕES INTERNAS        
        iptables -A FORWARD --protocol tcp --tcp-flags ALL SYN,ACK -j DROP             
        echo "OK -> Spy-packages protection..."                                        
 
        #BLOQUEANDO TRACEROUTE                                                         
        iptables -A INPUT -p udp -s 0/0 -i eth0 --dport 33435:33525 -j DROP            
        echo "OK -> Blocking traceroute..."                                            
 
        #REGRAS DE SEGURANÇA NA INTERNET                                               
        iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT               
        iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT             
        echo "OK -> Internet security rules..."                                        
 
        #PROTECOES DE KERNEL                                                           
        echo 0 > /proc/sys/net/ipv4/conf/eth0/accept_source_route                      
        echo 0 > /proc/sys/net/ipv4/conf/eth0/accept_redirects                         
        echo 0 > /proc/sys/net/ipv4/conf/all/accept_redirects                          
        echo 1 > /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses                  
        echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all                               
        echo 1 > /proc/sys/net/ipv4/tcp_syncookies                                     
        echo 0 > /proc/sys/net/ipv4/conf/all/accept_source_route                       
        echo 1 > /proc/sys/net/ipv4/conf/all/rp_filter                                 
        echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts                        
        echo 1 > /proc/sys/net/ipv4/conf/all/log_martians                              
        echo "OK -> Kernel protections..."                                             
 
        #Liberar Transmission                                                          
        #iptables -A INPUT -p tcp --dport 2450 -j ACCEPT                               
        #iptables -A INPUT -p tcp --dport 2451 -j ACCEPT                               
        #iptables -A INPUT -p tcp --dport 2452 -j ACCEPT                               
        #iptables -A INPUT -p tcp --dport 2453 -j ACCEPT                               
        #iptables -A INPUT -p tcp --dport 2454 -j ACCEPT                               
        #iptables -A INPUT -p tcp --dport 2455 -j ACCEPT                               
        #iptables -A INPUT -p tcp --dport 2456 -j ACCEPT                               
        iptables -A INPUT -p tcp --dport 2457 -j ACCEPT                                
        #iptables -A INPUT -p tcp --dport 2458 -j ACCEPT                               
        #iptables -A INPUT -p tcp --dport 2459 -j ACCEPT                               
 
        #Liberar Miro                                                                  
        iptables -A INPUT -p tcp --dport 8500:8600 -j ACCEPT                           
 
        #Liberar WebMin
        iptables -A INPUT -p udp --dport 10000 -j ACCEPT        
        iptables -A INPUT -p tcp --dport 10000 -j ACCEPT        
 
        #BZFlag                                                 
        #iptables -A INPUT -p tcp --dport 5154 -j DROP          
 
        #Apache
        iptables -A INPUT -p tcp --dport 80 -j ACCEPT 
        iptables -A INPUT -p tcp --dport 8080 -j ACCEPT 
 
 
        #Proteções Adicionais                           
        #iptables -A INPUT -p tcp --dport 5900 -j DROP  
        #iptables -A INPUT -p tcp --dport 53 -j DROP    
 
 
        #echo 'OK -> Definido redirecionamento de proxy transparente'
        iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3128
 
 
        # Proteção contra ping da morte                                                   
        # -------------------------------------------------------                         
        iptables -A FORWARD -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT                                                                 
 
 
        # Proteção contra trinoo                                                                                                                            
        # -------------------------------------------------------                                                                                           
        iptables -N TRINOO                                                                                                                                  
        iptables -A TRINOO -m limit --limit 15/m -j LOG --log-level 6 --log-prefix "FIREWALL: trinoo: "                                                     
        iptables -A TRINOO -j DROP                                                                                                                          
        iptables -A INPUT -p TCP -i eth0 --dport 27444 -j TRINOO                                                                                            
        iptables -A INPUT -p TCP -i eth0 --dport 27665 -j TRINOO                                                                                            
        iptables -A INPUT -p TCP -i eth0 --dport 31335 -j TRINOO                                                                                            
        iptables -A INPUT -p TCP -i eth0 --dport 34555 -j TRINOO                                                                                            
        iptables -A INPUT -p TCP -i eth0 --dport 35555 -j TRINOO                                                                                            
        echo 'OK -> Trinoo protection...'                                                                                                                   
 
        # Proteção contra trojans                                                                                                                           
        # -------------------------------------------------------                                                                                           
        iptables -N TROJAN                                                                                                                                  
        iptables -A TROJAN -m limit --limit 15/m -j LOG --log-level 6 --log-prefix "FIREWALL: trojan: "                                                     
        iptables -A TROJAN -j DROP                                                                                                                          
        iptables -A INPUT -p TCP -i eth0 --dport 666 -j TROJAN                                                                                              
        iptables -A INPUT -p TCP -i eth0 --dport 4000 -j TROJAN                                                                                             
        iptables -A INPUT -p TCP -i eth0 --dport 6000 -j TROJAN                                                                                             
        iptables -A INPUT -p TCP -i eth0 --dport 6006 -j TROJAN                                                                                             
        iptables -A INPUT -p TCP -i eth0 --dport 16660 -j TROJAN                                                                                            
        echo 'OK -> Trojan protection...'                                                                                                                   
 
        # Proteção contra worms                                                                                                                             
        # -------------------------------------------------------                                                                                           
        iptables -A FORWARD -p tcp --dport 135 -i eth0 -j REJECT                                                                                            
        echo 'OK -> Worm protection...'                                                                                                                     
 
        # Proteção contra port scanners                                                                                                                     
        # -------------------------------------------------------                                                                                           
        iptables -N SCANNER                                                                                                                                 
        iptables -A SCANNER -m limit --limit 15/m -j LOG --log-level 6 --log-prefix "FIREWALL: port scanner: "                                              
        iptables -A SCANNER -j DROP                                                                                                                         
        iptables -A INPUT -p tcp --tcp-flags ALL FIN,URG,PSH -i eth0 -j SCANNER                                                                             
        iptables -A INPUT -p tcp --tcp-flags ALL NONE -i eth0 -j SCANNER                                                                                    
        iptables -A INPUT -p tcp --tcp-flags ALL ALL -i eth0 -j SCANNER                                                                                     
        iptables -A INPUT -p tcp --tcp-flags ALL FIN,SYN -i eth0 -j SCANNER                                                                                 
        iptables -A INPUT -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -i eth0 -j SCANNER                                                                     
        iptables -A INPUT -p tcp --tcp-flags SYN,RST SYN,RST -i eth0 -j SCANNER                                                                             
        iptables -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -i eth0 -j SCANNER                                                                             
        echo 'OK -> Port Scanner Protection...'                                                                                                             
        ## BLOQUEANDO PORT SCANNERS OCULTOS                                                                                                                 
        iptables -A FORWARD -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s -j ACCEPT                                                           
        echo 'OK -> Hidden Port Scanner Protection...'                                                                                                         
 
        #BackOrifice                                                                                                                                        
        iptables -A INPUT -p tcp -m tcp --dport 31337 -j DROP                                                                                               
        iptables -A INPUT -p udp -m udp --dport 31337 -j DROP                                                                                               
        echo 'OK -> BackOrifice Protection...'                                                                                                              
 
        #NetBus                                                                                                                                             
        iptables -A INPUT -p tcp -m tcp --dport 12345:12346 -j DROP                                                                                         
        iptables -A INPUT -p udp -m udp --dport 12345:12346 -j DROP                                                                                         
        echo 'OK -> NetBus Protecion...'                                                                                                                    
 
        # Libera a comunicaçao para $REDE_INTERNA                                                                                                           
        iptables -A INPUT -s $REDE_INTERNA -j ACCEPT                                                                                                        
        iptables -A FORWARD -s $REDE_INTERNA -d $REDE_INTERNA -j ACCEPT                                                                                     
 
        # Ativa mascaramento de saída
        # -------------------------------------------------------
        iptables -A POSTROUTING -t nat -o eth0 -j MASQUERADE     
        echo 'OK -> Packages output masquerading...'             
 
        #Liberar distcc                                          
        iptables -A INPUT -p tcp --dport 3632 -m state --state NEW -j ACCEPT
        echo "OK -> Allow cross-compilation..."                             
 
        #Regra adicional: Bluetooth                                         
        hciconfig hci0 up                                                   
        hciconfig hci0 piscan                                               
        hciconfig hci0 encrypt                                              
        mkdir -p /dev/bluetooth/rfcomm                                      
        mknod -m 666 /dev/bluetooth/rfcomm/0 c 216 0                        
 
        echo
        mkdir -p /var/lock/subsys/
        touch /var/lock/subsys/iptables 
 
      }                                 
 
   stop() {
        echo "Stopping Guardian Angel..."
        echo "OK -> Flushing all chains" 
        iptables -F                      
        iptables -t nat -F               
        iptables -t mangle -F            
        echo "OK -> Removed user defined chains" 
        iptables -X                              
        iptables -t nat -X                       
        iptables -t mangle -X                    
        iptables -Z                              
        iptables -t nat -Z                       
        iptables -t mangle -Z                    
        iptables -P INPUT ACCEPT                 
        iptables -P FORWARD ACCEPT               
        iptables -P OUTPUT ACCEPT                
        echo "OK -> Resetted built-in chains to the default ACCEPT policy"
        echo OK                                                           
        echo                                                              
        rm -f /var/lock/subsys/iptables                                   
  }                                                                       
 
  case "$1" in                                                            
  start)                                                                  
  start                                                                   
  ;;                                                                      
 
  stop)
  stop
  ;;
 
  restart)
  #  Função inútil, mas... sejam felizes...
  start
  ;;
 
  status)
  iptables --list
  ;;
 
  panic)
  echo "OK -> Changed target policies to DROP"
  iptables -P INPUT DROP && \
  iptables -P FORWARD DROP && \
  iptables -P OUTPUT DROP && \
  echo
  echo "OK -> Flushing all chains"
  iptables -F INPUT && iptables -F FORWARD && iptables -F OUTPUT
  echo "OK -> Removed user defined chains"
  iptables -X
  echo "OK -> Extremelly paranoic mode [ON] (yes, you can be more paranoic than the default start function)"
  ;;
 
  *)
     echo "Opções disponíveis são: start|stop|restart|status|panic"
  ;;
 
 esac
 exit 0

4. Execute:

# chmod a+x /etc/init.d/firewall

5. Habilite no boot:

# apt-get install bum

Sistema > Administração > BootUp Manager Procure por firewall, habilite a caixa, dê aplicar e depois não.

6. Ative o firewall:

/etc/init.d/firewall start

Obs.: Para parar o firewall, execute

/etc/init.d/firewall stop

Importante: Tome cuidado, parar o firewall fara com que todas as conexões sejam aceitas, o que é um potencial risco de segurança. Seria o mesmo que não ter um firewall. Use por sua conta e risco...

Obs.2:Este firewall é voltado para máquinas que funcionam como rotuer de rede mista, mas nada impede que ele seja usado em máquinas de uso geral.

Checando Status

Via Terminal

Este script só funcionará para este firewall em específico, já que existem diversas maneiras de se fazer a mesma coisa. Crie um novo arquivo em /bin de nome firewall-frontend-shell e cole nele o seguinte:

#!/bin/sh

#Variables
POLICIES_INPUT=$(iptables -S | grep -e "-P INPUT" | awk '{print$3}')
POLICIES_FORWARD=$(iptables -S | grep -e "-P FORWARD" | awk '{print$3}')
POLICIES_OUTPUT=$(iptables -S | grep -e "-P OUTPUT" | awk '{print$3}')

RULES_LO_EXISTS=$(iptables -S | grep -e "-i lo" | wc -l)
RULES_LO_STATUS=$(iptables -S | grep -e "-i lo" | awk '{print$6}')
RULES_DOS_PROTECTION=$(iptables -S | grep -e "-A FORWARD -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -m limit --limit 1/sec -j ACCEPT " | wc -l)
RULES_INVALID_PKG=$(iptables -S | grep -e "-A FORWARD -o eth0 -m state --state INVALID,NEW -j DROP" | wc -l)
RULES_SPY_PKG=$(iptables -S | grep -e "-A FORWARD -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG SYN,ACK -j DROP" | wc -l)
RULES_TRACEROUTE=$(iptables -S | grep -e "-A INPUT -i eth0 -p udp -m udp --dport 33435:33525 -j" | awk '{print$12}')
RULES_INTERNET_GENERAL=$(iptables -S | grep -e "-m state --state RELATED,ESTABLISHED -j ACCEPT" | wc -l)
RULES_INTERNET_GENERAL_DROP=$(iptables -S | grep -e "-m state --state RELATED,ESTABLISHED -j ACCEPT" | awk '{print$2}')
RULES_APACHE=$(iptables -S | grep -e "-A INPUT -p tcp -m tcp --dport 80" | grep ACCEPT | awk '{print$8}')
RULES_DEATHPING=$(iptables -S | grep -e "-A FORWARD -p icmp -m icmp --icmp-type 8 -m limit --limit 1/sec -j ACCEPT" | wc -l)
RULES_TRINOO1=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 27444 -j TRINOO" | wc -l)
RULES_TRINOO2=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 27665 -j TRINOO" | wc -l)
RULES_TRINOO3=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 31335 -j TRINOO" | wc -l)
RULES_TRINOO4=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 34555 -j TRINOO" | wc -l)
RULES_TRINOO5=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 35555 -j TRINOO" | wc -l)
RULES_TRINOO6=$(iptables -S | grep -e '-A TRINOO -m limit --limit 15/min -j LOG --log-prefix "FIREWALL: trinoo: " --log-level 6' | wc -l)
RULES_TRINOO7=$(iptables -S | grep -e "-A TRINOO -j DROP" | wc -l)
RULES_TROJAN1=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 666 -j TROJAN" | wc -l)
RULES_TROJAN2=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 4000 -j TROJAN" | wc -l)
RULES_TROJAN3=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 6000 -j TROJAN" | wc -l)
RULES_TROJAN4=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 6006 -j TROJAN" | wc -l)
RULES_TROJAN5=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --dport 16660 -j TROJAN"| wc -l)
RULES_TROJAN6=$(iptables -S | grep -e '-A TROJAN -m limit --limit 15/min -j LOG --log-prefix "FIREWALL: trojan: " --log-level 6' | wc -l)
RULES_TROJAN7=$(iptables -S | grep -e "-A TROJAN -j DROP" | wc -l)
RULES_WORM=$(iptables -S | grep -e "-A FORWARD -i eth0 -p tcp -m tcp --dport 135 -j REJECT --reject-with icmp-port-unreachable" | wc -l)
RULES_SCANNER1=$(iptables -S | grep -e "-N SCANNER" | wc -l)
RULES_SCANNER2=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,PSH,URG -j SCANNER"  | wc -l)
RULES_SCANNER3=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j SCANNER"  | wc -l)
RULES_SCANNER4=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,PSH,ACK,URG -j SCANNER"  | wc -l)
RULES_SCANNER5=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN -j SCANNER"  | wc -l)
RULES_SCANNER6=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,ACK,URG -j SCANNER"  | wc -l)
RULES_SCANNER7=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j SCANNER"  | wc -l)
RULES_SCANNER8=$(iptables -S | grep -e "-A INPUT -i eth0 -p tcp -m tcp --tcp-flags FIN,SYN FIN,SYN -j SCANNER"  | wc -l)
RULES_SCANNER9=$(iptables -S | grep -e '-A SCANNER -m limit --limit 15/min -j LOG --log-prefix "FIREWALL: port scanner: " --log-level 6'  | wc -l)
RULES_SCANNER10=$(iptables -S | grep -e "-A SCANNER -j DROP" | wc -l)
RULES_HIDDEN_SCANNER=$(iptables -S | grep -e "-A FORWARD -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK RST -m limit --limit 1/sec -j ACCEPT" | wc -l)
RULES_BO1=$(iptables -S | grep -e "-A INPUT -p tcp -m tcp --dport 31337 -j DROP" | wc -l)
RULES_BO2=$(iptables -S | grep -e "-A INPUT -p udp -m udp --dport 31337 -j DROP" | wc -l)
RULES_NETBUS1=$(iptables -S | grep -e "-A INPUT -p tcp -m tcp --dport 12345:12346 -j DROP" | wc -l)
RULES_NETBUS2=$(iptables -S | grep -e "-A INPUT -p udp -m udp --dport 12345:12346 -j DROP" | wc -l)
RULES_MASQUERADE=$(iptables -t nat -L | grep -e "MASQUERADE  all  --  anywhere             anywhere" | wc -l)

KERNEL_IP_FORWARD=$(cat /proc/sys/net/ipv4/ip_forward)
KERNEL_ACCEPT_SOURCE=(cat /proc/sys/net/ipv4/conf/all/accept_source_route)
KERNEL_ACCEPT_REDIRECTS=(cat /proc/sys/net/ipv4/conf/all/accept_redirects)
KERNEL_IGNORE_BOGUS=$(cat /proc/sys/net/ipv4/icmp_ignore_bogus_error_responses)
KERNEL_IGNORE_ICMP_ECHO=$(cat /proc/sys/net/ipv4/icmp_echo_ignore_all)
KERNEL_TCP_SYNCOOKIES=$(cat /proc/sys/net/ipv4/tcp_syncookies)
KERNEL_RP_FILTER=$(cat /proc/sys/net/ipv4/conf/all/rp_filter)
KERNEL_LOG_MARTIANS=$(cat /proc/sys/net/ipv4/conf/all/log_martians)

EXT_FAIL2BAN_APACHE=$(iptables -S | grep -e "A INPUT -p tcp -m multiport --dports 80,443 -j fail2ban-apache" | grep -ve "-A INPUT -p tcp -m multiport --dports 80,443 -j fail2ban-apache-overflows" | grep -ve "-A INPUT -p tcp -m multiport --dports 80,443 -j fail2ban-apache-multiport" | grep -ve "-A INPUT -p tcp -m multiport --dports 80,443 -j fail2ban-apache-noscript" | wc -l) 
EXT_FAIL2BAN_SASL=$(iptables -S | grep -e "-A INPUT -p tcp -m multiport --dports 25,465,143,220,993,110,995 -j fail2ban-sasl" | wc -l) 
EXT_FAIL2BAN_POSTFIX=$(iptables -S | grep -e "-A INPUT -p tcp -m multiport --dports 25,465 -j fail2ban-postfix" | wc -l) 
EXT_FAIL2BAN_SSH=$(iptables -S | grep -e "-A INPUT -p tcp -m multiport --dports 22 -j fail2ban-ssh" | grep -ve "-A INPUT -p tcp -m multiport --dports 22 -j fail2ban-ssh-ddos" | wc -l) 
EXT_FAIL2BAN_APACHE_OVERFLOWS=$(iptables -S | grep -e "-A INPUT -p tcp -m multiport --dports 80,443 -j fail2ban-apache-overflows" | wc -l) 
EXT_FAIL2BAN_APACHE_MULTIPORT=$(iptables -S | grep -e "-A INPUT -p tcp -m multiport --dports 80,443 -j fail2ban-apache-multiport" | wc -l) 
EXT_FAIL2BAN_SSH_DDOS=$(iptables -S | grep -e "-A INPUT -p tcp -m multiport --dports 22 -j fail2ban-ssh-ddos" | wc -l) 
EXT_FAIL2BAN_APACHE_NOSCRIPT=$(iptables -S | grep -e "-A INPUT -p tcp -m multiport --dports 80,443 -j fail2ban-apache-noscript" | wc -l) 

echo "===Default Policies==="
echo INPUT: $POLICIES_INPUT 
echo FORWARD: $POLICIES_FORWARD
echo OUTPUT: $POLICIES_OUTPUT

echo

echo "===Rules==="

if [ "$RULES_LO_EXISTS" = "1" ]; then
        echo Loopback Interface: $RULES_LO_STATUS
else
        echo "Loopback Interface: Unknown"
fi

if [ "$RULES_DOS_PROTECTION" = "1" ]; then
        echo DOS Protection: On
else
        echo "DOS Protection: Off"
fi

if [ "$RULES_INVALID_PKG" = "1" ]; then
        echo Invalid/New PKG Protection: On
else
        echo "Invalid/New PKG Protection: Off"
fi

if [ "$RULES_SPY_PKG" = "1" ]; then
        echo Spy-Package Protection: On
else
        echo "Spy-Package Protection: Off"
fi

echo Traceroute Status: $RULES_TRACEROUTE

if [ "$RULES_INTERNET_GENERAL" = "2" ]; then 
        echo General Internet Security Rules: On

elif [ "$RULES_INTERNET_GENERAL" = "1" ]
then 
	echo General Internet Security: Partial: $RULES_INTERNET_GENERAL_DROP
	
else 
        echo "General Internet Security Rules: Off"

fi

echo Apache Ports Accepted: $RULES_APACHE

if [ "$RULES_DEATHPING" = "1" ]; then
        echo Death Ping Protection: On
else
        echo "Death Ping Protection: Off"
fi

if [ "$RULES_TRINOO1" = "1" ] && [ "$RULES_TRINOO2" = "1" ] && [ "$RULES_TRINOO3" = "1" ] && [ "$RULES_TRINOO4" = "1" ] && [ "$RULES_TRINOO5" = "1" ] && [ "$RULES_TRINOO6" = "1" ] && [ "$RULES_TRINOO7" = "1" ]; then
        echo Trinoo Protection: On
else
        echo "Trinoo Protection: Off"
fi

if [ "$RULES_TROJAN1" = "1" ] && [ "$RULES_TROJAN2" = "1" ] && [ "$RULES_TROJAN3" = "1" ] && [ "$RULES_TROJAN4" = "1" ] && [ "$RULES_TROJAN5" = "1" ] && [ "$RULES_TROJAN6" = "1" ] && [ "$RULES_TROJAN7" = "1" ]; then
	echo Trojan Protection: On
else
	echo Trojan Protection: Off
fi

if [ "$RULES_WORM" = "1" ]; then
        echo Worm Protection: On
else
        echo "Worm Protection: Off"
fi

if [ "$RULES_SCANNER1" = "1" ] && [ "$RULES_SCANNER2" = "1" ] && [ "$RULES_SCANNER3" = "1" ] && [ "$RULES_SCANNER4" = "1" ] && [ "$RULES_SCANNER5" = "1" ] && [ "$RULES_SCANNER6" = "1" ] && [ "$RULES_SCANNER7" = "1" ] && [ "$RULES_SCANNER8" = "1" ] && [ "$RULES_SCANNER9" = "1" ] && [ "$RULES_SCANNER10" = "1" ]; then
	echo Port-Scanner Protection: On
else
	echo Port-Scanner Protection: Off
fi

if [ "$RULES_HIDDEN_SCANNER" = "1" ]; then
        echo Hidden Port-Scanner Protection: On
else
        echo Hidden Port-Scanner Protection: Off
fi

if [ "$RULES_BO1" = "1" ] && [ "$RULES_BO2" = "1" ]; then
	echo BackOrifice Protection: On
else
	echo BackOrifice Prtection: Off
fi

if [ "$RULES_NETBUS1" = "1" ] && [ "$RULES_NETBUS2" = "1" ]; then
        echo NetBus Protection: On
else
        echo NetBus Protection: Off
fi

if [ "$RULES_MASQUERADE" = "1" ]; then
	echo Output Masquerade: On
else
	echo Output Masquerade: Off
fi

echo

echo "===Kernel Security==="

if [ "$KERNEL_IP_FORWARD" = "1" ]; then
        echo IP Forward: On
else
        echo "IP Forward: Off"
fi


if [ $KERNEL_ACCEPT_SOURCE = "1" ]; then
        echo Accept Source: On
else
        echo Accept Source: Off
fi

if [ $KERNEL_ACCEPT_REDIRECTS = "1" ]; then
        echo Accept Redirects: On
else
        echo Accept Redirects: Off
fi

if [ $KERNEL_IGNORE_BOGUS = "1" ]; then
        echo Ignore Bogus Response: On
else
        echo Ignore Bogus Response: Off
fi

if [ $KERNEL_IGNORE_ICMP_ECHO = 1 ]; then
        echo Ignore ICMP Echo: On
else
        echo Ignore ICMP Echo: Off
fi

if [ $KERNEL_TCP_SYNCOOKIES = "1" ]; then
        echo TCP SynCookies: On
else
        echo TCP SynCookies: Off
fi

if [ $KERNEL_RP_FILTER = "1" ]; then
        echo RP Filter: On
else
        echo RP Filter: Off
fi

if [ $KERNEL_LOG_MARTIANS = "1" ]; then
        echo Martian Packages Logging: On
else
        echo Martian Packages Logging: Off
fi

echo

echo "===External Programs==="

if [ $EXT_FAIL2BAN_SASL = 1 ]; then
	echo Fail2Ban_Sasl = On
else
	echo Fail2Ban_Sasl = Off
fi

if [ $EXT_FAIL2BAN_POSTFIX = 1 ]; then
	echo Fail2Ban_Postfix = On
else
	echo Fail2Ban_Postfix = Off
fi

if [ $EXT_FAIL2BAN_APACHE = 1 ]; then
        echo Fail2Ban_Apache = On
else
        echo Fail2Ban_Apache = Off
fi


if [ $EXT_FAIL2BAN_APACHE_OVERFLOWS = 1 ]; then
	echo Fail2Ban_Apache_Overflows = On
else
	echo Fail2Ban_Apache_Overflows = Off
fi

if [ $EXT_FAIL2BAN_APACHE_NOSCRIPT = 1 ]; then
        echo Fail2Ban_Apache_NoScript = On
else
	echo Fail2Ban_Apache_NoScript = Off
fi

if [ $EXT_FAIL2BAN_APACHE_MULTIPORT = 1 ]; then
	echo Fail2Ban_Apache_Multiport = On
else
	echo Fail2Ban_Apache_Multiport = Off
fi

if [ $EXT_FAIL2BAN_SSH = 1 ]; then
        echo Fail2Ban_SSH = On
else
        echo Fail2Ban_SSH = Off
fi


if [ $EXT_FAIL2BAN_SSH_DDOS = 1 ]; then
	echo Fail2Ban_SSH_DDoS = On
else
	echo Fail2Ban_SSH_DDoS = Off
fi

Dê permissões de execução com

chmod +x /bin/firewall-frontend-shell

e rode o comando firewall-frontend-shell. O script faz a checagem pela proteção adicional do programa fail2ban. Não entrarei em detalhes de como instalar este programa, dê uma procurada em www.vivaolinux.com.br . Lembrando que a falta desse programa não influenciará no uso do script.

Conclusão

Pronto, tudo feito. Agora você não precisa se preocupar, pois o firewall irá iniciar automaticamente no boot, sem necessidade de intervenção do usuário, e você terá um sistema protegido.

UFW

Créditos: Guevara

O UFW é a nova maneira de configurar o firewall no Hardy e estes são os principais comandos:

$ sudo ufw enable – Habilita o Firewall

$ sudo ufw disable – Desabilita o Firewall

$ sudo ufw default allow – Permitir todas as conexões por padrão

$ sudo ufw default deny – Drop (bloqueia) todas as conexões por default

$ sudo ufw status – Regras e estado atual do Firewall

$ sudo ufw allow port – Permitir trafego em determinada porta (necessário escolher qual)

$ sudoufw deny port – Bloquear porta

$ sudo ufw deny from ip – Bloquear endereço ip

Como editar o before.rules:

Bloqueando requisições por ICMP:

$ sudo nano /etc/ufw/before.rules

Onde é necessário comentar a linha que diz:

-A ufw-before-input -p icmp --icmp-type echo-request -j ACCEPT

de modo que fique assim:

#-A ufw-before-input -p icmp --icmp-type echo-request -j ACCEPT

Existem várias opções de configuração que podem ser visualizadas pelo terminal.

Para mais informações digite no terminal:

$ man ufw

--Kamus Hadenes 12h44min de 15 de Fevereiro de 2009 (UTC)

Comunidade Ubuntu Linux Brasil

Wiki

Home Wiki

Segurança

De ULBwiki

Tabela de conteúdo

Segurança

Fork Bomb

Firewall

Explicando

Aplicando

Checando Status

Via Terminal

Conclusão

UFW

Acessos

Ferramentas pessoais

Pesquisa

Criar página

Ferramentas

Comunidade Ubuntu Linux Brasil

Wiki

HomeWiki

Segurança

De ULBwiki

Tabela de conteúdo

Segurança

Fork Bomb

Firewall

Explicando

Aplicando

Checando Status

Via Terminal

Conclusão

UFW

Acessos

Ferramentas pessoais

Pesquisa

Criar página

Ferramentas

Home Wiki