Aumentando Segurança Linux -  Part III (DoS,IP Spoof, Format Bugs,Backdoors)
Autor: Paulo Cesar | Publicado: 2014-04-06T17:01:00-07:00


OBS:&nbsp;Todos os dados e exemplos descritos neste arquivo possuem somente

&nbsp; &nbsp; &nbsp;propositos educacionais, o autor nao se responsabiliza pelo mau uso

&nbsp; &nbsp; &nbsp;dos mesmos.


Continuando...



&nbsp;&nbsp;***********************************

&nbsp; * &nbsp; &nbsp;Conceitos e Praticas - III &nbsp;*

&nbsp; ***********************************



--------------------------------&nbsp;ÍNDICE&nbsp;----------------------------------



1. Introdução

2. Problemas de Segurança &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;---------------------------&gt; artigos anteriores

&nbsp; &nbsp;2.0 &nbsp;- Escaneamento &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;---------------------------&gt; artigos anteriores

&nbsp; &nbsp;2.1 &nbsp;- Brutal Force &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;---------------------------&gt; artigos anteriores

&nbsp; &nbsp;2.2 &nbsp;- Senhas&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;---------------------------&gt; artigos anteriores

&nbsp; &nbsp;2.3 &nbsp;- Overflows&nbsp; &nbsp; &nbsp;&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;---------------------------&gt; artigos anteriores

&nbsp; &nbsp;2.4 &nbsp;- Vírus &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;---------------------------&gt; artigos anteriores

&nbsp; &nbsp;2.5 &nbsp;- DoS&nbsp; &nbsp;&nbsp;

&nbsp; &nbsp;2.6 &nbsp;- IP Spoof&nbsp; &nbsp; &nbsp; &nbsp;

&nbsp; &nbsp;2.7 &nbsp;- Format Bugs&nbsp; &nbsp; &nbsp; &nbsp;

&nbsp; &nbsp;2.8 &nbsp;- Backdoors&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;

&nbsp; &nbsp;2.9 &nbsp;- Outros&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;---------------------------&gt; próximos artigos

3. Terminando

&nbsp; &nbsp;3.1 &nbsp;- Links e Referencias.&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; ---------------------------&gt; próximos artigos

&nbsp; &nbsp;3.2 &nbsp;- Considerações Finais.&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;---------------------------&gt; próximos artigos


---------------------------------------------------------------------------



---------------

1 - Introdução |

---------------



Diferente dos demais artigos, neste, eu me limitarei apenas a descrever os

assuntos por auto, da forma mais básica possível. Não pretendo entrar na

parte de programação, de modo que, os pre-requisitos para o total

entendimento deste artigo, se limitam apenas a um conhecimento básico do Linux.&nbsp;

A distribuição do linux a ser trabalhada é o famoso Slackware , em sua kernel original.

Os conceitos e ferramentas descritas podem ser expansíveis a outras distribuições,

Kernel e implementações. Este é mais um artigo onde o publico alvo é o pessoal newbie(iniciante)

&nbsp;fuçador, e o meu interesse em ensinar as coisas elementares aqui, não é prover discussão

de segurança, mas apenas informar a respeito de tais aspectos e e um futuro próximo,&nbsp;

aumentar a discussão a respeito de furos em tais conceitos e aspectos.



Muita gente havia me pedido p/ descrever o básico sobre alguns conceitos

envolvidos no hacking, de modo que me aproveitarei deste artigo p/


procurar descrever estes conceitos.


------------------------------------

2. Problemas de&nbsp;Segurança&nbsp;| &nbsp;&nbsp;&nbsp;----- CONTINUAÇÃO

----------------------------------

2.5 &nbsp;- DoS
-----------

Outro tipo de ataque que é comumente praticado por script kiddies, é o
ataque Denial of Service. Um DoS nada mais é que usar táticas e esquemas
para se derrubar um serviço e expandindo mais o conceito, derrubar uma
rede ou um computador! Os DoS são úteis para fuçadores em algunas casos
(IP Spoof, por exemplo), mas na maioria das vezes, este ataque é
realizado por script kiddies usando exploits de terceiros apenas para
sacanear pessoas ou derrubar redes por prazer!

Um método de dificultar que tais ataques ocorram, &nbsp;"pode",
ser o uso de um bom firewall! Nenhum firewall é capaz de defender uma
rede contra os DDoS(DoS Distribuidos - onde existe a implementação do
conceito de Amplificação do envio de Dados). Por mais que ferramentas
comerciais digam que protegem um sistema contra DoS, isto é um devaneio
e em alguns casos o próprio Firewall pode servir de implementação desta
tecnica! No mundo windows a coisa é bem pior e a implementação da Stack/TCP
dos Windows tem se mostrado muito suscetiveis a tais ataques!

No Linux recomenda-se uma "atualização" da kernel! Particularmente, vejo
&nbsp;como uma boa opcao na atualidade quanto a problemas no STACK/TCP.
O uso de uma boa política de firewall pode ajudar contra determinados ataques,
mas é recomendável o uso de uma ferramenta IDS capaz de prever ataques DoS.

Existem também ataques locais, onde um usuário com acesso shell poderia
perfeitamente indisponibilizar os recursos de uma maquina! Em um sistema
Linux, um usuário qualquer poderia escrever um programa que consumisse
toda a memória da máquina, por isso, se faz necessário setar "quotas"
de memória e limitar o número de processos que um usuário comum pode
executar no linux! Um modo de se fazer isso é usando o comando ulimit
da BASH&nbsp;.Você poderia acrescentar as seguintes linhas em
/etc/profile:

if [ "$UID" != 0 ]; then
&nbsp; &nbsp;echo "Setando ulimit...";echo
&nbsp; &nbsp;ulimit -n 50
&nbsp; &nbsp;ulimit -u 10
&nbsp; &nbsp;echo "ulimit setado...";echo
fi

Setando deste modo o limite de 50 arquivos a serem abertos e setando
o limite de 50 processos a serem abertos pelo usuario! Manipulando
o comando ulimit, você poderia setar os limites de várias operações
conforme a necessidade de seus usuarios.


2.6 &nbsp;- IP Spoof
----------------

Como vimos acima, a técnica descrita como Denial of Service tem uma
utilidade maior, que é a implementação eficaz de invasões via IP Spoof -
a la Mitnick! - Sem dúvida que muitos fuçadores usam o DoS não com o
intuito de destruir uma rede, mas de conseguir efetuar uma invasão. Se
você utiliza servicos R*, NFS e etc, preste atenção que você pode estar
vulnerável a implementação de IP Spoof! Todos os Linux com kerneis 2.2.X
são vulneráveis a implementação desta técnica! Apesar de ser uma técnica
que pode vir a ser extremamente trabalhosa para um atacante, a condição
de exploitação existe e jamais deve ser menosprezada! Sem dúvida que a
grande maioria dos script kiddies seriam incapazes de realizar tal
exploitação, mas devemos ter em mente que existem programas "semi-prontos"
que automatizam e facilitam muito a implementação desta técnica!

Um modo de dificultar a execução de IP Spoof em sua rede local é não
permitir o uso da opcao IP_HDRINCL da função setsockopt(), apesar de
não ser uma solução eficaz, metade dos script kiddies não saberiam
como passar por este problema, caso você de fato o setasse! Abaixo segue
um link aonde voce poderá obter o LKM:

http://packetstormsecurity.com/

Remotamente, um atacante pode perfeitamente forjar pacotes, e o máximo
que você poderá fazer é dificultar as coisas! Talvez implementando
regras em seu Roteador/Firewall que barrem o recebimento de pacotes
originarios de fora, mas com endereço de sua rede interna! Uma outra
opção eh usar kerneis &nbsp;(2.4.X) que possibilitem um melhor uso de
ramdomização(/dev/urandom).


2.7 &nbsp;- Format Bugs
-------------------

Esta é a técnica do momento! Milhares de fuçadores, analista de sistemas,
membros da segurança, newbies tem se esforçado ultimamente para dominarem
esta técnica que tem trazido muitos problemas aos fabricantes de software
e a administradores de redes! Os format bugs&nbsp;é uma técnica a parte que
permite exploitação de software que contém erros em seu código permitindo
a execucao de comandos remotos. As funções *printf(printk tb) e syslog são
as principais responsáveis pela implementação desta técnica, lógico, que
o erro principal reside na preguiça dos programadores, mas de fato essas
funções são as mais usadas p/ serem exploitadas. Recentemente saiu uma lib
muito interessante que procura interceptar as principais funções bugadas
e proteger o sistema contra uma exploitação via Format Bug.
Esta lib se chama lib-format e pode ser obtida em:

http://packetstormsecurity.com/

Ela procura proteger as seguintes funcoes:

typedef int (*vprintf_t) (const char *format, va_list ap);
typedef int (*vsprintf_t) (char *string, const char *format, va_list ap);
typedef int (*vfprintf_t) (FILE *stream, const char *format, va_list ap);
typedef int (*vsnprintf_t) (char *string, size_t size, const char *format,va_list ap);
typedef void (*vsyslog_t) (int priority, const char *format, va_list ap);
typedef void (*vwarn_t) (const char *format, va_list ap);
typedef void (*vwarnx_t) (const char *format, va_list ap);
typedef void (*verr_t) (int status, const char *format, va_list ap);
typedef void (*verrx_t) (int status, const char *format, va_list ap);

Vimos acima ela tentando proteger as funcoes *printf e syslog, no entanto
nada relacionado a printk que é usada pelo kernel e por aplicações em LKM
(Loadable Kernel Modules). Como eu tenho conhecimento de pelo menos um
LKM bugado, e que de fato se pode exploitar funções printk(), a libformat
pode ser útil somente para defender processos no user-space e no momento

não pode ser vista como uma solução eficaz!


2.8 - Backdoors
-----------------

Aqui a coisa esquenta e muito para o lado do administrador. Se um atacante
obteve acesso ao sistema, tem casos muito complexos de se determinar que
a rede possui uma backdoor. Para ser bem sincero, existem técnicas que são
literalmente capazes de "esconder" um invasor através de uma backdoor no
seu sistema. Irei apenas descrever os métodos mais básicos de procurar
backdoors simples e conhecidas, de modo que é melhor previnir do que
remediar! Ou seja, procure sempre evitar que um atacante obtenha acesso
ao sistema, senão a coisa poderá se complicar para o seu lado.

Existem centenas de tipos de backdoors. Dependendo do sistema, um atacante
poderá instalar backdoors classicas, se for um kiddie, backdoors antigas
e ultrapassadas. Para maiores detalhes sobre os principais tipos de
backdoors, recomendo a leitura do meu tutorial "BACKDOORS E TROJANS -
Parte 1", disponível no Blog. As backdoors possuem o
intuito de permitir que os acessos futuros de um invasor seja conseguido
do modo mais facilitado possível! A grande maioria das backdoors, procuram
alterar dados no sistema para que o acesso futuro seja não apenas
facilitado, mas que tambem evite que o administrador da rede possa
perceber que existe um intruso em sua rede.

Existem também vários métodos de detecção de backdoors, sendo o método
TripWire um dos mais recomendados. O que programas como TripWire fazem é
criar um banco de dados de informações de determinados arquivos visando
comparações futuras. Se uma backdoor é instalada no sistema, você quando
executar o TripWire, ele irá notar as alterações nos arquivos do sistema.
Uma excelente ferramenta capaz de gerar tais banco de dados e fazer tais
comparacoes ao estilo TripWire&nbsp;é o LSTAT, feito pelo Skylazard, que pode
ser obtido em:

http://insecure.org/

Algumas backdoors amplamente conhecidas, como a do inetd, rootkits como o
"Linux Rootkit" dentre outros, são facilmente detectadas quando o
sistema se utiliza de tais ferramentas.

Outra ferramenta capaz de detectar muitos tipos de backdoor é o chkrootkit
do Nelson Pangeia. Através de um shell script, esta ferramenta executa
alguns programas e procura através de "assinaturas" de backdoors, detectar
alguns rootkits. Ele é capaz de detectar os mais conhecidos Rootkits
feitos em LKM como o adore e o knark, também detecta o famoso "Linux
Rootkit", bem como algumas backdoors do tipo 'bindshell'. Ele pode ser
obtido em:

http://packetstorm.securify.com

No entanto, ambas as ferramentas ainda são falhas quando se lida com
boas Backdoors feitas em LKM. No que se refere ao LKM, a manipulação de
systemcalls diretamente no kernel, torna tais programas ineficientes.
O chkrootkit tentou criar um método p/ detectar as backdoors no user space,
atraves de chdir() em /proc/X, onde X é o um intervalo númerico referente
ao PID dos programas. Em uma das minhas versões da backdoor Sombria, eu
descrevi pormenores de como se passar por esta proteção. LKM&nbsp;é uma
poderosa ferramenta, e se torna difícil p/ um administrador lutar contra
ela. Um possível esquema, seria a de "Quem chegar primeiro", ou seja,
inserirmos um LKM Detector em uma rede recém-instalada visando deste modo,
detectar qualquer inserção de LKMs no sistema. Abaixo nós vemos um simples
exemplo de LKM Detector:




--------------------------- lkm_detector.c -----------------------------


/* LKM Detector retirado do tutorial da The Hackers Choice sobre LKM.
   http://www.infowar.co.uk/
   Atualizado para kernel 2.2.13 by SeQ Anj0!.
   nashleon@yahoo.com.br/
*/

#define     MODULE
#define   __KERNEL__


#include 
#include 
#include 
#include 
#include 
#include 
#include 

extern void* sys_call_table[];

int (*orig_create_module)(char*, unsigned long);

int hacked_create_module(char *name, unsigned long size)
{
 char *kernel_name;
 int ret;

 kernel_name = (char*) kmalloc(256, GFP_KERNEL);
 copy_from_user(kernel_name, name, 255);

 /*here we log to syslog, but you can log where you want*/
 printk("<1> SYS_CREATE_MODULE : %s\n", kernel_name);

 ret=orig_create_module(name, size);
 return ret;
}

int init_module(void)                /*module setup*/
{
 orig_create_module=sys_call_table[SYS_create_module];
 sys_call_table[SYS_create_module]=hacked_create_module;
 return 0;
}

void cleanup_module(void)            /*module shutdown*/
{
 sys_call_table[SYS_create_module]=orig_create_module;

}



--------------------------- lkm_detector.c -----------------------------



O LKM acima porém não é a solução, haja visto, ele apenas serve para

detectar se um LKM foi inserido no sistema. Um esquema melhor reside em

interceptar o systemcall "__NL_create_module" e não permitir maiores

inserções de módulos no kernel, no entanto isto deve ser feito com a

máxima cautela!&nbsp;



Alguns tipos clássicos de backdoor podem ser evitados com o uso de

atributos ext2fs, como no uso de comandos tais como chattr. Alguns arquivos

necessitam estar com atributos setados com maior segurança, tais como

/etc/passwd, /etc/shadow, /etc/inetd.conf e etc.&nbsp;

Como fazer isso?

Podemos usar o comando chattr(1) para atribuir atributos ext2fs em um

arquivo, e o comando lsttr(1) para listar os atributos ext2fs de um

arquivo ou diretorio qualquer.

Abaixo nos podemos ver um exemplo de um shell script atribuindo alguns atributos&nbsp;

ext2fs para alguns arquivos do sistema:




--------------------------- lkm_detector.c -----------------------------


#!/bin/bash
#Simples Shell Script Criado Para
#Setar Atributos Ext2FS Em Determinados
#Arquivos Essenciais do Sistema.
#Desenvolvido por By SeQ Anj0!

#checa pela existencia do comando
if [ -x /usr/bin/chattr ]; then
   CHATTR="/usr/bin/chattr"
else
   echo "Comando chattr nao encontrado no sistema!";echo
   exit 1
fi

if [ $UID != "0" ]; then
   echo "Necessita ser root para executar este script"
   exit 1
fi

if [ "$#" = "0" ]; then
   echo "Seta Atributos EXT2FS em Arquivos Essenciais do Sistema";echo
   echo "Uso: `basename $0`  [coloca/retira]";echo
   exit 0
fi

#Lista de Arquivos que serao setados:

ARQUIVO_0="/etc/profile"
ARQUIVO_1="/etc/inetd.conf"
ARQUIVO_2="/etc/passwd"
ARQUIVO_3="/etc/shadow"

#As permissoes abaixo sao "u" para indeletavel e "i" para imutavel.

function coloca {
$CHATTR +ui $ARQUIVO_0 $ARQUIVO_1 $ARQUIVO_2 $ARQUIVO_3
}

function retira {
$CHATTR -ui $ARQUIVO_0 $ARQUIVO_1 $ARQUIVO_2 $ARQUIVO_3
}

if [ "$1" = "coloca" ]; then
   coloca
   echo "Arquivos Setados Com Sucesso!"
else
  if [ $1 = "retira" ]; then
     retira
  else
     echo "Sintaxe Errada!"
     exit 1
  fi
fi



--------------------------- lkm_detector.c -----------------------------


O exemplo acima é apenas para fornecer o conceito. Poucos são os usuários
de Linux que conhece tais comandos e que de fato setam as permissões
corretamente. Você pegando a ideia acima poderá criar scripts e melhorar
cada vez mais a segurança do seu sistema!

Agora, supondo que um pseudo-hacker(script kiddie) brasileiro alterador de
home page de um grupo qualquer conseguiu obter acesso ao seu sistema!
Como ele é apenas um executor de scripts de terceiro, ele vai querer
instalar uma das melhores backdoors do momento! Uma backdoor em LKM!!
Vai que ele é brasileiro e me conhece! Sabe que sou contra as atitudes
lamers dele, mas mesmo assim ele usa uma backdoor minha em LKM.

Fica muito difícil você conseguir detectar, mas com o chkrootkit vc
consegue detectar esta versão, no entanto eu já publiquei um patch!
A coisa esquenta muito, mas existe um método para você detectar se o
seu sistema tem a minha backdoor instalada nele bem facinho!! Basta
você dar uma scaneada na sua rede usando o Nmap e comparar com as portas
que estão abertas e aparecem em "netstat -na". Se aparecer alguma porta
aberta no nmap que não há no netstat, então você possui uma chance muito
grande de um kiddie ter instalado a minha backdoor no teu sistema!
Reinicialize o seu linux e se a backdoor ainda estiver lá, cheque os
arquivos de módulo que são carregados atravéz dos scripts de inicializadao
(/etc/rc.d) e caso nao encontre algo, reinstale o seu linux e sua kernel!


Fiquem atentos as publicações de A Melhor Defesa é o Ataque pois é meu objetivo

expandir e trocar mais informações sobre todas as técnicas usadas por

fuçadores em toda e qualquer implementação, incluso hacking de WEB.



---------------------------- &nbsp; &nbsp;&nbsp;By SeQ Anjdric 2014!&nbsp;&nbsp; --------------------------------